19 #include "llvm/ADT/StringExtras.h" 20 #include "llvm/IR/Intrinsics.h" 21 #include "llvm/IR/MDBuilder.h" 22 #include "llvm/Support/Path.h" 24 using namespace clang;
25 using namespace CodeGen;
32 "VarDecl must have global or local (in the case of OpenCL) storage!");
34 "Should not call EmitDeclInit on a reference!");
63 llvm_unreachable(
"bad evaluation kind");
97 assert(!D.
getTLSKind() &&
"should have rejected this");
101 llvm::FunctionCallee Func;
102 llvm::Constant *Argument;
109 bool CanRegisterDestructor =
117 if (Record && (CanRegisterDestructor || UsingExternalHelper)) {
129 Argument = llvm::ConstantExpr::getBitCast(Addr.
getPointer(), DestTy);
133 Argument = llvm::ConstantPointerNull::get(DestTy);
135 Argument = llvm::ConstantExpr::getBitCast(
143 Argument = llvm::Constant::getNullValue(CGF.
Int8PtrTy);
152 llvm::Constant *Addr) {
166 llvm::Function *InvariantStart =
CGM.
getIntrinsic(InvStartID, ObjectPtr);
171 llvm::ConstantExpr::getBitCast(Addr,
Int8PtrTy)};
172 Builder.CreateCall(InvariantStart, Args);
176 llvm::Constant *DeclPtr,
198 unsigned ActualAddrSpace = DeclPtr->getType()->getPointerAddressSpace();
199 if (ActualAddrSpace != ExpectedAddrSpace) {
201 llvm::PointerType *PTy = llvm::PointerType::get(LTy, ExpectedAddrSpace);
202 DeclPtr = llvm::ConstantExpr::getAddrSpaceCast(DeclPtr, PTy);
209 D.
hasAttr<OMPThreadPrivateDeclAttr>()) {
211 &D, DeclAddr, D.
getAttr<OMPThreadPrivateDeclAttr>()->getLocation(),
223 assert(PerformInit &&
"cannot have constant initializer which needs " 224 "destruction for reference");
232 llvm::FunctionCallee dtor,
233 llvm::Constant *addr) {
235 llvm::FunctionType *ty = llvm::FunctionType::get(
CGM.
VoidTy,
false);
238 llvm::raw_svector_ostream Out(FnName);
251 llvm::CallInst *call = CGF.
Builder.CreateCall(dtor, addr);
254 if (llvm::Function *dtorFn =
255 dyn_cast<llvm::Function>(dtor.getCallee()->stripPointerCasts()))
256 call->setCallingConv(dtorFn->getCallingConv());
265 llvm::FunctionCallee dtor,
266 llvm::Constant *addr) {
274 llvm::FunctionType *atexitTy =
275 llvm::FunctionType::get(
IntTy, dtorStub->getType(),
false);
277 llvm::FunctionCallee atexit =
280 if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit.getCallee()))
281 atexitFn->setDoesNotThrow();
287 llvm::GlobalVariable *DeclPtr,
294 "this initialization requires a guard variable, which " 295 "the kernel does not support");
301 llvm::BasicBlock *InitBlock,
302 llvm::BasicBlock *NoInitBlock,
309 static const uint64_t InitsPerTLSVar = 1024;
310 static const uint64_t InitsPerLocalVar = 1024 * 1024;
312 llvm::MDNode *Weights;
324 NumInits = InitsPerTLSVar;
326 NumInits = InitsPerLocalVar;
331 Weights = MDHelper.createBranchWeights(1, NumInits - 1);
334 Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights);
338 llvm::FunctionType *FTy,
const Twine &Name,
const CGFunctionInfo &FI,
345 if (
const char *Section =
getTarget().getStaticInitSectionSpecifier())
346 Fn->setSection(Section);
349 SetInternalFunctionAttributes(
GlobalDecl(), Fn, FI);
354 Fn->setDoesNotThrow();
356 if (
getLangOpts().Sanitize.has(SanitizerKind::Address) &&
357 !isInSanitizerBlacklist(SanitizerKind::Address, Fn, Loc))
358 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
360 if (
getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) &&
361 !isInSanitizerBlacklist(SanitizerKind::KernelAddress, Fn, Loc))
362 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
364 if (
getLangOpts().Sanitize.has(SanitizerKind::HWAddress) &&
365 !isInSanitizerBlacklist(SanitizerKind::HWAddress, Fn, Loc))
366 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
368 if (
getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) &&
369 !isInSanitizerBlacklist(SanitizerKind::KernelHWAddress, Fn, Loc))
370 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
372 if (
getLangOpts().Sanitize.has(SanitizerKind::MemTag) &&
373 !isInSanitizerBlacklist(SanitizerKind::MemTag, Fn, Loc))
374 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
376 if (
getLangOpts().Sanitize.has(SanitizerKind::Thread) &&
377 !isInSanitizerBlacklist(SanitizerKind::Thread, Fn, Loc))
378 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
380 if (
getLangOpts().Sanitize.has(SanitizerKind::Memory) &&
381 !isInSanitizerBlacklist(SanitizerKind::Memory, Fn, Loc))
382 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
384 if (
getLangOpts().Sanitize.has(SanitizerKind::KernelMemory) &&
385 !isInSanitizerBlacklist(SanitizerKind::KernelMemory, Fn, Loc))
386 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
388 if (
getLangOpts().Sanitize.has(SanitizerKind::SafeStack) &&
389 !isInSanitizerBlacklist(SanitizerKind::SafeStack, Fn, Loc))
390 Fn->addFnAttr(llvm::Attribute::SafeStack);
392 if (
getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) &&
393 !isInSanitizerBlacklist(SanitizerKind::ShadowCallStack, Fn, Loc))
394 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
396 auto RASignKind = getCodeGenOpts().getSignReturnAddress();
398 Fn->addFnAttr(
"sign-return-address",
402 auto RASignKey = getCodeGenOpts().getSignReturnAddressKey();
403 Fn->addFnAttr(
"sign-return-address-key",
404 RASignKey == CodeGenOptions::SignReturnAddressKeyValue::AKey
409 if (getCodeGenOpts().BranchTargetEnforcement)
410 Fn->addFnAttr(
"branch-target-enforcement");
418 void CodeGenModule::EmitPointerToInitFunc(
const VarDecl *D,
419 llvm::GlobalVariable *GV,
420 llvm::Function *InitFunc,
422 llvm::GlobalVariable *PtrArray =
new llvm::GlobalVariable(
423 TheModule, InitFunc->getType(),
true,
424 llvm::GlobalValue::PrivateLinkage, InitFunc,
"__cxx_init_fn_ptr");
425 PtrArray->setSection(ISA->getSection());
426 addUsedGlobal(PtrArray);
429 if (llvm::Comdat *C = GV->getComdat())
430 PtrArray->setComdat(C);
434 CodeGenModule::EmitCXXGlobalVarDeclInitFunc(
const VarDecl *D,
435 llvm::GlobalVariable *Addr,
444 (D->
hasAttr<CUDADeviceAttr>() || D->
hasAttr<CUDAConstantAttr>() ||
453 auto I = DelayedCXXInitPosition.find(D);
454 if (I != DelayedCXXInitPosition.end() && I->second == ~0U)
457 llvm::FunctionType *FTy = llvm::FunctionType::get(
VoidTy,
false);
460 llvm::raw_svector_ostream Out(FnName);
461 getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out);
466 CreateGlobalInitOrDestructFunction(FTy, FnName.str(),
470 auto *ISA = D->
getAttr<InitSegAttr>();
474 llvm::GlobalVariable *COMDATKey =
481 CXXThreadLocalInits.push_back(Fn);
482 CXXThreadLocalInitVars.push_back(D);
483 }
else if (PerformInit && ISA) {
484 EmitPointerToInitFunc(D, Addr, Fn, ISA);
485 }
else if (
auto *IPA = D->
getAttr<InitPriorityAttr>()) {
487 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
502 AddGlobalCtor(Fn, 65535, COMDATKey);
503 if (
getTarget().getCXXABI().isMicrosoft() && COMDATKey) {
506 addUsedGlobal(COMDATKey);
508 }
else if (D->
hasAttr<SelectAnyAttr>()) {
512 AddGlobalCtor(Fn, 65535, COMDATKey);
514 I = DelayedCXXInitPosition.find(D);
515 if (I == DelayedCXXInitPosition.end()) {
516 CXXGlobalInits.push_back(Fn);
517 }
else if (I->second != ~0U) {
518 assert(I->second < CXXGlobalInits.size() &&
519 CXXGlobalInits[I->second] ==
nullptr);
520 CXXGlobalInits[I->second] = Fn;
525 DelayedCXXInitPosition[D] = ~0U;
528 void CodeGenModule::EmitCXXThreadLocalInitFunc() {
529 getCXXABI().EmitThreadLocalInitFuncs(
530 *
this, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars);
532 CXXThreadLocalInits.clear();
533 CXXThreadLocalInitVars.clear();
534 CXXThreadLocals.clear();
538 CodeGenModule::EmitCXXGlobalInitFunc() {
539 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
540 CXXGlobalInits.pop_back();
542 if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty())
545 llvm::FunctionType *FTy = llvm::FunctionType::get(
VoidTy,
false);
549 if (!PrioritizedCXXGlobalInits.empty()) {
551 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
552 PrioritizedCXXGlobalInits.end());
557 I = PrioritizedCXXGlobalInits.begin(),
558 E = PrioritizedCXXGlobalInits.end(); I != E; ) {
560 PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp());
562 LocalCXXGlobalInits.clear();
563 unsigned Priority = I->first.priority;
566 std::string PrioritySuffix = llvm::utostr(Priority);
568 PrioritySuffix = std::string(6-PrioritySuffix.size(),
'0')+PrioritySuffix;
569 llvm::Function *Fn = CreateGlobalInitOrDestructFunction(
570 FTy,
"_GLOBAL__I_" + PrioritySuffix, FI);
572 for (; I < PrioE; ++I)
573 LocalCXXGlobalInits.push_back(I->second);
576 AddGlobalCtor(Fn, Priority);
578 PrioritizedCXXGlobalInits.clear();
585 if (FileName.empty())
588 for (
size_t i = 0;
i < FileName.size(); ++
i) {
595 llvm::Function *Fn = CreateGlobalInitOrDestructFunction(
596 FTy, llvm::Twine(
"_GLOBAL__sub_I_", FileName), FI);
610 GenOpenCLArgMetadata(Fn);
611 Fn->setCallingConv(llvm::CallingConv::SPIR_KERNEL);
614 CXXGlobalInits.clear();
617 void CodeGenModule::EmitCXXGlobalDtorFunc() {
618 if (CXXGlobalDtors.empty())
621 llvm::FunctionType *FTy = llvm::FunctionType::get(
VoidTy,
false);
626 CreateGlobalInitOrDestructFunction(FTy,
"_GLOBAL__D_a", FI);
635 llvm::GlobalVariable *Addr,
655 if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage() ||
677 llvm::BasicBlock *ExitBlock =
nullptr;
683 "guard.uninitialized");
710 for (
unsigned i = 0, e = Decls.size();
i != e; ++
i)
714 Scope.ForceCleanup();
727 const std::vector<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
728 llvm::Constant *>> &DtorsAndObjects) {
737 for (
unsigned i = 0, e = DtorsAndObjects.size();
i != e; ++
i) {
738 llvm::FunctionType *CalleeTy;
741 std::tie(CalleeTy, Callee, Arg) = DtorsAndObjects[e -
i - 1];
742 llvm::CallInst *CI =
Builder.CreateCall(CalleeTy, Callee, Arg);
744 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
745 CI->setCallingConv(F->getCallingConv());
757 bool useEHCleanupForArray,
const VarDecl *VD) {
761 args.push_back(&Dst);
767 FTy,
"__cxx_global_array_dtor", FI, VD->
getLocation());
773 emitDestroy(addr, type, destroyer, useEHCleanupForArray);
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
const llvm::DataLayout & getDataLayout() const
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.
llvm::IntegerType * IntTy
int
Other implicit parameter.
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
A (possibly-)qualified type.
CodeGenTypes & getTypes()
const CodeGenOptions & getCodeGenOpts() const
llvm::LLVMContext & getLLVMContext()
The base class of the type hierarchy.
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
Represents a variable declaration or definition.
llvm::Value * EmitObjCAutoreleasePoolPush()
Produce the code to do a objc_autoreleasepool_push.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
const TargetInfo & getTarget() const
void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
emitDestroy - Immediately perform the destruction of the given object.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
llvm::IntegerType * Int64Ty
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
bool isReferenceType() const
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.
SourceLocation getBeginLoc() const LLVM_READONLY
void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit)
Emit the code necessary to initialize the given global variable.
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...
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
CharUnits - This is an opaque type for sizes expressed in character units.
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::PointerType * VoidPtrTy
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind...
LangAS getAddressSpace() const
Scope - A scope is a transient data structure that is used while parsing the program.
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
virtual bool canCallMismatchedFunctionType() const
Returns true if the target allows calling a function through a pointer with a different signature tha...
constexpr XRayInstrMask All
virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, bool threadlocal=false)=0
bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor)
isTypeConstant - Determine whether an object of this type can be emitted as a constant.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
ASTContext & getContext() const
const TargetCodeGenInfo & getTargetCodeGenInfo()
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
virtual void mangleDynamicAtExitDestructor(const VarDecl *D, raw_ostream &)=0
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
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...
llvm::CallingConv::ID getRuntimeCC() const
void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)
Emit code in this function to perform a guarded variable initialization.
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)
generateDestroyHelper - Generates a helper function which, when invoked, destroys the given object...
This represents one expression.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
const CGFunctionInfo & arrangeNullaryFunction()
A nullary function is a freestanding function of type 'void ()'.
Represents a C++ destructor within a class.
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 ...
void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size)
TLSKind getTLSKind() const
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function *> CXXThreadLocals, ConstantAddress Guard=ConstantAddress::invalid())
GenerateCXXGlobalInitFunc - Generates code for initializing global variables.
void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr, bool PerformInit)
EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.
bool isObjCStrong() const
ASTContext & getContext() const
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
GlobalDecl - represents a global declaration.
The l-value was considered opaque, so the alignment was determined from a type.
Encodes a location in the source.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
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.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
MangleContext & getMangleContext()
Gets the mangle context.
constexpr XRayInstrMask None
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
FunctionArgList - Type for representing both the decl and type of parameters to a function...
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
TLS with a dynamic initializer.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
Dataflow Directional Tag Classes.
const Expr * getInit() const
llvm::Constant * getPointer() const
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
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.
static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, ConstantAddress Addr)
Emit code to cause the destruction of the given variable with static storage duration.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type *> Tys=None)
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
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)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
llvm::Function * createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)
Create a stub function, suitable for being passed to atexit, which passes the given address to the gi...
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
GVALinkage GetGVALinkageForVariable(const VarDecl *VD)
virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0
virtual bool emitDeclareTargetVarDefinition(const VarDecl *VD, llvm::GlobalVariable *Addr, bool PerformInit)
Emit a code for initialization of declare target variable.
CodeGenTypes & getTypes() const
llvm::PointerType * Int8PtrTy
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create or return a runtime function declaration with the specified type and name. ...
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D, ConstantAddress DeclPtr)
llvm::FunctionCallee getAddrAndTypeOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Represents a C++ struct/union/class.
llvm::Function * CreateGlobalInitOrDestructFunction(llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI, SourceLocation Loc=SourceLocation(), bool TLS=false)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
A specialization of Address that requires the address to be an LLVM Constant.
void GenerateCXXGlobalDtorsFunc(llvm::Function *Fn, const std::vector< std::tuple< llvm::FunctionType *, llvm::WeakTrackingVH, llvm::Constant *>> &DtorsAndObjects)
GenerateCXXGlobalDtorsFunc - Generates code for destroying global variables.
CGCXXABI & getCXXABI() const
virtual LangAS getAddrSpaceOfCxaAtexitPtrParam() const
Get address space of pointer parameter for __cxa_atexit.
void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr)
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
LValue - This represents an lvalue references.
const LangOptions & getLangOpts() const
unsigned getTargetAddressSpace(QualType T) const
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
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 LangOptions & getLangOpts() const
SourceLocation getLocation() const
bool isExternallyVisible() const
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...
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
static CharUnits getDeclAlign(Expr *E, CharUnits TypeAlign, ASTContext &Context)
A helper function to get the alignment of a Decl referred to by DeclRefExpr or MemberExpr.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
bool isNoDestroy(const ASTContext &) const
Do we need to emit an exit-time destructor for this variable?