[SelectionDAG] Inverted args for PTRADD on getMemBasePlusOffset()

By allowing getMemBasePlusOffset() to know whether its use for regular
ADDs does not take pointer first and offset second, the generation of
PTRADD on enabled targets can be done correctly, with the arguments
inverted.

This modification is to avoid changing the generation of some ADDs,
thus requiring the rewrite of several tests for several architectures.

Author: rgwott

llvm/include/llvm/CodeGen/SelectionDAG.h

@@ -1072,7 +1072,8 @@ class SelectionDAG {
   SDValue getMemBasePlusOffset(SDValue Base, TypeSize Offset, const SDLoc &DL,
                                const SDNodeFlags Flags = SDNodeFlags());
   SDValue getMemBasePlusOffset(SDValue Base, SDValue Offset, const SDLoc &DL,
-                               const SDNodeFlags Flags = SDNodeFlags());
+                               const SDNodeFlags Flags = SDNodeFlags(),
+                               const bool Inverted = false);
 
   /// Create an add instruction with appropriate flags when used for
   /// addressing some offset of an object. i.e. if a load is split into multiple

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

@@ -3970,14 +3970,7 @@ bool SelectionDAGLegalize::ExpandNode(SDNode *Node) {
     else
       Index = DAG.getNode(ISD::MUL, dl, Index.getValueType(), Index,
                           DAG.getConstant(EntrySize, dl, Index.getValueType()));
-    SDValue Addr;
-    if (!DAG.getTarget().shouldPreservePtrArith(
-            DAG.getMachineFunction().getFunction())) {
-      Addr = DAG.getNode(ISD::ADD, dl, Index.getValueType(), Index, Table);
-    } else {
-      // PTRADD always takes the pointer first, so the operands are commuted
-      Addr = DAG.getNode(ISD::PTRADD, dl, Index.getValueType(), Table, Index);
-    }
+    SDValue Addr = DAG.getMemBasePlusOffset(Index, Table, dl, true);
 
     EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
     SDValue LD = DAG.getExtLoad(
@@ -3988,15 +3981,8 @@ bool SelectionDAGLegalize::ExpandNode(SDNode *Node) {
       // For PIC, the sequence is:
       // BRIND(load(Jumptable + index) + RelocBase)
       // RelocBase can be JumpTable, GOT or some sort of global base.
-      if (!DAG.getTarget().shouldPreservePtrArith(
-              DAG.getMachineFunction().getFunction())) {
-        Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr,
-                           TLI.getPICJumpTableRelocBase(Table, DAG));
-      } else {
-        // PTRADD always takes the pointer first, so the operands are commuted
-        Addr = DAG.getNode(ISD::PTRADD, dl, PTy,
-                           TLI.getPICJumpTableRelocBase(Table, DAG), Addr);
-      }
+      Addr = DAG.getMemBasePlusOffset(
+          Addr, TLI.getPICJumpTableRelocBase(Table, DAG), dl);
     }
 
     Tmp1 = TLI.expandIndirectJTBranch(dl, LD.getValue(1), Addr, JTI, DAG);

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

@@ -8062,14 +8062,19 @@ SDValue SelectionDAG::getMemBasePlusOffset(SDValue Base, TypeSize Offset,
 
 SDValue SelectionDAG::getMemBasePlusOffset(SDValue Ptr, SDValue Offset,
                                            const SDLoc &DL,
-                                           const SDNodeFlags Flags) {
+                                           const SDNodeFlags Flags,
+                                           const bool Inverted) {
   assert(Offset.getValueType().isInteger());
   EVT BasePtrVT = Ptr.getValueType();
   if (!this->getTarget().shouldPreservePtrArith(
           this->getMachineFunction().getFunction())) {
     return getNode(ISD::ADD, DL, BasePtrVT, Ptr, Offset, Flags);
   } else {
-    return getNode(ISD::PTRADD, DL, BasePtrVT, Ptr, Offset, Flags);
+    if (Inverted) {
+      return getNode(ISD::PTRADD, DL, BasePtrVT, Offset, Ptr, Flags);
+    } else {
+      return getNode(ISD::PTRADD, DL, BasePtrVT, Ptr, Offset, Flags);
+    }
   }
 }
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

@@ -4499,18 +4499,9 @@ void SelectionDAGBuilder::visitAlloca(const AllocaInst &I) {
   // Round the size of the allocation up to the stack alignment size
   // by add SA-1 to the size. This doesn't overflow because we're computing
   // an address inside an alloca.
-  SDNodeFlags Flags;
-  Flags.setNoUnsignedWrap(true);
-  if (DAG.getTarget().shouldPreservePtrArith(
-          DAG.getMachineFunction().getFunction())) {
-    AllocSize = DAG.getNode(ISD::PTRADD, dl, AllocSize.getValueType(),
-                            DAG.getConstant(StackAlignMask, dl, IntPtr),
-                            AllocSize, SDNodeFlags::NoUnsignedWrap);
-  } else {
-    AllocSize = DAG.getNode(ISD::ADD, dl, AllocSize.getValueType(), AllocSize,
-                            DAG.getConstant(StackAlignMask, dl, IntPtr),
-                            SDNodeFlags::NoUnsignedWrap);
-  }
+  AllocSize = DAG.getMemBasePlusOffset(
+      AllocSize, DAG.getConstant(StackAlignMask, dl, IntPtr), dl,
+      SDNodeFlags::NoUnsignedWrap, true);
 
   // Mask out the low bits for alignment purposes.
   AllocSize = DAG.getNode(ISD::AND, dl, AllocSize.getValueType(), AllocSize,