mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-14 11:32:34 +00:00
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
This commit is contained in:
Evan Cheng
parent
e818f770bb
commit
48e8c80e17
@ -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<unsigned int>(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<unsigned int>(sizeof(uint64_t)) * 8,
|
||||
/// Byte size of a word
|
||||
APINT_WORD_SIZE = static_cast<unsigned int>(sizeof(uint64_t))
|
||||
};
|
||||
|
||||
/// This constructor is used only internally for speed of construction of
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user