Index: lib/CodeGen/CodeGenModule.h =================================================================== --- lib/CodeGen/CodeGenModule.h +++ lib/CodeGen/CodeGenModule.h @@ -700,7 +700,8 @@ /// with the specified type instead of whatever the normal requested type /// would be. llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D, - llvm::Type *Ty = nullptr); + llvm::Type *Ty = nullptr, + bool IsForDefinition = false); /// Return the address of the given function. If Ty is non-null, then this /// function will use the specified type if it has to create it. @@ -1135,7 +1136,8 @@ llvm::Constant *GetOrCreateLLVMGlobal(StringRef MangledName, llvm::PointerType *PTy, - const VarDecl *D); + const VarDecl *D, + bool IsForDefinition = false); void setNonAliasAttributes(const Decl *D, llvm::GlobalObject *GO); @@ -1146,7 +1148,7 @@ void EmitGlobalDefinition(GlobalDecl D, llvm::GlobalValue *GV = nullptr); void EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV); - void EmitGlobalVarDefinition(const VarDecl *D); + void EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative = false); void EmitAliasDefinition(GlobalDecl GD); void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D); void EmitObjCIvarInitializations(ObjCImplementationDecl *D); Index: lib/CodeGen/CodeGenModule.cpp =================================================================== --- lib/CodeGen/CodeGenModule.cpp +++ lib/CodeGen/CodeGenModule.cpp @@ -1226,19 +1226,14 @@ for (DeferredGlobal &G : CurDeclsToEmit) { GlobalDecl D = G.GD; - llvm::GlobalValue *GV = G.GV; G.GV = nullptr; // We should call GetAddrOfGlobal with IsForDefinition set to true in order // to get GlobalValue with exactly the type we need, not something that // might had been created for another decl with the same mangled name but // different type. - // FIXME: Support for variables is not implemented yet. - if (isa(D.getDecl())) - GV = cast(GetAddrOfGlobal(D, /*IsForDefinition=*/true)); - else - if (!GV) - GV = GetGlobalValue(getMangledName(D)); + llvm::GlobalValue *GV = + cast(GetAddrOfGlobal(D, /*IsForDefinition=*/true)); // Check to see if we've already emitted this. This is necessary // for a couple of reasons: first, decls can end up in the @@ -1246,7 +1241,7 @@ // up with definitions in unusual ways (e.g. by an extern inline // function acquiring a strong function redefinition). Just // ignore these cases. - if (GV && !GV->isDeclaration()) + if (!GV->isDeclaration()) continue; // Otherwise, emit the definition and move on to the next one. @@ -1707,7 +1702,7 @@ } if (const auto *VD = dyn_cast(D)) - return EmitGlobalVarDefinition(VD); + return EmitGlobalVarDefinition(VD, !VD->hasDefinition()); llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); } @@ -1748,8 +1743,8 @@ // error. if (IsForDefinition && !Entry->isDeclaration()) { GlobalDecl OtherGD; - // Check that GD is not yet in ExplicitDefinitions is required to make - // sure that we issue an error only once. + // Check that GD is not yet in DiagnosedConflictingDefinitions is required + // to make sure that we issue an error only once. if (lookupRepresentativeDecl(MangledName, OtherGD) && (GD.getCanonicalDecl().getDecl() != OtherGD.getCanonicalDecl().getDecl()) && @@ -1962,7 +1957,8 @@ llvm::Constant * CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::PointerType *Ty, - const VarDecl *D) { + const VarDecl *D, + bool IsForDefinition) { // Lookup the entry, lazily creating it if necessary. llvm::GlobalValue *Entry = GetGlobalValue(MangledName); if (Entry) { @@ -1978,11 +1974,35 @@ if (Entry->getType() == Ty) return Entry; + // If there are two attempts to define the same mangled name, issue an + // error. + if (IsForDefinition && !Entry->isDeclaration()) { + GlobalDecl OtherGD; + const VarDecl *OtherD; + + // Check that D is not yet in DiagnosedConflictingDefinitions is required + // to make sure that we issue an error only once. + if (lookupRepresentativeDecl(MangledName, OtherGD) && + (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) && + (OtherD = dyn_cast(OtherGD.getDecl())) && + OtherD->hasInit() && + DiagnosedConflictingDefinitions.insert(D).second) { + getDiags().Report(D->getLocation(), + diag::err_duplicate_mangled_name); + getDiags().Report(OtherGD.getDecl()->getLocation(), + diag::note_previous_definition); + } + } + // Make sure the result is of the correct type. if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace()) return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty); - return llvm::ConstantExpr::getBitCast(Entry, Ty); + // Make sure the result is of the correct type. + // (If global is requested for a definition, we always need to create a new + // global, not just return a bitcast.) + if (!IsForDefinition) + return llvm::ConstantExpr::getBitCast(Entry, Ty); } unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); @@ -1991,6 +2011,20 @@ llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace); + // If we already created a global with the same mangled name (but different + // type) before, take its name and remove it from its parent. + if (Entry) { + GV->takeName(Entry); + + if (!Entry->use_empty()) { + llvm::Constant *NewPtrForOldDecl = + llvm::ConstantExpr::getBitCast(GV, Entry->getType()); + Entry->replaceAllUsesWith(NewPtrForOldDecl); + } + + Entry->eraseFromParent(); + } + // This is the first use or definition of a mangled name. If there is a // deferred decl with this name, remember that we need to emit it at the end // of the file. @@ -2063,7 +2097,8 @@ return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false, IsForDefinition); } else - return GetAddrOfGlobalVar(cast(GD.getDecl())); + return GetAddrOfGlobalVar(cast(GD.getDecl()), /*Ty=*/nullptr, + IsForDefinition); } llvm::GlobalVariable * @@ -2113,7 +2148,8 @@ /// then it will be created with the specified type instead of whatever the /// normal requested type would be. llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, - llvm::Type *Ty) { + llvm::Type *Ty, + bool IsForDefinition) { assert(D->hasGlobalStorage() && "Not a global variable"); QualType ASTTy = D->getType(); if (!Ty) @@ -2123,7 +2159,7 @@ llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy)); StringRef MangledName = getMangledName(D); - return GetOrCreateLLVMGlobal(MangledName, PTy, D); + return GetOrCreateLLVMGlobal(MangledName, PTy, D, IsForDefinition); } /// CreateRuntimeVariable - Create a new runtime global variable with the @@ -2137,17 +2173,25 @@ void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { assert(!D->getInit() && "Cannot emit definite definitions here!"); + StringRef MangledName = getMangledName(D); + llvm::GlobalValue *GV = GetGlobalValue(MangledName); + if (!MustBeEmitted(D)) { // If we have not seen a reference to this variable yet, place it // into the deferred declarations table to be emitted if needed // later. - StringRef MangledName = getMangledName(D); - if (!GetGlobalValue(MangledName)) { + if (!GV) { DeferredDecls[MangledName] = D; return; } } + // We already have a definition, not declaration, with the same mangled name. + // Emitting of declaration is not required (and actually overwrites emitted + // definition). + if (GV && !GV->isDeclaration()) + return; + // The tentative definition is the only definition. EmitGlobalVarDefinition(D); } @@ -2236,7 +2280,8 @@ GO.setComdat(TheModule.getOrInsertComdat(GO.getName())); } -void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { +void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D, + bool IsTentative) { llvm::Constant *Init = nullptr; QualType ASTTy = D->getType(); CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); @@ -2295,7 +2340,8 @@ } llvm::Type* InitType = Init->getType(); - llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); + llvm::Constant *Entry = + GetAddrOfGlobalVar(D, InitType, /*IsForDefinition=*/!IsTentative); // Strip off a bitcast if we got one back. if (auto *CE = dyn_cast(Entry)) { @@ -2327,7 +2373,8 @@ Entry->setName(StringRef()); // Make a new global with the correct type, this is now guaranteed to work. - GV = cast(GetAddrOfGlobalVar(D, InitType)); + GV = cast( + GetAddrOfGlobalVar(D, InitType, /*IsForDefinition=*/!IsTentative)); // Replace all uses of the old global with the new global llvm::Constant *NewPtrForOldDecl = Index: test/CodeGenCXX/duplicate-mangled-name.cpp =================================================================== --- test/CodeGenCXX/duplicate-mangled-name.cpp +++ test/CodeGenCXX/duplicate-mangled-name.cpp @@ -1,5 +1,7 @@ // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s -verify -DTEST1 -// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s -verify -DTEST2 +// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s -verify -DTEST2 -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s -verify -DTEST3 +// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only %s -verify -DTEST4 #ifdef TEST1 @@ -14,28 +16,61 @@ #elif TEST2 -// We expect no warnings here, as there is only declaration of _ZN1TD1Ev function, no definitions. +// expected-no-diagnostics + +// We expect no warnings here, as there is only declaration of _ZN1TD1Ev +// function, no definitions. extern "C" void _ZN1TD1Ev(); struct T { ~T() {} }; -void foo() { +// We expect no warnings here, as there is only declaration of _ZN2nm3abcE +// global, no definitions. +extern "C" { + int _ZN2nm3abcE; +} + +namespace nm { + float abc = 2; +} +// CHECK: @_ZN2nm3abcE = global float + +float foo() { _ZN1TD1Ev(); +// CHECK: call void bitcast (void (%struct.T*)* @_ZN1TD1Ev to void ()*)() T t; +// CHECK: call void @_ZN1TD1Ev(%struct.T* %t) + return _ZN2nm3abcE + nm::abc; } +#elif TEST3 + extern "C" void _ZN2T2D2Ev() {}; // expected-note {{previous definition is here}} struct T2 { ~T2() {} // expected-error {{definition with same mangled name as another definition}} }; -void bar() { +void foo() { _ZN2T2D2Ev(); T2 t; } +#elif TEST4 + +extern "C" { + int _ZN2nm3abcE = 1; // expected-note {{previous definition is here}} +} + +namespace nm { + float abc = 2; // expected-error {{definition with same mangled name as another definition}} +} + +float foo() { + return _ZN2nm3abcE + nm::abc; +} + #else #error Unknwon test