Merged bleeding_edge -r 685:746 into regexp2000.

src/builtins-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 111 matching lines @@
     __ add(edi, Operand(ebx));  // Calculate new top
     ExternalReference new_space_allocation_limit =
         ExternalReference::new_space_allocation_limit_address();
     __ cmp(edi, Operand::StaticVariable(new_space_allocation_limit));
     __ j(greater_equal, &rt_call);
     // Allocated the JSObject, now initialize the fields.
     // eax: initial map
     // ebx: JSObject
     // edi: start of next object
     __ mov(Operand(ebx, JSObject::kMapOffset), eax);
-    __ mov(Operand(ecx), Factory::empty_fixed_array());
+    __ mov(ecx, Factory::empty_fixed_array());
     __ mov(Operand(ebx, JSObject::kPropertiesOffset), ecx);
     __ mov(Operand(ebx, JSObject::kElementsOffset), ecx);
     // Set extra fields in the newly allocated object.
     // eax: initial map
     // ebx: JSObject
     // edi: start of next object
     { Label loop, entry;
-      __ mov(Operand(edx), Factory::undefined_value());
+      __ mov(edx, Factory::undefined_value());
       __ lea(ecx, Operand(ebx, JSObject::kHeaderSize));
       __ jmp(&entry);
       __ bind(&loop);
       __ mov(Operand(ecx, 0), edx);
       __ add(Operand(ecx), Immediate(kPointerSize));
       __ bind(&entry);
       __ cmp(ecx, Operand(edi));
       __ j(less, &loop);
     }
 
@@ skipping 40 matching lines @@
     // ecx: start of next object
     __ mov(eax, Factory::fixed_array_map());
     __ mov(Operand(edi, JSObject::kMapOffset), eax);  // setup the map
     __ mov(Operand(edi, Array::kLengthOffset), edx);  // and length
 
     // Initialize the fields to undefined.
     // ebx: JSObject
     // edi: FixedArray
     // ecx: start of next object
     { Label loop, entry;
-      __ mov(Operand(edx), Factory::undefined_value());
+      __ mov(edx, Factory::undefined_value());
       __ lea(eax, Operand(edi, FixedArray::kHeaderSize));
       __ jmp(&entry);
       __ bind(&loop);
       __ mov(Operand(eax, 0), edx);
       __ add(Operand(eax), Immediate(kPointerSize));
       __ bind(&entry);
       __ cmp(eax, Operand(ecx));
       __ j(less, &loop);
     }
 
@@ skipping 221 matching lines @@
     __ EnterInternalFrame();  // preserves eax, ebx, edi
 
     // Store the arguments count on the stack (smi tagged).
     ASSERT(kSmiTag == 0);
     __ shl(eax, kSmiTagSize);
     __ push(eax);
 
     __ push(edi);  // save edi across the call
     __ push(ebx);
     __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
-    __ mov(Operand(ebx), eax);
+    __ mov(ebx, eax);
     __ pop(edi);  // restore edi after the call
 
     // Get the arguments count and untag it.
     __ pop(eax);
     __ shr(eax, kSmiTagSize);
 
     __ LeaveInternalFrame();
     __ jmp(&patch_receiver);
 
     // Use the global receiver object from the called function as the receiver.
@@ skipping 196 matching lines @@
   __ push(Immediate(ArgumentsAdaptorFrame::SENTINEL));
 
   // Push the function on the stack.
   __ push(edi);
 
   // Preserve the number of arguments on the stack. Must preserve both
   // eax and ebx because these registers are used when copying the
   // arguments and the receiver.
   ASSERT(kSmiTagSize == 1);
   __ lea(ecx, Operand(eax, eax, times_1, kSmiTag));
-  __ push(Operand(ecx));
+  __ push(ecx);
 }
 
 
 static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) {
   // Retrieve the number of arguments from the stack.
   __ mov(ebx, Operand(ebp, ArgumentsAdaptorFrameConstants::kLengthOffset));
 
   // Leave the frame.
   __ leave();
 
@@ skipping 100 matching lines @@
   __ EnterInternalFrame();
 
   // Store the registers containing object pointers on the expression stack to
   // make sure that these are correctly updated during GC.
   __ PushRegistersFromMemory(pointer_regs);
 
 #ifdef DEBUG
   __ RecordComment("// Calling from debug break to runtime - come in - over");
 #endif
   __ Set(eax, Immediate(0));  // no arguments
-  __ mov(Operand(ebx), Immediate(ExternalReference::debug_break()));
+  __ mov(ebx, Immediate(ExternalReference::debug_break()));
 
   CEntryDebugBreakStub ceb;
   __ CallStub(&ceb);
 
   // Restore the register values containing object pointers from the expression
   // stack in the reverse order as they where pushed.
   __ PopRegistersToMemory(pointer_regs);
 
   // Get rid of the internal frame.
   __ LeaveInternalFrame();
@@ skipping 101 matching lines @@
   // Register state for stub CallFunction (from CallFunctionStub in ic-ia32.cc).
   // ----------- S t a t e -------------
   //  No registers used on entry.
   // -----------------------------------
   Generate_DebugBreakCallHelper(masm, 0, false);
 }
 
 #undef __
 
 } }  // namespace v8::internal