Add option to force filetype=asm for testing

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 1117 matching lines @@
       Src1 /= 3;
     } else if (Src1 % 2 == 0) {
       if (Count2 == 0)
         ++CountOps;
       ++Count2;
       Src1 /= 2;
     } else {
       return false;
     }
   }
-  // Lea optimization only works for i16 and i32 types, not i8.
-  if (Ty != IceType_i16 && Ty != IceType_i32 && (Count3 || Count5 || Count9))
+  // Lea optimization only works for i32 type, not i8 or i16.

[Jim Stichnoth, 2016/01/12 14:54:02]

What's the story with i64 under x86-64?  Ask John, he just had to do something
in this area for x86-64 sandboxing.

[sehr, 2016/01/12 19:01:19]

Not supported either.  I changed the comment.

+  if (Ty != IceType_i32 && (Count3 || Count5 || Count9))
     return false;
   // Limit the number of lea/shl operations for a single multiply, to a
   // somewhat arbitrary choice of 3.
   constexpr uint32_t MaxOpsForOptimizedMul = 3;
   if (CountOps > MaxOpsForOptimizedMul)
     return false;
   _mov(T, Src0);
   Constant *Zero = Ctx->getConstantZero(IceType_i32);
   for (uint32_t i = 0; i < Count9; ++i) {
     constexpr uint16_t Shift = 3; // log2(9-1)
@@ skipping 4433 matching lines @@
     StackArgumentsSize = getCallStackArgumentsSizeBytes(Call);
     Context.insert(Call);
     Arith->setDeleted();
   } else if (auto *Cast = llvm::dyn_cast<InstCast>(Instr)) {
     InstCast::OpKind CastKind = Cast->getCastKind();
     Operand *Src0 = Cast->getSrc(0);
     const Type SrcType = Src0->getType();
     Variable *Dest = Cast->getDest();
     const Type DestTy = Dest->getType();
     const char *HelperName = nullptr;
+    Variable *CallDest = Dest;
     switch (CastKind) {
     default:
       return;
     case InstCast::Fptosi:
       if (!Traits::Is64Bit && DestTy == IceType_i64) {
         HelperName = isFloat32Asserting32Or64(SrcType) ? H_fptosi_f32_i64
                                                        : H_fptosi_f64_i64;
       } else {
         return;
       }
@@ skipping 45 matching lines @@
       break;
     case InstCast::Bitcast: {
       if (DestTy == Src0->getType())
         return;
       switch (DestTy) {
       default:
         return;
       case IceType_i8:
         assert(Src0->getType() == IceType_v8i1);
         HelperName = H_bitcast_8xi1_i8;
+        CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_i16:
         assert(Src0->getType() == IceType_v16i1);
         HelperName = H_bitcast_16xi1_i16;
+        CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_v8i1: {
         assert(Src0->getType() == IceType_i8);
         HelperName = H_bitcast_i8_8xi1;
         Variable *Src0AsI32 = Func->makeVariable(stackSlotType());
         // Arguments to functions are required to be at least 32 bits wide.
         Context.insert<InstCast>(InstCast::Zext, Src0AsI32, Src0);
         Src0 = Src0AsI32;
       } break;
       case IceType_v16i1: {
         assert(Src0->getType() == IceType_i16);
         HelperName = H_bitcast_i16_16xi1;
         Variable *Src0AsI32 = Func->makeVariable(stackSlotType());
         // Arguments to functions are required to be at least 32 bits wide.
         Context.insert<InstCast>(InstCast::Zext, Src0AsI32, Src0);
         Src0 = Src0AsI32;
       } break;
       }
     } break;
     }
     constexpr SizeT MaxSrcs = 1;
-    InstCall *Call = makeHelperCall(HelperName, Dest, MaxSrcs);
+    InstCall *Call = makeHelperCall(HelperName, CallDest, MaxSrcs);
     Call->addArg(Src0);
     StackArgumentsSize = getCallStackArgumentsSizeBytes(Call);
     Context.insert(Call);
+    // Sometimes we need to convert from i8 or i16 type to i32 to maintain ABI

[Jim Stichnoth, 2016/01/12 14:54:02]

This is a little confusing because we're actually converting from i32 to i8/i16.
 How about something like this:

The PNaCl ABI disallows i8/i16 return types, so truncate the helper call result
to the appropriate type as necessary.

[sehr, 2016/01/12 19:01:19]

Done.

+    // compatibility. If so, insert a conversion operator after the call.
+    if (CallDest != Dest)

[Jim Stichnoth, 2016/01/12 14:54:02]

I think it would be marginally more future-proof if the condition were
"CallDest->getType() != Dest->getType()".

[sehr, 2016/01/12 19:01:19]

Done.

+      Context.insert<InstCast>(InstCast::Trunc, Dest, CallDest);
     Cast->setDeleted();
   } else if (auto *Intrinsic = llvm::dyn_cast<InstIntrinsicCall>(Instr)) {
     std::vector<Type> ArgTypes;
     Type ReturnType = IceType_void;
     switch (Intrinsics::IntrinsicID ID = Intrinsic->getIntrinsicInfo().ID) {
     default:
       return;
     case Intrinsics::Ctpop: {
       Operand *Val = Intrinsic->getArg(0);
       Type ValTy = Val->getType();
@@ skipping 137 matching lines @@
                                                        int32_t RegNum) {
   return makeZeroedRegister(Ty, RegNum);
 }
 
 template <typename TraitsType>
 Variable *TargetX86Base<TraitsType>::makeVectorOfMinusOnes(Type Ty,
                                                            int32_t RegNum) {
   Variable *MinusOnes = makeReg(Ty, RegNum);
   // Insert a FakeDef so the live range of MinusOnes is not overestimated.
   Context.insert<InstFakeDef>(MinusOnes);
-  _pcmpeq(MinusOnes, MinusOnes);
+  if (Ty == IceType_f64)
+    // Making a vector of minus ones of type f64 is currently only used for the
+    // fabs intrinsic.  To use the f64 type to create this mask with pcmpeqq
+    // requires SSE 4.1.  Since we're just creating a mask, pcmpeqd does the
+    // same job and only requires SSE2.
+    _pcmpeq(MinusOnes, MinusOnes, IceType_f32);
+  else
+    _pcmpeq(MinusOnes, MinusOnes);
   return MinusOnes;
 }
 
 template <typename TraitsType>
 Variable *TargetX86Base<TraitsType>::makeVectorOfOnes(Type Ty, int32_t RegNum) {
   Variable *Dest = makeVectorOfZeros(Ty, RegNum);
   Variable *MinusOne = makeVectorOfMinusOnes(Ty);
   _psub(Dest, MinusOne);
   return Dest;
 }
@@ skipping 700 matching lines @@
   }
   // the offset is not eligible for blinding or pooling, return the original
   // mem operand
   return MemOperand;
 }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H