Index: lib/LTO/ThinLTOCodeGenerator.cpp =================================================================== --- lib/LTO/ThinLTOCodeGenerator.cpp +++ lib/LTO/ThinLTOCodeGenerator.cpp @@ -94,6 +94,104 @@ WriteBitcodeToFile(&TheModule, OS, true, false); } +bool IsFirstDefinitionForLinker(const GlobalValueInfoList &GVInfo, + const ModuleSummaryIndex &Index, + StringRef ModulePath) { + // Get the first *linker visible* definition for this global in the summary + // list. + auto FirstDefForLinker = llvm::find_if( + GVInfo, [](const std::unique_ptr &FuncInfo) { + auto Linkage = FuncInfo->summary()->linkage(); + return !GlobalValue::isAvailableExternallyLinkage(Linkage); + }); + // If \p GV is not the first definition, give up... + if ((*FirstDefForLinker)->summary()->modulePath() != ModulePath) + return false; + // If there is any strong definition anywhere, do not bother emitting this. + if (llvm::any_of( + GVInfo, [](const std::unique_ptr &FuncInfo) { + auto Linkage = FuncInfo->summary()->linkage(); + return !GlobalValue::isAvailableExternallyLinkage(Linkage) && + !GlobalValue::isWeakForLinker(Linkage); + })) + return false; + return true; +}; + +static void ResolveODR(GlobalValue &GV, const ModuleSummaryIndex &Index, + StringRef ModulePath) { + if (GV.isDeclaration()) + return; + + auto HasMultipleCopies = + [&](const GlobalValueInfoList &GVInfo) { return GVInfo.size() > 1; }; + + auto getGVInfo = [&](GlobalValue &GV) -> const GlobalValueInfoList *{ + auto GUID = Function::getGlobalIdentifier(GV.getName(), GV.getLinkage(), + ModulePath); + auto It = Index.findGlobalValueInfoList(GV.getName()); + if (It == Index.end()) + return nullptr; + return &It->second; + }; + + switch (GV.getLinkage()) { + case GlobalValue::ExternalLinkage: + case GlobalValue::AvailableExternallyLinkage: + case GlobalValue::AppendingLinkage: + case GlobalValue::InternalLinkage: + case GlobalValue::PrivateLinkage: + case GlobalValue::ExternalWeakLinkage: + case GlobalValue::CommonLinkage: + case GlobalValue::LinkOnceAnyLinkage: + case GlobalValue::WeakAnyLinkage: + break; + case GlobalValue::LinkOnceODRLinkage: + case GlobalValue::WeakODRLinkage: { + auto *GVInfo = getGVInfo(GV); + if (!GVInfo) + break; + // We need to emit only one of these, the first module will keep + // it, but turned into a weak while the others will drop it. + if (!HasMultipleCopies(*GVInfo)) + break; + if (IsFirstDefinitionForLinker(*GVInfo, Index, ModulePath)) + GV.setLinkage(GlobalValue::WeakODRLinkage); + else + GV.setLinkage(GlobalValue::AvailableExternallyLinkage); + break; + } + } +} + +/// Resolve LinkOnceODR and WeakODR. +/// +/// We'd like to drop these function if they are no longer referenced in the +/// current module. However there is a chance that another module is still +/// referencing them because of the import. We make sure we always emit at least +/// one copy. +static void ResolveODR(Module &TheModule, + const ModuleSummaryIndex &Index) { + // We won't optimize the globals that are referenced by an alias for now + // Ideally we should turn the alias into a global and duplicate the definition + // when needed. + DenseSet GlobalInvolvedWithAlias; + for (auto &GA : TheModule.aliases()) { + auto *GO = GA.getBaseObject(); + if (auto *GV = dyn_cast(GO)) + GlobalInvolvedWithAlias.insert(GV); + } + // Process functions and global now + for (auto &GV : TheModule) { + if (!GlobalInvolvedWithAlias.count(&GV)) + ResolveODR(GV, Index, TheModule.getModuleIdentifier()); + } + for (auto &GV : TheModule.globals()) { + if (!GlobalInvolvedWithAlias.count(&GV)) + ResolveODR(GV, Index, TheModule.getModuleIdentifier()); + } +} + static StringMap generateModuleMap(const std::vector &Modules) { StringMap ModuleMap; @@ -205,6 +303,11 @@ if (!SingleModule) { promoteModule(TheModule, Index); + // Resolve the LinkOnce/Weak ODR, trying to turn them into + // "available_externally" when possible. + // This is a compile-time optimization. + ResolveODR(TheModule, Index); + // Save temps: after promotion. saveTempBitcode(TheModule, SaveTempsDir, count, ".2.promoted.bc"); @@ -326,6 +429,11 @@ */ void ThinLTOCodeGenerator::promote(Module &TheModule, ModuleSummaryIndex &Index) { + + // Resolve the LinkOnceODR, trying to turn them into "available_externally" + // where possible. + ResolveODR(TheModule, Index); + promoteModule(TheModule, Index); } Index: test/ThinLTO/X86/Inputs/odr_resolution.ll =================================================================== --- /dev/null +++ test/ThinLTO/X86/Inputs/odr_resolution.ll @@ -0,0 +1,29 @@ +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.11.0" + +; Alias are not optimized +@linkoncealias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias + +; Function with an alias are not optimized +define linkonce_odr void @linkonceodrfuncwithalias() #0 { +entry: + ret void +} + +define linkonce_odr void @linkonceodrfunc() #0 { +entry: + ret void +} +define linkonce void @linkoncefunc() #0 { +entry: + ret void +} +define weak_odr void @weakodrfunc() #0 { +entry: + ret void +} +define weak void @weakfunc() #0 { +entry: + ret void +} + Index: test/ThinLTO/X86/odr_resolution.ll =================================================================== --- /dev/null +++ test/ThinLTO/X86/odr_resolution.ll @@ -0,0 +1,50 @@ +; Do setup work for all below tests: generate bitcode and combined index +; RUN: llvm-as -module-summary %s -o %t.bc +; RUN: llvm-as -module-summary %p/Inputs/odr_resolution.ll -o %t2.bc +; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc + +; Verify that only one ODR is selected across modules, but non ODR are not affected. +; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD1 +; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=MOD2 + +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.11.0" + +; Alias are not optimized +; MOD1: @linkoncealias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias +; MOD2: @linkoncealias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias +@linkoncealias = linkonce_odr alias void (), void ()* @linkonceodrfuncwithalias + +; Function with an alias are not optimized +; MOD1: define linkonce_odr void @linkonceodrfuncwithalias() +; MOD2: define linkonce_odr void @linkonceodrfuncwithalias() +define linkonce_odr void @linkonceodrfuncwithalias() #0 { +entry: + ret void +} + +; MOD1: define weak_odr void @linkonceodrfunc() +; MOD2: define available_externally void @linkonceodrfunc() +define linkonce_odr void @linkonceodrfunc() #0 { +entry: + ret void +} +; MOD1: define linkonce void @linkoncefunc() +; MOD2: define linkonce void @linkoncefunc() +define linkonce void @linkoncefunc() #0 { +entry: + ret void +} +; MOD1: define weak_odr void @weakodrfunc() +; MOD2: define available_externally void @weakodrfunc() +define weak_odr void @weakodrfunc() #0 { +entry: + ret void +} +; MOD1: define weak void @weakfunc() +; MOD2: define weak void @weakfunc() +define weak void @weakfunc() #0 { +entry: + ret void +} +