X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FBlockFrequency.cpp;h=6f7e341904b90f85c33ce4c4141ffbae2d7b52c4;hb=e8757c5dbbb50a0ac106f01360c462a3217ef62f;hp=8de517fad6416cb1ca059087096d833a67b89beb;hpb=e187512bde9fd090a78924928a0b8793e3d87cbb;p=oota-llvm.git

diff --git a/lib/Support/BlockFrequency.cpp b/lib/Support/BlockFrequency.cpp
index 8de517fad64..6f7e341904b 100644
--- a/lib/Support/BlockFrequency.cpp
+++ b/lib/Support/BlockFrequency.cpp
@@ -18,78 +18,8 @@
 
 using namespace llvm;
 
-/// Multiply FREQ by N and store result in W array.
-static void mult96bit(uint64_t freq, uint32_t N, uint64_t W[2]) {
-  uint64_t u0 = freq & UINT32_MAX;
-  uint64_t u1 = freq >> 32;
-
-  // Represent 96-bit value as w[2]:w[1]:w[0];
-  uint32_t w[3] = { 0, 0, 0 };
-
-  uint64_t t = u0 * N;
-  uint64_t k = t >> 32;
-  w[0] = t;
-  t = u1 * N + k;
-  w[1] = t;
-  w[2] = t >> 32;
-
-  // W[1] - higher bits.
-  // W[0] - lower bits.
-  W[0] = w[0] + ((uint64_t) w[1] << 32);
-  W[1] = w[2];
-}
-
-
-/// Divide 96-bit value stored in W array by D.
-/// Return 64-bit quotient, saturated to UINT64_MAX on overflow.
-static uint64_t div96bit(uint64_t W[2], uint32_t D) {
-  uint64_t y = W[0];
-  uint64_t x = W[1];
-  unsigned i;
-
-  // This is really a 64-bit division.
-  if (!x)
-    return y / D;
-
-  // This long division algorithm automatically saturates on overflow.
-  for (i = 0; i < 64 && x; ++i) {
-    uint32_t t = -((x >> 31) & 1); // Splat bit 31 to bits 0-31.
-    x = (x << 1) | (y >> 63);
-    y = y << 1;
-    if ((x | t) >= D) {
-      x -= D;
-      ++y;
-    }
-  }
-
-  return y << (64 - i);
-}
-
-
-void BlockFrequency::scale(uint32_t N, uint32_t D) {
-  assert(D != 0 && "Division by zero");
-
-  // Calculate Frequency * N.
-  uint64_t MulLo = (Frequency & UINT32_MAX) * N;
-  uint64_t MulHi = (Frequency >> 32) * N;
-  uint64_t MulRes = (MulHi << 32) + MulLo;
-
-  // If the product fits in 64 bits, just use built-in division.
-  if (MulHi <= UINT32_MAX && MulRes <= MulLo) {
-    Frequency = MulRes / D;
-    return;
-  }
-
-  // Product overflowed, use 96-bit operations.
-  // 96-bit value represented as W[1]:W[0].
-  uint64_t W[2];
-  mult96bit(Frequency, N, W);
-  Frequency = div96bit(W, D);
-  return;
-}
-
 BlockFrequency &BlockFrequency::operator*=(const BranchProbability &Prob) {
-  scale(Prob.getNumerator(), Prob.getDenominator());
+  Frequency = Prob.scale(Frequency);
   return *this;
 }
 
@@ -101,7 +31,7 @@ BlockFrequency::operator*(const BranchProbability &Prob) const {
 }
 
 BlockFrequency &BlockFrequency::operator/=(const BranchProbability &Prob) {
-  scale(Prob.getDenominator(), Prob.getNumerator());
+  Frequency = Prob.scaleByInverse(Frequency);
   return *this;
 }
 
@@ -129,24 +59,14 @@ BlockFrequency::operator+(const BlockFrequency &Prob) const {
   return Freq;
 }
 
-void BlockFrequency::print(raw_ostream &OS) const {
-  // Convert fixed-point number to decimal.
-  OS << Frequency / getEntryFrequency() << ".";
-  uint64_t Rem = Frequency % getEntryFrequency();
-  uint64_t Eps = 1;
-  do {
-    Rem *= 10;
-    Eps *= 10;
-    OS << Rem / getEntryFrequency();
-    Rem = Rem % getEntryFrequency();
-  } while (Rem >= Eps/2);
-}
+BlockFrequency &BlockFrequency::operator>>=(const unsigned count) {
+  // Frequency can never be 0 by design.
+  assert(Frequency != 0);
 
-namespace llvm {
-
-raw_ostream &operator<<(raw_ostream &OS, const BlockFrequency &Freq) {
-  Freq.print(OS);
-  return OS;
-}
+  // Shift right by count.
+  Frequency >>= count;
 
+  // Saturate to 1 if we are 0.
+  Frequency |= Frequency == 0;
+  return *this;
 }