Index: include/llvm/Bitcode/LLVMBitCodes.h =================================================================== --- include/llvm/Bitcode/LLVMBitCodes.h +++ include/llvm/Bitcode/LLVMBitCodes.h @@ -195,27 +195,27 @@ // The summary section uses different codes in the per-module // and combined index cases. enum GlobalValueSummarySymtabCodes { - // PERMODULE: [valueid, linkage, instcount, numrefs, numrefs x valueid, + // PERMODULE: [valueid, flags, instcount, numrefs, numrefs x valueid, // n x (valueid, callsitecount)] FS_PERMODULE = 1, - // PERMODULE_PROFILE: [valueid, linkage, instcount, numrefs, + // PERMODULE_PROFILE: [valueid, flags, instcount, numrefs, // numrefs x valueid, // n x (valueid, callsitecount, profilecount)] FS_PERMODULE_PROFILE = 2, - // PERMODULE_GLOBALVAR_INIT_REFS: [valueid, linkage, n x valueid] + // PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid] FS_PERMODULE_GLOBALVAR_INIT_REFS = 3, - // COMBINED: [modid, linkage, instcount, numrefs, numrefs x valueid, + // COMBINED: [modid, flags, instcount, numrefs, numrefs x valueid, // n x (valueid, callsitecount)] FS_COMBINED = 4, - // COMBINED_PROFILE: [modid, linkage, instcount, numrefs, + // COMBINED_PROFILE: [modid, flags, instcount, numrefs, // numrefs x valueid, // n x (valueid, callsitecount, profilecount)] FS_COMBINED_PROFILE = 5, - // COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid] + // COMBINED_GLOBALVAR_INIT_REFS: [modid, flags, n x valueid] FS_COMBINED_GLOBALVAR_INIT_REFS = 6, - // ALIAS: [valueid, linkage, valueid] + // ALIAS: [valueid, flags, valueid] FS_ALIAS = 7, - // COMBINED_ALIAS: [modid, linkage, offset] + // COMBINED_ALIAS: [modid, flags, offset] FS_COMBINED_ALIAS = 8, // COMBINED_ORIGINAL_NAME: [original_name_hash] FS_COMBINED_ORIGINAL_NAME = 9, Index: include/llvm/IR/ModuleSummaryIndex.h =================================================================== --- include/llvm/IR/ModuleSummaryIndex.h +++ include/llvm/IR/ModuleSummaryIndex.h @@ -92,6 +92,22 @@ /// \brief Sububclass discriminator (for dyn_cast<> et al.) enum SummaryKind { AliasKind, FunctionKind, GlobalVarKind }; + /// Group flags (Linkage, hasSection, isOptSize, etc.) as a bitfield. + struct GVFlags { + /// \brief The linkage type of the associated global value. + /// + /// One use is to flag values that have local linkage types and need to + /// have module identifier appended before placing into the combined + /// index, to disambiguate from other values with the same name. + /// In the future this will be used to update and optimize linkage + /// types based on global summary-based analysis. + GlobalValue::LinkageTypes Linkage : 4; + + /// Convenience Constructors + explicit GVFlags(GlobalValue::LinkageTypes Linkage) : Linkage(Linkage) {} + GVFlags(const GlobalValue &GV) : Linkage(GV.getLinkage()) {} + }; + private: /// Kind of summary for use in dyn_cast<> et al. SummaryKind Kind; @@ -110,14 +126,7 @@ /// module path string table. StringRef ModulePath; - /// \brief The linkage type of the associated global value. - /// - /// One use is to flag values that have local linkage types and need to - /// have module identifier appended before placing into the combined - /// index, to disambiguate from other values with the same name. - /// In the future this will be used to update and optimize linkage - /// types based on global summary-based analysis. - GlobalValue::LinkageTypes Linkage; + GVFlags Flags; /// List of values referenced by this global value's definition /// (either by the initializer of a global variable, or referenced @@ -127,8 +136,7 @@ protected: /// GlobalValueSummary constructor. - GlobalValueSummary(SummaryKind K, GlobalValue::LinkageTypes Linkage) - : Kind(K), Linkage(Linkage) {} + GlobalValueSummary(SummaryKind K, GVFlags Flags) : Kind(K), Flags(Flags) {} public: virtual ~GlobalValueSummary() = default; @@ -150,8 +158,11 @@ /// Get the path to the module containing this function. StringRef modulePath() const { return ModulePath; } + /// Get the flags for this GlobalValue (see \p struct GVFlags). + GVFlags flags() { return Flags; } + /// Return linkage type recorded for this global value. - GlobalValue::LinkageTypes linkage() const { return Linkage; } + GlobalValue::LinkageTypes linkage() const { return Flags.Linkage; } /// Record a reference from this global value to the global value identified /// by \p RefGUID. @@ -179,8 +190,7 @@ public: /// Summary constructors. - AliasSummary(GlobalValue::LinkageTypes Linkage) - : GlobalValueSummary(AliasKind, Linkage) {} + AliasSummary(GVFlags Flags) : GlobalValueSummary(AliasKind, Flags) {} /// Check if this is an alias summary. static bool classof(const GlobalValueSummary *GVS) { @@ -216,8 +226,8 @@ public: /// Summary constructors. - FunctionSummary(GlobalValue::LinkageTypes Linkage, unsigned NumInsts) - : GlobalValueSummary(FunctionKind, Linkage), InstCount(NumInsts) {} + FunctionSummary(GVFlags Flags, unsigned NumInsts) + : GlobalValueSummary(FunctionKind, Flags), InstCount(NumInsts) {} /// Check if this is a function summary. static bool classof(const GlobalValueSummary *GVS) { @@ -263,8 +273,7 @@ public: /// Summary constructors. - GlobalVarSummary(GlobalValue::LinkageTypes Linkage) - : GlobalValueSummary(GlobalVarKind, Linkage) {} + GlobalVarSummary(GVFlags Flags) : GlobalValueSummary(GlobalVarKind, Flags) {} /// Check if this is a global variable summary. static bool classof(const GlobalValueSummary *GVS) { Index: lib/Analysis/ModuleSummaryAnalysis.cpp =================================================================== --- lib/Analysis/ModuleSummaryAnalysis.cpp +++ lib/Analysis/ModuleSummaryAnalysis.cpp @@ -95,8 +95,9 @@ findRefEdges(&*I, RefEdges, Visited); } + GlobalValueSummary::GVFlags Flags(F); std::unique_ptr FuncSummary = - llvm::make_unique(F.getLinkage(), NumInsts); + llvm::make_unique(Flags, NumInsts); FuncSummary->addCallGraphEdges(CallGraphEdges); FuncSummary->addRefEdges(RefEdges); std::unique_ptr GVInfo = @@ -108,8 +109,9 @@ DenseSet RefEdges; SmallPtrSet Visited; findRefEdges(&V, RefEdges, Visited); + GlobalValueSummary::GVFlags Flags(V); std::unique_ptr GVarSummary = - llvm::make_unique(V.getLinkage()); + llvm::make_unique(Flags); GVarSummary->addRefEdges(RefEdges); std::unique_ptr GVInfo = llvm::make_unique(0, std::move(GVarSummary)); Index: lib/Bitcode/Reader/BitcodeReader.cpp =================================================================== --- lib/Bitcode/Reader/BitcodeReader.cpp +++ lib/Bitcode/Reader/BitcodeReader.cpp @@ -718,6 +718,16 @@ } } +// Decode the flags for GlobalValue in the summary +static GlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags, + uint64_t Version) { + // Summary were not emitted before LLVM 3.9, we don't need to upgrade Linkage + // like getDecodedLinkage() above. Any future change to the linkage enum and + // to getDecodedLinkage() will need to be taken into account here as above. + auto Linkage = GlobalValue::LinkageTypes(RawFlags & 0xF); // 4 bits + return GlobalValueSummary::GVFlags(Linkage); +} + static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) { switch (Val) { default: // Map unknown visibilities to default. @@ -5940,19 +5950,20 @@ switch (BitCode) { default: // Default behavior: ignore. break; - // FS_PERMODULE: [valueid, linkage, instcount, numrefs, numrefs x valueid, + // FS_PERMODULE: [valueid, flags, instcount, numrefs, numrefs x valueid, // n x (valueid, callsitecount)] - // FS_PERMODULE_PROFILE: [valueid, linkage, instcount, numrefs, + // FS_PERMODULE_PROFILE: [valueid, flags, instcount, numrefs, // numrefs x valueid, // n x (valueid, callsitecount, profilecount)] case bitc::FS_PERMODULE: case bitc::FS_PERMODULE_PROFILE: { unsigned ValueID = Record[0]; - uint64_t RawLinkage = Record[1]; + uint64_t RawFlags = Record[1]; unsigned InstCount = Record[2]; unsigned NumRefs = Record[3]; - std::unique_ptr FS = llvm::make_unique( - getDecodedLinkage(RawLinkage), InstCount); + auto Flags = getDecodedGVSummaryFlags(RawFlags, Version); + std::unique_ptr FS = + llvm::make_unique(Flags, InstCount); // 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 @@ -5986,15 +5997,15 @@ Info->setSummary(std::move(FS)); break; } - // FS_ALIAS: [valueid, linkage, valueid] + // FS_ALIAS: [valueid, flags, 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]; + uint64_t RawFlags = Record[1]; unsigned AliaseeID = Record[2]; - std::unique_ptr AS = - llvm::make_unique(getDecodedLinkage(RawLinkage)); + auto Flags = getDecodedGVSummaryFlags(RawFlags, Version); + std::unique_ptr AS = llvm::make_unique(Flags); // 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 @@ -6015,12 +6026,13 @@ Info->setSummary(std::move(AS)); break; } - // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, linkage, n x valueid] + // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid] case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: { unsigned ValueID = Record[0]; - uint64_t RawLinkage = Record[1]; + uint64_t RawFlags = Record[1]; + auto Flags = getDecodedGVSummaryFlags(RawFlags, Version); std::unique_ptr FS = - llvm::make_unique(getDecodedLinkage(RawLinkage)); + llvm::make_unique(Flags); FS->setModulePath( TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first()); for (unsigned I = 2, E = Record.size(); I != E; ++I) { @@ -6034,19 +6046,20 @@ Info->setSummary(std::move(FS)); break; } - // FS_COMBINED: [modid, linkage, instcount, numrefs, numrefs x valueid, + // FS_COMBINED: [modid, flags, instcount, numrefs, numrefs x valueid, // n x (valueid, callsitecount)] - // FS_COMBINED_PROFILE: [modid, linkage, instcount, numrefs, + // FS_COMBINED_PROFILE: [modid, flags, instcount, numrefs, // numrefs x valueid, // n x (valueid, callsitecount, profilecount)] case bitc::FS_COMBINED: case bitc::FS_COMBINED_PROFILE: { uint64_t ModuleId = Record[0]; - uint64_t RawLinkage = Record[1]; + uint64_t RawFlags = Record[1]; unsigned InstCount = Record[2]; unsigned NumRefs = Record[3]; - std::unique_ptr FS = llvm::make_unique( - getDecodedLinkage(RawLinkage), InstCount); + auto Flags = getDecodedGVSummaryFlags(RawFlags, Version); + std::unique_ptr FS = + llvm::make_unique(Flags, InstCount); LastSeenSummary = FS.get(); FS->setModulePath(ModuleIdMap[ModuleId]); static int RefListStartIndex = 4; @@ -6074,15 +6087,15 @@ Combined = true; break; } - // FS_COMBINED_ALIAS: [modid, linkage, offset] + // FS_COMBINED_ALIAS: [modid, flags, 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 RawFlags = Record[1]; uint64_t AliaseeSummaryOffset = Record[2]; - std::unique_ptr AS = - llvm::make_unique(getDecodedLinkage(RawLinkage)); + auto Flags = getDecodedGVSummaryFlags(RawFlags, Version); + std::unique_ptr AS = llvm::make_unique(Flags); LastSeenSummary = AS.get(); AS->setModulePath(ModuleIdMap[ModuleId]); @@ -6097,12 +6110,13 @@ Combined = true; break; } - // FS_COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid] + // FS_COMBINED_GLOBALVAR_INIT_REFS: [modid, flags, n x valueid] case bitc::FS_COMBINED_GLOBALVAR_INIT_REFS: { uint64_t ModuleId = Record[0]; - uint64_t RawLinkage = Record[1]; + uint64_t RawFlags = Record[1]; + auto Flags = getDecodedGVSummaryFlags(RawFlags, Version); std::unique_ptr FS = - llvm::make_unique(getDecodedLinkage(RawLinkage)); + llvm::make_unique(Flags); LastSeenSummary = FS.get(); FS->setModulePath(ModuleIdMap[ModuleId]); for (unsigned I = 2, E = Record.size(); I != E; ++I) { Index: lib/Bitcode/Writer/BitcodeWriter.cpp =================================================================== --- lib/Bitcode/Writer/BitcodeWriter.cpp +++ lib/Bitcode/Writer/BitcodeWriter.cpp @@ -786,6 +786,14 @@ return getEncodedLinkage(GV.getLinkage()); } +// Decode the flags for GlobalValue in the summary +static uint64_t getEncodedGVSummaryFlags(GlobalValueSummary::GVFlags Flags) { + uint64_t RawFlags = 0; + // Emit Linkage enum. + RawFlags |= Flags.Linkage; // 4 bits + return RawFlags; +} + static unsigned getEncodedVisibility(const GlobalValue &GV) { switch (GV.getVisibility()) { case GlobalValue::DefaultVisibility: return 0; @@ -3021,7 +3029,7 @@ NameVals.push_back(ValueID); FunctionSummary *FS = cast(Info->summary()); - NameVals.push_back(getEncodedLinkage(FS->linkage())); + NameVals.push_back(getEncodedGVSummaryFlags(FS->flags())); NameVals.push_back(FS->instCount()); NameVals.push_back(FS->refs().size()); @@ -3055,7 +3063,7 @@ if (V.isDeclaration()) return; NameVals.push_back(VE.getValueID(&V)); - NameVals.push_back(getEncodedLinkage(V.getLinkage())); + NameVals.push_back(getEncodedGVSummaryFlags(V)); auto *Info = Index->getGlobalValueInfo(V); GlobalVarSummary *VS = cast(Info->summary()); for (auto Ref : VS->refs()) @@ -3079,7 +3087,7 @@ if (Index->begin() == Index->end()) return; - Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3); + Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 4); Stream.EmitRecord(bitc::FS_VERSION, ArrayRef{INDEX_VERSION}); @@ -3087,7 +3095,7 @@ BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs // numrefs x valueid, n x (valueid, callsitecount) @@ -3099,7 +3107,7 @@ Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_PROFILE)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs // numrefs x valueid, n x (valueid, callsitecount, profilecount) @@ -3111,7 +3119,7 @@ Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); // valueids Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv); @@ -3120,7 +3128,7 @@ 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, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv); @@ -3155,7 +3163,7 @@ auto AliasId = VE.getValueID(&A); auto AliaseeId = VE.getValueID(Aliasee); NameVals.push_back(AliasId); - NameVals.push_back(getEncodedLinkage(A.getLinkage())); + NameVals.push_back(getEncodedGVSummaryFlags(A)); NameVals.push_back(AliaseeId); Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev); NameVals.clear(); @@ -3173,7 +3181,7 @@ BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs // numrefs x valueid, n x (valueid, callsitecount) @@ -3185,7 +3193,7 @@ Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_PROFILE)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs // numrefs x valueid, n x (valueid, callsitecount, profilecount) @@ -3197,7 +3205,7 @@ Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); // valueids Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv); @@ -3206,7 +3214,7 @@ 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, 6)); // flags Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // offset unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv); @@ -3241,7 +3249,7 @@ if (auto *VS = dyn_cast(S)) { NameVals.push_back(Index.getModuleId(VS->modulePath())); - NameVals.push_back(getEncodedLinkage(VS->linkage())); + NameVals.push_back(getEncodedGVSummaryFlags(VS->flags())); for (auto &RI : VS->refs()) { NameVals.push_back(getValueId(RI.getGUID())); } @@ -3264,7 +3272,7 @@ auto *FS = cast(S); NameVals.push_back(Index.getModuleId(FS->modulePath())); - NameVals.push_back(getEncodedLinkage(FS->linkage())); + NameVals.push_back(getEncodedGVSummaryFlags(FS->flags())); NameVals.push_back(FS->instCount()); NameVals.push_back(FS->refs().size()); @@ -3313,7 +3321,7 @@ for (auto GVI : Aliases) { AliasSummary *AS = cast(GVI->summary()); NameVals.push_back(Index.getModuleId(AS->modulePath())); - NameVals.push_back(getEncodedLinkage(AS->linkage())); + NameVals.push_back(getEncodedGVSummaryFlags(AS->flags())); auto AliaseeOffset = SummaryToOffsetMap[&AS->getAliasee()]; assert(AliaseeOffset); NameVals.push_back(AliaseeOffset); Index: test/Bitcode/thinlto-function-summary-refgraph.ll =================================================================== --- test/Bitcode/thinlto-function-summary-refgraph.ll +++ test/Bitcode/thinlto-function-summary-refgraph.ll @@ -13,18 +13,18 @@ ; Function main contains call to func, as well as address reference to func: ; CHECK-DAG: ; Function W contains a call to func3 as well as a reference to globalvar: -; CHECK-DAG: +; CHECK-DAG: ; Function X contains call to foo, as well as address reference to foo ; which is in the same instruction as the call: -; CHECK-DAG: +; CHECK-DAG: ; Function Y contains call to func2, and ensures we don't incorrectly add ; a reference to it when reached while earlier analyzing the phi using its ; return value: -; CHECK-DAG: +; CHECK-DAG: ; Function Z contains call to func2, and ensures we don't incorrectly add ; a reference to it when reached while analyzing subsequent use of its return ; value: -; CHECK-DAG: +; CHECK-DAG: ; Variable bar initialization contains address reference to func: ; CHECK-DAG: ; CHECK: Index: test/Bitcode/thinlto-function-summary.ll =================================================================== --- test/Bitcode/thinlto-function-summary.ll +++ test/Bitcode/thinlto-function-summary.ll @@ -7,7 +7,7 @@ ; BC: