[llvm] r298900 - [APInt] Reformat tc functions to put opening curly braces on the end of the previous line. NFC
Craig Topper via llvm-commits
llvm-commits at lists.llvm.org
Mon Mar 27 22:32:55 PDT 2017
Author: ctopper
Date: Tue Mar 28 00:32:55 2017
New Revision: 298900
URL: http://llvm.org/viewvc/llvm-project?rev=298900&view=rev
Log:
[APInt] Reformat tc functions to put opening curly braces on the end of the previous line. NFC
Modified:
llvm/trunk/lib/Support/APInt.cpp
Modified: llvm/trunk/lib/Support/APInt.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/APInt.cpp?rev=298900&r1=298899&r2=298900&view=diff
==============================================================================
--- llvm/trunk/lib/Support/APInt.cpp (original)
+++ llvm/trunk/lib/Support/APInt.cpp Tue Mar 28 00:32:55 2017
@@ -2362,49 +2362,37 @@ static_assert(integerPartWidth % 2 == 0,
/* Returns the integer part with the least significant BITS set.
BITS cannot be zero. */
-static inline integerPart
-lowBitMask(unsigned bits)
-{
+static inline integerPart lowBitMask(unsigned bits) {
assert(bits != 0 && bits <= integerPartWidth);
return ~(integerPart) 0 >> (integerPartWidth - bits);
}
/* Returns the value of the lower half of PART. */
-static inline integerPart
-lowHalf(integerPart part)
-{
+static inline integerPart lowHalf(integerPart part) {
return part & lowBitMask(integerPartWidth / 2);
}
/* Returns the value of the upper half of PART. */
-static inline integerPart
-highHalf(integerPart part)
-{
+static inline integerPart highHalf(integerPart part) {
return part >> (integerPartWidth / 2);
}
/* Returns the bit number of the most significant set bit of a part.
If the input number has no bits set -1U is returned. */
-static unsigned
-partMSB(integerPart value)
-{
+static unsigned partMSB(integerPart value) {
return findLastSet(value, ZB_Max);
}
/* Returns the bit number of the least significant set bit of a
part. If the input number has no bits set -1U is returned. */
-static unsigned
-partLSB(integerPart value)
-{
+static unsigned partLSB(integerPart value) {
return findFirstSet(value, ZB_Max);
}
/* Sets the least significant part of a bignum to the input value, and
zeroes out higher parts. */
-void
-APInt::tcSet(integerPart *dst, integerPart part, unsigned parts)
-{
+void APInt::tcSet(integerPart *dst, integerPart part, unsigned parts) {
assert(parts > 0);
dst[0] = part;
@@ -2413,17 +2401,13 @@ APInt::tcSet(integerPart *dst, integerPa
}
/* Assign one bignum to another. */
-void
-APInt::tcAssign(integerPart *dst, const integerPart *src, unsigned parts)
-{
+void APInt::tcAssign(integerPart *dst, const integerPart *src, unsigned parts) {
for (unsigned i = 0; i < parts; i++)
dst[i] = src[i];
}
/* Returns true if a bignum is zero, false otherwise. */
-bool
-APInt::tcIsZero(const integerPart *src, unsigned parts)
-{
+bool APInt::tcIsZero(const integerPart *src, unsigned parts) {
for (unsigned i = 0; i < parts; i++)
if (src[i])
return false;
@@ -2432,33 +2416,25 @@ APInt::tcIsZero(const integerPart *src,
}
/* Extract the given bit of a bignum; returns 0 or 1. */
-int
-APInt::tcExtractBit(const integerPart *parts, unsigned bit)
-{
+int APInt::tcExtractBit(const integerPart *parts, unsigned bit) {
return (parts[bit / integerPartWidth] &
((integerPart) 1 << bit % integerPartWidth)) != 0;
}
/* Set the given bit of a bignum. */
-void
-APInt::tcSetBit(integerPart *parts, unsigned bit)
-{
+void APInt::tcSetBit(integerPart *parts, unsigned bit) {
parts[bit / integerPartWidth] |= (integerPart) 1 << (bit % integerPartWidth);
}
/* Clears the given bit of a bignum. */
-void
-APInt::tcClearBit(integerPart *parts, unsigned bit)
-{
+void APInt::tcClearBit(integerPart *parts, unsigned bit) {
parts[bit / integerPartWidth] &=
~((integerPart) 1 << (bit % integerPartWidth));
}
/* Returns the bit number of the least significant set bit of a
number. If the input number has no bits set -1U is returned. */
-unsigned
-APInt::tcLSB(const integerPart *parts, unsigned n)
-{
+unsigned APInt::tcLSB(const integerPart *parts, unsigned n) {
for (unsigned i = 0; i < n; i++) {
if (parts[i] != 0) {
unsigned lsb = partLSB(parts[i]);
@@ -2472,9 +2448,7 @@ APInt::tcLSB(const integerPart *parts, u
/* Returns the bit number of the most significant set bit of a number.
If the input number has no bits set -1U is returned. */
-unsigned
-APInt::tcMSB(const integerPart *parts, unsigned n)
-{
+unsigned APInt::tcMSB(const integerPart *parts, unsigned n) {
do {
--n;
@@ -2493,9 +2467,8 @@ APInt::tcMSB(const integerPart *parts, u
the least significant bit of DST. All high bits above srcBITS in
DST are zero-filled. */
void
-APInt::tcExtract(integerPart *dst, unsigned dstCount,const integerPart *src,
- unsigned srcBits, unsigned srcLSB)
-{
+APInt::tcExtract(integerPart *dst, unsigned dstCount, const integerPart *src,
+ unsigned srcBits, unsigned srcLSB) {
unsigned dstParts = (srcBits + integerPartWidth - 1) / integerPartWidth;
assert(dstParts <= dstCount);
@@ -2524,10 +2497,8 @@ APInt::tcExtract(integerPart *dst, unsig
}
/* DST += RHS + C where C is zero or one. Returns the carry flag. */
-integerPart
-APInt::tcAdd(integerPart *dst, const integerPart *rhs,
- integerPart c, unsigned parts)
-{
+integerPart APInt::tcAdd(integerPart *dst, const integerPart *rhs,
+ integerPart c, unsigned parts) {
assert(c <= 1);
for (unsigned i = 0; i < parts; i++) {
@@ -2547,9 +2518,8 @@ APInt::tcAdd(integerPart *dst, const int
}
/* DST -= RHS + C where C is zero or one. Returns the carry flag. */
-integerPart
-APInt::tcSubtract(integerPart *dst, const integerPart *rhs,
- integerPart c, unsigned parts)
+integerPart APInt::tcSubtract(integerPart *dst, const integerPart *rhs,
+ integerPart c, unsigned parts)
{
assert(c <= 1);
@@ -2570,9 +2540,7 @@ APInt::tcSubtract(integerPart *dst, cons
}
/* Negate a bignum in-place. */
-void
-APInt::tcNegate(integerPart *dst, unsigned parts)
-{
+void APInt::tcNegate(integerPart *dst, unsigned parts) {
tcComplement(dst, parts);
tcIncrement(dst, parts);
}
@@ -2588,12 +2556,10 @@ APInt::tcNegate(integerPart *dst, unsign
DSTPARTS parts of the result, and if all of the omitted higher
parts were zero return zero, otherwise overflow occurred and
return one. */
-int
-APInt::tcMultiplyPart(integerPart *dst, const integerPart *src,
- integerPart multiplier, integerPart carry,
- unsigned srcParts, unsigned dstParts,
- bool add)
-{
+int APInt::tcMultiplyPart(integerPart *dst, const integerPart *src,
+ integerPart multiplier, integerPart carry,
+ unsigned srcParts, unsigned dstParts,
+ bool add) {
/* Otherwise our writes of DST kill our later reads of SRC. */
assert(dst <= src || dst >= src + srcParts);
assert(dstParts <= srcParts + 1);
@@ -2615,7 +2581,7 @@ APInt::tcMultiplyPart(integerPart *dst,
srcPart = src[i];
- if (multiplier == 0 || srcPart == 0) {
+ if (multiplier == 0 || srcPart == 0) {
low = carry;
high = 0;
} else {
@@ -2680,10 +2646,8 @@ APInt::tcMultiplyPart(integerPart *dst,
is filled with the least significant parts of the result. Returns
one if overflow occurred, otherwise zero. DST must be disjoint
from both operands. */
-int
-APInt::tcMultiply(integerPart *dst, const integerPart *lhs,
- const integerPart *rhs, unsigned parts)
-{
+int APInt::tcMultiply(integerPart *dst, const integerPart *lhs,
+ const integerPart *rhs, unsigned parts) {
assert(dst != lhs && dst != rhs);
int overflow = 0;
@@ -2700,11 +2664,9 @@ APInt::tcMultiply(integerPart *dst, cons
operands. No overflow occurs. DST must be disjoint from both
operands. Returns the number of parts required to hold the
result. */
-unsigned
-APInt::tcFullMultiply(integerPart *dst, const integerPart *lhs,
- const integerPart *rhs, unsigned lhsParts,
- unsigned rhsParts)
-{
+unsigned APInt::tcFullMultiply(integerPart *dst, const integerPart *lhs,
+ const integerPart *rhs, unsigned lhsParts,
+ unsigned rhsParts) {
/* Put the narrower number on the LHS for less loops below. */
if (lhsParts > rhsParts) {
return tcFullMultiply (dst, rhs, lhs, rhsParts, lhsParts);
@@ -2732,11 +2694,9 @@ APInt::tcFullMultiply(integerPart *dst,
use by the routine; its contents need not be initialized and are
destroyed. LHS, REMAINDER and SCRATCH must be distinct.
*/
-int
-APInt::tcDivide(integerPart *lhs, const integerPart *rhs,
- integerPart *remainder, integerPart *srhs,
- unsigned parts)
-{
+int APInt::tcDivide(integerPart *lhs, const integerPart *rhs,
+ integerPart *remainder, integerPart *srhs,
+ unsigned parts) {
assert(lhs != remainder && lhs != srhs && remainder != srhs);
unsigned shiftCount = tcMSB(rhs, parts) + 1;
@@ -2778,9 +2738,7 @@ APInt::tcDivide(integerPart *lhs, const
/* Shift a bignum left COUNT bits in-place. Shifted in bits are zero.
There are no restrictions on COUNT. */
-void
-APInt::tcShiftLeft(integerPart *dst, unsigned parts, unsigned count)
-{
+void APInt::tcShiftLeft(integerPart *dst, unsigned parts, unsigned count) {
if (count) {
/* Jump is the inter-part jump; shift is is intra-part shift. */
unsigned jump = count / integerPartWidth;
@@ -2810,9 +2768,7 @@ APInt::tcShiftLeft(integerPart *dst, uns
/* Shift a bignum right COUNT bits in-place. Shifted in bits are
zero. There are no restrictions on COUNT. */
-void
-APInt::tcShiftRight(integerPart *dst, unsigned parts, unsigned count)
-{
+void APInt::tcShiftRight(integerPart *dst, unsigned parts, unsigned count) {
if (count) {
/* Jump is the inter-part jump; shift is is intra-part shift. */
unsigned jump = count / integerPartWidth;
@@ -2840,42 +2796,32 @@ APInt::tcShiftRight(integerPart *dst, un
}
/* Bitwise and of two bignums. */
-void
-APInt::tcAnd(integerPart *dst, const integerPart *rhs, unsigned parts)
-{
+void APInt::tcAnd(integerPart *dst, const integerPart *rhs, unsigned parts) {
for (unsigned i = 0; i < parts; i++)
dst[i] &= rhs[i];
}
/* Bitwise inclusive or of two bignums. */
-void
-APInt::tcOr(integerPart *dst, const integerPart *rhs, unsigned parts)
-{
+void APInt::tcOr(integerPart *dst, const integerPart *rhs, unsigned parts) {
for (unsigned i = 0; i < parts; i++)
dst[i] |= rhs[i];
}
/* Bitwise exclusive or of two bignums. */
-void
-APInt::tcXor(integerPart *dst, const integerPart *rhs, unsigned parts)
-{
+void APInt::tcXor(integerPart *dst, const integerPart *rhs, unsigned parts) {
for (unsigned i = 0; i < parts; i++)
dst[i] ^= rhs[i];
}
/* Complement a bignum in-place. */
-void
-APInt::tcComplement(integerPart *dst, unsigned parts)
-{
+void APInt::tcComplement(integerPart *dst, unsigned parts) {
for (unsigned i = 0; i < parts; i++)
dst[i] = ~dst[i];
}
/* Comparison (unsigned) of two bignums. */
-int
-APInt::tcCompare(const integerPart *lhs, const integerPart *rhs,
- unsigned parts)
-{
+int APInt::tcCompare(const integerPart *lhs, const integerPart *rhs,
+ unsigned parts) {
while (parts) {
parts--;
if (lhs[parts] == rhs[parts])
@@ -2891,9 +2837,7 @@ APInt::tcCompare(const integerPart *lhs,
}
/* Increment a bignum in-place, return the carry flag. */
-integerPart
-APInt::tcIncrement(integerPart *dst, unsigned parts)
-{
+integerPart APInt::tcIncrement(integerPart *dst, unsigned parts) {
unsigned i;
for (i = 0; i < parts; i++)
if (++dst[i] != 0)
@@ -2903,8 +2847,7 @@ APInt::tcIncrement(integerPart *dst, uns
}
/* Decrement a bignum in-place, return the borrow flag. */
-integerPart
-APInt::tcDecrement(integerPart *dst, unsigned parts) {
+integerPart APInt::tcDecrement(integerPart *dst, unsigned parts) {
for (unsigned i = 0; i < parts; i++) {
// If the current word is non-zero, then the decrement has no effect on the
// higher-order words of the integer and no borrow can occur. Exit early.
@@ -2918,10 +2861,8 @@ APInt::tcDecrement(integerPart *dst, uns
/* Set the least significant BITS bits of a bignum, clear the
rest. */
-void
-APInt::tcSetLeastSignificantBits(integerPart *dst, unsigned parts,
- unsigned bits)
-{
+void APInt::tcSetLeastSignificantBits(integerPart *dst, unsigned parts,
+ unsigned bits) {
unsigned i = 0;
while (bits > integerPartWidth) {
dst[i++] = ~(integerPart) 0;
More information about the llvm-commits
mailing list