[SubZero] Implement load and store for MIPS

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 92 matching lines @@
     return Operand->getKind() == static_cast<OperandKind>(kMem);
   }
 
   /// Return true if a load/store instruction for an element of type Ty
   /// can encode the Offset directly in the immediate field of the 32-bit
   /// MIPS instruction. For some types, if the load is Sign extending, then
   /// the range is reduced.
   static bool canHoldOffset(Type Ty, bool SignExt, int32_t Offset);
 
   void dump(const Cfg *Func, Ostream &Str) const override {
-    (void)Func;
-    (void)Str;
+    if (!BuildDefs::dump())
+      return;
+    Str << "[";
+    if (Func)
+      getBase()->dump(Func);
+    else
+      getBase()->dump(Str);
+    Str << ", ";
+    getOffset()->dump(Func, Str);
+    Str << "] AddrMode==";
+    if (getAddrMode() == Offset) {
+      Str << "Offset";
+    } else {
+      Str << "Unknown";
+    }
   }
 
 private:
   OperandMIPS32Mem(Cfg *Func, Type Ty, Variable *Base, Operand *ImmOffset,
                    AddrMode Mode);
 
   Variable *Base;
   Operand *const ImmOffset;
   const AddrMode Mode;
 };
@@ skipping 383 matching lines @@
   static InstMIPS32Load *create(Cfg *Func, Variable *Value,
                                 OperandMIPS32Mem *Mem, RelocOp Reloc = RO_No) {
     return new (Func->allocate<InstMIPS32Load>())
         InstMIPS32Load(Func, Value, Mem, Reloc);
   }
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrEmit();
-    assert(getSrcSize() == 1);
-    Str << "\t" << Opcode << "\t";
+    const Type Ty = getDest()->getType();
+    if (Ty == IceType_i8 || Ty == IceType_i1) {

[Jim Stichnoth, 2016/09/03 13:47:13]

Maybe use a switch statement instead?  (here and below)

[jaydeep.patil, 2016/09/04 06:24:30]

Done.

+      Str << "\t" << "lb" << "\t";
+    } else if (Ty == IceType_i16) {
+      Str << "\t" << "lh" << "\t";
+    } else if (Ty == IceType_i32) {
+      Str << "\t" << "lw" << "\t";
+    } else if (Ty == IceType_f32) {
+      Str << "\t" << "lwc1" << "\t";
+    } else if (Ty == IceType_f64) {
+      Str << "\t" << "ldc1" << "\t";
+    } else {
+      llvm_unreachable("InstMIPS32Load unknown type");
+    }
     getDest()->emit(Func);
     Str << ", ";
     emitRelocOp(Str, Reloc);
     getSrc(0)->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";
+    dumpOpcode(Str, Opcode, getDest()->getType());
+    Str << " ";
     getDest()->dump(Func);
     Str << ", ";
     emitRelocOp(Str, Reloc);
-    Str << (Reloc ? "(" : "");
     getSrc(0)->dump(Func);
-    Str << (Reloc ? ")" : "");
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstMIPS32Load(Cfg *Func, Variable *Value, OperandMIPS32Mem *Mem,
                  RelocOp Reloc = RO_No)
       : InstMIPS32(Func, K, 2, Value), Reloc(Reloc) {
     addSource(Mem);
   }
   static const char *Opcode;
@@ skipping 13 matching lines @@
                                  OperandMIPS32Mem *Mem, RelocOp Reloc = RO_No) {
     return new (Func->allocate<InstMIPS32Store>())
         InstMIPS32Store(Func, Value, Mem, Reloc);
   }
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 2);
-    Str << "\t" << Opcode << "\t";
+    const Type Ty = getSrc(0)->getType();
+    if (Ty == IceType_i8 || Ty == IceType_i1) {
+      Str << "\t" << "sb" << "\t";
+    } else if (Ty == IceType_i16) {
+      Str << "\t" << "sh" << "\t";
+    } else if (Ty == IceType_i32) {
+      Str << "\t" << "sw" << "\t";
+    } else if (Ty == IceType_f32) {
+      Str << "\t" << "swc1" << "\t";
+    } else if (Ty == IceType_f64) {
+      Str << "\t" << "sdc1" << "\t";
+    } else {
+      llvm_unreachable("InstMIPS32Store unknown type");
+    }
     getSrc(0)->emit(Func);
     Str << ", ";
     emitRelocOp(Str, Reloc);
     getSrc(1)->emit(Func);
   }
 
   void emitIAS(const Cfg *Func) const override {
     (void)Func;
-    llvm_unreachable("Not yet implemented");
+    llvm_unreachable("InstMIPS32Store: Not yet implemented");
   }
 
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
-    Str << "\t" << Opcode << "\t";
+    dumpOpcode(Str, Opcode, getSrc(0)->getType());
+    Str << " ";
     getSrc(0)->dump(Func);
     Str << ", ";
     emitRelocOp(Str, Reloc);
-    Str << (Reloc ? "(" : "");
     getSrc(1)->dump(Func);
-    Str << (Reloc ? ")" : "");
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstMIPS32Store(Cfg *Func, Variable *Value, OperandMIPS32Mem *Mem,
                   RelocOp Reloc = RO_No)
       : InstMIPS32(Func, K, 2, nullptr), Reloc(Reloc) {
     addSource(Value);
     addSource(Mem);
   }
@@ skipping 160 matching lines @@
   }
 
   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();
+    dumpOpcode(Str, Opcode, getDest()->getType());
     Str << " ";
-    Str << "\t" << Opcode << "\t";
     dumpDest(Func);
     Str << ", ";
     dumpSources(Func);
+    Str << ", ";
     if (Signed)
       Str << (int32_t)Imm;
     else
       Str << Imm;
   }
 
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstMIPS32Imm16(Cfg *Func, Variable *Dest, Operand *Source, uint32_t Imm)
@@ skipping 119 matching lines @@
 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;
 template <> void InstMIPS32Lui::emit(const Cfg *Func) const;
 
 } // end of namespace MIPS32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTMIPS32_H