[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();
+    switch (Ty) {
+    case IceType_i1:
+    case IceType_i8:
+      Str << "\t"

[Jim Stichnoth, 2016/09/04 14:19:00]

A few suggestions/possibilities for future CLs.

1. Instead of this:
  Str << "\t" << "xxx" << "\t"
you can do this:
  Str << "\t" "xxx" "\t"
which preserves the ability to find such text via "git grep -w xxx" but also
results in a smaller, faster pnacl-sz binary.  We try to use this pattern in
general, but I'm sure there are other places where this has slipped through.

2. You could simplify this by moving the two instances of "\t" outside the
switch statement.

3. This is a pattern where a string is modified according to some Type value. 
In Subzero, this is usually handled through static tables defined by x-macros. 
See for example the various string constants in ICETYPEARM32_TABLE or
ICETYPEX8664_TABLE.

[jaydeep.patil, 2016/09/05 04:51:48]

Acknowledged.

+          << "lb"
+          << "\t";
+      break;
+    case IceType_i16:
+      Str << "\t"
+          << "lh"
+          << "\t";
+      break;
+    case IceType_i32:
+      Str << "\t"
+          << "lw"
+          << "\t";
+      break;
+    case IceType_f32:
+      Str << "\t"
+          << "lwc1"
+          << "\t";
+      break;
+    case IceType_f64:
+      Str << "\t"
+          << "ldc1"
+          << "\t";
+      break;
+    default:
+      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();
+    switch (Ty) {
+    case IceType_i1:
+    case IceType_i8:
+      Str << "\t"
+          << "sb"
+          << "\t";
+      break;
+    case IceType_i16:
+      Str << "\t"
+          << "sh"
+          << "\t";
+      break;
+    case IceType_i32:
+      Str << "\t"
+          << "sw"
+          << "\t";
+      break;
+    case IceType_f32:
+      Str << "\t"
+          << "swc1"
+          << "\t";
+      break;
+    case IceType_f64:
+      Str << "\t"
+          << "sdc1"
+          << "\t";
+      break;
+    default:
+      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