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

runtime/vm/intrinsifier_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"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
@@ skipping 26 matching lines @@
   // Compute the size to be allocated, it is based on the array length
   // and is computed as:
   // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
   __ movq(RDI, Address(RSP, kArrayLengthOffset));  // Array Length.
   // Assert that length is a Smi.
   __ testq(RDI, Immediate(kSmiTagSize));
   __ j(NOT_ZERO, &fall_through);
   __ cmpq(RDI, Immediate(0));
   __ j(LESS, &fall_through);
   // Check for maximum allowed length.
-  const Immediate max_len =
+  const Immediate& max_len =
       Immediate(reinterpret_cast<int64_t>(Smi::New(Array::kMaxElements)));
   __ cmpq(RDI, max_len);
   __ j(GREATER, &fall_through);
   intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
   __ leaq(RDI, Address(RDI, TIMES_4, fixed_size));  // RDI is a Smi.
   ASSERT(kSmiTagShift == 1);
   __ andq(RDI, Immediate(-kObjectAlignment));
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
@@ skipping 51 matching lines @@
   __ movq(RDI, Address(RSP, kArrayLengthOffset));  // Array Length.
   __ StoreIntoObjectNoBarrier(RAX,
                               FieldAddress(RAX, Array::length_offset()),
                               RDI);
 
   // Initialize all array elements to raw_null.
   // RAX: new object start as a tagged pointer.
   // RCX: new object end address.
   // RDI: iterator which initially points to the start of the variable
   // data area to be initialized.
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ leaq(RDI, FieldAddress(RAX, sizeof(RawArray)));
   Label done;
   Label init_loop;
   __ Bind(&init_loop);
   __ cmpq(RDI, RCX);
   __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
   __ movq(Address(RDI, 0), raw_null);
   __ addq(RDI, Immediate(kWordSize));
   __ jmp(&init_loop, Assembler::kNearJump);
@@ skipping 256 matching lines @@
   if (FLAG_enable_type_checks) return false;
   Label fall_through;
   __ movq(RAX, Address(RSP, + 2 * kWordSize));  // Array.
   __ movq(RCX, FieldAddress(RAX, GrowableObjectArray::length_offset()));
   // RCX: length.
   __ movq(RDX, FieldAddress(RAX, GrowableObjectArray::data_offset()));
   // RDX: data.
   // Compare length with capacity.
   __ cmpq(RCX, FieldAddress(RDX, Array::length_offset()));
   __ j(EQUAL, &fall_through, Assembler::kNearJump);  // Must grow data.
-  const Immediate value_one = Immediate(reinterpret_cast<int64_t>(Smi::New(1)));
+  const Immediate& value_one =
+      Immediate(reinterpret_cast<int64_t>(Smi::New(1)));
   // len = len + 1;
   __ addq(FieldAddress(RAX, GrowableObjectArray::length_offset()), value_one);
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // Value
   ASSERT(kSmiTagShift == 1);
   __ StoreIntoObject(RDX,
                      FieldAddress(RDX, RCX, TIMES_4, Array::data_offset()),
                      RAX);
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<int64_t>(Object::null()));
   __ movq(RAX, raw_null);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::ByteArrayBase_getLength(Assembler* assembler) {
   __ movq(RAX, Address(RSP, + 1 * kWordSize));
@@ skipping 710 matching lines @@
 
 
 bool Intrinsifier::Integer_equal(Assembler* assembler) {
   return Integer_equalToInteger(assembler);
 }
 
 
 bool Intrinsifier::Integer_sar(Assembler* assembler) {
   Label fall_through, shift_count_ok;
   TestBothArgumentsSmis(assembler, &fall_through);
-  Immediate count_limit = Immediate(0x3F);
+  const Immediate& count_limit = Immediate(0x3F);
   // Check that the count is not larger than what the hardware can handle.
   // For shifting right a Smi the result is the same for all numbers
   // >= count_limit.
   __ SmiUntag(RAX);
   // Negative counts throw exception.
   __ cmpq(RAX, Immediate(0));
   __ j(LESS, &fall_through, Assembler::kNearJump);
   __ cmpq(RAX, count_limit);
   __ j(LESS_EQUAL, &shift_count_ok, Assembler::kNearJump);
   __ movq(RAX, count_limit);
@@ skipping 399 matching lines @@
   __ LoadObject(RAX, Bool::True());
   __ ret();
   return true;
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64