From: Chandler Carruth Date: Sun, 2 Nov 2014 09:10:31 +0000 (+0000) Subject: Revert r221014: "Refactor duplicated code in liking GlobalValues." X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=e82f41785f062ceef716279d60e3afd2156859a8 Revert r221014: "Refactor duplicated code in liking GlobalValues." This commit introduces heap-use-after-free detected by ASan. Here is the output for one of several tests that detect it: ******************** TEST 'LLVM :: Linker/AppendingLinkage.ll' FAILED ******************** Command Output (stderr): -- ================================================================= ==2122==ERROR: AddressSanitizer: heap-use-after-free on address 0x60c00000b9c8 at pc 0x0000005d05d1 bp 0x7fff64ed27c0 sp 0x7fff64ed27b8 READ of size 4 at 0x60c00000b9c8 thread T0 #0 0x5d05d0 in llvm::GlobalValue::setUnnamedAddr(bool) /usr/local/google/home/chandlerc/src/llvm/build/../include/llvm/IR/GlobalValue.h:115:35 #1 0x69fff1 in (anonymous namespace)::ModuleLinker::linkGlobalValueProto(llvm::GlobalValue*) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1041:5 #2 0x697229 in (anonymous namespace)::ModuleLinker::run() /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1485:9 #3 0x696542 in llvm::Linker::linkInModule(llvm::Module*) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1621:10 #4 0x4a2db7 in main /usr/local/google/home/chandlerc/src/llvm/build/../tools/llvm-link/llvm-link.cpp:116:9 #5 0x7f4ae61e5ec4 in __libc_start_main /build/buildd/eglibc-2.19/csu/libc-start.c:287 #6 0x41eb71 in _start (/usr/local/google/home/chandlerc/src/llvm/build/bin/llvm-link+0x41eb71) 0x60c00000b9c8 is located 72 bytes inside of 128-byte region [0x60c00000b980,0x60c00000ba00) freed by thread T0 here: #0 0x4a1e6b in operator delete(void*) /usr/local/google/home/chandlerc/src/llvm/opt-build/../projects/compiler-rt/lib/asan/asan_new_delete.cc:94:3 #1 0x5d1a7a in llvm::iplist >::erase(llvm::ilist_iterator) /usr/local/google/home/chandlerc/src/llvm/build/../inclu de/llvm/ADT/ilist.h:466:5 #2 0x5d1980 in llvm::GlobalVariable::eraseFromParent() /usr/local/google/home/chandlerc/src/llvm/build/../lib/IR/Globals.cpp:204:3 #3 0x6a8a4d in (anonymous namespace)::ModuleLinker::linkAppendingVarProto(llvm::GlobalVariable*, llvm::GlobalVariable const*) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules. cpp:980:3 #4 0x6a7403 in (anonymous namespace)::ModuleLinker::linkGlobalVariableProto(llvm::GlobalVariable const*, llvm::GlobalValue*, bool) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkMod ules.cpp:1074:11 #5 0x69ff4e in (anonymous namespace)::ModuleLinker::linkGlobalValueProto(llvm::GlobalValue*) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1028:13 #6 0x697229 in (anonymous namespace)::ModuleLinker::run() /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1485:9 #7 0x696542 in llvm::Linker::linkInModule(llvm::Module*) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1621:10 #8 0x4a2db7 in main /usr/local/google/home/chandlerc/src/llvm/build/../tools/llvm-link/llvm-link.cpp:116:9 #9 0x7f4ae61e5ec4 in __libc_start_main /build/buildd/eglibc-2.19/csu/libc-start.c:287 previously allocated by thread T0 here: #0 0x4a192b in operator new(unsigned long) /usr/local/google/home/chandlerc/src/llvm/opt-build/../projects/compiler-rt/lib/asan/asan_new_delete.cc:62:35 #1 0x61d85c in llvm::User::operator new(unsigned long, unsigned int) /usr/local/google/home/chandlerc/src/llvm/build/../lib/IR/User.cpp:57:19 #2 0x6a7525 in (anonymous namespace)::ModuleLinker::linkGlobalVariableProto(llvm::GlobalVariable const*, llvm::GlobalValue*, bool) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkMod ules.cpp:1100:3 #3 0x69ff4e in (anonymous namespace)::ModuleLinker::linkGlobalValueProto(llvm::GlobalValue*) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1028:13 #4 0x697229 in (anonymous namespace)::ModuleLinker::run() /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1485:9 #5 0x696542 in llvm::Linker::linkInModule(llvm::Module*) /usr/local/google/home/chandlerc/src/llvm/build/../lib/Linker/LinkModules.cpp:1621:10 #6 0x4a2db7 in main /usr/local/google/home/chandlerc/src/llvm/build/../tools/llvm-link/llvm-link.cpp:116:9 #7 0x7f4ae61e5ec4 in __libc_start_main /build/buildd/eglibc-2.19/csu/libc-start.c:287 SUMMARY: AddressSanitizer: heap-use-after-free /usr/local/google/home/chandlerc/src/llvm/build/../include/llvm/IR/GlobalValue.h:115 llvm::GlobalValue::setUnnamedAddr(bool) Shadow bytes around the buggy address: 0x0c187fff96e0: fa fa fa fa fa fa fa fa 00 00 00 00 00 00 00 00 0x0c187fff96f0: 00 00 00 00 00 00 00 fa fa fa fa fa fa fa fa fa 0x0c187fff9700: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fa 0x0c187fff9710: fa fa fa fa fa fa fa fa 00 00 00 00 00 00 00 00 0x0c187fff9720: 00 00 00 00 00 00 00 00 fa fa fa fa fa fa fa fa =>0x0c187fff9730: fd fd fd fd fd fd fd fd fd[fd]fd fd fd fd fd fd 0x0c187fff9740: fa fa fa fa fa fa fa fa fd fd fd fd fd fd fd fd 0x0c187fff9750: fd fd fd fd fd fd fd fa fa fa fa fa fa fa fa fa 0x0c187fff9760: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd 0x0c187fff9770: fa fa fa fa fa fa fa fa fd fd fd fd fd fd fd fd 0x0c187fff9780: fd fd fd fd fd fd fd fd fa fa fa fa fa fa fa fa Shadow byte legend (one shadow byte represents 8 application bytes): Addressable: 00 Partially addressable: 01 02 03 04 05 06 07 Heap left redzone: fa Heap right redzone: fb Freed heap region: fd Stack left redzone: f1 Stack mid redzone: f2 Stack right redzone: f3 Stack partial redzone: f4 Stack after return: f5 Stack use after scope: f8 Global redzone: f9 Global init order: f6 Poisoned by user: f7 Container overflow: fc Array cookie: ac ASan internal: fe ==2122==ABORTING git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@221096 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 3e8eb25999f..4320e886bbb 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -453,6 +453,13 @@ namespace { bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK, bool &LinkFromSrc); + /// This analyzes the two global values and determines what the result will + /// look like in the destination module. + bool getLinkageResult(GlobalValue *Dest, const GlobalValue *Src, + GlobalValue::LinkageTypes <, + GlobalValue::VisibilityTypes &Vis, + bool &LinkFromSrc); + /// Given a global in the source module, return the global in the /// destination module that is being linked to, if any. GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) { @@ -481,15 +488,9 @@ namespace { bool linkAppendingVarProto(GlobalVariable *DstGV, const GlobalVariable *SrcGV); - - bool linkGlobalValueProto(GlobalValue *GV); - GlobalValue *linkGlobalVariableProto(const GlobalVariable *SGVar, - GlobalValue *DGV, bool LinkFromSrc); - GlobalValue *linkFunctionProto(const Function *SF, GlobalValue *DGV, - bool LinkFromSrc); - GlobalValue *linkGlobalAliasProto(const GlobalAlias *SGA, GlobalValue *DGV, - bool LinkFromSrc); - + bool linkGlobalProto(const GlobalVariable *SrcGV); + bool linkFunctionProto(Function *SrcF); + bool linkAliasProto(GlobalAlias *SrcA); bool linkModuleFlagsMetadata(); void linkAppendingVarInit(const AppendingVarInfo &AVI); @@ -687,12 +688,6 @@ bool ModuleLinker::getComdatResult(const Comdat *SrcC, bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest, const GlobalValue &Src) { - // We always have to add Src if it has appending linkage. - if (Src.hasAppendingLinkage()) { - LinkFromSrc = true; - return false; - } - bool SrcIsDeclaration = Src.isDeclarationForLinker(); bool DestIsDeclaration = Dest.isDeclarationForLinker(); @@ -762,6 +757,36 @@ bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc, "': symbol multiply defined!"); } +/// This analyzes the two global values and determines what the result will look +/// like in the destination module. In particular, it computes the resultant +/// linkage type and visibility, computes whether the global in the source +/// should be copied over to the destination (replacing the existing one), and +/// computes whether this linkage is an error or not. +bool ModuleLinker::getLinkageResult(GlobalValue *Dest, const GlobalValue *Src, + GlobalValue::LinkageTypes <, + GlobalValue::VisibilityTypes &Vis, + bool &LinkFromSrc) { + assert(Dest && "Must have two globals being queried"); + assert(!Src->hasLocalLinkage() && + "If Src has internal linkage, Dest shouldn't be set!"); + + if (shouldLinkFromSource(LinkFromSrc, *Dest, *Src)) + return true; + + if (LinkFromSrc) + LT = Src->getLinkage(); + else + LT = Dest->getLinkage(); + + // Compute the visibility. We follow the rules in the System V Application + // Binary Interface. + assert(!GlobalValue::isLocalLinkage(LT) && + "Symbols with local linkage should not be merged"); + Vis = isLessConstraining(Src->getVisibility(), Dest->getVisibility()) ? + Dest->getVisibility() : Src->getVisibility(); + return false; +} + /// Loop over all of the linked values to compute type mappings. For example, /// if we link "extern Foo *x" and "Foo *x = NULL", then we have two struct /// types 'Foo' but one got renamed when the module was loaded into the same @@ -985,164 +1010,256 @@ bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV, return false; } -bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { +/// Loop through the global variables in the src module and merge them into the +/// dest module. +bool ModuleLinker::linkGlobalProto(const GlobalVariable *SGV) { GlobalValue *DGV = getLinkedToGlobal(SGV); - bool LinkFromSrc = true; - Comdat *C = nullptr; - GlobalValue::VisibilityTypes Visibility = SGV->getVisibility(); + llvm::Optional NewVisibility; bool HasUnnamedAddr = SGV->hasUnnamedAddr(); + unsigned Alignment = SGV->getAlignment(); + bool LinkFromSrc = false; + Comdat *DC = nullptr; if (const Comdat *SC = SGV->getComdat()) { Comdat::SelectionKind SK; std::tie(SK, LinkFromSrc) = ComdatsChosen[SC]; - C = DstM->getOrInsertComdat(SC->getName()); - C->setSelectionKind(SK); - } else if (DGV) { - if (shouldLinkFromSource(LinkFromSrc, *DGV, *SGV)) - return true; + DC = DstM->getOrInsertComdat(SC->getName()); + DC->setSelectionKind(SK); } - if (!LinkFromSrc) { - // Track the source global so that we don't attempt to copy it over when - // processing global initializers. - DoNotLinkFromSource.insert(SGV); + if (DGV) { + if (!DC) { + // Concatenation of appending linkage variables is magic and handled later. + if (DGV->hasAppendingLinkage() || SGV->hasAppendingLinkage()) + return linkAppendingVarProto(cast(DGV), SGV); + + // Determine whether linkage of these two globals follows the source + // module's definition or the destination module's definition. + GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage; + GlobalValue::VisibilityTypes NV; + if (getLinkageResult(DGV, SGV, NewLinkage, NV, LinkFromSrc)) + return true; + NewVisibility = NV; + HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr(); + if (DGV->hasCommonLinkage() && SGV->hasCommonLinkage()) + Alignment = std::max(Alignment, DGV->getAlignment()); + else if (!LinkFromSrc) + Alignment = DGV->getAlignment(); + + // If we're not linking from the source, then keep the definition that we + // have. + if (!LinkFromSrc) { + // Special case for const propagation. + if (GlobalVariable *DGVar = dyn_cast(DGV)) { + DGVar->setAlignment(Alignment); + + if (DGVar->isDeclaration() && !SGV->isConstant()) + DGVar->setConstant(false); + } + + // Set calculated linkage, visibility and unnamed_addr. + DGV->setLinkage(NewLinkage); + DGV->setVisibility(*NewVisibility); + DGV->setUnnamedAddr(HasUnnamedAddr); + } + } - if (DGV) + if (!LinkFromSrc) { // Make sure to remember this mapping. - ValueMap[SGV] = - ConstantExpr::getBitCast(DGV, TypeMap.get(SGV->getType())); - } + ValueMap[SGV] = ConstantExpr::getBitCast(DGV,TypeMap.get(SGV->getType())); - if (DGV) { - Visibility = isLessConstraining(Visibility, DGV->getVisibility()) - ? DGV->getVisibility() - : Visibility; - HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr(); + // Track the source global so that we don't attempt to copy it over when + // processing global initializers. + DoNotLinkFromSource.insert(SGV); + + return false; + } } - if (!LinkFromSrc && !DGV) + // If the Comdat this variable was inside of wasn't selected, skip it. + if (DC && !DGV && !LinkFromSrc) { + DoNotLinkFromSource.insert(SGV); return false; - - GlobalValue *NewGV; - if (auto *SGVar = dyn_cast(SGV)) { - NewGV = linkGlobalVariableProto(SGVar, DGV, LinkFromSrc); - if (!NewGV) - return true; - } else if (auto *SF = dyn_cast(SGV)) { - NewGV = linkFunctionProto(SF, DGV, LinkFromSrc); - } else { - NewGV = linkGlobalAliasProto(cast(SGV), DGV, LinkFromSrc); } - if (NewGV) { - if (NewGV != DGV) - copyGVAttributes(NewGV, SGV); - - NewGV->setUnnamedAddr(HasUnnamedAddr); - NewGV->setVisibility(Visibility); + // No linking to be performed or linking from the source: simply create an + // identical version of the symbol over in the dest module... the + // initializer will be filled in later by LinkGlobalInits. + GlobalVariable *NewDGV = + new GlobalVariable(*DstM, TypeMap.get(SGV->getType()->getElementType()), + SGV->isConstant(), SGV->getLinkage(), /*init*/nullptr, + SGV->getName(), /*insertbefore*/nullptr, + SGV->getThreadLocalMode(), + SGV->getType()->getAddressSpace()); + // Propagate alignment, visibility and section info. + copyGVAttributes(NewDGV, SGV); + NewDGV->setAlignment(Alignment); + if (NewVisibility) + NewDGV->setVisibility(*NewVisibility); + NewDGV->setUnnamedAddr(HasUnnamedAddr); - if (auto *NewGO = dyn_cast(NewGV)) { - if (C) - NewGO->setComdat(C); - } + if (DC) + NewDGV->setComdat(DC); - // Make sure to remember this mapping. - if (NewGV != DGV) { - if (DGV) { - DGV->replaceAllUsesWith( - ConstantExpr::getBitCast(NewGV, DGV->getType())); - DGV->eraseFromParent(); - } - ValueMap[SGV] = NewGV; - } + if (DGV) { + DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDGV, DGV->getType())); + DGV->eraseFromParent(); } + // Make sure to remember this mapping. + ValueMap[SGV] = NewDGV; return false; } -/// Loop through the global variables in the src module and merge them into the -/// dest module. -GlobalValue *ModuleLinker::linkGlobalVariableProto(const GlobalVariable *SGVar, - GlobalValue *DGV, - bool LinkFromSrc) { - unsigned Alignment = 0; - bool ClearConstant = false; +/// Link the function in the source module into the destination module if +/// needed, setting up mapping information. +bool ModuleLinker::linkFunctionProto(Function *SF) { + GlobalValue *DGV = getLinkedToGlobal(SF); + llvm::Optional NewVisibility; + bool HasUnnamedAddr = SF->hasUnnamedAddr(); + + bool LinkFromSrc = false; + Comdat *DC = nullptr; + if (const Comdat *SC = SF->getComdat()) { + Comdat::SelectionKind SK; + std::tie(SK, LinkFromSrc) = ComdatsChosen[SC]; + DC = DstM->getOrInsertComdat(SC->getName()); + DC->setSelectionKind(SK); + } if (DGV) { - // Concatenation of appending linkage variables is magic and handled later. - if (DGV->hasAppendingLinkage()) { - if (linkAppendingVarProto(cast(DGV), SGVar)) - return nullptr; - return DGV; + if (!DC) { + GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage; + GlobalValue::VisibilityTypes NV; + if (getLinkageResult(DGV, SF, NewLinkage, NV, LinkFromSrc)) + return true; + NewVisibility = NV; + HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr(); + + if (!LinkFromSrc) { + // Set calculated linkage + DGV->setLinkage(NewLinkage); + DGV->setVisibility(*NewVisibility); + DGV->setUnnamedAddr(HasUnnamedAddr); + } } - if (DGV->hasCommonLinkage() && SGVar->hasCommonLinkage()) - Alignment = std::max(SGVar->getAlignment(), DGV->getAlignment()); + if (!LinkFromSrc) { + // Make sure to remember this mapping. + ValueMap[SF] = ConstantExpr::getBitCast(DGV, TypeMap.get(SF->getType())); - auto *DGVar = dyn_cast(DGV); - if (!SGVar->isConstant() || (DGVar && !DGVar->isConstant())) - ClearConstant = true; - } + // Track the function from the source module so we don't attempt to remap + // it. + DoNotLinkFromSource.insert(SF); - if (!LinkFromSrc) { - if (auto *NewGVar = dyn_cast(DGV)) { - if (Alignment) - NewGVar->setAlignment(Alignment); - if (NewGVar->isDeclaration() && ClearConstant) - NewGVar->setConstant(false); + return false; } - return DGV; } - // No linking to be performed or linking from the source: simply create an - // identical version of the symbol over in the dest module... the - // initializer will be filled in later by LinkGlobalInits. - GlobalVariable *NewDGV = new GlobalVariable( - *DstM, TypeMap.get(SGVar->getType()->getElementType()), - SGVar->isConstant(), SGVar->getLinkage(), /*init*/ nullptr, - SGVar->getName(), /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(), - SGVar->getType()->getAddressSpace()); - - if (Alignment) - NewDGV->setAlignment(Alignment); - - return NewDGV; -} - -/// Link the function in the source module into the destination module if -/// needed, setting up mapping information. -GlobalValue *ModuleLinker::linkFunctionProto(const Function *SF, - GlobalValue *DGV, - bool LinkFromSrc) { - if (!LinkFromSrc) - return DGV; - // If the function is to be lazily linked, don't create it just yet. // The ValueMaterializerTy will deal with creating it if it's used. if (!DGV && (SF->hasLocalLinkage() || SF->hasLinkOnceLinkage() || SF->hasAvailableExternallyLinkage())) { DoNotLinkFromSource.insert(SF); - return nullptr; + return false; + } + + // If the Comdat this function was inside of wasn't selected, skip it. + if (DC && !DGV && !LinkFromSrc) { + DoNotLinkFromSource.insert(SF); + return false; } // If there is no linkage to be performed or we are linking from the source, // bring SF over. - return Function::Create(TypeMap.get(SF->getFunctionType()), SF->getLinkage(), - SF->getName(), DstM); + Function *NewDF = Function::Create(TypeMap.get(SF->getFunctionType()), + SF->getLinkage(), SF->getName(), DstM); + copyGVAttributes(NewDF, SF); + if (NewVisibility) + NewDF->setVisibility(*NewVisibility); + NewDF->setUnnamedAddr(HasUnnamedAddr); + + if (DC) + NewDF->setComdat(DC); + + if (DGV) { + // Any uses of DF need to change to NewDF, with cast. + DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDF, DGV->getType())); + DGV->eraseFromParent(); + } + + ValueMap[SF] = NewDF; + return false; } /// Set up prototypes for any aliases that come over from the source module. -GlobalValue *ModuleLinker::linkGlobalAliasProto(const GlobalAlias *SGA, - GlobalValue *DGV, - bool LinkFromSrc) { - if (!LinkFromSrc) - return DGV; +bool ModuleLinker::linkAliasProto(GlobalAlias *SGA) { + GlobalValue *DGV = getLinkedToGlobal(SGA); + llvm::Optional NewVisibility; + bool HasUnnamedAddr = SGA->hasUnnamedAddr(); + + bool LinkFromSrc = false; + Comdat *DC = nullptr; + if (const Comdat *SC = SGA->getComdat()) { + Comdat::SelectionKind SK; + std::tie(SK, LinkFromSrc) = ComdatsChosen[SC]; + DC = DstM->getOrInsertComdat(SC->getName()); + DC->setSelectionKind(SK); + } + + if (DGV) { + if (!DC) { + GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage; + GlobalValue::VisibilityTypes NV; + if (getLinkageResult(DGV, SGA, NewLinkage, NV, LinkFromSrc)) + return true; + NewVisibility = NV; + HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr(); + + if (!LinkFromSrc) { + // Set calculated linkage. + DGV->setLinkage(NewLinkage); + DGV->setVisibility(*NewVisibility); + DGV->setUnnamedAddr(HasUnnamedAddr); + } + } + + if (!LinkFromSrc) { + // Make sure to remember this mapping. + ValueMap[SGA] = ConstantExpr::getBitCast(DGV,TypeMap.get(SGA->getType())); + + // Track the alias from the source module so we don't attempt to remap it. + DoNotLinkFromSource.insert(SGA); + + return false; + } + } + + // If the Comdat this alias was inside of wasn't selected, skip it. + if (DC && !DGV && !LinkFromSrc) { + DoNotLinkFromSource.insert(SGA); + return false; + } // If there is no linkage to be performed or we're linking from the source, // bring over SGA. auto *PTy = cast(TypeMap.get(SGA->getType())); - return GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), - SGA->getLinkage(), SGA->getName(), DstM); + auto *NewDA = + GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), + SGA->getLinkage(), SGA->getName(), DstM); + copyGVAttributes(NewDA, SGA); + if (NewVisibility) + NewDA->setVisibility(*NewVisibility); + NewDA->setUnnamedAddr(HasUnnamedAddr); + + if (DGV) { + // Any uses of DGV need to change to NewDA, with cast. + DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDA, DGV->getType())); + DGV->eraseFromParent(); + } + + ValueMap[SGA] = NewDA; + return false; } static void getArrayElements(const Constant *C, @@ -1482,7 +1599,7 @@ bool ModuleLinker::run() { // initializers (which could refer to functions not yet mapped over). for (Module::global_iterator I = SrcM->global_begin(), E = SrcM->global_end(); I != E; ++I) - if (linkGlobalValueProto(I)) + if (linkGlobalProto(I)) return true; // Link the functions together between the two modules, without doing function @@ -1491,13 +1608,13 @@ bool ModuleLinker::run() { // all of the global values that may be referenced are available in our // ValueMap. for (Module::iterator I = SrcM->begin(), E = SrcM->end(); I != E; ++I) - if (linkGlobalValueProto(I)) + if (linkFunctionProto(I)) return true; // If there were any aliases, link them now. for (Module::alias_iterator I = SrcM->alias_begin(), E = SrcM->alias_end(); I != E; ++I) - if (linkGlobalValueProto(I)) + if (linkAliasProto(I)) return true; for (unsigned i = 0, e = AppendingVars.size(); i != e; ++i) diff --git a/test/Linker/Inputs/visibility.ll b/test/Linker/Inputs/visibility.ll index 2ab58fd3bd0..f5b2065b85f 100644 --- a/test/Linker/Inputs/visibility.ll +++ b/test/Linker/Inputs/visibility.ll @@ -1,10 +1,7 @@ -$c1 = comdat any - ; Variables @v1 = weak hidden global i32 0 @v2 = weak protected global i32 0 @v3 = weak hidden global i32 0 -@v4 = hidden global i32 1, comdat $c1 ; Aliases @a1 = weak hidden alias i32* @v1 diff --git a/test/Linker/visibility.ll b/test/Linker/visibility.ll index 6436197bf20..fc950fa1d89 100644 --- a/test/Linker/visibility.ll +++ b/test/Linker/visibility.ll @@ -4,21 +4,16 @@ ; The values in this file are strong, the ones in Inputs/visibility.ll are weak, ; but we should still get the visibility from them. - -$c1 = comdat any - ; Variables -; CHECK-DAG: @v1 = hidden global i32 0 +; CHECK: @v1 = hidden global i32 0 @v1 = global i32 0 -; CHECK-DAG: @v2 = protected global i32 0 +; CHECK: @v2 = protected global i32 0 @v2 = global i32 0 -; CHECK-DAG: @v3 = hidden global i32 0 +; CHECK: @v3 = hidden global i32 0 @v3 = protected global i32 0 -; CHECK-DAG: @v4 = hidden global i32 1, comdat $c1 -@v4 = global i32 1, comdat $c1 ; Aliases ; CHECK: @a1 = hidden alias i32* @v1