Fix vm code base so that it can be built for --arch=simarm (no snapshot yet).

runtime/vm/stub_code_ia32.cc

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 62 matching lines @@
   __ movl(Address(ESP, retval_offset), EAX);  // Set retval in NativeArguments.
   __ call(ECX);
 
   // Reset exit frame information in Isolate structure.
   __ movl(Address(CTX, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Load Context pointer from Isolate structure into ECX.
   __ movl(ECX, Address(CTX, Isolate::top_context_offset()));
 
   // Reset Context pointer in Isolate structure.
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movl(Address(CTX, Isolate::top_context_offset()), raw_null);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movl(CTX, ECX);
 
   __ LeaveFrame();
   __ ret();
 }
 
@@ skipping 69 matching lines @@
   __ movl(Address(ESP, 0), EAX);  // Pass the pointer to the NativeArguments.
   __ call(ECX);
 
   // Reset exit frame information in Isolate structure.
   __ movl(Address(CTX, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Load Context pointer from Isolate structure into EDI.
   __ movl(EDI, Address(CTX, Isolate::top_context_offset()));
 
   // Reset Context pointer in Isolate structure.
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movl(Address(CTX, Isolate::top_context_offset()), raw_null);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movl(CTX, EDI);
 
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   EDX: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ CallRuntime(kPatchStaticCallRuntimeEntry);
   __ popl(EAX);  // Get Code object result.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
 
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(ECX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(ECX);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // EDX: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ CallRuntime(kFixCallersTargetRuntimeEntry);
   __ popl(EAX);  // Get Code object.
   __ popl(EDX);  // Restore arguments descriptor array.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
 }
 
 
 // Input parameters:
 //   EDX: smi-tagged argument count, may be zero.
 // Uses EAX, EBX, ECX, EDX.
 static void PushArgumentsArray(Assembler* assembler, intptr_t arg_offset) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
   // Allocate array to store arguments of caller.
   __ movl(ECX, raw_null);  // Null element type for raw Array.
   __ call(&StubCode::AllocateArrayLabel());
   __ SmiUntag(EDX);
   // EAX: newly allocated array.
   // EDX: length of the array (was preserved by the stub).
   __ pushl(EAX);  // Array is in EAX and on top of stack.
   __ leal(EBX, Address(ESP, EDX, TIMES_4, arg_offset));  // Addr of first arg.
@@ skipping 14 matching lines @@
 // Input parameters:
 //   ECX: ic-data.
 //   EDX: arguments descriptor array.
 // Note: The receiver object is the first argument to the function being
 //       called, the stub accesses the receiver from this location directly
 //       when trying to resolve the call.
 // Uses EDI.
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
   AssemblerMacros::EnterStubFrame(assembler);
 
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Space for the return value.
 
   // Push the receiver as an argument.  Load the smi-tagged argument
   // count into EDI to index the receiver in the stack.  There are
   // three words (null, stub's pc marker, saved fp) above the return
   // address.
   __ movl(EDI, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   __ pushl(Address(ESP, EDI, TIMES_2, (3 * kWordSize)));
 
@@ skipping 149 matching lines @@
   // Load the receiver into EAX.  The argument count in the arguments
   // descriptor in EDX is a smi.
   __ movl(EAX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   // Two words (saved fp, stub's pc marker) in the stack above the return
   // address.
   __ movl(EAX, Address(ESP, EAX, TIMES_2, 2 * kWordSize));
   // Preserve IC data and arguments descriptor.
   __ pushl(ECX);
   __ pushl(EDX);
 
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Instructions::null()));
   __ pushl(raw_null);  // Space for the result of the runtime call.
   __ pushl(EAX);  // Pass receiver.
   __ pushl(ECX);  // Pass IC data.
   __ pushl(EDX);  // Pass rguments descriptor.
   __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry);
   // Discard arguments.
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);
@@ skipping 15 matching lines @@
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   EDX : Array length as Smi.
 //   ECX : array element type (either NULL or an instantiated type).
 // Uses EAX, EBX, ECX, EDI  as temporary registers.
 // NOTE: EDX cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in EAX.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   Label slow_case;
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
   if (FLAG_inline_alloc) {
     // Compute the size to be allocated, it is based on the array length
     // and is computed as:
     // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
     // Assert that length is a Smi.
     __ testl(EDX, Immediate(kSmiTagSize));
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case);
@@ skipping 116 matching lines @@
 }
 
 
 // Input parameters:
 //   EDX: Arguments descriptor array.
 // Note: The closure object is the first argument to the function being
 //       called, the stub accesses the closure from this location directly
 //       when trying to resolve the call.
 // Uses EDI.
 void StubCode::GenerateCallClosureFunctionStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
   // Load num_args.
   __ movl(EAX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   // Load closure object in EDI.
   __ movl(EDI, Address(ESP, EAX, TIMES_2, 0));  // EAX is a Smi.
 
   // Verify that EDI is a closure by checking its class.
   Label not_closure;
   __ cmpl(EDI, raw_null);
@@ skipping 207 matching lines @@
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 // EDX: number of context variables.
 // Output:
 // EAX: new allocated RawContext object.
 // EBX and EDX are destroyed.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   if (FLAG_inline_alloc) {
     const Class& context_class = Class::ZoneHandle(Object::context_class());
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     // First compute the rounded instance size.
     // EDX: number of context variables.
     intptr_t fixed_size = (sizeof(RawContext) + kObjectAlignment - 1);
     __ leal(EBX, Address(EDX, TIMES_4, fixed_size));
     __ andl(EBX, Immediate(-kObjectAlignment));
@@ skipping 52 matching lines @@
     __ movl(FieldAddress(EAX, Context::num_variables_offset()), EDX);
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into EBX.
     // EAX: new object.
     // EDX: number of context variables.
     __ movl(EBX, FieldAddress(CTX, Context::isolate_offset()));
     // EBX: Isolate, not an object.
     __ movl(FieldAddress(EAX, Context::isolate_offset()), EBX);
 
-    const Immediate raw_null =
+    const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     // Setup the parent field.
     // EAX: new object.
     // EDX: number of context variables.
     __ movl(FieldAddress(EAX, Context::parent_offset()), raw_null);
 
     // Initialize the context variables.
     // EAX: new object.
     // EDX: number of context variables.
     {
@@ skipping 90 matching lines @@
 // Called for inline allocation of objects.
 // Input parameters:
 //   ESP + 8 : type arguments object (only if class is parameterized).
 //   ESP + 4 : type arguments of instantiator (only if class is parameterized).
 //   ESP : points to return address.
 // Uses EAX, EBX, ECX, EDX, EDI as temporary registers.
 void StubCode::GenerateAllocationStubForClass(Assembler* assembler,
                                               const Class& cls) {
   const intptr_t kObjectTypeArgumentsOffset = 2 * kWordSize;
   const intptr_t kInstantiatorTypeArgumentsOffset = 1 * kWordSize;
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // The generated code is different if the class is parameterized.
   const bool is_cls_parameterized =
       cls.type_arguments_field_offset() != Class::kNoTypeArguments;
   // kInlineInstanceSize is a constant used as a threshold for determining
   // when the object initialization should be done as a loop or as
   // straight line code.
   const int kInlineInstanceSize = 12;
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
@@ skipping 72 matching lines @@
     // EDI: new object type arguments (if is_cls_parameterized).
     __ LoadObject(EDX, cls);  // Load class of object to be allocated.
     // Set the tags.
     uword tags = 0;
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     __ movl(Address(EAX, Instance::tags_offset()), Immediate(tags));
 
     // Initialize the remaining words of the object.
-    const Immediate raw_null =
+    const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
     // EAX: new object start.
     // EBX: next object start.
     // EDX: class of the object to be allocated.
     // EDI: new object type arguments (if is_cls_parameterized).
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
       // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
@@ skipping 60 matching lines @@
 
 
 // Called for inline allocation of closures.
 // Input parameters:
 //   ESP + 8 : receiver (null if not an implicit instance closure).
 //   ESP + 4 : type arguments object (null if class is no parameterized).
 //   ESP : points to return address.
 // Uses EAX, EBX, ECX, EDX as temporary registers.
 void StubCode::GenerateAllocationStubForClosure(Assembler* assembler,
                                                 const Function& func) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   ASSERT(func.IsClosureFunction());
   const bool is_implicit_static_closure =
       func.IsImplicitStaticClosureFunction();
   const bool is_implicit_instance_closure =
       func.IsImplicitInstanceClosureFunction();
   const Class& cls = Class::ZoneHandle(func.signature_class());
   const bool has_type_arguments = cls.HasTypeArguments();
   const intptr_t kTypeArgumentsOffset = 1 * kWordSize;
   const intptr_t kReceiverOffset = 2 * kWordSize;
@@ skipping 136 matching lines @@
 //   EBP : points to previous frame pointer.
 //   EBP + 4 : points to return address.
 //   EBP + 8 : address of last argument (arg n-1).
 //   EBP + 8 + 4*(n-1) : address of first argument (arg 0).
 //   ECX : ic-data.
 //   EDX : arguments descriptor array.
 // Uses EAX, EBX, EDI as temporary registers.
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
   // The target function was not found, so invoke method
   // "dynamic noSuchMethod(InvocationMirror invocation)".
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movl(EDI, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   __ movl(EAX, Address(EBP, EDI, TIMES_2, kWordSize));  // Get receiver.
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
 
   __ pushl(raw_null);  // Setup space on stack for result from noSuchMethod.
   __ pushl(EAX);  // Receiver.
@@ skipping 163 matching lines @@
 
   const intptr_t entry_size = ICData::TestEntryLengthFor(num_args) * kWordSize;
   __ addl(EBX, Immediate(entry_size));  // Next entry.
   __ movl(EDI, Address(EBX, 0));  // Next class ID.
 
   __ Bind(&test);
   __ cmpl(EDI, Immediate(Smi::RawValue(kIllegalCid)));  // Done?
   __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
 
   // IC miss.
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Compute address of arguments (first read number of arguments from
   // arguments descriptor array and then compute address on the stack).
   __ movl(EAX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   __ leal(EAX, Address(ESP, EAX, TIMES_2, 0));  // EAX is Smi.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);  // Preserve IC data object.
@@ skipping 141 matching lines @@
 }
 
 
 //  EDX: Arguments descriptor array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EDX);  // Preserve arguments descriptor.
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Room for result.
   __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
   __ popl(EAX);  // Code object.
   __ popl(EDX);  // Restore arguments descriptor.
   __ LeaveFrame();
 
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
@@ skipping 58 matching lines @@
 // TOS + 0: return address.
 // TOS + 1: instantiator type arguments (can be NULL).
 // TOS + 2: instance.
 // TOS + 3: SubtypeTestCache.
 // Result in ECX: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
   ASSERT((1 <= n) && (n <= 3));
   const intptr_t kInstantiatorTypeArgumentsInBytes = 1 * kWordSize;
   const intptr_t kInstanceOffsetInBytes = 2 * kWordSize;
   const intptr_t kCacheOffsetInBytes = 3 * kWordSize;
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movl(EAX, Address(ESP, kInstanceOffsetInBytes));
   if (n > 1) {
     // Get instance type arguments.
     __ LoadClass(ECX, EAX, EBX);
     // Compute instance type arguments into EBX.
     Label has_no_type_arguments;
     __ movl(EBX, raw_null);
     __ movl(EDI, FieldAddress(ECX,
         Class::type_arguments_field_offset_in_words_offset()));
@@ skipping 227 matching lines @@
   __ LeaveFrame();
 
   __ jmp(&compute_result, Assembler::kNearJump);
 }
 
 
 // Calls to runtime to ooptimized give function
 // EDI: function to be reoptimized.
 // EDX: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EDX);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDI);
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
   __ popl(EAX);  // Discard argument.
   __ popl(EAX);  // Get Code object
   __ popl(EDX);  // Restore argument descriptor.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
@@ skipping 85 matching lines @@
   __ Bind(&done);
   __ popl(temp);
   __ popl(right);
   __ popl(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32