Rename the field type_arguments_instance_field_offset_ to

vm/stub_code_ia32.cc

 // Copyright (c) 2012, 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_IA32)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
@@ skipping 1096 matching lines @@
 //   ESP : points to return address.
 // Uses EAX, EBX, ECX, EDX, EDI as temporary registers.
 void StubCode::GenerateAllocationStubForClass(Assembler* assembler,
                                               const Class& cls) {
   const intptr_t kObjectTypeArgumentsOffset = 2 * kWordSize;
   const intptr_t kInstantiatorTypeArgumentsOffset = 1 * kWordSize;
   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_instance_field_offset() != Class::kNoTypeArguments;
+      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;
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
   const intptr_t type_args_size = InstantiatedTypeArguments::InstanceSize();
   if (FLAG_inline_alloc &&
       PageSpace::IsPageAllocatableSize(instance_size + type_args_size)) {
     Label slow_case;
@@ skipping 104 matching lines @@
       __ cmpl(ECX, EBX);
       __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
       __ movl(Address(ECX, 0), raw_null);
       __ addl(ECX, Immediate(kWordSize));
       __ jmp(&init_loop, Assembler::kNearJump);
       __ Bind(&done);
     }
     if (is_cls_parameterized) {
       // EDI: new object type arguments.
       // Set the type arguments in the new object.
-      __ movl(Address(EAX, cls.type_arguments_instance_field_offset()), EDI);
+      __ movl(Address(EAX, cls.type_arguments_field_offset()), EDI);
     }
     // Done allocating and initializing the instance.
     // EAX: new object.
     __ addl(EAX, Immediate(kHeapObjectTag));
     __ ret();
 
     __ Bind(&slow_case);
   }
   if (is_cls_parameterized) {
     __ movl(EAX, Address(ESP, kObjectTypeArgumentsOffset));
@@ skipping 621 matching lines @@
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movl(EAX, Address(ESP, kInstanceOffsetInBytes));
   if (n > 1) {
     // Get instance type arguments.
     __ LoadClass(ECX, EAX, EBX);
     // Compute instance type arguments into EBX.
     Label has_no_type_arguments;
     __ movl(EBX, raw_null);
     __ movl(EDI, FieldAddress(ECX,
-        Class::type_arguments_instance_field_offset_offset()));
+        Class::type_arguments_field_offset_offset()));
     __ cmpl(EDI, Immediate(Class::kNoTypeArguments));
     __ j(EQUAL, &has_no_type_arguments, Assembler::kNearJump);
     __ movl(EBX, FieldAddress(EAX, EDI, TIMES_1, 0));
     __ Bind(&has_no_type_arguments);
   }
   __ LoadClassId(ECX, EAX);
   // EAX: instance, ECX: instance class id.
   // EBX: instance type arguments (null if none), used only if n > 1.
   __ movl(EDX, Address(ESP, kCacheOffsetInBytes));
   // EDX: SubtypeTestCache.
@@ skipping 317 matching lines @@
   __ Bind(&done);
   __ popl(temp);
   __ popl(right);
   __ popl(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32