From 48e8c80e1791adb7a07b8fd6e27edcdfbb756950 Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Fri, 2 May 2008 21:15:08 +0000 Subject: [PATCH] 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 --- include/llvm/ADT/APInt.h | 9 +++++--- lib/Support/APFloat.cpp | 48 +++++++++++++++++++++------------------- lib/Support/APInt.cpp | 41 +++++++++++++++++----------------- 3 files changed, 52 insertions(+), 46 deletions(-) diff --git a/include/llvm/ADT/APInt.h b/include/llvm/ADT/APInt.h index 737c5e620f7..49b243bf346 100644 --- a/include/llvm/ADT/APInt.h +++ b/include/llvm/ADT/APInt.h @@ -31,7 +31,8 @@ namespace llvm { typedef uint64_t integerPart; const unsigned int host_char_bit = 8; - const unsigned int integerPartWidth = host_char_bit * sizeof(integerPart); + const unsigned int integerPartWidth = host_char_bit * + static_cast(sizeof(integerPart)); //===----------------------------------------------------------------------===// // APInt Class @@ -76,8 +77,10 @@ class APInt { /// This enum is used to hold the constants we needed for APInt. enum { - APINT_BITS_PER_WORD = sizeof(uint64_t) * 8, ///< Bits in a word - APINT_WORD_SIZE = sizeof(uint64_t) ///< Byte size of a word + /// Bits in a word + APINT_BITS_PER_WORD = static_cast(sizeof(uint64_t)) * 8, + /// Byte size of a word + APINT_WORD_SIZE = static_cast(sizeof(uint64_t)) }; /// This constructor is used only internally for speed of construction of diff --git a/lib/Support/APFloat.cpp b/lib/Support/APFloat.cpp index 35de71497a9..7d6c4dc0bfc 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((dot - p) - (dot > p)); + D->normalizedExponent = (D->exponent + + static_cast((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(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(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(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(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(i1>>63); + sign2 = static_cast(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(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 615fcac8a60..ef35e1c554c 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; -- 2.34.1