Use shorting encoding for mov reg, imm.

src/codegen-ia32.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1023 matching lines @@
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
       frame_->Pop(eax);
       if (!reversed) {
         deferred = new DeferredInlinedSmiSub(this, int_value, overwrite_mode);
         __ sub(Operand(eax), Immediate(value));
       } else {
         deferred = new DeferredInlinedSmiSubReversed(this, edx, overwrite_mode);
         __ mov(edx, Operand(eax));
-        __ mov(Operand(eax), Immediate(value));
+        __ mov(eax, Immediate(value));

[Kevin Millikin (Chromium), 2008/11/10 15:05:41]

Couldn't this just be __ mov(eax, value)?

         __ sub(eax, Operand(edx));
       }
       __ j(overflow, deferred->enter(), not_taken);
       __ test(eax, Immediate(kSmiTagMask));
       __ j(not_zero, deferred->enter(), not_taken);
       __ bind(deferred->exit());
       frame_->Push(eax);
       break;
     }
 
@@ skipping 203 matching lines @@
   Condition cc_;
   bool strict_;
   int value_;
 };
 
 
 void SmiComparisonDeferred::Generate() {
   CompareStub stub(cc_, strict_);
   // Setup parameters and call stub.
   __ mov(edx, Operand(eax));
-  __ mov(Operand(eax), Immediate(Smi::FromInt(value_)));
+  __ Set(eax, Immediate(Smi::FromInt(value_)));
   __ CallStub(&stub);
   __ cmp(eax, 0);
   // "result" is returned in the flags
 }
 
 
 void CodeGenerator::SmiComparison(Condition cc,
                                       Handle<Object> value,
                                       bool strict) {
   // Strict only makes sense for equality comparisons.
@@ skipping 3698 matching lines @@
   // edi: number of arguments including receiver (C callee-saved)
   // esi: argv pointer (C callee-saved)
 
   Label throw_out_of_memory_exception;
   Label throw_normal_exception;
 
   // Call into the runtime system. Collect garbage before the call if
   // running with --gc-greedy set.
   if (FLAG_gc_greedy) {
     Failure* failure = Failure::RetryAfterGC(0);
-    __ mov(Operand(eax), Immediate(reinterpret_cast<int32_t>(failure)));
+    __ mov(eax, Immediate(reinterpret_cast<int32_t>(failure)));

[Kevin Millikin (Chromium), 2008/11/10 15:05:41]

Similarly __ mov(eax, reinterpret_cast<int32_t>(failure))?

   }
   GenerateCore(masm, &throw_normal_exception,
                &throw_out_of_memory_exception,
                frame_type,
                FLAG_gc_greedy,
                false);
 
   // Do space-specific GC and retry runtime call.
   GenerateCore(masm,
                &throw_normal_exception,
                &throw_out_of_memory_exception,
                frame_type,
                true,
                false);
 
   // Do full GC and retry runtime call one final time.
   Failure* failure = Failure::InternalError();
-  __ mov(Operand(eax), Immediate(reinterpret_cast<int32_t>(failure)));
+  __ mov(eax, Immediate(reinterpret_cast<int32_t>(failure)));

[Kevin Millikin (Chromium), 2008/11/10 15:05:41]

Ditto.

   GenerateCore(masm,
                &throw_normal_exception,
                &throw_out_of_memory_exception,
                frame_type,
                true,
                true);
 
   __ bind(&throw_out_of_memory_exception);
   GenerateThrowOutOfMemory(masm);
   // control flow for generated will not return.
@@ skipping 45 matching lines @@
 
   // Fake a receiver (NULL).
   __ push(Immediate(0));  // receiver
 
   // Invoke the function by calling through JS entry trampoline
   // builtin and pop the faked function when we return. Notice that we
   // cannot store a reference to the trampoline code directly in this
   // stub, because the builtin stubs may not have been generated yet.
   if (is_construct) {
     ExternalReference construct_entry(Builtins::JSConstructEntryTrampoline);
-    __ mov(Operand(edx), Immediate(construct_entry));
+    __ mov(edx, Immediate(construct_entry));
   } else {
     ExternalReference entry(Builtins::JSEntryTrampoline);
-    __ mov(Operand(edx), Immediate(entry));
+    __ mov(edx, Immediate(entry));
   }
   __ mov(edx, Operand(edx, 0));  // deref address
   __ lea(edx, FieldOperand(edx, Code::kHeaderSize));
   __ call(Operand(edx));
 
   // Unlink this frame from the handler chain.
   __ pop(Operand::StaticVariable(ExternalReference(Top::k_handler_address)));
   // Pop next_sp.
   __ add(Operand(esp), Immediate(StackHandlerConstants::kSize - kPointerSize));
 
@@ skipping 64 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal