[Subzero][MIPS32] Implement sext, zext and trunc

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 103 matching lines @@
   InstMIPS32(const InstMIPS32 &) = delete;
   InstMIPS32 &operator=(const InstMIPS32 &) = delete;
 
 public:
   enum InstKindMIPS32 {
     k__Start = Inst::Target,
     Add,
     Addiu,
     Addu,
     And,
+    Andi,
     Br,
     Call,
     La,
     Label,
     Lui,
     Mfhi,
     Mflo,
     Mov, // actually a pseudo op for addi rd, rs, 0
     Mthi,
     Mtlo,
     Mul,
     Mult,
     Multu,
     Or,
     Ori,
     Ret,
+    Sll,
     Slt,
     Slti,
     Sltiu,
     Sltu,
+    Sra,
     Sub,
     Subu,
     Xor,
     Xori
   };
 
   static const char *getWidthString(Type Ty);
 
   void dump(const Cfg *Func) const override;
 
@@ skipping 243 matching lines @@
                                  uint32_t Imm) {
     return new (Func->allocate<InstMIPS32Imm16>())
         InstMIPS32Imm16(Func, Dest, Source, Imm);
   }
 
   static InstMIPS32Imm16 *create(Cfg *Func, Variable *Dest, uint32_t Imm) {
     return new (Func->allocate<InstMIPS32Imm16>())
         InstMIPS32Imm16(Func, Dest, Imm);
   }
 
+  static InstMIPS32Imm16 *create(Cfg *Func, Variable *Dest, Operand *Source,
+                                 ConstantInteger32 *Imm) {
+    return new (Func->allocate<InstMIPS32Imm16>())
+        InstMIPS32Imm16(Func, Dest, Source, Imm);
+  }
+
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrEmit();
     Str << "\t" << Opcode << "\t";
     getDest()->emit(Func);
     if (getSrcSize() > 0) {
       Str << ", ";
       getSrc(0)->emit(Func);
     }
@@ skipping 29 matching lines @@
 
 private:
   InstMIPS32Imm16(Cfg *Func, Variable *Dest, Operand *Source, uint32_t Imm)
       : InstMIPS32(Func, K, 1, Dest), Imm(Imm) {
     addSource(Source);
   }
 
   InstMIPS32Imm16(Cfg *Func, Variable *Dest, uint32_t Imm)
       : InstMIPS32(Func, K, 0, Dest), Imm(Imm) {}
 
+  InstMIPS32Imm16(Cfg *Func, Variable *Dest, Operand *Source,

[Jim Stichnoth, 2016/05/06 19:55:09]

Why is this new form needed?

It seems to me that if the specific MIPS instruction requires an Imm16 operand,
you might as well keep it simple and just use the uint32_t form?

It's really up to the TargetLowering implementation (e.g. MIPS32) to decide how
to handle these things, so I just wanted to understand the assumptions/direction
here.

[sagar.thakur, 2016/05/09 11:03:40]

I was following arm and x86 implementation of TargetLowering. Yes, this is
actually not needed here. I'll just use the uint32_t form.

+                  ConstantInteger32 *Imm)
+      : InstMIPS32(Func, K, 1, Dest), Imm(Imm->getValue()) {
+    addSource(Source);
+  }
+
   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 InstMIPS32Andi = InstMIPS32Imm16<InstMIPS32::Andi>;
 using InstMIPS32Lui = InstMIPS32Imm16<InstMIPS32::Lui>;
 using InstMIPS32La = InstMIPS32UnaryopGPR<InstMIPS32::La>;
 using InstMIPS32Mfhi = InstMIPS32UnaryopGPR<InstMIPS32::Mfhi>;
 using InstMIPS32Mflo = InstMIPS32UnaryopGPR<InstMIPS32::Mflo>;
 using InstMIPS32Mthi = InstMIPS32UnaryopGPR<InstMIPS32::Mthi>;
 using InstMIPS32Mtlo = InstMIPS32UnaryopGPR<InstMIPS32::Mtlo>;
 using InstMIPS32Mul = InstMIPS32ThreeAddrGPR<InstMIPS32::Mul>;
 using InstMIPS32Mult = InstMIPS32ThreeAddrGPR<InstMIPS32::Mult>;
 using InstMIPS32Multu = InstMIPS32ThreeAddrGPR<InstMIPS32::Multu>;
 using InstMIPS32Or = InstMIPS32ThreeAddrGPR<InstMIPS32::Or>;
 using InstMIPS32Ori = InstMIPS32Imm16<InstMIPS32::Ori>;
+using InstMIPS32Sll = InstMIPS32Imm16<InstMIPS32::Sll>;
 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 InstMIPS32Sub = InstMIPS32ThreeAddrGPR<InstMIPS32::Sub>;
 using InstMIPS32Subu = InstMIPS32ThreeAddrGPR<InstMIPS32::Subu>;
 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;
@@ skipping 40 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