head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.12 netbsd-11-0-RC3:1.1.1.12 netbsd-11-0-RC2:1.1.1.12 netbsd-11-0-RC1:1.1.1.12 perseant-exfatfs-base-20250801:1.1.1.12 netbsd-11:1.1.1.12.0.10 netbsd-11-base:1.1.1.12 netbsd-10-1-RELEASE:1.1.1.12 perseant-exfatfs-base-20240630:1.1.1.12 perseant-exfatfs:1.1.1.12.0.8 perseant-exfatfs-base:1.1.1.12 netbsd-8-3-RELEASE:1.1.1.9 netbsd-9-4-RELEASE:1.1.1.11 netbsd-10-0-RELEASE:1.1.1.12 netbsd-10-0-RC6:1.1.1.12 netbsd-10-0-RC5:1.1.1.12 netbsd-10-0-RC4:1.1.1.12 netbsd-10-0-RC3:1.1.1.12 netbsd-10-0-RC2:1.1.1.12 netbsd-10-0-RC1:1.1.1.12 netbsd-10:1.1.1.12.0.6 netbsd-10-base:1.1.1.12 netbsd-9-3-RELEASE:1.1.1.11 cjep_sun2x:1.1.1.12.0.4 cjep_sun2x-base:1.1.1.12 cjep_staticlib_x-base1:1.1.1.12 netbsd-9-2-RELEASE:1.1.1.11 cjep_staticlib_x:1.1.1.12.0.2 cjep_staticlib_x-base:1.1.1.12 netbsd-9-1-RELEASE:1.1.1.11 phil-wifi-20200421:1.1.1.12 phil-wifi-20200411:1.1.1.12 phil-wifi-20200406:1.1.1.12 netbsd-8-2-RELEASE:1.1.1.9 netbsd-9-0-RELEASE:1.1.1.11 netbsd-9-0-RC2:1.1.1.11 netbsd-9-0-RC1:1.1.1.11 netbsd-9:1.1.1.11.0.2 netbsd-9-base:1.1.1.11 phil-wifi-20190609:1.1.1.11 netbsd-8-1-RELEASE:1.1.1.9 netbsd-8-1-RC1:1.1.1.9 pgoyette-compat-merge-20190127:1.1.1.10.2.1 pgoyette-compat-20190127:1.1.1.11 pgoyette-compat-20190118:1.1.1.11 pgoyette-compat-1226:1.1.1.11 pgoyette-compat-1126:1.1.1.11 pgoyette-compat-1020:1.1.1.11 pgoyette-compat-0930:1.1.1.11 pgoyette-compat-0906:1.1.1.11 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.11 clang-337282:1.1.1.11 netbsd-8-0-RELEASE:1.1.1.9 phil-wifi:1.1.1.10.0.4 phil-wifi-base:1.1.1.10 pgoyette-compat-0625:1.1.1.10 netbsd-8-0-RC2:1.1.1.9 pgoyette-compat-0521:1.1.1.10 pgoyette-compat-0502:1.1.1.10 pgoyette-compat-0422:1.1.1.10 netbsd-8-0-RC1:1.1.1.9 pgoyette-compat-0415:1.1.1.10 pgoyette-compat-0407:1.1.1.10 pgoyette-compat-0330:1.1.1.10 pgoyette-compat-0322:1.1.1.10 pgoyette-compat-0315:1.1.1.10 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.10.0.2 pgoyette-compat-base:1.1.1.10 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.10 matt-nb8-mediatek:1.1.1.9.0.8 matt-nb8-mediatek-base:1.1.1.9 clang-309604:1.1.1.10 perseant-stdc-iso10646:1.1.1.9.0.6 perseant-stdc-iso10646-base:1.1.1.9 netbsd-8:1.1.1.9.0.4 netbsd-8-base:1.1.1.9 prg-localcount2-base3:1.1.1.9 prg-localcount2-base2:1.1.1.9 prg-localcount2-base1:1.1.1.9 prg-localcount2:1.1.1.9.0.2 prg-localcount2-base:1.1.1.9 pgoyette-localcount-20170426:1.1.1.9 bouyer-socketcan-base1:1.1.1.9 pgoyette-localcount-20170320:1.1.1.9 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.9 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.3 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.08; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.02.14.20.07.08; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid annVkZ1sc17rF6px; 1.1.1.4 date 2014.05.30.18.14.41; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.35; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.12.09; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.33.15; author joerg; state Exp; branches 1.1.1.8.2.1; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.02.09.17.37.59; author joerg; state Exp; branches; next 1.1.1.10; commitid UxB8JMFWM7xyMiFz; 1.1.1.10 date 2017.08.01.19.35.21; author joerg; state Exp; branches 1.1.1.10.2.1 1.1.1.10.4.1; next 1.1.1.11; commitid pMuDy65V0VicSx1A; 1.1.1.11 date 2018.07.17.18.31.03; author joerg; state Exp; branches; next 1.1.1.12; commitid wDzL46ALjrCZgwKA; 1.1.1.12 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.02.14.20.07.08; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.35; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.37; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.2.1 date 2017.04.21.16.51.38; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.10.2.1 date 2018.07.28.04.33.17; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.10.4.1 date 2019.06.10.21.45.21; author christos; state Exp; branches; next 1.1.1.10.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.10.4.2 date 2020.04.13.07.46.32; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with code generation of C++ declarations // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCXXABI.h" #include "CGObjCRuntime.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Intrinsics.h" using namespace clang; using namespace CodeGen; static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *DeclPtr) { assert(D.hasGlobalStorage() && "VarDecl must have global storage!"); assert(!D.getType()->isReferenceType() && "Should not call EmitDeclInit on a reference!"); ASTContext &Context = CGF.getContext(); CharUnits alignment = Context.getDeclAlign(&D); QualType type = D.getType(); LValue lv = CGF.MakeAddrLValue(DeclPtr, type, alignment); const Expr *Init = D.getInit(); switch (CGF.getEvaluationKind(type)) { case TEK_Scalar: { CodeGenModule &CGM = CGF.CGM; if (lv.isObjCStrong()) CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init), DeclPtr, D.getTLSKind()); else if (lv.isObjCWeak()) CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init), DeclPtr); else CGF.EmitScalarInit(Init, &D, lv, false); return; } case TEK_Complex: CGF.EmitComplexExprIntoLValue(Init, lv, /*isInit*/ true); return; case TEK_Aggregate: CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv,AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); return; } llvm_unreachable("bad evaluation kind"); } /// Emit code to cause the destruction of the given variable with /// static storage duration. static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *addr) { CodeGenModule &CGM = CGF.CGM; // FIXME: __attribute__((cleanup)) ? QualType type = D.getType(); QualType::DestructionKind dtorKind = type.isDestructedType(); switch (dtorKind) { case QualType::DK_none: return; case QualType::DK_cxx_destructor: break; case QualType::DK_objc_strong_lifetime: case QualType::DK_objc_weak_lifetime: // We don't care about releasing objects during process teardown. assert(!D.getTLSKind() && "should have rejected this"); return; } llvm::Constant *function; llvm::Constant *argument; // Special-case non-array C++ destructors, where there's a function // with the right signature that we can just call. const CXXRecordDecl *record = 0; if (dtorKind == QualType::DK_cxx_destructor && (record = type->getAsCXXRecordDecl())) { assert(!record->hasTrivialDestructor()); CXXDestructorDecl *dtor = record->getDestructor(); function = CGM.GetAddrOfCXXDestructor(dtor, Dtor_Complete); argument = llvm::ConstantExpr::getBitCast( addr, CGF.getTypes().ConvertType(type)->getPointerTo()); // Otherwise, the standard logic requires a helper function. } else { function = CodeGenFunction(CGM) .generateDestroyHelper(addr, type, CGF.getDestroyer(dtorKind), CGF.needsEHCleanup(dtorKind), &D); argument = llvm::Constant::getNullValue(CGF.Int8PtrTy); } CGM.getCXXABI().registerGlobalDtor(CGF, D, function, argument); } /// Emit code to cause the variable at the given address to be considered as /// constant from this point onwards. static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *Addr) { // Don't emit the intrinsic if we're not optimizing. if (!CGF.CGM.getCodeGenOpts().OptimizationLevel) return; // Grab the llvm.invariant.start intrinsic. llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start; llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID); // Emit a call with the size in bytes of the object. CharUnits WidthChars = CGF.getContext().getTypeSizeInChars(D.getType()); uint64_t Width = WidthChars.getQuantity(); llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width), llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)}; CGF.Builder.CreateCall(InvariantStart, Args); } void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr, bool PerformInit) { const Expr *Init = D.getInit(); QualType T = D.getType(); if (!T->isReferenceType()) { if (PerformInit) EmitDeclInit(*this, D, DeclPtr); if (CGM.isTypeConstant(D.getType(), true)) EmitDeclInvariant(*this, D, DeclPtr); else EmitDeclDestroy(*this, D, DeclPtr); return; } assert(PerformInit && "cannot have constant initializer which needs " "destruction for reference"); unsigned Alignment = getContext().getDeclAlign(&D).getQuantity(); RValue RV = EmitReferenceBindingToExpr(Init); EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T); } static llvm::Function * CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, llvm::FunctionType *ty, const Twine &name, bool TLS = false); /// Create a stub function, suitable for being passed to atexit, /// which passes the given address to the given destructor function. static llvm::Constant *createAtExitStub(CodeGenModule &CGM, const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { // Get the destructor function type, void(*)(void). llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false); SmallString<256> FnName; { llvm::raw_svector_ostream Out(FnName); CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out); } llvm::Function *fn = CreateGlobalInitOrDestructFunction(CGM, ty, FnName.str()); CodeGenFunction CGF(CGM); CGF.StartFunction(&VD, CGM.getContext().VoidTy, fn, CGM.getTypes().arrangeNullaryFunction(), FunctionArgList(), SourceLocation()); llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr); // Make sure the call and the callee agree on calling convention. if (llvm::Function *dtorFn = dyn_cast(dtor->stripPointerCasts())) call->setCallingConv(dtorFn->getCallingConv()); CGF.FinishFunction(); return fn; } /// Register a global destructor using the C atexit runtime function. void CodeGenFunction::registerGlobalDtorWithAtExit(const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { // Create a function which calls the destructor. llvm::Constant *dtorStub = createAtExitStub(CGM, VD, dtor, addr); // extern "C" int atexit(void (*f)(void)); llvm::FunctionType *atexitTy = llvm::FunctionType::get(IntTy, dtorStub->getType(), false); llvm::Constant *atexit = CGM.CreateRuntimeFunction(atexitTy, "atexit"); if (llvm::Function *atexitFn = dyn_cast(atexit)) atexitFn->setDoesNotThrow(); EmitNounwindRuntimeCall(atexit, dtorStub); } void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit) { // If we've been asked to forbid guard variables, emit an error now. // This diagnostic is hard-coded for Darwin's use case; we can find // better phrasing if someone else needs it. if (CGM.getCodeGenOpts().ForbidGuardVariables) CGM.Error(D.getLocation(), "this initialization requires a guard variable, which " "the kernel does not support"); CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit); } static llvm::Function * CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, llvm::FunctionType *FTy, const Twine &Name, bool TLS) { llvm::Function *Fn = llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage, Name, &CGM.getModule()); if (!CGM.getLangOpts().AppleKext && !TLS) { // Set the section if needed. if (const char *Section = CGM.getTarget().getStaticInitSectionSpecifier()) Fn->setSection(Section); } Fn->setCallingConv(CGM.getRuntimeCC()); if (!CGM.getLangOpts().Exceptions) Fn->setDoesNotThrow(); if (CGM.getSanOpts().Address) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (CGM.getSanOpts().Thread) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (CGM.getSanOpts().Memory) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); return Fn; } void CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit) { llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); SmallString<256> FnName; { llvm::raw_svector_ostream Out(FnName); getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out); } // Create a variable initialization function. llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, FnName.str()); CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr, PerformInit); if (D->getTLSKind()) { // FIXME: Should we support init_priority for thread_local? // FIXME: Ideally, initialization of instantiated thread_local static data // members of class templates should not trigger initialization of other // entities in the TU. // FIXME: We only need to register one __cxa_thread_atexit function for the // entire TU. CXXThreadLocalInits.push_back(Fn); } else if (D->hasAttr()) { unsigned int order = D->getAttr()->getPriority(); OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size()); PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn)); DelayedCXXInitPosition.erase(D); } else if (D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization && D->getTemplateSpecializationKind() != TSK_Undeclared) { // C++ [basic.start.init]p2: // Definitions of explicitly specialized class template static data // members have ordered initialization. Other class template static data // members (i.e., implicitly or explicitly instantiated specializations) // have unordered initialization. // // As a consequence, we can put them into their own llvm.global_ctors entry. // This should allow GlobalOpt to fire more often, and allow us to implement // the Microsoft C++ ABI, which uses COMDAT elimination to avoid double // initializaiton. AddGlobalCtor(Fn); DelayedCXXInitPosition.erase(D); } else { llvm::DenseMap::iterator I = DelayedCXXInitPosition.find(D); if (I == DelayedCXXInitPosition.end()) { CXXGlobalInits.push_back(Fn); } else { assert(CXXGlobalInits[I->second] == 0); CXXGlobalInits[I->second] = Fn; DelayedCXXInitPosition.erase(I); } } } void CodeGenModule::EmitCXXThreadLocalInitFunc() { llvm::Function *InitFn = 0; if (!CXXThreadLocalInits.empty()) { // Generate a guarded initialization function. llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); InitFn = CreateGlobalInitOrDestructFunction(*this, FTy, "__tls_init", /*TLS*/ true); llvm::GlobalVariable *Guard = new llvm::GlobalVariable( getModule(), Int8Ty, false, llvm::GlobalVariable::InternalLinkage, llvm::ConstantInt::get(Int8Ty, 0), "__tls_guard"); Guard->setThreadLocal(true); CodeGenFunction(*this) .GenerateCXXGlobalInitFunc(InitFn, CXXThreadLocalInits, Guard); } getCXXABI().EmitThreadLocalInitFuncs(CXXThreadLocals, InitFn); CXXThreadLocalInits.clear(); CXXThreadLocals.clear(); } void CodeGenModule::EmitCXXGlobalInitFunc() { while (!CXXGlobalInits.empty() && !CXXGlobalInits.back()) CXXGlobalInits.pop_back(); if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty()) return; llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); // Create our global initialization function. if (!PrioritizedCXXGlobalInits.empty()) { SmallVector LocalCXXGlobalInits; llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(), PrioritizedCXXGlobalInits.end()); // Iterate over "chunks" of ctors with same priority and emit each chunk // into separate function. Note - everything is sorted first by priority, // second - by lex order, so we emit ctor functions in proper order. for (SmallVectorImpl::iterator I = PrioritizedCXXGlobalInits.begin(), E = PrioritizedCXXGlobalInits.end(); I != E; ) { SmallVectorImpl::iterator PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp()); LocalCXXGlobalInits.clear(); unsigned Priority = I->first.priority; // Compute the function suffix from priority. Prepend with zeroes to make // sure the function names are also ordered as priorities. std::string PrioritySuffix = llvm::utostr(Priority); // Priority is always <= 65535 (enforced by sema).. PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix; llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_" + PrioritySuffix); for (; I < PrioE; ++I) LocalCXXGlobalInits.push_back(I->second); CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits); AddGlobalCtor(Fn, Priority); } } llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a"); CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits); AddGlobalCtor(Fn); CXXGlobalInits.clear(); PrioritizedCXXGlobalInits.clear(); } void CodeGenModule::EmitCXXGlobalDtorFunc() { if (CXXGlobalDtors.empty()) return; llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); // Create our global destructor function. llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a"); CodeGenFunction(*this).GenerateCXXGlobalDtorsFunc(Fn, CXXGlobalDtors); AddGlobalDtor(Fn); } /// Emit the code necessary to initialize the given global variable. void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit) { // Check if we need to emit debug info for variable initializer. if (D->hasAttr()) DebugInfo = NULL; // disable debug info indefinitely for this function StartFunction(GlobalDecl(D), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList(), D->getInit()->getExprLoc()); // Use guarded initialization if the global variable is weak. This // occurs for, e.g., instantiated static data members and // definitions explicitly marked weak. if (Addr->getLinkage() == llvm::GlobalValue::WeakODRLinkage || Addr->getLinkage() == llvm::GlobalValue::WeakAnyLinkage) { EmitCXXGuardedInit(*D, Addr, PerformInit); } else { EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit); } FinishFunction(); } void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef Decls, llvm::GlobalVariable *Guard) { StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList(), SourceLocation()); llvm::BasicBlock *ExitBlock = 0; if (Guard) { // If we have a guard variable, check whether we've already performed these // initializations. This happens for TLS initialization functions. llvm::Value *GuardVal = Builder.CreateLoad(Guard); llvm::Value *Uninit = Builder.CreateIsNull(GuardVal, "guard.uninitialized"); // Mark as initialized before initializing anything else. If the // initializers use previously-initialized thread_local vars, that's // probably supposed to be OK, but the standard doesn't say. Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(), 1), Guard); llvm::BasicBlock *InitBlock = createBasicBlock("init"); ExitBlock = createBasicBlock("exit"); Builder.CreateCondBr(Uninit, InitBlock, ExitBlock); EmitBlock(InitBlock); } RunCleanupsScope Scope(*this); // When building in Objective-C++ ARC mode, create an autorelease pool // around the global initializers. if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) { llvm::Value *token = EmitObjCAutoreleasePoolPush(); EmitObjCAutoreleasePoolCleanup(token); } for (unsigned i = 0, e = Decls.size(); i != e; ++i) if (Decls[i]) EmitRuntimeCall(Decls[i]); Scope.ForceCleanup(); if (ExitBlock) { Builder.CreateBr(ExitBlock); EmitBlock(ExitBlock); } FinishFunction(); } void CodeGenFunction::GenerateCXXGlobalDtorsFunc(llvm::Function *Fn, const std::vector > &DtorsAndObjects) { StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList(), SourceLocation()); // Emit the dtors, in reverse order from construction. for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; llvm::CallInst *CI = Builder.CreateCall(Callee, DtorsAndObjects[e - i - 1].second); // Make sure the call and the callee agree on calling convention. if (llvm::Function *F = dyn_cast(Callee)) CI->setCallingConv(F->getCallingConv()); } FinishFunction(); } /// generateDestroyHelper - Generates a helper function which, when /// invoked, destroys the given object. llvm::Function *CodeGenFunction::generateDestroyHelper( llvm::Constant *addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD) { FunctionArgList args; ImplicitParamDecl dst(0, SourceLocation(), 0, getContext().VoidPtrTy); args.push_back(&dst); const CGFunctionInfo &FI = CGM.getTypes().arrangeFunctionDeclaration(getContext().VoidTy, args, FunctionType::ExtInfo(), /*variadic*/ false); llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *fn = CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor"); StartFunction(VD, getContext().VoidTy, fn, FI, args, SourceLocation()); emitDestroy(addr, type, destroyer, useEHCleanupForArray); FinishFunction(); return fn; } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d284 3 a286 2 } else if (const InitPriorityAttr *IPA = D->getAttr()) { OrderGlobalInits Key(IPA->getPriority(), PrioritizedCXXGlobalInits.size()); @ 1.1.1.3 log @Import Clang 3.5svn r201163. @ text @d505 5 a509 3 const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( getContext().VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); @ 1.1.1.3.2.1 log @Rebase. @ text @a19 1 #include "llvm/Support/Path.h" d92 1 a92 1 const CXXRecordDecl *record = nullptr; d181 2 a182 1 CGM.getTypes().arrangeNullaryFunction(), FunctionArgList()); d297 4 a300 6 // // In addition, put the initializer into a COMDAT group with the global // being initialized. On most platforms, this is a minor startup time // optimization. In the MS C++ ABI, there are no guard variables, so this // COMDAT key is required for correctness. AddGlobalCtor(Fn, 65535, Addr); d308 1 a308 1 assert(CXXGlobalInits[I->second] == nullptr); d316 1 a316 1 llvm::Function *InitFn = nullptr; d366 1 a366 1 // Priority is always <= 65535 (enforced by sema). d380 2 a381 14 // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. SourceManager &SM = Context.getSourceManager(); SmallString<128> FileName(llvm::sys::path::filename( SM.getFileEntryForID(SM.getMainFileID())->getName())); for (size_t i = 0; i < FileName.size(); ++i) { // Replace everything that's not [a-zA-Z0-9._] with a _. This set happens // to be the set of C preprocessing numbers. if (!isPreprocessingNumberBody(FileName[i])) FileName[i] = '_'; } llvm::Function *Fn = CreateGlobalInitOrDestructFunction( *this, FTy, llvm::Twine("_GLOBAL__sub_I_", FileName)); d411 1 a411 1 DebugInfo = nullptr; // disable debug info indefinitely for this function d415 1 a415 2 FunctionArgList(), D->getLocation(), D->getInit()->getExprLoc()); d420 2 a421 1 if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage()) { d434 3 a436 25 { ArtificialLocation AL(*this, Builder); StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList()); // Emit an artificial location for this function. AL.Emit(); llvm::BasicBlock *ExitBlock = nullptr; if (Guard) { // If we have a guard variable, check whether we've already performed // these initializations. This happens for TLS initialization functions. llvm::Value *GuardVal = Builder.CreateLoad(Guard); llvm::Value *Uninit = Builder.CreateIsNull(GuardVal, "guard.uninitialized"); // Mark as initialized before initializing anything else. If the // initializers use previously-initialized thread_local vars, that's // probably supposed to be OK, but the standard doesn't say. Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard); llvm::BasicBlock *InitBlock = createBasicBlock("init"); ExitBlock = createBasicBlock("exit"); Builder.CreateCondBr(Uninit, InitBlock, ExitBlock); EmitBlock(InitBlock); } RunCleanupsScope Scope(*this); d438 34 a471 17 // When building in Objective-C++ ARC mode, create an autorelease pool // around the global initializers. if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) { llvm::Value *token = EmitObjCAutoreleasePoolPush(); EmitObjCAutoreleasePoolCleanup(token); } for (unsigned i = 0, e = Decls.size(); i != e; ++i) if (Decls[i]) EmitRuntimeCall(Decls[i]); Scope.ForceCleanup(); if (ExitBlock) { Builder.CreateBr(ExitBlock); EmitBlock(ExitBlock); } d480 12 a491 16 { ArtificialLocation AL(*this, Builder); StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList()); // Emit an artificial location for this function. AL.Emit(); // Emit the dtors, in reverse order from construction. for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; llvm::CallInst *CI = Builder.CreateCall(Callee, DtorsAndObjects[e - i - 1].second); // Make sure the call and the callee agree on calling convention. if (llvm::Function *F = dyn_cast(Callee)) CI->setCallingConv(F->getCallingConv()); } d503 1 a503 2 ImplicitParamDecl dst(getContext(), nullptr, SourceLocation(), nullptr, getContext().VoidPtrTy); d512 1 a512 1 StartFunction(VD, getContext().VoidTy, fn, FI, args); @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @a19 1 #include "llvm/Support/Path.h" d92 1 a92 1 const CXXRecordDecl *record = nullptr; d181 2 a182 1 CGM.getTypes().arrangeNullaryFunction(), FunctionArgList()); d297 4 a300 6 // // In addition, put the initializer into a COMDAT group with the global // being initialized. On most platforms, this is a minor startup time // optimization. In the MS C++ ABI, there are no guard variables, so this // COMDAT key is required for correctness. AddGlobalCtor(Fn, 65535, Addr); d308 1 a308 1 assert(CXXGlobalInits[I->second] == nullptr); d316 1 a316 1 llvm::Function *InitFn = nullptr; d366 1 a366 1 // Priority is always <= 65535 (enforced by sema). d380 2 a381 14 // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. SourceManager &SM = Context.getSourceManager(); SmallString<128> FileName(llvm::sys::path::filename( SM.getFileEntryForID(SM.getMainFileID())->getName())); for (size_t i = 0; i < FileName.size(); ++i) { // Replace everything that's not [a-zA-Z0-9._] with a _. This set happens // to be the set of C preprocessing numbers. if (!isPreprocessingNumberBody(FileName[i])) FileName[i] = '_'; } llvm::Function *Fn = CreateGlobalInitOrDestructFunction( *this, FTy, llvm::Twine("_GLOBAL__sub_I_", FileName)); d411 1 a411 1 DebugInfo = nullptr; // disable debug info indefinitely for this function d415 1 a415 2 FunctionArgList(), D->getLocation(), D->getInit()->getExprLoc()); d420 2 a421 1 if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage()) { d434 3 a436 25 { ArtificialLocation AL(*this, Builder); StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList()); // Emit an artificial location for this function. AL.Emit(); llvm::BasicBlock *ExitBlock = nullptr; if (Guard) { // If we have a guard variable, check whether we've already performed // these initializations. This happens for TLS initialization functions. llvm::Value *GuardVal = Builder.CreateLoad(Guard); llvm::Value *Uninit = Builder.CreateIsNull(GuardVal, "guard.uninitialized"); // Mark as initialized before initializing anything else. If the // initializers use previously-initialized thread_local vars, that's // probably supposed to be OK, but the standard doesn't say. Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard); llvm::BasicBlock *InitBlock = createBasicBlock("init"); ExitBlock = createBasicBlock("exit"); Builder.CreateCondBr(Uninit, InitBlock, ExitBlock); EmitBlock(InitBlock); } RunCleanupsScope Scope(*this); d438 34 a471 17 // When building in Objective-C++ ARC mode, create an autorelease pool // around the global initializers. if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) { llvm::Value *token = EmitObjCAutoreleasePoolPush(); EmitObjCAutoreleasePoolCleanup(token); } for (unsigned i = 0, e = Decls.size(); i != e; ++i) if (Decls[i]) EmitRuntimeCall(Decls[i]); Scope.ForceCleanup(); if (ExitBlock) { Builder.CreateBr(ExitBlock); EmitBlock(ExitBlock); } d480 12 a491 16 { ArtificialLocation AL(*this, Builder); StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList()); // Emit an artificial location for this function. AL.Emit(); // Emit the dtors, in reverse order from construction. for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; llvm::CallInst *CI = Builder.CreateCall(Callee, DtorsAndObjects[e - i - 1].second); // Make sure the call and the callee agree on calling convention. if (llvm::Function *F = dyn_cast(Callee)) CI->setCallingConv(F->getCallingConv()); } d503 1 a503 2 ImplicitParamDecl dst(getContext(), nullptr, SourceLocation(), nullptr, getContext().VoidPtrTy); d512 1 a512 1 StartFunction(VD, getContext().VoidTy, fn, FI, args); @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @d248 6 a253 8 if (!CGM.getSanitizerBlacklist().isIn(*Fn)) { if (CGM.getLangOpts().Sanitize.Address) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (CGM.getLangOpts().Sanitize.Thread) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (CGM.getLangOpts().Sanitize.Memory) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); } a257 26 /// Create a global pointer to a function that will initialize a global /// variable. The user has requested that this pointer be emitted in a specific /// section. void CodeGenModule::EmitPointerToInitFunc(const VarDecl *D, llvm::GlobalVariable *GV, llvm::Function *InitFunc, InitSegAttr *ISA) { llvm::GlobalVariable *PtrArray = new llvm::GlobalVariable( TheModule, InitFunc->getType(), /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, InitFunc, "__cxx_init_fn_ptr"); PtrArray->setSection(ISA->getSection()); addUsedGlobal(PtrArray); // If the GV is already in a comdat group, then we have to join it. llvm::Comdat *C = GV->getComdat(); // LinkOnce and Weak linkage are lowered down to a single-member comdat group. // Make an explicit group so we can join it. if (!C && (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage())) { C = TheModule.getOrInsertComdat(GV->getName()); GV->setComdat(C); } if (C) PtrArray->setComdat(C); } a272 1 auto *ISA = D->getAttr(); d275 1 d284 1 a284 4 } else if (PerformInit && ISA) { EmitPointerToInitFunc(D, Addr, Fn, ISA); DelayedCXXInitPosition.erase(D); } else if (auto *IPA = D->getAttr()) { @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a16 1 #include "CGOpenMPRuntime.h" d99 1 a99 1 function = CGM.getAddrOfCXXStructor(dtor, StructorType::Complete); a141 4 if (getLangOpts().OpenMP && D.hasAttr()) (void)CGM.getOpenMPRuntime().EmitOMPThreadPrivateVarDefinition( &D, DeclPtr, D.getAttr()->getLocation(), PerformInit, this); d158 6 d166 3 a168 3 llvm::Constant *CodeGenFunction::createAtExitStub(const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { d176 2 a177 2 llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(ty, FnName.str(), VD.getLocation()); d201 1 a201 1 llvm::Constant *dtorStub = createAtExitStub(VD, dtor, addr); d229 4 a232 2 llvm::Function *CodeGenModule::CreateGlobalInitOrDestructFunction( llvm::FunctionType *FTy, const Twine &Name, SourceLocation Loc, bool TLS) { d235 2 a236 2 Name, &getModule()); if (!getLangOpts().AppleKext && !TLS) { d238 2 a239 1 if (const char *Section = getTarget().getStaticInitSectionSpecifier()) d243 1 a243 1 Fn->setCallingConv(getRuntimeCC()); d245 1 a245 1 if (!getLangOpts().Exceptions) d248 2 a249 2 if (!isInSanitizerBlacklist(Fn, Loc)) { if (getLangOpts().Sanitize.has(SanitizerKind::Address)) d251 1 a251 1 if (getLangOpts().Sanitize.has(SanitizerKind::Thread)) d253 1 a253 1 if (getLangOpts().Sanitize.has(SanitizerKind::Memory)) d299 1 a299 1 CreateGlobalInitOrDestructFunction(FTy, FnName.str(), D->getLocation()); a303 4 llvm::GlobalVariable *COMDATKey = supportsCOMDAT() && D->isExternallyVisible() ? Addr : nullptr; a311 1 CXXThreadLocalInitVars.push_back(Addr); d319 2 a320 1 } else if (isTemplateInstantiation(D->getTemplateSpecializationKind())) { d329 5 a333 11 // If the global is externally visible, put the initializer into a COMDAT // group with the global being initialized. On most platforms, this is a // minor startup time optimization. In the MS C++ ABI, there are no guard // variables, so this COMDAT key is required for correctness. AddGlobalCtor(Fn, 65535, COMDATKey); DelayedCXXInitPosition.erase(D); } else if (D->hasAttr()) { // SelectAny globals will be comdat-folded. Put the initializer into a // COMDAT group associated with the global, so the initializers get folded // too. AddGlobalCtor(Fn, 65535, COMDATKey); d349 15 a363 2 getCXXABI().EmitThreadLocalInitFuncs( *this, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars); a365 1 CXXThreadLocalInitVars.clear(); d382 1 a382 1 SmallVector LocalCXXGlobalInits; d401 4 a404 3 llvm::Function *Fn = CreateGlobalInitOrDestructFunction( FTy, "_GLOBAL__I_" + PrioritySuffix); d412 4 a415 2 SmallString<128> FileName; d417 2 a418 9 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. FileName = llvm::sys::path::filename(MainFile->getName()); } else { FileName = SmallString<128>(""); } a424 1 d426 1 a426 1 FTy, llvm::Twine("_GLOBAL__sub_I_", FileName)); d442 2 a443 1 llvm::Function *Fn = CreateGlobalInitOrDestructFunction(FTy, "_GLOBAL__D_a"); a457 2 CurEHLocation = D->getLocStart(); d477 1 a477 1 ArrayRef Decls, d480 1 a480 1 ApplyDebugLocation NL(*this); d484 1 a484 1 ArtificialLocation AL(*this); d531 1 a531 1 ApplyDebugLocation NL(*this); d535 1 a535 1 ArtificialLocation AL(*this); d564 2 a565 4 llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction( FTy, "__cxx_global_array_dtor", VD->getLocation()); CurEHLocation = VD->getLocStart(); @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @a16 1 #include "CGOpenMPRuntime.h" d99 1 a99 1 function = CGM.getAddrOfCXXStructor(dtor, StructorType::Complete); a141 4 if (getLangOpts().OpenMP && D.hasAttr()) (void)CGM.getOpenMPRuntime().EmitOMPThreadPrivateVarDefinition( &D, DeclPtr, D.getAttr()->getLocation(), PerformInit, this); d158 6 d166 3 a168 3 llvm::Constant *CodeGenFunction::createAtExitStub(const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { d176 2 a177 2 llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(ty, FnName.str(), VD.getLocation()); d201 1 a201 1 llvm::Constant *dtorStub = createAtExitStub(VD, dtor, addr); d229 4 a232 2 llvm::Function *CodeGenModule::CreateGlobalInitOrDestructFunction( llvm::FunctionType *FTy, const Twine &Name, SourceLocation Loc, bool TLS) { d235 2 a236 2 Name, &getModule()); if (!getLangOpts().AppleKext && !TLS) { d238 2 a239 1 if (const char *Section = getTarget().getStaticInitSectionSpecifier()) d243 1 a243 1 Fn->setCallingConv(getRuntimeCC()); d245 1 a245 1 if (!getLangOpts().Exceptions) d248 2 a249 2 if (!isInSanitizerBlacklist(Fn, Loc)) { if (getLangOpts().Sanitize.has(SanitizerKind::Address)) d251 1 a251 1 if (getLangOpts().Sanitize.has(SanitizerKind::Thread)) d253 1 a253 1 if (getLangOpts().Sanitize.has(SanitizerKind::Memory)) d299 1 a299 1 CreateGlobalInitOrDestructFunction(FTy, FnName.str(), D->getLocation()); a303 4 llvm::GlobalVariable *COMDATKey = supportsCOMDAT() && D->isExternallyVisible() ? Addr : nullptr; a311 1 CXXThreadLocalInitVars.push_back(Addr); d319 2 a320 1 } else if (isTemplateInstantiation(D->getTemplateSpecializationKind())) { d329 5 a333 11 // If the global is externally visible, put the initializer into a COMDAT // group with the global being initialized. On most platforms, this is a // minor startup time optimization. In the MS C++ ABI, there are no guard // variables, so this COMDAT key is required for correctness. AddGlobalCtor(Fn, 65535, COMDATKey); DelayedCXXInitPosition.erase(D); } else if (D->hasAttr()) { // SelectAny globals will be comdat-folded. Put the initializer into a // COMDAT group associated with the global, so the initializers get folded // too. AddGlobalCtor(Fn, 65535, COMDATKey); d349 15 a363 2 getCXXABI().EmitThreadLocalInitFuncs( *this, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars); a365 1 CXXThreadLocalInitVars.clear(); d382 1 a382 1 SmallVector LocalCXXGlobalInits; d401 4 a404 3 llvm::Function *Fn = CreateGlobalInitOrDestructFunction( FTy, "_GLOBAL__I_" + PrioritySuffix); d412 4 a415 2 SmallString<128> FileName; d417 2 a418 9 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. FileName = llvm::sys::path::filename(MainFile->getName()); } else { FileName = SmallString<128>(""); } a424 1 d426 1 a426 1 FTy, llvm::Twine("_GLOBAL__sub_I_", FileName)); d442 2 a443 1 llvm::Function *Fn = CreateGlobalInitOrDestructFunction(FTy, "_GLOBAL__D_a"); a457 2 CurEHLocation = D->getLocStart(); d477 1 a477 1 ArrayRef Decls, d480 1 a480 1 ApplyDebugLocation NL(*this); d484 1 a484 1 ArtificialLocation AL(*this); d531 1 a531 1 ApplyDebugLocation NL(*this); d535 1 a535 1 ArtificialLocation AL(*this); d564 2 a565 4 llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction( FTy, "__cxx_global_array_dtor", VD->getLocation()); CurEHLocation = VD->getLocStart(); @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d27 1 a27 1 ConstantAddress DeclPtr) { d32 3 d36 1 a36 1 LValue lv = CGF.MakeAddrLValue(DeclPtr, type); d67 1 a67 1 ConstantAddress addr) { d102 1 a102 1 addr.getPointer(), CGF.getTypes().ConvertType(type)->getPointerTo()); a141 25 // The address space of a static local variable (DeclPtr) may be different // from the address space of the "this" argument of the constructor. In that // case, we need an addrspacecast before calling the constructor. // // struct StructWithCtor { // __device__ StructWithCtor() {...} // }; // __device__ void foo() { // __shared__ StructWithCtor s; // ... // } // // For example, in the above CUDA code, the static local variable s has a // "shared" address space qualifier, but the constructor of StructWithCtor // expects "this" in the "generic" address space. unsigned ExpectedAddrSpace = getContext().getTargetAddressSpace(T); unsigned ActualAddrSpace = DeclPtr->getType()->getPointerAddressSpace(); if (ActualAddrSpace != ExpectedAddrSpace) { llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(T); llvm::PointerType *PTy = llvm::PointerType::get(LTy, ExpectedAddrSpace); DeclPtr = llvm::ConstantExpr::getAddrSpaceCast(DeclPtr, PTy); } ConstantAddress DeclAddr(DeclPtr, getContext().getDeclAlign(&D)); d144 2 a145 2 (void)CGM.getOpenMPRuntime().emitThreadPrivateVarDefinition( &D, DeclAddr, D.getAttr()->getLocation(), d148 1 a148 1 EmitDeclInit(*this, D, DeclAddr); d152 1 a152 1 EmitDeclDestroy(*this, D, DeclAddr); d158 1 d160 1 a160 1 EmitStoreOfScalar(RV.getScalarVal(), DeclAddr, false, T); a174 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction(); a175 1 FI, d180 2 a181 1 CGF.StartFunction(&VD, CGM.getContext().VoidTy, fn, FI, FunctionArgList()); d229 1 a229 2 llvm::FunctionType *FTy, const Twine &Name, const CGFunctionInfo &FI, SourceLocation Loc, bool TLS) { a238 2 SetInternalFunctionAttributes(nullptr, Fn, FI); d245 1 a245 2 if (getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress)) a250 2 if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack)) Fn->addFnAttr(llvm::Attribute::SafeStack); d270 9 a278 1 if (llvm::Comdat *C = GV->getComdat()) a285 5 // Check if we've already initialized this decl. auto I = DelayedCXXInitPosition.find(D); if (I != DelayedCXXInitPosition.end() && I->second == ~0U) return; d295 1 a295 3 CreateGlobalInitOrDestructFunction(FTy, FnName.str(), getTypes().arrangeNullaryFunction(), D->getLocation()); d312 1 a312 1 CXXThreadLocalInitVars.push_back(D); d315 1 d319 1 d334 1 d340 1 d342 2 a343 1 I = DelayedCXXInitPosition.find(D); // Re-do lookup in case of re-hash. d346 2 a347 3 } else if (I->second != ~0U) { assert(I->second < CXXGlobalInits.size() && CXXGlobalInits[I->second] == nullptr); d349 1 a351 3 // Remember that we already emitted the initializer for this global. DelayedCXXInitPosition[D] = ~0U; d372 1 a372 1 const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction(); d396 1 a396 1 FTy, "_GLOBAL__I_" + PrioritySuffix, FI); a403 1 PrioritizedCXXGlobalInits.clear(); d414 1 a414 1 FileName = ""; d425 1 a425 1 FTy, llvm::Twine("_GLOBAL__sub_I_", FileName), FI); d431 1 d441 1 a441 3 const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction(); llvm::Function *Fn = CreateGlobalInitOrDestructFunction(FTy, "_GLOBAL__D_a", FI); d478 1 a478 1 Address Guard) { d480 1 a480 1 auto NL = ApplyDebugLocation::CreateEmpty(*this); d484 1 a484 1 auto AL = ApplyDebugLocation::CreateArtificial(*this); d487 1 a487 1 if (Guard.isValid()) { d493 4 a500 4 // Mark as initialized before initializing anything else. If the // initializers use previously-initialized thread_local vars, that's // probably supposed to be OK, but the standard doesn't say. Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard); d531 1 a531 1 auto NL = ApplyDebugLocation::CreateEmpty(*this); d535 1 a535 1 auto AL = ApplyDebugLocation::CreateArtificial(*this); d552 1 a552 2 /// invoked, destroys the given object. The address of the object /// should be in global memory. d554 1 a554 1 Address addr, QualType type, Destroyer *destroyer, d565 1 a565 1 FTy, "__cxx_global_array_dtor", FI, VD->getLocation()); @ 1.1.1.7.2.1 log @Sync with HEAD @ text @d89 7 a95 15 // Special-case non-array C++ destructors, if they have the right signature. // Under some ABIs, destructors return this instead of void, and cannot be // passed directly to __cxa_atexit if the target does not allow this mismatch. const CXXRecordDecl *Record = type->getAsCXXRecordDecl(); bool CanRegisterDestructor = Record && (!CGM.getCXXABI().HasThisReturn( GlobalDecl(Record->getDestructor(), Dtor_Complete)) || CGM.getCXXABI().canCallMismatchedFunctionType()); // If __cxa_atexit is disabled via a flag, a different helper function is // generated elsewhere which uses atexit instead, and it takes the destructor // directly. bool UsingExternalHelper = !CGM.getCodeGenOpts().CXAAtExit; if (Record && (CanRegisterDestructor || UsingExternalHelper)) { assert(!Record->hasTrivialDestructor()); CXXDestructorDecl *dtor = Record->getDestructor(); d116 1 a116 1 // Do not emit the intrinsic if we're not optimizing. d122 1 a122 3 // Overloaded address space type. llvm::Type *ObjectPtr[1] = {CGF.Int8PtrTy}; llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID, ObjectPtr); d230 1 a230 2 CGM.CreateRuntimeFunction(atexitTy, "atexit", llvm::AttributeSet(), /*Local=*/true); a306 11 // According to E.2.3.1 in CUDA-7.5 Programming guide: __device__, // __constant__ and __shared__ variables defined in namespace scope, // that are of class type, cannot have a non-empty constructor. All // the checks have been done in Sema by now. Whatever initializers // are allowed are empty and we just need to ignore them here. if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice && (D->hasAttr() || D->hasAttr() || D->hasAttr())) return; d334 3 d590 2 a591 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy, args); @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @d89 7 a95 15 // Special-case non-array C++ destructors, if they have the right signature. // Under some ABIs, destructors return this instead of void, and cannot be // passed directly to __cxa_atexit if the target does not allow this mismatch. const CXXRecordDecl *Record = type->getAsCXXRecordDecl(); bool CanRegisterDestructor = Record && (!CGM.getCXXABI().HasThisReturn( GlobalDecl(Record->getDestructor(), Dtor_Complete)) || CGM.getCXXABI().canCallMismatchedFunctionType()); // If __cxa_atexit is disabled via a flag, a different helper function is // generated elsewhere which uses atexit instead, and it takes the destructor // directly. bool UsingExternalHelper = !CGM.getCodeGenOpts().CXAAtExit; if (Record && (CanRegisterDestructor || UsingExternalHelper)) { assert(!Record->hasTrivialDestructor()); CXXDestructorDecl *dtor = Record->getDestructor(); d116 1 a116 1 // Do not emit the intrinsic if we're not optimizing. d122 1 a122 3 // Overloaded address space type. llvm::Type *ObjectPtr[1] = {CGF.Int8PtrTy}; llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID, ObjectPtr); d230 1 a230 2 CGM.CreateRuntimeFunction(atexitTy, "atexit", llvm::AttributeSet(), /*Local=*/true); a306 11 // According to E.2.3.1 in CUDA-7.5 Programming guide: __device__, // __constant__ and __shared__ variables defined in namespace scope, // that are of class type, cannot have a non-empty constructor. All // the checks have been done in Sema by now. Whatever initializers // are allowed are empty and we just need to ignore them here. if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice && (D->hasAttr() || D->hasAttr() || D->hasAttr())) return; d590 2 a591 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy, args); @ 1.1.1.8.2.1 log @Sync with HEAD @ text @d356 3 @ 1.1.1.9 log @Import Clang 4.0RC1 r294123. @ text @d356 3 @ 1.1.1.10 log @Import clang r309604 from branches/release_50 @ text @d240 1 a240 1 CGM.CreateRuntimeFunction(atexitTy, "atexit", llvm::AttributeList(), d574 3 a576 4 void CodeGenFunction::GenerateCXXGlobalDtorsFunc( llvm::Function *Fn, const std::vector> &DtorsAndObjects) { d605 3 a607 3 ImplicitParamDecl Dst(getContext(), getContext().VoidPtrTy, ImplicitParamDecl::Other); args.push_back(&Dst); @ 1.1.1.10.4.1 log @Sync with HEAD @ text @a20 1 #include "llvm/IR/MDBuilder.h" d55 1 a55 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap)); a80 1 case QualType::DK_nontrivial_c_struct: d175 1 a175 2 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd && D.hasAttr()) { a178 1 } a233 2 registerGlobalDtorWithAtExit(dtorStub); } a234 1 void CodeGenFunction::registerGlobalDtorWithAtExit(llvm::Constant *dtorStub) { a261 37 void CodeGenFunction::EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D) { assert((Kind == GuardKind::TlsGuard || D) && "no guarded variable"); // A guess at how many times we will enter the initialization of a // variable, depending on the kind of variable. static const uint64_t InitsPerTLSVar = 1024; static const uint64_t InitsPerLocalVar = 1024 * 1024; llvm::MDNode *Weights; if (Kind == GuardKind::VariableGuard && !D->isLocalVarDecl()) { // For non-local variables, don't apply any weighting for now. Due to our // use of COMDATs, we expect there to be at most one initialization of the // variable per DSO, but we have no way to know how many DSOs will try to // initialize the variable. Weights = nullptr; } else { uint64_t NumInits; // FIXME: For the TLS case, collect and use profiling information to // determine a more accurate brach weight. if (Kind == GuardKind::TlsGuard || D->getTLSKind()) NumInits = InitsPerTLSVar; else NumInits = InitsPerLocalVar; // The probability of us entering the initializer is // 1 / (total number of times we attempt to initialize the variable). llvm::MDBuilder MDHelper(CGM.getLLVMContext()); Weights = MDHelper.createBranchWeights(1, NumInits - 1); } Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights); } d274 1 a274 1 SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d281 11 a291 31 if (getLangOpts().Sanitize.has(SanitizerKind::Address) && !isInSanitizerBlacklist(SanitizerKind::Address, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) && !isInSanitizerBlacklist(SanitizerKind::KernelAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) && !isInSanitizerBlacklist(SanitizerKind::HWAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress); if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) && !isInSanitizerBlacklist(SanitizerKind::KernelHWAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress); if (getLangOpts().Sanitize.has(SanitizerKind::Thread) && !isInSanitizerBlacklist(SanitizerKind::Thread, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (getLangOpts().Sanitize.has(SanitizerKind::Memory) && !isInSanitizerBlacklist(SanitizerKind::Memory, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) && !isInSanitizerBlacklist(SanitizerKind::SafeStack, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SafeStack); if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) && !isInSanitizerBlacklist(SanitizerKind::ShadowCallStack, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::ShadowCallStack); a328 4 if (getLangOpts().OpenMP && getOpenMPRuntime().emitDeclareTargetVarDefinition(D, Addr, PerformInit)) return; d452 8 a459 5 // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. SmallString<128> FileName = llvm::sys::path::filename(getModule().getName()); if (FileName.empty()) d461 1 d542 1 a542 2 EmitCXXGuardedInitBranch(Uninit, InitBlock, ExitBlock, GuardKind::TlsGuard, nullptr); @ 1.1.1.10.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.10.2.1 log @Sync with HEAD @ text @a20 1 #include "llvm/IR/MDBuilder.h" d55 1 a55 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap)); a80 1 case QualType::DK_nontrivial_c_struct: d175 1 a175 2 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd && D.hasAttr()) { a178 1 } a233 2 registerGlobalDtorWithAtExit(dtorStub); } a234 1 void CodeGenFunction::registerGlobalDtorWithAtExit(llvm::Constant *dtorStub) { a261 37 void CodeGenFunction::EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D) { assert((Kind == GuardKind::TlsGuard || D) && "no guarded variable"); // A guess at how many times we will enter the initialization of a // variable, depending on the kind of variable. static const uint64_t InitsPerTLSVar = 1024; static const uint64_t InitsPerLocalVar = 1024 * 1024; llvm::MDNode *Weights; if (Kind == GuardKind::VariableGuard && !D->isLocalVarDecl()) { // For non-local variables, don't apply any weighting for now. Due to our // use of COMDATs, we expect there to be at most one initialization of the // variable per DSO, but we have no way to know how many DSOs will try to // initialize the variable. Weights = nullptr; } else { uint64_t NumInits; // FIXME: For the TLS case, collect and use profiling information to // determine a more accurate brach weight. if (Kind == GuardKind::TlsGuard || D->getTLSKind()) NumInits = InitsPerTLSVar; else NumInits = InitsPerLocalVar; // The probability of us entering the initializer is // 1 / (total number of times we attempt to initialize the variable). llvm::MDBuilder MDHelper(CGM.getLLVMContext()); Weights = MDHelper.createBranchWeights(1, NumInits - 1); } Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights); } d274 1 a274 1 SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d281 11 a291 31 if (getLangOpts().Sanitize.has(SanitizerKind::Address) && !isInSanitizerBlacklist(SanitizerKind::Address, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) && !isInSanitizerBlacklist(SanitizerKind::KernelAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) && !isInSanitizerBlacklist(SanitizerKind::HWAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress); if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) && !isInSanitizerBlacklist(SanitizerKind::KernelHWAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress); if (getLangOpts().Sanitize.has(SanitizerKind::Thread) && !isInSanitizerBlacklist(SanitizerKind::Thread, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (getLangOpts().Sanitize.has(SanitizerKind::Memory) && !isInSanitizerBlacklist(SanitizerKind::Memory, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) && !isInSanitizerBlacklist(SanitizerKind::SafeStack, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SafeStack); if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) && !isInSanitizerBlacklist(SanitizerKind::ShadowCallStack, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::ShadowCallStack); a328 4 if (getLangOpts().OpenMP && getOpenMPRuntime().emitDeclareTargetVarDefinition(D, Addr, PerformInit)) return; d452 8 a459 5 // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. SmallString<128> FileName = llvm::sys::path::filename(getModule().getName()); if (FileName.empty()) d461 1 d542 1 a542 2 EmitCXXGuardedInitBranch(Uninit, InitBlock, ExitBlock, GuardKind::TlsGuard, nullptr); @ 1.1.1.11 log @Import clang r337282 from trunk @ text @a20 1 #include "llvm/IR/MDBuilder.h" d55 1 a55 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap)); a80 1 case QualType::DK_nontrivial_c_struct: d175 1 a175 2 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd && D.hasAttr()) { a178 1 } a233 2 registerGlobalDtorWithAtExit(dtorStub); } a234 1 void CodeGenFunction::registerGlobalDtorWithAtExit(llvm::Constant *dtorStub) { a261 37 void CodeGenFunction::EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D) { assert((Kind == GuardKind::TlsGuard || D) && "no guarded variable"); // A guess at how many times we will enter the initialization of a // variable, depending on the kind of variable. static const uint64_t InitsPerTLSVar = 1024; static const uint64_t InitsPerLocalVar = 1024 * 1024; llvm::MDNode *Weights; if (Kind == GuardKind::VariableGuard && !D->isLocalVarDecl()) { // For non-local variables, don't apply any weighting for now. Due to our // use of COMDATs, we expect there to be at most one initialization of the // variable per DSO, but we have no way to know how many DSOs will try to // initialize the variable. Weights = nullptr; } else { uint64_t NumInits; // FIXME: For the TLS case, collect and use profiling information to // determine a more accurate brach weight. if (Kind == GuardKind::TlsGuard || D->getTLSKind()) NumInits = InitsPerTLSVar; else NumInits = InitsPerLocalVar; // The probability of us entering the initializer is // 1 / (total number of times we attempt to initialize the variable). llvm::MDBuilder MDHelper(CGM.getLLVMContext()); Weights = MDHelper.createBranchWeights(1, NumInits - 1); } Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights); } d274 1 a274 1 SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d281 11 a291 31 if (getLangOpts().Sanitize.has(SanitizerKind::Address) && !isInSanitizerBlacklist(SanitizerKind::Address, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) && !isInSanitizerBlacklist(SanitizerKind::KernelAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) && !isInSanitizerBlacklist(SanitizerKind::HWAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress); if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) && !isInSanitizerBlacklist(SanitizerKind::KernelHWAddress, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress); if (getLangOpts().Sanitize.has(SanitizerKind::Thread) && !isInSanitizerBlacklist(SanitizerKind::Thread, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (getLangOpts().Sanitize.has(SanitizerKind::Memory) && !isInSanitizerBlacklist(SanitizerKind::Memory, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) && !isInSanitizerBlacklist(SanitizerKind::SafeStack, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::SafeStack); if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) && !isInSanitizerBlacklist(SanitizerKind::ShadowCallStack, Fn, Loc)) Fn->addFnAttr(llvm::Attribute::ShadowCallStack); a328 4 if (getLangOpts().OpenMP && getOpenMPRuntime().emitDeclareTargetVarDefinition(D, Addr, PerformInit)) return; d452 8 a459 5 // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. SmallString<128> FileName = llvm::sys::path::filename(getModule().getName()); if (FileName.empty()) d461 1 d542 1 a542 2 EmitCXXGuardedInitBranch(Uninit, InitBlock, ExitBlock, GuardKind::TlsGuard, nullptr); @ 1.1.1.12 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file CGDeclCXX.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 574 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 574 //===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with code generation of C++ declarations // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCXXABI.h" #include "CGObjCRuntime.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Support/Path.h" using namespace clang; using namespace CodeGen; static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *DeclPtr) { assert(D.hasGlobalStorage() && "VarDecl must have global storage!"); assert(!D.getType()->isReferenceType() && "Should not call EmitDeclInit on a reference!"); ASTContext &Context = CGF.getContext(); CharUnits alignment = Context.getDeclAlign(&D); QualType type = D.getType(); LValue lv = CGF.MakeAddrLValue(DeclPtr, type, alignment); const Expr *Init = D.getInit(); switch (CGF.getEvaluationKind(type)) { case TEK_Scalar: { CodeGenModule &CGM = CGF.CGM; if (lv.isObjCStrong()) CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init), DeclPtr, D.getTLSKind()); else if (lv.isObjCWeak()) CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init), DeclPtr); else CGF.EmitScalarInit(Init, &D, lv, false); return; } case TEK_Complex: CGF.EmitComplexExprIntoLValue(Init, lv, /*isInit*/ true); return; case TEK_Aggregate: CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv,AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); return; } llvm_unreachable("bad evaluation kind"); } /// Emit code to cause the destruction of the given variable with /// static storage duration. static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *addr) { CodeGenModule &CGM = CGF.CGM; // FIXME: __attribute__((cleanup)) ? QualType type = D.getType(); QualType::DestructionKind dtorKind = type.isDestructedType(); switch (dtorKind) { case QualType::DK_none: return; case QualType::DK_cxx_destructor: break; case QualType::DK_objc_strong_lifetime: case QualType::DK_objc_weak_lifetime: // We don't care about releasing objects during process teardown. assert(!D.getTLSKind() && "should have rejected this"); return; } llvm::Constant *function; llvm::Constant *argument; // Special-case non-array C++ destructors, where there's a function // with the right signature that we can just call. const CXXRecordDecl *record = nullptr; if (dtorKind == QualType::DK_cxx_destructor && (record = type->getAsCXXRecordDecl())) { assert(!record->hasTrivialDestructor()); CXXDestructorDecl *dtor = record->getDestructor(); function = CGM.GetAddrOfCXXDestructor(dtor, Dtor_Complete); argument = llvm::ConstantExpr::getBitCast( addr, CGF.getTypes().ConvertType(type)->getPointerTo()); // Otherwise, the standard logic requires a helper function. } else { function = CodeGenFunction(CGM) .generateDestroyHelper(addr, type, CGF.getDestroyer(dtorKind), CGF.needsEHCleanup(dtorKind), &D); argument = llvm::Constant::getNullValue(CGF.Int8PtrTy); } CGM.getCXXABI().registerGlobalDtor(CGF, D, function, argument); } /// Emit code to cause the variable at the given address to be considered as /// constant from this point onwards. static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *Addr) { // Don't emit the intrinsic if we're not optimizing. if (!CGF.CGM.getCodeGenOpts().OptimizationLevel) return; // Grab the llvm.invariant.start intrinsic. llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start; llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID); // Emit a call with the size in bytes of the object. CharUnits WidthChars = CGF.getContext().getTypeSizeInChars(D.getType()); uint64_t Width = WidthChars.getQuantity(); llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width), llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)}; CGF.Builder.CreateCall(InvariantStart, Args); } void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr, bool PerformInit) { const Expr *Init = D.getInit(); QualType T = D.getType(); if (!T->isReferenceType()) { if (PerformInit) EmitDeclInit(*this, D, DeclPtr); if (CGM.isTypeConstant(D.getType(), true)) EmitDeclInvariant(*this, D, DeclPtr); else EmitDeclDestroy(*this, D, DeclPtr); return; } assert(PerformInit && "cannot have constant initializer which needs " "destruction for reference"); unsigned Alignment = getContext().getDeclAlign(&D).getQuantity(); RValue RV = EmitReferenceBindingToExpr(Init); EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T); } static llvm::Function * CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, llvm::FunctionType *ty, const Twine &name, bool TLS = false); /// Create a stub function, suitable for being passed to atexit, /// which passes the given address to the given destructor function. static llvm::Constant *createAtExitStub(CodeGenModule &CGM, const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { // Get the destructor function type, void(*)(void). llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false); SmallString<256> FnName; { llvm::raw_svector_ostream Out(FnName); CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out); } llvm::Function *fn = CreateGlobalInitOrDestructFunction(CGM, ty, FnName.str()); CodeGenFunction CGF(CGM); CGF.StartFunction(&VD, CGM.getContext().VoidTy, fn, CGM.getTypes().arrangeNullaryFunction(), FunctionArgList()); llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr); // Make sure the call and the callee agree on calling convention. if (llvm::Function *dtorFn = dyn_cast(dtor->stripPointerCasts())) call->setCallingConv(dtorFn->getCallingConv()); CGF.FinishFunction(); return fn; } /// Register a global destructor using the C atexit runtime function. void CodeGenFunction::registerGlobalDtorWithAtExit(const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { // Create a function which calls the destructor. llvm::Constant *dtorStub = createAtExitStub(CGM, VD, dtor, addr); // extern "C" int atexit(void (*f)(void)); llvm::FunctionType *atexitTy = llvm::FunctionType::get(IntTy, dtorStub->getType(), false); llvm::Constant *atexit = CGM.CreateRuntimeFunction(atexitTy, "atexit"); if (llvm::Function *atexitFn = dyn_cast(atexit)) atexitFn->setDoesNotThrow(); EmitNounwindRuntimeCall(atexit, dtorStub); } void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit) { // If we've been asked to forbid guard variables, emit an error now. // This diagnostic is hard-coded for Darwin's use case; we can find // better phrasing if someone else needs it. if (CGM.getCodeGenOpts().ForbidGuardVariables) CGM.Error(D.getLocation(), "this initialization requires a guard variable, which " "the kernel does not support"); CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit); } static llvm::Function * CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, llvm::FunctionType *FTy, const Twine &Name, bool TLS) { llvm::Function *Fn = llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage, Name, &CGM.getModule()); if (!CGM.getLangOpts().AppleKext && !TLS) { // Set the section if needed. if (const char *Section = CGM.getTarget().getStaticInitSectionSpecifier()) Fn->setSection(Section); } Fn->setCallingConv(CGM.getRuntimeCC()); if (!CGM.getLangOpts().Exceptions) Fn->setDoesNotThrow(); if (!CGM.getSanitizerBlacklist().isIn(*Fn)) { if (CGM.getLangOpts().Sanitize.Address) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (CGM.getLangOpts().Sanitize.Thread) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (CGM.getLangOpts().Sanitize.Memory) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); } return Fn; } /// Create a global pointer to a function that will initialize a global /// variable. The user has requested that this pointer be emitted in a specific /// section. void CodeGenModule::EmitPointerToInitFunc(const VarDecl *D, llvm::GlobalVariable *GV, llvm::Function *InitFunc, InitSegAttr *ISA) { llvm::GlobalVariable *PtrArray = new llvm::GlobalVariable( TheModule, InitFunc->getType(), /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, InitFunc, "__cxx_init_fn_ptr"); PtrArray->setSection(ISA->getSection()); addUsedGlobal(PtrArray); // If the GV is already in a comdat group, then we have to join it. llvm::Comdat *C = GV->getComdat(); // LinkOnce and Weak linkage are lowered down to a single-member comdat group. // Make an explicit group so we can join it. if (!C && (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage())) { C = TheModule.getOrInsertComdat(GV->getName()); GV->setComdat(C); } if (C) PtrArray->setComdat(C); } void CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit) { llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); SmallString<256> FnName; { llvm::raw_svector_ostream Out(FnName); getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out); } // Create a variable initialization function. llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, FnName.str()); auto *ISA = D->getAttr(); CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr, PerformInit); if (D->getTLSKind()) { // FIXME: Should we support init_priority for thread_local? // FIXME: Ideally, initialization of instantiated thread_local static data // members of class templates should not trigger initialization of other // entities in the TU. // FIXME: We only need to register one __cxa_thread_atexit function for the // entire TU. CXXThreadLocalInits.push_back(Fn); } else if (PerformInit && ISA) { EmitPointerToInitFunc(D, Addr, Fn, ISA); DelayedCXXInitPosition.erase(D); } else if (auto *IPA = D->getAttr()) { OrderGlobalInits Key(IPA->getPriority(), PrioritizedCXXGlobalInits.size()); PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn)); DelayedCXXInitPosition.erase(D); } else if (D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization && D->getTemplateSpecializationKind() != TSK_Undeclared) { // C++ [basic.start.init]p2: // Definitions of explicitly specialized class template static data // members have ordered initialization. Other class template static data // members (i.e., implicitly or explicitly instantiated specializations) // have unordered initialization. // // As a consequence, we can put them into their own llvm.global_ctors entry. // // In addition, put the initializer into a COMDAT group with the global // being initialized. On most platforms, this is a minor startup time // optimization. In the MS C++ ABI, there are no guard variables, so this // COMDAT key is required for correctness. AddGlobalCtor(Fn, 65535, Addr); DelayedCXXInitPosition.erase(D); } else { llvm::DenseMap::iterator I = DelayedCXXInitPosition.find(D); if (I == DelayedCXXInitPosition.end()) { CXXGlobalInits.push_back(Fn); } else { assert(CXXGlobalInits[I->second] == nullptr); CXXGlobalInits[I->second] = Fn; DelayedCXXInitPosition.erase(I); } } } void CodeGenModule::EmitCXXThreadLocalInitFunc() { llvm::Function *InitFn = nullptr; if (!CXXThreadLocalInits.empty()) { // Generate a guarded initialization function. llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); InitFn = CreateGlobalInitOrDestructFunction(*this, FTy, "__tls_init", /*TLS*/ true); llvm::GlobalVariable *Guard = new llvm::GlobalVariable( getModule(), Int8Ty, false, llvm::GlobalVariable::InternalLinkage, llvm::ConstantInt::get(Int8Ty, 0), "__tls_guard"); Guard->setThreadLocal(true); CodeGenFunction(*this) .GenerateCXXGlobalInitFunc(InitFn, CXXThreadLocalInits, Guard); } getCXXABI().EmitThreadLocalInitFuncs(CXXThreadLocals, InitFn); CXXThreadLocalInits.clear(); CXXThreadLocals.clear(); } void CodeGenModule::EmitCXXGlobalInitFunc() { while (!CXXGlobalInits.empty() && !CXXGlobalInits.back()) CXXGlobalInits.pop_back(); if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty()) return; llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); // Create our global initialization function. if (!PrioritizedCXXGlobalInits.empty()) { SmallVector LocalCXXGlobalInits; llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(), PrioritizedCXXGlobalInits.end()); // Iterate over "chunks" of ctors with same priority and emit each chunk // into separate function. Note - everything is sorted first by priority, // second - by lex order, so we emit ctor functions in proper order. for (SmallVectorImpl::iterator I = PrioritizedCXXGlobalInits.begin(), E = PrioritizedCXXGlobalInits.end(); I != E; ) { SmallVectorImpl::iterator PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp()); LocalCXXGlobalInits.clear(); unsigned Priority = I->first.priority; // Compute the function suffix from priority. Prepend with zeroes to make // sure the function names are also ordered as priorities. std::string PrioritySuffix = llvm::utostr(Priority); // Priority is always <= 65535 (enforced by sema). PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix; llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_" + PrioritySuffix); for (; I < PrioE; ++I) LocalCXXGlobalInits.push_back(I->second); CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits); AddGlobalCtor(Fn, Priority); } } // Include the filename in the symbol name. Including "sub_" matches gcc and // makes sure these symbols appear lexicographically behind the symbols with // priority emitted above. SourceManager &SM = Context.getSourceManager(); SmallString<128> FileName(llvm::sys::path::filename( SM.getFileEntryForID(SM.getMainFileID())->getName())); for (size_t i = 0; i < FileName.size(); ++i) { // Replace everything that's not [a-zA-Z0-9._] with a _. This set happens // to be the set of C preprocessing numbers. if (!isPreprocessingNumberBody(FileName[i])) FileName[i] = '_'; } llvm::Function *Fn = CreateGlobalInitOrDestructFunction( *this, FTy, llvm::Twine("_GLOBAL__sub_I_", FileName)); CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits); AddGlobalCtor(Fn); CXXGlobalInits.clear(); PrioritizedCXXGlobalInits.clear(); } void CodeGenModule::EmitCXXGlobalDtorFunc() { if (CXXGlobalDtors.empty()) return; llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); // Create our global destructor function. llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a"); CodeGenFunction(*this).GenerateCXXGlobalDtorsFunc(Fn, CXXGlobalDtors); AddGlobalDtor(Fn); } /// Emit the code necessary to initialize the given global variable. void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit) { // Check if we need to emit debug info for variable initializer. if (D->hasAttr()) DebugInfo = nullptr; // disable debug info indefinitely for this function StartFunction(GlobalDecl(D), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList(), D->getLocation(), D->getInit()->getExprLoc()); // Use guarded initialization if the global variable is weak. This // occurs for, e.g., instantiated static data members and // definitions explicitly marked weak. if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage()) { EmitCXXGuardedInit(*D, Addr, PerformInit); } else { EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit); } FinishFunction(); } void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef Decls, llvm::GlobalVariable *Guard) { { ArtificialLocation AL(*this, Builder); StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList()); // Emit an artificial location for this function. AL.Emit(); llvm::BasicBlock *ExitBlock = nullptr; if (Guard) { // If we have a guard variable, check whether we've already performed // these initializations. This happens for TLS initialization functions. llvm::Value *GuardVal = Builder.CreateLoad(Guard); llvm::Value *Uninit = Builder.CreateIsNull(GuardVal, "guard.uninitialized"); // Mark as initialized before initializing anything else. If the // initializers use previously-initialized thread_local vars, that's // probably supposed to be OK, but the standard doesn't say. Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard); llvm::BasicBlock *InitBlock = createBasicBlock("init"); ExitBlock = createBasicBlock("exit"); Builder.CreateCondBr(Uninit, InitBlock, ExitBlock); EmitBlock(InitBlock); } RunCleanupsScope Scope(*this); // When building in Objective-C++ ARC mode, create an autorelease pool // around the global initializers. if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) { llvm::Value *token = EmitObjCAutoreleasePoolPush(); EmitObjCAutoreleasePoolCleanup(token); } for (unsigned i = 0, e = Decls.size(); i != e; ++i) if (Decls[i]) EmitRuntimeCall(Decls[i]); Scope.ForceCleanup(); if (ExitBlock) { Builder.CreateBr(ExitBlock); EmitBlock(ExitBlock); } } FinishFunction(); } void CodeGenFunction::GenerateCXXGlobalDtorsFunc(llvm::Function *Fn, const std::vector > &DtorsAndObjects) { { ArtificialLocation AL(*this, Builder); StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList()); // Emit an artificial location for this function. AL.Emit(); // Emit the dtors, in reverse order from construction. for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; llvm::CallInst *CI = Builder.CreateCall(Callee, DtorsAndObjects[e - i - 1].second); // Make sure the call and the callee agree on calling convention. if (llvm::Function *F = dyn_cast(Callee)) CI->setCallingConv(F->getCallingConv()); } } FinishFunction(); } /// generateDestroyHelper - Generates a helper function which, when /// invoked, destroys the given object. llvm::Function *CodeGenFunction::generateDestroyHelper( llvm::Constant *addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD) { FunctionArgList args; ImplicitParamDecl dst(getContext(), nullptr, SourceLocation(), nullptr, getContext().VoidPtrTy); args.push_back(&dst); const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( getContext().VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *fn = CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor"); StartFunction(VD, getContext().VoidTy, fn, FI, args); emitDestroy(addr, type, destroyer, useEHCleanupForArray); FinishFunction(); return fn; } @ 1.1.1.3.4.1 log @file CGDeclCXX.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 519 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 519 //===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with code generation of C++ declarations // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCXXABI.h" #include "CGObjCRuntime.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Intrinsics.h" using namespace clang; using namespace CodeGen; static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *DeclPtr) { assert(D.hasGlobalStorage() && "VarDecl must have global storage!"); assert(!D.getType()->isReferenceType() && "Should not call EmitDeclInit on a reference!"); ASTContext &Context = CGF.getContext(); CharUnits alignment = Context.getDeclAlign(&D); QualType type = D.getType(); LValue lv = CGF.MakeAddrLValue(DeclPtr, type, alignment); const Expr *Init = D.getInit(); switch (CGF.getEvaluationKind(type)) { case TEK_Scalar: { CodeGenModule &CGM = CGF.CGM; if (lv.isObjCStrong()) CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init), DeclPtr, D.getTLSKind()); else if (lv.isObjCWeak()) CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init), DeclPtr); else CGF.EmitScalarInit(Init, &D, lv, false); return; } case TEK_Complex: CGF.EmitComplexExprIntoLValue(Init, lv, /*isInit*/ true); return; case TEK_Aggregate: CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv,AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); return; } llvm_unreachable("bad evaluation kind"); } /// Emit code to cause the destruction of the given variable with /// static storage duration. static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *addr) { CodeGenModule &CGM = CGF.CGM; // FIXME: __attribute__((cleanup)) ? QualType type = D.getType(); QualType::DestructionKind dtorKind = type.isDestructedType(); switch (dtorKind) { case QualType::DK_none: return; case QualType::DK_cxx_destructor: break; case QualType::DK_objc_strong_lifetime: case QualType::DK_objc_weak_lifetime: // We don't care about releasing objects during process teardown. assert(!D.getTLSKind() && "should have rejected this"); return; } llvm::Constant *function; llvm::Constant *argument; // Special-case non-array C++ destructors, where there's a function // with the right signature that we can just call. const CXXRecordDecl *record = 0; if (dtorKind == QualType::DK_cxx_destructor && (record = type->getAsCXXRecordDecl())) { assert(!record->hasTrivialDestructor()); CXXDestructorDecl *dtor = record->getDestructor(); function = CGM.GetAddrOfCXXDestructor(dtor, Dtor_Complete); argument = llvm::ConstantExpr::getBitCast( addr, CGF.getTypes().ConvertType(type)->getPointerTo()); // Otherwise, the standard logic requires a helper function. } else { function = CodeGenFunction(CGM) .generateDestroyHelper(addr, type, CGF.getDestroyer(dtorKind), CGF.needsEHCleanup(dtorKind), &D); argument = llvm::Constant::getNullValue(CGF.Int8PtrTy); } CGM.getCXXABI().registerGlobalDtor(CGF, D, function, argument); } /// Emit code to cause the variable at the given address to be considered as /// constant from this point onwards. static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *Addr) { // Don't emit the intrinsic if we're not optimizing. if (!CGF.CGM.getCodeGenOpts().OptimizationLevel) return; // Grab the llvm.invariant.start intrinsic. llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start; llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID); // Emit a call with the size in bytes of the object. CharUnits WidthChars = CGF.getContext().getTypeSizeInChars(D.getType()); uint64_t Width = WidthChars.getQuantity(); llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width), llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)}; CGF.Builder.CreateCall(InvariantStart, Args); } void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr, bool PerformInit) { const Expr *Init = D.getInit(); QualType T = D.getType(); if (!T->isReferenceType()) { if (PerformInit) EmitDeclInit(*this, D, DeclPtr); if (CGM.isTypeConstant(D.getType(), true)) EmitDeclInvariant(*this, D, DeclPtr); else EmitDeclDestroy(*this, D, DeclPtr); return; } assert(PerformInit && "cannot have constant initializer which needs " "destruction for reference"); unsigned Alignment = getContext().getDeclAlign(&D).getQuantity(); RValue RV = EmitReferenceBindingToExpr(Init); EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T); } static llvm::Function * CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, llvm::FunctionType *ty, const Twine &name, bool TLS = false); /// Create a stub function, suitable for being passed to atexit, /// which passes the given address to the given destructor function. static llvm::Constant *createAtExitStub(CodeGenModule &CGM, const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { // Get the destructor function type, void(*)(void). llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false); SmallString<256> FnName; { llvm::raw_svector_ostream Out(FnName); CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out); } llvm::Function *fn = CreateGlobalInitOrDestructFunction(CGM, ty, FnName.str()); CodeGenFunction CGF(CGM); CGF.StartFunction(&VD, CGM.getContext().VoidTy, fn, CGM.getTypes().arrangeNullaryFunction(), FunctionArgList(), SourceLocation()); llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr); // Make sure the call and the callee agree on calling convention. if (llvm::Function *dtorFn = dyn_cast(dtor->stripPointerCasts())) call->setCallingConv(dtorFn->getCallingConv()); CGF.FinishFunction(); return fn; } /// Register a global destructor using the C atexit runtime function. void CodeGenFunction::registerGlobalDtorWithAtExit(const VarDecl &VD, llvm::Constant *dtor, llvm::Constant *addr) { // Create a function which calls the destructor. llvm::Constant *dtorStub = createAtExitStub(CGM, VD, dtor, addr); // extern "C" int atexit(void (*f)(void)); llvm::FunctionType *atexitTy = llvm::FunctionType::get(IntTy, dtorStub->getType(), false); llvm::Constant *atexit = CGM.CreateRuntimeFunction(atexitTy, "atexit"); if (llvm::Function *atexitFn = dyn_cast(atexit)) atexitFn->setDoesNotThrow(); EmitNounwindRuntimeCall(atexit, dtorStub); } void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit) { // If we've been asked to forbid guard variables, emit an error now. // This diagnostic is hard-coded for Darwin's use case; we can find // better phrasing if someone else needs it. if (CGM.getCodeGenOpts().ForbidGuardVariables) CGM.Error(D.getLocation(), "this initialization requires a guard variable, which " "the kernel does not support"); CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit); } static llvm::Function * CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, llvm::FunctionType *FTy, const Twine &Name, bool TLS) { llvm::Function *Fn = llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage, Name, &CGM.getModule()); if (!CGM.getLangOpts().AppleKext && !TLS) { // Set the section if needed. if (const char *Section = CGM.getTarget().getStaticInitSectionSpecifier()) Fn->setSection(Section); } Fn->setCallingConv(CGM.getRuntimeCC()); if (!CGM.getLangOpts().Exceptions) Fn->setDoesNotThrow(); if (CGM.getSanOpts().Address) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (CGM.getSanOpts().Thread) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (CGM.getSanOpts().Memory) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); return Fn; } void CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit) { llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); SmallString<256> FnName; { llvm::raw_svector_ostream Out(FnName); getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out); } // Create a variable initialization function. llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, FnName.str()); CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr, PerformInit); if (D->getTLSKind()) { // FIXME: Should we support init_priority for thread_local? // FIXME: Ideally, initialization of instantiated thread_local static data // members of class templates should not trigger initialization of other // entities in the TU. // FIXME: We only need to register one __cxa_thread_atexit function for the // entire TU. CXXThreadLocalInits.push_back(Fn); } else if (const InitPriorityAttr *IPA = D->getAttr()) { OrderGlobalInits Key(IPA->getPriority(), PrioritizedCXXGlobalInits.size()); PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn)); DelayedCXXInitPosition.erase(D); } else if (D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization && D->getTemplateSpecializationKind() != TSK_Undeclared) { // C++ [basic.start.init]p2: // Definitions of explicitly specialized class template static data // members have ordered initialization. Other class template static data // members (i.e., implicitly or explicitly instantiated specializations) // have unordered initialization. // // As a consequence, we can put them into their own llvm.global_ctors entry. // This should allow GlobalOpt to fire more often, and allow us to implement // the Microsoft C++ ABI, which uses COMDAT elimination to avoid double // initializaiton. AddGlobalCtor(Fn); DelayedCXXInitPosition.erase(D); } else { llvm::DenseMap::iterator I = DelayedCXXInitPosition.find(D); if (I == DelayedCXXInitPosition.end()) { CXXGlobalInits.push_back(Fn); } else { assert(CXXGlobalInits[I->second] == 0); CXXGlobalInits[I->second] = Fn; DelayedCXXInitPosition.erase(I); } } } void CodeGenModule::EmitCXXThreadLocalInitFunc() { llvm::Function *InitFn = 0; if (!CXXThreadLocalInits.empty()) { // Generate a guarded initialization function. llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); InitFn = CreateGlobalInitOrDestructFunction(*this, FTy, "__tls_init", /*TLS*/ true); llvm::GlobalVariable *Guard = new llvm::GlobalVariable( getModule(), Int8Ty, false, llvm::GlobalVariable::InternalLinkage, llvm::ConstantInt::get(Int8Ty, 0), "__tls_guard"); Guard->setThreadLocal(true); CodeGenFunction(*this) .GenerateCXXGlobalInitFunc(InitFn, CXXThreadLocalInits, Guard); } getCXXABI().EmitThreadLocalInitFuncs(CXXThreadLocals, InitFn); CXXThreadLocalInits.clear(); CXXThreadLocals.clear(); } void CodeGenModule::EmitCXXGlobalInitFunc() { while (!CXXGlobalInits.empty() && !CXXGlobalInits.back()) CXXGlobalInits.pop_back(); if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty()) return; llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); // Create our global initialization function. if (!PrioritizedCXXGlobalInits.empty()) { SmallVector LocalCXXGlobalInits; llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(), PrioritizedCXXGlobalInits.end()); // Iterate over "chunks" of ctors with same priority and emit each chunk // into separate function. Note - everything is sorted first by priority, // second - by lex order, so we emit ctor functions in proper order. for (SmallVectorImpl::iterator I = PrioritizedCXXGlobalInits.begin(), E = PrioritizedCXXGlobalInits.end(); I != E; ) { SmallVectorImpl::iterator PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp()); LocalCXXGlobalInits.clear(); unsigned Priority = I->first.priority; // Compute the function suffix from priority. Prepend with zeroes to make // sure the function names are also ordered as priorities. std::string PrioritySuffix = llvm::utostr(Priority); // Priority is always <= 65535 (enforced by sema).. PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix; llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_" + PrioritySuffix); for (; I < PrioE; ++I) LocalCXXGlobalInits.push_back(I->second); CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits); AddGlobalCtor(Fn, Priority); } } llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a"); CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits); AddGlobalCtor(Fn); CXXGlobalInits.clear(); PrioritizedCXXGlobalInits.clear(); } void CodeGenModule::EmitCXXGlobalDtorFunc() { if (CXXGlobalDtors.empty()) return; llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); // Create our global destructor function. llvm::Function *Fn = CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a"); CodeGenFunction(*this).GenerateCXXGlobalDtorsFunc(Fn, CXXGlobalDtors); AddGlobalDtor(Fn); } /// Emit the code necessary to initialize the given global variable. void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit) { // Check if we need to emit debug info for variable initializer. if (D->hasAttr()) DebugInfo = NULL; // disable debug info indefinitely for this function StartFunction(GlobalDecl(D), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList(), D->getInit()->getExprLoc()); // Use guarded initialization if the global variable is weak. This // occurs for, e.g., instantiated static data members and // definitions explicitly marked weak. if (Addr->getLinkage() == llvm::GlobalValue::WeakODRLinkage || Addr->getLinkage() == llvm::GlobalValue::WeakAnyLinkage) { EmitCXXGuardedInit(*D, Addr, PerformInit); } else { EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit); } FinishFunction(); } void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef Decls, llvm::GlobalVariable *Guard) { StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList(), SourceLocation()); llvm::BasicBlock *ExitBlock = 0; if (Guard) { // If we have a guard variable, check whether we've already performed these // initializations. This happens for TLS initialization functions. llvm::Value *GuardVal = Builder.CreateLoad(Guard); llvm::Value *Uninit = Builder.CreateIsNull(GuardVal, "guard.uninitialized"); // Mark as initialized before initializing anything else. If the // initializers use previously-initialized thread_local vars, that's // probably supposed to be OK, but the standard doesn't say. Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(), 1), Guard); llvm::BasicBlock *InitBlock = createBasicBlock("init"); ExitBlock = createBasicBlock("exit"); Builder.CreateCondBr(Uninit, InitBlock, ExitBlock); EmitBlock(InitBlock); } RunCleanupsScope Scope(*this); // When building in Objective-C++ ARC mode, create an autorelease pool // around the global initializers. if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) { llvm::Value *token = EmitObjCAutoreleasePoolPush(); EmitObjCAutoreleasePoolCleanup(token); } for (unsigned i = 0, e = Decls.size(); i != e; ++i) if (Decls[i]) EmitRuntimeCall(Decls[i]); Scope.ForceCleanup(); if (ExitBlock) { Builder.CreateBr(ExitBlock); EmitBlock(ExitBlock); } FinishFunction(); } void CodeGenFunction::GenerateCXXGlobalDtorsFunc(llvm::Function *Fn, const std::vector > &DtorsAndObjects) { StartFunction(GlobalDecl(), getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(), FunctionArgList(), SourceLocation()); // Emit the dtors, in reverse order from construction. for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; llvm::CallInst *CI = Builder.CreateCall(Callee, DtorsAndObjects[e - i - 1].second); // Make sure the call and the callee agree on calling convention. if (llvm::Function *F = dyn_cast(Callee)) CI->setCallingConv(F->getCallingConv()); } FinishFunction(); } /// generateDestroyHelper - Generates a helper function which, when /// invoked, destroys the given object. llvm::Function *CodeGenFunction::generateDestroyHelper( llvm::Constant *addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD) { FunctionArgList args; ImplicitParamDecl dst(0, SourceLocation(), 0, getContext().VoidPtrTy); args.push_back(&dst); const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( getContext().VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *fn = CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor"); StartFunction(VD, getContext().VoidTy, fn, FI, args, SourceLocation()); emitDestroy(addr, type, destroyer, useEHCleanupForArray); FinishFunction(); return fn; } @