top | up | prev | next

Emitter Class

Definition at line 20 of Emitter.hpp

Constructors

Emitter(EmittingContext* emittingContext_)

Member Functions

void	AddCase(void* switchInst, void* caseValue, void* caseDest) override
void	AddClauseToLangdingPad(void* landingPad, void* exceptionTypeId) override
void	AddControlFlowGraphEdge(int32_t startNodeId, int32_t endNodeId) override
int32_t	AddControlFlowGraphNode() override
void	AddHandlerToCatchSwitch(void* catchSwitch, void* target) override
void	AddInlineFunctionAttribute(void* function) override
void	AddLocalVariable(const std::string& localVariableName, const boost::uuids::uuid& typeId, void* irObject) override
void	AddMDItem(void* mdStruct, const std::string& fieldName, void* mdItem) override
void	AddNoUnwindAttribute(void* function) override
void	AddUWTableAttribute(void* function) override
void	BeginInstructionFlag(int16_t flag) override
void	BeginScope() override
void	BeginSubstituteLineNumber(int32_t lineNumber) override
void*	CleanupBlock() override
void	Compile(const std::string& bcFilePath, const std::string& objectFilePath, int optimizationLevel) override
void*	ComputeAddress(void* ptr, void* index) override
void*	CreateAShr(void* left, void* right) override
void*	CreateAdd(void* left, void* right) override
void*	CreateAlloca(void* irType) override
void*	CreateAnd(void* left, void* right) override
void*	CreateArrayIndexAddress(void* arrayPtr, void* index) override
void*	CreateBasicBlock(const std::string& name) override
void*	CreateBeginCatch() override
void*	CreateBeginTry() override
void*	CreateBitCast(void* operand, void* destinationType) override
void	CreateBr(void* targetBasicBlock) override
void*	CreateCall(void* callee, const std::vector<void*>& args) override
void*	CreateCallInst(void* callee, const std::vector<void>& args, const std::vector<void>& bundles, const Span& span) override
void*	CreateCallInstToBasicBlock(void* callee, const std::vector<void>& args, const std::vector<void>& bundles, void* basicBlock, const Span& span) override
void*	CreateCatchPad(void* parentPad, const std::vector<void*>& args) override
void*	CreateCatchRet(void* catchPad, void* returnTarget) override
void*	CreateCatchSwitch(void* unwindBlock) override
void*	CreateCatchSwitchWithParent(void* parentPad, void* unwindBlock) override
void*	CreateClassDIType(void* classPtr) override
void	CreateCleanup() override
void*	CreateCleanupPad(const std::vector<void*>& args) override
void*	CreateCleanupPadWithParent(void* parentPad, const std::vector<void*>& args) override
void*	CreateCleanupRet(void* cleanupPad, void* unwindTarget) override
void	CreateCondBr(void* cond, void* trueBasicBlock, void* falseBasicBlock) override
void*	CreateConstDIType(void* diType) override
void*	CreateDIAutoVariable(const std::string& name, const Span& span, const boost::uuids::uuid& moduleId, void* irType, void* allocaInst) override
void*	CreateDIFunction(const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId, void* subroutineType, unsigned flags) override
void*	CreateDIMemberType(void* scope, const std::string& name, const Span& span, const boost::uuids::uuid& moduleId, uint64_t sizeInBits, uint64_t alignInBits, uint64_t offsetInBits, void* diType) override
void*	CreateDIMethod(const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId, void* subroutineType, unsigned virtuality, unsigned vtableIndex, void* vtableHolder, unsigned flags) override
void*	CreateDIParameterVariable(const std::string& name, int index, const Span& span, const boost::uuids::uuid& moduleId, void* irType, void* allocaInst) override
void*	CreateDITypeForArray(void* elementDIType, const std::vector<void*>& elements) override
void*	CreateDITypeForBool() override
void*	CreateDITypeForByte() override
void*	CreateDITypeForChar() override
void*	CreateDITypeForClassType(void* irType, const std::vector<void>& memberVariableElements, const Span& classSpan, const boost::uuids::uuid& moduleId, const std::string& name, void vtableHolderClass, const std::string& mangledName, void* baseClassDIType) override
void*	CreateDITypeForDouble() override
void*	CreateDITypeForEnumConstant(const std::string& name, int64_t value) override
void*	CreateDITypeForEnumType(const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId, const std::vector<void>& enumConstantElements, uint64_t sizeInBits, uint32_t alignInBits, void underlyingDIType) override
void*	CreateDITypeForFloat() override
void*	CreateDITypeForInt() override
void*	CreateDITypeForLong() override
void*	CreateDITypeForSByte() override
void*	CreateDITypeForShort() override
void*	CreateDITypeForUChar() override
void*	CreateDITypeForUInt() override
void*	CreateDITypeForULong() override
void*	CreateDITypeForUShort() override
void*	CreateDITypeForVoid() override
void*	CreateDITypeForWChar() override
void*	CreateDebugInfoForNamespace(void* scope, const std::string& name) override
void*	CreateDefaultIrValueForArrayType(void* arrayIrType, const std::vector<void*>& arrayOfDefaults) override
void*	CreateDefaultIrValueForBool() override
void*	CreateDefaultIrValueForByte() override
void*	CreateDefaultIrValueForChar() override
void*	CreateDefaultIrValueForDelegateType(void* irType) override
void*	CreateDefaultIrValueForDerivedType(void* irType) override
void*	CreateDefaultIrValueForDouble() override
void*	CreateDefaultIrValueForFloat() override
void*	CreateDefaultIrValueForInt() override
void*	CreateDefaultIrValueForLong() override
void*	CreateDefaultIrValueForPtrType(void* irType) override
void*	CreateDefaultIrValueForSByte() override
void*	CreateDefaultIrValueForShort() override
void*	CreateDefaultIrValueForStruct(void* irType, const std::vector<void*>& defaultMembers) override
void*	CreateDefaultIrValueForUChar() override
void*	CreateDefaultIrValueForUInt() override
void*	CreateDefaultIrValueForULong() override
void*	CreateDefaultIrValueForUShort() override
void*	CreateDefaultIrValueForVoidPtrType() override
void*	CreateDefaultIrValueForWChar() override
void*	CreateEndCatch(void* nextDest) override
void*	CreateEndTry(void* nextDest) override
void*	CreateExtractValue(void* aggregate, const std::vector<unsigned int>& indeces) override
void*	CreateFAdd(void* left, void* right) override
void*	CreateFCmpOEQ(void* left, void* right) override
void*	CreateFCmpOLT(void* left, void* right) override
void*	CreateFDiv(void* left, void* right) override
void*	CreateFMul(void* left, void* right) override
void*	CreateFNeg(void* value) override
void*	CreateFPExt(void* operand, void* destinationType) override
void*	CreateFPToSI(void* operand, void* destinationType) override
void*	CreateFPToUI(void* operand, void* destinationType) override
void*	CreateFPTrunc(void* operand, void* destinationType) override
void*	CreateFSub(void* left, void* right) override
void*	CreateFwdIrTypeForClassType() override
void*	CreateGlobalStringPtr(const std::string& stringValue) override
void*	CreateGlobalUStringPtr(const std::u32string& stringValue) override
void*	CreateGlobalWStringPtr(const std::u16string& stringValue) override
void*	CreateICmpEQ(void* left, void* right) override
void*	CreateICmpSLT(void* left, void* right) override
void*	CreateICmpULT(void* left, void* right) override
void*	CreateIncludeBasicBlockInstruction(void* basicBlock) override
void*	CreateInsertValue(void* aggregate, void* value, const std::vector<unsigned int>& indeces) override
void*	CreateIntToPtr(void* intValue, void* destinationType) override
void*	CreateInvoke(void* callee, void* normalBlock, void* unwindBlock, const std::vector<void*>& args) override
void*	CreateInvokeInst(void* callee, void* normalBlock, void* unwindBlock, const std::vector<void>& args, const std::vector<void>& bundles, const Span& span) override
void*	CreateIrDIForwardDeclaration(void* irType, const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId) override
void*	CreateIrValueForBool(bool value) override
void*	CreateIrValueForByte(uint8_t value) override
void*	CreateIrValueForChar(uint8_t value) override
void*	CreateIrValueForConstantArray(void* arrayIrType, const std::vector<void*>& elementConstants, const std::string& prefix) override
void*	CreateIrValueForConstantStruct(void* structIrType, const std::vector<void*>& elementConstants) override
void*	CreateIrValueForDouble(double value) override
void*	CreateIrValueForFloat(float value) override
void*	CreateIrValueForInt(int32_t value) override
void*	CreateIrValueForLong(int64_t value) override
void*	CreateIrValueForSByte(int8_t value) override
void*	CreateIrValueForShort(int16_t value) override
void*	CreateIrValueForUChar(uint32_t value) override
void*	CreateIrValueForUInt(uint32_t value) override
void*	CreateIrValueForULong(uint64_t value) override
void*	CreateIrValueForUShort(uint16_t value) override
void*	CreateIrValueForUString(void* ustringConstant) override
void*	CreateIrValueForUuid(void* uuidConstant) override
void*	CreateIrValueForWChar(uint16_t value) override
void*	CreateIrValueForWString(void* wstringConstant) override
void*	CreateLShr(void* left, void* right) override
void*	CreateLValueRefDIType(void* diType) override
void*	CreateLandingPad(void* lpType) override
void*	CreateLexicalBlock(const Span& span, const boost::uuids::uuid& moduleId) override
void*	CreateLoad(void* ptr) override
void*	CreateMDBasicBlockRef(void* bb) override
void*	CreateMDBool(bool value) override
void*	CreateMDLong(int64_t value) override
void*	CreateMDString(const std::string& value) override
void*	CreateMDStruct() override
void*	CreateMDStructRef(int id) override
void*	CreateModule(const std::string& moduleName) override
void*	CreateMul(void* left, void* right) override
void*	CreateNeg(void* value) override
void*	CreateNop() override
void*	CreateNot(void* value) override
void*	CreateOr(void* left, void* right) override
void*	CreatePointerDIType(void* diType) override
void*	CreatePtrDiff(void* left, void* right) override
void*	CreatePtrToInt(void* ptrValue, void* destinationType) override
void*	CreateRValueRefDIType(void* diType) override
void	CreateResume(void* exception) override
void*	CreateRet(void* value) override
void*	CreateRetVoid() override
void*	CreateSDiv(void* left, void* right) override
void*	CreateSExt(void* operand, void* destinationType) override
void*	CreateSIToFP(void* operand, void* destinationType) override
void*	CreateSRem(void* left, void* right) override
void*	CreateSave() override
void*	CreateShl(void* left, void* right) override
void	CreateStore(void* value, void* ptr) override
void*	CreateSub(void* left, void* right) override
void*	CreateSubroutineType(const std::vector<void*>& elementTypes) override
void*	CreateSwitch(void* condition, void* defaultDest, unsigned numCases) override
void*	CreateTrunc(void* operand, void* destinationType) override
void*	CreateUDiv(void* left, void* right) override
void*	CreateUIToFP(void* operand, void* destinationType) override
void*	CreateURem(void* left, void* right) override
void*	CreateUndefValue(void* type) override
void*	CreateUnspecifiedDIType(const std::string& name) override
void*	CreateXor(void* left, void* right) override
void*	CreateZExt(void* operand, void* destinationType) override
void*	CurrentBasicBlock() const override
Pad*	CurrentPad() override
void*	CurrentScope() override
void*	DIBuilder() override
void	DebugPrintDebugInfo(const std::string& filePath) override
void	DestroyModule(void* module) override
void	Disassemble(const std::string& bcFilePath, const std::string& filePath) override
void	EmitIrFile(const std::string& filePath) override
void	EmitIrText(const std::string& filePath) override
void	EmitObjectCodeFile(const std::string& objectFilePath) override
void	EndDebugInfo() override
void	EndInstructionFlag(int16_t flag) override
void	EndScope() override
void	EndSubstituteLineNumber() override
void	FinalizeDebugInfo() override
void	FinalizeFunction(void* function, bool hasCleanup) override
void*	GenerateTrap(const std::vector<void*>& args) override
uint64_t	GetAlignmentInBits(void* irType) override
void*	GetArrayBeginAddress(void* arrayPtr) override
void*	GetArrayEndAddress(void* arrayPtr, uint64_t size) override
int	GetBasicBlockId(void* basicBlock) override
void*	GetBoundCompileUnit() const override
void*	GetClassIdPtr(void* vmtPtr, int32_t classIdVmtIndexOffset) override
void*	GetClassName(void* vmtPtr, int32_t classNameVmtIndexOffset) override
uint64_t	GetClassTypeAlignmentInBits(void* classIrType) override
uint64_t	GetClassTypeSizeInBits(void* classIrType) override
void*	GetClsIdValue(const std::string& typeId) override
void*	GetConversionValue(void* type, void* from) override
int16_t	GetCurrentScopeId() const override
void*	GetDIMemberType(const std::pair<boost::uuids::uuid, int32_t>& memberVariableId) override
void*	GetDITypeByTypeId(const boost::uuids::uuid& typeId) const override
void*	GetDebugInfoForFile(const Span& span, const boost::uuids::uuid& moduleId) override
void*	GetDelegateFromClassDelegate(void* classDelegatePtr) override
EmittingContext*	GetEmittingContext() const
void*	GetFunctionArgument(void* function, int argumentIndex) override
unsigned	GetFunctionFlags(bool isStatic, unsigned accessFlags, bool isExplicit) override
void*	GetFunctionIrType(void* functionSymbol) const override
void*	GetGlobalStringPtr(int stringId) override
void*	GetGlobalUStringConstant(int stringId) override
void*	GetGlobalUuidConstant(int uuidId) override
void*	GetGlobalWStringConstant(int stringId) override
void*	GetImt(void* imtArray, int32_t interfaceIndex) override
void*	GetImtArray(void* vmtObjectPtr, int32_t imtsVmtIndexOffset) override
std::string	GetImtArrayObjectName(void* symbol) const override
void*	GetImtPtrFromInterface(void* interfaceTypePtr) override
void*	GetInterfaceMethod(void* imtPtr, int32_t methodIndex, void* interfaceMethodType) override
void*	GetIrObject(void* symbol) const override
void*	GetIrTypeByTypeId(const boost::uuids::uuid& typeId) override
void*	GetIrTypeForArrayType(void* elementType, int64_t size) override
void*	GetIrTypeForBool() override
void*	GetIrTypeForByte() override
void*	GetIrTypeForChar() override
void*	GetIrTypeForClassType(const std::vector<void*>& elementTypes) override
void*	GetIrTypeForDelegateType(void* retType, const std::vector<void*>& paramTypes) override
void*	GetIrTypeForDouble() override
void*	GetIrTypeForFloat() override
void*	GetIrTypeForFunction(void* retType, const std::vector<void*>& paramTypes) override
void*	GetIrTypeForInt() override
void*	GetIrTypeForLong() override
void*	GetIrTypeForPtrType(void* baseIrType) override
void*	GetIrTypeForSByte() override
void*	GetIrTypeForShort() override
void*	GetIrTypeForStructType(const std::vector<void*>& elementTypes) override
void*	GetIrTypeForUChar() override
void*	GetIrTypeForUInt() override
void*	GetIrTypeForULong() override
void*	GetIrTypeForUShort() override
void*	GetIrTypeForVariableParamFunction(void* retType) override
void*	GetIrTypeForVoid() override
void*	GetIrTypeForVoidPtrType() override
void*	GetIrTypeForWChar() override
std::string	GetIrTypeName(void* irType) override
int	GetMDStructId(void* mdStruct) override
void*	GetMDStructRefForSourceFile(const std::string& sourceFileName) override
void*	GetMemberVariablePtr(void* classPtr, int32_t memberVariableLayoutIndex) override
void*	GetMethodPtr(void* vmtPtr, int32_t vmtIndex) override
uint32_t	GetNoFlags() override
void*	GetObjectFromClassDelegate(void* classDelegatePtr) override
void*	GetObjectFromInterface(void* interfaceTypePtr) override
void*	GetObjectPointer() override
void*	GetObjectPtrFromInterface(void* interfaceTypePtr) override
uint64_t	GetOffsetInBits(void* classIrType, int layoutIndex) override
void*	GetOrInsertAnyComdat(const std::string& name, void* global) override
void*	GetOrInsertAnyFunctionComdat(const std::string& name, void* function) override
void*	GetOrInsertFunction(const std::string& name, void* type, bool nothrow) override
void*	GetOrInsertGlobal(const std::string& name, void* type) override
uint32_t	GetPrivateFlag() override
uint32_t	GetProtectedFlag() override
uint32_t	GetPublicFlag() override
unsigned	GetPureVirtualVirtuality() override
uint64_t	GetSizeInBits(void* irType) override
std::string	GetStaticObjectName(void* symbol) const override
void*	GetStaticObjectType(void* symbol) const override
unsigned	GetVirtualVirtuality() override
std::string	GetVmtObjectName(void* symbol) const override
void*	GetVmtObjectType(void* symbol) const override
void*	GetVmtPtr(void* thisPtr, int32_t vmtPtrIndex, void* vmtPtrType) override
void*	HandlerBlock() override
int	Install(const std::string& str) override
int	Install(const std::u16string& str) override
int	Install(const std::u32string& str) override
bool	IsStaticObjectCreated(void* symbol) const override
bool	IsVmtObjectCreated(void* symbol) const override
std::string	MakeVmtVariableName(const std::string& vmtObjectName) override
void	MapClassPtr(const boost::uuids::uuid& typeId, void* classPtr, const std::string& className) override
void	MapFwdDeclaration(void* fwdDeclaration, const boost::uuids::uuid& typeId) override
void	MoveAllocaIntoBasicBlock(void* allocaInst, void* lastAlloca, void* basicBlock) override
bool	NewCleanupNeeded() override
void	Optimize(const std::string& bcFilePath, const std::string& optBCFilePath, const std::string& optimizationFlags) override
void	PopParentBlock() override
void	PopScope() override
void	PushParentBlock() override
void	PushScope(void* scope) override
void	ResetCurrentDebugLocation() override
void	SaveObjectPointer(void* objectPointer_) override
void	SetBoundCompileUnit(void* boundCompileUnit_) override
void	SetCleanupBlock(void* cleanupBlock) override
void	SetColumnSpanProvider(ColumnSpanProvider* columnSpanProvider_) override
void	SetCompileUnitId(const std::string& compileUnitId) override
void	SetCurrentBasicBlock(void* basicBlock) override
void	SetCurrentControlFlowGraphNodeId(int32_t controlFlowGraphNodeId) override
void	SetCurrentDIBuilder(void* diBuilder_) override
void	SetCurrentDebugLocation(const Span& span) override
void	SetCurrentScopeId(int16_t scopeId) override
void	SetCurrentSourceSpan(int32_t line, int16_t scol, int16_t ecol) override
void	SetDICompileUnit(void* diCompileUnit_) override
void	SetDIFile(void* diFile_) override
void	SetDIMemberType(const std::pair<boost::uuids::uuid, int32_t>& memberVariableId, void* diType) override
void	SetDISubprogram(void* function, void* subprogram) override
void	SetDITypeByTypeId(const boost::uuids::uuid& typeId, void* diType, const std::string& typeName) override
void	SetDataLayout(void* dataLayout_) override
void	SetDebugLoc(void* callInst) override
void	SetEmittingDelegate(EmittingDelegate* emittingDelegate_) override
void	SetFunction(void* function_, int32_t fileIndex, const boost::uuids::uuid& sourceModuleId, const boost::uuids::uuid& functionId) override
void	SetFunctionCallConventionToStdCall(void* function) override
void	SetFunctionIrType(void* symbol, void* irType) override
void	SetFunctionLinkage(void* function, bool setInline) override
void	SetFunctionLinkageToLinkOnceODRLinkage(void* function) override
void	SetFunctionMdId(void* function, int mdId) override
void	SetFunctionName(const std::string& functionName) override
void	SetFwdIrTypeBody(void* forwardDeclaredType, const std::vector<void*>& elementTypes) override
void	SetHandlerBlock(void* tryBlock, void* catchBlock) override
void	SetImtArrayObjectName(void* symbol, const std::string& imtArrayObjectName) override
void	SetInPrologue(bool inPrologue_) override
void	SetInitializer(void* global, void* initializer) override
void	SetIrObject(void* symbol, void* irObject) override
void	SetIrTypeByTypeId(const boost::uuids::uuid& typeId, void* irType) override
void	SetLandindPadAsCleanup(void* landingPad) override
void	SetLineNumber(int32_t lineNumber) override
void	SetMetadataRef(void* inst, void* mdStructRef) override
void	SetModule(void* module_) override
void	SetObjectPointer(void* objectPointer_) override
void	SetPersonalityFunction(void* function, void* personalityFunction) override
void	SetPrivateLinkage(void* global) override
void	SetSourceFileName(const std::string& sourceFileName) override
void	SetStaticObjectCreated(void* symbol) override
void	SetStaticObjectName(void* symbol, const std::string& staticObjectName) override
void	SetStaticObjectType(void* symbol, void* type) override
void	SetTargetTriple(const std::string& targetTriple) override
void	SetVmtObjectCreated(void* symbol) override
void	SetVmtObjectName(void* symbol, const std::string& vmtObjectName) override
void	SetVmtObjectType(void* symbol, void* vmtObjectType) override
void*	SizeOf(void* ptrType) override
void	StartDebugInfo(const std::string& sourceFilePath, const std::string& compilerVersion, bool optimized, ColumnSpanProvider* columnSpanProvider_) override
void	VerifyModule() override

Member Variables

CompileUnit*	compileUnit
Context*	context
Function*	currentFunction
EmittingContext*	emittingContext
EmittingDelegate*	emittingDelegate
std::unordered_map<void, FunctionType>	functionIrTypeMap
std::unordered_map<void, Value>	irObjectMap
std::unordered_map<boost::uuids::uuid, Type*, boost::hash<boost::uuids::uuid>>	irTypeTypeIdMap
Value*	objectPointer
ValueStack	stack
std::unordered_set<void*>	staticObjectCreatedSet
std::unordered_map<void*, std::string>	staticObjectNameMap
std::unordered_map<void, StructureType>	staticTypeMap
std::unordered_set<void*>	vmtObjectCreatedSet

Constructor Details

Emitter Constructor

cmsxbe::Emitter::Emitter(EmittingContext * emittingContext_)

Definition at line 12 of Emitter.cpp :
  12 :
  13 cmajor::ir::Emitter(&stack), emittingContext(emittingContext_), emittingDelegate(nullptr), context(nullptr), compileUnit(nullptr), currentFunction(nullptr),
  14 objectPointer(nullptr)
  15 {
  16 }

Member Function Details

AddCase Member Function

void cmsxbe::Emitter::AddCase(void * switchInst, void * caseValue, void * caseDest) override

Definition at line 1781 of Emitter.cpp :
1782 {
1783 cmsxi::SwitchInstruction* inst = static_cast<cmsxi::SwitchInstruction*>(switchInst);
1784 inst->AddCase(static_cast<cmsxi::Value*>(caseValue), static_cast<cmsxi::BasicBlock*>(caseDest));
1785 }

Declaration at line 332 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddCase

Calls: cmsxi::SwitchInstruction::AddCase

AddClauseToLangdingPad Member Function

void cmsxbe::Emitter::AddClauseToLangdingPad(void * landingPad, void * exceptionTypeId) override

Definition at line 1900 of Emitter.cpp :
1901 {
1902 }

Declaration at line 355 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddClauseToLangdingPad

AddControlFlowGraphEdge Member Function

void cmsxbe::Emitter::AddControlFlowGraphEdge(int32_t startNodeId, int32_t endNodeId) override

Definition at line 1655 of Emitter.cpp :
1656 {
1657 }

Declaration at line 307 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddControlFlowGraphEdge

AddControlFlowGraphNode Member Function

int32_t cmsxbe::Emitter::AddControlFlowGraphNode() override

Definition at line 1646 of Emitter.cpp :
1647 {
1648 return -1;
1649 }

Declaration at line 305 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddControlFlowGraphNode

AddHandlerToCatchSwitch Member Function

void cmsxbe::Emitter::AddHandlerToCatchSwitch(void * catchSwitch, void * target) override

Definition at line 1173 of Emitter.cpp :
1174 {
1176 }

Declaration at line 230 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddHandlerToCatchSwitch

AddInlineFunctionAttribute Member Function

void cmsxbe::Emitter::AddInlineFunctionAttribute(void * function) override

Definition at line 1599 of Emitter.cpp :
1600 {
1602 }

Declaration at line 295 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddInlineFunctionAttribute

AddLocalVariable Member Function

void cmsxbe::Emitter::AddLocalVariable(const std::string& localVariableName, const boost::uuids::uuid& typeId, void * irObject) override

Definition at line 1659 of Emitter.cpp :
1660 {
1661 }

Declaration at line 308 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddLocalVariable

AddMDItem Member Function

void cmsxbe::Emitter::AddMDItem(void * mdStruct, const std::string& fieldName, void * mdItem) override

Definition at line 1842 of Emitter.cpp :
1843 {
1844 context->AddMDStructItem(static_cast<cmsxi::MDStruct*>(mdStruct), fieldName, static_cast<cmsxi::MDItem*>(mdItem));
1845 }

Declaration at line 343 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddMDItem

Calls: cmsxi::Context::AddMDStructItem

Called by: cmsxbe::Emitter::CreateInvoke

AddNoUnwindAttribute Member Function

void cmsxbe::Emitter::AddNoUnwindAttribute(void * function) override

Definition at line 1760 of Emitter.cpp :
1761 {
1763 }

Declaration at line 328 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddNoUnwindAttribute

AddUWTableAttribute Member Function

void cmsxbe::Emitter::AddUWTableAttribute(void * function) override

Definition at line 1765 of Emitter.cpp :
1766 {
1768 }

Declaration at line 329 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::AddUWTableAttribute

BeginInstructionFlag Member Function

void cmsxbe::Emitter::BeginInstructionFlag(int16_t flag) override

Definition at line 1663 of Emitter.cpp :
1664 {
1665 }

Declaration at line 309 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::BeginInstructionFlag

BeginScope Member Function

void cmsxbe::Emitter::BeginScope() override

Definition at line 1629 of Emitter.cpp :
1630 {
1631 }

Declaration at line 301 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::BeginScope

BeginSubstituteLineNumber Member Function

void cmsxbe::Emitter::BeginSubstituteLineNumber(int32_t lineNumber) override

Definition at line 1927 of Emitter.cpp :
1928 {
1929 }

Declaration at line 361 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::BeginSubstituteLineNumber

CleanupBlock Member Function

void * cmsxbe::Emitter::CleanupBlock() override

Definition at line 1116 of Emitter.cpp :
1117 {
1118 return emittingDelegate->CleanupBlock();
1119 }

Declaration at line 220 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CleanupBlock

Calls: cmajor::ir::EmittingDelegate::CleanupBlock

Called by: cmsxbe::Emitter::CreateInvoke

Compile Member Function

void cmsxbe::Emitter::Compile(const std::string& bcFilePath, const std::string& objectFilePath, int optimizationLevel) override

Definition at line 1544 of Emitter.cpp :
1545 {
1547 }

Declaration at line 285 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::Compile

ComputeAddress Member Function

void * cmsxbe::Emitter::ComputeAddress(void * ptr, void * index) override

Definition at line 1424 of Emitter.cpp :
1425 {
1426 return context->CreatePtrOffset(static_cast<cmsxi::Value*>(ptr), static_cast<cmsxi::Value*>(index));
1427 }

Declaration at line 262 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::ComputeAddress

Calls: cmsxi::Context::CreatePtrOffset

CreateAShr Member Function

void * cmsxbe::Emitter::CreateAShr(void * left, void * right) override

Definition at line 835 of Emitter.cpp :
836 {
837 return context->CreateShr(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
838 }

Declaration at line 171 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateAShr

Calls: cmsxi::Context::CreateShr

CreateAdd Member Function

void * cmsxbe::Emitter::CreateAdd(void * left, void * right) override

Definition at line 760 of Emitter.cpp :
761 {
762 return context->CreateAdd(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
763 }

Declaration at line 156 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateAdd

Calls: cmsxi::Context::CreateAdd

CreateAlloca Member Function

void * cmsxbe::Emitter::CreateAlloca(void * irType) override

Definition at line 1718 of Emitter.cpp :
1719 {
1720 return context->CreateLocal(static_cast<cmsxi::Type*>(irType));
1721 }

Declaration at line 320 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateAlloca

Calls: cmsxi::Context::CreateLocal

CreateAnd Member Function

void * cmsxbe::Emitter::CreateAnd(void * left, void * right) override

Definition at line 815 of Emitter.cpp :
816 {
817 return context->CreateAnd(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
818 }

Declaration at line 167 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateAnd

Calls: cmsxi::Context::CreateAnd

CreateArrayIndexAddress Member Function

void * cmsxbe::Emitter::CreateArrayIndexAddress(void * arrayPtr, void * index) override

Definition at line 745 of Emitter.cpp :
746 {
747 return context->CreateElemAddr(static_cast<cmsxi::Value*>(arrayPtr), static_cast<cmsxi::Value*>(index));
748 }

Declaration at line 153 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateArrayIndexAddress

Calls: cmsxi::Context::CreateElemAddr

CreateBasicBlock Member Function

void * cmsxbe::Emitter::CreateBasicBlock(const std::string& name) override

Definition at line 687 of Emitter.cpp :
688 {
689     if (name == "cleanup")
690     {
691         return currentFunction->CreateCleanupBasicBlock();
692     }
693     else
694     {
695         return currentFunction->CreateBasicBlock();
696     }
697 }

Declaration at line 142 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateBasicBlock

Calls: cmsxi::Function::CreateBasicBlock , cmsxi::Function::CreateCleanupBasicBlock

CreateBeginCatch Member Function

void * cmsxbe::Emitter::CreateBeginCatch() override

Definition at line 979 of Emitter.cpp :
980 {
981 return nullptr;
982 }

Declaration at line 197 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateBeginCatch

CreateBeginTry Member Function

void * cmsxbe::Emitter::CreateBeginTry() override

Definition at line 969 of Emitter.cpp :
970 {
971 return nullptr;
972 }

Declaration at line 195 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateBeginTry

CreateBitCast Member Function

void * cmsxbe::Emitter::CreateBitCast(void * operand, void * destinationType) override

Definition at line 895 of Emitter.cpp :
896 {
897 return context->CreateBitCast(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
898 }

Declaration at line 183 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateBitCast

Calls: cmsxi::Context::CreateBitCast

CreateBr Member Function

void cmsxbe::Emitter::CreateBr(void * targetBasicBlock) override

Definition at line 725 of Emitter.cpp :
726 {
727 context->CreateJump(static_cast<cmsxi::BasicBlock*>(targetBasicBlock));
728 }

Declaration at line 149 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateBr

Calls: cmsxi::Context::CreateJump

CreateCall Member Function

void * cmsxbe::Emitter::CreateCall(void * callee, const std::vector<void *>& args) override

Definition at line 1190 of Emitter.cpp :
1191 {
1192     for (void* arg : args)
1193     {
1194         cmsxi::Value* argument = static_cast<cmsxi::Value*>(arg);
1195         context->CreateArg(argument);
1196     }
1197     cmsxi::Value* calleeValue = static_cast<cmsxi::Value*>(callee);
1198     return context->CreateCall(calleeValue);
1199 }

Declaration at line 233 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCall

Calls: cmsxi::Context::CreateArg , cmsxi::Context::CreateCall

Called by: cmsxbe::Emitter::CreateInvoke

CreateCallInst Member Function

void * cmsxbe::Emitter::CreateCallInst(void * callee, const std::vector<void >& args, const std::vector<void >& bundles, const Span& span) override

Definition at line 1201 of Emitter.cpp :
1202 {
1203     for (void* arg : args)
1204     {
1205         cmsxi::Value* argument = static_cast<cmsxi::Value*>(arg);
1206         context->CreateArg(argument);
1207     }
1208     cmsxi::Value* calleeValue = static_cast<cmsxi::Value*>(callee);
1209     return context->CreateCall(calleeValue);
1210 }

Declaration at line 234 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCallInst

Calls: cmsxi::Context::CreateArg , cmsxi::Context::CreateCall

CreateCallInstToBasicBlock Member Function

void * cmsxbe::Emitter::CreateCallInstToBasicBlock(void * callee, const std::vector<void >& args, const std::vector<void >& bundles, void * basicBlock, const Span& span) override

Definition at line 1212 of Emitter.cpp
Declaration at line 235 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCallInstToBasicBlock

Calls: cmsxbe::Emitter::SetCurrentBasicBlock , cmsxi::Context::CreateArg , cmsxi::Context::CreateCall , cmsxi::Context::GetCurrentBasicBlock

CreateCatchPad Member Function

void * cmsxbe::Emitter::CreateCatchPad(void * parentPad, const std::vector<void *>& args) override

Definition at line 1178 of Emitter.cpp :
1179 {
1181 return nullptr;
1182 }

Declaration at line 231 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCatchPad

CreateCatchRet Member Function

void * cmsxbe::Emitter::CreateCatchRet(void * catchPad, void * returnTarget) override

Definition at line 1155 of Emitter.cpp :
1156 {
1158 return nullptr;
1159 }

Declaration at line 227 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCatchRet

CreateCatchSwitch Member Function

void * cmsxbe::Emitter::CreateCatchSwitch(void * unwindBlock) override

Definition at line 1161 of Emitter.cpp :
1162 {
1164 return nullptr;
1165 }

Declaration at line 228 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCatchSwitch

CreateCatchSwitchWithParent Member Function

void * cmsxbe::Emitter::CreateCatchSwitchWithParent(void * parentPad, void * unwindBlock) override

Definition at line 1167 of Emitter.cpp :
1168 {
1170 return nullptr;
1171 }

Declaration at line 229 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCatchSwitchWithParent

CreateClassDIType Member Function

void * cmsxbe::Emitter::CreateClassDIType(void * classPtr) override

Definition at line 1184 of Emitter.cpp :
1185 {
1187 return nullptr;
1188 }

Declaration at line 232 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateClassDIType

CreateCleanup Member Function

void cmsxbe::Emitter::CreateCleanup() override

Definition at line 1126 of Emitter.cpp :
1127 {
1128 return emittingDelegate->CreateCleanup();
1129 }

Declaration at line 222 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCleanup

Calls: cmajor::ir::EmittingDelegate::CreateCleanup

CreateCleanupPad Member Function

void * cmsxbe::Emitter::CreateCleanupPad(const std::vector<void *>& args) override

Definition at line 1143 of Emitter.cpp :
1144 {
1146 return nullptr;
1147 }

Declaration at line 225 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCleanupPad

CreateCleanupPadWithParent Member Function

void * cmsxbe::Emitter::CreateCleanupPadWithParent(void * parentPad, const std::vector<void *>& args) override

Definition at line 1137 of Emitter.cpp :
1138 {
1140 return nullptr;
1141 }

Declaration at line 224 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCleanupPadWithParent

CreateCleanupRet Member Function

void * cmsxbe::Emitter::CreateCleanupRet(void * cleanupPad, void * unwindTarget) override

Definition at line 1149 of Emitter.cpp :
1150 {
1152 return nullptr;
1153 }

Declaration at line 226 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCleanupRet

CreateCondBr Member Function

void cmsxbe::Emitter::CreateCondBr(void * cond, void * trueBasicBlock, void * falseBasicBlock) override

Definition at line 740 of Emitter.cpp :
741 {
742 context->CreateBranch(static_cast<cmsxi::Value*>(cond), static_cast<cmsxi::BasicBlock*>(trueBasicBlock), static_cast<cmsxi::BasicBlock*>(falseBasicBlock));
743 }

Declaration at line 152 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateCondBr

Calls: cmsxi::Context::CreateBranch

CreateConstDIType Member Function

void * cmsxbe::Emitter::CreateConstDIType(void * diType) override

Definition at line 623 of Emitter.cpp :
624 {
626 return nullptr;
627 }

Declaration at line 131 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateConstDIType

CreateDIAutoVariable Member Function

void * cmsxbe::Emitter::CreateDIAutoVariable(const std::string& name, const Span& span, const boost::uuids::uuid& moduleId, void * irType, void * allocaInst) override

Definition at line 1729 of Emitter.cpp :
1730 {
1732 return nullptr;
1733 }

Declaration at line 322 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDIAutoVariable

CreateDIFunction Member Function

void * cmsxbe::Emitter::CreateDIFunction(const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId, void * subroutineType, unsigned flags) override

Definition at line 1707 of Emitter.cpp :
1708 {
1710 return nullptr;
1711 }

Declaration at line 318 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDIFunction

CreateDIMemberType Member Function

void * cmsxbe::Emitter::CreateDIMemberType(void * scope, const std::string& name, const Span& span, const boost::uuids::uuid& moduleId, uint64_t sizeInBits, uint64_t alignInBits, uint64_t offsetInBits, void * diType) override

Definition at line 617 of Emitter.cpp :
618 {
620 return nullptr;
621 }

Declaration at line 130 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDIMemberType

CreateDIMethod Member Function

void * cmsxbe::Emitter::CreateDIMethod(const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId, void * subroutineType, unsigned virtuality, unsigned vtableIndex, void * vtableHolder, unsigned flags) override

Definition at line 1700 of Emitter.cpp :
1702 {
1704 return nullptr;
1705 }

Declaration at line 316 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDIMethod

CreateDIParameterVariable Member Function

void * cmsxbe::Emitter::CreateDIParameterVariable(const std::string& name, int index, const Span& span, const boost::uuids::uuid& moduleId, void * irType, void * allocaInst) override

Definition at line 1723 of Emitter.cpp :
1724 {
1726 return nullptr;
1727 }

Declaration at line 321 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDIParameterVariable

CreateDITypeForArray Member Function

void * cmsxbe::Emitter::CreateDITypeForArray(void * elementDIType, const std::vector<void *>& elements) override

Definition at line 552 of Emitter.cpp :
553 {
555 return nullptr;
556 }

Declaration at line 117 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForArray

CreateDITypeForBool Member Function

void * cmsxbe::Emitter::CreateDITypeForBool() override

Definition at line 462 of Emitter.cpp :
463 {
465 return nullptr;
466 }

Declaration at line 102 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForBool

CreateDITypeForByte Member Function

void * cmsxbe::Emitter::CreateDITypeForByte() override

Definition at line 474 of Emitter.cpp :
475 {
477 return nullptr;
478 }

Declaration at line 104 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForByte

CreateDITypeForChar Member Function

void * cmsxbe::Emitter::CreateDITypeForChar() override

Definition at line 528 of Emitter.cpp :
529 {
531 return nullptr;
532 }

Declaration at line 113 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForChar

CreateDITypeForClassType Member Function

void * cmsxbe::Emitter::CreateDITypeForClassType(void * irType, const std::vector<void >& memberVariableElements, const Span& classSpan, const boost::uuids::uuid& moduleId, const std::string& name, void vtableHolderClass, const std::string& mangledName, void * baseClassDIType) override

Definition at line 583 of Emitter.cpp :
585 {
587 return nullptr;
588 }

Declaration at line 123 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForClassType

CreateDITypeForDouble Member Function

void * cmsxbe::Emitter::CreateDITypeForDouble() override

Definition at line 522 of Emitter.cpp :
523 {
525 return nullptr;
526 }

Declaration at line 112 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForDouble

CreateDITypeForEnumConstant Member Function

void * cmsxbe::Emitter::CreateDITypeForEnumConstant(const std::string& name, int64_t value) override

Definition at line 558 of Emitter.cpp :
559 {
561 return nullptr;
562 }

Declaration at line 118 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForEnumConstant

CreateDITypeForEnumType Member Function

void * cmsxbe::Emitter::CreateDITypeForEnumType(const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId, const std::vector<void >& enumConstantElements, uint64_t sizeInBits, uint32_t alignInBits, void underlyingDIType) override

Definition at line 564 of Emitter.cpp :
566 {
568 return nullptr;
569 }

Declaration at line 119 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForEnumType

CreateDITypeForFloat Member Function

void * cmsxbe::Emitter::CreateDITypeForFloat() override

Definition at line 516 of Emitter.cpp :
517 {
519 return nullptr;
520 }

Declaration at line 111 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForFloat

CreateDITypeForInt Member Function

void * cmsxbe::Emitter::CreateDITypeForInt() override

Definition at line 492 of Emitter.cpp :
493 {
495 return nullptr;
496 }

Declaration at line 107 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForInt

CreateDITypeForLong Member Function

void * cmsxbe::Emitter::CreateDITypeForLong() override

Definition at line 504 of Emitter.cpp :
505 {
507 return nullptr;
508 }

Declaration at line 109 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForLong

CreateDITypeForSByte Member Function

void * cmsxbe::Emitter::CreateDITypeForSByte() override

Definition at line 468 of Emitter.cpp :
469 {
471 return nullptr;
472 }

Declaration at line 103 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForSByte

CreateDITypeForShort Member Function

void * cmsxbe::Emitter::CreateDITypeForShort() override

Definition at line 480 of Emitter.cpp :
481 {
483 return nullptr;
484 }

Declaration at line 105 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForShort

CreateDITypeForUChar Member Function

void * cmsxbe::Emitter::CreateDITypeForUChar() override

Definition at line 540 of Emitter.cpp :
541 {
543 return nullptr;
544 }

Declaration at line 115 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForUChar

CreateDITypeForUInt Member Function

void * cmsxbe::Emitter::CreateDITypeForUInt() override

Definition at line 498 of Emitter.cpp :
499 {
501 return nullptr;
502 }

Declaration at line 108 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForUInt

CreateDITypeForULong Member Function

void * cmsxbe::Emitter::CreateDITypeForULong() override

Definition at line 510 of Emitter.cpp :
511 {
513 return nullptr;
514 }

Declaration at line 110 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForULong

CreateDITypeForUShort Member Function

void * cmsxbe::Emitter::CreateDITypeForUShort() override

Definition at line 486 of Emitter.cpp :
487 {
489 return nullptr;
490 }

Declaration at line 106 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForUShort

CreateDITypeForVoid Member Function

void * cmsxbe::Emitter::CreateDITypeForVoid() override

Definition at line 546 of Emitter.cpp :
547 {
549 return nullptr;
550 }

Declaration at line 116 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForVoid

CreateDITypeForWChar Member Function

void * cmsxbe::Emitter::CreateDITypeForWChar() override

Definition at line 534 of Emitter.cpp :
535 {
537 return nullptr;
538 }

Declaration at line 114 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDITypeForWChar

CreateDebugInfoForNamespace Member Function

void * cmsxbe::Emitter::CreateDebugInfoForNamespace(void * scope, const std::string& name) override

Definition at line 1559 of Emitter.cpp :
1560 {
1562 return nullptr;
1563 }

Declaration at line 288 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDebugInfoForNamespace

CreateDefaultIrValueForArrayType Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForArrayType(void * arrayIrType, const std::vector<void *>& arrayOfDefaults) override

Definition at line 203 of Emitter.cpp :
204 {
205     std::vector<cmsxi::ConstantValue*> arrayOfConstants;
206     for (void* constant : arrayOfDefaults)
207     {
208         arrayOfConstants.push_back(static_cast<cmsxi::ConstantValue*>(constant));
209     }
210     cmsxi::Type* arrayType = static_cast<cmsxi::Type*>(arrayIrType);
211     return context->GetArrayValue(arrayType, arrayOfConstants, std::string());
212 }

Declaration at line 55 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForArrayType

Calls: cmsxi::Context::GetArrayValue

CreateDefaultIrValueForBool Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForBool() override

Definition at line 214 of Emitter.cpp :
215 {
216 return context->GetDefaultBoolValue();
217 }

Declaration at line 56 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForBool

Calls: cmsxi::Context::GetDefaultBoolValue

CreateDefaultIrValueForByte Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForByte() override

Definition at line 224 of Emitter.cpp :
225 {
226 return context->GetDefaultByteValue();
227 }

Declaration at line 58 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForByte

Calls: cmsxi::Context::GetDefaultByteValue

CreateDefaultIrValueForChar Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForChar() override

Definition at line 270 of Emitter.cpp :
271 {
272 return context->GetDefaultByteValue();
273 }

Declaration at line 67 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForChar

Calls: cmsxi::Context::GetDefaultByteValue

CreateDefaultIrValueForDelegateType Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForDelegateType(void * irType) override

Definition at line 295 of Emitter.cpp :
296 {
297 return context->GetNullValue(static_cast<cmsxi::PtrType*>(irType));
298 }

Declaration at line 71 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForDelegateType

Calls: cmsxi::Context::GetNullValue

CreateDefaultIrValueForDerivedType Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForDerivedType(void * irType) override

Definition at line 305 of Emitter.cpp :
306 {
307 return static_cast<cmsxi::Type*>(irType)->DefaultValue();
308 }

Declaration at line 73 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForDerivedType

CreateDefaultIrValueForDouble Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForDouble() override

Definition at line 265 of Emitter.cpp :
266 {
267 return context->GetDefaultDoubleValue();
268 }

Declaration at line 66 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForDouble

Calls: cmsxi::Context::GetDefaultDoubleValue

CreateDefaultIrValueForFloat Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForFloat() override

Definition at line 259 of Emitter.cpp :
260 {
261 return context->GetDefaultDoubleValue();
263 }

Declaration at line 65 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForFloat

Calls: cmsxi::Context::GetDefaultDoubleValue

CreateDefaultIrValueForInt Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForInt() override

Definition at line 239 of Emitter.cpp :
240 {
241 return context->GetDefaultIntValue();
242 }

Declaration at line 61 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForInt

Calls: cmsxi::Context::GetDefaultIntValue

CreateDefaultIrValueForLong Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForLong() override

Definition at line 249 of Emitter.cpp :
250 {
251 return context->GetDefaultLongValue();
252 }

Declaration at line 63 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForLong

Calls: cmsxi::Context::GetDefaultLongValue

CreateDefaultIrValueForPtrType Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForPtrType(void * irType) override

Definition at line 310 of Emitter.cpp :
311 {
312 return context->GetNullValue(static_cast<cmsxi::PtrType*>(irType));
313 }

Declaration at line 74 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForPtrType

Calls: cmsxi::Context::GetNullValue

CreateDefaultIrValueForSByte Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForSByte() override

Definition at line 219 of Emitter.cpp :
220 {
221 return context->GetDefaultSByteValue();
222 }

Declaration at line 57 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForSByte

Calls: cmsxi::Context::GetDefaultSByteValue

CreateDefaultIrValueForShort Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForShort() override

Definition at line 229 of Emitter.cpp :
230 {
231 return context->GetDefaultShortValue();
232 }

Declaration at line 59 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForShort

Calls: cmsxi::Context::GetDefaultShortValue

CreateDefaultIrValueForStruct Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForStruct(void * irType, const std::vector<void *>& defaultMembers) override

Definition at line 285 of Emitter.cpp :
286 {
287     std::vector<cmsxi::ConstantValue*> arrayOfDefaults;
288     for (void* constant : defaultMembers)
289     {
290         arrayOfDefaults.push_back(static_cast<cmsxi::ConstantValue*>(constant));
291     }
292     return context->GetStructureValue(static_cast<cmsxi::StructureType*>(irType), arrayOfDefaults);
293 }

Declaration at line 70 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForStruct

Calls: cmsxi::Context::GetStructureValue

CreateDefaultIrValueForUChar Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForUChar() override

Definition at line 280 of Emitter.cpp :
281 {
282 return context->GetDefaultUIntValue();
283 }

Declaration at line 69 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForUChar

Calls: cmsxi::Context::GetDefaultUIntValue

CreateDefaultIrValueForUInt Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForUInt() override

Definition at line 244 of Emitter.cpp :
245 {
246 return context->GetDefaultUIntValue();
247 }

Declaration at line 62 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForUInt

Calls: cmsxi::Context::GetDefaultUIntValue

CreateDefaultIrValueForULong Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForULong() override

Definition at line 254 of Emitter.cpp :
255 {
256 return context->GetDefaultULongValue();
257 }

Declaration at line 64 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForULong

Calls: cmsxi::Context::GetDefaultULongValue

CreateDefaultIrValueForUShort Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForUShort() override

Definition at line 234 of Emitter.cpp :
235 {
236 return context->GetDefaultUShortValue();
237 }

Declaration at line 60 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForUShort

Calls: cmsxi::Context::GetDefaultUShortValue

CreateDefaultIrValueForVoidPtrType Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForVoidPtrType() override

Definition at line 300 of Emitter.cpp :
301 {
302 return context->GetNullValue(static_cast<cmsxi::PtrType*>(context->GetPtrType(context->GetVoidType())));
303 }

Declaration at line 72 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForVoidPtrType

Calls: cmsxi::Context::GetNullValue , cmsxi::Context::GetPtrType , cmsxi::Context::GetVoidType

CreateDefaultIrValueForWChar Member Function

void * cmsxbe::Emitter::CreateDefaultIrValueForWChar() override

Definition at line 275 of Emitter.cpp :
276 {
277 return context->GetDefaultUShortValue();
278 }

Declaration at line 68 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateDefaultIrValueForWChar

Calls: cmsxi::Context::GetDefaultUShortValue

CreateEndCatch Member Function

void * cmsxbe::Emitter::CreateEndCatch(void * nextDest) override

Definition at line 984 of Emitter.cpp :
985 {
986 return nullptr;
987 }

Declaration at line 198 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateEndCatch

CreateEndTry Member Function

void * cmsxbe::Emitter::CreateEndTry(void * nextDest) override

Definition at line 974 of Emitter.cpp :
975 {
976 return nullptr;
977 }

Declaration at line 196 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateEndTry

CreateExtractValue Member Function

void * cmsxbe::Emitter::CreateExtractValue(void * aggregate, const std::vector<unsigned int >& indeces) override

Definition at line 1904 of Emitter.cpp :
1905 {
1906 return nullptr;
1907 }

Declaration at line 356 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateExtractValue

CreateFAdd Member Function

void * cmsxbe::Emitter::CreateFAdd(void * left, void * right) override

Definition at line 765 of Emitter.cpp :
766 {
767 return context->CreateAdd(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
768 }

Declaration at line 157 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFAdd

Calls: cmsxi::Context::CreateAdd

CreateFCmpOEQ Member Function

void * cmsxbe::Emitter::CreateFCmpOEQ(void * left, void * right) override

Definition at line 850 of Emitter.cpp :
851 {
852 return context->CreateEqual(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
853 }

Declaration at line 174 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFCmpOEQ

Calls: cmsxi::Context::CreateEqual

CreateFCmpOLT Member Function

void * cmsxbe::Emitter::CreateFCmpOLT(void * left, void * right) override

Definition at line 865 of Emitter.cpp :
866 {
867 return context->CreateLess(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
868 }

Declaration at line 177 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFCmpOLT

Calls: cmsxi::Context::CreateLess

CreateFDiv Member Function

void * cmsxbe::Emitter::CreateFDiv(void * left, void * right) override

Definition at line 800 of Emitter.cpp :
801 {
802 return context->CreateDiv(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
803 }

Declaration at line 164 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFDiv

Calls: cmsxi::Context::CreateDiv

CreateFMul Member Function

void * cmsxbe::Emitter::CreateFMul(void * left, void * right) override

Definition at line 785 of Emitter.cpp :
786 {
787 return context->CreateMul(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
788 }

Declaration at line 161 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFMul

Calls: cmsxi::Context::CreateMul

CreateFNeg Member Function

void * cmsxbe::Emitter::CreateFNeg(void * value) override

Definition at line 940 of Emitter.cpp
Declaration at line 192 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFNeg

Calls: cmsxi::Context::CreateMul , cmsxi::Context::GetDoubleValue , cmsxi::Context::GetFloatValue , cmsxi::Type::Id , cmsxi::Value::GetType

CreateFPExt Member Function

void * cmsxbe::Emitter::CreateFPExt(void * operand, void * destinationType) override

Definition at line 880 of Emitter.cpp :
881 {
882 return operand;
883 }

Declaration at line 180 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFPExt

CreateFPToSI Member Function

void * cmsxbe::Emitter::CreateFPToSI(void * operand, void * destinationType) override

Definition at line 915 of Emitter.cpp :
916 {
917 return context->CreateFloatToInt(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
918 }

Declaration at line 187 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFPToSI

Calls: cmsxi::Context::CreateFloatToInt

CreateFPToUI Member Function

void * cmsxbe::Emitter::CreateFPToUI(void * operand, void * destinationType) override

Definition at line 910 of Emitter.cpp :
911 {
912 return context->CreateFloatToInt(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
913 }

Declaration at line 186 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFPToUI

Calls: cmsxi::Context::CreateFloatToInt

CreateFPTrunc Member Function

void * cmsxbe::Emitter::CreateFPTrunc(void * operand, void * destinationType) override

Definition at line 890 of Emitter.cpp :
891 {
892 return context->CreateBitCast(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
893 }

Declaration at line 182 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFPTrunc

Calls: cmsxi::Context::CreateBitCast

CreateFSub Member Function

void * cmsxbe::Emitter::CreateFSub(void * left, void * right) override

Definition at line 775 of Emitter.cpp :
776 {
777 return context->CreateSub(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
778 }

Declaration at line 159 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFSub

Calls: cmsxi::Context::CreateSub

CreateFwdIrTypeForClassType Member Function

void * cmsxbe::Emitter::CreateFwdIrTypeForClassType() override

Definition at line 147 of Emitter.cpp :
148 {
149 return context->CreateStructureType();
150 }

Declaration at line 47 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateFwdIrTypeForClassType

Calls: cmsxi::Context::CreateStructureType

CreateGlobalStringPtr Member Function

void * cmsxbe::Emitter::CreateGlobalStringPtr(const std::string& stringValue) override

Definition at line 427 of Emitter.cpp :
428 {
429 return context->CreateGlobalStringPtr(stringValue);
430 }

Declaration at line 95 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateGlobalStringPtr

Calls: cmsxi::Context::CreateGlobalStringPtr

CreateGlobalUStringPtr Member Function

void * cmsxbe::Emitter::CreateGlobalUStringPtr(const std::u32string& stringValue) override

Definition at line 437 of Emitter.cpp :
438 {
439 return nullptr;
440 }

Declaration at line 97 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateGlobalUStringPtr

CreateGlobalWStringPtr Member Function

void * cmsxbe::Emitter::CreateGlobalWStringPtr(const std::u16string& stringValue) override

Definition at line 432 of Emitter.cpp :
433 {
434 return nullptr;
435 }

Declaration at line 96 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateGlobalWStringPtr

CreateICmpEQ Member Function

void * cmsxbe::Emitter::CreateICmpEQ(void * left, void * right) override

Definition at line 845 of Emitter.cpp :
846 {
847 return context->CreateEqual(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
848 }

Declaration at line 173 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateICmpEQ

Calls: cmsxi::Context::CreateEqual

CreateICmpSLT Member Function

void * cmsxbe::Emitter::CreateICmpSLT(void * left, void * right) override

Definition at line 860 of Emitter.cpp :
861 {
862 return context->CreateLess(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
863 }

Declaration at line 176 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateICmpSLT

Calls: cmsxi::Context::CreateLess

CreateICmpULT Member Function

void * cmsxbe::Emitter::CreateICmpULT(void * left, void * right) override

Definition at line 855 of Emitter.cpp :
856 {
857 return context->CreateLess(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
858 }

Declaration at line 175 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateICmpULT

Calls: cmsxi::Context::CreateLess

CreateIncludeBasicBlockInstruction Member Function

void * cmsxbe::Emitter::CreateIncludeBasicBlockInstruction(void * basicBlock) override

Definition at line 699 of Emitter.cpp :
700 {
701 return nullptr;
702 }

Declaration at line 143 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIncludeBasicBlockInstruction

CreateInsertValue Member Function

void * cmsxbe::Emitter::CreateInsertValue(void * aggregate, void * value, const std::vector<unsigned int >& indeces) override

Definition at line 1909 of Emitter.cpp :
1910 {
1911 return nullptr;
1912 }

Declaration at line 357 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateInsertValue

CreateIntToPtr Member Function

void * cmsxbe::Emitter::CreateIntToPtr(void * intValue, void * destinationType) override

Definition at line 920 of Emitter.cpp :
921 {
922 return context->CreateIntToPtr(static_cast<cmsxi::Value*>(intValue), static_cast<cmsxi::Type*>(destinationType));
923 }

Declaration at line 188 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIntToPtr

Calls: cmsxi::Context::CreateIntToPtr

CreateInvoke Member Function

void * cmsxbe::Emitter::CreateInvoke(void * callee, void * normalBlock, void * unwindBlock, const std::vector<void *>& args) override

Definition at line 1227 of Emitter.cpp
Declaration at line 236 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateInvoke

Calls: cmajor::ir::EmittingDelegate::CurrentTryBlockId , cmajor::ir::EmittingDelegate::InTryBlock , cmsxbe::Emitter::AddMDItem , cmsxbe::Emitter::CleanupBlock , cmsxbe::Emitter::CreateCall , cmsxbe::Emitter::CreateMDBasicBlockRef , cmsxbe::Emitter::CreateMDLong , cmsxbe::Emitter::CreateMDStruct , cmsxbe::Emitter::CreateMDStructRef , cmsxbe::Emitter::CreateNop , cmsxbe::Emitter::GetMDStructId , cmsxbe::Emitter::SetMetadataRef

Called by: cmsxbe::Emitter::CreateInvokeInst

CreateInvokeInst Member Function

void * cmsxbe::Emitter::CreateInvokeInst(void * callee, void * normalBlock, void * unwindBlock, const std::vector<void >& args, const std::vector<void >& bundles, const Span& span) override

Definition at line 1258 of Emitter.cpp :
1259 {
1260 return CreateInvoke(callee, normalBlock, unwindBlock, args);
1261 }

Declaration at line 237 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateInvokeInst

Calls: cmsxbe::Emitter::CreateInvoke

CreateIrDIForwardDeclaration Member Function

void * cmsxbe::Emitter::CreateIrDIForwardDeclaration(void * irType, const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId) override

Definition at line 571 of Emitter.cpp :
572 {
574 return nullptr;
575 }

Declaration at line 121 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrDIForwardDeclaration

CreateIrValueForBool Member Function

void * cmsxbe::Emitter::CreateIrValueForBool(bool value) override

Definition at line 315 of Emitter.cpp :
316 {
317 return context->GetBoolValue(value);
318 }

Declaration at line 75 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForBool

Calls: cmsxi::Context::GetBoolValue

CreateIrValueForByte Member Function

void * cmsxbe::Emitter::CreateIrValueForByte(uint8_t value) override

Definition at line 325 of Emitter.cpp :
326 {
327 return context->GetByteValue(value);
328 }

Declaration at line 77 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForByte

Calls: cmsxi::Context::GetByteValue

CreateIrValueForChar Member Function

void * cmsxbe::Emitter::CreateIrValueForChar(uint8_t value) override

Definition at line 371 of Emitter.cpp :
372 {
373 return context->GetByteValue(value);
374 }

Declaration at line 86 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForChar

Calls: cmsxi::Context::GetByteValue

CreateIrValueForConstantArray Member Function

void * cmsxbe::Emitter::CreateIrValueForConstantArray(void * arrayIrType, const std::vector<void *>& elementConstants, const std::string& prefix) override

Definition at line 396 of Emitter.cpp :
397 {
398     std::vector<cmsxi::ConstantValue*> elements;
399     for (void* elementConstant : elementConstants)
400     {
401         elements.push_back(static_cast<cmsxi::ConstantValue*>(elementConstant));
402     }
403     return context->GetArrayValue(static_cast<cmsxi::ArrayType*>(arrayIrType), elements, prefix);
404 }

Declaration at line 91 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForConstantArray

Calls: cmsxi::Context::GetArrayValue

CreateIrValueForConstantStruct Member Function

void * cmsxbe::Emitter::CreateIrValueForConstantStruct(void * structIrType, const std::vector<void *>& elementConstants) override

Definition at line 406 of Emitter.cpp :
407 {
408     std::vector<cmsxi::ConstantValue*> memberConstants;
409     for (void* elementConstant : elementConstants)
410     {
411         memberConstants.push_back(static_cast<cmsxi::ConstantValue*>(elementConstant));
412     }
413     return context->GetStructureValue(static_cast<cmsxi::StructureType*>(structIrType), memberConstants);
414 }

Declaration at line 92 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForConstantStruct

Calls: cmsxi::Context::GetStructureValue

CreateIrValueForDouble Member Function

void * cmsxbe::Emitter::CreateIrValueForDouble(double value) override

Definition at line 366 of Emitter.cpp :
367 {
368 return context->GetDoubleValue(value);
369 }

Declaration at line 85 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForDouble

Calls: cmsxi::Context::GetDoubleValue

CreateIrValueForFloat Member Function

void * cmsxbe::Emitter::CreateIrValueForFloat(float value) override

Definition at line 360 of Emitter.cpp :
361 {
362 return context->GetDoubleValue(value);
364 }

Declaration at line 84 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForFloat

Calls: cmsxi::Context::GetDoubleValue

CreateIrValueForInt Member Function

void * cmsxbe::Emitter::CreateIrValueForInt(int32_t value) override

Definition at line 340 of Emitter.cpp :
341 {
342 return context->GetIntValue(value);
343 }

Declaration at line 80 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForInt

Calls: cmsxi::Context::GetIntValue

CreateIrValueForLong Member Function

void * cmsxbe::Emitter::CreateIrValueForLong(int64_t value) override

Definition at line 350 of Emitter.cpp :
351 {
352 return context->GetLongValue(value);
353 }

Declaration at line 82 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForLong

Calls: cmsxi::Context::GetLongValue

CreateIrValueForSByte Member Function

void * cmsxbe::Emitter::CreateIrValueForSByte(int8_t value) override

Definition at line 320 of Emitter.cpp :
321 {
322 return context->GetSByteValue(value);
323 }

Declaration at line 76 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForSByte

Calls: cmsxi::Context::GetSByteValue

CreateIrValueForShort Member Function

void * cmsxbe::Emitter::CreateIrValueForShort(int16_t value) override

Definition at line 330 of Emitter.cpp :
331 {
332 return context->GetShortValue(value);
333 }

Declaration at line 78 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForShort

Calls: cmsxi::Context::GetShortValue

CreateIrValueForUChar Member Function

void * cmsxbe::Emitter::CreateIrValueForUChar(uint32_t value) override

Definition at line 381 of Emitter.cpp :
382 {
383 return context->GetUIntValue(value);
384 }

Declaration at line 88 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForUChar

Calls: cmsxi::Context::GetUIntValue

CreateIrValueForUInt Member Function

void * cmsxbe::Emitter::CreateIrValueForUInt(uint32_t value) override

Definition at line 345 of Emitter.cpp :
346 {
347 return context->GetUIntValue(value);
348 }

Declaration at line 81 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForUInt

Calls: cmsxi::Context::GetUIntValue

CreateIrValueForULong Member Function

void * cmsxbe::Emitter::CreateIrValueForULong(uint64_t value) override

Definition at line 355 of Emitter.cpp :
356 {
357 return context->GetULongValue(value);
358 }

Declaration at line 83 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForULong

Calls: cmsxi::Context::GetULongValue

CreateIrValueForUShort Member Function

void * cmsxbe::Emitter::CreateIrValueForUShort(uint16_t value) override

Definition at line 335 of Emitter.cpp :
336 {
337 return context->GetUShortValue(value);
338 }

Declaration at line 79 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForUShort

Calls: cmsxi::Context::GetUShortValue

CreateIrValueForUString Member Function

void * cmsxbe::Emitter::CreateIrValueForUString(void * ustringConstant) override

Definition at line 391 of Emitter.cpp :
392 {
393 return static_cast<cmsxi::Value*>(ustringConstant);
394 }

Declaration at line 90 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForUString

CreateIrValueForUuid Member Function

void * cmsxbe::Emitter::CreateIrValueForUuid(void * uuidConstant) override

Definition at line 416 of Emitter.cpp :
417 {
418 cmsxi::Value* arg = context->CreatePtrOffset(static_cast<cmsxi::Value*>(uuidConstant), context->GetLongValue(0));
419 return context->CreateBitCast(arg, context->GetPtrType(context->GetVoidType()));
420 }

Declaration at line 93 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForUuid

Calls: cmsxi::Context::CreateBitCast , cmsxi::Context::CreatePtrOffset , cmsxi::Context::GetLongValue , cmsxi::Context::GetPtrType , cmsxi::Context::GetVoidType

CreateIrValueForWChar Member Function

void * cmsxbe::Emitter::CreateIrValueForWChar(uint16_t value) override

Definition at line 376 of Emitter.cpp :
377 {
378 return context->GetUShortValue(value);
379 }

Declaration at line 87 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForWChar

Calls: cmsxi::Context::GetUShortValue

CreateIrValueForWString Member Function

void * cmsxbe::Emitter::CreateIrValueForWString(void * wstringConstant) override

Definition at line 386 of Emitter.cpp :
387 {
388 return static_cast<cmsxi::Value*>(wstringConstant);
389 }

Declaration at line 89 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateIrValueForWString

CreateLShr Member Function

void * cmsxbe::Emitter::CreateLShr(void * left, void * right) override

Definition at line 840 of Emitter.cpp :
841 {
842 return context->CreateShr(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
843 }

Declaration at line 172 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateLShr

Calls: cmsxi::Context::CreateShr

CreateLValueRefDIType Member Function

void * cmsxbe::Emitter::CreateLValueRefDIType(void * diType) override

Definition at line 629 of Emitter.cpp :
630 {
632 return nullptr;
633 }

Declaration at line 132 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateLValueRefDIType

CreateLandingPad Member Function

void * cmsxbe::Emitter::CreateLandingPad(void * lpType) override

Definition at line 1887 of Emitter.cpp :
1888 {
1889 return nullptr;
1890 }

Declaration at line 352 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateLandingPad

CreateLexicalBlock Member Function

void * cmsxbe::Emitter::CreateLexicalBlock(const Span& span, const boost::uuids::uuid& moduleId) override

Definition at line 1770 of Emitter.cpp :
1771 {
1773 return nullptr;
1774 }

Declaration at line 330 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateLexicalBlock

CreateLoad Member Function

void * cmsxbe::Emitter::CreateLoad(void * ptr) override

Definition at line 755 of Emitter.cpp :
756 {
757 return context->CreateLoad(static_cast<cmsxi::Value*>(ptr));
758 }

Declaration at line 155 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateLoad

Calls: cmsxi::Context::CreateLoad

CreateMDBasicBlockRef Member Function

void * cmsxbe::Emitter::CreateMDBasicBlockRef(void * bb) override

Definition at line 1837 of Emitter.cpp :
1838 {
1839 return context->CreateMDBasicBlockRef(bb);
1840 }

Declaration at line 342 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateMDBasicBlockRef

Calls: cmsxi::Context::CreateMDBasicBlockRef

Called by: cmsxbe::Emitter::CreateInvoke

CreateMDBool Member Function

void * cmsxbe::Emitter::CreateMDBool(bool value) override

Definition at line 1807 of Emitter.cpp :
1808 {
1809 return context->CreateMDBool(value);
1810 }

Declaration at line 336 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateMDBool

Calls: cmsxi::Context::CreateMDBool

CreateMDLong Member Function

void * cmsxbe::Emitter::CreateMDLong(int64_t value) override

Definition at line 1812 of Emitter.cpp :
1813 {
1814 return context->CreateMDLong(value);
1815 }

Declaration at line 337 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateMDLong

Calls: cmsxi::Context::CreateMDLong

Called by: cmsxbe::Emitter::CreateInvoke

CreateMDString Member Function

void * cmsxbe::Emitter::CreateMDString(const std::string& value) override

Definition at line 1817 of Emitter.cpp :
1818 {
1819 return context->CreateMDString(value);
1820 }

Declaration at line 338 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateMDString

Calls: cmsxi::Context::CreateMDString

CreateMDStruct Member Function

void * cmsxbe::Emitter::CreateMDStruct() override

Definition at line 1832 of Emitter.cpp :
1833 {
1834 return context->CreateMDStruct();
1835 }

Declaration at line 341 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateMDStruct

Calls: cmsxi::Context::CreateMDStruct

Called by: cmsxbe::Emitter::CreateInvoke

CreateMDStructRef Member Function

void * cmsxbe::Emitter::CreateMDStructRef(int id) override

Definition at line 1822 of Emitter.cpp :
1823 {
1824 return context->CreateMDStructRef(id);
1825 }

Declaration at line 339 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateMDStructRef

Calls: cmsxi::Context::CreateMDStructRef

Called by: cmsxbe::Emitter::CreateInvoke

CreateModule Member Function

void * cmsxbe::Emitter::CreateModule(const std::string& moduleName) override

Definition at line 1458 of Emitter.cpp :
1459 {
1460 return new cmsxi::CompileUnit(moduleName);
1461 }

Declaration at line 268 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateModule

CreateMul Member Function

void * cmsxbe::Emitter::CreateMul(void * left, void * right) override

Definition at line 780 of Emitter.cpp :
781 {
782 return context->CreateMul(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
783 }

Declaration at line 160 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateMul

Calls: cmsxi::Context::CreateMul

CreateNeg Member Function

void * cmsxbe::Emitter::CreateNeg(void * value) override

Definition at line 935 of Emitter.cpp :
936 {
937 return context->CreateNeg(static_cast<cmsxi::Value*>(value));
938 }

Declaration at line 191 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateNeg

Calls: cmsxi::Context::CreateNeg

CreateNop Member Function

void * cmsxbe::Emitter::CreateNop() override

Definition at line 959 of Emitter.cpp :
960 {
961 return context->CreateNop();
962 }

Declaration at line 193 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateNop

Calls: cmsxi::Context::CreateNop

Called by: cmsxbe::Emitter::CreateInvoke

CreateNot Member Function

void * cmsxbe::Emitter::CreateNot(void * value) override

Definition at line 930 of Emitter.cpp :
931 {
932 return context->CreateNot(static_cast<cmsxi::Value*>(value));
933 }

Declaration at line 190 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateNot

Calls: cmsxi::Context::CreateNot

CreateOr Member Function

void * cmsxbe::Emitter::CreateOr(void * left, void * right) override

Definition at line 820 of Emitter.cpp :
821 {
822 return context->CreateOr(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
823 }

Declaration at line 168 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateOr

Calls: cmsxi::Context::CreateOr

CreatePointerDIType Member Function

void * cmsxbe::Emitter::CreatePointerDIType(void * diType) override

Definition at line 641 of Emitter.cpp :
642 {
644 return nullptr;
645 }

Declaration at line 134 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreatePointerDIType

CreatePtrDiff Member Function

void * cmsxbe::Emitter::CreatePtrDiff(void * left, void * right) override

Definition at line 1429 of Emitter.cpp :
1430 {
1431 return context->CreatePtrDiff(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
1432 }

Declaration at line 263 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreatePtrDiff

Calls: cmsxi::Context::CreatePtrDiff

CreatePtrToInt Member Function

void * cmsxbe::Emitter::CreatePtrToInt(void * ptrValue, void * destinationType) override

Definition at line 925 of Emitter.cpp :
926 {
927 return context->CreatePtrToInt(static_cast<cmsxi::Value*>(ptrValue), static_cast<cmsxi::Type*>(destinationType));
928 }

Declaration at line 189 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreatePtrToInt

Calls: cmsxi::Context::CreatePtrToInt

CreateRValueRefDIType Member Function

void * cmsxbe::Emitter::CreateRValueRefDIType(void * diType) override

Definition at line 635 of Emitter.cpp :
636 {
638 return nullptr;
639 }

Declaration at line 133 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateRValueRefDIType

CreateResume Member Function

void cmsxbe::Emitter::CreateResume(void * exception) override

Definition at line 1919 of Emitter.cpp :
1920 {
1921 }

Declaration at line 359 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateResume

CreateRet Member Function

void * cmsxbe::Emitter::CreateRet(void * value) override

Definition at line 1745 of Emitter.cpp :
1746 {
1747 return context->CreateRet(static_cast<cmsxi::Value*>(value));
1748 }

Declaration at line 325 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateRet

Calls: cmsxi::Context::CreateRet

CreateRetVoid Member Function

void * cmsxbe::Emitter::CreateRetVoid() override

Definition at line 1750 of Emitter.cpp :
1751 {
1752 return context->CreateRet(nullptr);
1753 }

Declaration at line 326 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateRetVoid

Calls: cmsxi::Context::CreateRet

CreateSDiv Member Function

void * cmsxbe::Emitter::CreateSDiv(void * left, void * right) override

Definition at line 795 of Emitter.cpp :
796 {
797 return context->CreateDiv(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
798 }

Declaration at line 163 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSDiv

Calls: cmsxi::Context::CreateDiv

CreateSExt Member Function

void * cmsxbe::Emitter::CreateSExt(void * operand, void * destinationType) override

Definition at line 870 of Emitter.cpp :
871 {
872 return context->CreateSignExtend(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
873 }

Declaration at line 178 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSExt

Calls: cmsxi::Context::CreateSignExtend

CreateSIToFP Member Function

void * cmsxbe::Emitter::CreateSIToFP(void * operand, void * destinationType) override

Definition at line 905 of Emitter.cpp :
906 {
907 return context->CreateIntToFloat(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
908 }

Declaration at line 185 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSIToFP

Calls: cmsxi::Context::CreateIntToFloat

CreateSRem Member Function

void * cmsxbe::Emitter::CreateSRem(void * left, void * right) override

Definition at line 810 of Emitter.cpp :
811 {
812 return context->CreateMod(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
813 }

Declaration at line 166 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSRem

Calls: cmsxi::Context::CreateMod

CreateSave Member Function

void * cmsxbe::Emitter::CreateSave() override

Definition at line 964 of Emitter.cpp :
965 {
966 return context->CreateSave();
967 }

Declaration at line 194 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSave

Calls: cmsxi::Context::CreateSave

CreateShl Member Function

void * cmsxbe::Emitter::CreateShl(void * left, void * right) override

Definition at line 830 of Emitter.cpp :
831 {
832 return context->CreateShl(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
833 }

Declaration at line 170 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateShl

Calls: cmsxi::Context::CreateShl

CreateStore Member Function

void cmsxbe::Emitter::CreateStore(void * value, void * ptr) override

Definition at line 750 of Emitter.cpp :
751 {
752 context->CreateStore(static_cast<cmsxi::Value*>(value), static_cast<cmsxi::Value*>(ptr));
753 }

Declaration at line 154 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateStore

Calls: cmsxi::Context::CreateStore

CreateSub Member Function

void * cmsxbe::Emitter::CreateSub(void * left, void * right) override

Definition at line 770 of Emitter.cpp :
771 {
772 return context->CreateSub(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
773 }

Declaration at line 158 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSub

Calls: cmsxi::Context::CreateSub

CreateSubroutineType Member Function

void * cmsxbe::Emitter::CreateSubroutineType(const std::vector<void *>& elementTypes) override

Definition at line 1676 of Emitter.cpp :
1677 {
1679 return nullptr;
1680 }

Declaration at line 312 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSubroutineType

CreateSwitch Member Function

void * cmsxbe::Emitter::CreateSwitch(void * condition, void * defaultDest, unsigned numCases) override

Definition at line 1776 of Emitter.cpp :
1777 {
1778 return context->CreateSwitch(static_cast<cmsxi::Value*>(condition), static_cast<cmsxi::BasicBlock*>(defaultDest));
1779 }

Declaration at line 331 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateSwitch

Calls: cmsxi::Context::CreateSwitch

CreateTrunc Member Function

void * cmsxbe::Emitter::CreateTrunc(void * operand, void * destinationType) override

Definition at line 885 of Emitter.cpp :
886 {
887 return context->CreateTruncate(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
888 }

Declaration at line 181 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateTrunc

Calls: cmsxi::Context::CreateTruncate

CreateUDiv Member Function

void * cmsxbe::Emitter::CreateUDiv(void * left, void * right) override

Definition at line 790 of Emitter.cpp :
791 {
792 return context->CreateDiv(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
793 }

Declaration at line 162 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateUDiv

Calls: cmsxi::Context::CreateDiv

CreateUIToFP Member Function

void * cmsxbe::Emitter::CreateUIToFP(void * operand, void * destinationType) override

Definition at line 900 of Emitter.cpp :
901 {
902 return context->CreateIntToFloat(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
903 }

Declaration at line 184 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateUIToFP

Calls: cmsxi::Context::CreateIntToFloat

CreateURem Member Function

void * cmsxbe::Emitter::CreateURem(void * left, void * right) override

Definition at line 805 of Emitter.cpp :
806 {
807 return context->CreateMod(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
808 }

Declaration at line 165 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateURem

Calls: cmsxi::Context::CreateMod

CreateUndefValue Member Function

void * cmsxbe::Emitter::CreateUndefValue(void * type) override

Definition at line 1914 of Emitter.cpp :
1915 {
1916 return nullptr;
1917 }

Declaration at line 358 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateUndefValue

CreateUnspecifiedDIType Member Function

void * cmsxbe::Emitter::CreateUnspecifiedDIType(const std::string& name) override

Definition at line 647 of Emitter.cpp :
648 {
650 return nullptr;
651 }

Declaration at line 135 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateUnspecifiedDIType

CreateXor Member Function

void * cmsxbe::Emitter::CreateXor(void * left, void * right) override

Definition at line 825 of Emitter.cpp :
826 {
827 return context->CreateXor(static_cast<cmsxi::Value*>(left), static_cast<cmsxi::Value*>(right));
828 }

Declaration at line 169 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateXor

Calls: cmsxi::Context::CreateXor

CreateZExt Member Function

void * cmsxbe::Emitter::CreateZExt(void * operand, void * destinationType) override

Definition at line 875 of Emitter.cpp :
876 {
877 return context->CreateZeroExtend(static_cast<cmsxi::Value*>(operand), static_cast<cmsxi::Type*>(destinationType));
878 }

Declaration at line 179 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CreateZExt

Calls: cmsxi::Context::CreateZeroExtend

CurrentBasicBlock Member Function

void * cmsxbe::Emitter::CurrentBasicBlock() const override

Definition at line 730 of Emitter.cpp :
731 {
732 return context->GetCurrentBasicBlock();
733 }

Declaration at line 150 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CurrentBasicBlock

Calls: cmsxi::Context::GetCurrentBasicBlock

CurrentPad Member Function

Pad * cmsxbe::Emitter::CurrentPad() override

Definition at line 1131 of Emitter.cpp :
1132 {
1134 return nullptr;
1135 }

Declaration at line 223 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CurrentPad

CurrentScope Member Function

void * cmsxbe::Emitter::CurrentScope() override

Definition at line 1581 of Emitter.cpp :
1582 {
1584 return nullptr;
1585 }

Declaration at line 292 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::CurrentScope

DIBuilder Member Function

void * cmsxbe::Emitter::DIBuilder() override

Definition at line 1263 of Emitter.cpp :
1264 {
1266 return nullptr;
1267 }

Declaration at line 238 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::DIBuilder

DebugPrintDebugInfo Member Function

void cmsxbe::Emitter::DebugPrintDebugInfo(const std::string& filePath) override

Definition at line 1923 of Emitter.cpp :
1924 {
1925 }

Declaration at line 360 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::DebugPrintDebugInfo

DestroyModule Member Function

void cmsxbe::Emitter::DestroyModule(void * module) override

Definition at line 1463 of Emitter.cpp :
1464 {
1465 delete static_cast<cmsxi::CompileUnit*>(module);
1466 }

Declaration at line 269 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::DestroyModule

Disassemble Member Function

void cmsxbe::Emitter::Disassemble(const std::string& bcFilePath, const std::string& filePath) override

Definition at line 1539 of Emitter.cpp :
1540 {
1542 }

Declaration at line 284 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::Disassemble

EmitIrFile Member Function

void cmsxbe::Emitter::EmitIrFile(const std::string& filePath) override

Definition at line 1529 of Emitter.cpp :
1530 {
1532 }

Declaration at line 282 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::EmitIrFile

EmitIrText Member Function

void cmsxbe::Emitter::EmitIrText(const std::string& filePath) override

Definition at line 1524 of Emitter.cpp :
1525 {
1527 }

Declaration at line 281 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::EmitIrText

EmitObjectCodeFile Member Function

void cmsxbe::Emitter::EmitObjectCodeFile(const std::string& objectFilePath) override

Definition at line 1554 of Emitter.cpp :
1555 {
1557 }

Declaration at line 287 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::EmitObjectCodeFile

EndDebugInfo Member Function

void cmsxbe::Emitter::EndDebugInfo() override

Definition at line 1519 of Emitter.cpp :
1520 {
1522 }

Declaration at line 280 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::EndDebugInfo

EndInstructionFlag Member Function

void cmsxbe::Emitter::EndInstructionFlag(int16_t flag) override

Definition at line 1667 of Emitter.cpp :
1668 {
1669 }

Declaration at line 310 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::EndInstructionFlag

EndScope Member Function

void cmsxbe::Emitter::EndScope() override

Definition at line 1633 of Emitter.cpp :
1634 {
1635 }

Declaration at line 302 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::EndScope

EndSubstituteLineNumber Member Function

void cmsxbe::Emitter::EndSubstituteLineNumber() override

Definition at line 1931 of Emitter.cpp :
1932 {
1933 }

Declaration at line 362 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::EndSubstituteLineNumber

FinalizeDebugInfo Member Function

void cmsxbe::Emitter::FinalizeDebugInfo() override

Definition at line 1514 of Emitter.cpp :
1515 {
1517 }

Declaration at line 279 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::FinalizeDebugInfo

FinalizeFunction Member Function

void cmsxbe::Emitter::FinalizeFunction(void * function, bool hasCleanup) override

Definition at line 1867 of Emitter.cpp :
1868 {
1869 static_cast<cmsxi::Function*>(function)->Finalize();
1870 }

Declaration at line 348 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::FinalizeFunction

GenerateTrap Member Function

void * cmsxbe::Emitter::GenerateTrap(const std::vector<void *>& args) override

Definition at line 1787 of Emitter.cpp :
1788 {
1789     std::vector<cmsxi::Value*> arguments;
1790     for (void* arg : args)
1791     {
1792         arguments.push_back(static_cast<cmsxi::Value*>(arg));
1793     }
1794     return context->CreateTrap(arguments);
1795 }

Declaration at line 333 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GenerateTrap

Calls: cmsxi::Context::CreateTrap

GetAlignmentInBits Member Function

uint64_t cmsxbe::Emitter::GetAlignmentInBits(void * irType) override

Definition at line 665 of Emitter.cpp :
666 {
668 return 0;
670 }

Declaration at line 138 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetAlignmentInBits

GetArrayBeginAddress Member Function

void * cmsxbe::Emitter::GetArrayBeginAddress(void * arrayPtr) override

Definition at line 677 of Emitter.cpp :
678 {
679 return context->CreateElemAddr(static_cast<cmsxi::Value*>(arrayPtr), context->GetLongValue(0));
680 }

Declaration at line 140 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetArrayBeginAddress

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::GetLongValue

GetArrayEndAddress Member Function

void * cmsxbe::Emitter::GetArrayEndAddress(void * arrayPtr, uint64_t size) override

Definition at line 682 of Emitter.cpp :
683 {
684 return context->CreateElemAddr(static_cast<cmsxi::Value*>(arrayPtr), context->GetLongValue(size));
685 }

Declaration at line 141 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetArrayEndAddress

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::GetLongValue

GetBasicBlockId Member Function

int cmsxbe::Emitter::GetBasicBlockId(void * basicBlock) override

Definition at line 720 of Emitter.cpp :
721 {
722 return static_cast<cmsxi::BasicBlock*>(basicBlock)->Id();
723 }

Declaration at line 148 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetBasicBlockId

GetBoundCompileUnit Member Function

void * cmsxbe::Emitter::GetBoundCompileUnit() const override

Definition at line 364 of Emitter.hpp :
364 { return nullptr; }

Base class overridden functions: cmajor::ir::Emitter::GetBoundCompileUnit

GetClassIdPtr Member Function

void * cmsxbe::Emitter::GetClassIdPtr(void * vmtPtr, int32_t classIdVmtIndexOffset) override

Definition at line 1409 of Emitter.cpp :
1410 {
1411 cmsxi::Value* classIdPtr = context->CreateElemAddr(static_cast<cmsxi::Value*>(vmtPtr), context->GetLongValue(0));
1412 return classIdPtr;
1413 }

Declaration at line 260 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetClassIdPtr

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::GetLongValue

GetClassName Member Function

void * cmsxbe::Emitter::GetClassName(void * vmtPtr, int32_t classNameVmtIndexOffset) override

Definition at line 1415 of Emitter.cpp :
1416 {
1417     cmsxi::Value* classNamePtrPtr = context->CreateElemAddr(static_cast<cmsxi::Value*>(vmtPtr), context->GetLongValue(classNameVmtIndexOffset));
1418     cmsxi::Value* classNamePtr = context->CreateLoad(classNamePtrPtr);
1419     cmsxi::Value* classNameCharPtr = context->CreateBitCast(classNamePtr, context->GetPtrType(context->GetPtrType(context->GetByteType())));
1420     cmsxi::Value* className = context->CreateLoad(classNameCharPtr);
1421     return className;
1422 }

Declaration at line 261 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetClassName

Calls: cmsxi::Context::CreateBitCast , cmsxi::Context::CreateElemAddr , cmsxi::Context::CreateLoad , cmsxi::Context::GetByteType , cmsxi::Context::GetLongValue , cmsxi::Context::GetPtrType

GetClassTypeAlignmentInBits Member Function

uint64_t cmsxbe::Emitter::GetClassTypeAlignmentInBits(void * classIrType) override

Definition at line 1593 of Emitter.cpp :
1594 {
1596 return uint64_t();
1597 }

Declaration at line 294 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetClassTypeAlignmentInBits

GetClassTypeSizeInBits Member Function

uint64_t cmsxbe::Emitter::GetClassTypeSizeInBits(void * classIrType) override

Definition at line 1587 of Emitter.cpp :
1588 {
1590 return uint64_t();
1591 }

Declaration at line 293 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetClassTypeSizeInBits

GetClsIdValue Member Function

void * cmsxbe::Emitter::GetClsIdValue(const std::string& typeId) override

Definition at line 1802 of Emitter.cpp :
1803 {
1804 return context->GetClsIdValue(typeId);
1805 }

Declaration at line 335 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetClsIdValue

Calls: cmsxi::Context::GetClsIdValue

GetConversionValue Member Function

void * cmsxbe::Emitter::GetConversionValue(void * type, void * from) override

Definition at line 422 of Emitter.cpp :
423 {
424 return context->GetConversionValue(static_cast<cmsxi::Type*>(type), static_cast<cmsxi::ConstantValue*>(from));
425 }

Declaration at line 94 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetConversionValue

Calls: cmsxi::Context::GetConversionValue

GetCurrentScopeId Member Function

int16_t cmsxbe::Emitter::GetCurrentScopeId() const override

Definition at line 1637 of Emitter.cpp :
1638 {
1639 return 0;
1640 }

Declaration at line 303 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetCurrentScopeId

GetDIMemberType Member Function

void * cmsxbe::Emitter::GetDIMemberType(const std::pair<boost::uuids::uuid, int32_t>& memberVariableId) override

Definition at line 606 of Emitter.cpp :
607 {
609 return nullptr;
610 }

Declaration at line 128 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetDIMemberType

GetDITypeByTypeId Member Function

void * cmsxbe::Emitter::GetDITypeByTypeId(const boost::uuids::uuid& typeId) const override

Definition at line 595 of Emitter.cpp :
596 {
598 return nullptr;
599 }

Declaration at line 126 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetDITypeByTypeId

GetDebugInfoForFile Member Function

void * cmsxbe::Emitter::GetDebugInfoForFile(const Span& span, const boost::uuids::uuid& moduleId) override

Definition at line 1565 of Emitter.cpp :
1566 {
1568 return nullptr;
1569 }

Declaration at line 289 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetDebugInfoForFile

GetDelegateFromClassDelegate Member Function

void * cmsxbe::Emitter::GetDelegateFromClassDelegate(void * classDelegatePtr) override

Definition at line 1279 of Emitter.cpp :
1280 {
1281 return context->CreateElemAddr(static_cast<cmsxi::Value*>(classDelegatePtr), context->GetLongValue(1));
1282 }

Declaration at line 241 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetDelegateFromClassDelegate

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::GetLongValue

GetEmittingContext Member Function

EmittingContext * cmsxbe::Emitter::GetEmittingContext() const

Definition at line 24 of Emitter.hpp :
24 { return emittingContext; }

GetFunctionArgument Member Function

void * cmsxbe::Emitter::GetFunctionArgument(void * function, int argumentIndex) override

Definition at line 1735 of Emitter.cpp :
1736 {
1737 return static_cast<cmsxi::Function*>(function)->GetParam(argumentIndex);
1738 }

Declaration at line 323 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetFunctionArgument

GetFunctionFlags Member Function

unsigned cmsxbe::Emitter::GetFunctionFlags(bool isStatic, unsigned accessFlags, bool isExplicit) override

Definition at line 1694 of Emitter.cpp :
1695 {
1697 return unsigned();
1698 }

Declaration at line 315 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetFunctionFlags

GetFunctionIrType Member Function

void * cmsxbe::Emitter::GetFunctionIrType(void * functionSymbol) const override

Definition at line 1310 of Emitter.cpp
Declaration at line 246 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetFunctionIrType

GetGlobalStringPtr Member Function

void * cmsxbe::Emitter::GetGlobalStringPtr(int stringId) override

Definition at line 442 of Emitter.cpp :
443 {
444 return emittingDelegate->GetGlobalStringPtr(stringId);
445 }

Declaration at line 98 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetGlobalStringPtr

Calls: cmajor::ir::EmittingDelegate::GetGlobalStringPtr

GetGlobalUStringConstant Member Function

void * cmsxbe::Emitter::GetGlobalUStringConstant(int stringId) override

Definition at line 452 of Emitter.cpp :
453 {
454 return emittingDelegate->GetGlobalUStringConstant(stringId);
455 }

Declaration at line 100 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetGlobalUStringConstant

Calls: cmajor::ir::EmittingDelegate::GetGlobalUStringConstant

GetGlobalUuidConstant Member Function

void * cmsxbe::Emitter::GetGlobalUuidConstant(int uuidId) override

Definition at line 457 of Emitter.cpp :
458 {
459 return emittingDelegate->GetGlobalUuidConstant(uuidId);
460 }

Declaration at line 101 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetGlobalUuidConstant

Calls: cmajor::ir::EmittingDelegate::GetGlobalUuidConstant

GetGlobalWStringConstant Member Function

void * cmsxbe::Emitter::GetGlobalWStringConstant(int stringId) override

Definition at line 447 of Emitter.cpp :
448 {
449 return emittingDelegate->GetGlobalWStringConstant(stringId);
450 }

Declaration at line 99 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetGlobalWStringConstant

Calls: cmajor::ir::EmittingDelegate::GetGlobalWStringConstant

GetImt Member Function

void * cmsxbe::Emitter::GetImt(void * imtArray, int32_t interfaceIndex) override

Definition at line 1348 of Emitter.cpp :
1349 {
1350 cmsxi::Value* imtArrayPtr = context->CreatePtrOffset(static_cast<cmsxi::Value*>(imtArray), context->GetLongValue(interfaceIndex));
1351 return context->CreateLoad(imtArrayPtr);
1352 }

Declaration at line 251 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetImt

Calls: cmsxi::Context::CreateLoad , cmsxi::Context::CreatePtrOffset , cmsxi::Context::GetLongValue

GetImtArray Member Function

void * cmsxbe::Emitter::GetImtArray(void * vmtObjectPtr, int32_t imtsVmtIndexOffset) override

Definition at line 1341 of Emitter.cpp :
1342 {
1343     cmsxi::Value* imtsArrayPtrPtr = context->CreateElemAddr(static_cast<cmsxi::Value*>(vmtObjectPtr), context->GetLongValue(imtsVmtIndexOffset));
1344     cmsxi::Value* imtsArrayPtr = context->CreateBitCast(imtsArrayPtrPtr, context->GetPtrType(context->GetPtrType(context->GetVoidType())));
1345     return context->CreateLoad(imtsArrayPtr);
1346 }

Declaration at line 250 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetImtArray

Calls: cmsxi::Context::CreateBitCast , cmsxi::Context::CreateElemAddr , cmsxi::Context::CreateLoad , cmsxi::Context::GetLongValue , cmsxi::Context::GetPtrType , cmsxi::Context::GetVoidType

GetImtArrayObjectName Member Function

std::string cmsxbe::Emitter::GetImtArrayObjectName(void * symbol) const override

Definition at line 1000 of Emitter.cpp :
1001 {
1003 return std::string();
1004 }

Declaration at line 201 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetImtArrayObjectName

GetImtPtrFromInterface Member Function

void * cmsxbe::Emitter::GetImtPtrFromInterface(void * interfaceTypePtr) override

Definition at line 1295 of Emitter.cpp :
1296 {
1297     cmsxi::Value* interfacePtrAddr = context->CreateElemAddr(static_cast<cmsxi::Value*>(interfaceTypePtr), context->GetLongValue(1));
1298     cmsxi::Value* interfacePtr = context->CreateLoad(interfacePtrAddr);
1299     return context->CreateBitCast(interfacePtr, context->GetPtrType(context->GetVoidType()));
1300 }

Declaration at line 244 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetImtPtrFromInterface

Calls: cmsxi::Context::CreateBitCast , cmsxi::Context::CreateElemAddr , cmsxi::Context::CreateLoad , cmsxi::Context::GetLongValue , cmsxi::Context::GetPtrType , cmsxi::Context::GetVoidType

GetInterfaceMethod Member Function

void * cmsxbe::Emitter::GetInterfaceMethod(void * imtPtr, int32_t methodIndex, void * interfaceMethodType) override

Definition at line 1302 of Emitter.cpp :
1303 {
1304     cmsxi::Value* methodPtrPtr = context->CreatePtrOffset(static_cast<cmsxi::Value*>(imtPtr), context->GetLongValue(methodIndex));
1305     cmsxi::Value* methodPtr = context->CreateLoad(methodPtrPtr);
1306     cmsxi::Value* callee = context->CreateBitCast(methodPtr, context->GetPtrType(static_cast<cmsxi::Type*>(interfaceMethodType)));
1307     return callee;
1308 }

Declaration at line 245 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetInterfaceMethod

Calls: cmsxi::Context::CreateBitCast , cmsxi::Context::CreateLoad , cmsxi::Context::CreatePtrOffset , cmsxi::Context::GetLongValue , cmsxi::Context::GetPtrType

GetIrObject Member Function

void * cmsxbe::Emitter::GetIrObject(void * symbol) const override

Definition at line 1354 of Emitter.cpp
Declaration at line 252 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrObject

GetIrTypeByTypeId Member Function

void * cmsxbe::Emitter::GetIrTypeByTypeId(const boost::uuids::uuid& typeId) override

Definition at line 114 of Emitter.cpp
Declaration at line 43 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeByTypeId

GetIrTypeForArrayType Member Function

void * cmsxbe::Emitter::GetIrTypeForArrayType(void * elementType, int64_t size) override

Definition at line 132 of Emitter.cpp :
133 {
134 return context->GetArrayType(static_cast<cmsxi::Type*>(elementType), size);
135 }

Declaration at line 45 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForArrayType

Calls: cmsxi::Context::GetArrayType

GetIrTypeForBool Member Function

void * cmsxbe::Emitter::GetIrTypeForBool() override

Definition at line 23 of Emitter.cpp :
  24 {
  25     return context->GetBoolType();
  26 }

Declaration at line 26 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForBool

Calls: cmsxi::Context::GetBoolType

GetIrTypeForByte Member Function

void * cmsxbe::Emitter::GetIrTypeForByte() override

Definition at line 33 of Emitter.cpp :
  34 {
  35     return context->GetByteType();
  36 }

Declaration at line 28 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForByte

Calls: cmsxi::Context::GetByteType

GetIrTypeForChar Member Function

void * cmsxbe::Emitter::GetIrTypeForChar() override

Definition at line 78 of Emitter.cpp :
  79 {
  80     return context->GetByteType();
  81 }

Declaration at line 37 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForChar

Calls: cmsxi::Context::GetByteType

GetIrTypeForClassType Member Function

void * cmsxbe::Emitter::GetIrTypeForClassType(const std::vector<void *>& elementTypes) override

Definition at line 137 of Emitter.cpp :
138 {
139     std::vector<cmsxi::Type*> memberTypes;
140     for (void* elementType : elementTypes)
141     {
142         memberTypes.push_back(static_cast<cmsxi::Type*>(elementType));
143     }
144     return context->GetStructureType(memberTypes);
145 }

Declaration at line 46 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForClassType

Calls: cmsxi::Context::GetStructureType

GetIrTypeForDelegateType Member Function

void * cmsxbe::Emitter::GetIrTypeForDelegateType(void * retType, const std::vector<void *>& paramTypes) override

Definition at line 163 of Emitter.cpp :
164 {
165     std::vector<cmsxi::Type*> parameterTypes;
166     for (void* paramType : paramTypes)
167     {
168         parameterTypes.push_back(static_cast<cmsxi::Type*>(paramType));
169     }
170     return context->GetPtrType(context->GetFunctionType(static_cast<cmsxi::Type*>(retType), parameterTypes));
171 }

Declaration at line 49 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForDelegateType

Calls: cmsxi::Context::GetFunctionType , cmsxi::Context::GetPtrType

GetIrTypeForDouble Member Function

void * cmsxbe::Emitter::GetIrTypeForDouble() override

Definition at line 73 of Emitter.cpp :
  74 {
  75     return context->GetDoubleType();
  76 }

Declaration at line 36 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForDouble

Calls: cmsxi::Context::GetDoubleType

GetIrTypeForFloat Member Function

void * cmsxbe::Emitter::GetIrTypeForFloat() override

Definition at line 68 of Emitter.cpp :
  69 {
  70     return context->GetFloatType();
  71 }

Declaration at line 35 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForFloat

Calls: cmsxi::Context::GetFloatType

GetIrTypeForFunction Member Function

void * cmsxbe::Emitter::GetIrTypeForFunction(void * retType, const std::vector<void *>& paramTypes) override

Definition at line 98 of Emitter.cpp :
  99 {
100     std::vector<cmsxi::Type*> parameterTypes;
101     for (void* paramType : paramTypes)
102     {
103         parameterTypes.push_back(static_cast<cmsxi::Type*>(paramType));
104     }
105     return context->GetFunctionType(static_cast<cmsxi::Type*>(retType), parameterTypes);
106 }

Declaration at line 41 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForFunction

Calls: cmsxi::Context::GetFunctionType

GetIrTypeForInt Member Function

void * cmsxbe::Emitter::GetIrTypeForInt() override

Definition at line 48 of Emitter.cpp :
  49 {
  50     return context->GetIntType();
  51 }

Declaration at line 31 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForInt

Calls: cmsxi::Context::GetIntType

GetIrTypeForLong Member Function

void * cmsxbe::Emitter::GetIrTypeForLong() override

Definition at line 58 of Emitter.cpp :
  59 {
  60     return context->GetLongType();
  61 }

Declaration at line 33 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForLong

Calls: cmsxi::Context::GetLongType

GetIrTypeForPtrType Member Function

void * cmsxbe::Emitter::GetIrTypeForPtrType(void * baseIrType) override

Definition at line 188 of Emitter.cpp :
189 {
190 return context->GetPtrType(static_cast<cmsxi::Type*>(baseIrType));
191 }

Declaration at line 52 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForPtrType

Calls: cmsxi::Context::GetPtrType

GetIrTypeForSByte Member Function

void * cmsxbe::Emitter::GetIrTypeForSByte() override

Definition at line 28 of Emitter.cpp :
  29 {
  30     return context->GetSByteType();
  31 }

Declaration at line 27 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForSByte

Calls: cmsxi::Context::GetSByteType

GetIrTypeForShort Member Function

void * cmsxbe::Emitter::GetIrTypeForShort() override

Definition at line 38 of Emitter.cpp :
  39 {
  40     return context->GetShortType();
  41 }

Declaration at line 29 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForShort

Calls: cmsxi::Context::GetShortType

GetIrTypeForStructType Member Function

void * cmsxbe::Emitter::GetIrTypeForStructType(const std::vector<void *>& elementTypes) override

Definition at line 178 of Emitter.cpp :
179 {
180     std::vector<cmsxi::Type*> memberTypes;
181     for (void* elementType : elementTypes)
182     {
183         memberTypes.push_back(static_cast<cmsxi::Type*>(elementType));
184     }
185     return context->GetStructureType(memberTypes);
186 }

Declaration at line 51 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForStructType

Calls: cmsxi::Context::GetStructureType

GetIrTypeForUChar Member Function

void * cmsxbe::Emitter::GetIrTypeForUChar() override

Definition at line 88 of Emitter.cpp :
  89 {
  90     return context->GetUIntType();
  91 }

Declaration at line 39 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForUChar

Calls: cmsxi::Context::GetUIntType

GetIrTypeForUInt Member Function

void * cmsxbe::Emitter::GetIrTypeForUInt() override

Definition at line 53 of Emitter.cpp :
  54 {
  55     return context->GetUIntType();
  56 }

Declaration at line 32 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForUInt

Calls: cmsxi::Context::GetUIntType

GetIrTypeForULong Member Function

void * cmsxbe::Emitter::GetIrTypeForULong() override

Definition at line 63 of Emitter.cpp :
  64 {
  65     return context->GetULongType();
  66 }

Declaration at line 34 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForULong

Calls: cmsxi::Context::GetULongType

GetIrTypeForUShort Member Function

void * cmsxbe::Emitter::GetIrTypeForUShort() override

Definition at line 43 of Emitter.cpp :
  44 {
  45     return context->GetUShortType();
  46 }

Declaration at line 30 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForUShort

Calls: cmsxi::Context::GetUShortType

GetIrTypeForVariableParamFunction Member Function

void * cmsxbe::Emitter::GetIrTypeForVariableParamFunction(void * retType) override

Definition at line 108 of Emitter.cpp :
109 {
111 return nullptr;
112 }

Declaration at line 42 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForVariableParamFunction

GetIrTypeForVoid Member Function

void * cmsxbe::Emitter::GetIrTypeForVoid() override

Definition at line 93 of Emitter.cpp :
  94 {
  95     return context->GetVoidType();
  96 }

Declaration at line 40 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForVoid

Calls: cmsxi::Context::GetVoidType

GetIrTypeForVoidPtrType Member Function

void * cmsxbe::Emitter::GetIrTypeForVoidPtrType() override

Definition at line 173 of Emitter.cpp :
174 {
175 return context->GetPtrType(context->GetVoidType());
176 }

Declaration at line 50 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForVoidPtrType

Calls: cmsxi::Context::GetPtrType , cmsxi::Context::GetVoidType

GetIrTypeForWChar Member Function

void * cmsxbe::Emitter::GetIrTypeForWChar() override

Definition at line 83 of Emitter.cpp :
  84 {
  85     return context->GetUShortType();
  86 }

Declaration at line 38 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeForWChar

Calls: cmsxi::Context::GetUShortType

GetIrTypeName Member Function

std::string cmsxbe::Emitter::GetIrTypeName(void * irType) override

Definition at line 193 of Emitter.cpp :
194 {
195 return std::string();
196 }

Declaration at line 53 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetIrTypeName

GetMDStructId Member Function

int cmsxbe::Emitter::GetMDStructId(void * mdStruct) override

Definition at line 1827 of Emitter.cpp :
1828 {
1829 return static_cast<cmsxi::MDStruct*>(mdStruct)->Id();
1830 }

Declaration at line 340 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetMDStructId

Called by: cmsxbe::Emitter::CreateInvoke

GetMDStructRefForSourceFile Member Function

void * cmsxbe::Emitter::GetMDStructRefForSourceFile(const std::string& sourceFileName) override

Definition at line 1857 of Emitter.cpp :
1858 {
1859 return context->GetMDStructRefForSourceFile(sourceFileName);
1860 }

Declaration at line 346 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetMDStructRefForSourceFile

Calls: cmsxi::Context::GetMDStructRefForSourceFile

GetMemberVariablePtr Member Function

void * cmsxbe::Emitter::GetMemberVariablePtr(void * classPtr, int32_t memberVariableLayoutIndex) override

Definition at line 1372 of Emitter.cpp :
1373 {
1374 cmsxi::Value* clsPtr = static_cast<cmsxi::Value*>(classPtr);
1375 return context->CreateElemAddr(clsPtr, context->GetLongValue(memberVariableLayoutIndex));
1376 }

Declaration at line 254 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetMemberVariablePtr

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::GetLongValue

GetMethodPtr Member Function

void * cmsxbe::Emitter::GetMethodPtr(void * vmtPtr, int32_t vmtIndex) override

Definition at line 1335 of Emitter.cpp :
1336 {
1337 cmsxi::Value* funPtrPtr = context->CreateElemAddr(static_cast<cmsxi::Value*>(vmtPtr), context->GetLongValue(vmtIndex));
1338 return context->CreateLoad(funPtrPtr);
1339 }

Declaration at line 249 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetMethodPtr

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::CreateLoad , cmsxi::Context::GetLongValue

GetNoFlags Member Function

uint32_t cmsxbe::Emitter::GetNoFlags() override

Definition at line 1452 of Emitter.cpp :
1453 {
1455 return uint32_t();
1456 }

Declaration at line 267 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetNoFlags

GetObjectFromClassDelegate Member Function

void * cmsxbe::Emitter::GetObjectFromClassDelegate(void * classDelegatePtr) override

Definition at line 1274 of Emitter.cpp :
1275 {
1276 return context->CreateElemAddr(static_cast<cmsxi::Value*>(classDelegatePtr), context->GetLongValue(0));
1277 }

Declaration at line 240 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetObjectFromClassDelegate

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::GetLongValue

GetObjectFromInterface Member Function

void * cmsxbe::Emitter::GetObjectFromInterface(void * interfaceTypePtr) override

Definition at line 1284 of Emitter.cpp :
1285 {
1286 cmsxi::Value* addr = context->CreateElemAddr(static_cast<cmsxi::Value*>(interfaceTypePtr), context->GetLongValue(0));
1287 return context->CreateLoad(addr);
1288 }

Declaration at line 242 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetObjectFromInterface

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::CreateLoad , cmsxi::Context::GetLongValue

GetObjectPointer Member Function

void * cmsxbe::Emitter::GetObjectPointer() override

Definition at line 1404 of Emitter.cpp :
1405 {
1406 return objectPointer;
1407 }

Declaration at line 259 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetObjectPointer

GetObjectPtrFromInterface Member Function

void * cmsxbe::Emitter::GetObjectPtrFromInterface(void * interfaceTypePtr) override

Definition at line 1290 of Emitter.cpp :
1291 {
1292 return context->CreateElemAddr(static_cast<cmsxi::Value*>(interfaceTypePtr), context->GetLongValue(0));
1293 }

Declaration at line 243 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetObjectPtrFromInterface

Calls: cmsxi::Context::CreateElemAddr , cmsxi::Context::GetLongValue

GetOffsetInBits Member Function

uint64_t cmsxbe::Emitter::GetOffsetInBits(void * classIrType, int layoutIndex) override

Definition at line 577 of Emitter.cpp :
578 {
580 return uint64_t();
581 }

Declaration at line 122 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetOffsetInBits

GetOrInsertAnyComdat Member Function

void * cmsxbe::Emitter::GetOrInsertAnyComdat(const std::string& name, void * global) override

Definition at line 1063 of Emitter.cpp :
1064 {
1065 static_cast<cmsxi::GlobalVariable*>(global)->SetLinkOnce();
1066 return nullptr;
1067 }

Declaration at line 210 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetOrInsertAnyComdat

GetOrInsertAnyFunctionComdat Member Function

void * cmsxbe::Emitter::GetOrInsertAnyFunctionComdat(const std::string& name, void * function) override

Definition at line 1069 of Emitter.cpp :
1070 {
1071 static_cast<cmsxi::Function*>(function)->SetLinkOnce();
1072 return nullptr;
1073 }

Declaration at line 211 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetOrInsertAnyFunctionComdat

GetOrInsertFunction Member Function

void * cmsxbe::Emitter::GetOrInsertFunction(const std::string& name, void * type, bool nothrow) override

Definition at line 1075 of Emitter.cpp :
1076 {
1077 return compileUnit->GetOrInsertFunction(name, static_cast<cmsxi::FunctionType*>(type));
1078 }

Declaration at line 212 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetOrInsertFunction

Calls: cmsxi::CompileUnit::GetOrInsertFunction

GetOrInsertGlobal Member Function

void * cmsxbe::Emitter::GetOrInsertGlobal(const std::string& name, void * type) override

Definition at line 1058 of Emitter.cpp :
1059 {
1060 return context->GetOrInsertGlobal(name, static_cast<cmsxi::Type*>(type));
1061 }

Declaration at line 209 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetOrInsertGlobal

Calls: cmsxi::Context::GetOrInsertGlobal

GetPrivateFlag Member Function

uint32_t cmsxbe::Emitter::GetPrivateFlag() override

Definition at line 1434 of Emitter.cpp :
1435 {
1437 return uint32_t();
1438 }

Declaration at line 264 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetPrivateFlag

GetProtectedFlag Member Function

uint32_t cmsxbe::Emitter::GetProtectedFlag() override

Definition at line 1440 of Emitter.cpp :
1441 {
1443 return uint32_t();
1444 }

Declaration at line 265 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetProtectedFlag

GetPublicFlag Member Function

uint32_t cmsxbe::Emitter::GetPublicFlag() override

Definition at line 1446 of Emitter.cpp :
1447 {
1449 return uint32_t();
1450 }

Declaration at line 266 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetPublicFlag

GetPureVirtualVirtuality Member Function

unsigned cmsxbe::Emitter::GetPureVirtualVirtuality() override

Definition at line 1682 of Emitter.cpp :
1683 {
1685 return unsigned();
1686 }

Declaration at line 313 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetPureVirtualVirtuality

GetSizeInBits Member Function

uint64_t cmsxbe::Emitter::GetSizeInBits(void * irType) override

Definition at line 658 of Emitter.cpp :
659 {
661 return 0;
663 }

Declaration at line 137 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetSizeInBits

GetStaticObjectName Member Function

std::string cmsxbe::Emitter::GetStaticObjectName(void * symbol) const override

Definition at line 1040 of Emitter.cpp
Declaration at line 207 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetStaticObjectName

GetStaticObjectType Member Function

void * cmsxbe::Emitter::GetStaticObjectType(void * symbol) const override

Definition at line 1022 of Emitter.cpp
Declaration at line 205 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetStaticObjectType

GetVirtualVirtuality Member Function

unsigned cmsxbe::Emitter::GetVirtualVirtuality() override

Definition at line 1688 of Emitter.cpp :
1689 {
1691 return unsigned();
1692 }

Declaration at line 314 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetVirtualVirtuality

GetVmtObjectName Member Function

std::string cmsxbe::Emitter::GetVmtObjectName(void * symbol) const override

Definition at line 989 of Emitter.cpp :
990 {
992 return std::string();
993 }

Declaration at line 199 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetVmtObjectName

GetVmtObjectType Member Function

void * cmsxbe::Emitter::GetVmtObjectType(void * symbol) const override

Definition at line 1011 of Emitter.cpp :
1012 {
1014 return nullptr;
1015 }

Declaration at line 203 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetVmtObjectType

GetVmtPtr Member Function

void * cmsxbe::Emitter::GetVmtPtr(void * thisPtr, int32_t vmtPtrIndex, void * vmtPtrType) override

Definition at line 1328 of Emitter.cpp :
1329 {
1330     cmsxi::Value* vmtPtrPtr = context->CreateElemAddr(static_cast<cmsxi::Value*>(thisPtr), context->GetLongValue(vmtPtrIndex));
1331     cmsxi::Value* vmtPtr = context->CreateLoad(vmtPtrPtr);
1332     return context->CreateBitCast(vmtPtr, static_cast<cmsxi::Type*>(vmtPtrType));
1333 }

Declaration at line 248 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::GetVmtPtr

Calls: cmsxi::Context::CreateBitCast , cmsxi::Context::CreateElemAddr , cmsxi::Context::CreateLoad , cmsxi::Context::GetLongValue

HandlerBlock Member Function

void * cmsxbe::Emitter::HandlerBlock() override

Definition at line 1111 of Emitter.cpp :
1112 {
1113 return emittingDelegate->HandlerBlock();
1114 }

Declaration at line 219 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::HandlerBlock

Calls: cmajor::ir::EmittingDelegate::HandlerBlock

Install Member Function

int cmsxbe::Emitter::Install(const std::string& str) override

Definition at line 1872 of Emitter.cpp :
1873 {
1874 return emittingDelegate->Install(str);
1875 }

Declaration at line 349 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::Install

Calls: cmajor::ir::EmittingDelegate::Install

Install Member Function

int cmsxbe::Emitter::Install(const std::u16string& str) override

Definition at line 1877 of Emitter.cpp :
1878 {
1879 return emittingDelegate->Install(str);
1880 }

Declaration at line 350 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::Install

Calls: cmajor::ir::EmittingDelegate::Install

Install Member Function

int cmsxbe::Emitter::Install(const std::u32string& str) override

Definition at line 1882 of Emitter.cpp :
1883 {
1884 return emittingDelegate->Install(str);
1885 }

Declaration at line 351 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::Install

Calls: cmajor::ir::EmittingDelegate::Install

IsStaticObjectCreated Member Function

bool cmsxbe::Emitter::IsStaticObjectCreated(void * symbol) const override

Definition at line 1101 of Emitter.cpp :
1102 {
1103 return staticObjectCreatedSet.find(symbol) != staticObjectCreatedSet.cend();
1104 }

Declaration at line 217 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::IsStaticObjectCreated

IsVmtObjectCreated Member Function

bool cmsxbe::Emitter::IsVmtObjectCreated(void * symbol) const override

Definition at line 1091 of Emitter.cpp :
1092 {
1093 return vmtObjectCreatedSet.find(symbol) != vmtObjectCreatedSet.cend();
1094 }

Declaration at line 215 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::IsVmtObjectCreated

MakeVmtVariableName Member Function

std::string cmsxbe::Emitter::MakeVmtVariableName(const std::string& vmtObjectName) override

Definition at line 198 of Emitter.cpp :
199 {
200 return std::string();
201 }

Declaration at line 54 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::MakeVmtVariableName

MapClassPtr Member Function

void cmsxbe::Emitter::MapClassPtr(const boost::uuids::uuid& typeId, void * classPtr, const std::string& className) override

Definition at line 653 of Emitter.cpp :
654 {
656 }

Declaration at line 136 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::MapClassPtr

MapFwdDeclaration Member Function

void cmsxbe::Emitter::MapFwdDeclaration(void * fwdDeclaration, const boost::uuids::uuid& typeId) override

Definition at line 590 of Emitter.cpp :
591 {
593 }

Declaration at line 125 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::MapFwdDeclaration

MoveAllocaIntoBasicBlock Member Function

void cmsxbe::Emitter::MoveAllocaIntoBasicBlock(void * allocaInst, void * lastAlloca, void * basicBlock) override

Definition at line 1896 of Emitter.cpp :
1897 {
1898 }

Declaration at line 354 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::MoveAllocaIntoBasicBlock

NewCleanupNeeded Member Function

bool cmsxbe::Emitter::NewCleanupNeeded() override

Definition at line 1121 of Emitter.cpp :
1122 {
1123 return emittingDelegate->NewCleanupNeeded();
1124 }

Declaration at line 221 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::NewCleanupNeeded

Calls: cmajor::ir::EmittingDelegate::NewCleanupNeeded

Optimize Member Function

void cmsxbe::Emitter::Optimize(const std::string& bcFilePath, const std::string& optBCFilePath, const std::string& optimizationFlags) override

Definition at line 1534 of Emitter.cpp :
1535 {
1537 }

Declaration at line 283 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::Optimize

PopParentBlock Member Function

void cmsxbe::Emitter::PopParentBlock() override

Definition at line 708 of Emitter.cpp :
709 {
710 }

Declaration at line 145 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::PopParentBlock

PopScope Member Function

void cmsxbe::Emitter::PopScope() override

Definition at line 1576 of Emitter.cpp :
1577 {
1579 }

Declaration at line 291 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::PopScope

PushParentBlock Member Function

void cmsxbe::Emitter::PushParentBlock() override

Definition at line 704 of Emitter.cpp :
705 {
706 }

Declaration at line 144 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::PushParentBlock

PushScope Member Function

void cmsxbe::Emitter::PushScope(void * scope) override

Definition at line 1571 of Emitter.cpp :
1572 {
1574 }

Declaration at line 290 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::PushScope

ResetCurrentDebugLocation Member Function

void cmsxbe::Emitter::ResetCurrentDebugLocation() override

Definition at line 1504 of Emitter.cpp :
1505 {
1507 }

Declaration at line 277 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::ResetCurrentDebugLocation

SaveObjectPointer Member Function

void cmsxbe::Emitter::SaveObjectPointer(void * objectPointer_) override

Definition at line 1391 of Emitter.cpp :
1392 {
1393     if (objectPointer == nullptr)
1394     {
1395         objectPointer = static_cast<cmsxi::Value*>(objectPointer_);
1396     }
1397 }

Declaration at line 257 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SaveObjectPointer

SetBoundCompileUnit Member Function

void cmsxbe::Emitter::SetBoundCompileUnit(void * boundCompileUnit_) override

Definition at line 363 of Emitter.hpp :
363 { }

Base class overridden functions: cmajor::ir::Emitter::SetBoundCompileUnit

SetCleanupBlock Member Function

void cmsxbe::Emitter::SetCleanupBlock(void * cleanupBlock) override

Definition at line 716 of Emitter.cpp :
717 {
718 }

Declaration at line 147 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCleanupBlock

SetColumnSpanProvider Member Function

void cmsxbe::Emitter::SetColumnSpanProvider(ColumnSpanProvider * columnSpanProvider_) override

Definition at line 1499 of Emitter.cpp :
1500 {
1502 }

Declaration at line 276 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetColumnSpanProvider

SetCompileUnitId Member Function

void cmsxbe::Emitter::SetCompileUnitId(const std::string& compileUnitId) override

Definition at line 1797 of Emitter.cpp :
1798 {
1799 context->SetCompileUnitId(compileUnitId);
1800 }

Declaration at line 334 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCompileUnitId

Calls: cmsxi::Context::SetCompileUnitId

SetCurrentBasicBlock Member Function

void cmsxbe::Emitter::SetCurrentBasicBlock(void * basicBlock) override

Definition at line 735 of Emitter.cpp :
736 {
737 context->SetCurrentBasicBlock(static_cast<cmsxi::BasicBlock*>(basicBlock));
738 }

Declaration at line 151 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCurrentBasicBlock

Calls: cmsxi::Context::SetCurrentBasicBlock

Called by: cmsxbe::Emitter::CreateCallInstToBasicBlock

SetCurrentControlFlowGraphNodeId Member Function

void cmsxbe::Emitter::SetCurrentControlFlowGraphNodeId(int32_t controlFlowGraphNodeId) override

Definition at line 1651 of Emitter.cpp :
1652 {
1653 }

Declaration at line 306 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCurrentControlFlowGraphNodeId

SetCurrentDIBuilder Member Function

void cmsxbe::Emitter::SetCurrentDIBuilder(void * diBuilder_) override

Definition at line 1269 of Emitter.cpp :
1270 {
1272 }

Declaration at line 239 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCurrentDIBuilder

SetCurrentDebugLocation Member Function

void cmsxbe::Emitter::SetCurrentDebugLocation(const Span& span) override

Definition at line 672 of Emitter.cpp :
673 {
675 }

Declaration at line 139 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCurrentDebugLocation

SetCurrentScopeId Member Function

void cmsxbe::Emitter::SetCurrentScopeId(int16_t scopeId) override

Definition at line 1642 of Emitter.cpp :
1643 {
1644 }

Declaration at line 304 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCurrentScopeId

SetCurrentSourceSpan Member Function

void cmsxbe::Emitter::SetCurrentSourceSpan(int32_t line, int16_t scol, int16_t ecol) override

Definition at line 1852 of Emitter.cpp :
1853 {
1854 context->SetCurrentLineNumber(line);
1855 }

Declaration at line 345 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetCurrentSourceSpan

Calls: cmsxi::Context::SetCurrentLineNumber

SetDICompileUnit Member Function

void cmsxbe::Emitter::SetDICompileUnit(void * diCompileUnit_) override

Definition at line 1489 of Emitter.cpp :
1490 {
1492 }

Declaration at line 274 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetDICompileUnit

SetDIFile Member Function

void cmsxbe::Emitter::SetDIFile(void * diFile_) override

Definition at line 1494 of Emitter.cpp :
1495 {
1497 }

Declaration at line 275 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetDIFile

SetDIMemberType Member Function

void cmsxbe::Emitter::SetDIMemberType(const std::pair<boost::uuids::uuid, int32_t>& memberVariableId, void * diType) override

Definition at line 612 of Emitter.cpp :
613 {
615 }

Declaration at line 129 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetDIMemberType

SetDISubprogram Member Function

void cmsxbe::Emitter::SetDISubprogram(void * function, void * subprogram) override

Definition at line 1713 of Emitter.cpp :
1714 {
1716 }

Declaration at line 319 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetDISubprogram

SetDITypeByTypeId Member Function

void cmsxbe::Emitter::SetDITypeByTypeId(const boost::uuids::uuid& typeId, void * diType, const std::string& typeName) override

Definition at line 601 of Emitter.cpp :
602 {
604 }

Declaration at line 127 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetDITypeByTypeId

SetDataLayout Member Function

void cmsxbe::Emitter::SetDataLayout(void * dataLayout_) override

Definition at line 1479 of Emitter.cpp :
1480 {
1482 }

Declaration at line 272 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetDataLayout

SetDebugLoc Member Function

void cmsxbe::Emitter::SetDebugLoc(void * callInst) override

Definition at line 1740 of Emitter.cpp :
1741 {
1743 }

Declaration at line 324 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetDebugLoc

SetEmittingDelegate Member Function

void cmsxbe::Emitter::SetEmittingDelegate(EmittingDelegate * emittingDelegate_) override

Definition at line 18 of Emitter.cpp :
  19 {
  20     emittingDelegate = emittingDelegate_;
  21 }

Declaration at line 25 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetEmittingDelegate

SetFunction Member Function

void cmsxbe::Emitter::SetFunction(void * function_, int32_t fileIndex, const boost::uuids::uuid& sourceModuleId, const boost::uuids::uuid& functionId) override

Definition at line 1620 of Emitter.cpp :
1621 {
1622 currentFunction = static_cast<cmsxi::Function*>(function_);
1623 }

Declaration at line 299 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFunction

SetFunctionCallConventionToStdCall Member Function

void cmsxbe::Emitter::SetFunctionCallConventionToStdCall(void * function) override

Definition at line 1615 of Emitter.cpp :
1616 {
1618 }

Declaration at line 298 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFunctionCallConventionToStdCall

SetFunctionIrType Member Function

void cmsxbe::Emitter::SetFunctionIrType(void * symbol, void * irType) override

Definition at line 1323 of Emitter.cpp :
1324 {
1325 functionIrTypeMap[symbol] = static_cast<cmsxi::FunctionType*>(irType);
1326 }

Declaration at line 247 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFunctionIrType

SetFunctionLinkage Member Function

void cmsxbe::Emitter::SetFunctionLinkage(void * function, bool setInline) override

Definition at line 1604 of Emitter.cpp :
1605 {
1607 }

Declaration at line 296 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFunctionLinkage

SetFunctionLinkageToLinkOnceODRLinkage Member Function

void cmsxbe::Emitter::SetFunctionLinkageToLinkOnceODRLinkage(void * function) override

Definition at line 1609 of Emitter.cpp :
1610 {
1613 }

Declaration at line 297 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFunctionLinkageToLinkOnceODRLinkage

SetFunctionMdId Member Function

void cmsxbe::Emitter::SetFunctionMdId(void * function, int mdId) override

Definition at line 1847 of Emitter.cpp :
1848 {
1849 static_cast<cmsxi::Function*>(function)->SetMdId(mdId);
1850 }

Declaration at line 344 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFunctionMdId

SetFunctionName Member Function

void cmsxbe::Emitter::SetFunctionName(const std::string& functionName) override

Definition at line 1625 of Emitter.cpp :
1626 {
1627 }

Declaration at line 300 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFunctionName

SetFwdIrTypeBody Member Function

void cmsxbe::Emitter::SetFwdIrTypeBody(void * forwardDeclaredType, const std::vector<void *>& elementTypes) override

Definition at line 152 of Emitter.cpp :
153 {
154     std::vector<cmsxi::Type*> memberTypes;
155     for (void* elementType : elementTypes)
156     {
157         memberTypes.push_back(static_cast<cmsxi::Type*>(elementType));
158     }
159     cmsxi::StructureType* structureType = static_cast<cmsxi::StructureType*>(forwardDeclaredType);
160     structureType->SetMemberTypes(memberTypes);
161 }

Declaration at line 48 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetFwdIrTypeBody

Calls: cmsxi::StructureType::SetMemberTypes

SetHandlerBlock Member Function

void cmsxbe::Emitter::SetHandlerBlock(void * tryBlock, void * catchBlock) override

Definition at line 712 of Emitter.cpp :
713 {
714 }

Declaration at line 146 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetHandlerBlock

SetImtArrayObjectName Member Function

void cmsxbe::Emitter::SetImtArrayObjectName(void * symbol, const std::string& imtArrayObjectName) override

Definition at line 1006 of Emitter.cpp :
1007 {
1009 }

Declaration at line 202 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetImtArrayObjectName

SetInPrologue Member Function

void cmsxbe::Emitter::SetInPrologue(bool inPrologue_) override

Definition at line 1671 of Emitter.cpp :
1672 {
1674 }

Declaration at line 311 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetInPrologue

SetInitializer Member Function

void cmsxbe::Emitter::SetInitializer(void * global, void * initializer) override

Definition at line 1080 of Emitter.cpp :
1081 {
1082 cmsxi::GlobalVariable* globalVar = static_cast<cmsxi::GlobalVariable*>(global);
1083 globalVar->SetInitializer(static_cast<cmsxi::ConstantValue*>(initializer));
1084 }

Declaration at line 213 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetInitializer

Calls: cmsxi::GlobalVariable::SetInitializer

SetIrObject Member Function

void cmsxbe::Emitter::SetIrObject(void * symbol, void * irObject) override

Definition at line 1367 of Emitter.cpp :
1368 {
1369 irObjectMap[symbol] = static_cast<cmsxi::Value*>(irObject);
1370 }

Declaration at line 253 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetIrObject

SetIrTypeByTypeId Member Function

void cmsxbe::Emitter::SetIrTypeByTypeId(const boost::uuids::uuid& typeId, void * irType) override

Definition at line 127 of Emitter.cpp :
128 {
129 irTypeTypeIdMap[typeId] = static_cast<cmsxi::Type*>(irType);
130 }

Declaration at line 44 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetIrTypeByTypeId

SetLandindPadAsCleanup Member Function

void cmsxbe::Emitter::SetLandindPadAsCleanup(void * landingPad) override

Definition at line 1892 of Emitter.cpp :
1893 {
1894 }

Declaration at line 353 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetLandindPadAsCleanup

SetLineNumber Member Function

void cmsxbe::Emitter::SetLineNumber(int32_t lineNumber) override

Definition at line 1386 of Emitter.cpp :
1387 {
1389 }

Declaration at line 256 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetLineNumber

SetMetadataRef Member Function

void cmsxbe::Emitter::SetMetadataRef(void * inst, void * mdStructRef) override

Definition at line 1862 of Emitter.cpp :
1863 {
1864 context->SetMetadataRef(static_cast<cmsxi::Instruction*>(inst), static_cast<cmsxi::MDStructRef*>(mdStructRef));
1865 }

Declaration at line 347 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetMetadataRef

Calls: cmsxi::Context::SetMetadataRef

Called by: cmsxbe::Emitter::CreateInvoke

SetModule Member Function

void cmsxbe::Emitter::SetModule(void * module_) override

Definition at line 1468 of Emitter.cpp :
1469 {
1470 compileUnit = static_cast<cmsxi::CompileUnit*>(module_);
1471 context = compileUnit->GetContext();
1472 }

Declaration at line 270 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetModule

Calls: cmsxi::CompileUnit::GetContext

SetObjectPointer Member Function

void cmsxbe::Emitter::SetObjectPointer(void * objectPointer_) override

Definition at line 1399 of Emitter.cpp :
1400 {
1401 objectPointer = static_cast<cmsxi::Value*>(objectPointer_);
1402 }

Declaration at line 258 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetObjectPointer

SetPersonalityFunction Member Function

void cmsxbe::Emitter::SetPersonalityFunction(void * function, void * personalityFunction) override

Definition at line 1755 of Emitter.cpp :
1756 {
1758 }

Declaration at line 327 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetPersonalityFunction

SetPrivateLinkage Member Function

void cmsxbe::Emitter::SetPrivateLinkage(void * global) override

Definition at line 1086 of Emitter.cpp :
1087 {
1089 }

Declaration at line 214 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetPrivateLinkage

SetSourceFileName Member Function

void cmsxbe::Emitter::SetSourceFileName(const std::string& sourceFileName) override

Definition at line 1484 of Emitter.cpp :
1485 {
1487 }

Declaration at line 273 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetSourceFileName

SetStaticObjectCreated Member Function

void cmsxbe::Emitter::SetStaticObjectCreated(void * symbol) override

Definition at line 1106 of Emitter.cpp :
1107 {
1108 staticObjectCreatedSet.insert(symbol);
1109 }

Declaration at line 218 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetStaticObjectCreated

SetStaticObjectName Member Function

void cmsxbe::Emitter::SetStaticObjectName(void * symbol, const std::string& staticObjectName) override

Definition at line 1053 of Emitter.cpp :
1054 {
1055 staticObjectNameMap[symbol] = staticObjectName;
1056 }

Declaration at line 208 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetStaticObjectName

SetStaticObjectType Member Function

void cmsxbe::Emitter::SetStaticObjectType(void * symbol, void * type) override

Definition at line 1035 of Emitter.cpp :
1036 {
1037 staticTypeMap[symbol] = static_cast<cmsxi::StructureType*>(type);
1038 }

Declaration at line 206 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetStaticObjectType

SetTargetTriple Member Function

void cmsxbe::Emitter::SetTargetTriple(const std::string& targetTriple) override

Definition at line 1474 of Emitter.cpp :
1475 {
1477 }

Declaration at line 271 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetTargetTriple

SetVmtObjectCreated Member Function

void cmsxbe::Emitter::SetVmtObjectCreated(void * symbol) override

Definition at line 1096 of Emitter.cpp :
1097 {
1098 vmtObjectCreatedSet.insert(symbol);
1099 }

Declaration at line 216 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetVmtObjectCreated

SetVmtObjectName Member Function

void cmsxbe::Emitter::SetVmtObjectName(void * symbol, const std::string& vmtObjectName) override

Definition at line 995 of Emitter.cpp :
996 {
998 }

Declaration at line 200 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetVmtObjectName

SetVmtObjectType Member Function

void cmsxbe::Emitter::SetVmtObjectType(void * symbol, void * vmtObjectType) override

Definition at line 1017 of Emitter.cpp :
1018 {
1020 }

Declaration at line 204 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SetVmtObjectType

SizeOf Member Function

void * cmsxbe::Emitter::SizeOf(void * ptrType) override

Definition at line 1378 of Emitter.cpp :
1379 {
1380     cmsxi::Value* nullPtr = context->GetNullValue(static_cast<cmsxi::PtrType*>(ptrType));
1381     cmsxi::Value* one = context->CreatePtrOffset(nullPtr, context->GetLongValue(1));
1382     cmsxi::Value* size = context->CreatePtrToInt(one, context->GetLongType());
1383     return size;
1384 }

Declaration at line 255 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::SizeOf

Calls: cmsxi::Context::CreatePtrOffset , cmsxi::Context::CreatePtrToInt , cmsxi::Context::GetLongType , cmsxi::Context::GetLongValue , cmsxi::Context::GetNullValue

StartDebugInfo Member Function

void cmsxbe::Emitter::StartDebugInfo(const std::string& sourceFilePath, const std::string& compilerVersion, bool optimized, ColumnSpanProvider * columnSpanProvider_) override

Definition at line 1509 of Emitter.cpp :
1510 {
1512 }

Declaration at line 278 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::StartDebugInfo

VerifyModule Member Function

void cmsxbe::Emitter::VerifyModule() override

Definition at line 1549 of Emitter.cpp :
1550 {
1552 }

Declaration at line 286 of Emitter.hpp

Base class overridden functions: cmajor::ir::Emitter::VerifyModule

top | up | prev | next

Emitter Class

Constructors

Member Functions

Member Variables

Constructor Details

Emitter Constructor

cmsxbe::Emitter::Emitter(EmittingContext * emittingContext_)

Member Function Details

AddCase Member Function

void cmsxbe::Emitter::AddCase(void * switchInst, void * caseValue, void * caseDest) override

AddClauseToLangdingPad Member Function

void cmsxbe::Emitter::AddClauseToLangdingPad(void * landingPad, void * exceptionTypeId) override

AddControlFlowGraphEdge Member Function

void cmsxbe::Emitter::AddControlFlowGraphEdge(int32_t startNodeId, int32_t endNodeId) override

AddControlFlowGraphNode Member Function

int32_t cmsxbe::Emitter::AddControlFlowGraphNode() override

AddHandlerToCatchSwitch Member Function

void cmsxbe::Emitter::AddHandlerToCatchSwitch(void * catchSwitch, void * target) override

AddInlineFunctionAttribute Member Function

void cmsxbe::Emitter::AddInlineFunctionAttribute(void * function) override

AddLocalVariable Member Function

void cmsxbe::Emitter::AddLocalVariable(const std::string& localVariableName, const boost::uuids::uuid& typeId, void * irObject) override

AddMDItem Member Function

void cmsxbe::Emitter::AddMDItem(void * mdStruct, const std::string& fieldName, void * mdItem) override

AddNoUnwindAttribute Member Function

void cmsxbe::Emitter::AddNoUnwindAttribute(void * function) override

AddUWTableAttribute Member Function

void cmsxbe::Emitter::AddUWTableAttribute(void * function) override

BeginInstructionFlag Member Function

void cmsxbe::Emitter::BeginInstructionFlag(int16_t flag) override

BeginScope Member Function

void cmsxbe::Emitter::BeginScope() override

BeginSubstituteLineNumber Member Function

void cmsxbe::Emitter::BeginSubstituteLineNumber(int32_t lineNumber) override

CleanupBlock Member Function

void * cmsxbe::Emitter::CleanupBlock() override

Compile Member Function

void cmsxbe::Emitter::Compile(const std::string& bcFilePath, const std::string& objectFilePath, int optimizationLevel) override

ComputeAddress Member Function

void * cmsxbe::Emitter::ComputeAddress(void * ptr, void * index) override

CreateAShr Member Function

void * cmsxbe::Emitter::CreateAShr(void * left, void * right) override

CreateAdd Member Function

void * cmsxbe::Emitter::CreateAdd(void * left, void * right) override

CreateAlloca Member Function

void * cmsxbe::Emitter::CreateAlloca(void * irType) override

CreateAnd Member Function

void * cmsxbe::Emitter::CreateAnd(void * left, void * right) override

CreateArrayIndexAddress Member Function

void * cmsxbe::Emitter::CreateArrayIndexAddress(void * arrayPtr, void * index) override

CreateBasicBlock Member Function

void * cmsxbe::Emitter::CreateBasicBlock(const std::string& name) override

CreateBeginCatch Member Function

void * cmsxbe::Emitter::CreateBeginCatch() override

CreateBeginTry Member Function

void * cmsxbe::Emitter::CreateBeginTry() override

CreateBitCast Member Function

void * cmsxbe::Emitter::CreateBitCast(void * operand, void * destinationType) override

CreateBr Member Function

void cmsxbe::Emitter::CreateBr(void * targetBasicBlock) override

CreateCall Member Function

void * cmsxbe::Emitter::CreateCall(void * callee, const std::vector<void *>& args) override

CreateCallInst Member Function

void * cmsxbe::Emitter::CreateCallInst(void * callee, const std::vector<void *>& args, const std::vector<void *>& bundles, const Span& span) override

CreateCallInstToBasicBlock Member Function

void * cmsxbe::Emitter::CreateCallInstToBasicBlock(void * callee, const std::vector<void *>& args, const std::vector<void *>& bundles, void * basicBlock, const Span& span) override

CreateCatchPad Member Function

void * cmsxbe::Emitter::CreateCatchPad(void * parentPad, const std::vector<void *>& args) override

CreateCatchRet Member Function

void * cmsxbe::Emitter::CreateCatchRet(void * catchPad, void * returnTarget) override

CreateCatchSwitch Member Function

void * cmsxbe::Emitter::CreateCatchSwitch(void * unwindBlock) override

CreateCatchSwitchWithParent Member Function

void * cmsxbe::Emitter::CreateCatchSwitchWithParent(void * parentPad, void * unwindBlock) override

CreateClassDIType Member Function

void * cmsxbe::Emitter::CreateClassDIType(void * classPtr) override

CreateCleanup Member Function

void cmsxbe::Emitter::CreateCleanup() override

CreateCleanupPad Member Function

void * cmsxbe::Emitter::CreateCleanupPad(const std::vector<void *>& args) override

void * cmsxbe::Emitter::CreateCallInst(void * callee, const std::vector<void >& args, const std::vector<void >& bundles, const Span& span) override

void * cmsxbe::Emitter::CreateCallInstToBasicBlock(void * callee, const std::vector<void >& args, const std::vector<void >& bundles, void * basicBlock, const Span& span) override

void * cmsxbe::Emitter::CreateDITypeForClassType(void * irType, const std::vector<void >& memberVariableElements, const Span& classSpan, const boost::uuids::uuid& moduleId, const std::string& name, void vtableHolderClass, const std::string& mangledName, void * baseClassDIType) override

void * cmsxbe::Emitter::CreateDITypeForEnumType(const std::string& name, const std::string& mangledName, const Span& span, const boost::uuids::uuid& moduleId, const std::vector<void >& enumConstantElements, uint64_t sizeInBits, uint32_t alignInBits, void underlyingDIType) override