[LLVM][Alignment] Introduce Alignment Type in DataLayout

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

Reviewers: courbet, jfb, jakehehrlich

Subscribers: hiraditya, dexonsmith, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D65521

Make getFunctionPtrAlign() return MaybeAlign

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

diff --git a/include/llvm/IR/DataLayout.h b/include/llvm/IR/DataLayout.h
index ac9770a15120d929be94d72462acd0d00aef5441..175e779fc986ce36565e8ee9711c7094823c4963 100644 (file)
--- a/include/llvm/IR/DataLayout.h
+++ b/include/llvm/IR/DataLayout.h
@@ -29,6 +29,7 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Alignment.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
@@ -120,10 +121,10 @@ private:
   bool BigEndian;
 
   unsigned AllocaAddrSpace;
-  unsigned StackNaturalAlign;
+  MaybeAlign StackNaturalAlign;
   unsigned ProgramAddrSpace;
 
-  unsigned FunctionPtrAlign;
+  MaybeAlign FunctionPtrAlign;
   FunctionPtrAlignType TheFunctionPtrAlignType;
 
   enum ManglingModeT {
@@ -261,17 +262,17 @@ public:
   bool isIllegalInteger(uint64_t Width) const { return !isLegalInteger(Width); }
 
   /// Returns true if the given alignment exceeds the natural stack alignment.
-  bool exceedsNaturalStackAlignment(unsigned Align) const {
-    return (StackNaturalAlign != 0) && (Align > StackNaturalAlign);
+  bool exceedsNaturalStackAlignment(llvm::Align Align) const {
+    return StackNaturalAlign && (Align > StackNaturalAlign);
   }
 
-  unsigned getStackAlignment() const { return StackNaturalAlign; }
+  unsigned getStackAlignment() const { return StackNaturalAlign ? StackNaturalAlign->value() : 0; }
   unsigned getAllocaAddrSpace() const { return AllocaAddrSpace; }
 
   /// Returns the alignment of function pointers, which may or may not be
   /// related to the alignment of functions.
   /// \see getFunctionPtrAlignType
-  unsigned getFunctionPtrAlign() const { return FunctionPtrAlign; }
+  MaybeAlign getFunctionPtrAlign() const { return FunctionPtrAlign; }
 
   /// Return the type of function pointer alignment.
   /// \see getFunctionPtrAlign

diff --git a/lib/CodeGen/GlobalISel/CombinerHelper.cpp b/lib/CodeGen/GlobalISel/CombinerHelper.cpp
index 1ae454f4bd4570a7561616fb0d6ae17477907d85..373d52fd1d46421af8923f2788ca2abd2bf1865c 100644 (file)
--- a/lib/CodeGen/GlobalISel/CombinerHelper.cpp
+++ b/lib/CodeGen/GlobalISel/CombinerHelper.cpp
@@ -698,7 +698,7 @@ bool CombinerHelper::optimizeMemcpy(MachineInstr &MI, Register Dst,
     const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
     if (!TRI->needsStackRealignment(MF))
       while (NewAlign > Align &&
-             DL.exceedsNaturalStackAlignment(NewAlign))
+             DL.exceedsNaturalStackAlignment(llvm::Align(NewAlign)))
           NewAlign /= 2;
 
     if (NewAlign > Align) {
@@ -804,7 +804,7 @@ bool CombinerHelper::optimizeMemmove(MachineInstr &MI, Register Dst,
     const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
     if (!TRI->needsStackRealignment(MF))
       while (NewAlign > Align &&
-             DL.exceedsNaturalStackAlignment(NewAlign))
+             DL.exceedsNaturalStackAlignment(llvm::Align(NewAlign)))
           NewAlign /= 2;
 
     if (NewAlign > Align) {

diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index 40f97eeeb79d62daeee4acd642d0295233cd4e15..9594dedb44bb5a00e8b94789208d5c3a9709ed57 100644 (file)
--- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -5804,7 +5804,7 @@ static SDValue getMemcpyLoadsAndStores(SelectionDAG &DAG, const SDLoc &dl,
     const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
     if (!TRI->needsStackRealignment(MF))
       while (NewAlign > Align &&
-             DL.exceedsNaturalStackAlignment(NewAlign))
+             DL.exceedsNaturalStackAlignment(llvm::Align(NewAlign)))
           NewAlign /= 2;
 
     if (NewAlign > Align) {

diff --git a/lib/IR/DataLayout.cpp b/lib/IR/DataLayout.cpp
index 6e0ebbd4a730ba5cdbdb41328129119f224a84af..ab90388fae3ca1d80b2517b0063d8aadfa83704f 100644 (file)
--- a/lib/IR/DataLayout.cpp
+++ b/lib/IR/DataLayout.cpp
@@ -182,9 +182,9 @@ void DataLayout::reset(StringRef Desc) {
   LayoutMap = nullptr;
   BigEndian = false;
   AllocaAddrSpace = 0;
-  StackNaturalAlign = 0;
+  StackNaturalAlign.reset();
   ProgramAddrSpace = 0;
-  FunctionPtrAlign = 0;
+  FunctionPtrAlign.reset();
   TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
   ManglingMode = MM_None;
   NonIntegralAddressSpaces.clear();
@@ -378,7 +378,7 @@ void DataLayout::parseSpecifier(StringRef Desc) {
       }
       break;
     case 'S': { // Stack natural alignment.
-      StackNaturalAlign = inBytes(getInt(Tok));
+      StackNaturalAlign = MaybeAlign(inBytes(getInt(Tok)));
       break;
     }
     case 'F': {
@@ -394,7 +394,7 @@ void DataLayout::parseSpecifier(StringRef Desc) {
                            "datalayout string");
       }
       Tok = Tok.substr(1);
-      FunctionPtrAlign = inBytes(getInt(Tok));
+      FunctionPtrAlign = MaybeAlign(inBytes(getInt(Tok)));
       break;
     }
     case 'P': { // Function address space.

diff --git a/lib/IR/Value.cpp b/lib/IR/Value.cpp
index 763bc2099ef3e7b4071d65835421dacfa9231ca5..b3dcaee766c80e7f45e134fc3dd955db3a5f3086 100644 (file)
--- a/lib/IR/Value.cpp
+++ b/lib/IR/Value.cpp
@@ -681,11 +681,13 @@ unsigned Value::getPointerAlignment(const DataLayout &DL) const {
   unsigned Align = 0;
   if (auto *GO = dyn_cast<GlobalObject>(this)) {
     if (isa<Function>(GO)) {
+      MaybeAlign FunctionPtrAlign = DL.getFunctionPtrAlign();
+      unsigned Align = FunctionPtrAlign ? FunctionPtrAlign->value() : 0;
       switch (DL.getFunctionPtrAlignType()) {
       case DataLayout::FunctionPtrAlignType::Independent:
-        return DL.getFunctionPtrAlign();
+        return Align;
       case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
-        return std::max(DL.getFunctionPtrAlign(), GO->getAlignment());
+        return std::max(Align, GO->getAlignment());
       }
     }
     Align = GO->getAlignment();

diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index 725bc70c9efb04343ff5baa24417073531d6cd88..68443c15a7822fe540aead79c36984d0c531cc67 100644 (file)
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -1152,7 +1152,7 @@ static unsigned enforceKnownAlignment(Value *V, unsigned Align,
 
     // If the preferred alignment is greater than the natural stack alignment
     // then don't round up. This avoids dynamic stack realignment.
-    if (DL.exceedsNaturalStackAlignment(PrefAlign))
+    if (DL.exceedsNaturalStackAlignment(llvm::Align(PrefAlign)))
       return Align;
     AI->setAlignment(PrefAlign);
     return PrefAlign;

diff --git a/unittests/IR/DataLayoutTest.cpp b/unittests/IR/DataLayoutTest.cpp
index e7ed70b7de5d54acc03057383f66e0082758db24..e24e8e045dbd7c6ea85bb053485799fc1620262e 100644 (file)
--- a/unittests/IR/DataLayoutTest.cpp
+++ b/unittests/IR/DataLayoutTest.cpp
@@ -14,15 +14,15 @@ using namespace llvm;
 namespace {
 
 TEST(DataLayoutTest, FunctionPtrAlign) {
-  EXPECT_EQ(0U, DataLayout("").getFunctionPtrAlign());
-  EXPECT_EQ(1U, DataLayout("Fi8").getFunctionPtrAlign());
-  EXPECT_EQ(2U, DataLayout("Fi16").getFunctionPtrAlign());
-  EXPECT_EQ(4U, DataLayout("Fi32").getFunctionPtrAlign());
-  EXPECT_EQ(8U, DataLayout("Fi64").getFunctionPtrAlign());
-  EXPECT_EQ(1U, DataLayout("Fn8").getFunctionPtrAlign());
-  EXPECT_EQ(2U, DataLayout("Fn16").getFunctionPtrAlign());
-  EXPECT_EQ(4U, DataLayout("Fn32").getFunctionPtrAlign());
-  EXPECT_EQ(8U, DataLayout("Fn64").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(0), DataLayout("").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(1), DataLayout("Fi8").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(2), DataLayout("Fi16").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(4), DataLayout("Fi32").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(8), DataLayout("Fi64").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(1), DataLayout("Fn8").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(2), DataLayout("Fn16").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(4), DataLayout("Fn32").getFunctionPtrAlign());
+  EXPECT_EQ(MaybeAlign(8), DataLayout("Fn64").getFunctionPtrAlign());
   EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \
       DataLayout("").getFunctionPtrAlignType());
   EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \