asmjit::BaseCompiler Class Reference

Inheritance diagram for asmjit::BaseCompiler:

Code emitter that uses virtual registers and performs register allocation.

Compiler is a high-level code-generation tool that provides register allocation and automatic handling of function calling conventions. It was primarily designed for merging multiple parts of code into a function without worrying about registers and function calling conventions.

BaseCompiler can be used, with a minimum effort, to handle 32-bit and 64-bit code generation within a single code base.

BaseCompiler is based on BaseBuilder and contains all the features it provides. It means that the code it stores can be modified (removed, added, injected) and analyzed. When the code is finalized the compiler can emit the code into an Assembler to translate the abstract representation into a machine code.

Check out architecture specific compilers for more details and examples:

• x86::Compiler - X86/X64 compiler implementation.
• a64::Compiler - AArch64 compiler implementation.

Public Members

Members

FuncNode* _func

Zone _vRegZone

ZoneVector<VirtReg*> _vRegArray

ZoneVector<JumpAnnotation*> _jumpAnnotations

ConstPoolNode* _constPools[2]

 Public Attributes inherited from asmjit::BaseBuilder

Zone _codeZone

Zone _dataZone

Zone _passZone

ZoneAllocator _allocator

ZoneVector<Pass*> _passes {}

ZoneVector<SectionNode*> _sectionNodes {}

ZoneVector<LabelNode*> _labelNodes {}

BaseNode* _cursor = nullptr

NodeList _nodeList

NodeFlags _nodeFlags = NodeFlags::kNone

bool _dirtySectionLinks = false

 Public Attributes inherited from asmjit::BaseEmitter

EmitterType _emitterType = EmitterType::kNone

EmitterFlags _emitterFlags = EmitterFlags::kNone

uint8_t _instructionAlignment = 0u

ValidationFlags _validationFlags = ValidationFlags::kNone

DiagnosticOptions _diagnosticOptions = DiagnosticOptions::kNone

uint64_t _archMask = 0

EncodingOptions _encodingOptions = EncodingOptions::kNone

InstOptions _forcedInstOptions = InstOptions::kReserved

uint32_t _privateData = 0

CodeHolder* _code = nullptr

Logger* _logger = nullptr

ErrorHandler* _errorHandler = nullptr

Environment _environment {}

OperandSignature _gpSignature {}

InstOptions _instOptions = InstOptions::kNone

RegOnly _extraReg {}

const char* _inlineComment = nullptr

Funcs _funcs {}

Public Types

typedef BaseBuilder Base

 Public Types inherited from asmjit::BaseBuilder

typedef BaseEmitter Base

Member Functions

BaseCompiler(const BaseCompiler& other) = delete

BaseCompiler& operator=(const BaseCompiler& other) = delete

Construction & Destruction

BaseCompiler() noexcept

~BaseCompiler() noexcept override

Function Management

Error newFuncNode(FuncNode** out, const FuncSignature& signature)

Error addFuncNode(FuncNode** out, const FuncSignature& signature)

Error newFuncRetNode(FuncRetNode** out, const Operand_& o0, const Operand_& o1)

Error addFuncRetNode(FuncRetNode** out, const Operand_& o0, const Operand_& o1)

FuncNode* func() const noexcept

FuncNode* newFunc(const FuncSignature& signature)

FuncNode* addFunc(const FuncSignature& signature)

FuncNode* addFunc(FuncNode* func)

Error endFunc()

Error addRet(const Operand_& o0, const Operand_& o1)

Function Invocation

Error newInvokeNode(InvokeNode** out, InstId instId, const Operand_& o0, const FuncSignature& signature)

Error addInvokeNode(InvokeNode** out, InstId instId, const Operand_& o0, const FuncSignature& signature)

Virtual Registers

Error newVirtReg(VirtReg** out, TypeId typeId, OperandSignature signature, const char* name)

Error _newReg(BaseReg* out, TypeId typeId, const char* name = nullptr)

Error _newRegFmt(BaseReg* out, TypeId typeId, const char* fmt, ...)

Error _newRegFmt(BaseReg* out, TypeId typeId)

Error _newReg(BaseReg* out, const BaseReg& ref, const char* name = nullptr)

Error _newRegFmt(BaseReg* out, const BaseReg& ref, const char* fmt, ...)

bool isVirtIdValid(uint32_t id) const noexcept

bool isVirtRegValid(const BaseReg& reg) const noexcept

VirtReg* virtRegById(uint32_t id) const noexcept

VirtReg* virtRegByReg(const BaseReg& reg) const noexcept

VirtReg* virtRegByIndex(uint32_t index) const noexcept

const ZoneVector<VirtReg*>& virtRegs() const noexcept

Stack

Error _newStack(BaseMem* out, uint32_t size, uint32_t alignment, const char* name = nullptr)

Error setStackSize(uint32_t virtId, uint32_t newSize, uint32_t newAlignment = 0)

Error setStackSize(const BaseMem& mem, uint32_t newSize, uint32_t newAlignment = 0)

Constants

Error _newConst(BaseMem* out, ConstPoolScope scope, const void* data, size_t size)

Miscellaneous

void rename(const BaseReg& reg, const char* fmt, ...)

Jump Annotations

const ZoneVector<JumpAnnotation*>& jumpAnnotations() const noexcept

Error newJumpNode(JumpNode** out, InstId instId, InstOptions instOptions, const Operand_& o0, JumpAnnotation* annotation)

Error emitAnnotatedJump(InstId instId, const Operand_& o0, JumpAnnotation* annotation)

JumpAnnotation* newJumpAnnotation()

Events

Error onAttach(CodeHolder* code) noexcept override

Error onDetach(CodeHolder* code) noexcept override

 Public Member Functions inherited from asmjit::BaseBuilder

BaseBuilder(const BaseBuilder& other) = delete

BaseBuilder& operator=(const BaseBuilder& other) = delete

BaseBuilder() noexcept

~BaseBuilder() noexcept override

NodeList nodeList() const noexcept

BaseNode* firstNode() const noexcept

BaseNode* lastNode() const noexcept

template<typename T, typename... Args>

Error _newNodeT(T** out, Args&&... args)

Error newInstNode(InstNode** out, InstId instId, InstOptions instOptions, uint32_t opCount)

Error newLabelNode(LabelNode** out)

Error newAlignNode(AlignNode** out, AlignMode alignMode, uint32_t alignment)

Error newEmbedDataNode(EmbedDataNode** out, TypeId typeId, const void* data, size_t itemCount, size_t repeatCount = 1)

Error newConstPoolNode(ConstPoolNode** out)

Error newCommentNode(CommentNode** out, const char* data, size_t size)

BaseNode* addNode(BaseNode* node) noexcept

BaseNode* addAfter(BaseNode* node, BaseNode* ref) noexcept

BaseNode* addBefore(BaseNode* node, BaseNode* ref) noexcept

BaseNode* removeNode(BaseNode* node) noexcept

void removeNodes(BaseNode* first, BaseNode* last) noexcept

BaseNode* cursor() const noexcept

BaseNode* setCursor(BaseNode* node) noexcept

void _setCursor(BaseNode* node) noexcept

const ZoneVector<SectionNode*>& sectionNodes() const noexcept

bool hasRegisteredSectionNode(uint32_t sectionId) const noexcept

Error sectionNodeOf(SectionNode** out, uint32_t sectionId)

Error section(Section* section) override

bool hasDirtySectionLinks() const noexcept

void updateSectionLinks() noexcept

const ZoneVector<LabelNode*>& labelNodes() const noexcept

bool hasRegisteredLabelNode(uint32_t labelId) const noexcept

bool hasRegisteredLabelNode(const Label& label) const noexcept

Error labelNodeOf(LabelNode** out, uint32_t labelId)

Error labelNodeOf(LabelNode** out, const Label& label)

Error registerLabelNode(LabelNode* node)

Label newLabel() override

Label newNamedLabel(const char* name, size_t nameSize = SIZE_MAX, LabelType type = LabelType::kGlobal, uint32_t parentId = Globals::kInvalidId) override

Error bind(const Label& label) override

const ZoneVector<Pass*>& passes() const noexcept

template<typename T>

T* newPassT() noexcept

template<typename T, typename... Args>

T* newPassT(Args&&... args) noexcept

template<typename T>

Error addPassT()

template<typename T, typename... Args>

Error addPassT(Args&&... args)

Pass* passByName(const char* name) const noexcept

Error addPass(Pass* pass) noexcept

Error deletePass(Pass* pass) noexcept

Error runPasses()

Error _emit(InstId instId, const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_* opExt) override

Error align(AlignMode alignMode, uint32_t alignment) override

Error embed(const void* data, size_t dataSize) override

Error embedDataArray(TypeId typeId, const void* data, size_t count, size_t repeat = 1) override

Error embedConstPool(const Label& label, const ConstPool& pool) override

Error embedLabel(const Label& label, size_t dataSize = 0) override

Error embedLabelDelta(const Label& label, const Label& base, size_t dataSize = 0) override

Error comment(const char* data, size_t size = SIZE_MAX) override

Error serializeTo(BaseEmitter* dst)

 Public Member Functions inherited from asmjit::BaseEmitter

BaseEmitter(const BaseEmitter& other) = delete

BaseEmitter& operator=(const BaseEmitter& other) = delete

BaseEmitter(EmitterType emitterType) noexcept

~BaseEmitter() noexcept

template<typename T>

T* as() noexcept

template<typename T>

const T* as() const noexcept

EmitterType emitterType() const noexcept

EmitterFlags emitterFlags() const noexcept

bool isAssembler() const noexcept

bool isBuilder() const noexcept

bool isCompiler() const noexcept

bool hasEmitterFlag(EmitterFlags flag) const noexcept

bool isFinalized() const noexcept

bool isDestroyed() const noexcept

CodeHolder* code() const noexcept

const Environment& environment() const noexcept

bool is32Bit() const noexcept

bool is64Bit() const noexcept

Arch arch() const noexcept

SubArch subArch() const noexcept

uint32_t registerSize() const noexcept

OperandSignature gpSignature() const noexcept

uint32_t instructionAlignment() const noexcept

bool isInitialized() const noexcept

Error finalize()

bool hasLogger() const noexcept

bool hasOwnLogger() const noexcept

Logger* logger() const noexcept

void setLogger(Logger* logger) noexcept

void resetLogger() noexcept

bool hasErrorHandler() const noexcept

bool hasOwnErrorHandler() const noexcept

ErrorHandler* errorHandler() const noexcept

void setErrorHandler(ErrorHandler* errorHandler) noexcept

void resetErrorHandler() noexcept

Error reportError(Error err, const char* message = nullptr)

EncodingOptions encodingOptions() const noexcept

bool hasEncodingOption(EncodingOptions option) const noexcept

void addEncodingOptions(EncodingOptions options) noexcept

void clearEncodingOptions(EncodingOptions options) noexcept

DiagnosticOptions diagnosticOptions() const noexcept

bool hasDiagnosticOption(DiagnosticOptions option) const noexcept

void addDiagnosticOptions(DiagnosticOptions options) noexcept

void clearDiagnosticOptions(DiagnosticOptions options) noexcept

InstOptions forcedInstOptions() const noexcept

InstOptions instOptions() const noexcept

void setInstOptions(InstOptions options) noexcept

void addInstOptions(InstOptions options) noexcept

void resetInstOptions() noexcept

bool hasExtraReg() const noexcept

const RegOnly& extraReg() const noexcept

void setExtraReg(const BaseReg& reg) noexcept

void setExtraReg(const RegOnly& reg) noexcept

void resetExtraReg() noexcept

const char* inlineComment() const noexcept

void setInlineComment(const char* s) noexcept

void resetInlineComment() noexcept

void resetState() noexcept

Label newAnonymousLabel(const char* name, size_t nameSize = SIZE_MAX)

Label newExternalLabel(const char* name, size_t nameSize = SIZE_MAX)

Label labelByName(const char* name, size_t nameSize = SIZE_MAX, uint32_t parentId = Globals::kInvalidId) noexcept

bool isLabelValid(uint32_t labelId) const noexcept

bool isLabelValid(const Label& label) const noexcept

Error _emitI(InstId instId)

Error _emitI(InstId instId, const Operand_& o0)

Error _emitI(InstId instId, const Operand_& o0, const Operand_& o1)

Error _emitI(InstId instId, const Operand_& o0, const Operand_& o1, const Operand_& o2)

Error _emitI(InstId instId, const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_& o3)

Error _emitI(InstId instId, const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_& o3, const Operand_& o4)

Error _emitI(InstId instId, const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_& o3, const Operand_& o4, const Operand_& o5)

template<typename... Args>

Error emit(InstId instId, Args&&... operands)

Error emitOpArray(InstId instId, const Operand_* operands, size_t opCount)

Error emitInst(const BaseInst& inst, const Operand_* operands, size_t opCount)

Error emitProlog(const FuncFrame& frame)

Error emitEpilog(const FuncFrame& frame)

Error emitArgsAssignment(const FuncFrame& frame, const FuncArgsAssignment& args)

Error embedInt8(int8_t value, size_t repeatCount = 1)

Error embedUInt8(uint8_t value, size_t repeatCount = 1)

Error embedInt16(int16_t value, size_t repeatCount = 1)

Error embedUInt16(uint16_t value, size_t repeatCount = 1)

Error embedInt32(int32_t value, size_t repeatCount = 1)

Error embedUInt32(uint32_t value, size_t repeatCount = 1)

Error embedInt64(int64_t value, size_t repeatCount = 1)

Error embedUInt64(uint64_t value, size_t repeatCount = 1)

Error embedFloat(float value, size_t repeatCount = 1)

Error embedDouble(double value, size_t repeatCount = 1)

Error commentf(const char* fmt, ...)

Error commentv(const char* fmt, va_list ap)

void onSettingsUpdated() noexcept

Constructor & Destructor Documentation

BaseCompiler::BaseCompiler()noexcept

Creates a new BaseCompiler instance.

BaseCompiler::~BaseCompiler()overridenoexcept

Destroys the BaseCompiler instance.

Member Function Documentation

Error BaseCompiler::newFuncNode(FuncNode** out, const FuncSignature& signature)

Creates a new FuncNode.

Error BaseCompiler::addFuncNode(FuncNode** out, const FuncSignature& signature)

Creates a new FuncNode adds it to the instruction stream.

Error BaseCompiler::newFuncRetNode(FuncRetNode** out, const Operand_& o0, const Operand_& o1)

Creates a new FuncRetNode.

Error BaseCompiler::addFuncRetNode(FuncRetNode** out, const Operand_& o0, const Operand_& o1)

Creates a new FuncRetNode and adds it to the instruction stream.

FuncNode* BaseCompiler::func() constnoexcept

Returns the current function.

FuncNode* BaseCompiler::newFunc(const FuncSignature& signature)

Creates a new FuncNode with the given signature and returns it.

FuncNode* BaseCompiler::addFunc(const FuncSignature& signature)[1/2]

Creates a new FuncNode with the given signature, adds it to the instruction stream by using the addFunc(FuncNode*) overload, and returns it.

FuncNode* BaseCompiler::addFunc(FuncNode* func)[2/2]

Adds a function node to the instruction stream.

Error BaseCompiler::endFunc()

Emits a sentinel that marks the end of the current function.

Error BaseCompiler::newInvokeNode(InvokeNode** out, InstId instId, const Operand_& o0, const FuncSignature& signature)

Creates a new InvokeNode.

Error BaseCompiler::addInvokeNode(InvokeNode** out, InstId instId, const Operand_& o0, const FuncSignature& signature)

Creates a new InvokeNode and adds it to the instruction stream.

Error BaseCompiler::newVirtReg(VirtReg** out, TypeId typeId, OperandSignature signature, const char* name)

Creates a new virtual register representing the given typeId and signature.

Note

This function is public, but it's not generally recommended to be used by AsmJit users, use architecture specific newReg() functionality instead or functions like _newReg() and _newRegFmt().

Error BaseCompiler::_newReg(BaseReg* out, TypeId typeId, const char* name = nullptr)[1/2]

Creates a new virtual register of the given typeId and stores it to out operand.

Error BaseCompiler::_newRegFmt(BaseReg* out, TypeId typeId, const char* fmt, ...)[1/3]

Creates a new virtual register of the given typeId and stores it to out operand.

Note

This version accepts a snprintf() format fmt followed by a variadic arguments.

Error BaseCompiler::_newRegFmt(BaseReg* out, TypeId typeId)[2/3]

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Error BaseCompiler::_newReg(BaseReg* out, const BaseReg& ref, const char* name = nullptr)[2/2]

Creates a new virtual register compatible with the provided reference register ref.

Error BaseCompiler::_newRegFmt(BaseReg* out, const BaseReg& ref, const char* fmt, ...)[3/3]

Creates a new virtual register compatible with the provided reference register ref.

Note

This version accepts a snprintf() format fmt followed by a variadic arguments.

bool BaseCompiler::isVirtIdValid(uint32_t id) constnoexcept

Tests whether the given id is a valid virtual register id.

bool BaseCompiler::isVirtRegValid(const BaseReg& reg) constnoexcept

Tests whether the given reg is a virtual register having a valid id.

VirtReg* BaseCompiler::virtRegById(uint32_t id) constnoexcept

Returns VirtReg associated with the given id.

VirtReg* BaseCompiler::virtRegByReg(const BaseReg& reg) constnoexcept

Returns VirtReg associated with the given reg.

VirtReg* BaseCompiler::virtRegByIndex(uint32_t index) constnoexcept

Returns VirtReg associated with the given virtual register index.

Note

This is not the same as virtual register id. The conversion between id and its index is implemented by Operand_::virtIdToIndex() and Operand_::indexToVirtId() functions.

const ZoneVector<VirtReg*>& BaseCompiler::virtRegs() constnoexcept

Returns an array of all virtual registers managed by the Compiler.

Error BaseCompiler::_newStack(BaseMem* out, uint32_t size, uint32_t alignment, const char* name = nullptr)

Creates a new stack of the given size and alignment and stores it to out.

Note

name can be used to give the stack a name, for debugging purposes.

Error BaseCompiler::setStackSize(uint32_t virtId, uint32_t newSize, uint32_t newAlignment = 0)[1/2]

Updates the stack size of a stack created by _newStack() by its virtId.

Error BaseCompiler::setStackSize(const BaseMem& mem, uint32_t newSize, uint32_t newAlignment = 0)[2/2]

Updates the stack size of a stack created by _newStack().

Error BaseCompiler::_newConst(BaseMem* out, ConstPoolScope scope, const void* data, size_t size)

Creates a new constant of the given scope (see ConstPoolScope).

This function adds a constant of the given size to the built-in ConstPool and stores the reference to that constant to the out operand.

void BaseCompiler::rename(const BaseReg& reg, const char* fmt, ...)

Rename the given virtual register reg to a formatted string fmt.

JumpAnnotation* BaseCompiler::newJumpAnnotation()

Returns a new JumpAnnotation instance, which can be used to aggregate possible targets of a jump where the target is not a label, for example to implement jump tables.

Error BaseCompiler::onAttach(CodeHolder* code)overridenoexcept

Called after the emitter was attached to CodeHolder.

Reimplemented from asmjit::BaseBuilder.

Reimplemented in asmjit::x86::Compiler.

Error BaseCompiler::onDetach(CodeHolder* code)overridenoexcept

Called after the emitter was detached from CodeHolder.

Reimplemented from asmjit::BaseBuilder.

Reimplemented in asmjit::x86::Compiler.

Member Data Documentation

FuncNode* BaseCompiler::_func

Current function.

Zone BaseCompiler::_vRegZone

Allocates VirtReg objects.

ZoneVector<VirtReg*>BaseCompiler::_vRegArray

Stores array of VirtReg pointers.

ZoneVector<JumpAnnotation*>BaseCompiler::_jumpAnnotations

Stores jump annotations.

ConstPoolNode* BaseCompiler::_constPools[2]

Local and global constant pools.

Local constant pool is flushed with each function, global constant pool is flushed only by finalize().