Subzero: Mips: Lower some i64 arithmetic instructions

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 100 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,
+    Addu,
     And,
     Addiu,
+    Call,
     La,
     Lui,
     Mov, // actually a pseudo op for addi rd, rs, 0
     Mul,
     Or,
     Ori,
     Ret,
     Sub,
+    Subu,
+    Sltu,
     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;
   }
 
+  // TODO(rkotler): while branching is not implemented
+  bool repointEdges(CfgNode *, CfgNode *) override { return true; }
+
   /// 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) {
@@ skipping 114 matching lines @@
   InstMIPS32ThreeAddrGPR(Cfg *Func, Variable *Dest, Variable *Src0,
                          Variable *Src1)
       : InstMIPS32(Func, K, 2, Dest) {
     addSource(Src0);
     addSource(Src1);
   }
 
   static const char *Opcode;
 };
 
+class InstMIPS32Call : public InstMIPS32 {
+  InstMIPS32Call() = delete;
+  InstMIPS32Call(const InstMIPS32Call &) = delete;
+  InstMIPS32Call &operator=(const InstMIPS32Call &) = delete;
+
+public:
+  static InstMIPS32Call *create(Cfg *Func, Variable *Dest,
+                                Operand *CallTarget) {
+    return new (Func->allocate<InstMIPS32Call>())
+        InstMIPS32Call(Func, Dest, CallTarget);
+  }
+  Operand *getCallTarget() const { return getSrc(0); }
+  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, Call); }
+
+private:
+  InstMIPS32Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
+};
+
 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 53 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;
 };
 
 using InstMIPS32Add = InstMIPS32ThreeAddrGPR<InstMIPS32::Add>;
+using InstMIPS32Addu = InstMIPS32ThreeAddrGPR<InstMIPS32::Addu>;
 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 InstMIPS32Sltu = InstMIPS32ThreeAddrGPR<InstMIPS32::Sltu>;
 using InstMIPS32Sub = InstMIPS32ThreeAddrGPR<InstMIPS32::Sub>;
+using InstMIPS32Subu = InstMIPS32ThreeAddrGPR<InstMIPS32::Subu>;
 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:
@@ skipping 26 matching lines @@
   void emitSingleDestMultiSource(const Cfg *Func) const;
   void emitSingleDestSingleSource(const Cfg *Func) const;
 
   Variable *DestHi = nullptr;
 };
 
 } // end of namespace MIPS32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTMIPS32_H