Commit 9e46dd96 authored by Chris Lattner's avatar Chris Lattner
Browse files

[APInt.h] Reduce the APInt header file interface a bit. NFC 

This moves one mid-size function out of line, inlines the
trivial tcAnd/tcOr/tcXor/tcComplement methods into their only
caller, and moves the magic/umagic functions into SelectionDAG
since they are implementation details of its algorithm. This
also removes the unit tests for magic, but these are already
tested in the divide lowering logic for various targets.

This also upgrades some C style comments to C++.

Differential Revision: https://reviews.llvm.org/D109476
parent 22a64d4a

llvm/include/llvm/ADT/APInt.h

+5 −57
Original line number Diff line number Diff line
@@ -1638,25 +1638,7 @@ public: 
  ///

  /// to get around any mathematical concerns resulting from

  /// referencing 2 in a space where 2 does no exist.

  unsigned nearestLogBase2() const {

    // Special case when we have a bitwidth of 1. If VAL is 1, then we

    // get 0. If VAL is 0, we get WORDTYPE_MAX which gets truncated to

    // UINT32_MAX.

    if (BitWidth == 1)

      return U.VAL - 1;



    // Handle the zero case.

    if (isNullValue())

      return UINT32_MAX;



    // The non-zero case is handled by computing:

    //

    //   nearestLogBase2(x) = logBase2(x) + x[logBase2(x)-1].

    //

    // where x[i] is referring to the value of the ith bit of x.

    unsigned lg = logBase2();

    return lg + unsigned((*this)[lg - 1]);

  }

  unsigned nearestLogBase2() const;



  /// \returns the log base 2 of this APInt if its an exact power of two, -1

  /// otherwise
@@ -1666,12 +1648,12 @@ public: 
    return logBase2();

  }



  /// Compute the square root

  /// Compute the square root.

  APInt sqrt() const;



  /// Get the absolute value;

  ///

  /// If *this is < 0 then return -(*this), otherwise *this;

  /// Get the absolute value.  If *this is < 0 then return -(*this), otherwise

  /// *this.  Note that the "most negative" signed number (e.g. -128 for 8 bit

  /// wide APInt) is unchanged due to how negation works.

  APInt abs() const {

    if (isNegative())

      return -(*this);
@@ -1681,18 +1663,6 @@ public: 
  /// \returns the multiplicative inverse for a given modulo.

  APInt multiplicativeInverse(const APInt &modulo) const;



  /// @}

  /// \name Support for division by constant

  /// @{



  /// Calculate the magic number for signed division by a constant.

  struct ms;

  ms magic() const;



  /// Calculate the magic number for unsigned division by a constant.

  struct mu;

  mu magicu(unsigned LeadingZeros = 0) const;



  /// @}

  /// \name Building-block Operations for APInt and APFloat

  /// @{
@@ -1794,12 +1764,6 @@ public: 
  /// restrictions on Count.

  static void tcShiftRight(WordType *, unsigned Words, unsigned Count);



  /// The obvious AND, OR and XOR and complement operations.

  static void tcAnd(WordType *, const WordType *, unsigned);

  static void tcOr(WordType *, const WordType *, unsigned);

  static void tcXor(WordType *, const WordType *, unsigned);

  static void tcComplement(WordType *, unsigned);



  /// Comparison (unsigned) of two bignums.

  static int tcCompare(const WordType *, const WordType *, unsigned);
@@ -1813,9 +1777,6 @@ public: 
    return tcSubtractPart(dst, 1, parts);

  }



  /// Set the least significant BITS and clear the rest.

  static void tcSetLeastSignificantBits(WordType *, unsigned, unsigned bits);



  /// Used to insert APInt objects, or objects that contain APInt objects, into

  ///  FoldingSets.

  void Profile(FoldingSetNodeID &id) const;
@@ -1996,19 +1957,6 @@ private: 
  /// @}

};



/// Magic data for optimising signed division by a constant.

struct APInt::ms {

  APInt m;    ///< magic number

  unsigned s; ///< shift amount

};



/// Magic data for optimising unsigned division by a constant.

struct APInt::mu {

  APInt m;    ///< magic number

  bool a;     ///< add indicator

  unsigned s; ///< shift amount

};



inline bool operator==(uint64_t V1, const APInt &V2) { return V2 == V1; }



inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; }

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

+109 −3
Original line number Diff line number Diff line
@@ -5131,6 +5131,112 @@ SDValue TargetLowering::BuildSDIVPow2(SDNode *N, const APInt &Divisor, 
  return SDValue();

}



namespace {

/// Magic data for optimising signed division by a constant.

struct ms {

  APInt m;    ///< magic number

  unsigned s; ///< shift amount

};



/// Magic data for optimising unsigned division by a constant.

struct mu {

  APInt m;    ///< magic number

  bool a;     ///< add indicator

  unsigned s; ///< shift amount

};

} // namespace



/// Calculate the magic numbers required to implement an unsigned integer

/// division by a constant as a sequence of multiplies, adds and shifts.

/// Requires that the divisor not be 0.  Taken from "Hacker's Delight", Henry

/// S. Warren, Jr., chapter 10.

/// LeadingZeros can be used to simplify the calculation if the upper bits

/// of the divided value are known zero.

static mu magicu(const APInt &d, unsigned LeadingZeros = 0) {

  unsigned p;

  APInt nc, delta, q1, r1, q2, r2;

  struct mu magu;

  magu.a = 0; // initialize "add" indicator

  APInt allOnes = APInt::getAllOnesValue(d.getBitWidth()).lshr(LeadingZeros);

  APInt signedMin = APInt::getSignedMinValue(d.getBitWidth());

  APInt signedMax = APInt::getSignedMaxValue(d.getBitWidth());



  nc = allOnes - (allOnes - d).urem(d);

  p = d.getBitWidth() - 1;  // initialize p

  q1 = signedMin.udiv(nc);  // initialize q1 = 2p/nc

  r1 = signedMin - q1 * nc; // initialize r1 = rem(2p,nc)

  q2 = signedMax.udiv(d);   // initialize q2 = (2p-1)/d

  r2 = signedMax - q2 * d;  // initialize r2 = rem((2p-1),d)

  do {

    p = p + 1;

    if (r1.uge(nc - r1)) {

      q1 = q1 + q1 + 1;  // update q1

      r1 = r1 + r1 - nc; // update r1

    } else {

      q1 = q1 + q1; // update q1

      r1 = r1 + r1; // update r1

    }

    if ((r2 + 1).uge(d - r2)) {

      if (q2.uge(signedMax))

        magu.a = 1;

      q2 = q2 + q2 + 1;     // update q2

      r2 = r2 + r2 + 1 - d; // update r2

    } else {

      if (q2.uge(signedMin))

        magu.a = 1;

      q2 = q2 + q2;     // update q2

      r2 = r2 + r2 + 1; // update r2

    }

    delta = d - 1 - r2;

  } while (p < d.getBitWidth() * 2 &&

           (q1.ult(delta) || (q1 == delta && r1 == 0)));

  magu.m = q2 + 1;              // resulting magic number

  magu.s = p - d.getBitWidth(); // resulting shift

  return magu;

}



/// Calculate the magic numbers required to implement a signed integer division

/// by a constant as a sequence of multiplies, adds and shifts.  Requires that

/// the divisor not be 0, 1, or -1.  Taken from "Hacker's Delight", Henry S.

/// Warren, Jr., Chapter 10.

static ms magic(const APInt &d) {

  unsigned p;

  APInt ad, anc, delta, q1, r1, q2, r2, t;

  APInt signedMin = APInt::getSignedMinValue(d.getBitWidth());

  struct ms mag;



  ad = d.abs();

  t = signedMin + (d.lshr(d.getBitWidth() - 1));

  anc = t - 1 - t.urem(ad);  // absolute value of nc

  p = d.getBitWidth() - 1;   // initialize p

  q1 = signedMin.udiv(anc);  // initialize q1 = 2p/abs(nc)

  r1 = signedMin - q1 * anc; // initialize r1 = rem(2p,abs(nc))

  q2 = signedMin.udiv(ad);   // initialize q2 = 2p/abs(d)

  r2 = signedMin - q2 * ad;  // initialize r2 = rem(2p,abs(d))

  do {

    p = p + 1;

    q1 = q1 << 1;      // update q1 = 2p/abs(nc)

    r1 = r1 << 1;      // update r1 = rem(2p/abs(nc))

    if (r1.uge(anc)) { // must be unsigned comparison

      q1 = q1 + 1;

      r1 = r1 - anc;

    }

    q2 = q2 << 1;     // update q2 = 2p/abs(d)

    r2 = r2 << 1;     // update r2 = rem(2p/abs(d))

    if (r2.uge(ad)) { // must be unsigned comparison

      q2 = q2 + 1;

      r2 = r2 - ad;

    }

    delta = ad - r2;

  } while (q1.ult(delta) || (q1 == delta && r1 == 0));



  mag.m = q2 + 1;

  if (d.isNegative())

    mag.m = -mag.m;            // resulting magic number

  mag.s = p - d.getBitWidth(); // resulting shift

  return mag;

}



/// Given an ISD::SDIV node expressing a divide by constant,

/// return a DAG expression to select that will generate the same value by

/// multiplying by a magic number.
@@ -5175,7 +5281,7 @@ SDValue TargetLowering::BuildSDIV(SDNode *N, SelectionDAG &DAG, 
      return false;



    const APInt &Divisor = C->getAPIntValue();

    APInt::ms magics = Divisor.magic();

    ms magics = magic(Divisor);

    int NumeratorFactor = 0;

    int ShiftMask = -1;
@@ -5321,7 +5427,7 @@ SDValue TargetLowering::BuildUDIV(SDNode *N, SelectionDAG &DAG, 
    // FIXME: We should use a narrower constant when the upper

    // bits are known to be zero.

    const APInt& Divisor = C->getAPIntValue();

    APInt::mu magics = Divisor.magicu();

    mu magics = magicu(Divisor);

    unsigned PreShift = 0, PostShift = 0;



    // If the divisor is even, we can avoid using the expensive fixup by
@@ -5329,7 +5435,7 @@ SDValue TargetLowering::BuildUDIV(SDNode *N, SelectionDAG &DAG, 
    if (magics.a != 0 && !Divisor[0]) {

      PreShift = Divisor.countTrailingZeros();

      // Get magic number for the shifted divisor.

      magics = Divisor.lshr(PreShift).magicu(PreShift);

      magics = magicu(Divisor.lshr(PreShift), PreShift);

      assert(magics.a == 0 && "Should use cheap fixup now");

    }

llvm/lib/Support/APFloat.cpp

+20 −3
Original line number Diff line number Diff line
@@ -1288,6 +1288,23 @@ IEEEFloat::compareAbsoluteValue(const IEEEFloat &rhs) const { 
    return cmpEqual;

}



/* Set the least significant BITS bits of a bignum, clear the

   rest.  */

static void tcSetLeastSignificantBits(APInt::WordType *dst, unsigned parts,

                                      unsigned bits) {

  unsigned i = 0;

  while (bits > APInt::APINT_BITS_PER_WORD) {

    dst[i++] = ~(APInt::WordType)0;

    bits -= APInt::APINT_BITS_PER_WORD;

  }



  if (bits)

    dst[i++] = ~(APInt::WordType)0 >> (APInt::APINT_BITS_PER_WORD - bits);



  while (i < parts)

    dst[i++] = 0;

}



/* Handle overflow.  Sign is preserved.  We either become infinity or

   the largest finite number.  */

IEEEFloat::opStatus IEEEFloat::handleOverflow(roundingMode rounding_mode) {
@@ -1303,7 +1320,7 @@ IEEEFloat::opStatus IEEEFloat::handleOverflow(roundingMode rounding_mode) { 
  /* Otherwise we become the largest finite number.  */

  category = fcNormal;

  exponent = semantics->maxExponent;

  APInt::tcSetLeastSignificantBits(significandParts(), partCount(),

  tcSetLeastSignificantBits(significandParts(), partCount(),

                            semantics->precision);



  return opInexact;
@@ -2412,7 +2429,7 @@ IEEEFloat::convertToInteger(MutableArrayRef<integerPart> parts, 
    else

      bits = width - isSigned;



    APInt::tcSetLeastSignificantBits(parts.data(), dstPartsCount, bits);

    tcSetLeastSignificantBits(parts.data(), dstPartsCount, bits);

    if (sign && isSigned)

      APInt::tcShiftLeft(parts.data(), dstPartsCount, width - 1);

  }

llvm/lib/Support/APInt.cpp

+121 −227

File changed.

Preview size limit exceeded, changes collapsed.

llvm/unittests/ADT/APIntTest.cpp

+0 −20
Original line number Diff line number Diff line
@@ -1419,26 +1419,6 @@ TEST(APIntTest, Log2) { 
  EXPECT_EQ(APInt(15, 9).exactLogBase2(), -1);

}



TEST(APIntTest, magic) {

  EXPECT_EQ(APInt(32, 3).magic().m, APInt(32, "55555556", 16));

  EXPECT_EQ(APInt(32, 3).magic().s, 0U);

  EXPECT_EQ(APInt(32, 5).magic().m, APInt(32, "66666667", 16));

  EXPECT_EQ(APInt(32, 5).magic().s, 1U);

  EXPECT_EQ(APInt(32, 7).magic().m, APInt(32, "92492493", 16));

  EXPECT_EQ(APInt(32, 7).magic().s, 2U);

}



TEST(APIntTest, magicu) {

  EXPECT_EQ(APInt(32, 3).magicu().m, APInt(32, "AAAAAAAB", 16));

  EXPECT_EQ(APInt(32, 3).magicu().s, 1U);

  EXPECT_EQ(APInt(32, 5).magicu().m, APInt(32, "CCCCCCCD", 16));

  EXPECT_EQ(APInt(32, 5).magicu().s, 2U);

  EXPECT_EQ(APInt(32, 7).magicu().m, APInt(32, "24924925", 16));

  EXPECT_EQ(APInt(32, 7).magicu().s, 3U);

  EXPECT_EQ(APInt(64, 25).magicu(1).m, APInt(64, "A3D70A3D70A3D70B", 16));

  EXPECT_EQ(APInt(64, 25).magicu(1).s, 4U);

}



#ifdef GTEST_HAS_DEATH_TEST

#ifndef NDEBUG

TEST(APIntTest, StringDeath) {