Index: llvm/trunk/include/llvm/Support/Alignment.h =================================================================== --- llvm/trunk/include/llvm/Support/Alignment.h +++ llvm/trunk/include/llvm/Support/Alignment.h @@ -0,0 +1,345 @@ +//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains types to represent alignments. +// They are instrumented to guarantee some invariants are preserved and prevent +// invalid manipulations. +// +// - Align represents an alignment in bytes, it is always set and always a valid +// power of two, its minimum value is 1 which means no alignment requirements. +// +// - MaybeAlign is an optional type, it may be undefined or set. When it's set +// you can get the underlying Align type by using the getValue() method. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_SUPPORT_ALIGNMENT_H_ +#define LLVM_SUPPORT_ALIGNMENT_H_ + +#include "llvm/ADT/Optional.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/MathExtras.h" +#include +#include + +namespace llvm { + +#define ALIGN_CHECK_ISPOSITIVE(decl) \ + assert(decl > 0 && (#decl " should be defined")) +#define ALIGN_CHECK_ISSET(decl) \ + assert(decl.hasValue() && (#decl " should be defined")) + +// This struct is a compact representation of a valid (non-zero power of two) +// alignment. +// It is suitable for use as static global constants. +struct Align { +private: + uint8_t ShiftValue = 0; // The log2 of the required alignment. + // ShiftValue is less than 64 by construction. + + friend struct MaybeAlign; + friend unsigned Log2(Align); + friend bool operator==(Align Lhs, Align Rhs); + friend bool operator!=(Align Lhs, Align Rhs); + friend bool operator<=(Align Lhs, Align Rhs); + friend bool operator>=(Align Lhs, Align Rhs); + friend bool operator<(Align Lhs, Align Rhs); + friend bool operator>(Align Lhs, Align Rhs); + friend unsigned encode(struct MaybeAlign A); + friend struct MaybeAlign decodeMaybeAlign(unsigned Value); + +public: + // Default is byte-aligned. + Align() = default; + // Do not perform checks in case of copy/move construct/assign, because the + // checks have been performed when building `Other`. + Align(const Align &Other) = default; + Align &operator=(const Align &Other) = default; + Align(Align &&Other) = default; + Align &operator=(Align &&Other) = default; + + explicit Align(uint64_t Value) { + assert(Value > 0 && "Value must not be 0"); + assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2"); + ShiftValue = Log2_64(Value); + assert(ShiftValue < 64 && "Broken invariant"); + } + + // This is a hole in the type system and should not be abused. + // Needed to interact with C for instance. + uint64_t value() const { return uint64_t(1) << ShiftValue; } +}; + +// Treats the value 0 as a 1, so Align is always at least 1. +inline Align assumeAligned(uint64_t Value) { + return Value ? Align(Value) : Align(); +} + +// This struct is a compact representation of a valid (power of two) or +// undefined (0) alignment. +struct MaybeAlign : public llvm::Optional { +private: + using UP = llvm::Optional; + +public: + // Do not perform checks in case of copy/move construct/assign, because the + // checks have been performed when building `Other`. + MaybeAlign(const MaybeAlign &Other) = default; + MaybeAlign &operator=(const MaybeAlign &Other) = default; + MaybeAlign(MaybeAlign &&Other) = default; + MaybeAlign &operator=(MaybeAlign &&Other) = default; + + // Use llvm::Optional constructor. + using UP::UP; + + explicit MaybeAlign(uint64_t Value) { + assert((Value == 0 || llvm::isPowerOf2_64(Value)) && + "Alignment is not 0 or a power of 2"); + if (Value) + emplace(Value); + } + + // For convenience, returns a valid alignment or 1 if undefined. + Align valueOrOne() const { return hasValue() ? getValue() : Align(); } +}; + +// ----------------------------------------------------------------------------- +// isAligned: Checks that SizeInBytes is a multiple of the alignment. +// ----------------------------------------------------------------------------- + +inline bool isAligned(Align Lhs, uint64_t SizeInBytes) { + return SizeInBytes % Lhs.value() == 0; +} + +// Returns false if the alignment is undefined. +inline bool isAligned(MaybeAlign Lhs, uint64_t SizeInBytes) { + ALIGN_CHECK_ISSET(Lhs); + return SizeInBytes % (*Lhs).value() == 0; +} + +// ----------------------------------------------------------------------------- +// alignTo: Returns a multiple of A needed to store `Size` bytes. +// ----------------------------------------------------------------------------- + +inline uint64_t alignTo(uint64_t Size, Align A) { + return (Size + A.value() - 1) / A.value() * A.value(); +} + +// Returns `Size` if current alignment is undefined. +inline uint64_t alignTo(uint64_t Size, MaybeAlign A) { + return A ? alignTo(Size, A.getValue()) : Size; +} + +// ----------------------------------------------------------------------------- +// log2: Returns the log2 of the alignment. +// e.g. Align(16).log2() == 4 +// ----------------------------------------------------------------------------- + +inline unsigned Log2(Align A) { return A.ShiftValue; } + +/// \pre A must be defined. +inline unsigned Log2(MaybeAlign A) { + ALIGN_CHECK_ISSET(A); + return Log2(A.getValue()); +} + +// ----------------------------------------------------------------------------- +// commonAlignment: returns the alignment that satisfies both alignments. +// Same semantic as MinAlign. +// ----------------------------------------------------------------------------- + +inline Align commonAlignment(Align A, Align B) { return std::min(A, B); } + +inline Align commonAlignment(Align A, uint64_t Offset) { + return Align(MinAlign(A.value(), Offset)); +} + +inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) { + return A && B ? commonAlignment(*A, *B) : A ? A : B; +} + +inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) { + return MaybeAlign(MinAlign((*A).value(), Offset)); +} + +// ----------------------------------------------------------------------------- +// Encode/Decode +// ----------------------------------------------------------------------------- + +// Returns a more compact representation of the alignment. +// An undefined MaybeAlign is encoded as 0. +inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; } + +// Dual operation of the encode function above. +inline MaybeAlign decodeMaybeAlign(unsigned Value) { + if (Value == 0) + return MaybeAlign(); + Align Out; + Out.ShiftValue = Value - 1; + return Out; +} + +// Returns a more compact representation of the alignment. +// The encoded value is positive by definition. +// e.g. Align(1).encode() == 1 +// e.g. Align(16).encode() == 5 +inline unsigned encode(Align A) { return encode(MaybeAlign(A)); } + +// ----------------------------------------------------------------------------- +// Comparisons +// ----------------------------------------------------------------------------- + +// Comparisons between Align and scalars. Rhs must be positive. +inline bool operator==(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() == Rhs; +} +inline bool operator!=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() != Rhs; +} +inline bool operator<=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() <= Rhs; +} +inline bool operator>=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() >= Rhs; +} +inline bool operator<(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() < Rhs; +} +inline bool operator>(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() > Rhs; +} + +// Comparisons between MaybeAlign and scalars. +inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) { + return Lhs ? (*Lhs).value() == Rhs : Rhs == 0; +} +inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) { + return Lhs ? (*Lhs).value() != Rhs : Rhs != 0; +} +inline bool operator<=(MaybeAlign Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return (*Lhs).value() <= Rhs; +} +inline bool operator>=(MaybeAlign Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return (*Lhs).value() >= Rhs; +} +inline bool operator<(MaybeAlign Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return (*Lhs).value() < Rhs; +} +inline bool operator>(MaybeAlign Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return (*Lhs).value() > Rhs; +} + +// Comparisons operators between Align. +inline bool operator==(Align Lhs, Align Rhs) { + return Lhs.ShiftValue == Rhs.ShiftValue; +} +inline bool operator!=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue != Rhs.ShiftValue; +} +inline bool operator<=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue <= Rhs.ShiftValue; +} +inline bool operator>=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue >= Rhs.ShiftValue; +} +inline bool operator<(Align Lhs, Align Rhs) { + return Lhs.ShiftValue < Rhs.ShiftValue; +} +inline bool operator>(Align Lhs, Align Rhs) { + return Lhs.ShiftValue > Rhs.ShiftValue; +} + +// Comparisons operators between Align and MaybeAlign. +inline bool operator==(Align Lhs, MaybeAlign Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() == (*Rhs).value(); +} +inline bool operator!=(Align Lhs, MaybeAlign Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() != (*Rhs).value(); +} +inline bool operator<=(Align Lhs, MaybeAlign Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() <= (*Rhs).value(); +} +inline bool operator>=(Align Lhs, MaybeAlign Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() >= (*Rhs).value(); +} +inline bool operator<(Align Lhs, MaybeAlign Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() < (*Rhs).value(); +} +inline bool operator>(Align Lhs, MaybeAlign Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() > (*Rhs).value(); +} + +// Comparisons operators between MaybeAlign and Align. +inline bool operator==(MaybeAlign Lhs, Align Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs && (*Lhs).value() == Rhs.value(); +} +inline bool operator!=(MaybeAlign Lhs, Align Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs && (*Lhs).value() != Rhs.value(); +} +inline bool operator<=(MaybeAlign Lhs, Align Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs && (*Lhs).value() <= Rhs.value(); +} +inline bool operator>=(MaybeAlign Lhs, Align Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs && (*Lhs).value() >= Rhs.value(); +} +inline bool operator<(MaybeAlign Lhs, Align Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs && (*Lhs).value() < Rhs.value(); +} +inline bool operator>(MaybeAlign Lhs, Align Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs && (*Lhs).value() > Rhs.value(); +} + +// ----------------------------------------------------------------------------- +// Division +// ----------------------------------------------------------------------------- + +inline Align operator/(Align Lhs, uint64_t Divisor) { + assert(llvm::isPowerOf2_64(Divisor) && + "Divisor must be positive and a power of 2"); + assert(Lhs != 1 && "Can't halve byte alignment"); + return Align(Lhs.value() / Divisor); +} + +inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) { + assert(llvm::isPowerOf2_64(Divisor) && + "Divisor must be positive and a power of 2"); + return Lhs ? Lhs.getValue() / Divisor : MaybeAlign(); +} + +#undef ALIGN_CHECK_ISPOSITIVE +#undef ALIGN_CHECK_ISSET + +} // namespace llvm + +#endif // LLVM_SUPPORT_ALIGNMENT_H_ Index: llvm/trunk/unittests/Support/AlignmentTest.cpp =================================================================== --- llvm/trunk/unittests/Support/AlignmentTest.cpp +++ llvm/trunk/unittests/Support/AlignmentTest.cpp @@ -0,0 +1,284 @@ +//=== - llvm/unittest/Support/Alignment.cpp - Alignment utility tests -----===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "llvm/Support/Alignment.h" +#include "gtest/gtest.h" + +#include + +using namespace llvm; + +namespace { + +std::vector getValidAlignments() { + std::vector Out; + for (size_t Shift = 0; Shift < 64; ++Shift) + Out.push_back(1ULL << Shift); + return Out; +} + +// We use a subset of valid alignments for DEATH_TESTs as they are particularly +// slow. +std::vector getValidAlignmentsForDeathTest() { + return {1, 1ULL << 31, 1ULL << 63}; +} + +std::vector getNonPowerOfTwo() { return {3, 10, 15}; } + +TEST(Alignment, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); } + +TEST(Alignment, MaybeAlignDefaultCTor) { + EXPECT_FALSE(MaybeAlign().hasValue()); +} + +TEST(Alignment, ValidCTors) { + for (size_t Value : getValidAlignments()) { + EXPECT_EQ(Align(Value).value(), Value); + EXPECT_EQ((*MaybeAlign(Value)).value(), Value); + } +} + +TEST(Alignment, InvalidCTors) { + EXPECT_DEATH((Align(0)), "Value must not be 0"); + for (size_t Value : getNonPowerOfTwo()) { + EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2"); + EXPECT_DEATH((MaybeAlign(Value)), "Alignment is not 0 or a power of 2"); + } +} + +TEST(Alignment, CheckMaybeAlignHasValue) { + EXPECT_TRUE(MaybeAlign(1)); + EXPECT_TRUE(MaybeAlign(1).hasValue()); + EXPECT_FALSE(MaybeAlign(0)); + EXPECT_FALSE(MaybeAlign(0).hasValue()); + EXPECT_FALSE(MaybeAlign()); + EXPECT_FALSE(MaybeAlign().hasValue()); +} + +TEST(Alignment, CantConvertUnsetMaybe) { + EXPECT_DEATH((MaybeAlign(0).getValue()), ".*"); +} + +TEST(Alignment, Division) { + for (size_t Value : getValidAlignments()) { + if (Value == 1) { + EXPECT_DEATH(Align(Value) / 2, "Can't halve byte alignment"); + EXPECT_DEATH(MaybeAlign(Value) / 2, "Can't halve byte alignment"); + } else { + EXPECT_EQ(Align(Value) / 2, Value / 2); + EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2); + } + } + EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0)); + + EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2"); + EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2"); +} + +TEST(Alignment, AlignTo) { + struct { + uint64_t alignment; + uint64_t offset; + uint64_t rounded; + } kTests[] = { + // MaybeAlign + {0, 0, 0}, + {0, 1, 1}, + {0, 5, 5}, + // MaybeAlign / Align + {1, 0, 0}, + {1, 1, 1}, + {1, 5, 5}, + {2, 0, 0}, + {2, 1, 2}, + {2, 2, 2}, + {2, 7, 8}, + {2, 16, 16}, + {4, 0, 0}, + {4, 1, 4}, + {4, 4, 4}, + {4, 6, 8}, + }; + for (const auto &T : kTests) { + MaybeAlign A(T.alignment); + // Test MaybeAlign + EXPECT_EQ(alignTo(T.offset, A), T.rounded); + // Test Align + if (A) + EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded); + } +} + +TEST(Alignment, Log2) { + for (size_t Value : getValidAlignments()) { + EXPECT_EQ(Log2(Align(Value)), Log2_64(Value)); + EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value)); + } + EXPECT_DEATH(Log2(MaybeAlign(0)), ".* should be defined"); +} + +TEST(Alignment, MinAlign) { + struct { + uint64_t A; + uint64_t B; + uint64_t MinAlign; + } kTests[] = { + // MaybeAlign + {0, 0, 0}, + {0, 8, 8}, + {2, 0, 2}, + // MaybeAlign / Align + {1, 2, 1}, + {8, 4, 4}, + }; + for (const auto &T : kTests) { + EXPECT_EQ(commonAlignment(MaybeAlign(T.A), MaybeAlign(T.B)), T.MinAlign); + EXPECT_EQ(MinAlign(T.A, T.B), T.MinAlign); + if (T.A) + EXPECT_EQ(commonAlignment(Align(T.A), MaybeAlign(T.B)), T.MinAlign); + if (T.B) + EXPECT_EQ(commonAlignment(MaybeAlign(T.A), Align(T.B)), T.MinAlign); + if (T.A && T.B) + EXPECT_EQ(commonAlignment(Align(T.A), Align(T.B)), T.MinAlign); + } +} + +TEST(Alignment, Encode_Decode) { + for (size_t Value : getValidAlignments()) { + { + Align Actual(Value); + Align Expected = decodeMaybeAlign(encode(Actual)).getValue(); + EXPECT_EQ(Expected, Actual); + } + { + MaybeAlign Actual(Value); + MaybeAlign Expected = decodeMaybeAlign(encode(Actual)); + EXPECT_EQ(Expected, Actual); + } + } + MaybeAlign Actual(0); + MaybeAlign Expected = decodeMaybeAlign(encode(Actual)); + EXPECT_EQ(Expected, Actual); +} + +TEST(Alignment, isAligned) { + struct { + uint64_t alignment; + uint64_t offset; + bool isAligned; + } kTests[] = { + // MaybeAlign / Align + {1, 0, true}, {1, 1, true}, {1, 5, true}, {2, 0, true}, + {2, 1, false}, {2, 2, true}, {2, 7, false}, {2, 16, true}, + {4, 0, true}, {4, 1, false}, {4, 4, true}, {4, 6, false}, + }; + for (const auto &T : kTests) { + MaybeAlign A(T.alignment); + // Test MaybeAlign + EXPECT_EQ(isAligned(A, T.offset), T.isAligned); + // Test Align + if (A) + EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned); + } +} + +TEST(Alignment, AlignComparisons) { + std::vector ValidAlignments = getValidAlignments(); + std::sort(ValidAlignments.begin(), ValidAlignments.end()); + for (size_t I = 1; I < ValidAlignments.size(); ++I) { + assert(I >= 1); + const Align A(ValidAlignments[I - 1]); + const Align B(ValidAlignments[I]); + EXPECT_EQ(A, A); + EXPECT_NE(A, B); + EXPECT_LT(A, B); + EXPECT_GT(B, A); + EXPECT_LE(A, B); + EXPECT_GE(B, A); + EXPECT_LE(A, A); + EXPECT_GE(A, A); + + EXPECT_EQ(A, A.value()); + EXPECT_NE(A, B.value()); + EXPECT_LT(A, B.value()); + EXPECT_GT(B, A.value()); + EXPECT_LE(A, B.value()); + EXPECT_GE(B, A.value()); + EXPECT_LE(A, A.value()); + EXPECT_GE(A, A.value()); + + EXPECT_EQ(std::max(A, B), B); + EXPECT_EQ(std::min(A, B), A); + + const MaybeAlign MA(ValidAlignments[I - 1]); + const MaybeAlign MB(ValidAlignments[I]); + EXPECT_EQ(MA, MA); + EXPECT_NE(MA, MB); + EXPECT_LT(MA, MB); + EXPECT_GT(MB, MA); + EXPECT_LE(MA, MB); + EXPECT_GE(MB, MA); + EXPECT_LE(MA, MA); + EXPECT_GE(MA, MA); + + EXPECT_EQ(MA, MA ? (*MA).value() : 0); + EXPECT_NE(MA, MB ? (*MB).value() : 0); + EXPECT_LT(MA, MB ? (*MB).value() : 0); + EXPECT_GT(MB, MA ? (*MA).value() : 0); + EXPECT_LE(MA, MB ? (*MB).value() : 0); + EXPECT_GE(MB, MA ? (*MA).value() : 0); + EXPECT_LE(MA, MA ? (*MA).value() : 0); + EXPECT_GE(MA, MA ? (*MA).value() : 0); + + EXPECT_EQ(std::max(A, B), B); + EXPECT_EQ(std::min(A, B), A); + } +} + +TEST(Alignment, AssumeAligned) { + EXPECT_EQ(assumeAligned(0), Align(1)); + EXPECT_EQ(assumeAligned(0), Align()); + EXPECT_EQ(assumeAligned(1), Align(1)); + EXPECT_EQ(assumeAligned(1), Align()); +} + +TEST(Alignment, ComparisonsWithZero) { + for (size_t Value : getValidAlignmentsForDeathTest()) { + EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) >= 0), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) <= 0), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) > 0), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) < 0), ".* should be defined"); + } +} + +TEST(Alignment, CompareMaybeAlignToZero) { + for (size_t Value : getValidAlignmentsForDeathTest()) { + // MaybeAlign is allowed to be == or != 0 + (void)(MaybeAlign(Value) == 0); + (void)(MaybeAlign(Value) != 0); + EXPECT_DEATH((void)(MaybeAlign(Value) >= 0), ".* should be defined"); + EXPECT_DEATH((void)(MaybeAlign(Value) <= 0), ".* should be defined"); + EXPECT_DEATH((void)(MaybeAlign(Value) > 0), ".* should be defined"); + EXPECT_DEATH((void)(MaybeAlign(Value) < 0), ".* should be defined"); + } +} + +TEST(Alignment, CompareAlignToUndefMaybeAlign) { + for (size_t Value : getValidAlignmentsForDeathTest()) { + EXPECT_DEATH((void)(Align(Value) == MaybeAlign(0)), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) != MaybeAlign(0)), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) >= MaybeAlign(0)), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) <= MaybeAlign(0)), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) > MaybeAlign(0)), ".* should be defined"); + EXPECT_DEATH((void)(Align(Value) < MaybeAlign(0)), ".* should be defined"); + } +} + +} // end anonymous namespace Index: llvm/trunk/unittests/Support/CMakeLists.txt =================================================================== --- llvm/trunk/unittests/Support/CMakeLists.txt +++ llvm/trunk/unittests/Support/CMakeLists.txt @@ -3,6 +3,7 @@ ) add_llvm_unittest(SupportTests + AlignmentTest.cpp AlignOfTest.cpp AllocatorTest.cpp AnnotationsTest.cpp