Add option to force filetype=asm for testing

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 187 matching lines @@
   Variable *ReturnReg = nullptr;
   Variable *ReturnRegHi = nullptr;
   if (Dest) {
     switch (Dest->getType()) {
     case IceType_NUM:
     case IceType_void:
       llvm::report_fatal_error("Invalid Call dest type");
       break;
     case IceType_i1:
     case IceType_i8:
+      ReturnReg = makeReg(Dest->getType(), Traits::RegisterSet::Reg_al);
+      break;
     case IceType_i16:
+      ReturnReg = makeReg(Dest->getType(), Traits::RegisterSet::Reg_ax);
+      break;
     case IceType_i32:
       ReturnReg = makeReg(Dest->getType(), Traits::RegisterSet::Reg_eax);

[Jim Stichnoth, 2015/12/20 18:42:23]

Instead of the above, I think you could do something like:
  ReturnReg = makeReg(Dest->getType(), Traits::getGprForType(Dest->getType(),
Traits::RegisterSet::Reg_eax));

Also, it would probably be good to change all the Dest->getType() calls in this
method into DestTy=Dest->getType() .  And maybe do the same in the x8664 file
for symmetry.

[sehr, 2016/01/07 18:53:11]

Done.

       break;
     case IceType_i64:
       ReturnReg = makeReg(IceType_i32, Traits::RegisterSet::Reg_eax);
       ReturnRegHi = makeReg(IceType_i32, Traits::RegisterSet::Reg_edx);
       break;
     case IceType_f32:
     case IceType_f64:
       // Leave ReturnReg==ReturnRegHi==nullptr, and capture the result with the
       // fstp instruction.
       break;
@@ skipping 114 matching lines @@
       Variable *eax =
           legalizeToReg(loOperand(Src0), Traits::RegisterSet::Reg_eax);
       Variable *edx =
           legalizeToReg(hiOperand(Src0), Traits::RegisterSet::Reg_edx);
       Reg = eax;
       Context.insert<InstFakeUse>(edx);
     } else if (isScalarFloatingType(Src0->getType())) {
       _fld(Src0);
     } else if (isVectorType(Src0->getType())) {
       Reg = legalizeToReg(Src0, Traits::RegisterSet::Reg_xmm0);
+    } else if (Src0->getType() == IceType_i8) {

[Jim Stichnoth, 2015/12/20 18:42:23]

Maybe check against i1 as well, for completeness

[sehr, 2016/01/07 18:53:11]

I converted these all to use the getGprForType scheme.

+      // TODO(sehr,stichnot): I think these need to sign/zero extend.

[Jim Stichnoth, 2015/12/20 18:42:23]

I don't think the x86-32 processor ABI has anything to say on this matter.

So it comes down to consistency between the caller and callee.  Subzero should
be self-consistent in this regard.

But if Subzero output is linked against another translator's output, such as for
bisection debugging, this would be an issue.

Given that returning i1/i8/i16 isn't even valid in a pexe, I think it would be
fine to explicitly zero-extend.  In fact, that could potentially save debugging
time for some future non-PNaCl-based integration when we have long forgotten
this issue.

[sehr, 2016/01/07 18:53:11]

I'm going with the idea that we're doing this for pexes and it's not valid, so I
remove the comment.

+      _mov(Reg, Src0, Traits::RegisterSet::Reg_al);
+    } else if (Src0->getType() == IceType_i16) {
+      _mov(Reg, Src0, Traits::RegisterSet::Reg_ax);
     } else {
       _mov(Reg, Src0, Traits::RegisterSet::Reg_eax);
     }
   }
   // Add a ret instruction even if sandboxing is enabled, because addEpilog
   // explicitly looks for a ret instruction as a marker for where to insert the
   // frame removal instructions.
   _ret(Reg);
   // Add a fake use of esp to make sure esp stays alive for the entire
   // function. Otherwise post-call esp adjustments get dead-code eliminated.
@@ skipping 639 matching lines @@
 // case the high-level table has extra entries.
 #define X(tag, sizeLog2, align, elts, elty, str)                               \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 } // end of namespace dummy3
 } // end of anonymous namespace
 
 } // end of namespace Ice