Subzero: Legalize the movzx argument.

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 1651 matching lines @@
   if (Ty != IceType_i32 && !(Traits::Is64Bit && Ty == IceType_i64) &&
       (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;
   Variable *T = makeReg(Traits::WordType);
   if (typeWidthInBytes(Src0->getType()) < typeWidthInBytes(T->getType())) {
-    _movzx(T, Src0);
+    Operand *Src0RM = legalize(Src0, Legal_Reg | Legal_Mem);
+    _movzx(T, Src0RM);
   } else {
     _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)
     _lea(T, X86OperandMem::create(Func, IceType_void, T, Zero, T, Shift));
   }
   for (uint32_t i = 0; i < Count5; ++i) {
     constexpr uint16_t Shift = 2; // log2(5-1)
@@ skipping 2516 matching lines @@
 
     if (!Traits::Is64Bit) {
       T = Dest;
     } else {
       T = makeReg(IceType_i64);
       if (ValTy == IceType_i32) {
         // in x86-64, __popcountsi2 is not defined, so we cheat a bit by
         // converting it to a 64-bit value, and using ctpop_i64. _movzx should
         // ensure we will not have any bits set on Val's upper 32 bits.
         Variable *V = makeReg(IceType_i64);
-        _movzx(V, Val);
+        Operand *ValRM = legalize(Val, Legal_Reg | Legal_Mem);
+        _movzx(V, ValRM);
         Val = V;
       }
       ValTy = IceType_i64;
     }
 
     InstCall *Call =
         makeHelperCall(ValTy == IceType_i32 ? RuntimeHelper::H_call_ctpop_i32
                                             : RuntimeHelper::H_call_ctpop_i64,
                        T, 1);
     Call->addArg(Val);
@@ skipping 2618 matching lines @@
 
     // Make sure the index is a register of the same width as the base
     Variable *Index;
     const Type PointerType = getPointerType();
     if (RangeIndex->getType() != PointerType) {
       Index = makeReg(PointerType);
       if (RangeIndex->getType() == IceType_i64) {
         assert(Traits::Is64Bit);
         _mov(Index, RangeIndex); // trunc
       } else {
-        _movzx(Index, RangeIndex);
+        Operand *RangeIndexRM = legalize(RangeIndex, Legal_Reg | Legal_Mem);
+        _movzx(Index, RangeIndexRM);
       }
     } else {
       Index = legalizeToReg(RangeIndex);
     }
 
     constexpr RelocOffsetT RelocOffset = 0;
     constexpr Variable *NoBase = nullptr;
     constexpr Constant *NoOffset = nullptr;
     auto JTName = GlobalString::createWithString(Ctx, JumpTable->getName());
     Constant *Offset = Ctx->getConstantSym(RelocOffset, JTName);
@@ skipping 1554 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H