[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

772–773

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?

772–773

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

397

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,
#endif
 
   /// Append the extracted elements from Start to Count out of the vector Op
   /// in Args. If Count is 0, all of the elements will be extracted.
   void ExtractVectorElements(SDValue Op, SmallVectorImpl<SDValue> &Args,
                              unsigned Start = 0, unsigned Count = 0);
 
   unsigned getEVTAlignment(EVT MemoryVT) const;
 
+  /// Test whether the given value is a constant int or similar node.
+  SDNode *isConstantIntBuildVectorOrConstantInt(SDValue N);
+
 private:
   void InsertNode(SDNode *N);
   bool RemoveNodeFromCSEMaps(SDNode *N);
   void AddModifiedNodeToCSEMaps(SDNode *N);
   SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos);
   SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2,
                                void *&InsertPos);
   SDNode *FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,

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);
 
+    /// 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) {
   unsigned SplatBitSize;
   bool HasAnyUndefs;
   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) {
-  if (isa<ConstantSDNode>(N))
-    return N.getNode();
-  if (ISD::isBuildVectorOfConstantSDNodes(N.getNode()))
-    return N.getNode();
-  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::isBuildVectorOfConstantFPSDNodes(N.getNode()))
     return N.getNode();
   return nullptr;
 }
 
 // \brief Returns the SDNode if it is a constant splat BuildVector or constant
 // int.
 static ConstantSDNode *isConstOrConstSplat(SDValue N) {
static ConstantFPSDNode *isConstOrConstSplatFP(SDValue N) {
 
   return nullptr;
 }
 
 SDValue DAGCombiner::ReassociateOps(unsigned Opc, SDLoc DL,
                                     SDValue N0, SDValue N1) {
   EVT VT = N0.getValueType();
   if (N0.getOpcode() == Opc) {
-    if (SDNode *L = isConstantIntBuildVectorOrConstantInt(N0.getOperand(1))) {
-      if (SDNode *R = isConstantIntBuildVectorOrConstantInt(N1)) {
+    if (SDNode *L = DAG.isConstantIntBuildVectorOrConstantInt(N0.getOperand(1))) {
+      if (SDNode *R = DAG.isConstantIntBuildVectorOrConstantInt(N1)) {
         // reassoc. (op (op x, c1), c2) -> (op x, (op c1, c2))
         if (SDValue OpNode = DAG.FoldConstantArithmetic(Opc, DL, VT, L, R))
           return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode);
         return SDValue();
       }
       if (N0.hasOneUse()) {
         // reassoc. (op (op x, c1), y) -> (op (op x, y), c1) iff x+c1 has one
         // use
         SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0.getOperand(0), N1);
         if (!OpNode.getNode())
           return SDValue();
         AddToWorklist(OpNode.getNode());
         return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1));
       }
     }
   }
 
   if (N1.getOpcode() == Opc) {
-    if (SDNode *R = isConstantIntBuildVectorOrConstantInt(N1.getOperand(1))) {
-      if (SDNode *L = isConstantIntBuildVectorOrConstantInt(N0)) {
+    if (SDNode *R = DAG.isConstantIntBuildVectorOrConstantInt(N1.getOperand(1))) {
+      if (SDNode *L = DAG.isConstantIntBuildVectorOrConstantInt(N0)) {
         // reassoc. (op c2, (op x, c1)) -> (op x, (op c1, c2))
         if (SDValue OpNode = DAG.FoldConstantArithmetic(Opc, DL, VT, R, L))
           return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode);
         return SDValue();
       }
       if (N1.hasOneUse()) {
         // reassoc. (op y, (op x, c1)) -> (op (op x, y), c1) iff x+c1 has one
         // use
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 (DAG.isConstantIntBuildVectorOrConstantInt(N0)) {
     // canonicalize constant to RHS
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
-     !isConstantIntBuildVectorOrConstantInt(N1))
+    if (!DAG.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 (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
+      DAG.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::visitMUL(SDNode *N) {
   }
 
   // fold (mul c1, c2) -> c1*c2
   if (N0IsConst && N1IsConst && !N0IsOpaqueConst && !N1IsOpaqueConst)
     return DAG.FoldConstantArithmetic(ISD::MUL, SDLoc(N), VT,
                                       N0.getNode(), N1.getNode());
 
   // canonicalize constant to RHS (vector doesn't have to splat)
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
-     !isConstantIntBuildVectorOrConstantInt(N1))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
+     !DAG.isConstantIntBuildVectorOrConstantInt(N1))
     return DAG.getNode(ISD::MUL, SDLoc(N), VT, N1, N0);
   // fold (mul x, 0) -> 0
   if (N1IsConst && ConstValue1 == 0)
     return N1;
   // We require a splat of the entire scalar bit width for non-contiguous
   // bit patterns.
   bool IsFullSplat =
     ConstValue1.getBitWidth() == VT.getScalarType().getSizeInBits();
if (Sh.getNode()) {
       SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
                                 Sh.getOperand(0), Y);
       return DAG.getNode(ISD::SHL, SDLoc(N), VT,
                          Mul, Sh.getOperand(1));
     }
   }
 
   // fold (mul (add x, c1), c2) -> (add (mul x, c2), c1*c2)
-  if (isConstantIntBuildVectorOrConstantInt(N1) &&
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N1) &&
       N0.getOpcode() == ISD::ADD &&
-      isConstantIntBuildVectorOrConstantInt(N0.getOperand(1)) &&
+      DAG.isConstantIntBuildVectorOrConstantInt(N0.getOperand(1)) &&
       isMulAddWithConstProfitable(N, N0, N1))
       return DAG.getNode(ISD::ADD, SDLoc(N), VT,
                          DAG.getNode(ISD::MUL, SDLoc(N0), VT,
                                      N0.getOperand(0), N1),
                          DAG.getNode(ISD::MUL, SDLoc(N1), VT,
                                      N0.getOperand(1), N1));
 
   // reassociate mul
SDValue DAGCombiner::visitIMINMAX(SDNode *N) {
 
   // fold (add c1, c2) -> c1+c2
   ConstantSDNode *N0C = getAsNonOpaqueConstant(N0);
   ConstantSDNode *N1C = getAsNonOpaqueConstant(N1);
   if (N0C && N1C)
     return DAG.FoldConstantArithmetic(N->getOpcode(), SDLoc(N), VT, N0C, N1C);
 
   // canonicalize constant to RHS
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
-     !isConstantIntBuildVectorOrConstantInt(N1))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
+     !DAG.isConstantIntBuildVectorOrConstantInt(N1))
     return DAG.getNode(N->getOpcode(), SDLoc(N), VT, N1, N0);
 
   return SDValue();
 }
 
 /// If this is a binary operator with two operands of the same opcode, try to
 /// simplify it.
 SDValue DAGCombiner::SimplifyBinOpWithSameOpcodeHands(SDNode *N) {
SDValue DAGCombiner::visitAND(SDNode *N) {
   }
 
   // fold (and c1, c2) -> c1&c2
   ConstantSDNode *N0C = getAsNonOpaqueConstant(N0);
   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
   if (N0C && N1C && !N1C->isOpaque())
     return DAG.FoldConstantArithmetic(ISD::AND, SDLoc(N), VT, N0C, N1C);
   // canonicalize constant to RHS
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
-     !isConstantIntBuildVectorOrConstantInt(N1))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
+     !DAG.isConstantIntBuildVectorOrConstantInt(N1))
     return DAG.getNode(ISD::AND, SDLoc(N), VT, N1, N0);
   // fold (and x, -1) -> x
   if (isAllOnesConstant(N1))
     return N0;
   // if (and x, c) is known to be zero, return 0
   unsigned BitWidth = VT.getScalarType().getSizeInBits();
   if (N1C && DAG.MaskedValueIsZero(SDValue(N, 0),
                                    APInt::getAllOnesValue(BitWidth)))
SDValue DAGCombiner::visitOR(SDNode *N) {
   }
 
   // fold (or c1, c2) -> c1|c2
   ConstantSDNode *N0C = getAsNonOpaqueConstant(N0);
   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
   if (N0C && N1C && !N1C->isOpaque())
     return DAG.FoldConstantArithmetic(ISD::OR, SDLoc(N), VT, N0C, N1C);
   // canonicalize constant to RHS
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
-     !isConstantIntBuildVectorOrConstantInt(N1))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
+     !DAG.isConstantIntBuildVectorOrConstantInt(N1))
     return DAG.getNode(ISD::OR, SDLoc(N), VT, N1, N0);
   // fold (or x, 0) -> x
   if (isNullConstant(N1))
     return N0;
   // fold (or x, -1) -> -1
   if (isAllOnesConstant(N1))
     return N1;
   // fold (or x, c) -> c iff (x & ~c) == 0
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))) {
+    if (DAG.isConstantIntBuildVectorOrConstantInt(Op.getOperand(1))) {
       Mask = Op.getOperand(1);
       Op = Op.getOperand(0);
     } else {
       return false;
     }
   }
 
   if (Op.getOpcode() == ISD::SRL || Op.getOpcode() == ISD::SHL) {
SDValue DAGCombiner::visitXOR(SDNode *N) {
   if (N1.getOpcode() == ISD::UNDEF)
     return N1;
   // fold (xor c1, c2) -> c1^c2
   ConstantSDNode *N0C = getAsNonOpaqueConstant(N0);
   ConstantSDNode *N1C = getAsNonOpaqueConstant(N1);
   if (N0C && N1C)
     return DAG.FoldConstantArithmetic(ISD::XOR, SDLoc(N), VT, N0C, N1C);
   // canonicalize constant to RHS
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
-     !isConstantIntBuildVectorOrConstantInt(N1))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
+     !DAG.isConstantIntBuildVectorOrConstantInt(N1))
     return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
   // fold (xor x, 0) -> x
   if (isNullConstant(N1))
     return N0;
   // reassociate xor
   if (SDValue RXOR = ReassociateOps(ISD::XOR, SDLoc(N), N0, N1))
     return RXOR;
 
SDValue DAGCombiner::visitSRL(SDNode *N) {
   return SDValue();
 }
 
 SDValue DAGCombiner::visitBSWAP(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
 
   // fold (bswap c1) -> c2
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N0);
   // fold (bswap (bswap x)) -> x
   if (N0.getOpcode() == ISD::BSWAP)
     return N0->getOperand(0);
   return SDValue();
 }
 
 SDValue DAGCombiner::visitCTLZ(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
 
   // fold (ctlz c1) -> c2
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::CTLZ, SDLoc(N), VT, N0);
   return SDValue();
 }
 
 SDValue DAGCombiner::visitCTLZ_ZERO_UNDEF(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
 
   // fold (ctlz_zero_undef c1) -> c2
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SDLoc(N), VT, N0);
   return SDValue();
 }
 
 SDValue DAGCombiner::visitCTTZ(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
 
   // fold (cttz c1) -> c2
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::CTTZ, SDLoc(N), VT, N0);
   return SDValue();
 }
 
 SDValue DAGCombiner::visitCTTZ_ZERO_UNDEF(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
 
   // fold (cttz_zero_undef c1) -> c2
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, SDLoc(N), VT, N0);
   return SDValue();
 }
 
 SDValue DAGCombiner::visitCTPOP(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
 
   // fold (ctpop c1) -> c2
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::CTPOP, SDLoc(N), VT, N0);
   return SDValue();
 }
 
 
 /// \brief Generate Min/Max node
 static SDValue combineMinNumMaxNum(SDLoc DL, EVT VT, SDValue LHS, SDValue RHS,
                                    SDValue True, SDValue False,
SDValue DAGCombiner::visitSIGN_EXTEND_INREG(SDNode *N) {
   EVT EVT = cast<VTSDNode>(N1)->getVT();
   unsigned VTBits = VT.getScalarType().getSizeInBits();
   unsigned EVTBits = EVT.getScalarType().getSizeInBits();
 
   if (N0.isUndef())
     return DAG.getUNDEF(VT);
 
   // fold (sext_in_reg c1) -> c1
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
 
   // If the input is already sign extended, just drop the extension.
   if (DAG.ComputeNumSignBits(N0) >= VTBits-EVTBits+1)
     return N0;
 
   // fold (sext_in_reg (sext_in_reg x, VT2), VT1) -> (sext_in_reg x, minVT) pt2
   if (N0.getOpcode() == ISD::SIGN_EXTEND_INREG &&
SDValue DAGCombiner::visitTRUNCATE(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
   bool isLE = DAG.getDataLayout().isLittleEndian();
 
   // noop truncate
   if (N0.getValueType() == N->getValueType(0))
     return N0;
   // fold (truncate c1) -> c1
-  if (isConstantIntBuildVectorOrConstantInt(N0))
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0))
     return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0);
   // fold (truncate (truncate x)) -> (truncate x)
   if (N0.getOpcode() == ISD::TRUNCATE)
     return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
   // fold (truncate (ext x)) -> (ext x) or (truncate x) or x
   if (N0.getOpcode() == ISD::ZERO_EXTEND ||
       N0.getOpcode() == ISD::SIGN_EXTEND ||
       N0.getOpcode() == ISD::ANY_EXTEND) {

 }
 
 SDValue DAGCombiner::visitSINT_TO_FP(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
   EVT OpVT = N0.getValueType();
 
   // fold (sint_to_fp c1) -> c1fp
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
       // ...but only if the target supports immediate floating-point values
       (!LegalOperations ||
        TLI.isOperationLegalOrCustom(llvm::ISD::ConstantFP, VT)))
     return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
 
   // If the input is a legal type, and SINT_TO_FP is not legal on this target,
   // but UINT_TO_FP is legal on this target, try to convert.
   if (!TLI.isOperationLegalOrCustom(ISD::SINT_TO_FP, OpVT) &&

 }
 
 SDValue DAGCombiner::visitUINT_TO_FP(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
   EVT OpVT = N0.getValueType();
 
   // fold (uint_to_fp c1) -> c1fp
-  if (isConstantIntBuildVectorOrConstantInt(N0) &&
+  if (DAG.isConstantIntBuildVectorOrConstantInt(N0) &&
       // ...but only if the target supports immediate floating-point values
       (!LegalOperations ||
        TLI.isOperationLegalOrCustom(llvm::ISD::ConstantFP, VT)))
     return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
 
   // If the input is a legal type, and UINT_TO_FP is not legal on this target,
   // but SINT_TO_FP is legal on this target, try to convert.
   if (!TLI.isOperationLegalOrCustom(ISD::UINT_TO_FP, OpVT) &&
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.
if (Use->getOpcode() == ISD::MUL) { // We have another multiply use.
       //     ...
       //     OtherOp = (A + c2)
       //     Use     = OtherOp * ConstNode <-- visiting Use.
       //
       // If we make this transformation, we will have a common
       // multiply (CONST * A) after we also do the same transformation
       // to the "t2" instruction.
       if (OtherOp->getOpcode() == ISD::ADD &&
-          isConstantIntBuildVectorOrConstantInt(OtherOp->getOperand(1)) &&
+          DAG.isConstantIntBuildVectorOrConstantInt(OtherOp->getOperand(1)) &&
           OtherOp->getOperand(0).getNode() == MulVar)
         return true;
     }
   }
 
   // Didn't find a case where this would be profitable.
   return false;
 }
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!");
bool ShuffleVectorSDNode::isSplatMask(const int *Mask, EVT VT) {
   // Make sure all remaining elements are either undef or the same as the first
   // non-undef value.
   for (int Idx = Mask[i]; i != e; ++i)
     if (Mask[i] >= 0 && Mask[i] != Idx)
       return false;
   return true;
 }
 
+// \brief Returns the SDNode if it is a constant integer BuildVector
+// or constant integer.
+SDNode *SelectionDAG::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;
+}
+
 #ifndef NDEBUG
 static void checkForCyclesHelper(const SDNode *N,
                                  SmallPtrSetImpl<const SDNode*> &Visited,
                                  SmallPtrSetImpl<const SDNode*> &Checked,
                                  const llvm::SelectionDAG *DAG) {
   // If this node has already been checked, don't check it again.
   if (Checked.count(N))
     return;

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