From 23ab6ffa1086a2105123fa30819be16f294f631f Mon Sep 17 00:00:00 2001 From: peter klausler Date: Wed, 30 May 2018 16:09:52 -0700 Subject: [PATCH] [flang] Reformat Original-commit: flang-compiler/f18@104ca5f4c6c462ba74b500a00badc916605e4f66 Reviewed-on: https://github.com/flang-compiler/f18/pull/101 Tree-same-pre-rewrite: false --- flang/lib/evaluate/constant.cc | 30 ++++--- flang/lib/evaluate/constant.h | 34 ++++---- flang/lib/evaluate/fixed-point.h | 53 ++++++------ flang/lib/evaluate/leading-zero-bit-count.h | 38 ++++----- flang/lib/evaluate/type.h | 4 +- flang/test/evaluate/fixed-point-test.cc | 95 ++++++++++++++-------- flang/test/evaluate/leading-zero-bit-count-test.cc | 2 +- flang/test/evaluate/testing.cc | 14 ++-- flang/test/evaluate/testing.h | 13 ++- 9 files changed, 160 insertions(+), 123 deletions(-) diff --git a/flang/lib/evaluate/constant.cc b/flang/lib/evaluate/constant.cc index bd195c2..4cecc86 100644 --- a/flang/lib/evaluate/constant.cc +++ b/flang/lib/evaluate/constant.cc @@ -25,39 +25,43 @@ ScalarIntegerConstant ScalarIntegerConstant::Negate() const { } template -ScalarIntegerConstant ScalarIntegerConstant::Add(const ScalarIntegerConstant &that) const { +ScalarIntegerConstant ScalarIntegerConstant::Add( + const ScalarIntegerConstant &that) const { ScalarIntegerConstant result{*this}; - return result.Assign(static_cast(value_) + - static_cast(that.value_)); + return result.Assign( + static_cast(value_) + static_cast(that.value_)); } template -ScalarIntegerConstant ScalarIntegerConstant::Subtract(const ScalarIntegerConstant &that) const { +ScalarIntegerConstant ScalarIntegerConstant::Subtract( + const ScalarIntegerConstant &that) const { ScalarIntegerConstant result{*this}; - return result.Assign(static_cast(value_) - - static_cast(that.value_)); + return result.Assign( + static_cast(value_) - static_cast(that.value_)); } template -ScalarIntegerConstant ScalarIntegerConstant::Multiply(const ScalarIntegerConstant &that) const { +ScalarIntegerConstant ScalarIntegerConstant::Multiply( + const ScalarIntegerConstant &that) const { ScalarIntegerConstant result{*this}; - return result.Assign(static_cast(value_) - - static_cast(that.value_)); + return result.Assign( + static_cast(value_) - static_cast(that.value_)); } template -ScalarIntegerConstant ScalarIntegerConstant::Divide(const ScalarIntegerConstant &that) const { +ScalarIntegerConstant ScalarIntegerConstant::Divide( + const ScalarIntegerConstant &that) const { ScalarIntegerConstant result{*this}; if (that.value_ == 0) { result.SetError(Error::DivisionByZero); return result; } else { - return result.Assign(static_cast(value_) / - static_cast(that.value_)); + return result.Assign( + static_cast(value_) / static_cast(that.value_)); } } template class ScalarConstant; + IntrinsicType::Classification::Integer, 1>; } // namespace Fortran::evaluate diff --git a/flang/lib/evaluate/constant.h b/flang/lib/evaluate/constant.h index 529ff58..7902ee3 100644 --- a/flang/lib/evaluate/constant.h +++ b/flang/lib/evaluate/constant.h @@ -15,8 +15,8 @@ #ifndef FORTRAN_EVALUATE_CONSTANT_H_ #define FORTRAN_EVALUATE_CONSTANT_H_ -#include "../parser/idioms.h" #include "type.h" +#include "../parser/idioms.h" #include #include #include @@ -29,25 +29,27 @@ enum class Error { None, Overflow, DivisionByZero, InvalidOperation }; enum class Relation { LessThan, Equal, GreaterThan, Unordered }; template + IntrinsicTypeClassification CLASSIFICATION, + IntrinsicType::KindLenCType KIND> class ScalarConstant; template + IntrinsicTypeClassification CLASSIFICATION, + IntrinsicType::KindLenCType KIND> class ScalarConstantBase { public: constexpr ScalarConstantBase() {} - constexpr IntrinsicType Type() const {return {CLASSIFICATION, KIND}; } + constexpr IntrinsicType Type() const { return {CLASSIFICATION, KIND}; } constexpr Error error() const { return error_; } constexpr bool AnyError() const { return error_ != Error::None; } + protected: constexpr void SetError(Error error) { if (error_ == Error::None) { error_ = error; } } + private: Error error_{Error::None}; }; @@ -55,13 +57,14 @@ private: // Integer scalar constants template class ScalarConstant + IntrinsicType::Classification::Integer, KIND> : public ScalarConstantBase { + IntrinsicType::Classification::Integer, KIND> { private: static_assert(KIND == 1 || KIND == 2 || KIND == 4 || KIND == 8); using BaseType = ScalarConstantBase; + IntrinsicType::Classification::Integer, KIND>; + public: using ValueCType = std::int64_t; @@ -122,18 +125,17 @@ private: }; template -using ScalarIntegerConstant = - ScalarConstant; +using ScalarIntegerConstant = ScalarConstant; extern template class ScalarConstant; + IntrinsicType::Classification::Integer, 1>; extern template class ScalarConstant; + IntrinsicType::Classification::Integer, 2>; extern template class ScalarConstant; + IntrinsicType::Classification::Integer, 4>; extern template class ScalarConstant; + IntrinsicType::Classification::Integer, 8>; } // namespace Fortran::evaluate #endif // FORTRAN_EVALUATE_CONSTANT_H_ diff --git a/flang/lib/evaluate/fixed-point.h b/flang/lib/evaluate/fixed-point.h index 8d2af32..c3e0f2e 100644 --- a/flang/lib/evaluate/fixed-point.h +++ b/flang/lib/evaluate/fixed-point.h @@ -42,8 +42,8 @@ static constexpr Ordering Reverse(Ordering ordering) { // testing of what would otherwise be more rare edge cases, this template class // may be configured to use other part types &/or partial fields in the // parts. -template +template class FixedPoint { public: static constexpr int bits{BITS}; @@ -58,7 +58,8 @@ private: static constexpr int extraPartBits{maxPartBits - partBits}; static constexpr int parts{(bits + partBits - 1) / partBits}; static_assert(parts >= 1); - static constexpr int extraTopPartBits{extraPartBits + (parts * partBits) - bits}; + static constexpr int extraTopPartBits{ + extraPartBits + (parts * partBits) - bits}; static constexpr int topPartBits{maxPartBits - extraTopPartBits}; static_assert(topPartBits > 0 && topPartBits <= partBits); static_assert((parts - 1) * partBits + topPartBits == bits); @@ -105,7 +106,7 @@ public: } constexpr bool IsNegative() const { - return (part_[parts-1] >> (topPartBits - 1)) & 1; + return (part_[parts - 1] >> (topPartBits - 1)) & 1; } constexpr Ordering CompareToZeroSigned() const { @@ -116,7 +117,7 @@ public: } constexpr Ordering CompareUnsigned(const FixedPoint &y) const { - for (int j{parts}; j-- > 0; ) { + for (int j{parts}; j-- > 0;) { if (part_[j] > y.part_[j]) { return Ordering::Greater; } @@ -136,8 +137,8 @@ public: } constexpr int LeadingZeroBitCount() const { - if (part_[parts-1] != 0) { - int lzbc{evaluate::LeadingZeroBitCount(part_[parts-1])}; + if (part_[parts - 1] != 0) { + int lzbc{evaluate::LeadingZeroBitCount(part_[parts - 1])}; return lzbc - extraTopPartBits; } int upperZeroes{topPartBits}; @@ -172,7 +173,7 @@ public: for (int j{0}; j + 1 < parts; ++j) { part_[j] = ~part_[j] & partMask; } - part_[parts-1] = ~part_[parts-1] & topPartMask; + part_[parts - 1] = ~part_[parts - 1] & topPartMask; } // Returns true on overflow (i.e., negating the most negative signed number) @@ -183,9 +184,9 @@ public: part_[j] = (~part_[j] + carry) & partMask; carry = newCarry; } - Part before{part_[parts-1]}; - part_[parts-1] = (~before + carry) & topPartMask; - return before != 0 && part_[parts-1] == before; + Part before{part_[parts - 1]}; + part_[parts - 1] = (~before + carry) & topPartMask; + return before != 0 && part_[parts - 1] == before; } constexpr void And(const FixedPoint &y) { @@ -212,7 +213,7 @@ public: } else if (count > 0) { int shiftParts{count / partBits}; int bitShift{count - partBits * shiftParts}; - int j{parts-1}; + int j{parts - 1}; if (bitShift == 0) { for (; j >= shiftParts; --j) { part_[j] = part_[j - shiftParts] & PartMask(j); @@ -223,8 +224,8 @@ public: } else { for (; j > shiftParts; --j) { part_[j] = ((part_[j - shiftParts] << bitShift) | - (part_[j - shiftParts - 1] >> (partBits - bitShift))) & - PartMask(j); + (part_[j - shiftParts - 1] >> (partBits - bitShift))) & + PartMask(j); } if (j == shiftParts) { part_[j] = (part_[0] << bitShift) & PartMask(j); @@ -254,8 +255,8 @@ public: } else { for (; j + shiftParts + 1 < parts; ++j) { part_[j] = ((part_[j + shiftParts] >> bitShift) | - (part_[j + shiftParts + 1] << (partBits - bitShift))) & - partMask; + (part_[j + shiftParts + 1] << (partBits - bitShift))) & + partMask; } if (j + shiftParts + 1 == parts) { part_[j++] = part_[parts - 1] >> bitShift; @@ -276,9 +277,9 @@ public: part_[j] = carry & partMask; carry >>= partBits; } - carry += part_[parts-1]; - carry += y.part_[parts-1]; - part_[parts-1] = carry & topPartMask; + carry += part_[parts - 1]; + carry += y.part_[parts - 1]; + part_[parts - 1] = carry & topPartMask; return carry > topPartMask; } @@ -309,7 +310,7 @@ public: if (y.part_[k] != 0) { BigPart xy{part_[j]}; xy *= y.part_[k]; - for (int to{j+k}; xy != 0; ++to) { + for (int to{j + k}; xy != 0; ++to) { xy += product[to]; product[to] = xy & partMask; xy >>= partBits; @@ -324,8 +325,8 @@ public: } if (topPartBits < partBits) { upper.ShiftLeft(partBits - topPartBits); - upper.part_[0] |= part_[parts-1] >> topPartBits; - part_[parts-1] &= topPartMask; + upper.part_[0] |= part_[parts - 1] >> topPartBits; + part_[parts - 1] &= topPartMask; } } @@ -352,7 +353,8 @@ public: } // Overwrites *this with quotient. Returns true on division by zero. - constexpr bool DivideUnsigned(const FixedPoint &divisor, FixedPoint &remainder) { + constexpr bool DivideUnsigned( + const FixedPoint &divisor, FixedPoint &remainder) { remainder.Clear(); if (divisor.IsZero()) { RightMask(bits); @@ -410,7 +412,8 @@ public: // Dividend was (and remains) the most negative number. // See whether the original divisor was -1 (if so, it's 1 now). if (divisorOrdering == Ordering::Less && - divisor.CompareUnsigned(FixedPoint{std::uint64_t{1}}) == Ordering::Equal) { + divisor.CompareUnsigned(FixedPoint{std::uint64_t{1}}) == + Ordering::Equal) { // most negative number / -1 is the sole overflow case remainder.Clear(); return true; @@ -465,7 +468,7 @@ public: private: static constexpr Part PartMask(int part) { - return part == parts-1 ? topPartMask : partMask; + return part == parts - 1 ? topPartMask : partMask; } constexpr void Clear() { diff --git a/flang/lib/evaluate/leading-zero-bit-count.h b/flang/lib/evaluate/leading-zero-bit-count.h index 076a03e..058550f 100644 --- a/flang/lib/evaluate/leading-zero-bit-count.h +++ b/flang/lib/evaluate/leading-zero-bit-count.h @@ -41,11 +41,10 @@ namespace { // 0 7 e d d 5 e 5 9 a 4 e 2 8 c 2 // 0000011111101101110101011110010110011010010011100010100011000010 static constexpr std::uint64_t deBruijn{0x07edd5e59a4e28c2}; -static constexpr std::uint8_t mapping[64]{ - 63, 0, 58, 1, 59, 47, 53, 2, 60, 39, 48, 27, 54, 33, 42, 3, - 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4, - 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21, - 56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5 }; +static constexpr std::uint8_t mapping[64]{63, 0, 58, 1, 59, 47, 53, 2, 60, 39, + 48, 27, 54, 33, 42, 3, 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, + 14, 22, 4, 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21, + 56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5}; } // namespace inline constexpr int LeadingZeroBitCount(std::uint64_t x) { @@ -78,24 +77,17 @@ inline constexpr int LeadingZeroBitCount(std::uint16_t x) { } namespace { -static constexpr std::uint8_t eightBitLeadingZeroBitCount[256]{ - 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; +static constexpr std::uint8_t eightBitLeadingZeroBitCount[256]{8, 7, 6, 6, 5, 5, + 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; } // namespace inline constexpr int LeadingZeroBitCount(std::uint8_t x) { diff --git a/flang/lib/evaluate/type.h b/flang/lib/evaluate/type.h index 5520462..7cc7fd1 100644 --- a/flang/lib/evaluate/type.h +++ b/flang/lib/evaluate/type.h @@ -40,8 +40,8 @@ public: } IntrinsicType() = delete; - constexpr IntrinsicType(Classification c, KindLenCType kind, - KindLenCType len = 1) + constexpr IntrinsicType( + Classification c, KindLenCType kind, KindLenCType len = 1) : classification_{c}, kind_{kind}, len_{len} {} // Defaulted kinds. diff --git a/flang/test/evaluate/fixed-point-test.cc b/flang/test/evaluate/fixed-point-test.cc index 9e39ece..8baa20d 100644 --- a/flang/test/evaluate/fixed-point-test.cc +++ b/flang/test/evaluate/fixed-point-test.cc @@ -12,21 +12,21 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "../../lib/evaluate/fixed-point.h" #include "testing.h" +#include "../../lib/evaluate/fixed-point.h" #include -using Fortran::evaluate::Ordering; using Fortran::evaluate::FixedPoint; +using Fortran::evaluate::Ordering; -template> -void exhaustiveTesting() { +template> void exhaustiveTesting() { COMPARE(BITS, ==, FP::bits); std::uint64_t maxUnsignedValue{(std::uint64_t{1} << BITS) - 1}; std::int64_t maxPositiveSignedValue{(std::int64_t{1} << (BITS - 1)) - 1}; - std::int64_t mostNegativeSignedValue{-(std::int64_t{1} << (BITS-1))}; + std::int64_t mostNegativeSignedValue{-(std::int64_t{1} << (BITS - 1))}; char desc[64]; - std::snprintf(desc, sizeof desc, "BITS=%d, PARTBITS=%d, sizeof(Part)=%d", BITS, FP::partBits, static_cast(sizeof(typename FP::Part))); + std::snprintf(desc, sizeof desc, "BITS=%d, PARTBITS=%d, sizeof(Part)=%d", + BITS, FP::partBits, static_cast(sizeof(typename FP::Part))); FP zero; TEST(zero.IsZero())(desc); for (std::uint64_t x{0}; x <= maxUnsignedValue; ++x) { @@ -36,17 +36,19 @@ void exhaustiveTesting() { COMPARE(x, ==, copy.ToUInt64())(desc); copy = a; COMPARE(x, ==, copy.ToUInt64())(desc); - COMPARE(x==0, ==, a.IsZero())("%s, x=0x%llx", desc, x); + COMPARE(x == 0, ==, a.IsZero())("%s, x=0x%llx", desc, x); copy.OnesComplement(); COMPARE(x ^ maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx", desc, x); copy = a; bool over{copy.TwosComplement()}; - COMPARE(over, ==, x == std::uint64_t{1} << (BITS-1))("%s, x=0x%llx", desc, x); - COMPARE(-x & maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx", desc, x); + COMPARE(over, ==, x == std::uint64_t{1} << (BITS - 1)) + ("%s, x=0x%llx", desc, x); + COMPARE(-x & maxUnsignedValue, ==, copy.ToUInt64()) + ("%s, x=0x%llx", desc, x); int lzbc{a.LeadingZeroBitCount()}; COMPARE(lzbc, >=, 0)("%s, x=0x%llx", desc, x); COMPARE(lzbc, <=, BITS)("%s, x=0x%llx", desc, x); - COMPARE(x==0, ==, lzbc == BITS)("%s, x=0x%llx, lzbc=%d", desc, x, lzbc); + COMPARE(x == 0, ==, lzbc == BITS)("%s, x=0x%llx, lzbc=%d", desc, x, lzbc); std::uint64_t lzcheck{std::uint64_t{1} << (BITS - lzbc)}; COMPARE(x, <, lzcheck)("%s, x=0x%llx, lzbc=%d", desc, x, lzbc); COMPARE(x + x + !x, >=, lzcheck)("%s, x=0x%llx, lzbc=%d", desc, x, lzbc); @@ -71,16 +73,20 @@ void exhaustiveTesting() { for (int count{0}; count <= BITS + 1; ++count) { copy = a; copy.ShiftLeft(count); - COMPARE((x << count) & maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx, count=%d", desc, x, count); + COMPARE((x << count) & maxUnsignedValue, ==, copy.ToUInt64()) + ("%s, x=0x%llx, count=%d", desc, x, count); copy = a; copy.ShiftRightLogical(count); - COMPARE(x >> count, ==, copy.ToUInt64())("%s, x=0x%llx, count=%d", desc, x, count); + COMPARE(x >> count, ==, copy.ToUInt64()) + ("%s, x=0x%llx, count=%d", desc, x, count); copy = a; copy.ShiftLeft(-count); - COMPARE(x >> count, ==, copy.ToUInt64())("%s, x=0x%llx, count=%d", desc, x, count); + COMPARE(x >> count, ==, copy.ToUInt64()) + ("%s, x=0x%llx, count=%d", desc, x, count); copy = a; copy.ShiftRightLogical(-count); - COMPARE((x << count) & maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx, count=%d", desc, x, count); + COMPARE((x << count) & maxUnsignedValue, ==, copy.ToUInt64()) + ("%s, x=0x%llx, count=%d", desc, x, count); } for (std::uint64_t y{0}; y <= maxUnsignedValue; ++y) { std::int64_t sy = y; @@ -103,7 +109,9 @@ void exhaustiveTesting() { } else { ord = Ordering::Equal; } - TEST(a.CompareSigned(b) == ord)("%s, x=0x%llx %lld %d, y=0x%llx %lld %d", desc, x, sx, a.IsNegative(), y, sy, b.IsNegative()); + TEST(a.CompareSigned(b) == ord) + ("%s, x=0x%llx %lld %d, y=0x%llx %lld %d", desc, x, sx, a.IsNegative(), y, + sy, b.IsNegative()); copy = a; copy.And(b); COMPARE(x & y, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); @@ -115,50 +123,71 @@ void exhaustiveTesting() { COMPARE(x ^ y, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); copy = a; bool carry{copy.AddUnsigned(b)}; - COMPARE(x + y, ==, copy.ToUInt64() + (std::uint64_t{carry} << BITS))("%s, x=0x%llx, y=0x%llx, carry=%d", desc, x, y, carry); + COMPARE(x + y, ==, copy.ToUInt64() + (std::uint64_t{carry} << BITS)) + ("%s, x=0x%llx, y=0x%llx, carry=%d", desc, x, y, carry); copy = a; over = copy.AddSigned(b); - COMPARE((sx + sy) & maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); - COMPARE(over, ==, sx+sy < mostNegativeSignedValue || sx+sy > maxPositiveSignedValue)("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE((sx + sy) & maxUnsignedValue, ==, copy.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(over, ==, + sx + sy < mostNegativeSignedValue || sx + sy > maxPositiveSignedValue) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); copy = a; over = copy.SubtractSigned(b); - COMPARE((sx - sy) & maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); - COMPARE(over, ==, sx-sy < mostNegativeSignedValue || sx-sy > maxPositiveSignedValue)("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE((sx - sy) & maxUnsignedValue, ==, copy.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(over, ==, + sx - sy < mostNegativeSignedValue || sx - sy > maxPositiveSignedValue) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); copy = a; FP upper; copy.MultiplyUnsigned(b, upper); - COMPARE(x * y, ==, (upper.ToUInt64() << BITS) ^ copy.ToUInt64())("%s, x=0x%llx, y=0x%llx, lower=0x%llx, upper=0x%llx", desc, x, y, copy.ToUInt64(), upper.ToUInt64()); + COMPARE(x * y, ==, (upper.ToUInt64() << BITS) ^ copy.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx, lower=0x%llx, upper=0x%llx", desc, x, y, + copy.ToUInt64(), upper.ToUInt64()); copy = a; copy.MultiplySigned(b, upper); - COMPARE((sx * sy) & maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); - COMPARE(((sx * sy) >> BITS) & maxUnsignedValue, ==, upper.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE((sx * sy) & maxUnsignedValue, ==, copy.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(((sx * sy) >> BITS) & maxUnsignedValue, ==, upper.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); copy = a; FP rem; - COMPARE(y == 0, ==, copy.DivideUnsigned(b, rem))("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(y == 0, ==, copy.DivideUnsigned(b, rem)) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); if (y == 0) { - COMPARE(maxUnsignedValue, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(maxUnsignedValue, ==, copy.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); COMPARE(0, ==, rem.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); } else { - COMPARE(x / y, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); - COMPARE(x % y, ==, rem.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(x / y, ==, copy.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(x % y, ==, rem.ToUInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); } copy = a; bool badCase{sx == mostNegativeSignedValue && - ((sy == -1 && sx != sy) || (BITS==1 && sx==sy))}; - COMPARE(y == 0 || badCase, ==, copy.DivideSigned(b, rem))("%s, x=0x%llx, y=0x%llx", desc, x, y); + ((sy == -1 && sx != sy) || (BITS == 1 && sx == sy))}; + COMPARE(y == 0 || badCase, ==, copy.DivideSigned(b, rem)) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); if (y == 0) { if (sx >= 0) { - COMPARE(maxPositiveSignedValue, ==, copy.ToInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(maxPositiveSignedValue, ==, copy.ToInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); } else { - COMPARE(mostNegativeSignedValue, ==, copy.ToInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(mostNegativeSignedValue, ==, copy.ToInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); } COMPARE(0, ==, rem.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); } else if (badCase) { COMPARE(x, ==, copy.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); COMPARE(0, ==, rem.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); } else { - COMPARE(sx/sy, ==, copy.ToInt64())("%s, x=0x%llx %lld, y=0x%llx %lld; unsigned 0x%llx", desc, x, sx, y, sy, copy.ToUInt64()); - COMPARE(sx-sy*(sx/sy), ==, rem.ToInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y); + COMPARE(sx / sy, ==, copy.ToInt64()) + ("%s, x=0x%llx %lld, y=0x%llx %lld; unsigned 0x%llx", desc, x, sx, y, + sy, copy.ToUInt64()); + COMPARE(sx - sy * (sx / sy), ==, rem.ToInt64()) + ("%s, x=0x%llx, y=0x%llx", desc, x, y); } } } diff --git a/flang/test/evaluate/leading-zero-bit-count-test.cc b/flang/test/evaluate/leading-zero-bit-count-test.cc index 7923c78..45123da 100644 --- a/flang/test/evaluate/leading-zero-bit-count-test.cc +++ b/flang/test/evaluate/leading-zero-bit-count-test.cc @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "../../lib/evaluate/leading-zero-bit-count.h" #include "testing.h" +#include "../../lib/evaluate/leading-zero-bit-count.h" using Fortran::evaluate::LeadingZeroBitCount; diff --git a/flang/test/evaluate/testing.cc b/flang/test/evaluate/testing.cc index 8bd3338..7d9af8a 100644 --- a/flang/test/evaluate/testing.cc +++ b/flang/test/evaluate/testing.cc @@ -23,7 +23,7 @@ namespace testing { namespace { int passes{0}; int failures{0}; -} +} // namespace static void BitBucket(const char *, ...) {} @@ -36,8 +36,8 @@ static void PrintFailureDetails(const char *format, ...) { fputc('\n', stderr); } -FailureDetailPrinter Test(const char *file, int line, const char *predicate, - bool pass) { +FailureDetailPrinter Test( + const char *file, int line, const char *predicate, bool pass) { if (pass) { ++passes; return BitBucket; @@ -48,7 +48,9 @@ FailureDetailPrinter Test(const char *file, int line, const char *predicate, } } -FailureDetailPrinter Compare(const char *file, int line, const char *xs, const char *rel, const char *ys, unsigned long long x, unsigned long long y) { +FailureDetailPrinter Compare(const char *file, int line, const char *xs, + const char *rel, const char *ys, unsigned long long x, + unsigned long long y) { while (*rel == ' ') { ++rel; } @@ -75,8 +77,8 @@ FailureDetailPrinter Compare(const char *file, int line, const char *xs, const c return BitBucket; } else { ++failures; - fprintf(stderr, "%s:%d: FAIL %s[0x%llx] %s %s[0x%llx]:\n", file, line, - xs, x, rel, ys, y); + fprintf(stderr, "%s:%d: FAIL %s[0x%llx] %s %s[0x%llx]:\n", file, line, xs, + x, rel, ys, y); return PrintFailureDetails; } } diff --git a/flang/test/evaluate/testing.h b/flang/test/evaluate/testing.h index e6aaa08..87ef9d3 100644 --- a/flang/test/evaluate/testing.h +++ b/flang/test/evaluate/testing.h @@ -25,12 +25,17 @@ int Complete(); // function that can be optionally called to print more detail, e.g. // COMPARE(x, ==, y)("z is 0x%llx", z); // will also print z after the usual failure message if x != y. -#define TEST(predicate) testing::Test(__FILE__, __LINE__, #predicate, (predicate)) -#define COMPARE(x, rel, y) testing::Compare(__FILE__, __LINE__, #x, #rel, #y, (x), (y)) +#define TEST(predicate) \ + testing::Test(__FILE__, __LINE__, #predicate, (predicate)) +#define COMPARE(x, rel, y) \ + testing::Compare(__FILE__, __LINE__, #x, #rel, #y, (x), (y)) // Functions called by thesemacros; do not call directly. using FailureDetailPrinter = void (*)(const char *, ...); -FailureDetailPrinter Test(const char *file, int line, const char *predicate, bool pass); -FailureDetailPrinter Compare(const char *file, int line, const char *xs, const char *rel, const char *ys, unsigned long long x, unsigned long long y); +FailureDetailPrinter Test( + const char *file, int line, const char *predicate, bool pass); +FailureDetailPrinter Compare(const char *file, int line, const char *xs, + const char *rel, const char *ys, unsigned long long x, + unsigned long long y); } // namespace testing #endif // FORTRAN_EVALUATE_TESTING_H_ -- 2.7.4