Index: llvm/include/llvm/IR/GlobalAlias.h =================================================================== --- llvm/include/llvm/IR/GlobalAlias.h +++ llvm/include/llvm/IR/GlobalAlias.h @@ -59,10 +59,6 @@ // Linkage, Type, Parent and AddressSpace taken from the Aliasee. static GlobalAlias *create(const Twine &Name, GlobalValue *Aliasee); - void copyAttributesFrom(const GlobalValue *Src) { - GlobalValue::copyAttributesFrom(Src); - } - /// removeFromParent - This method unlinks 'this' from the containing module, /// but does not delete it. /// Index: llvm/include/llvm/IR/GlobalIFunc.h =================================================================== --- llvm/include/llvm/IR/GlobalIFunc.h +++ llvm/include/llvm/IR/GlobalIFunc.h @@ -47,10 +47,6 @@ LinkageTypes Linkage, const Twine &Name, Constant *Resolver, Module *Parent); - void copyAttributesFrom(const GlobalIFunc *Src) { - GlobalValue::copyAttributesFrom(Src); - } - /// This method unlinks 'this' from the containing module, but does not /// delete it. void removeFromParent(); Index: llvm/include/llvm/IR/GlobalIndirectSymbol.h =================================================================== --- llvm/include/llvm/IR/GlobalIndirectSymbol.h +++ llvm/include/llvm/IR/GlobalIndirectSymbol.h @@ -43,6 +43,10 @@ /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); + void copyAttributesFrom(const GlobalValue *Src) { + GlobalValue::copyAttributesFrom(Src); + } + /// These methods set and retrieve indirect symbol. void setIndirectSymbol(Constant *Symbol) { setOperand(0, Symbol); Index: llvm/include/llvm/Transforms/Utils/ValueMapper.h =================================================================== --- llvm/include/llvm/Transforms/Utils/ValueMapper.h +++ llvm/include/llvm/Transforms/Utils/ValueMapper.h @@ -23,7 +23,7 @@ class Constant; class Function; -class GlobalAlias; +class GlobalIndirectSymbol; class GlobalVariable; class Instruction; class MDNode; @@ -121,7 +121,7 @@ /// instance: /// - \a scheduleMapGlobalInitializer() /// - \a scheduleMapAppendingVariable() -/// - \a scheduleMapGlobalAliasee() +/// - \a scheduleMapGlobalIndirectSymbol() /// - \a scheduleRemapFunction() /// /// Sometimes a callback needs a different mapping context. Such a context can @@ -181,8 +181,9 @@ bool IsOldCtorDtor, ArrayRef NewMembers, unsigned MappingContextID = 0); - void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MappingContextID = 0); + void scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS, + Constant &Aliasee, + unsigned MappingContextID = 0); void scheduleRemapFunction(Function &F, unsigned MappingContextID = 0); }; Index: llvm/lib/Linker/IRMover.cpp =================================================================== --- llvm/lib/Linker/IRMover.cpp +++ llvm/lib/Linker/IRMover.cpp @@ -399,7 +399,7 @@ /// due to the use of Value handles which the Linker doesn't actually need, /// but this allows us to reuse the ValueMapper code. ValueToValueMapTy ValueMap; - ValueToValueMapTy AliasValueMap; + ValueToValueMapTy IndirectSymbolValueMap; DenseSet ValuesToLink; std::vector Worklist; @@ -437,7 +437,7 @@ /// Entry point for mapping values and alternate context for mapping aliases. ValueMapper Mapper; - unsigned AliasMCID; + unsigned IndirectSymbolMCID; /// Handles cloning of a global values from the source module into /// the destination module, including setting the attributes and visibility. @@ -480,20 +480,21 @@ /// /// Note this code may call the client-provided \p AddLazyFor. bool shouldLink(GlobalValue *DGV, GlobalValue &SGV); - Expected linkGlobalValueProto(GlobalValue *GV, bool ForAlias); + Expected linkGlobalValueProto(GlobalValue *GV, bool ForIndirectSymbol); Error linkModuleFlagsMetadata(); void linkGlobalVariable(GlobalVariable &Dst, GlobalVariable &Src); Error linkFunctionBody(Function &Dst, Function &Src); - void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src); + void linkIndirectSymbolBody(GlobalIndirectSymbol &Dst, + GlobalIndirectSymbol &Src); Error linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src); /// Functions that take care of cloning a specific global value type /// into the destination module. GlobalVariable *copyGlobalVariableProto(const GlobalVariable *SGVar); Function *copyFunctionProto(const Function *SF); - GlobalValue *copyGlobalAliasProto(const GlobalAlias *SGA); + GlobalValue *copyGlobalIndirectSymbolProto(const GlobalIndirectSymbol *SGIS); /// When importing for ThinLTO, prevent importing of types listed on /// the DICompileUnit that we don't need a copy of in the importing @@ -512,8 +513,8 @@ SharedMDs(SharedMDs), IsPerformingImport(IsPerformingImport), Mapper(ValueMap, RF_MoveDistinctMDs | RF_IgnoreMissingLocals, &TypeMap, &GValMaterializer), - AliasMCID(Mapper.registerAlternateMappingContext(AliasValueMap, - &LValMaterializer)) { + IndirectSymbolMCID(Mapper.registerAlternateMappingContext( + IndirectSymbolValueMap, &LValMaterializer)) { ValueMap.getMDMap() = std::move(SharedMDs); for (GlobalValue *GV : ValuesToLink) maybeAdd(GV); @@ -523,7 +524,7 @@ ~IRLinker() { SharedMDs = std::move(*ValueMap.getMDMap()); } Error run(); - Value *materialize(Value *V, bool ForAlias); + Value *materialize(Value *V, bool ForIndirectSymbol); }; } @@ -556,12 +557,12 @@ return TheIRLinker.materialize(SGV, true); } -Value *IRLinker::materialize(Value *V, bool ForAlias) { +Value *IRLinker::materialize(Value *V, bool ForIndirectSymbol) { auto *SGV = dyn_cast(V); if (!SGV) return nullptr; - Expected NewProto = linkGlobalValueProto(SGV, ForAlias); + Expected NewProto = linkGlobalValueProto(SGV, ForIndirectSymbol); if (!NewProto) { setError(NewProto.takeError()); return nullptr; @@ -581,8 +582,8 @@ if (V->hasInitializer() || V->hasAppendingLinkage()) return New; } else { - auto *A = cast(New); - if (A->getAliasee()) + auto *IS = cast(New); + if (IS->getIndirectSymbol()) return New; } @@ -594,10 +595,10 @@ // different, it means that the value already had a definition in the // destination module (linkonce for instance), but we need a new definition // for the alias ("New" will be different. - if (ForAlias && ValueMap.lookup(SGV) == New) + if (ForIndirectSymbol && ValueMap.lookup(SGV) == New) return New; - if (ForAlias || shouldLink(New, *SGV)) + if (ForIndirectSymbol || shouldLink(New, *SGV)) setError(linkGlobalValueBody(*New, *SGV)); return New; @@ -632,16 +633,24 @@ return F; } -/// Set up prototypes for any aliases that come over from the source module. -GlobalValue *IRLinker::copyGlobalAliasProto(const GlobalAlias *SGA) { +/// Set up prototypes for any indirect symbols that come over from the source +/// module. +GlobalValue * +IRLinker::copyGlobalIndirectSymbolProto(const GlobalIndirectSymbol *SGIS) { // If there is no linkage to be performed or we're linking from the source, // bring over SGA. - auto *Ty = TypeMap.get(SGA->getValueType()); - auto *GA = - GlobalAlias::create(Ty, SGA->getType()->getPointerAddressSpace(), - GlobalValue::ExternalLinkage, SGA->getName(), &DstM); - GA->copyAttributesFrom(SGA); - return GA; + auto *Ty = TypeMap.get(SGIS->getValueType()); + GlobalIndirectSymbol *GIS; + if (isa(SGIS)) + GIS = GlobalAlias::create(Ty, SGIS->getType()->getPointerAddressSpace(), + GlobalValue::ExternalLinkage, SGIS->getName(), + &DstM); + else + GIS = GlobalIFunc::create(Ty, SGIS->getType()->getPointerAddressSpace(), + GlobalValue::ExternalLinkage, SGIS->getName(), + nullptr, &DstM); + GIS->copyAttributesFrom(SGIS); + return GIS; } GlobalValue *IRLinker::copyGlobalValueProto(const GlobalValue *SGV, @@ -653,7 +662,7 @@ NewGV = copyFunctionProto(SF); } else { if (ForDefinition) - NewGV = copyGlobalAliasProto(cast(SGV)); + NewGV = copyGlobalIndirectSymbolProto(cast(SGV)); else if (SGV->getValueType()->isFunctionTy()) NewGV = Function::Create(cast(TypeMap.get(SGV->getValueType())), @@ -912,7 +921,7 @@ } Expected IRLinker::linkGlobalValueProto(GlobalValue *SGV, - bool ForAlias) { + bool ForIndirectSymbol) { GlobalValue *DGV = getLinkedToGlobal(SGV); bool ShouldLink = shouldLink(DGV, *SGV); @@ -923,12 +932,12 @@ if (I != ValueMap.end()) return cast(I->second); - I = AliasValueMap.find(SGV); - if (I != AliasValueMap.end()) + I = IndirectSymbolValueMap.find(SGV); + if (I != IndirectSymbolValueMap.end()) return cast(I->second); } - if (!ShouldLink && ForAlias) + if (!ShouldLink && ForIndirectSymbol) DGV = nullptr; // Handle the ultra special appending linkage case first. @@ -947,8 +956,8 @@ if (DoneLinkingBodies) return nullptr; - NewGV = copyGlobalValueProto(SGV, ShouldLink || ForAlias); - if (ShouldLink || !ForAlias) + NewGV = copyGlobalValueProto(SGV, ShouldLink || ForIndirectSymbol); + if (ShouldLink || !ForIndirectSymbol) forceRenaming(NewGV, SGV->getName()); } @@ -959,7 +968,7 @@ if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F)) NewGV = Remangled.getValue(); - if (ShouldLink || ForAlias) { + if (ShouldLink || ForIndirectSymbol) { if (const Comdat *SC = SGV->getComdat()) { if (auto *GO = dyn_cast(NewGV)) { Comdat *DC = DstM.getOrInsertComdat(SC->getName()); @@ -969,7 +978,7 @@ } } - if (!ShouldLink && ForAlias) + if (!ShouldLink && ForIndirectSymbol) NewGV->setLinkage(GlobalValue::InternalLinkage); Constant *C = NewGV; @@ -1029,8 +1038,10 @@ return Error::success(); } -void IRLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) { - Mapper.scheduleMapGlobalAliasee(Dst, *Src.getAliasee(), AliasMCID); +void IRLinker::linkIndirectSymbolBody(GlobalIndirectSymbol &Dst, + GlobalIndirectSymbol &Src) { + Mapper.scheduleMapGlobalIndirectSymbol(Dst, *Src.getIndirectSymbol(), + IndirectSymbolMCID); } Error IRLinker::linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src) { @@ -1040,7 +1051,7 @@ linkGlobalVariable(cast(Dst), *GVar); return Error::success(); } - linkAliasBody(cast(Dst), cast(Src)); + linkIndirectSymbolBody(cast(Dst), cast(Src)); return Error::success(); } @@ -1352,7 +1363,7 @@ // Already mapped. if (ValueMap.find(GV) != ValueMap.end() || - AliasValueMap.find(GV) != AliasValueMap.end()) + IndirectSymbolValueMap.find(GV) != IndirectSymbolValueMap.end()) continue; assert(!GV->isDeclaration()); Index: llvm/lib/Transforms/Utils/ValueMapper.cpp =================================================================== --- llvm/lib/Transforms/Utils/ValueMapper.cpp +++ llvm/lib/Transforms/Utils/ValueMapper.cpp @@ -28,8 +28,8 @@ #include "llvm/IR/DebugInfoMetadata.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Function.h" -#include "llvm/IR/GlobalAlias.h" #include "llvm/IR/GlobalObject.h" +#include "llvm/IR/GlobalIndirectSymbol.h" #include "llvm/IR/GlobalVariable.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Instruction.h" @@ -67,7 +67,7 @@ enum EntryKind { MapGlobalInit, MapAppendingVar, - MapGlobalAliasee, + MapGlobalIndirectSymbol, RemapFunction }; struct GVInitTy { @@ -78,9 +78,9 @@ GlobalVariable *GV; Constant *InitPrefix; }; - struct GlobalAliaseeTy { - GlobalAlias *GA; - Constant *Aliasee; + struct GlobalIndirectSymbolTy { + GlobalIndirectSymbol *GIS; + Constant *Target; }; unsigned Kind : 2; @@ -90,7 +90,7 @@ union { GVInitTy GVInit; AppendingGVTy AppendingGV; - GlobalAliaseeTy GlobalAliasee; + GlobalIndirectSymbolTy GlobalIndirectSymbol; Function *RemapF; } Data; }; @@ -162,8 +162,8 @@ bool IsOldCtorDtor, ArrayRef NewMembers, unsigned MCID); - void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MCID); + void scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS, Constant &Target, + unsigned MCID); void scheduleRemapFunction(Function &F, unsigned MCID); void flush(); @@ -173,7 +173,7 @@ void mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix, bool IsOldCtorDtor, ArrayRef NewMembers); - void mapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee); + void mapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS, Constant &Target); void remapFunction(Function &F, ValueToValueMapTy &VM); ValueToValueMapTy &getVM() { return *MCs[CurrentMCID].VM; } @@ -847,9 +847,9 @@ AppendingInits.resize(PrefixSize); break; } - case WorklistEntry::MapGlobalAliasee: - E.Data.GlobalAliasee.GA->setAliasee( - mapConstant(E.Data.GlobalAliasee.Aliasee)); + case WorklistEntry::MapGlobalIndirectSymbol: + E.Data.GlobalIndirectSymbol.GIS->setIndirectSymbol( + mapConstant(E.Data.GlobalIndirectSymbol.Target)); break; case WorklistEntry::RemapFunction: remapFunction(*E.Data.RemapF); @@ -1027,16 +1027,16 @@ AppendingInits.append(NewMembers.begin(), NewMembers.end()); } -void Mapper::scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MCID) { - assert(AlreadyScheduled.insert(&GA).second && "Should not reschedule"); +void Mapper::scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS, + Constant &Target, unsigned MCID) { + assert(AlreadyScheduled.insert(&GIS).second && "Should not reschedule"); assert(MCID < MCs.size() && "Invalid mapping context"); WorklistEntry WE; - WE.Kind = WorklistEntry::MapGlobalAliasee; + WE.Kind = WorklistEntry::MapGlobalIndirectSymbol; WE.MCID = MCID; - WE.Data.GlobalAliasee.GA = &GA; - WE.Data.GlobalAliasee.Aliasee = &Aliasee; + WE.Data.GlobalIndirectSymbol.GIS = &GIS; + WE.Data.GlobalIndirectSymbol.Target = &Target; Worklist.push_back(WE); } @@ -1133,9 +1133,10 @@ GV, InitPrefix, IsOldCtorDtor, NewMembers, MCID); } -void ValueMapper::scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MCID) { - getAsMapper(pImpl)->scheduleMapGlobalAliasee(GA, Aliasee, MCID); +void ValueMapper::scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS, + Constant &Target, + unsigned MCID) { + getAsMapper(pImpl)->scheduleMapGlobalIndirectSymbol(GIS, Target, MCID); } void ValueMapper::scheduleRemapFunction(Function &F, unsigned MCID) { Index: llvm/test/LTO/Resolution/X86/Inputs/ifunc2.ll =================================================================== --- /dev/null +++ llvm/test/LTO/Resolution/X86/Inputs/ifunc2.ll @@ -0,0 +1,6 @@ +target datalayout = "e-p:64:64" +target triple = "x86_64-unknown-linux-gnu" + +define i32 @foo_resolver() { + ret i32 2 +} Index: llvm/test/LTO/Resolution/X86/ifunc2.ll =================================================================== --- /dev/null +++ llvm/test/LTO/Resolution/X86/ifunc2.ll @@ -0,0 +1,19 @@ +; RUN: llvm-as -o %t1.o %s +; RUN: llvm-as -o %t2.o %S/Inputs/ifunc2.ll +; RUN: llvm-lto2 run %t1.o %t2.o -r %t1.o,foo,p -r %t1.o,foo_resolver, -r %t2.o,foo_resolver,p -save-temps -o %t3.o +; RUN: llvm-dis -o - %t3.o.0.0.preopt.bc | FileCheck %s + +target datalayout = "e-p:64:64" +target triple = "x86_64-unknown-linux-gnu" + +; CHECK: @foo = ifunc i32 (), i32 ()* @foo_resolver.2 +@foo = ifunc i32 (), i32 ()* @foo_resolver + +; CHECK: define internal i32 @foo_resolver.2() { +; CHECK-NEXT: ret i32 1 + +; CHECK: define i32 @foo_resolver() { +; CHECK-NEXT: ret i32 2 +define weak i32 @foo_resolver() { + ret i32 1 +}