[Alignment][NFC] Allow constexpr Align

[gchatelet]

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

[thakis]

This breaks building with gcc 5.3 (the system compiler on Ubuntu Xenial LTS), and supported by LLVM per https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain

FAILED: lib/MC/CMakeFiles/LLVMMC.dir/MCAssembler.cpp.o 
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc530trusty/bin/g++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Ilib/MC -I/b/s/w/ir/cache/builder/src/third_party/llvm/llvm/lib/MC -I/usr/include/libxml2 -Iinclude -I/b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include -DLLVM_FORCE_HEAD_REVISION -fvisibility-inlines-hidden -Werror=date-time -std=c++14 -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -fdiagnostics-color -ffunction-sections -fdata-sections -O3    -UNDEBUG  -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-rtti -MD -MT lib/MC/CMakeFiles/LLVMMC.dir/MCAssembler.cpp.o -MF lib/MC/CMakeFiles/LLVMMC.dir/MCAssembler.cpp.o.d -o lib/MC/CMakeFiles/LLVMMC.dir/MCAssembler.cpp.o -c /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/lib/MC/MCAssembler.cpp
In file included from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/MC/MCSection.h:20:0,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/MC/MCDwarf.h:22,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/MC/MCAssembler.h:20,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/lib/MC/MCAssembler.cpp:9:
/b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/Support/Alignment.h:62:20: error: explicitly defaulted function ‘constexpr llvm::Align& llvm::Align::operator=(const llvm::Align&)’ cannot be declared as constexpr because the implicit declaration is not constexpr:
   constexpr Align &operator=(const Align &Other) = default;
                    ^
/b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/Support/Alignment.h:64:20: error: explicitly defaulted function ‘constexpr llvm::Align& llvm::Align::operator=(llvm::Align&&)’ cannot be declared as constexpr because the implicit declaration is not constexpr:
   constexpr Align &operator=(Align &&Other) = default;
                    ^

Can you take a look, and it's difficult to fix, revert for now?

[gchatelet]

In D68329#1693070, @thakis wrote:

This breaks building with gcc 5.3 (the system compiler on Ubuntu Xenial LTS), and supported by LLVM per https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain

Thx for reporting, from stackoverflow it looks like a GCC bug.
I'm not sure it can be fixed so I'll revert the patch for now.

[gchatelet]

In D68329#1693086, @gchatelet wrote:

In D68329#1693070, @thakis wrote:

This breaks building with gcc 5.3 (the system compiler on Ubuntu Xenial LTS), and supported by LLVM per https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain

Thx for reporting, from stackoverflow it looks like a GCC bug.
I'm not sure it can be fixed so I'll revert the patch for now.

reverted in rL373619

llvm/trunk/include/llvm/Support/Alignment.h

private:
   friend unsigned encode(struct MaybeAlign A);
   friend struct MaybeAlign decodeMaybeAlign(unsigned Value);
 
 public:
   /// Default is byte-aligned.
   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");
     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; }
 
   /// Returns a default constructed Align which corresponds to no alignment.
   /// This is useful to test for unalignment as it conveys clear semantic.
   /// `if (A != Align::None())`
   /// 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.
 inline Align assumeAligned(uint64_t Value) {
   return Value ? Align(Value) : Align();
 }
 
 /// This struct is a compact representation of a valid (power of two) or

llvm/trunk/include/llvm/Support/MathExtras.h

 inline double Log2(double Value) {
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 18
   return __builtin_log(Value) / __builtin_log(2.0);
 #else
   return log2(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
 inline unsigned Log2_32(uint32_t Value) {
   return 31 - countLeadingZeros(Value);
 }
 
 /// Return the floor log base 2 of the specified value, -1 if the value is zero.

llvm/trunk/lib/Target/AArch64/AArch64StackTagging.cpp

 
 static cl::opt<bool> ClMergeInit(
     "stack-tagging-merge-init", cl::Hidden, cl::init(true), cl::ZeroOrMore,
     cl::desc("merge stack variable initializers with tagging when possible"));
 
 static cl::opt<unsigned> 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 {
 
 class InitializerBuilder {
   uint64_t Size;
   const DataLayout *DL;
   Value *BasePtr;
   Function *SetTagFn;

llvm/trunk/unittests/Support/AlignmentTest.cpp

 
 TEST(AlignmentTest, ValidCTors) {
   for (uint64_t Value : getValidAlignments()) {
     EXPECT_EQ(Align(Value).value(), Value);
     EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
   }
 }
 
+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());
   EXPECT_FALSE(MaybeAlign(0));
   EXPECT_FALSE(MaybeAlign(0).hasValue());
   EXPECT_FALSE(MaybeAlign());
   EXPECT_FALSE(MaybeAlign().hasValue());
 }

llvm/trunk/unittests/Support/MathExtrasTest.cpp

 }
 
 TEST(MathExtras, PowerOf2Floor) {
   EXPECT_EQ(0U, PowerOf2Floor(0U));
   EXPECT_EQ(8U, PowerOf2Floor(8U));
   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));
 }
 
 TEST(MathExtras, ByteSwap_64) {
   EXPECT_EQ(0x8877665544332211ULL, ByteSwap_64(0x1122334455667788LL));
   EXPECT_EQ(0x1100FFEEDDCCBBAAULL, ByteSwap_64(0xAABBCCDDEEFF0011LL));