Check all cases with "__ movl(FieldAddress" and converted them to StoreIntoObject where appropriate.

vm/intrinsifier_ia32.cc

 // Copyright (c) 2011, 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.
 
@@ skipping 108 matching lines @@
   // next object start and initialize the object.
   __ movl(Address::Absolute(heap->TopAddress()), EBX);
   __ addl(EAX, Immediate(kHeapObjectTag));
 
   // EAX: new object start as a tagged pointer.
   // EBX: new object end address.
   // Store class value for array.
   __ movl(EDI, FieldAddress(CTX, Context::isolate_offset()));
   __ movl(EDI, Address(EDI, Isolate::object_store_offset()));
   __ movl(EDI, Address(EDI, ObjectStore::array_class_offset()));
-  __ movl(FieldAddress(EAX, Instance::class_offset()), EDI);
+  __ StoreIntoObject(EAX, FieldAddress(EAX, Instance::class_offset()), EDI);
 
   // Store the type argument field.
   __ movl(EDI, Address(ESP, kTypeArgumentsOffset));  // type argument.
-  __ movl(FieldAddress(EAX, Array::type_arguments_offset()), EDI);
+  __ StoreIntoObject(EAX,
+                     FieldAddress(EAX, Array::type_arguments_offset()),
+                     EDI);
 
   // Set the length field.
   __ movl(EDI, Address(ESP, kArrayLengthOffset));  // Array Length.
-  __ movl(FieldAddress(EAX, Array::length_offset()), EDI);
+  __ StoreIntoObject(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 =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ leal(EDI, FieldAddress(EAX, sizeof(RawArray)));
   Label done;
@@ skipping 56 matching lines @@
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);
   __ movl(EAX, Address(ESP, + 3 * kWordSize));  // Array.
   // Range check.
   __ cmpl(EBX, FieldAddress(EAX, Array::length_offset()));
   // Runtime throws exception.
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
   // Note that EBX is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   // Destroy ECX as we will not continue in the function.
   __ movl(ECX, Address(ESP, + 1 * kWordSize));
-  __ movl(FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)), ECX);
+  __ StoreIntoObject(EAX,
+                     FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)),
+                     ECX);
   // Caller is responsible of preserving the value if necessary.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 static intptr_t GetOffsetForField(const char* class_name_p,
                                   const char* field_name_p) {
   const String& class_name = String::Handle(String::NewSymbol(class_name_p));
@@ skipping 245 matching lines @@
   __ shld(EDI, EAX);
   // Result in EDI (high) and EBX (low).
   const Class& mint_class = Class::ZoneHandle(
       Isolate::Current()->object_store()->mint_class());
   __ LoadObject(ECX, mint_class);
   AssemblerMacros::TryAllocate(assembler,
                                mint_class,
                                ECX,  // Class register.
                                &fall_through,
                                EAX);  // Result register.
+  // EBX and EDI are not objects but integer values.
   __ movl(FieldAddress(EAX, Mint::value_offset()), EBX);
   __ movl(FieldAddress(EAX, Mint::value_offset() + kWordSize), EDI);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 static bool CompareIntegers(Assembler* assembler, Condition true_condition) {
   Label fall_through, true_label;
@@ skipping 393 matching lines @@
   __ cmpl(EBX, FieldAddress(EAX, Array::length_offset()));  // Range check.
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
 
   // EBX is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   __ movl(EDI, FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)));  // Result.
   const Immediate value = Immediate(reinterpret_cast<int32_t>(Smi::New(1)));
   __ addl(EBX, value);  // _pos++.
   __ j(OVERFLOW, &fall_through, Assembler::kNearJump);
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Receiver.
-  __ movl(FieldAddress(EAX, pos_offset), EBX);  // Store _pos.
+  __ StoreIntoObject(EAX, FieldAddress(EAX, pos_offset), EBX);  // Store _pos.
   __ movl(EAX, EDI);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Class 'FixedSizeArrayIterator':
 //   bool hasNext() {
 //     return _length > _pos;
@@ skipping 103 matching lines @@
   }                                                                            \
 
 INTRINSIC_LIST(FIND_INTRINSICS);
 #undef FIND_INTRINSICS
   return false;
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32