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

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

clang: lib/CodeGen/CGDeclCXX.cpp Source File

;

CodeGen;

(

.hasGlobalStorage() ||

);

assert(!

.getType()->isReferenceType() &&

);

DeclPtr,

.getTLSKind());

llvm_unreachable(

);

assert(!

.getTLSKind() &&

);

llvm::FunctionCallee

;

llvm::Constant *Argument;

CanRegisterDestructor =

(

&& (CanRegisterDestructor || UsingExternalHelper)) {

assert(!

->hasTrivialDestructor());

DestTy = llvm::PointerType::get(

SrcAS =

.getType().getQualifiers().getAddressSpace();

Argument = llvm::ConstantPointerNull::get(DestTy);

Argument = llvm::Constant::getNullValue(CGF.

);

llvm::Constant *Addr) {

CodeGenFunction::EmitInvariantStart(llvm::Constant *Addr,

Size) {

llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start;

assert(Addr->getType()->isPointerTy() &&

);

llvm::Type *ObjectPtr[1] = {Addr->getType()};

llvm::Function *InvariantStart =

.

(InvStartID, ObjectPtr);

llvm::Value *Args[2] = {llvm::ConstantInt::getSigned(

, Width), Addr};

.CreateCall(InvariantStart, Args);

llvm::GlobalVariable *GV,

ActualAddrSpace = GV->getAddressSpace();

llvm::Constant *DeclPtr = GV;

(ActualAddrSpace != ExpectedAddrSpace) {

llvm::PointerType *PTy =

DeclPtr = llvm::ConstantExpr::getAddrSpaceCast(DeclPtr, PTy);

DeclPtr, GV->getValueType(),

().getDeclAlign(&

));

.

<OMPThreadPrivateDeclAttr>()) {

&

, DeclAddr,

.

<OMPThreadPrivateDeclAttr>()->getLocation(),

(

.getType().isConstantStorage(

(),

, !NeedsDtor))

assert(PerformInit &&

);

llvm::FunctionCallee dtor,

llvm::Constant *addr) {

llvm::FunctionType *ty = llvm::FunctionType::get(

.

,

);

llvm::raw_svector_ostream Out(FnName);

llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);

(

*dtorFn = dyn_cast<llvm::Function>(

dtor.getCallee()->stripPointerCastsAndAliases()))

call->setCallingConv(dtorFn->getCallingConv());

CGF.FinishFunction();

&

, llvm::FunctionCallee Dtor, llvm::Constant *Addr,

llvm::FunctionCallee &

) {

llvm::raw_svector_ostream Out(FnName);

llvm::FunctionType *StubTy =

llvm::FunctionType::get(

.

, {CGM.IntTy},

);

Args.push_back(&IPD);

llvm::CallInst *call = CGF.Builder.CreateCall(Dtor, Addr);

(

*DtorFn = dyn_cast<llvm::Function>(

Dtor.getCallee()->stripPointerCastsAndAliases()))

call->setCallingConv(DtorFn->getCallingConv());

CGF.Builder.CreateStore(llvm::Constant::getNullValue(

.

),

CGF.FinishFunction();

llvm::FunctionCallee dtor,

llvm::Constant *addr) {

llvm::FunctionCallee Dtor,

llvm::Constant *Addr) {

llvm::Function *dtorStub =

assert(dtorStub->getType() ==

llvm::PointerType::get(

llvm::FunctionType::get(

.

,

),

dtorStub->getType()->getPointerAddressSpace()) &&

);

llvm::FunctionType *atexitTy =

llvm::FunctionType::get(

, dtorStub->getType(),

);

llvm::FunctionCallee atexit =

(llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit.getCallee()))

atexitFn->setDoesNotThrow();

assert(dtorStub->getType() ==

llvm::PointerType::get(

llvm::FunctionType::get(

.

,

),

dtorStub->getType()->getPointerAddressSpace()) &&

);

llvm::FunctionType *unatexitTy =

llvm::FunctionType::get(

, {dtorStub->getType()},

);

llvm::FunctionCallee unatexit =

cast<llvm::Function>(unatexit.getCallee())->setDoesNotThrow();

llvm::GlobalVariable *DeclPtr,

);

llvm::BasicBlock *InitBlock,

llvm::BasicBlock *NoInitBlock,

InitsPerTLSVar = 1024;

InitsPerLocalVar = 1024 * 1024;

llvm::MDNode *Weights;

NumInits = InitsPerTLSVar;

NumInits = InitsPerLocalVar;

Weights = MDHelper.createBranchWeights(1, NumInits - 1);

.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights);

llvm::FunctionType *FTy,

Twine &Name,

&FI,

llvm::Function *Fn = llvm::Function::Create(FTy,

, Name, &

());

(

*Section =

().getStaticInitSectionSpecifier())

Fn->setSection(Section);

(

== llvm::GlobalVariable::InternalLinkage)

Fn->setDoesNotThrow();

(

().Sanitize.has(SanitizerKind::Address) &&

Fn->addFnAttr(llvm::Attribute::SanitizeAddress);

(

().Sanitize.has(SanitizerKind::KernelAddress) &&

Fn->addFnAttr(llvm::Attribute::SanitizeAddress);

(

().Sanitize.has(SanitizerKind::HWAddress) &&

Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);

(

().Sanitize.has(SanitizerKind::KernelHWAddress) &&

Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);

(

().Sanitize.has(SanitizerKind::MemtagStack) &&

Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);

(

().Sanitize.has(SanitizerKind::Type) &&

Fn->addFnAttr(llvm::Attribute::SanitizeType);

(

().Sanitize.has(SanitizerKind::Thread) &&

Fn->addFnAttr(llvm::Attribute::SanitizeThread);

(

().Sanitize.has(SanitizerKind::NumericalStability) &&

Fn->addFnAttr(llvm::Attribute::SanitizeNumericalStability);

(

().Sanitize.has(SanitizerKind::Memory) &&

Fn->addFnAttr(llvm::Attribute::SanitizeMemory);

(

().Sanitize.has(SanitizerKind::KernelMemory) &&

Fn->addFnAttr(llvm::Attribute::SanitizeMemory);

(

().Sanitize.has(SanitizerKind::SafeStack) &&

Fn->addFnAttr(llvm::Attribute::SafeStack);

(

().Sanitize.has(SanitizerKind::ShadowCallStack) &&

Fn->addFnAttr(llvm::Attribute::ShadowCallStack);

CodeGenModule::EmitPointerToInitFunc(

*

,

llvm::GlobalVariable *GV,

llvm::Function *InitFunc,

llvm::GlobalVariable *PtrArray =

llvm::GlobalVariable(

TheModule, InitFunc->getType(),

,

llvm::GlobalValue::PrivateLinkage, InitFunc,

);

PtrArray->setSection(ISA->getSection());

(llvm::Comdat *

= GV->getComdat())

PtrArray->setComdat(

);

CodeGenModule::EmitCXXGlobalVarDeclInitFunc(

*

,

llvm::GlobalVariable *Addr,

I = DelayedCXXInitPosition.find(

);

(I != DelayedCXXInitPosition.end() && I->second == ~0

)

llvm::FunctionType *FTy = llvm::FunctionType::get(

,

);

llvm::raw_svector_ostream Out(FnName);

*ISA =

->

<InitSegAttr>();

llvm::GlobalVariable *COMDATKey =

(

->getTLSKind()) {

CXXThreadLocalInits.push_back(Fn);

CXXThreadLocalInitVars.push_back(

);

}

(PerformInit && ISA) {

(ISA->getSection() ==

)

(ISA->getSection() ==

)

EmitPointerToInitFunc(

, Addr, Fn, ISA);

}

(

*IPA =

->

<InitPriorityAttr>()) {

PrioritizedCXXGlobalInits.size());

PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));

I = DelayedCXXInitPosition.find(

);

I == DelayedCXXInitPosition.end() ? CXXGlobalInits.size() : I->second;

(COMDATKey && (

().isOSBinFormatELF() ||

llvm::Comdat *

= Addr->getComdat();

(COMDATKey &&

&&

I = DelayedCXXInitPosition.find(

);

(I == DelayedCXXInitPosition.end()) {

CXXGlobalInits.push_back(Fn);

}

(I->second != ~0

) {

assert(I->second < CXXGlobalInits.size() &&

CXXGlobalInits[I->second] ==

);

CXXGlobalInits[I->second] =

;

DelayedCXXInitPosition[

] = ~0

;

CodeGenModule::EmitCXXThreadLocalInitFunc() {

*

, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars);

CXXThreadLocalInits.clear();

CXXThreadLocalInitVars.clear();

CXXThreadLocals.clear();

CodeGenModule::EmitCXXModuleInitFunc(

*Primary) {

(!CXXGlobalInits.empty() && !CXXGlobalInits.back())

CXXGlobalInits.pop_back();

(

I : Primary->

)

AllImports.insert(I.getPointer());

AllImports.insert(M);

assert((SubM->isGlobalModule() || SubM->isPrivateModule()) &&

);

assert(SubM->Exports.empty() &&

);

AllImports.insert(M);

(

*M : AllImports) {

llvm::FunctionType *FTy = llvm::FunctionType::get(

,

);

llvm::raw_svector_ostream Out(FnName);

cast<ItaniumMangleContext>(

().getMangleContext())

.mangleModuleInitializer(M, Out);

);

llvm::Function *

= llvm::Function::Create(

FTy, llvm::Function::ExternalLinkage, FnName.str(), &

());

ModuleInits.push_back(Fn);

(!PrioritizedCXXGlobalInits.empty()) {

llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),

PrioritizedCXXGlobalInits.end());

I = PrioritizedCXXGlobalInits.begin(),

= PrioritizedCXXGlobalInits.end();

std::upper_bound(I + 1,

, *I, GlobalInitPriorityCmp());

(; I < PrioE; ++I)

ModuleInits.push_back(I->second);

(

*F : CXXGlobalInits)

ModuleInits.push_back(F);

llvm::FunctionType *FTy = llvm::FunctionType::get(

,

);

llvm::Function *

;

llvm::raw_svector_ostream Out(InitFnName);

cast<ItaniumMangleContext>(

().getMangleContext())

.mangleModuleInitializer(Primary, Out);

llvm::GlobalVariable::ExternalLinkage);

(!ModuleInits.empty()) {

llvm::GlobalVariable *Guard =

llvm::GlobalVariable(

llvm::GlobalVariable::InternalLinkage,

llvm::ConstantInt::get(

, 0), InitFnName.str() +

);

Guard->setAlignment(GuardAlign.

());

->setCallingConv(llvm::CallingConv::SPIR_KERNEL);

->setCallingConv(llvm::CallingConv::SPIR_KERNEL);

->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);

->addFnAttr(

);

PrioritizedCXXGlobalInits.clear();

CXXGlobalInits.clear();

(

i = 0; i <

.size(); ++i) {

assert(

<= 65535 &&

);

std::string PrioritySuffix = llvm::utostr(

);

PrioritySuffix = std::string(6 - PrioritySuffix.size(),

) + PrioritySuffix;

PrioritySuffix;

CodeGenModule::EmitCXXGlobalInitFunc() {

(!CXXGlobalInits.empty() && !CXXGlobalInits.back())

CXXGlobalInits.pop_back();

(CXX20ModuleInits)

(

*M : ImportedModules) {

llvm::FunctionType *FTy = llvm::FunctionType::get(

,

);

llvm::raw_svector_ostream Out(FnName);

cast<ItaniumMangleContext>(

().getMangleContext())

.mangleModuleInitializer(M, Out);

);

llvm::Function *

= llvm::Function::Create(

FTy, llvm::Function::ExternalLinkage, FnName.str(), &

());

ModuleInits.push_back(Fn);

(ModuleInits.empty() && CXXGlobalInits.empty() &&

PrioritizedCXXGlobalInits.empty())

llvm::FunctionType *FTy = llvm::FunctionType::get(

,

);

(!PrioritizedCXXGlobalInits.empty()) {

llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),

PrioritizedCXXGlobalInits.end());

I = PrioritizedCXXGlobalInits.begin(),

= PrioritizedCXXGlobalInits.end(); I !=

; ) {

PrioE = std::upper_bound(I + 1,

, *I, GlobalInitPriorityCmp());

LocalCXXGlobalInits.clear();

= I->first.priority;

(!ModuleInits.empty()) {

(

*F : ModuleInits)

LocalCXXGlobalInits.push_back(F);

(; I < PrioE; ++I)

LocalCXXGlobalInits.push_back(I->second);

PrioritizedCXXGlobalInits.clear();

(

().useSinitAndSterm() && ModuleInits.empty() &&

CXXGlobalInits.empty())

(

*F : CXXGlobalInits)

ModuleInits.push_back(F);

CXXGlobalInits.clear();

llvm::Function *

;

(CXX20ModuleInits &&

().getCurrentNamedModule() &&

!

().getCurrentNamedModule()->isModuleImplementation()) {

llvm::raw_svector_ostream Out(InitFnName);

cast<ItaniumMangleContext>(

().getMangleContext())

.mangleModuleInitializer(

().getCurrentNamedModule(), Out);

llvm::GlobalVariable::ExternalLinkage);

->setCallingConv(llvm::CallingConv::SPIR_KERNEL);

->setCallingConv(llvm::CallingConv::SPIR_KERNEL);

->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);

->addFnAttr(

);

CodeGenModule::EmitCXXGlobalCleanUpFunc() {

(CXXGlobalDtorsOrStermFinalizers.empty() &&

PrioritizedCXXStermFinalizers.empty())

llvm::FunctionType *FTy = llvm::FunctionType::get(

,

);

(!PrioritizedCXXStermFinalizers.empty()) {

llvm::array_pod_sort(PrioritizedCXXStermFinalizers.begin(),

PrioritizedCXXStermFinalizers.end());

I = PrioritizedCXXStermFinalizers.begin(),

= PrioritizedCXXStermFinalizers.end();

std::upper_bound(I + 1,

, *I, StermFinalizerPriorityCmp());

LocalCXXStermFinalizers.clear();

= I->first.priority;

(; I < PrioE; ++I) {

llvm::FunctionCallee DtorFn = I->second;

LocalCXXStermFinalizers.emplace_back(DtorFn.getFunctionType(),

DtorFn.getCallee(),

);

Fn, LocalCXXStermFinalizers);

PrioritizedCXXStermFinalizers.clear();

(CXXGlobalDtorsOrStermFinalizers.empty())

llvm::Function *

=

Fn, CXXGlobalDtorsOrStermFinalizers);

CXXGlobalDtorsOrStermFinalizers.clear();

llvm::GlobalVariable *Addr,

DebugInfo =

;

(Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage() ||

llvm::BasicBlock *ExitBlock =

;

);

RunCleanupsScope

(*

);

(

i = 0, e = Decls.size(); i != e; ++i)

.ForceCleanup();

<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,

DtorsOrStermFinalizers) {

(

i = 0, e = DtorsOrStermFinalizers.size(); i != e; ++i) {

llvm::FunctionType *CalleeTy;

llvm::Constant *Arg;

std::tie(CalleeTy, Callee, Arg) = DtorsOrStermFinalizers[e - i - 1];

llvm::CallInst *CI =

;

(Arg ==

) {

);

CI =

.CreateCall(CalleeTy, Callee);

CI =

.CreateCall(CalleeTy, Callee, Arg);

(llvm::Function *F = dyn_cast<llvm::Function>(Callee))

CI->setCallingConv(F->getCallingConv());

useEHCleanupForArray,

*VD) {

args.push_back(&Dst);

FTy,

, FI, VD->

());

static std::string getPrioritySuffix(unsigned int Priority)

static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D, ConstantAddress DeclPtr)

static SmallString< 128 > getTransformedFileName(llvm::Module &M)

static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, ConstantAddress Addr)

Emit code to cause the destruction of the given variable with static storage duration.

static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *Addr)

Emit code to cause the variable at the given address to be considered as constant from this point onw...

Defines the clang::LangOptions interface.

llvm::MachO::Record Record

const LangOptions & getLangOpts() const

CharUnits getTypeSizeInChars(QualType T) const

Return the size of the specified (complete) type T, in characters.

QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const

Return a normal function type with a typed argument list.

unsigned getTargetAddressSpace(LangAS AS) const

Represents a C++ destructor within a class.

Represents a C++ struct/union/class.

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

llvm::Align getAsAlign() const

getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...

static CharUnits One()

One - Construct a CharUnits quantity of one.

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

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

static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)

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="")

llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")

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 bool useSinitAndSterm() const

virtual void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)=0

Emits the guarded initializer and destructor setup for the given variable, given that it couldn't be ...

virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr)=0

Emit code to force the execution of a destructor during global teardown.

virtual bool canCallMismatchedFunctionType() const

Returns true if the target allows calling a function through a pointer with a different signature tha...

virtual void EmitThreadLocalInitFuncs(CodeGenModule &CGM, ArrayRef< const VarDecl * > CXXThreadLocals, ArrayRef< llvm::Function * > CXXThreadLocalInits, ArrayRef< const VarDecl * > CXXThreadLocalInitVars)=0

Emits ABI-required functions necessary to initialize thread_local variables in this translation unit.

MangleContext & getMangleContext()

Gets the mangle context.

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

void annotateHLSLResource(const VarDecl *D, llvm::GlobalVariable *GV)

virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0

virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, bool threadlocal=false)=0

virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)

Emit a code for initialization of threadprivate variable.

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

void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function * > CXXThreadLocals, ConstantAddress Guard=ConstantAddress::invalid())

GenerateCXXGlobalInitFunc - Generates code for initializing global variables.

void FinishFunction(SourceLocation EndLoc=SourceLocation())

FinishFunction - Complete IR generation of the current function.

static TypeEvaluationKind getEvaluationKind(QualType T)

getEvaluationKind - Return the TypeEvaluationKind of QualType T.

llvm::Constant * createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)

llvm::Value * EmitObjCAutoreleasePoolPush()

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

createBasicBlock - Create an LLVM basic block.

const LangOptions & getLangOpts() const

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

EmitBlock - Emit the given block.

llvm::Type * ConvertTypeForMem(QualType T)

llvm::Function * createTLSAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr, llvm::FunctionCallee &AtExit)

void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)

void registerGlobalDtorWithLLVM(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)

Registers the dtor using 'llvm.global_dtors' for platforms that do not support an 'atexit()' function...

Destroyer * getDestroyer(QualType::DestructionKind destructionKind)

void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)

llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)

void GenerateCXXGlobalCleanUpFunc(llvm::Function *Fn, ArrayRef< std::tuple< llvm::FunctionType *, llvm::WeakTrackingVH, llvm::Constant * > > DtorsOrStermFinalizers)

GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global variables.

void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)

Emit code in this function to perform a guarded variable initialization.

void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV, bool PerformInit)

EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.

void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)

EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...

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 registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)

Call atexit() with a function that passes the given argument to the given function.

llvm::Value * unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub)

Call unatexit() with function dtorStub.

RValue EmitReferenceBindingToExpr(const Expr *E)

Emits a reference binding to the passed in expression.

void EmitAggExpr(const Expr *E, AggValueSlot AS)

EmitAggExpr - Emit the computation of the specified expression of aggregate type.

llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

ASTContext & getContext() const

bool needsEHCleanup(QualType::DestructionKind kind)

Determines whether an EH cleanup is required to destroy a type with the given destruction kind.

llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size)

CodeGenTypes & getTypes() const

void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit)

LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)

void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr)

llvm::LLVMContext & getLLVMContext()

llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)

EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...

void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)

EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...

void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D)

Emit a branch to select whether or not to perform guarded initialization.

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

void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)

Set the attributes on the LLVM function for the given decl and function info.

CGHLSLRuntime & getHLSLRuntime()

Return a reference to the configured HLSL runtime.

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.

llvm::FunctionCallee getAddrAndTypeOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)

llvm::Constant * getFunctionPointer(GlobalDecl GD, llvm::Type *Ty=nullptr)

Return the ABI-correct function pointer value for a reference to the given function.

bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

void addUsedGlobal(llvm::GlobalValue *GV)

Add a global to a list to be added to the llvm.used metadata.

const llvm::DataLayout & getDataLayout() const

void Error(SourceLocation loc, StringRef error)

Emit a general error that something can't be done.

CGCXXABI & getCXXABI() const

CGOpenMPRuntime & getOpenMPRuntime()

Return a reference to the configured OpenMP runtime.

const llvm::Triple & getTriple() const

void AddGlobalDtor(llvm::Function *Dtor, int Priority=65535, bool IsDtorAttrFunc=false)

AddGlobalDtor - Add a function to the list that will be called when the module is unloaded.

ASTContext & getContext() const

bool supportsCOMDAT() const

const TargetCodeGenInfo & getTargetCodeGenInfo()

const CodeGenOptions & getCodeGenOpts() const

llvm::LLVMContext & getLLVMContext()

llvm::GlobalValue * GetGlobalValue(StringRef Ref)

void GenKernelArgMetadata(llvm::Function *FN, const FunctionDecl *FD=nullptr, CodeGenFunction *CGF=nullptr)

OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument information in the program executab...

llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})

CGObjCRuntime & getObjCRuntime()

Return a reference to the configured Objective-C runtime.

void AddGlobalCtor(llvm::Function *Ctor, int Priority=65535, unsigned LexOrder=~0U, llvm::Constant *AssociatedData=nullptr)

AddGlobalCtor - Add a function to the list that will be called before main() runs.

llvm::Function * CreateGlobalInitOrCleanUpFunction(llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI, SourceLocation Loc=SourceLocation(), bool TLS=false, llvm::GlobalVariable::LinkageTypes Linkage=llvm::GlobalVariable::InternalLinkage)

const CGFunctionInfo & arrangeLLVMFunctionInfo(CanQualType returnType, FnInfoOpts opts, ArrayRef< CanQualType > argTypes, FunctionType::ExtInfo info, ArrayRef< FunctionProtoType::ExtParameterInfo > paramInfos, RequiredArgs args)

"Arrange" the LLVM information for a call or type with the given signature.

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

GetFunctionType - Get the LLVM function type for.

const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)

A builtin function is a freestanding function using the default C conventions.

unsigned getTargetAddressSpace(QualType T) const

const CGFunctionInfo & arrangeNullaryFunction()

A nullary function is a freestanding function of type 'void ()'.

A specialization of Address that requires the address to be an LLVM Constant.

ConstantAddress withElementType(llvm::Type *ElemTy) const

static ConstantAddress invalid()

llvm::Constant * getPointer() const

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

LValue - This represents an lvalue references.

bool isObjCStrong() const

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

llvm::Value * getScalarVal() const

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

virtual LangAS getAddrSpaceOfCxaAtexitPtrParam() const

Get address space of pointer parameter for __cxa_atexit.

SourceLocation getLocation() const

SourceLocation getBeginLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

This represents one expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

A class which abstracts out some details necessary for making a call.

GlobalDecl - represents a global declaration.

virtual void mangleDynamicAtExitDestructor(const VarDecl *D, raw_ostream &)=0

virtual void mangleDynamicInitializer(const VarDecl *D, raw_ostream &)=0

Describes a module or submodule.

SmallVector< ExportDecl, 2 > Exports

The set of export declarations.

bool isNamedModuleInterfaceHasInit() const

bool isInterfaceOrPartition() const

llvm::SmallSetVector< Module *, 2 > Imports

The set of modules imported by this module, and on which this module depends.

llvm::iterator_range< submodule_iterator > submodules()

bool isHeaderLikeModule() const

Is this module have similar semantics as headers.

A (possibly-)qualified type.

@ DK_objc_strong_lifetime

Scope - A scope is a transient data structure that is used while parsing the program.

Encodes a location in the source.

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

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

bool isReferenceType() const

Represents a variable declaration or definition.

const Expr * getInit() const

@ TLS_Dynamic

TLS with a dynamic initializer.

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

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

bool isTemplateInstantiation(TemplateSpecializationKind Kind)

Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...

bool isUniqueGVALinkage(GVALinkage L)

Do we know that this will be the only definition of this symbol (excluding inlining-only definitions)...

Linkage

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

@ Dtor_Complete

Complete object dtor.

LLVM_READONLY bool isPreprocessingNumberBody(unsigned char c)

Return true if this is the body character of a C preprocessing number, which is [a-zA-Z0-9_.

const FunctionProtoType * T

@ Other

Other implicit parameter.

llvm::PointerType * VoidPtrTy

llvm::IntegerType * Int64Ty

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::CallingConv::ID getRuntimeCC() const

llvm::IntegerType * IntTy

int

llvm::PointerType * Int8PtrTy

Extra information about a function prototype.

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