Subzero. X8664. Fixes filetype=asm.

src/IceInstX86BaseImpl.h

Index: src/IceInstX86BaseImpl.h
diff --git a/src/IceInstX86BaseImpl.h b/src/IceInstX86BaseImpl.h
index a1425622604242b587b824208abc5a88f769202f..c2cd1d22e5615702265c33836515564ef135a796 100644
--- a/src/IceInstX86BaseImpl.h
+++ b/src/IceInstX86BaseImpl.h
@@ -2129,10 +2129,6 @@ template <class Machine> void InstX86Lea<Machine>::emit(const Cfg *Func) const {
   this->getDest()->emit(Func);
 }
 
-inline bool isIntegerConstant(const Operand *Op) {
-  return llvm::isa<ConstantInteger32>(Op) || llvm::isa<ConstantInteger64>(Op);
-}
-
 template <class Machine> void InstX86Mov<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
@@ -2142,9 +2138,10 @@ template <class Machine> void InstX86Mov<Machine>::emit(const Cfg *Func) const {
   Type SrcTy = Src->getType();
   Type DestTy = this->getDest()->getType();
   if (InstX86Base<Machine>::Traits::Is64Bit && DestTy == IceType_i64 &&
-      isIntegerConstant(Src)) {
+      llvm::isa<ConstantInteger64>(Src)) {
     Str << "\t"
-           "movabs\t";
+           "movabs"
+           "\t";
   } else {
     Str << "\t"
            "mov" << (!isScalarFloatingType(DestTy)
@@ -2214,19 +2211,14 @@ void InstX86Mov<Machine>::emitIAS(const Cfg *Func) const {
       assert(isScalarIntegerType(DestTy));
       // Widen DestTy for truncation (see above note). We should only do this
       // when both Src and Dest are integer types.
-      if (InstX86Base<Machine>::Traits::Is64Bit && DestTy == IceType_i64 &&
-          isIntegerConstant(Src)) {
-        uint64_t Value = -1;
+      if (InstX86Base<Machine>::Traits::Is64Bit && DestTy == IceType_i64) {
         if (const auto *C64 = llvm::dyn_cast<ConstantInteger64>(Src)) {
-          Value = C64->getValue();
-        } else {
-          Value = llvm::cast<ConstantInteger32>(Src)->getValue();
+          Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>()
+              ->movabs(InstX86Base<Machine>::Traits::getEncodedGPR(
+                           Dest->getRegNum()),
+                       C64->getValue());
+          return;
         }
-        Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>()
-            ->movabs(
-                InstX86Base<Machine>::Traits::getEncodedGPR(Dest->getRegNum()),
-                Value);
-        return;
       }
       if (isScalarIntegerType(SrcTy)) {
         SrcTy = DestTy;
@@ -2412,6 +2404,33 @@ void InstX86Movsx<Machine>::emitIAS(const Cfg *Func) const {
 }
 
 template <class Machine>
+void InstX86Movzx<Machine>::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+  if (InstX86Base<Machine>::Traits::Is64Bit) {
+    // There's no movzx %eXX, %rXX. To zero extend 32- to 64-bits, we emit a
+    // mov %eXX, %eXX. The processor will still do a movzx[bw]q.
+    assert(this->getSrcSize() == 1);
+    const Operand *Src = this->getSrc(0);
+    const Variable *Dest = this->Dest;
+    if (Src->getType() == IceType_i32 && Dest->getType() == IceType_i64) {
+      Ostream &Str = Func->getContext()->getStrEmit();
+      Str << "\t"
+             "mov"
+             "\t";
+      Src->emit(Func);
+      Str << ", ";
+      Dest->asType(IceType_i32, InstX86Base<Machine>::Traits::getGprForType(
+                                    IceType_i32, Dest->getRegNum()))
+          ->emit(Func);
+      Str << " /* movzx */";
+      return;
+    }
+  }
+  InstX86BaseUnaryopGPR<Machine, InstX86Base<Machine>::Movzx>::emit(Func);
+}
+
+template <class Machine>
 void InstX86Movzx<Machine>::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 1);
   const Variable *Dest = this->getDest();