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

runtime/vm/stub_code_x64.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_X64)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 63 matching lines @@
   __ movq(Address(RSP, retval_offset), RAX);  // Set retval in NativeArguments.
   __ call(RBX);
 
   // Reset exit frame information in Isolate structure.
   __ movq(Address(CTX, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Load Context pointer from Isolate structure into RBX.
   __ movq(RBX, 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()));
   __ movq(Address(CTX, Isolate::top_context_offset()), raw_null);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movq(CTX, RBX);
 
   __ LeaveFrame();
   __ ret();
 }
 
@@ skipping 67 matching lines @@
   __ movq(RDI, RSP);  // Pass the pointer to the NativeArguments.
   __ call(RBX);
 
   // Reset exit frame information in Isolate structure.
   __ movq(Address(CTX, Isolate::top_exit_frame_info_offset()), Immediate(0));
 
   // Load Context pointer from Isolate structure into R8.
   __ movq(R8, 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()));
   __ movq(Address(CTX, Isolate::top_context_offset()), raw_null);
 
   // Cache Context pointer into CTX while executing Dart code.
   __ movq(CTX, R8);
 
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   R10: 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);
   __ pushq(R10);  // Preserve arguments descriptor array.
   __ pushq(raw_null);  // Setup space on stack for return value.
   __ CallRuntime(kPatchStaticCallRuntimeEntry);
   __ popq(RAX);  // Get Code object result.
   __ popq(R10);  // Restore arguments descriptor array.
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
 
   __ movq(RBX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RBX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RBX);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // R10: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushq(R10);  // Preserve arguments descriptor array.
   __ pushq(raw_null);  // Setup space on stack for return value.
   __ CallRuntime(kFixCallersTargetRuntimeEntry);
   __ popq(RAX);  // Get Code object.
   __ popq(R10);  // Restore arguments descriptor array.
   __ movq(RAX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(RAX);
   __ int3();
 }
 
 
 // Input parameters:
 //   R10: smi-tagged argument count, may be zero.
 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.
   __ movq(RBX, raw_null);  // Null element type for raw Array.
   __ call(&StubCode::AllocateArrayLabel());
   __ SmiUntag(R10);
   // RAX: newly allocated array.
   // R10: length of the array (was preserved by the stub).
   __ pushq(RAX);  // Array is in RAX and on top of stack.
   __ leaq(R12, Address(RSP, R10, TIMES_8, arg_offset));  // Addr of first arg.
@@ skipping 13 matching lines @@
 
 // Input parameters:
 //   RBX: ic-data.
 //   R10: 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.
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
   AssemblerMacros::EnterStubFrame(assembler);
 
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushq(raw_null);  // Space for the return value.
 
   // Push the receiver as an argument.  Load the smi-tagged argument
   // count into R13 to index the receiver in the stack.  There are
   // three words (null, stub's pc marker, saved fp) above the return
   // address.
   __ movq(R13, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ pushq(Address(RSP, R13, TIMES_4, (3 * kWordSize)));
 
@@ skipping 150 matching lines @@
   // Load the receiver into RAX.  The argument count in the arguments
   // descriptor in R10 is a smi.
   __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   // Two words (saved fp, stub's pc marker) in the stack above the return
   // address.
   __ movq(RAX, Address(RSP, RAX, TIMES_4, 2 * kWordSize));
   // Preserve IC data and arguments descriptor.
   __ pushq(RBX);
   __ pushq(R10);
 
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Instructions::null()));
   __ pushq(raw_null);  // Space for the result of the runtime call.
   __ pushq(RAX);  // Receiver.
   __ pushq(RBX);  // IC data.
   __ pushq(R10);  // Arguments descriptor.
   __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry);
   // Discard arguments.
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);
@@ skipping 14 matching lines @@
 
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   R10 : Array length as Smi.
 //   RBX : array element type (either NULL or an instantiated type).
 // NOTE: R10 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in RAX.
 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.
     __ testq(R10, Immediate(kSmiTagSize));
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case);
@@ skipping 110 matching lines @@
   __ ret();
 }
 
 
 // Input parameters:
 //   R10: 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.
 void StubCode::GenerateCallClosureFunctionStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
   // Load num_args.
   __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   // Load closure object in R13.
   __ movq(R13, Address(RSP, RAX, TIMES_4, 0));  // RAX is a Smi.
 
   // Verify that R13 is a closure by checking its class.
   Label not_closure;
   __ cmpq(R13, raw_null);
@@ skipping 206 matching lines @@
   __ ret();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 // R10: number of context variables.
 // Output:
 // RAX: new allocated RawContext object.
 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.
     // R10: number of context variables.
     intptr_t fixed_size = (sizeof(RawContext) + kObjectAlignment - 1);
     __ leaq(R13, Address(R10, TIMES_8, fixed_size));
     __ andq(R13, Immediate(-kObjectAlignment));
@@ skipping 55 matching lines @@
     __ movq(FieldAddress(RAX, Context::num_variables_offset()), R10);
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into R13.
     // RAX: new object.
     // R10: number of context variables.
     __ movq(R13, FieldAddress(CTX, Context::isolate_offset()));
     // R13: Isolate, not an object.
     __ movq(FieldAddress(RAX, Context::isolate_offset()), R13);
 
-    const Immediate raw_null =
+    const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     // Setup the parent field.
     // RAX: new object.
     // R10: number of context variables.
     __ movq(FieldAddress(RAX, Context::parent_offset()), raw_null);
 
     // Initialize the context variables.
     // RAX: new object.
     // R10: number of context variables.
     {
@@ skipping 82 matching lines @@
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   RSP + 16 : type arguments object (only if class is parameterized).
 //   RSP + 8 : type arguments of instantiator (only if class is parameterized).
 //   RSP : points to return address.
 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;  // In words.
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
@@ skipping 75 matching lines @@
     // RDI: new object type arguments (if is_cls_parameterized).
     __ LoadObject(RDX, 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);
     __ movq(Address(RAX, 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()));
 
     // RAX: new object start.
     // RBX: next object start.
     // RDX: class of the object to be allocated.
     // RDI: 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 58 matching lines @@
 }
 
 
 // Called for inline allocation of closures.
 // Input parameters:
 //   RSP + 16 : receiver (null if not an implicit instance closure).
 //   RSP + 8 : type arguments object (null if class is not parameterized).
 //   RSP : points to return address.
 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 138 matching lines @@
 //   RBP - 8 : PC marker => RawInstruction object.
 //   RBP : points to previous frame pointer.
 //   RBP + 8 : points to return address.
 //   RBP + 16 : address of last argument (arg n-1).
 //   RBP + 16 + 8*(n-1) : address of first argument (arg 0).
 //   RBX : ic-data.
 //   R10 : arguments descriptor array.
 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()));
   __ movq(R13, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ movq(RAX, Address(RBP, R13, TIMES_4, kWordSize));  // Get receiver.
 
   // Create a stub frame.
   AssemblerMacros::EnterStubFrame(assembler);
 
   __ pushq(raw_null);  // Setup space on stack for result from noSuchMethod.
   __ pushq(RAX);  // Receiver.
   __ pushq(RBX);  // IC data array.
@@ skipping 160 matching lines @@
 
   const intptr_t entry_size = ICData::TestEntryLengthFor(num_args) * kWordSize;
   __ addq(R12, Immediate(entry_size));  // Next entry.
   __ movq(R13, Address(R12, 0));  // Next class ID.
 
   __ Bind(&test);
   __ cmpq(R13, 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).
   __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ leaq(RAX, Address(RSP, RAX, TIMES_4, 0));  // RAX is Smi.
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushq(R10);  // Preserve arguments descriptor array.
   __ pushq(RBX);  // Preserve IC data object.
   __ pushq(raw_null);  // Setup space on stack for result (target code object).
   // Push call arguments.
@@ skipping 131 matching lines @@
 
 // Megamorphic call is currently implemented as IC call but through a stub
 // that does not check/count function invocations.
 void StubCode::GenerateMegamorphicCallStub(Assembler* assembler) {
   GenerateNArgsCheckInlineCacheStub(assembler, 1);
 }
 
 //  R10: Arguments descriptor array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushq(R10);  // Preserve arguments descriptor.
   __ pushq(raw_null);  // Room for result.
   __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
   __ popq(RAX);  // Code object.
   __ popq(R10);  // Restore arguments descriptor.
   __ LeaveFrame();
 
   // Now call the static function. The breakpoint handler function
@@ skipping 50 matching lines @@
 
 
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
 // TOS + 1: instantiator type arguments (can be NULL).
 // TOS + 2: instance.
 // TOS + 3: SubtypeTestCache.
 // Result in RCX: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
   ASSERT((1 <= n) && (n <= 3));
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   const intptr_t kInstantiatorTypeArgumentsInBytes = 1 * kWordSize;
   const intptr_t kInstanceOffsetInBytes = 2 * kWordSize;
   const intptr_t kCacheOffsetInBytes = 3 * kWordSize;
   __ movq(RAX, Address(RSP, kInstanceOffsetInBytes));
   if (n > 1) {
     __ LoadClass(R10, RAX);
     // Compute instance type arguments into R13.
     Label has_no_type_arguments;
     __ movq(R13, raw_null);
@@ skipping 226 matching lines @@
   __ Drop(4);
   __ LeaveFrame();
 
   __ jmp(&compute_result, Assembler::kNearJump);
 }
 
 // Calls to the runtime to optimize the given function.
 // RDI: function to be reoptimized.
 // R10: 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);
   __ pushq(R10);
   __ pushq(raw_null);  // Setup space on stack for return value.
   __ pushq(RDI);
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
   __ popq(RAX);  // Disard argument.
   __ popq(RAX);  // Get Code object.
   __ popq(R10);  // Restore argument descriptor.
   __ movq(RAX, FieldAddress(RAX, Code::instructions_offset()));
@@ skipping 75 matching lines @@
   __ cmpq(left, right);
   __ Bind(&done);
   __ popq(right);
   __ popq(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64