ARM: Add a postRA pass to legalize stack offsets. Greedy approach (reserve IP).

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 738 matching lines @@
 void TargetX86Base<Machine>::emitVariable(const Variable *Var) const {
   Ostream &Str = Ctx->getStrEmit();
   if (Var->hasReg()) {
     Str << "%" << getRegName(Var->getRegNum(), Var->getType());
     return;
   }
   if (Var->getWeight().isInf()) {
     llvm_unreachable("Infinite-weight Variable has no register assigned");
   }
   int32_t Offset = Var->getStackOffset();
-  if (!hasFramePointer())
-    Offset += getStackAdjustment();
+  int32_t BaseRegNum = Var->getBaseRegNum();

[jvoung (off chromium), 2015/07/23 23:26:32]

Well.. this is an extra virtual call, but I didn't have a good idea for
overriding if it happened to be something like StackVariable (though that's only
applicable for ARM). I didn't want to override "emit()" and "dump()" and do
something like override stackVarToAsmOperand(), since it's *almost* the same.

[Jim Stichnoth, 2015/07/24 22:08:29]

No need to worry about performance in dump() or emit() functions.

BTW, this being an emit() function, it should start with:
  if (!BuildDefs::dump())
    return;

[jvoung (off chromium), 2015/07/27 17:02:58]

Okay stackVarToAsmOperand also does this though, and it's used by emitIAS.
Added here, and in arm and mips.

+  if (BaseRegNum == Variable::NoRegister) {
+    BaseRegNum = getFrameOrStackReg();
+    if (!hasFramePointer())
+      Offset += getStackAdjustment();
+  }
   if (Offset)
     Str << Offset;
   const Type FrameSPTy = IceType_i32;
-  Str << "(%" << getRegName(getFrameOrStackReg(), FrameSPTy) << ")";
+  Str << "(%" << getRegName(BaseRegNum, FrameSPTy) << ")";
 }
 
 template <class Machine>
 typename TargetX86Base<Machine>::Traits::Address
 TargetX86Base<Machine>::stackVarToAsmOperand(const Variable *Var) const {
   if (Var->hasReg())
     llvm_unreachable("Stack Variable has a register assigned");
   if (Var->getWeight().isInf()) {
     llvm_unreachable("Infinite-weight Variable has no register assigned");
   }
   int32_t Offset = Var->getStackOffset();
-  if (!hasFramePointer())
-    Offset += getStackAdjustment();
+  int32_t BaseRegNum = Var->getBaseRegNum();
+  if (Var->getBaseRegNum() == Variable::NoRegister) {
+    BaseRegNum = getFrameOrStackReg();
+    if (!hasFramePointer())
+      Offset += getStackAdjustment();
+  }
   return typename Traits::Address(
-      Traits::RegisterSet::getEncodedGPR(getFrameOrStackReg()), Offset);
+      Traits::RegisterSet::getEncodedGPR(BaseRegNum), Offset);
 }
 
 template <class Machine> void TargetX86Base<Machine>::lowerArguments() {
   VarList &Args = Func->getArgs();
   // The first four arguments of vector type, regardless of their
   // position relative to the other arguments in the argument list, are
   // passed in registers xmm0 - xmm3.
   unsigned NumXmmArgs = 0;
 
   Context.init(Func->getEntryNode());
@@ skipping 4826 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