Merge fixed alloca stack adjustments into the prolog

src/IceInstX8632.cpp

 //===- subzero/src/IceInstX8632.cpp - X86-32 instruction implementation ---===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 80 matching lines @@
     Vars = Func->allocateArrayOf<Variable *>(NumVars);
     SizeT I = 0;
     if (Base)
       Vars[I++] = Base;
     if (Index)
       Vars[I++] = Index;
     assert(I == NumVars);
   }
 }
 
+namespace {
+static int32_t GetRematerializableOffset(Variable *Var, bool IgnoreStackAdjust,
+                                         const Ice::TargetLowering *Target) {

[John, 2015/11/16 14:00:02]

const Ice::TargetX8632 *? I would hope llvm would devirtualize the call to
getStackReg and getFrameReg if you passed a concrete, final class.

[sehr, 2015/11/16 18:42:24]

Done.

+  int32_t Disp = 0;
+  Disp += Var->getStackOffset();
+  if (static_cast<SizeT>(Var->getRegNum()) == Target->getStackReg()) {

[Jim Stichnoth, 2015/11/16 14:47:57]

Pull "static_cast<SizeT>(Var->getRegNum())" out of the if/then/else construct
for clarity?

SizeT RegNum = static_cast<SizeT>(Var->getRegNum());
if (RegNum == Target->getStackReg()) {

[sehr, 2015/11/16 18:42:24]

Done.

+    if (!IgnoreStackAdjust)
+      Disp += Target->getStackAdjustment();
+  } else if (static_cast<SizeT>(Var->getRegNum()) == Target->getFrameReg()) {
+    Disp += Target->getFrameFixedAllocaOffset();
+  } else {
+    llvm_unreachable("Unexpected rematerializable register type");

[Jim Stichnoth, 2015/11/16 14:47:57]

llvm::report_fatal_error

[sehr, 2015/11/16 18:42:24]

Done.

+  }
+  return Disp;
+}
+}  // end namespace

[Jim Stichnoth, 2015/11/16 14:47:57]

end of anonymous namespace

[sehr, 2015/11/16 18:42:24]

Done.

+
 void MachineTraits<TargetX8632>::X86OperandMem::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
-  const ::Ice::TargetLowering *Target = Func->getTarget();
+  Ice::TargetLowering *Target = Func->getTarget();

[Jim Stichnoth, 2015/11/16 14:47:57]

Retain the const?

[sehr, 2015/11/16 18:42:24]

Done.

   // If the base is rematerializable, we need to replace it with the correct
   // physical register (esp or ebp), and update the Offset.
   int32_t Disp = 0;
   if (getBase() && getBase()->isRematerializable()) {
-    Disp += getBase()->getStackOffset();
-    if (!getIgnoreStackAdjust())
-      Disp += Target->getStackAdjustment();
+    Disp += GetRematerializableOffset(getBase(), getIgnoreStackAdjust(),
+                                      Target);
   }
   // The index should never be rematerializable.  But if we ever allow it, then
   // we should make sure the rematerialization offset is shifted by the Shift
   // value.
   if (getIndex())
     assert(!getIndex()->isRematerializable());
   Ostream &Str = Func->getContext()->getStrEmit();
   if (SegmentReg != DefaultSegment) {
     assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
     Str << "%" << X8632::Traits::InstSegmentRegNames[SegmentReg] << ":";
   }
   // Emit as Offset(Base,Index,1<<Shift). Offset is emitted without the leading
   // '$'. Omit the (Base,Index,1<<Shift) part if Base==nullptr.
   if (getOffset() == 0 && Disp == 0) {
     // No offset, emit nothing.
   } else if (getOffset() == 0 && Disp != 0) {
     Str << Disp;
   } else if (const auto *CI = llvm::dyn_cast<ConstantInteger32>(getOffset())) {
     if (getBase() == nullptr || CI->getValue() || Disp != 0)
       // Emit a non-zero offset without a leading '$'.
       Str << CI->getValue() + Disp;
   } else if (const auto *CR =
                  llvm::dyn_cast<ConstantRelocatable>(getOffset())) {
     // TODO(sehr): ConstantRelocatable still needs updating for
     // rematerializable base/index and Disp.
     assert(Disp == 0);
-    CR->emitWithoutPrefix(Func->getTarget());
+    CR->emitWithoutPrefix(Target);
   } else {
     llvm_unreachable("Invalid offset type for x86 mem operand");
   }
 
   if (getBase() || getIndex()) {
     Str << "(";
     if (getBase())
       getBase()->emit(Func);
     if (getIndex()) {
       Str << ",";
@@ skipping 10 matching lines @@
   if (!BuildDefs::dump())
     return;
   if (SegmentReg != DefaultSegment) {
     assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
     Str << X8632::Traits::InstSegmentRegNames[SegmentReg] << ":";
   }
   bool Dumped = false;
   Str << "[";
   int32_t Disp = 0;
   if (getBase() && getBase()->isRematerializable()) {
-    Disp += getBase()->getStackOffset();
-    if (!getIgnoreStackAdjust())
-      Disp += Func->getTarget()->getStackAdjustment();
+    Disp += GetRematerializableOffset(getBase(), getIgnoreStackAdjust(),
+                                      Func->getTarget());
   }
   if (getBase()) {
     if (Func)
       getBase()->dump(Func);
     else
       getBase()->dump(Str);
     Dumped = true;
   }
   if (getIndex()) {
     assert(!getIndex()->isRematerializable());
@@ skipping 44 matching lines @@
     Asm->emitSegmentOverride(X8632::Traits::InstSegmentPrefixes[SegmentReg]);
   }
 }
 
 MachineTraits<TargetX8632>::Address
 MachineTraits<TargetX8632>::X86OperandMem::toAsmAddress(
     MachineTraits<TargetX8632>::Assembler *Asm,
     const Ice::TargetLowering *Target) const {
   int32_t Disp = 0;
   if (getBase() && getBase()->isRematerializable()) {
-    Disp += getBase()->getStackOffset();
-    if (!getIgnoreStackAdjust()) {
-      Disp += Target->getStackAdjustment();
-    }
+    Disp += GetRematerializableOffset(getBase(), getIgnoreStackAdjust(),
+                                      Target);
   }
   // The index should never be rematerializable.  But if we ever allow it, then
   // we should make sure the rematerialization offset is shifted by the Shift
   // value.
   if (getIndex())
     assert(!getIndex()->isRematerializable());
   AssemblerFixup *Fixup = nullptr;
   // Determine the offset (is it relocatable?)
   if (getOffset()) {
     if (const auto *CI = llvm::dyn_cast<ConstantInteger32>(getOffset())) {
@@ skipping 67 matching lines @@
     Var->dump(Func);
   else
     Var->dump(Str);
   Str << ")";
 }
 
 } // namespace X86Internal
 } // end of namespace Ice
 
 X86INSTS_DEFINE_STATIC_DATA(TargetX8632)