Mirrors/asmjit
1
0
Fork 0
mirror of https://github.com/asmjit/asmjit.git synced 2025-12-17 04:24:37 +03:00
Code Issues Packages Projects Releases Wiki Activity

Minor code cleanup, fixed 64-bit BMI and BMI2 instructions

Browse Source
This commit is contained in:
kobalicek
2016-06-30 18:59:59 +02:00
parent 286bc22f49
commit d25f392c6e
59 changed files with 2690 additions and 3037 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
README.md
View File

@@ -497,11 +497,11 @@ printf("Logger Content:\n%s", logger.getString());
// You can use `logger.clearString()` if the intend is to reuse the logger. // You can use `logger.clearString()` if the intend is to reuse the logger.
``` ```
Logger can be configured to show more information by using `logger.setOption()` method. The following options are available: Logger can be configured to show more information by using `logger.addOptions()` method. The following options are available:
* `kLoggerOptionBinaryForm` - Log also binary sequence for each instruction generated. * `Logger::kOptionBinaryForm` - Log also binary sequence for each instruction generated.
* `kLoggerOptionHexImmediate` - Format immediate values to base16 (hex) form. * `Logger::kOptionHexImmediate` - Log immediate values as hexadecimal.
* `kLoggerOptionHexDisplacement` - Format memory displacements to base16 (hex) form. * `Logger::kOptionHexDisplacement` - Log memory displacements as hexadecimal.
TODO: Liveness analysis and instruction scheduling options. TODO: Liveness analysis and instruction scheduling options.

2
src/asmjit/apibegin.h
View File

@@ -4,7 +4,7 @@
// [License] // [License]
// Zlib - See LICENSE.md file in the package. // Zlib - See LICENSE.md file in the package.
// [Dependencies - AsmJit] // [Dependencies]
#if !defined(_ASMJIT_BUILD_H) #if !defined(_ASMJIT_BUILD_H)
#include "./build.h" #include "./build.h"
#endif // !_ASMJIT_BUILD_H #endif // !_ASMJIT_BUILD_H

2
src/asmjit/arm.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_ARM_H #ifndef _ASMJIT_ARM_H
#define _ASMJIT_ARM_H #define _ASMJIT_ARM_H
// [Dependencies - AsmJit] // [Dependencies]
#include "./base.h" #include "./base.h"
#include "./arm/armassembler.h" #include "./arm/armassembler.h"

8
src/asmjit/asmjit.h
View File

@@ -340,20 +340,20 @@
//! } //! }
//! ~~~ //! ~~~
// [Dependencies - Base] // [Dependencies]
#include "./base.h" #include "./base.h"
// [Dependencies - ARM/ARM64] // [ARM/ARM64]
#if defined(ASMJIT_BUILD_ARM32) || defined(ASMJIT_BUILD_ARM64) #if defined(ASMJIT_BUILD_ARM32) || defined(ASMJIT_BUILD_ARM64)
#include "./arm.h" #include "./arm.h"
#endif // ASMJIT_BUILD_ARM32 || ASMJIT_BUILD_ARM64 #endif // ASMJIT_BUILD_ARM32 || ASMJIT_BUILD_ARM64
// [Dependencies - X86/X64] // [X86/X64]
#if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64) #if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)
#include "./x86.h" #include "./x86.h"
#endif // ASMJIT_BUILD_X86 || ASMJIT_BUILD_X64 #endif // ASMJIT_BUILD_X86 || ASMJIT_BUILD_X64
// [Dependencies - Host] // [Host]
#include "./host.h" #include "./host.h"
// [Guard] // [Guard]

2
src/asmjit/base.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_H #ifndef _ASMJIT_BASE_H
#define _ASMJIT_BASE_H #define _ASMJIT_BASE_H
// [Dependencies - AsmJit] // [Dependencies]
#include "./build.h" #include "./build.h"
#include "./base/assembler.h" #include "./base/assembler.h"

6
src/asmjit/base/assembler.cpp
View File

@@ -7,12 +7,10 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/assembler.h" #include "../base/assembler.h"
#include "../base/utils.h" #include "../base/utils.h"
#include "../base/vmem.h" #include "../base/vmem.h"
// [Dependenceis - C]
#include <stdarg.h> #include <stdarg.h>
// [Api-Begin] // [Api-Begin]
@@ -162,7 +160,7 @@ Error Assembler::setLastError(Error error, const char* message) noexcept {
if (message == nullptr) if (message == nullptr)
message = DebugUtils::errorAsString(error); message = DebugUtils::errorAsString(error);
// Logging is skipped if the error is handled by `ErrorHandler. // Logging is skipped if the error is handled by `ErrorHandler`.
ErrorHandler* eh = _errorHandler; ErrorHandler* eh = _errorHandler;
ASMJIT_TLOG("[ERROR (Assembler)] %s (0x%0.8u) %s\n", message, ASMJIT_TLOG("[ERROR (Assembler)] %s (0x%0.8u) %s\n", message,
static_cast<unsigned int>(error), static_cast<unsigned int>(error),

11
src/asmjit/base/assembler.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_ASSEMBLER_H #ifndef _ASMJIT_BASE_ASSEMBLER_H
#define _ASMJIT_BASE_ASSEMBLER_H #define _ASMJIT_BASE_ASSEMBLER_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/containers.h" #include "../base/containers.h"
#include "../base/logger.h" #include "../base/logger.h"
#include "../base/operand.h" #include "../base/operand.h"
@@ -235,7 +235,8 @@ struct RelocData {
//! Please note that `addRef` and `release` functions are used, but there is //! Please note that `addRef` and `release` functions are used, but there is
//! no reference counting implemented by default, reimplement to change the //! no reference counting implemented by default, reimplement to change the
//! default behavior. //! default behavior.
struct ASMJIT_VIRTAPI ErrorHandler { class ASMJIT_VIRTAPI ErrorHandler {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -297,7 +298,8 @@ struct ASMJIT_VIRTAPI ErrorHandler {
// ============================================================================ // ============================================================================
//! An external tool (i.e. `Stream` or `Compiler`) that can serialize to `Assembler` //! An external tool (i.e. `Stream` or `Compiler`) that can serialize to `Assembler`
struct ASMJIT_VIRTAPI ExternalTool { class ASMJIT_VIRTAPI ExternalTool {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -404,7 +406,8 @@ struct ASMJIT_VIRTAPI ExternalTool {
//! specific assemblers. //! specific assemblers.
//! //!
//! \sa Compiler. //! \sa Compiler.
struct ASMJIT_VIRTAPI Assembler { class ASMJIT_VIRTAPI Assembler {
public:
ASMJIT_NO_COPY(Assembler) ASMJIT_NO_COPY(Assembler)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

4
src/asmjit/base/compiler.cpp
View File

@@ -11,15 +11,13 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/assembler.h" #include "../base/assembler.h"
#include "../base/compiler.h" #include "../base/compiler.h"
#include "../base/compilercontext_p.h" #include "../base/compilercontext_p.h"
#include "../base/cpuinfo.h" #include "../base/cpuinfo.h"
#include "../base/logger.h" #include "../base/logger.h"
#include "../base/utils.h" #include "../base/utils.h"
// [Dependencies - C]
#include <stdarg.h> #include <stdarg.h>
// [Api-Begin] // [Api-Begin]

5
src/asmjit/base/compiler.h
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/assembler.h" #include "../base/assembler.h"
#include "../base/compilerfunc.h" #include "../base/compilerfunc.h"
#include "../base/constpool.h" #include "../base/constpool.h"
@@ -138,7 +138,8 @@ struct VarInfo {
//! Compiler interface. //! Compiler interface.
//! //!
//! \sa Assembler. //! \sa Assembler.
struct ASMJIT_VIRTAPI Compiler : public ExternalTool { class ASMJIT_VIRTAPI Compiler : public ExternalTool {
public:
ASMJIT_NO_COPY(Compiler) ASMJIT_NO_COPY(Compiler)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/base/compilercontext.cpp
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/compilercontext_p.h" #include "../base/compilercontext_p.h"
#include "../base/utils.h" #include "../base/utils.h"

2
src/asmjit/base/compilercontext_p.h
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/compiler.h" #include "../base/compiler.h"
#include "../base/podvector.h" #include "../base/podvector.h"
#include "../base/zone.h" #include "../base/zone.h"

2
src/asmjit/base/compilerfunc.h
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/operand.h" #include "../base/operand.h"
#include "../base/utils.h" #include "../base/utils.h"

2
src/asmjit/base/constpool.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/constpool.h" #include "../base/constpool.h"
#include "../base/utils.h" #include "../base/utils.h"

5
src/asmjit/base/constpool.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_CONSTPOOL_H #ifndef _ASMJIT_BASE_CONSTPOOL_H
#define _ASMJIT_BASE_CONSTPOOL_H #define _ASMJIT_BASE_CONSTPOOL_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/zone.h" #include "../base/zone.h"
// [Api-Begin] // [Api-Begin]
@@ -24,7 +24,8 @@ namespace asmjit {
// ============================================================================ // ============================================================================
//! Constant pool. //! Constant pool.
struct ConstPool { class ConstPool {
public:
ASMJIT_NO_COPY(ConstPool) ASMJIT_NO_COPY(ConstPool)
enum { enum {

2
src/asmjit/base/containers.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/containers.h" #include "../base/containers.h"
#include "../base/utils.h" #include "../base/utils.h"

11
src/asmjit/base/containers.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_CONTAINERS_H #ifndef _ASMJIT_BASE_CONTAINERS_H
#define _ASMJIT_BASE_CONTAINERS_H #define _ASMJIT_BASE_CONTAINERS_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
// [Api-Begin] // [Api-Begin]
@@ -141,7 +141,8 @@ struct BitArray {
//! \internal //! \internal
template <typename T> template <typename T>
struct PodList { class PodList {
public:
ASMJIT_NO_COPY(PodList<T>) ASMJIT_NO_COPY(PodList<T>)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -230,7 +231,8 @@ struct PodList {
//! //!
//! String builder contains method specific to AsmJit functionality, used for //! String builder contains method specific to AsmJit functionality, used for
//! logging or HTML output. //! logging or HTML output.
struct StringBuilder { class StringBuilder {
public:
ASMJIT_NO_COPY(StringBuilder) ASMJIT_NO_COPY(StringBuilder)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -511,7 +513,8 @@ struct StringBuilder {
//! Temporary string builder, has statically allocated `N` bytes. //! Temporary string builder, has statically allocated `N` bytes.
template<size_t N> template<size_t N>
struct StringBuilderTmp : public StringBuilder { class StringBuilderTmp : public StringBuilder {
public:
ASMJIT_NO_COPY(StringBuilderTmp<N>) ASMJIT_NO_COPY(StringBuilderTmp<N>)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/base/cpuinfo.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/cpuinfo.h" #include "../base/cpuinfo.h"
#include "../base/utils.h" #include "../base/utils.h"

5
src/asmjit/base/cpuinfo.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_CPUINFO_H #ifndef _ASMJIT_BASE_CPUINFO_H
#define _ASMJIT_BASE_CPUINFO_H #define _ASMJIT_BASE_CPUINFO_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
// [Api-Begin] // [Api-Begin]
@@ -24,7 +24,8 @@ namespace asmjit {
// ============================================================================ // ============================================================================
//! CPU information. //! CPU information.
struct CpuInfo { class CpuInfo {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Vendor] // [Vendor]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/base/globals.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
// [Api-Begin] // [Api-Begin]

2
src/asmjit/base/globals.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_GLOBALS_H #ifndef _ASMJIT_BASE_GLOBALS_H
#define _ASMJIT_BASE_GLOBALS_H #define _ASMJIT_BASE_GLOBALS_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../build.h" #include "../build.h"
// [Api-Begin] // [Api-Begin]

2
src/asmjit/base/hlstream.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/hlstream.h" #include "../base/hlstream.h"
// [Api-Begin] // [Api-Begin]

51
src/asmjit/base/hlstream.h
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/assembler.h" #include "../base/assembler.h"
#include "../base/operand.h" #include "../base/operand.h"
@@ -27,15 +27,15 @@ namespace asmjit {
// [Forward Declarations] // [Forward Declarations]
// ============================================================================ // ============================================================================
struct Compiler; class Compiler;
struct VarData; struct VarData;
struct VarState; struct VarState;
struct VarMap; struct VarMap;
struct HLInst; class HLInst;
struct HLJump; class HLJump;
struct HLLabel; class HLLabel;
struct HLSentinel; class HLSentinel;
//! \addtogroup asmjit_base //! \addtogroup asmjit_base
//! \{ //! \{
@@ -48,7 +48,8 @@ struct HLSentinel;
//! //!
//! Every node represents an abstract instruction, directive, label, or macro //! Every node represents an abstract instruction, directive, label, or macro
//! instruction that can be serialized to `Assembler`. //! instruction that can be serialized to `Assembler`.
struct HLNode { class HLNode {
public:
ASMJIT_NO_COPY(HLNode) ASMJIT_NO_COPY(HLNode)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -324,7 +325,8 @@ struct HLNode {
//! Instruction (HL). //! Instruction (HL).
//! //!
//! Wraps an instruction with its options and operands. //! Wraps an instruction with its options and operands.
struct HLInst : public HLNode { class HLInst : public HLNode {
public:
ASMJIT_NO_COPY(HLInst) ASMJIT_NO_COPY(HLInst)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -449,7 +451,8 @@ L_Update:
//! Conditional or direct jump (HL). //! Conditional or direct jump (HL).
//! //!
//! Extension of `HLInst` node, which stores more information about the jump. //! Extension of `HLInst` node, which stores more information about the jump.
struct HLJump : public HLInst { class HLJump : public HLInst {
public:
ASMJIT_NO_COPY(HLJump) ASMJIT_NO_COPY(HLJump)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -488,7 +491,8 @@ struct HLJump : public HLInst {
//! Wraps `.data` directive. The node contains data that will be placed at the //! Wraps `.data` directive. The node contains data that will be placed at the
//! node's position in the assembler stream. The data is considered to be RAW; //! node's position in the assembler stream. The data is considered to be RAW;
//! no analysis nor byte-order conversion is performed on RAW data. //! no analysis nor byte-order conversion is performed on RAW data.
struct HLData : public HLNode { class HLData : public HLNode {
public:
ASMJIT_NO_COPY(HLData) ASMJIT_NO_COPY(HLData)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -545,7 +549,8 @@ struct HLData : public HLNode {
//! Align directive (HL). //! Align directive (HL).
//! //!
//! Wraps `.align` directive. //! Wraps `.align` directive.
struct HLAlign : public HLNode { class HLAlign : public HLNode {
public:
ASMJIT_NO_COPY(HLAlign) ASMJIT_NO_COPY(HLAlign)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -592,7 +597,8 @@ struct HLAlign : public HLNode {
// ============================================================================ // ============================================================================
//! label (HL). //! label (HL).
struct HLLabel : public HLNode { class HLLabel : public HLNode {
public:
ASMJIT_NO_COPY(HLLabel) ASMJIT_NO_COPY(HLLabel)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -658,7 +664,8 @@ struct HLLabel : public HLNode {
// ============================================================================ // ============================================================================
//! Comment (HL). //! Comment (HL).
struct HLComment : public HLNode { class HLComment : public HLNode {
public:
ASMJIT_NO_COPY(HLComment) ASMJIT_NO_COPY(HLComment)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -682,7 +689,8 @@ struct HLComment : public HLNode {
// ============================================================================ // ============================================================================
//! Sentinel (HL). //! Sentinel (HL).
struct HLSentinel : public HLNode { class HLSentinel : public HLNode {
public:
ASMJIT_NO_COPY(HLSentinel) ASMJIT_NO_COPY(HLSentinel)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -704,7 +712,8 @@ struct HLSentinel : public HLNode {
// ============================================================================ // ============================================================================
//! Hint node. //! Hint node.
struct HLHint : public HLNode { class HLHint : public HLNode {
public:
ASMJIT_NO_COPY(HLHint) ASMJIT_NO_COPY(HLHint)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -758,7 +767,8 @@ struct HLHint : public HLNode {
// ============================================================================ // ============================================================================
//! Function (HL). //! Function (HL).
struct HLFunc : public HLNode { class HLFunc : public HLNode {
public:
ASMJIT_NO_COPY(HLFunc) ASMJIT_NO_COPY(HLFunc)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -978,7 +988,8 @@ struct HLFunc : public HLNode {
// ============================================================================ // ============================================================================
//! Function return (HL). //! Function return (HL).
struct HLRet : public HLNode { class HLRet : public HLNode {
public:
ASMJIT_NO_COPY(HLRet) ASMJIT_NO_COPY(HLRet)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1024,7 +1035,8 @@ struct HLRet : public HLNode {
// ============================================================================ // ============================================================================
//! Function call (HL). //! Function call (HL).
struct HLCall : public HLNode { class HLCall : public HLNode {
public:
ASMJIT_NO_COPY(HLCall) ASMJIT_NO_COPY(HLCall)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1097,7 +1109,8 @@ struct HLCall : public HLNode {
// ============================================================================ // ============================================================================
//! Function call's argument (HL). //! Function call's argument (HL).
struct HLCallArg : public HLNode { class HLCallArg : public HLNode {
public:
ASMJIT_NO_COPY(HLCallArg) ASMJIT_NO_COPY(HLCallArg)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

4
src/asmjit/base/logger.cpp
View File

@@ -11,12 +11,10 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_LOGGER) #if !defined(ASMJIT_DISABLE_LOGGER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/containers.h" #include "../base/containers.h"
#include "../base/logger.h" #include "../base/logger.h"
#include "../base/utils.h" #include "../base/utils.h"
// [Dependencies - C]
#include <stdarg.h> #include <stdarg.h>
// [Api-Begin] // [Api-Begin]

26
src/asmjit/base/logger.h
View File

@@ -10,10 +10,8 @@
#include "../build.h" #include "../build.h"
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/containers.h" #include "../base/containers.h"
// [Dependencies - C]
#include <stdarg.h> #include <stdarg.h>
// [Api-Begin] // [Api-Begin]
@@ -59,7 +57,8 @@ struct LogUtil {
//! //!
//! This class also contain `_enabled` member that can be used to enable //! This class also contain `_enabled` member that can be used to enable
//! or disable logging. //! or disable logging.
struct ASMJIT_VIRTAPI Logger { class ASMJIT_VIRTAPI Logger {
public:
ASMJIT_NO_COPY(Logger) ASMJIT_NO_COPY(Logger)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -68,16 +67,9 @@ struct ASMJIT_VIRTAPI Logger {
//! Logger options. //! Logger options.
ASMJIT_ENUM(Options) { ASMJIT_ENUM(Options) {
//! Whether to output instructions also in binary form. kOptionBinaryForm = 0x00000001, //! Output instructions also in binary form.
kOptionBinaryForm = 0, kOptionHexImmediate = 0x00000002, //! Output immediates as hexadecimal numbers.
kOptionHexDisplacement = 0x00000004 //! Output displacements as hexadecimal numbers.
//! Whether to output immediates as hexadecimal numbers.
kOptionHexImmediate = 1,
//! Whether to output displacements as hexadecimal numbers.
kOptionHexDisplacement = 2,
//! Count of logger options.
kOptionCount = 3
}; };
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -163,7 +155,8 @@ struct ASMJIT_VIRTAPI Logger {
// ============================================================================ // ============================================================================
//! Logger that can log to standard C `FILE*` stream. //! Logger that can log to standard C `FILE*` stream.
struct ASMJIT_VIRTAPI FileLogger : public Logger { class ASMJIT_VIRTAPI FileLogger : public Logger {
public:
ASMJIT_NO_COPY(FileLogger) ASMJIT_NO_COPY(FileLogger)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -212,7 +205,8 @@ struct ASMJIT_VIRTAPI FileLogger : public Logger {
// ============================================================================ // ============================================================================
//! String logger. //! String logger.
struct ASMJIT_VIRTAPI StringLogger : public Logger { class ASMJIT_VIRTAPI StringLogger : public Logger {
public:
ASMJIT_NO_COPY(StringLogger) ASMJIT_NO_COPY(StringLogger)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/base/operand.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
// [Api-Begin] // [Api-Begin]

20
src/asmjit/base/operand.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_OPERAND_H #ifndef _ASMJIT_BASE_OPERAND_H
#define _ASMJIT_BASE_OPERAND_H #define _ASMJIT_BASE_OPERAND_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/utils.h" #include "../base/utils.h"
// [Api-Begin] // [Api-Begin]
@@ -143,7 +143,8 @@ ASMJIT_ENUM(VarType) {
// ============================================================================ // ============================================================================
//! Operand can contain register, memory location, immediate, or label. //! Operand can contain register, memory location, immediate, or label.
struct Operand { class Operand {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Type] // [Type]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -563,7 +564,8 @@ struct OperandUtil {
// ============================================================================ // ============================================================================
//! Base class for all register operands. //! Base class for all register operands.
struct Reg : public Operand { class Reg : public Operand {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -683,7 +685,8 @@ struct Reg : public Operand {
// ============================================================================ // ============================================================================
//! Base class for all memory operands. //! Base class for all memory operands.
struct BaseMem : public Operand { class BaseMem : public Operand {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -778,7 +781,8 @@ struct BaseMem : public Operand {
//! //!
//! To create immediate operand use `imm()` or `imm_u()` non-members or `Imm` //! To create immediate operand use `imm()` or `imm_u()` non-members or `Imm`
//! constructors. //! constructors.
struct Imm : public Operand { class Imm : public Operand {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1056,7 +1060,8 @@ struct Imm : public Operand {
//! // Bind label to the current position, see `Assembler::bind()`. //! // Bind label to the current position, see `Assembler::bind()`.
//! a.bind(L1); //! a.bind(L1);
//! ~~~ //! ~~~
struct Label : public Operand { class Label : public Operand {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1108,7 +1113,8 @@ struct Label : public Operand {
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
//! Base class for all variables. //! Base class for all variables.
struct Var : public Operand { class Var : public Operand {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/base/podvector.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/podvector.h" #include "../base/podvector.h"
#include "../base/utils.h" #include "../base/utils.h"

11
src/asmjit/base/podvector.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_PODVECTOR_H #ifndef _ASMJIT_BASE_PODVECTOR_H
#define _ASMJIT_BASE_PODVECTOR_H #define _ASMJIT_BASE_PODVECTOR_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
// [Api-Begin] // [Api-Begin]
@@ -24,7 +24,8 @@ namespace asmjit {
// ============================================================================ // ============================================================================
//! \internal //! \internal
struct PodVectorBase { class PodVectorBase {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Data] // [Data]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -95,7 +96,8 @@ public:
//! - Optimized for working only with POD types //! - Optimized for working only with POD types
//! - Uses ASMJIT_... memory management macros //! - Uses ASMJIT_... memory management macros
template <typename T> template <typename T>
struct PodVector : PodVectorBase { class PodVector : public PodVectorBase {
public:
ASMJIT_NO_COPY(PodVector<T>) ASMJIT_NO_COPY(PodVector<T>)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -237,7 +239,8 @@ public:
// ============================================================================ // ============================================================================
template<typename T, size_t N> template<typename T, size_t N>
struct PodVectorTmp : public PodVector<T> { class PodVectorTmp : public PodVector<T> {
public:
ASMJIT_NO_COPY(PodVectorTmp<T, N>) ASMJIT_NO_COPY(PodVectorTmp<T, N>)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/base/runtime.cpp
View File

@@ -7,7 +7,7 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/assembler.h" #include "../base/assembler.h"
#include "../base/runtime.h" #include "../base/runtime.h"

18
src/asmjit/base/runtime.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_RUNTIME_H #ifndef _ASMJIT_BASE_RUNTIME_H
#define _ASMJIT_BASE_RUNTIME_H #define _ASMJIT_BASE_RUNTIME_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/cpuinfo.h" #include "../base/cpuinfo.h"
#include "../base/vmem.h" #include "../base/vmem.h"
@@ -21,8 +21,8 @@ namespace asmjit {
// [Forward Declarations] // [Forward Declarations]
// ============================================================================ // ============================================================================
struct Assembler; class Assembler;
struct CpuInfo; class CpuInfo;
//! \addtogroup asmjit_base //! \addtogroup asmjit_base
//! \{ //! \{
@@ -32,7 +32,8 @@ struct CpuInfo;
// ============================================================================ // ============================================================================
//! Base runtime. //! Base runtime.
struct ASMJIT_VIRTAPI Runtime { class ASMJIT_VIRTAPI Runtime {
public:
ASMJIT_NO_COPY(Runtime) ASMJIT_NO_COPY(Runtime)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -132,7 +133,8 @@ struct ASMJIT_VIRTAPI Runtime {
// ============================================================================ // ============================================================================
//! Base runtime for JIT code generation. //! Base runtime for JIT code generation.
struct ASMJIT_VIRTAPI HostRuntime : public Runtime { class ASMJIT_VIRTAPI HostRuntime : public Runtime {
public:
ASMJIT_NO_COPY(HostRuntime) ASMJIT_NO_COPY(HostRuntime)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -170,7 +172,8 @@ struct ASMJIT_VIRTAPI HostRuntime : public Runtime {
//! //!
//! JIT static runtime can be used to generate code to a memory location that //! JIT static runtime can be used to generate code to a memory location that
//! is known. //! is known.
struct ASMJIT_VIRTAPI StaticRuntime : public HostRuntime { class ASMJIT_VIRTAPI StaticRuntime : public HostRuntime {
public:
ASMJIT_NO_COPY(StaticRuntime) ASMJIT_NO_COPY(StaticRuntime)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -212,7 +215,8 @@ struct ASMJIT_VIRTAPI StaticRuntime : public HostRuntime {
// ============================================================================ // ============================================================================
//! JIT runtime. //! JIT runtime.
struct ASMJIT_VIRTAPI JitRuntime : public HostRuntime { class ASMJIT_VIRTAPI JitRuntime : public HostRuntime {
public:
ASMJIT_NO_COPY(JitRuntime) ASMJIT_NO_COPY(JitRuntime)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

5
src/asmjit/base/utils.cpp
View File

@@ -7,21 +7,18 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/utils.h" #include "../base/utils.h"
// [Dependencies - Posix]
#if ASMJIT_OS_POSIX #if ASMJIT_OS_POSIX
# include <time.h> # include <time.h>
# include <unistd.h> # include <unistd.h>
#endif // ASMJIT_OS_POSIX #endif // ASMJIT_OS_POSIX
// [Dependencies - Mac]
#if ASMJIT_OS_MAC #if ASMJIT_OS_MAC
# include <mach/mach_time.h> # include <mach/mach_time.h>
#endif // ASMJIT_OS_MAC #endif // ASMJIT_OS_MAC
// [Dependencies - Windows]
#if ASMJIT_OS_WINDOWS #if ASMJIT_OS_WINDOWS
# if defined(_MSC_VER) && _MSC_VER >= 1400 # if defined(_MSC_VER) && _MSC_VER >= 1400
# include <intrin.h> # include <intrin.h>

2
src/asmjit/base/utils.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_UTILS_H #ifndef _ASMJIT_BASE_UTILS_H
#define _ASMJIT_BASE_UTILS_H #define _ASMJIT_BASE_UTILS_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
#if ASMJIT_CC_MSC_GE(14, 0, 0) #if ASMJIT_CC_MSC_GE(14, 0, 0)

2
src/asmjit/base/vectypes.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_VECTYPES_H #ifndef _ASMJIT_BASE_VECTYPES_H
#define _ASMJIT_BASE_VECTYPES_H #define _ASMJIT_BASE_VECTYPES_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
// [Api-Begin] // [Api-Begin]

3
src/asmjit/base/vmem.cpp
View File

@@ -7,11 +7,10 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
#include "../base/vmem.h" #include "../base/vmem.h"
// [Dependencies - Posix]
#if ASMJIT_OS_POSIX #if ASMJIT_OS_POSIX
# include <sys/types.h> # include <sys/types.h>
# include <sys/mman.h> # include <sys/mman.h>

9
src/asmjit/base/vmem.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_VMEM_H #ifndef _ASMJIT_BASE_VMEM_H
#define _ASMJIT_BASE_VMEM_H #define _ASMJIT_BASE_VMEM_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/utils.h" #include "../base/utils.h"
// [Api-Begin] // [Api-Begin]
@@ -89,7 +89,8 @@ struct VMemUtil {
//! Reference implementation of memory manager that uses `VMemUtil` to allocate //! Reference implementation of memory manager that uses `VMemUtil` to allocate
//! chunks of virtual memory and bit arrays to manage it. //! chunks of virtual memory and bit arrays to manage it.
struct VMemMgr { class VMemMgr {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -101,8 +102,8 @@ struct VMemMgr {
//! Create a `VMemMgr` instance. //! Create a `VMemMgr` instance.
//! //!
//! \note When running on Windows it's possible to specify a `hProcess` to //! \note When running on Windows it's possible to specify a `hProcess` to
//! be used for memory allocation. This allows to allocate memory of remote //! be used for memory allocation. Using `hProcess` allows to allocate memory
//! process. //! of a remote process.
ASMJIT_API VMemMgr(HANDLE hProcess = static_cast<HANDLE>(0)) noexcept; ASMJIT_API VMemMgr(HANDLE hProcess = static_cast<HANDLE>(0)) noexcept;
#endif // ASMJIT_OS_WINDOWS #endif // ASMJIT_OS_WINDOWS

4
src/asmjit/base/zone.cpp
View File

@@ -7,11 +7,9 @@
// [Export] // [Export]
#define ASMJIT_EXPORTS #define ASMJIT_EXPORTS
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/utils.h" #include "../base/utils.h"
#include "../base/zone.h" #include "../base/zone.h"
// [Dependencies - C]
#include <stdarg.h> #include <stdarg.h>
// [Api-Begin] // [Api-Begin]

2
src/asmjit/base/zone.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_ZONE_H #ifndef _ASMJIT_BASE_ZONE_H
#define _ASMJIT_BASE_ZONE_H #define _ASMJIT_BASE_ZONE_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/globals.h" #include "../base/globals.h"
// [Api-Begin] // [Api-Begin]

7
src/asmjit/host.h
View File

@@ -8,13 +8,10 @@
#ifndef _ASMJIT_HOST_H #ifndef _ASMJIT_HOST_H
#define _ASMJIT_HOST_H #define _ASMJIT_HOST_H
// [Dependencies - Core] // [Dependencies]
#include "./base.h" #include "./base.h"
// ============================================================================ // [X86 / X64]
// [asmjit::host - X86 / X64]
// ============================================================================
#if ASMJIT_ARCH_X86 || ASMJIT_ARCH_X64 #if ASMJIT_ARCH_X86 || ASMJIT_ARCH_X64
#include "./x86.h" #include "./x86.h"

2
src/asmjit/x86.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_X86_H #ifndef _ASMJIT_X86_H
#define _ASMJIT_X86_H #define _ASMJIT_X86_H
// [Dependencies - AsmJit] // [Dependencies]
#include "./base.h" #include "./base.h"
#include "./x86/x86assembler.h" #include "./x86/x86assembler.h"

351
src/asmjit/x86/x86assembler.cpp
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64) #if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/containers.h" #include "../base/containers.h"
#include "../base/cpuinfo.h" #include "../base/cpuinfo.h"
#include "../base/logger.h" #include "../base/logger.h"
@@ -189,6 +189,9 @@ static ASMJIT_INLINE uint32_t x86ExtractO(uint32_t opCode) {
return (opCode >> kX86InstOpCode_O_Shift) & 0x07; return (opCode >> kX86InstOpCode_O_Shift) & 0x07;
} }
static ASMJIT_INLINE bool x86IsGpq(const Operand* op) { return op->isRegType(kX86RegTypeGpq); }
static ASMJIT_INLINE bool x86IsGpq(const X86Reg* reg) { return reg->isGpq(); }
static ASMJIT_INLINE bool x86IsXmm(const Operand* op) { return op->isRegType(kX86RegTypeXmm); } static ASMJIT_INLINE bool x86IsXmm(const Operand* op) { return op->isRegType(kX86RegTypeXmm); }
static ASMJIT_INLINE bool x86IsXmm(const X86Reg* reg) { return reg->isXmm(); } static ASMJIT_INLINE bool x86IsXmm(const X86Reg* reg) { return reg->isXmm(); }
@@ -1031,30 +1034,30 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
// [Group] // [Group]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
switch (info.getEncodingId()) { switch (info.getEncoding()) {
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
// [None] // [None]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdNone: case kX86InstEncodingNone:
goto _EmitDone; goto _EmitDone;
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
// [X86] // [X86]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdX86Op_66H: case kX86InstEncodingX86Op_66H:
ADD_66H_P(true); ADD_66H_P(true);
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdX86Op: case kX86InstEncodingX86Op:
goto _EmitX86Op; goto _EmitX86Op;
case kX86InstEncodingIdX86Rm_B: case kX86InstEncodingX86Rm_B:
opCode += o0->getSize() != 1; opCode += o0->getSize() != 1;
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdX86Rm: case kX86InstEncodingX86Rm:
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize()); ADD_REX_W_BY_SIZE(o0->getSize());
@@ -1069,7 +1072,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86RmReg: case kX86InstEncodingX86RmReg:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opCode += o0->getSize() != 1; opCode += o0->getSize() != 1;
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
@@ -1091,7 +1094,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86RegRm: case kX86InstEncodingX86RegRm:
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize()); ADD_REX_W_BY_SIZE(o0->getSize());
@@ -1114,14 +1117,14 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86M: case kX86InstEncodingX86M:
if (encoded == ENC_OPS(Mem, None, None)) { if (encoded == ENC_OPS(Mem, None, None)) {
rmMem = x86OpMem(o0); rmMem = x86OpMem(o0);
goto _EmitX86M; goto _EmitX86M;
} }
break; break;
case kX86InstEncodingIdX86Arith: case kX86InstEncodingX86Arith:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opCode += (o0->getSize() != 1) + 2; opCode += (o0->getSize() != 1) + 2;
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
@@ -1193,7 +1196,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86BSwap: case kX86InstEncodingX86BSwap:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
if (o0->getSize() < 4) if (o0->getSize() < 4)
goto _IllegalInst; goto _IllegalInst;
@@ -1204,7 +1207,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86BTest: case kX86InstEncodingX86BTest:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
ADD_66H_P_BY_SIZE(o1->getSize()); ADD_66H_P_BY_SIZE(o1->getSize());
ADD_REX_W_BY_SIZE(o1->getSize()); ADD_REX_W_BY_SIZE(o1->getSize());
@@ -1247,7 +1250,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Call: case kX86InstEncodingX86Call:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
rmReg = x86OpReg(o0); rmReg = x86OpReg(o0);
goto _EmitX86R; goto _EmitX86R;
@@ -1289,7 +1292,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Enter: case kX86InstEncodingX86Enter:
if (encoded == ENC_OPS(Imm, Imm, None)) { if (encoded == ENC_OPS(Imm, Imm, None)) {
EMIT_BYTE(0xC8); EMIT_BYTE(0xC8);
EMIT_WORD(static_cast<const Imm*>(o1)->getUInt16()); EMIT_WORD(static_cast<const Imm*>(o1)->getUInt16());
@@ -1298,7 +1301,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Imul: case kX86InstEncodingX86Imul:
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize()); ADD_REX_W_BY_SIZE(o0->getSize());
@@ -1395,7 +1398,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86IncDec: case kX86InstEncodingX86IncDec:
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize()); ADD_REX_W_BY_SIZE(o0->getSize());
@@ -1421,7 +1424,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Int: case kX86InstEncodingX86Int:
if (encoded == ENC_OPS(Imm, None, None)) { if (encoded == ENC_OPS(Imm, None, None)) {
imVal = static_cast<const Imm*>(o0)->getInt64(); imVal = static_cast<const Imm*>(o0)->getInt64();
uint8_t imm8 = static_cast<uint8_t>(imVal & 0xFF); uint8_t imm8 = static_cast<uint8_t>(imVal & 0xFF);
@@ -1437,7 +1440,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Jcc: case kX86InstEncodingX86Jcc:
if (encoded == ENC_OPS(Label, None, None)) { if (encoded == ENC_OPS(Label, None, None)) {
label = self->getLabelData(static_cast<const Label*>(o0)->getId()); label = self->getLabelData(static_cast<const Label*>(o0)->getId());
@@ -1493,7 +1496,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Jecxz: case kX86InstEncodingX86Jecxz:
if (encoded == ENC_OPS(Reg, Label, None)) { if (encoded == ENC_OPS(Reg, Label, None)) {
if (x86OpReg(o0) != kX86RegIndexCx) if (x86OpReg(o0) != kX86RegIndexCx)
goto _IllegalInst; goto _IllegalInst;
@@ -1525,7 +1528,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Jmp: case kX86InstEncodingX86Jmp:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
rmReg = x86OpReg(o0); rmReg = x86OpReg(o0);
goto _EmitX86R; goto _EmitX86R;
@@ -1588,7 +1591,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Lea: case kX86InstEncodingX86Lea:
if (encoded == ENC_OPS(Reg, Mem, None)) { if (encoded == ENC_OPS(Reg, Mem, None)) {
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize()); ADD_REX_W_BY_SIZE(o0->getSize());
@@ -1599,7 +1602,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Mov: case kX86InstEncodingX86Mov:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -1746,7 +1749,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86MovSxZx: case kX86InstEncodingX86MovSxZx:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opCode += o1->getSize() != 1; opCode += o1->getSize() != 1;
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
@@ -1768,7 +1771,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86MovSxd: case kX86InstEncodingX86MovSxd:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
ADD_REX_W(true); ADD_REX_W(true);
@@ -1786,7 +1789,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86MovPtr: case kX86InstEncodingX86MovPtr:
if (encoded == ENC_OPS(Reg, Imm, None)) { if (encoded == ENC_OPS(Reg, Imm, None)) {
if (x86OpReg(o0) != 0) if (x86OpReg(o0) != 0)
goto _IllegalInst; goto _IllegalInst;
@@ -1817,7 +1820,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
break; break;
case kX86InstEncodingIdX86Push: case kX86InstEncodingX86Push:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
if (o0->isRegType(kX86RegTypeSeg)) { if (o0->isRegType(kX86RegTypeSeg)) {
uint32_t segment = x86OpReg(o0); uint32_t segment = x86OpReg(o0);
@@ -1844,7 +1847,7 @@ static ASMJIT_INLINE Error X86Assembler_emit(Assembler* self_, uint32_t code, co
} }
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdX86Pop: case kX86InstEncodingX86Pop:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
if (o0->isRegType(kX86RegTypeSeg)) { if (o0->isRegType(kX86RegTypeSeg)) {
uint32_t segment = x86OpReg(o0); uint32_t segment = x86OpReg(o0);
@@ -1883,12 +1886,12 @@ _GroupPop_Gp:
} }
break; break;
case kX86InstEncodingIdX86Rep: case kX86InstEncodingX86Rep:
// Emit REP 0xF2 or 0xF3 prefix first. // Emit REP 0xF2 or 0xF3 prefix first.
EMIT_BYTE(0xF2 + opReg); EMIT_BYTE(0xF2 + opReg);
goto _EmitX86Op; goto _EmitX86Op;
case kX86InstEncodingIdX86Ret: case kX86InstEncodingX86Ret:
if (encoded == ENC_OPS(None, None, None)) { if (encoded == ENC_OPS(None, None, None)) {
EMIT_BYTE(0xC3); EMIT_BYTE(0xC3);
goto _EmitDone; goto _EmitDone;
@@ -1908,7 +1911,7 @@ _GroupPop_Gp:
} }
break; break;
case kX86InstEncodingIdX86Rot: case kX86InstEncodingX86Rot:
opCode += o0->getSize() != 1; opCode += o0->getSize() != 1;
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize()); ADD_REX_W_BY_SIZE(o0->getSize());
@@ -1949,7 +1952,7 @@ _GroupPop_Gp:
} }
break; break;
case kX86InstEncodingIdX86Set: case kX86InstEncodingX86Set:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
ASMJIT_ASSERT(o0->getSize() == 1); ASMJIT_ASSERT(o0->getSize() == 1);
@@ -1965,7 +1968,7 @@ _GroupPop_Gp:
} }
break; break;
case kX86InstEncodingIdX86Shlrd: case kX86InstEncodingX86Shlrd:
if (encoded == ENC_OPS(Reg, Reg, Imm)) { if (encoded == ENC_OPS(Reg, Reg, Imm)) {
ASMJIT_ASSERT(o0->getSize() == o1->getSize()); ASMJIT_ASSERT(o0->getSize() == o1->getSize());
@@ -2019,7 +2022,7 @@ _GroupPop_Gp:
} }
break; break;
case kX86InstEncodingIdX86Test: case kX86InstEncodingX86Test:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
ASMJIT_ASSERT(o0->getSize() == o1->getSize()); ASMJIT_ASSERT(o0->getSize() == o1->getSize());
@@ -2079,7 +2082,7 @@ _GroupPop_Gp:
} }
break; break;
case kX86InstEncodingIdX86Xchg: case kX86InstEncodingX86Xchg:
if (encoded == ENC_OPS(Reg, Mem, None)) { if (encoded == ENC_OPS(Reg, Mem, None)) {
opCode += o0->getSize() != 1; opCode += o0->getSize() != 1;
ADD_66H_P_BY_SIZE(o0->getSize()); ADD_66H_P_BY_SIZE(o0->getSize());
@@ -2091,7 +2094,7 @@ _GroupPop_Gp:
} }
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdX86Xadd: case kX86InstEncodingX86Xadd:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o1); opReg = x86OpReg(o1);
rmReg = x86OpReg(o0); rmReg = x86OpReg(o0);
@@ -2123,14 +2126,57 @@ _GroupPop_Gp:
} }
break; break;
case kX86InstEncodingX86Crc:
ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize());
if (encoded == ENC_OPS(Reg, Reg, None)) {
if (!Utils::inInterval<uint32_t>(static_cast<const X86Reg*>(o0)->getRegType(), kX86RegTypeGpd, kX86RegTypeGpq))
goto _IllegalInst;
opCode += o0->getSize() != 1;
opReg = x86OpReg(o0);
rmReg = x86OpReg(o1);
goto _EmitX86R;
}
if (encoded == ENC_OPS(Reg, Mem, None)) {
if (!Utils::inInterval<uint32_t>(static_cast<const X86Reg*>(o0)->getRegType(), kX86RegTypeGpd, kX86RegTypeGpq))
goto _IllegalInst;
opCode += o0->getSize() != 1;
opReg = x86OpReg(o0);
rmMem = x86OpMem(o1);
goto _EmitX86M;
}
break;
case kX86InstEncodingX86Prefetch:
if (encoded == ENC_OPS(Mem, Imm, None)) {
opReg = static_cast<const Imm*>(o1)->getUInt32() & 0x3;
rmMem = x86OpMem(o0);
goto _EmitX86M;
}
break;
case kX86InstEncodingX86Fence:
if (Arch == kArchX64 && (opCode & kX86InstOpCode_W_Mask)) {
EMIT_BYTE(kX86ByteRex | kX86ByteRexW);
}
EMIT_BYTE(0x0F);
EMIT_BYTE(opCode);
EMIT_BYTE(0xC0 | (opReg << 3));
goto _EmitDone;
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
// [Fpu] // [Fpu]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdFpuOp: case kX86InstEncodingFpuOp:
goto _EmitFpuOp; goto _EmitFpuOp;
case kX86InstEncodingIdFpuArith: case kX86InstEncodingFpuArith:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2161,7 +2207,7 @@ _EmitFpArith_Mem:
} }
break; break;
case kX86InstEncodingIdFpuCom: case kX86InstEncodingFpuCom:
if (encoded == ENC_OPS(None, None, None)) { if (encoded == ENC_OPS(None, None, None)) {
rmReg = 1; rmReg = 1;
goto _EmitFpArith_Reg; goto _EmitFpArith_Reg;
@@ -2177,7 +2223,7 @@ _EmitFpArith_Mem:
} }
break; break;
case kX86InstEncodingIdFpuFldFst: case kX86InstEncodingFpuFldFst:
if (encoded == ENC_OPS(Mem, None, None)) { if (encoded == ENC_OPS(Mem, None, None)) {
rmMem = x86OpMem(o0); rmMem = x86OpMem(o0);
@@ -2216,7 +2262,7 @@ _EmitFpArith_Mem:
break; break;
case kX86InstEncodingIdFpuM: case kX86InstEncodingFpuM:
if (encoded == ENC_OPS(Mem, None, None)) { if (encoded == ENC_OPS(Mem, None, None)) {
rmMem = x86OpMem(o0); rmMem = x86OpMem(o0);
@@ -2237,21 +2283,21 @@ _EmitFpArith_Mem:
} }
break; break;
case kX86InstEncodingIdFpuRDef: case kX86InstEncodingFpuRDef:
if (encoded == ENC_OPS(None, None, None)) { if (encoded == ENC_OPS(None, None, None)) {
opCode += 1; opCode += 1;
goto _EmitFpuOp; goto _EmitFpuOp;
} }
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdFpuR: case kX86InstEncodingFpuR:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
opCode += x86OpReg(o0); opCode += x86OpReg(o0);
goto _EmitFpuOp; goto _EmitFpuOp;
} }
break; break;
case kX86InstEncodingIdFpuStsw: case kX86InstEncodingFpuStsw:
if (encoded == ENC_OPS(Reg, None, None)) { if (encoded == ENC_OPS(Reg, None, None)) {
if (x86OpReg(o0) != 0) if (x86OpReg(o0) != 0)
goto _IllegalInst; goto _IllegalInst;
@@ -2270,32 +2316,7 @@ _EmitFpArith_Mem:
// [Ext] // [Ext]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdExtCrc: case kX86InstEncodingSimdPextrw:
ADD_66H_P_BY_SIZE(o0->getSize());
ADD_REX_W_BY_SIZE(o0->getSize());
if (encoded == ENC_OPS(Reg, Reg, None)) {
if (!Utils::inInterval<uint32_t>(static_cast<const X86Reg*>(o0)->getRegType(), kX86RegTypeGpd, kX86RegTypeGpq))
goto _IllegalInst;
opCode += o0->getSize() != 1;
opReg = x86OpReg(o0);
rmReg = x86OpReg(o1);
goto _EmitX86R;
}
if (encoded == ENC_OPS(Reg, Mem, None)) {
if (!Utils::inInterval<uint32_t>(static_cast<const X86Reg*>(o0)->getRegType(), kX86RegTypeGpd, kX86RegTypeGpq))
goto _IllegalInst;
opCode += o0->getSize() != 1;
opReg = x86OpReg(o0);
rmMem = x86OpMem(o1);
goto _EmitX86M;
}
break;
case kX86InstEncodingIdExtExtrW:
if (encoded == ENC_OPS(Reg, Reg, Imm)) { if (encoded == ENC_OPS(Reg, Reg, Imm)) {
ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o1))); ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o1)));
@@ -2321,7 +2342,7 @@ _EmitFpArith_Mem:
} }
break; break;
case kX86InstEncodingIdExtExtract: case kX86InstEncodingSimdExtract:
if (encoded == ENC_OPS(Reg, Reg, Imm)) { if (encoded == ENC_OPS(Reg, Reg, Imm)) {
ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o1))); ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o1)));
@@ -2345,18 +2366,8 @@ _EmitFpArith_Mem:
} }
break; break;
case kX86InstEncodingIdExtFence: case kX86InstEncodingSimdMov:
if (Arch == kArchX64 && (opCode & kX86InstOpCode_W_Mask)) { case kX86InstEncodingSimdMovNoRexW:
EMIT_BYTE(kX86ByteRex | kX86ByteRexW);
}
EMIT_BYTE(0x0F);
EMIT_BYTE(opCode);
EMIT_BYTE(0xC0 | (opReg << 3));
goto _EmitDone;
case kX86InstEncodingIdExtMov:
case kX86InstEncodingIdExtMovNoRexW:
ASMJIT_ASSERT(extendedInfo._opFlags[0] != 0); ASMJIT_ASSERT(extendedInfo._opFlags[0] != 0);
ASMJIT_ASSERT(extendedInfo._opFlags[1] != 0); ASMJIT_ASSERT(extendedInfo._opFlags[1] != 0);
@@ -2374,8 +2385,8 @@ _EmitFpArith_Mem:
// Gp|Mm|Xmm <- Gp|Mm|Xmm // Gp|Mm|Xmm <- Gp|Mm|Xmm
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
ADD_REX_W(static_cast<const X86Reg*>(o0)->isGpq() && (info.getEncodingId() != kX86InstEncodingIdExtMovNoRexW)); ADD_REX_W(x86IsGpq(static_cast<const X86Reg*>(o0)) && (info.getEncoding() != kX86InstEncodingSimdMovNoRexW));
ADD_REX_W(static_cast<const X86Reg*>(o1)->isGpq() && (info.getEncodingId() != kX86InstEncodingIdExtMovNoRexW)); ADD_REX_W(x86IsGpq(static_cast<const X86Reg*>(o1)) && (info.getEncoding() != kX86InstEncodingSimdMovNoRexW));
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2384,7 +2395,7 @@ _EmitFpArith_Mem:
// Gp|Mm|Xmm <- Mem // Gp|Mm|Xmm <- Mem
if (encoded == ENC_OPS(Reg, Mem, None)) { if (encoded == ENC_OPS(Reg, Mem, None)) {
ADD_REX_W(static_cast<const X86Reg*>(o0)->isGpq() && (info.getEncodingId() != kX86InstEncodingIdExtMovNoRexW)); ADD_REX_W(x86IsGpq(static_cast<const X86Reg*>(o0)) && (info.getEncoding() != kX86InstEncodingSimdMovNoRexW));
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmMem = x86OpMem(o1); rmMem = x86OpMem(o1);
@@ -2396,7 +2407,7 @@ _EmitFpArith_Mem:
// X86Mem <- Gp|Mm|Xmm // X86Mem <- Gp|Mm|Xmm
if (encoded == ENC_OPS(Mem, Reg, None)) { if (encoded == ENC_OPS(Mem, Reg, None)) {
ADD_REX_W(static_cast<const X86Reg*>(o1)->isGpq() && (info.getEncodingId() != kX86InstEncodingIdExtMovNoRexW)); ADD_REX_W(x86IsGpq(static_cast<const X86Reg*>(o1)) && (info.getEncoding() != kX86InstEncodingSimdMovNoRexW));
opReg = x86OpReg(o1); opReg = x86OpReg(o1);
rmMem = x86OpMem(o0); rmMem = x86OpMem(o0);
@@ -2404,7 +2415,7 @@ _EmitFpArith_Mem:
} }
break; break;
case kX86InstEncodingIdExtMovBe: case kX86InstEncodingSimdMovBe:
if (encoded == ENC_OPS(Reg, Mem, None)) { if (encoded == ENC_OPS(Reg, Mem, None)) {
if (o0->getSize() == 1) if (o0->getSize() == 1)
goto _IllegalInst; goto _IllegalInst;
@@ -2433,7 +2444,7 @@ _EmitFpArith_Mem:
} }
break; break;
case kX86InstEncodingIdExtMovD: case kX86InstEncodingSimdMovD:
_EmitMmMovD: _EmitMmMovD:
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o0))); ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o0)));
@@ -2468,7 +2479,7 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtMovQ: case kX86InstEncodingSimdMovQ:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2539,23 +2550,15 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtPrefetch: case kX86InstEncodingSimdRm_PQ:
if (encoded == ENC_OPS(Mem, Imm, None)) {
opReg = static_cast<const Imm*>(o1)->getUInt32() & 0x3;
rmMem = x86OpMem(o0);
goto _EmitX86M;
}
break;
case kX86InstEncodingIdExtRm_PQ:
ADD_66H_P(o0->isRegType(kX86RegTypeXmm) || o1->isRegType(kX86RegTypeXmm)); ADD_66H_P(o0->isRegType(kX86RegTypeXmm) || o1->isRegType(kX86RegTypeXmm));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdExtRm_Q: case kX86InstEncodingSimdRm_Q:
ADD_REX_W(o0->isRegType(kX86RegTypeGpq) || o1->isRegType(kX86RegTypeGpq) || (o1->isMem() && o1->getSize() == 8)); ADD_REX_W(o0->isRegType(kX86RegTypeGpq) || o1->isRegType(kX86RegTypeGpq) || (o1->isMem() && o1->getSize() == 8));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdExtRm: case kX86InstEncodingSimdRm:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2569,7 +2572,7 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtRm_P: case kX86InstEncodingSimdRm_P:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o0)) | x86IsXmm(static_cast<const X86Reg*>(o1))); ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o0)) | x86IsXmm(static_cast<const X86Reg*>(o1)));
@@ -2587,7 +2590,7 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtRmRi: case kX86InstEncodingSimdRmRi:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2613,7 +2616,7 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtRmRi_P: case kX86InstEncodingSimdRmRi_P:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o0)) | x86IsXmm(static_cast<const X86Reg*>(o1))); ADD_66H_P(x86IsXmm(static_cast<const X86Reg*>(o0)) | x86IsXmm(static_cast<const X86Reg*>(o1)));
@@ -2645,7 +2648,7 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtRmi: case kX86InstEncodingSimdRmi:
imVal = static_cast<const Imm*>(o2)->getInt64(); imVal = static_cast<const Imm*>(o2)->getInt64();
imLen = 1; imLen = 1;
@@ -2662,7 +2665,7 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtRmi_P: case kX86InstEncodingSimdRmi_P:
imVal = static_cast<const Imm*>(o2)->getInt64(); imVal = static_cast<const Imm*>(o2)->getInt64();
imLen = 1; imLen = 1;
@@ -2687,7 +2690,7 @@ _EmitMmMovD:
// [Group - Extrq / Insertq (SSE4a)] // [Group - Extrq / Insertq (SSE4a)]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdExtExtrq: case kX86InstEncodingSimdExtrq:
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2707,7 +2710,7 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdExtInsertq: case kX86InstEncodingSimdInsertq:
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2729,7 +2732,7 @@ _EmitMmMovD:
// [Group - 3dNow] // [Group - 3dNow]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingId3dNow: case kX86InstEncodingSimd3dNow:
// Every 3dNow instruction starts with 0x0F0F and the actual opcode is // Every 3dNow instruction starts with 0x0F0F and the actual opcode is
// stored as 8-bit immediate. // stored as 8-bit immediate.
imVal = opCode & 0xFF; imVal = opCode & 0xFF;
@@ -2753,21 +2756,21 @@ _EmitMmMovD:
// [Avx] // [Avx]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdAvxOp: case kX86InstEncodingAvxOp:
goto _EmitAvxOp; goto _EmitAvxOp;
case kX86InstEncodingIdAvxM: case kX86InstEncodingAvxM:
if (encoded == ENC_OPS(Mem, None, None)) { if (encoded == ENC_OPS(Mem, None, None)) {
rmMem = x86OpMem(o0); rmMem = x86OpMem(o0);
goto _EmitAvxM; goto _EmitAvxM;
} }
break; break;
case kX86InstEncodingIdAvxMr_P: case kX86InstEncodingAvxMr_OptL:
ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxMr: case kX86InstEncodingAvxMr:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o1); opReg = x86OpReg(o1);
rmReg = x86OpReg(o0); rmReg = x86OpReg(o0);
@@ -2781,11 +2784,11 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdAvxMri_P: case kX86InstEncodingAvxMri_OptL:
ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxMri: case kX86InstEncodingAvxMri:
imVal = static_cast<const Imm*>(o2)->getInt64(); imVal = static_cast<const Imm*>(o2)->getInt64();
imLen = 1; imLen = 1;
@@ -2802,11 +2805,11 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdAvxRm_P: case kX86InstEncodingAvxRm_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRm: case kX86InstEncodingAvxRm:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2820,11 +2823,8 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdAvxRmi_P: case kX86InstEncodingAvxRmi:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1)); CaseAvxRmi:
ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRmi:
imVal = static_cast<const Imm*>(o2)->getInt64(); imVal = static_cast<const Imm*>(o2)->getInt64();
imLen = 1; imLen = 1;
@@ -2841,13 +2841,18 @@ _EmitMmMovD:
} }
break; break;
case kX86InstEncodingIdAvxRvm_P: case kX86InstEncodingAvxRmi_OptW:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsGpq(static_cast<const X86Reg*>(o0)) | x86IsGpq(o1));
ASMJIT_FALLTHROUGH; goto CaseAvxRmi;
case kX86InstEncodingIdAvxRvm: case kX86InstEncodingAvxRmi_OptL:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1));
goto CaseAvxRmi;
case kX86InstEncodingAvxRvm:
_EmitAvxRvm: _EmitAvxRvm:
if (encoded == ENC_OPS(Reg, Reg, Reg)) {
_EmitAvxRvm_Reg:
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1));
rmReg = x86OpReg(o2); rmReg = x86OpReg(o2);
goto _EmitAvxR; goto _EmitAvxR;
@@ -2860,11 +2865,19 @@ _EmitAvxRvm:
} }
break; break;
case kX86InstEncodingIdAvxRvmr_P: case kX86InstEncodingAvxRvm_OptW:
ADD_VEX_L(x86IsGpq(static_cast<const X86Reg*>(o0)) | x86IsGpq(static_cast<const X86Reg*>(o1)));
goto _EmitAvxRvm;
case kX86InstEncodingAvxRvm_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
goto _EmitAvxRvm;
case kX86InstEncodingAvxRvmr_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRvmr: case kX86InstEncodingAvxRvmr:
if (!o3->isReg()) if (!o3->isReg())
goto _IllegalInst; goto _IllegalInst;
@@ -2884,11 +2897,11 @@ _EmitAvxRvm:
} }
break; break;
case kX86InstEncodingIdAvxRvmi_P: case kX86InstEncodingAvxRvmi_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRvmi: case kX86InstEncodingAvxRvmi:
if (!o3->isImm()) if (!o3->isImm())
goto _IllegalInst; goto _IllegalInst;
@@ -2908,7 +2921,8 @@ _EmitAvxRvm:
} }
break; break;
case kX86InstEncodingIdAvxRmv: case kX86InstEncodingAvxRmv:
CaseAvxRmv:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2));
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2922,7 +2936,11 @@ _EmitAvxRvm:
} }
break; break;
case kX86InstEncodingIdAvxRmvi: case kX86InstEncodingAvxRmv_OptW:
ADD_VEX_W(x86IsGpq(static_cast<const X86Reg*>(o0)) | x86IsGpq(static_cast<const X86Reg*>(o2)));
goto CaseAvxRmv;
case kX86InstEncodingAvxRmvi:
if (!o3->isImm()) if (!o3->isImm())
goto _IllegalInst; goto _IllegalInst;
@@ -2942,7 +2960,7 @@ _EmitAvxRvm:
} }
break; break;
case kX86InstEncodingIdAvxMovDQ: case kX86InstEncodingAvxMovDQ:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
if (static_cast<const X86Reg*>(o0)->isGp()) { if (static_cast<const X86Reg*>(o0)->isGp()) {
opCode = extendedInfo.getSecondaryOpCode(); opCode = extendedInfo.getSecondaryOpCode();
@@ -2960,11 +2978,11 @@ _EmitAvxRvm:
goto _AvxRmMr_AfterRegRegCheck; goto _AvxRmMr_AfterRegRegCheck;
case kX86InstEncodingIdAvxRmMr_P: case kX86InstEncodingAvxRmMr_OptL:
ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRmMr: case kX86InstEncodingAvxRmMr:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -2989,11 +3007,11 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxRvmRmi_P: case kX86InstEncodingAvxRvmRmi_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRvmRmi: case kX86InstEncodingAvxRvmRmi:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1));
rmReg = x86OpReg(o2); rmReg = x86OpReg(o2);
@@ -3026,7 +3044,7 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxRvmMr: case kX86InstEncodingAvxRvmMr:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1));
rmReg = x86OpReg(o2); rmReg = x86OpReg(o2);
@@ -3055,11 +3073,11 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxRvmMvr_P: case kX86InstEncodingAvxRvmMvr_OptL:
ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(o0) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRvmMvr: case kX86InstEncodingAvxRvmMvr:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1));
rmReg = x86OpReg(o2); rmReg = x86OpReg(o2);
@@ -3083,11 +3101,11 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxRvmVmi_P: case kX86InstEncodingAvxRvmVmi_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRvmVmi: case kX86InstEncodingAvxRvmVmi:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o1));
rmReg = x86OpReg(o2); rmReg = x86OpReg(o2);
@@ -3121,7 +3139,8 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxVm: case kX86InstEncodingAvxVm:
CaseAvxVm:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86RegAndVvvv(opReg, x86OpReg(o0)); opReg = x86RegAndVvvv(opReg, x86OpReg(o0));
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -3135,11 +3154,15 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxVmi_P: case kX86InstEncodingAvxVm_OptW:
ADD_VEX_W(x86IsGpq(static_cast<const X86Reg*>(o0)) | x86IsGpq(o1));
goto CaseAvxVm;
case kX86InstEncodingAvxVmi_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxVmi: case kX86InstEncodingAvxVmi:
imVal = static_cast<const Imm*>(o3)->getInt64(); imVal = static_cast<const Imm*>(o3)->getInt64();
imLen = 1; imLen = 1;
@@ -3156,11 +3179,11 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxRvrmRvmr_P: case kX86InstEncodingAvxRvrmRvmr_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdAvxRvrmRvmr: case kX86InstEncodingAvxRvrmRvmr:
if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) { if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) {
imVal = x86OpReg(o3) << 4; imVal = x86OpReg(o3) << 4;
imLen = 1; imLen = 1;
@@ -3193,9 +3216,9 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxMovSsSd: case kX86InstEncodingAvxMovSsSd:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
goto _EmitAvxRvm; goto _EmitAvxRvm_Reg;
} }
if (encoded == ENC_OPS(Reg, Mem, None)) { if (encoded == ENC_OPS(Reg, Mem, None)) {
@@ -3212,7 +3235,7 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxGatherEx: case kX86InstEncodingAvxGatherEx:
if (encoded == ENC_OPS(Reg, Mem, Reg)) { if (encoded == ENC_OPS(Reg, Mem, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2));
rmMem = x86OpMem(o1); rmMem = x86OpMem(o1);
@@ -3226,7 +3249,7 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdAvxGather: case kX86InstEncodingAvxGather:
if (encoded == ENC_OPS(Reg, Mem, Reg)) { if (encoded == ENC_OPS(Reg, Mem, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2));
rmMem = x86OpMem(o1); rmMem = x86OpMem(o1);
@@ -3244,12 +3267,12 @@ _AvxRmMr_AfterRegRegCheck:
// [FMA4] // [FMA4]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdFma4_P: case kX86InstEncodingFma4_OptL:
// It's fine to just check the first operand, second is just for sanity. // It's fine to just check the first operand, second is just for sanity.
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdFma4: case kX86InstEncodingFma4:
if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) { if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) {
imVal = x86OpReg(o3) << 4; imVal = x86OpReg(o3) << 4;
imLen = 1; imLen = 1;
@@ -3286,11 +3309,11 @@ _AvxRmMr_AfterRegRegCheck:
// [XOP] // [XOP]
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
case kX86InstEncodingIdXopRm_P: case kX86InstEncodingXopRm_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1)); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(o1));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdXopRm: case kX86InstEncodingXopRm:
if (encoded == ENC_OPS(Reg, Reg, None)) { if (encoded == ENC_OPS(Reg, Reg, None)) {
opReg = x86OpReg(o0); opReg = x86OpReg(o0);
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -3304,7 +3327,7 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdXopRvmRmv: case kX86InstEncodingXopRvmRmv:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2));
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -3329,7 +3352,7 @@ _AvxRmMr_AfterRegRegCheck:
break; break;
case kX86InstEncodingIdXopRvmRmi: case kX86InstEncodingXopRvmRmi:
if (encoded == ENC_OPS(Reg, Reg, Reg)) { if (encoded == ENC_OPS(Reg, Reg, Reg)) {
opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2)); opReg = x86RegAndVvvv(x86OpReg(o0), x86OpReg(o2));
rmReg = x86OpReg(o1); rmReg = x86OpReg(o1);
@@ -3370,11 +3393,11 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdXopRvmr_P: case kX86InstEncodingXopRvmr_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdXopRvmr: case kX86InstEncodingXopRvmr:
if (!o3->isReg()) if (!o3->isReg())
goto _IllegalInst; goto _IllegalInst;
@@ -3394,11 +3417,11 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdXopRvmi_P: case kX86InstEncodingXopRvmi_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdXopRvmi: case kX86InstEncodingXopRvmi:
if (!o3->isImm()) if (!o3->isImm())
goto _IllegalInst; goto _IllegalInst;
@@ -3418,11 +3441,11 @@ _AvxRmMr_AfterRegRegCheck:
} }
break; break;
case kX86InstEncodingIdXopRvrmRvmr_P: case kX86InstEncodingXopRvrmRvmr_OptL:
ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1))); ADD_VEX_L(x86IsYmm(static_cast<const X86Reg*>(o0)) | x86IsYmm(static_cast<const X86Reg*>(o1)));
ASMJIT_FALLTHROUGH; ASMJIT_FALLTHROUGH;
case kX86InstEncodingIdXopRvrmRvmr: case kX86InstEncodingXopRvrmRvmr:
if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) { if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) {
imVal = x86OpReg(o3) << 4; imVal = x86OpReg(o3) << 4;
imLen = 1; imLen = 1;

5
src/asmjit/x86/x86assembler.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_X86_X86ASSEMBLER_H #ifndef _ASMJIT_X86_X86ASSEMBLER_H
#define _ASMJIT_X86_X86ASSEMBLER_H #define _ASMJIT_X86_X86ASSEMBLER_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/assembler.h" #include "../base/assembler.h"
#include "../x86/x86inst.h" #include "../x86/x86inst.h"
#include "../x86/x86operand.h" #include "../x86/x86operand.h"
@@ -379,7 +379,8 @@ namespace asmjit {
//! functions available that return a new register operand. //! functions available that return a new register operand.
//! //!
//! \sa X86Compiler. //! \sa X86Compiler.
struct ASMJIT_VIRTAPI X86Assembler : public Assembler { class ASMJIT_VIRTAPI X86Assembler : public Assembler {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/x86/x86compiler.cpp
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) && (defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)) #if !defined(ASMJIT_DISABLE_COMPILER) && (defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64))
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/containers.h" #include "../base/containers.h"
#include "../base/utils.h" #include "../base/utils.h"
#include "../x86/x86assembler.h" #include "../x86/x86assembler.h"

15
src/asmjit/x86/x86compiler.h
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/compiler.h" #include "../base/compiler.h"
#include "../base/vectypes.h" #include "../base/vectypes.h"
#include "../x86/x86assembler.h" #include "../x86/x86assembler.h"
@@ -26,8 +26,8 @@ namespace asmjit {
// [Forward Declarations] // [Forward Declarations]
// ============================================================================ // ============================================================================
struct X86CallNode; class X86CallNode;
struct X86FuncNode; class X86FuncNode;
//! \addtogroup asmjit_x86 //! \addtogroup asmjit_x86
//! \{ //! \{
@@ -64,7 +64,8 @@ ASMJIT_VARAPI const uint8_t _x64VarMapping[kX86VarTypeCount];
// ============================================================================ // ============================================================================
//! X86/X64 function node. //! X86/X64 function node.
struct X86FuncNode : public HLFunc { class X86FuncNode : public HLFunc {
public:
ASMJIT_NO_COPY(X86FuncNode) ASMJIT_NO_COPY(X86FuncNode)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -194,7 +195,8 @@ struct X86FuncNode : public HLFunc {
// ============================================================================ // ============================================================================
//! X86/X64 function-call node. //! X86/X64 function-call node.
struct X86CallNode : public HLCall { class X86CallNode : public HLCall {
public:
ASMJIT_NO_COPY(X86CallNode) ASMJIT_NO_COPY(X86CallNode)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -711,7 +713,8 @@ struct X86CallNode : public HLCall {
//! Other use cases are waiting for you! Be sure that instruction that are //! Other use cases are waiting for you! Be sure that instruction that are
//! being emitted are correct and encodable, otherwise the Assembler will //! being emitted are correct and encodable, otherwise the Assembler will
//! fail and set the status code to `kErrorUnknownInst`. //! fail and set the status code to `kErrorUnknownInst`.
struct ASMJIT_VIRTAPI X86Compiler : public Compiler { class ASMJIT_VIRTAPI X86Compiler : public Compiler {
public:
ASMJIT_NO_COPY(X86Compiler) ASMJIT_NO_COPY(X86Compiler)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------

2
src/asmjit/x86/x86compilercontext.cpp
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) && (defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)) #if !defined(ASMJIT_DISABLE_COMPILER) && (defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64))
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/containers.h" #include "../base/containers.h"
#include "../base/cpuinfo.h" #include "../base/cpuinfo.h"
#include "../base/utils.h" #include "../base/utils.h"

2
src/asmjit/x86/x86compilercontext_p.h
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/compiler.h" #include "../base/compiler.h"
#include "../base/compilercontext_p.h" #include "../base/compilercontext_p.h"
#include "../base/utils.h" #include "../base/utils.h"

2
src/asmjit/x86/x86compilerfunc.cpp
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) && (defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)) #if !defined(ASMJIT_DISABLE_COMPILER) && (defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64))
// [Dependencies - AsmJit] // [Dependencies]
#include "../x86/x86compiler.h" #include "../x86/x86compiler.h"
#include "../x86/x86compilerfunc.h" #include "../x86/x86compilerfunc.h"

2
src/asmjit/x86/x86compilerfunc.h
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/compilerfunc.h" #include "../base/compilerfunc.h"
#include "../x86/x86operand.h" #include "../x86/x86operand.h"

3828
src/asmjit/x86/x86inst.cpp
View File

File diff suppressed because it is too large Load Diff

832
src/asmjit/x86/x86inst.h
View File

File diff suppressed because it is too large Load Diff

2
src/asmjit/x86/x86operand.cpp
View File

@@ -11,7 +11,7 @@
#include "../build.h" #include "../build.h"
#if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64) #if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)
// [Dependencies - AsmJit] // [Dependencies]
#include "../x86/x86operand.h" #include "../x86/x86operand.h"
// [Api-Begin] // [Api-Begin]

117
src/asmjit/x86/x86operand.h
View File

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_X86_X86OPERAND_H #ifndef _ASMJIT_X86_X86OPERAND_H
#define _ASMJIT_X86_X86OPERAND_H #define _ASMJIT_X86_X86OPERAND_H
// [Dependencies - AsmJit] // [Dependencies]
#include "../base/assembler.h" #include "../base/assembler.h"
#include "../base/compiler.h" #include "../base/compiler.h"
#include "../base/operand.h" #include "../base/operand.h"
@@ -30,26 +30,26 @@ namespace asmjit {
// [Forward Declarations] // [Forward Declarations]
// ============================================================================ // ============================================================================
struct X86Reg; class X86Reg;
struct X86GpReg; class X86GpReg;
struct X86FpReg; class X86FpReg;
struct X86MmReg; class X86MmReg;
struct X86KReg; class X86KReg;
struct X86XmmReg; class X86XmmReg;
struct X86YmmReg; class X86YmmReg;
struct X86ZmmReg; class X86ZmmReg;
struct X86SegReg; class X86SegReg;
struct X86RipReg; class X86RipReg;
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
struct X86Var; class X86Var;
struct X86GpVar; class X86GpVar;
struct X86MmVar; class X86MmVar;
struct X86KVar; class X86KVar;
struct X86XmmVar; class X86XmmVar;
struct X86YmmVar; class X86YmmVar;
struct X86ZmmVar; class X86ZmmVar;
#endif // !ASMJIT_DISABLE_COMPILER #endif // !ASMJIT_DISABLE_COMPILER
//! \addtogroup asmjit_x86 //! \addtogroup asmjit_x86
@@ -680,15 +680,15 @@ struct X86RegMask {
// without calling a constructor. Compiler will store these in .DATA section. // without calling a constructor. Compiler will store these in .DATA section.
// //
// Kept in union to prevent LTO warnings. // Kept in union to prevent LTO warnings.
struct X86RipReg { union { Operand::VRegOp _vreg; }; }; class X86RipReg { public: union { Operand::VRegOp _vreg; }; };
struct X86SegReg { union { Operand::VRegOp _vreg; }; }; class X86SegReg { public: union { Operand::VRegOp _vreg; }; };
struct X86GpReg { union { Operand::VRegOp _vreg; }; }; class X86GpReg { public: union { Operand::VRegOp _vreg; }; };
struct X86FpReg { union { Operand::VRegOp _vreg; }; }; class X86FpReg { public: union { Operand::VRegOp _vreg; }; };
struct X86KReg { union { Operand::VRegOp _vreg; }; }; class X86KReg { public: union { Operand::VRegOp _vreg; }; };
struct X86MmReg { union { Operand::VRegOp _vreg; }; }; class X86MmReg { public: union { Operand::VRegOp _vreg; }; };
struct X86XmmReg { union { Operand::VRegOp _vreg; }; }; class X86XmmReg { public: union { Operand::VRegOp _vreg; }; };
struct X86YmmReg { union { Operand::VRegOp _vreg; }; }; class X86YmmReg { public: union { Operand::VRegOp _vreg; }; };
struct X86ZmmReg { union { Operand::VRegOp _vreg; }; }; class X86ZmmReg { public: union { Operand::VRegOp _vreg; }; };
#else #else
@@ -697,7 +697,8 @@ struct X86ZmmReg { union { Operand::VRegOp _vreg; }; };
// ============================================================================ // ============================================================================
//! X86/X86 register base class. //! X86/X86 register base class.
struct X86Reg : public Reg { class X86Reg : public Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -772,7 +773,8 @@ struct X86Reg : public Reg {
// ============================================================================ // ============================================================================
//! X86/X64 RIP register. //! X86/X64 RIP register.
struct X86RipReg : public X86Reg { class X86RipReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -796,7 +798,8 @@ struct X86RipReg : public X86Reg {
// ============================================================================ // ============================================================================
//! X86/X64 segment register. //! X86/X64 segment register.
struct X86SegReg : public X86Reg { class X86SegReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -824,7 +827,8 @@ struct X86SegReg : public X86Reg {
// ============================================================================ // ============================================================================
//! X86/X64 Gpb/Gpw/Gpd/Gpq register. //! X86/X64 Gpb/Gpw/Gpd/Gpq register.
struct X86GpReg : public X86Reg { class X86GpReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -879,7 +883,8 @@ struct X86GpReg : public X86Reg {
// ============================================================================ // ============================================================================
//! X86/X64 80-bit Fp register. //! X86/X64 80-bit Fp register.
struct X86FpReg : public X86Reg { class X86FpReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -932,7 +937,8 @@ struct X86FpReg : public X86Reg {
//! //!
//! - `movd` - writes 4-bytes in `LO-DWord` and zeroes `HI-DWord`. //! - `movd` - writes 4-bytes in `LO-DWord` and zeroes `HI-DWord`.
//! - `movq` - writes 8-bytes in `QWord`. //! - `movq` - writes 8-bytes in `QWord`.
struct X86MmReg : public X86Reg { class X86MmReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -960,7 +966,8 @@ struct X86MmReg : public X86Reg {
// ============================================================================ // ============================================================================
//! X86/X64 64-bit K register (AVX512+). //! X86/X64 64-bit K register (AVX512+).
struct X86KReg : public X86Reg { class X86KReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1041,7 +1048,8 @@ struct X86KReg : public X86Reg {
//! - `movddup`, //! - `movddup`,
//! - `movsldup`, //! - `movsldup`,
//! - `movshdup` - writes 16 bytes in `OWord`. //! - `movshdup` - writes 16 bytes in `OWord`.
struct X86XmmReg : public X86Reg { class X86XmmReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1102,7 +1110,8 @@ struct X86XmmReg : public X86Reg {
//! |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00| //! |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
//! +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ //! +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
//! ~~~ //! ~~~
struct X86YmmReg : public X86Reg { class X86YmmReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1143,7 +1152,8 @@ ASMJIT_INLINE X86YmmReg X86XmmReg::ymm() const noexcept { return X86YmmReg(kX86R
// ============================================================================ // ============================================================================
//! X86/X64 512-bit Zmm register (AVX512+). //! X86/X64 512-bit Zmm register (AVX512+).
struct X86ZmmReg : public X86Reg { class X86ZmmReg : public X86Reg {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1185,7 +1195,8 @@ ASMJIT_INLINE X86ZmmReg X86YmmReg::zmm() const noexcept { return X86ZmmReg(kX86R
// ============================================================================ // ============================================================================
//! X86 memory operand. //! X86 memory operand.
struct X86Mem : public BaseMem { class X86Mem : public BaseMem {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1649,7 +1660,8 @@ struct X86Mem : public BaseMem {
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
//! Base class for all X86 variables. //! Base class for all X86 variables.
struct X86Var : public Var { class X86Var : public Var {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1836,7 +1848,8 @@ protected:
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
//! Gp variable. //! Gp variable.
struct X86GpVar : public X86Var { class X86GpVar : public X86Var {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1906,7 +1919,8 @@ public:
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
//! Mm variable. //! Mm variable.
struct X86MmVar : public X86Var { class X86MmVar : public X86Var {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1945,7 +1959,8 @@ struct X86MmVar : public X86Var {
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
//! Xmm variable. //! Xmm variable.
struct X86XmmVar : public X86Var { class X86XmmVar : public X86Var {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -1954,8 +1969,8 @@ protected:
ASMJIT_INLINE X86XmmVar(const X86Var& other, uint32_t reg, uint32_t size) noexcept ASMJIT_INLINE X86XmmVar(const X86Var& other, uint32_t reg, uint32_t size) noexcept
: X86Var(other, reg, size) {} : X86Var(other, reg, size) {}
friend struct X86YmmVar; friend class X86YmmVar;
friend struct X86ZmmVar; friend class X86ZmmVar;
public: public:
//! Create a new uninitialized `X86XmmVar` instance. //! Create a new uninitialized `X86XmmVar` instance.
@@ -1999,7 +2014,8 @@ public:
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
//! Ymm variable. //! Ymm variable.
struct X86YmmVar : public X86Var { class X86YmmVar : public X86Var {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -2008,8 +2024,8 @@ protected:
ASMJIT_INLINE X86YmmVar(const X86Var& other, uint32_t reg, uint32_t size) noexcept ASMJIT_INLINE X86YmmVar(const X86Var& other, uint32_t reg, uint32_t size) noexcept
: X86Var(other, reg, size) {} : X86Var(other, reg, size) {}
friend struct X86XmmVar; friend class X86XmmVar;
friend struct X86ZmmVar; friend class X86ZmmVar;
public: public:
//! Create a new uninitialized `X86YmmVar` instance. //! Create a new uninitialized `X86YmmVar` instance.
@@ -2055,7 +2071,8 @@ ASMJIT_INLINE X86YmmVar X86XmmVar::ymm() const noexcept { return X86YmmVar(*this
#if !defined(ASMJIT_DISABLE_COMPILER) #if !defined(ASMJIT_DISABLE_COMPILER)
//! Zmm variable. //! Zmm variable.
struct X86ZmmVar : public X86Var { class X86ZmmVar : public X86Var {
public:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// [Construction / Destruction] // [Construction / Destruction]
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -2064,8 +2081,8 @@ protected:
ASMJIT_INLINE X86ZmmVar(const X86Var& other, uint32_t reg, uint32_t size) noexcept ASMJIT_INLINE X86ZmmVar(const X86Var& other, uint32_t reg, uint32_t size) noexcept
: X86Var(other, reg, size) {} : X86Var(other, reg, size) {}
friend struct X86XmmVar; friend class X86XmmVar;
friend struct X86YmmVar; friend class X86YmmVar;
public: public:
//! Create a new uninitialized `X86ZmmVar` instance. //! Create a new uninitialized `X86ZmmVar` instance.

277
src/asmjit/x86/x86operand_regs.cpp
View File

@@ -12,7 +12,7 @@
#include "../build.h" #include "../build.h"
#if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64) #if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)
// [Dependencies - AsmJit] // [Dependencies]
#include "../x86/x86operand.h" #include "../x86/x86operand.h"
// [Api-Begin] // [Api-Begin]
@@ -20,244 +20,41 @@
namespace asmjit { namespace asmjit {
#define REG(_Type_, _Index_, _Size_) {{{ \ #define REG(type, index, size) {{{ \
Operand::kTypeReg, _Size_, { ((_Type_) << 8) + _Index_ }, kInvalidValue, {{ kInvalidVar, 0 }} \ Operand::kTypeReg, size, { ((type) << 8) + index }, kInvalidValue, {{ kInvalidVar, 0 }} \
}}} }}}
#define REG_LIST_04(type, start, size) \
REG(type, start + 0, size), \
REG(type, start + 1, size), \
REG(type, start + 2, size), \
REG(type, start + 3, size)
#define REG_LIST_08(type, start, size) \
REG_LIST_04(type, start + 0, size), \
REG_LIST_04(type, start + 4, size)
#define REG_LIST_16(type, start, size) \
REG_LIST_08(type, start + 0, size), \
REG_LIST_08(type, start + 8, size)
#define REG_LIST_32(type, start, size) \
REG_LIST_16(type, start + 0, size), \
REG_LIST_16(type, start + 16, size)
const X86RegData x86RegData = { const X86RegData x86RegData = {
// Gpd. { REG_LIST_16(kX86RegTypeGpd , 0, 4) },
{ { REG_LIST_16(kX86RegTypeGpq , 0, 8) },
REG(kX86RegTypeGpd, 0 , 4), { REG_LIST_16(kX86RegTypeGpbLo, 0, 1) },
REG(kX86RegTypeGpd, 1 , 4), { REG_LIST_04(kX86RegTypeGpbHi, 0, 1) },
REG(kX86RegTypeGpd, 2 , 4), { REG_LIST_16(kX86RegTypeGpw , 0, 2) },
REG(kX86RegTypeGpd, 3 , 4), { REG_LIST_32(kX86RegTypeXmm , 0, 16) },
REG(kX86RegTypeGpd, 4 , 4), { REG_LIST_32(kX86RegTypeYmm , 0, 32) },
REG(kX86RegTypeGpd, 5 , 4), { REG_LIST_32(kX86RegTypeZmm , 0, 64) },
REG(kX86RegTypeGpd, 6 , 4), { REG_LIST_08(kX86RegTypeK , 0, 8) },
REG(kX86RegTypeGpd, 7 , 4), { REG_LIST_08(kX86RegTypeFp , 0, 10) },
REG(kX86RegTypeGpd, 8 , 4), { REG_LIST_08(kX86RegTypeMm , 0, 8) },
REG(kX86RegTypeGpd, 9 , 4),
REG(kX86RegTypeGpd, 10, 4),
REG(kX86RegTypeGpd, 11, 4),
REG(kX86RegTypeGpd, 12, 4),
REG(kX86RegTypeGpd, 13, 4),
REG(kX86RegTypeGpd, 14, 4),
REG(kX86RegTypeGpd, 15, 4)
},
// Gpq.
{
REG(kX86RegTypeGpq, 0 , 8),
REG(kX86RegTypeGpq, 1 , 8),
REG(kX86RegTypeGpq, 2 , 8),
REG(kX86RegTypeGpq, 3 , 8),
REG(kX86RegTypeGpq, 4 , 8),
REG(kX86RegTypeGpq, 5 , 8),
REG(kX86RegTypeGpq, 6 , 8),
REG(kX86RegTypeGpq, 7 , 8),
REG(kX86RegTypeGpq, 8 , 8),
REG(kX86RegTypeGpq, 9 , 8),
REG(kX86RegTypeGpq, 10, 8),
REG(kX86RegTypeGpq, 11, 8),
REG(kX86RegTypeGpq, 12, 8),
REG(kX86RegTypeGpq, 13, 8),
REG(kX86RegTypeGpq, 14, 8),
REG(kX86RegTypeGpq, 15, 8)
},
// GpbLo.
{
REG(kX86RegTypeGpbLo, 0, 1),
REG(kX86RegTypeGpbLo, 1, 1),
REG(kX86RegTypeGpbLo, 2, 1),
REG(kX86RegTypeGpbLo, 3, 1),
REG(kX86RegTypeGpbLo, 4, 1),
REG(kX86RegTypeGpbLo, 5, 1),
REG(kX86RegTypeGpbLo, 6, 1),
REG(kX86RegTypeGpbLo, 7, 1),
REG(kX86RegTypeGpbLo, 8, 1),
REG(kX86RegTypeGpbLo, 9, 1),
REG(kX86RegTypeGpbLo, 10, 1),
REG(kX86RegTypeGpbLo, 11, 1),
REG(kX86RegTypeGpbLo, 12, 1),
REG(kX86RegTypeGpbLo, 13, 1),
REG(kX86RegTypeGpbLo, 14, 1),
REG(kX86RegTypeGpbLo, 15, 1)
},
// GpbHi.
{
REG(kX86RegTypeGpbHi, 0, 1),
REG(kX86RegTypeGpbHi, 1, 1),
REG(kX86RegTypeGpbHi, 2, 1),
REG(kX86RegTypeGpbHi, 3, 1)
},
// Gpw.
{
REG(kX86RegTypeGpw, 0 , 2),
REG(kX86RegTypeGpw, 1 , 2),
REG(kX86RegTypeGpw, 2 , 2),
REG(kX86RegTypeGpw, 3 , 2),
REG(kX86RegTypeGpw, 4 , 2),
REG(kX86RegTypeGpw, 5 , 2),
REG(kX86RegTypeGpw, 6 , 2),
REG(kX86RegTypeGpw, 7 , 2),
REG(kX86RegTypeGpw, 8 , 2),
REG(kX86RegTypeGpw, 9 , 2),
REG(kX86RegTypeGpw, 10, 2),
REG(kX86RegTypeGpw, 11, 2),
REG(kX86RegTypeGpw, 12, 2),
REG(kX86RegTypeGpw, 13, 2),
REG(kX86RegTypeGpw, 14, 2),
REG(kX86RegTypeGpw, 15, 2)
},
// Xmm.
{
REG(kX86RegTypeXmm, 0 , 16),
REG(kX86RegTypeXmm, 1 , 16),
REG(kX86RegTypeXmm, 2 , 16),
REG(kX86RegTypeXmm, 3 , 16),
REG(kX86RegTypeXmm, 4 , 16),
REG(kX86RegTypeXmm, 5 , 16),
REG(kX86RegTypeXmm, 6 , 16),
REG(kX86RegTypeXmm, 7 , 16),
REG(kX86RegTypeXmm, 8 , 16),
REG(kX86RegTypeXmm, 9 , 16),
REG(kX86RegTypeXmm, 10, 16),
REG(kX86RegTypeXmm, 11, 16),
REG(kX86RegTypeXmm, 12, 16),
REG(kX86RegTypeXmm, 13, 16),
REG(kX86RegTypeXmm, 14, 16),
REG(kX86RegTypeXmm, 15, 16),
REG(kX86RegTypeXmm, 16, 16),
REG(kX86RegTypeXmm, 17, 16),
REG(kX86RegTypeXmm, 18, 16),
REG(kX86RegTypeXmm, 19, 16),
REG(kX86RegTypeXmm, 20, 16),
REG(kX86RegTypeXmm, 21, 16),
REG(kX86RegTypeXmm, 22, 16),
REG(kX86RegTypeXmm, 23, 16),
REG(kX86RegTypeXmm, 24, 16),
REG(kX86RegTypeXmm, 25, 16),
REG(kX86RegTypeXmm, 26, 16),
REG(kX86RegTypeXmm, 27, 16),
REG(kX86RegTypeXmm, 28, 16),
REG(kX86RegTypeXmm, 29, 16),
REG(kX86RegTypeXmm, 30, 16),
REG(kX86RegTypeXmm, 31, 16)
},
// Ymm.
{
REG(kX86RegTypeYmm, 0 , 32),
REG(kX86RegTypeYmm, 1 , 32),
REG(kX86RegTypeYmm, 2 , 32),
REG(kX86RegTypeYmm, 3 , 32),
REG(kX86RegTypeYmm, 4 , 32),
REG(kX86RegTypeYmm, 5 , 32),
REG(kX86RegTypeYmm, 6 , 32),
REG(kX86RegTypeYmm, 7 , 32),
REG(kX86RegTypeYmm, 8 , 32),
REG(kX86RegTypeYmm, 9 , 32),
REG(kX86RegTypeYmm, 10, 32),
REG(kX86RegTypeYmm, 11, 32),
REG(kX86RegTypeYmm, 12, 32),
REG(kX86RegTypeYmm, 13, 32),
REG(kX86RegTypeYmm, 14, 32),
REG(kX86RegTypeYmm, 15, 32),
REG(kX86RegTypeYmm, 16, 32),
REG(kX86RegTypeYmm, 17, 32),
REG(kX86RegTypeYmm, 18, 32),
REG(kX86RegTypeYmm, 19, 32),
REG(kX86RegTypeYmm, 20, 32),
REG(kX86RegTypeYmm, 21, 32),
REG(kX86RegTypeYmm, 22, 32),
REG(kX86RegTypeYmm, 23, 32),
REG(kX86RegTypeYmm, 24, 32),
REG(kX86RegTypeYmm, 25, 32),
REG(kX86RegTypeYmm, 26, 32),
REG(kX86RegTypeYmm, 27, 32),
REG(kX86RegTypeYmm, 28, 32),
REG(kX86RegTypeYmm, 29, 32),
REG(kX86RegTypeYmm, 30, 32),
REG(kX86RegTypeYmm, 31, 32)
},
// Zmm.
{
REG(kX86RegTypeZmm, 0 , 64),
REG(kX86RegTypeZmm, 1 , 64),
REG(kX86RegTypeZmm, 2 , 64),
REG(kX86RegTypeZmm, 3 , 64),
REG(kX86RegTypeZmm, 4 , 64),
REG(kX86RegTypeZmm, 5 , 64),
REG(kX86RegTypeZmm, 6 , 64),
REG(kX86RegTypeZmm, 7 , 64),
REG(kX86RegTypeZmm, 8 , 64),
REG(kX86RegTypeZmm, 9 , 64),
REG(kX86RegTypeZmm, 10, 64),
REG(kX86RegTypeZmm, 11, 64),
REG(kX86RegTypeZmm, 12, 64),
REG(kX86RegTypeZmm, 13, 64),
REG(kX86RegTypeZmm, 14, 64),
REG(kX86RegTypeZmm, 15, 64),
REG(kX86RegTypeZmm, 16, 64),
REG(kX86RegTypeZmm, 17, 64),
REG(kX86RegTypeZmm, 18, 64),
REG(kX86RegTypeZmm, 19, 64),
REG(kX86RegTypeZmm, 20, 64),
REG(kX86RegTypeZmm, 21, 64),
REG(kX86RegTypeZmm, 22, 64),
REG(kX86RegTypeZmm, 23, 64),
REG(kX86RegTypeZmm, 24, 64),
REG(kX86RegTypeZmm, 25, 64),
REG(kX86RegTypeZmm, 26, 64),
REG(kX86RegTypeZmm, 27, 64),
REG(kX86RegTypeZmm, 28, 64),
REG(kX86RegTypeZmm, 29, 64),
REG(kX86RegTypeZmm, 30, 64),
REG(kX86RegTypeZmm, 31, 64)
},
// K.
{
REG(kX86RegTypeK, 0, 8),
REG(kX86RegTypeK, 1, 8),
REG(kX86RegTypeK, 2, 8),
REG(kX86RegTypeK, 3, 8),
REG(kX86RegTypeK, 4, 8),
REG(kX86RegTypeK, 5, 8),
REG(kX86RegTypeK, 6, 8),
REG(kX86RegTypeK, 7, 8)
},
// Fp.
{
REG(kX86RegTypeFp, 0, 10),
REG(kX86RegTypeFp, 1, 10),
REG(kX86RegTypeFp, 2, 10),
REG(kX86RegTypeFp, 3, 10),
REG(kX86RegTypeFp, 4, 10),
REG(kX86RegTypeFp, 5, 10),
REG(kX86RegTypeFp, 6, 10),
REG(kX86RegTypeFp, 7, 10)
},
// Mm.
{
REG(kX86RegTypeMm, 0, 8),
REG(kX86RegTypeMm, 1, 8),
REG(kX86RegTypeMm, 2, 8),
REG(kX86RegTypeMm, 3, 8),
REG(kX86RegTypeMm, 4, 8),
REG(kX86RegTypeMm, 5, 8),
REG(kX86RegTypeMm, 6, 8),
REG(kX86RegTypeMm, 7, 8)
},
// Segments.
{ {
REG(kX86RegTypeSeg, 0, 2), // Default. REG(kX86RegTypeSeg, 0, 2), // Default.
REG(kX86RegTypeSeg, 1, 2), // ES. REG(kX86RegTypeSeg, 1, 2), // ES.
@@ -268,12 +65,14 @@ const X86RegData x86RegData = {
REG(kX86RegTypeSeg, 6, 2) // GS. REG(kX86RegTypeSeg, 6, 2) // GS.
}, },
// NoGp. REG(kInvalidReg, kInvalidReg, 0), // NoGp.
REG(kInvalidReg, kInvalidReg, 0), REG(kX86RegTypeRip, 0, 0), // RIP.
// RIP.
REG(kX86RegTypeRip, 0, 0),
}; };
#undef REG_LIST_32
#undef REG_LIST_16
#undef REG_LIST_08
#undef REG_LIST_04
#undef REG #undef REG
} // asmjit namespace } // asmjit namespace

5
src/test/asmjit_bench_x86.cpp
View File

@@ -4,14 +4,11 @@
// [License] // [License]
// Zlib - See LICENSE.md file in the package. // Zlib - See LICENSE.md file in the package.
// [Dependencies - AsmJit] // [Dependencies]
#include "../asmjit/asmjit.h" #include "../asmjit/asmjit.h"
// [Dependencies - Test]
#include "./asmjit_test_opcode.h" #include "./asmjit_test_opcode.h"
#include "./genblend.h" #include "./genblend.h"
// [Dependencies - C]
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

5
src/test/asmjit_test_opcode.cpp
View File

@@ -8,13 +8,10 @@
// disassembled in your IDE or by your favourite disassembler. Instructions // disassembled in your IDE or by your favourite disassembler. Instructions
// are grouped by category and then sorted alphabetically. // are grouped by category and then sorted alphabetically.
// [Dependencies - AsmJit] // [Dependencies]
#include "../asmjit/asmjit.h" #include "../asmjit/asmjit.h"
// [Dependencies - Test]
#include "./asmjit_test_opcode.h" #include "./asmjit_test_opcode.h"
// [Dependencies - C]
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

2
src/test/asmjit_test_unit.cpp
View File

@@ -4,7 +4,7 @@
// [License] // [License]
// Zlib - See LICENSE.md file in the package. // Zlib - See LICENSE.md file in the package.
// [Dependencies - AsmJit] // [Dependencies]
#include "../asmjit/asmjit.h" #include "../asmjit/asmjit.h"
// ============================================================================ // ============================================================================

5
src/test/asmjit_test_x86.cpp
View File

@@ -4,13 +4,10 @@
// [License] // [License]
// Zlib - See LICENSE.md file in the package. // Zlib - See LICENSE.md file in the package.
// [Dependencies - AsmJit] // [Dependencies]
#include "../asmjit/asmjit.h" #include "../asmjit/asmjit.h"
// [Dependencies - Test]
#include "./genblend.h" #include "./genblend.h"
// [Dependencies - C]
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

2
src/test/broken.cpp
View File

@@ -4,7 +4,7 @@
// [License] // [License]
// Public Domain (Unlicense) // Public Domain (Unlicense)
// [Dependencies - Broken] // [Dependencies]
#include "./broken.h" #include "./broken.h"
// ============================================================================ // ============================================================================

2
src/test/broken.h
View File

@@ -8,7 +8,7 @@
#ifndef BROKEN_INTERNAL_H #ifndef BROKEN_INTERNAL_H
#define BROKEN_INTERNAL_H #define BROKEN_INTERNAL_H
// [Dependencies - C] // [Dependencies]
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

10
tools/src-gendefs.js
View File

@@ -451,9 +451,7 @@ var main = function(files) {
}); });
}; };
main([ main([{
{ name: "../src/asmjit/x86/x86inst.cpp",
name: "../src/asmjit/x86/x86inst.cpp", arch: "x86"
arch: "x86" }]);
}
]);