diff --git a/llvm/include/llvm/Support/Alignment.h b/llvm/include/llvm/Support/Alignment.h new file mode 100644 --- /dev/null +++ b/llvm/include/llvm/Support/Alignment.h @@ -0,0 +1,570 @@ +//===-- 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 get() method. +// +// Before the alignments were represented as `unsigned` with 0 meaning +// `undefined alignment requirements` and 1 meaning `no alignment requirements`, +// this caused hard to spot bugs: +// +// * Unclear semantic when comparing alignments: +// unsigned AlignmentA = GetA(); +// unsigned AlignmentB = GetB(); +// if (AlignmentA <= AlignmentB) { +// // Unclear what this means if AlignmentA or AlignmentB are allowed to +// // be zero. +// } +// * Mistakenly passing a `bool` as an alignment in a function call because of +// integral type promotion. +// * Passing -1 as an alignment. +// * Convoluted bit masking / shifting / arithmetic using `unsigned` with poor +// guarantees on the final value correctness. +// * Semantic slippage when halving alignment: +// unsigned Align = GetAlignment(); +// unsigned HalfAlign = Align / 2; // If Align is 1, HalfAlign is undefined +// +//===----------------------------------------------------------------------===// + +#ifndef THIRD_PARTY_LLVM_LLVM_INCLUDE_LLVM_SUPPORT_ALIGNMENT_H_ +#define THIRD_PARTY_LLVM_LLVM_INCLUDE_LLVM_SUPPORT_ALIGNMENT_H_ + +#include "llvm/Support/Compiler.h" +#include "llvm/Support/MathExtras.h" +#include +#include + +namespace llvm { + +// FIXME: Enable when all the call sites are fixed to check correct alignment +// semantic. +#define ALIGN_HARDENED_ALIGNMENT 0 + +#if ALIGN_HARDENED_ALIGNMENT +#define ALIGN_CHECK_ISPOSITIVE(decl) \ + assert(decl > 0 && (#decl " should be defined")) +#define ALIGN_CHECK_ISSET(decl) \ + assert(decl.isSet() && (#decl " should be defined")) +#define ALIGN_DEPRECATED(decl, message) LLVM_ATTRIBUTE_DEPRECATED(decl, message) +#else +#define ALIGN_CHECK_ISPOSITIVE(decl) +#define ALIGN_CHECK_ISSET(decl) +#define ALIGN_DEPRECATED(decl, message) decl +#endif + +// This struct is a compact representation of a valid (non-zero power of two) +// alignment. +// Its minimum value is 1, its maximum value is 2^31, 2^32 is excluded on +// purpose to prevent mixing it up with -1. +// It is suitable for use as static global constants. +struct Align final { +private: + uint32_t Value; // The alignment value in Bytes. + friend struct MaybeAlign; + +public: + // Default is byte-aligned. + Align() : Value(1) {} + // 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) : Value(Value) { + assert(Value < std::numeric_limits::max() && "Value too big"); + assert(Value > 0 && "Value must not be 0"); + assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2"); + } + + // A safe halving method that makes sure semantic is preserved. + Align half() const { + assert(Value > 1 && "Can't halve byte alignment"); + return Align(Value / 2); + } + + // Whether we need extra bytes after storing `Size` bytes to keep the current + // alignment. + bool needsPadding(uint64_t Size) const { + return (Size & (uint64_t(Value) - 1)) != 0; + } + + // 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 Value; } +}; + +// This struct is a compact representation of a valid (power of two) or +// undefined (0) alignment. +// Its minimum value is 0, its maximum value is 2^31, 2^32 is excluded on +// purpose to prevent mixing it up with -1. +// It is suitable for use as static global constants. +struct MaybeAlign final { +private: + uint32_t Value; + +public: + static constexpr unsigned kSentinel = std::numeric_limits::max(); + + // Default is undefined alignment. + MaybeAlign() : Value(0) {} + // 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; + + explicit MaybeAlign(uint64_t Value) : Value(Value) { + assert(Value < std::numeric_limits::max() && "Value too big"); + assert((Value == 0 || llvm::isPowerOf2_64(Value)) && + "Alignment is not 0 or a power of 2"); + } + + // Allow construction and assignment from Align type. + MaybeAlign(const Align &Other) : Value(Other.Value) {} + void operator=(const Align &Alignement) { *this = MaybeAlign(Alignement); } + + // For convenience, checks whether the alignment is set. + // e.g. if(MaybeAlign A = GetAlignement()) { /* */ } + explicit operator bool() const { return Value > 0; } + + // Returns whether the alignment is set or undefined. + bool isSet() const { return Value > 0; } + + // Returns an Align from this MaybeAlign. + // Precondition, this alignment must be set. + Align get() const { + assert(isSet() && "Can't convert undefined alignment to Align type"); + return Align(Value); + } + + // Convenient method to help straighten the alignment. MaybeAlign types after + // this point can be turned into Align. + void mustBeSetAtThisPoint() const { + assert(Value && "Alignment must be set at this point"); + } + + // For convenience, returns a valid alignment or 1 if undefined. + Align valueOrOne() const { return Value ? Align(Value) : Align(1); } + + // This is a hole in the type system and should not be abused. + // Needed to interact with C for instance. + unsigned safeValue() const { + assert(Value && "Can't return an unset alignment"); + return Value; + } + + // This is a hole in the type system and should not be abused. + // Needed to interact with C for instance. + uint64_t rawValue() const { return Value; } + + // See Align::needsPadding for documentation. Returns false if current + // alignment is undefined. + // FIXME: /!\ this method hides the undefined semantics and should be removed + // once the call sites are updated. + ALIGN_DEPRECATED( + bool needsPadding(uint64_t Size) const, + "needsPadding involving MaybeAlign mixes semantics, use Align instead"); + + // See Align::half for documentation. Returns undefined alignment if current + // alignment is undefined. + // FIXME: /!\ this method hides the undefined semantics and should be removed + // once the call sites are updated. + ALIGN_DEPRECATED( + MaybeAlign half() const, + "half involving MaybeAlign mixes semantics, use Align instead"); +}; + +inline bool MaybeAlign::needsPadding(uint64_t Size) const { + return Value ? Align(Value).needsPadding(Size) : false; +} + +inline MaybeAlign MaybeAlign::half() const { + return Value ? Align(Value).half() : MaybeAlign(); +} + +// ----------------------------------------------------------------------------- +// isAligned: Checks that SizeInBytes is a multiple of the alignment. +// ----------------------------------------------------------------------------- + +inline bool isAligned(const Align &Lhs, uint64_t SizeInBytes) { + return SizeInBytes % Lhs.value() == 0; +} + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED( + bool isAligned(const MaybeAlign &Lhs, uint64_t SizeInBytes), + "isAligned involving MaybeAlign mixes semantics, use Align instead"); + +// Returns false if the alignment is undefined. +inline bool isAligned(const MaybeAlign &Lhs, uint64_t SizeInBytes) { + ALIGN_CHECK_ISSET(Lhs); + return SizeInBytes % Lhs.rawValue() == 0; +} + +// This function is here for the purpose of refactoring the LLVM's alignment but +// seems to be logically wrong. +// Checks that alignment is a multiple of the SizeInBytes. e.g. +// isAlignedBogus(Align(4), 4) == true +// isAlignedBogus(Align(2), 4) == false +// isAlignedBogus(Align(8), 4) == true +// isAlignedBogus(Align(2), 5) == false +inline bool isAlignedBogus(const Align &Lhs, uint64_t SizeInBytes) { + ALIGN_CHECK_ISPOSITIVE(SizeInBytes); + return Lhs.value() % SizeInBytes == 0; +} + +// This function is here for the purpose of refactoring the LLVM's alignment but +// seems to be logically wrong. +// Checks that alignment is a multiple of the SizeInBytes. +// Returns false if the alignment is undefined. e.g. +// isAlignedBogus(MaybeAlign(0), 4) == false +// isAlignedBogus(MaybeAlign(4), 4) == true +// isAlignedBogus(MaybeAlign(2), 4) == false +// isAlignedBogus(MaybeAlign(8), 4) == true +// isAlignedBogus(MaybeAlign(2), 5) == false +inline bool isAlignedBogus(const MaybeAlign &Lhs, uint64_t SizeInBytes) { + ALIGN_CHECK_ISPOSITIVE(SizeInBytes); + ALIGN_CHECK_ISSET(Lhs); + return Lhs.rawValue() % SizeInBytes == 0; +} + +// ----------------------------------------------------------------------------- +// alignTo: Returns a multiple of A needed to store `Size` bytes. +// ----------------------------------------------------------------------------- + +inline uint64_t alignTo(uint64_t Size, const Align &A) { + return (Size + A.value() - 1) / A.value() * A.value(); +} + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED( + uint64_t alignTo(uint64_t Size, const MaybeAlign &A), + "roundUp involving MaybeAlign mixes semantics, use Align instead"); + +// Returns `Size` if current alignment is undefined. +inline uint64_t alignTo(uint64_t Size, const MaybeAlign &A) { + return A ? alignTo(Size, A.get()) : Size; +} + +// ----------------------------------------------------------------------------- +// log2: Returns the log2 of the alignment. +// e.g. Align(16).log2() == 4 +// ----------------------------------------------------------------------------- + +inline unsigned Log2_32(const Align &A) { return Log2_32(A.value()); } + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED( + unsigned Log2_32(const MaybeAlign &A), + "log2 involving MaybeAlign mixes semantics, use Align instead"); + +// Returns unsigned(-1) if current alignment is undefined. +inline unsigned Log2_32(const MaybeAlign &A) { + return A ? Log2_32(A.get()) : MaybeAlign::kSentinel; +} + +// ----------------------------------------------------------------------------- +// commonAlignment: returns the alignment that satisfies both alignments. +// Same semantic as MinAlign. +// ----------------------------------------------------------------------------- + +inline Align commonAlignment(const Align &A, const Align &B) { + return Align(MinAlign(A.value(), B.value())); +} + +inline Align commonAlignment(const Align &A, uint64_t Offset) { + return Align(MinAlign(A.value(), Offset)); +} + +ALIGN_DEPRECATED( + MaybeAlign commonAlignment(const MaybeAlign &A, const MaybeAlign &B), + "commonAlignment involving MaybeAlign mixes semantics, use Align instead"); + +ALIGN_DEPRECATED( + Align commonAlignment(const MaybeAlign &A, uint64_t Offset), + "commonAlignment involving MaybeAlign mixes semantics, use Align instead"); + +inline MaybeAlign commonAlignment(const MaybeAlign &A, const MaybeAlign &B) { + return MaybeAlign(MinAlign(A.rawValue(), B.rawValue())); +} + +inline Align commonAlignment(const MaybeAlign &A, uint64_t Offset) { + return commonAlignment(A.get(), Offset); +} + +// ----------------------------------------------------------------------------- +// Encode/Decode +// ----------------------------------------------------------------------------- + +// 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(const Align &A) { return Log2_32(A.value()) + 1; } + +// Returns a more compact representation of the alignment. +// An undefined MaybeAlign is encoded as 0. +inline unsigned encode(const MaybeAlign &A) { + return Log2_32(A.rawValue()) + 1; +} + +// Dual operation of the encode function above. +inline MaybeAlign decodeMaybeAlign(unsigned Value) { + return MaybeAlign((1U << Value) / 2); +} + +// ----------------------------------------------------------------------------- +// Comparisons +// ----------------------------------------------------------------------------- + +// Comparisons between Align and scalars. Rhs must be positive. +inline bool operator==(const Align &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() == Rhs; +} +inline bool operator!=(const Align &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() != Rhs; +} +inline bool operator<=(const Align &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() <= Rhs; +} +inline bool operator>=(const Align &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() >= Rhs; +} +inline bool operator<(const Align &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() < Rhs; +} +inline bool operator>(const Align &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() > Rhs; +} + +// Comparisons between MaybeAlign and scalars. +bool operator==(const MaybeAlign &Lhs, uint64_t Rhs) { + // Fine to compare with 0. + return Lhs.rawValue() == Rhs; +} +bool operator!=(const MaybeAlign &Lhs, uint64_t Rhs) { + // Fine to compare with 0. + return Lhs.rawValue() != Rhs; +} +bool operator<=(const MaybeAlign &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.rawValue() <= Rhs; +} +bool operator>=(const MaybeAlign &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.rawValue() >= Rhs; +} +bool operator<(const MaybeAlign &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.rawValue() < Rhs; +} +bool operator>(const MaybeAlign &Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.rawValue() > Rhs; +} + +// Comparisons operators between Align. +inline bool operator==(const Align &Lhs, const Align &Rhs) { + return Lhs.value() == Rhs.value(); +} +inline bool operator!=(const Align &Lhs, const Align &Rhs) { + return Lhs.value() != Rhs.value(); +} +inline bool operator<=(const Align &Lhs, const Align &Rhs) { + return Lhs.value() <= Rhs.value(); +} +inline bool operator>=(const Align &Lhs, const Align &Rhs) { + return Lhs.value() >= Rhs.value(); +} +inline bool operator<(const Align &Lhs, const Align &Rhs) { + return Lhs.value() < Rhs.value(); +} +inline bool operator>(const Align &Lhs, const Align &Rhs) { + return Lhs.value() > Rhs.value(); +} + +// Comparisons operators between Align and MaybeAlign. +inline bool operator==(const Align &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() == Rhs.rawValue(); +} +inline bool operator!=(const Align &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() != Rhs.rawValue(); +} +inline bool operator<=(const Align &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() <= Rhs.rawValue(); +} +inline bool operator>=(const Align &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() >= Rhs.rawValue(); +} +inline bool operator<(const Align &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() < Rhs.rawValue(); +} +inline bool operator>(const Align &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Rhs); + return Lhs.value() > Rhs.rawValue(); +} + +// Comparisons operators between MaybeAlign and Align. +inline bool operator==(const MaybeAlign &Lhs, const Align &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs.rawValue() == Rhs.value(); +} +inline bool operator!=(const MaybeAlign &Lhs, const Align &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs.rawValue() != Rhs.value(); +} +inline bool operator<=(const MaybeAlign &Lhs, const Align &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs.rawValue() <= Rhs.value(); +} +inline bool operator>=(const MaybeAlign &Lhs, const Align &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs.rawValue() >= Rhs.value(); +} +inline bool operator<(const MaybeAlign &Lhs, const Align &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs.rawValue() < Rhs.value(); +} +inline bool operator>(const MaybeAlign &Lhs, const Align &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + return Lhs.rawValue() > Rhs.value(); +} + +// Comparisons operators between MaybeAlign. +bool operator==(const MaybeAlign &Lhs, const MaybeAlign &Rhs) { + // Fine to compare with 0. + return Lhs.rawValue() == Rhs.rawValue(); +} +bool operator!=(const MaybeAlign &Lhs, const MaybeAlign &Rhs) { + // Fine to compare with 0. + return Lhs.rawValue() != Rhs.rawValue(); +} +bool operator<=(const MaybeAlign &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISSET(Rhs); + return Lhs.rawValue() <= Rhs.rawValue(); +} +bool operator>=(const MaybeAlign &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISSET(Rhs); + return Lhs.rawValue() >= Rhs.rawValue(); +} +bool operator<(const MaybeAlign &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISSET(Rhs); + return Lhs.rawValue() < Rhs.rawValue(); +} +bool operator>(const MaybeAlign &Lhs, const MaybeAlign &Rhs) { + ALIGN_CHECK_ISSET(Lhs); + ALIGN_CHECK_ISSET(Rhs); + return Lhs.rawValue() > Rhs.rawValue(); +} + +// ----------------------------------------------------------------------------- +// max: Returns the greatest of the two alignments. +// ----------------------------------------------------------------------------- + +// The maximum of two valid alignments is a valid alignment. +inline Align max(const Align &A, const Align &B) { return A > B ? A : B; } + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED(MaybeAlign max(const MaybeAlign &A, const MaybeAlign &B), + "max involving MaybeAlign mixes semantics, use Align instead"); + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED(Align max(const Align &A, const MaybeAlign &B), + "max involving MaybeAlign mixes semantics, use Align instead"); + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED(Align max(const MaybeAlign &A, const Align &B), + "max involving MaybeAlign mixes semantics, use Align instead"); + +inline MaybeAlign max(const MaybeAlign &A, const MaybeAlign &B) { + return MaybeAlign(std::max(A.rawValue(), B.rawValue())); +} + +inline Align max(const Align &A, const MaybeAlign &B) { + return Align(std::max(A.value(), B.rawValue())); +} + +inline Align max(const MaybeAlign &A, const Align &B) { + return Align(std::max(A.rawValue(), B.value())); +} + +// ----------------------------------------------------------------------------- +// min: Returns the smallest of the two alignments. +// ----------------------------------------------------------------------------- + +// The minimum of two valid alignments is a valid alignment. +inline Align min(const Align &A, const Align &B) { return A > B ? B : A; } + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED(MaybeAlign min(const MaybeAlign &A, const MaybeAlign &B), + "min involving MaybeAlign mixes semantics, use Align instead"); + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED(MaybeAlign min(const Align &A, const MaybeAlign &B), + "min involving MaybeAlign mixes semantics, use Align instead"); + +// FIXME: /!\ this method hides the undefined semantics and should be removed +// once the call sites are updated. +ALIGN_DEPRECATED(MaybeAlign min(const MaybeAlign &A, const Align &B), + "min involving MaybeAlign mixes semantics, use Align instead"); + +inline MaybeAlign min(const MaybeAlign &A, const MaybeAlign &B) { + return MaybeAlign(std::min(A.rawValue(), B.rawValue())); +} + +inline MaybeAlign min(const Align &A, const MaybeAlign &B) { + return MaybeAlign(std::min(A.value(), B.rawValue())); +} + +inline MaybeAlign min(const MaybeAlign &A, const Align &B) { + return MaybeAlign(std::min(A.rawValue(), B.value())); +} + +#undef ALIGN_CHECK_ISPOSITIVE +#undef ALIGN_CHECK_ISSET +#undef ALIGN_DEPRECATED + +} // namespace llvm + +#endif // THIRD_PARTY_LLVM_LLVM_INCLUDE_LLVM_SUPPORT_ALIGNMENT_H_ diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp new file mode 100644 --- /dev/null +++ b/llvm/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 < 31; ++Shift) + Out.push_back(1ULL << Shift); + return Out; +} + +std::vector getNonPowerOfTwo() { + return {3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15}; +} + +std::vector getAlignmentTooBig() { + return {std::numeric_limits::max() /*2^32*/, + std::numeric_limits::max() /*2^64*/}; +} + +TEST(Alignment, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); } + +TEST(Alignment, MaybeAlignDefaultCTor) { + EXPECT_EQ(MaybeAlign().rawValue(), 0ULL); +} + +TEST(Alignment, ValidCTors) { + for (size_t Value : getValidAlignments()) { + EXPECT_EQ(Align(Value).value(), Value); + EXPECT_EQ(MaybeAlign(Value).safeValue(), Value); + } + EXPECT_EQ(MaybeAlign(0).rawValue(), 0ULL); +} + +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"); + } + for (size_t Value : getAlignmentTooBig()) { + EXPECT_DEATH((Align(Value)), "Value too big"); + EXPECT_DEATH((MaybeAlign(Value)), "Value too big"); + } +} + +TEST(Alignment, CheckMaybeAlignIsSet) { + EXPECT_TRUE(MaybeAlign(1)); + EXPECT_TRUE(MaybeAlign(1).isSet()); + EXPECT_FALSE(MaybeAlign(0)); + EXPECT_FALSE(MaybeAlign(0).isSet()); + EXPECT_FALSE(MaybeAlign()); + EXPECT_FALSE(MaybeAlign().isSet()); +} + +TEST(Alignment, CantConvertUnsetMaybe) { + EXPECT_DEATH((MaybeAlign(0).get()), + "Can't convert undefined alignment to Align type"); + EXPECT_DEATH((MaybeAlign(0).safeValue()), "Can't return an unset alignment"); +} + +TEST(Alignment, Half) { + for (size_t Value : getValidAlignments()) { + if (Value == 1) { + EXPECT_DEATH(Align(Value).half(), "Can't halve byte alignment"); + EXPECT_DEATH(MaybeAlign(Value).half(), "Can't halve byte alignment"); + } else { + EXPECT_EQ(Align(Value).half(), Value / 2); + EXPECT_EQ(MaybeAlign(Value).half(), Value / 2); + } + } + EXPECT_EQ(MaybeAlign(0).half(), MaybeAlign(0)); +} + +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.get()), T.rounded); + } +} + +TEST(Alignment, NeedsPadding) { + struct { + uint64_t alignment; + uint64_t offset; + bool needsPadding; + } kTests[] = { + // MaybeAlign + {0, 0, false}, + {0, 1, false}, + {0, 5, false}, + // MaybeAlign / Align + {1, 0, false}, + {1, 1, false}, + {1, 5, false}, + {2, 0, false}, + {2, 1, true}, + {2, 2, false}, + {2, 7, true}, + {2, 16, false}, + {4, 0, false}, + {4, 1, true}, + {4, 4, false}, + {4, 6, true}, + }; + for (const auto &T : kTests) { + MaybeAlign A(T.alignment); + // Test MaybeAlign + EXPECT_EQ(A.needsPadding(T.offset), T.needsPadding); + // Test Align + if (A) + EXPECT_EQ(A.get().needsPadding(T.offset), T.needsPadding); + } +} + +TEST(Alignment, Log2_32) { + for (size_t Value : getValidAlignments()) { + EXPECT_EQ(Log2_32(Align(Value)), Log2_64(Value)); + EXPECT_EQ(Log2_32(MaybeAlign(Value)), Log2_64(Value)); + } + EXPECT_EQ(Log2_32(MaybeAlign(0)), (unsigned)-1); +} + +TEST(Alignment, Encode_Decode) { + for (size_t Value : getValidAlignments()) { + { + Align Actual(Value); + Align Expected = decodeMaybeAlign(encode(Actual)).get(); + 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.get(), 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(max(A, B), B); + EXPECT_EQ(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.safeValue()); + EXPECT_NE(MA, MB.safeValue()); + EXPECT_LT(MA, MB.safeValue()); + EXPECT_GT(MB, MA.safeValue()); + EXPECT_LE(MA, MB.safeValue()); + EXPECT_GE(MB, MA.safeValue()); + EXPECT_LE(MA, MA.safeValue()); + EXPECT_GE(MA, MA.safeValue()); + + EXPECT_EQ(max(A, B), B); + EXPECT_EQ(min(A, B), A); + } +} + +#if ALIGN_HARDENED_ALIGNMENT +TEST(Alignment, ComparisonsWithZero) { + for (size_t Value : getValidAlignments()) { + // Compare Align to 0. + 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"); + + // Compare MaybeAlign to 0, MaybeAlign is allowed to be == or != 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"); + + // Compare Align to undefined MaybeAlign + 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"); + } +} +#endif + +} // end anonymous namespace diff --git a/llvm/unittests/Support/CMakeLists.txt b/llvm/unittests/Support/CMakeLists.txt --- a/llvm/unittests/Support/CMakeLists.txt +++ b/llvm/unittests/Support/CMakeLists.txt @@ -3,6 +3,7 @@ ) add_llvm_unittest(SupportTests + AlignmentTest.cpp AlignOfTest.cpp AllocatorTest.cpp AnnotationsTest.cpp