1 //===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This contains code dealing with code generation of C++ declarations 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CodeGenFunction.h" 15 #include "CGCXXABI.h" 16 #include "CGObjCRuntime.h" 17 #include "CGOpenMPRuntime.h" 18 #include "clang/Frontend/CodeGenOptions.h" 19 #include "llvm/ADT/StringExtras.h" 20 #include "llvm/IR/Intrinsics.h" 21 #include "llvm/Support/Path.h" 22 23 using namespace clang; 24 using namespace CodeGen; 25 26 static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D, 27 ConstantAddress DeclPtr) { 28 assert(D.hasGlobalStorage() && "VarDecl must have global storage!"); 29 assert(!D.getType()->isReferenceType() && 30 "Should not call EmitDeclInit on a reference!"); 31 32 QualType type = D.getType(); 33 LValue lv = CGF.MakeAddrLValue(DeclPtr, type); 34 35 const Expr *Init = D.getInit(); 36 switch (CGF.getEvaluationKind(type)) { 37 case TEK_Scalar: { 38 CodeGenModule &CGM = CGF.CGM; 39 if (lv.isObjCStrong()) 40 CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init), 41 DeclPtr, D.getTLSKind()); 42 else if (lv.isObjCWeak()) 43 CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init), 44 DeclPtr); 45 else 46 CGF.EmitScalarInit(Init, &D, lv, false); 47 return; 48 } 49 case TEK_Complex: 50 CGF.EmitComplexExprIntoLValue(Init, lv, /*isInit*/ true); 51 return; 52 case TEK_Aggregate: 53 CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv,AggValueSlot::IsDestructed, 54 AggValueSlot::DoesNotNeedGCBarriers, 55 AggValueSlot::IsNotAliased)); 56 return; 57 } 58 llvm_unreachable("bad evaluation kind"); 59 } 60 61 /// Emit code to cause the destruction of the given variable with 62 /// static storage duration. 63 static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, 64 ConstantAddress addr) { 65 CodeGenModule &CGM = CGF.CGM; 66 67 // FIXME: __attribute__((cleanup)) ? 68 69 QualType type = D.getType(); 70 QualType::DestructionKind dtorKind = type.isDestructedType(); 71 72 switch (dtorKind) { 73 case QualType::DK_none: 74 return; 75 76 case QualType::DK_cxx_destructor: 77 break; 78 79 case QualType::DK_objc_strong_lifetime: 80 case QualType::DK_objc_weak_lifetime: 81 // We don't care about releasing objects during process teardown. 82 assert(!D.getTLSKind() && "should have rejected this"); 83 return; 84 } 85 86 llvm::Constant *function; 87 llvm::Constant *argument; 88 89 // Special-case non-array C++ destructors, where there's a function 90 // with the right signature that we can just call. 91 const CXXRecordDecl *record = nullptr; 92 if (dtorKind == QualType::DK_cxx_destructor && 93 (record = type->getAsCXXRecordDecl())) { 94 assert(!record->hasTrivialDestructor()); 95 CXXDestructorDecl *dtor = record->getDestructor(); 96 97 function = CGM.getAddrOfCXXStructor(dtor, StructorType::Complete); 98 argument = llvm::ConstantExpr::getBitCast( 99 addr.getPointer(), CGF.getTypes().ConvertType(type)->getPointerTo()); 100 101 // Otherwise, the standard logic requires a helper function. 102 } else { 103 function = CodeGenFunction(CGM) 104 .generateDestroyHelper(addr, type, CGF.getDestroyer(dtorKind), 105 CGF.needsEHCleanup(dtorKind), &D); 106 argument = llvm::Constant::getNullValue(CGF.Int8PtrTy); 107 } 108 109 CGM.getCXXABI().registerGlobalDtor(CGF, D, function, argument); 110 } 111 112 /// Emit code to cause the variable at the given address to be considered as 113 /// constant from this point onwards. 114 static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D, 115 llvm::Constant *Addr) { 116 // Don't emit the intrinsic if we're not optimizing. 117 if (!CGF.CGM.getCodeGenOpts().OptimizationLevel) 118 return; 119 120 // Grab the llvm.invariant.start intrinsic. 121 llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start; 122 llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID); 123 124 // Emit a call with the size in bytes of the object. 125 CharUnits WidthChars = CGF.getContext().getTypeSizeInChars(D.getType()); 126 uint64_t Width = WidthChars.getQuantity(); 127 llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width), 128 llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)}; 129 CGF.Builder.CreateCall(InvariantStart, Args); 130 } 131 132 void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D, 133 llvm::Constant *DeclPtr, 134 bool PerformInit) { 135 136 const Expr *Init = D.getInit(); 137 QualType T = D.getType(); 138 139 // The address space of a static local variable (DeclPtr) may be different 140 // from the address space of the "this" argument of the constructor. In that 141 // case, we need an addrspacecast before calling the constructor. 142 // 143 // struct StructWithCtor { 144 // __device__ StructWithCtor() {...} 145 // }; 146 // __device__ void foo() { 147 // __shared__ StructWithCtor s; 148 // ... 149 // } 150 // 151 // For example, in the above CUDA code, the static local variable s has a 152 // "shared" address space qualifier, but the constructor of StructWithCtor 153 // expects "this" in the "generic" address space. 154 unsigned ExpectedAddrSpace = getContext().getTargetAddressSpace(T); 155 unsigned ActualAddrSpace = DeclPtr->getType()->getPointerAddressSpace(); 156 if (ActualAddrSpace != ExpectedAddrSpace) { 157 llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(T); 158 llvm::PointerType *PTy = llvm::PointerType::get(LTy, ExpectedAddrSpace); 159 DeclPtr = llvm::ConstantExpr::getAddrSpaceCast(DeclPtr, PTy); 160 } 161 162 ConstantAddress DeclAddr(DeclPtr, getContext().getDeclAlign(&D)); 163 164 if (!T->isReferenceType()) { 165 if (getLangOpts().OpenMP && D.hasAttr<OMPThreadPrivateDeclAttr>()) 166 (void)CGM.getOpenMPRuntime().emitThreadPrivateVarDefinition( 167 &D, DeclAddr, D.getAttr<OMPThreadPrivateDeclAttr>()->getLocation(), 168 PerformInit, this); 169 if (PerformInit) 170 EmitDeclInit(*this, D, DeclAddr); 171 if (CGM.isTypeConstant(D.getType(), true)) 172 EmitDeclInvariant(*this, D, DeclPtr); 173 else 174 EmitDeclDestroy(*this, D, DeclAddr); 175 return; 176 } 177 178 assert(PerformInit && "cannot have constant initializer which needs " 179 "destruction for reference"); 180 RValue RV = EmitReferenceBindingToExpr(Init); 181 EmitStoreOfScalar(RV.getScalarVal(), DeclAddr, false, T); 182 } 183 184 /// Create a stub function, suitable for being passed to atexit, 185 /// which passes the given address to the given destructor function. 186 llvm::Constant *CodeGenFunction::createAtExitStub(const VarDecl &VD, 187 llvm::Constant *dtor, 188 llvm::Constant *addr) { 189 // Get the destructor function type, void(*)(void). 190 llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false); 191 SmallString<256> FnName; 192 { 193 llvm::raw_svector_ostream Out(FnName); 194 CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out); 195 } 196 197 const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction(); 198 llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(ty, FnName.str(), 199 FI, 200 VD.getLocation()); 201 202 CodeGenFunction CGF(CGM); 203 204 CGF.StartFunction(&VD, CGM.getContext().VoidTy, fn, FI, FunctionArgList()); 205 206 llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr); 207 208 // Make sure the call and the callee agree on calling convention. 209 if (llvm::Function *dtorFn = 210 dyn_cast<llvm::Function>(dtor->stripPointerCasts())) 211 call->setCallingConv(dtorFn->getCallingConv()); 212 213 CGF.FinishFunction(); 214 215 return fn; 216 } 217 218 /// Register a global destructor using the C atexit runtime function. 219 void CodeGenFunction::registerGlobalDtorWithAtExit(const VarDecl &VD, 220 llvm::Constant *dtor, 221 llvm::Constant *addr) { 222 // Create a function which calls the destructor. 223 llvm::Constant *dtorStub = createAtExitStub(VD, dtor, addr); 224 225 // extern "C" int atexit(void (*f)(void)); 226 llvm::FunctionType *atexitTy = 227 llvm::FunctionType::get(IntTy, dtorStub->getType(), false); 228 229 llvm::Constant *atexit = 230 CGM.CreateRuntimeFunction(atexitTy, "atexit"); 231 if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit)) 232 atexitFn->setDoesNotThrow(); 233 234 EmitNounwindRuntimeCall(atexit, dtorStub); 235 } 236 237 void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D, 238 llvm::GlobalVariable *DeclPtr, 239 bool PerformInit) { 240 // If we've been asked to forbid guard variables, emit an error now. 241 // This diagnostic is hard-coded for Darwin's use case; we can find 242 // better phrasing if someone else needs it. 243 if (CGM.getCodeGenOpts().ForbidGuardVariables) 244 CGM.Error(D.getLocation(), 245 "this initialization requires a guard variable, which " 246 "the kernel does not support"); 247 248 CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit); 249 } 250 251 llvm::Function *CodeGenModule::CreateGlobalInitOrDestructFunction( 252 llvm::FunctionType *FTy, const Twine &Name, const CGFunctionInfo &FI, 253 SourceLocation Loc, bool TLS) { 254 llvm::Function *Fn = 255 llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage, 256 Name, &getModule()); 257 if (!getLangOpts().AppleKext && !TLS) { 258 // Set the section if needed. 259 if (const char *Section = getTarget().getStaticInitSectionSpecifier()) 260 Fn->setSection(Section); 261 } 262 263 SetInternalFunctionAttributes(nullptr, Fn, FI); 264 265 Fn->setCallingConv(getRuntimeCC()); 266 267 if (!getLangOpts().Exceptions) 268 Fn->setDoesNotThrow(); 269 270 if (!isInSanitizerBlacklist(Fn, Loc)) { 271 if (getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address | 272 SanitizerKind::KernelAddress)) 273 Fn->addFnAttr(llvm::Attribute::SanitizeAddress); 274 if (getLangOpts().Sanitize.has(SanitizerKind::Thread)) 275 Fn->addFnAttr(llvm::Attribute::SanitizeThread); 276 if (getLangOpts().Sanitize.has(SanitizerKind::Memory)) 277 Fn->addFnAttr(llvm::Attribute::SanitizeMemory); 278 if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack)) 279 Fn->addFnAttr(llvm::Attribute::SafeStack); 280 } 281 282 return Fn; 283 } 284 285 /// Create a global pointer to a function that will initialize a global 286 /// variable. The user has requested that this pointer be emitted in a specific 287 /// section. 288 void CodeGenModule::EmitPointerToInitFunc(const VarDecl *D, 289 llvm::GlobalVariable *GV, 290 llvm::Function *InitFunc, 291 InitSegAttr *ISA) { 292 llvm::GlobalVariable *PtrArray = new llvm::GlobalVariable( 293 TheModule, InitFunc->getType(), /*isConstant=*/true, 294 llvm::GlobalValue::PrivateLinkage, InitFunc, "__cxx_init_fn_ptr"); 295 PtrArray->setSection(ISA->getSection()); 296 addUsedGlobal(PtrArray); 297 298 // If the GV is already in a comdat group, then we have to join it. 299 if (llvm::Comdat *C = GV->getComdat()) 300 PtrArray->setComdat(C); 301 } 302 303 void 304 CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, 305 llvm::GlobalVariable *Addr, 306 bool PerformInit) { 307 // Check if we've already initialized this decl. 308 auto I = DelayedCXXInitPosition.find(D); 309 if (I != DelayedCXXInitPosition.end() && I->second == ~0U) 310 return; 311 312 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); 313 SmallString<256> FnName; 314 { 315 llvm::raw_svector_ostream Out(FnName); 316 getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out); 317 } 318 319 // Create a variable initialization function. 320 llvm::Function *Fn = 321 CreateGlobalInitOrDestructFunction(FTy, FnName.str(), 322 getTypes().arrangeNullaryFunction(), 323 D->getLocation()); 324 325 auto *ISA = D->getAttr<InitSegAttr>(); 326 CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr, 327 PerformInit); 328 329 llvm::GlobalVariable *COMDATKey = 330 supportsCOMDAT() && D->isExternallyVisible() ? Addr : nullptr; 331 332 if (D->getTLSKind()) { 333 // FIXME: Should we support init_priority for thread_local? 334 // FIXME: Ideally, initialization of instantiated thread_local static data 335 // members of class templates should not trigger initialization of other 336 // entities in the TU. 337 // FIXME: We only need to register one __cxa_thread_atexit function for the 338 // entire TU. 339 CXXThreadLocalInits.push_back(Fn); 340 CXXThreadLocalInitVars.push_back(D); 341 } else if (PerformInit && ISA) { 342 EmitPointerToInitFunc(D, Addr, Fn, ISA); 343 } else if (auto *IPA = D->getAttr<InitPriorityAttr>()) { 344 OrderGlobalInits Key(IPA->getPriority(), PrioritizedCXXGlobalInits.size()); 345 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn)); 346 } else if (isTemplateInstantiation(D->getTemplateSpecializationKind())) { 347 // C++ [basic.start.init]p2: 348 // Definitions of explicitly specialized class template static data 349 // members have ordered initialization. Other class template static data 350 // members (i.e., implicitly or explicitly instantiated specializations) 351 // have unordered initialization. 352 // 353 // As a consequence, we can put them into their own llvm.global_ctors entry. 354 // 355 // If the global is externally visible, put the initializer into a COMDAT 356 // group with the global being initialized. On most platforms, this is a 357 // minor startup time optimization. In the MS C++ ABI, there are no guard 358 // variables, so this COMDAT key is required for correctness. 359 AddGlobalCtor(Fn, 65535, COMDATKey); 360 } else if (D->hasAttr<SelectAnyAttr>()) { 361 // SelectAny globals will be comdat-folded. Put the initializer into a 362 // COMDAT group associated with the global, so the initializers get folded 363 // too. 364 AddGlobalCtor(Fn, 65535, COMDATKey); 365 } else { 366 I = DelayedCXXInitPosition.find(D); // Re-do lookup in case of re-hash. 367 if (I == DelayedCXXInitPosition.end()) { 368 CXXGlobalInits.push_back(Fn); 369 } else if (I->second != ~0U) { 370 assert(I->second < CXXGlobalInits.size() && 371 CXXGlobalInits[I->second] == nullptr); 372 CXXGlobalInits[I->second] = Fn; 373 } 374 } 375 376 // Remember that we already emitted the initializer for this global. 377 DelayedCXXInitPosition[D] = ~0U; 378 } 379 380 void CodeGenModule::EmitCXXThreadLocalInitFunc() { 381 getCXXABI().EmitThreadLocalInitFuncs( 382 *this, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars); 383 384 CXXThreadLocalInits.clear(); 385 CXXThreadLocalInitVars.clear(); 386 CXXThreadLocals.clear(); 387 } 388 389 void 390 CodeGenModule::EmitCXXGlobalInitFunc() { 391 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back()) 392 CXXGlobalInits.pop_back(); 393 394 if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty()) 395 return; 396 397 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); 398 const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction(); 399 400 // Create our global initialization function. 401 if (!PrioritizedCXXGlobalInits.empty()) { 402 SmallVector<llvm::Function *, 8> LocalCXXGlobalInits; 403 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(), 404 PrioritizedCXXGlobalInits.end()); 405 // Iterate over "chunks" of ctors with same priority and emit each chunk 406 // into separate function. Note - everything is sorted first by priority, 407 // second - by lex order, so we emit ctor functions in proper order. 408 for (SmallVectorImpl<GlobalInitData >::iterator 409 I = PrioritizedCXXGlobalInits.begin(), 410 E = PrioritizedCXXGlobalInits.end(); I != E; ) { 411 SmallVectorImpl<GlobalInitData >::iterator 412 PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp()); 413 414 LocalCXXGlobalInits.clear(); 415 unsigned Priority = I->first.priority; 416 // Compute the function suffix from priority. Prepend with zeroes to make 417 // sure the function names are also ordered as priorities. 418 std::string PrioritySuffix = llvm::utostr(Priority); 419 // Priority is always <= 65535 (enforced by sema). 420 PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix; 421 llvm::Function *Fn = CreateGlobalInitOrDestructFunction( 422 FTy, "_GLOBAL__I_" + PrioritySuffix, FI); 423 424 for (; I < PrioE; ++I) 425 LocalCXXGlobalInits.push_back(I->second); 426 427 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits); 428 AddGlobalCtor(Fn, Priority); 429 } 430 PrioritizedCXXGlobalInits.clear(); 431 } 432 433 SmallString<128> FileName; 434 SourceManager &SM = Context.getSourceManager(); 435 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 436 // Include the filename in the symbol name. Including "sub_" matches gcc and 437 // makes sure these symbols appear lexicographically behind the symbols with 438 // priority emitted above. 439 FileName = llvm::sys::path::filename(MainFile->getName()); 440 } else { 441 FileName = "<null>"; 442 } 443 444 for (size_t i = 0; i < FileName.size(); ++i) { 445 // Replace everything that's not [a-zA-Z0-9._] with a _. This set happens 446 // to be the set of C preprocessing numbers. 447 if (!isPreprocessingNumberBody(FileName[i])) 448 FileName[i] = '_'; 449 } 450 451 llvm::Function *Fn = CreateGlobalInitOrDestructFunction( 452 FTy, llvm::Twine("_GLOBAL__sub_I_", FileName), FI); 453 454 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits); 455 AddGlobalCtor(Fn); 456 457 CXXGlobalInits.clear(); 458 } 459 460 void CodeGenModule::EmitCXXGlobalDtorFunc() { 461 if (CXXGlobalDtors.empty()) 462 return; 463 464 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); 465 466 // Create our global destructor function. 467 const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction(); 468 llvm::Function *Fn = 469 CreateGlobalInitOrDestructFunction(FTy, "_GLOBAL__D_a", FI); 470 471 CodeGenFunction(*this).GenerateCXXGlobalDtorsFunc(Fn, CXXGlobalDtors); 472 AddGlobalDtor(Fn); 473 } 474 475 /// Emit the code necessary to initialize the given global variable. 476 void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, 477 const VarDecl *D, 478 llvm::GlobalVariable *Addr, 479 bool PerformInit) { 480 // Check if we need to emit debug info for variable initializer. 481 if (D->hasAttr<NoDebugAttr>()) 482 DebugInfo = nullptr; // disable debug info indefinitely for this function 483 484 CurEHLocation = D->getLocStart(); 485 486 StartFunction(GlobalDecl(D), getContext().VoidTy, Fn, 487 getTypes().arrangeNullaryFunction(), 488 FunctionArgList(), D->getLocation(), 489 D->getInit()->getExprLoc()); 490 491 // Use guarded initialization if the global variable is weak. This 492 // occurs for, e.g., instantiated static data members and 493 // definitions explicitly marked weak. 494 if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage()) { 495 EmitCXXGuardedInit(*D, Addr, PerformInit); 496 } else { 497 EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit); 498 } 499 500 FinishFunction(); 501 } 502 503 void 504 CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn, 505 ArrayRef<llvm::Function *> Decls, 506 Address Guard) { 507 { 508 auto NL = ApplyDebugLocation::CreateEmpty(*this); 509 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, 510 getTypes().arrangeNullaryFunction(), FunctionArgList()); 511 // Emit an artificial location for this function. 512 auto AL = ApplyDebugLocation::CreateArtificial(*this); 513 514 llvm::BasicBlock *ExitBlock = nullptr; 515 if (Guard.isValid()) { 516 // If we have a guard variable, check whether we've already performed 517 // these initializations. This happens for TLS initialization functions. 518 llvm::Value *GuardVal = Builder.CreateLoad(Guard); 519 llvm::Value *Uninit = Builder.CreateIsNull(GuardVal, 520 "guard.uninitialized"); 521 llvm::BasicBlock *InitBlock = createBasicBlock("init"); 522 ExitBlock = createBasicBlock("exit"); 523 Builder.CreateCondBr(Uninit, InitBlock, ExitBlock); 524 EmitBlock(InitBlock); 525 // Mark as initialized before initializing anything else. If the 526 // initializers use previously-initialized thread_local vars, that's 527 // probably supposed to be OK, but the standard doesn't say. 528 Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard); 529 } 530 531 RunCleanupsScope Scope(*this); 532 533 // When building in Objective-C++ ARC mode, create an autorelease pool 534 // around the global initializers. 535 if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) { 536 llvm::Value *token = EmitObjCAutoreleasePoolPush(); 537 EmitObjCAutoreleasePoolCleanup(token); 538 } 539 540 for (unsigned i = 0, e = Decls.size(); i != e; ++i) 541 if (Decls[i]) 542 EmitRuntimeCall(Decls[i]); 543 544 Scope.ForceCleanup(); 545 546 if (ExitBlock) { 547 Builder.CreateBr(ExitBlock); 548 EmitBlock(ExitBlock); 549 } 550 } 551 552 FinishFunction(); 553 } 554 555 void CodeGenFunction::GenerateCXXGlobalDtorsFunc(llvm::Function *Fn, 556 const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> > 557 &DtorsAndObjects) { 558 { 559 auto NL = ApplyDebugLocation::CreateEmpty(*this); 560 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, 561 getTypes().arrangeNullaryFunction(), FunctionArgList()); 562 // Emit an artificial location for this function. 563 auto AL = ApplyDebugLocation::CreateArtificial(*this); 564 565 // Emit the dtors, in reverse order from construction. 566 for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { 567 llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; 568 llvm::CallInst *CI = Builder.CreateCall(Callee, 569 DtorsAndObjects[e - i - 1].second); 570 // Make sure the call and the callee agree on calling convention. 571 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee)) 572 CI->setCallingConv(F->getCallingConv()); 573 } 574 } 575 576 FinishFunction(); 577 } 578 579 /// generateDestroyHelper - Generates a helper function which, when 580 /// invoked, destroys the given object. The address of the object 581 /// should be in global memory. 582 llvm::Function *CodeGenFunction::generateDestroyHelper( 583 Address addr, QualType type, Destroyer *destroyer, 584 bool useEHCleanupForArray, const VarDecl *VD) { 585 FunctionArgList args; 586 ImplicitParamDecl dst(getContext(), nullptr, SourceLocation(), nullptr, 587 getContext().VoidPtrTy); 588 args.push_back(&dst); 589 590 const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( 591 getContext().VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); 592 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI); 593 llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction( 594 FTy, "__cxx_global_array_dtor", FI, VD->getLocation()); 595 596 CurEHLocation = VD->getLocStart(); 597 598 StartFunction(VD, getContext().VoidTy, fn, FI, args); 599 600 emitDestroy(addr, type, destroyer, useEHCleanupForArray); 601 602 FinishFunction(); 603 604 return fn; 605 } 606