top | up | prev | next

Emitter Class

Definition at line 26 of Emitter.hpp

Constructors

Emitter(llvm::LLVMContext& context_, 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
llvm::IRBuilder&	Builder()
void*	CleanupBlock() override
void	Compile(const std::string& bcFilePath, const std::string& objectFilePath, int optimizationLevel) override
void*	ComputeAddress(void* ptr, void* index) override
llvm::LLVMContext&	Context()
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*	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* leftValue, void* rightValue) 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& name) override
void*	CreateGlobalUStringPtr(const std::u32string& name) override
void*	CreateGlobalWStringPtr(const std::u16string& name) override
void*	CreateICmpEQ(void* left, void* right) override
void*	CreateICmpSLT(void* leftValue, void* rightValue) override
void*	CreateICmpULT(void* leftValue, void* rightValue) 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*	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*>& elements, 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
llvm::DICompileUnit*	DICompileUnit()
llvm::DIFile*	DIFile()
llvm::DataLayout*	DataLayout()
void	DebugPrintDebugInfo(const std::string& filePath) override
void	DestroyModule(void* module) override
void	Disassemble(const std::string& bcFilePath, const std::string& llFilePath) 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
llvm::Function*	Function()
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	GetClassTypeAlignmentInBits(void* classIrType) override
uint64_t	GetClassTypeSizeInBits(void* classIrType) override
void*	GetClsIdValue(const std::string& typeId) override
int	GetColumn(const Span& span) const
void*	GetConversionValue(void* type, void* from) override
llvm::DebugLoc	GetCurrentDebugLocation()
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
llvm::DebugLoc	GetDebugLocation(const Span& span)
void*	GetDelegateFromClassDelegate(void* classDelegatePtr) override
void*	GetFunctionArgument(void* function, int argumentIndex) override
unsigned	GetFunctionFlags(bool isStatic, unsigned accessFlags, bool isExplicit) override
void*	GetFunctionIrType(void* symbol) 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	GetSourceFilePath(const Span& span, const boost::uuids::uuid& moduleId)
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
llvm::Module*	Module()
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	ReplaceForwardDeclarations()
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* currentBasicBlock_) 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
ValueStack&	Stack()
void	StartDebugInfo(const std::string& sourceFilePath, const std::string& compilerVersion, bool optimized, ColumnSpanProvider* columnSpanProvider_) override
void	VerifyModule() override

Member Variables

llvm::IRBuilder	builder
std::unordered_map<void*, std::string>	classNameMap
std::unordered_map<boost::uuids::uuid, void*, boost::hash<boost::uuids::uuid>>	classPtrMap
ColumnSpanProvider*	columnSpanProvider
std::string	compileUnitId
int32_t	compileUnitIndex
llvm::LLVMContext&	context
llvm::BasicBlock*	currentBasicBlock
llvm::DIBuilder*	currentDIBuilder
llvm::DebugLoc	currentDebugLocation
int32_t	currentLineNumber
llvm::DataLayout*	dataLayout
std::unique_ptr<llvm::DIBuilder>	diBuilder
llvm::DICompileUnit*	diCompileUnit
llvm::DIFile*	diFile
std::unordered_map<std::pair<boost::uuids::uuid, int32_t>, llvm::DIDerivedType*, boost::hash<std::pair<boost::uuids::uuid, int32_t>>>	diMemberTypeMap
std::unordered_map<llvm::DIType*, std::string>	diTypeNameMap
std::unordered_map<boost::uuids::uuid, llvm::DIType*, boost::hash<boost::uuids::uuid>>	diTypeTypeIdMap
EmittingContext&	emittingContext
EmittingDelegate*	emittingDelegate
std::unordered_map<int32_t, llvm::DIFile*>	fileMap
llvm::Function*	function
std::unordered_map<void, llvm::FunctionType>	functionIrTypeMap
std::unordered_map<llvm::DIType*, boost::uuids::uuid>	fwdDeclarationMap
std::unordered_map<void*, std::string>	imtArrayObjectNameMap
bool	inPrologue
std::unordered_map<void, llvm::Value>	irObjectMap
std::unordered_map<void, llvm::Type>	irTypeMap
std::unordered_map<boost::uuids::uuid, llvm::Type*, boost::hash<boost::uuids::uuid>>	irTypeTypeIdMap
llvm::Module*	module
llvm::Value*	objectPointer
std::vector<llvm::DIScope*>	scopes
ValueStack	stack
std::unordered_set<void*>	staticObjectCreatedSet
std::unordered_map<void*, std::string>	staticObjectNameMap
std::unordered_map<void, llvm::StructType>	staticTypeMap
bool	substituteLineNumber
std::unordered_set<void*>	vmtObjectCreatedSet
std::unordered_map<void*, std::string>	vmtObjectNameMap
std::unordered_map<void, llvm::ArrayType>	vmtObjectTypeMap

Constructor Details

Emitter Constructor

cmllvm::Emitter::Emitter(llvm::LLVMContext& context_, EmittingContext & emittingContext_)

Definition at line 34 of Emitter.cpp :
  34 :
  35 cmajor::ir::Emitter(&stack), emittingContext(emittingContext_), emittingDelegate(nullptr),
  36 context(context_), builder(context), module(nullptr), dataLayout(nullptr), diCompileUnit(nullptr), diFile(nullptr), diBuilder(nullptr), columnSpanProvider(nullptr), compileUnitIndex(-1),
  37 stack(), objectPointer(nullptr), function(nullptr), currentBasicBlock(nullptr), inPrologue(false), currentDIBuilder(nullptr), substituteLineNumber(false), currentLineNumber(-1)
  38 {
  39 }

Declaration at line 29 of Emitter.hpp

Member Function Details

AddCase Member Function

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

Definition at line 2081 of Emitter.cpp :
2082 {
2083 static_cast<llvm::SwitchInst*>(switchInst)->addCase(llvm::cast<llvm::ConstantInt>(static_cast<llvm::Value*>(caseValue)), static_cast<llvm::BasicBlock*>(caseDest));
2084 }

Declaration at line 330 of Emitter.hpp

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

AddClauseToLangdingPad Member Function

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

Definition at line 2264 of Emitter.cpp :
2265 {
2266     llvm::LandingPadInst* lp = static_cast<llvm::LandingPadInst*>(landingPad);
2267     llvm::Constant* typeId = static_cast<llvm::Constant*>(exceptionTypeId);
2268     lp->addClause(llvm::cast<llvm::Constant>(builder.CreateBitCast(typeId, builder.getInt8PtrTy())));
2269 }

Declaration at line 373 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBitCast

AddControlFlowGraphEdge Member Function

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

Definition at line 249 of Emitter.cpp :
250 {
251 }

Declaration at line 258 of Emitter.hpp

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

AddControlFlowGraphNode Member Function

int32_t cmllvm::Emitter::AddControlFlowGraphNode() override

Definition at line 240 of Emitter.cpp :
241 {
242 return -1;
243 }

Declaration at line 256 of Emitter.hpp

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

AddHandlerToCatchSwitch Member Function

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

Definition at line 2126 of Emitter.cpp :
2127 {
2128 static_cast<llvm::CatchSwitchInst*>(catchSwitch)->addHandler(static_cast<llvm::BasicBlock*>(target));
2129 }

Declaration at line 337 of Emitter.hpp

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

AddInlineFunctionAttribute Member Function

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

Definition at line 1897 of Emitter.cpp :
1898 {
1899 llvm::Function* fun = static_cast<llvm::Function*>(function);
1900 fun->addFnAttr(llvm::Attribute::InlineHint);
1901 }

Declaration at line 306 of Emitter.hpp

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

AddLocalVariable Member Function

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

Definition at line 253 of Emitter.cpp :
254 {
255 }

Declaration at line 259 of Emitter.hpp

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

AddMDItem Member Function

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

Definition at line 2191 of Emitter.cpp :
2192 {
2193 }

Declaration at line 361 of Emitter.hpp

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

AddNoUnwindAttribute Member Function

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

Definition at line 2057 of Emitter.cpp :
2058 {
2059 static_cast<llvm::Function*>(function)->addFnAttr(llvm::Attribute::NoUnwind);
2060 }

Declaration at line 326 of Emitter.hpp

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

AddUWTableAttribute Member Function

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

Definition at line 2062 of Emitter.cpp :
2063 {
2064 static_cast<llvm::Function*>(function)->addFnAttr(llvm::Attribute::UWTable);
2065 }

Declaration at line 327 of Emitter.hpp

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

BeginInstructionFlag Member Function

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

Definition at line 257 of Emitter.cpp :
258 {
259 }

Declaration at line 260 of Emitter.hpp

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

BeginScope Member Function

void cmllvm::Emitter::BeginScope() override

Definition at line 223 of Emitter.cpp :
224 {
225 }

Declaration at line 252 of Emitter.hpp

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

BeginSubstituteLineNumber Member Function

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

Definition at line 2311 of Emitter.cpp :
2312 {
2313 substituteLineNumber = true;
2314 currentLineNumber = lineNumber;
2315 }

Declaration at line 379 of Emitter.hpp

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

Builder Member Function

llvm::IRBuilder& cmllvm::Emitter::Builder()

Definition at line 235 of Emitter.hpp :
235 { return builder; }

CleanupBlock Member Function

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

Definition at line 341 of Emitter.hpp :
341 { return emittingDelegate->CleanupBlock(); }

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

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

Compile Member Function

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

Definition at line 389 of Emitter.cpp
Declaration at line 278 of Emitter.hpp

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

Calls: soulng::util::Process::ExitCode , soulng::util::Process::ReadToEnd , soulng::util::Process::WaitForExit

ComputeAddress Member Function

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

Definition at line 1115 of Emitter.cpp :
1116 {
1117 return builder.CreateGEP(static_cast<llvm::Value*>(ptr), static_cast<llvm::Value*>(index));
1118 }

Declaration at line 225 of Emitter.hpp

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

Context Member Function

llvm::LLVMContext& cmllvm::Emitter::Context()

Definition at line 234 of Emitter.hpp :
234 { return context; }

CreateAShr Member Function

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

Definition at line 649 of Emitter.cpp :
650 {
651 return builder.CreateAShr(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
652 }

Declaration at line 167 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateAShr

Called by: cmllvm::Emitter::CreateAShr

CreateAdd Member Function

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

Definition at line 574 of Emitter.cpp :
575 {
576 return builder.CreateAdd(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
577 }

Declaration at line 152 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateAdd

Called by: cmllvm::Emitter::CreateAdd

CreateAlloca Member Function

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

Definition at line 2007 of Emitter.cpp :
2008 {
2009 return builder.CreateAlloca(static_cast<llvm::Type*>(irType));
2010 }

Declaration at line 318 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateAlloca

Called by: cmllvm::Emitter::CreateAlloca

CreateAnd Member Function

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

Definition at line 629 of Emitter.cpp :
630 {
631 return builder.CreateAnd(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
632 }

Declaration at line 163 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateAnd

Called by: cmllvm::Emitter::CreateAnd

CreateArrayIndexAddress Member Function

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

Definition at line 556 of Emitter.cpp :
557 {
558     ArgVector elementIndeces;
559     elementIndeces.push_back(builder.getInt64(0));
560     elementIndeces.push_back(static_cast<llvm::Value*>(index));
561     return builder.CreateGEP(static_cast<llvm::Value*>(arrayPtr), elementIndeces);
562 }

Declaration at line 149 of Emitter.hpp

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

CreateBasicBlock Member Function

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

Definition at line 515 of Emitter.cpp :
516 {
517 return llvm::BasicBlock::Create(context, name, Function());
518 }

Declaration at line 140 of Emitter.hpp

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

Calls: cmllvm::Emitter::Function

CreateBeginCatch Member Function

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

Definition at line 779 of Emitter.cpp :
780 {
781 return nullptr;
782 }

Declaration at line 193 of Emitter.hpp

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

CreateBeginTry Member Function

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

Definition at line 769 of Emitter.cpp :
770 {
771 return nullptr;
772 }

Declaration at line 191 of Emitter.hpp

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

CreateBitCast Member Function

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

Definition at line 709 of Emitter.cpp :
710 {
711 return builder.CreateBitCast(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
712 }

Declaration at line 179 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBitCast

Called by: cmllvm::Emitter::AddClauseToLangdingPad , cmllvm::Emitter::CreateBitCast , cmllvm::Emitter::CreateIrValueForUuid , cmllvm::Emitter::GetImtArray , cmllvm::Emitter::GetImtPtrFromInterface , cmllvm::Emitter::GetInterfaceMethod , cmllvm::Emitter::GetVmtPtr

CreateBr Member Function

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

Definition at line 546 of Emitter.cpp :
547 {
548 builder.CreateBr(static_cast<llvm::BasicBlock*>(targetBasicBlock));
549 }

Declaration at line 147 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBr

Called by: cmllvm::Emitter::CreateBr

CreateCall Member Function

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

Definition at line 853 of Emitter.cpp
Declaration at line 204 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateCall

Called by: cmllvm::Emitter::CreateCall

CreateCallInst Member Function

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

Definition at line 867 of Emitter.cpp
Declaration at line 205 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentBasicBlock , cmllvm::Emitter::DIBuilder , cmllvm::Emitter::GetDebugLocation

CreateCallInstToBasicBlock Member Function

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

Definition at line 895 of Emitter.cpp
Declaration at line 206 of Emitter.hpp

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

Calls: cmllvm::Emitter::DIBuilder , cmllvm::Emitter::GetDebugLocation

CreateCatchPad Member Function

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

Definition at line 2131 of Emitter.cpp :
2132 {
2133     std::vector<llvm::Value*> arguments;
2134     for (void* arg : args)
2135     {
2136         arguments.push_back(static_cast<llvm::Value*>(arg));
2137     }
2138     return builder.CreateCatchPad(static_cast<llvm::Value*>(parentPad), arguments);
2139 }

Declaration at line 338 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateCatchPad

Called by: cmllvm::Emitter::CreateCatchPad

CreateCatchRet Member Function

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

Definition at line 2111 of Emitter.cpp :
2112 {
2113 return builder.CreateCatchRet(llvm::cast<llvm::CatchPadInst>(static_cast<llvm::Value*>(catchPad)), static_cast<llvm::BasicBlock*>(returnTarget));
2114 }

Declaration at line 334 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateCatchRet

Called by: cmllvm::Emitter::CreateCatchRet

CreateCatchSwitch Member Function

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

Definition at line 2116 of Emitter.cpp :
2117 {
2118 return builder.CreateCatchSwitch(llvm::ConstantTokenNone::get(context), static_cast<llvm::BasicBlock*>(unwindBlock), 1);
2119 }

Declaration at line 335 of Emitter.hpp

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

CreateCatchSwitchWithParent Member Function

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

Definition at line 2121 of Emitter.cpp :
2122 {
2123 return builder.CreateCatchSwitch(static_cast<llvm::Value*>(parentPad), static_cast<llvm::BasicBlock*>(unwindBlock), 1);
2124 }

Declaration at line 336 of Emitter.hpp

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

CreateClassDIType Member Function

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

Definition at line 346 of Emitter.hpp :
346 { return emittingDelegate->CreateClassDIType(classPtr); }

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

Calls: cmajor::ir::EmittingDelegate::CreateClassDIType

Called by: cmllvm::Emitter::ReplaceForwardDeclarations

CreateCleanup Member Function

void cmllvm::Emitter::CreateCleanup() override

Definition at line 343 of Emitter.hpp :
343 { emittingDelegate->CreateCleanup(); }

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

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

CreateCleanupPad Member Function

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

Definition at line 2096 of Emitter.cpp :
2097 {
2098     std::vector<llvm::Value*> arguments;
2099     for (void* arg : args)
2100     {
2101         arguments.push_back(static_cast<llvm::Value*>(arg));
2102     }
2103     return builder.CreateCleanupPad(llvm::ConstantTokenNone::get(context), arguments);
2104 }

Declaration at line 332 of Emitter.hpp

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

CreateCleanupPadWithParent Member Function

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

Definition at line 2086 of Emitter.cpp :
2087 {
2088     std::vector<llvm::Value*> arguments;
2089     for (void* arg : args)
2090     {
2091         arguments.push_back(static_cast<llvm::Value*>(arg));
2092     }
2093     return builder.CreateCleanupPad(static_cast<llvm::Value*>(parentPad), arguments);
2094 }

Declaration at line 331 of Emitter.hpp

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

CreateCleanupRet Member Function

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

Definition at line 2106 of Emitter.cpp :
2107 {
2108 return builder.CreateCleanupRet(llvm::cast<llvm::CleanupPadInst>(static_cast<llvm::Value*>(cleanupPad)), static_cast<llvm::BasicBlock*>(unwindTarget));
2109 }

Declaration at line 333 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateCleanupRet

Called by: cmllvm::Emitter::CreateCleanupRet

CreateCondBr Member Function

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

Definition at line 551 of Emitter.cpp :
552 {
553 builder.CreateCondBr(static_cast<llvm::Value*>(cond), static_cast<llvm::BasicBlock*>(trueBasicBlock), static_cast<llvm::BasicBlock*>(falseBasicBlock));
554 }

Declaration at line 148 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateCondBr

Called by: cmllvm::Emitter::CreateCondBr

CreateConstDIType Member Function

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

Definition at line 1217 of Emitter.cpp :
1218 {
1219 return diBuilder->createQualifiedType(llvm::dwarf::DW_TAG_const_type, static_cast<llvm::DIType*>(diType));
1220 }

Declaration at line 129 of Emitter.hpp

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

CreateDIAutoVariable Member Function

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

Definition at line 2022 of Emitter.cpp :
2023 {
2024     llvm::DILocalVariable* localVar = diBuilder->createAutoVariable(static_cast<llvm::DIScope*>(CurrentScope()), name, static_cast<llvm::DIFile*>(GetDebugInfoForFile(span, moduleId)),
2025         span.line, static_cast<llvm::DIType*>(irType));
2026     llvm::SmallVector<int64_t, 13> expr;
2027     diBuilder->insertDeclare(static_cast<llvm::Value*>(allocaInst), localVar, diBuilder->createExpression(expr), GetDebugLocation(span), builder.GetInsertBlock());
2028     return localVar;
2029 }

Declaration at line 320 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetDebugInfoForFile , cmllvm::Emitter::GetDebugLocation

CreateDIFunction Member Function

void * cmllvm::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 1993 of Emitter.cpp :
1994 {
1995     void* subprogram = diBuilder->createFunction(static_cast<llvm::DIScope*>(CurrentScope()), name, mangledName, static_cast<llvm::DIFile*>(
1996         GetDebugInfoForFile(span, moduleId)),
1997         span.line, static_cast<llvm::DISubroutineType*>(subroutineType), span.line, static_cast<llvm::DINode::DIFlags>(flags),
1998         llvm::DISubprogram::SPFlagDefinition);
1999     return subprogram;
2000 }

Declaration at line 316 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetDebugInfoForFile

CreateDIMemberType Member Function

void * cmllvm::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 1209 of Emitter.cpp :
1210 {
1211     llvm::DINode::DIFlags flags = llvm::DINode::DIFlags::FlagZero;
1212     return diBuilder->createMemberType(static_cast<llvm::DIType*>(scope), name, static_cast<llvm::DIFile*>(
1213         GetDebugInfoForFile(span, moduleId)), span.line, sizeInBits, alignInBits, offsetInBits, flags,
1214         static_cast<llvm::DIType*>(diType));
1215 }

Declaration at line 128 of Emitter.hpp

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

Calls: cmllvm::Emitter::GetDebugInfoForFile

CreateDIMethod Member Function

void * cmllvm::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 1973 of Emitter.cpp :
1975 {
1976     void* subprogram = diBuilder->createMethod(static_cast<llvm::DIScope*>(CurrentScope()), name, mangledName, static_cast<llvm::DIFile*>(GetDebugInfoForFile(span, moduleId)),
1977         span.line, static_cast<llvm::DISubroutineType*>(subroutineType), vtableIndex, 0, static_cast<llvm::DIType*>(vtableHolder),
1978         static_cast<llvm::DINode::DIFlags>(flags), llvm::DISubprogram::SPFlagDefinition);
1979     return subprogram;
1980 }

Declaration at line 314 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetDebugInfoForFile

CreateDIParameterVariable Member Function

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

Definition at line 2012 of Emitter.cpp :
2013 {
2014     llvm::DILocalVariable* paramVar = diBuilder->createParameterVariable(static_cast<llvm::DIScope*>(CurrentScope()), name, index, static_cast<llvm::DIFile*>(
2015         GetDebugInfoForFile(span, moduleId)),
2016         span.line, static_cast<llvm::DIType*>(irType));
2017     llvm::SmallVector<int64_t, 13> expr;
2018     diBuilder->insertDeclare(static_cast<llvm::Value*>(allocaInst), paramVar, diBuilder->createExpression(expr), GetDebugLocation(span), builder.GetInsertBlock());
2019     return paramVar;
2020 }

Declaration at line 319 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetDebugInfoForFile , cmllvm::Emitter::GetDebugLocation

CreateDITypeForArray Member Function

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

Definition at line 1661 of Emitter.cpp :
1662 {
1664 std::vector<llvm::Metadata*> metadataElements;
1665 return diBuilder->createArrayType(elements.size(), 8, static_cast<llvm::DIType*>(elementDIType), diBuilder->getOrCreateArray(metadataElements));
1667 }

Declaration at line 115 of Emitter.hpp

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

CreateDITypeForBool Member Function

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

Definition at line 1586 of Emitter.cpp :
1587 {
1588 return diBuilder->createBasicType("bool", 8, llvm::dwarf::DW_ATE_boolean);
1589 }

Declaration at line 100 of Emitter.hpp

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

CreateDITypeForByte Member Function

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

Definition at line 1596 of Emitter.cpp :
1597 {
1598 return diBuilder->createBasicType("byte", 8, llvm::dwarf::DW_ATE_unsigned);
1599 }

Declaration at line 102 of Emitter.hpp

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

CreateDITypeForChar Member Function

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

Definition at line 1641 of Emitter.cpp :
1642 {
1643 return diBuilder->createBasicType("char", 8, llvm::dwarf::DW_ATE_unsigned_char);
1644 }

Declaration at line 111 of Emitter.hpp

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

CreateDITypeForClassType Member Function

void * cmllvm::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 1703 of Emitter.cpp
Declaration at line 118 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetDebugInfoForFile

CreateDITypeForClassType Member Function

void * cmllvm::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 1724 of Emitter.cpp
Declaration at line 118 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetDebugInfoForFile

CreateDITypeForDouble Member Function

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

Definition at line 1636 of Emitter.cpp :
1637 {
1638 return diBuilder->createBasicType("double", 64, llvm::dwarf::DW_ATE_float);
1639 }

Declaration at line 110 of Emitter.hpp

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

CreateDITypeForEnumConstant Member Function

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

Definition at line 189 of Emitter.cpp :
190 {
191 return diBuilder->createEnumerator(name, value);
192 }

Declaration at line 120 of Emitter.hpp

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

CreateDITypeForEnumType Member Function

void * cmllvm::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 194 of Emitter.cpp :
196 {
197     std::vector<llvm::Metadata*> elements;
198     for (void* element : enumConstantElements)
199     {
200         elements.push_back(static_cast<llvm::Metadata*>(element));
201     }
202     return diBuilder->createEnumerationType(nullptr, name, static_cast<llvm::DIFile*>(GetDebugInfoForFile(span, moduleId)), span.line, sizeInBits, alignInBits,
203         diBuilder->getOrCreateArray(elements), static_cast<llvm::DIType*>(underlyingDIType), mangledName);
204 }

Declaration at line 121 of Emitter.hpp

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

Calls: cmllvm::Emitter::GetDebugInfoForFile

CreateDITypeForFloat Member Function

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

Definition at line 1631 of Emitter.cpp :
1632 {
1633 return diBuilder->createBasicType("float", 32, llvm::dwarf::DW_ATE_float);
1634 }

Declaration at line 109 of Emitter.hpp

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

CreateDITypeForInt Member Function

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

Definition at line 1611 of Emitter.cpp :
1612 {
1613 return diBuilder->createBasicType("int", 32, llvm::dwarf::DW_ATE_signed);
1614 }

Declaration at line 105 of Emitter.hpp

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

CreateDITypeForLong Member Function

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

Definition at line 1621 of Emitter.cpp :
1622 {
1623 return diBuilder->createBasicType("long", 64, llvm::dwarf::DW_ATE_signed);
1624 }

Declaration at line 107 of Emitter.hpp

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

CreateDITypeForSByte Member Function

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

Definition at line 1591 of Emitter.cpp :
1592 {
1593 return diBuilder->createBasicType("sbyte", 8, llvm::dwarf::DW_ATE_signed);
1594 }

Declaration at line 101 of Emitter.hpp

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

CreateDITypeForShort Member Function

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

Definition at line 1601 of Emitter.cpp :
1602 {
1603 return diBuilder->createBasicType("short", 16, llvm::dwarf::DW_ATE_signed);
1604 }

Declaration at line 103 of Emitter.hpp

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

CreateDITypeForUChar Member Function

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

Definition at line 1651 of Emitter.cpp :
1652 {
1653 return diBuilder->createBasicType("uchar", 32, llvm::dwarf::DW_ATE_unsigned_char);
1654 }

Declaration at line 113 of Emitter.hpp

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

CreateDITypeForUInt Member Function

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

Definition at line 1616 of Emitter.cpp :
1617 {
1618 return diBuilder->createBasicType("uint", 32, llvm::dwarf::DW_ATE_unsigned);
1619 }

Declaration at line 106 of Emitter.hpp

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

CreateDITypeForULong Member Function

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

Definition at line 1626 of Emitter.cpp :
1627 {
1628 return diBuilder->createBasicType("ulong", 64, llvm::dwarf::DW_ATE_unsigned);
1629 }

Declaration at line 108 of Emitter.hpp

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

CreateDITypeForUShort Member Function

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

Definition at line 1606 of Emitter.cpp :
1607 {
1608 return diBuilder->createBasicType("ushort", 16, llvm::dwarf::DW_ATE_unsigned);
1609 }

Declaration at line 104 of Emitter.hpp

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

CreateDITypeForVoid Member Function

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

Definition at line 1656 of Emitter.cpp :
1657 {
1658 return diBuilder->createUnspecifiedType("void");
1659 }

Declaration at line 114 of Emitter.hpp

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

CreateDITypeForWChar Member Function

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

Definition at line 1646 of Emitter.cpp :
1647 {
1648 return diBuilder->createBasicType("wchar", 16, llvm::dwarf::DW_ATE_unsigned_char);
1649 }

Declaration at line 112 of Emitter.hpp

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

CreateDebugInfoForNamespace Member Function

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

Definition at line 323 of Emitter.cpp :
324 {
325 llvm::DINamespace* ns = diBuilder->createNameSpace(static_cast<llvm::DIScope*>(CurrentScope()), name, false);
326 return ns;
327 }

Declaration at line 273 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope

CreateDefaultIrValueForArrayType Member Function

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

Definition at line 1349 of Emitter.cpp :
1350 {
1351     std::vector<llvm::Constant*> arrayOfConstants;
1352     for (void* constant : arrayOfDefaults)
1353     {
1354         arrayOfConstants.push_back(static_cast<llvm::Constant*>(constant));
1355     }
1356     llvm::Type* arrayType = static_cast<llvm::Type*>(arrayIrType);
1357     return llvm::ConstantArray::get(llvm::cast<llvm::ArrayType>(arrayType), arrayOfConstants);
1358 }

Declaration at line 60 of Emitter.hpp

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

CreateDefaultIrValueForBool Member Function

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

Definition at line 1360 of Emitter.cpp :
1361 {
1362 return builder.getInt1(false);
1363 }

Declaration at line 61 of Emitter.hpp

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

CreateDefaultIrValueForByte Member Function

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

Definition at line 1370 of Emitter.cpp :
1371 {
1372 return builder.getInt8(0);
1373 }

Declaration at line 63 of Emitter.hpp

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

CreateDefaultIrValueForChar Member Function

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

Definition at line 1415 of Emitter.cpp :
1416 {
1417 return builder.getInt8(0);
1418 }

Declaration at line 72 of Emitter.hpp

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

CreateDefaultIrValueForDelegateType Member Function

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

Definition at line 1440 of Emitter.cpp :
1441 {
1442 return llvm::Constant::getNullValue(static_cast<llvm::Type*>(irType));
1443 }

Declaration at line 76 of Emitter.hpp

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

CreateDefaultIrValueForDerivedType Member Function

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

Definition at line 1450 of Emitter.cpp :
1451 {
1452 return llvm::Constant::getNullValue(static_cast<llvm::Type*>(irType));
1453 }

Declaration at line 78 of Emitter.hpp

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

CreateDefaultIrValueForDouble Member Function

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

Definition at line 1410 of Emitter.cpp :
1411 {
1412 return llvm::ConstantFP::get(llvm::Type::getDoubleTy(context), 0.0);
1413 }

Declaration at line 71 of Emitter.hpp

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

CreateDefaultIrValueForFloat Member Function

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

Definition at line 1405 of Emitter.cpp :
1406 {
1407 return llvm::ConstantFP::get(llvm::Type::getFloatTy(context), 0.0);
1408 }

Declaration at line 70 of Emitter.hpp

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

CreateDefaultIrValueForInt Member Function

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

Definition at line 1385 of Emitter.cpp :
1386 {
1387 return builder.getInt32(0);
1388 }

Declaration at line 66 of Emitter.hpp

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

CreateDefaultIrValueForLong Member Function

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

Definition at line 1395 of Emitter.cpp :
1396 {
1397 return builder.getInt64(0);
1398 }

Declaration at line 68 of Emitter.hpp

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

CreateDefaultIrValueForPtrType Member Function

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

Definition at line 1455 of Emitter.cpp :
1456 {
1457 return llvm::Constant::getNullValue(static_cast<llvm::Type*>(irType));
1458 }

Declaration at line 79 of Emitter.hpp

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

Called by: cmllvm::Emitter::SizeOf

CreateDefaultIrValueForSByte Member Function

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

Definition at line 1365 of Emitter.cpp :
1366 {
1367 return builder.getInt8(0);
1368 }

Declaration at line 62 of Emitter.hpp

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

CreateDefaultIrValueForShort Member Function

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

Definition at line 1375 of Emitter.cpp :
1376 {
1377 return builder.getInt16(0);
1378 }

Declaration at line 64 of Emitter.hpp

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

CreateDefaultIrValueForStruct Member Function

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

Definition at line 1430 of Emitter.cpp :
1431 {
1432     std::vector<llvm::Constant*> arrayOfDefaults;
1433     for (void* constant : defaultMembers)
1434     {
1435         arrayOfDefaults.push_back(static_cast<llvm::Constant*>(constant));
1436     }
1437     return llvm::ConstantStruct::get(llvm::cast<llvm::StructType>(static_cast<llvm::Type*>(irType)), arrayOfDefaults);
1438 }

Declaration at line 75 of Emitter.hpp

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

CreateDefaultIrValueForUChar Member Function

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

Definition at line 1425 of Emitter.cpp :
1426 {
1427 return builder.getInt32(0);
1428 }

Declaration at line 74 of Emitter.hpp

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

CreateDefaultIrValueForUInt Member Function

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

Definition at line 1390 of Emitter.cpp :
1391 {
1392 return builder.getInt32(0);
1393 }

Declaration at line 67 of Emitter.hpp

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

CreateDefaultIrValueForULong Member Function

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

Definition at line 1400 of Emitter.cpp :
1401 {
1402 return builder.getInt64(0);
1403 }

Declaration at line 69 of Emitter.hpp

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

CreateDefaultIrValueForUShort Member Function

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

Definition at line 1380 of Emitter.cpp :
1381 {
1382 return builder.getInt16(0);
1383 }

Declaration at line 65 of Emitter.hpp

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

CreateDefaultIrValueForVoidPtrType Member Function

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

Definition at line 1445 of Emitter.cpp :
1446 {
1447 return llvm::Constant::getNullValue(builder.getInt8PtrTy());
1448 }

Declaration at line 77 of Emitter.hpp

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

CreateDefaultIrValueForWChar Member Function

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

Definition at line 1420 of Emitter.cpp :
1421 {
1422 return builder.getInt16(0);
1423 }

Declaration at line 73 of Emitter.hpp

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

CreateEndCatch Member Function

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

Definition at line 784 of Emitter.cpp :
785 {
786 return nullptr;
787 }

Declaration at line 194 of Emitter.hpp

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

CreateEndTry Member Function

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

Definition at line 774 of Emitter.cpp :
775 {
776 return nullptr;
777 }

Declaration at line 192 of Emitter.hpp

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

CreateExtractValue Member Function

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

Definition at line 2271 of Emitter.cpp :
2272 {
2273 return builder.CreateExtractValue(static_cast<llvm::Value*>(aggregate), indeces);
2274 }

Declaration at line 374 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateExtractValue

Called by: cmllvm::Emitter::CreateExtractValue

CreateFAdd Member Function

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

Definition at line 579 of Emitter.cpp :
580 {
581 return builder.CreateFAdd(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
582 }

Declaration at line 153 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFAdd

Called by: cmllvm::Emitter::CreateFAdd

CreateFCmpOEQ Member Function

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

Definition at line 664 of Emitter.cpp :
665 {
666 return builder.CreateFCmpOEQ(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
667 }

Declaration at line 170 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFCmpOEQ

Called by: cmllvm::Emitter::CreateFCmpOEQ

CreateFCmpOLT Member Function

void * cmllvm::Emitter::CreateFCmpOLT(void * leftValue, void * rightValue) override

Definition at line 679 of Emitter.cpp :
680 {
681 return builder.CreateFCmpOLT(static_cast<llvm::Value*>(leftValue), static_cast<llvm::Value*>(rightValue));
682 }

Declaration at line 173 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFCmpOLT

Called by: cmllvm::Emitter::CreateFCmpOLT

CreateFDiv Member Function

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

Definition at line 614 of Emitter.cpp :
615 {
616 return builder.CreateFDiv(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
617 }

Declaration at line 160 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFDiv

Called by: cmllvm::Emitter::CreateFDiv

CreateFMul Member Function

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

Definition at line 599 of Emitter.cpp :
600 {
601 return builder.CreateFMul(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
602 }

Declaration at line 157 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFMul

Called by: cmllvm::Emitter::CreateFMul

CreateFNeg Member Function

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

Definition at line 754 of Emitter.cpp :
755 {
756 return builder.CreateFNeg(static_cast<llvm::Value*>(value));
757 }

Declaration at line 188 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFNeg

Called by: cmllvm::Emitter::CreateFNeg

CreateFPExt Member Function

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

Definition at line 694 of Emitter.cpp :
695 {
696 return builder.CreateFPExt(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
697 }

Declaration at line 176 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFPExt

Called by: cmllvm::Emitter::CreateFPExt

CreateFPToSI Member Function

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

Definition at line 729 of Emitter.cpp :
730 {
731 return builder.CreateFPToSI(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
732 }

Declaration at line 183 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFPToSI

Called by: cmllvm::Emitter::CreateFPToSI

CreateFPToUI Member Function

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

Definition at line 724 of Emitter.cpp :
725 {
726 return builder.CreateFPToUI(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
727 }

Declaration at line 182 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFPToUI

Called by: cmllvm::Emitter::CreateFPToUI

CreateFPTrunc Member Function

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

Definition at line 704 of Emitter.cpp :
705 {
706 return builder.CreateFPTrunc(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
707 }

Declaration at line 178 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFPTrunc

Called by: cmllvm::Emitter::CreateFPTrunc

CreateFSub Member Function

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

Definition at line 589 of Emitter.cpp :
590 {
591 return builder.CreateFSub(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
592 }

Declaration at line 155 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateFSub

Called by: cmllvm::Emitter::CreateFSub

CreateFwdIrTypeForClassType Member Function

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

Definition at line 147 of Emitter.cpp :
148 {
149 return llvm::StructType::create(context);
150 }

Declaration at line 50 of Emitter.hpp

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

CreateGlobalStringPtr Member Function

void * cmllvm::Emitter::CreateGlobalStringPtr(const std::string& name) override

Definition at line 832 of Emitter.cpp :
833 {
834     llvm::Constant* strConstant = llvm::ConstantDataArray::getString(context, name);
835     llvm::GlobalVariable* gv = new llvm::GlobalVariable(*module, strConstant->getType(), true, llvm::GlobalValue::PrivateLinkage, strConstant, "", nullptr, llvm::GlobalVariable::NotThreadLocal, 0);
836     gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
837     gv->setAlignment(llvm::MaybeAlign(1));
838     llvm::Constant* zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(context), 0);
839     llvm::Constant* indices[] = { zero, zero };
840     return llvm::ConstantExpr::getInBoundsGetElementPtr(gv->getValueType(), gv, indices);
841 }

Declaration at line 201 of Emitter.hpp

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

CreateGlobalUStringPtr Member Function

void * cmllvm::Emitter::CreateGlobalUStringPtr(const std::u32string& name) override

Definition at line 848 of Emitter.cpp :
849 {
850 return nullptr;
851 }

Declaration at line 203 of Emitter.hpp

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

CreateGlobalWStringPtr Member Function

void * cmllvm::Emitter::CreateGlobalWStringPtr(const std::u16string& name) override

Definition at line 843 of Emitter.cpp :
844 {
845 return nullptr;
846 }

Declaration at line 202 of Emitter.hpp

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

CreateICmpEQ Member Function

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

Definition at line 659 of Emitter.cpp :
660 {
661 return builder.CreateICmpEQ(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
662 }

Declaration at line 169 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateICmpEQ

Called by: cmllvm::Emitter::CreateICmpEQ

CreateICmpSLT Member Function

void * cmllvm::Emitter::CreateICmpSLT(void * leftValue, void * rightValue) override

Definition at line 674 of Emitter.cpp :
675 {
676 return builder.CreateICmpSLT(static_cast<llvm::Value*>(leftValue), static_cast<llvm::Value*>(rightValue));
677 }

Declaration at line 172 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateICmpSLT

Called by: cmllvm::Emitter::CreateICmpSLT

CreateICmpULT Member Function

void * cmllvm::Emitter::CreateICmpULT(void * leftValue, void * rightValue) override

Definition at line 669 of Emitter.cpp :
670 {
671 return builder.CreateICmpULT(static_cast<llvm::Value*>(leftValue), static_cast<llvm::Value*>(rightValue));
672 }

Declaration at line 171 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateICmpULT

Called by: cmllvm::Emitter::CreateICmpULT

CreateIncludeBasicBlockInstruction Member Function

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

Definition at line 520 of Emitter.cpp :
521 {
522 return nullptr;
523 }

Declaration at line 141 of Emitter.hpp

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

CreateInsertValue Member Function

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

Definition at line 2276 of Emitter.cpp :
2277 {
2278 return builder.CreateInsertValue(static_cast<llvm::Value*>(aggregate), static_cast<llvm::Value*>(value), indeces);
2279 }

Declaration at line 375 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateInsertValue

Called by: cmllvm::Emitter::CreateInsertValue

CreateIntToPtr Member Function

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

Definition at line 734 of Emitter.cpp :
735 {
736 return builder.CreateIntToPtr(static_cast<llvm::Value*>(intValue), static_cast<llvm::Type*>(destinationType));
737 }

Declaration at line 184 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateIntToPtr

Called by: cmllvm::Emitter::CreateIntToPtr

CreateInvoke Member Function

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

Definition at line 923 of Emitter.cpp
Declaration at line 207 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateInvoke

Called by: cmllvm::Emitter::CreateInvoke

CreateInvokeInst Member Function

void * cmllvm::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 939 of Emitter.cpp
Declaration at line 208 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentBasicBlock , cmllvm::Emitter::DIBuilder , cmllvm::Emitter::GetDebugLocation

CreateIrDIForwardDeclaration Member Function

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

Definition at line 1682 of Emitter.cpp :
1683 {
1684     uint64_t sizeInBits = dataLayout->getStructLayout(llvm::cast<llvm::StructType>(static_cast<llvm::Type*>(irType)))->getSizeInBits();
1685     uint32_t alignInBits = 8 * dataLayout->getStructLayout(llvm::cast<llvm::StructType>(static_cast<llvm::Type*>(irType)))->getAlignment();
1686     uint64_t offsetInBits = 0;
1687     return diBuilder->createReplaceableCompositeType(llvm::dwarf::DW_TAG_class_type, name, nullptr, static_cast<llvm::DIFile*>(
1688         GetDebugInfoForFile(span, moduleId)), span.line,
1689         0, sizeInBits, alignInBits, llvm::DINode::DIFlags::FlagZero, mangledName);
1690 }

Declaration at line 116 of Emitter.hpp

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

Calls: cmllvm::Emitter::GetDebugInfoForFile

CreateIrDIForwardDeclaration Member Function

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

Definition at line 1671 of Emitter.cpp
Declaration at line 116 of Emitter.hpp

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

Calls: cmllvm::Emitter::GetDebugInfoForFile

CreateIrValueForBool Member Function

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

Definition at line 1460 of Emitter.cpp :
1461 {
1462 return builder.getInt1(value);
1463 }

Declaration at line 80 of Emitter.hpp

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

CreateIrValueForByte Member Function

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

Definition at line 1470 of Emitter.cpp :
1471 {
1472 return builder.getInt8(value);
1473 }

Declaration at line 82 of Emitter.hpp

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

CreateIrValueForChar Member Function

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

Definition at line 1522 of Emitter.cpp :
1523 {
1524 return builder.getInt8(value);
1525 }

Declaration at line 91 of Emitter.hpp

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

CreateIrValueForConstantArray Member Function

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

Definition at line 1553 of Emitter.cpp :
1554 {
1555     std::vector<llvm::Constant*> elementConstants;
1556     for (void* elementConstant : elements)
1557     {
1558         elementConstants.push_back(static_cast<llvm::Constant*>(elementConstant));
1559     }
1560     return llvm::ConstantArray::get(llvm::cast<llvm::ArrayType>(static_cast<llvm::Type*>(arrayIrType)), elementConstants);
1561 }

Declaration at line 96 of Emitter.hpp

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

CreateIrValueForConstantStruct Member Function

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

Definition at line 1563 of Emitter.cpp :
1564 {
1565     std::vector<llvm::Constant*> memberConstants;
1566     for (void* elementConstant : elementConstants)
1567     {
1568         memberConstants.push_back(static_cast<llvm::Constant*>(elementConstant));
1569     }
1570     return llvm::ConstantStruct::get(llvm::cast<llvm::StructType>(static_cast<llvm::Type*>(structIrType)), memberConstants);
1571 }

Declaration at line 97 of Emitter.hpp

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

CreateIrValueForDouble Member Function

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

Definition at line 1517 of Emitter.cpp :
1518 {
1519 return llvm::ConstantFP::get(builder.getDoubleTy(), value);
1520 }

Declaration at line 90 of Emitter.hpp

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

CreateIrValueForFloat Member Function

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

Definition at line 1512 of Emitter.cpp :
1513 {
1514 return llvm::ConstantFP::get(builder.getFloatTy(), value);
1515 }

Declaration at line 89 of Emitter.hpp

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

CreateIrValueForInt Member Function

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

Definition at line 1485 of Emitter.cpp :
1486 {
1487     if (substituteLineNumber)
1488     {
1489         return builder.getInt32(static_cast<uint32_t>(currentLineNumber));
1490     }
1491     else
1492     {
1493         return builder.getInt32(static_cast<uint32_t>(value));
1494     }
1495 }

Declaration at line 85 of Emitter.hpp

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

CreateIrValueForLong Member Function

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

Definition at line 1502 of Emitter.cpp :
1503 {
1504 return builder.getInt64(static_cast<uint64_t>(value));
1505 }

Declaration at line 87 of Emitter.hpp

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

CreateIrValueForSByte Member Function

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

Definition at line 1465 of Emitter.cpp :
1466 {
1467 return builder.getInt8(static_cast<uint8_t>(value));
1468 }

Declaration at line 81 of Emitter.hpp

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

CreateIrValueForShort Member Function

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

Definition at line 1475 of Emitter.cpp :
1476 {
1477 return builder.getInt16(static_cast<uint16_t>(value));
1478 }

Declaration at line 83 of Emitter.hpp

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

CreateIrValueForUChar Member Function

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

Definition at line 1532 of Emitter.cpp :
1533 {
1534 return builder.getInt32(value);
1535 }

Declaration at line 93 of Emitter.hpp

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

CreateIrValueForUInt Member Function

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

Definition at line 1497 of Emitter.cpp :
1498 {
1499 return builder.getInt32(value);
1500 }

Declaration at line 86 of Emitter.hpp

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

CreateIrValueForULong Member Function

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

Definition at line 1507 of Emitter.cpp :
1508 {
1509 return builder.getInt64(value);
1510 }

Declaration at line 88 of Emitter.hpp

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

CreateIrValueForUShort Member Function

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

Definition at line 1480 of Emitter.cpp :
1481 {
1482 return builder.getInt16(value);
1483 }

Declaration at line 84 of Emitter.hpp

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

CreateIrValueForUString Member Function

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

Definition at line 1545 of Emitter.cpp :
1546 {
1547     ArgVector indeces;
1548     indeces.push_back(builder.getInt32(0));
1549     indeces.push_back(builder.getInt32(0));
1550     return builder.CreateGEP(static_cast<llvm::Value*>(ustringConstant), indeces);
1551 }

Declaration at line 95 of Emitter.hpp

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

CreateIrValueForUuid Member Function

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

Definition at line 1573 of Emitter.cpp :
1574 {
1575     ArgVector indeces;
1576     indeces.push_back(builder.getInt32(0));
1577     indeces.push_back(builder.getInt32(0));
1578     return builder.CreateBitCast(builder.CreateGEP(static_cast<llvm::Value*>(uuidConstant), indeces), builder.getInt8PtrTy());
1579 }

Declaration at line 98 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBitCast

CreateIrValueForWChar Member Function

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

Definition at line 1527 of Emitter.cpp :
1528 {
1529 return builder.getInt16(value);
1530 }

Declaration at line 92 of Emitter.hpp

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

CreateIrValueForWString Member Function

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

Definition at line 1537 of Emitter.cpp :
1538 {
1539     ArgVector indeces;
1540     indeces.push_back(builder.getInt32(0));
1541     indeces.push_back(builder.getInt32(0));
1542     return builder.CreateGEP(static_cast<llvm::Value*>(wstringConstant), indeces);
1543 }

Declaration at line 94 of Emitter.hpp

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

CreateLShr Member Function

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

Definition at line 654 of Emitter.cpp :
655 {
656 return builder.CreateLShr(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
657 }

Declaration at line 168 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateLShr

Called by: cmllvm::Emitter::CreateLShr

CreateLValueRefDIType Member Function

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

Definition at line 1222 of Emitter.cpp :
1223 {
1224 return diBuilder->createReferenceType(llvm::dwarf::DW_TAG_reference_type, static_cast<llvm::DIType*>(diType));
1225 }

Declaration at line 130 of Emitter.hpp

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

CreateLandingPad Member Function

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

Definition at line 2231 of Emitter.cpp :
2232 {
2233 llvm::LandingPadInst* lp = builder.CreateLandingPad(static_cast<llvm::Type*>(lpType), 1);
2234 return lp;
2235 }

Declaration at line 370 of Emitter.hpp

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

CreateLexicalBlock Member Function

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

Definition at line 2067 of Emitter.cpp :
2068 {
2069     llvm::DILexicalBlock* block = diBuilder->createLexicalBlock(static_cast<llvm::DIScope*>(CurrentScope()), static_cast<llvm::DIFile*>(GetDebugInfoForFile(span, moduleId)),
2070         span.line, GetColumn(span));
2071     PushScope(block);
2072     return block;
2073 }

Declaration at line 328 of Emitter.hpp

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

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetColumn , cmllvm::Emitter::GetDebugInfoForFile , cmllvm::Emitter::PushScope

CreateLoad Member Function

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

Definition at line 569 of Emitter.cpp :
570 {
571 return builder.CreateLoad(static_cast<llvm::Value*>(ptr));
572 }

Declaration at line 151 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateLoad

Called by: cmllvm::Emitter::CreateLoad , cmllvm::Emitter::GetClassName , cmllvm::Emitter::GetImt , cmllvm::Emitter::GetImtArray , cmllvm::Emitter::GetImtPtrFromInterface , cmllvm::Emitter::GetInterfaceMethod , cmllvm::Emitter::GetMethodPtr , cmllvm::Emitter::GetObjectFromInterface , cmllvm::Emitter::GetVmtPtr

CreateMDBasicBlockRef Member Function

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

Definition at line 2181 of Emitter.cpp :
2182 {
2183 return nullptr;
2184 }

Declaration at line 359 of Emitter.hpp

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

CreateMDBool Member Function

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

Definition at line 2156 of Emitter.cpp :
2157 {
2158 return nullptr;
2159 }

Declaration at line 354 of Emitter.hpp

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

CreateMDLong Member Function

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

Definition at line 2161 of Emitter.cpp :
2162 {
2163 return nullptr;
2164 }

Declaration at line 355 of Emitter.hpp

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

CreateMDString Member Function

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

Definition at line 2166 of Emitter.cpp :
2167 {
2168 return nullptr;
2169 }

Declaration at line 356 of Emitter.hpp

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

CreateMDStruct Member Function

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

Definition at line 2176 of Emitter.cpp :
2177 {
2178 return nullptr;
2179 }

Declaration at line 358 of Emitter.hpp

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

CreateMDStructRef Member Function

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

Definition at line 2171 of Emitter.cpp :
2172 {
2173 return nullptr;
2174 }

Declaration at line 357 of Emitter.hpp

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

CreateModule Member Function

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

Definition at line 1145 of Emitter.cpp :
1146 {
1147 return new llvm::Module(moduleName, context);
1148 }

Declaration at line 231 of Emitter.hpp

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

CreateMul Member Function

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

Definition at line 594 of Emitter.cpp :
595 {
596 return builder.CreateMul(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
597 }

Declaration at line 156 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateMul

Called by: cmllvm::Emitter::CreateMul

CreateNeg Member Function

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

Definition at line 749 of Emitter.cpp :
750 {
751 return builder.CreateNeg(static_cast<llvm::Value*>(value));
752 }

Declaration at line 187 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateNeg

Called by: cmllvm::Emitter::CreateNeg

CreateNop Member Function

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

Definition at line 759 of Emitter.cpp :
760 {
761 return nullptr;
762 }

Declaration at line 189 of Emitter.hpp

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

CreateNot Member Function

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

Definition at line 744 of Emitter.cpp :
745 {
746 return builder.CreateNot(static_cast<llvm::Value*>(value));
747 }

Declaration at line 186 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateNot

Called by: cmllvm::Emitter::CreateNot

CreateOr Member Function

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

Definition at line 634 of Emitter.cpp :
635 {
636 return builder.CreateOr(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
637 }

Declaration at line 164 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateOr

Called by: cmllvm::Emitter::CreateOr

CreatePointerDIType Member Function

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

Definition at line 1232 of Emitter.cpp :
1233 {
1234 return diBuilder->createPointerType(static_cast<llvm::DIType*>(diType), 64);
1235 }

Declaration at line 132 of Emitter.hpp

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

CreatePtrDiff Member Function

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

Definition at line 1120 of Emitter.cpp :
1121 {
1122 return builder.CreatePtrDiff(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
1123 }

Declaration at line 226 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreatePtrDiff

Called by: cmllvm::Emitter::CreatePtrDiff

CreatePtrToInt Member Function

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

Definition at line 739 of Emitter.cpp :
740 {
741 return builder.CreatePtrToInt(static_cast<llvm::Value*>(ptrValue), static_cast<llvm::Type*>(destinationType));
742 }

Declaration at line 185 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreatePtrToInt

Called by: cmllvm::Emitter::CreatePtrToInt , cmllvm::Emitter::SizeOf

CreateRValueRefDIType Member Function

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

Definition at line 1227 of Emitter.cpp :
1228 {
1229 return diBuilder->createReferenceType(llvm::dwarf::DW_TAG_rvalue_reference_type, static_cast<llvm::DIType*>(diType));
1230 }

Declaration at line 131 of Emitter.hpp

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

CreateResume Member Function

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

Definition at line 2286 of Emitter.cpp :
2287 {
2288 builder.CreateResume(static_cast<llvm::Value*>(exception));
2289 }

Declaration at line 377 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateResume

Called by: cmllvm::Emitter::CreateResume

CreateRet Member Function

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

Definition at line 2042 of Emitter.cpp :
2043 {
2044 return builder.CreateRet(static_cast<llvm::Value*>(value));
2045 }

Declaration at line 323 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateRet

Called by: cmllvm::Emitter::CreateRet

CreateRetVoid Member Function

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

Definition at line 2047 of Emitter.cpp :
2048 {
2049 return builder.CreateRetVoid();
2050 }

Declaration at line 324 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateRetVoid

Called by: cmllvm::Emitter::CreateRetVoid

CreateSDiv Member Function

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

Definition at line 609 of Emitter.cpp :
610 {
611 return builder.CreateSDiv(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
612 }

Declaration at line 159 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateSDiv

Called by: cmllvm::Emitter::CreateSDiv

CreateSExt Member Function

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

Definition at line 684 of Emitter.cpp :
685 {
686 return builder.CreateSExt(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
687 }

Declaration at line 174 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateSExt

Called by: cmllvm::Emitter::CreateSExt

CreateSIToFP Member Function

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

Definition at line 719 of Emitter.cpp :
720 {
721 return builder.CreateSIToFP(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
722 }

Declaration at line 181 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateSIToFP

Called by: cmllvm::Emitter::CreateSIToFP

CreateSRem Member Function

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

Definition at line 624 of Emitter.cpp :
625 {
626 return builder.CreateSRem(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
627 }

Declaration at line 162 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateSRem

Called by: cmllvm::Emitter::CreateSRem

CreateSave Member Function

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

Definition at line 764 of Emitter.cpp :
765 {
766 return nullptr;
767 }

Declaration at line 190 of Emitter.hpp

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

CreateShl Member Function

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

Definition at line 644 of Emitter.cpp :
645 {
646 return builder.CreateShl(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
647 }

Declaration at line 166 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateShl

Called by: cmllvm::Emitter::CreateShl

CreateStore Member Function

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

Definition at line 564 of Emitter.cpp :
565 {
566 builder.CreateStore(static_cast<llvm::Value*>(value), static_cast<llvm::Value*>(ptr));
567 }

Declaration at line 150 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateStore

Called by: cmllvm::Emitter::CreateStore

CreateSub Member Function

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

Definition at line 584 of Emitter.cpp :
585 {
586 return builder.CreateSub(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
587 }

Declaration at line 154 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateSub

Called by: cmllvm::Emitter::CreateSub

CreateSubroutineType Member Function

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

Definition at line 1925 of Emitter.cpp :
1926 {
1927     std::vector<llvm::Metadata*> elements;
1928     for (void* elementType : elementTypes)
1929     {
1930         elements.push_back(static_cast<llvm::Metadata*>(elementType));
1931     }
1932     llvm::DISubroutineType* subroutineType = diBuilder->createSubroutineType(diBuilder->getOrCreateTypeArray(elements));
1933     return subroutineType;
1934 }

Declaration at line 310 of Emitter.hpp

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

CreateSwitch Member Function

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

Definition at line 2075 of Emitter.cpp :
2076 {
2077 void* switchInst = builder.CreateSwitch(static_cast<llvm::Value*>(condition), static_cast<llvm::BasicBlock*>(defaultDest), numCases);
2078 return switchInst;
2079 }

Declaration at line 329 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateSwitch

Called by: cmllvm::Emitter::CreateSwitch

CreateTrunc Member Function

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

Definition at line 699 of Emitter.cpp :
700 {
701 return builder.CreateTrunc(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
702 }

Declaration at line 177 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateTrunc

Called by: cmllvm::Emitter::CreateTrunc

CreateUDiv Member Function

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

Definition at line 604 of Emitter.cpp :
605 {
606 return builder.CreateUDiv(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
607 }

Declaration at line 158 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateUDiv

Called by: cmllvm::Emitter::CreateUDiv

CreateUIToFP Member Function

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

Definition at line 714 of Emitter.cpp :
715 {
716 return builder.CreateUIToFP(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
717 }

Declaration at line 180 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateUIToFP

Called by: cmllvm::Emitter::CreateUIToFP

CreateURem Member Function

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

Definition at line 619 of Emitter.cpp :
620 {
621 return builder.CreateURem(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
622 }

Declaration at line 161 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateURem

Called by: cmllvm::Emitter::CreateURem

CreateUndefValue Member Function

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

Definition at line 2281 of Emitter.cpp :
2282 {
2283 return llvm::UndefValue::get(static_cast<llvm::Type*>(type));
2284 }

Declaration at line 376 of Emitter.hpp

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

CreateUnspecifiedDIType Member Function

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

Definition at line 1237 of Emitter.cpp :
1238 {
1239 return diBuilder->createUnspecifiedType(name);
1240 }

Declaration at line 133 of Emitter.hpp

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

CreateXor Member Function

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

Definition at line 639 of Emitter.cpp :
640 {
641 return builder.CreateXor(static_cast<llvm::Value*>(left), static_cast<llvm::Value*>(right));
642 }

Declaration at line 165 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateXor

Called by: cmllvm::Emitter::CreateXor

CreateZExt Member Function

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

Definition at line 689 of Emitter.cpp :
690 {
691 return builder.CreateZExt(static_cast<llvm::Value*>(operand), static_cast<llvm::Type*>(destinationType));
692 }

Declaration at line 175 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateZExt

Called by: cmllvm::Emitter::CreateZExt

CurrentBasicBlock Member Function

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

Definition at line 263 of Emitter.hpp :
263 { return currentBasicBlock; }

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

Called by: cmllvm::Emitter::CreateCallInst , cmllvm::Emitter::CreateInvokeInst

CurrentPad Member Function

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

Definition at line 345 of Emitter.hpp :
345 { return emittingDelegate->CurrentPad(); }

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

Calls: cmajor::ir::EmittingDelegate::CurrentPad

CurrentScope Member Function

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

Definition at line 275 of Emitter.cpp :
276 {
277     llvm::DIScope* currentScope = diCompileUnit;
278     if (!scopes.empty())
279     {
280         currentScope = scopes.back();
281     }
282     return currentScope;
283 }

Declaration at line 268 of Emitter.hpp

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

Called by: cmllvm::Emitter::CreateDIAutoVariable , cmllvm::Emitter::CreateDIFunction , cmllvm::Emitter::CreateDIMethod , cmllvm::Emitter::CreateDIParameterVariable , cmllvm::Emitter::CreateDITypeForClassType , cmllvm::Emitter::CreateDITypeForClassType , cmllvm::Emitter::CreateDebugInfoForNamespace , cmllvm::Emitter::CreateLexicalBlock , cmllvm::Emitter::GetDebugLocation

DIBuilder Member Function

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

Definition at line 209 of Emitter.hpp :
209 { return currentDIBuilder; }

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

Called by: cmllvm::Emitter::CreateCallInst , cmllvm::Emitter::CreateCallInstToBasicBlock , cmllvm::Emitter::CreateInvokeInst

DICompileUnit Member Function

llvm::DICompileUnit* cmllvm::Emitter::DICompileUnit()

Definition at line 238 of Emitter.hpp :
238 { return diCompileUnit; }

DIFile Member Function

llvm::DIFile* cmllvm::Emitter::DIFile()

Definition at line 239 of Emitter.hpp :
239 { return diFile; }

DataLayout Member Function

llvm::DataLayout* cmllvm::Emitter::DataLayout()

Definition at line 237 of Emitter.hpp :
237 { return dataLayout; }

DebugPrintDebugInfo Member Function

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

Definition at line 2291 of Emitter.cpp
Declaration at line 378 of Emitter.hpp

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

DestroyModule Member Function

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

Definition at line 1150 of Emitter.cpp :
1151 {
1152 delete static_cast<llvm::Module*>(module);
1153 }

Declaration at line 232 of Emitter.hpp

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

Disassemble Member Function

void cmllvm::Emitter::Disassemble(const std::string& bcFilePath, const std::string& llFilePath) override

Definition at line 367 of Emitter.cpp
Declaration at line 277 of Emitter.hpp

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

Calls: soulng::util::Process::ExitCode , soulng::util::Process::ReadToEnd , soulng::util::Process::WaitForExit

EmitIrFile Member Function

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

Definition at line 337 of Emitter.cpp :
338 {
339     std::ofstream bcFile(filePath, std::ios::binary);
340     llvm::raw_os_ostream bcOs(bcFile);
341     llvm::WriteBitcodeToFile(*module, bcOs);
342     bcOs.flush();
343 }

Declaration at line 275 of Emitter.hpp

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

EmitIrText Member Function

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

Definition at line 329 of Emitter.cpp :
330 {
331     std::ofstream llFile(filePath);
332     llvm::raw_os_ostream llOs(llFile);
333     module->print(llOs, nullptr);
334     llOs.flush();
335 }

Declaration at line 274 of Emitter.hpp

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

EmitObjectCodeFile Member Function

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

Definition at line 444 of Emitter.cpp
Declaration at line 280 of Emitter.hpp

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

Calls: cmajor::ir::EmittingContext::TargetMachine

EndDebugInfo Member Function

void cmllvm::Emitter::EndDebugInfo() override

Definition at line 317 of Emitter.cpp :
318 {
319 PopScope();
320 diBuilder.reset();
321 }

Declaration at line 272 of Emitter.hpp

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

Calls: cmllvm::Emitter::PopScope

EndInstructionFlag Member Function

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

Definition at line 261 of Emitter.cpp :
262 {
263 }

Declaration at line 261 of Emitter.hpp

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

EndScope Member Function

void cmllvm::Emitter::EndScope() override

Definition at line 227 of Emitter.cpp :
228 {
229 }

Declaration at line 253 of Emitter.hpp

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

EndSubstituteLineNumber Member Function

void cmllvm::Emitter::EndSubstituteLineNumber() override

Definition at line 2317 of Emitter.cpp :
2318 {
2319 substituteLineNumber = false;
2320 }

Declaration at line 380 of Emitter.hpp

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

FinalizeDebugInfo Member Function

void cmllvm::Emitter::FinalizeDebugInfo() override

Definition at line 311 of Emitter.cpp :
312 {
313 ReplaceForwardDeclarations();
314 diBuilder->finalize();
315 }

Declaration at line 271 of Emitter.hpp

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

Calls: cmllvm::Emitter::ReplaceForwardDeclarations

FinalizeFunction Member Function

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

Definition at line 2212 of Emitter.cpp :
2213 {
2214 }

Declaration at line 366 of Emitter.hpp

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

Function Member Function

llvm::Function* cmllvm::Emitter::Function()

Definition at line 262 of Emitter.hpp :
262 { return function; }

Called by: cmllvm::Emitter::CreateBasicBlock

GenerateTrap Member Function

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

Definition at line 2141 of Emitter.cpp :
2142 {
2143 return nullptr;
2144 }

Declaration at line 351 of Emitter.hpp

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

GetAlignmentInBits Member Function

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

Definition at line 1256 of Emitter.cpp :
1257 {
1258 return 8 * dataLayout->getABITypeAlignment(static_cast<llvm::Type*>(irType));
1259 }

Declaration at line 136 of Emitter.hpp

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

GetArrayBeginAddress Member Function

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

Definition at line 496 of Emitter.cpp :
497 {
498     ArgVector elementIndeces;
499     elementIndeces.push_back(builder.getInt64(0));
500     elementIndeces.push_back(builder.getInt64(0));
501     llvm::Value* beginPtr = builder.CreateGEP(static_cast<llvm::Value*>(arrayPtr), elementIndeces);
502     return beginPtr;
503 }

Declaration at line 138 of Emitter.hpp

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

GetArrayEndAddress Member Function

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

Definition at line 505 of Emitter.cpp :
506 {
507     ArgVector elementIndeces;
508     elementIndeces.push_back(builder.getInt64(0));
509     elementIndeces.push_back(builder.getInt64(size));
510     llvm::Value* endPtr = builder.CreateGEP(static_cast<llvm::Value*>(arrayPtr), elementIndeces);
511     return endPtr;
513 }

Declaration at line 139 of Emitter.hpp

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

GetBasicBlockId Member Function

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

Definition at line 541 of Emitter.cpp :
542 {
543 return -1;
544 }

Declaration at line 146 of Emitter.hpp

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

GetBoundCompileUnit Member Function

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

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

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

GetClassIdPtr Member Function

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

Definition at line 1096 of Emitter.cpp :
1097 {
1098     ArgVector indeces;
1099     indeces.push_back(builder.getInt32(0));
1100     indeces.push_back(builder.getInt32(classIdVmtIndexOffset));
1101     llvm::Value* classIdPtr = builder.CreateGEP(static_cast<llvm::Value*>(vmtPtr), indeces);
1102     return classIdPtr;
1103 }

Declaration at line 223 of Emitter.hpp

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

GetClassName Member Function

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

Definition at line 1105 of Emitter.cpp :
1106 {
1107     ArgVector indeces;
1108     indeces.push_back(builder.getInt32(0));
1109     indeces.push_back(builder.getInt32(classNameVmtIndexOffset));
1110     llvm::Value* classNamePtr = builder.CreateGEP(static_cast<llvm::Value*>(vmtPtr), indeces);
1111     llvm::Value* className = builder.CreateLoad(classNamePtr);
1112     return className;
1113 }

Declaration at line 224 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateLoad

GetClassTypeAlignmentInBits Member Function

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

Definition at line 1889 of Emitter.cpp :
1890 {
1891 uint32_t alignInBits = 8 * dataLayout->getStructLayout(llvm::cast<llvm::StructType>(static_cast<llvm::StructType*>(classIrType)))->getAlignment();
1892 return alignInBits;
1893 }

Declaration at line 305 of Emitter.hpp

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

GetClassTypeAlignmentInBits Member Function

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

Definition at line 1881 of Emitter.cpp
Declaration at line 305 of Emitter.hpp

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

GetClassTypeSizeInBits Member Function

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

Definition at line 1873 of Emitter.cpp :
1874 {
1875 uint64_t sizeInBits = dataLayout->getStructLayout(llvm::cast<llvm::StructType>(static_cast<llvm::StructType*>(classIrType)))->getSizeInBits();
1876 return sizeInBits;
1877 }

Declaration at line 304 of Emitter.hpp

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

GetClsIdValue Member Function

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

Definition at line 2151 of Emitter.cpp :
2152 {
2153 return nullptr;
2154 }

Declaration at line 353 of Emitter.hpp

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

GetColumn Member Function

int cmllvm::Emitter::GetColumn(const Span& span) const

Definition at line 285 of Emitter.cpp :
286 {
287     int column = 1;
288     if (columnSpanProvider)
289     {
290         column = columnSpanProvider->GetColumn(span);
291     }
292     return column;
293 }

Declaration at line 269 of Emitter.hpp

Calls: cmajor::common::ColumnSpanProvider::GetColumn

Called by: cmllvm::Emitter::CreateLexicalBlock , cmllvm::Emitter::GetDebugLocation

GetConversionValue Member Function

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

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

Declaration at line 99 of Emitter.hpp

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

GetCurrentDebugLocation Member Function

llvm::DebugLoc cmllvm::Emitter::GetCurrentDebugLocation()

Definition at line 283 of Emitter.hpp :
283 { return currentDebugLocation; }

Called by: cmllvm::Emitter::SetDebugLoc

GetCurrentScopeId Member Function

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

Definition at line 231 of Emitter.cpp :
232 {
233 return 0;
234 }

Declaration at line 254 of Emitter.hpp

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

GetDIMemberType Member Function

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

Definition at line 1194 of Emitter.cpp :
1195 {
1196     auto it = diMemberTypeMap.find(memberVariableId);
1197     if (it != diMemberTypeMap.cend())
1198     {
1199         return it->second;
1200     }
1201     return nullptr;
1202 }

Declaration at line 126 of Emitter.hpp

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

GetDITypeByTypeId Member Function

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

Definition at line 1175 of Emitter.cpp
Declaration at line 124 of Emitter.hpp

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

Called by: cmllvm::Emitter::ReplaceForwardDeclarations

GetDebugInfoForFile Member Function

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

GetDebugLocation Member Function

llvm::DebugLoc cmllvm::Emitter::GetDebugLocation(const Span& span)

Definition at line 468 of Emitter.cpp :
469 {
470     if (!diCompileUnit || !span.Valid() || !currentDIBuilder) return llvm::DebugLoc();
471     int column = GetColumn(span);
472     return llvm::DebugLoc::get(span.line, column, static_cast<llvm::DIScope*>(CurrentScope()));
473 }

Declaration at line 282 of Emitter.hpp

Calls: cmllvm::Emitter::CurrentScope , cmllvm::Emitter::GetColumn

Called by: cmllvm::Emitter::CreateCallInst , cmllvm::Emitter::CreateCallInstToBasicBlock , cmllvm::Emitter::CreateDIAutoVariable , cmllvm::Emitter::CreateDIParameterVariable , cmllvm::Emitter::CreateInvokeInst , cmllvm::Emitter::SetCurrentDebugLocation

GetDelegateFromClassDelegate Member Function

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

Definition at line 978 of Emitter.cpp :
979 {
980     ArgVector delegateIndeces;
981     delegateIndeces.push_back(builder.getInt32(0));
982     delegateIndeces.push_back(builder.getInt32(1));
983     llvm::Value* delegatePtr = builder.CreateGEP(static_cast<llvm::Value*>(classDelegatePtr), delegateIndeces);
984     return delegatePtr;
985 }

Declaration at line 212 of Emitter.hpp

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

GetFunctionArgument Member Function

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

Definition at line 2031 of Emitter.cpp :
2032 {
2033 auto it = static_cast<llvm::Function*>(function)->args().begin() + argumentIndex;
2034 return &*it;
2035 }

Declaration at line 321 of Emitter.hpp

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

GetFunctionFlags Member Function

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

Definition at line 1946 of Emitter.cpp
Declaration at line 313 of Emitter.hpp

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

GetFunctionIrType Member Function

void * cmllvm::Emitter::GetFunctionIrType(void * symbol) const override

Definition at line 1745 of Emitter.cpp
Declaration at line 288 of Emitter.hpp

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

GetGlobalStringPtr Member Function

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

Definition at line 347 of Emitter.hpp :
347 { return emittingDelegate->GetGlobalStringPtr(stringId); }

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

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

GetGlobalUStringConstant Member Function

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

Definition at line 349 of Emitter.hpp :
349 { return emittingDelegate->GetGlobalUStringConstant(stringId); }

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

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

GetGlobalUuidConstant Member Function

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

Definition at line 350 of Emitter.hpp :
350 { return emittingDelegate->GetGlobalUuidConstant(uuidId); }

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

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

GetGlobalWStringConstant Member Function

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

Definition at line 348 of Emitter.hpp :
348 { return emittingDelegate->GetGlobalWStringConstant(stringId); }

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

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

GetImt Member Function

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

Definition at line 1058 of Emitter.cpp :
1059 {
1060     ArgVector imtArrayIndeces;
1061     imtArrayIndeces.push_back(builder.getInt32(interfaceIndex));
1062     llvm::Value* imtArrayPtr = builder.CreateGEP(static_cast<llvm::Value*>(imtArray), imtArrayIndeces);
1063     llvm::Value* imt = builder.CreateLoad(imtArrayPtr);
1064     return imt;
1065 }

Declaration at line 220 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateLoad

GetImtArray Member Function

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

Definition at line 1047 of Emitter.cpp :
1048 {
1049     ArgVector imtsArrayIndeces;
1050     imtsArrayIndeces.push_back(builder.getInt32(0));
1051     imtsArrayIndeces.push_back(builder.getInt32(imtsVmtIndexOffset));
1052     llvm::Value* imtsArrayPtrPtr = builder.CreateGEP(static_cast<llvm::Value*>(vmtObjectPtr), imtsArrayIndeces);
1053     llvm::Value* imtsArrayPtr = builder.CreateBitCast(imtsArrayPtrPtr, llvm::PointerType::get(llvm::PointerType::get(builder.getInt8PtrTy(), 0), 0));
1054     llvm::Value* imtArray = builder.CreateLoad(imtsArrayPtr);
1055     return imtArray;
1056 }

Declaration at line 219 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBitCast , cmllvm::Emitter::CreateLoad

GetImtArrayObjectName Member Function

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

Definition at line 1855 of Emitter.cpp
Declaration at line 302 of Emitter.hpp

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

GetImtPtrFromInterface Member Function

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

Definition at line 1006 of Emitter.cpp :
1007 {
1008     ArgVector interfaceIndeces;
1009     interfaceIndeces.push_back(builder.getInt32(0));
1010     interfaceIndeces.push_back(builder.getInt32(1));
1011     llvm::Value* interfacePtrPtr = builder.CreateGEP(static_cast<llvm::Value*>(interfaceTypePtr), interfaceIndeces);
1012     llvm::Value* interfacePtr = builder.CreateLoad(interfacePtrPtr);
1013     llvm::Value* imtPtr = builder.CreateBitCast(interfacePtr, llvm::PointerType::get(builder.getInt8PtrTy(), 0));
1014     return imtPtr;
1015 }

Declaration at line 215 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBitCast , cmllvm::Emitter::CreateLoad

GetInterfaceMethod Member Function

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

Definition at line 1017 of Emitter.cpp :
1018 {
1019     ArgVector methodIndeces;
1020     methodIndeces.push_back(builder.getInt32(methodIndex));
1021     llvm::Value* methodPtrPtr = builder.CreateGEP(static_cast<llvm::Value*>(imtPtr), methodIndeces);
1022     llvm::Value* methodPtr = builder.CreateLoad(methodPtrPtr);
1023     llvm::Value* callee = builder.CreateBitCast(methodPtr, llvm::PointerType::get(static_cast<llvm::Type*>(interfaceMethodType), 0));
1024     return callee;
1025 }

Declaration at line 216 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBitCast , cmllvm::Emitter::CreateLoad

GetIrObject Member Function

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

Definition at line 1298 of Emitter.cpp
Declaration at line 286 of Emitter.hpp

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

GetIrTypeByTypeId Member Function

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

Definition at line 1316 of Emitter.cpp
Declaration at line 55 of Emitter.hpp

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

GetIrTypeForArrayType Member Function

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

Definition at line 131 of Emitter.cpp :
132 {
133 llvm::Type* elementIrType = static_cast<llvm::Type*>(elementType);
134 return llvm::ArrayType::get(elementIrType, size);
135 }

Declaration at line 48 of Emitter.hpp

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

GetIrTypeForBool Member Function

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

Definition at line 41 of Emitter.cpp :
  42 {
  43     return llvm::Type::getInt1Ty(context);
  44 }

Declaration at line 31 of Emitter.hpp

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

GetIrTypeForByte Member Function

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

Definition at line 51 of Emitter.cpp :
  52 {
  53     return llvm::Type::getInt8Ty(context);
  54 }

Declaration at line 33 of Emitter.hpp

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

GetIrTypeForChar Member Function

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

Definition at line 96 of Emitter.cpp :
  97 {
  98     return llvm::Type::getInt8Ty(context);
  99 }

Declaration at line 42 of Emitter.hpp

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

GetIrTypeForClassType Member Function

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

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

Declaration at line 49 of Emitter.hpp

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

GetIrTypeForDelegateType Member Function

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

Definition at line 163 of Emitter.cpp :
164 {
165     llvm::Type* returnType = static_cast<llvm::Type*>(retType);
166     std::vector<llvm::Type*> parameterTypes;
167     for (void* paramType : paramTypes)
168     {
169         parameterTypes.push_back(static_cast<llvm::Type*>(paramType));
170     }
171     return llvm::PointerType::get(llvm::FunctionType::get(returnType, parameterTypes, false), 0);
172 }

Declaration at line 52 of Emitter.hpp

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

GetIrTypeForDouble Member Function

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

Definition at line 91 of Emitter.cpp :
  92 {
  93     return llvm::Type::getDoubleTy(context);
  94 }

Declaration at line 41 of Emitter.hpp

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

GetIrTypeForFloat Member Function

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

Definition at line 86 of Emitter.cpp :
  87 {
  88     return llvm::Type::getFloatTy(context);
  89 }

Declaration at line 40 of Emitter.hpp

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

GetIrTypeForFunction Member Function

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

Definition at line 116 of Emitter.cpp :
117 {
118     std::vector<llvm::Type*> parameterTypes;
119     for (void* paramType : paramTypes)
120     {
121         parameterTypes.push_back(static_cast<llvm::Type*>(paramType));
122     }
123     return llvm::FunctionType::get(static_cast<llvm::Type*>(retType), parameterTypes, false);
124 }

Declaration at line 46 of Emitter.hpp

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

GetIrTypeForInt Member Function

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

Definition at line 66 of Emitter.cpp :
  67 {
  68     return llvm::Type::getInt32Ty(context);
  69 }

Declaration at line 36 of Emitter.hpp

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

GetIrTypeForLong Member Function

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

Definition at line 76 of Emitter.cpp :
  77 {
  78     return llvm::Type::getInt64Ty(context);
  79 }

Declaration at line 38 of Emitter.hpp

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

GetIrTypeForPtrType Member Function

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

Definition at line 1334 of Emitter.cpp :
1335 {
1336 return llvm::PointerType::get(static_cast<llvm::Type*>(baseIrType), 0);
1337 }

Declaration at line 57 of Emitter.hpp

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

GetIrTypeForSByte Member Function

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

Definition at line 46 of Emitter.cpp :
  47 {
  48     return llvm::Type::getInt8Ty(context);
  49 }

Declaration at line 32 of Emitter.hpp

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

GetIrTypeForShort Member Function

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

Definition at line 56 of Emitter.cpp :
  57 {
  58     return llvm::Type::getInt16Ty(context);
  59 }

Declaration at line 34 of Emitter.hpp

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

GetIrTypeForStructType Member Function

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

Definition at line 179 of Emitter.cpp :
180 {
181     std::vector<llvm::Type*> elementIrTypes;
182     for (void* elementType : elementTypes)
183     {
184         elementIrTypes.push_back(static_cast<llvm::Type*>(elementType));
185     }
186     return llvm::StructType::get(context, elementIrTypes);
187 }

Declaration at line 54 of Emitter.hpp

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

GetIrTypeForUChar Member Function

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

Definition at line 106 of Emitter.cpp :
107 {
108 return llvm::Type::getInt32Ty(context);
109 }

Declaration at line 44 of Emitter.hpp

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

GetIrTypeForUInt Member Function

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

Definition at line 71 of Emitter.cpp :
  72 {
  73     return llvm::Type::getInt32Ty(context);
  74 }

Declaration at line 37 of Emitter.hpp

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

GetIrTypeForULong Member Function

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

Definition at line 81 of Emitter.cpp :
  82 {
  83     return llvm::Type::getInt64Ty(context);
  84 }

Declaration at line 39 of Emitter.hpp

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

GetIrTypeForUShort Member Function

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

Definition at line 61 of Emitter.cpp :
  62 {
  63     return llvm::Type::getInt16Ty(context);
  64 }

Declaration at line 35 of Emitter.hpp

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

GetIrTypeForVariableParamFunction Member Function

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

Definition at line 126 of Emitter.cpp :
127 {
128 return llvm::FunctionType::get(static_cast<llvm::Type*>(retType), true);
129 }

Declaration at line 47 of Emitter.hpp

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

GetIrTypeForVoid Member Function

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

Definition at line 111 of Emitter.cpp :
112 {
113 return llvm::Type::getVoidTy(context);
114 }

Declaration at line 45 of Emitter.hpp

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

GetIrTypeForVoidPtrType Member Function

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

Definition at line 174 of Emitter.cpp :
175 {
176 return llvm::Type::getInt8PtrTy(context);
177 }

Declaration at line 53 of Emitter.hpp

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

GetIrTypeForWChar Member Function

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

Definition at line 101 of Emitter.cpp :
102 {
103 return llvm::Type::getInt16Ty(context);
104 }

Declaration at line 43 of Emitter.hpp

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

GetIrTypeName Member Function

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

Definition at line 1339 of Emitter.cpp :
1340 {
1341 return std::string();
1342 }

Declaration at line 58 of Emitter.hpp

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

GetMDStructId Member Function

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

Definition at line 2186 of Emitter.cpp :
2187 {
2188 return 0;
2189 }

Declaration at line 360 of Emitter.hpp

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

GetMDStructRefForSourceFile Member Function

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

Definition at line 2203 of Emitter.cpp :
2204 {
2205 return nullptr;
2206 }

Declaration at line 364 of Emitter.hpp

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

GetMemberVariablePtr Member Function

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

Definition at line 1067 of Emitter.cpp :
1068 {
1069     ArgVector indeces;
1070     indeces.push_back(builder.getInt32(0));
1071     indeces.push_back(builder.getInt32(memberVariableLayoutIndex));
1072     llvm::Value* memberVariablePtr = builder.CreateGEP(static_cast<llvm::Value*>(classPtr), indeces);
1073     return memberVariablePtr;
1074 }

Declaration at line 221 of Emitter.hpp

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

GetMethodPtr Member Function

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

Definition at line 1037 of Emitter.cpp :
1038 {
1039     ArgVector funPtrIndeces;
1040     funPtrIndeces.push_back(builder.getInt32(0));
1041     funPtrIndeces.push_back(builder.getInt32(vmtIndex));
1042     llvm::Value* funPtrPtr = builder.CreateGEP(static_cast<llvm::Value*>(vmtPtr), funPtrIndeces);
1043     void* funAsVoidPtr = builder.CreateLoad(funPtrPtr);
1044     return funAsVoidPtr;
1045 }

Declaration at line 218 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateLoad

GetNoFlags Member Function

uint32_t cmllvm::Emitter::GetNoFlags() override

Definition at line 1140 of Emitter.cpp :
1141 {
1142 return static_cast<uint32_t>(llvm::DINode::DIFlags::FlagZero);
1143 }

Declaration at line 230 of Emitter.hpp

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

GetObjectFromClassDelegate Member Function

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

Definition at line 969 of Emitter.cpp :
970 {
971     ArgVector objectIndeces;
972     objectIndeces.push_back(builder.getInt32(0));
973     objectIndeces.push_back(builder.getInt32(0));
974     llvm::Value* objectPtr = builder.CreateGEP(static_cast<llvm::Value*>(classDelegatePtr), objectIndeces);
975     return objectPtr;
976 }

Declaration at line 211 of Emitter.hpp

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

GetObjectFromInterface Member Function

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

Definition at line 987 of Emitter.cpp :
988 {
989     ArgVector objectIndeces;
990     objectIndeces.push_back(builder.getInt32(0));
991     objectIndeces.push_back(builder.getInt32(0));
992     llvm::Value* objectPtrPtr = builder.CreateGEP(static_cast<llvm::Value*>(interfaceTypePtr), objectIndeces);
993     llvm::Value* objectPtr = builder.CreateLoad(objectPtrPtr);
994     return objectPtr;
995 }

Declaration at line 213 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateLoad

GetObjectPointer Member Function

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

Definition at line 249 of Emitter.hpp :
249 { return objectPointer; }

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

GetObjectPtrFromInterface Member Function

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

Definition at line 997 of Emitter.cpp :
998 {
999     ArgVector objectIndeces;
1000     objectIndeces.push_back(builder.getInt32(0));
1001     objectIndeces.push_back(builder.getInt32(0));
1002     llvm::Value* objectPtrPtr = builder.CreateGEP(static_cast<llvm::Value*>(interfaceTypePtr), objectIndeces);
1003     return objectPtrPtr;
1004 }

Declaration at line 214 of Emitter.hpp

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

GetOffsetInBits Member Function

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

Definition at line 1694 of Emitter.cpp :
1695 {
1696     const llvm::StructLayout* structLayout = dataLayout->getStructLayout(llvm::cast<llvm::StructType>(static_cast<llvm::Type*>(classIrType)));
1697     uint64_t offsetInBits = structLayout->getElementOffsetInBits(layoutIndex);
1698     return offsetInBits;
1699 }

Declaration at line 117 of Emitter.hpp

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

GetOrInsertAnyComdat Member Function

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

Definition at line 794 of Emitter.cpp :
795 {
796     llvm::GlobalVariable* globalVar = llvm::cast<llvm::GlobalVariable>(static_cast<llvm::Constant*>(global));
797     llvm::Comdat* comdat = module->getOrInsertComdat(name);
798     comdat->setSelectionKind(llvm::Comdat::SelectionKind::Any);
799     globalVar->setComdat(comdat);
800     return comdat;
801 }

Declaration at line 196 of Emitter.hpp

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

GetOrInsertAnyFunctionComdat Member Function

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

Definition at line 803 of Emitter.cpp :
804 {
805     llvm::Comdat* comdat = module->getOrInsertComdat(name);
806     comdat->setSelectionKind(llvm::Comdat::SelectionKind::Any);
807     static_cast<llvm::Function*>(function)->setComdat(comdat);
808     return comdat;
809 }

Declaration at line 197 of Emitter.hpp

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

GetOrInsertFunction Member Function

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

Definition at line 823 of Emitter.cpp :
824 {
826 return module->getOrInsertFunction(name, static_cast<llvm::FunctionType*>(type)).getCallee();
828 return module->getOrInsertFunction(name, static_cast<llvm::FunctionType*>(type));
830 }

Declaration at line 200 of Emitter.hpp

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

GetOrInsertGlobal Member Function

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

Definition at line 789 of Emitter.cpp :
790 {
791 return module->getOrInsertGlobal(name, static_cast<llvm::Type*>(type));
792 }

Declaration at line 195 of Emitter.hpp

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

GetPrivateFlag Member Function

uint32_t cmllvm::Emitter::GetPrivateFlag() override

Definition at line 1125 of Emitter.cpp :
1126 {
1127 return static_cast<uint32_t>(llvm::DINode::DIFlags::FlagPrivate);
1128 }

Declaration at line 227 of Emitter.hpp

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

GetProtectedFlag Member Function

uint32_t cmllvm::Emitter::GetProtectedFlag() override

Definition at line 1130 of Emitter.cpp :
1131 {
1132 return static_cast<uint32_t>(llvm::DINode::DIFlags::FlagProtected);
1133 }

Declaration at line 228 of Emitter.hpp

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

GetPublicFlag Member Function

uint32_t cmllvm::Emitter::GetPublicFlag() override

Definition at line 1135 of Emitter.cpp :
1136 {
1137 return static_cast<uint32_t>(llvm::DINode::DIFlags::FlagPublic);
1138 }

Declaration at line 229 of Emitter.hpp

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

GetPureVirtualVirtuality Member Function

unsigned cmllvm::Emitter::GetPureVirtualVirtuality() override

Definition at line 1936 of Emitter.cpp :
1937 {
1938 return static_cast<unsigned>(llvm::dwarf::DW_VIRTUALITY_pure_virtual);
1939 }

Declaration at line 311 of Emitter.hpp

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

GetSizeInBits Member Function

uint64_t cmllvm::Emitter::GetSizeInBits(void * irType) override

Definition at line 1251 of Emitter.cpp :
1252 {
1253 return dataLayout->getTypeSizeInBits(static_cast<llvm::Type*>(irType));
1254 }

Declaration at line 135 of Emitter.hpp

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

GetSourceFilePath Member Function

std::string cmllvm::Emitter::GetSourceFilePath(const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 344 of Emitter.hpp :
344 { return emittingDelegate->GetSourceFilePath(span, moduleId); }

Calls: cmajor::ir::EmittingDelegate::GetSourceFilePath

Called by: cmllvm::Emitter::GetDebugInfoForFile

GetStaticObjectName Member Function

std::string cmllvm::Emitter::GetStaticObjectName(void * symbol) const override

Definition at line 1819 of Emitter.cpp
Declaration at line 298 of Emitter.hpp

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

GetStaticObjectType Member Function

void * cmllvm::Emitter::GetStaticObjectType(void * symbol) const override

Definition at line 1783 of Emitter.cpp
Declaration at line 294 of Emitter.hpp

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

GetVirtualVirtuality Member Function

unsigned cmllvm::Emitter::GetVirtualVirtuality() override

Definition at line 1941 of Emitter.cpp :
1942 {
1943 return static_cast<unsigned>(llvm::dwarf::DW_VIRTUALITY_virtual);
1944 }

Declaration at line 312 of Emitter.hpp

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

GetVmtObjectName Member Function

std::string cmllvm::Emitter::GetVmtObjectName(void * symbol) const override

Definition at line 1837 of Emitter.cpp
Declaration at line 300 of Emitter.hpp

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

GetVmtObjectType Member Function

void * cmllvm::Emitter::GetVmtObjectType(void * symbol) const override

Definition at line 1801 of Emitter.cpp
Declaration at line 296 of Emitter.hpp

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

GetVmtPtr Member Function

void * cmllvm::Emitter::GetVmtPtr(void * thisPtr, int32_t vmtPtrIndex, void * vmtPtrType) override

Definition at line 1027 of Emitter.cpp :
1028 {
1029     ArgVector vmtPtrIndeces;
1030     vmtPtrIndeces.push_back(builder.getInt32(0));
1031     vmtPtrIndeces.push_back(builder.getInt32(vmtPtrIndex));
1032     llvm::Value* vmtPtrPtr = builder.CreateGEP(static_cast<llvm::Value*>(thisPtr), vmtPtrIndeces);
1033     void* vmtPtr = builder.CreateBitCast(builder.CreateLoad(vmtPtrPtr), static_cast<llvm::Type*>(vmtPtrType));
1034     return vmtPtr;
1035 }

Declaration at line 217 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateBitCast , cmllvm::Emitter::CreateLoad

HandlerBlock Member Function

void * cmllvm::Emitter::HandlerBlock() override

Definition at line 340 of Emitter.hpp :
340 { return emittingDelegate->HandlerBlock(); }

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

Calls: cmajor::ir::EmittingDelegate::HandlerBlock

Install Member Function

int cmllvm::Emitter::Install(const std::string& str) override

Definition at line 2216 of Emitter.cpp :
2217 {
2218 return emittingDelegate->Install(str);
2219 }

Declaration at line 367 of Emitter.hpp

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

Calls: cmajor::ir::EmittingDelegate::Install

Install Member Function

int cmllvm::Emitter::Install(const std::u16string& str) override

Definition at line 2221 of Emitter.cpp :
2222 {
2223 return emittingDelegate->Install(str);
2224 }

Declaration at line 368 of Emitter.hpp

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

Calls: cmajor::ir::EmittingDelegate::Install

Install Member Function

int cmllvm::Emitter::Install(const std::u32string& str) override

Definition at line 2226 of Emitter.cpp :
2227 {
2228 return emittingDelegate->Install(str);
2229 }

Declaration at line 369 of Emitter.hpp

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

Calls: cmajor::ir::EmittingDelegate::Install

IsStaticObjectCreated Member Function

bool cmllvm::Emitter::IsStaticObjectCreated(void * symbol) const override

Definition at line 1773 of Emitter.cpp :
1774 {
1775 return staticObjectCreatedSet.find(symbol) != staticObjectCreatedSet.cend();
1776 }

Declaration at line 292 of Emitter.hpp

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

IsVmtObjectCreated Member Function

bool cmllvm::Emitter::IsVmtObjectCreated(void * symbol) const override

Definition at line 1763 of Emitter.cpp :
1764 {
1765 return vmtObjectCreatedSet.find(symbol) != vmtObjectCreatedSet.cend();
1766 }

Declaration at line 290 of Emitter.hpp

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

MakeVmtVariableName Member Function

std::string cmllvm::Emitter::MakeVmtVariableName(const std::string& vmtObjectName) override

Definition at line 1344 of Emitter.cpp :
1345 {
1346 return std::string();
1347 }

Declaration at line 59 of Emitter.hpp

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

MapClassPtr Member Function

void cmllvm::Emitter::MapClassPtr(const boost::uuids::uuid& typeId, void * classPtr, const std::string& className) override

Definition at line 1242 of Emitter.cpp :
1243 {
1244     if (classPtrMap.find(typeId) == classPtrMap.cend())
1245     {
1246         classPtrMap[typeId] = classPtr;
1247         classNameMap[classPtr] = className;
1248     }
1249 }

Declaration at line 134 of Emitter.hpp

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

MapFwdDeclaration Member Function

void cmllvm::Emitter::MapFwdDeclaration(void * fwdDeclaration, const boost::uuids::uuid& typeId) override

Definition at line 206 of Emitter.cpp :
207 {
208 fwdDeclarationMap[static_cast<llvm::DIType*>(fwdDeclaration)] = typeId;
209 }

Declaration at line 123 of Emitter.hpp

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

Module Member Function

llvm::Module* cmllvm::Emitter::Module()

Definition at line 236 of Emitter.hpp :
236 { return module; }

MoveAllocaIntoBasicBlock Member Function

void cmllvm::Emitter::MoveAllocaIntoBasicBlock(void * allocaInst, void * lastAlloca, void * basicBlock) override

Definition at line 2243 of Emitter.cpp
Declaration at line 372 of Emitter.hpp

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

NewCleanupNeeded Member Function

bool cmllvm::Emitter::NewCleanupNeeded() override

Definition at line 342 of Emitter.hpp :
342 { return emittingDelegate->NewCleanupNeeded(); }

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

Calls: cmajor::ir::EmittingDelegate::NewCleanupNeeded

Optimize Member Function

void cmllvm::Emitter::Optimize(const std::string& bcFilePath, const std::string& optBCFilePath, const std::string& optimizationFlags) override

Definition at line 345 of Emitter.cpp
Declaration at line 276 of Emitter.hpp

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

Calls: soulng::util::Process::ExitCode , soulng::util::Process::ReadToEnd , soulng::util::Process::WaitForExit

PopParentBlock Member Function

void cmllvm::Emitter::PopParentBlock() override

Definition at line 529 of Emitter.cpp :
530 {
531 }

Declaration at line 143 of Emitter.hpp

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

PopScope Member Function

void cmllvm::Emitter::PopScope() override

Definition at line 270 of Emitter.cpp :
271 {
272 scopes.pop_back();
273 }

Declaration at line 267 of Emitter.hpp

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

Called by: cmllvm::Emitter::EndDebugInfo

PushParentBlock Member Function

void cmllvm::Emitter::PushParentBlock() override

Definition at line 525 of Emitter.cpp :
526 {
527 }

Declaration at line 142 of Emitter.hpp

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

PushScope Member Function

void cmllvm::Emitter::PushScope(void * scope) override

Definition at line 265 of Emitter.cpp :
266 {
267 scopes.push_back(static_cast<llvm::DIScope*>(scope));
268 }

Declaration at line 266 of Emitter.hpp

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

Called by: cmllvm::Emitter::CreateLexicalBlock , cmllvm::Emitter::StartDebugInfo

ReplaceForwardDeclarations Member Function

void cmllvm::Emitter::ReplaceForwardDeclarations()

Definition at line 1261 of Emitter.cpp
Declaration at line 285 of Emitter.hpp

Calls: cmllvm::Emitter::CreateClassDIType , cmllvm::Emitter::GetDITypeByTypeId

Called by: cmllvm::Emitter::FinalizeDebugInfo

ResetCurrentDebugLocation Member Function

void cmllvm::Emitter::ResetCurrentDebugLocation() override

Definition at line 475 of Emitter.cpp :
476 {
477 currentDebugLocation = llvm::DebugLoc();
478 builder.SetCurrentDebugLocation(currentDebugLocation);
479 }

Declaration at line 281 of Emitter.hpp

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

Calls: cmllvm::Emitter::SetCurrentDebugLocation

SaveObjectPointer Member Function

void cmllvm::Emitter::SaveObjectPointer(void * objectPointer_) override

Definition at line 211 of Emitter.cpp :
212 {
213     if (objectPointer == nullptr)
214     {
215         objectPointer = static_cast<llvm::Value*>(objectPointer_);
216     }
217 }

Declaration at line 247 of Emitter.hpp

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

SetBoundCompileUnit Member Function

void cmllvm::Emitter::SetBoundCompileUnit(void * boundCompileUnit_) override

Definition at line 381 of Emitter.hpp :
381 { }

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

SetCleanupBlock Member Function

void cmllvm::Emitter::SetCleanupBlock(void * cleanupBlock) override

Definition at line 537 of Emitter.cpp :
538 {
539 }

Declaration at line 145 of Emitter.hpp

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

SetColumnSpanProvider Member Function

void cmllvm::Emitter::SetColumnSpanProvider(ColumnSpanProvider * columnSpanProvider_) override

Definition at line 246 of Emitter.hpp :
246 { columnSpanProvider = columnSpanProvider_; }

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

Called by: cmllvm::Emitter::StartDebugInfo

SetCompileUnitId Member Function

void cmllvm::Emitter::SetCompileUnitId(const std::string& compileUnitId_) override

Definition at line 2146 of Emitter.cpp :
2147 {
2148 compileUnitId = compileUnitId_;
2149 }

Declaration at line 352 of Emitter.hpp

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

SetCurrentBasicBlock Member Function

void cmllvm::Emitter::SetCurrentBasicBlock(void * currentBasicBlock_) override

Definition at line 264 of Emitter.hpp :
264 { currentBasicBlock = static_cast<llvm::BasicBlock*>(currentBasicBlock_); builder.SetInsertPoint(currentBasicBlock); }

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

SetCurrentControlFlowGraphNodeId Member Function

void cmllvm::Emitter::SetCurrentControlFlowGraphNodeId(int32_t controlFlowGraphNodeId) override

Definition at line 245 of Emitter.cpp :
246 {
247 }

Declaration at line 257 of Emitter.hpp

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

SetCurrentDIBuilder Member Function

void cmllvm::Emitter::SetCurrentDIBuilder(void * diBuilder_) override

Definition at line 210 of Emitter.hpp :
210 { currentDIBuilder = static_cast<llvm::DIBuilder*>(diBuilder_); }

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

SetCurrentDebugLocation Member Function

void cmllvm::Emitter::SetCurrentDebugLocation(const Span& span) override

Definition at line 481 of Emitter.cpp
Declaration at line 137 of Emitter.hpp

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

Calls: cmllvm::Emitter::GetDebugLocation , cmllvm::Emitter::SetCurrentDebugLocation

Called by: cmllvm::Emitter::ResetCurrentDebugLocation , cmllvm::Emitter::SetCurrentDebugLocation

SetCurrentScopeId Member Function

void cmllvm::Emitter::SetCurrentScopeId(int16_t scopeId) override

Definition at line 236 of Emitter.cpp :
237 {
238 }

Declaration at line 255 of Emitter.hpp

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

SetCurrentSourceSpan Member Function

void cmllvm::Emitter::SetCurrentSourceSpan(int32_t line, int16_t scol, int16_t ecol) override

Definition at line 2199 of Emitter.cpp :
2200 {
2201 }

Declaration at line 363 of Emitter.hpp

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

SetDICompileUnit Member Function

void cmllvm::Emitter::SetDICompileUnit(void * diCompileUnit_) override

Definition at line 244 of Emitter.hpp :
244 { diCompileUnit = static_cast<llvm::DICompileUnit*>(diCompileUnit_); }

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

Called by: cmllvm::Emitter::StartDebugInfo

SetDIFile Member Function

void cmllvm::Emitter::SetDIFile(void * diFile_) override

Definition at line 1155 of Emitter.cpp :
1156 {
1157 diFile = static_cast<llvm::DIFile*>(diFile_);
1158 }

Declaration at line 245 of Emitter.hpp

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

Called by: cmllvm::Emitter::StartDebugInfo

SetDIMemberType Member Function

void cmllvm::Emitter::SetDIMemberType(const std::pair<boost::uuids::uuid, int32_t>& memberVariableId, void * diType) override

Definition at line 1204 of Emitter.cpp :
1205 {
1206 diMemberTypeMap[memberVariableId] = static_cast<llvm::DIDerivedType*>(diType);
1207 }

Declaration at line 127 of Emitter.hpp

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

SetDISubprogram Member Function

void cmllvm::Emitter::SetDISubprogram(void * function, void * subprogram) override

Definition at line 2002 of Emitter.cpp :
2003 {
2004 static_cast<llvm::Function*>(function)->setSubprogram(static_cast<llvm::DISubprogram*>(subprogram));
2005 }

Declaration at line 317 of Emitter.hpp

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

SetDITypeByTypeId Member Function

void cmllvm::Emitter::SetDITypeByTypeId(const boost::uuids::uuid& typeId, void * diType, const std::string& typeName) override

Definition at line 1188 of Emitter.cpp :
1189 {
1190 diTypeTypeIdMap[typeId] = static_cast<llvm::DIType*>(diType);
1191 diTypeNameMap[static_cast<llvm::DIType*>(diType)] = typeName;
1192 }

Declaration at line 125 of Emitter.hpp

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

SetDataLayout Member Function

void cmllvm::Emitter::SetDataLayout(void * dataLayout_) override

Definition at line 242 of Emitter.hpp :
242 { dataLayout = static_cast<llvm::DataLayout*>(dataLayout_); module->setDataLayout(*dataLayout); }

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

SetDebugLoc Member Function

void cmllvm::Emitter::SetDebugLoc(void * callInst) override

Definition at line 2037 of Emitter.cpp :
2038 {
2039 static_cast<llvm::CallInst*>(callInst)->setDebugLoc(GetCurrentDebugLocation());
2040 }

Declaration at line 322 of Emitter.hpp

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

Calls: cmllvm::Emitter::GetCurrentDebugLocation

SetEmittingDelegate Member Function

void cmllvm::Emitter::SetEmittingDelegate(EmittingDelegate * emittingDelegate_) override

Definition at line 30 of Emitter.hpp :
30 { emittingDelegate = emittingDelegate_; }

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

SetFunction Member Function

void cmllvm::Emitter::SetFunction(void * function_, int32_t fileIndex, const boost::uuids::uuid& sourceModuleId, const boost::uuids::uuid& functionId) override

Definition at line 250 of Emitter.hpp :
250 { function = static_cast<llvm::Function*>(function_); }

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

SetFunctionCallConventionToStdCall Member Function

void cmllvm::Emitter::SetFunctionCallConventionToStdCall(void * function) override

Definition at line 1918 of Emitter.cpp :
1919 {
1920 llvm::Function* fun = static_cast<llvm::Function*>(function);
1921 fun->setCallingConv(llvm::CallingConv::X86_StdCall);
1923 }

Declaration at line 309 of Emitter.hpp

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

SetFunctionIrType Member Function

void cmllvm::Emitter::SetFunctionIrType(void * symbol, void * irType) override

Definition at line 1758 of Emitter.cpp :
1759 {
1760 functionIrTypeMap[symbol] = static_cast<llvm::FunctionType*>(irType);
1761 }

Declaration at line 289 of Emitter.hpp

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

SetFunctionLinkage Member Function

void cmllvm::Emitter::SetFunctionLinkage(void * function, bool setInline) override

Definition at line 1903 of Emitter.cpp :
1904 {
1905     llvm::Function* fun = static_cast<llvm::Function*>(function);
1906     if (setInline)
1907     {
1908         fun->setLinkage(llvm::GlobalValue::LinkageTypes::WeakODRLinkage);
1909     }
1910 }

Declaration at line 307 of Emitter.hpp

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

SetFunctionLinkageToLinkOnceODRLinkage Member Function

void cmllvm::Emitter::SetFunctionLinkageToLinkOnceODRLinkage(void * function) override

Definition at line 1912 of Emitter.cpp :
1913 {
1914 llvm::Function* fun = static_cast<llvm::Function*>(function);
1915 fun->setLinkage(llvm::GlobalValue::LinkageTypes::LinkOnceODRLinkage);
1916 }

Declaration at line 308 of Emitter.hpp

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

SetFunctionMdId Member Function

void cmllvm::Emitter::SetFunctionMdId(void * function, int mdId) override

Definition at line 2195 of Emitter.cpp :
2196 {
2197 }

Declaration at line 362 of Emitter.hpp

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

SetFunctionName Member Function

void cmllvm::Emitter::SetFunctionName(const std::string& functionName) override

Definition at line 219 of Emitter.cpp :
220 {
221 }

Declaration at line 251 of Emitter.hpp

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

SetFwdIrTypeBody Member Function

void cmllvm::Emitter::SetFwdIrTypeBody(void * forwardDeclaredType, const std::vector<void *>& elementTypes) override

Definition at line 152 of Emitter.cpp :
153 {
154     llvm::StructType* structType = static_cast<llvm::StructType*>(forwardDeclaredType);
155     std::vector<llvm::Type*> elementIrTypes;
156     for (void* elementType : elementTypes)
157     {
158         elementIrTypes.push_back(static_cast<llvm::Type*>(elementType));
159     }
160     structType->setBody(elementIrTypes);
161 }

Declaration at line 51 of Emitter.hpp

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

SetHandlerBlock Member Function

void cmllvm::Emitter::SetHandlerBlock(void * tryBlock, void * catchBlock) override

Definition at line 533 of Emitter.cpp :
534 {
535 }

Declaration at line 144 of Emitter.hpp

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

SetImtArrayObjectName Member Function

void cmllvm::Emitter::SetImtArrayObjectName(void * symbol, const std::string& imtArrayObjectName) override

Definition at line 1868 of Emitter.cpp :
1869 {
1870 imtArrayObjectNameMap[symbol] = imtArrayObjectName;
1871 }

Declaration at line 303 of Emitter.hpp

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

SetInPrologue Member Function

void cmllvm::Emitter::SetInPrologue(bool inPrologue_) override

Definition at line 265 of Emitter.hpp :
265 { inPrologue = inPrologue_; }

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

SetInitializer Member Function

void cmllvm::Emitter::SetInitializer(void * global, void * initializer) override

Definition at line 811 of Emitter.cpp :
812 {
813 llvm::GlobalVariable* globalVar = llvm::cast<llvm::GlobalVariable>(static_cast<llvm::Constant*>(global));
814 globalVar->setInitializer(static_cast<llvm::Constant*>(initializer));
815 }

Declaration at line 198 of Emitter.hpp

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

SetIrObject Member Function

void cmllvm::Emitter::SetIrObject(void * symbol, void * irObject) override

Definition at line 1311 of Emitter.cpp :
1312 {
1313 irObjectMap[symbol] = static_cast<llvm::Value*>(irObject);
1314 }

Declaration at line 287 of Emitter.hpp

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

SetIrTypeByTypeId Member Function

void cmllvm::Emitter::SetIrTypeByTypeId(const boost::uuids::uuid& typeId, void * irType) override

Definition at line 1329 of Emitter.cpp :
1330 {
1331 irTypeTypeIdMap[typeId] = static_cast<llvm::Type*>(irType);
1332 }

Declaration at line 56 of Emitter.hpp

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

SetLandindPadAsCleanup Member Function

void cmllvm::Emitter::SetLandindPadAsCleanup(void * landingPad) override

Definition at line 2237 of Emitter.cpp :
2238 {
2239 llvm::LandingPadInst* lp = static_cast<llvm::LandingPadInst*>(landingPad);
2240 lp->setCleanup(true);
2241 }

Declaration at line 371 of Emitter.hpp

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

SetLineNumber Member Function

void cmllvm::Emitter::SetLineNumber(int32_t lineNumber) override

Definition at line 339 of Emitter.hpp :
339 { emittingDelegate->SetLineNumber(lineNumber); }

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

Calls: cmajor::ir::EmittingDelegate::SetLineNumber

SetMetadataRef Member Function

void cmllvm::Emitter::SetMetadataRef(void * inst, void * mdStructRef) override

Definition at line 2208 of Emitter.cpp :
2209 {
2210 }

Declaration at line 365 of Emitter.hpp

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

SetModule Member Function

void cmllvm::Emitter::SetModule(void * module_) override

Definition at line 233 of Emitter.hpp :
233 { module = static_cast<llvm::Module*>(module_); }

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

SetObjectPointer Member Function

void cmllvm::Emitter::SetObjectPointer(void * objectPointer_) override

Definition at line 248 of Emitter.hpp :
248 { objectPointer = static_cast<llvm::Value*>(objectPointer_); }

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

SetPersonalityFunction Member Function

void cmllvm::Emitter::SetPersonalityFunction(void * function, void * personalityFunction) override

Definition at line 2052 of Emitter.cpp :
2053 {
2054 static_cast<llvm::Function*>(function)->setPersonalityFn(llvm::ConstantExpr::getBitCast(static_cast<llvm::Function*>(personalityFunction), builder.getInt8PtrTy()));
2055 }

Declaration at line 325 of Emitter.hpp

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

SetPrivateLinkage Member Function

void cmllvm::Emitter::SetPrivateLinkage(void * global) override

Definition at line 817 of Emitter.cpp :
818 {
819 llvm::GlobalVariable* globalVar = llvm::cast<llvm::GlobalVariable>(static_cast<llvm::Constant*>(global));
820 globalVar->setLinkage(llvm::GlobalValue::PrivateLinkage);
821 }

Declaration at line 199 of Emitter.hpp

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

SetSourceFileName Member Function

void cmllvm::Emitter::SetSourceFileName(const std::string& sourceFileName) override

Definition at line 243 of Emitter.hpp :
243 { module->setSourceFileName(sourceFileName); }

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

SetStaticObjectCreated Member Function

void cmllvm::Emitter::SetStaticObjectCreated(void * symbol) override

Definition at line 1778 of Emitter.cpp :
1779 {
1780 staticObjectCreatedSet.insert(symbol);
1781 }

Declaration at line 293 of Emitter.hpp

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

SetStaticObjectName Member Function

void cmllvm::Emitter::SetStaticObjectName(void * symbol, const std::string& staticObjectName) override

Definition at line 1832 of Emitter.cpp :
1833 {
1834 staticObjectNameMap[symbol] = staticObjectName;
1835 }

Declaration at line 299 of Emitter.hpp

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

SetStaticObjectType Member Function

void cmllvm::Emitter::SetStaticObjectType(void * symbol, void * type) override

Definition at line 1796 of Emitter.cpp :
1797 {
1798 staticTypeMap[symbol] = static_cast<llvm::StructType*>(type);
1799 }

Declaration at line 295 of Emitter.hpp

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

SetTargetTriple Member Function

void cmllvm::Emitter::SetTargetTriple(const std::string& targetTriple) override

Definition at line 241 of Emitter.hpp :
241 { module->setTargetTriple(targetTriple); }

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

SetVmtObjectCreated Member Function

void cmllvm::Emitter::SetVmtObjectCreated(void * symbol) override

Definition at line 1768 of Emitter.cpp :
1769 {
1770 vmtObjectCreatedSet.insert(symbol);
1771 }

Declaration at line 291 of Emitter.hpp

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

SetVmtObjectName Member Function

void cmllvm::Emitter::SetVmtObjectName(void * symbol, const std::string& vmtObjectName) override

Definition at line 1850 of Emitter.cpp :
1851 {
1852 vmtObjectNameMap[symbol] = vmtObjectName;
1853 }

Declaration at line 301 of Emitter.hpp

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

SetVmtObjectType Member Function

void cmllvm::Emitter::SetVmtObjectType(void * symbol, void * vmtObjectType) override

Definition at line 1814 of Emitter.cpp :
1815 {
1816 vmtObjectTypeMap[symbol] = static_cast<llvm::ArrayType*>(vmtObjectType);
1817 }

Declaration at line 297 of Emitter.hpp

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

SizeOf Member Function

void * cmllvm::Emitter::SizeOf(void * ptrType) override

Definition at line 1076 of Emitter.cpp :
1077 {
1078     void* nullPtr = CreateDefaultIrValueForPtrType(static_cast<llvm::Type*>(ptrType));
1079     llvm::Value* gep = builder.CreateGEP(static_cast<llvm::Value*>(nullPtr), builder.getInt64(1));
1080     llvm::Value* size = builder.CreatePtrToInt(gep, builder.getInt64Ty());
1081     return size;
1082 }

Declaration at line 222 of Emitter.hpp

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

Calls: cmllvm::Emitter::CreateDefaultIrValueForPtrType , cmllvm::Emitter::CreatePtrToInt

Stack Member Function

ValueStack & cmllvm::Emitter::Stack()

Definition at line 240 of Emitter.hpp :
240 { return stack; }

StartDebugInfo Member Function

void cmllvm::Emitter::StartDebugInfo(const std::string& sourceFilePath, const std::string& compilerVersion, bool optimized, ColumnSpanProvider * columnSpanProvider_) override

Definition at line 295 of Emitter.cpp
Declaration at line 270 of Emitter.hpp

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

Calls: cmllvm::Emitter::PushScope , cmllvm::Emitter::SetColumnSpanProvider , cmllvm::Emitter::SetDICompileUnit , cmllvm::Emitter::SetDIFile , soulng::util::Path::GetDirectoryName , soulng::util::Path::GetFileName

VerifyModule Member Function

void cmllvm::Emitter::VerifyModule() override

Definition at line 434 of Emitter.cpp :
435 {
436     std::string errorMessageStore;
437     llvm::raw_string_ostream errorMessage(errorMessageStore);
438     if (llvm::verifyModule(*module, &errorMessage))
439     {
440         throw std::runtime_error("Emitter: verification of module '" + module->getSourceFileName() + "' failed. " + errorMessage.str());
441     }
442 }

Declaration at line 279 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

cmllvm::Emitter::Emitter(llvm::LLVMContext& context_, EmittingContext & emittingContext_)

Member Function Details

AddCase Member Function

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

AddClauseToLangdingPad Member Function

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

AddControlFlowGraphEdge Member Function

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

AddControlFlowGraphNode Member Function

int32_t cmllvm::Emitter::AddControlFlowGraphNode() override

AddHandlerToCatchSwitch Member Function

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

AddInlineFunctionAttribute Member Function

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

AddLocalVariable Member Function

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

AddMDItem Member Function

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

AddNoUnwindAttribute Member Function

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

AddUWTableAttribute Member Function

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

BeginInstructionFlag Member Function

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

BeginScope Member Function

void cmllvm::Emitter::BeginScope() override

BeginSubstituteLineNumber Member Function

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

Builder Member Function

llvm::IRBuilder& cmllvm::Emitter::Builder()

CleanupBlock Member Function

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

Compile Member Function

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

ComputeAddress Member Function

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

Context Member Function

llvm::LLVMContext& cmllvm::Emitter::Context()

CreateAShr Member Function

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

CreateAdd Member Function

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

CreateAlloca Member Function

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

CreateAnd Member Function

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

CreateArrayIndexAddress Member Function

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

CreateBasicBlock Member Function

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

CreateBeginCatch Member Function

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

CreateBeginTry Member Function

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

CreateBitCast Member Function

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

CreateBr Member Function

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

CreateCall Member Function

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

CreateCallInst Member Function

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

CreateCallInstToBasicBlock Member Function

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

CreateCatchPad Member Function

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

CreateCatchRet Member Function

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

CreateCatchSwitch Member Function

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

CreateCatchSwitchWithParent Member Function

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

CreateClassDIType Member Function

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

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

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

void * cmllvm::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 * cmllvm::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 * cmllvm::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