From bfb84d0bd6dd47f2d074c3eefb3520672217fada Mon Sep 17 00:00:00 2001 From: Benjamin Kramer Date: Fri, 21 Jun 2013 20:20:27 +0000 Subject: [PATCH] Revert "BlockFrequency: Saturate at 1 instead of 0 when multiplying a frequency with a branch probability." This reverts commit r184584. Breaks PPC selfhost. llvm-svn: 184590 --- llvm/include/llvm/Support/BlockFrequency.h | 8 --- llvm/lib/Support/BlockFrequency.cpp | 12 +--- .../BlockFrequencyInfo/singularity.ll | 65 ------------------- llvm/unittests/Support/BlockFrequencyTest.cpp | 13 +--- 4 files changed, 3 insertions(+), 95 deletions(-) delete mode 100644 llvm/test/Analysis/BlockFrequencyInfo/singularity.ll diff --git a/llvm/include/llvm/Support/BlockFrequency.h b/llvm/include/llvm/Support/BlockFrequency.h index 257888f8d0c1..839cf9371247 100644 --- a/llvm/include/llvm/Support/BlockFrequency.h +++ b/llvm/include/llvm/Support/BlockFrequency.h @@ -30,20 +30,12 @@ class BlockFrequency { public: BlockFrequency(uint64_t Freq = 0) : Frequency(Freq) { } - /// \brief Returns the frequency of the entry block of the function. static uint64_t getEntryFrequency() { return ENTRY_FREQ; } - - /// \brief Returns the frequency as a fixpoint number scaled by the entry - /// frequency. uint64_t getFrequency() const { return Frequency; } - /// \brief Multiplies with a branch probability. The computation will never - /// overflow. If the result is equal to zero but the input wasn't this method - /// will return a frequency of one. BlockFrequency &operator*=(const BranchProbability &Prob); const BlockFrequency operator*(const BranchProbability &Prob) const; - /// \brief Adds another block frequency using saturating arithmetic. BlockFrequency &operator+=(const BlockFrequency &Freq); const BlockFrequency operator+(const BlockFrequency &Freq) const; diff --git a/llvm/lib/Support/BlockFrequency.cpp b/llvm/lib/Support/BlockFrequency.cpp index 53bbd8ad12dd..84a993e3e5b6 100644 --- a/llvm/lib/Support/BlockFrequency.cpp +++ b/llvm/lib/Support/BlockFrequency.cpp @@ -65,9 +65,6 @@ uint64_t div96bit(uint64_t W[2], uint32_t D) { BlockFrequency &BlockFrequency::operator*=(const BranchProbability &Prob) { - if (Frequency == 0) - return *this; - uint32_t n = Prob.getNumerator(); uint32_t d = Prob.getDenominator(); @@ -87,15 +84,10 @@ BlockFrequency &BlockFrequency::operator*=(const BranchProbability &Prob) { // 64-bit. mult96bit(Frequency, n, W); Frequency = div96bit(W, d); - } else { - // Fast case. - Frequency = mulRes / d; + return *this; } - // Limit the result to 1; 0 is a sentinel value. This keeps BlockFrequencyInfo - // from getting stuck at zero frequencies just because a value became too - // small to be represented as a BlockFrequency. - Frequency = (n == 0 || Frequency != 0) ? Frequency : 1; + Frequency = mulRes / d; return *this; } diff --git a/llvm/test/Analysis/BlockFrequencyInfo/singularity.ll b/llvm/test/Analysis/BlockFrequencyInfo/singularity.ll deleted file mode 100644 index 9077cc0656af..000000000000 --- a/llvm/test/Analysis/BlockFrequencyInfo/singularity.ll +++ /dev/null @@ -1,65 +0,0 @@ -; RUN: opt < %s -analyze -block-freq | FileCheck %s -; PR16402 - -define void @test1(i32 %n) nounwind { -entry: - %call = tail call i32* @cond() nounwind - %tobool = icmp eq i32* %call, null - br i1 %tobool, label %land.lhs.true, label %if.end - -land.lhs.true: ; preds = %entry - %call1 = tail call i32* @cond() nounwind - %tobool2 = icmp eq i32* %call1, null - br i1 %tobool2, label %land.lhs.true3, label %if.end - -land.lhs.true3: ; preds = %land.lhs.true - %call4 = tail call i32* @cond() nounwind - %tobool5 = icmp eq i32* %call4, null - br i1 %tobool5, label %land.lhs.true6, label %if.end - -land.lhs.true6: ; preds = %land.lhs.true3 - %call7 = tail call i32* @cond() nounwind - %tobool8 = icmp eq i32* %call7, null - br i1 %tobool8, label %land.lhs.true9, label %if.end - -land.lhs.true9: ; preds = %land.lhs.true6 - %call10 = tail call i32* @cond() nounwind - %tobool11 = icmp eq i32* %call10, null - br i1 %tobool11, label %land.lhs.true12, label %if.end - -land.lhs.true12: ; preds = %land.lhs.true9 - %call13 = tail call i32* @cond() nounwind - %tobool14 = icmp eq i32* %call13, null - br i1 %tobool14, label %land.lhs.true15, label %if.end - -land.lhs.true15: ; preds = %land.lhs.true12 - %call16 = tail call i32* @cond() nounwind - %tobool17 = icmp eq i32* %call16, null - br i1 %tobool17, label %for.cond.preheader, label %if.end - -for.cond.preheader: ; preds = %land.lhs.true15 - %cmp21 = icmp eq i32 %n, 0 - br i1 %cmp21, label %for.end, label %for.body - -for.body: ; preds = %for.cond.preheader, %for.body - %i.022 = phi i32 [ %inc, %for.body ], [ 0, %for.cond.preheader ] - %call18 = tail call i32 @call() nounwind - %inc = add nsw i32 %i.022, 1 - %cmp = icmp eq i32 %inc, %n - br i1 %cmp, label %for.end, label %for.body - -for.end: ; preds = %for.body, %for.cond.preheader - %call19 = tail call i32* @cond() nounwind - br label %if.end - -if.end: ; preds = %land.lhs.true15, %land.lhs.true12, %land.lhs.true9, %land.lhs.true6, %land.lhs.true3, %land.lhs.true, %entry, %for.end - ret void - -; CHECK: entry = 1024 -; CHECK-NOT: for.body = 0 -; CHECK-NOT: for.end = 0 -} - -declare i32* @cond() nounwind - -declare i32 @call() nounwind diff --git a/llvm/unittests/Support/BlockFrequencyTest.cpp b/llvm/unittests/Support/BlockFrequencyTest.cpp index bcb88c889507..ff66bc4e45aa 100644 --- a/llvm/unittests/Support/BlockFrequencyTest.cpp +++ b/llvm/unittests/Support/BlockFrequencyTest.cpp @@ -8,22 +8,11 @@ using namespace llvm; namespace { -TEST(BlockFrequencyTest, ZeroToZero) { - BlockFrequency Freq(0); - BranchProbability Prob(UINT32_MAX - 1, UINT32_MAX); - Freq *= Prob; - EXPECT_EQ(Freq.getFrequency(), 0u); - - Freq = 1; - Freq *= BranchProbability::getZero(); - EXPECT_EQ(Freq.getFrequency(), 0u); -} - TEST(BlockFrequencyTest, OneToZero) { BlockFrequency Freq(1); BranchProbability Prob(UINT32_MAX - 1, UINT32_MAX); Freq *= Prob; - EXPECT_EQ(Freq.getFrequency(), 1u); + EXPECT_EQ(Freq.getFrequency(), 0u); } TEST(BlockFrequencyTest, OneToOne) {