From: Teresa Johnson Date: Mon, 16 Jul 2018 15:30:27 +0000 (+0000) Subject: Restore "[ThinLTO] Ensure we always select the same function copy to import" X-Git-Tag: llvmorg-7.0.0-rc1~1340 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d68935c5ac4da578d82936e4d1dfcd0574ef8366;p=platform%2Fupstream%2Fllvm.git Restore "[ThinLTO] Ensure we always select the same function copy to import" This reverts commit r337081, therefore restoring r337050 (and fix in r337059), with test fix for bot failure described after the original description below. In order to always import the same copy of a linkonce function, even when encountering it with different thresholds (a higher one then a lower one), keep track of the summary we decided to import. This ensures that the backend only gets a single definition to import for each GUID, so that it doesn't need to choose one. Move the largest threshold the GUID was considered for import into the current module out of the ImportMap (which is part of a larger map maintained across the whole index), and into a new map just maintained for the current module we are computing imports for. This saves some memory since we no longer have the thresholds maintained across the whole index (and throughout the in-process backends when doing a normal non-distributed ThinLTO build), at the cost of some additional information being maintained for each invocation of ComputeImportForModule (the selected summary pointer for each import). There is an additional map lookup for each callee being considered for importing, however, this was able to subsume a map lookup in the Worklist iteration that invokes computeImportForFunction. We also are able to avoid calling selectCallee if we already failed to import at the same or higher threshold. I compared the run time and peak memory for the SPEC2006 471.omnetpp benchmark (running in-process ThinLTO backends), as well as for a large internal benchmark with a distributed ThinLTO build (so just looking at the thin link time/memory). Across a number of runs with and without this change there was no significant change in the time and memory. (I tried a few other variations of the change but they also didn't improve time or peak memory). The new commit removes a test that no longer makes sense (Transforms/FunctionImport/hotness_based_import2.ll), as exposed by the reverse-iteration bot. The test depends on the order of processing the summary call edges, and actually depended on the old problematic behavior of selecting more than one summary for a given GUID when encountered with different thresholds. There was no guarantee even before that we would eventually pick the linkonce copy with the hottest call edges, it just happened to work with the test and the old code, and there was no guarantee that we would end up importing the selected version of the copy that had the hottest call edges (since the backend would effectively import only one of the selected copies). Reviewers: davidxl Subscribers: mehdi_amini, inglorion, llvm-commits Differential Revision: https://reviews.llvm.org/D48670 llvm-svn: 337184 --- diff --git a/llvm/include/llvm/Transforms/IPO/FunctionImport.h b/llvm/include/llvm/Transforms/IPO/FunctionImport.h index 369a12e..120a34e 100644 --- a/llvm/include/llvm/Transforms/IPO/FunctionImport.h +++ b/llvm/include/llvm/Transforms/IPO/FunctionImport.h @@ -33,11 +33,17 @@ class Module; /// based on the provided summary informations. class FunctionImporter { public: - /// Set of functions to import from a source module. Each entry is a map - /// containing all the functions to import for a source module. - /// The keys is the GUID identifying a function to import, and the value - /// is the threshold applied when deciding to import it. - using FunctionsToImportTy = std::map; + /// Set of functions to import from a source module. Each entry is a set + /// containing all the GUIDs of all functions to import for a source module. + using FunctionsToImportTy = std::unordered_set; + + /// Map of callee GUID considered for import into a given module to a pair + /// consisting of the largest threshold applied when deciding whether to + /// import it and, if we decided to import, a pointer to the summary instance + /// imported. If we decided not to import, the summary will be nullptr. + using ImportThresholdsTy = + DenseMap>; /// The map contains an entry for every module to import from, the key being /// the module identifier to pass to the ModuleLoader. The value is the set of diff --git a/llvm/lib/LTO/LTO.cpp b/llvm/lib/LTO/LTO.cpp index 34cca32..3ce2315 100644 --- a/llvm/lib/LTO/LTO.cpp +++ b/llvm/lib/LTO/LTO.cpp @@ -156,7 +156,7 @@ static void computeCacheKey( AddUint64(Entry.second.size()); for (auto &Fn : Entry.second) - AddUint64(Fn.first); + AddUint64(Fn); } // Include the hash for the resolved ODR. @@ -221,7 +221,7 @@ static void computeCacheKey( // so we need to collect their used resolutions as well. for (auto &ImpM : ImportList) for (auto &ImpF : ImpM.second) - AddUsedThings(Index.findSummaryInModule(ImpF.first, ImpM.first())); + AddUsedThings(Index.findSummaryInModule(ImpF, ImpM.first())); auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) { AddString(TId); diff --git a/llvm/lib/Transforms/IPO/FunctionImport.cpp b/llvm/lib/Transforms/IPO/FunctionImport.cpp index c290793..15808a0 100644 --- a/llvm/lib/Transforms/IPO/FunctionImport.cpp +++ b/llvm/lib/Transforms/IPO/FunctionImport.cpp @@ -262,7 +262,7 @@ static void computeImportForReferencedGlobals( !RefSummary->modulePath().empty() && !GlobalValue::isInterposableLinkage(RefSummary->linkage()) && RefSummary->refs().empty()) { - ImportList[RefSummary->modulePath()][VI.getGUID()] = 1; + ImportList[RefSummary->modulePath()].insert(VI.getGUID()); if (ExportLists) (*ExportLists)[RefSummary->modulePath()].insert(VI.getGUID()); break; @@ -278,7 +278,8 @@ static void computeImportForFunction( const unsigned Threshold, const GVSummaryMapTy &DefinedGVSummaries, SmallVectorImpl &Worklist, FunctionImporter::ImportMapTy &ImportList, - StringMap *ExportLists = nullptr) { + StringMap *ExportLists, + FunctionImporter::ImportThresholdsTy &ImportThresholds) { computeImportForReferencedGlobals(Summary, DefinedGVSummaries, ImportList, ExportLists); static int ImportCount = 0; @@ -315,19 +316,85 @@ static void computeImportForFunction( const auto NewThreshold = Threshold * GetBonusMultiplier(Edge.second.getHotness()); - auto *CalleeSummary = selectCallee(Index, VI.getSummaryList(), NewThreshold, - Summary.modulePath()); - if (!CalleeSummary) { - LLVM_DEBUG( - dbgs() << "ignored! No qualifying callee with summary found.\n"); - continue; - } + auto IT = ImportThresholds.insert( + std::make_pair(VI.getGUID(), std::make_pair(NewThreshold, nullptr))); + bool PreviouslyVisited = !IT.second; + auto &ProcessedThreshold = IT.first->second.first; + auto &CalleeSummary = IT.first->second.second; + + const FunctionSummary *ResolvedCalleeSummary = nullptr; + if (CalleeSummary) { + assert(PreviouslyVisited); + // Since the traversal of the call graph is DFS, we can revisit a function + // a second time with a higher threshold. In this case, it is added back + // to the worklist with the new threshold (so that its own callee chains + // can be considered with the higher threshold). + if (NewThreshold <= ProcessedThreshold) { + LLVM_DEBUG( + dbgs() << "ignored! Target was already imported with Threshold " + << ProcessedThreshold << "\n"); + continue; + } + // Update with new larger threshold. + ProcessedThreshold = NewThreshold; + ResolvedCalleeSummary = cast(CalleeSummary); + } else { + // If we already rejected importing a callee at the same or higher + // threshold, don't waste time calling selectCallee. + if (PreviouslyVisited && NewThreshold <= ProcessedThreshold) { + LLVM_DEBUG( + dbgs() << "ignored! Target was already rejected with Threshold " + << ProcessedThreshold << "\n"); + continue; + } - // "Resolve" the summary - const auto *ResolvedCalleeSummary = cast(CalleeSummary->getBaseObject()); + CalleeSummary = selectCallee(Index, VI.getSummaryList(), NewThreshold, + Summary.modulePath()); + if (!CalleeSummary) { + // Update with new larger threshold if this was a retry (otherwise + // we would have already inserted with NewThreshold above). + if (PreviouslyVisited) + ProcessedThreshold = NewThreshold; + LLVM_DEBUG( + dbgs() << "ignored! No qualifying callee with summary found.\n"); + continue; + } - assert(ResolvedCalleeSummary->instCount() <= NewThreshold && - "selectCallee() didn't honor the threshold"); + // "Resolve" the summary + CalleeSummary = CalleeSummary->getBaseObject(); + ResolvedCalleeSummary = cast(CalleeSummary); + + assert(ResolvedCalleeSummary->instCount() <= NewThreshold && + "selectCallee() didn't honor the threshold"); + + auto ExportModulePath = ResolvedCalleeSummary->modulePath(); + auto ILI = ImportList[ExportModulePath].insert(VI.getGUID()); + // We previously decided to import this GUID definition if it was already + // inserted in the set of imports from the exporting module. + bool PreviouslyImported = !ILI.second; + + // Make exports in the source module. + if (ExportLists) { + auto &ExportList = (*ExportLists)[ExportModulePath]; + ExportList.insert(VI.getGUID()); + if (!PreviouslyImported) { + // This is the first time this function was exported from its source + // module, so mark all functions and globals it references as exported + // to the outside if they are defined in the same source module. + // For efficiency, we unconditionally add all the referenced GUIDs + // to the ExportList for this module, and will prune out any not + // defined in the module later in a single pass. + for (auto &Edge : ResolvedCalleeSummary->calls()) { + auto CalleeGUID = Edge.first.getGUID(); + ExportList.insert(CalleeGUID); + } + for (auto &Ref : ResolvedCalleeSummary->refs()) { + auto GUID = Ref.getGUID(); + ExportList.insert(GUID); + } + } + } + } auto GetAdjustedThreshold = [](unsigned Threshold, bool IsHotCallsite) { // Adjust the threshold for next level of imported functions. @@ -342,44 +409,8 @@ static void computeImportForFunction( Edge.second.getHotness() == CalleeInfo::HotnessType::Hot; const auto AdjThreshold = GetAdjustedThreshold(Threshold, IsHotCallsite); - auto ExportModulePath = ResolvedCalleeSummary->modulePath(); - auto &ProcessedThreshold = ImportList[ExportModulePath][VI.getGUID()]; - /// Since the traversal of the call graph is DFS, we can revisit a function - /// a second time with a higher threshold. In this case, it is added back to - /// the worklist with the new threshold. - if (ProcessedThreshold && ProcessedThreshold >= AdjThreshold) { - LLVM_DEBUG(dbgs() << "ignored! Target was already seen with Threshold " - << ProcessedThreshold << "\n"); - continue; - } - bool PreviouslyImported = ProcessedThreshold != 0; - // Mark this function as imported in this module, with the current Threshold - ProcessedThreshold = AdjThreshold; - ImportCount++; - // Make exports in the source module. - if (ExportLists) { - auto &ExportList = (*ExportLists)[ExportModulePath]; - ExportList.insert(VI.getGUID()); - if (!PreviouslyImported) { - // This is the first time this function was exported from its source - // module, so mark all functions and globals it references as exported - // to the outside if they are defined in the same source module. - // For efficiency, we unconditionally add all the referenced GUIDs - // to the ExportList for this module, and will prune out any not - // defined in the module later in a single pass. - for (auto &Edge : ResolvedCalleeSummary->calls()) { - auto CalleeGUID = Edge.first.getGUID(); - ExportList.insert(CalleeGUID); - } - for (auto &Ref : ResolvedCalleeSummary->refs()) { - auto GUID = Ref.getGUID(); - ExportList.insert(GUID); - } - } - } - // Insert the newly imported function to the worklist. Worklist.emplace_back(ResolvedCalleeSummary, AdjThreshold, VI.getGUID()); } @@ -395,6 +426,7 @@ static void ComputeImportForModule( // Worklist contains the list of function imported in this module, for which // we will analyse the callees and may import further down the callgraph. SmallVector Worklist; + FunctionImporter::ImportThresholdsTy ImportThresholds; // Populate the worklist with the import for the functions in the current // module @@ -416,7 +448,7 @@ static void ComputeImportForModule( LLVM_DEBUG(dbgs() << "Initialize import for " << VI << "\n"); computeImportForFunction(*FuncSummary, Index, ImportInstrLimit, DefinedGVSummaries, Worklist, ImportList, - ExportLists); + ExportLists, ImportThresholds); } // Process the newly imported functions and add callees to the worklist. @@ -424,17 +456,10 @@ static void ComputeImportForModule( auto FuncInfo = Worklist.pop_back_val(); auto *Summary = std::get<0>(FuncInfo); auto Threshold = std::get<1>(FuncInfo); - auto GUID = std::get<2>(FuncInfo); - - // Check if we later added this summary with a higher threshold. - // If so, skip this entry. - auto ExportModulePath = Summary->modulePath(); - auto &LatestProcessedThreshold = ImportList[ExportModulePath][GUID]; - if (LatestProcessedThreshold > Threshold) - continue; computeImportForFunction(*Summary, Index, Threshold, DefinedGVSummaries, - Worklist, ImportList, ExportLists); + Worklist, ImportList, ExportLists, + ImportThresholds); } } @@ -451,11 +476,6 @@ static bool isGlobalVarSummary(const ModuleSummaryIndex &Index, static GlobalValue::GUID getGUID(GlobalValue::GUID G) { return G; } -static GlobalValue::GUID -getGUID(const std::pair &P) { - return P.first; -} - template static unsigned numGlobalVarSummaries(const ModuleSummaryIndex &Index, T &Cont) { @@ -574,9 +594,8 @@ void llvm::ComputeCrossModuleImportForModuleFromIndex( // e.g. record required linkage changes. if (Summary->modulePath() == ModulePath) continue; - // Doesn't matter what value we plug in to the map, just needs an entry - // to provoke importing by thinBackend. - ImportList[Summary->modulePath()][GUID] = 1; + // Add an entry to provoke importing by thinBackend. + ImportList[Summary->modulePath()].insert(GUID); } #ifndef NDEBUG dumpImportListForModule(Index, ModulePath, ImportList); @@ -698,10 +717,10 @@ void llvm::gatherImportedSummariesForModule( const auto &DefinedGVSummaries = ModuleToDefinedGVSummaries.lookup(ILI.first()); for (auto &GI : ILI.second) { - const auto &DS = DefinedGVSummaries.find(GI.first); + const auto &DS = DefinedGVSummaries.find(GI); assert(DS != DefinedGVSummaries.end() && "Expected a defined summary for imported global value"); - SummariesForIndex[GI.first] = DS->second; + SummariesForIndex[GI] = DS->second; } } } diff --git a/llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved1.ll b/llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved1.ll new file mode 100644 index 0000000..2b2443c --- /dev/null +++ b/llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved1.ll @@ -0,0 +1,34 @@ +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.11.0" + +define void @foo() { + call void @linkonceodrfunc() + call void @linkonceodrfunc2() + ret void +} + +define linkonce_odr void @linkonceodrfunc() { + call void @f() + call void @f() + call void @f() + call void @f() + call void @f() + call void @f() + call void @f() + ret void +} + +define linkonce_odr void @linkonceodrfunc2() { + call void @f() + call void @f() + call void @f() + call void @f() + call void @f() + call void @f() + call void @f() + ret void +} + +define internal void @f() { + ret void +} diff --git a/llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved2.ll b/llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved2.ll new file mode 100644 index 0000000..278a7f4 --- /dev/null +++ b/llvm/test/Transforms/FunctionImport/Inputs/funcimport_resolved2.ll @@ -0,0 +1,6 @@ +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.11.0" + +define linkonce_odr void @linkonceodrfunc() { + ret void +} diff --git a/llvm/test/Transforms/FunctionImport/Inputs/hotness_based_import2.ll b/llvm/test/Transforms/FunctionImport/Inputs/hotness_based_import2.ll deleted file mode 100644 index 4f17cb2..0000000 --- a/llvm/test/Transforms/FunctionImport/Inputs/hotness_based_import2.ll +++ /dev/null @@ -1,42 +0,0 @@ -; ModuleID = 'thinlto-function-summary-callgraph-profile-summary2.ll' -target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" -target triple = "x86_64-unknown-linux-gnu" - - -define void @hot() #1 !prof !28 { - call void @calledFromHot() - ret void -} - -; 9 instructions so it is above decayed cold threshold of 7 and below -; decayed hot threshold of 10. -define void @calledFromHot() !prof !28 { - %b = alloca i32, align 4 - store i32 1, i32* %b, align 4 - store i32 1, i32* %b, align 4 - store i32 1, i32* %b, align 4 - store i32 1, i32* %b, align 4 - store i32 1, i32* %b, align 4 - store i32 1, i32* %b, align 4 - store i32 1, i32* %b, align 4 - ret void -} - -!llvm.module.flags = !{!1} - -!1 = !{i32 1, !"ProfileSummary", !2} -!2 = !{!3, !4, !5, !6, !7, !8, !9, !10} -!3 = !{!"ProfileFormat", !"InstrProf"} -!4 = !{!"TotalCount", i64 222} -!5 = !{!"MaxCount", i64 110} -!6 = !{!"MaxInternalCount", i64 1} -!7 = !{!"MaxFunctionCount", i64 110} -!8 = !{!"NumCounts", i64 4} -!9 = !{!"NumFunctions", i64 3} -!10 = !{!"DetailedSummary", !11} -!11 = !{!12, !13, !14} -!12 = !{i32 10000, i64 110, i32 2} -!13 = !{i32 999000, i64 2, i32 4} -!14 = !{i32 999999, i64 2, i32 4} -!28 = !{!"function_entry_count", i64 110} -!29 = !{!"function_entry_count", i64 1} diff --git a/llvm/test/Transforms/FunctionImport/funcimport_resolved.ll b/llvm/test/Transforms/FunctionImport/funcimport_resolved.ll new file mode 100644 index 0000000..b256a61 --- /dev/null +++ b/llvm/test/Transforms/FunctionImport/funcimport_resolved.ll @@ -0,0 +1,52 @@ +; Test to ensure that we always select the same copy of a linkonce function +; when it is encountered with different thresholds. When we encounter the +; copy in funcimport_resolved1.ll with a higher threshold via the direct call +; from main(), it will be selected for importing. When we encounter it with a +; lower threshold by reaching it from the deeper call chain via foo(), it +; won't be selected for importing. We don't want to select both the copy from +; funcimport_resolved1.ll and the smaller one from funcimport_resolved2.ll, +; leaving it up to the backend to figure out which one to actually import. +; The linkonce_odr may have different instruction counts in practice due to +; different inlines in the compile step. + +; Require asserts so we can use -debug-only +; REQUIRES: asserts + +; REQUIRES: x86-registered-target + +; RUN: opt -module-summary %s -o %t.bc +; RUN: opt -module-summary %p/Inputs/funcimport_resolved1.ll -o %t2.bc +; RUN: opt -module-summary %p/Inputs/funcimport_resolved2.ll -o %t3.bc + +; First do a sanity check that all callees are imported with the default +; instruction limit +; RUN: llvm-lto2 run %t.bc %t2.bc %t3.bc -o %t4 -r=%t.bc,_main,pl -r=%t.bc,_linkonceodrfunc,l -r=%t.bc,_foo,l -r=%t2.bc,_foo,pl -r=%t2.bc,_linkonceodrfunc,pl -r=%t2.bc,_linkonceodrfunc2,pl -r=%t3.bc,_linkonceodrfunc,l -thinlto-threads=1 -debug-only=function-import 2>&1 | FileCheck %s --check-prefix=INSTLIMDEFAULT +; INSTLIMDEFAULT: Is importing function {{.*}} foo from {{.*}}funcimport_resolved1.ll +; INSTLIMDEFAULT: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved1.ll +; INSTLIMDEFAULT: Is importing function {{.*}} linkonceodrfunc2 from {{.*}}funcimport_resolved1.ll +; INSTLIMDEFAULT: Is importing function {{.*}} f from {{.*}}funcimport_resolved1.ll +; INSTLIMDEFAULT-NOT: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved2.ll + +; Now run with the lower threshold that will only allow linkonceodrfunc to be +; imported from funcimport_resolved1.ll when encountered via the direct call +; from main(). Ensure we don't also select the copy in funcimport_resolved2.ll +; when it is encountered via the deeper call chain. +; RUN: llvm-lto2 run %t.bc %t2.bc %t3.bc -o %t4 -r=%t.bc,_main,pl -r=%t.bc,_linkonceodrfunc,l -r=%t.bc,_foo,l -r=%t2.bc,_foo,pl -r=%t2.bc,_linkonceodrfunc,pl -r=%t2.bc,_linkonceodrfunc2,pl -r=%t3.bc,_linkonceodrfunc,l -thinlto-threads=1 -debug-only=function-import -import-instr-limit=8 2>&1 | FileCheck %s --check-prefix=INSTLIM8 +; INSTLIM8: Is importing function {{.*}} foo from {{.*}}funcimport_resolved1.ll +; INSTLIM8: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved1.ll +; INSTLIM8: Not importing function {{.*}} linkonceodrfunc2 from {{.*}}funcimport_resolved1.ll +; INSTLIM8: Is importing function {{.*}} f from {{.*}}funcimport_resolved1.ll +; INSTLIM8-NOT: Is importing function {{.*}} linkonceodrfunc from {{.*}}funcimport_resolved2.ll + +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.11.0" + +define i32 @main() #0 { +entry: + call void (...) @foo() + call void (...) @linkonceodrfunc() + ret i32 0 +} + +declare void @foo(...) #1 +declare void @linkonceodrfunc(...) #1 diff --git a/llvm/test/Transforms/FunctionImport/hotness_based_import2.ll b/llvm/test/Transforms/FunctionImport/hotness_based_import2.ll deleted file mode 100644 index 50de331..0000000 --- a/llvm/test/Transforms/FunctionImport/hotness_based_import2.ll +++ /dev/null @@ -1,53 +0,0 @@ -; Test to check that callee reached from cold and then hot path gets -; hot thresholds. -; RUN: opt -module-summary %s -o %t.bc -; RUN: opt -module-summary %p/Inputs/hotness_based_import2.ll -o %t2.bc -; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc - -; Teset with limit set to 10 and multipliers set to 1. Since cold call to -; hot is first in the other module, we'll first add calledFromHot to worklist -; with threshold decayed by default 0.7 factor. Test ensures that when we -; encounter it again from hot path, we re-enqueue with higher non-decayed -; threshold which will allow it to be imported. -; RUN: opt -function-import -summary-file %t3.thinlto.bc %t.bc -import-instr-limit=10 -import-hot-multiplier=1.0 -import-cold-multiplier=1.0 -S | FileCheck %s --check-prefix=CHECK -; CHECK-DAG: define available_externally void @hot() -; CHECK-DAG: define available_externally void @calledFromHot() - -; ModuleID = 'thinlto-function-summary-callgraph.ll' -target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" -target triple = "x86_64-unknown-linux-gnu" - -; This function has a high profile count, so entry block is hot. -define void @hot_function(i1 %a, i1 %a2) !prof !28 { -entry: - call void @hot() - ret void -} - -; This function has a low profile count, so entry block is hot. -define void @cold_function(i1 %a, i1 %a2) !prof !29 { -entry: - call void @hot() - ret void -} - -declare void @hot() #1 - -!llvm.module.flags = !{!1} - -!1 = !{i32 1, !"ProfileSummary", !2} -!2 = !{!3, !4, !5, !6, !7, !8, !9, !10} -!3 = !{!"ProfileFormat", !"InstrProf"} -!4 = !{!"TotalCount", i64 222} -!5 = !{!"MaxCount", i64 110} -!6 = !{!"MaxInternalCount", i64 1} -!7 = !{!"MaxFunctionCount", i64 110} -!8 = !{!"NumCounts", i64 4} -!9 = !{!"NumFunctions", i64 3} -!10 = !{!"DetailedSummary", !11} -!11 = !{!12, !13, !14} -!12 = !{i32 10000, i64 110, i32 2} -!13 = !{i32 999000, i64 2, i32 4} -!14 = !{i32 999999, i64 2, i32 4} -!28 = !{!"function_entry_count", i64 110} -!29 = !{!"function_entry_count", i64 1} diff --git a/llvm/tools/llvm-link/llvm-link.cpp b/llvm/tools/llvm-link/llvm-link.cpp index a50b26d..b7a8883 100644 --- a/llvm/tools/llvm-link/llvm-link.cpp +++ b/llvm/tools/llvm-link/llvm-link.cpp @@ -262,7 +262,7 @@ static bool importFunctions(const char *argv0, Module &DestModule) { errs() << "Importing " << FunctionName << " from " << FileName << "\n"; auto &Entry = ImportList[FileName]; - Entry.insert(std::make_pair(F->getGUID(), /* (Unused) threshold */ 1.0)); + Entry.insert(F->getGUID()); } auto CachedModuleLoader = [&](StringRef Identifier) { return ModuleLoaderCache.takeModule(Identifier);