Revert "[Alignment][NFC] Allow constexpr Align"

This reverts commit b3af236fb5fc6e50fcc1b54d868f0bff557f3fb1.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@373619 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Support/Alignment.h b/include/llvm/Support/Alignment.h
index f94d7cdc9a14e00c6f008dda2d2a8d6af19b56ab..3d8a4235b0e654ad5fb677b43eb32fab82734cb3 100644 (file)
--- a/include/llvm/Support/Alignment.h
+++ b/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`.
-  constexpr Align(const Align &Other) = default;
-  constexpr Align &operator=(const Align &Other) = default;
-  constexpr Align(Align &&Other) = default;
-  constexpr Align &operator=(Align &&Other) = default;
+  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");
@@ -80,24 +80,6 @@ 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 <uint64_t kValue> constexpr static Align Constant() {
-    static_assert(kValue > 0 && llvm::isPowerOf2_64(kValue),
-                  "Not a valid alignment");
-    Align A;
-    A.ShiftValue = CTLog2<kValue>();
-    return A;
-  }
 };
 
 /// Treats the value 0 as a 1, so Align is always at least 1.

diff --git a/include/llvm/Support/MathExtras.h b/include/llvm/Support/MathExtras.h
index 9570ae67a9d15c7d0573ebcdeb2fa8611063d2c8..775d19a698f4973875c54347b6deb6c4d3c81c81 100644 (file)
--- a/include/llvm/Support/MathExtras.h
+++ b/include/llvm/Support/MathExtras.h
@@ -532,15 +532,6 @@ 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 <uint64_t kValue> 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<kValue / 2>();
-}
-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/lib/Target/AArch64/AArch64StackTagging.cpp b/lib/Target/AArch64/AArch64StackTagging.cpp
index 55c7afbd69f7d5215cd42f36e1f8315469ab2eac..0c52711a8d7e9bbb7bf8d6cd6a72291d63a16c8e 100644 (file)
--- a/lib/Target/AArch64/AArch64StackTagging.cpp
+++ b/lib/Target/AArch64/AArch64StackTagging.cpp
@@ -62,7 +62,7 @@ static cl::opt<bool> ClMergeInit(
 static cl::opt<unsigned> ClScanLimit("stack-tagging-merge-init-scan-limit",
                                      cl::init(40), cl::Hidden);
 
-static constexpr Align kTagGranuleSize = Align::Constant<16>();
+static const Align kTagGranuleSize = Align(16);
 
 namespace {
 

diff --git a/unittests/Support/AlignmentTest.cpp b/unittests/Support/AlignmentTest.cpp
index 3d35a612b8325d0f969e6f6a0e4e65f8203cea30..0b1435912b93020bd576007a89126f4645952fc9 100644 (file)
--- a/unittests/Support/AlignmentTest.cpp
+++ b/unittests/Support/AlignmentTest.cpp
@@ -44,16 +44,6 @@ 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/unittests/Support/MathExtrasTest.cpp b/unittests/Support/MathExtrasTest.cpp
index 00d037ad110beca08d47a297f186191258f9ea6a..01c83c9e14d3f7250af93ff88d562446d7f5c0fc 100644 (file)
--- a/unittests/Support/MathExtrasTest.cpp
+++ b/unittests/Support/MathExtrasTest.cpp
@@ -203,25 +203,6 @@ 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));