[clang] [llvm] Revert "[llvm][IR] Extend BranchWeightMetadata to track provenance of weights" (PR #95060)
via cfe-commits
cfe-commits at lists.llvm.org
Mon Jun 10 16:45:11 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-pgo
Author: Paul Kirth (ilovepi)
<details>
<summary>Changes</summary>
Reverts llvm/llvm-project#<!-- -->86609
This change causes compile-time regressions for stage2 builds (https://llvm-compile-time-tracker.com/compare.php?from=3254f31a66263ea9647c9547f1531c3123444fcd&to=c5978f1eb5eeca8610b9dfce1fcbf1f473911cd8&stat=instructions:u). It also introduced unintended changes to `.text` which should be addressed before relanding.
---
Patch is 38.70 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/95060.diff
30 Files Affected:
- (modified) clang/test/CodeGenCXX/attr-likelihood-if-vs-builtin-expect.cpp (+2-2)
- (modified) llvm/docs/BranchWeightMetadata.rst (-7)
- (modified) llvm/include/llvm/IR/MDBuilder.h (+2-9)
- (modified) llvm/include/llvm/IR/ProfDataUtils.h (+1-16)
- (modified) llvm/lib/CodeGen/CodeGenPrepare.cpp (+1-2)
- (modified) llvm/lib/IR/Instruction.cpp (+4-15)
- (modified) llvm/lib/IR/Instructions.cpp (+1-5)
- (modified) llvm/lib/IR/MDBuilder.cpp (+5-9)
- (modified) llvm/lib/IR/Metadata.cpp (+4-4)
- (modified) llvm/lib/IR/ProfDataUtils.cpp (+9-31)
- (modified) llvm/lib/IR/Verifier.cpp (+3-6)
- (modified) llvm/lib/Transforms/IPO/SampleProfile.cpp (+3-4)
- (modified) llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp (+1-1)
- (modified) llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp (+1-2)
- (modified) llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp (+2-3)
- (modified) llvm/lib/Transforms/Scalar/JumpThreading.cpp (+2-2)
- (modified) llvm/lib/Transforms/Scalar/LowerExpectIntrinsic.cpp (+7-9)
- (modified) llvm/lib/Transforms/Utils/Local.cpp (+1-1)
- (modified) llvm/lib/Transforms/Utils/LoopPeel.cpp (+2-2)
- (modified) llvm/lib/Transforms/Utils/LoopRotationUtils.cpp (+2-2)
- (modified) llvm/lib/Transforms/Utils/SimplifyCFG.cpp (+10-13)
- (modified) llvm/lib/Transforms/Vectorize/LoopVectorize.cpp (+6-6)
- (modified) llvm/test/Transforms/LowerExpectIntrinsic/basic.ll (+4-4)
- (modified) llvm/test/Transforms/LowerExpectIntrinsic/expect-with-probability.ll (+4-4)
- (modified) llvm/test/Transforms/LowerExpectIntrinsic/expect_nonboolean.ll (+3-2)
- (modified) llvm/test/Transforms/LowerExpectIntrinsic/phi_merge.ll (+2-2)
- (modified) llvm/test/Transforms/LowerExpectIntrinsic/phi_or.ll (+2-2)
- (modified) llvm/test/Transforms/LowerExpectIntrinsic/phi_tern.ll (+1-1)
- (modified) llvm/test/Transforms/LowerExpectIntrinsic/phi_unexpect.ll (+2-2)
- (modified) llvm/test/Transforms/PhaseOrdering/AArch64/hoist-runtime-checks.ll (+1-1)
``````````diff
diff --git a/clang/test/CodeGenCXX/attr-likelihood-if-vs-builtin-expect.cpp b/clang/test/CodeGenCXX/attr-likelihood-if-vs-builtin-expect.cpp
index 81d9334356520..fb236aeb982e0 100644
--- a/clang/test/CodeGenCXX/attr-likelihood-if-vs-builtin-expect.cpp
+++ b/clang/test/CodeGenCXX/attr-likelihood-if-vs-builtin-expect.cpp
@@ -221,5 +221,5 @@ void tu2(int &i) {
}
}
-// CHECK: [[BW_LIKELY]] = !{!"branch_weights", !"expected", i32 2000, i32 1}
-// CHECK: [[BW_UNLIKELY]] = !{!"branch_weights", !"expected", i32 1, i32 2000}
+// CHECK: [[BW_LIKELY]] = !{!"branch_weights", i32 2000, i32 1}
+// CHECK: [[BW_UNLIKELY]] = !{!"branch_weights", i32 1, i32 2000}
diff --git a/llvm/docs/BranchWeightMetadata.rst b/llvm/docs/BranchWeightMetadata.rst
index 62204753e29b0..522f37cdad4fc 100644
--- a/llvm/docs/BranchWeightMetadata.rst
+++ b/llvm/docs/BranchWeightMetadata.rst
@@ -28,14 +28,11 @@ Supported Instructions
Metadata is only assigned to the conditional branches. There are two extra
operands for the true and the false branch.
-We optionally track if the metadata was added by ``__builtin_expect`` or
-``__builtin_expect_with_probability`` with an optional field ``!"expected"``.
.. code-block:: none
!0 = !{
!"branch_weights",
- [ !"expected", ]
i32 <TRUE_BRANCH_WEIGHT>,
i32 <FALSE_BRANCH_WEIGHT>
}
@@ -50,7 +47,6 @@ is always case #0).
!0 = !{
!"branch_weights",
- [ !"expected", ]
i32 <DEFAULT_BRANCH_WEIGHT>
[ , i32 <CASE_BRANCH_WEIGHT> ... ]
}
@@ -64,7 +60,6 @@ Branch weights are assigned to every destination.
!0 = !{
!"branch_weights",
- [ !"expected", ]
i32 <LABEL_BRANCH_WEIGHT>
[ , i32 <LABEL_BRANCH_WEIGHT> ... ]
}
@@ -80,7 +75,6 @@ block and entry counts which may not be accurate with sampling.
!0 = !{
!"branch_weights",
- [ !"expected", ]
i32 <CALL_BRANCH_WEIGHT>
}
@@ -101,7 +95,6 @@ is used.
!0 = !{
!"branch_weights",
- [ !"expected", ]
i32 <INVOKE_NORMAL_WEIGHT>
[ , i32 <INVOKE_UNWIND_WEIGHT> ]
}
diff --git a/llvm/include/llvm/IR/MDBuilder.h b/llvm/include/llvm/IR/MDBuilder.h
index e02ec8f5a3d8b..3265589b7c8df 100644
--- a/llvm/include/llvm/IR/MDBuilder.h
+++ b/llvm/include/llvm/IR/MDBuilder.h
@@ -59,11 +59,7 @@ class MDBuilder {
//===------------------------------------------------------------------===//
/// Return metadata containing two branch weights.
- /// @param TrueWeight the weight of the true branch
- /// @param FalseWeight the weight of the false branch
- /// @param Do these weights come from __builtin_expect*
- MDNode *createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight,
- bool IsExpected = false);
+ MDNode *createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight);
/// Return metadata containing two branch weights, with significant bias
/// towards `true` destination.
@@ -74,10 +70,7 @@ class MDBuilder {
MDNode *createUnlikelyBranchWeights();
/// Return metadata containing a number of branch weights.
- /// @param Weights the weights of all the branches
- /// @param Do these weights come from __builtin_expect*
- MDNode *createBranchWeights(ArrayRef<uint32_t> Weights,
- bool IsExpected = false);
+ MDNode *createBranchWeights(ArrayRef<uint32_t> Weights);
/// Return metadata specifying that a branch or switch is unpredictable.
MDNode *createUnpredictable();
diff --git a/llvm/include/llvm/IR/ProfDataUtils.h b/llvm/include/llvm/IR/ProfDataUtils.h
index 1d7c97d9be953..88fbad4d6b9d8 100644
--- a/llvm/include/llvm/IR/ProfDataUtils.h
+++ b/llvm/include/llvm/IR/ProfDataUtils.h
@@ -55,17 +55,6 @@ MDNode *getBranchWeightMDNode(const Instruction &I);
/// Nullptr otherwise.
MDNode *getValidBranchWeightMDNode(const Instruction &I);
-/// Check if Branch Weight Metadata has an "expected" field from an llvm.expect*
-/// intrinsic
-bool hasBranchWeightOrigin(const Instruction &I);
-
-/// Check if Branch Weight Metadata has an "expected" field from an llvm.expect*
-/// intrinsic
-bool hasBranchWeightOrigin(const MDNode *ProfileData);
-
-/// Return the offset to the first branch weight data
-unsigned getBranchWeightOffset(const MDNode *ProfileData);
-
/// Extract branch weights from MD_prof metadata
///
/// \param ProfileData A pointer to an MDNode.
@@ -122,11 +111,7 @@ bool extractProfTotalWeight(const Instruction &I, uint64_t &TotalWeights);
/// Create a new `branch_weights` metadata node and add or overwrite
/// a `prof` metadata reference to instruction `I`.
-/// \param I the Instruction to set branch weights on.
-/// \param Weights an array of weights to set on instruction I.
-/// \param IsExpected were these weights added from an llvm.expect* intrinsic.
-void setBranchWeights(Instruction &I, ArrayRef<uint32_t> Weights,
- bool IsExpected);
+void setBranchWeights(Instruction &I, ArrayRef<uint32_t> Weights);
/// Scaling the profile data attached to 'I' using the ratio of S/T.
void scaleProfData(Instruction &I, uint64_t S, uint64_t T);
diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp
index 0e01080bd75cc..339a1f1f2f002 100644
--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -8866,8 +8866,7 @@ bool CodeGenPrepare::splitBranchCondition(Function &F, ModifyDT &ModifiedDT) {
scaleWeights(NewTrueWeight, NewFalseWeight);
Br1->setMetadata(LLVMContext::MD_prof,
MDBuilder(Br1->getContext())
- .createBranchWeights(TrueWeight, FalseWeight,
- hasBranchWeightOrigin(*Br1)));
+ .createBranchWeights(TrueWeight, FalseWeight));
NewTrueWeight = TrueWeight;
NewFalseWeight = 2 * FalseWeight;
diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp
index aec927a8cf31d..29272e627a1d1 100644
--- a/llvm/lib/IR/Instruction.cpp
+++ b/llvm/lib/IR/Instruction.cpp
@@ -1268,23 +1268,12 @@ Instruction *Instruction::cloneImpl() const {
void Instruction::swapProfMetadata() {
MDNode *ProfileData = getBranchWeightMDNode(*this);
- if (!ProfileData)
- return;
- unsigned FirstIdx = getBranchWeightOffset(ProfileData);
- if (ProfileData->getNumOperands() != 2 + FirstIdx)
+ if (!ProfileData || ProfileData->getNumOperands() != 3)
return;
- unsigned SecondIdx = FirstIdx + 1;
- SmallVector<Metadata *, 4> Ops;
- // If there are more weights past the second, we can't swap them
- if (ProfileData->getNumOperands() > SecondIdx + 1)
- return;
- for (unsigned Idx = 0; Idx < FirstIdx; ++Idx) {
- Ops.push_back(ProfileData->getOperand(Idx));
- }
- // Switch the order of the weights
- Ops.push_back(ProfileData->getOperand(SecondIdx));
- Ops.push_back(ProfileData->getOperand(FirstIdx));
+ // The first operand is the name. Fetch them backwards and build a new one.
+ Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
+ ProfileData->getOperand(1)};
setMetadata(LLVMContext::MD_prof,
MDNode::get(ProfileData->getContext(), Ops));
}
diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp
index de369bd62a617..1213f078d05ec 100644
--- a/llvm/lib/IR/Instructions.cpp
+++ b/llvm/lib/IR/Instructions.cpp
@@ -5199,11 +5199,7 @@ void SwitchInstProfUpdateWrapper::init() {
if (!ProfileData)
return;
- // FIXME: This check belongs in ProfDataUtils. Its almost equivalent to
- // getValidBranchWeightMDNode(), but the need to use llvm_unreachable
- // makes them slightly different.
- if (ProfileData->getNumOperands() !=
- SI.getNumSuccessors() + getBranchWeightOffset(ProfileData)) {
+ if (ProfileData->getNumOperands() != SI.getNumSuccessors() + 1) {
llvm_unreachable("number of prof branch_weights metadata operands does "
"not correspond to number of succesors");
}
diff --git a/llvm/lib/IR/MDBuilder.cpp b/llvm/lib/IR/MDBuilder.cpp
index 000027754d13e..bd68db3a6f961 100644
--- a/llvm/lib/IR/MDBuilder.cpp
+++ b/llvm/lib/IR/MDBuilder.cpp
@@ -35,8 +35,8 @@ MDNode *MDBuilder::createFPMath(float Accuracy) {
}
MDNode *MDBuilder::createBranchWeights(uint32_t TrueWeight,
- uint32_t FalseWeight, bool IsExpected) {
- return createBranchWeights({TrueWeight, FalseWeight}, IsExpected);
+ uint32_t FalseWeight) {
+ return createBranchWeights({TrueWeight, FalseWeight});
}
MDNode *MDBuilder::createLikelyBranchWeights() {
@@ -49,19 +49,15 @@ MDNode *MDBuilder::createUnlikelyBranchWeights() {
return createBranchWeights(1, (1U << 20) - 1);
}
-MDNode *MDBuilder::createBranchWeights(ArrayRef<uint32_t> Weights,
- bool IsExpected) {
+MDNode *MDBuilder::createBranchWeights(ArrayRef<uint32_t> Weights) {
assert(Weights.size() >= 1 && "Need at least one branch weights!");
- unsigned int Offset = IsExpected ? 2 : 1;
- SmallVector<Metadata *, 4> Vals(Weights.size() + Offset);
+ SmallVector<Metadata *, 4> Vals(Weights.size() + 1);
Vals[0] = createString("branch_weights");
- if (IsExpected)
- Vals[1] = createString("expected");
Type *Int32Ty = Type::getInt32Ty(Context);
for (unsigned i = 0, e = Weights.size(); i != e; ++i)
- Vals[i + Offset] = createConstant(ConstantInt::get(Int32Ty, Weights[i]));
+ Vals[i + 1] = createConstant(ConstantInt::get(Int32Ty, Weights[i]));
return MDNode::get(Context, Vals);
}
diff --git a/llvm/lib/IR/Metadata.cpp b/llvm/lib/IR/Metadata.cpp
index 5f42ce22f72fe..b6c932495a145 100644
--- a/llvm/lib/IR/Metadata.cpp
+++ b/llvm/lib/IR/Metadata.cpp
@@ -1196,10 +1196,10 @@ MDNode *MDNode::mergeDirectCallProfMetadata(MDNode *A, MDNode *B,
StringRef AProfName = AMDS->getString();
StringRef BProfName = BMDS->getString();
if (AProfName == "branch_weights" && BProfName == "branch_weights") {
- ConstantInt *AInstrWeight = mdconst::dyn_extract<ConstantInt>(
- A->getOperand(getBranchWeightOffset(A)));
- ConstantInt *BInstrWeight = mdconst::dyn_extract<ConstantInt>(
- B->getOperand(getBranchWeightOffset(B)));
+ ConstantInt *AInstrWeight =
+ mdconst::dyn_extract<ConstantInt>(A->getOperand(1));
+ ConstantInt *BInstrWeight =
+ mdconst::dyn_extract<ConstantInt>(B->getOperand(1));
assert(AInstrWeight && BInstrWeight && "verified by LLVM verifier");
return MDNode::get(Ctx,
{MDHelper.createString("branch_weights"),
diff --git a/llvm/lib/IR/ProfDataUtils.cpp b/llvm/lib/IR/ProfDataUtils.cpp
index c4b1ed55de8a2..51e78dc5e6c00 100644
--- a/llvm/lib/IR/ProfDataUtils.cpp
+++ b/llvm/lib/IR/ProfDataUtils.cpp
@@ -40,6 +40,9 @@ namespace {
// We maintain some constants here to ensure that we access the branch weights
// correctly, and can change the behavior in the future if the layout changes
+// The index at which the weights vector starts
+constexpr unsigned WeightsIdx = 1;
+
// the minimum number of operands for MD_prof nodes with branch weights
constexpr unsigned MinBWOps = 3;
@@ -72,7 +75,6 @@ static void extractFromBranchWeightMD(const MDNode *ProfileData,
assert(isBranchWeightMD(ProfileData) && "wrong metadata");
unsigned NOps = ProfileData->getNumOperands();
- unsigned WeightsIdx = getBranchWeightOffset(ProfileData);
assert(WeightsIdx < NOps && "Weights Index must be less than NOps.");
Weights.resize(NOps - WeightsIdx);
@@ -80,8 +82,8 @@ static void extractFromBranchWeightMD(const MDNode *ProfileData,
ConstantInt *Weight =
mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(Idx));
assert(Weight && "Malformed branch_weight in MD_prof node");
- assert(Weight->getValue().getActiveBits() <= (sizeof(T) * 8) &&
- "Too many bits for MD_prof branch_weight");
+ assert(Weight->getValue().getActiveBits() <= 32 &&
+ "Too many bits for uint32_t");
Weights[Idx - WeightsIdx] = Weight->getZExtValue();
}
}
@@ -121,26 +123,6 @@ bool hasValidBranchWeightMD(const Instruction &I) {
return getValidBranchWeightMDNode(I);
}
-bool hasBranchWeightOrigin(const Instruction &I) {
- auto *ProfileData = I.getMetadata(LLVMContext::MD_prof);
- return hasBranchWeightOrigin(ProfileData);
-}
-
-bool hasBranchWeightOrigin(const MDNode *ProfileData) {
- if (!isBranchWeightMD(ProfileData))
- return false;
- auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(1));
- // NOTE: if we ever have more types of branch weight provenance,
- // we need to check the string value is "expected". For now, we
- // supply a more generic API, and avoid the spurious comparisons.
- assert(ProfDataName == nullptr || ProfDataName->getString() == "expected");
- return ProfDataName != nullptr;
-}
-
-unsigned getBranchWeightOffset(const MDNode *ProfileData) {
- return hasBranchWeightOrigin(ProfileData) ? 2 : 1;
-}
-
MDNode *getBranchWeightMDNode(const Instruction &I) {
auto *ProfileData = I.getMetadata(LLVMContext::MD_prof);
if (!isBranchWeightMD(ProfileData))
@@ -150,9 +132,7 @@ MDNode *getBranchWeightMDNode(const Instruction &I) {
MDNode *getValidBranchWeightMDNode(const Instruction &I) {
auto *ProfileData = getBranchWeightMDNode(I);
- auto Offset = getBranchWeightOffset(ProfileData);
- if (ProfileData &&
- ProfileData->getNumOperands() == Offset + I.getNumSuccessors())
+ if (ProfileData && ProfileData->getNumOperands() == 1 + I.getNumSuccessors())
return ProfileData;
return nullptr;
}
@@ -211,8 +191,7 @@ bool extractProfTotalWeight(const MDNode *ProfileData, uint64_t &TotalVal) {
return false;
if (ProfDataName->getString() == "branch_weights") {
- unsigned Offset = getBranchWeightOffset(ProfileData);
- for (unsigned Idx = Offset; Idx < ProfileData->getNumOperands(); ++Idx) {
+ for (unsigned Idx = 1; Idx < ProfileData->getNumOperands(); Idx++) {
auto *V = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(Idx));
assert(V && "Malformed branch_weight in MD_prof node");
TotalVal += V->getValue().getZExtValue();
@@ -233,10 +212,9 @@ bool extractProfTotalWeight(const Instruction &I, uint64_t &TotalVal) {
return extractProfTotalWeight(I.getMetadata(LLVMContext::MD_prof), TotalVal);
}
-void setBranchWeights(Instruction &I, ArrayRef<uint32_t> Weights,
- bool IsExpected) {
+void setBranchWeights(Instruction &I, ArrayRef<uint32_t> Weights) {
MDBuilder MDB(I.getContext());
- MDNode *BranchWeights = MDB.createBranchWeights(Weights, IsExpected);
+ MDNode *BranchWeights = MDB.createBranchWeights(Weights);
I.setMetadata(LLVMContext::MD_prof, BranchWeights);
}
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index fe2253dd04eb3..e5927203f33a2 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -104,7 +104,6 @@
#include "llvm/IR/Module.h"
#include "llvm/IR/ModuleSlotTracker.h"
#include "llvm/IR/PassManager.h"
-#include "llvm/IR/ProfDataUtils.h"
#include "llvm/IR/Statepoint.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Use.h"
@@ -4809,10 +4808,8 @@ void Verifier::visitProfMetadata(Instruction &I, MDNode *MD) {
// Check consistency of !prof branch_weights metadata.
if (ProfName == "branch_weights") {
- unsigned int Offset = getBranchWeightOffset(MD);
if (isa<InvokeInst>(&I)) {
- Check(MD->getNumOperands() == (1 + Offset) ||
- MD->getNumOperands() == (2 + Offset),
+ Check(MD->getNumOperands() == 2 || MD->getNumOperands() == 3,
"Wrong number of InvokeInst branch_weights operands", MD);
} else {
unsigned ExpectedNumOperands = 0;
@@ -4832,10 +4829,10 @@ void Verifier::visitProfMetadata(Instruction &I, MDNode *MD) {
CheckFailed("!prof branch_weights are not allowed for this instruction",
MD);
- Check(MD->getNumOperands() == Offset + ExpectedNumOperands,
+ Check(MD->getNumOperands() == 1 + ExpectedNumOperands,
"Wrong number of operands", MD);
}
- for (unsigned i = Offset; i < MD->getNumOperands(); ++i) {
+ for (unsigned i = 1; i < MD->getNumOperands(); ++i) {
auto &MDO = MD->getOperand(i);
Check(MDO, "second operand should not be null", MD);
Check(mdconst::dyn_extract<ConstantInt>(MDO),
diff --git a/llvm/lib/Transforms/IPO/SampleProfile.cpp b/llvm/lib/Transforms/IPO/SampleProfile.cpp
index 7e6a8817b7a67..92ad4c34da6e7 100644
--- a/llvm/lib/Transforms/IPO/SampleProfile.cpp
+++ b/llvm/lib/Transforms/IPO/SampleProfile.cpp
@@ -1662,8 +1662,7 @@ void SampleProfileLoader::generateMDProfMetadata(Function &F) {
else if (OverwriteExistingWeights)
I.setMetadata(LLVMContext::MD_prof, nullptr);
} else if (!isa<IntrinsicInst>(&I)) {
- setBranchWeights(I, {static_cast<uint32_t>(BlockWeights[BB])},
- /*IsExpected=*/false);
+ setBranchWeights(I, {static_cast<uint32_t>(BlockWeights[BB])});
}
}
} else if (OverwriteExistingWeights || ProfileSampleBlockAccurate) {
@@ -1674,7 +1673,7 @@ void SampleProfileLoader::generateMDProfMetadata(Function &F) {
if (cast<CallBase>(I).isIndirectCall()) {
I.setMetadata(LLVMContext::MD_prof, nullptr);
} else {
- setBranchWeights(I, {uint32_t(0)}, /*IsExpected=*/false);
+ setBranchWeights(I, {uint32_t(0)});
}
}
}
@@ -1757,7 +1756,7 @@ void SampleProfileLoader::generateMDProfMetadata(Function &F) {
if (MaxWeight > 0 &&
(!TI->extractProfTotalWeight(TempWeight) || OverwriteExistingWeights)) {
LLVM_DEBUG(dbgs() << "SUCCESS. Found non-zero weights.\n");
- setBranchWeights(*TI, Weights, /*IsExpected=*/false);
+ setBranchWeights(*TI, Weights);
ORE->emit([&]() {
return OptimizationRemark(DEBUG_TYPE, "PopularDest", MaxDestInst)
<< "most popular destination for conditional branches at "
diff --git a/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp b/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp
index 731104d4fcef0..0a3d8d6000cf4 100644
--- a/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp
+++ b/llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp
@@ -1878,7 +1878,7 @@ void CHR::fixupBranchesAndSelects(CHRScope *Scope,
static_cast<uint32_t>(CHRBranchBias.scale(1000)),
static_cast<uint32_t>(CHRBranchBias.getCompl().scale(1000)),
};
- setBranchWeights(*MergedBR, Weights, /*IsExpected=*/false);
+ setBranchWeights(*MergedBR, Weights);
CHR_DEBUG(dbgs() << "CHR branch bias " << Weights[0] << ":" << Weights[1]
<< "\n");
}
diff --git a/llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp b/llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp
index 6db76ca78b218..23a7c6a20aecb 100644
--- a/llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp
+++ b/llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp
@@ -259,8 +259,7 @@ CallBase &llvm::pgo::promoteIndirectCall(CallBase &CB, Function *DirectCallee,
promoteCallWithIfThenElse(CB, DirectCallee, BranchWeights);
if (AttachProfToDirectCall) {
- setBranchWeights(NewInst, {static_cast<uint32_t>(Count)},
- /*IsExpected=*/false);
+ setBranchWeights(NewInst, {static_cast<uint32_t>(Count)});
}
using namespace ore;
diff --git a/llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp b/llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp
index ac6d3348b3db9..2269c2e0fffae 100644
--- a/llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp
+++ b/llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp
@@ -1474,8 +1474,7 @@ void PGOUseFunc::populateCoverage(IndexedInstrProfReader *PGOReader) {
for (auto *Succ : successors(&BB))
Weights.push_back((Coverage[Succ] || !Coverage[&BB]) ? 1 : 0);
if (Weights.size() >= 2)
- llvm::setBranchWeights(*BB.getTerminator(), Weights,
- /*IsExpected=*/false);
+ llvm::setBranchWeights(*BB.getTerminator(), Weights);
}
unsigned NumCorruptCoverage = 0;
@@ -2261,7 +2260,7 @@ void llvm::setProfMetadata(Module *M, Instruction *TI,
misexpect::checkExpectAnnotations(*TI, Weights, /*IsFrontend=*...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/95060
More information about the cfe-commits
mailing list