From b3af236fb5fc6e50fcc1b54d868f0bff557f3fb1 Mon Sep 17 00:00:00 2001 From: Guillaume Chatelet Date: Thu, 3 Oct 2019 10:53:10 +0000 Subject: [PATCH] [Alignment][NFC] Allow constexpr Align Summary: This is patch is part of a series to introduce an Alignment type. See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2019-July/133851.html See this patch for the introduction of the type: https://reviews.llvm.org/D64790 Reviewers: courbet Subscribers: hiraditya, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D68329 llvm-svn: 373580 --- llvm/include/llvm/Support/Alignment.h | 26 +++++++++++++++++++++---- llvm/include/llvm/Support/MathExtras.h | 9 +++++++++ llvm/lib/Target/AArch64/AArch64StackTagging.cpp | 2 +- llvm/unittests/Support/AlignmentTest.cpp | 10 ++++++++++ llvm/unittests/Support/MathExtrasTest.cpp | 19 ++++++++++++++++++ 5 files changed, 61 insertions(+), 5 deletions(-) diff --git a/llvm/include/llvm/Support/Alignment.h b/llvm/include/llvm/Support/Alignment.h index 3d8a423..f94d7cd 100644 --- a/llvm/include/llvm/Support/Alignment.h +++ b/llvm/include/llvm/Support/Alignment.h @@ -58,10 +58,10 @@ public: constexpr 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; + constexpr Align(const Align &Other) = default; + constexpr Align &operator=(const Align &Other) = default; + constexpr Align(Align &&Other) = default; + constexpr Align &operator=(Align &&Other) = default; explicit Align(uint64_t Value) { assert(Value > 0 && "Value must not be 0"); @@ -80,6 +80,24 @@ public: /// would be better than /// `if (A > Align(1))` constexpr static const Align None() { return Align(); } + + /// This function is useful when initializing constexpr Align constants. + /// e.g. static constexpr Align kAlign16 = Align::Constant<16>(); + /// Most compilers (clang, gcc, icc) will be able to compute `ShiftValue` + /// at compile time with `Align::Align(uint64_t Value)` but to be + /// able to use Align as a constexpr constant use this method. + /// FIXME: When LLVM is C++17 ready `Align::Align(uint64_t Value)` + /// can be constexpr and we can dispatch between runtime (Log2_64) vs + /// compile time (CTLog2) versions using constexpr-if. Then this + /// function is no more necessary and we can add user defined literals + /// for convenience. + template constexpr static Align Constant() { + static_assert(kValue > 0 && llvm::isPowerOf2_64(kValue), + "Not a valid alignment"); + Align A; + A.ShiftValue = CTLog2(); + return A; + } }; /// Treats the value 0 as a 1, so Align is always at least 1. diff --git a/llvm/include/llvm/Support/MathExtras.h b/llvm/include/llvm/Support/MathExtras.h index 775d19a..9570ae6 100644 --- a/llvm/include/llvm/Support/MathExtras.h +++ b/llvm/include/llvm/Support/MathExtras.h @@ -532,6 +532,15 @@ inline double Log2(double Value) { #endif } +/// Return the compile time log base 2 of the specified Value. +/// `kValue` has to be a power of two. +template static constexpr inline uint8_t CTLog2() { + static_assert(kValue > 0 && llvm::isPowerOf2_64(kValue), + "Value is not a valid power of 2"); + return 1 + CTLog2(); +} +template <> constexpr inline uint8_t CTLog2<1>() { return 0; } + /// Return the floor log base 2 of the specified value, -1 if the value is zero. /// (32 bit edition.) /// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2 diff --git a/llvm/lib/Target/AArch64/AArch64StackTagging.cpp b/llvm/lib/Target/AArch64/AArch64StackTagging.cpp index 0c52711..55c7afb 100644 --- a/llvm/lib/Target/AArch64/AArch64StackTagging.cpp +++ b/llvm/lib/Target/AArch64/AArch64StackTagging.cpp @@ -62,7 +62,7 @@ static cl::opt ClMergeInit( static cl::opt ClScanLimit("stack-tagging-merge-init-scan-limit", cl::init(40), cl::Hidden); -static const Align kTagGranuleSize = Align(16); +static constexpr Align kTagGranuleSize = Align::Constant<16>(); namespace { diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp index 0b14359..3d35a61 100644 --- a/llvm/unittests/Support/AlignmentTest.cpp +++ b/llvm/unittests/Support/AlignmentTest.cpp @@ -44,6 +44,16 @@ TEST(AlignmentTest, ValidCTors) { } } +TEST(AlignmentTest, CompileTimeConstant) { + EXPECT_EQ(Align::Constant<1>(), Align(1)); + EXPECT_EQ(Align::Constant<2>(), Align(2)); + EXPECT_EQ(Align::Constant<4>(), Align(4)); + EXPECT_EQ(Align::Constant<8>(), Align(8)); + EXPECT_EQ(Align::Constant<16>(), Align(16)); + EXPECT_EQ(Align::Constant<32>(), Align(32)); + EXPECT_EQ(Align::Constant<64>(), Align(64)); +} + TEST(AlignmentTest, CheckMaybeAlignHasValue) { EXPECT_TRUE(MaybeAlign(1)); EXPECT_TRUE(MaybeAlign(1).hasValue()); diff --git a/llvm/unittests/Support/MathExtrasTest.cpp b/llvm/unittests/Support/MathExtrasTest.cpp index 01c83c9..00d037a 100644 --- a/llvm/unittests/Support/MathExtrasTest.cpp +++ b/llvm/unittests/Support/MathExtrasTest.cpp @@ -203,6 +203,25 @@ TEST(MathExtras, PowerOf2Floor) { EXPECT_EQ(4U, PowerOf2Floor(7U)); } +TEST(MathExtras, CTLog2) { + EXPECT_EQ(CTLog2<1ULL << 0>(), 0); + EXPECT_EQ(CTLog2<1ULL << 1>(), 1); + EXPECT_EQ(CTLog2<1ULL << 2>(), 2); + EXPECT_EQ(CTLog2<1ULL << 3>(), 3); + EXPECT_EQ(CTLog2<1ULL << 4>(), 4); + EXPECT_EQ(CTLog2<1ULL << 5>(), 5); + EXPECT_EQ(CTLog2<1ULL << 6>(), 6); + EXPECT_EQ(CTLog2<1ULL << 7>(), 7); + EXPECT_EQ(CTLog2<1ULL << 8>(), 8); + EXPECT_EQ(CTLog2<1ULL << 9>(), 9); + EXPECT_EQ(CTLog2<1ULL << 10>(), 10); + EXPECT_EQ(CTLog2<1ULL << 11>(), 11); + EXPECT_EQ(CTLog2<1ULL << 12>(), 12); + EXPECT_EQ(CTLog2<1ULL << 13>(), 13); + EXPECT_EQ(CTLog2<1ULL << 14>(), 14); + EXPECT_EQ(CTLog2<1ULL << 15>(), 15); +} + TEST(MathExtras, ByteSwap_32) { EXPECT_EQ(0x44332211u, ByteSwap_32(0x11223344)); EXPECT_EQ(0xDDCCBBAAu, ByteSwap_32(0xAABBCCDD)); -- 2.7.4