emitIAS for icmp, and test, movss-reg, movq, movups, storep, storeq, tighten some of the Xmm ops

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - Low-level x86 instructions --*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the InstX8632 and OperandX8632 classes and
@@ skipping 182 matching lines @@
     Imul,
     Insertps,
     Label,
     Lea,
     Load,
     Mfence,
     Mov,
     Movd,
     Movp,
     Movq,
-    Movss,
+    MovssRegs,
     Movsx,
     Movzx,
     Mul,
     Mulps,
     Mulss,
     Neg,
     Nop,
     Or,
     Padd,
     Pand,
@@ skipping 300 matching lines @@
       : InstX8632(Func, K, 1, Dest) {
     addSource(Src);
   }
   InstX8632UnaryopGPR(const InstX8632UnaryopGPR &) = delete;
   InstX8632UnaryopGPR &operator=(const InstX8632UnaryopGPR &) = delete;
   ~InstX8632UnaryopGPR() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::GPREmitterRegOp Emitter;
 };
 
-void emitIASVarOperandTyXMM(const Cfg *Func, Type Ty, const Variable *Var,
-                            const Operand *Src,
-                            const x86::AssemblerX86::XmmEmitterTwoOps &Emitter);
+void emitIASRegOpTyXMM(const Cfg *Func, Type Ty, const Variable *Var,
+                       const Operand *Src,
+                       const x86::AssemblerX86::XmmEmitterRegOp &Emitter);
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632UnaryopXmm : public InstX8632 {
 public:
   static InstX8632UnaryopXmm *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstX8632UnaryopXmm>())
         InstX8632UnaryopXmm(Func, Dest, Src);
   }
   void emit(const Cfg *Func) const override {
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 1);
     Str << "\t" << Opcode << "\t";
     getDest()->emit(Func);
     Str << ", ";
     getSrc(0)->emit(Func);
     Str << "\n";
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
     assert(getSrcSize() == 1);
-    emitIASVarOperandTyXMM(Func, Ty, getDest(), getSrc(0), Emitter);
+    emitIASRegOpTyXMM(Func, Ty, getDest(), getSrc(0), Emitter);
   }
   void dump(const Cfg *Func) const override {
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632UnaryopXmm(Cfg *Func, Variable *Dest, Operand *Src)
       : InstX8632(Func, K, 1, Dest) {
     addSource(Src);
   }
   InstX8632UnaryopXmm(const InstX8632UnaryopXmm &) = delete;
   InstX8632UnaryopXmm &operator=(const InstX8632UnaryopXmm &) = delete;
   ~InstX8632UnaryopXmm() override {}
   static const char *Opcode;
-  static const x86::AssemblerX86::XmmEmitterTwoOps Emitter;
+  static const x86::AssemblerX86::XmmEmitterRegOp Emitter;
 };
 
 // See the definition of emitTwoAddress() for a description of
 // ShiftHack.
 void emitTwoAddress(const char *Opcode, const Inst *Inst, const Cfg *Func,
                     bool ShiftHack = false);
 
-template <InstX8632::InstKindX8632 K> class InstX8632Binop : public InstX8632 {
-public:
-  // Create a binary-op instruction (not yet migrated to integrated assembler)
-  static InstX8632Binop *create(Cfg *Func, Variable *Dest, Operand *Source) {
-    return new (Func->allocate<InstX8632Binop>())
-        InstX8632Binop(Func, Dest, Source);
-  }
-  void emit(const Cfg *Func) const override {
-    const bool ShiftHack = false;
-    emitTwoAddress(Opcode, this, Func, ShiftHack);
-  }
-  void dump(const Cfg *Func) const override {
-    Ostream &Str = Func->getContext()->getStrDump();
-    dumpDest(Func);
-    Str << " = " << Opcode << "." << getDest()->getType() << " ";
-    dumpSources(Func);
-  }
-  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
-
-private:
-  InstX8632Binop(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX8632(Func, K, 2, Dest) {
-    addSource(Dest);
-    addSource(Source);
-  }
-  InstX8632Binop(const InstX8632Binop &) = delete;
-  InstX8632Binop &operator=(const InstX8632Binop &) = delete;
-  ~InstX8632Binop() override {}
-  static const char *Opcode;
-};
-
 void emitIASGPRShift(const Cfg *Func, Type Ty, const Variable *Var,
                      const Operand *Src,
                      const x86::AssemblerX86::GPREmitterShiftOp &Emitter);
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632BinopGPRShift : public InstX8632 {
 public:
   // Create a binary-op GPR shift instruction.
   static InstX8632BinopGPRShift *create(Cfg *Func, Variable *Dest,
                                         Operand *Source) {
@@ skipping 78 matching lines @@
   }
   void emit(const Cfg *Func) const override {
     const bool ShiftHack = false;
     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
     if (NeedsElementType)
       Ty = typeElementType(Ty);
     assert(getSrcSize() == 2);
-    emitIASVarOperandTyXMM(Func, Ty, getDest(), getSrc(1), Emitter);
+    emitIASRegOpTyXMM(Func, Ty, getDest(), getSrc(1), Emitter);
   }
   void dump(const Cfg *Func) const override {
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632BinopXmm(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX8632(Func, K, 2, Dest) {
     addSource(Dest);
     addSource(Source);
   }
   InstX8632BinopXmm(const InstX8632BinopXmm &) = delete;
   InstX8632BinopXmm &operator=(const InstX8632BinopXmm &) = delete;
   ~InstX8632BinopXmm() override {}
   static const char *Opcode;
-  static const x86::AssemblerX86::XmmEmitterTwoOps Emitter;
+  static const x86::AssemblerX86::XmmEmitterRegOp Emitter;
 };
 
 void emitIASXmmShift(const Cfg *Func, Type Ty, const Variable *Var,
                      const Operand *Src,
                      const x86::AssemblerX86::XmmEmitterShiftOp &Emitter);
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632BinopXmmShift : public InstX8632 {
 public:
   // Create an XMM binary-op shift operation.
@@ skipping 125 matching lines @@
 public:
   static InstX8632Movlike *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Movlike>())
         InstX8632Movlike(Func, Dest, Source);
   }
   bool isRedundantAssign() const override {
     return checkForRedundantAssign(getDest(), getSrc(0));
   }
   bool isSimpleAssign() const override { return true; }
   void emit(const Cfg *Func) const override;
+  void emitIAS(const Cfg *Func) const override { emit(Func); }
   void dump(const Cfg *Func) const override {
     Ostream &Str = Func->getContext()->getStrDump();
     Str << Opcode << "." << getDest()->getType() << " ";
     dumpDest(Func);
     Str << ", ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
@@ skipping 49 matching lines @@
 typedef InstX8632BinopXmm<InstX8632::Divps, true> InstX8632Divps;
 typedef InstX8632BinopXmm<InstX8632::Divss, false> InstX8632Divss;
 typedef InstX8632BinopGPRShift<InstX8632::Rol> InstX8632Rol;
 typedef InstX8632BinopGPRShift<InstX8632::Shl> InstX8632Shl;
 typedef InstX8632BinopXmmShift<InstX8632::Psll> InstX8632Psll;
 typedef InstX8632BinopGPRShift<InstX8632::Shr> InstX8632Shr;
 typedef InstX8632BinopGPRShift<InstX8632::Sar> InstX8632Sar;
 typedef InstX8632BinopXmmShift<InstX8632::Psra> InstX8632Psra;
 typedef InstX8632BinopXmm<InstX8632::Pcmpeq, true> InstX8632Pcmpeq;
 typedef InstX8632BinopXmm<InstX8632::Pcmpgt, true> InstX8632Pcmpgt;
-// TODO: movss is only a binary operation when the source and dest
-// operands are both registers.  In other cases, it behaves like a copy
-// (mov-like) operation.  Eventually, InstX8632Movss should assert that
-// both its source and dest operands are registers, and the lowering
-// code should use _mov instead of _movss in cases where a copy
-// operation is intended.
-typedef InstX8632Binop<InstX8632::Movss> InstX8632Movss;
+// movss is only a binary operation when the source and dest
+// operands are both registers (the high bits of dest are left untouched).
+// In other cases, it behaves like a copy (mov-like) operation (and the
+// high bits of dest are cleared).
+// InstX8632Movss will assert that both its source and dest operands are
+// registers, so the lowering code should use _mov instead of _movss
+// in cases where a copy operation is intended.
+typedef InstX8632BinopXmm<InstX8632::MovssRegs, false> InstX8632MovssRegs;
 typedef InstX8632Ternop<InstX8632::Idiv> InstX8632Idiv;
 typedef InstX8632Ternop<InstX8632::Div> InstX8632Div;
 typedef InstX8632Ternop<InstX8632::Insertps> InstX8632Insertps;
 typedef InstX8632Ternop<InstX8632::Pinsr> InstX8632Pinsr;
 typedef InstX8632Ternop<InstX8632::Shufps> InstX8632Shufps;
 typedef InstX8632Ternop<InstX8632::Blendvps> InstX8632Blendvps;
 typedef InstX8632Ternop<InstX8632::Pblendvb> InstX8632Pblendvb;
 typedef InstX8632ThreeAddressop<InstX8632::Pextr> InstX8632Pextr;
 typedef InstX8632ThreeAddressop<InstX8632::Pshufd> InstX8632Pshufd;
 
@@ skipping 201 matching lines @@
 };
 
 // cmp - Integer compare instruction.
 class InstX8632Icmp : public InstX8632 {
 public:
   static InstX8632Icmp *create(Cfg *Func, Operand *Src1, Operand *Src2) {
     return new (Func->allocate<InstX8632Icmp>())
         InstX8632Icmp(Func, Src1, Src2);
   }
   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, Icmp); }
 
 private:
   InstX8632Icmp(Cfg *Func, Operand *Src1, Operand *Src2);
   InstX8632Icmp(const InstX8632Icmp &) = delete;
   InstX8632Icmp &operator=(const InstX8632Icmp &) = delete;
   ~InstX8632Icmp() override {}
 };
 
@@ skipping 16 matching lines @@
   ~InstX8632Ucomiss() override {}
 };
 
 // UD2 instruction.
 class InstX8632UD2 : public InstX8632 {
 public:
   static InstX8632UD2 *create(Cfg *Func) {
     return new (Func->allocate<InstX8632UD2>()) InstX8632UD2(Func);
   }
   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, UD2); }
 
 private:
   InstX8632UD2(Cfg *Func);
   InstX8632UD2(const InstX8632UD2 &) = delete;
   InstX8632UD2 &operator=(const InstX8632UD2 &) = delete;
   ~InstX8632UD2() override {}
 };
 
 // Test instruction.
 class InstX8632Test : public InstX8632 {
 public:
   static InstX8632Test *create(Cfg *Func, Operand *Source1, Operand *Source2) {
     return new (Func->allocate<InstX8632Test>())
         InstX8632Test(Func, Source1, Source2);
   }
   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, Test); }
 
 private:
   InstX8632Test(Cfg *Func, Operand *Source1, Operand *Source2);
   InstX8632Test(const InstX8632Test &) = delete;
   InstX8632Test &operator=(const InstX8632Test &) = delete;
   ~InstX8632Test() override {}
 };
 
@@ skipping 28 matching lines @@
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Store); }
 
 private:
   InstX8632Store(Cfg *Func, Operand *Value, OperandX8632 *Mem);
   InstX8632Store(const InstX8632Store &) = delete;
   InstX8632Store &operator=(const InstX8632Store &) = delete;
   ~InstX8632Store() override {}
 };
 
+// This is essentially a vector "mov" instruction with an OperandX8632Mem
+// operand instead of Variable as the destination.  It's important
+// for liveness that there is no Dest operand. The source must be an
+// Xmm register, since Dest is mem.
 class InstX8632StoreP : public InstX8632 {
 public:
-  static InstX8632StoreP *create(Cfg *Func, Operand *Value, OperandX8632 *Mem) {
+  static InstX8632StoreP *create(Cfg *Func, Variable *Value,
+                                 OperandX8632Mem *Mem) {
     return new (Func->allocate<InstX8632StoreP>())
         InstX8632StoreP(Func, Value, Mem);
   }
   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, StoreP); }
 
 private:
-  InstX8632StoreP(Cfg *Func, Operand *Value, OperandX8632 *Mem);
+  InstX8632StoreP(Cfg *Func, Variable *Value, OperandX8632Mem *Mem);
   InstX8632StoreP(const InstX8632StoreP &) = delete;
   InstX8632StoreP &operator=(const InstX8632StoreP &) = delete;
   ~InstX8632StoreP() override {}
 };
 
-// This is essentially a "movq" instruction with an OperandX8632Mem
-// operand instead of Variable as the destination.  It's important
-// for liveness that there is no Dest operand.
 class InstX8632StoreQ : public InstX8632 {
 public:
-  static InstX8632StoreQ *create(Cfg *Func, Operand *Value, OperandX8632 *Mem) {
+  static InstX8632StoreQ *create(Cfg *Func, Variable *Value,
+                                 OperandX8632Mem *Mem) {
     return new (Func->allocate<InstX8632StoreQ>())
         InstX8632StoreQ(Func, Value, Mem);
   }
   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, StoreQ); }
 
 private:
-  InstX8632StoreQ(Cfg *Func, Operand *Value, OperandX8632 *Mem);
+  InstX8632StoreQ(Cfg *Func, Variable *Value, OperandX8632Mem *Mem);
   InstX8632StoreQ(const InstX8632StoreQ &) = delete;
   InstX8632StoreQ &operator=(const InstX8632StoreQ &) = delete;
   ~InstX8632StoreQ() override {}
 };
 
 // Movsx - copy from a narrower integer type to a wider integer
 // type, with sign extension.
 class InstX8632Movsx : public InstX8632 {
 public:
   static InstX8632Movsx *create(Cfg *Func, Variable *Dest, Operand *Source) {
@@ skipping 218 matching lines @@
 template <> void InstX8632Psra::emit(const Cfg *Func) const;
 template <> void InstX8632Psub::emit(const Cfg *Func) const;
 template <> void InstX8632Sqrtss::emit(const Cfg *Func) const;
 template <> void InstX8632Subss::emit(const Cfg *Func) const;
 
 template <> void InstX8632Div::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Idiv::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Imul::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Cbwdq::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movd::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Movp::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Movq::emitIAS(const Cfg *Func) const;
+template <> void InstX8632MovssRegs::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pmull::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H