maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Fix minor style issues. 

llvm-svn: 99414
This commit is contained in:
Dan Gohman 2010-03-24 19:38:02 +00:00
parent 4634b7d4f6
commit b452d4e9e4
6 changed files with 206 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

252
llvm/lib/Support/APFloat.cpp
View File

@ -100,15 +100,15 @@ hexDigitValue(unsigned int c)
unsigned int r;
r = c - '0';
if(r <= 9)
if (r <= 9)
return r;
r = c - 'A';
if(r <= 5)
if (r <= 5)
return r + 10;
r = c - 'a';
if(r <= 5)
if (r <= 5)
return r + 10;
return -1U;
@ -116,8 +116,8 @@ hexDigitValue(unsigned int c)
static inline void
assertArithmeticOK(const llvm::fltSemantics &semantics) {
assert(semantics.arithmeticOK
&& "Compile-time arithmetic does not support these semantics");
assert(semantics.arithmeticOK &&
"Compile-time arithmetic does not support these semantics");
}
/* Return the value of a decimal exponent of the form
@ -179,37 +179,37 @@ totalExponent(StringRef::iterator p, StringRef::iterator end,
assert(p != end && "Exponent has no digits");
negative = *p == '-';
if(*p == '-' || *p == '+') {
if (*p == '-' || *p == '+') {
p++;
assert(p != end && "Exponent has no digits");
}
unsignedExponent = 0;
overflow = false;
for(; p != end; ++p) {
for (; p != end; ++p) {
unsigned int value;
value = decDigitValue(*p);
assert(value < 10U && "Invalid character in exponent");
unsignedExponent = unsignedExponent * 10 + value;
if(unsignedExponent > 65535)
if (unsignedExponent > 65535)
overflow = true;
}
if(exponentAdjustment > 65535 || exponentAdjustment < -65536)
if (exponentAdjustment > 65535 || exponentAdjustment < -65536)
overflow = true;
if(!overflow) {
if (!overflow) {
exponent = unsignedExponent;
if(negative)
if (negative)
exponent = -exponent;
exponent += exponentAdjustment;
if(exponent > 65535 || exponent < -65536)
if (exponent > 65535 || exponent < -65536)
overflow = true;
}
if(overflow)
if (overflow)
exponent = negative ? -65536: 65535;
return exponent;
@ -221,15 +221,15 @@ skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end,
{
StringRef::iterator p = begin;
*dot = end;
while(*p == '0' && p != end)
while (*p == '0' && p != end)
p++;
if(*p == '.') {
if (*p == '.') {
*dot = p++;
assert(end - begin != 1 && "Significand has no digits");
while(*p == '0' && p != end)
while (*p == '0' && p != end)
p++;
}
@ -323,13 +323,13 @@ trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
/* If the first trailing digit isn't 0 or 8 we can work out the
fraction immediately. */
if(digitValue > 8)
if (digitValue > 8)
return lfMoreThanHalf;
else if(digitValue < 8 && digitValue > 0)
else if (digitValue < 8 && digitValue > 0)
return lfLessThanHalf;
/* Otherwise we need to find the first non-zero digit. */
while(*p == '0')
while (*p == '0')
p++;
assert(p != end && "Invalid trailing hexadecimal fraction!");
@ -338,7 +338,7 @@ trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
/* If we ran off the end it is exactly zero or one-half, otherwise
a little more. */
if(hexDigit == -1U)
if (hexDigit == -1U)
return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
else
return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
@ -356,12 +356,12 @@ lostFractionThroughTruncation(const integerPart *parts,
lsb = APInt::tcLSB(parts, partCount);
/* Note this is guaranteed true if bits == 0, or LSB == -1U. */
if(bits <= lsb)
if (bits <= lsb)
return lfExactlyZero;
if(bits == lsb + 1)
if (bits == lsb + 1)
return lfExactlyHalf;
if(bits <= partCount * integerPartWidth
&& APInt::tcExtractBit(parts, bits - 1))
if (bits <= partCount * integerPartWidth &&
APInt::tcExtractBit(parts, bits - 1))
return lfMoreThanHalf;
return lfLessThanHalf;
@ -385,10 +385,10 @@ static lostFraction
combineLostFractions(lostFraction moreSignificant,
lostFraction lessSignificant)
{
if(lessSignificant != lfExactlyZero) {
if(moreSignificant == lfExactlyZero)
if (lessSignificant != lfExactlyZero) {
if (moreSignificant == lfExactlyZero)
moreSignificant = lfLessThanHalf;
else if(moreSignificant == lfExactlyHalf)
else if (moreSignificant == lfExactlyHalf)
moreSignificant = lfMoreThanHalf;
}
@ -588,14 +588,14 @@ APFloat::initialize(const fltSemantics *ourSemantics)
semantics = ourSemantics;
count = partCount();
if(count > 1)
if (count > 1)
significand.parts = new integerPart[count];
}
void
APFloat::freeSignificand()
{
if(partCount() > 1)
if (partCount() > 1)
delete [] significand.parts;
}
@ -609,7 +609,7 @@ APFloat::assign(const APFloat &rhs)
exponent = rhs.exponent;
sign2 = rhs.sign2;
exponent2 = rhs.exponent2;
if(category == fcNormal || category == fcNaN)
if (category == fcNormal || category == fcNaN)
copySignificand(rhs);
}
@ -683,8 +683,8 @@ APFloat APFloat::makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
APFloat &
APFloat::operator=(const APFloat &rhs)
{
if(this != &rhs) {
if(semantics != rhs.semantics) {
if (this != &rhs) {
if (semantics != rhs.semantics) {
freeSignificand();
initialize(rhs.semantics);
}
@ -881,7 +881,7 @@ APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
precision = semantics->precision;
newPartsCount = partCountForBits(precision * 2);
if(newPartsCount > 4)
if (newPartsCount > 4)
fullSignificand = new integerPart[newPartsCount];
else
fullSignificand = scratch;
@ -896,7 +896,7 @@ APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
exponent += rhs.exponent;
if(addend) {
if (addend) {
Significand savedSignificand = significand;
const fltSemantics *savedSemantics = semantics;
fltSemantics extendedSemantics;
@ -905,8 +905,7 @@ APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
/* Normalize our MSB. */
extendedPrecision = precision + precision - 1;
if(omsb != extendedPrecision)
{
if (omsb != extendedPrecision) {
APInt::tcShiftLeft(fullSignificand, newPartsCount,
extendedPrecision - omsb);
exponent -= extendedPrecision - omsb;
@ -916,7 +915,7 @@ APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
extendedSemantics = *semantics;
extendedSemantics.precision = extendedPrecision;
if(newPartsCount == 1)
if (newPartsCount == 1)
significand.part = fullSignificand[0];
else
significand.parts = fullSignificand;
@ -928,7 +927,7 @@ APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
lost_fraction = addOrSubtractSignificand(extendedAddend, false);
/* Restore our state. */
if(newPartsCount == 1)
if (newPartsCount == 1)
fullSignificand[0] = significand.part;
significand = savedSignificand;
semantics = savedSemantics;
@ -938,7 +937,7 @@ APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
exponent -= (precision - 1);
if(omsb > precision) {
if (omsb > precision) {
unsigned int bits, significantParts;
lostFraction lf;
@ -951,7 +950,7 @@ APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
if(newPartsCount > 4)
if (newPartsCount > 4)
delete [] fullSignificand;
return lost_fraction;
@ -973,7 +972,7 @@ APFloat::divideSignificand(const APFloat &rhs)
rhsSignificand = rhs.significandParts();
partsCount = partCount();
if(partsCount > 2)
if (partsCount > 2)
dividend = new integerPart[partsCount * 2];
else
dividend = scratch;
@ -981,7 +980,7 @@ APFloat::divideSignificand(const APFloat &rhs)
divisor = dividend + partsCount;
/* Copy the dividend and divisor as they will be modified in-place. */
for(i = 0; i < partsCount; i++) {
for (i = 0; i < partsCount; i++) {
dividend[i] = lhsSignificand[i];
divisor[i] = rhsSignificand[i];
lhsSignificand[i] = 0;
@ -993,14 +992,14 @@ APFloat::divideSignificand(const APFloat &rhs)
/* Normalize the divisor. */
bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
if(bit) {
if (bit) {
exponent += bit;
APInt::tcShiftLeft(divisor, partsCount, bit);
}
/* Normalize the dividend. */
bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
if(bit) {
if (bit) {
exponent -= bit;
APInt::tcShiftLeft(dividend, partsCount, bit);
}
@ -1008,15 +1007,15 @@ APFloat::divideSignificand(const APFloat &rhs)
/* Ensure the dividend >= divisor initially for the loop below.
Incidentally, this means that the division loop below is
guaranteed to set the integer bit to one. */
if(APInt::tcCompare(dividend, divisor, partsCount) < 0) {
if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
exponent--;
APInt::tcShiftLeft(dividend, partsCount, 1);
assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
}
/* Long division. */
for(bit = precision; bit; bit -= 1) {
if(APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
for (bit = precision; bit; bit -= 1) {
if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
APInt::tcSubtract(dividend, divisor, 0, partsCount);
APInt::tcSetBit(lhsSignificand, bit - 1);
}
@ -1027,16 +1026,16 @@ APFloat::divideSignificand(const APFloat &rhs)
/* Figure out the lost fraction. */
int cmp = APInt::tcCompare(dividend, divisor, partsCount);
if(cmp > 0)
if (cmp > 0)
lost_fraction = lfMoreThanHalf;
else if(cmp == 0)
else if (cmp == 0)
lost_fraction = lfExactlyHalf;
else if(APInt::tcIsZero(dividend, partsCount))
else if (APInt::tcIsZero(dividend, partsCount))
lost_fraction = lfExactlyZero;
else
lost_fraction = lfLessThanHalf;
if(partsCount > 2)
if (partsCount > 2)
delete [] dividend;
return lost_fraction;
@ -1072,7 +1071,7 @@ APFloat::shiftSignificandLeft(unsigned int bits)
{
assert(bits < semantics->precision);
if(bits) {
if (bits) {
unsigned int partsCount = partCount();
APInt::tcShiftLeft(significandParts(), partsCount, bits);
@ -1095,13 +1094,13 @@ APFloat::compareAbsoluteValue(const APFloat &rhs) const
/* If exponents are equal, do an unsigned bignum comparison of the
significands. */
if(compare == 0)
if (compare == 0)
compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
partCount());
if(compare > 0)
if (compare > 0)
return cmpGreaterThan;
else if(compare < 0)
else if (compare < 0)
return cmpLessThan;
else
return cmpEqual;
@ -1113,11 +1112,10 @@ APFloat::opStatus
APFloat::handleOverflow(roundingMode rounding_mode)
{
/* Infinity? */
if(rounding_mode == rmNearestTiesToEven
|| rounding_mode == rmNearestTiesToAway
|| (rounding_mode == rmTowardPositive && !sign)
|| (rounding_mode == rmTowardNegative && sign))
{
if (rounding_mode == rmNearestTiesToEven ||
rounding_mode == rmNearestTiesToAway ||
(rounding_mode == rmTowardPositive && !sign) ||
(rounding_mode == rmTowardNegative && sign)) {
category = fcInfinity;
return (opStatus) (opOverflow | opInexact);
}
@ -1155,11 +1153,11 @@ APFloat::roundAwayFromZero(roundingMode rounding_mode,
return lost_fraction == lfExactlyHalf || lost_fraction == lfMoreThanHalf;
case rmNearestTiesToEven:
if(lost_fraction == lfMoreThanHalf)
if (lost_fraction == lfMoreThanHalf)
return true;
/* Our zeroes don't have a significand to test. */
if(lost_fraction == lfExactlyHalf && category != fcZero)
if (lost_fraction == lfExactlyHalf && category != fcZero)
return APInt::tcExtractBit(significandParts(), bit);
return false;
@ -1182,13 +1180,13 @@ APFloat::normalize(roundingMode rounding_mode,
unsigned int omsb; /* One, not zero, based MSB. */
int exponentChange;
if(category != fcNormal)
if (category != fcNormal)
return opOK;
/* Before rounding normalize the exponent of fcNormal numbers. */
omsb = significandMSB() + 1;
if(omsb) {
if (omsb) {
/* OMSB is numbered from 1. We want to place it in the integer
bit numbered PRECISON if possible, with a compensating change in
the exponent. */
@ -1196,16 +1194,16 @@ APFloat::normalize(roundingMode rounding_mode,
/* If the resulting exponent is too high, overflow according to
the rounding mode. */
if(exponent + exponentChange > semantics->maxExponent)
if (exponent + exponentChange > semantics->maxExponent)
return handleOverflow(rounding_mode);
/* Subnormal numbers have exponent minExponent, and their MSB
is forced based on that. */
if(exponent + exponentChange < semantics->minExponent)
if (exponent + exponentChange < semantics->minExponent)
exponentChange = semantics->minExponent - exponent;
/* Shifting left is easy as we don't lose precision. */
if(exponentChange < 0) {
if (exponentChange < 0) {
assert(lost_fraction == lfExactlyZero);
shiftSignificandLeft(-exponentChange);
@ -1213,7 +1211,7 @@ APFloat::normalize(roundingMode rounding_mode,
return opOK;
}
if(exponentChange > 0) {
if (exponentChange > 0) {
lostFraction lf;
/* Shift right and capture any new lost fraction. */
@ -1222,7 +1220,7 @@ APFloat::normalize(roundingMode rounding_mode,
lost_fraction = combineLostFractions(lf, lost_fraction);
/* Keep OMSB up-to-date. */
if(omsb > (unsigned) exponentChange)
if (omsb > (unsigned) exponentChange)
omsb -= exponentChange;
else
omsb = 0;
@ -1234,28 +1232,28 @@ APFloat::normalize(roundingMode rounding_mode,
/* As specified in IEEE 754, since we do not trap we do not report
underflow for exact results. */
if(lost_fraction == lfExactlyZero) {
if (lost_fraction == lfExactlyZero) {
/* Canonicalize zeroes. */
if(omsb == 0)
if (omsb == 0)
category = fcZero;
return opOK;
}
/* Increment the significand if we're rounding away from zero. */
if(roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
if(omsb == 0)
if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
if (omsb == 0)
exponent = semantics->minExponent;
incrementSignificand();
omsb = significandMSB() + 1;
/* Did the significand increment overflow? */
if(omsb == (unsigned) semantics->precision + 1) {
if (omsb == (unsigned) semantics->precision + 1) {
/* Renormalize by incrementing the exponent and shifting our
significand right one. However if we already have the
maximum exponent we overflow to infinity. */
if(exponent == semantics->maxExponent) {
if (exponent == semantics->maxExponent) {
category = fcInfinity;
return (opStatus) (opOverflow | opInexact);
@ -1269,14 +1267,14 @@ APFloat::normalize(roundingMode rounding_mode,
/* The normal case - we were and are not denormal, and any
significand increment above didn't overflow. */
if(omsb == semantics->precision)
if (omsb == semantics->precision)
return opInexact;
/* We have a non-zero denormal. */
assert(omsb < semantics->precision);
/* Canonicalize zeroes. */
if(omsb == 0)
if (omsb == 0)
category = fcZero;
/* The fcZero case is a denormal that underflowed to zero. */
@ -1324,7 +1322,7 @@ APFloat::addOrSubtractSpecials(const APFloat &rhs, bool subtract)
case convolve(fcInfinity, fcInfinity):
/* Differently signed infinities can only be validly
subtracted. */
if(((sign ^ rhs.sign)!=0) != subtract) {
if (((sign ^ rhs.sign)!=0) != subtract) {
makeNaN();
return opInvalidOp;
}
@ -1352,7 +1350,7 @@ APFloat::addOrSubtractSignificand(const APFloat &rhs, bool subtract)
bits = exponent - rhs.exponent;
/* Subtraction is more subtle than one might naively expect. */
if(subtract) {
if (subtract) {
APFloat temp_rhs(rhs);
bool reverse;
@ -1381,16 +1379,16 @@ APFloat::addOrSubtractSignificand(const APFloat &rhs, bool subtract)
/* Invert the lost fraction - it was on the RHS and
subtracted. */
if(lost_fraction == lfLessThanHalf)
if (lost_fraction == lfLessThanHalf)
lost_fraction = lfMoreThanHalf;
else if(lost_fraction == lfMoreThanHalf)
else if (lost_fraction == lfMoreThanHalf)
lost_fraction = lfLessThanHalf;
/* The code above is intended to ensure that no borrow is
necessary. */
assert(!carry);
} else {
if(bits > 0) {
if (bits > 0) {
APFloat temp_rhs(rhs);
lost_fraction = temp_rhs.shiftSignificandRight(bits);
@ -1561,7 +1559,7 @@ APFloat::addOrSubtract(const APFloat &rhs, roundingMode rounding_mode,
fs = addOrSubtractSpecials(rhs, subtract);
/* This return code means it was not a simple case. */
if(fs == opDivByZero) {
if (fs == opDivByZero) {
lostFraction lost_fraction;
lost_fraction = addOrSubtractSignificand(rhs, subtract);
@ -1574,8 +1572,8 @@ APFloat::addOrSubtract(const APFloat &rhs, roundingMode rounding_mode,
/* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
positive zero unless rounding to minus infinity, except that
adding two like-signed zeroes gives that zero. */
if(category == fcZero) {
if(rhs.category != fcZero || (sign == rhs.sign) == subtract)
if (category == fcZero) {
if (rhs.category != fcZero || (sign == rhs.sign) == subtract)
sign = (rounding_mode == rmTowardNegative);
}
@ -1606,10 +1604,10 @@ APFloat::multiply(const APFloat &rhs, roundingMode rounding_mode)
sign ^= rhs.sign;
fs = multiplySpecials(rhs);
if(category == fcNormal) {
if (category == fcNormal) {
lostFraction lost_fraction = multiplySignificand(rhs, 0);
fs = normalize(rounding_mode, lost_fraction);
if(lost_fraction != lfExactlyZero)
if (lost_fraction != lfExactlyZero)
fs = (opStatus) (fs | opInexact);
}
@ -1626,10 +1624,10 @@ APFloat::divide(const APFloat &rhs, roundingMode rounding_mode)
sign ^= rhs.sign;
fs = divideSpecials(rhs);
if(category == fcNormal) {
if (category == fcNormal) {
lostFraction lost_fraction = divideSignificand(rhs);
fs = normalize(rounding_mode, lost_fraction);
if(lost_fraction != lfExactlyZero)
if (lost_fraction != lfExactlyZero)
fs = (opStatus) (fs | opInexact);
}
@ -1730,20 +1728,20 @@ APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
/* If and only if all arguments are normal do we need to do an
extended-precision calculation. */
if(category == fcNormal
&& multiplicand.category == fcNormal
&& addend.category == fcNormal) {
if (category == fcNormal &&
multiplicand.category == fcNormal &&
addend.category == fcNormal) {
lostFraction lost_fraction;
lost_fraction = multiplySignificand(multiplicand, &addend);
fs = normalize(rounding_mode, lost_fraction);
if(lost_fraction != lfExactlyZero)
if (lost_fraction != lfExactlyZero)
fs = (opStatus) (fs | opInexact);
/* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
positive zero unless rounding to minus infinity, except that
adding two like-signed zeroes gives that zero. */
if(category == fcZero && sign != addend.sign)
if (category == fcZero && sign != addend.sign)
sign = (rounding_mode == rmTowardNegative);
} else {
fs = multiplySpecials(multiplicand);
@ -1755,7 +1753,7 @@ APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
If we need to do the addition we can do so with normal
precision. */
if(fs == opOK)
if (fs == opOK)
fs = addOrSubtract(addend, rounding_mode, false);
}
@ -1787,7 +1785,7 @@ APFloat::compare(const APFloat &rhs) const
case convolve(fcInfinity, fcNormal):
case convolve(fcInfinity, fcZero):
case convolve(fcNormal, fcZero):
if(sign)
if (sign)
return cmpLessThan;
else
return cmpGreaterThan;
@ -1795,15 +1793,15 @@ APFloat::compare(const APFloat &rhs) const
case convolve(fcNormal, fcInfinity):
case convolve(fcZero, fcInfinity):
case convolve(fcZero, fcNormal):
if(rhs.sign)
if (rhs.sign)
return cmpGreaterThan;
else
return cmpLessThan;
case convolve(fcInfinity, fcInfinity):
if(sign == rhs.sign)
if (sign == rhs.sign)
return cmpEqual;
else if(sign)
else if (sign)
return cmpLessThan;
else
return cmpGreaterThan;
@ -1816,8 +1814,8 @@ APFloat::compare(const APFloat &rhs) const
}
/* Two normal numbers. Do they have the same sign? */
if(sign != rhs.sign) {
if(sign)
if (sign != rhs.sign) {
if (sign)
result = cmpLessThan;
else
result = cmpGreaterThan;
@ -1825,10 +1823,10 @@ APFloat::compare(const APFloat &rhs) const
/* Compare absolute values; invert result if negative. */
result = compareAbsoluteValue(rhs);
if(sign) {
if(result == cmpLessThan)
if (sign) {
if (result == cmpLessThan)
result = cmpGreaterThan;
else if(result == cmpGreaterThan)
else if (result == cmpGreaterThan)
result = cmpLessThan;
}
}
@ -1886,7 +1884,7 @@ APFloat::convert(const fltSemantics &toSemantics,
}
}
if(category == fcNormal) {
if (category == fcNormal) {
/* Re-interpret our bit-pattern. */
exponent += toSemantics.precision - semantics->precision;
semantics = &toSemantics;
@ -1956,12 +1954,12 @@ APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
*isExact = false;
/* Handle the three special cases first. */
if(category == fcInfinity || category == fcNaN)
if (category == fcInfinity || category == fcNaN)
return opInvalidOp;
dstPartsCount = partCountForBits(width);
if(category == fcZero) {
if (category == fcZero) {
APInt::tcSet(parts, 0, dstPartsCount);
// Negative zero can't be represented as an int.
*isExact = !sign;
@ -2004,8 +2002,8 @@ APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
if (truncatedBits) {
lost_fraction = lostFractionThroughTruncation(src, partCount(),
truncatedBits);
if (lost_fraction != lfExactlyZero
&& roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
if (lost_fraction != lfExactlyZero &&
roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
if (APInt::tcIncrement(parts, dstPartsCount))
return opInvalidOp; /* Overflow. */
}
@ -2149,8 +2147,8 @@ APFloat::convertFromSignExtendedInteger(const integerPart *src,
opStatus status;
assertArithmeticOK(*semantics);
if (isSigned
&& APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
if (isSigned &&
APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
integerPart *copy;
/* If we're signed and negative negate a copy. */
@ -2178,7 +2176,7 @@ APFloat::convertFromZeroExtendedInteger(const integerPart *parts,
APInt api = APInt(width, partCount, parts);
sign = false;
if(isSigned && APInt::tcExtractBit(parts, width - 1)) {
if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
sign = true;
api = -api;
}
@ -2209,10 +2207,10 @@ APFloat::convertFromHexadecimalString(const StringRef &s,
StringRef::iterator p = skipLeadingZeroesAndAnyDot(begin, end, &dot);
firstSignificantDigit = p;
for(; p != end;) {
for (; p != end;) {
integerPart hex_value;
if(*p == '.') {
if (*p == '.') {
assert(dot == end && "String contains multiple dots");
dot = p++;
if (p == end) {
@ -2221,7 +2219,7 @@ APFloat::convertFromHexadecimalString(const StringRef &s,
}
hex_value = hexDigitValue(*p);
if(hex_value == -1U) {
if (hex_value == -1U) {
break;
}
@ -2231,13 +2229,13 @@ APFloat::convertFromHexadecimalString(const StringRef &s,
break;
} else {
/* Store the number whilst 4-bit nibbles remain. */
if(bitPos) {
if (bitPos) {
bitPos -= 4;
hex_value <<= bitPos % integerPartWidth;
significand[bitPos / integerPartWidth] |= hex_value;
} else {
lost_fraction = trailingHexadecimalFraction(p, end, hex_value);
while(p != end && hexDigitValue(*p) != -1U)
while (p != end && hexDigitValue(*p) != -1U)
p++;
break;
}
@ -2251,7 +2249,7 @@ APFloat::convertFromHexadecimalString(const StringRef &s,
assert((dot == end || p - begin != 1) && "Significand has no digits");
/* Ignore the exponent if we are zero. */
if(p != firstSignificantDigit) {
if (p != firstSignificantDigit) {
int expAdjustment;
/* Implicit hexadecimal point? */
@ -2261,7 +2259,7 @@ APFloat::convertFromHexadecimalString(const StringRef &s,
/* Calculate the exponent adjustment implicit in the number of
significant digits. */
expAdjustment = static_cast<int>(dot - firstSignificantDigit);
if(expAdjustment < 0)
if (expAdjustment < 0)
expAdjustment++;
expAdjustment = expAdjustment * 4 - 1;
@ -2287,8 +2285,8 @@ APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
integerPart pow5Parts[maxPowerOfFiveParts];
bool isNearest;
isNearest = (rounding_mode == rmNearestTiesToEven
|| rounding_mode == rmNearestTiesToAway);
isNearest = (rounding_mode == rmNearestTiesToEven ||
rounding_mode == rmNearestTiesToAway);
parts = partCountForBits(semantics->precision + 11);
@ -2482,13 +2480,13 @@ APFloat::convertFromString(const StringRef &str, roundingMode rounding_mode)
StringRef::iterator p = str.begin();
size_t slen = str.size();
sign = *p == '-' ? 1 : 0;
if(*p == '-' || *p == '+') {
if (*p == '-' || *p == '+') {
p++;
slen--;
assert(slen && "String has no digits");
}
if(slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
if (slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
assert(slen - 2 && "Invalid string");
return convertFromHexadecimalString(StringRef(p + 2, slen - 2),
rounding_mode);
@ -3217,8 +3215,8 @@ APFloat APFloat::getLargest(const fltSemantics &Sem, bool Negative) {
significand[i] = ~((integerPart) 0);
// ...and then clear the top bits for internal consistency.
significand[N-1]
&= (((integerPart) 1) << ((Sem.precision % integerPartWidth) - 1)) - 1;
significand[N-1] &=
(((integerPart) 1) << ((Sem.precision % integerPartWidth) - 1)) - 1;
return Val;
}
@ -3247,8 +3245,8 @@ APFloat APFloat::getSmallestNormalized(const fltSemantics &Sem, bool Negative) {
Val.exponent = Sem.minExponent;
Val.zeroSignificand();
Val.significandParts()[partCountForBits(Sem.precision)-1]
|= (((integerPart) 1) << ((Sem.precision % integerPartWidth) - 1));
Val.significandParts()[partCountForBits(Sem.precision)-1] |=
(((integerPart) 1) << ((Sem.precision % integerPartWidth) - 1));
return Val;
}

51
llvm/lib/Support/APInt.cpp
View File

@ -702,8 +702,7 @@ static inline uint32_t hashword(const uint64_t *k64, size_t length)
a = b = c = 0xdeadbeef + (((uint32_t)length)<<2);
/*------------------------------------------------- handle most of the key */
while (length > 3)
{
while (length > 3) {
a += k[0];
b += k[1];
c += k[2];
@ -2065,8 +2064,8 @@ void APInt::fromString(unsigned numbits, const StringRef& str, uint8_t radix) {
assert((slen <= numbits || radix != 2) && "Insufficient bit width");
assert(((slen-1)*3 <= numbits || radix != 8) && "Insufficient bit width");
assert(((slen-1)*4 <= numbits || radix != 16) && "Insufficient bit width");
assert((((slen-1)*64)/22 <= numbits || radix != 10)
&& "Insufficient bit width");
assert((((slen-1)*64)/22 <= numbits || radix != 10) &&
"Insufficient bit width");
// Allocate memory
if (!isSingleWord())
@ -2229,7 +2228,7 @@ namespace {
static inline integerPart
lowBitMask(unsigned int bits)
{
assert (bits != 0 && bits <= integerPartWidth);
assert(bits != 0 && bits <= integerPartWidth);
return ~(integerPart) 0 >> (integerPartWidth - bits);
}
@ -2306,10 +2305,10 @@ APInt::tcSet(integerPart *dst, integerPart part, unsigned int parts)
{
unsigned int i;
assert (parts > 0);
assert(parts > 0);
dst[0] = part;
for(i = 1; i < parts; i++)
for (i = 1; i < parts; i++)
dst[i] = 0;
}
@ -2319,7 +2318,7 @@ APInt::tcAssign(integerPart *dst, const integerPart *src, unsigned int parts)
{
unsigned int i;
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
dst[i] = src[i];
}
@ -2329,7 +2328,7 @@ APInt::tcIsZero(const integerPart *src, unsigned int parts)
{
unsigned int i;
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
if (src[i])
return false;
@ -2340,8 +2339,8 @@ APInt::tcIsZero(const integerPart *src, unsigned int parts)
int
APInt::tcExtractBit(const integerPart *parts, unsigned int bit)
{
return(parts[bit / integerPartWidth]
& ((integerPart) 1 << bit % integerPartWidth)) != 0;
return (parts[bit / integerPartWidth] &
((integerPart) 1 << bit % integerPartWidth)) != 0;
}
/* Set the given bit of a bignum. */
@ -2366,7 +2365,7 @@ APInt::tcLSB(const integerPart *parts, unsigned int n)
{
unsigned int i, lsb;
for(i = 0; i < n; i++) {
for (i = 0; i < n; i++) {
if (parts[i] != 0) {
lsb = partLSB(parts[i]);
@ -2408,7 +2407,7 @@ APInt::tcExtract(integerPart *dst, unsigned int dstCount,const integerPart *src,
unsigned int firstSrcPart, dstParts, shift, n;
dstParts = (srcBits + integerPartWidth - 1) / integerPartWidth;
assert (dstParts <= dstCount);
assert(dstParts <= dstCount);
firstSrcPart = srcLSB / integerPartWidth;
tcAssign (dst, src + firstSrcPart, dstParts);
@ -2443,7 +2442,7 @@ APInt::tcAdd(integerPart *dst, const integerPart *rhs,
assert(c <= 1);
for(i = 0; i < parts; i++) {
for (i = 0; i < parts; i++) {
integerPart l;
l = dst[i];
@ -2468,7 +2467,7 @@ APInt::tcSubtract(integerPart *dst, const integerPart *rhs,
assert(c <= 1);
for(i = 0; i < parts; i++) {
for (i = 0; i < parts; i++) {
integerPart l;
l = dst[i];
@ -2518,7 +2517,7 @@ APInt::tcMultiplyPart(integerPart *dst, const integerPart *src,
/* N loops; minimum of dstParts and srcParts. */
n = dstParts < srcParts ? dstParts: srcParts;
for(i = 0; i < n; i++) {
for (i = 0; i < n; i++) {
integerPart low, mid, high, srcPart;
/* [ LOW, HIGH ] = MULTIPLIER * SRC[i] + DST[i] + CARRY.
@ -2583,7 +2582,7 @@ APInt::tcMultiplyPart(integerPart *dst, const integerPart *src,
non-zero. This is true if any remaining src parts are non-zero
and the multiplier is non-zero. */
if (multiplier)
for(; i < srcParts; i++)
for (; i < srcParts; i++)
if (src[i])
return 1;
@ -2608,7 +2607,7 @@ APInt::tcMultiply(integerPart *dst, const integerPart *lhs,
overflow = 0;
tcSet(dst, 0, parts);
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
overflow |= tcMultiplyPart(&dst[i], lhs, rhs[i], 0, parts,
parts - i, true);
@ -2634,7 +2633,7 @@ APInt::tcFullMultiply(integerPart *dst, const integerPart *lhs,
tcSet(dst, 0, rhsParts);
for(n = 0; n < lhsParts; n++)
for (n = 0; n < lhsParts; n++)
tcMultiplyPart(&dst[n], rhs, lhs[n], 0, rhsParts, rhsParts + 1, true);
n = lhsParts + rhsParts;
@ -2678,7 +2677,7 @@ APInt::tcDivide(integerPart *lhs, const integerPart *rhs,
/* Loop, subtracting SRHS if REMAINDER is greater and adding that to
the total. */
for(;;) {
for (;;) {
int compare;
compare = tcCompare(remainder, srhs, parts);
@ -2746,7 +2745,7 @@ APInt::tcShiftRight(integerPart *dst, unsigned int parts, unsigned int count)
/* Perform the shift. This leaves the most significant COUNT bits
of the result at zero. */
for(i = 0; i < parts; i++) {
for (i = 0; i < parts; i++) {
integerPart part;
if (i + jump >= parts) {
@ -2771,7 +2770,7 @@ APInt::tcAnd(integerPart *dst, const integerPart *rhs, unsigned int parts)
{
unsigned int i;
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
dst[i] &= rhs[i];
}
@ -2781,7 +2780,7 @@ APInt::tcOr(integerPart *dst, const integerPart *rhs, unsigned int parts)
{
unsigned int i;
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
dst[i] |= rhs[i];
}
@ -2791,7 +2790,7 @@ APInt::tcXor(integerPart *dst, const integerPart *rhs, unsigned int parts)
{
unsigned int i;
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
dst[i] ^= rhs[i];
}
@ -2801,7 +2800,7 @@ APInt::tcComplement(integerPart *dst, unsigned int parts)
{
unsigned int i;
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
dst[i] = ~dst[i];
}
@ -2830,7 +2829,7 @@ APInt::tcIncrement(integerPart *dst, unsigned int parts)
{
unsigned int i;
for(i = 0; i < parts; i++)
for (i = 0; i < parts; i++)
if (++dst[i] != 0)
break;

4
llvm/lib/Support/CommandLine.cpp
View File

@ -676,8 +676,8 @@ void cl::ParseCommandLineOptions(int argc, char **argv,
<< " positional arguments: See: " << argv[0] << " -help\n";
ErrorParsing = true;
} else if (!HasUnlimitedPositionals
&& PositionalVals.size() > PositionalOpts.size()) {
} else if (!HasUnlimitedPositionals &&
PositionalVals.size() > PositionalOpts.size()) {
errs() << ProgramName
<< ": Too many positional arguments specified!\n"
<< "Can specify at most " << PositionalOpts.size()

3
llvm/lib/Support/Debug.cpp
View File

@ -64,8 +64,7 @@ DebugOnly("debug-only", cl::desc("Enable a specific type of debug output"),
cl::location(DebugOnlyOptLoc), cl::ValueRequired);
// Signal handlers - dump debug output on termination.
static void debug_user_sig_handler(void *Cookie)
{
static void debug_user_sig_handler(void *Cookie) {
// This is a bit sneaky. Since this is under #ifndef NDEBUG, we
// know that debug mode is enabled and dbgs() really is a
// circular_raw_ostream. If NDEBUG is defined, then dbgs() ==

1
llvm/lib/Support/ErrorHandling.cpp
View File

@ -71,4 +71,3 @@ void llvm_unreachable_internal(const char *msg, const char *file,
abort();
}
}

4
llvm/lib/Support/raw_ostream.cpp
View File

@ -418,14 +418,14 @@ raw_fd_ostream::~raw_fd_ostream() {
void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
assert (FD >= 0 && "File already closed.");
assert(FD >= 0 && "File already closed.");
pos += Size;
if (::write(FD, Ptr, Size) != (ssize_t) Size)
error_detected();
}
void raw_fd_ostream::close() {
assert (ShouldClose);
assert(ShouldClose);
ShouldClose = false;
flush();
if (::close(FD) != 0)