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.
```
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.
* `kLoggerOptionHexImmediate` - Format immediate values to base16 (hex) form.
* `kLoggerOptionHexDisplacement` - Format memory displacements to base16 (hex) form.
* `Logger::kOptionBinaryForm` - Log also binary sequence for each instruction generated.
* `Logger::kOptionHexImmediate` - Log immediate values as hexadecimal.
* `Logger::kOptionHexDisplacement` - Log memory displacements as hexadecimal.
TODO: Liveness analysis and instruction scheduling options.

2
src/asmjit/apibegin.h
View File

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

2
src/asmjit/arm.h
View File

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

8
src/asmjit/asmjit.h
View File

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

2
src/asmjit/base.h
View File

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

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

@@ -7,12 +7,10 @@
// [Export]
#define ASMJIT_EXPORTS
// [Dependencies - AsmJit]
// [Dependencies]
#include "../base/assembler.h"
#include "../base/utils.h"
#include "../base/vmem.h"
// [Dependenceis - C]
#include <stdarg.h>
// [Api-Begin]
@@ -162,7 +160,7 @@ Error Assembler::setLastError(Error error, const char* message) noexcept {
if (message == nullptr)
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;
ASMJIT_TLOG("[ERROR (Assembler)] %s (0x%0.8u) %s\n", message,
static_cast<unsigned int>(error),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_RUNTIME_H
#define _ASMJIT_BASE_RUNTIME_H
// [Dependencies - AsmJit]
// [Dependencies]
#include "../base/cpuinfo.h"
#include "../base/vmem.h"
@@ -21,8 +21,8 @@ namespace asmjit {
// [Forward Declarations]
// ============================================================================
struct Assembler;
struct CpuInfo;
class Assembler;
class CpuInfo;
//! \addtogroup asmjit_base
//! \{
@@ -32,7 +32,8 @@ struct CpuInfo;
// ============================================================================
//! Base runtime.
struct ASMJIT_VIRTAPI Runtime {
class ASMJIT_VIRTAPI Runtime {
public:
ASMJIT_NO_COPY(Runtime)
// --------------------------------------------------------------------------
@@ -132,7 +133,8 @@ struct ASMJIT_VIRTAPI Runtime {
// ============================================================================
//! Base runtime for JIT code generation.
struct ASMJIT_VIRTAPI HostRuntime : public Runtime {
class ASMJIT_VIRTAPI HostRuntime : public Runtime {
public:
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
//! is known.
struct ASMJIT_VIRTAPI StaticRuntime : public HostRuntime {
class ASMJIT_VIRTAPI StaticRuntime : public HostRuntime {
public:
ASMJIT_NO_COPY(StaticRuntime)
// --------------------------------------------------------------------------
@@ -212,7 +215,8 @@ struct ASMJIT_VIRTAPI StaticRuntime : public HostRuntime {
// ============================================================================
//! JIT runtime.
struct ASMJIT_VIRTAPI JitRuntime : public HostRuntime {
class ASMJIT_VIRTAPI JitRuntime : public HostRuntime {
public:
ASMJIT_NO_COPY(JitRuntime)
// --------------------------------------------------------------------------

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

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

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

@@ -8,7 +8,7 @@
#ifndef _ASMJIT_BASE_UTILS_H
#define _ASMJIT_BASE_UTILS_H
// [Dependencies - AsmJit]
// [Dependencies]
#include "../base/globals.h"
#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
#define _ASMJIT_BASE_VECTYPES_H
// [Dependencies - AsmJit]
// [Dependencies]
#include "../base/globals.h"
// [Api-Begin]

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

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

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

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

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

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

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

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

7
src/asmjit/host.h
View File

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

2
src/asmjit/x86.h
View File

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

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

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

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

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

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

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

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

@@ -11,7 +11,7 @@
#include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit]
// [Dependencies]
#include "../base/compiler.h"
#include "../base/vectypes.h"
#include "../x86/x86assembler.h"
@@ -26,8 +26,8 @@ namespace asmjit {
// [Forward Declarations]
// ============================================================================
struct X86CallNode;
struct X86FuncNode;
class X86CallNode;
class X86FuncNode;
//! \addtogroup asmjit_x86
//! \{
@@ -64,7 +64,8 @@ ASMJIT_VARAPI const uint8_t _x64VarMapping[kX86VarTypeCount];
// ============================================================================
//! X86/X64 function node.
struct X86FuncNode : public HLFunc {
class X86FuncNode : public HLFunc {
public:
ASMJIT_NO_COPY(X86FuncNode)
// --------------------------------------------------------------------------
@@ -194,7 +195,8 @@ struct X86FuncNode : public HLFunc {
// ============================================================================
//! X86/X64 function-call node.
struct X86CallNode : public HLCall {
class X86CallNode : public HLCall {
public:
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
//! being emitted are correct and encodable, otherwise the Assembler will
//! 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)
// --------------------------------------------------------------------------

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

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

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

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

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

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

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

@@ -11,7 +11,7 @@
#include "../build.h"
#if !defined(ASMJIT_DISABLE_COMPILER)
// [Dependencies - AsmJit]
// [Dependencies]
#include "../base/compilerfunc.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"
#if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)
// [Dependencies - AsmJit]
// [Dependencies]
#include "../x86/x86operand.h"
// [Api-Begin]

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

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

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

@@ -12,7 +12,7 @@
#include "../build.h"
#if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)
// [Dependencies - AsmJit]
// [Dependencies]
#include "../x86/x86operand.h"
// [Api-Begin]
@@ -20,244 +20,41 @@
namespace asmjit {
#define REG(_Type_, _Index_, _Size_) {{{ \
Operand::kTypeReg, _Size_, { ((_Type_) << 8) + _Index_ }, kInvalidValue, {{ kInvalidVar, 0 }} \
#define REG(type, index, size) {{{ \
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 = {
// Gpd.
{
REG(kX86RegTypeGpd, 0 , 4),
REG(kX86RegTypeGpd, 1 , 4),
REG(kX86RegTypeGpd, 2 , 4),
REG(kX86RegTypeGpd, 3 , 4),
REG(kX86RegTypeGpd, 4 , 4),
REG(kX86RegTypeGpd, 5 , 4),
REG(kX86RegTypeGpd, 6 , 4),
REG(kX86RegTypeGpd, 7 , 4),
REG(kX86RegTypeGpd, 8 , 4),
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)
},
{ REG_LIST_16(kX86RegTypeGpd , 0, 4) },
{ REG_LIST_16(kX86RegTypeGpq , 0, 8) },
{ REG_LIST_16(kX86RegTypeGpbLo, 0, 1) },
{ REG_LIST_04(kX86RegTypeGpbHi, 0, 1) },
{ REG_LIST_16(kX86RegTypeGpw , 0, 2) },
{ REG_LIST_32(kX86RegTypeXmm , 0, 16) },
{ REG_LIST_32(kX86RegTypeYmm , 0, 32) },
{ REG_LIST_32(kX86RegTypeZmm , 0, 64) },
{ REG_LIST_08(kX86RegTypeK , 0, 8) },
{ REG_LIST_08(kX86RegTypeFp , 0, 10) },
{ REG_LIST_08(kX86RegTypeMm , 0, 8) },
// 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, 1, 2), // ES.
@@ -268,12 +65,14 @@ const X86RegData x86RegData = {
REG(kX86RegTypeSeg, 6, 2) // GS.
},
// NoGp.
REG(kInvalidReg, kInvalidReg, 0),
// RIP.
REG(kX86RegTypeRip, 0, 0),
REG(kInvalidReg, kInvalidReg, 0), // NoGp.
REG(kX86RegTypeRip, 0, 0), // RIP.
};
#undef REG_LIST_32
#undef REG_LIST_16
#undef REG_LIST_08
#undef REG_LIST_04
#undef REG
} // asmjit namespace

5
src/test/asmjit_bench_x86.cpp
View File

@@ -4,14 +4,11 @@
// [License]
// Zlib - See LICENSE.md file in the package.
// [Dependencies - AsmJit]
// [Dependencies]
#include "../asmjit/asmjit.h"
// [Dependencies - Test]
#include "./asmjit_test_opcode.h"
#include "./genblend.h"
// [Dependencies - C]
#include <stdio.h>
#include <stdlib.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
// are grouped by category and then sorted alphabetically.
// [Dependencies - AsmJit]
// [Dependencies]
#include "../asmjit/asmjit.h"
// [Dependencies - Test]
#include "./asmjit_test_opcode.h"
// [Dependencies - C]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

2
src/test/asmjit_test_unit.cpp
View File

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

5
src/test/asmjit_test_x86.cpp
View File

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

2
src/test/broken.cpp
View File

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

2
src/test/broken.h
View File

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

10
tools/src-gendefs.js
View File

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