[LLVM][Alignment] Introduce Alignment In GlobalObject

[gchatelet]

Summary

This is patch is part of a serie 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

[jfb]

llvm/include/llvm/IR/GlobalObject.h

67 ↗

(On Diff #213364)

Can you leave a FIXME on this line instead of the comment above?

llvm/include/llvm/Support/Alignment.h

104 ↗

(On Diff #213364)

neither / nor?

[gchatelet]

Added FIXME and used neither instead of not

llvm/trunk/include/llvm/IR/GlobalObject.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_GLOBALOBJECT_H
 #define LLVM_IR_GLOBALOBJECT_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/Alignment.h"
 #include <string>
 #include <utility>
 
 namespace llvm {
 
 class Comdat;
 class MDNode;
 class Metadata;
private:
   static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
 
 public:
   GlobalObject(const GlobalObject &) = delete;
 
   unsigned getAlignment() const {
     unsigned Data = getGlobalValueSubClassData();
     unsigned AlignmentData = Data & AlignmentMask;
-    return (1u << AlignmentData) >> 1;
+    MaybeAlign Align = decodeMaybeAlign(AlignmentData);
+    return Align ? Align->value() : 0;
   }
+
+  /// FIXME: Remove this setter once the migration to MaybeAlign is over.
   void setAlignment(unsigned Align);
+  void setAlignment(MaybeAlign Align);
 
   unsigned getGlobalObjectSubClassData() const {
     unsigned ValueData = getGlobalValueSubClassData();
     return ValueData >> GlobalObjectBits;
   }
 
   void setGlobalObjectSubClassData(unsigned Val) {
     unsigned OldData = getGlobalValueSubClassData();

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

public:
   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");
+           "Alignment is neither 0 nor 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(); }
 };
 

llvm/trunk/lib/IR/Globals.cpp

 }
 
 unsigned GlobalValue::getAddressSpace() const {
   PointerType *PtrTy = getType();
   return PtrTy->getAddressSpace();
 }
 
 void GlobalObject::setAlignment(unsigned Align) {
-  assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
-  assert(Align <= MaximumAlignment &&
+  setAlignment(MaybeAlign(Align));
+}
+
+void GlobalObject::setAlignment(MaybeAlign Align) {
+  assert(!Align || Align <= MaximumAlignment &&
                        "Alignment is greater than MaximumAlignment!");
-  unsigned AlignmentData = Log2_32(Align) + 1;
+  unsigned AlignmentData = encode(Align);
   unsigned OldData = getGlobalValueSubClassData();
   setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
-  assert(getAlignment() == Align && "Alignment representation error!");
+  assert(MaybeAlign(getAlignment()) == Align &&
+         "Alignment representation error!");
 }
 
 void GlobalObject::copyAttributesFrom(const GlobalObject *Src) {
   GlobalValue::copyAttributesFrom(Src);
   setAlignment(Src->getAlignment());
   setSection(Src->getSection());
 }
 

llvm/trunk/unittests/IR/ValueTest.cpp

TEST(GlobalTest, AlignDeath) {
   LLVMContext Ctx;
   std::unique_ptr<Module> M(new Module("TestModule", Ctx));
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   GlobalVariable *Var =
       new GlobalVariable(*M, Int32Ty, true, GlobalValue::ExternalLinkage,
                          Constant::getAllOnesValue(Int32Ty), "var", nullptr,
                          GlobalVariable::NotThreadLocal, 1);
 
-  EXPECT_DEATH(Var->setAlignment(536870913U), "Alignment is not a power of 2");
+  EXPECT_DEATH(Var->setAlignment(536870913U),
+               "Alignment is neither 0 nor a power of 2");
   EXPECT_DEATH(Var->setAlignment(1073741824U),
                "Alignment is greater than MaximumAlignment");
 }
 #endif
 #endif
 
 TEST(ValueTest, printSlots) {
   // Check that Value::print() and Value::printAsOperand() work with and

llvm/trunk/unittests/Support/AlignmentTest.cpp

TEST(AlignmentDeathTest, Division) {
   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(AlignmentDeathTest, InvalidCTors) {
   EXPECT_DEATH((Align(0)), "Value must not be 0");
   for (uint64_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");
+    EXPECT_DEATH((MaybeAlign(Value)),
+                 "Alignment is neither 0 nor a power of 2");
   }
 }
 
 TEST(AlignmentDeathTest, ComparisonsWithZero) {
   for (uint64_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");