mirror of
https://github.com/asmjit/asmjit.git
synced 2025-12-17 12:34:35 +03:00
f77f792cc4
X86Compiler - Always create SArg for every stack-based function argument X86Compiler - Possible to allocate a register that has to be used to convert variable to function argument. X86Compiler - ContextID generation moved to context_p.h. X86Compiler - Support for one variable being used by multiple function-call arguments. X86Defs - Removed support for 'long double' (buggy, never used). X86Func - Register arguments have to be converted from Fp32/Fp64 to XmmSs/XmmSd, respectively.
921 lines
34 KiB
Plaintext
921 lines
34 KiB
Plaintext
@library asmjit
|
|
@
|
|
@define NULL (0)
|
|
@
|
|
@define asmjit::kInvalidValue (0xFFFFFFFF)
|
|
@
|
|
@define asmjit::kOperandTypeNone (0x0)
|
|
@define asmjit::kOperandTypeReg (0x1)
|
|
@define asmjit::kOperandTypeVar (0x2)
|
|
@define asmjit::kOperandTypeMem (0x3)
|
|
@define asmjit::kOperandTypeImm (0x4)
|
|
@define asmjit::kOperandTypeLabel (0x5)
|
|
@
|
|
@define asmjit::kMemTypeBaseIndex (0x0)
|
|
@define asmjit::kMemTypeStackIndex (0x1)
|
|
@define asmjit::kMemTypeLabel (0x2)
|
|
@define asmjit::kMemTypeAbsolute (0x3)
|
|
@
|
|
@define asmjit::kVarAttrInReg (0x00000001)
|
|
@define asmjit::kVarAttrOutReg (0x00000002)
|
|
@define asmjit::kVarAttrInOutReg (0x00000003)
|
|
@define asmjit::kVarAttrInMem (0x00000004)
|
|
@define asmjit::kVarAttrOutMem (0x00000008)
|
|
@define asmjit::kVarAttrInOutMem (0x0000000C)
|
|
@define asmjit::kVarAttrInDecide (0x00000010)
|
|
@define asmjit::kVarAttrOutDecide (0x00000020)
|
|
@define asmjit::kVarAttrInOutDecide (0x00000030)
|
|
@define asmjit::kVarAttrInConv (0x00000040)
|
|
@define asmjit::kVarAttrOutConv (0x00000080)
|
|
@define asmjit::kVarAttrInOutConv (0x000000C0)
|
|
@define asmjit::kVarAttrInCall (0x00000100)
|
|
@define asmjit::kVarAttrInArg (0x00000200)
|
|
@define asmjit::kVarAttrOutRet (0x00000400)
|
|
@define asmjit::kVarAttrUnuse (0x00000800)
|
|
@
|
|
@define asmjit::kVarTypeInt8 (0x0)
|
|
@define asmjit::kVarTypeUInt8 (0x1)
|
|
@define asmjit::kVarTypeInt16 (0x2)
|
|
@define asmjit::kVarTypeUInt16 (0x3)
|
|
@define asmjit::kVarTypeInt32 (0x4)
|
|
@define asmjit::kVarTypeUInt32 (0x5)
|
|
@define asmjit::kVarTypeInt64 (0x6)
|
|
@define asmjit::kVarTypeUInt64 (0x7)
|
|
@define asmjit::kVarTypeFp32 (0x8)
|
|
@define asmjit::kVarTypeFp64 (0x9)
|
|
@define asmjit::kVarTypeFpEx (0xA)
|
|
@define asmjit::kVarTypeInvalid (0xFF)
|
|
@
|
|
@define asmjit::x86x64::kVarTypeMm (0xB)
|
|
@define asmjit::x86x64::kVarTypeXmm (0xC)
|
|
@define asmjit::x86x64::kVarTypeXmmSs (0xD)
|
|
@define asmjit::x86x64::kVarTypeXmmPs (0xE)
|
|
@define asmjit::x86x64::kVarTypeXmmSd (0xF)
|
|
@define asmjit::x86x64::kVarTypeXmmPd (0x10)
|
|
@
|
|
@define asmjit::kVarStateUnused (0x0)
|
|
@define asmjit::kVarStateReg (0x1)
|
|
@define asmjit::kVarStateMem (0x2)
|
|
@
|
|
@define asmjit::kNodeTypeNone (0x0)
|
|
@define asmjit::kNodeTypeAlign (0x1)
|
|
@define asmjit::kNodeTypeEmbed (0x2)
|
|
@define asmjit::kNodeTypeComment (0x3)
|
|
@define asmjit::kNodeTypeHint (0x4)
|
|
@define asmjit::kNodeTypeTarget (0x5)
|
|
@define asmjit::kNodeTypeInst (0x6)
|
|
@define asmjit::kNodeTypeFunc (0x7)
|
|
@define asmjit::kNodeTypeEnd (0x8)
|
|
@define asmjit::kNodeTypeRet (0x9)
|
|
@define asmjit::kNodeTypeCall (0xA)
|
|
@define asmjit::kNodeTypeSArg (0xB)
|
|
@
|
|
@define asmjit::kNodeFlagIsTranslated (0x0001)
|
|
@define asmjit::kNodeFlagIsJmp (0x0002)
|
|
@define asmjit::kNodeFlagIsJcc (0x0004)
|
|
@define asmjit::kNodeFlagIsTaken (0x0008)
|
|
@define asmjit::kNodeFlagIsRet (0x0010)
|
|
@define asmjit::kNodeFlagIsSpecial (0x0020)
|
|
@define asmjit::kNodeFlagIsFp (0x0040)
|
|
|
|
[Visualizer]
|
|
|
|
; =============================================================================
|
|
; [asmjit::base]
|
|
; =============================================================================
|
|
|
|
asmjit::PodVector<*> {
|
|
preview(
|
|
#(
|
|
"[", $e._length, "]",
|
|
"(",
|
|
#array(
|
|
expr: ((($T1*)($e._d + 1))[$i]),
|
|
size: $e._d->length
|
|
),
|
|
")"
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#array(
|
|
expr: ((($T1*)($e._d + 1))[$i]),
|
|
size: $e._d->length
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
; =============================================================================
|
|
; [asmjit::x86x64 - Operand]
|
|
; =============================================================================
|
|
|
|
asmjit::Operand {
|
|
preview(
|
|
#(
|
|
#if ($e._base.op == asmjit::kOperandTypeReg) ([(*(asmjit::BaseReg *) &$e)])
|
|
#elif ($e._base.op == asmjit::kOperandTypeVar) ([(*(asmjit::BaseVar *) &$e)])
|
|
#elif ($e._base.op == asmjit::kOperandTypeMem) ([(*(asmjit::BaseMem *) &$e)])
|
|
#elif ($e._base.op == asmjit::kOperandTypeImm) ([(*(asmjit::Imm *) &$e)])
|
|
#elif ($e._base.op == asmjit::kOperandTypeLabel) ([(*(asmjit::Label *) &$e)])
|
|
#else ("noOperand")
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
#(base: [$e._base]),
|
|
#(reg: [(*(asmjit::BaseReg*) &$e)]),
|
|
#(var: [(*(asmjit::BaseVar*) &$e)]),
|
|
#(mem: [(*(asmjit::BaseMem*) &$e)]),
|
|
#(imm: [(*(asmjit::Imm*) &$e)]),
|
|
#(label: [(*(asmjit::Label*) &$e)])
|
|
)
|
|
)
|
|
}
|
|
|
|
asmjit::BaseReg|asmjit::x86x64::X86Reg|asmjit::x86x64::GpReg|asmjit::x86x64::FpReg|asmjit::x86x64::MmReg|asmjit::x86x64::XmmReg|asmjit::x86x64::SegReg {
|
|
preview(
|
|
#(
|
|
#if ($e._reg.code == 0x0100) ("al")
|
|
#elif ($e._reg.code == 0x0101) ("cl")
|
|
#elif ($e._reg.code == 0x0102) ("dl")
|
|
#elif ($e._reg.code == 0x0103) ("bl")
|
|
#elif ($e._reg.code == 0x0104) ("spl")
|
|
#elif ($e._reg.code == 0x0105) ("bpl")
|
|
#elif ($e._reg.code == 0x0106) ("sil")
|
|
#elif ($e._reg.code == 0x0107) ("dil")
|
|
#elif ($e._reg.code == 0x0108) ("r8b")
|
|
#elif ($e._reg.code == 0x0109) ("r9b")
|
|
#elif ($e._reg.code == 0x010A) ("r10b")
|
|
#elif ($e._reg.code == 0x010B) ("r11b")
|
|
#elif ($e._reg.code == 0x010C) ("r12b")
|
|
#elif ($e._reg.code == 0x010D) ("r13b")
|
|
#elif ($e._reg.code == 0x010E) ("r14b")
|
|
#elif ($e._reg.code == 0x010F) ("r15b")
|
|
|
|
#elif ($e._reg.code == 0x0200) ("ah")
|
|
#elif ($e._reg.code == 0x0201) ("ch")
|
|
#elif ($e._reg.code == 0x0202) ("dh")
|
|
#elif ($e._reg.code == 0x0203) ("bh")
|
|
|
|
#elif ($e._reg.code == 0x1000) ("ax")
|
|
#elif ($e._reg.code == 0x1001) ("cx")
|
|
#elif ($e._reg.code == 0x1002) ("dx")
|
|
#elif ($e._reg.code == 0x1003) ("bx")
|
|
#elif ($e._reg.code == 0x1004) ("sp")
|
|
#elif ($e._reg.code == 0x1005) ("bp")
|
|
#elif ($e._reg.code == 0x1006) ("si")
|
|
#elif ($e._reg.code == 0x1007) ("di")
|
|
#elif ($e._reg.code == 0x1008) ("r8w")
|
|
#elif ($e._reg.code == 0x1009) ("r9w")
|
|
#elif ($e._reg.code == 0x100A) ("r10w")
|
|
#elif ($e._reg.code == 0x100B) ("r11w")
|
|
#elif ($e._reg.code == 0x100C) ("r12w")
|
|
#elif ($e._reg.code == 0x100D) ("r13w")
|
|
#elif ($e._reg.code == 0x100E) ("r14w")
|
|
#elif ($e._reg.code == 0x100F) ("r15w")
|
|
|
|
#elif ($e._reg.code == 0x2000) ("eax")
|
|
#elif ($e._reg.code == 0x2001) ("ecx")
|
|
#elif ($e._reg.code == 0x2002) ("edx")
|
|
#elif ($e._reg.code == 0x2003) ("ebx")
|
|
#elif ($e._reg.code == 0x2004) ("esp")
|
|
#elif ($e._reg.code == 0x2005) ("ebp")
|
|
#elif ($e._reg.code == 0x2006) ("esi")
|
|
#elif ($e._reg.code == 0x2007) ("edi")
|
|
#elif ($e._reg.code == 0x2008) ("r8d")
|
|
#elif ($e._reg.code == 0x2009) ("r9d")
|
|
#elif ($e._reg.code == 0x200A) ("r10d")
|
|
#elif ($e._reg.code == 0x200B) ("r11d")
|
|
#elif ($e._reg.code == 0x200C) ("r12d")
|
|
#elif ($e._reg.code == 0x200D) ("r13d")
|
|
#elif ($e._reg.code == 0x200E) ("r14d")
|
|
#elif ($e._reg.code == 0x200F) ("r15d")
|
|
|
|
#elif ($e._reg.code == 0x3000) ("rax")
|
|
#elif ($e._reg.code == 0x3001) ("rcx")
|
|
#elif ($e._reg.code == 0x3002) ("rdx")
|
|
#elif ($e._reg.code == 0x3003) ("rbx")
|
|
#elif ($e._reg.code == 0x3004) ("rsp")
|
|
#elif ($e._reg.code == 0x3005) ("rbp")
|
|
#elif ($e._reg.code == 0x3006) ("rsi")
|
|
#elif ($e._reg.code == 0x3007) ("rdi")
|
|
#elif ($e._reg.code == 0x3008) ("r8")
|
|
#elif ($e._reg.code == 0x3009) ("r9")
|
|
#elif ($e._reg.code == 0x300A) ("r10")
|
|
#elif ($e._reg.code == 0x300B) ("r11")
|
|
#elif ($e._reg.code == 0x300C) ("r12")
|
|
#elif ($e._reg.code == 0x300D) ("r13")
|
|
#elif ($e._reg.code == 0x300E) ("r14")
|
|
#elif ($e._reg.code == 0x300F) ("r15")
|
|
|
|
#elif ($e._reg.code == 0x5000) ("fp0")
|
|
#elif ($e._reg.code == 0x5001) ("fp1")
|
|
#elif ($e._reg.code == 0x5002) ("fp2")
|
|
#elif ($e._reg.code == 0x5003) ("fp3")
|
|
#elif ($e._reg.code == 0x5004) ("fp4")
|
|
#elif ($e._reg.code == 0x5005) ("fp5")
|
|
#elif ($e._reg.code == 0x5006) ("fp6")
|
|
#elif ($e._reg.code == 0x5007) ("fp7")
|
|
|
|
#elif ($e._reg.code == 0x6000) ("mm0")
|
|
#elif ($e._reg.code == 0x6001) ("mm1")
|
|
#elif ($e._reg.code == 0x6002) ("mm2")
|
|
#elif ($e._reg.code == 0x6003) ("mm3")
|
|
#elif ($e._reg.code == 0x6004) ("mm4")
|
|
#elif ($e._reg.code == 0x6005) ("mm5")
|
|
#elif ($e._reg.code == 0x6006) ("mm6")
|
|
#elif ($e._reg.code == 0x6007) ("mm7")
|
|
|
|
#elif ($e._reg.code == 0x7000) ("xmm0")
|
|
#elif ($e._reg.code == 0x7001) ("xmm1")
|
|
#elif ($e._reg.code == 0x7002) ("xmm2")
|
|
#elif ($e._reg.code == 0x7003) ("xmm3")
|
|
#elif ($e._reg.code == 0x7004) ("xmm4")
|
|
#elif ($e._reg.code == 0x7005) ("xmm5")
|
|
#elif ($e._reg.code == 0x7006) ("xmm6")
|
|
#elif ($e._reg.code == 0x7007) ("xmm7")
|
|
#elif ($e._reg.code == 0x7008) ("xmm8")
|
|
#elif ($e._reg.code == 0x7009) ("xmm9")
|
|
#elif ($e._reg.code == 0x700A) ("xmm10")
|
|
#elif ($e._reg.code == 0x700B) ("xmm11")
|
|
#elif ($e._reg.code == 0x700C) ("xmm12")
|
|
#elif ($e._reg.code == 0x700D) ("xmm13")
|
|
#elif ($e._reg.code == 0x700E) ("xmm14")
|
|
#elif ($e._reg.code == 0x700F) ("xmm15")
|
|
|
|
#elif ($e._reg.code == 0x8000) ("ymm0")
|
|
#elif ($e._reg.code == 0x8001) ("ymm1")
|
|
#elif ($e._reg.code == 0x8002) ("ymm2")
|
|
#elif ($e._reg.code == 0x8003) ("ymm3")
|
|
#elif ($e._reg.code == 0x8004) ("ymm4")
|
|
#elif ($e._reg.code == 0x8005) ("ymm5")
|
|
#elif ($e._reg.code == 0x8006) ("ymm6")
|
|
#elif ($e._reg.code == 0x8007) ("ymm7")
|
|
#elif ($e._reg.code == 0x8008) ("ymm8")
|
|
#elif ($e._reg.code == 0x8009) ("ymm9")
|
|
#elif ($e._reg.code == 0x800A) ("ymm10")
|
|
#elif ($e._reg.code == 0x800B) ("ymm11")
|
|
#elif ($e._reg.code == 0x800C) ("ymm12")
|
|
#elif ($e._reg.code == 0x800D) ("ymm13")
|
|
#elif ($e._reg.code == 0x800E) ("ymm14")
|
|
#elif ($e._reg.code == 0x800F) ("ymm15")
|
|
|
|
#elif ($e._reg.code == 0xD000) ("es")
|
|
#elif ($e._reg.code == 0xD001) ("cs")
|
|
#elif ($e._reg.code == 0xD002) ("ss")
|
|
#elif ($e._reg.code == 0xD003) ("ds")
|
|
#elif ($e._reg.code == 0xD004) ("fs")
|
|
#elif ($e._reg.code == 0xD005) ("gs")
|
|
|
|
#else ("noReg")
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
#(op: [$e._reg.op, x]),
|
|
#(size: [$e._reg.size, u]),
|
|
#(code: [$e._reg.code, x])
|
|
)
|
|
)
|
|
}
|
|
|
|
asmjit::BaseVar|asmjit::x86x64::X86Var|asmjit::x86x64::GpVar|asmjit::x86x64::FpVar|asmjit::x86x64::MmVar|asmjit::x86x64::XmmVar {
|
|
preview(
|
|
#(
|
|
#if ($e._var.varType == asmjit::kVarTypeInt8) ("gpbLo")
|
|
#elif ($e._var.varType == asmjit::kVarTypeUInt8) ("gpbLo")
|
|
#elif ($e._var.varType == asmjit::kVarTypeInt16) ("gpw")
|
|
#elif ($e._var.varType == asmjit::kVarTypeUInt16) ("gpw")
|
|
#elif ($e._var.varType == asmjit::kVarTypeInt32) ("gpd")
|
|
#elif ($e._var.varType == asmjit::kVarTypeUInt32) ("gpd")
|
|
#elif ($e._var.varType == asmjit::kVarTypeInt64) ("gpq")
|
|
#elif ($e._var.varType == asmjit::kVarTypeUInt64) ("gpq")
|
|
#elif ($e._var.varType == asmjit::kVarTypeFp32) ("fp32")
|
|
#elif ($e._var.varType == asmjit::kVarTypeFp64) ("fp64")
|
|
#elif ($e._var.varType == asmjit::kVarTypeFpEx) ("fpEx")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeMm) ("mm")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeXmm) ("xmm")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeXmmSs) ("xmmSs")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeXmmSd) ("xmmSd")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeXmmPs) ("xmmPs")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeXmmPd) ("xmmPd")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeYmm) ("ymm")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeYmmPs) ("ymmPs")
|
|
#elif ($e._var.varType == asmjit::x86x64::kVarTypeYmmPd) ("ymmPd")
|
|
#else ("noVar"),
|
|
"(",
|
|
"id=",
|
|
#if ($e._var.id != asmjit::kInvalidValue) (
|
|
[$e._var.id, x]
|
|
)
|
|
#else (
|
|
"INVALID"
|
|
),
|
|
")"
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
#(op: [$e._var.op, x]),
|
|
#(size: [$e._var.size, u]),
|
|
#(id: [$e._var.id, x]),
|
|
#(code: [$e._var.code, x]),
|
|
#(varType: [$e._var.varType, x])
|
|
)
|
|
)
|
|
}
|
|
|
|
asmjit::BaseMem|asmjit::x86x64::Mem {
|
|
preview(
|
|
#(
|
|
#if ($e._mem.size == 1) ("byte ptr")
|
|
#elif ($e._mem.size == 2) ("word ptr")
|
|
#elif ($e._mem.size == 4) ("dword ptr")
|
|
#elif ($e._mem.size == 8) ("qword ptr")
|
|
#elif ($e._mem.size == 10) ("tword ptr")
|
|
#elif ($e._mem.size == 16) ("dqword ptr")
|
|
#elif ($e._mem.size == 32) ("qqword ptr")
|
|
#else ("ptr"),
|
|
|
|
#if ($e._mem.segment == 0) (" es:")
|
|
#elif ($e._mem.segment == 1) (" cs:")
|
|
#elif ($e._mem.segment == 2) (" ss:")
|
|
#elif ($e._mem.segment == 3) (" ds:")
|
|
#elif ($e._mem.segment == 4) (" fs:")
|
|
#elif ($e._mem.segment == 5) (" gs:")
|
|
#else (""),
|
|
|
|
"[",
|
|
|
|
#if ($e._mem.id == asmjit::kInvalidValue) (
|
|
#(
|
|
#if ($e._mem.type == asmjit::kMemTypeBaseIndex) (
|
|
#if ((sizeof(uintptr_t) == 4) && ($e._mem.sizePrefix == 1)) (
|
|
#if (($e._mem.base & 0xFF) == 0x0) ("ax")
|
|
#elif (($e._mem.base & 0xFF) == 0x1) ("cx")
|
|
#elif (($e._mem.base & 0xFF) == 0x2) ("dx")
|
|
#elif (($e._mem.base & 0xFF) == 0x3) ("bx")
|
|
#elif (($e._mem.base & 0xFF) == 0x4) ("sp")
|
|
#elif (($e._mem.base & 0xFF) == 0x5) ("bp")
|
|
#elif (($e._mem.base & 0xFF) == 0x6) ("si")
|
|
#elif (($e._mem.base & 0xFF) == 0x7) ("di")
|
|
#elif (($e._mem.base & 0xFF) == 0x8) ("r8w")
|
|
#elif (($e._mem.base & 0xFF) == 0x9) ("r9w")
|
|
#elif (($e._mem.base & 0xFF) == 0xA) ("r10w")
|
|
#elif (($e._mem.base & 0xFF) == 0xB) ("r11w")
|
|
#elif (($e._mem.base & 0xFF) == 0xC) ("r12w")
|
|
#elif (($e._mem.base & 0xFF) == 0xD) ("r13w")
|
|
#elif (($e._mem.base & 0xFF) == 0xE) ("r14w")
|
|
#elif (($e._mem.base & 0xFF) == 0xF) ("r15w")
|
|
#else ("INVALID")
|
|
)
|
|
#elif ((sizeof(uintptr_t) == 4) || ($e._mem.sizePrefix == 1)) (
|
|
#if (($e._mem.base & 0xFF) == 0x0) ("eax")
|
|
#elif (($e._mem.base & 0xFF) == 0x1) ("ecx")
|
|
#elif (($e._mem.base & 0xFF) == 0x2) ("edx")
|
|
#elif (($e._mem.base & 0xFF) == 0x3) ("ebx")
|
|
#elif (($e._mem.base & 0xFF) == 0x4) ("esp")
|
|
#elif (($e._mem.base & 0xFF) == 0x5) ("ebp")
|
|
#elif (($e._mem.base & 0xFF) == 0x6) ("esi")
|
|
#elif (($e._mem.base & 0xFF) == 0x7) ("edi")
|
|
#elif (($e._mem.base & 0xFF) == 0x8) ("r8d")
|
|
#elif (($e._mem.base & 0xFF) == 0x9) ("r9d")
|
|
#elif (($e._mem.base & 0xFF) == 0xA) ("r10d")
|
|
#elif (($e._mem.base & 0xFF) == 0xB) ("r11d")
|
|
#elif (($e._mem.base & 0xFF) == 0xC) ("r12d")
|
|
#elif (($e._mem.base & 0xFF) == 0xD) ("r13d")
|
|
#elif (($e._mem.base & 0xFF) == 0xE) ("r14d")
|
|
#elif (($e._mem.base & 0xFF) == 0xF) ("r15d")
|
|
#else ("INVALID")
|
|
)
|
|
#else (
|
|
#if (($e._mem.base & 0xFF) == 0x0) ("rax")
|
|
#elif (($e._mem.base & 0xFF) == 0x1) ("rcx")
|
|
#elif (($e._mem.base & 0xFF) == 0x2) ("rdx")
|
|
#elif (($e._mem.base & 0xFF) == 0x3) ("rbx")
|
|
#elif (($e._mem.base & 0xFF) == 0x4) ("rsp")
|
|
#elif (($e._mem.base & 0xFF) == 0x5) ("rbp")
|
|
#elif (($e._mem.base & 0xFF) == 0x6) ("rsi")
|
|
#elif (($e._mem.base & 0xFF) == 0x7) ("rdi")
|
|
#elif (($e._mem.base & 0xFF) == 0x8) ("r8")
|
|
#elif (($e._mem.base & 0xFF) == 0x9) ("r9")
|
|
#elif (($e._mem.base & 0xFF) == 0xA) ("r10")
|
|
#elif (($e._mem.base & 0xFF) == 0xB) ("r11")
|
|
#elif (($e._mem.base & 0xFF) == 0xC) ("r12")
|
|
#elif (($e._mem.base & 0xFF) == 0xD) ("r13")
|
|
#elif (($e._mem.base & 0xFF) == 0xE) ("r14")
|
|
#elif (($e._mem.base & 0xFF) == 0xF) ("r15")
|
|
#else ("INVALID")
|
|
)
|
|
)
|
|
#elif ($e._mem.type == asmjit::kMemTypeLabel) (
|
|
#(
|
|
"L.",
|
|
#if ($e._mem.base != asmjit::kInvalidValue) (
|
|
[$e._mem.base & 0x3FFFFFFF, x]
|
|
)
|
|
#else (
|
|
"INVALID"
|
|
)
|
|
)
|
|
)
|
|
#else (
|
|
[$e._mem.target]
|
|
)
|
|
)
|
|
)
|
|
#else (
|
|
#("{id=", [$e._mem.id, x], "}")
|
|
),
|
|
|
|
#if ($e._mem.index != asmjit::kInvalidValue) (
|
|
#(
|
|
" + ",
|
|
|
|
#if ((sizeof(uintptr_t) == 4) && ($e._mem.sizePrefix == 1)) (
|
|
#if (($e._mem.index & 0xFF) == 0x0) ("ax")
|
|
#elif (($e._mem.index & 0xFF) == 0x1) ("cx")
|
|
#elif (($e._mem.index & 0xFF) == 0x2) ("dx")
|
|
#elif (($e._mem.index & 0xFF) == 0x3) ("bx")
|
|
#elif (($e._mem.index & 0xFF) == 0x4) ("sp")
|
|
#elif (($e._mem.index & 0xFF) == 0x5) ("bp")
|
|
#elif (($e._mem.index & 0xFF) == 0x6) ("si")
|
|
#elif (($e._mem.index & 0xFF) == 0x7) ("di")
|
|
#elif (($e._mem.index & 0xFF) == 0x8) ("r8w")
|
|
#elif (($e._mem.index & 0xFF) == 0x9) ("r9w")
|
|
#elif (($e._mem.index & 0xFF) == 0xA) ("r10w")
|
|
#elif (($e._mem.index & 0xFF) == 0xB) ("r11w")
|
|
#elif (($e._mem.index & 0xFF) == 0xC) ("r12w")
|
|
#elif (($e._mem.index & 0xFF) == 0xD) ("r13w")
|
|
#elif (($e._mem.index & 0xFF) == 0xE) ("r14w")
|
|
#elif (($e._mem.index & 0xFF) == 0xF) ("r15w")
|
|
#else ("INVALID")
|
|
)
|
|
#elif ((sizeof(uintptr_t) == 4) || ($e._mem.sizePrefix == 1)) (
|
|
#if (($e._mem.index & 0xFF) == 0x0) ("eax")
|
|
#elif (($e._mem.index & 0xFF) == 0x1) ("ecx")
|
|
#elif (($e._mem.index & 0xFF) == 0x2) ("edx")
|
|
#elif (($e._mem.index & 0xFF) == 0x3) ("ebx")
|
|
#elif (($e._mem.index & 0xFF) == 0x4) ("esp")
|
|
#elif (($e._mem.index & 0xFF) == 0x5) ("ebp")
|
|
#elif (($e._mem.index & 0xFF) == 0x6) ("esi")
|
|
#elif (($e._mem.index & 0xFF) == 0x7) ("edi")
|
|
#elif (($e._mem.index & 0xFF) == 0x8) ("r8d")
|
|
#elif (($e._mem.index & 0xFF) == 0x9) ("r9d")
|
|
#elif (($e._mem.index & 0xFF) == 0xA) ("r10d")
|
|
#elif (($e._mem.index & 0xFF) == 0xB) ("r11d")
|
|
#elif (($e._mem.index & 0xFF) == 0xC) ("r12d")
|
|
#elif (($e._mem.index & 0xFF) == 0xD) ("r13d")
|
|
#elif (($e._mem.index & 0xFF) == 0xE) ("r14d")
|
|
#elif (($e._mem.index & 0xFF) == 0xF) ("r15d")
|
|
#else ("INVALID")
|
|
)
|
|
#else (
|
|
#if (($e._mem.index & 0xFF) == 0x0) ("rax")
|
|
#elif (($e._mem.index & 0xFF) == 0x1) ("rcx")
|
|
#elif (($e._mem.index & 0xFF) == 0x2) ("rdx")
|
|
#elif (($e._mem.index & 0xFF) == 0x3) ("rbx")
|
|
#elif (($e._mem.index & 0xFF) == 0x4) ("rsp")
|
|
#elif (($e._mem.index & 0xFF) == 0x5) ("rbp")
|
|
#elif (($e._mem.index & 0xFF) == 0x6) ("rsi")
|
|
#elif (($e._mem.index & 0xFF) == 0x7) ("rdi")
|
|
#elif (($e._mem.index & 0xFF) == 0x8) ("r8")
|
|
#elif (($e._mem.index & 0xFF) == 0x9) ("r9")
|
|
#elif (($e._mem.index & 0xFF) == 0xA) ("r10")
|
|
#elif (($e._mem.index & 0xFF) == 0xB) ("r11")
|
|
#elif (($e._mem.index & 0xFF) == 0xC) ("r12")
|
|
#elif (($e._mem.index & 0xFF) == 0xD) ("r13")
|
|
#elif (($e._mem.index & 0xFF) == 0xE) ("r14")
|
|
#elif (($e._mem.index & 0xFF) == 0xF) ("r15")
|
|
#else ("INVALID")
|
|
),
|
|
|
|
#if ($e._mem.shift == 1) (" * 2")
|
|
#elif ($e._mem.shift == 2) (" * 4")
|
|
#elif ($e._mem.shift == 3) (" * 8")
|
|
#else ("")
|
|
)
|
|
),
|
|
|
|
#if (($e._mem.type != asmjit::kMemTypeAbsolute) && ($e._mem.displacement != 0)) (
|
|
#if ($e._mem.displacement < 0) (
|
|
#(" - ", [-$e._mem.displacement, i])
|
|
)
|
|
#else (
|
|
#(" + ", [$e._mem.displacement, i])
|
|
)
|
|
),
|
|
|
|
"]"
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#(op: [$e._mem.op, x]),
|
|
#(size: [$e._mem.size, u]),
|
|
|
|
#(type: [$e._mem.type, u]),
|
|
#(segment: [$e._mem.segment, u]),
|
|
|
|
#(sizePrefix: [$e._mem.sizePrefix, u]),
|
|
#(shift: [$e._mem.shift, u]),
|
|
|
|
#(id: [$e._mem.id, x]),
|
|
#(base: [$e._mem.base, u]),
|
|
#(index: [$e._mem.index, u]),
|
|
|
|
#(target: [$e._mem.target]),
|
|
#(displacement: [$e._mem.displacement, i])
|
|
)
|
|
)
|
|
}
|
|
|
|
asmjit::Imm {
|
|
preview(
|
|
#(
|
|
"i=", [(int64_t)$e._imm.value, i],
|
|
" ",
|
|
"u=", [(uint64_t)$e._imm.value, u],
|
|
" ",
|
|
"x=", [(uint64_t)$e._imm.value, x]
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#(op: [$e._imm.op, x]),
|
|
#(size: [$e._imm.size, u]),
|
|
|
|
#(value_s: [(int64_t)$e._imm.value, i]),
|
|
#(value_u: [(uint64_t)$e._imm.value, u]),
|
|
#(value_x: [(uint64_t)$e._imm.value, x])
|
|
)
|
|
)
|
|
}
|
|
|
|
asmjit::Label {
|
|
preview(
|
|
#(
|
|
"L_",
|
|
#if ($e._label.id != asmjit::kInvalidValue) (
|
|
[$e._label.id, x]
|
|
)
|
|
#else (
|
|
"INVALID"
|
|
),
|
|
""
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#(op: [$e._label.op, x]),
|
|
#(size: [$e._label.size, u]),
|
|
|
|
#(id: [$e._label.id, x])
|
|
)
|
|
)
|
|
}
|
|
|
|
; =============================================================================
|
|
; [asmjit::x86x64 - RegMask]
|
|
; =============================================================================
|
|
|
|
asmjit::x86x64::RegMask {
|
|
preview(
|
|
#(
|
|
#if (($e._gp | $e._fp | $e._mm | $e._xy) != 0) (
|
|
#(
|
|
#if ($e._gp != 0) (
|
|
#(
|
|
"gp=", [$e._gp, x],
|
|
#if ($e._gp & 0x0001) ("|rax"),
|
|
#if ($e._gp & 0x0002) ("|rcx"),
|
|
#if ($e._gp & 0x0004) ("|rdx"),
|
|
#if ($e._gp & 0x0008) ("|rbx"),
|
|
#if ($e._gp & 0x0010) ("|rsp"),
|
|
#if ($e._gp & 0x0020) ("|rbp"),
|
|
#if ($e._gp & 0x0040) ("|rsi"),
|
|
#if ($e._gp & 0x0080) ("|rdi"),
|
|
#if ($e._gp & 0x0100) ("|r8"),
|
|
#if ($e._gp & 0x0200) ("|r9"),
|
|
#if ($e._gp & 0x0400) ("|r10"),
|
|
#if ($e._gp & 0x0800) ("|r11"),
|
|
#if ($e._gp & 0x1000) ("|r12"),
|
|
#if ($e._gp & 0x2000) ("|r13"),
|
|
#if ($e._gp & 0x4000) ("|r14"),
|
|
#if ($e._gp & 0x8000) ("|r15"),
|
|
#if (($e._fp | $e._mm | $e._xy) != 0) (" ")
|
|
)
|
|
),
|
|
|
|
#if ($e._fp != 0) (
|
|
#(
|
|
"fp=", [$e._fp, x],
|
|
#if ($e._fp & 0x0001) ("|fp0"),
|
|
#if ($e._fp & 0x0002) ("|fp1"),
|
|
#if ($e._fp & 0x0004) ("|fp2"),
|
|
#if ($e._fp & 0x0008) ("|fp3"),
|
|
#if ($e._fp & 0x0010) ("|fp4"),
|
|
#if ($e._fp & 0x0020) ("|fp5"),
|
|
#if ($e._fp & 0x0040) ("|fp6"),
|
|
#if ($e._fp & 0x0080) ("|fp7"),
|
|
#if (($e._mm | $e._xy) != 0) (" ")
|
|
)
|
|
),
|
|
|
|
#if ($e._mm != 0) (
|
|
#(
|
|
"mm=", [$e._mm, x],
|
|
#if ($e._mm & 0x0001) ("|mm0"),
|
|
#if ($e._mm & 0x0002) ("|mm1"),
|
|
#if ($e._mm & 0x0004) ("|mm2"),
|
|
#if ($e._mm & 0x0008) ("|mm3"),
|
|
#if ($e._mm & 0x0010) ("|mm4"),
|
|
#if ($e._mm & 0x0020) ("|mm5"),
|
|
#if ($e._mm & 0x0040) ("|mm6"),
|
|
#if ($e._mm & 0x0080) ("|mm7"),
|
|
#if ($e._xy != 0) (" ")
|
|
)
|
|
),
|
|
|
|
#if ($e._xy != 0) (
|
|
#(
|
|
"xy=", [$e._xy, x],
|
|
#if ($e._xy & 0x0001) ("|xy0"),
|
|
#if ($e._xy & 0x0002) ("|xy1"),
|
|
#if ($e._xy & 0x0004) ("|xy2"),
|
|
#if ($e._xy & 0x0008) ("|xy3"),
|
|
#if ($e._xy & 0x0010) ("|xy4"),
|
|
#if ($e._xy & 0x0020) ("|xy5"),
|
|
#if ($e._xy & 0x0040) ("|xy6"),
|
|
#if ($e._xy & 0x0080) ("|xy7"),
|
|
#if ($e._xy & 0x0100) ("|xy8"),
|
|
#if ($e._xy & 0x0200) ("|xy9"),
|
|
#if ($e._xy & 0x0400) ("|xy10"),
|
|
#if ($e._xy & 0x0800) ("|xy11"),
|
|
#if ($e._xy & 0x1000) ("|xy12"),
|
|
#if ($e._xy & 0x2000) ("|xy13"),
|
|
#if ($e._xy & 0x4000) ("|xy14"),
|
|
#if ($e._xy & 0x8000) ("|xy15")
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#else (
|
|
"empty"
|
|
)
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#(gp: [$e._gp, x]),
|
|
#(fp: [$e._fp, x]),
|
|
#(mm: [$e._mm, x]),
|
|
#(xy: [$e._xy, x])
|
|
)
|
|
)
|
|
}
|
|
|
|
; =============================================================================
|
|
; [asmjit::x86x64 - Var]
|
|
; =============================================================================
|
|
|
|
asmjit::BaseVarAttr|asmjit::x86x64::VarAttr {
|
|
preview(
|
|
#(
|
|
"VarAttr(",
|
|
#if ($e._vd != NULL) (
|
|
#(
|
|
"id=",
|
|
[$e._vd->_id, x],
|
|
" ",
|
|
|
|
#if (($e._vd->_contextId) != asmjit::kInvalidValue) (
|
|
#("cid=", [($e._vd->_contextId), u], " ")
|
|
),
|
|
|
|
#if (($e._vd->_name) != NULL) (
|
|
#("name=", [($e._vd->_name), s], " ")
|
|
),
|
|
|
|
"state=",
|
|
#if ($e._vd->_state == asmjit::kVarStateUnused) ("unused")
|
|
#elif ($e._vd->_state == asmjit::kVarStateReg) (#("reg|", [$e._vd->_regIndex, u]))
|
|
#elif ($e._vd->_state == asmjit::kVarStateMem) ("mem")
|
|
#else ("INVALID"),
|
|
" ",
|
|
|
|
#if (($e._flags & (asmjit::kVarAttrInReg | asmjit::kVarAttrInMem | asmjit::kVarAttrInDecide | asmjit::kVarAttrInConv | asmjit::kVarAttrInCall | asmjit::kVarAttrInArg)) != 0) (
|
|
#(
|
|
"in[",
|
|
#if (($e._flags & asmjit::kVarAttrInReg) != 0) ("reg "),
|
|
#if (($e._flags & asmjit::kVarAttrInMem) != 0) ("mem "),
|
|
#if (($e._flags & asmjit::kVarAttrInDecide) != 0) ("decide "),
|
|
#if (($e._flags & asmjit::kVarAttrInConv) != 0) ("conv "),
|
|
#if (($e._flags & asmjit::kVarAttrInCall) != 0) ("call "),
|
|
#if (($e._flags & asmjit::kVarAttrInArg) != 0) ("arg "),
|
|
"] "
|
|
)
|
|
),
|
|
#if (($e._flags & (asmjit::kVarAttrOutReg | asmjit::kVarAttrOutMem | asmjit::kVarAttrOutDecide | asmjit::kVarAttrOutConv | asmjit::kVarAttrOutRet)) != 0) (
|
|
#(
|
|
"out[",
|
|
#if (($e._flags & asmjit::kVarAttrOutReg) != 0) ("reg "),
|
|
#if (($e._flags & asmjit::kVarAttrOutMem) != 0) ("mem "),
|
|
#if (($e._flags & asmjit::kVarAttrOutDecide) != 0) ("decide "),
|
|
#if (($e._flags & asmjit::kVarAttrOutConv) != 0) ("conv "),
|
|
#if (($e._flags & asmjit::kVarAttrOutRet) != 0) ("ret "),
|
|
"] "
|
|
)
|
|
),
|
|
#if (($e._flags & asmjit::kVarAttrUnuse) == asmjit::kVarAttrUnuse) ("unuse ")
|
|
)
|
|
)
|
|
#else (
|
|
"INVALID "
|
|
),
|
|
")"
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#(vd: [(asmjit::x86x64::VarData*)$e._vd]),
|
|
#(flags: [$e._flags, x]),
|
|
#(varCount: [$e._varCount, u]),
|
|
#(argCount: [$e._argCount, u]),
|
|
#(inRegIndex: [$e._inRegIndex, u]),
|
|
#(outRegIndex: [$e._outRegIndex, u]),
|
|
#(inRegs: [$e._inRegs, x]),
|
|
#(allocableRegs: [$e._allocableRegs, x])
|
|
)
|
|
)
|
|
}
|
|
|
|
asmjit::BaseVarInst|asmjit::x86x64::VarInst {
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#(inRegs: [$e._inRegs]),
|
|
#(outRegs: [$e._outRegs]),
|
|
#(clobberedRegs: [$e._clobberedRegs]),
|
|
#(start: [$e._start]),
|
|
#(count: [$e._count]),
|
|
|
|
#(vaCount: [$e._vaCount, u]),
|
|
#array(
|
|
expr: $e._list[$i],
|
|
size: $e._vaCount
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
; =============================================================================
|
|
; [asmjit::X86 - Compiler - BaseNode]
|
|
; =============================================================================
|
|
|
|
asmjit::BaseNode|asmjit::AlignNode|asmjit::EmbedNode|asmjit::CommentNode|asmjit::HintNode|asmjit::TargetNode|asmjit::InstNode|asmjit::JumpNode::asmjit::FuncNode|asmjit::EndNode|asmjit::RetNode|asmjit::x86x64::X86X64FuncNode|asmjit::x86x64::X86X64CallNode|asmjit::SArgNode {
|
|
preview(
|
|
#(
|
|
#if ($e._type == asmjit::kNodeTypeAlign) ("AlignNode")
|
|
#elif ($e._type == asmjit::kNodeTypeEmbed) ("EmbedNode")
|
|
#elif ($e._type == asmjit::kNodeTypeComment) ("CommentNode")
|
|
#elif ($e._type == asmjit::kNodeTypeHint) ("HintNode")
|
|
#elif ($e._type == asmjit::kNodeTypeTarget) ("TargetNode")
|
|
#elif ($e._type == asmjit::kNodeTypeInst) ("InstNode")
|
|
#elif ($e._type == asmjit::kNodeTypeFunc) ("FuncNode")
|
|
#elif ($e._type == asmjit::kNodeTypeEnd) ("EndNode")
|
|
#elif ($e._type == asmjit::kNodeTypeRet) ("RetNode")
|
|
#elif ($e._type == asmjit::kNodeTypeCall) ("CallNode")
|
|
#elif ($e._type == asmjit::kNodeTypeSArg) ("SArgNode")
|
|
#else ("BaseNode"),
|
|
|
|
"(",
|
|
#if (($e._liveness) != NULL) ("analyzed "),
|
|
#if (($e._flags & asmjit::kNodeFlagIsTranslated) != 0) ("translated "),
|
|
#if (($e._flags & asmjit::kNodeFlagIsJmp) != 0) ("jmp "),
|
|
#if (($e._flags & asmjit::kNodeFlagIsJcc) != 0) ("jcc "),
|
|
#if (($e._flags & asmjit::kNodeFlagIsTaken) != 0) ("taken "),
|
|
#if (($e._flags & asmjit::kNodeFlagIsRet) != 0) ("ret "),
|
|
")"
|
|
)
|
|
)
|
|
|
|
children(
|
|
#(
|
|
#([...]: [$c,!]),
|
|
|
|
#(prev: [$e._prev]),
|
|
#(next: [$e._next]),
|
|
|
|
#(type: [$e._type]),
|
|
#(flags: [$e._flags]),
|
|
#(flowId: [$e._flowId]),
|
|
#(comment: [$e._comment]),
|
|
|
|
#(varInst: [( (asmjit::x86x64::VarInst*)($e._varInst) )]),
|
|
#(liveness: [( (asmjit::VarBits*)($e._liveness) )]),
|
|
#(state: [( (asmjit::x86x64::VarState*)($e._state) )]),
|
|
|
|
#if ($e._type == asmjit::kNodeTypeAlign) (
|
|
#(
|
|
#(size : [( ((asmjit::AlignNode*)&$e)->_size )])
|
|
)
|
|
)
|
|
#elif (($e._type == asmjit::kNodeTypeEmbed) && (($e._packedData.embed.size) <= (sizeof(uintptr_t)))) (
|
|
#(
|
|
#(size : [( ((asmjit::EmbedNode*)&$e)->_size )]),
|
|
#(data : [( ((asmjit::EmbedNode*)&$e)->_data.buf )])
|
|
)
|
|
)
|
|
#elif (($e._type == asmjit::kNodeTypeEmbed) && (($e._packedData.embed.size) > (sizeof(uintptr_t)))) (
|
|
#(
|
|
#(size : [( ((asmjit::EmbedNode*)&$e)->_size )]),
|
|
#(data : [( ((asmjit::EmbedNode*)&$e)->_data.ptr )])
|
|
)
|
|
)
|
|
#elif ($e._type == asmjit::kNodeTypeHint) (
|
|
#(
|
|
#(var : [( (asmjit::x86x64::VarData*) (((asmjit::HintNode*)&$e)->_var) )]),
|
|
#(hint : [( ((asmjit::HintNode*)&$e)->_hint )]),
|
|
#(value : [( ((asmjit::HintNode*)&$e)->_value )])
|
|
)
|
|
)
|
|
#elif ($e._type == asmjit::kNodeTypeTarget) (
|
|
#(
|
|
#(label : [( ((asmjit::TargetNode*)&$e)->_label )]),
|
|
#(from : [( ((asmjit::TargetNode*)&$e)->_from )]),
|
|
#(numRefs: [( ((asmjit::TargetNode*)&$e)->_numRefs )])
|
|
)
|
|
)
|
|
#elif ($e._type == asmjit::kNodeTypeInst) (
|
|
#(
|
|
#(opCount: [( ((asmjit::x86x64::X86X64InstNode*)&$e)->_opCount )]),
|
|
#array(
|
|
expr: ( ((asmjit::x86x64::X86X64InstNode*)&$e)->_opList[$i] ),
|
|
size: ( ((asmjit::x86x64::X86X64InstNode*)&$e)->_opCount )
|
|
)
|
|
)
|
|
)
|
|
#elif ($e._type == asmjit::kNodeTypeFunc) (
|
|
#(
|
|
#(entryTarget : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_entryTarget )]),
|
|
#(exitTarget : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_exitTarget )]),
|
|
#(decl : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_x86Decl )]),
|
|
#(end : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_end )]),
|
|
#(argList : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_argList )]),
|
|
#(funcHints : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_funcHints )]),
|
|
#(funcFlags : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_funcFlags )]),
|
|
|
|
#(expectedStackAlignment: [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_expectedStackAlignment )]),
|
|
#(requiredStackAlignment: [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_requiredStackAlignment )]),
|
|
|
|
#(redZoneSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_redZoneSize )]),
|
|
#(spillZoneSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_spillZoneSize )]),
|
|
#(argStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_argStackSize )]),
|
|
#(memStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_memStackSize )]),
|
|
#(callStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_callStackSize )]),
|
|
|
|
; X86.
|
|
#(saveRestoreRegs : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_saveRestoreRegs )]),
|
|
|
|
#(alignStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_alignStackSize )]),
|
|
#(alignedMemStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_alignedMemStackSize )]),
|
|
#(pushPopStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_pushPopStackSize )]),
|
|
#(moveStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_moveStackSize )]),
|
|
#(extraStackSize : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_extraStackSize )]),
|
|
|
|
#(stackFrameRegIndex : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_stackFrameRegIndex )]),
|
|
#(stackFrameRegPreserved: [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_isStackFrameRegPreserved )]),
|
|
#(stackFrameCopyGpIndex : [( ((asmjit::x86x64::X86X64FuncNode*)&$e)->_stackFrameCopyGpIndex )])
|
|
)
|
|
)
|
|
)
|
|
)
|
|
}
|