[llvm-commits] [llvm] r99414 - in /llvm/trunk/lib/Support: APFloat.cpp APInt.cpp CommandLine.cpp Debug.cpp ErrorHandling.cpp raw_ostream.cpp
Dan Gohman
gohman at apple.com
Wed Mar 24 12:38:03 PDT 2010
Author: djg
Date: Wed Mar 24 14:38:02 2010
New Revision: 99414
URL: http://llvm.org/viewvc/llvm-project?rev=99414&view=rev
Log:
Fix minor style issues.
Modified:
llvm/trunk/lib/Support/APFloat.cpp
llvm/trunk/lib/Support/APInt.cpp
llvm/trunk/lib/Support/CommandLine.cpp
llvm/trunk/lib/Support/Debug.cpp
llvm/trunk/lib/Support/ErrorHandling.cpp
llvm/trunk/lib/Support/raw_ostream.cpp
Modified: llvm/trunk/lib/Support/APFloat.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APFloat.cpp?rev=99414&r1=99413&r2=99414&view=diff
==============================================================================
--- llvm/trunk/lib/Support/APFloat.cpp (original)
+++ llvm/trunk/lib/Support/APFloat.cpp Wed Mar 24 14:38:02 2010
@@ -65,7 +65,7 @@
pow(5, power) is
power * 815 / (351 * integerPartWidth) + 1
-
+
However, whilst the result may require only this many parts,
because we are multiplying two values to get it, the
multiplication may require an extra part with the excess part
@@ -100,15 +100,15 @@
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 @@
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 @@
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 @@
{
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 @@
/* 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 @@
/* 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 @@
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 @@
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;
}
@@ -468,7 +468,7 @@
15625, 78125 };
integerPart pow5s[maxPowerOfFiveParts * 2 + 5];
pow5s[0] = 78125 * 5;
-
+
unsigned int partsCount[16] = { 1 };
integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
unsigned int result;
@@ -588,14 +588,14 @@
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 @@
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::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 @@
precision = semantics->precision;
newPartsCount = partCountForBits(precision * 2);
- if(newPartsCount > 4)
+ if (newPartsCount > 4)
fullSignificand = new integerPart[newPartsCount];
else
fullSignificand = scratch;
@@ -896,7 +896,7 @@
omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
exponent += rhs.exponent;
- if(addend) {
+ if (addend) {
Significand savedSignificand = significand;
const fltSemantics *savedSemantics = semantics;
fltSemantics extendedSemantics;
@@ -905,18 +905,17 @@
/* Normalize our MSB. */
extendedPrecision = precision + precision - 1;
- if(omsb != extendedPrecision)
- {
- APInt::tcShiftLeft(fullSignificand, newPartsCount,
- extendedPrecision - omsb);
- exponent -= extendedPrecision - omsb;
- }
+ if (omsb != extendedPrecision) {
+ APInt::tcShiftLeft(fullSignificand, newPartsCount,
+ extendedPrecision - omsb);
+ exponent -= extendedPrecision - omsb;
+ }
/* Create new semantics. */
extendedSemantics = *semantics;
extendedSemantics.precision = extendedPrecision;
- if(newPartsCount == 1)
+ if (newPartsCount == 1)
significand.part = fullSignificand[0];
else
significand.parts = fullSignificand;
@@ -928,7 +927,7 @@
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 @@
exponent -= (precision - 1);
- if(omsb > precision) {
+ if (omsb > precision) {
unsigned int bits, significantParts;
lostFraction lf;
@@ -951,7 +950,7 @@
APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
- if(newPartsCount > 4)
+ if (newPartsCount > 4)
delete [] fullSignificand;
return lost_fraction;
@@ -973,7 +972,7 @@
rhsSignificand = rhs.significandParts();
partsCount = partCount();
- if(partsCount > 2)
+ if (partsCount > 2)
dividend = new integerPart[partsCount * 2];
else
dividend = scratch;
@@ -981,7 +980,7 @@
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 @@
/* 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 @@
/* 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 @@
/* 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 @@
{
assert(bits < semantics->precision);
- if(bits) {
+ if (bits) {
unsigned int partsCount = partCount();
APInt::tcShiftLeft(significandParts(), partsCount, bits);
@@ -1095,13 +1094,13 @@
/* 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,14 +1112,13 @@
APFloat::handleOverflow(roundingMode rounding_mode)
{
/* Infinity? */
- if(rounding_mode == rmNearestTiesToEven
- || rounding_mode == rmNearestTiesToAway
- || (rounding_mode == rmTowardPositive && !sign)
- || (rounding_mode == rmTowardNegative && sign))
- {
- category = fcInfinity;
- return (opStatus) (opOverflow | opInexact);
- }
+ if (rounding_mode == rmNearestTiesToEven ||
+ rounding_mode == rmNearestTiesToAway ||
+ (rounding_mode == rmTowardPositive && !sign) ||
+ (rounding_mode == rmTowardNegative && sign)) {
+ category = fcInfinity;
+ return (opStatus) (opOverflow | opInexact);
+ }
/* Otherwise we become the largest finite number. */
category = fcNormal;
@@ -1155,11 +1153,11 @@
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 @@
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 @@
/* 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 @@
return opOK;
}
- if(exponentChange > 0) {
+ if (exponentChange > 0) {
lostFraction lf;
/* Shift right and capture any new lost fraction. */
@@ -1222,7 +1220,7 @@
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 @@
/* 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 @@
/* 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 @@
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 @@
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 @@
/* 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 @@
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 @@
/* 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 @@
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 @@
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);
}
@@ -1673,7 +1671,7 @@
return fs;
}
-/* Normalized llvm frem (C fmod).
+/* Normalized llvm frem (C fmod).
This is not currently correct in all cases. */
APFloat::opStatus
APFloat::mod(const APFloat &rhs, roundingMode rounding_mode)
@@ -1730,20 +1728,20 @@
/* 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 @@
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 @@
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 @@
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 @@
}
/* 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 @@
/* 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 @@
}
}
- if(category == fcNormal) {
+ if (category == fcNormal) {
/* Re-interpret our bit-pattern. */
exponent += toSemantics.precision - semantics->precision;
semantics = &toSemantics;
@@ -1911,7 +1909,7 @@
// x87 long double).
if (APInt::tcLSB(significandParts(), newPartCount) < ushift)
*losesInfo = true;
- if (oldSemantics == &APFloat::x87DoubleExtended &&
+ if (oldSemantics == &APFloat::x87DoubleExtended &&
(!(*significandParts() & 0x8000000000000000ULL) ||
!(*significandParts() & 0x4000000000000000ULL)))
*losesInfo = true;
@@ -1956,12 +1954,12 @@
*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 @@
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. */
}
@@ -2062,7 +2060,7 @@
{
opStatus fs;
- fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
+ fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
isExact);
if (fs == opInvalidOp) {
@@ -2149,8 +2147,8 @@
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 @@
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 @@
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 @@
}
hex_value = hexDigitValue(*p);
- if(hex_value == -1U) {
+ if (hex_value == -1U) {
break;
}
@@ -2231,13 +2229,13 @@
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 @@
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 @@
/* 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 @@
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 @@
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);
@@ -3013,7 +3011,7 @@
// exponent2 and significand2 are required to be 0; we don't check
category = fcInfinity;
} else if (myexponent==0x7ff && mysignificand!=0) {
- // exponent meaningless. So is the whole second word, but keep it
+ // exponent meaningless. So is the whole second word, but keep it
// for determinism.
category = fcNaN;
exponent2 = myexponent2;
@@ -3031,7 +3029,7 @@
exponent = -1022;
else
significandParts()[0] |= 0x10000000000000LL; // integer bit
- if (myexponent2==0)
+ if (myexponent2==0)
exponent2 = -1022;
else
significandParts()[1] |= 0x10000000000000LL; // integer bit
@@ -3217,8 +3215,8 @@
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 @@
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;
}
@@ -3433,7 +3431,7 @@
// log2(N * 5^e) == log2(N) + e * log2(5)
// <= semantics->precision + e * 137 / 59
// (log_2(5) ~ 2.321928 < 2.322034 ~ 137/59)
-
+
unsigned precision = semantics->precision + 137 * texp / 59;
// Multiply significand by 5^e.
@@ -3442,7 +3440,7 @@
APInt five_to_the_i(precision, 5);
while (true) {
if (texp & 1) significand *= five_to_the_i;
-
+
texp >>= 1;
if (!texp) break;
five_to_the_i *= five_to_the_i;
Modified: llvm/trunk/lib/Support/APInt.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APInt.cpp?rev=99414&r1=99413&r2=99414&view=diff
==============================================================================
--- llvm/trunk/lib/Support/APInt.cpp (original)
+++ llvm/trunk/lib/Support/APInt.cpp Wed Mar 24 14:38:02 2010
@@ -702,15 +702,14 @@
a = b = c = 0xdeadbeef + (((uint32_t)length)<<2);
/*------------------------------------------------- handle most of the key */
- while (length > 3)
- {
- a += k[0];
- b += k[1];
- c += k[2];
- mix(a,b,c);
- length -= 3;
- k += 3;
- }
+ while (length > 3) {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ mix(a,b,c);
+ length -= 3;
+ k += 3;
+ }
/*------------------------------------------- handle the last 3 uint32_t's */
switch (length) { /* all the case statements fall through */
@@ -2065,8 +2064,8 @@
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 @@
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 @@
{
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 @@
{
unsigned int i;
- for(i = 0; i < parts; i++)
+ for (i = 0; i < parts; i++)
dst[i] = src[i];
}
@@ -2329,7 +2328,7 @@
{
unsigned int i;
- for(i = 0; i < parts; i++)
+ for (i = 0; i < parts; i++)
if (src[i])
return false;
@@ -2340,8 +2339,8 @@
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 @@
{
unsigned int i, lsb;
- for(i = 0; i < n; i++) {
+ for (i = 0; i < n; i++) {
if (parts[i] != 0) {
lsb = partLSB(parts[i]);
@@ -2385,13 +2384,13 @@
unsigned int msb;
do {
- --n;
+ --n;
- if (parts[n] != 0) {
- msb = partMSB(parts[n]);
+ if (parts[n] != 0) {
+ msb = partMSB(parts[n]);
- return msb + n * integerPartWidth;
- }
+ return msb + n * integerPartWidth;
+ }
} while (n);
return -1U;
@@ -2408,7 +2407,7 @@
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 @@
assert(c <= 1);
- for(i = 0; i < parts; i++) {
+ for (i = 0; i < parts; i++) {
integerPart l;
l = dst[i];
@@ -2468,7 +2467,7 @@
assert(c <= 1);
- for(i = 0; i < parts; i++) {
+ for (i = 0; i < parts; i++) {
integerPart l;
l = dst[i];
@@ -2518,7 +2517,7 @@
/* 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 @@
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 @@
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 @@
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 @@
/* 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 @@
/* 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 @@
{
unsigned int i;
- for(i = 0; i < parts; i++)
+ for (i = 0; i < parts; i++)
dst[i] &= rhs[i];
}
@@ -2781,7 +2780,7 @@
{
unsigned int i;
- for(i = 0; i < parts; i++)
+ for (i = 0; i < parts; i++)
dst[i] |= rhs[i];
}
@@ -2791,7 +2790,7 @@
{
unsigned int i;
- for(i = 0; i < parts; i++)
+ for (i = 0; i < parts; i++)
dst[i] ^= rhs[i];
}
@@ -2801,7 +2800,7 @@
{
unsigned int i;
- for(i = 0; i < parts; i++)
+ for (i = 0; i < parts; i++)
dst[i] = ~dst[i];
}
@@ -2830,7 +2829,7 @@
{
unsigned int i;
- for(i = 0; i < parts; i++)
+ for (i = 0; i < parts; i++)
if (++dst[i] != 0)
break;
Modified: llvm/trunk/lib/Support/CommandLine.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/CommandLine.cpp?rev=99414&r1=99413&r2=99414&view=diff
==============================================================================
--- llvm/trunk/lib/Support/CommandLine.cpp (original)
+++ llvm/trunk/lib/Support/CommandLine.cpp Wed Mar 24 14:38:02 2010
@@ -676,8 +676,8 @@
<< " 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()
Modified: llvm/trunk/lib/Support/Debug.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/Debug.cpp?rev=99414&r1=99413&r2=99414&view=diff
==============================================================================
--- llvm/trunk/lib/Support/Debug.cpp (original)
+++ llvm/trunk/lib/Support/Debug.cpp Wed Mar 24 14:38:02 2010
@@ -64,8 +64,7 @@
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() ==
Modified: llvm/trunk/lib/Support/ErrorHandling.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/ErrorHandling.cpp?rev=99414&r1=99413&r2=99414&view=diff
==============================================================================
--- llvm/trunk/lib/Support/ErrorHandling.cpp (original)
+++ llvm/trunk/lib/Support/ErrorHandling.cpp Wed Mar 24 14:38:02 2010
@@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines an API for error handling, it supersedes cerr+abort(), and
+// This file defines an API for error handling, it supersedes cerr+abort(), and
// cerr+exit() style error handling.
// Callbacks can be registered for these errors through this API.
//===----------------------------------------------------------------------===//
@@ -57,7 +57,7 @@
exit(1);
}
-void llvm_unreachable_internal(const char *msg, const char *file,
+void llvm_unreachable_internal(const char *msg, const char *file,
unsigned line) {
// This code intentionally doesn't call the ErrorHandler callback, because
// llvm_unreachable is intended to be used to indicate "impossible"
@@ -71,4 +71,3 @@
abort();
}
}
-
Modified: llvm/trunk/lib/Support/raw_ostream.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/raw_ostream.cpp?rev=99414&r1=99413&r2=99414&view=diff
==============================================================================
--- llvm/trunk/lib/Support/raw_ostream.cpp (original)
+++ llvm/trunk/lib/Support/raw_ostream.cpp Wed Mar 24 14:38:02 2010
@@ -81,9 +81,9 @@
SetUnbuffered();
}
-void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
+void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
BufferKind Mode) {
- assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) ||
+ assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) ||
(Mode != Unbuffered && BufferStart && Size)) &&
"stream must be unbuffered or have at least one byte");
// Make sure the current buffer is free of content (we can't flush here; the
@@ -104,11 +104,11 @@
// Zero is a special case.
if (N == 0)
return *this << '0';
-
+
char NumberBuffer[20];
char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
char *CurPtr = EndPtr;
-
+
while (N) {
*--CurPtr = '0' + char(N % 10);
N /= 10;
@@ -121,7 +121,7 @@
*this << '-';
N = -N;
}
-
+
return this->operator<<(static_cast<unsigned long>(N));
}
@@ -133,7 +133,7 @@
char NumberBuffer[20];
char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
char *CurPtr = EndPtr;
-
+
while (N) {
*--CurPtr = '0' + char(N % 10);
N /= 10;
@@ -146,7 +146,7 @@
*this << '-';
N = -N;
}
-
+
return this->operator<<(static_cast<unsigned long long>(N));
}
@@ -297,33 +297,33 @@
size_t BufferBytesLeft = OutBufEnd - OutBufCur;
if (BufferBytesLeft > 3) {
size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
-
+
// Common case is that we have plenty of space.
if (BytesUsed <= BufferBytesLeft) {
OutBufCur += BytesUsed;
return *this;
}
-
+
// Otherwise, we overflowed and the return value tells us the size to try
// again with.
NextBufferSize = BytesUsed;
}
-
+
// If we got here, we didn't have enough space in the output buffer for the
// string. Try printing into a SmallVector that is resized to have enough
// space. Iterate until we win.
SmallVector<char, 128> V;
-
+
while (1) {
V.resize(NextBufferSize);
-
+
// Try formatting into the SmallVector.
size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
-
+
// If BytesUsed fit into the vector, we win.
if (BytesUsed <= NextBufferSize)
return write(V.data(), BytesUsed);
-
+
// Otherwise, try again with a new size.
assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
NextBufferSize = BytesUsed;
@@ -339,7 +339,7 @@
// Usually the indentation is small, handle it with a fastpath.
if (NumSpaces < array_lengthof(Spaces))
return write(Spaces, NumSpaces);
-
+
while (NumSpaces) {
unsigned NumToWrite = std::min(NumSpaces,
(unsigned)array_lengthof(Spaces)-1);
@@ -372,7 +372,7 @@
// Verify that we don't have both "append" and "excl".
assert((!(Flags & F_Excl) || !(Flags & F_Append)) &&
"Cannot specify both 'excl' and 'append' file creation flags!");
-
+
ErrorInfo.clear();
// Handle "-" as stdout.
@@ -385,20 +385,20 @@
ShouldClose = false;
return;
}
-
+
int OpenFlags = O_WRONLY|O_CREAT;
#ifdef O_BINARY
if (Flags & F_Binary)
OpenFlags |= O_BINARY;
#endif
-
+
if (Flags & F_Append)
OpenFlags |= O_APPEND;
else
OpenFlags |= O_TRUNC;
if (Flags & F_Excl)
OpenFlags |= O_EXCL;
-
+
FD = open(Filename, OpenFlags, 0664);
if (FD < 0) {
ErrorInfo = "Error opening output file '" + std::string(Filename) + "'";
@@ -418,14 +418,14 @@
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)
@@ -438,7 +438,7 @@
pos = ::lseek(FD, off, SEEK_SET);
if (pos != off)
error_detected();
- return pos;
+ return pos;
}
size_t raw_fd_ostream::preferred_buffer_size() const {
@@ -447,7 +447,7 @@
struct stat statbuf;
if (fstat(FD, &statbuf) != 0)
return 0;
-
+
// If this is a terminal, don't use buffering. Line buffering
// would be a more traditional thing to do, but it's not worth
// the complexity.
More information about the llvm-commits
mailing list