Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CGVTables_8cpp_source.html below:

clang: lib/CodeGen/CGVTables.cpp Source File

;

CodeGen;

: CGM(CGM), VTContext(CGM.getContext().getVTableContext()) {}

GetOrCreateLLVMFunction(Name, FnTy, GD,

,

llvm::Function *ThunkFn,

ForVTable,

ThunkFn->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);

ThunkFn->setDSOLocal(

);

ThunkFn->setComdat(CGM.

().getOrInsertComdat(ThunkFn->getName()));

(isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||

(isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));

llvm::BasicBlock *AdjustNull =

;

llvm::BasicBlock *AdjustNotNull =

;

llvm::BasicBlock *AdjustEnd =

;

CGF.

.CreateCondBr(

, AdjustNull, AdjustNotNull);

ClassDecl, Thunk.

);

CGF.

.CreateBr(AdjustEnd);

CGF.

.CreateBr(AdjustEnd);

llvm::PHINode *PHI = CGF.

.CreatePHI(ReturnValue->getType(), 2);

PHI->addIncoming(ReturnValue, AdjustNotNull);

PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),

llvm::ValueToValueMapTy &VMap) {

*DIS = Fn->getSubprogram();

*NewDIS = DIS->replaceWithDistinct(DIS->clone());

VMap.MD()[DIS].reset(NewDIS);

(

&BB : *Fn) {

(

&I : BB) {

(llvm::DbgVariableRecord &DVR :

llvm::filterDbgVars(I.getDbgRecordRange())) {

*DILocal = DVR.getVariable();

(!DILocal->isResolved())

(

*DII = dyn_cast<llvm::DbgVariableIntrinsic>(&I)) {

*DILocal = DII->getVariable();

(!DILocal->isResolved())

llvm::Function *BaseFn = cast<llvm::Function>(Callee);

assert(!BaseFn->isDeclaration() &&

);

llvm::ValueToValueMapTy VMap;

llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap);

->replaceAllUsesWith(NewFn);

->eraseFromParent();

llvm::Function::arg_iterator AI =

->arg_begin();

llvm::BasicBlock *EntryBB = &

->front();

llvm::BasicBlock::iterator ThisStore =

llvm::find_if(*EntryBB, [&](llvm::Instruction &I) {

isa<llvm::StoreInst>(I) && I.getOperand(0) == &*AI;

assert(ThisStore != EntryBB->end() &&

);

.SetInsertPoint(&*ThisStore);

*

, ThisPtr, ThisValueClass, Thunk);

AdjustedThisPtr =

.CreateBitCast(AdjustedThisPtr,

ThisStore->getOperand(0)->getType());

ThisStore->setOperand(0, AdjustedThisPtr);

(llvm::BasicBlock &BB : *Fn) {

llvm::Instruction *

= BB.getTerminator();

(isa<llvm::ReturnInst>(

)) {

->eraseFromParent();

IsUnprototyped) {

assert(!

.

() &&

);

ResultType = ThisType;

(!IsUnprototyped) {

(isa<CXXDestructorDecl>(MD))

CXXThisValue = CXXABIThisValue;

IsUnprototyped) {

);

llvm::Value *AdjustedThisPtr =

ThisValueClass, *Thunk)

MD,

);

llvm_unreachable(

);

MD,

);

(isa<CXXDestructorDecl>(MD))

PrefixArgs = CallArgs.size() - 1;

assert(isa<CXXDestructorDecl>(MD) ||

(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),

assert(

(CallFnInfo.arg_begin()[i].info,

CallFnInfo.arg_begin()[i].type,

llvm::CallBase *CallOrInvoke;

CallArgs, &CallOrInvoke);

(llvm::CallInst*

= dyn_cast<llvm::CallInst>(CallOrInvoke))

->setTailCallKind(llvm::CallInst::TCK_Tail);

llvm::Value *AdjustedThisPtr,

llvm::FunctionCallee Callee) {

llvm::Type *ThisType = Args[ThisArgNo]->getType();

(ThisType != AdjustedThisPtr->getType())

AdjustedThisPtr =

.CreateBitCast(AdjustedThisPtr, ThisType);

Args[ThisArgNo] = AdjustedThisPtr;

assert(ThisAI.

() &&

);

(ThisType != AdjustedThisPtr->getType())

AdjustedThisPtr =

.CreateBitCast(AdjustedThisPtr, ThisType);

llvm::CallInst *

=

.CreateCall(Callee, Args);

->setTailCallKind(llvm::CallInst::TCK_MustTail);

llvm::AttributeList Attrs;

->setAttributes(Attrs);

->setCallingConv(

llvm::CallingConv::ID

(

));

(

->getType()->isVoidTy())

IsUnprototyped) {

&Thunk, IsUnprototyped);

IsUnprototyped,

ForVTable) {

CGM.

().OptimizationLevel && !IsUnprototyped;

llvm::Constant *CodeGenVTables::maybeEmitThunk(

GD,

llvm::raw_svector_ostream Out(Name);

llvm::Constant *Thunk = CGM.

(Name, ThunkVTableTy, GD);

llvm::Function *ThunkFn = cast<llvm::Function>(Thunk->stripPointerCasts());

(ThunkFn->getFunctionType() != ThunkFnTy) {

llvm::GlobalValue *OldThunkFn = ThunkFn;

assert(OldThunkFn->isDeclaration() &&

);

OldThunkFn->setName(StringRef());

ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage,

(!OldThunkFn->use_empty()) {

OldThunkFn->replaceAllUsesWith(ThunkFn);

OldThunkFn->eraseFromParent();

UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions;

(!ThunkFn->isDeclaration()) {

(!ABIHasKeyFunctions || UseAvailableExternallyLinkage) {

ThunkFn->addFnAttr(

);

ShouldCloneVarArgs =

;

(!IsUnprototyped && ThunkFn->isVarArg()) {

ShouldCloneVarArgs =

;

llvm::Triple::x86_64:

llvm::Triple::x86:

llvm::Triple::aarch64:

ShouldCloneVarArgs =

;

(ShouldCloneVarArgs) {

(UseAvailableExternallyLinkage)

(!ThunkInfoVector)

(

& Thunk : *ThunkInfoVector)

maybeEmitThunk(GD, Thunk,

);

llvm::Constant *component,

vtableAddressPoint,

vtableHasLocalLinkage,

isCompleteDtor)

{

(component->isNullValue())

builder.add(llvm::ConstantInt::get(CGM.

, 0));

cast<llvm::GlobalValue>(component->stripPointerCastsAndAliases());

llvm::Module &module = CGM.

();

stubLinkage = vtableHasLocalLinkage

? llvm::GlobalValue::InternalLinkage

: llvm::GlobalValue::LinkOnceODRLinkage;

llvm::Constant *target;

(

*func = dyn_cast<llvm::Function>(globalVal)) {

target = llvm::DSOLocalEquivalent::get(func);

rttiProxyName.append(

);

llvm::GlobalVariable *proxy = module.getNamedGlobal(rttiProxyName);

proxy =

llvm::GlobalVariable(module, globalVal->getType(),

globalVal, rttiProxyName);

proxy->setDSOLocal(

);

proxy->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

(!proxy->hasLocalLinkage()) {

proxy->setVisibility(llvm::GlobalValue::HiddenVisibility);

proxy->setComdat(module.getOrInsertComdat(rttiProxyName));

builder.addRelativeOffsetToPosition(CGM.

, target,

CodeGenVTables::useRelativeLayout()

{

llvm::Type *CodeGenVTables::getVTableComponentType()

{

builder.add(llvm::ConstantExpr::getIntToPtr(

componentIndex,

llvm::Constant *rtti,

&nextVTableThunkIndex,

vtableAddressPoint,

vtableHasLocalLinkage) {

addOffsetConstant =

(component.getKind()) {

addOffsetConstant(CGM, builder, component.getVCallOffset());

addOffsetConstant(CGM, builder, component.getVBaseOffset());

addOffsetConstant(CGM, builder, component.getOffsetToTop());

(useRelativeLayout())

addRelativeComponent(builder, rtti, vtableAddressPoint,

vtableHasLocalLinkage,

builder.add(rtti);

? MD->

<CUDADeviceAttr>()

: (MD->

<CUDAHostAttr>() || !MD->

<CUDADeviceAttr>());

getSpecialVirtualFn = [&](StringRef

) -> llvm::Constant * {

(useRelativeLayout())

llvm::FunctionType *fnTy =

llvm::FunctionType::get(CGM.

,

);

llvm::Constant *fn = cast<llvm::Constant>(

(

f = dyn_cast<llvm::Function>(fn))

f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

llvm::Constant *fnPtr;

(cast<CXXMethodDecl>(GD.

())->isPureVirtual()) {

fnPtr = PureVirtualFn;

}

(cast<CXXMethodDecl>(GD.

())->isDeleted()) {

(!DeletedVirtualFn)

fnPtr = DeletedVirtualFn;

}

(nextVTableThunkIndex < layout.

().size() &&

&thunkInfo = layout.

()[nextVTableThunkIndex].second;

nextVTableThunkIndex++;

fnPtr = maybeEmitThunk(GD, thunkInfo,

);

assert(thunkInfo.Method &&

);

(useRelativeLayout()) {

addRelativeComponent(

builder, fnPtr, vtableAddressPoint, vtableHasLocalLinkage,

FnAS = fnPtr->getType()->getPointerAddressSpace();

(

&Schema =

builder.addSignedPointer(fnPtr, Schema, GD,

());

builder.add(fnPtr);

(useRelativeLayout())

builder.add(llvm::ConstantExpr::getNullValue(CGM.

));

llvm_unreachable(

);

llvm::Type *componentType = getVTableComponentType();

(

i = 0, e = layout.

(); i != e; ++i)

tys.push_back(llvm::ArrayType::get(componentType, layout.

(i)));

llvm::Constant *rtti,

vtableHasLocalLinkage) {

llvm::Type *componentType = getVTableComponentType();

nextVTableThunkIndex = 0;

(

vtableIndex = 0, endIndex = layout.

();

vtableIndex != endIndex; ++vtableIndex) {

vtableElem = builder.

(componentType);

vtableEnd = vtableStart + layout.

(vtableIndex);

(

componentIndex = vtableStart; componentIndex < vtableEnd;

addVTableComponent(vtableElem, layout, componentIndex, rtti,

nextVTableThunkIndex, addressPoints[vtableIndex],

vtableHasLocalLinkage);

vtableElem.finishAndAddTo(builder);

llvm::GlobalVariable::LinkageTypes

,

VTableAddressPointsMapTy &AddressPoints) {

DI->completeClassData(

.getBase());

std::unique_ptr<VTableLayout> VTLayout(

.getBase(),

.getBaseOffset(), BaseIsVirtual, RD));

AddressPoints = VTLayout->getAddressPoints();

llvm::raw_svector_ostream Out(OutName);

.mangleCXXCtorVTable(RD,

.getBaseOffset().getQuantity(),

.getBase(), Out);

VTableAliasExists =

UsingRelativeLayout && CGM.

().getNamedAlias(Name);

(VTableAliasExists) {

Name.append(

);

(

== llvm::GlobalVariable::AvailableExternallyLinkage)

= llvm::GlobalVariable::InternalLinkage;

llvm::Align Align = CGM.

().getABITypeAlign(VTType);

llvm::GlobalVariable *VTable =

VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

VTable->hasLocalLinkage());

components.finishAndSetAsInitializer(VTable);

assert(!VTable->isDeclaration() &&

);

(UsingRelativeLayout) {

(!VTable->isDSOLocal())

llvm::GlobalValue::SanitizerMetadata Meta;

(GV->hasSanitizerMetadata())

Meta = GV->getSanitizerMetadata();

Meta.NoHWAddress =

;

GV->setSanitizerMetadata(Meta);

llvm::StringRef AliasNameRef) {

);

assert(!VTable->isDSOLocal() &&

);

(VTable->hasAvailableExternallyLinkage())

VTable->setName(AliasName +

);

= VTable->getLinkage();

assert(llvm::GlobalAlias::isValidLinkage(

) &&

);

llvm::GlobalAlias *VTableAlias = CGM.

().getNamedAlias(AliasName);

VTableAlias = llvm::GlobalAlias::create(VTable->getValueType(),

VTable->getAddressSpace(),

,

assert(VTableAlias->getValueType() == VTable->getValueType());

assert(VTableAlias->getLinkage() ==

);

VTableAlias->setVisibility(VTable->getVisibility());

VTableAlias->setUnnamedAddr(VTable->getUnnamedAddr());

(!VTable->hasComdat()) {

VTable->setLinkage(llvm::GlobalValue::InternalLinkage);

VTable->setVisibility(llvm::GlobalValue::HiddenVisibility);

VTableAlias->setAliasee(VTable);

llvm::GlobalVariable::LinkageTypes

llvm::GlobalVariable::InternalLinkage;

(IsInNamedModule || (keyFunction && !RD->

<DLLImportAttr>())) {

(keyFunction && keyFunction->

(def))

keyFunction = cast<CXXMethodDecl>(def);

IsExternalDefinition =

(IsInNamedModule || def || CodeGenOpts.OptimizationLevel > 0 ||

CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo) &&

);

(IsExternalDefinition && CodeGenOpts.OptimizationLevel > 0)

llvm::GlobalVariable::AvailableExternallyLinkage;

(keyFunction && keyFunction->

())

? llvm::GlobalVariable::LinkOnceODRLinkage

: llvm::Function::InternalLinkage;

llvm::GlobalVariable::ExternalLinkage;

llvm::GlobalVariable::LinkOnceODRLinkage :

llvm::Function::InternalLinkage;

llvm::GlobalVariable::WeakODRLinkage :

llvm::Function::InternalLinkage;

llvm_unreachable(

);

llvm::Function::InternalLinkage;

llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage =

llvm::GlobalValue::LinkOnceODRLinkage;

llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage =

llvm::GlobalValue::WeakODRLinkage;

(RD->

<DLLExportAttr>()) {

DiscardableODRLinkage = NonDiscardableODRLinkage;

}

(RD->

<DLLImportAttr>()) {

DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;

NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;

DiscardableODRLinkage;

DiscardableODRLinkage;

? llvm::GlobalVariable::AvailableExternallyLinkage

: llvm::GlobalVariable::ExternalLinkage;

NonDiscardableODRLinkage;

llvm_unreachable(

);

DI->completeClassData(RD);

assert(RD->

() &&

);

!keyFunction->

();

CodeGenModule::EmitDeferredVTables() {

savedSize = DeferredVTables.size();

(shouldOpportunisticallyEmitVTables())

OpportunisticVTables.push_back(RD);

assert(savedSize == DeferredVTables.size() &&

);

DeferredVTables.clear();

(RD->

<LTOVisibilityPublicAttr>() || RD->

<UuidAttr>() ||

RD->

<DLLExportAttr>() || RD->

<DLLImportAttr>())

*

= cast<Decl>(DC);

(

*ND = dyn_cast<NamespaceDecl>(

))

(II->isStr(

) || II->isStr(

))

(!

().isOSBinFormatCOFF() &&

(!

.insert(RD).second)

llvm::GlobalObject::VCallVisibilityTranslationUnit;

llvm::GlobalObject::VCallVisibility TypeVis;

TypeVis = llvm::GlobalObject::VCallVisibilityTranslationUnit;

TypeVis = llvm::GlobalObject::VCallVisibilityLinkageUnit;

TypeVis = llvm::GlobalObject::VCallVisibilityPublic;

(

&B : RD->

())

(B.getType()->getAsCXXRecordDecl()->isDynamicClass())

(

&B : RD->

())

(B.getType()->getAsCXXRecordDecl()->isDynamicClass())

llvm::GlobalVariable *VTable,

AddressPoint {

(

AddressPoint &RHS)

{

=

.compare(RHS.TypeName);

< 0 || (

== 0 && Offset < RHS.Offset);

std::vector<AddressPoint> AddressPoints;

AddressPoint N{AP.first.getBase(),

AP.second.AddressPointIndex,

llvm::raw_string_ostream Stream(N.TypeName);

(N.Base->getTypeForDecl(), 0), Stream);

AddressPoints.push_back(std::move(N));

llvm::sort(AddressPoints);

(

AP : AddressPoints) {

(

I = 0; I != Comps.size(); ++I) {

Comps[I].getFunctionDecl()->getType(),

VTable->addTypeMetadata((ComponentWidth * I).getQuantity(), MD);

llvm::DenseSet<const CXXRecordDecl *>

;

llvm::GlobalObject::VCallVisibility TypeVis =

(TypeVis != llvm::GlobalObject::VCallVisibilityPublic)

VTable->setVCallVisibilityMetadata(TypeVis);

static RValue PerformReturnAdjustment(CodeGenFunction &CGF, QualType ResultType, RValue RV, const ThunkInfo &Thunk)

static void setThunkProperties(CodeGenModule &CGM, const ThunkInfo &Thunk, llvm::Function *ThunkFn, bool ForVTable, GlobalDecl GD)

static bool shouldEmitVTableThunk(CodeGenModule &CGM, const CXXMethodDecl *MD, bool IsUnprototyped, bool ForVTable)

static void resolveTopLevelMetadata(llvm::Function *Fn, llvm::ValueToValueMapTy &VMap)

This function clones a function's DISubprogram node and enters it into a value map with the intent th...

static bool shouldEmitAvailableExternallyVTable(const CodeGenModule &CGM, const CXXRecordDecl *RD)

static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM, const CXXRecordDecl *RD)

Given that we're currently at the end of the translation unit, and we've emitted a reference to the v...

static void AddRelativeLayoutOffset(const CodeGenModule &CGM, ConstantArrayBuilder &builder, CharUnits offset)

static void AddPointerLayoutOffset(const CodeGenModule &CGM, ConstantArrayBuilder &builder, CharUnits offset)

static bool similar(const ABIArgInfo &infoL, CanQualType typeL, const ABIArgInfo &infoR, CanQualType typeR)

static bool UseRelativeLayout(const CodeGenModule &CGM)

static Decl::Kind getKind(const Decl *D)

llvm::DenseSet< const void * > Visited

QualType getTagDeclType(const TagDecl *Decl) const

Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.

QualType getMemberPointerType(QualType T, const Type *Cls) const

Return the uniqued reference to the type for a member pointer to the specified type in the specified ...

QualType getRecordType(const RecordDecl *Decl) const

const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)

Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...

const LangOptions & getLangOpts() const

bool useAbbreviatedThunkName(GlobalDecl VirtualMethodDecl, StringRef MangledName)

Represents a C++ destructor within a class.

Represents a static or instance method of a struct/union/class.

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

QualType getThisType() const

Return the type of the this pointer.

QualType getFunctionObjectParameterType() const

CXXMethodDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

Represents a C++ struct/union/class.

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine whether this particular class is a specialization or instantiation of a class template or m...

base_class_range vbases()

bool isDynamicClass() const

unsigned getNumVBases() const

Retrieves the number of virtual base classes of this class.

CharUnits - This is an opaque type for sizes expressed in character units.

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

PointerAuthOptions PointerAuth

Configuration for pointer-signing.

ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...

@ Indirect

Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...

bool isSRetAfterThis() const

Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...

llvm::Type * getElementType() const

Return the type of the values stored in this address.

static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)

Apply TemporaryLocation if it is valid.

static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)

Set the IRBuilder to not attach debug locations.

llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)

llvm::Value * CreateIsNull(Address Addr, const Twine &Name="")

virtual bool hasMostDerivedReturn(GlobalDecl GD) const

virtual bool HasThisReturn(GlobalDecl GD) const

Returns true if the given constructor or destructor is one of the kinds that the ABI says returns 'th...

virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF)=0

Emit the ABI-specific prolog for the function.

virtual llvm::Value * performThisAdjustment(CodeGenFunction &CGF, Address This, const CXXRecordDecl *UnadjustedClass, const ThunkInfo &TI)=0

virtual StringRef GetPureVirtualCallName()=0

Gets the pure virtual member call function.

virtual void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResultType)

virtual bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const =0

Determine whether it's possible to emit a vtable for RD, even though we do not know that the vtable h...

virtual StringRef GetDeletedVirtualCallName()=0

Gets the deleted virtual member call name.

void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)

Build a parameter variable suitable for 'this'.

virtual llvm::Value * performReturnAdjustment(CodeGenFunction &CGF, Address Ret, const CXXRecordDecl *UnadjustedClass, const ReturnAdjustment &RA)=0

virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, FunctionArgList &Params)=0

Insert any ABI-specific implicit parameters into the parameter list for a function.

virtual void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD, bool ReturnAdjustment)=0

virtual void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD, CallArgList &CallArgs)

virtual void emitVirtualInheritanceTables(const CXXRecordDecl *RD)=0

Emit any tables needed to implement virtual inheritance.

virtual void emitVTableDefinitions(CodeGenVTables &CGVT, const CXXRecordDecl *RD)=0

Emits the VTable definitions required for the given record type.

virtual bool exportThunk()=0

MangleContext & getMangleContext()

Gets the mangle context.

static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())

This class gathers all debug information during compilation and is responsible for emitting to llvm g...

CGFunctionInfo - Class to encapsulate the information about a function definition.

bool usesInAlloca() const

Return true if this function uses inalloca arguments.

ABIArgInfo & getReturnInfo()

unsigned getCallingConvention() const

getCallingConvention - Return the user specified calling convention, which has been translated into a...

const_arg_iterator arg_begin() const

unsigned getRegParm() const

CanQualType getReturnType() const

unsigned arg_size() const

CallArgList - Type for representing both the value and type of arguments in a call.

void add(RValue rvalue, QualType type)

CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...

void FinishFunction(SourceLocation EndLoc=SourceLocation())

FinishFunction - Complete IR generation of the current function.

GlobalDecl CurGD

CurGD - The GlobalDecl for the current function being compiled.

void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee, const ThunkInfo *Thunk, bool IsUnprototyped)

llvm::Function * GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk)

void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk, bool IsUnprototyped)

Generate a thunk for the given method.

bool CurFuncIsThunk

In C++, whether we are code generating a thunk.

llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)

createBasicBlock - Create an LLVM basic block.

void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)

EmitBlock - Emit the given block.

Address makeNaturalAddressForPointer(llvm::Value *Ptr, QualType T, CharUnits Alignment=CharUnits::Zero(), bool ForPointeeType=false, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

Construct an address with the natural alignment of T.

llvm::Type * ConvertTypeForMem(QualType T)

const Decl * CurCodeDecl

CurCodeDecl - This is the inner-most code context, which includes blocks.

void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())

Emit code for the start of a function.

void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)

EmitDelegateCallArg - We are performing a delegate call; that is, the current function is delegating ...

RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)

EmitCall - Generate a call of the given function, expecting the given result type,...

const Decl * CurFuncDecl

CurFuncDecl - Holds the Decl for the current outermost non-closure context.

void StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo, bool IsUnprototyped)

bool AutoreleaseResult

In ARC, whether we should autorelease the return value.

Address LoadCXXThisAddress()

static bool hasAggregateEvaluationKind(QualType T)

llvm::Value * LoadCXXThis()

LoadCXXThis - Load the value of 'this'.

const CGFunctionInfo * CurFnInfo

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

llvm::LLVMContext & getLLVMContext()

void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr, llvm::FunctionCallee Callee)

Emit a musttail call for a thunk with a potentially adjusted this pointer.

This class organizes the cross-function state that is used while generating LLVM code.

void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const

Set visibility, dllimport/dllexport and dso_local.

void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)

Create and attach type metadata for the given vtable.

llvm::GlobalObject::VCallVisibility GetVCallVisibilityLevel(const CXXRecordDecl *RD, llvm::DenseSet< const CXXRecordDecl * > &Visited)

Returns the vcall visibility of the given type.

llvm::Module & getModule() const

llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)

Create or return a runtime function declaration with the specified type and name.

CGDebugInfo * getModuleDebugInfo()

CodeGenVTables & getVTables()

CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const

Return the store size, in character units, of the given LLVM type.

llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)

Get the address of the RTTI descriptor for the given type.

llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)

Return the address of the given function.

void ErrorUnsupported(const Stmt *S, const char *Type)

Print out an error that codegen doesn't support the specified stmt yet.

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

void EmitVTableTypeMetadata(const CXXRecordDecl *RD, llvm::GlobalVariable *VTable, const VTableLayout &VTLayout)

Emit type metadata for the given vtable using the given layout.

bool HasHiddenLTOVisibility(const CXXRecordDecl *RD)

Returns whether the given record has hidden LTO visibility and therefore may participate in (single-m...

const llvm::DataLayout & getDataLayout() const

CGCXXABI & getCXXABI() const

CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)

Returns the assumed alignment of an opaque pointer to the given class.

const llvm::Triple & getTriple() const

bool AlwaysHasLTOVisibilityPublic(const CXXRecordDecl *RD)

Returns whether the given record has public LTO visibility (regardless of -lto-whole-program-visibili...

void EmitVTable(CXXRecordDecl *Class)

This is a callback from Sema to tell us that a particular vtable is required to be emitted in this tr...

void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk)

Get the LLVM attributes and calling convention to use for a particular function type.

void setFunctionLinkage(GlobalDecl GD, llvm::Function *F)

ItaniumVTableContext & getItaniumVTableContext()

ASTContext & getContext() const

llvm::Type * getVTableComponentType() const

bool supportsCOMDAT() const

bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)

Return true iff the given type uses 'sret' when used as a return type.

const CodeGenOptions & getCodeGenOpts() const

llvm::GlobalVariable * CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, llvm::Align Alignment)

Will return a global variable of the given type.

llvm::LLVMContext & getLLVMContext()

llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD)

Return the appropriate linkage for the vtable, VTT, and type information of the given class.

void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)

Set the LLVM function attributes (sext, zext, etc).

void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)

Set the LLVM function attributes which only apply to a function definition.

llvm::Metadata * CreateMetadataIdentifierForVirtualMemPtrType(QualType T)

Create a metadata identifier that is intended to be used to check virtual calls via a member function...

llvm::Constant * GetAddrOfThunk(StringRef Name, llvm::Type *FnTy, GlobalDecl GD)

Get the address of the thunk for the given global decl.

llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)

GetFunctionType - Get the LLVM function type for.

bool isFuncTypeConvertible(const FunctionType *FT)

isFuncTypeConvertible - Utility to check whether a function type can be converted to an LLVM type (i....

const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)

const CGFunctionInfo & arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD)

Arrange a thunk that takes 'this' as the first parameter followed by varargs.

const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required, unsigned numPrefixArgs)

Arrange a call to a C++ method, passing the given arguments.

llvm::Type * GetFunctionTypeForVTable(GlobalDecl GD)

GetFunctionTypeForVTable - Get the LLVM function type for use in a vtable, given a CXXMethodDecl.

void createVTableInitializer(ConstantStructBuilder &builder, const VTableLayout &layout, llvm::Constant *rtti, bool vtableHasLocalLinkage)

Add vtable components for the given vtable layout to the given global initializer.

void GenerateClassData(const CXXRecordDecl *RD)

GenerateClassData - Generate all the class data required to be generated upon definition of a KeyFunc...

void GenerateRelativeVTableAlias(llvm::GlobalVariable *VTable, llvm::StringRef AliasNameRef)

Generate a public facing alias for the vtable and make the vtable either hidden or private.

ItaniumVTableContext & getItaniumVTableContext()

CodeGenVTables(CodeGenModule &CGM)

llvm::GlobalVariable * GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual, llvm::GlobalVariable::LinkageTypes Linkage, VTableAddressPointsMapTy &AddressPoints)

GenerateConstructionVTable - Generate a construction vtable for the given base subobject.

llvm::Type * getVTableType(const VTableLayout &layout)

Returns the type of a vtable with the given layout.

bool isVTableExternal(const CXXRecordDecl *RD)

At this point in the translation unit, does it appear that can we rely on the vtable being defined el...

void RemoveHwasanMetadata(llvm::GlobalValue *GV) const

Specify a global should not be instrumented with hwasan.

void EmitThunks(GlobalDecl GD)

EmitThunks - Emit the associated thunks for the given global decl.

ArrayBuilder beginArray(llvm::Type *eltTy=nullptr)

A helper class of ConstantInitBuilder, used for building constant array initializers.

StructBuilder beginStruct(llvm::StructType *structTy=nullptr)

The standard implementation of ConstantInitBuilder used in Clang.

A helper class of ConstantInitBuilder, used for building constant struct initializers.

FunctionArgList - Type for representing both the decl and type of parameters to a function.

RValue - This trivial value class is used to represent the result of an expression that is evaluated.

static RValue get(llvm::Value *V)

llvm::Value * getScalarVal() const

getScalarVal() - Return the Value* of this scalar value.

static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)

Compute the arguments required by the given formal prototype, given that there may be some additional...

ReturnValueSlot - Contains the address where the return value of a function can be stored,...

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

DeclContext * getRedeclContext()

getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...

bool isInNamedModule() const

Whether this declaration comes from a named module.

SourceLocation getLocation() const

bool shouldEmitInExternalSource() const

Whether the definition of the declaration should be emitted in external sources.

Represents a function declaration or definition.

param_iterator param_end()

bool isInlined() const

Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...

ArrayRef< ParmVarDecl * > parameters() const

param_iterator param_begin()

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine what kind of template instantiation this function represents.

bool hasBody(const FunctionDecl *&Definition) const

Returns true if the function has a body.

bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const

Returns true if the function has a definition that does not need to be instantiated.

Represents a prototype with parameter type info, e.g.

FunctionType - C99 6.7.5.3 - Function Declarators.

QualType getReturnType() const

GlobalDecl - represents a global declaration.

GlobalDecl getWithDecl(const Decl *D)

CXXDtorType getDtorType() const

const Decl * getDecl() const

One of these records is kept for each identifier that is lexed.

bool isRelativeLayout() const

GlobalDecl findOriginalMethod(GlobalDecl GD)

Return the method that added the v-table slot that will be used to call the given method.

SanitizerSet Sanitize

Set of enabled sanitizers.

Visibility getVisibility() const

Linkage getLinkage() const

MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...

virtual void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, const ThunkInfo &Thunk, bool ElideOverrideInfo, raw_ostream &)=0

virtual void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk, bool ElideOverrideInfo, raw_ostream &)=0

virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0

Generates a unique string for an externally visible type for use with TBAA or type uniquing.

LinkageInfo getLinkageAndVisibility() const

Determines the linkage and visibility of this entity.

bool isExternallyVisible() const

Represents a parameter to a function.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

Encodes a location in the source.

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

bool isItaniumFamily() const

Does this ABI generally fall into the Itanium family of ABIs?

bool hasKeyFunctions() const

Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

const CXXRecordDecl * getPointeeCXXRecordDecl() const

If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

@ CK_DeletingDtorPointer

A pointer to the deleting destructor.

@ CK_UnusedFunctionPointer

An entry that is never used.

@ CK_CompleteDtorPointer

A pointer to the complete destructor.

virtual const ThunkInfoVectorTy * getThunkInfo(GlobalDecl GD)

const AddressPointsIndexMapTy & getAddressPointIndices() const

size_t getVTableOffset(size_t i) const

ArrayRef< VTableComponent > vtable_components() const

size_t getNumVTables() const

ArrayRef< VTableThunkTy > vtable_thunks() const

const AddressPointsMapTy & getAddressPoints() const

size_t getVTableSize(size_t i) const

RangeSelector name(std::string ID)

Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...

The JSON file list parser is used to communicate input to InstallAPI.

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

Linkage

Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.

@ Dtor_Base

Base object dtor.

const FunctionProtoType * T

TemplateSpecializationKind

Describes the kind of template specialization that a particular template specialization declaration r...

@ TSK_ExplicitInstantiationDefinition

This template specialization was instantiated from a template due to an explicit instantiation defini...

@ TSK_ExplicitInstantiationDeclaration

This template specialization was instantiated from a template due to an explicit instantiation declar...

@ TSK_ExplicitSpecialization

This template specialization was declared or defined by an explicit specialization (C++ [temp....

@ TSK_ImplicitInstantiation

This template specialization was implicitly instantiated from a template.

@ TSK_Undeclared

This template specialization was formed from a template-id but has not yet been declared,...

CallingConv

CallingConv - Specifies the calling convention that a function uses.

bool isExternallyVisible(Linkage L)

@ HiddenVisibility

Objects with "hidden" visibility are not seen by the dynamic linker.

llvm::PointerType * GlobalsInt8PtrTy

llvm::IntegerType * Int32Ty

llvm::IntegerType * PtrDiffTy

PointerAuthSchema CXXVirtualFunctionPointers

The ABI for most C++ virtual function pointers, i.e. v-table entries.

bool has(SanitizerMask K) const

Check if a certain (single) sanitizer is enabled.

The this pointer adjustment as well as an optional return adjustment for a thunk.

ReturnAdjustment Return

The return adjustment.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4