Match index adds as well as base

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 4473 matching lines @@
     if (Reason) {
       dumpAddressOpt(Func, Relocatable, Offset, Base, Index, Shift, Reason);
       AddressWasOptimized = true;
       Reason = nullptr;
     }
     // Update Base and Index to follow through assignments to definitions.
     if (matchAssign(VMetadata, Base, Relocatable, Offset, Reason)) {
       // Assignments of Base from a Relocatable or ConstantInt32 can result
       // in Base becoming nullptr.  To avoid code duplication in this loop we
       // prefer that Base be non-nullptr if possible.
-      if ((Base == nullptr) && (Index != nullptr) && (Shift == 0))
+      if ((Base == nullptr) && (Index != nullptr) && Shift == 0)
         std::swap(Base, Index);
       continue;
     }
     if (matchAssign(VMetadata, Index, Relocatable, Offset, Reason))
       continue;
 
     if (!MockBounds) {
       // Transition from:
       //   <Relocatable + Offset>(Base) to
       //   <Relocatable + Offset>(Base, Index)
       if (matchCombinedBaseIndex(VMetadata, Base, Index, Shift, Reason))
         continue;
       // Recognize multiply/shift and update Shift amount.
       // Index becomes Index=Var<<Const && Const+Shift<=3 ==>
       //   Index=Var, Shift+=Const
       // Index becomes Index=Const*Var && log2(Const)+Shift<=3 ==>
       //   Index=Var, Shift+=log2(Const)
       if (matchShiftedIndex(VMetadata, Index, Shift, Reason))
         continue;
       // If Shift is zero, the choice of Base and Index was purely arbitrary.
       // Recognize multiply/shift and set Shift amount.
       // Shift==0 && Base is Base=Var*Const && log2(Const)+Shift<=3 ==>
       //   swap(Index,Base)
       // Similar for Base=Const*Var and Base=Var<<Const
-      if ((Shift == 0) && matchShiftedIndex(VMetadata, Base, Shift, Reason)) {
+      if (Shift == 0 && matchShiftedIndex(VMetadata, Base, Shift, Reason)) {
         std::swap(Base, Index);
         continue;
       }
     }
     // Update Offset to reflect additions/subtractions with constants and
     // relocatables.
     // TODO: consider overflow issues with respect to Offset.
-    // TODO: handle symbolic constants.
     if (matchOffsetBase(VMetadata, Base, Relocatable, Offset, Reason))
       continue;
+    if (Shift == 0 &&
+        matchOffsetBase(VMetadata, Index, Relocatable, Offset, Reason))
+      continue;
     // TODO(sehr, stichnot): Handle updates of Index with Shift != 0.
     // Index is Index=Var+Const ==>
     //   set Index=Var, Offset+=(Const<<Shift)
     // Index is Index=Const+Var ==>
     //   set Index=Var, Offset+=(Const<<Shift)
     // Index is Index=Var-Const ==>
     //   set Index=Var, Offset-=(Const<<Shift)
     break;
   } while (Reason);
   return AddressWasOptimized;
@@ skipping 1318 matching lines @@
   }
   // the offset is not eligible for blinding or pooling, return the original
   // mem operand
   return MemOperand;
 }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H