Handle GPR and vector shift ops. Handle pmull also.

src/assembler_ia32.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===- subzero/src/assembler_ia32.h - Assembler for x86-32 ----------------===//
 //
 //                        The Subzero Code Generator
 //
@@ skipping 336 matching lines @@
   typedef void (AssemblerX86::*TypedEmitGPRAddr)(Type, GPRRegister,
                                                  const Address &);
   typedef void (AssemblerX86::*TypedEmitGPRImm)(Type, GPRRegister,
                                                 const Immediate &);
   struct GPREmitterRegOp {
     TypedEmitGPRGPR GPRGPR;
     TypedEmitGPRAddr GPRAddr;
     TypedEmitGPRImm GPRImm;
   };
 
+  struct GPREmitterShiftOp {
+    TypedEmitGPRGPR GPRGPR;
+    TypedEmitGPRImm GPRImm;
+    // Technically, Addr/GPR and Addr/Imm are also allowed, but */Addr are not.
+    // In practice, we always normalize the Dest to a Register first.
+  };
+
   // Operations to emit XMM instructions (and dispatch on operand type).
   typedef void (AssemblerX86::*TypedEmitXmmXmm)(Type, XmmRegister, XmmRegister);
   typedef void (AssemblerX86::*TypedEmitXmmAddr)(Type, XmmRegister,
                                                  const Address &);
   typedef void (AssemblerX86::*TypedEmitAddrXmm)(Type, const Address &,
                                                  XmmRegister);
   struct XmmEmitterTwoOps {
     TypedEmitXmmXmm XmmXmm;
     TypedEmitXmmAddr XmmAddr;
     TypedEmitAddrXmm AddrXmm;
   };
 
+  typedef void (AssemblerX86::*TypedEmitXmmImm)(Type, XmmRegister,
+                                                const Immediate &);
+
+  struct XmmEmitterShiftOp {
+    TypedEmitXmmXmm XmmXmm;
+    TypedEmitXmmAddr XmmAddr;
+    TypedEmitXmmImm XmmImm;
+  };
+
   /*
    * Emit Machine Instructions.
    */
   void call(GPRRegister reg);
   void call(const Address &address);
   void call(Label *label);
   void call(const ConstantRelocatable *label);
 
   static const intptr_t kCallExternalLabelSize = 5;
 
@@ skipping 67 matching lines @@
 
   void movups(XmmRegister dst, const Address &src);
   void movups(const Address &dst, XmmRegister src);
 
   void padd(Type Ty, XmmRegister dst, XmmRegister src);
   void padd(Type Ty, XmmRegister dst, const Address &src);
   void pand(Type Ty, XmmRegister dst, XmmRegister src);
   void pand(Type Ty, XmmRegister dst, const Address &src);
   void pandn(Type Ty, XmmRegister dst, XmmRegister src);
   void pandn(Type Ty, XmmRegister dst, const Address &src);
+  void pmull(Type Ty, XmmRegister dst, XmmRegister src);
+  void pmull(Type Ty, XmmRegister dst, const Address &src);
   void pmuludq(Type Ty, XmmRegister dst, XmmRegister src);
   void pmuludq(Type Ty, XmmRegister dst, const Address &src);
   void por(Type Ty, XmmRegister dst, XmmRegister src);
   void por(Type Ty, XmmRegister dst, const Address &src);
   void psub(Type Ty, XmmRegister dst, XmmRegister src);
   void psub(Type Ty, XmmRegister dst, const Address &src);
   void pxor(Type Ty, XmmRegister dst, XmmRegister src);
   void pxor(Type Ty, XmmRegister dst, const Address &src);
 
+  void psll(Type Ty, XmmRegister dst, XmmRegister src);
+  void psll(Type Ty, XmmRegister dst, const Address &src);
+  void psll(Type Ty, XmmRegister dst, const Immediate &src);
+
+  void psra(Type Ty, XmmRegister dst, XmmRegister src);
+  void psra(Type Ty, XmmRegister dst, const Address &src);
+  void psra(Type Ty, XmmRegister dst, const Immediate &src);
+
   void addps(Type Ty, XmmRegister dst, XmmRegister src);
   void addps(Type Ty, XmmRegister dst, const Address &src);
   void subps(Type Ty, XmmRegister dst, XmmRegister src);
   void subps(Type Ty, XmmRegister dst, const Address &src);
   void divps(Type Ty, XmmRegister dst, XmmRegister src);
   void divps(Type Ty, XmmRegister dst, const Address &src);
   void mulps(Type Ty, XmmRegister dst, XmmRegister src);
   void mulps(Type Ty, XmmRegister dst, const Address &src);
   void minps(XmmRegister dst, XmmRegister src);
   void maxps(XmmRegister dst, XmmRegister src);
@@ skipping 147 matching lines @@
 
   void mul(Type Ty, GPRRegister reg);
   void mul(Type Ty, const Address &address);
 
   void incl(GPRRegister reg);
   void incl(const Address &address);
 
   void decl(GPRRegister reg);
   void decl(const Address &address);
 
-  void shll(GPRRegister reg, const Immediate &imm);
-  void shll(GPRRegister operand, GPRRegister shifter);
-  void shll(const Address &operand, GPRRegister shifter);
-  void shrl(GPRRegister reg, const Immediate &imm);
-  void shrl(GPRRegister operand, GPRRegister shifter);
-  void sarl(GPRRegister reg, const Immediate &imm);
-  void sarl(GPRRegister operand, GPRRegister shifter);
-  void sarl(const Address &address, GPRRegister shifter);
+  void rol(Type Ty, GPRRegister reg, const Immediate &imm);
+  void rol(Type Ty, GPRRegister operand, GPRRegister shifter);
+  void rol(Type Ty, const Address &operand, GPRRegister shifter);
+
+  void shl(Type Ty, GPRRegister reg, const Immediate &imm);
+  void shl(Type Ty, GPRRegister operand, GPRRegister shifter);
+  void shl(Type Ty, const Address &operand, GPRRegister shifter);
+
+  void shr(Type Ty, GPRRegister reg, const Immediate &imm);
+  void shr(Type Ty, GPRRegister operand, GPRRegister shifter);
+  void shr(Type Ty, const Address &operand, GPRRegister shifter);
+
+  void sar(Type Ty, GPRRegister reg, const Immediate &imm);
+  void sar(Type Ty, GPRRegister operand, GPRRegister shifter);
+  void sar(Type Ty, const Address &address, GPRRegister shifter);
+
   void shld(GPRRegister dst, GPRRegister src);
   void shld(GPRRegister dst, GPRRegister src, const Immediate &imm);
   void shld(const Address &operand, GPRRegister src);
   void shrd(GPRRegister dst, GPRRegister src);
   void shrd(GPRRegister dst, GPRRegister src, const Immediate &imm);
   void shrd(const Address &dst, GPRRegister src);
 
   void neg(Type Ty, GPRRegister reg);
   void neg(Type Ty, const Address &addr);
   void notl(GPRRegister reg);
@@ skipping 64 matching lines @@
   void EmitOperand(int rm, const Operand &operand);
   void EmitImmediate(Type ty, const Immediate &imm);
   void EmitComplexI8(int rm, const Operand &operand,
                      const Immediate &immediate);
   void EmitComplex(Type Ty, int rm, const Operand &operand,
                    const Immediate &immediate);
   void EmitLabel(Label *label, intptr_t instruction_size);
   void EmitLabelLink(Label *label);
   void EmitNearLabelLink(Label *label);
 
-  void EmitGenericShift(int rm, GPRRegister reg, const Immediate &imm);
-  void EmitGenericShift(int rm, const Operand &operand, GPRRegister shifter);
+  void EmitGenericShift(int rm, Type Ty, GPRRegister reg, const Immediate &imm);
+  void EmitGenericShift(int rm, Type Ty, const Operand &operand,
+                        GPRRegister shifter);
 
   AssemblerBuffer buffer_;
 
   AssemblerX86(const AssemblerX86 &) = delete;
   AssemblerX86 &operator=(const AssemblerX86 &) = delete;
 };
 
 inline void AssemblerX86::EmitUint8(uint8_t value) {
   buffer_.Emit<uint8_t>(value);
 }
@@ skipping 18 matching lines @@
 inline void AssemblerX86::EmitFixup(AssemblerFixup *fixup) {
   buffer_.EmitFixup(fixup);
 }
 
 inline void AssemblerX86::EmitOperandSizeOverride() { EmitUint8(0x66); }
 
 } // end of namespace x86
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ASSEMBLER_IA32_H_