[SelectionDAG] Fold more offsets into GlobalAddresses

[sunfish]

Summary

SelectionDAG currently misses opportunities to fold constants into GlobalAddresses in several areas. For example, given (add (add GA, c1), y), it often reassociates to (add (add GA, y), c1), missing the opportunity to create (add GA+c, y). This isn't often visible on targets such as X86 which effectively reassociate adds in their complex address-mode folding logic, however it is currently visible on WebAssembly since it currently has very simple address mode folding code that doesn't reassociate anything.

The attached patch fixes this by making SelectionDAG fold offsets into GlobalAddresses at the same times that it folds constants together, so that it doesn't miss any opportunities to perform such folding.

[sunfish]

Ping.

[arsenm]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

397

Why does this need to be added here? I don't see a new use of this

782–783

The order of these checks should be swapped

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

3269–3272

Ditto

3276

This should be int64_t, since you use getSExtValue and negate it below

[sunfish]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

397

It calls isConstantIntBuildVectorOrConstantInt, which is also being made a member function, so that we don't have to pass the TLI around. Or would it be better to just explicitly pass the TLI around so that these don't need to be member functions?

782–783

Fixed.

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

3269–3272

Fixed.

3276

We need to do the negate and the add as unsigned to avoid undefined behavior. But I can make the variable signed and just cast it at its uses. Fixed.

[sunfish]

• address review comments
• rebase on trunk

[arsenm]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

397

I think it would be better to move this to either SelectionDAG (or maybe TLI). It should be generally useful to targets

[arsenm]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

397

By this I mean isConstantIntBuildVectorOrConstantInt, not MatchRotateHalf

[sunfish]

• Move isConstantIntBuildVectorOrConstantInt to SelectionDAG.

[sunfish]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

400

Done.

[arsenm]

LGTM

[sunfish]

Thanks!

include/llvm/CodeGen/SelectionDAG.h

#endif
   /// specified value type.  If minAlign is specified, the slot size will have
   /// at least that alignment.
   SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1);
 
   /// Create a stack temporary suitable for holding
   /// either of the specified value types.
   SDValue CreateStackTemporary(EVT VT1, EVT VT2);
 
+  SDValue FoldSymbolOffset(unsigned Opcode, EVT VT,
+                           const GlobalAddressSDNode *GA,
+                           const SDNode *N2);
+
   SDValue FoldConstantArithmetic(unsigned Opcode, SDLoc DL, EVT VT,
                                  SDNode *Cst1, SDNode *Cst2);
 
   SDValue FoldConstantArithmetic(unsigned Opcode, SDLoc DL, EVT VT,
                                  const ConstantSDNode *Cst1,
                                  const ConstantSDNode *Cst2);
 
   SDValue FoldConstantVectorArithmetic(unsigned Opcode, SDLoc DL,

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

private:
     /// Walk up chain skipping non-aliasing memory nodes, looking for a better
     /// chain (aliasing node.)
     SDValue FindBetterChain(SDNode *N, SDValue Chain);
 
     /// Do FindBetterChain for a store and any possibly adjacent stores on
     /// consecutive chains.
     bool findBetterNeighborChains(StoreSDNode *St);
 
+    /// Test whether the given value is a constant int or similar node.
+    SDNode *isConstantIntBuildVectorOrConstantInt(SDValue N);
+
+    /// Match "(X shl/srl V1) & V2" where V2 may not be present.
+    bool MatchRotateHalf(SDValue Op, SDValue &Shift, SDValue &Mask);
+
     /// Holds a pointer to an LSBaseSDNode as well as information on where it
     /// is located in a sequence of memory operations connected by a chain.
     struct MemOpLink {
       MemOpLink (LSBaseSDNode *N, int64_t Offset, unsigned Seq):
       MemNode(N), OffsetFromBase(Offset), SequenceNum(Seq) { }
       // Ptr to the mem node.
       LSBaseSDNode *MemNode;
       // Offset from the base ptr.
       int64_t OffsetFromBase;
       // What is the sequence number of this mem node.
static bool isConstantSplatVector(SDNode *N, APInt& SplatValue) {
   EVT EltVT = N->getValueType(0).getVectorElementType();
   return (C->isConstantSplat(SplatValue, SplatUndef, SplatBitSize,
                              HasAnyUndefs) &&
           EltVT.getSizeInBits() >= SplatBitSize);
 }
 
 // \brief Returns the SDNode if it is a constant integer BuildVector
 // or constant integer.
-static SDNode *isConstantIntBuildVectorOrConstantInt(SDValue N) {
+SDNode *DAGCombiner::isConstantIntBuildVectorOrConstantInt(SDValue N) {
   if (isa<ConstantSDNode>(N))
     return N.getNode();
   if (ISD::isBuildVectorOfConstantSDNodes(N.getNode()))
     return N.getNode();
+  // Treat a GlobalAddress supporting constant offset folding as a
+  // constant integer.
+  if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(N))
+    if (GA->getOpcode() == ISD::GlobalAddress &&
+        TLI.isOffsetFoldingLegal(GA))
+      return GA;
   return nullptr;
 }
 
 // \brief Returns the SDNode if it is a constant float BuildVector
 // or constant float.
 static SDNode *isConstantFPBuildVectorOrConstantFP(SDValue N) {
   if (isa<ConstantFPSDNode>(N))
     return N.getNode();
if (ISD::isBuildVectorAllZeros(N0.getNode()))
       return N1;
   }
 
   // fold (add x, undef) -> undef
   if (N0.getOpcode() == ISD::UNDEF)
     return N0;
   if (N1.getOpcode() == ISD::UNDEF)
     return N1;
-  // fold (add c1, c2) -> c1+c2
-  ConstantSDNode *N0C = getAsNonOpaqueConstant(N0);
-  ConstantSDNode *N1C = getAsNonOpaqueConstant(N1);
-  if (N0C && N1C)
-    return DAG.FoldConstantArithmetic(ISD::ADD, SDLoc(N), VT, N0C, N1C);
+  if (isConstantIntBuildVectorOrConstantInt(N0)) {
     // canonicalize constant to RHS
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
-     !isConstantIntBuildVectorOrConstantInt(N1))
+    if (!isConstantIntBuildVectorOrConstantInt(N1))
       return DAG.getNode(ISD::ADD, SDLoc(N), VT, N1, N0);
+    // fold (add c1, c2) -> c1+c2
+    return DAG.FoldConstantArithmetic(ISD::ADD, SDLoc(N), VT,
+                                      N0.getNode(), N1.getNode());
+  }
   // fold (add x, 0) -> x
   if (isNullConstant(N1))
     return N0;
-  // fold (add Sym, c) -> Sym+c
-  if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(N0))
-    if (!LegalOperations && TLI.isOffsetFoldingLegal(GA) && N1C &&
-        GA->getOpcode() == ISD::GlobalAddress)
-      return DAG.getGlobalAddress(GA->getGlobal(), SDLoc(N1C), VT,
-                                  GA->getOffset() +
-                                    (uint64_t)N1C->getSExtValue());
   // fold ((c1-A)+c2) -> (c1+c2)-A
-  if (N1C && N0.getOpcode() == ISD::SUB)
+  if (ConstantSDNode *N1C = getAsNonOpaqueConstant(N1)) {
+    if (N0.getOpcode() == ISD::SUB)
       if (ConstantSDNode *N0C = getAsNonOpaqueConstant(N0.getOperand(0))) {
         SDLoc DL(N);
         return DAG.getNode(ISD::SUB, DL, VT,
                            DAG.getConstant(N1C->getAPIntValue()+
                                            N0C->getAPIntValue(), DL, VT),
                            N0.getOperand(1));
       }
+  }
   // reassociate add
   if (SDValue RADD = ReassociateOps(ISD::ADD, SDLoc(N), N0, N1))
     return RADD;
   // fold ((0-A) + B) -> B-A
   if (N0.getOpcode() == ISD::SUB && isNullConstant(N0.getOperand(0)))
     return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1, N0.getOperand(1));
   // fold (A + (0-B)) -> A-B
   if (N1.getOpcode() == ISD::SUB && isNullConstant(N1.getOperand(0)))
if (VT.isVector()) {
     if (ISD::isBuildVectorAllZeros(N1.getNode()))
       return N0;
   }
 
   // fold (sub x, x) -> 0
   // FIXME: Refactor this and xor and other similar operations together.
   if (N0 == N1)
     return tryFoldToZero(SDLoc(N), TLI, VT, DAG, LegalOperations, LegalTypes);
+  if (isConstantIntBuildVectorOrConstantInt(N0) &&
+      isConstantIntBuildVectorOrConstantInt(N1)) {
     // fold (sub c1, c2) -> c1-c2
+    return DAG.FoldConstantArithmetic(ISD::SUB, SDLoc(N), VT,
+                                      N0.getNode(), N1.getNode());
+  }
   ConstantSDNode *N0C = getAsNonOpaqueConstant(N0);
   ConstantSDNode *N1C = getAsNonOpaqueConstant(N1);
-  if (N0C && N1C)
-    return DAG.FoldConstantArithmetic(ISD::SUB, SDLoc(N), VT, N0C, N1C);
   // fold (sub x, c) -> (add x, -c)
   if (N1C) {
     SDLoc DL(N);
     return DAG.getNode(ISD::ADD, DL, VT, N0,
                        DAG.getConstant(-N1C->getAPIntValue(), DL, VT));
   }
   // Canonicalize (sub -1, x) -> ~x, i.e. (xor x, -1)
   if (isAllOnesConstant(N0))
SDValue DAGCombiner::visitOR(SDNode *N) {
   if (!VT.isVector() &&
       SimplifyDemandedBits(SDValue(N, 0)))
     return SDValue(N, 0);
 
   return SDValue();
 }
 
 /// Match "(X shl/srl V1) & V2" where V2 may not be present.
-static bool MatchRotateHalf(SDValue Op, SDValue &Shift, SDValue &Mask) {
+bool DAGCombiner::MatchRotateHalf(SDValue Op, SDValue &Shift, SDValue &Mask) {
   if (Op.getOpcode() == ISD::AND) {
     if (isConstantIntBuildVectorOrConstantInt(Op.getOperand(1))) {
       Mask = Op.getOperand(1);
       Op = Op.getOperand(0);
     } else {
       return false;
     }
   }
BaseIndexOffset(SDValue Base, SDValue Index, int64_t Offset,
     Base(Base), Index(Index), Offset(Offset), IsIndexSignExt(IsIndexSignExt) {}
 
   bool equalBaseIndex(const BaseIndexOffset &Other) {
     return Other.Base == Base && Other.Index == Index &&
       Other.IsIndexSignExt == IsIndexSignExt;
   }
 
   /// Parses tree in Ptr for base, index, offset addresses.
-  static BaseIndexOffset match(SDValue Ptr) {
+  static BaseIndexOffset match(SDValue Ptr, SelectionDAG &DAG) {
     bool IsIndexSignExt = false;
 
+    // Split up a folded GlobalAddress+Offset into its component parts.
+    if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Ptr))
+      if (GA->getOpcode() == ISD::GlobalAddress && GA->getOffset() != 0) {
+        return BaseIndexOffset(DAG.getGlobalAddress(GA->getGlobal(),
+                                                    SDLoc(GA),
+                                                    GA->getValueType(0),
+                                                    /*Offset=*/0,
+                                                    /*isTargetGA=*/false,
+                                                    GA->getTargetFlags()),
+                               SDValue(),
+                               GA->getOffset(),
+                               IsIndexSignExt);
+      }
+
     // We only can pattern match BASE + INDEX + OFFSET. If Ptr is not an ADD
     // instruction, then it could be just the BASE or everything else we don't
     // know how to handle. Just use Ptr as BASE and give up.
     if (Ptr->getOpcode() != ISD::ADD)
       return BaseIndexOffset(Ptr, SDValue(), 0, IsIndexSignExt);
 
     // We know that we have at least an ADD instruction. Try to pattern match
     // the simple case of BASE + OFFSET.
bool DAGCombiner::MergeStoresOfConstantsOrVecElts(
   return true;
 }
 
 void DAGCombiner::getStoreMergeAndAliasCandidates(
     StoreSDNode* St, SmallVectorImpl<MemOpLink> &StoreNodes,
     SmallVectorImpl<LSBaseSDNode*> &AliasLoadNodes) {
   // This holds the base pointer, index, and the offset in bytes from the base
   // pointer.
-  BaseIndexOffset BasePtr = BaseIndexOffset::match(St->getBasePtr());
+  BaseIndexOffset BasePtr = BaseIndexOffset::match(St->getBasePtr(), DAG);
 
   // We must have a base and an offset.
   if (!BasePtr.Base.getNode())
     return;
 
   // Do not handle stores to undef base pointers.
   if (BasePtr.Base.getOpcode() == ISD::UNDEF)
     return;
for (auto I = Chain->use_begin(), E = Chain->use_end(); I != E; ++I) {
           continue;
 
         if (OtherST->isVolatile() || OtherST->isIndexed())
           continue;
 
         if (OtherST->getMemoryVT() != MemVT)
           continue;
 
-        BaseIndexOffset Ptr = BaseIndexOffset::match(OtherST->getBasePtr());
+        BaseIndexOffset Ptr = BaseIndexOffset::match(OtherST->getBasePtr(), DAG);
 
         if (Ptr.equalBaseIndex(BasePtr))
           StoreNodes.push_back(MemOpLink(OtherST, Ptr.Offset, Seq++));
       }
     }
 
     return;
   }
 
   while (Index) {
     // If the chain has more than one use, then we can't reorder the mem ops.
     if (Index != St && !SDValue(Index, 0)->hasOneUse())
       break;
 
     // Find the base pointer and offset for this memory node.
-    BaseIndexOffset Ptr = BaseIndexOffset::match(Index->getBasePtr());
+    BaseIndexOffset Ptr = BaseIndexOffset::match(Index->getBasePtr(), DAG);
 
     // Check that the base pointer is the same as the original one.
     if (!Ptr.equalBaseIndex(BasePtr))
       break;
 
     // The memory operands must not be volatile.
     if (Index->isVolatile() || Index->isIndexed())
       break;
for (unsigned i=0; i<LastConsecutiveStore+1; ++i) {
     // We do not accept ext loads.
     if (Ld->getExtensionType() != ISD::NON_EXTLOAD)
       break;
 
     // The stored memory type must be the same.
     if (Ld->getMemoryVT() != MemVT)
       break;
 
-    BaseIndexOffset LdPtr = BaseIndexOffset::match(Ld->getBasePtr());
+    BaseIndexOffset LdPtr = BaseIndexOffset::match(Ld->getBasePtr(), DAG);
     // If this is not the first ptr that we check.
     if (LdBasePtr.Base.getNode()) {
       // The base ptr must be the same.
       if (!LdPtr.equalBaseIndex(LdBasePtr))
         break;
     } else {
       // Check that all other base pointers are the same as this one.
       LdBasePtr = LdPtr;
SDValue DAGCombiner::FindBetterChain(SDNode *N, SDValue OldChain) {
 
   // Construct a custom tailored token factor.
   return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other, Aliases);
 }
 
 bool DAGCombiner::findBetterNeighborChains(StoreSDNode* St) {
   // This holds the base pointer, index, and the offset in bytes from the base
   // pointer.
-  BaseIndexOffset BasePtr = BaseIndexOffset::match(St->getBasePtr());
+  BaseIndexOffset BasePtr = BaseIndexOffset::match(St->getBasePtr(), DAG);
 
   // We must have a base and an offset.
   if (!BasePtr.Base.getNode())
     return false;
 
   // Do not handle stores to undef base pointers.
   if (BasePtr.Base.getOpcode() == ISD::UNDEF)
     return false;
while (Index) {
     // If the chain has more than one use, then we can't reorder the mem ops.
     if (Index != St && !SDValue(Index, 0)->hasOneUse())
       break;
 
     if (Index->isVolatile() || Index->isIndexed())
       break;
 
     // Find the base pointer and offset for this memory node.
-    BaseIndexOffset Ptr = BaseIndexOffset::match(Index->getBasePtr());
+    BaseIndexOffset Ptr = BaseIndexOffset::match(Index->getBasePtr(), DAG);
 
     // Check that the base pointer is the same as the original one.
     if (!Ptr.equalBaseIndex(BasePtr))
       break;
 
     // Find the next memory operand in the chain. If the next operand in the
     // chain is a store then move up and continue the scan with the next
     // memory operand. If the next operand is a load save it and use alias

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, SDLoc DL, EVT VT,
 
   std::pair<APInt, bool> Folded = FoldValue(Opcode, Cst1->getAPIntValue(),
                                             Cst2->getAPIntValue());
   if (!Folded.second)
     return SDValue();
   return getConstant(Folded.first, DL, VT);
 }
 
+SDValue SelectionDAG::FoldSymbolOffset(unsigned Opcode, EVT VT,
+                                       const GlobalAddressSDNode *GA,
+                                       const SDNode *N2) {
+  if (GA->getOpcode() != ISD::GlobalAddress)
+    return SDValue();
+  if (!TLI->isOffsetFoldingLegal(GA))
+    return SDValue();
+  const ConstantSDNode *Cst2 = dyn_cast<ConstantSDNode>(N2);
+  if (!Cst2)
+    return SDValue();
+  int64_t Offset = Cst2->getSExtValue();
+  switch (Opcode) {
+  case ISD::ADD: break;
+  case ISD::SUB: Offset = -uint64_t(Offset); break;
+  default: return SDValue();
+  }
+  return getGlobalAddress(GA->getGlobal(), SDLoc(Cst2), VT,
+                          GA->getOffset() + uint64_t(Offset));
+}
+
 SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, SDLoc DL, EVT VT,
                                              SDNode *Cst1, SDNode *Cst2) {
   // If the opcode is a target-specific ISD node, there's nothing we can
   // do here and the operand rules may not line up with the below, so
   // bail early.
   if (Opcode >= ISD::BUILTIN_OP_END)
     return SDValue();
 
if (const ConstantSDNode *Scalar2 = dyn_cast<ConstantSDNode>(Cst2)) {
         // Build a big vector out of the scalar elements we generated.
         return getNode(ISD::BUILD_VECTOR, SDLoc(), VT, Outputs);
       } else {
         return SDValue();
       }
     }
   }
 
+  // fold (add Sym, c) -> Sym+c
+  if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Cst1))
+    return FoldSymbolOffset(Opcode, VT, GA, Cst2);
+  if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Cst2))
+    return FoldSymbolOffset(Opcode, VT, GA, Cst1);
+
   // For vectors extract each constant element into Inputs so we can constant
   // fold them individually.
   BuildVectorSDNode *BV1 = dyn_cast<BuildVectorSDNode>(Cst1);
   BuildVectorSDNode *BV2 = dyn_cast<BuildVectorSDNode>(Cst2);
   if (!BV1 || !BV2)
     return SDValue();
 
   assert(BV1->getNumOperands() == BV2->getNumOperands() && "Out of sync!");

test/CodeGen/WebAssembly/address-offsets.ll

+; RUN: llc < %s -asm-verbose=false | FileCheck %s
+
+; Test folding constant offsets and symbols into load and store addresses under
+; a variety of circumstances.
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+@g = external global [0 x i32], align 4
+
+; CHECK-LABEL: load_test0:
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: i32.load  $push1=, g+40($pop0){{$}}
+; CHECK-NEXT: return    $pop1{{$}}
+define i32 @load_test0() {
+  %t = load i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test0_noinbounds:
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: i32.load  $push1=, g+40($pop0){{$}}
+; CHECK-NEXT: return    $pop1{{$}}
+
+define i32 @load_test0_noinbounds() {
+  %t = load i32, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test1:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test1(i32 %n) {
+  %add = add nsw i32 %n, 10
+  %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test2:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test2(i32 %n) {
+  %add = add nsw i32 10, %n
+  %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test3:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test3(i32 %n) {
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  %t = load i32, i32* %add.ptr1, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test4:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test4(i32 %n) {
+  %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
+  %t = load i32, i32* %add.ptr, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test5:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test5(i32 %n) {
+  %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
+  %t = load i32, i32* %add.ptr, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test6:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test6(i32 %n) {
+  %add = add nsw i32 %n, 10
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  %t = load i32, i32* %add.ptr, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test7:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test7(i32 %n) {
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  %t = load i32, i32* %add.ptr1, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test8:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, g+40($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test8(i32 %n) {
+  %add = add nsw i32 10, %n
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  %t = load i32, i32* %add.ptr, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test9:
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: i32.load  $push1=, g-40($pop0){{$}}
+; CHECK-NEXT: return    $pop1{{$}}
+define i32 @load_test9() {
+  %t = load i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test10:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.const $push2=, g-40{{$}}
+; CHECK-NEXT: i32.add   $push3=, $pop1, $pop2{{$}}
+; CHECK-NEXT: i32.load  $push4=, 0($pop3){{$}}
+; CHECK-NEXT: return    $pop4{{$}}
+define i32 @load_test10(i32 %n) {
+  %add = add nsw i32 %n, -10
+  %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test11:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.load  $push0=, 40($0){{$}}
+; CHECK-NEXT: return    $pop0{{$}}
+define i32 @load_test11(i32* %p) {
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 10
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test11_noinbounds:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 40{{$}}
+; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, 0($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test11_noinbounds(i32* %p) {
+  %arrayidx = getelementptr i32, i32* %p, i32 10
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test12:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
+; CHECK-NEXT: return    $pop5{{$}}
+define i32 @load_test12(i32* %p, i32 %n) {
+  %add = add nsw i32 %n, 10
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test13:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
+; CHECK-NEXT: return    $pop5{{$}}
+define i32 @load_test13(i32* %p, i32 %n) {
+  %add = add nsw i32 10, %n
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test14:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.load  $push3=, 40($pop2){{$}}
+; CHECK-NEXT: return    $pop3{{$}}
+define i32 @load_test14(i32* %p, i32 %n) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  %t = load i32, i32* %add.ptr1, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test15:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
+; CHECK-NEXT: return    $pop5{{$}}
+define i32 @load_test15(i32* %p, i32 %n) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
+  %t = load i32, i32* %add.ptr1, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test16:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
+; CHECK-NEXT: return    $pop5{{$}}
+define i32 @load_test16(i32* %p, i32 %n) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
+  %t = load i32, i32* %add.ptr1, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test17:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
+; CHECK-NEXT: return    $pop5{{$}}
+define i32 @load_test17(i32* %p, i32 %n) {
+  %add = add nsw i32 %n, 10
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
+  %t = load i32, i32* %add.ptr, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test18:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.load  $push3=, 40($pop2){{$}}
+; CHECK-NEXT: return    $pop3{{$}}
+define i32 @load_test18(i32* %p, i32 %n) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  %t = load i32, i32* %add.ptr1, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test19:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
+; CHECK-NEXT: return    $pop5{{$}}
+define i32 @load_test19(i32* %p, i32 %n) {
+  %add = add nsw i32 10, %n
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
+  %t = load i32, i32* %add.ptr, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test20:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, -40{{$}}
+; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.load  $push2=, 0($pop1){{$}}
+; CHECK-NEXT: return    $pop2{{$}}
+define i32 @load_test20(i32* %p) {
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: load_test21:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: result    i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, -40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
+; CHECK-NEXT: return    $pop5{{$}}
+define i32 @load_test21(i32* %p, i32 %n) {
+  %add = add nsw i32 %n, -10
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
+  %t = load i32, i32* %arrayidx, align 4
+  ret i32 %t
+}
+
+; CHECK-LABEL: store_test0:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop0), $0{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test0(i32 %i) {
+  store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test0_noinbounds:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop0), $0{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test0_noinbounds(i32 %i) {
+  store i32 %i, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test1:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test1(i32 %n, i32 %i) {
+  %add = add nsw i32 %n, 10
+  %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test2:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test2(i32 %n, i32 %i) {
+  %add = add nsw i32 10, %n
+  %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test3:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test3(i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  store i32 %i, i32* %add.ptr1, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test4:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test4(i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
+  store i32 %i, i32* %add.ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test5:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test5(i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n
+  store i32 %i, i32* %add.ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test6:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test6(i32 %n, i32 %i) {
+  %add = add nsw i32 %n, 10
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  store i32 %i, i32* %add.ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test7:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test7(i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  store i32 %i, i32* %add.ptr1, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test8:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, g+40($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test8(i32 %n, i32 %i) {
+  %add = add nsw i32 10, %n
+  %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  store i32 %i, i32* %add.ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test9:
+; CHECK-NEXT: param     i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: i32.store $discard=, g-40($pop0), $0{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test9(i32 %i) {
+  store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test10:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.const $push2=, g-40{{$}}
+; CHECK-NEXT: i32.add   $push3=, $pop1, $pop2{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop3), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test10(i32 %n, i32 %i) {
+  %add = add nsw i32 %n, -10
+  %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test11:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.store $discard=, 40($0), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test11(i32* %p, i32 %i) {
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 10
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test11_noinbounds:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 40{{$}}
+; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test11_noinbounds(i32* %p, i32 %i) {
+  %arrayidx = getelementptr i32, i32* %p, i32 10
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test12:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test12(i32* %p, i32 %n, i32 %i) {
+  %add = add nsw i32 %n, 10
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test13:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test13(i32* %p, i32 %n, i32 %i) {
+  %add = add nsw i32 10, %n
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test14:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.store $discard=, 40($pop2), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test14(i32* %p, i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  store i32 %i, i32* %add.ptr1, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test15:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test15(i32* %p, i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
+  store i32 %i, i32* %add.ptr1, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test16:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test16(i32* %p, i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
+  store i32 %i, i32* %add.ptr1, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test17:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test17(i32* %p, i32 %n, i32 %i) {
+  %add = add nsw i32 %n, 10
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
+  store i32 %i, i32* %add.ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test18:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
+; CHECK-NEXT: i32.store $discard=, 40($pop2), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test18(i32* %p, i32 %n, i32 %i) {
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
+  %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
+  store i32 %i, i32* %add.ptr1, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test19:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, 40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test19(i32* %p, i32 %n, i32 %i) {
+  %add = add nsw i32 10, %n
+  %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
+  store i32 %i, i32* %add.ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test20:
+; CHECK-NEXT: param     i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, -40{{$}}
+; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop1), $1{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test20(i32* %p, i32 %i) {
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}
+
+; CHECK-LABEL: store_test21:
+; CHECK-NEXT: param     i32, i32, i32{{$}}
+; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
+; CHECK-NEXT: i32.add   $push2=, $pop1, $0{{$}}
+; CHECK-NEXT: i32.const $push3=, -40{{$}}
+; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
+; CHECK-NEXT: i32.store $discard=, 0($pop4), $2{{$}}
+; CHECK-NEXT: return{{$}}
+define void @store_test21(i32* %p, i32 %n, i32 %i) {
+  %add = add nsw i32 %n, -10
+  %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
+  store i32 %i, i32* %arrayidx, align 4
+  ret void
+}

test/CodeGen/X86/lea-opt.ll

 sw.bb.2:                                          ; preds = %entry
   store i32 333, i32* %b, align 4
   store i32 444, i32* %c, align 4
   br label %sw.epilog
 
 sw.epilog:                                        ; preds = %sw.bb.2, %sw.bb.1, %entry
   ret void
 ; CHECK-LABEL: test1:
-; CHECK:  leaq (%rdi,%rdi,2), [[REG1:%[a-z]+]]
-; CHECK:  movl arr1(,[[REG1]],4), {{.*}}
-; CHECK:  leaq arr1+4(,[[REG1]],4), [[REG2:%[a-z]+]]
-; CHECK:  subl arr1+4(,[[REG1]],4), {{.*}}
-; CHECK:  leaq arr1+8(,[[REG1]],4), [[REG3:%[a-z]+]]
-; CHECK:  addl arr1+8(,[[REG1]],4), {{.*}}
+; CHECK:  shlq $2, [[REG1:%[a-z]+]]
+; CHECK:  movl arr1([[REG1]],[[REG1]],2), {{.*}}
+; CHECK:  leaq arr1+4([[REG1]],[[REG1]],2), [[REG2:%[a-z]+]]
+; CHECK:  subl arr1+4([[REG1]],[[REG1]],2), {{.*}}
+; CHECK:  leaq arr1+8([[REG1]],[[REG1]],2), [[REG3:%[a-z]+]]
+; CHECK:  addl arr1+8([[REG1]],[[REG1]],2), {{.*}}
 ; CHECK:  movl ${{[1-4]+}}, ([[REG2]])
 ; CHECK:  movl ${{[1-4]+}}, ([[REG3]])
 ; CHECK:  movl ${{[1-4]+}}, ([[REG2]])
 ; CHECK:  movl ${{[1-4]+}}, ([[REG3]])
 }
 
 define void @test2(i64 %x) nounwind optsize {
 entry:

 sw.bb.2:                                          ; preds = %entry
   store i32 333, i32* %b, align 4
   store i32 444, i32* %c, align 4
   br label %sw.epilog
 
 sw.epilog:                                        ; preds = %sw.bb.2, %sw.bb.1, %entry
   ret void
 ; CHECK-LABEL: test2:
-; CHECK:  leaq (%rdi,%rdi,2), [[REG1:%[a-z]+]]
-; CHECK:  leaq arr1+4(,[[REG1]],4), [[REG2:%[a-z]+]]
+; CHECK:  shlq $2, [[REG1:%[a-z]+]]
+; CHECK:  leaq arr1+4([[REG1]],[[REG1]],2), [[REG2:%[a-z]+]]
 ; CHECK:  movl -4([[REG2]]), {{.*}}
 ; CHECK:  subl ([[REG2]]), {{.*}}
-; CHECK:  leaq arr1+8(,[[REG1]],4), [[REG3:%[a-z]+]]
+; CHECK:  leaq arr1+8([[REG1]],[[REG1]],2), [[REG3:%[a-z]+]]
 ; CHECK:  addl ([[REG3]]), {{.*}}
 ; CHECK:  movl ${{[1-4]+}}, ([[REG2]])
 ; CHECK:  movl ${{[1-4]+}}, ([[REG3]])
 ; CHECK:  movl ${{[1-4]+}}, ([[REG2]])
 ; CHECK:  movl ${{[1-4]+}}, ([[REG3]])
 }
 
 ; Check that LEA optimization pass takes into account a resultant address

test/CodeGen/XCore/threads.ll

 }
 
 define i32* @f_tle() {
 ; CHECK-LABEL: f_tle:
 ; CHECK: get r11, id
 ; CHECK: shl [[R0:r[0-9]]], r11, 3
 ; CHECK: ldaw [[R1:r[0-9]]], dp[tle]
 ; r0 = &tl + id*8
-; CHECK: add r0, [[R1]], [[R0]]
+; CHECK: add r0, [[R0]], [[R1]]
   ret i32* getelementptr inbounds ([2 x i32], [2 x i32]* @tle, i32 0, i32 0)
 }
 
 define i32 @f_tlExpr () {
 ; CHECK-LABEL: f_tlExpr:
 ; CHECK: get r11, id
 ; CHECK: shl [[R0:r[0-9]]], r11, 3
 ; CHECK: ldaw [[R1:r[0-9]]], dp[tle]
-; CHECK: add [[R2:r[0-9]]], [[R1]], [[R0]]
+; CHECK: add [[R2:r[0-9]]], [[R0]], [[R1]]
 ; CHECK: add r0, [[R2]], [[R2]]
   ret i32 add(
       i32 ptrtoint( i32* getelementptr inbounds ([2 x i32], [2 x i32]* @tle, i32 0, i32 0) to i32),
       i32 ptrtoint( i32* getelementptr inbounds ([2 x i32], [2 x i32]* @tle, i32 0, i32 0) to i32))
 }
 
 define void @phiNode1() {
 ; N.B. lowering of duplicate constexpr in a PHI node requires -O=0