Suppress -Wshorten-64-to-32 warnings for 64-bit hosts.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50590 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 46 insertions, 43 deletions

diff --git a/lib/Support/APFloat.cpp b/lib/Support/APFloat.cpp
index 35de71497a..7d6c4dc0bf 100644
--- a/lib/Support/APFloat.cpp
+++ b/lib/Support/APFloat.cpp
@@ -163,9 +163,9 @@ namespace {
   static int
   totalExponent(const char *p, int exponentAdjustment)
   {
-    integerPart unsignedExponent;
+    int unsignedExponent;
     bool negative, overflow;
-    long exponent;
+    int exponent;
 
     /* Move past the exponent letter and sign to the digits.  */
     p++;
@@ -280,9 +280,10 @@ namespace {
       while (*p == '.');
 
       /* Adjust the exponents for any decimal point.  */
-      D->exponent += (dot - p) - (dot > p);
-      D->normalizedExponent = (D->exponent + (p - D->firstSigDigit)
-                               - (dot > D->firstSigDigit && dot < p));
+      D->exponent += static_cast<exponent_t>((dot - p) - (dot > p));
+      D->normalizedExponent = (D->exponent +
+                static_cast<exponent_t>((p - D->firstSigDigit)
+                                        - (dot > D->firstSigDigit && dot < p)));
     }
 
     D->lastSigDigit = p;
@@ -2002,7 +2003,7 @@ APFloat::convertFromHexadecimalString(const char *p,
   firstSignificantDigit = p;
 
   for(;;) {
-    integerPart hex_value;
+    unsigned int hex_value;
 
     if(*p == '.') {
       assert(dot == 0);
@@ -2043,7 +2044,7 @@ APFloat::convertFromHexadecimalString(const char *p,
 
     /* Calculate the exponent adjustment implicit in the number of
        significant digits.  */
-    expAdjustment = dot - firstSignificantDigit;
+    expAdjustment = static_cast<int>(dot - firstSignificantDigit);
     if(expAdjustment < 0)
       expAdjustment++;
     expAdjustment = expAdjustment * 4 - 1;
@@ -2097,7 +2098,8 @@ APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
     decSig.exponent += exp;
 
     lostFraction calcLostFraction;
-    integerPart HUerr, HUdistance, powHUerr;
+    integerPart HUerr, HUdistance;
+    unsigned int powHUerr;
 
     if (exp >= 0) {
       /* multiplySignificand leaves the precision-th bit set to 1.  */
@@ -2113,7 +2115,7 @@ APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
           excessPrecision = calcSemantics.precision;
       }
       /* Extra half-ulp lost in reciprocal of exponent.  */
-      powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0: 2;
+      powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
     }
 
     /* Both multiplySignificand and divideSignificand return the
@@ -2190,7 +2192,7 @@ APFloat::convertFromDecimalString(const char *p, roundingMode rounding_mode)
        N-digit decimal integer is N * 196 / 59.  Allocate enough space
        to hold the full significand, and an extra part required by
        tcMultiplyPart.  */
-    partCount = (D.lastSigDigit - D.firstSigDigit) + 1;
+    partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
     partCount = partCountForBits(1 + 196 * partCount / 59);
     decSignificand = new integerPart[partCount + 1];
     partCount = 0;
@@ -2320,7 +2322,7 @@ APFloat::convertToHexString(char *dst, unsigned int hexDigits,
 
   *dst = 0;
 
-  return dst - p;
+  return static_cast<unsigned int>(dst - p);
 }
 
 /* Does the hard work of outputting the correctly rounded hexadecimal
@@ -2443,7 +2445,7 @@ APFloat::getHashValue() const
     uint32_t hash = sign<<11 | semantics->precision | exponent<<12;
     const integerPart* p = significandParts();
     for (int i=partCount(); i>0; i--, p++)
-      hash ^= ((uint32_t)*p) ^ (*p)>>32;
+      hash ^= ((uint32_t)*p) ^ (uint32_t)((*p)>>32);
     return hash;
   }
 }
@@ -2483,8 +2485,8 @@ APFloat::convertF80LongDoubleAPFloatToAPInt() const
   }
 
   uint64_t words[2];
-  words[0] =  (((uint64_t)sign & 1) << 63) |
-              ((myexponent & 0x7fff) <<  48) |
+  words[0] =  ((uint64_t)(sign & 1) << 63) |
+              ((myexponent & 0x7fffLL) <<  48) |
               ((mysignificand >>16) & 0xffffffffffffLL);
   words[1] = mysignificand & 0xffff;
   return APInt(80, 2, words);
@@ -2526,10 +2528,10 @@ APFloat::convertPPCDoubleDoubleAPFloatToAPInt() const
   }
 
   uint64_t words[2];
-  words[0] =  (((uint64_t)sign & 1) << 63) |
+  words[0] =  ((uint64_t)(sign & 1) << 63) |
               ((myexponent & 0x7ff) <<  52) |
               (mysignificand & 0xfffffffffffffLL);
-  words[1] =  (((uint64_t)sign2 & 1) << 63) |
+  words[1] =  ((uint64_t)(sign2 & 1) << 63) |
               ((myexponent2 & 0x7ff) <<  52) |
               (mysignificand2 & 0xfffffffffffffLL);
   return APInt(128, 2, words);
@@ -2560,7 +2562,7 @@ APFloat::convertDoubleAPFloatToAPInt() const
     mysignificand = *significandParts();
   }
 
-  return APInt(64, (((((uint64_t)sign & 1) << 63) |
+  return APInt(64, ((((uint64_t)(sign & 1) << 63) |
                      ((myexponent & 0x7ff) <<  52) |
                      (mysignificand & 0xfffffffffffffLL))));
 }
@@ -2575,7 +2577,7 @@ APFloat::convertFloatAPFloatToAPInt() const
 
   if (category==fcNormal) {
     myexponent = exponent+127; //bias
-    mysignificand = *significandParts();
+    mysignificand = (uint32_t)*significandParts();
     if (myexponent == 1 && !(mysignificand & 0x800000))
       myexponent = 0;   // denormal
   } else if (category==fcZero) {
@@ -2587,7 +2589,7 @@ APFloat::convertFloatAPFloatToAPInt() const
   } else {
     assert(category == fcNaN && "Unknown category!");
     myexponent = 0xff;
-    mysignificand = *significandParts();
+    mysignificand = (uint32_t)*significandParts();
   }
 
   return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
@@ -2649,7 +2651,7 @@ APFloat::initFromF80LongDoubleAPInt(const APInt &api)
   initialize(&APFloat::x87DoubleExtended);
   assert(partCount()==2);
 
-  sign = i1>>63;
+  sign = static_cast<unsigned int>(i1>>63);
   if (myexponent==0 && mysignificand==0) {
     // exponent, significand meaningless
     category = fcZero;
@@ -2685,8 +2687,8 @@ APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
   initialize(&APFloat::PPCDoubleDouble);
   assert(partCount()==2);
 
-  sign = i1>>63;
-  sign2 = i2>>63;
+  sign = static_cast<unsigned int>(i1>>63);
+  sign2 = static_cast<unsigned int>(i2>>63);
   if (myexponent==0 && mysignificand==0) {
     // exponent, significand meaningless
     // exponent2 and significand2 are required to be 0; we don't check
@@ -2732,7 +2734,7 @@ APFloat::initFromDoubleAPInt(const APInt &api)
   initialize(&APFloat::IEEEdouble);
   assert(partCount()==1);
 
-  sign = i>>63;
+  sign = static_cast<unsigned int>(i>>63);
   if (myexponent==0 && mysignificand==0) {
     // exponent, significand meaningless
     category = fcZero;
diff --git a/lib/Support/APInt.cpp b/lib/Support/APInt.cpp
index 615fcac8a6..ef35e1c554 100644
--- a/lib/Support/APInt.cpp
+++ b/lib/Support/APInt.cpp
@@ -99,7 +99,7 @@ APInt::APInt(uint32_t numbits, const std::string& Val, uint8_t radix)
   assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
   assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
   assert(!Val.empty() && "String empty?");
-  fromString(numbits, Val.c_str(), Val.size(), radix);
+  fromString(numbits, Val.c_str(), (uint32_t)Val.size(), radix);
 }
 
 APInt::APInt(const APInt& that)
@@ -905,7 +905,7 @@ APInt llvm::APIntOps::RoundDoubleToAPInt(double Double, uint32_t width) {
 
   // Otherwise, we have to shift the mantissa bits up to the right location
   APInt Tmp(width, mantissa);
-  Tmp = Tmp.shl(exp - 52);
+  Tmp = Tmp.shl((uint32_t)exp - 52);
   return isNeg ? -Tmp : Tmp;
 }
 
@@ -1086,7 +1086,7 @@ APInt &APInt::sextOrTrunc(uint32_t width) {
 /// Arithmetic right-shift this APInt by shiftAmt.
 /// @brief Arithmetic right-shift function.
 APInt APInt::ashr(const APInt &shiftAmt) const {
-  return ashr(shiftAmt.getLimitedValue(BitWidth));
+  return ashr((uint32_t)shiftAmt.getLimitedValue(BitWidth));
 }
 
 /// Arithmetic right-shift this APInt by shiftAmt.
@@ -1175,7 +1175,7 @@ APInt APInt::ashr(uint32_t shiftAmt) const {
 /// Logical right-shift this APInt by shiftAmt.
 /// @brief Logical right-shift function.
 APInt APInt::lshr(const APInt &shiftAmt) const {
-  return lshr(shiftAmt.getLimitedValue(BitWidth));
+  return lshr((uint32_t)shiftAmt.getLimitedValue(BitWidth));
 }
 
 /// Logical right-shift this APInt by shiftAmt.
@@ -1244,7 +1244,7 @@ APInt APInt::lshr(uint32_t shiftAmt) const {
 /// @brief Left-shift function.
 APInt APInt::shl(const APInt &shiftAmt) const {
   // It's undefined behavior in C to shift by BitWidth or greater, but
-  return shl(shiftAmt.getLimitedValue(BitWidth));
+  return shl((uint32_t)shiftAmt.getLimitedValue(BitWidth));
 }
 
 /// Left-shift this APInt by shiftAmt.
@@ -1307,7 +1307,7 @@ APInt APInt::shl(uint32_t shiftAmt) const {
 }
 
 APInt APInt::rotl(const APInt &rotateAmt) const {
-  return rotl(rotateAmt.getLimitedValue(BitWidth));
+  return rotl((uint32_t)rotateAmt.getLimitedValue(BitWidth));
 }
 
 APInt APInt::rotl(uint32_t rotateAmt) const {
@@ -1322,7 +1322,7 @@ APInt APInt::rotl(uint32_t rotateAmt) const {
 }
 
 APInt APInt::rotr(const APInt &rotateAmt) const {
-  return rotr(rotateAmt.getLimitedValue(BitWidth));
+  return rotr((uint32_t)rotateAmt.getLimitedValue(BitWidth));
 }
 
 APInt APInt::rotr(uint32_t rotateAmt) const {
@@ -1517,8 +1517,8 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
 
       uint64_t result = u_tmp - subtrahend;
       uint32_t k = j + i;
-      u[k++] = result & (b-1); // subtract low word
-      u[k++] = result >> 32;   // subtract high word
+      u[k++] = (uint32_t)(result & (b-1)); // subtract low word
+      u[k++] = (uint32_t)(result >> 32);   // subtract high word
       while (borrow && k <= m+n) { // deal with borrow to the left
         borrow = u[k] == 0;
         u[k]--;
@@ -1549,7 +1549,7 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
 
     // D5. [Test remainder.] Set q[j] = qp. If the result of step D4 was 
     // negative, go to step D6; otherwise go on to step D7.
-    q[j] = qp;
+    q[j] = (uint32_t)qp;
     if (isNeg) {
       // D6. [Add back]. The probability that this step is necessary is very 
       // small, on the order of only 2/b. Make sure that test data accounts for
@@ -1645,8 +1645,8 @@ void APInt::divide(const APInt LHS, uint32_t lhsWords,
   memset(U, 0, (m+n+1)*sizeof(uint32_t));
   for (unsigned i = 0; i < lhsWords; ++i) {
     uint64_t tmp = (LHS.getNumWords() == 1 ? LHS.VAL : LHS.pVal[i]);
-    U[i * 2] = tmp & mask;
-    U[i * 2 + 1] = tmp >> (sizeof(uint32_t)*8);
+    U[i * 2] = (uint32_t)(tmp & mask);
+    U[i * 2 + 1] = (uint32_t)(tmp >> (sizeof(uint32_t)*8));
   }
   U[m+n] = 0; // this extra word is for "spill" in the Knuth algorithm.
 
@@ -1654,8 +1654,8 @@ void APInt::divide(const APInt LHS, uint32_t lhsWords,
   memset(V, 0, (n)*sizeof(uint32_t));
   for (unsigned i = 0; i < rhsWords; ++i) {
     uint64_t tmp = (RHS.getNumWords() == 1 ? RHS.VAL : RHS.pVal[i]);
-    V[i * 2] = tmp & mask;
-    V[i * 2 + 1] = tmp >> (sizeof(uint32_t)*8);
+    V[i * 2] = (uint32_t)(tmp & mask);
+    V[i * 2 + 1] = (uint32_t)(tmp >> (sizeof(uint32_t)*8));
   }
 
   // initialize the quotient and remainder
@@ -1691,13 +1691,13 @@ void APInt::divide(const APInt LHS, uint32_t lhsWords,
         remainder = 0;
       } else if (partial_dividend < divisor) {
         Q[i] = 0;
-        remainder = partial_dividend;
+        remainder = (uint32_t)partial_dividend;
       } else if (partial_dividend == divisor) {
         Q[i] = 1;
         remainder = 0;
       } else {
-        Q[i] = partial_dividend / divisor;
-        remainder = partial_dividend - (Q[i] * divisor);
+        Q[i] = (uint32_t)(partial_dividend / divisor);
+        remainder = (uint32_t)(partial_dividend - (Q[i] * divisor));
       }
     }
     if (R)
@@ -1991,7 +1991,7 @@ std::string APInt::toString(uint8_t radix, bool wantSigned) const {
       memset(buf, 0, 65);
       uint64_t v = VAL;
       while (bits_used) {
-        uint32_t bit = v & 1;
+        uint32_t bit = (uint32_t)v & 1;
         bits_used--;
         buf[bits_used] = digits[bit][0];
         v >>=1;
@@ -2026,7 +2026,8 @@ std::string APInt::toString(uint8_t radix, bool wantSigned) const {
       uint64_t mask = radix - 1;
       APInt zero(tmp.getBitWidth(), 0);
       while (tmp.ne(zero)) {
-        unsigned digit = (tmp.isSingleWord() ? tmp.VAL : tmp.pVal[0]) & mask;
+        unsigned digit =
+          (unsigned)((tmp.isSingleWord() ? tmp.VAL : tmp.pVal[0]) & mask);
         result.insert(insert_at, digits[digit]);
         tmp = tmp.lshr(shift);
       }
@@ -2054,7 +2055,7 @@ std::string APInt::toString(uint8_t radix, bool wantSigned) const {
     APInt tmp2(tmp.getBitWidth(), 0);
     divide(tmp, tmp.getNumWords(), divisor, divisor.getNumWords(), &tmp2, 
            &APdigit);
-    uint32_t digit = APdigit.getZExtValue();
+    uint32_t digit = (uint32_t)APdigit.getZExtValue();
     assert(digit < radix && "divide failed");
     result.insert(insert_at,digits[digit]);
     tmp = tmp2;