[Alignment][NFC] Change internal representation of TargetLowering.h

[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

[courbet]

Please change the name to [Alignment][NFC]

llvm/trunk/include/llvm/CodeGen/TargetLowering.h

   }
 
   virtual bool needsFixedCatchObjects() const {
     report_fatal_error("Funclet EH is not implemented for this target");
   }
 
   /// Return the minimum stack alignment of an argument.
   unsigned getMinStackArgumentAlignment() const {
-    return MinStackArgumentAlignment;
+    return MinStackArgumentAlignment.value();
   }
 
   /// Return the minimum function alignment.
   unsigned getMinFunctionLogAlignment() const {
-    return MinFunctionLogAlignment;
+    return Log2(MinFunctionAlignment);
   }
 
   /// Return the preferred function alignment.
   unsigned getPrefFunctionLogAlignment() const {
-    return PrefFunctionLogAlignment;
+    return Log2(PrefFunctionAlignment);
   }
 
   /// Return the preferred loop alignment.
   virtual unsigned getPrefLoopLogAlignment(MachineLoop *ML = nullptr) const {
-    return PrefLoopLogAlignment;
+    return Log2(PrefLoopAlignment);
   }
 
   /// Should loops be aligned even when the function is marked OptSize (but not
   /// MinSize).
   virtual bool alignLoopsWithOptSize() const {
     return false;
   }
 
protected:
   /// PerformDAGCombine virtual method.
   void setTargetDAGCombine(ISD::NodeType NT) {
     assert(unsigned(NT >> 3) < array_lengthof(TargetDAGCombineArray));
     TargetDAGCombineArray[NT >> 3] |= 1 << (NT&7);
   }
 
   /// Set the target's minimum function alignment (in log2(bytes))
   void setMinFunctionLogAlignment(unsigned LogAlign) {
-    MinFunctionLogAlignment = LogAlign;
+    MinFunctionAlignment = llvm::Align(1ULL << LogAlign);
   }
 
   /// Set the target's preferred function alignment.  This should be set if
   /// there is a performance benefit to higher-than-minimum alignment (in
   /// log2(bytes))
   void setPrefFunctionLogAlignment(unsigned LogAlign) {
-    PrefFunctionLogAlignment = LogAlign;
+    PrefFunctionAlignment = llvm::Align(1ULL << LogAlign);
   }
 
   /// Set the target's preferred loop alignment. Default alignment is zero, it
   /// means the target does not care about loop alignment.  The alignment is
   /// specified in log2(bytes). The target may also override
   /// getPrefLoopAlignment to provide per-loop values.
   void setPrefLoopLogAlignment(unsigned LogAlign) {
-    PrefLoopLogAlignment = LogAlign;
+    PrefLoopAlignment = llvm::Align(1ULL << LogAlign);
   }
 
   /// Set the minimum stack alignment of an argument.
   void setMinStackArgumentAlignment(unsigned Align) {
-    MinStackArgumentAlignment = Align;
+    MinStackArgumentAlignment = llvm::Align(Align);
   }
 
   /// Set the maximum atomic operation size supported by the
   /// backend. Atomic operations greater than this size (as well as
   /// ones that are not naturally aligned), will be expanded by
   /// AtomicExpandPass into an __atomic_* library call.
   void setMaxAtomicSizeInBitsSupported(unsigned SizeInBits) {
     MaxAtomicSizeInBitsSupported = SizeInBits;
private:
   /// when the element type is wider than i1. See getBooleanContents.
   BooleanContent BooleanVectorContents;
 
   /// The target scheduling preference: shortest possible total cycles or lowest
   /// register usage.
   Sched::Preference SchedPreferenceInfo;
 
   /// The minimum alignment that any argument on the stack needs to have.
-  unsigned MinStackArgumentAlignment;
+  llvm::Align MinStackArgumentAlignment;
 
   /// The minimum function alignment (used when optimizing for size, and to
   /// prevent explicitly provided alignment from leading to incorrect code).
-  unsigned MinFunctionLogAlignment;
+  llvm::Align MinFunctionAlignment;
 
   /// The preferred function alignment (used when alignment unspecified and
   /// optimizing for speed).
-  unsigned PrefFunctionLogAlignment;
+  llvm::Align PrefFunctionAlignment;
 
   /// The preferred loop alignment (in log2 bot in bytes).
-  unsigned PrefLoopLogAlignment;
+  llvm::Align PrefLoopAlignment;
 
   /// Size in bits of the maximum atomics size the backend supports.
   /// Accesses larger than this will be expanded by AtomicExpandPass.
   unsigned MaxAtomicSizeInBitsSupported;
 
   /// Size in bits of the minimum cmpxchg or ll/sc operation the
   /// backend supports.
   unsigned MinCmpXchgSizeInBits;

llvm/trunk/lib/CodeGen/TargetLoweringBase.cpp

TargetLoweringBase::TargetLoweringBase(const TargetMachine &tm) : TM(tm) {
   JumpIsExpensive = JumpIsExpensiveOverride;
   PredictableSelectIsExpensive = false;
   EnableExtLdPromotion = false;
   StackPointerRegisterToSaveRestore = 0;
   BooleanContents = UndefinedBooleanContent;
   BooleanFloatContents = UndefinedBooleanContent;
   BooleanVectorContents = UndefinedBooleanContent;
   SchedPreferenceInfo = Sched::ILP;
-  MinFunctionLogAlignment = 0;
-  PrefFunctionLogAlignment = 0;
-  PrefLoopLogAlignment = 0;
   GatherAllAliasesMaxDepth = 18;
-  MinStackArgumentAlignment = 1;
   // TODO: the default will be switched to 0 in the next commit, along
   // with the Target-specific changes necessary.
   MaxAtomicSizeInBitsSupported = 1024;
 
   MinCmpXchgSizeInBits = 0;
   SupportsUnalignedAtomics = false;
 
   std::fill(std::begin(LibcallRoutineNames), std::end(LibcallRoutineNames), nullptr);