Index: lib/CodeGen/CGDecl.cpp =================================================================== --- lib/CodeGen/CGDecl.cpp +++ lib/CodeGen/CGDecl.cpp @@ -146,58 +146,79 @@ return EmitAutoVarDecl(D); } -static std::string GetStaticDeclName(CodeGenFunction &CGF, const VarDecl &D) { - CodeGenModule &CGM = CGF.CGM; - - if (CGF.getLangOpts().CPlusPlus) +static std::string getStaticDeclName(CodeGenModule &CGM, const VarDecl &D) { + if (CGM.getLangOpts().CPlusPlus) return CGM.getMangledName(&D).str(); - StringRef ContextName; - if (!CGF.CurFuncDecl) { - // Better be in a block declared in global scope. - const NamedDecl *ND = cast(&D); - const DeclContext *DC = ND->getDeclContext(); - if (const BlockDecl *BD = dyn_cast(DC)) - ContextName = CGM.getBlockMangledName(GlobalDecl(), BD); - else - llvm_unreachable("Unknown context for block static var decl"); - } else if (const FunctionDecl *FD = dyn_cast(CGF.CurFuncDecl)) + // If this isn't C++, we don't need a mangled name, just a pretty one. + assert(!D.isExternallyVisible() && "name shouldn't matter"); + std::string ContextName; + const DeclContext *DC = D.getDeclContext(); + if (const auto *FD = dyn_cast(DC)) ContextName = CGM.getMangledName(FD); - else if (isa(CGF.CurFuncDecl)) - ContextName = CGF.CurFn->getName(); + else if (const auto *BD = dyn_cast(DC)) + ContextName = CGM.getBlockMangledName(GlobalDecl(), BD); + else if (const auto *OMD = dyn_cast(DC)) + ContextName = OMD->getSelector().getAsString(); else llvm_unreachable("Unknown context for static var decl"); - return ContextName.str() + "." + D.getNameAsString(); + ContextName += "." + D.getNameAsString(); + return ContextName; +} + +static llvm::Constant *adjustAddrSpaceAndUpdateMap(CodeGenModule &CGM, + const VarDecl &D, + unsigned AddrSpace, + unsigned ExpectedAddrSpace, + llvm::Constant *Addr) { + // Insert an address space cast if we're placing this global into an address + // space other than the one expected by the type system. + if (AddrSpace != ExpectedAddrSpace) { + auto *OldPTy = cast(Addr->getType()); + auto *PTy = + llvm::PointerType::get(OldPTy->getElementType(), ExpectedAddrSpace); + Addr = llvm::ConstantExpr::getAddrSpaceCast(Addr, PTy); + } + + // Update the static local decl map before we try to emit the initializer in + // case there is a circular reference to this decl. + CGM.setStaticLocalDeclAddress(&D, Addr); + + return Addr; } -llvm::Constant * -CodeGenFunction::CreateStaticVarDecl(const VarDecl &D, - llvm::GlobalValue::LinkageTypes Linkage) { +llvm::Constant *CodeGenModule::getOrCreateStaticVarDecl( + const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage) { + // In general, we don't always emit static var decls once before we reference + // them. It is possible to reference them before emitting the function that + // contains them, and it is possible to emit the containing function multiple + // times. + if (llvm::Constant *ExistingGV = StaticLocalDeclMap[&D]) + return ExistingGV; + QualType Ty = D.getType(); assert(Ty->isConstantSizeType() && "VLAs can't be static"); // Use the label if the variable is renamed with the asm-label extension. std::string Name; if (D.hasAttr()) - Name = CGM.getMangledName(&D); + Name = getMangledName(&D); else - Name = GetStaticDeclName(*this, D); + Name = getStaticDeclName(*this, D); - llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(Ty); - unsigned AddrSpace = - CGM.GetGlobalVarAddressSpace(&D, CGM.getContext().getTargetAddressSpace(Ty)); + llvm::Type *LTy = getTypes().ConvertTypeForMem(Ty); + unsigned ExpectedAddrSpace = getContext().getTargetAddressSpace(Ty); + unsigned AddrSpace = GetGlobalVarAddressSpace(&D, ExpectedAddrSpace); llvm::GlobalVariable *GV = - new llvm::GlobalVariable(CGM.getModule(), LTy, - Ty.isConstant(getContext()), Linkage, - CGM.EmitNullConstant(D.getType()), Name, nullptr, - llvm::GlobalVariable::NotThreadLocal, - AddrSpace); + new llvm::GlobalVariable(getModule(), LTy, Ty.isConstant(getContext()), + Linkage, EmitNullConstant(Ty), Name, nullptr, + llvm::GlobalVariable::NotThreadLocal, AddrSpace); GV->setAlignment(getContext().getDeclAlign(&D).getQuantity()); - CGM.setGlobalVisibility(GV, &D); + setGlobalVisibility(GV, &D); if (D.getTLSKind()) - CGM.setTLSMode(GV, D); + setTLSMode(GV, D); if (D.isExternallyVisible()) { if (D.hasAttr()) @@ -206,14 +227,53 @@ GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass); } - // Make sure the result is of the correct type. - unsigned ExpectedAddrSpace = CGM.getContext().getTargetAddressSpace(Ty); - if (AddrSpace != ExpectedAddrSpace) { - llvm::PointerType *PTy = llvm::PointerType::get(LTy, ExpectedAddrSpace); - return llvm::ConstantExpr::getAddrSpaceCast(GV, PTy); + llvm::Constant *Addr = + adjustAddrSpaceAndUpdateMap(*this, D, AddrSpace, ExpectedAddrSpace, GV); + + // If there is an initializer, try to emit it as a constant. If it's not + // constant, leave the zero initializer so that var decl emission can + // overwrite it at runtime. + llvm::Constant *Init = nullptr; + if (D.getInit()) + Init = EmitConstantInit(D); + + if (Init) { + // The initializer may differ in type from the global. Rewrite + // the global to match the initializer. (We have to do this + // because some types, like unions, can't be completely represented + // in the LLVM type system.) + if (GV->getType()->getElementType() != Init->getType()) { + llvm::GlobalVariable *OldGV = GV; + + GV = new llvm::GlobalVariable( + getModule(), Init->getType(), OldGV->isConstant(), + OldGV->getLinkage(), Init, "", + /*InsertBefore*/ OldGV, OldGV->getThreadLocalMode(), + ExpectedAddrSpace); + GV->copyAttributesFrom(OldGV); + + // Steal the name of the old global + GV->takeName(OldGV); + + // Replace all uses of the old global with the new global + llvm::Constant *NewPtrForOldDecl = + llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); + OldGV->replaceAllUsesWith(NewPtrForOldDecl); + + // We also have to change the value in the map and redo the address space + // casting, now that we've replaced the value. + Addr = adjustAddrSpaceAndUpdateMap(*this, D, AddrSpace, ExpectedAddrSpace, + NewPtrForOldDecl); + + // Erase the old global, since it is no longer used. + OldGV->eraseFromParent(); + } + + GV->setConstant(isTypeConstant(Ty, true)); + GV->setInitializer(Init); } - return GV; + return Addr; } /// hasNontrivialDestruction - Determine whether a type's destruction is @@ -224,13 +284,9 @@ return RD && !RD->hasTrivialDestructor(); } -/// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the -/// global variable that has already been created for it. If the initializer -/// has a different type than GV does, this may free GV and return a different -/// one. Otherwise it just returns GV. -llvm::GlobalVariable * -CodeGenFunction::AddInitializerToStaticVarDecl(const VarDecl &D, - llvm::GlobalVariable *GV) { +void +CodeGenFunction::EmitInitializerForStaticVarDecl(const VarDecl &D, + llvm::GlobalVariable *GV) { llvm::Constant *Init = CGM.EmitConstantInit(D, this); // If constant emission failed, then this should be a C++ static @@ -245,38 +301,16 @@ EmitCXXGuardedInit(D, GV, /*PerformInit*/true); } - return GV; - } - - // The initializer may differ in type from the global. Rewrite - // the global to match the initializer. (We have to do this - // because some types, like unions, can't be completely represented - // in the LLVM type system.) - if (GV->getType()->getElementType() != Init->getType()) { - llvm::GlobalVariable *OldGV = GV; - - GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), - OldGV->isConstant(), - OldGV->getLinkage(), Init, "", - /*InsertBefore*/ OldGV, - OldGV->getThreadLocalMode(), - CGM.getContext().getTargetAddressSpace(D.getType())); - GV->setVisibility(OldGV->getVisibility()); - - // Steal the name of the old global - GV->takeName(OldGV); - - // Replace all uses of the old global with the new global - llvm::Constant *NewPtrForOldDecl = - llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); - OldGV->replaceAllUsesWith(NewPtrForOldDecl); - - // Erase the old global, since it is no longer used. - OldGV->eraseFromParent(); + return; } - GV->setConstant(CGM.isTypeConstant(D.getType(), true)); - GV->setInitializer(Init); + // Constant evaluation might fail when referencing the static local from some + // other scope and succeed when we enter the context of the function. If so, + // update the initializer. + assert(GV->getType()->getElementType() == Init->getType() && + "static var initializer has incorrect type"); + if (GV->getInitializer() != Init) + GV->setInitializer(Init); if (hasNontrivialDestruction(D.getType())) { // We have a constant initializer, but a nontrivial destructor. We still @@ -284,23 +318,15 @@ // destructor. EmitCXXGuardedInit(D, GV, /*PerformInit*/false); } - - return GV; } -void CodeGenFunction::EmitStaticVarDecl(const VarDecl &D, - llvm::GlobalValue::LinkageTypes Linkage) { +void +CodeGenFunction::EmitStaticVarDecl(const VarDecl &D, + llvm::GlobalValue::LinkageTypes Linkage) { llvm::Value *&DMEntry = LocalDeclMap[&D]; assert(!DMEntry && "Decl already exists in localdeclmap!"); - // Check to see if we already have a global variable for this - // declaration. This can happen when double-emitting function - // bodies, e.g. with complete and base constructors. - llvm::Constant *addr = - CGM.getStaticLocalDeclAddress(&D); - - if (!addr) - addr = CreateStaticVarDecl(D, Linkage); + llvm::Constant *addr = CGM.getOrCreateStaticVarDecl(D, Linkage); // Store into LocalDeclMap before generating initializer to handle // circular references. @@ -320,7 +346,7 @@ cast(addr->stripPointerCasts()); // If this value has an initializer, emit it. if (D.getInit()) - var = AddInitializerToStaticVarDecl(D, var); + EmitInitializerForStaticVarDecl(D, var); var->setAlignment(getContext().getDeclAlign(&D).getQuantity()); @@ -1127,7 +1153,7 @@ } else { // Otherwise, create a temporary global with the initializer then // memcpy from the global to the alloca. - std::string Name = GetStaticDeclName(*this, D); + std::string Name = getStaticDeclName(CGM, D); llvm::GlobalVariable *GV = new llvm::GlobalVariable(CGM.getModule(), constant->getType(), true, llvm::GlobalValue::PrivateLinkage, Index: lib/CodeGen/CGExpr.cpp =================================================================== --- lib/CodeGen/CGExpr.cpp +++ lib/CodeGen/CGExpr.cpp @@ -1924,7 +1924,8 @@ llvm::Value *V = LocalDeclMap.lookup(VD); if (!V && VD->isStaticLocal()) - V = CGM.getStaticLocalDeclAddress(VD); + V = CGM.getOrCreateStaticVarDecl( + *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false)); // Use special handling for lambdas. if (!V) { Index: lib/CodeGen/CGExprConstant.cpp =================================================================== --- lib/CodeGen/CGExprConstant.cpp +++ lib/CodeGen/CGExprConstant.cpp @@ -868,8 +868,10 @@ if (!VD->hasLocalStorage()) { if (VD->isFileVarDecl() || VD->hasExternalStorage()) return CGM.GetAddrOfGlobalVar(VD); - else if (VD->isLocalVarDecl()) - return CGM.getStaticLocalDeclAddress(VD); + else if (VD->isLocalVarDecl()) { + return CGM.getOrCreateStaticVarDecl( + *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false)); + } } } return nullptr; @@ -916,7 +918,8 @@ return CGM.GetAddrOfConstantCString("", ".tmp"); } case Expr::AddrLabelExprClass: { - assert(CGF && "Invalid address of label expression outside function."); + if (!CGF) + return llvm::Constant::getNullValue(ConvertType(E->getType())); llvm::Constant *Ptr = CGF->GetAddrOfLabel(cast(E)->getLabel()); return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType())); Index: lib/CodeGen/CodeGenFunction.h =================================================================== --- lib/CodeGen/CodeGenFunction.h +++ lib/CodeGen/CodeGenFunction.h @@ -2426,19 +2426,10 @@ /// EmitLoadOfComplex - Load a complex number from the specified l-value. ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc); - /// CreateStaticVarDecl - Create a zero-initialized LLVM global for - /// a static local variable. - llvm::Constant *CreateStaticVarDecl(const VarDecl &D, - llvm::GlobalValue::LinkageTypes Linkage); - - /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the - /// global variable that has already been created for it. If the initializer - /// has a different type than GV does, this may free GV and return a different - /// one. Otherwise it just returns GV. - llvm::GlobalVariable * - AddInitializerToStaticVarDecl(const VarDecl &D, - llvm::GlobalVariable *GV); - + /// EmitInitializerForStaticVarDecl - Emits an initializer for 'D' into the + /// global variable that has already been created for it. + void EmitInitializerForStaticVarDecl(const VarDecl &D, + llvm::GlobalVariable *GV); /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++ /// variable with global storage. Index: lib/CodeGen/CodeGenModule.h =================================================================== --- lib/CodeGen/CodeGenModule.h +++ lib/CodeGen/CodeGenModule.h @@ -540,9 +540,13 @@ return CoverageMapping.get(); } - llvm::Constant *getStaticLocalDeclAddress(const VarDecl *D) { - return StaticLocalDeclMap[D]; - } + /// CreateStaticVarDecl - Get or create an LLVM global for a static local + /// variable. Constant variables will be initialized, and non-constant + /// variables will be zero-initialized. + llvm::Constant * + getOrCreateStaticVarDecl(const VarDecl &D, + llvm::GlobalValue::LinkageTypes Linkage); + void setStaticLocalDeclAddress(const VarDecl *D, llvm::Constant *C) { StaticLocalDeclMap[D] = C; Index: test/CodeGenCXX/static-local-in-local-class.cpp =================================================================== --- test/CodeGenCXX/static-local-in-local-class.cpp +++ test/CodeGenCXX/static-local-in-local-class.cpp @@ -1,6 +1,12 @@ -// RUN: %clang_cc1 -emit-llvm -o %t %s -// PR6769 +// RUN: %clang_cc1 -triple x86_64-linux -emit-llvm -o - %s -std=c++1y | FileCheck %s + +// CHECK: @_ZZL14deduced_returnvE1n = internal global i32 0 +// CHECK: @"_ZZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEvE2l2" = +// CHECK: internal global i32* @"_ZZNK17pr18020_constexpr3$_1clEvE2l1" + + +namespace pr6769 { struct X { static void f(); }; @@ -19,8 +25,9 @@ } (void)i; } +} -// pr7101 +namespace pr7101 { void foo() { static int n = 0; struct Helper { @@ -30,4 +37,77 @@ }; Helper::Execute(); } +} + +// These tests all break the assumption that the static var decl has to be +// emitted before use of the var decl. This happens because we defer emission +// of variables with internal linkage and no initialization side effects, such +// as 'x'. Then we hit operator()() in 'f', and emit the callee before we emit +// the arguments, so we emit the innermost function first. + +namespace pr18020_lambda { +// Referring to l1 before emitting it used to crash. +auto x = []() { + static int l1 = 0; + return [] { return l1; }; +}; +int f() { return x()(); } +} + +// CHECK-LABEL: define internal i32 @"_ZZNK14pr18020_lambda3$_0clEvENKUlvE_clEv" +// CHECK: load i32* @"_ZZNK14pr18020_lambda3$_0clEvE2l1" + +namespace pr18020_constexpr { +// Taking the address of l1 in a constant expression used to crash. +auto x = []() { + static int l1 = 0; + return [] { + static int *l2 = &l1; + return *l2; + }; +}; +int f() { return x()(); } +} + +// CHECK-LABEL: define internal i32 @"_ZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEv" +// CHECK: load i32** @"_ZZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEvE2l2" + +// Lambda-less reduction that references l1 before emitting it. This didn't +// crash if you put it in a namespace. +struct pr18020_class { + auto operator()() { + static int l1 = 0; + struct U { + int operator()() { return l1; } + }; + return U(); + } +}; +static pr18020_class x; +int pr18020_f() { return x()(); } + +// CHECK-LABEL: define linkonce_odr i32 @_ZZN13pr18020_classclEvEN1UclEv +// CHECK: load i32* @_ZZN13pr18020_classclEvE2l1 + +// In this test case, the function containing the static local will not be +// emitted because it is unneeded. However, the operator call of the inner class +// is called, and the static local is referenced and must be emitted. +static auto deduced_return() { + static int n; + struct S { int &operator()() { return n; } }; + return S(); +} + +extern "C" int call_deduced_return_operator() { + return decltype(deduced_return())()(); +} + +// CHECK-LABEL: define i32 @call_deduced_return_operator() +// CHECK: call dereferenceable(4) i32* @_ZZL14deduced_returnvEN1SclEv(%struct.S* %tmp) +// CHECK: load i32* % +// CHECK: ret i32 % + +// CHECK-LABEL: define internal dereferenceable(4) i32* @_ZZL14deduced_returnvEN1SclEv(%struct.S* %this) +// CHECK: ret i32* @_ZZL14deduced_returnvE1n +// FIXME: Surely we can exercise this edge case in C with -fblocks. Index: test/CodeGenObjC/local-static-block.m =================================================================== --- test/CodeGenObjC/local-static-block.m +++ test/CodeGenObjC/local-static-block.m @@ -53,5 +53,5 @@ } // CHECK-LP64: @ArrayRecurs = internal global // CHECK-LP64: @FUNC.ArrayRecurs = internal global -// CHECK-LP64: @FUNC.ArrayRecurs3 = internal global +// CHECK-LP64: @FUNC.ArrayRecurs6 = internal global // CHECK-LP64: @FUNC1.ArrayRecurs = internal global