mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-31 20:51:52 +01:00
[LLVM][NFC] Adding an Alignment type to LLVM
Summary: This patch introduces a type to straighten LLVM's alignment management. See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2019-July/133851.html The next step is to use this type throughout LLVM Reviewers: jfb, jakehehrlich Subscribers: mgorny, mgrang, dexonsmith, llvm-commits, courbet Tags: #llvm Differential Revision: https://reviews.llvm.org/D64790 llvm-svn: 367393
This commit is contained in:
Guillaume Chatelet
parent
9a12e50547
commit
1e50b9400b
345
include/llvm/Support/Alignment.h
Normal file
345
include/llvm/Support/Alignment.h
Normal file
@ -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_
|
||||
284
unittests/Support/AlignmentTest.cpp
Normal file
284
unittests/Support/AlignmentTest.cpp
Normal file
@ -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
|
||||
@ -3,6 +3,7 @@ set(LLVM_LINK_COMPONENTS
|
||||
)
|
||||
|
||||
add_llvm_unittest(SupportTests
|
||||
AlignmentTest.cpp
|
||||
AlignOfTest.cpp
|
||||
AllocatorTest.cpp
|
||||
AnnotationsTest.cpp
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user