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

runtime/vm/intrinsifier_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.
 //
 // The intrinsic code below is executed before a method has built its frame.
 // The return address is on the stack and the arguments below it.
 // Registers EDX (arguments descriptor) and ECX (function) must be preserved.
 // Each intrinsification method returns true if the corresponding
 // Dart method was intrinsified.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
@@ skipping 27 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)).
   __ movl(EDI, Address(ESP, kArrayLengthOffset));  // Array Length.
   // Assert that length is a Smi.
   __ testl(EDI, Immediate(kSmiTagSize));
   __ j(NOT_ZERO, &fall_through);
   __ cmpl(EDI, Immediate(0));
   __ j(LESS, &fall_through);
   // Check for maximum allowed length.
-  const Immediate max_len =
+  const Immediate& max_len =
       Immediate(reinterpret_cast<int32_t>(Smi::New(Array::kMaxElements)));
   __ cmpl(EDI, max_len);
   __ j(GREATER, &fall_through);
   intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
   __ leal(EDI, Address(EDI, TIMES_2, fixed_size));  // EDI is a Smi.
   ASSERT(kSmiTagShift == 1);
   __ andl(EDI, Immediate(-kObjectAlignment));
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
@@ skipping 50 matching lines @@
   __ movl(EDI, Address(ESP, kArrayLengthOffset));  // Array Length.
   __ StoreIntoObjectNoBarrier(EAX,
                               FieldAddress(EAX, Array::length_offset()),
                               EDI);
 
   // Initialize all array elements to raw_null.
   // EAX: new object start as a tagged pointer.
   // EBX: new object end address.
   // EDI: 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()));
   __ leal(EDI, FieldAddress(EAX, sizeof(RawArray)));
   Label done;
   Label init_loop;
   __ Bind(&init_loop);
   __ cmpl(EDI, EBX);
   __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
   __ movl(Address(EDI, 0), raw_null);
   __ addl(EDI, Immediate(kWordSize));
   __ jmp(&init_loop, Assembler::kNearJump);
@@ skipping 56 matching lines @@
 
 
 // Intrinsify only for Smi value and index. Non-smi values need a store buffer
 // update. Array length is always a Smi.
 bool Intrinsifier::Array_setIndexed(Assembler* assembler) {
   Label fall_through;
   if (FLAG_enable_type_checks) {
     const intptr_t type_args_field_offset =
         ComputeObjectArrayTypeArgumentsOffset();
     // Inline simple tests (Smi, null), fallthrough if not positive.
-    const Immediate raw_null =
+    const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     Label checked_ok;
     __ movl(EDI, Address(ESP, + 1 * kWordSize));  // Value.
     // Null value is valid for any type.
     __ cmpl(EDI, raw_null);
     __ j(EQUAL, &checked_ok, Assembler::kNearJump);
 
     __ movl(EBX, Address(ESP, + 3 * kWordSize));  // Array.
     __ movl(EBX, FieldAddress(EBX, type_args_field_offset));
     // EBX: Type arguments of array.
@@ skipping 226 matching lines @@
   if (FLAG_enable_type_checks) return false;
   Label fall_through;
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Array.
   __ movl(EBX, FieldAddress(EAX, GrowableObjectArray::length_offset()));
   // EBX: length.
   __ movl(EDI, FieldAddress(EAX, GrowableObjectArray::data_offset()));
   // EDI: data.
   // Compare length with capacity.
   __ cmpl(EBX, FieldAddress(EDI, Array::length_offset()));
   __ j(EQUAL, &fall_through, Assembler::kNearJump);  // Must grow data.
-  const Immediate value_one = Immediate(reinterpret_cast<int32_t>(Smi::New(1)));
+  const Immediate& value_one =
+      Immediate(reinterpret_cast<int32_t>(Smi::New(1)));
   // len = len + 1;
   __ addl(FieldAddress(EAX, GrowableObjectArray::length_offset()), value_one);
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Value
   ASSERT(kSmiTagShift == 1);
   __ StoreIntoObject(EDI,
                      FieldAddress(EDI, EBX, TIMES_2, Array::data_offset()),
                      EAX);
-  const Immediate raw_null =
+  const Immediate& raw_null =
       Immediate(reinterpret_cast<int32_t>(Object::null()));
   __ movl(EAX, raw_null);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Gets the length of a ByteArray.
 bool Intrinsifier::ByteArrayBase_getLength(Assembler* assembler) {
@@ skipping 785 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);
   // Can destroy ECX since we are not falling through.
-  Immediate count_limit = Immediate(0x1F);
+  const Immediate& count_limit = Immediate(0x1F);
   // 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(EAX);
   // Negative counts throw exception.
   __ cmpl(EAX, Immediate(0));
   __ j(LESS, &fall_through, Assembler::kNearJump);
   __ cmpl(EAX, count_limit);
   __ j(LESS_EQUAL, &shift_count_ok, Assembler::kNearJump);
   __ movl(EAX, count_limit);
@@ skipping 403 matching lines @@
   __ Bind(&is_true);
   __ LoadObject(EAX, Bool::True());
   __ ret();
   return true;
 }
 
 #undef __
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32