Materializes the content of the emitter by serializing it to the attached CodeHolder through an architecture specific BaseAssembler. This function won't do anything if the emitter inherits from BaseAssembler as assemblers emit directly to a CodeBuffer held by CodeHolder. However, if this is an emitter that inherits from BaseBuilder or BaseCompiler then these emitters need the materialization phase as they store their content in a representation not visible to CodeHolder.

Reimplemented in asmjit::a64::Builder, asmjit::a64::Compiler, asmjit::x86::Builder, and asmjit::x86::Compiler.

bool BaseEmitter::hasLogger() constnoexcept[¶]

Tests whether the emitter has a logger.

bool BaseEmitter::hasOwnLogger() constnoexcept[¶]

Tests whether the emitter has its own logger.

Own logger means that it overrides the possible logger that may be used by CodeHolder this emitter is attached to.

Logger* BaseEmitter::logger() constnoexcept[¶]

Returns the logger this emitter uses.

The returned logger is either the emitter's own logger or it's logger used by CodeHolder this emitter is attached to.

void BaseEmitter::setLogger(
Logger* logger
)noexcept[¶]

Sets or resets the logger of the emitter.

If the logger argument is non-null then the logger will be considered emitter's own logger, see hasOwnLogger() for more details. If the given logger is null then the emitter will automatically use logger that is attached to the CodeHolder this emitter is attached to.

void BaseEmitter::resetLogger()noexcept[¶]

Resets the logger of this emitter.

The emitter will bail to using a logger attached to CodeHolder this emitter is attached to, or no logger at all if CodeHolder doesn't have one.

bool BaseEmitter::hasErrorHandler() constnoexcept[¶]

Tests whether the emitter has an error handler attached.

bool BaseEmitter::hasOwnErrorHandler() constnoexcept[¶]

Tests whether the emitter has its own error handler.

Own error handler means that it overrides the possible error handler that may be used by CodeHolder this emitter is attached to.

ErrorHandler* BaseEmitter::errorHandler() constnoexcept[¶]

Returns the error handler this emitter uses.

The returned error handler is either the emitter's own error handler or it's error handler used by CodeHolder this emitter is attached to.

void BaseEmitter::setErrorHandler(
ErrorHandler* errorHandler
)noexcept[¶]

Sets or resets the error handler of the emitter.

void BaseEmitter::resetErrorHandler()noexcept[¶]

Resets the error handler.

Error BaseEmitter::reportError(
Error err,
const char* message = nullptr
)[¶]

Handles the given error in the following way:

If the emitter has ErrorHandler attached, it calls its ErrorHandler::handleError() member function first, and then returns the error. The handleError() function may throw.
if the emitter doesn't have ErrorHandler, the error is simply returned.

EncodingOptions BaseEmitter::encodingOptions() constnoexcept[¶]

Returns encoding options.

bool BaseEmitter::hasEncodingOption(
EncodingOptions option
) constnoexcept[¶]

Tests whether the encoding option is set.

void BaseEmitter::addEncodingOptions(
EncodingOptions options
)noexcept[¶]

Enables the given encoding options.

void BaseEmitter::clearEncodingOptions(
EncodingOptions options
)noexcept[¶]

Disables the given encoding options.

DiagnosticOptions BaseEmitter::diagnosticOptions() constnoexcept[¶]

Returns the emitter's diagnostic options.

bool BaseEmitter::hasDiagnosticOption(
DiagnosticOptions option
) constnoexcept[¶]

Tests whether the given option is present in the emitter's diagnostic options.

void BaseEmitter::addDiagnosticOptions(
DiagnosticOptions options
)noexcept[¶]

Activates the given diagnostic options.

This function is used to activate explicit validation options that will be then used by all emitter implementations. There are in general two possibilities:

Architecture specific assembler is used. In this case a DiagnosticOptions::kValidateAssembler can be used to turn on explicit validation that will be used before an instruction is emitted. This means that internally an extra step will be performed to make sure that the instruction is correct. This is needed, because by default assemblers prefer speed over strictness.

This option should be used in debug builds as it's pretty expensive.
Architecture specific builder or compiler is used. In this case the user can turn on DiagnosticOptions::kValidateIntermediate option that adds explicit validation step before the Builder or Compiler creates an InstNode to represent an emitted instruction. Error will be returned if the instruction is ill-formed. In addition, also DiagnosticOptions::kValidateAssembler can be used, which would not be consumed by Builder / Compiler directly, but it would be propagated to an architecture specific BaseAssembler implementation it creates during BaseEmitter::finalize().

void BaseEmitter::clearDiagnosticOptions(
DiagnosticOptions options
)noexcept[¶]

Deactivates the given validation options.

See addDiagnosticOptions() and DiagnosticOptions for more details.

InstOptions BaseEmitter::forcedInstOptions() constnoexcept[¶]

Returns forced instruction options.

Forced instruction options are merged with next instruction options before the instruction is encoded. These options have some bits reserved that are used by error handling, logging, and instruction validation purposes. Other options are globals that affect each instruction.

InstOptions BaseEmitter::instOptions() constnoexcept[¶]

Returns options of the next instruction.

void BaseEmitter::setInstOptions(
InstOptions options
)noexcept[¶]

Returns options of the next instruction.

void BaseEmitter::addInstOptions(
InstOptions options
)noexcept[¶]

Adds options of the next instruction.

void BaseEmitter::resetInstOptions()noexcept[¶]

Resets options of the next instruction.

bool BaseEmitter::hasExtraReg() constnoexcept[¶]

Tests whether the extra register operand is valid.

const RegOnly& BaseEmitter::extraReg() constnoexcept[¶]

Returns an extra operand that will be used by the next instruction (architecture specific).

void BaseEmitter::setExtraReg(
const BaseReg& reg
)noexcept[1/2][¶]

Sets an extra operand that will be used by the next instruction (architecture specific).

void BaseEmitter::setExtraReg(
const RegOnly& reg
)noexcept[2/2][¶]

Sets an extra operand that will be used by the next instruction (architecture specific).

void BaseEmitter::resetExtraReg()noexcept[¶]

Resets an extra operand that will be used by the next instruction (architecture specific).

const char* BaseEmitter::inlineComment() constnoexcept[¶]

Returns comment/annotation of the next instruction.

void BaseEmitter::setInlineComment(
const char* s
)noexcept[¶]

Sets comment/annotation of the next instruction.

Note: This string is set back to null by _emit(), but until that it has to remain valid as the Emitter is not required to make a copy of it (and it would be slow to do that for each instruction).

void BaseEmitter::resetInlineComment()noexcept[¶]

Resets the comment/annotation to nullptr.

void BaseEmitter::resetState()noexcept[¶]

Resets the emitter state, which contains instruction options, extra register, and inline comment.

Emitter can have a state that describes instruction options and extra register used by the instruction. Most instructions don't need nor use the state, however, if an instruction uses a prefix such as REX or REP prefix, which is set explicitly, then the state would contain it. This allows to mimic the syntax of assemblers such as X86. For example rep().movs(...) would map to a REP MOVS instuction on X86. The same applies to various hints and the use of a mask register in AVX-512 mode.

Error BaseEmitter::section(
Section* section
)virtual[¶]

Switches the given section.

Once switched, everything is added to the given section.

Reimplemented in asmjit::BaseAssembler, and asmjit::BaseBuilder.

Label BaseEmitter::newLabel()virtual[¶]

Creates a new label.

Reimplemented in asmjit::BaseAssembler, and asmjit::BaseBuilder.

Label BaseEmitter::newNamedLabel(
const char* name,
size_t nameSize = SIZE_MAX,
LabelType type = LabelType::kGlobal,
uint32_t parentId = Globals::kInvalidId
)virtual[¶]

Creates a new named label.

Reimplemented in asmjit::BaseAssembler, and asmjit::BaseBuilder.

Label BaseEmitter::newAnonymousLabel(
const char* name,
size_t nameSize = SIZE_MAX
)[¶]

Creates a new anonymous label with a name, which can only be used for debugging purposes.

Label BaseEmitter::newExternalLabel(
const char* name,
size_t nameSize = SIZE_MAX
)[¶]

Creates a new external label.

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

Returns Label by name.

Returns invalid Label in case that the name is invalid or label was not found.

Note: This function doesn't trigger ErrorHandler in case the name is invalid or no such label exist. You must always check the validity of the Label returned.

Error BaseEmitter::bind(
const Label& label
)virtual[¶]

Binds the label to the current position of the current section.

Note: Attempt to bind the same label multiple times will return an error.

Reimplemented in asmjit::BaseAssembler, and asmjit::BaseBuilder.

bool BaseEmitter::isLabelValid(
uint32_t labelId
) constnoexcept[1/2][¶]

Tests whether the label id is valid (i.e. registered).

bool BaseEmitter::isLabelValid(
const Label& label
) constnoexcept[2/2][¶]

Tests whether the label is valid (i.e. registered).