[llvm] [ThinLTO] Add tail call flag to call edges in summary (PR #74043)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Nov 30 22:14:44 PST 2023
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-lto
Author: Teresa Johnson (teresajohnson)
<details>
<summary>Changes</summary>
This adds support for a HasTailCall flag on function call edges in the
ThinLTO summary. It is intended for use in aiding discovery of missing
frames from tail calls in profiled call stacks for MemProf of profiled
binaries that did not disable tail call elimination. A follow on change
will add the use of this new flag during MemProf context disambiguation.
The new flag is encoded in the bitcode along with either the hotness
flag from the profile, or the relative block frequency under the
-write-relbf-to-summary flag when there is no profile data.
Because we now will always have some additional call edge information, I
have removed the non-profile function summary record format, and we
simply encode the tail call flag along with a hotness type of none when
there is no profile information or relative block frequency. The change
of record format and name caused most of the test case changes.
I have added explicit testing of generation of the new tail call flag
into the bitcode and IR assembly format as part of the changes to
llvm/test/Bitcode/thinlto-function-summary-refgraph.ll. I have also
added round trip testing through assembly and bitcode to
llvm/test/Assembler/thinlto-summary.ll.
---
Patch is 50.91 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/74043.diff
27 Files Affected:
- (modified) llvm/include/llvm/Bitcode/LLVMBitCodes.h (+3-3)
- (modified) llvm/include/llvm/IR/ModuleSummaryIndex.h (+15-5)
- (modified) llvm/lib/Analysis/ModuleSummaryAnalysis.cpp (+2)
- (modified) llvm/lib/AsmParser/LLParser.cpp (+25-8)
- (modified) llvm/lib/Bitcode/Reader/BitcodeReader.cpp (+26-6)
- (modified) llvm/lib/Bitcode/Writer/BitcodeWriter.cpp (+43-57)
- (modified) llvm/lib/IR/AsmWriter.cpp (+4)
- (modified) llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp (+2-1)
- (modified) llvm/test/Analysis/StackSafetyAnalysis/ipa.ll (+1-1)
- (modified) llvm/test/Assembler/thinlto-summary.ll (+6-4)
- (modified) llvm/test/Bitcode/thinlto-alias.ll (+3-3)
- (modified) llvm/test/Bitcode/thinlto-alias2.ll (+2-2)
- (modified) llvm/test/Bitcode/thinlto-asm-noimport.ll (+1-1)
- (modified) llvm/test/Bitcode/thinlto-function-summary-callgraph-cast.ll (+3-3)
- (modified) llvm/test/Bitcode/thinlto-function-summary-callgraph-partial-sample-profile-summary.ll (+9-9)
- (modified) llvm/test/Bitcode/thinlto-function-summary-callgraph-profile-summary.ll (+7-7)
- (modified) llvm/test/Bitcode/thinlto-function-summary-callgraph-sample-profile-summary.ll (+9-9)
- (modified) llvm/test/Bitcode/thinlto-function-summary-callgraph.ll (+3-3)
- (modified) llvm/test/Bitcode/thinlto-function-summary-functionattrs.ll (+4-4)
- (modified) llvm/test/Bitcode/thinlto-function-summary-originalnames.ll (+1-1)
- (modified) llvm/test/Bitcode/thinlto-function-summary-paramaccess.ll (+19-19)
- (modified) llvm/test/Bitcode/thinlto-function-summary-refgraph.ll (+11-11)
- (modified) llvm/test/Bitcode/thinlto-function-summary.ll (+4-4)
- (modified) llvm/test/Bitcode/thinlto-summary-linkage-types.ll (+16-16)
- (modified) llvm/test/Bitcode/thinlto-summary-section.ll (+2-2)
- (modified) llvm/test/ThinLTO/X86/deadstrip.ll (+11-11)
- (modified) llvm/test/ThinLTO/X86/distributed_indexes.ll (+4-4)
``````````diff
diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
index 9fa70c0671ef340..09f764c257e602b 100644
--- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
@@ -210,7 +210,7 @@ enum GlobalValueSummarySymtabCodes {
FS_PERMODULE = 1,
// PERMODULE_PROFILE: [valueid, flags, instcount, numrefs,
// numrefs x valueid,
- // n x (valueid, hotness)]
+ // n x (valueid, hotness+tailcall)]
FS_PERMODULE_PROFILE = 2,
// PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid]
FS_PERMODULE_GLOBALVAR_INIT_REFS = 3,
@@ -219,7 +219,7 @@ enum GlobalValueSummarySymtabCodes {
FS_COMBINED = 4,
// COMBINED_PROFILE: [valueid, modid, flags, instcount, numrefs,
// numrefs x valueid,
- // n x (valueid, hotness)]
+ // n x (valueid, hotness+tailcall)]
FS_COMBINED_PROFILE = 5,
// COMBINED_GLOBALVAR_INIT_REFS: [valueid, modid, flags, n x valueid]
FS_COMBINED_GLOBALVAR_INIT_REFS = 6,
@@ -268,7 +268,7 @@ enum GlobalValueSummarySymtabCodes {
// Per-module summary that also adds relative block frequency to callee info.
// PERMODULE_RELBF: [valueid, flags, instcount, numrefs,
// numrefs x valueid,
- // n x (valueid, relblockfreq)]
+ // n x (valueid, relblockfreq+tailcall)]
FS_PERMODULE_RELBF = 19,
// Index-wide flags
FS_FLAGS = 20,
diff --git a/llvm/include/llvm/IR/ModuleSummaryIndex.h b/llvm/include/llvm/IR/ModuleSummaryIndex.h
index cd02c71adddfc25..fe0c65b419af3ed 100644
--- a/llvm/include/llvm/IR/ModuleSummaryIndex.h
+++ b/llvm/include/llvm/IR/ModuleSummaryIndex.h
@@ -68,21 +68,31 @@ struct CalleeInfo {
// added to HotnessType enum.
uint32_t Hotness : 3;
+ // True if at least one of the calls to the callee is a tail call.
+ bool HasTailCall : 1;
+
/// The value stored in RelBlockFreq has to be interpreted as the digits of
/// a scaled number with a scale of \p -ScaleShift.
- uint32_t RelBlockFreq : 29;
+ static constexpr unsigned RelBlockFreqBits = 28;
+ uint32_t RelBlockFreq : RelBlockFreqBits;
static constexpr int32_t ScaleShift = 8;
- static constexpr uint64_t MaxRelBlockFreq = (1 << 29) - 1;
+ static constexpr uint64_t MaxRelBlockFreq = (1 << RelBlockFreqBits) - 1;
CalleeInfo()
- : Hotness(static_cast<uint32_t>(HotnessType::Unknown)), RelBlockFreq(0) {}
- explicit CalleeInfo(HotnessType Hotness, uint64_t RelBF)
- : Hotness(static_cast<uint32_t>(Hotness)), RelBlockFreq(RelBF) {}
+ : Hotness(static_cast<uint32_t>(HotnessType::Unknown)),
+ HasTailCall(false), RelBlockFreq(0) {}
+ explicit CalleeInfo(HotnessType Hotness, bool hasTC, uint64_t RelBF)
+ : Hotness(static_cast<uint32_t>(Hotness)), HasTailCall(hasTC),
+ RelBlockFreq(RelBF) {}
void updateHotness(const HotnessType OtherHotness) {
Hotness = std::max(Hotness, static_cast<uint32_t>(OtherHotness));
}
+ bool hasTailCall() const { return HasTailCall; }
+
+ void setHasTailCall(const bool hasTC) { HasTailCall = hasTC; }
+
HotnessType getHotness() const { return HotnessType(Hotness); }
/// Update \p RelBlockFreq from \p BlockFreq and \p EntryFreq
diff --git a/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp b/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp
index 058a107691674ce..1f15e94783240a7 100644
--- a/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp
+++ b/llvm/lib/Analysis/ModuleSummaryAnalysis.cpp
@@ -409,6 +409,8 @@ static void computeFunctionSummary(
auto &ValueInfo = CallGraphEdges[Index.getOrInsertValueInfo(
cast<GlobalValue>(CalledValue))];
ValueInfo.updateHotness(Hotness);
+ if (CB->isTailCall())
+ ValueInfo.setHasTailCall(true);
// Add the relative block frequency to CalleeInfo if there is no profile
// information.
if (BFI != nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index f9df70fb6fc0996..6d547f3b99e2745 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -9058,7 +9058,8 @@ bool LLParser::parseOptionalFFlags(FunctionSummary::FFlags &FFlags) {
/// OptionalCalls
/// := 'calls' ':' '(' Call [',' Call]* ')'
/// Call ::= '(' 'callee' ':' GVReference
-/// [( ',' 'hotness' ':' Hotness | ',' 'relbf' ':' UInt32 )]? ')'
+/// [( ',' 'hotness' ':' Hotness | ',' 'relbf' ':' UInt32 )]?
+/// [ ',' 'tail' ]? ')'
bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) {
assert(Lex.getKind() == lltok::kw_calls);
Lex.Lex();
@@ -9083,23 +9084,39 @@ bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) {
CalleeInfo::HotnessType Hotness = CalleeInfo::HotnessType::Unknown;
unsigned RelBF = 0;
- if (EatIfPresent(lltok::comma)) {
- // Expect either hotness or relbf
- if (EatIfPresent(lltok::kw_hotness)) {
+ unsigned HasTailCall = false;
+
+ // parse optional fields
+ while (EatIfPresent(lltok::comma)) {
+ switch (Lex.getKind()) {
+ case lltok::kw_hotness:
+ Lex.Lex();
if (parseToken(lltok::colon, "expected ':'") || parseHotness(Hotness))
return true;
- } else {
- if (parseToken(lltok::kw_relbf, "expected relbf") ||
- parseToken(lltok::colon, "expected ':'") || parseUInt32(RelBF))
+ break;
+ case lltok::kw_relbf:
+ Lex.Lex();
+ if (parseToken(lltok::colon, "expected ':'") || parseUInt32(RelBF))
+ return true;
+ break;
+ case lltok::kw_tail:
+ Lex.Lex();
+ if (parseToken(lltok::colon, "expected ':'") || parseFlag(HasTailCall))
return true;
+ break;
+ default:
+ return error(Lex.getLoc(), "expected hotness, relbf, or tail");
}
}
+ if (Hotness != CalleeInfo::HotnessType::Unknown && RelBF > 0)
+ return tokError("Expected only one of hotness or relbf");
// Keep track of the Call array index needing a forward reference.
// We will save the location of the ValueInfo needing an update, but
// can only do so once the std::vector is finalized.
if (VI.getRef() == FwdVIRef)
IdToIndexMap[GVId].push_back(std::make_pair(Calls.size(), Loc));
- Calls.push_back(FunctionSummary::EdgeTy{VI, CalleeInfo(Hotness, RelBF)});
+ Calls.push_back(
+ FunctionSummary::EdgeTy{VI, CalleeInfo(Hotness, HasTailCall, RelBF)});
if (parseToken(lltok::rparen, "expected ')' in call"))
return true;
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index 76431e883b8d96d..81fad7786fb22db 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1117,6 +1117,21 @@ static GlobalVarSummary::GVarFlags getDecodedGVarFlags(uint64_t RawFlags) {
(GlobalObject::VCallVisibility)(RawFlags >> 3));
}
+static void getDecodedHotnessCallEdgeInfo(uint64_t RawFlags,
+ CalleeInfo::HotnessType &Hotness,
+ bool &HasTailCall) {
+ Hotness = static_cast<CalleeInfo::HotnessType>(RawFlags & 0x7); // 3 bits
+ HasTailCall = (RawFlags & 0x8); // 1 bit
+}
+
+static void getDecodedRelBFCallEdgeInfo(uint64_t RawFlags, uint64_t &RelBF,
+ bool &HasTailCall) {
+ static constexpr uint64_t RelBlockFreqMask =
+ (1 << CalleeInfo::RelBlockFreqBits) - 1;
+ RelBF = RawFlags & RelBlockFreqMask; // RelBlockFreqBits bits
+ HasTailCall = (RawFlags & (1 << CalleeInfo::RelBlockFreqBits)); // 1 bit
+}
+
static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) {
switch (Val) {
default: // Map unknown visibilities to default.
@@ -7007,6 +7022,7 @@ ModuleSummaryIndexBitcodeReader::makeCallList(ArrayRef<uint64_t> Record,
Ret.reserve(Record.size());
for (unsigned I = 0, E = Record.size(); I != E; ++I) {
CalleeInfo::HotnessType Hotness = CalleeInfo::HotnessType::Unknown;
+ bool HasTailCall = false;
uint64_t RelBF = 0;
ValueInfo Callee = std::get<0>(getValueInfoFromValueId(Record[I]));
if (IsOldProfileFormat) {
@@ -7014,10 +7030,11 @@ ModuleSummaryIndexBitcodeReader::makeCallList(ArrayRef<uint64_t> Record,
if (HasProfile)
I += 1; // Skip old profilecount field
} else if (HasProfile)
- Hotness = static_cast<CalleeInfo::HotnessType>(Record[++I]);
+ getDecodedHotnessCallEdgeInfo(Record[++I], Hotness, HasTailCall);
else if (HasRelBF)
- RelBF = Record[++I];
- Ret.push_back(FunctionSummary::EdgeTy{Callee, CalleeInfo(Hotness, RelBF)});
+ getDecodedRelBFCallEdgeInfo(Record[++I], RelBF, HasTailCall);
+ Ret.push_back(FunctionSummary::EdgeTy{
+ Callee, CalleeInfo(Hotness, HasTailCall, RelBF)});
}
return Ret;
}
@@ -7231,14 +7248,15 @@ Error ModuleSummaryIndexBitcodeReader::parseEntireSummary(unsigned ID) {
TheIndex.getOrInsertValueInfo(RefGUID), RefGUID, RefGUID);
break;
}
+ // FS_PERMODULE is legacy and does not have support for the tail call flag.
// FS_PERMODULE: [valueid, flags, instcount, fflags, numrefs,
// numrefs x valueid, n x (valueid)]
// FS_PERMODULE_PROFILE: [valueid, flags, instcount, fflags, numrefs,
// numrefs x valueid,
- // n x (valueid, hotness)]
+ // n x (valueid, hotness+tailcall flags)]
// FS_PERMODULE_RELBF: [valueid, flags, instcount, fflags, numrefs,
// numrefs x valueid,
- // n x (valueid, relblockfreq)]
+ // n x (valueid, relblockfreq+tailcall)]
case bitc::FS_PERMODULE:
case bitc::FS_PERMODULE_RELBF:
case bitc::FS_PERMODULE_PROFILE: {
@@ -7385,10 +7403,12 @@ Error ModuleSummaryIndexBitcodeReader::parseEntireSummary(unsigned ID) {
TheIndex.addGlobalValueSummary(std::get<0>(GUID), std::move(VS));
break;
}
+ // FS_COMBINED is legacy and does not have support for the tail call flag.
// FS_COMBINED: [valueid, modid, flags, instcount, fflags, numrefs,
// numrefs x valueid, n x (valueid)]
// FS_COMBINED_PROFILE: [valueid, modid, flags, instcount, fflags, numrefs,
- // numrefs x valueid, n x (valueid, hotness)]
+ // numrefs x valueid,
+ // n x (valueid, hotness+tailcall flags)]
case bitc::FS_COMBINED:
case bitc::FS_COMBINED_PROFILE: {
unsigned ValueID = Record[0];
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index d16b5c7781c2413..cb5ec8bfa821e8d 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -1158,6 +1158,24 @@ static uint64_t getEncodedGVarFlags(GlobalVarSummary::GVarFlags Flags) {
return RawFlags;
}
+static uint64_t getEncodedHotnessCallEdgeInfo(const CalleeInfo &CI) {
+ uint64_t RawFlags = 0;
+
+ RawFlags |= CI.Hotness; // 3 bits
+ RawFlags |= (CI.HasTailCall << 3); // 1 bit
+
+ return RawFlags;
+}
+
+static uint64_t getEncodedRelBFCallEdgeInfo(const CalleeInfo &CI) {
+ uint64_t RawFlags = 0;
+
+ RawFlags |= CI.RelBlockFreq; // CalleeInfo::RelBlockFreqBits bits
+ RawFlags |= (CI.HasTailCall << CalleeInfo::RelBlockFreqBits); // 1 bit
+
+ return RawFlags;
+}
+
static unsigned getEncodedVisibility(const GlobalValue &GV) {
switch (GV.getVisibility()) {
case GlobalValue::DefaultVisibility: return 0;
@@ -4003,8 +4021,9 @@ static void writeFunctionHeapProfileRecords(
// Helper to emit a single function summary record.
void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(
SmallVector<uint64_t, 64> &NameVals, GlobalValueSummary *Summary,
- unsigned ValueID, unsigned FSCallsAbbrev, unsigned FSCallsProfileAbbrev,
- unsigned CallsiteAbbrev, unsigned AllocAbbrev, const Function &F) {
+ unsigned ValueID, unsigned FSCallsRelBFAbbrev,
+ unsigned FSCallsProfileAbbrev, unsigned CallsiteAbbrev,
+ unsigned AllocAbbrev, const Function &F) {
NameVals.push_back(ValueID);
FunctionSummary *FS = cast<FunctionSummary>(Summary);
@@ -4031,21 +4050,20 @@ void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(
for (auto &RI : FS->refs())
NameVals.push_back(VE.getValueID(RI.getValue()));
- bool HasProfileData =
- F.hasProfileData() || ForceSummaryEdgesCold != FunctionSummary::FSHT_None;
+ bool UseRelBFRecord = WriteRelBFToSummary && !F.hasProfileData() &&
+ ForceSummaryEdgesCold == FunctionSummary::FSHT_None;
for (auto &ECI : FS->calls()) {
NameVals.push_back(getValueId(ECI.first));
- if (HasProfileData)
- NameVals.push_back(static_cast<uint8_t>(ECI.second.Hotness));
- else if (WriteRelBFToSummary)
- NameVals.push_back(ECI.second.RelBlockFreq);
+ if (UseRelBFRecord)
+ NameVals.push_back(getEncodedRelBFCallEdgeInfo(ECI.second));
+ else
+ NameVals.push_back(getEncodedHotnessCallEdgeInfo(ECI.second));
}
- unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
+ unsigned FSAbbrev =
+ (UseRelBFRecord ? FSCallsRelBFAbbrev : FSCallsProfileAbbrev);
unsigned Code =
- (HasProfileData ? bitc::FS_PERMODULE_PROFILE
- : (WriteRelBFToSummary ? bitc::FS_PERMODULE_RELBF
- : bitc::FS_PERMODULE));
+ (UseRelBFRecord ? bitc::FS_PERMODULE_RELBF : bitc::FS_PERMODULE_PROFILE);
// Emit the finished record.
Stream.EmitRecord(Code, NameVals, FSAbbrev);
@@ -4154,17 +4172,14 @@ void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
- // numrefs x valueid, n x (valueid, hotness)
+ // numrefs x valueid, n x (valueid, hotness+tailcall flags)
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
- // Abbrev for FS_PERMODULE or FS_PERMODULE_RELBF.
+ // Abbrev for FS_PERMODULE_RELBF.
Abbv = std::make_shared<BitCodeAbbrev>();
- if (WriteRelBFToSummary)
- Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_RELBF));
- else
- Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE));
+ Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_RELBF));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
@@ -4172,10 +4187,10 @@ void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
- // numrefs x valueid, n x (valueid [, rel_block_freq])
+ // numrefs x valueid, n x (valueid, rel_block_freq+tailcall])
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
- unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
+ unsigned FSCallsRelBFAbbrev = Stream.EmitAbbrev(std::move(Abbv));
// Abbrev for FS_PERMODULE_GLOBALVAR_INIT_REFS.
Abbv = std::make_shared<BitCodeAbbrev>();
@@ -4247,9 +4262,9 @@ void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
continue;
}
auto *Summary = VI.getSummaryList()[0].get();
- writePerModuleFunctionSummaryRecord(NameVals, Summary, VE.getValueID(&F),
- FSCallsAbbrev, FSCallsProfileAbbrev,
- CallsiteAbbrev, AllocAbbrev, F);
+ writePerModuleFunctionSummaryRecord(
+ NameVals, Summary, VE.getValueID(&F), FSCallsRelBFAbbrev,
+ FSCallsProfileAbbrev, CallsiteAbbrev, AllocAbbrev, F);
}
// Capture references from GlobalVariable initializers, which are outside
@@ -4320,25 +4335,8 @@ void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
Stream.EmitRecord(bitc::FS_STACK_IDS, StackIds, StackIdAbbvId);
}
- // Abbrev for FS_COMBINED.
- auto Abbv = std::make_shared<BitCodeAbbrev>();
- Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // entrycount
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
- // numrefs x valueid, n x (valueid)
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
- Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
- unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
-
// Abbrev for FS_COMBINED_PROFILE.
- Abbv = std::make_shared<BitCodeAbbrev>();
+ auto Abbv = std::make_shared<BitCodeAbbrev>();
Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_PROFILE));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
@@ -4349,7 +4347,7 @@ void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // rorefcnt
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // worefcnt
- // numrefs x valueid, n x (valueid, hotness)
+ // numrefs x valueid, n x (valueid, hotness+tailcall flags)
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
@@ -4529,14 +4527,6 @@ void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
NameVals[7] = RORefCnt;
NameVals[8] = WORefCnt;
- bool HasProfileData = false;
- for (auto &EI : FS->calls()) {
- HasProfileData |=
- EI.second.getHotness() != CalleeInfo::HotnessType::Unknown;
- if (HasProfileData)
- break;
- }
-
for (auto &EI : FS->calls()) {
// If this GUID doesn't have a value id, it doesn't have a function
// summary and we don't need to record any calls to it.
@@ -4544,16 +4534,12 @@ void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
if (!CallValueId)
continue;
NameVals.push_back(*CallValueId);
- if (HasProfileData)
- NameVals.push_back(static_cast<uint8_t>(EI.second.Hotness));
+ NameVals.push_back(getEncodedHotnessCallEdgeInfo(EI.second));
}
- unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
- unsigned Code =
- (HasProfileData ? bitc::FS_COMBINED_PROFILE : bitc::FS_COMBINED);
-
// Emit the finished record.
- Stream.EmitRecord(Code, NameVals, FSAbbrev);
+ Stream.EmitRecord(bitc::FS_COMBINED_PROFILE, NameVals,
+ FSCallsProfileAbbrev);
NameVals.clear();
MaybeEmitOriginalName(*S);
});
diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
index 6d66b34423949fb..3bc45b92278ca98 100644
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -3216,6 +3216,10 @@ void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
Out << ", hotness: " << getHotnessName(Call.second.getHotness());
else if (Call.second.RelBlockFreq)
Out << ", relbf: " << Call.second.RelBlockFreq;
+ // Follow the convention of emitting flags as a boolean value, but only
+ // emit if true to avoid unnecessary verbosity and test churn.
+ if (Call.second....
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/74043
More information about the llvm-commits
mailing list