Subzero: Add fabs intrinsic support.

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 216 matching lines @@
     Pcmpgt,
     Pextr,
     Pinsr,
     Pmull,
     Pmuludq,
     Pop,
     Por,
     Pshufd,
     Psll,
     Psra,
+    Psrl,
     Psub,
     Push,
     Pxor,
     Ret,
     Rol,
     Sar,
     Sbb,
     Shl,
     Shld,
     Shr,
@@ skipping 532 matching lines @@
   }
   ~InstX8632BinopXmm() override {}
   static const char *Opcode;
   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>
+template <InstX8632::InstKindX8632 K, bool AllowAllTypes = false>
 class InstX8632BinopXmmShift : public InstX8632 {
   InstX8632BinopXmmShift() = delete;
   InstX8632BinopXmmShift(const InstX8632BinopXmmShift &) = delete;
   InstX8632BinopXmmShift &operator=(const InstX8632BinopXmmShift &) = delete;
 
 public:
   // Create an XMM binary-op shift operation.
   static InstX8632BinopXmmShift *create(Cfg *Func, Variable *Dest,
                                         Operand *Source) {
     return new (Func->allocate<InstX8632BinopXmmShift>())
         InstX8632BinopXmmShift(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
     if (!ALLOW_DUMP)
       return;
     const bool ShiftHack = false;
     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
-    assert(Ty == IceType_v8i16 || Ty == IceType_v8i1 || Ty == IceType_v4i32 ||
-           Ty == IceType_v4i1);
+    assert(AllowAllTypes || Ty == IceType_v8i16 || Ty == IceType_v8i1 ||

[jvoung (off chromium), 2015/03/19 16:37:53]

We might be able to get away with just removing the assert at this layer, and
the lower level assembler code will know what types are handled:

E.g., for psra:


  if (Ty == IceType_i16) {
    EmitUint8(0xE1);
  } else {
    assert(Ty == IceType_i32);
  //...
  }

but what's missing is the check that isVectorType(Ty)

[Jim Stichnoth, 2015/03/19 18:35:15]

The problem here is that psra's Ty argument is actually the element type (see 2
lines below this).  If Ty==IceType_i32, then ElementTy is also IceType_i32 which
psra will allow.

Maybe we could simplify this as a test for vector type, then let psll/psra/psrl
do the element-type check?

Except that psrl is explicitly used for fabs of scalar float and double so it
shouldn't be subject to an isVectorType check.

I made the isVectorType() simplification, ptal.

[jvoung (off chromium), 2015/03/19 18:50:33]

Ah, ok that's what I missed.
Okay this is a bit simpler / less specific to psra and psll.

+           Ty == IceType_v4i32 || Ty == IceType_v4i1);
     Type ElementTy = typeElementType(Ty);
     assert(getSrcSize() == 2);
     emitIASXmmShift(Func, ElementTy, getDest(), getSrc(1), Emitter);
   }
   void dump(const Cfg *Func) const override {
     if (!ALLOW_DUMP)
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
@@ skipping 184 matching lines @@
 typedef InstX8632BinopGPR<InstX8632::Imul> InstX8632Imul;
 typedef InstX8632BinopXmm<InstX8632::Mulps, true> InstX8632Mulps;
 typedef InstX8632BinopXmm<InstX8632::Mulss, false> InstX8632Mulss;
 typedef InstX8632BinopXmm<InstX8632::Pmull, true> InstX8632Pmull;
 typedef InstX8632BinopXmm<InstX8632::Pmuludq, false> InstX8632Pmuludq;
 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 InstX8632BinopXmmShift<InstX8632::Psrl, true> InstX8632Psrl;
 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;
 // 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
@@ skipping 599 matching lines @@
 template <> void InstX8632Padd::emit(const Cfg *Func) const;
 template <> void InstX8632Pblendvb::emit(const Cfg *Func) const;
 template <> void InstX8632Pcmpeq::emit(const Cfg *Func) const;
 template <> void InstX8632Pcmpgt::emit(const Cfg *Func) const;
 template <> void InstX8632Pextr::emit(const Cfg *Func) const;
 template <> void InstX8632Pinsr::emit(const Cfg *Func) const;
 template <> void InstX8632Pmull::emit(const Cfg *Func) const;
 template <> void InstX8632Pmuludq::emit(const Cfg *Func) const;
 template <> void InstX8632Psll::emit(const Cfg *Func) const;
 template <> void InstX8632Psra::emit(const Cfg *Func) const;
+template <> void InstX8632Psrl::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 InstX8632Blendvps::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Cbwdq::emitIAS(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 InstX8632Insertps::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movd::emitIAS(const Cfg *Func) const;
 template <> void InstX8632MovssRegs::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pblendvb::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pextr::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pinsr::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movsx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movzx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pmull::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pshufd::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Shufps::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H