Fix issue 9644: object stores become large pieces of code if heap tracing is turned on; jumps aroun…

runtime/vm/intrinsifier_ia32.cc

 // 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.
 
@@ skipping 191 matching lines @@
     __ 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.
     __ cmpl(EBX, raw_null);
     __ j(EQUAL, &checked_ok, Assembler::kNearJump);
     // Check if it's dynamic.
     // For now handle only TypeArguments and bail out if InstantiatedTypeArgs.
     __ CompareClassId(EBX, kTypeArgumentsCid, EAX);
-    __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
+    __ j(NOT_EQUAL, &fall_through);
     // Get type at index 0.
     __ movl(EAX, FieldAddress(EBX, TypeArguments::type_at_offset(0)));
     __ CompareObject(EAX, Type::ZoneHandle(Type::DynamicType()));
     __ j(EQUAL,  &checked_ok, Assembler::kNearJump);
     // Check for int and num.
     __ testl(EDI, Immediate(kSmiTagMask));  // Value is Smi?
-    __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi value.
+    __ j(NOT_ZERO, &fall_through);  // Non-smi value.
     __ CompareObject(EAX, Type::ZoneHandle(Type::IntType()));
     __ j(EQUAL,  &checked_ok, Assembler::kNearJump);
     __ CompareObject(EAX, Type::ZoneHandle(Type::Number()));
-    __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
+    __ j(NOT_EQUAL, &fall_through);
     __ Bind(&checked_ok);
   }
   __ movl(EBX, Address(ESP, + 2 * kWordSize));  // Index.
   __ testl(EBX, Immediate(kSmiTagMask));
   // Index not Smi.
-  __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);
+  __ j(NOT_ZERO, &fall_through);
   __ 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);
+  __ j(ABOVE_EQUAL, &fall_through);
   // 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));  // Value.
   __ StoreIntoObject(EAX,
                      FieldAddress(EAX, EBX, TIMES_2, Array::data_offset()),
                      ECX);
   // Caller is responsible of preserving the value if necessary.
   __ ret();
   __ Bind(&fall_through);
@@ skipping 19 matching lines @@
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   __ movl(EAX, Address::Absolute(heap->TopAddress()));
   __ leal(EBX, Address(EAX, fixed_size));
 
   // Check if the allocation fits into the remaining space.
   // EAX: potential new backing array object start.
   // EBX: potential next object start.
   __ cmpl(EBX, Address::Absolute(heap->EndAddress()));
-  __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
+  __ j(ABOVE_EQUAL, &fall_through);
 
   // Successfully allocated the object(s), now update top to point to
   // next object start and initialize the object.
   __ movl(Address::Absolute(heap->TopAddress()), EBX);
   __ addl(EAX, Immediate(kHeapObjectTag));
 
   // Initialize the tags.
   // EAX: new growable array object start as a tagged pointer.
   const Class& cls = Class::Handle(
       isolate->object_store()->growable_object_array_class());
@@ skipping 74 matching lines @@
 // Set value into growable object array at specified index.
 // On stack: growable array (+3), index (+2), value (+1), return-address (+0).
 bool Intrinsifier::GrowableArray_setIndexed(Assembler* assembler) {
   if (FLAG_enable_type_checks) {
     return false;
   }
   Label fall_through;
   __ movl(EBX, Address(ESP, + 2 * kWordSize));  // Index.
   __ movl(EAX, Address(ESP, + 3 * kWordSize));  // GrowableArray.
   __ testl(EBX, Immediate(kSmiTagMask));
-  __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi index.
+  __ j(NOT_ZERO, &fall_through);  // Non-smi index.
   // Range check using _length field.
   __ cmpl(EBX, FieldAddress(EAX, GrowableObjectArray::length_offset()));
   // Runtime throws exception.
-  __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
+  __ j(ABOVE_EQUAL, &fall_through);
   __ movl(EAX, FieldAddress(EAX, GrowableObjectArray::data_offset()));  // data.
   __ movl(EDI, Address(ESP, + 1 * kWordSize));  // Value.
   // Note that EBX is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   __ StoreIntoObject(EAX,
                      FieldAddress(EAX, EBX, TIMES_2, Array::data_offset()),
                      EDI);
   __ ret();
   __ Bind(&fall_through);
   return false;
@@ skipping 21 matching lines @@
 // Set data of growable object array.
 // On stack: growable array (+2), data (+1), return-address (+0).
 bool Intrinsifier::GrowableArray_setData(Assembler* assembler) {
   if (FLAG_enable_type_checks) {
     return false;
   }
   Label fall_through;
   __ movl(EBX, Address(ESP, + 1 * kWordSize));  // Data.
   // Check that data is an ObjectArray.
   __ testl(EBX, Immediate(kSmiTagMask));
-  __ j(ZERO, &fall_through, Assembler::kNearJump);  // Data is Smi.
+  __ j(ZERO, &fall_through);  // Data is Smi.
   __ CompareClassId(EBX, kArrayCid, EAX);
-  __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
+  __ j(NOT_EQUAL, &fall_through);
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Growable array.
   __ StoreIntoObject(EAX,
                      FieldAddress(EAX, GrowableObjectArray::data_offset()),
                      EBX);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Add an element to growable array if it doesn't need to grow, otherwise
 // call into regular code.
 // On stack: growable array (+2), value (+1), return-address (+0).
 bool Intrinsifier::GrowableArray_add(Assembler* assembler) {
   // In checked mode we need to type-check the incoming argument.
   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.
+  __ j(EQUAL, &fall_through);  // Must grow data.
   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 =
@@ skipping 1042 matching lines @@
   __ SmiTag(EAX);
   __ movl(FieldAddress(EBX, String::hash_offset()), EAX);
   __ ret();
   return true;
 }
 
 #undef __
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32