[ia32] Use more efficient encoding when loading integer constants.

src/compiler/ia32/code-generator-ia32.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/code-generator.h"
 
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 231 matching lines @@
         __ imul(i.OutputRegister(), i.InputOperand(0), i.InputInt32(1));
       } else {
         __ imul(i.OutputRegister(), i.InputOperand(1));
       }
       break;
     case kIA32Idiv:
       __ cdq();
       __ idiv(i.InputOperand(1));
       break;
     case kIA32Udiv:
-      __ xor_(edx, edx);
+      __ Move(edx, Immediate(0));
       __ div(i.InputOperand(1));
       break;
     case kIA32Not:
       __ not_(i.OutputOperand());
       break;
     case kIA32Neg:
       __ neg(i.OutputOperand());
       break;
     case kIA32Or:
       if (HasImmediateInput(instr, 1)) {
@@ skipping 282 matching lines @@
 
   // Materialize a full 32-bit 1 or 0 value. The result register is always the
   // last output of the instruction.
   Label check;
   DCHECK_NE(0, instr->OutputCount());
   Register reg = i.OutputRegister(instr->OutputCount() - 1);
   Condition cc = no_condition;
   switch (condition) {
     case kUnorderedEqual:
       __ j(parity_odd, &check, Label::kNear);
-      __ mov(reg, Immediate(0));
+      __ Move(reg, Immediate(0));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kEqual:
       cc = equal;
       break;
     case kUnorderedNotEqual:
       __ j(parity_odd, &check, Label::kNear);
       __ mov(reg, Immediate(1));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kNotEqual:
       cc = not_equal;
       break;
     case kSignedLessThan:
       cc = less;
       break;
     case kSignedGreaterThanOrEqual:
       cc = greater_equal;
       break;
     case kSignedLessThanOrEqual:
       cc = less_equal;
       break;
     case kSignedGreaterThan:
       cc = greater;
       break;
     case kUnorderedLessThan:
       __ j(parity_odd, &check, Label::kNear);
-      __ mov(reg, Immediate(0));
+      __ Move(reg, Immediate(0));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kUnsignedLessThan:
       cc = below;
       break;
     case kUnorderedGreaterThanOrEqual:
       __ j(parity_odd, &check, Label::kNear);
       __ mov(reg, Immediate(1));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kUnsignedGreaterThanOrEqual:
       cc = above_equal;
       break;
     case kUnorderedLessThanOrEqual:
       __ j(parity_odd, &check, Label::kNear);
-      __ mov(reg, Immediate(0));
+      __ Move(reg, Immediate(0));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kUnsignedLessThanOrEqual:
       cc = below_equal;
       break;
     case kUnorderedGreaterThan:
       __ j(parity_odd, &check, Label::kNear);
       __ mov(reg, Immediate(1));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kUnsignedGreaterThan:
       cc = above;
       break;
     case kOverflow:
       cc = overflow;
       break;
     case kNotOverflow:
       cc = no_overflow;
       break;
   }
   __ bind(&check);
   if (reg.is_byte_register()) {
     // setcc for byte registers (al, bl, cl, dl).
     __ setcc(cc, reg);
     __ movzx_b(reg, reg);
   } else {
     // Emit a branch to set a register to either 1 or 0.
     Label set;
     __ j(cc, &set, Label::kNear);
-    __ mov(reg, Immediate(0));
+    __ Move(reg, Immediate(0));
     __ jmp(&done, Label::kNear);
     __ bind(&set);
     __ mov(reg, Immediate(1));
   }
   __ bind(&done);
 }
 
 
 void CodeGenerator::AssembleDeoptimizerCall(int deoptimization_id) {
   Address deopt_entry = Deoptimizer::GetDeoptimizationEntry(
@@ skipping 252 matching lines @@
         AllowDeferredHandleDereference embedding_raw_address;
         if (isolate()->heap()->InNewSpace(*src)) {
           __ PushHeapObject(src);
           __ pop(dst);
         } else {
           __ mov(dst, src);
         }
       }
     } else if (destination->IsRegister()) {
       Register dst = g.ToRegister(destination);
-      __ mov(dst, g.ToImmediate(source));
+      __ Move(dst, g.ToImmediate(source));
     } else if (destination->IsStackSlot()) {
       Operand dst = g.ToOperand(destination);
-      __ mov(dst, g.ToImmediate(source));
+      __ Move(dst, g.ToImmediate(source));
     } else if (src_constant.type() == Constant::kFloat32) {
       // TODO(turbofan): Can we do better here?
       uint32_t src = bit_cast<uint32_t>(src_constant.ToFloat32());
       if (destination->IsDoubleRegister()) {
         XMMRegister dst = g.ToDoubleRegister(destination);
         __ Move(dst, src);
       } else {
         DCHECK(destination->IsDoubleStackSlot());
         Operand dst = g.ToOperand(destination);
-        __ mov(dst, Immediate(src));
+        __ Move(dst, Immediate(src));
       }
     } else {
       DCHECK_EQ(Constant::kFloat64, src_constant.type());
       uint64_t src = bit_cast<uint64_t>(src_constant.ToFloat64());
       uint32_t lower = static_cast<uint32_t>(src);
       uint32_t upper = static_cast<uint32_t>(src >> 32);
       if (destination->IsDoubleRegister()) {
         XMMRegister dst = g.ToDoubleRegister(destination);
         __ Move(dst, src);
       } else {
         DCHECK(destination->IsDoubleStackSlot());
         Operand dst0 = g.ToOperand(destination);
         Operand dst1 = g.HighOperand(destination);
-        __ mov(dst0, Immediate(lower));
-        __ mov(dst1, Immediate(upper));
+        __ Move(dst0, Immediate(lower));
+        __ Move(dst1, Immediate(upper));
       }
     }
   } else if (source->IsDoubleRegister()) {
     XMMRegister src = g.ToDoubleRegister(source);
     if (destination->IsDoubleRegister()) {
       XMMRegister dst = g.ToDoubleRegister(destination);
       __ movaps(dst, src);
     } else {
       DCHECK(destination->IsDoubleStackSlot());
       Operand dst = g.ToOperand(destination);
@@ skipping 88 matching lines @@
     }
   }
   MarkLazyDeoptSite();
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8