Lower a few basic MIPS binops for i{8,16,32,64}.

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 96 matching lines @@
 
 /// Base class for Mips instructions.
 class InstMIPS32 : public InstTarget {
   InstMIPS32() = delete;
   InstMIPS32(const InstMIPS32 &) = delete;
   InstMIPS32 &operator=(const InstMIPS32 &) = delete;
 
 public:
   enum InstKindMIPS32 {
     k__Start = Inst::Target,
+    Add,
+    And,
     Addiu,
     La,
     Lui,
     Mov, // actually a pseudo op for addi rd, rs, 0
+    Mul,
+    Or,
     Ori,
-    Ret
+    Ret,
+    Sub,
+    Xor
   };
 
   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;
   }
 
   /// Shared emit routines for common forms of instructions.
   static void emitUnaryopGPR(const char *Opcode, const InstMIPS32 *Inst,
                              const Cfg *Func);
+  static void emitThreeAddr(const char *Opcode, const InstMIPS32 *Inst,
+                            const Cfg *Func);
 
 protected:
   InstMIPS32(Cfg *Func, InstKindMIPS32 Kind, SizeT Maxsrcs, Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
   static bool isClassof(const Inst *Inst, InstKindMIPS32 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
   }
 };
 
 /// Ret pseudo-instruction. This is actually a "jr" instruction with an "ra"
@@ skipping 60 matching lines @@
 protected:
   InstMIPS32UnaryopGPR(Cfg *Func, Variable *Dest, Operand *Src)
       : InstMIPS32(Func, K, 1, Dest) {
     addSource(Src);
   }
 
 private:
   static const char *Opcode;
 };
 
+/// Instructions of the form x := y op z. May have the side-effect of setting
+/// status flags.
+template <InstMIPS32::InstKindMIPS32 K>
+class InstMIPS32ThreeAddrGPR : public InstMIPS32 {
+  InstMIPS32ThreeAddrGPR() = delete;
+  InstMIPS32ThreeAddrGPR(const InstMIPS32ThreeAddrGPR &) = delete;
+  InstMIPS32ThreeAddrGPR &operator=(const InstMIPS32ThreeAddrGPR &) = delete;
+
+public:
+  /// Create an ordinary binary-op instruction like add, and sub. Dest and Src1
+  /// must be registers.
+  static InstMIPS32ThreeAddrGPR *create(Cfg *Func, Variable *Dest,
+                                        Variable *Src0, Operand *Src1) {
+    return new (Func->allocate<InstMIPS32ThreeAddrGPR>())
+        InstMIPS32ThreeAddrGPR(Func, Dest, Src0, Src1);
+  }
+  void emit(const Cfg *Func) const override {
+    if (!BuildDefs::dump())
+      return;
+    emitThreeAddr(Opcode, this, 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();
+    dumpDest(Func);
+    Str << " = ";
+    dumpOpcode(Str, Opcode, getDest()->getType());
+    Str << (SetFlags ? ".s " : " ");
+    dumpSources(Func);
+  }
+  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+
+private:
+  InstMIPS32ThreeAddrGPR(Cfg *Func, Variable *Dest, Variable *Src0,
+                         Operand *Src1)
+      : InstMIPS32(Func, K, 2, Dest) {
+    addSource(Src0);
+    addSource(Src1);
+  }
+
+  static const char *Opcode;
+  bool SetFlags;

[Jim Stichnoth, 2015/11/04 14:47:24]

This isn't initialized anywhere.  I think it needs to be an argument to the ctor
and the create() method, like in its ARM counterpart.

[rkotlerimgtec, 2015/11/05 01:28:43]

This variable is not needed. Was copied from ARM part and is not used, except in
one other place in a dump routine which needs to be deleted because it is not
needed.

+};
+
 template <InstMIPS32::InstKindMIPS32 K, bool Signed = false>
 class InstMIPS32Imm16 : public InstMIPS32 {
   InstMIPS32Imm16() = delete;
   InstMIPS32Imm16(const InstMIPS32Imm16 &) = delete;
   InstMIPS32Imm16 &operator=(const InstMIPS32Imm16 &) = delete;
 
 public:
   static InstMIPS32Imm16 *create(Cfg *Func, Variable *Dest, Operand *Source,
                                  uint32_t Imm) {
     return new (Func->allocate<InstMIPS32Imm16>())
@@ skipping 52 matching lines @@
   }
 
   InstMIPS32Imm16(Cfg *Func, Variable *Dest, uint32_t Imm)
       : InstMIPS32(Func, K, 0, Dest), Imm(Imm) {}
 
   static const char *Opcode;
 
   const uint32_t Imm;
 };
 
-typedef InstMIPS32Imm16<InstMIPS32::Addiu, true> InstMIPS32Addiu;
-typedef InstMIPS32Imm16<InstMIPS32::Lui> InstMIPS32Lui;
-typedef InstMIPS32UnaryopGPR<InstMIPS32::La> InstMIPS32La;
-typedef InstMIPS32Imm16<InstMIPS32::Ori> InstMIPS32Ori;
+using InstMIPS32Add = InstMIPS32ThreeAddrGPR<InstMIPS32::Add>;
+using InstMIPS32Addiu = InstMIPS32Imm16<InstMIPS32::Addiu, true>;
+using InstMIPS32And = InstMIPS32ThreeAddrGPR<InstMIPS32::And>;
+using InstMIPS32Lui = InstMIPS32Imm16<InstMIPS32::Lui>;
+using InstMIPS32La = InstMIPS32UnaryopGPR<InstMIPS32::La>;
+using InstMIPS32Mul = InstMIPS32ThreeAddrGPR<InstMIPS32::Mul>;
+using InstMIPS32Or = InstMIPS32ThreeAddrGPR<InstMIPS32::Or>;
+using InstMIPS32Ori = InstMIPS32Imm16<InstMIPS32::Ori>;
+using InstMIPS32Sub = InstMIPS32ThreeAddrGPR<InstMIPS32::Sub>;
+using InstMIPS32Ori = InstMIPS32Imm16<InstMIPS32::Ori>;
+using InstMIPS32Xor = InstMIPS32ThreeAddrGPR<InstMIPS32::Xor>;
 
 /// Handles (some of) vmov's various formats.
 class InstMIPS32Mov final : public InstMIPS32 {
   InstMIPS32Mov() = delete;
   InstMIPS32Mov(const InstMIPS32Mov &) = delete;
   InstMIPS32Mov &operator=(const InstMIPS32Mov &) = delete;
 
 public:
   static InstMIPS32Mov *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstMIPS32Mov>()) InstMIPS32Mov(Func, Dest, Src);
@@ skipping 23 matching lines @@
   void emitMultiDestSingleSource(const Cfg *Func) const;
   void emitSingleDestMultiSource(const Cfg *Func) const;
   void emitSingleDestSingleSource(const Cfg *Func) const;
 
   Variable *DestHi = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTMIPS32_H