Page MenuHomePhabricator

D64790.diff
No OneTemporary

File Metadata

Created
Tue, Sep 17, 5:58 PM

D64790.diff

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 <cassert>
+#include <limits>
+
+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<Align> {
+private:
+ using UP = llvm::Optional<Align>;
+
+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<Align> 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 <vector>
+
+using namespace llvm;
+
+namespace {
+
+std::vector<uint64_t> getValidAlignments() {
+ std::vector<uint64_t> 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<uint64_t> getValidAlignmentsForDeathTest() {
+ return {1, 1ULL << 31, 1ULL << 63};
+}
+
+std::vector<uint64_t> 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<size_t> 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

Event Timeline