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

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 73 matching lines @@
   InstList::iterator Next;
   /// Begin is a copy of Insts.begin(), used if iterators are moved backward.
   InstList::iterator Begin;
   /// End is a copy of Insts.end(), used if Next needs to be advanced.
   InstList::iterator End;
 
   void skipDeleted(InstList::iterator &I) const;
   void advanceForward(InstList::iterator &I) const;
 };
 
+/// A helper class to advance the LoweringContext at each loop iteration.
+class PostIncrLoweringContext {
+  PostIncrLoweringContext() = delete;
+  PostIncrLoweringContext(const PostIncrLoweringContext &) = delete;
+  PostIncrLoweringContext &operator=(const PostIncrLoweringContext &) = delete;
+
+public:
+  explicit PostIncrLoweringContext(LoweringContext &Context)
+      : Context(Context) {}
+  ~PostIncrLoweringContext() {
+    Context.advanceCur();
+    Context.advanceNext();
+  }
+
+private:
+  LoweringContext &Context;
+};
+
 class TargetLowering {
   TargetLowering() = delete;
   TargetLowering(const TargetLowering &) = delete;
   TargetLowering &operator=(const TargetLowering &) = delete;
 
 public:
   // TODO(jvoung): return a unique_ptr like the other factory functions.
   static TargetLowering *createLowering(TargetArch Target, Cfg *Func);
   static std::unique_ptr<Assembler> createAssembler(TargetArch Target,
                                                     Cfg *Func);
@@ skipping 53 matching lines @@
   /// register.  This is generally used to get very direct access to
   /// the register such as in the prolog or epilog or for marking
   /// scratch registers as killed by a call.  If a Type is not
   /// provided, a target-specific default type is used.
   virtual Variable *getPhysicalRegister(SizeT RegNum,
                                         Type Ty = IceType_void) = 0;
   /// Returns a printable name for the register.
   virtual IceString getRegName(SizeT RegNum, Type Ty) const = 0;
 
   virtual bool hasFramePointer() const { return false; }
   virtual SizeT getFrameOrStackReg() const = 0;

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

What do you think about changing this to something like
  SizeT getFrameReg(const Variable *Var = nullptr) const;
such that if you pass a non-null Var, it first checks Var->getBaseRegNum() and
then defaults to esp/ebp/whatever?  I think it might make the uses of
getBaseRegNum() simpler.

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

I'm not totally sure that would simplify things.


In some cases, we want two pieces of information back: getBaseRegNum() affects
the Offset as well as the register number. E.g., the ARM pass is taking into
account getStackAdjustment() to see if that also overflows the offset, and then
makes that part of new variable's offset, so we don't want to count that stack
adjustment twice.

  int32_t Offset = Var->getStackOffset();
  int32_t BaseRegNum = Var->getBaseRegNum();
  if (Var->getBaseRegNum() == Variable::NoRegister) {
     BaseRegNum = getFrameOrStackReg();
     if (!hasFramePointer())
       Offset += getStackAdjustment();
     }
  }

[Jim Stichnoth, 2015/07/30 13:34:52]

I see, OK.

   virtual size_t typeWidthInBytesOnStack(Type Ty) const = 0;
 
   bool hasComputedFrame() const { return HasComputedFrame; }
   /// Returns true if this function calls a function that has the
   /// "returns twice" attribute.
   bool callsReturnsTwice() const { return CallsReturnsTwice; }
   void setCallsReturnsTwice(bool RetTwice) { CallsReturnsTwice = RetTwice; }
   int32_t getStackAdjustment() const { return StackAdjustment; }
   void updateStackAdjustment(int32_t Offset) { StackAdjustment += Offset; }
   void resetStackAdjustment() { StackAdjustment = 0; }
@@ skipping 248 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H