From 2d28f7aa07483ba57428c654170467966581849c Mon Sep 17 00:00:00 2001 From: Mehdi Amini Date: Sat, 16 Apr 2016 06:56:44 +0000 Subject: [PATCH] ThinLTO: Make aliases explicit in the summary To be able to work accurately on the reference graph when taking decision about internalizing, promoting, renaming, etc. We need to have the alias information explicit. Differential Revision: http://reviews.llvm.org/D18836 From: Mehdi Amini llvm-svn: 266517 --- llvm/include/llvm/Bitcode/LLVMBitCodes.h | 4 ++ llvm/include/llvm/IR/ModuleSummaryIndex.h | 30 +++++++- llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 51 ++++++++++++++ llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 70 +++++++++++++++++- llvm/lib/IR/ModuleSummaryIndex.cpp | 2 +- llvm/lib/Transforms/IPO/FunctionImport.cpp | 86 ++++++++++++++--------- llvm/test/Bitcode/Inputs/thinlto-alias.ll | 13 ++++ llvm/test/Bitcode/thinlto-alias.ll | 45 ++++++++++++ llvm/test/Bitcode/thinlto-function-summary.ll | 7 +- llvm/test/Transforms/FunctionImport/funcimport.ll | 2 +- llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp | 2 + 11 files changed, 271 insertions(+), 41 deletions(-) create mode 100644 llvm/test/Bitcode/Inputs/thinlto-alias.ll create mode 100644 llvm/test/Bitcode/thinlto-alias.ll diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h index 3ce1662..14ba158 100644 --- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h +++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h @@ -213,6 +213,10 @@ enum GlobalValueSummarySymtabCodes { FS_COMBINED_PROFILE = 5, // COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid] FS_COMBINED_GLOBALVAR_INIT_REFS = 6, + // ALIAS: [valueid, linkage, valueid] + FS_ALIAS = 7, + // COMBINED_ALIAS: [modid, linkage, offset] + FS_COMBINED_ALIAS = 8, }; enum MetadataCodes { diff --git a/llvm/include/llvm/IR/ModuleSummaryIndex.h b/llvm/include/llvm/IR/ModuleSummaryIndex.h index 8f1a1d0..b1579e9 100644 --- a/llvm/include/llvm/IR/ModuleSummaryIndex.h +++ b/llvm/include/llvm/IR/ModuleSummaryIndex.h @@ -93,7 +93,7 @@ struct ValueInfo { class GlobalValueSummary { public: /// \brief Sububclass discriminator (for dyn_cast<> et al.) - enum SummaryKind { FunctionKind, GlobalVarKind }; + enum SummaryKind { AliasKind, FunctionKind, GlobalVarKind }; private: /// Kind of summary for use in dyn_cast<> et al. @@ -164,6 +164,32 @@ public: const std::vector &refs() const { return RefEdgeList; } }; +/// \brief Alias summary information. +class AliasSummary : public GlobalValueSummary { + GlobalValueSummary *AliaseeSummary; + +public: + /// Summary constructors. + AliasSummary(GlobalValue::LinkageTypes Linkage) + : GlobalValueSummary(AliasKind, Linkage) {} + + /// Check if this is an alias summary. + static bool classof(const GlobalValueSummary *GVS) { + return GVS->getSummaryKind() == AliasKind; + } + + void setAliasee(GlobalValueSummary *Aliasee) { AliaseeSummary = Aliasee; } + + const GlobalValueSummary &getAliasee() const { + return const_cast(this)->getAliasee(); + } + + GlobalValueSummary &getAliasee() { + assert(AliaseeSummary && "Unexpected missing aliasee summary"); + return *AliaseeSummary; + } +}; + /// \brief Function summary information to aid decisions and implementation of /// importing. class FunctionSummary : public GlobalValueSummary { @@ -439,7 +465,7 @@ public: /// (GUID -> Summary). void collectDefinedFunctionsForModule( StringRef ModulePath, - std::map &FunctionInfoMap) const; + std::map &FunctionInfoMap) const; }; } // End llvm namespace diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index c832283..ad14cbc 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -5865,6 +5865,35 @@ std::error_code ModuleSummaryIndexBitcodeReader::parseEntireSummary() { Info->setSummary(std::move(FS)); break; } + // FS_ALIAS: [valueid, linkage, valueid] + // Aliases must be emitted (and parsed) after all FS_PERMODULE entries, as + // they expect all aliasee summaries to be available. + case bitc::FS_ALIAS: { + unsigned ValueID = Record[0]; + uint64_t RawLinkage = Record[1]; + unsigned AliaseeID = Record[2]; + std::unique_ptr AS = + llvm::make_unique(getDecodedLinkage(RawLinkage)); + // The module path string ref set in the summary must be owned by the + // index's module string table. Since we don't have a module path + // string table section in the per-module index, we create a single + // module path string table entry with an empty (0) ID to take + // ownership. + AS->setModulePath( + TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first()); + + GlobalValue::GUID AliaseeGUID = getGUIDFromValueId(AliaseeID); + auto *AliaseeInfo = TheIndex->getGlobalValueInfo(AliaseeGUID); + if (!AliaseeInfo->summary()) + return error("Alias expects aliasee summary to be parsed"); + AS->setAliasee(AliaseeInfo->summary()); + + GlobalValue::GUID GUID = getGUIDFromValueId(ValueID); + auto *Info = TheIndex->getGlobalValueInfo(GUID); + assert(!Info->summary() && "Expected a single summary per VST entry"); + Info->setSummary(std::move(AS)); + break; + } // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, linkage, n x valueid] case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: { unsigned ValueID = Record[0]; @@ -5923,6 +5952,28 @@ std::error_code ModuleSummaryIndexBitcodeReader::parseEntireSummary() { Combined = true; break; } + // FS_COMBINED_ALIAS: [modid, linkage, offset] + // Aliases must be emitted (and parsed) after all FS_COMBINED entries, as + // they expect all aliasee summaries to be available. + case bitc::FS_COMBINED_ALIAS: { + uint64_t ModuleId = Record[0]; + uint64_t RawLinkage = Record[1]; + uint64_t AliaseeSummaryOffset = Record[2]; + std::unique_ptr AS = + llvm::make_unique(getDecodedLinkage(RawLinkage)); + AS->setModulePath(ModuleIdMap[ModuleId]); + + auto *AliaseeInfo = getInfoFromSummaryOffset(AliaseeSummaryOffset); + if (!AliaseeInfo->summary()) + return error("Alias expects aliasee summary to be parsed"); + AS->setAliasee(AliaseeInfo->summary()); + + auto *Info = getInfoFromSummaryOffset(CurRecordBit); + assert(!Info->summary() && "Expected a single summary per VST entry"); + Info->setSummary(std::move(AS)); + Combined = true; + break; + } // FS_COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid] case bitc::FS_COMBINED_GLOBALVAR_INIT_REFS: { uint64_t ModuleId = Record[0]; diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 0d10282..45f5da8 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -2925,16 +2925,24 @@ static void WritePerModuleGlobalValueSummary(const Module *M, Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv); + // Abbrev for FS_ALIAS. + Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid + unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv); + SmallVector NameVals; // Iterate over the list of functions instead of the Index to // ensure the ordering is stable. for (const Function &F : *M) { if (F.isDeclaration()) continue; - // Skip anonymous functions. We will emit a function summary for - // any aliases below. + // Summary emission does not support anonymous functions, they have to + // renamed using the anonymous function renaming pass. if (!F.hasName()) - continue; + report_fatal_error("Unexpected anonymous function when writing summary"); auto *Info = Index.getGlobalValueInfo(F); WritePerModuleFunctionSummaryRecord( @@ -2948,6 +2956,20 @@ static void WritePerModuleGlobalValueSummary(const Module *M, for (const GlobalVariable &G : M->globals()) WriteModuleLevelReferences(G, Index, VE, NameVals, FSModRefsAbbrev, Stream); + for (const GlobalAlias &A : M->aliases()) { + auto *Aliasee = A.getBaseObject(); + if (!Aliasee->hasName()) + // Nameless function don't have an entry in the summary, skip it. + continue; + auto AliasId = VE.getValueID(&A); + auto AliaseeId = VE.getValueID(Aliasee); + NameVals.push_back(AliasId); + NameVals.push_back(getEncodedLinkage(A.getLinkage())); + NameVals.push_back(AliaseeId); + Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev); + NameVals.clear(); + } + Stream.ExitBlock(); } @@ -2991,11 +3013,31 @@ static void WriteCombinedGlobalValueSummary( Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv); + // Abbrev for FS_COMBINED_ALIAS. + Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_ALIAS)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // offset + unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv); + + // The aliases are emitted as a post-pass, and will point to the summary + // offset id of the aliasee. For this purpose we need to be able to get back + // from the summary to the offset + SmallVector Aliases; + DenseMap SummaryToOffsetMap; + SmallVector NameVals; for (const auto &FII : Index) { for (auto &FI : FII.second) { GlobalValueSummary *S = FI->summary(); assert(S); + if (isa(S)) { + // Will process aliases as a post-pass because the reader wants all + // global to be loaded first. + Aliases.push_back(FI.get()); + continue; + } if (auto *VS = dyn_cast(S)) { NameVals.push_back(Index.getModuleId(VS->modulePath())); @@ -3018,6 +3060,8 @@ static void WriteCombinedGlobalValueSummary( // reader will invoke readRecord after the abbrev id read. FI->setBitcodeIndex(Stream.GetCurrentBitNo() + Stream.GetAbbrevIDWidth()); + // Store temporarily the offset in the map for a possible alias. + SummaryToOffsetMap[S] = FI->bitcodeIndex(); // Emit the finished record. Stream.EmitRecord(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS, NameVals, @@ -3069,6 +3113,8 @@ static void WriteCombinedGlobalValueSummary( // in the VST entry. Add the current code size since the // reader will invoke readRecord after the abbrev id read. FI->setBitcodeIndex(Stream.GetCurrentBitNo() + Stream.GetAbbrevIDWidth()); + // Store temporarily the offset in the map for a possible alias. + SummaryToOffsetMap[S] = FI->bitcodeIndex(); unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev); @@ -3081,6 +3127,24 @@ static void WriteCombinedGlobalValueSummary( } } + for (auto GVI : Aliases) { + AliasSummary *AS = cast(GVI->summary()); + NameVals.push_back(Index.getModuleId(AS->modulePath())); + NameVals.push_back(getEncodedLinkage(AS->linkage())); + auto AliaseeOffset = SummaryToOffsetMap[&AS->getAliasee()]; + assert(AliaseeOffset); + NameVals.push_back(AliaseeOffset); + + // Record the starting offset of this summary entry for use + // in the VST entry. Add the current code size since the + // reader will invoke readRecord after the abbrev id read. + GVI->setBitcodeIndex(Stream.GetCurrentBitNo() + Stream.GetAbbrevIDWidth()); + + // Emit the finished record. + Stream.EmitRecord(bitc::FS_COMBINED_ALIAS, NameVals, FSAliasAbbrev); + NameVals.clear(); + } + Stream.ExitBlock(); } diff --git a/llvm/lib/IR/ModuleSummaryIndex.cpp b/llvm/lib/IR/ModuleSummaryIndex.cpp index aa34532..cc1e8a9 100644 --- a/llvm/lib/IR/ModuleSummaryIndex.cpp +++ b/llvm/lib/IR/ModuleSummaryIndex.cpp @@ -73,7 +73,7 @@ void ModuleSummaryIndex::removeEmptySummaryEntries() { // (GUID -> Summary). void ModuleSummaryIndex::collectDefinedFunctionsForModule( StringRef ModulePath, - std::map &FunctionInfoMap) const { + std::map &FunctionInfoMap) const { for (auto &GlobalList : *this) { auto GUID = GlobalList.first; for (auto &GlobInfo : GlobalList.second) { diff --git a/llvm/lib/Transforms/IPO/FunctionImport.cpp b/llvm/lib/Transforms/IPO/FunctionImport.cpp index 088b114..d6dfe17 100644 --- a/llvm/lib/Transforms/IPO/FunctionImport.cpp +++ b/llvm/lib/Transforms/IPO/FunctionImport.cpp @@ -79,13 +79,16 @@ namespace { /// number of source modules parsed/linked. /// - One that has PGO data attached. /// - [insert you fancy metric here] -static const FunctionSummary * +static const GlobalValueSummary * selectCallee(const GlobalValueInfoList &CalleeInfoList, unsigned Threshold) { auto It = llvm::find_if( CalleeInfoList, [&](const std::unique_ptr &GlobInfo) { assert(GlobInfo->summary() && "We should not have a Global Info without summary"); - auto *Summary = cast(GlobInfo->summary()); + auto *GVSummary = GlobInfo->summary(); + if (auto *AS = dyn_cast(GVSummary)) + GVSummary = &AS->getAliasee(); + auto *Summary = cast(GVSummary); if (GlobalValue::isWeakAnyLinkage(Summary->linkage())) return false; @@ -98,14 +101,14 @@ selectCallee(const GlobalValueInfoList &CalleeInfoList, unsigned Threshold) { if (It == CalleeInfoList.end()) return nullptr; - return cast((*It)->summary()); + return cast((*It)->summary()); } /// Return the summary for the function \p GUID that fits the \p Threshold, or /// null if there's no match. -static const FunctionSummary *selectCallee(GlobalValue::GUID GUID, - unsigned Threshold, - const ModuleSummaryIndex &Index) { +static const GlobalValueSummary *selectCallee(GlobalValue::GUID GUID, + unsigned Threshold, + const ModuleSummaryIndex &Index) { auto CalleeInfoList = Index.findGlobalValueInfoList(GUID); if (CalleeInfoList == Index.end()) { return nullptr; // This function does not have a summary @@ -140,7 +143,7 @@ using EdgeInfo = std::pair; static void computeImportForFunction( const FunctionSummary &Summary, const ModuleSummaryIndex &Index, unsigned Threshold, - const std::map &DefinedFunctions, + const std::map &DefinedFunctions, SmallVectorImpl &Worklist, FunctionImporter::ImportMapTy &ImportsForModule, StringMap *ExportLists = nullptr) { @@ -158,11 +161,19 @@ static void computeImportForFunction( DEBUG(dbgs() << "ignored! No qualifying callee with summary found.\n"); continue; } - assert(CalleeSummary->instCount() <= Threshold && + // "Resolve" the summary, traversing alias, + const FunctionSummary *ResolvedCalleeSummary; + if (isa(CalleeSummary)) + ResolvedCalleeSummary = cast( + &cast(CalleeSummary)->getAliasee()); + else + ResolvedCalleeSummary = cast(CalleeSummary); + + assert(ResolvedCalleeSummary->instCount() <= Threshold && "selectCallee() didn't honor the threshold"); - auto &ProcessedThreshold = - ImportsForModule[CalleeSummary->modulePath()][GUID]; + auto ExportModulePath = ResolvedCalleeSummary->modulePath(); + auto &ProcessedThreshold = ImportsForModule[ExportModulePath][GUID]; /// 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. @@ -175,18 +186,17 @@ static void computeImportForFunction( ProcessedThreshold = Threshold; // Make exports in the source module. - auto ExportModulePath = CalleeSummary->modulePath(); if (ExportLists) { auto &ExportList = (*ExportLists)[ExportModulePath]; ExportList.insert(GUID); // Mark all functions and globals referenced by this function as exported // to the outside if they are defined in the same source module. - for (auto &Edge : CalleeSummary->calls()) { + for (auto &Edge : ResolvedCalleeSummary->calls()) { auto CalleeGUID = Edge.first.getGUID(); if (isGlobalExported(Index, ExportModulePath, CalleeGUID)) ExportList.insert(CalleeGUID); } - for (auto &Ref : CalleeSummary->refs()) { + for (auto &Ref : ResolvedCalleeSummary->refs()) { auto GUID = Ref.getGUID(); if (isGlobalExported(Index, ExportModulePath, GUID)) ExportList.insert(GUID); @@ -194,7 +204,7 @@ static void computeImportForFunction( } // Insert the newly imported function to the worklist. - Worklist.push_back(std::make_pair(CalleeSummary, Threshold)); + Worklist.push_back(std::make_pair(ResolvedCalleeSummary, Threshold)); } } @@ -202,7 +212,7 @@ static void computeImportForFunction( /// as well as the list of "exports", i.e. the list of symbols referenced from /// another module (that may require promotion). static void ComputeImportForModule( - const std::map &DefinedFunctions, + const std::map &DefinedFunctions, const ModuleSummaryIndex &Index, FunctionImporter::ImportMapTy &ImportsForModule, StringMap *ExportLists = nullptr) { @@ -214,8 +224,11 @@ static void ComputeImportForModule( // module for (auto &FuncInfo : DefinedFunctions) { auto *Summary = FuncInfo.second; + if (auto *AS = dyn_cast(Summary)) + Summary = &AS->getAliasee(); + auto *FuncSummary = cast(Summary); DEBUG(dbgs() << "Initalize import for " << FuncInfo.first << "\n"); - computeImportForFunction(*Summary, Index, ImportInstrLimit, + computeImportForFunction(*FuncSummary, Index, ImportInstrLimit, DefinedFunctions, Worklist, ImportsForModule, ExportLists); } @@ -245,16 +258,20 @@ void llvm::ComputeCrossModuleImport( // Collect for each module the list of function it defines. // GUID -> Summary - StringMap> + StringMap> Module2FunctionInfoMap(ModuleCount); for (auto &GlobalList : Index) { auto GUID = GlobalList.first; for (auto &GlobInfo : GlobalList.second) { - auto *Summary = dyn_cast_or_null(GlobInfo->summary()); - if (!Summary) + auto *Summary = GlobInfo->summary(); + if (isa(Summary)) /// Ignore global variable, focus on functions continue; + if (auto *AS = dyn_cast(Summary)) + if (isa(&AS->getAliasee())) + /// Ignore alias to global variable, focus on functions + continue; DEBUG(dbgs() << "Adding definition: Module '" << Summary->modulePath() << "' defines '" << GUID << "'\n"); Module2FunctionInfoMap[Summary->modulePath()][GUID] = Summary; @@ -295,7 +312,7 @@ void llvm::ComputeCrossModuleImportForModule( // Collect the list of functions this module defines. // GUID -> Summary - std::map FunctionInfoMap; + std::map FunctionInfoMap; Index.collectDefinedFunctionsForModule(ModulePath, FunctionInfoMap); // Compute the import list for this module. @@ -358,7 +375,7 @@ bool FunctionImporter::importFunctions( GlobalsToImport.insert(&GV); } } - for (auto &GV : SrcModule->aliases()) { + for (auto &GV : SrcModule->globals()) { if (!GV.hasName()) continue; auto GUID = GV.getGUID(); @@ -367,18 +384,11 @@ bool FunctionImporter::importFunctions( << GV.getName() << " from " << SrcModule->getSourceFileName() << "\n"); if (Import) { - // Alias can't point to "available_externally". However when we import - // linkOnceODR the linkage does not change. So we import the alias - // and aliasee only in this case. - const GlobalObject *GO = GV.getBaseObject(); - if (!GO->hasLinkOnceODRLinkage()) - continue; GV.materialize(); GlobalsToImport.insert(&GV); - GlobalsToImport.insert(GO); } } - for (auto &GV : SrcModule->globals()) { + for (auto &GV : SrcModule->aliases()) { if (!GV.hasName()) continue; auto GUID = GV.getGUID(); @@ -387,6 +397,20 @@ bool FunctionImporter::importFunctions( << GV.getName() << " from " << SrcModule->getSourceFileName() << "\n"); if (Import) { + // Alias can't point to "available_externally". However when we import + // linkOnceODR the linkage does not change. So we import the alias + // and aliasee only in this case. + GlobalObject *GO = GV.getBaseObject(); + if (!GO->hasLinkOnceODRLinkage()) + continue; +#ifndef NDEBUG + if (!GlobalsToImport.count(GO)) + DEBUG(dbgs() << " alias triggers importing aliasee " << GO->getGUID() + << " " << GO->getName() << " from " + << SrcModule->getSourceFileName() << "\n"); +#endif + GO->materialize(); + GlobalsToImport.insert(GO); GV.materialize(); GlobalsToImport.insert(&GV); } @@ -464,9 +488,7 @@ public: static char ID; /// Specify pass name for debug output - const char *getPassName() const override { - return "Function Importing"; - } + const char *getPassName() const override { return "Function Importing"; } explicit FunctionImportPass(const ModuleSummaryIndex *Index = nullptr) : ModulePass(ID), Index(Index) {} diff --git a/llvm/test/Bitcode/Inputs/thinlto-alias.ll b/llvm/test/Bitcode/Inputs/thinlto-alias.ll new file mode 100644 index 0000000..5a628e8 --- /dev/null +++ b/llvm/test/Bitcode/Inputs/thinlto-alias.ll @@ -0,0 +1,13 @@ +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + + + +@analias = alias void (...), bitcast (void ()* @aliasee to void (...)*) + +; Function Attrs: nounwind uwtable +define void @aliasee() #0 { +entry: + ret void +} + diff --git a/llvm/test/Bitcode/thinlto-alias.ll b/llvm/test/Bitcode/thinlto-alias.ll new file mode 100644 index 0000000..7fe6d43 --- /dev/null +++ b/llvm/test/Bitcode/thinlto-alias.ll @@ -0,0 +1,45 @@ +; Test to check the callgraph in summary +; RUN: opt -module-summary %s -o %t.o +; RUN: llvm-bcanalyzer -dump %t.o | FileCheck %s +; RUN: opt -module-summary %p/Inputs/thinlto-alias.ll -o %t2.o +; RUN: llvm-lto -thinlto -o %t3 %t.o %t2.o +; RUN: llvm-bcanalyzer -dump %t3.thinlto.bc | FileCheck %s --check-prefix=COMBINED + +; CHECK: +; CHECK-NEXT: +; CHECK-NEXT: + +; COMBINED: +; Followed by the alias and aliasee +; COMBINED-NEXT: +; COMBINED-NEXT: +; COMBINED-NEXT: + +; 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" + +; Function Attrs: nounwind uwtable +define i32 @main() { +entry: + call void (...) @analias() + ret i32 0 +} + +declare void @analias(...) diff --git a/llvm/test/Bitcode/thinlto-function-summary.ll b/llvm/test/Bitcode/thinlto-function-summary.ll index 04a3165..639b68d 100644 --- a/llvm/test/Bitcode/thinlto-function-summary.ll +++ b/llvm/test/Bitcode/thinlto-function-summary.ll @@ -1,4 +1,4 @@ -; RUN: opt -module-summary < %s | llvm-bcanalyzer -dump | FileCheck %s -check-prefix=BC +; RUN: opt -name-anon-functions -module-summary < %s | llvm-bcanalyzer -dump | FileCheck %s -check-prefix=BC ; Check for summary block/records. ; Check the value ids in the summary entries against the @@ -7,13 +7,16 @@ ; BC: record string = 'anon. ; BC-NEXT: record string = 'foo' ; BC-NEXT: record string = 'bar' ; BC-NEXT: record string = 'f' -; RUN: opt -module-summary < %s | llvm-dis | FileCheck %s +; RUN: opt -name-anon-functions -module-summary < %s | llvm-dis | FileCheck %s ; Check that this round-trips correctly. ; ModuleID = '' diff --git a/llvm/test/Transforms/FunctionImport/funcimport.ll b/llvm/test/Transforms/FunctionImport/funcimport.ll index c56aeb5..8e059ca 100644 --- a/llvm/test/Transforms/FunctionImport/funcimport.ll +++ b/llvm/test/Transforms/FunctionImport/funcimport.ll @@ -87,7 +87,7 @@ declare void @weakfunc(...) #1 ; INSTLIM5-DAG: declare hidden void @funcwithpersonality.llvm.{{.*}}() ; INSTLIMDEF-DAG: Import globalfunc2 -; INSTLIMDEF-DAG: 9 function-import - Number of functions imported +; INSTLIMDEF-DAG: 11 function-import - Number of functions imported ; The actual GUID values will depend on path to test. ; GUID-DAG: GUID {{.*}} is weakalias diff --git a/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp b/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp index 3c23103..15893ec 100644 --- a/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp +++ b/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp @@ -308,6 +308,8 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID, STRINGIFY_CODE(FS, COMBINED) STRINGIFY_CODE(FS, COMBINED_PROFILE) STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS) + STRINGIFY_CODE(FS, ALIAS) + STRINGIFY_CODE(FS, COMBINED_ALIAS) } case bitc::METADATA_ATTACHMENT_ID: switch(CodeID) { -- 2.7.4