Documentation ¶
Index ¶
- Constants
- Variables
- func FitIn32bit(v int64) bool
- func InstructionName(instruction asm.Instruction) string
- func IsFloatRegister(r asm.Register) bool
- func RegisterName(reg asm.Register) string
- type Assembler
- type AssemblerImpl
- func (a *AssemblerImpl) Assemble() ([]byte, error)
- func (a *AssemblerImpl) CompileConstToMemory(instruction asm.Instruction, value asm.ConstantValue, dstbaseReg asm.Register, ...) asm.Node
- func (a *AssemblerImpl) CompileConstToRegister(instruction asm.Instruction, value asm.ConstantValue, ...) (inst asm.Node)
- func (a *AssemblerImpl) CompileJump(jmpInstruction asm.Instruction) asm.Node
- func (a *AssemblerImpl) CompileJumpToMemory(jmpInstruction asm.Instruction, baseReg asm.Register, offset asm.ConstantValue)
- func (a *AssemblerImpl) CompileJumpToRegister(jmpInstruction asm.Instruction, reg asm.Register)
- func (a *AssemblerImpl) CompileMemoryToConst(instruction asm.Instruction, srcBaseReg asm.Register, ...) asm.Node
- func (a *AssemblerImpl) CompileMemoryToRegister(instruction asm.Instruction, sourceBaseReg asm.Register, ...)
- func (a *AssemblerImpl) CompileMemoryWithIndexToRegister(instruction asm.Instruction, srcBaseReg asm.Register, ...)
- func (a *AssemblerImpl) CompileNoneToMemory(instruction asm.Instruction, baseReg asm.Register, offset asm.ConstantValue)
- func (a *AssemblerImpl) CompileNoneToRegister(instruction asm.Instruction, register asm.Register)
- func (a *AssemblerImpl) CompileReadInstructionAddress(destinationRegister asm.Register, ...)
- func (a *AssemblerImpl) CompileRegisterToConst(instruction asm.Instruction, srcRegister asm.Register, value asm.ConstantValue) asm.Node
- func (a *AssemblerImpl) CompileRegisterToMemory(instruction asm.Instruction, sourceRegister asm.Register, ...)
- func (a *AssemblerImpl) CompileRegisterToMemoryWithIndex(instruction asm.Instruction, srcReg asm.Register, dstBaseReg asm.Register, ...)
- func (a *AssemblerImpl) CompileRegisterToNone(instruction asm.Instruction, register asm.Register)
- func (a *AssemblerImpl) CompileRegisterToRegister(instruction asm.Instruction, from, to asm.Register)
- func (a *AssemblerImpl) CompileRegisterToRegisterWithMode(instruction asm.Instruction, from, to asm.Register, mode Mode)
- func (a *AssemblerImpl) CompileStandAlone(instruction asm.Instruction) asm.Node
- func (a *AssemblerImpl) Encode() (err error)
- func (a *AssemblerImpl) EncodeConstToMemory(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeConstToRegister(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeMemoryToConst(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeMemoryToRegister(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeNode(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeNoneToMemory(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeNoneToRegister(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeRegisterToConst(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeRegisterToMemory(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeRegisterToNone(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeRegisterToRegister(n *NodeImpl) (err error)
- func (a *AssemblerImpl) EncodeRelativeJump(n *NodeImpl) (err error)
- func (a *AssemblerImpl) InitializeNodesForEncoding()
- func (a *AssemblerImpl) ResolveForwardRelativeJumps(target *NodeImpl) (err error)
- func (a *AssemblerImpl) WriteConst(v int64, length byte)
- type Mode
- type NodeFlag
- type NodeImpl
- func (n *NodeImpl) AssignDestinationConstant(value asm.ConstantValue)
- func (n *NodeImpl) AssignJumpTarget(target asm.Node)
- func (n *NodeImpl) AssignSourceConstant(value asm.ConstantValue)
- func (n *NodeImpl) GetMemoryLocation() (p RexPrefix, modRM byte, sbi *byte, displacementWidth byte, err error)
- func (n *NodeImpl) GetRegisterToRegisterModRM(srcOnModRMReg bool) (RexPrefix, modRM byte, err error)
- func (n *NodeImpl) OffsetInBinary() asm.NodeOffsetInBinary
- func (n *NodeImpl) String() (ret string)
- type OperandType
- type OperandTypes
- type RexPrefix
Constants ¶
const ( ConditionalRegisterStateE = asm.ConditionalRegisterStateUnset + 1 + iota // ZF equal to zero ConditionalRegisterStateNE //˜ZF not equal to zero ConditionalRegisterStateS // SF negative ConditionalRegisterStateNS // ˜SF non-negative ConditionalRegisterStateG // ˜(SF xor OF) & ˜ ZF greater (signed >) ConditionalRegisterStateGE // ˜(SF xor OF) greater or equal (signed >=) ConditionalRegisterStateL // SF xor OF less (signed <) ConditionalRegisterStateLE // (SF xor OF) | ZF less or equal (signed <=) ConditionalRegisterStateA // ˜CF & ˜ZF above (unsigned >) ConditionalRegisterStateAE // ˜CF above or equal (unsigned >=) ConditionalRegisterStateB // CF below (unsigned <) ConditionalRegisterStateBE // CF | ZF below or equal (unsigned <=) )
AMD64-specific conditional register states. https://www.lri.fr/~filliatr/ens/compil/x86-64.pdf https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.pdf
const ( NONE asm.Instruction = iota ADDL ADDQ ADDSD ADDSS ANDL ANDPD ANDPS ANDQ BSRL BSRQ CDQ CMOVQCS CMPL CMPQ COMISD COMISS CQO CVTSD2SS CVTSL2SD CVTSL2SS CVTSQ2SD CVTSQ2SS CVTSS2SD CVTTSD2SL CVTTSD2SQ CVTTSS2SL CVTTSS2SQ DECQ DIVL DIVQ DIVSD DIVSS IDIVL IDIVQ INCQ JCC JCS JEQ JGE JGT JHI JLE JLS JLT JMI JNE JPC JPL JPS LEAQ LZCNTL LZCNTQ MAXSD MAXSS MINSD MINSS MOVB MOVBLSX MOVBLZX MOVBQSX MOVBQZX MOVL MOVLQSX MOVLQZX MOVQ MOVW MOVWLSX MOVWLZX MOVWQSX MOVWQZX MULL MULQ MULSD MULSS ORL ORPD ORPS ORQ POPCNTL POPCNTQ PSLLL PSLLQ PSRLL PSRLQ ROLL ROLQ RORL RORQ ROUNDSD ROUNDSS SARL SARQ SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETPC SETPL SETPS SHLL SHLQ SHRL SHRQ SQRTSD SQRTSS SUBL SUBQ SUBSD SUBSS TESTL TESTQ TZCNTL TZCNTQ UCOMISD UCOMISS XORL XORPD XORPS XORQ RET JMP NOP UD2 )
AMD64-specific instructions. https://www.felixcloutier.com/x86/index.html
Note: here we do not define all of amd64 instructions, and we only define the ones used by wazero's JIT compiler. Note: naming convension is exactly the same as Go assembler: https://go.dev/doc/asm
const ( REG_AX asm.Register = asm.NilRegister + 1 + iota REG_CX REG_DX REG_BX REG_SP REG_BP REG_SI REG_DI REG_R8 REG_R9 REG_R10 REG_R11 REG_R12 REG_R13 REG_R14 REG_R15 REG_X0 REG_X1 REG_X2 REG_X3 REG_X4 REG_X5 REG_X6 REG_X7 REG_X8 REG_X9 REG_X10 REG_X11 REG_X12 REG_X13 REG_X14 REG_X15 )
Arm64-specific registers. https://www.lri.fr/~filliatr/ens/compil/x86-64.pdf https://cs.brown.edu/courses/cs033/docs/guides/x64_cheatsheet.pdf
Note: naming convension is exactly the same as Go assembler: https://go.dev/doc/asm
Variables ¶
var ( OperandTypesNoneToNone = OperandTypes{OperandTypeNone, OperandTypeNone} OperandTypesNoneToRegister = OperandTypes{OperandTypeNone, OperandTypeRegister} OperandTypesNoneToMemory = OperandTypes{OperandTypeNone, OperandTypeMemory} OperandTypesNoneToBranch = OperandTypes{OperandTypeNone, OperandTypeBranch} OperandTypesRegisterToNone = OperandTypes{OperandTypeRegister, OperandTypeNone} OperandTypesRegisterToRegister = OperandTypes{OperandTypeRegister, OperandTypeRegister} OperandTypesRegisterToMemory = OperandTypes{OperandTypeRegister, OperandTypeMemory} OperandTypesRegisterToConst = OperandTypes{OperandTypeRegister, OperandTypeConst} OperandTypesMemoryToRegister = OperandTypes{OperandTypeMemory, OperandTypeRegister} OperandTypesMemoryToConst = OperandTypes{OperandTypeMemory, OperandTypeConst} OperandTypesConstToRegister = OperandTypes{OperandTypeConst, OperandTypeRegister} OperandTypesConstToMemory = OperandTypes{OperandTypeConst, OperandTypeMemory} )
var RegisterToRegisterShiftOpcode = map[asm.Instruction]struct { opcode []byte rPrefix RexPrefix modRMExtension byte }{ ROLL: {/* contains filtered or unexported fields */}, ROLQ: {/* contains filtered or unexported fields */}, RORL: {/* contains filtered or unexported fields */}, RORQ: {/* contains filtered or unexported fields */}, SARL: {/* contains filtered or unexported fields */}, SARQ: {/* contains filtered or unexported fields */}, SHLL: {/* contains filtered or unexported fields */}, SHLQ: {/* contains filtered or unexported fields */}, SHRL: {/* contains filtered or unexported fields */}, SHRQ: {/* contains filtered or unexported fields */}, }
Functions ¶
func FitIn32bit ¶
func InstructionName ¶
func InstructionName(instruction asm.Instruction) string
func IsFloatRegister ¶
func RegisterName ¶
Types ¶
type Assembler ¶
type Assembler interface { asm.AssemblerBase // CompileRegisterToRegisterWithMode adds an instruction where source and destination // are `from` and `to` registers and the instruction's "Mode" is specified by `Mode`. CompileRegisterToRegisterWithMode(instruction asm.Instruction, from, to asm.Register, mode Mode) // CompileMemoryWithIndexToRegister adds an instruction where source operand is the memory address // specified as `srcBaseReg + srcOffsetConst + srcIndex*srcScale` and destination is the register `DstReg`. // Note: sourceScale must be one of 1, 2, 4, 8. CompileMemoryWithIndexToRegister(instruction asm.Instruction, srcBaseReg asm.Register, srcOffsetConst int64, srcIndex asm.Register, srcScale int16, dstReg asm.Register) // CompileRegisterToMemoryWithIndex adds an instruction where source operand is the register `SrcReg`, // and the destination is the memory address specified as `dstBaseReg + dstOffsetConst + dstIndex*dstScale` // Note: dstScale must be one of 1, 2, 4, 8. CompileRegisterToMemoryWithIndex(instruction asm.Instruction, srcReg asm.Register, dstBaseReg asm.Register, dstOffsetConst int64, dstIndex asm.Register, dstScale int16) // CompileRegisterToConst adds an instruction where source operand is the register `srcRegister`, // and the destination is the const `value`. CompileRegisterToConst(instruction asm.Instruction, srcRegister asm.Register, value int64) asm.Node // CompileRegisterToNone adds an instruction where source operand is the register `register`, // and there's no destination operand. CompileRegisterToNone(instruction asm.Instruction, register asm.Register) // CompileNoneToRegister adds an instruction where destination operand is the register `register`, // and there's no source operand. CompileNoneToRegister(instruction asm.Instruction, register asm.Register) // CompileNoneToMemory adds an instruction where destination operand is the memory address specified // as `baseReg+offset`. and there's no source operand. CompileNoneToMemory(instruction asm.Instruction, baseReg asm.Register, offset int64) // CompileConstToMemory adds an instruction where source operand is the constant `value` and // the destination is the memory address sppecified as `dstbaseReg+dstOffset`. CompileConstToMemory(instruction asm.Instruction, value int64, dstbaseReg asm.Register, dstOffset int64) asm.Node // CompileMemoryToConst adds an instruction where source operand is the memory address, and // the destination is the constant `value`. CompileMemoryToConst(instruction asm.Instruction, srcBaseReg asm.Register, srcOffset int64, value int64) asm.Node }
Assembler is the interface used by amd64 JIT compiler.
type AssemblerImpl ¶
type AssemblerImpl struct { asm.BaseAssemblerImpl EnablePadding bool Root, Current *NodeImpl Buf *bytes.Buffer ForceReAssemble bool }
AssemblerImpl implements Assembler.
func NewAssemblerImpl ¶
func NewAssemblerImpl() *AssemblerImpl
func (*AssemblerImpl) Assemble ¶
func (a *AssemblerImpl) Assemble() ([]byte, error)
Assemble implements asm.AssemblerBase
func (*AssemblerImpl) CompileConstToMemory ¶
func (a *AssemblerImpl) CompileConstToMemory(instruction asm.Instruction, value asm.ConstantValue, dstbaseReg asm.Register, dstOffset asm.ConstantValue) asm.Node
CompileConstToMemory implements assembler.CompileConstToMemory
func (*AssemblerImpl) CompileConstToRegister ¶
func (a *AssemblerImpl) CompileConstToRegister(instruction asm.Instruction, value asm.ConstantValue, destinationReg asm.Register) (inst asm.Node)
CompileConstToRegister implements asm.AssemblerBase.CompileConstToRegister
func (*AssemblerImpl) CompileJump ¶
func (a *AssemblerImpl) CompileJump(jmpInstruction asm.Instruction) asm.Node
CompileJump implements asm.AssemblerBase.CompileJump
func (*AssemblerImpl) CompileJumpToMemory ¶
func (a *AssemblerImpl) CompileJumpToMemory(jmpInstruction asm.Instruction, baseReg asm.Register, offset asm.ConstantValue)
CompileJumpToMemory implements asm.AssemblerBase.CompileJumpToMemory
func (*AssemblerImpl) CompileJumpToRegister ¶
func (a *AssemblerImpl) CompileJumpToRegister(jmpInstruction asm.Instruction, reg asm.Register)
CompileJumpToRegister implements asm.AssemblerBase.CompileJumpToRegister
func (*AssemblerImpl) CompileMemoryToConst ¶
func (a *AssemblerImpl) CompileMemoryToConst(instruction asm.Instruction, srcBaseReg asm.Register, srcOffset asm.ConstantValue, value asm.ConstantValue) asm.Node
CompileMemoryToConst implements assembler.CompileMemoryToConst
func (*AssemblerImpl) CompileMemoryToRegister ¶
func (a *AssemblerImpl) CompileMemoryToRegister(instruction asm.Instruction, sourceBaseReg asm.Register, sourceOffsetConst asm.ConstantValue, destinationReg asm.Register)
CompileMemoryToRegister implements asm.AssemblerBase.CompileMemoryToRegister
func (*AssemblerImpl) CompileMemoryWithIndexToRegister ¶
func (a *AssemblerImpl) CompileMemoryWithIndexToRegister(instruction asm.Instruction, srcBaseReg asm.Register, srcOffsetConst asm.ConstantValue, srcIndex asm.Register, srcScale int16, dstReg asm.Register)
CompileMemoryWithIndexToRegister implements assembler.CompileMemoryWithIndexToRegister
func (*AssemblerImpl) CompileNoneToMemory ¶
func (a *AssemblerImpl) CompileNoneToMemory(instruction asm.Instruction, baseReg asm.Register, offset asm.ConstantValue)
CompileNoneToMemory implements assembler.CompileNoneToMemory
func (*AssemblerImpl) CompileNoneToRegister ¶
func (a *AssemblerImpl) CompileNoneToRegister(instruction asm.Instruction, register asm.Register)
CompileNoneToRegister implements assembler.CompileNoneToRegister
func (*AssemblerImpl) CompileReadInstructionAddress ¶
func (a *AssemblerImpl) CompileReadInstructionAddress(destinationRegister asm.Register, beforeAcquisitionTargetInstruction asm.Instruction)
CompileReadInstructionAddress implements asm.AssemblerBase.CompileReadInstructionAddress
func (*AssemblerImpl) CompileRegisterToConst ¶
func (a *AssemblerImpl) CompileRegisterToConst(instruction asm.Instruction, srcRegister asm.Register, value asm.ConstantValue) asm.Node
CompileRegisterToConst implements assembler.CompileRegisterToConst
func (*AssemblerImpl) CompileRegisterToMemory ¶
func (a *AssemblerImpl) CompileRegisterToMemory(instruction asm.Instruction, sourceRegister asm.Register, destinationBaseRegister asm.Register, destinationOffsetConst asm.ConstantValue)
CompileRegisterToMemory implements asm.AssemblerBase.CompileRegisterToMemory
func (*AssemblerImpl) CompileRegisterToMemoryWithIndex ¶
func (a *AssemblerImpl) CompileRegisterToMemoryWithIndex(instruction asm.Instruction, srcReg asm.Register, dstBaseReg asm.Register, dstOffsetConst asm.ConstantValue, dstIndex asm.Register, dstScale int16)
CompileRegisterToMemoryWithIndex implements assembler.CompileRegisterToMemoryWithIndex
func (*AssemblerImpl) CompileRegisterToNone ¶
func (a *AssemblerImpl) CompileRegisterToNone(instruction asm.Instruction, register asm.Register)
CompileRegisterToNone implements assembler.CompileRegisterToNone
func (*AssemblerImpl) CompileRegisterToRegister ¶
func (a *AssemblerImpl) CompileRegisterToRegister(instruction asm.Instruction, from, to asm.Register)
CompileRegisterToRegister implements asm.AssemblerBase.CompileRegisterToRegister
func (*AssemblerImpl) CompileRegisterToRegisterWithMode ¶
func (a *AssemblerImpl) CompileRegisterToRegisterWithMode(instruction asm.Instruction, from, to asm.Register, mode Mode)
CompileRegisterToRegisterWithMode implements assembler.CompileRegisterToRegisterWithMode
func (*AssemblerImpl) CompileStandAlone ¶
func (a *AssemblerImpl) CompileStandAlone(instruction asm.Instruction) asm.Node
CompileStandAlone implements asm.AssemblerBase.CompileStandAlone
func (*AssemblerImpl) Encode ¶
func (a *AssemblerImpl) Encode() (err error)
func (*AssemblerImpl) EncodeConstToMemory ¶
func (a *AssemblerImpl) EncodeConstToMemory(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeConstToRegister ¶
func (a *AssemblerImpl) EncodeConstToRegister(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeMemoryToConst ¶
func (a *AssemblerImpl) EncodeMemoryToConst(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeMemoryToRegister ¶
func (a *AssemblerImpl) EncodeMemoryToRegister(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeNode ¶
func (a *AssemblerImpl) EncodeNode(n *NodeImpl) (err error)
EncodeNode encodes the given node into writer.
func (*AssemblerImpl) EncodeNoneToMemory ¶
func (a *AssemblerImpl) EncodeNoneToMemory(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeNoneToRegister ¶
func (a *AssemblerImpl) EncodeNoneToRegister(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeRegisterToConst ¶
func (a *AssemblerImpl) EncodeRegisterToConst(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeRegisterToMemory ¶
func (a *AssemblerImpl) EncodeRegisterToMemory(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeRegisterToNone ¶
func (a *AssemblerImpl) EncodeRegisterToNone(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeRegisterToRegister ¶
func (a *AssemblerImpl) EncodeRegisterToRegister(n *NodeImpl) (err error)
func (*AssemblerImpl) EncodeRelativeJump ¶
func (a *AssemblerImpl) EncodeRelativeJump(n *NodeImpl) (err error)
func (*AssemblerImpl) InitializeNodesForEncoding ¶
func (a *AssemblerImpl) InitializeNodesForEncoding()
InitializeNodesForEncoding initializes NodeImpl.Flag and determine all the jumps are forward or backward jump.
func (*AssemblerImpl) ResolveForwardRelativeJumps ¶
func (a *AssemblerImpl) ResolveForwardRelativeJumps(target *NodeImpl) (err error)
func (*AssemblerImpl) WriteConst ¶
func (a *AssemblerImpl) WriteConst(v int64, length byte)
type Mode ¶
type Mode = byte
Mode represents a Mode for specific instruction. For example, ROUND** instructions' behavior can be modified "Mode" constant. See https://www.felixcloutier.com/x86/roundss for ROUNDSS as an example.
type NodeFlag ¶
type NodeFlag byte
const ( // NodeFlagInitializedForEncoding is always set to indicate that node is already initialized. Notably, this is used to judge // whether a jump is backward or forward before encoding. NodeFlagInitializedForEncoding NodeFlag = (1 << iota) NodeFlagBackwardJump // NodeFlagShortForwardJump is set to false by default and only used by forward branch jumps, which means .JumpTarget != nil and // the target node is encoded afoter this node. False by default means that that we Encode all the jumps with JumpTarget // as short jump (i.e. relative signed 8-bit integer offset jump) and try to Encode as small as possible. NodeFlagShortForwardJump )
type NodeImpl ¶
type NodeImpl struct { Instruction asm.Instruction OffsetInBinaryField asm.NodeOffsetInBinary // Field suffix to dodge conflict with OffsetInBinary // JumpTarget holds the target node in the linked for the jump-kind instruction. JumpTarget *NodeImpl Flag NodeFlag // next holds the next node from this node in the assembled linked list. Next *NodeImpl Types OperandTypes SrcReg, DstReg asm.Register SrcConst, DstConst asm.ConstantValue SrcMemIndex, DstMemIndex asm.Register SrcMemScale, DstMemScale byte Mode byte // JumpOrigins hold all the nodes trying to jump into this node. In other words, all the nodes with .JumpTarget == this. JumpOrigins map[*NodeImpl]struct{} // contains filtered or unexported fields }
NodeImpl implements asm.Node for amd64.
func (*NodeImpl) AssignDestinationConstant ¶
func (n *NodeImpl) AssignDestinationConstant(value asm.ConstantValue)
AssignDestinationConstant implements asm.Node.AssignDestinationConstant.
func (*NodeImpl) AssignJumpTarget ¶
AssignJumpTarget implements asm.Node.AssignJumpTarget.
func (*NodeImpl) AssignSourceConstant ¶
func (n *NodeImpl) AssignSourceConstant(value asm.ConstantValue)
AssignSourceConstant implements asm.Node.AssignSourceConstant.
func (*NodeImpl) GetMemoryLocation ¶
func (*NodeImpl) GetRegisterToRegisterModRM ¶
func (n *NodeImpl) GetRegisterToRegisterModRM(srcOnModRMReg bool) (RexPrefix, modRM byte, err error)
TODO: srcOnModRMReg can be deleted after golang-asm removal. This is necessary to match our implementation with golang-asm, but in practice, there are equivalent opcodes to always have src on ModRM:reg without ambiguity.
func (*NodeImpl) OffsetInBinary ¶
func (n *NodeImpl) OffsetInBinary() asm.NodeOffsetInBinary
OffsetInBinary implements asm.Node.OffsetInBinary.
type OperandType ¶
type OperandType byte
OperandType represents where an operand is placed for an instruction. Note: this is almost the same as obj.AddrType in GO assembler.
const ( OperandTypeNone OperandType = iota OperandTypeRegister OperandTypeMemory OperandTypeConst OperandTypeBranch )
func (OperandType) String ¶
func (o OperandType) String() (ret string)
type OperandTypes ¶
type OperandTypes struct {
// contains filtered or unexported fields
}
OperandTypes represents the only combinations of two OperandTypes used by wazero
type RexPrefix ¶
type RexPrefix = byte
RexPrefix represents REX prefix https://wiki.osdev.org/X86-64_Instruction_Encoding#REX_prefix
const ( RexPrefixNone RexPrefix = 0x0000_0000 // Indicates that the instruction doesn't need RexPrefix. RexPrefixDefault RexPrefix = 0b0100_0000 RexPrefixW RexPrefix = 0b0000_1000 | RexPrefixDefault RexPrefixR RexPrefix = 0b0000_0100 | RexPrefixDefault RexPrefixX RexPrefix = 0b0000_0010 | RexPrefixDefault RexPrefixB RexPrefix = 0b0000_0001 | RexPrefixDefault )
REX prefixes are independent of each other and can be combined with OR.