Subzero: address mode opt: Transform *(reg+const) into [reg+const].

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 3370 matching lines @@
           break;
         }
         if (Shift + LogMult <= 3) {
           Index = IndexVariable0;
           Shift += LogMult;
           continue;
         }
       }
     }
 
+    // Base is Base=Var+Const || Base is Base=Const+Var ==>
+    //   set Base=Var, Offset+=Const
+    // Base is Base=Var-Const ==>
+    //   set Base=Var, Offset-=Const
+    const InstArithmetic *ArithInst =
+        llvm::dyn_cast_or_null<const InstArithmetic>(BaseInst);
+    if (ArithInst && (ArithInst->getOp() == InstArithmetic::Add ||
+                      ArithInst->getOp() == InstArithmetic::Sub)) {
+      bool IsAdd = ArithInst->getOp() == InstArithmetic::Add;
+      Variable *Var = NULL;
+      ConstantInteger *Const = NULL;
+      if (Variable *VariableOperand =
+              llvm::dyn_cast<Variable>(ArithInst->getSrc(0))) {
+        Var = VariableOperand;
+        Const = llvm::dyn_cast<ConstantInteger>(ArithInst->getSrc(1));
+      } else if (IsAdd) {
+        Const = llvm::dyn_cast<ConstantInteger>(ArithInst->getSrc(0));
+        Var = llvm::dyn_cast<Variable>(ArithInst->getSrc(1));
+      }
+      if (!(Const && Var)) {
+        break;
+      }
+      Base = Var;
+      Offset += IsAdd ? Const->getValue() : -Const->getValue();
+      continue;
+    }
+
     // Index is Index=Var<<Const && Const+Shift<=3 ==>
     //   Index=Var, Shift+=Const
 
     // Index is Index=Const*Var && log2(Const)+Shift<=3 ==>
     //   Index=Var, Shift+=log2(Const)
 
     // Index && Shift==0 && Base is Base=Var*Const && log2(Const)+Shift<=3 ==>
     //   swap(Index,Base)
     // Similar for Base=Const*Var and Base=Var<<Const
 
-    // Base is Base=Var+Const ==>
-    //   set Base=Var, Offset+=Const
-
-    // Base is Base=Const+Var ==>
-    //   set Base=Var, Offset+=Const
-
-    // Base is Base=Var-Const ==>
-    //   set Base=Var, Offset-=Const
-
     // 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)
 
     // TODO: consider overflow issues with respect to Offset.
@@ skipping 612 matching lines @@
         int32_t RegNum = AvailableTypedRegisters.find_first();
         Var->setRegNum(RegNum);
         AvailableRegisters[RegNum] = false;
       }
     }
   }
 }
 
 template <> void ConstantInteger::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
-  Str << getValue();
+  Str << (int64_t) getValue();
 }
 
 template <> void ConstantFloat::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
   // It would be better to prefix with ".L$" instead of "L$", but
   // llvm-mc doesn't parse "dword ptr [.L$foo]".
   Str << "dword ptr [L$" << IceType_f32 << "$" << getPoolEntryID() << "]";
 }
 
 template <> void ConstantDouble::emit(GlobalContext *Ctx) const {
@@ skipping 95 matching lines @@
     for (SizeT i = 0; i < Size; ++i) {
       Str << "\t.byte\t" << (((unsigned)Data[i]) & 0xff) << "\n";
     }
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   }
   Str << "\t" << (IsInternal ? ".local" : ".global") << "\t" << MangledName
       << "\n";
 }
 
 } // end of namespace Ice