[Subzero][MIPS32] Add LowerStore implementation

src/IceInstMIPS32.h

 //===- subzero/src/IceInstMIPS32.h - MIPS32 machine instrs --*- C++ -*-===    //
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 134 matching lines @@
     Slt,
     Slti,
     Sltiu,
     Sltu,
     Sra,
     Srav,
     Srl,
     Srlv,
     Sub,
     Subu,
+    Sw,
     Xor,
     Xori
   };
 
   static const char *getWidthString(Type Ty);
 
   void dump(const Cfg *Func) const override;
 
   void dumpOpcode(Ostream &Str, const char *Opcode, Type Ty) const {
     Str << Opcode << "." << Ty;
@@ skipping 135 matching lines @@
   InstMIPS32ThreeAddrGPR(Cfg *Func, Variable *Dest, Variable *Src0,
                          Variable *Src1)
       : InstMIPS32(Func, K, 2, Dest) {
     addSource(Src0);
     addSource(Src1);
   }
 
   static const char *Opcode;
 };
 
+// InstMIPS32Memory represents instructions which loads/stores data on memory
+// Its format is "OPCODE GPR, OFFSET(BASE GPR)"
+template <InstMIPS32::InstKindMIPS32 K>
+class InstMIPS32Memory : public InstMIPS32 {
+  InstMIPS32Memory() = delete;
+  InstMIPS32Memory(const InstMIPS32Memory &) = delete;
+  InstMIPS32Memory &operator=(const InstMIPS32Memory &) = delete;
+
+public:
+  static InstMIPS32Memory *create(Cfg *Func, Variable *Value,
+                                  OperandMIPS32Mem *Mem) {
+    return new (Func->allocate<InstMIPS32Memory>())
+        InstMIPS32Memory(Func, Value, Mem);
+  }
+
+  void emit(const Cfg *Func) const override {
+    if (!BuildDefs::dump())
+      return;
+    Ostream &Str = Func->getContext()->getStrEmit();
+    assert(getSrcSize() == 2);
+    Str << "\t" << Opcode << "\t";
+    getSrc(0)->emit(Func);
+    Str << ", ";
+    getSrc(1)->emit(Func);
+  }
+
+  void emitIAS(const Cfg *Func) const override {
+    (void)Func;
+    llvm_unreachable("Not yet implemented");
+  }
+
+  void dump(const Cfg *Func) const override {
+    if (!BuildDefs::dump())
+      return;
+    Ostream &Str = Func->getContext()->getStrDump();
+    Str << "\t" << Opcode << "\t";
+    Str << " ";
+    getSrc(1)->dump(Func);
+    Str << ", ";
+    getSrc(0)->dump(Func);
+  }
+  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+
+private:
+  InstMIPS32Memory(Cfg *Func, Variable *Value, OperandMIPS32Mem *Mem)
+      : InstMIPS32(Func, K, 2, nullptr) {
+    addSource(Value);
+    addSource(Mem);
+  }
+  static const char *Opcode;
+};
+
 // InstMIPS32Label represents an intra-block label that is the target of an
 // intra-block branch. The offset between the label and the branch must be fit
 // in the instruction immediate (considered "near").
 class InstMIPS32Label : public InstMIPS32 {
   InstMIPS32Label() = delete;
   InstMIPS32Label(const InstMIPS32Label &) = delete;
   InstMIPS32Label &operator=(const InstMIPS32Label &) = delete;
 
 public:
   static InstMIPS32Label *create(Cfg *Func, TargetMIPS32 *Target) {
@@ skipping 170 matching lines @@
 using InstMIPS32Slt = InstMIPS32ThreeAddrGPR<InstMIPS32::Slt>;
 using InstMIPS32Slti = InstMIPS32Imm16<InstMIPS32::Slti>;
 using InstMIPS32Sltiu = InstMIPS32Imm16<InstMIPS32::Sltiu>;
 using InstMIPS32Sltu = InstMIPS32ThreeAddrGPR<InstMIPS32::Sltu>;
 using InstMIPS32Sra = InstMIPS32Imm16<InstMIPS32::Sra>;
 using InstMIPS32Srav = InstMIPS32ThreeAddrGPR<InstMIPS32::Srav>;
 using InstMIPS32Srl = InstMIPS32Imm16<InstMIPS32::Srl>;
 using InstMIPS32Srlv = InstMIPS32ThreeAddrGPR<InstMIPS32::Srlv>;
 using InstMIPS32Sub = InstMIPS32ThreeAddrGPR<InstMIPS32::Sub>;
 using InstMIPS32Subu = InstMIPS32ThreeAddrGPR<InstMIPS32::Subu>;
+using InstMIPS32Sw = InstMIPS32Memory<InstMIPS32::Sw>;
 using InstMIPS32Ori = InstMIPS32Imm16<InstMIPS32::Ori>;
 using InstMIPS32Xor = InstMIPS32ThreeAddrGPR<InstMIPS32::Xor>;
 using InstMIPS32Xori = InstMIPS32Imm16<InstMIPS32::Xori>;
 
 /// Handles (some of) vmov's various formats.
 class InstMIPS32Mov final : public InstMIPS32 {
   InstMIPS32Mov() = delete;
   InstMIPS32Mov(const InstMIPS32Mov &) = delete;
   InstMIPS32Mov &operator=(const InstMIPS32Mov &) = delete;
 
@@ skipping 38 matching lines @@
 template <> void InstMIPS32Mfhi::emit(const Cfg *Func) const;
 template <> void InstMIPS32Mtlo::emit(const Cfg *Func) const;
 template <> void InstMIPS32Mthi::emit(const Cfg *Func) const;
 template <> void InstMIPS32Mult::emit(const Cfg *Func) const;
 template <> void InstMIPS32Multu::emit(const Cfg *Func) const;
 
 } // end of namespace MIPS32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTMIPS32_H