Refactor PUSH/POP in ARM assemblers.

src/IceInstARM32.h

 //===- subzero/src/IceInstARM32.h - ARM32 machine instructions --*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the InstARM32 and OperandARM32 classes and their subclasses.
 ///
 /// This represents the machine instructions and operands used for ARM32 code
 /// selection.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINSTARM32_H
 #define SUBZERO_SRC_ICEINSTARM32_H
 
 #include "IceConditionCodesARM32.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceInstARM32.def"
 #include "IceOperand.h"
 
 namespace Ice {
 namespace ARM32 {
 
+/// Encoding of an ARM 32-bit instruction.
+using IValueT = uint32_t;
+
+/// An Offset value (+/-) used in an ARM 32-bit instruction.
+using IOffsetT = int32_t;
+
 class TargetARM32;
 
 /// OperandARM32 extends the Operand hierarchy. Its subclasses are
 /// OperandARM32Mem and OperandARM32Flex.
 class OperandARM32 : public Operand {
   OperandARM32() = delete;
   OperandARM32(const OperandARM32 &) = delete;
   OperandARM32 &operator=(const OperandARM32 &) = delete;
 
 public:
@@ skipping 317 matching lines @@
 
 /// Base class for ARM instructions. While most ARM instructions can be
 /// conditionally executed, a few of them are not predicable (halt, memory
 /// barriers, etc.).
 class InstARM32 : public InstTarget {
   InstARM32() = delete;
   InstARM32(const InstARM32 &) = delete;
   InstARM32 &operator=(const InstARM32 &) = delete;
 
 public:
+  // Defines form that assembly instruction should be synthesized.
+  enum OutputForm { TextualOutput, BinaryOutput };
+
   enum InstKindARM32 {
     k__Start = Inst::Target,
     Adc,
     Add,
     And,
     Asr,
     Bic,
     Br,
     Call,
     Clz,
@@ skipping 45 matching lines @@
     Vsqrt,
     Vsub
   };
 
   static constexpr size_t InstSize = sizeof(uint32_t);
 
   static const char *getWidthString(Type Ty);
   static const char *getVecWidthString(Type Ty);
   static CondARM32::Cond getOppositeCondition(CondARM32::Cond Cond);
 
+  template <OutputForm> inline void startNextAsmInst(const Cfg *Func) const;
+
   /// Called inside derived methods emit() to communicate that multiple
   /// instructions are being generated. Used by emitIAS() methods to
   /// generate textual fixups for instructions that are not yet
   /// implemented.
   void startNextInst(const Cfg *Func) const;
 
   /// Shared emit routines for common forms of instructions.
   static void emitThreeAddrFP(const char *Opcode, const InstARM32 *Inst,
                               const Cfg *Func);
   static void emitFourAddrFP(const char *Opcode, const InstARM32 *Inst,
@@ skipping 608 matching lines @@
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Call); }
 
 private:
   InstARM32Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
 };
 
 /// Pops a list of registers. It may be a list of GPRs, or a list of VFP "s"
 /// regs, but not both. In any case, the list must be sorted.
 class InstARM32Pop : public InstARM32 {

[John, 2016/01/06 16:10:21]

Push and pop have nearly-identical emitters. It seems like there should be a

class InstARM32RegisterSaveRegister : public InstARM32 {
protected:
  void Assemble(OutputForm);
  virtual void emitSingle(OutputForm, Variable *Variable) = 0;
  virtual void emitMultiple(OutputForm, RegisterList) = 0;
};

class InstARM32Pop : public InstARM32RegisterSaveRegister {
protected:
  void emitSingle(OutputForm, Variable *Variable) override {
    switch (OutputForm) {
      case Binary:
        Asm->pop(...);
        return;
      case Textual: {
        if (!BuildDefs::dump())
          return;
        inline emitPop() here.
      }
    }
  }
}

class InstARM32Push : public InstARM32RegisterSaveRegister {}

This also gets rid of the template functions. Templates would definitively be
more efficient here, but the non-templated-code is easier to follow.

[Karl, 2016/01/06 23:21:58]

Rewrote with base class and virtuals.

   InstARM32Pop() = delete;
   InstARM32Pop(const InstARM32Pop &) = delete;
   InstARM32Pop &operator=(const InstARM32Pop &) = delete;
 
 public:
   static InstARM32Pop *create(Cfg *Func, const VarList &Dests) {
     return new (Func->allocate<InstARM32Pop>()) InstARM32Pop(Func, Dests);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Pop); }
 
 private:
   InstARM32Pop(Cfg *Func, const VarList &Dests);
-
+  template <OutputForm> inline void assemble(const Cfg *Func) const;
+  void emitPop(const Cfg *Func) const;
+  template <OutputForm>
+  inline void emitPop(const Cfg *Func, const Variable *Reg) const;
+  template <OutputForm>
+  inline void emitPopList(const Cfg *Func, ARM32::IValueT Registers) const;
+  template <OutputForm>
+  inline void emitVpop(const Cfg *Func, const Variable *BaseReg,
+                       SizeT RegCount) const;
   VarList Dests;
 };
 
 /// Pushes a list of registers. Just like Pop (see above), the list may be of
 /// GPRs, or VFP "s" registers, but not both.
 class InstARM32Push : public InstARM32 {
   InstARM32Push() = delete;
   InstARM32Push(const InstARM32Push &) = delete;
   InstARM32Push &operator=(const InstARM32Push &) = delete;
 
 public:
   static InstARM32Push *create(Cfg *Func, const VarList &Srcs) {
     return new (Func->allocate<InstARM32Push>()) InstARM32Push(Func, Srcs);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Push); }
 
 private:
   InstARM32Push(Cfg *Func, const VarList &Srcs);
+  void emitPush(const Cfg *Func) const;
+  template <OutputForm> inline void assemble(const Cfg *Func) const;
+  template <OutputForm>
+  inline void emitPush(const Cfg *Func, const Variable *Reg) const;
+  template <OutputForm>
+  inline void emitPushList(const Cfg *Func, ARM32::IValueT Registers) const;
+  template <OutputForm>
+  inline void emitVPush(const Cfg *Func, const Variable *BaseReg,
+                        SizeT RegCount) const;
 };
 
 /// Ret pseudo-instruction. This is actually a "bx" instruction with an "lr"
 /// register operand, but epilogue lowering will search for a Ret instead of a
 /// generic "bx". This instruction also takes a Source operand (for non-void
 /// returning functions) for liveness analysis, though a FakeUse before the ret
 /// would do just as well.
 ///
 /// NOTE: Even though "bx" can be predicated, for now leave out the predication
 /// since it's not yet known to be useful for Ret. That may complicate finding
@@ skipping 266 matching lines @@
 // violations and link errors.
 
 template <> void InstARM32Ldr::emit(const Cfg *Func) const;
 template <> void InstARM32Movw::emit(const Cfg *Func) const;
 template <> void InstARM32Movt::emit(const Cfg *Func) const;
 
 } // end of namespace ARM32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTARM32_H