clang/lib/CodeGen/CGDeclCXX.cpp

   1 //===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This contains code dealing with code generation of C++ declarations
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "CGCXXABI.h"
  14 #include "CGHLSLRuntime.h"
  15 #include "CGObjCRuntime.h"
  16 #include "CGOpenMPRuntime.h"
  17 #include "CodeGenFunction.h"
  18 #include "TargetInfo.h"
  19 #include "clang/AST/Attr.h"
  20 #include "clang/Basic/LangOptions.h"
  21 #include "llvm/ADT/StringExtras.h"
  22 #include "llvm/IR/Intrinsics.h"
  23 #include "llvm/IR/MDBuilder.h"
  24 #include "llvm/Support/Path.h"
  25
  26 using namespace clang;
  27 using namespace CodeGen;
  28
  29 static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D,
  30                          ConstantAddress DeclPtr) {
  31   assert(
  32       (D.hasGlobalStorage() ||
  33        (D.hasLocalStorage() && CGF.getContext().getLangOpts().OpenCLCPlusPlus)) &&
  34       "VarDecl must have global or local (in the case of OpenCL) storage!");
  35   assert(!D.getType()->isReferenceType() &&
  36          "Should not call EmitDeclInit on a reference!");
  37
  38   QualType type = D.getType();
  39   LValue lv = CGF.MakeAddrLValue(DeclPtr, type);
  40
  41   const Expr *Init = D.getInit();
  42   switch (CGF.getEvaluationKind(type)) {
  43   case TEK_Scalar: {
  44     CodeGenModule &CGM = CGF.CGM;
  45     if (lv.isObjCStrong())
  46       CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init),
  47                                                 DeclPtr, D.getTLSKind());
  48     else if (lv.isObjCWeak())
  49       CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init),
  50                                               DeclPtr);
  51     else
  52       CGF.EmitScalarInit(Init, &D, lv, false);
  53     return;
  54   }
  55   case TEK_Complex:
  56     CGF.EmitComplexExprIntoLValue(Init, lv, /*isInit*/ true);
  57     return;
  58   case TEK_Aggregate:
  59     CGF.EmitAggExpr(Init,
  60                     AggValueSlot::forLValue(lv, CGF, AggValueSlot::IsDestructed,
  61                                             AggValueSlot::DoesNotNeedGCBarriers,
  62                                             AggValueSlot::IsNotAliased,
  63                                             AggValueSlot::DoesNotOverlap));
  64     return;
  65   }
  66   llvm_unreachable("bad evaluation kind");
  67 }
  68
  69 /// Emit code to cause the destruction of the given variable with
  70 /// static storage duration.
  71 static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
  72                             ConstantAddress Addr) {
  73   // Honor __attribute__((no_destroy)) and bail instead of attempting
  74   // to emit a reference to a possibly nonexistent destructor, which
  75   // in turn can cause a crash. This will result in a global constructor
  76   // that isn't balanced out by a destructor call as intended by the
  77   // attribute. This also checks for -fno-c++-static-destructors and
  78   // bails even if the attribute is not present.
  79   QualType::DestructionKind DtorKind = D.needsDestruction(CGF.getContext());
  80
  81   // FIXME:  __attribute__((cleanup)) ?
  82
  83   switch (DtorKind) {
  84   case QualType::DK_none:
  85     return;
  86
  87   case QualType::DK_cxx_destructor:
  88     break;
  89
  90   case QualType::DK_objc_strong_lifetime:
  91   case QualType::DK_objc_weak_lifetime:
  92   case QualType::DK_nontrivial_c_struct:
  93     // We don't care about releasing objects during process teardown.
  94     assert(!D.getTLSKind() && "should have rejected this");
  95     return;
  96   }
  97
  98   llvm::FunctionCallee Func;
  99   llvm::Constant *Argument;
 100
 101   CodeGenModule &CGM = CGF.CGM;
 102   QualType Type = D.getType();
 103
 104   // Special-case non-array C++ destructors, if they have the right signature.
 105   // Under some ABIs, destructors return this instead of void, and cannot be
 106   // passed directly to __cxa_atexit if the target does not allow this
 107   // mismatch.
 108   const CXXRecordDecl *Record = Type->getAsCXXRecordDecl();
 109   bool CanRegisterDestructor =
 110       Record && (!CGM.getCXXABI().HasThisReturn(
 111                      GlobalDecl(Record->getDestructor(), Dtor_Complete)) ||
 112                  CGM.getCXXABI().canCallMismatchedFunctionType());
 113   // If __cxa_atexit is disabled via a flag, a different helper function is
 114   // generated elsewhere which uses atexit instead, and it takes the destructor
 115   // directly.
 116   bool UsingExternalHelper = !CGM.getCodeGenOpts().CXAAtExit;
 117   if (Record && (CanRegisterDestructor || UsingExternalHelper)) {
 118     assert(!Record->hasTrivialDestructor());
 119     CXXDestructorDecl *Dtor = Record->getDestructor();
 120
 121     Func = CGM.getAddrAndTypeOfCXXStructor(GlobalDecl(Dtor, Dtor_Complete));
 122     if (CGF.getContext().getLangOpts().OpenCL) {
 123       auto DestAS =
 124           CGM.getTargetCodeGenInfo().getAddrSpaceOfCxaAtexitPtrParam();
 125       auto DestTy = llvm::PointerType::get(
 126           CGM.getLLVMContext(), CGM.getContext().getTargetAddressSpace(DestAS));
 127       auto SrcAS = D.getType().getQualifiers().getAddressSpace();
 128       if (DestAS == SrcAS)
 129         Argument = llvm::ConstantExpr::getBitCast(Addr.getPointer(), DestTy);
 130       else
 131         // FIXME: On addr space mismatch we are passing NULL. The generation
 132         // of the global destructor function should be adjusted accordingly.
 133         Argument = llvm::ConstantPointerNull::get(DestTy);
 134     } else {
 135       Argument = Addr.getPointer();
 136     }
 137   // Otherwise, the standard logic requires a helper function.
 138   } else {
 139     Addr = Addr.withElementType(CGF.ConvertTypeForMem(Type));
 140     Func = CodeGenFunction(CGM)
 141            .generateDestroyHelper(Addr, Type, CGF.getDestroyer(DtorKind),
 142                                   CGF.needsEHCleanup(DtorKind), &D);
 143     Argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
 144   }
 145
 146   CGM.getCXXABI().registerGlobalDtor(CGF, D, Func, Argument);
 147 }
 148
 149 /// Emit code to cause the variable at the given address to be considered as
 150 /// constant from this point onwards.
 151 static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D,
 152                               llvm::Constant *Addr) {
 153   return CGF.EmitInvariantStart(
 154       Addr, CGF.getContext().getTypeSizeInChars(D.getType()));
 155 }
 156
 157 void CodeGenFunction::EmitInvariantStart(llvm::Constant *Addr, CharUnits Size) {
 158   // Do not emit the intrinsic if we're not optimizing.
 159   if (!CGM.getCodeGenOpts().OptimizationLevel)
 160     return;
 161
 162   // Grab the llvm.invariant.start intrinsic.
 163   llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start;
 164   // Overloaded address space type.
 165   llvm::Type *ObjectPtr[1] = {Int8PtrTy};
 166   llvm::Function *InvariantStart = CGM.getIntrinsic(InvStartID, ObjectPtr);
 167
 168   // Emit a call with the size in bytes of the object.
 169   uint64_t Width = Size.getQuantity();
 170   llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(Int64Ty, Width),
 171                            llvm::ConstantExpr::getBitCast(Addr, Int8PtrTy)};
 172   Builder.CreateCall(InvariantStart, Args);
 173 }
 174
 175 void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
 176                                                llvm::GlobalVariable *GV,
 177                                                bool PerformInit) {
 178
 179   const Expr *Init = D.getInit();
 180   QualType T = D.getType();
 181
 182   // The address space of a static local variable (DeclPtr) may be different
 183   // from the address space of the "this" argument of the constructor. In that
 184   // case, we need an addrspacecast before calling the constructor.
 185   //
 186   // struct StructWithCtor {
 187   //   __device__ StructWithCtor() {...}
 188   // };
 189   // __device__ void foo() {
 190   //   __shared__ StructWithCtor s;
 191   //   ...
 192   // }
 193   //
 194   // For example, in the above CUDA code, the static local variable s has a
 195   // "shared" address space qualifier, but the constructor of StructWithCtor
 196   // expects "this" in the "generic" address space.
 197   unsigned ExpectedAddrSpace = getTypes().getTargetAddressSpace(T);
 198   unsigned ActualAddrSpace = GV->getAddressSpace();
 199   llvm::Constant *DeclPtr = GV;
 200   if (ActualAddrSpace != ExpectedAddrSpace) {
 201     llvm::PointerType *PTy =
 202         llvm::PointerType::get(getLLVMContext(), ExpectedAddrSpace);
 203     DeclPtr = llvm::ConstantExpr::getAddrSpaceCast(DeclPtr, PTy);
 204   }
 205
 206   ConstantAddress DeclAddr(
 207       DeclPtr, GV->getValueType(), getContext().getDeclAlign(&D));
 208
 209   if (!T->isReferenceType()) {
 210     if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd &&
 211         D.hasAttr<OMPThreadPrivateDeclAttr>()) {
 212       (void)CGM.getOpenMPRuntime().emitThreadPrivateVarDefinition(
 213           &D, DeclAddr, D.getAttr<OMPThreadPrivateDeclAttr>()->getLocation(),
 214           PerformInit, this);
 215     }
 216     bool NeedsDtor =
 217         D.needsDestruction(getContext()) == QualType::DK_cxx_destructor;
 218     if (PerformInit)
 219       EmitDeclInit(*this, D, DeclAddr);
 220     if (D.getType().isConstantStorage(getContext(), true, !NeedsDtor))
 221       EmitDeclInvariant(*this, D, DeclPtr);
 222     else
 223       EmitDeclDestroy(*this, D, DeclAddr);
 224     return;
 225   }
 226
 227   assert(PerformInit && "cannot have constant initializer which needs "
 228          "destruction for reference");
 229   RValue RV = EmitReferenceBindingToExpr(Init);
 230   EmitStoreOfScalar(RV.getScalarVal(), DeclAddr, false, T);
 231 }
 232
 233 /// Create a stub function, suitable for being passed to atexit,
 234 /// which passes the given address to the given destructor function.
 235 llvm::Function *CodeGenFunction::createAtExitStub(const VarDecl &VD,
 236                                                   llvm::FunctionCallee dtor,
 237                                                   llvm::Constant *addr) {
 238   // Get the destructor function type, void(*)(void).
 239   llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false);
 240   SmallString<256> FnName;
 241   {
 242     llvm::raw_svector_ostream Out(FnName);
 243     CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out);
 244   }
 245
 246   const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
 247   llvm::Function *fn = CGM.CreateGlobalInitOrCleanUpFunction(
 248       ty, FnName.str(), FI, VD.getLocation());
 249
 250   CodeGenFunction CGF(CGM);
 251
 252   CGF.StartFunction(GlobalDecl(&VD, DynamicInitKind::AtExit),
 253                     CGM.getContext().VoidTy, fn, FI, FunctionArgList(),
 254                     VD.getLocation(), VD.getInit()->getExprLoc());
 255   // Emit an artificial location for this function.
 256   auto AL = ApplyDebugLocation::CreateArtificial(CGF);
 257
 258   llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);
 259
 260   // Make sure the call and the callee agree on calling convention.
 261   if (auto *dtorFn = dyn_cast<llvm::Function>(
 262           dtor.getCallee()->stripPointerCastsAndAliases()))
 263     call->setCallingConv(dtorFn->getCallingConv());
 264
 265   CGF.FinishFunction();
 266
 267   return fn;
 268 }
 269
 270 /// Create a stub function, suitable for being passed to __pt_atexit_np,
 271 /// which passes the given address to the given destructor function.
 272 llvm::Function *CodeGenFunction::createTLSAtExitStub(
 273     const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr,
 274     llvm::FunctionCallee &AtExit) {
 275   SmallString<256> FnName;
 276   {
 277     llvm::raw_svector_ostream Out(FnName);
 278     CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&D, Out);
 279   }
 280
 281   const CGFunctionInfo &FI = CGM.getTypes().arrangeLLVMFunctionInfo(
 282       getContext().IntTy, FnInfoOpts::None, {getContext().IntTy},
 283       FunctionType::ExtInfo(), {}, RequiredArgs::All);
 284
 285   // Get the stub function type, int(*)(int,...).
 286   llvm::FunctionType *StubTy =
 287       llvm::FunctionType::get(CGM.IntTy, {CGM.IntTy}, true);
 288
 289   llvm::Function *DtorStub = CGM.CreateGlobalInitOrCleanUpFunction(
 290       StubTy, FnName.str(), FI, D.getLocation());
 291
 292   CodeGenFunction CGF(CGM);
 293
 294   FunctionArgList Args;
 295   ImplicitParamDecl IPD(CGM.getContext(), CGM.getContext().IntTy,
 296                         ImplicitParamDecl::Other);
 297   Args.push_back(&IPD);
 298   QualType ResTy = CGM.getContext().IntTy;
 299
 300   CGF.StartFunction(GlobalDecl(&D, DynamicInitKind::AtExit), ResTy, DtorStub,
 301                     FI, Args, D.getLocation(), D.getInit()->getExprLoc());
 302
 303   // Emit an artificial location for this function.
 304   auto AL = ApplyDebugLocation::CreateArtificial(CGF);
 305
 306   llvm::CallInst *call = CGF.Builder.CreateCall(Dtor, Addr);
 307
 308   // Make sure the call and the callee agree on calling convention.
 309   if (auto *DtorFn = dyn_cast<llvm::Function>(
 310           Dtor.getCallee()->stripPointerCastsAndAliases()))
 311     call->setCallingConv(DtorFn->getCallingConv());
 312
 313   // Return 0 from function
 314   CGF.Builder.CreateStore(llvm::Constant::getNullValue(CGM.IntTy),
 315                           CGF.ReturnValue);
 316
 317   CGF.FinishFunction();
 318
 319   return DtorStub;
 320 }
 321
 322 /// Register a global destructor using the C atexit runtime function.
 323 void CodeGenFunction::registerGlobalDtorWithAtExit(const VarDecl &VD,
 324                                                    llvm::FunctionCallee dtor,
 325                                                    llvm::Constant *addr) {
 326   // Create a function which calls the destructor.
 327   llvm::Constant *dtorStub = createAtExitStub(VD, dtor, addr);
 328   registerGlobalDtorWithAtExit(dtorStub);
 329 }
 330
 331 void CodeGenFunction::registerGlobalDtorWithAtExit(llvm::Constant *dtorStub) {
 332   // extern "C" int atexit(void (*f)(void));
 333   assert(dtorStub->getType() ==
 334              llvm::PointerType::get(
 335                  llvm::FunctionType::get(CGM.VoidTy, false),
 336                  dtorStub->getType()->getPointerAddressSpace()) &&
 337          "Argument to atexit has a wrong type.");
 338
 339   llvm::FunctionType *atexitTy =
 340       llvm::FunctionType::get(IntTy, dtorStub->getType(), false);
 341
 342   llvm::FunctionCallee atexit =
 343       CGM.CreateRuntimeFunction(atexitTy, "atexit", llvm::AttributeList(),
 344                                 /*Local=*/true);
 345   if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit.getCallee()))
 346     atexitFn->setDoesNotThrow();
 347
 348   EmitNounwindRuntimeCall(atexit, dtorStub);
 349 }
 350
 351 llvm::Value *
 352 CodeGenFunction::unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub) {
 353   // The unatexit subroutine unregisters __dtor functions that were previously
 354   // registered by the atexit subroutine. If the referenced function is found,
 355   // it is removed from the list of functions that are called at normal program
 356   // termination and the unatexit returns a value of 0, otherwise a non-zero
 357   // value is returned.
 358   //
 359   // extern "C" int unatexit(void (*f)(void));
 360   assert(dtorStub->getType() ==
 361              llvm::PointerType::get(
 362                  llvm::FunctionType::get(CGM.VoidTy, false),
 363                  dtorStub->getType()->getPointerAddressSpace()) &&
 364          "Argument to unatexit has a wrong type.");
 365
 366   llvm::FunctionType *unatexitTy =
 367       llvm::FunctionType::get(IntTy, {dtorStub->getType()}, /*isVarArg=*/false);
 368
 369   llvm::FunctionCallee unatexit =
 370       CGM.CreateRuntimeFunction(unatexitTy, "unatexit", llvm::AttributeList());
 371
 372   cast<llvm::Function>(unatexit.getCallee())->setDoesNotThrow();
 373
 374   return EmitNounwindRuntimeCall(unatexit, dtorStub);
 375 }
 376
 377 void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,
 378                                          llvm::GlobalVariable *DeclPtr,
 379                                          bool PerformInit) {
 380   // If we've been asked to forbid guard variables, emit an error now.
 381   // This diagnostic is hard-coded for Darwin's use case;  we can find
 382   // better phrasing if someone else needs it.
 383   if (CGM.getCodeGenOpts().ForbidGuardVariables)
 384     CGM.Error(D.getLocation(),
 385               "this initialization requires a guard variable, which "
 386               "the kernel does not support");
 387
 388   CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit);
 389 }
 390
 391 void CodeGenFunction::EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
 392                                                llvm::BasicBlock *InitBlock,
 393                                                llvm::BasicBlock *NoInitBlock,
 394                                                GuardKind Kind,
 395                                                const VarDecl *D) {
 396   assert((Kind == GuardKind::TlsGuard || D) && "no guarded variable");
 397
 398   // A guess at how many times we will enter the initialization of a
 399   // variable, depending on the kind of variable.
 400   static const uint64_t InitsPerTLSVar = 1024;
 401   static const uint64_t InitsPerLocalVar = 1024 * 1024;
 402
 403   llvm::MDNode *Weights;
 404   if (Kind == GuardKind::VariableGuard && !D->isLocalVarDecl()) {
 405     // For non-local variables, don't apply any weighting for now. Due to our
 406     // use of COMDATs, we expect there to be at most one initialization of the
 407     // variable per DSO, but we have no way to know how many DSOs will try to
 408     // initialize the variable.
 409     Weights = nullptr;
 410   } else {
 411     uint64_t NumInits;
 412     // FIXME: For the TLS case, collect and use profiling information to
 413     // determine a more accurate brach weight.
 414     if (Kind == GuardKind::TlsGuard || D->getTLSKind())
 415       NumInits = InitsPerTLSVar;
 416     else
 417       NumInits = InitsPerLocalVar;
 418
 419     // The probability of us entering the initializer is
 420     //   1 / (total number of times we attempt to initialize the variable).
 421     llvm::MDBuilder MDHelper(CGM.getLLVMContext());
 422     Weights = MDHelper.createBranchWeights(1, NumInits - 1);
 423   }
 424
 425   Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights);
 426 }
 427
 428 llvm::Function *CodeGenModule::CreateGlobalInitOrCleanUpFunction(
 429     llvm::FunctionType *FTy, const Twine &Name, const CGFunctionInfo &FI,
 430     SourceLocation Loc, bool TLS, llvm::GlobalVariable::LinkageTypes Linkage) {
 431   llvm::Function *Fn = llvm::Function::Create(FTy, Linkage, Name, &getModule());
 432
 433   if (!getLangOpts().AppleKext && !TLS) {
 434     // Set the section if needed.
 435     if (const char *Section = getTarget().getStaticInitSectionSpecifier())
 436       Fn->setSection(Section);
 437   }
 438
 439   if (Linkage == llvm::GlobalVariable::InternalLinkage)
 440     SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 441
 442   Fn->setCallingConv(getRuntimeCC());
 443
 444   if (!getLangOpts().Exceptions)
 445     Fn->setDoesNotThrow();
 446
 447   if (getLangOpts().Sanitize.has(SanitizerKind::Address) &&
 448       !isInNoSanitizeList(SanitizerKind::Address, Fn, Loc))
 449     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
 450
 451   if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) &&
 452       !isInNoSanitizeList(SanitizerKind::KernelAddress, Fn, Loc))
 453     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
 454
 455   if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) &&
 456       !isInNoSanitizeList(SanitizerKind::HWAddress, Fn, Loc))
 457     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
 458
 459   if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) &&
 460       !isInNoSanitizeList(SanitizerKind::KernelHWAddress, Fn, Loc))
 461     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
 462
 463   if (getLangOpts().Sanitize.has(SanitizerKind::MemtagStack) &&
 464       !isInNoSanitizeList(SanitizerKind::MemtagStack, Fn, Loc))
 465     Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
 466
 467   if (getLangOpts().Sanitize.has(SanitizerKind::Thread) &&
 468       !isInNoSanitizeList(SanitizerKind::Thread, Fn, Loc))
 469     Fn->addFnAttr(llvm::Attribute::SanitizeThread);
 470
 471   if (getLangOpts().Sanitize.has(SanitizerKind::Memory) &&
 472       !isInNoSanitizeList(SanitizerKind::Memory, Fn, Loc))
 473     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
 474
 475   if (getLangOpts().Sanitize.has(SanitizerKind::KernelMemory) &&
 476       !isInNoSanitizeList(SanitizerKind::KernelMemory, Fn, Loc))
 477     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
 478
 479   if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) &&
 480       !isInNoSanitizeList(SanitizerKind::SafeStack, Fn, Loc))
 481     Fn->addFnAttr(llvm::Attribute::SafeStack);
 482
 483   if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) &&
 484       !isInNoSanitizeList(SanitizerKind::ShadowCallStack, Fn, Loc))
 485     Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
 486
 487   return Fn;
 488 }
 489
 490 /// Create a global pointer to a function that will initialize a global
 491 /// variable.  The user has requested that this pointer be emitted in a specific
 492 /// section.
 493 void CodeGenModule::EmitPointerToInitFunc(const VarDecl *D,
 494                                           llvm::GlobalVariable *GV,
 495                                           llvm::Function *InitFunc,
 496                                           InitSegAttr *ISA) {
 497   llvm::GlobalVariable *PtrArray = new llvm::GlobalVariable(
 498       TheModule, InitFunc->getType(), /*isConstant=*/true,
 499       llvm::GlobalValue::PrivateLinkage, InitFunc, "__cxx_init_fn_ptr");
 500   PtrArray->setSection(ISA->getSection());
 501   addUsedGlobal(PtrArray);
 502
 503   // If the GV is already in a comdat group, then we have to join it.
 504   if (llvm::Comdat *C = GV->getComdat())
 505     PtrArray->setComdat(C);
 506 }
 507
 508 void
 509 CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
 510                                             llvm::GlobalVariable *Addr,
 511                                             bool PerformInit) {
 512
 513   // According to E.2.3.1 in CUDA-7.5 Programming guide: __device__,
 514   // __constant__ and __shared__ variables defined in namespace scope,
 515   // that are of class type, cannot have a non-empty constructor. All
 516   // the checks have been done in Sema by now. Whatever initializers
 517   // are allowed are empty and we just need to ignore them here.
 518   if (getLangOpts().CUDAIsDevice && !getLangOpts().GPUAllowDeviceInit &&
 519       (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>() ||
 520        D->hasAttr<CUDASharedAttr>()))
 521     return;
 522
 523   if (getLangOpts().OpenMP &&
 524       getOpenMPRuntime().emitDeclareTargetVarDefinition(D, Addr, PerformInit))
 525     return;
 526
 527   // Check if we've already initialized this decl.
 528   auto I = DelayedCXXInitPosition.find(D);
 529   if (I != DelayedCXXInitPosition.end() && I->second == ~0U)
 530     return;
 531
 532   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 533   SmallString<256> FnName;
 534   {
 535     llvm::raw_svector_ostream Out(FnName);
 536     getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out);
 537   }
 538
 539   // Create a variable initialization function.
 540   llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
 541       FTy, FnName.str(), getTypes().arrangeNullaryFunction(), D->getLocation());
 542
 543   auto *ISA = D->getAttr<InitSegAttr>();
 544   CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr,
 545                                                           PerformInit);
 546
 547   llvm::GlobalVariable *COMDATKey =
 548       supportsCOMDAT() && D->isExternallyVisible() ? Addr : nullptr;
 549
 550   if (D->getTLSKind()) {
 551     // FIXME: Should we support init_priority for thread_local?
 552     // FIXME: We only need to register one __cxa_thread_atexit function for the
 553     // entire TU.
 554     CXXThreadLocalInits.push_back(Fn);
 555     CXXThreadLocalInitVars.push_back(D);
 556   } else if (PerformInit && ISA) {
 557     // Contract with backend that "init_seg(compiler)" corresponds to priority
 558     // 200 and "init_seg(lib)" corresponds to priority 400.
 559     int Priority = -1;
 560     if (ISA->getSection() == ".CRT$XCC")
 561       Priority = 200;
 562     else if (ISA->getSection() == ".CRT$XCL")
 563       Priority = 400;
 564
 565     if (Priority != -1)
 566       AddGlobalCtor(Fn, Priority, ~0U, COMDATKey);
 567     else
 568       EmitPointerToInitFunc(D, Addr, Fn, ISA);
 569   } else if (auto *IPA = D->getAttr<InitPriorityAttr>()) {
 570     OrderGlobalInitsOrStermFinalizers Key(IPA->getPriority(),
 571                                           PrioritizedCXXGlobalInits.size());
 572     PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
 573   } else if (isTemplateInstantiation(D->getTemplateSpecializationKind()) ||
 574              getContext().GetGVALinkageForVariable(D) == GVA_DiscardableODR ||
 575              D->hasAttr<SelectAnyAttr>()) {
 576     // C++ [basic.start.init]p2:
 577     //   Definitions of explicitly specialized class template static data
 578     //   members have ordered initialization. Other class template static data
 579     //   members (i.e., implicitly or explicitly instantiated specializations)
 580     //   have unordered initialization.
 581     //
 582     // As a consequence, we can put them into their own llvm.global_ctors entry.
 583     //
 584     // If the global is externally visible, put the initializer into a COMDAT
 585     // group with the global being initialized.  On most platforms, this is a
 586     // minor startup time optimization.  In the MS C++ ABI, there are no guard
 587     // variables, so this COMDAT key is required for correctness.
 588     //
 589     // SelectAny globals will be comdat-folded. Put the initializer into a
 590     // COMDAT group associated with the global, so the initializers get folded
 591     // too.
 592     I = DelayedCXXInitPosition.find(D);
 593     // CXXGlobalInits.size() is the lex order number for the next deferred
 594     // VarDecl. Use it when the current VarDecl is non-deferred. Although this
 595     // lex order number is shared between current VarDecl and some following
 596     // VarDecls, their order of insertion into `llvm.global_ctors` is the same
 597     // as the lexing order and the following stable sort would preserve such
 598     // order.
 599     unsigned LexOrder =
 600         I == DelayedCXXInitPosition.end() ? CXXGlobalInits.size() : I->second;
 601     AddGlobalCtor(Fn, 65535, LexOrder, COMDATKey);
 602     if (COMDATKey && (getTriple().isOSBinFormatELF() ||
 603                       getTarget().getCXXABI().isMicrosoft())) {
 604       // When COMDAT is used on ELF or in the MS C++ ABI, the key must be in
 605       // llvm.used to prevent linker GC.
 606       addUsedGlobal(COMDATKey);
 607     }
 608
 609     // If we used a COMDAT key for the global ctor, the init function can be
 610     // discarded if the global ctor entry is discarded.
 611     // FIXME: Do we need to restrict this to ELF and Wasm?
 612     llvm::Comdat *C = Addr->getComdat();
 613     if (COMDATKey && C &&
 614         (getTarget().getTriple().isOSBinFormatELF() ||
 615          getTarget().getTriple().isOSBinFormatWasm())) {
 616       Fn->setComdat(C);
 617     }
 618   } else {
 619     I = DelayedCXXInitPosition.find(D); // Re-do lookup in case of re-hash.
 620     if (I == DelayedCXXInitPosition.end()) {
 621       CXXGlobalInits.push_back(Fn);
 622     } else if (I->second != ~0U) {
 623       assert(I->second < CXXGlobalInits.size() &&
 624              CXXGlobalInits[I->second] == nullptr);
 625       CXXGlobalInits[I->second] = Fn;
 626     }
 627   }
 628
 629   // Remember that we already emitted the initializer for this global.
 630   DelayedCXXInitPosition[D] = ~0U;
 631 }
 632
 633 void CodeGenModule::EmitCXXThreadLocalInitFunc() {
 634   getCXXABI().EmitThreadLocalInitFuncs(
 635       *this, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars);
 636
 637   CXXThreadLocalInits.clear();
 638   CXXThreadLocalInitVars.clear();
 639   CXXThreadLocals.clear();
 640 }
 641
 642 /* Build the initializer for a C++20 module:
 643    This is arranged to be run only once regardless of how many times the module
 644    might be included transitively.  This arranged by using a guard variable.
 645
 646    If there are no initializers at all (and also no imported modules) we reduce
 647    this to an empty function (since the Itanium ABI requires that this function
 648    be available to a caller, which might be produced by a different
 649    implementation).
 650
 651    First we call any initializers for imported modules.
 652    We then call initializers for the Global Module Fragment (if present)
 653    We then call initializers for the current module.
 654    We then call initializers for the Private Module Fragment (if present)
 655 */
 656
 657 void CodeGenModule::EmitCXXModuleInitFunc(Module *Primary) {
 658   assert(Primary->isInterfaceOrPartition() &&
 659          "The function should only be called for C++20 named module interface"
 660          " or partition.");
 661
 662   while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
 663     CXXGlobalInits.pop_back();
 664
 665   // As noted above, we create the function, even if it is empty.
 666   // Module initializers for imported modules are emitted first.
 667
 668   // Collect all the modules that we import
 669   llvm::SmallSetVector<Module *, 8> AllImports;
 670   // Ones that we export
 671   for (auto I : Primary->Exports)
 672     AllImports.insert(I.getPointer());
 673   // Ones that we only import.
 674   for (Module *M : Primary->Imports)
 675     AllImports.insert(M);
 676   // Ones that we import in the global module fragment or the private module
 677   // fragment.
 678   for (Module *SubM : Primary->submodules()) {
 679     assert((SubM->isGlobalModule() || SubM->isPrivateModule()) &&
 680            "The sub modules of C++20 module unit should only be global module "
 681            "fragments or private module framents.");
 682     assert(SubM->Exports.empty() &&
 683            "The global mdoule fragments and the private module fragments are "
 684            "not allowed to export import modules.");
 685     for (Module *M : SubM->Imports)
 686       AllImports.insert(M);
 687   }
 688
 689   SmallVector<llvm::Function *, 8> ModuleInits;
 690   for (Module *M : AllImports) {
 691     // No Itanium initializer in header like modules.
 692     if (M->isHeaderLikeModule())
 693       continue; // TODO: warn of mixed use of module map modules and C++20?
 694     // We're allowed to skip the initialization if we are sure it doesn't
 695     // do any thing.
 696     if (!M->isNamedModuleInterfaceHasInit())
 697       continue;
 698     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 699     SmallString<256> FnName;
 700     {
 701       llvm::raw_svector_ostream Out(FnName);
 702       cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
 703           .mangleModuleInitializer(M, Out);
 704     }
 705     assert(!GetGlobalValue(FnName.str()) &&
 706            "We should only have one use of the initializer call");
 707     llvm::Function *Fn = llvm::Function::Create(
 708         FTy, llvm::Function::ExternalLinkage, FnName.str(), &getModule());
 709     ModuleInits.push_back(Fn);
 710   }
 711
 712   // Add any initializers with specified priority; this uses the same  approach
 713   // as EmitCXXGlobalInitFunc().
 714   if (!PrioritizedCXXGlobalInits.empty()) {
 715     SmallVector<llvm::Function *, 8> LocalCXXGlobalInits;
 716     llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
 717                          PrioritizedCXXGlobalInits.end());
 718     for (SmallVectorImpl<GlobalInitData>::iterator
 719              I = PrioritizedCXXGlobalInits.begin(),
 720              E = PrioritizedCXXGlobalInits.end();
 721          I != E;) {
 722       SmallVectorImpl<GlobalInitData>::iterator PrioE =
 723           std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp());
 724
 725       for (; I < PrioE; ++I)
 726         ModuleInits.push_back(I->second);
 727     }
 728   }
 729
 730   // Now append the ones without specified priority.
 731   for (auto *F : CXXGlobalInits)
 732     ModuleInits.push_back(F);
 733
 734   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 735   const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction();
 736
 737   // We now build the initializer for this module, which has a mangled name
 738   // as per the Itanium ABI .  The action of the initializer is guarded so that
 739   // each init is run just once (even though a module might be imported
 740   // multiple times via nested use).
 741   llvm::Function *Fn;
 742   {
 743     SmallString<256> InitFnName;
 744     llvm::raw_svector_ostream Out(InitFnName);
 745     cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
 746         .mangleModuleInitializer(Primary, Out);
 747     Fn = CreateGlobalInitOrCleanUpFunction(
 748         FTy, llvm::Twine(InitFnName), FI, SourceLocation(), false,
 749         llvm::GlobalVariable::ExternalLinkage);
 750
 751     // If we have a completely empty initializer then we do not want to create
 752     // the guard variable.
 753     ConstantAddress GuardAddr = ConstantAddress::invalid();
 754     if (!ModuleInits.empty()) {
 755       // Create the guard var.
 756       llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
 757           getModule(), Int8Ty, /*isConstant=*/false,
 758           llvm::GlobalVariable::InternalLinkage,
 759           llvm::ConstantInt::get(Int8Ty, 0), InitFnName.str() + "__in_chrg");
 760       CharUnits GuardAlign = CharUnits::One();
 761       Guard->setAlignment(GuardAlign.getAsAlign());
 762       GuardAddr = ConstantAddress(Guard, Int8Ty, GuardAlign);
 763     }
 764     CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, ModuleInits,
 765                                                      GuardAddr);
 766   }
 767
 768   // We allow for the case that a module object is added to a linked binary
 769   // without a specific call to the the initializer.  This also ensures that
 770   // implementation partition initializers are called when the partition
 771   // is not imported as an interface.
 772   AddGlobalCtor(Fn);
 773
 774   // See the comment in EmitCXXGlobalInitFunc about OpenCL global init
 775   // functions.
 776   if (getLangOpts().OpenCL) {
 777     GenKernelArgMetadata(Fn);
 778     Fn->setCallingConv(llvm::CallingConv::SPIR_KERNEL);
 779   }
 780
 781   assert(!getLangOpts().CUDA || !getLangOpts().CUDAIsDevice ||
 782          getLangOpts().GPUAllowDeviceInit);
 783   if (getLangOpts().HIP && getLangOpts().CUDAIsDevice) {
 784     Fn->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);
 785     Fn->addFnAttr("device-init");
 786   }
 787
 788   // We are done with the inits.
 789   AllImports.clear();
 790   PrioritizedCXXGlobalInits.clear();
 791   CXXGlobalInits.clear();
 792   ModuleInits.clear();
 793 }
 794
 795 static SmallString<128> getTransformedFileName(llvm::Module &M) {
 796   SmallString<128> FileName = llvm::sys::path::filename(M.getName());
 797
 798   if (FileName.empty())
 799     FileName = "<null>";
 800
 801   for (size_t i = 0; i < FileName.size(); ++i) {
 802     // Replace everything that's not [a-zA-Z0-9._] with a _. This set happens
 803     // to be the set of C preprocessing numbers.
 804     if (!isPreprocessingNumberBody(FileName[i]))
 805       FileName[i] = '_';
 806   }
 807
 808   return FileName;
 809 }
 810
 811 static std::string getPrioritySuffix(unsigned int Priority) {
 812   assert(Priority <= 65535 && "Priority should always be <= 65535.");
 813
 814   // Compute the function suffix from priority. Prepend with zeroes to make
 815   // sure the function names are also ordered as priorities.
 816   std::string PrioritySuffix = llvm::utostr(Priority);
 817   PrioritySuffix = std::string(6 - PrioritySuffix.size(), '0') + PrioritySuffix;
 818
 819   return PrioritySuffix;
 820 }
 821
 822 void
 823 CodeGenModule::EmitCXXGlobalInitFunc() {
 824   while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
 825     CXXGlobalInits.pop_back();
 826
 827   // When we import C++20 modules, we must run their initializers first.
 828   SmallVector<llvm::Function *, 8> ModuleInits;
 829   if (CXX20ModuleInits)
 830     for (Module *M : ImportedModules) {
 831       // No Itanium initializer in header like modules.
 832       if (M->isHeaderLikeModule())
 833         continue;
 834       llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 835       SmallString<256> FnName;
 836       {
 837         llvm::raw_svector_ostream Out(FnName);
 838         cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
 839             .mangleModuleInitializer(M, Out);
 840       }
 841       assert(!GetGlobalValue(FnName.str()) &&
 842              "We should only have one use of the initializer call");
 843       llvm::Function *Fn = llvm::Function::Create(
 844           FTy, llvm::Function::ExternalLinkage, FnName.str(), &getModule());
 845       ModuleInits.push_back(Fn);
 846     }
 847
 848   if (ModuleInits.empty() && CXXGlobalInits.empty() &&
 849       PrioritizedCXXGlobalInits.empty())
 850     return;
 851
 852   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 853   const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction();
 854
 855   // Create our global prioritized initialization function.
 856   if (!PrioritizedCXXGlobalInits.empty()) {
 857     SmallVector<llvm::Function *, 8> LocalCXXGlobalInits;
 858     llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
 859                          PrioritizedCXXGlobalInits.end());
 860     // Iterate over "chunks" of ctors with same priority and emit each chunk
 861     // into separate function. Note - everything is sorted first by priority,
 862     // second - by lex order, so we emit ctor functions in proper order.
 863     for (SmallVectorImpl<GlobalInitData >::iterator
 864            I = PrioritizedCXXGlobalInits.begin(),
 865            E = PrioritizedCXXGlobalInits.end(); I != E; ) {
 866       SmallVectorImpl<GlobalInitData >::iterator
 867         PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp());
 868
 869       LocalCXXGlobalInits.clear();
 870
 871       unsigned int Priority = I->first.priority;
 872       llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
 873           FTy, "_GLOBAL__I_" + getPrioritySuffix(Priority), FI);
 874
 875       // Prepend the module inits to the highest priority set.
 876       if (!ModuleInits.empty()) {
 877         for (auto *F : ModuleInits)
 878           LocalCXXGlobalInits.push_back(F);
 879         ModuleInits.clear();
 880       }
 881
 882       for (; I < PrioE; ++I)
 883         LocalCXXGlobalInits.push_back(I->second);
 884
 885       CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits);
 886       AddGlobalCtor(Fn, Priority);
 887     }
 888     PrioritizedCXXGlobalInits.clear();
 889   }
 890
 891   if (getCXXABI().useSinitAndSterm() && ModuleInits.empty() &&
 892       CXXGlobalInits.empty())
 893     return;
 894
 895   for (auto *F : CXXGlobalInits)
 896     ModuleInits.push_back(F);
 897   CXXGlobalInits.clear();
 898
 899   // Include the filename in the symbol name. Including "sub_" matches gcc
 900   // and makes sure these symbols appear lexicographically behind the symbols
 901   // with priority emitted above.  Module implementation units behave the same
 902   // way as a non-modular TU with imports.
 903   llvm::Function *Fn;
 904   if (CXX20ModuleInits && getContext().getCurrentNamedModule() &&
 905       !getContext().getCurrentNamedModule()->isModuleImplementation()) {
 906     SmallString<256> InitFnName;
 907     llvm::raw_svector_ostream Out(InitFnName);
 908     cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
 909         .mangleModuleInitializer(getContext().getCurrentNamedModule(), Out);
 910     Fn = CreateGlobalInitOrCleanUpFunction(
 911         FTy, llvm::Twine(InitFnName), FI, SourceLocation(), false,
 912         llvm::GlobalVariable::ExternalLinkage);
 913   } else
 914     Fn = CreateGlobalInitOrCleanUpFunction(
 915         FTy,
 916         llvm::Twine("_GLOBAL__sub_I_", getTransformedFileName(getModule())),
 917         FI);
 918
 919   CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, ModuleInits);
 920   AddGlobalCtor(Fn);
 921
 922   // In OpenCL global init functions must be converted to kernels in order to
 923   // be able to launch them from the host.
 924   // FIXME: Some more work might be needed to handle destructors correctly.
 925   // Current initialization function makes use of function pointers callbacks.
 926   // We can't support function pointers especially between host and device.
 927   // However it seems global destruction has little meaning without any
 928   // dynamic resource allocation on the device and program scope variables are
 929   // destroyed by the runtime when program is released.
 930   if (getLangOpts().OpenCL) {
 931     GenKernelArgMetadata(Fn);
 932     Fn->setCallingConv(llvm::CallingConv::SPIR_KERNEL);
 933   }
 934
 935   assert(!getLangOpts().CUDA || !getLangOpts().CUDAIsDevice ||
 936          getLangOpts().GPUAllowDeviceInit);
 937   if (getLangOpts().HIP && getLangOpts().CUDAIsDevice) {
 938     Fn->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);
 939     Fn->addFnAttr("device-init");
 940   }
 941
 942   ModuleInits.clear();
 943 }
 944
 945 void CodeGenModule::EmitCXXGlobalCleanUpFunc() {
 946   if (CXXGlobalDtorsOrStermFinalizers.empty() &&
 947       PrioritizedCXXStermFinalizers.empty())
 948     return;
 949
 950   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 951   const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction();
 952
 953   // Create our global prioritized cleanup function.
 954   if (!PrioritizedCXXStermFinalizers.empty()) {
 955     SmallVector<CXXGlobalDtorsOrStermFinalizer_t, 8> LocalCXXStermFinalizers;
 956     llvm::array_pod_sort(PrioritizedCXXStermFinalizers.begin(),
 957                          PrioritizedCXXStermFinalizers.end());
 958     // Iterate over "chunks" of dtors with same priority and emit each chunk
 959     // into separate function. Note - everything is sorted first by priority,
 960     // second - by lex order, so we emit dtor functions in proper order.
 961     for (SmallVectorImpl<StermFinalizerData>::iterator
 962              I = PrioritizedCXXStermFinalizers.begin(),
 963              E = PrioritizedCXXStermFinalizers.end();
 964          I != E;) {
 965       SmallVectorImpl<StermFinalizerData>::iterator PrioE =
 966           std::upper_bound(I + 1, E, *I, StermFinalizerPriorityCmp());
 967
 968       LocalCXXStermFinalizers.clear();
 969
 970       unsigned int Priority = I->first.priority;
 971       llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
 972           FTy, "_GLOBAL__a_" + getPrioritySuffix(Priority), FI);
 973
 974       for (; I < PrioE; ++I) {
 975         llvm::FunctionCallee DtorFn = I->second;
 976         LocalCXXStermFinalizers.emplace_back(DtorFn.getFunctionType(),
 977                                              DtorFn.getCallee(), nullptr);
 978       }
 979
 980       CodeGenFunction(*this).GenerateCXXGlobalCleanUpFunc(
 981           Fn, LocalCXXStermFinalizers);
 982       AddGlobalDtor(Fn, Priority);
 983     }
 984     PrioritizedCXXStermFinalizers.clear();
 985   }
 986
 987   if (CXXGlobalDtorsOrStermFinalizers.empty())
 988     return;
 989
 990   // Create our global cleanup function.
 991   llvm::Function *Fn =
 992       CreateGlobalInitOrCleanUpFunction(FTy, "_GLOBAL__D_a", FI);
 993
 994   CodeGenFunction(*this).GenerateCXXGlobalCleanUpFunc(
 995       Fn, CXXGlobalDtorsOrStermFinalizers);
 996   AddGlobalDtor(Fn);
 997   CXXGlobalDtorsOrStermFinalizers.clear();
 998 }
 999
1000 /// Emit the code necessary to initialize the given global variable.
1001 void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
1002                                                        const VarDecl *D,
1003                                                  llvm::GlobalVariable *Addr,
1004                                                        bool PerformInit) {
1005   // Check if we need to emit debug info for variable initializer.
1006   if (D->hasAttr<NoDebugAttr>())
1007     DebugInfo = nullptr; // disable debug info indefinitely for this function
1008
1009   CurEHLocation = D->getBeginLoc();
1010
1011   StartFunction(GlobalDecl(D, DynamicInitKind::Initializer),
1012                 getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(),
1013                 FunctionArgList());
1014   // Emit an artificial location for this function.
1015   auto AL = ApplyDebugLocation::CreateArtificial(*this);
1016
1017   // Use guarded initialization if the global variable is weak. This
1018   // occurs for, e.g., instantiated static data members and
1019   // definitions explicitly marked weak.
1020   //
1021   // Also use guarded initialization for a variable with dynamic TLS and
1022   // unordered initialization. (If the initialization is ordered, the ABI
1023   // layer will guard the whole-TU initialization for us.)
1024   if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage() ||
1025       (D->getTLSKind() == VarDecl::TLS_Dynamic &&
1026        isTemplateInstantiation(D->getTemplateSpecializationKind()))) {
1027     EmitCXXGuardedInit(*D, Addr, PerformInit);
1028   } else {
1029     EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit);
1030   }
1031
1032   if (getLangOpts().HLSL)
1033     CGM.getHLSLRuntime().annotateHLSLResource(D, Addr);
1034
1035   FinishFunction();
1036 }
1037
1038 void
1039 CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
1040                                            ArrayRef<llvm::Function *> Decls,
1041                                            ConstantAddress Guard) {
1042   {
1043     auto NL = ApplyDebugLocation::CreateEmpty(*this);
1044     StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
1045                   getTypes().arrangeNullaryFunction(), FunctionArgList());
1046     // Emit an artificial location for this function.
1047     auto AL = ApplyDebugLocation::CreateArtificial(*this);
1048
1049     llvm::BasicBlock *ExitBlock = nullptr;
1050     if (Guard.isValid()) {
1051       // If we have a guard variable, check whether we've already performed
1052       // these initializations. This happens for TLS initialization functions.
1053       llvm::Value *GuardVal = Builder.CreateLoad(Guard);
1054       llvm::Value *Uninit = Builder.CreateIsNull(GuardVal,
1055                                                  "guard.uninitialized");
1056       llvm::BasicBlock *InitBlock = createBasicBlock("init");
1057       ExitBlock = createBasicBlock("exit");
1058       EmitCXXGuardedInitBranch(Uninit, InitBlock, ExitBlock,
1059                                GuardKind::TlsGuard, nullptr);
1060       EmitBlock(InitBlock);
1061       // Mark as initialized before initializing anything else. If the
1062       // initializers use previously-initialized thread_local vars, that's
1063       // probably supposed to be OK, but the standard doesn't say.
1064       Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard);
1065
1066       // The guard variable can't ever change again.
1067       EmitInvariantStart(
1068           Guard.getPointer(),
1069           CharUnits::fromQuantity(
1070               CGM.getDataLayout().getTypeAllocSize(GuardVal->getType())));
1071     }
1072
1073     RunCleanupsScope Scope(*this);
1074
1075     // When building in Objective-C++ ARC mode, create an autorelease pool
1076     // around the global initializers.
1077     if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) {
1078       llvm::Value *token = EmitObjCAutoreleasePoolPush();
1079       EmitObjCAutoreleasePoolCleanup(token);
1080     }
1081
1082     for (unsigned i = 0, e = Decls.size(); i != e; ++i)
1083       if (Decls[i])
1084         EmitRuntimeCall(Decls[i]);
1085
1086     Scope.ForceCleanup();
1087
1088     if (ExitBlock) {
1089       Builder.CreateBr(ExitBlock);
1090       EmitBlock(ExitBlock);
1091     }
1092   }
1093
1094   FinishFunction();
1095 }
1096
1097 void CodeGenFunction::GenerateCXXGlobalCleanUpFunc(
1098     llvm::Function *Fn,
1099     ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
1100                         llvm::Constant *>>
1101         DtorsOrStermFinalizers) {
1102   {
1103     auto NL = ApplyDebugLocation::CreateEmpty(*this);
1104     StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
1105                   getTypes().arrangeNullaryFunction(), FunctionArgList());
1106     // Emit an artificial location for this function.
1107     auto AL = ApplyDebugLocation::CreateArtificial(*this);
1108
1109     // Emit the cleanups, in reverse order from construction.
1110     for (unsigned i = 0, e = DtorsOrStermFinalizers.size(); i != e; ++i) {
1111       llvm::FunctionType *CalleeTy;
1112       llvm::Value *Callee;
1113       llvm::Constant *Arg;
1114       std::tie(CalleeTy, Callee, Arg) = DtorsOrStermFinalizers[e - i - 1];
1115
1116       llvm::CallInst *CI = nullptr;
1117       if (Arg == nullptr) {
1118         assert(
1119             CGM.getCXXABI().useSinitAndSterm() &&
1120             "Arg could not be nullptr unless using sinit and sterm functions.");
1121         CI = Builder.CreateCall(CalleeTy, Callee);
1122       } else
1123         CI = Builder.CreateCall(CalleeTy, Callee, Arg);
1124
1125       // Make sure the call and the callee agree on calling convention.
1126       if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
1127         CI->setCallingConv(F->getCallingConv());
1128     }
1129   }
1130
1131   FinishFunction();
1132 }
1133
1134 /// generateDestroyHelper - Generates a helper function which, when
1135 /// invoked, destroys the given object.  The address of the object
1136 /// should be in global memory.
1137 llvm::Function *CodeGenFunction::generateDestroyHelper(
1138     Address addr, QualType type, Destroyer *destroyer,
1139     bool useEHCleanupForArray, const VarDecl *VD) {
1140   FunctionArgList args;
1141   ImplicitParamDecl Dst(getContext(), getContext().VoidPtrTy,
1142                         ImplicitParamDecl::Other);
1143   args.push_back(&Dst);
1144
1145   const CGFunctionInfo &FI =
1146     CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy, args);
1147   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
1148   llvm::Function *fn = CGM.CreateGlobalInitOrCleanUpFunction(
1149       FTy, "__cxx_global_array_dtor", FI, VD->getLocation());
1150
1151   CurEHLocation = VD->getBeginLoc();
1152
1153   StartFunction(GlobalDecl(VD, DynamicInitKind::GlobalArrayDestructor),
1154                 getContext().VoidTy, fn, FI, args);
1155   // Emit an artificial location for this function.
1156   auto AL = ApplyDebugLocation::CreateArtificial(*this);
1157
1158   emitDestroy(addr, type, destroyer, useEHCleanupForArray);
1159
1160   FinishFunction();
1161
1162   return fn;
1163 }