Wire GrowableArray to use the internal VM object.

vm/opt_code_generator_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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 219 matching lines @@
   }
 
  private:
   GrowableArray<const Class*> classes_;
   GrowableArray<const LocalVariable*> locals_;
 
   DISALLOW_COPY_AND_ASSIGN(ClassesForLocals);
 };
 
 
-static const char* kGrowableArrayClassName = "GrowableObjectArray";
-static const char* kGrowableArrayLengthFieldName = "_length";
-static const char* kGrowableArrayArrayFieldName = "backingArray";
-
-
 OptimizingCodeGenerator::OptimizingCodeGenerator(
     Assembler* assembler, const ParsedFunction& parsed_function)
         : CodeGenerator(assembler, parsed_function),
           deoptimization_blobs_(4),
           classes_for_locals_(new ClassesForLocals()),
           smi_class_(Class::ZoneHandle(Isolate::Current()->object_store()
               ->smi_class())),
           double_class_(Class::ZoneHandle(Isolate::Current()->object_store()
-              ->double_class())) {
+              ->double_class())),
+          growable_object_array_class_(Class::ZoneHandle(Isolate::Current()
+              ->object_store()->growable_object_array_class())) {
   ASSERT(parsed_function.function().is_optimizable());
 }
 
 
 DeoptimizationBlob*
 OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node,
                                                DeoptReasonId reason_id) {
   DeoptimizationBlob* d = new DeoptimizationBlob(node, reason_id);
   deoptimization_blobs_.Add(d);
   return d;
@@ skipping 1353 matching lines @@
 
   Recognizer::Kind recognized_kind = Recognizer::RecognizeKind(target);
   switch (recognized_kind) {
     case Recognizer::kObjectArrayLength: {
       TraceOpt(node, "Inlines ObjectArray.length");
       __ movl(EAX, FieldAddress(EBX, Array::length_offset()));
       return;
     }
     case Recognizer::kGrowableArrayLength: {
       TraceOpt(node, "Inlines GrowableObjectArray.length");
-      intptr_t field_offset = GetFieldOffset(
-          cls,
-          String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName)));
-      __ movl(EAX, FieldAddress(EBX, field_offset));
+      __ movl(EAX, FieldAddress(EBX, GrowableObjectArray::length_offset()));
       return;
     }
     case Recognizer::kStringBaseLength: {
       TraceOpt(node, "Inlines StringBase.length");
       __ movl(EAX, FieldAddress(EBX, String::length_offset()));
       return;
     }
     default:
       UNIMPLEMENTED();
   }
@@ skipping 727 matching lines @@
     __ cmpl(EDX, FieldAddress(EBX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     // Note that EDX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EBX, EDX, TIMES_2, sizeof(RawArray)));
     HandleResult(node, EAX);
     TraceOpt(node, kMessage);
     return;
   }
 
-  const String& growable_object_array_class_name = String::Handle(
-      String::NewSymbol(kGrowableArrayClassName));
-  const Class& growable_array_class = Class::ZoneHandle(
-      Library::Handle(Library::CoreImplLibrary()).
-          LookupClass(growable_object_array_class_name));
-  ASSERT(!growable_array_class.IsNull());
-  if (AtIdNodeHasClassAt(node, node->id(), growable_array_class, 0)) {
-    const String& growable_array_length_field_name =
-        String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName));
-    const String& growable_array_array_field_name =
-        String::Handle(String::NewSymbol(kGrowableArrayArrayFieldName));
-    intptr_t length_offset = GetFieldOffset(growable_array_class,
-                                            growable_array_length_field_name);
-    intptr_t array_offset = GetFieldOffset(growable_array_class,
-                                           growable_array_array_field_name);
+  if (AtIdNodeHasClassAt(node, node->id(), growable_object_array_class_, 0)) {
     CodeGenInfo array_info(node->array());
     CodeGenInfo index_info(node->index_expr());
     VisitLoadTwo(node->array(), node->index_expr(), EDX, EAX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EDX, EAX, kDeoptLoadIndexedGrowableArray);
     // EAX: index, EDX: array.
     if (!index_info.IsClass(smi_class_)) {
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Not Smi index.
       PropagateBackLocalClass(node->index_expr(), smi_class_);
     }
-    if (!array_info.IsClass(growable_array_class)) {
+    if (!array_info.IsClass(growable_object_array_class_)) {
       __ testl(EDX, Immediate(kSmiTagMask));
       __ j(ZERO, deopt_blob->label());  // Array is Smi.
       __ movl(EBX, FieldAddress(EDX, Object::class_offset()));
-      __ CompareObject(EBX, growable_array_class);
+      __ CompareObject(EBX, growable_object_array_class_);
       __ j(NOT_EQUAL, deopt_blob->label());  // Not GrowableObjectArray.
-      PropagateBackLocalClass(node->array(), growable_array_class);
+      PropagateBackLocalClass(node->array(), growable_object_array_class_);
     }
     // Range check: deoptimize if out of bounds.
-    __ cmpl(EAX, FieldAddress(EDX, length_offset));
+    __ cmpl(EAX, FieldAddress(EDX, GrowableObjectArray::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());
-    __ movl(EDX, FieldAddress(EDX, array_offset));  // backingArray.
+    __ movl(EDX, FieldAddress(EDX, GrowableObjectArray::data_offset()));
     // Note that EAX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EDX, EAX, TIMES_2, sizeof(RawArray)));
     HandleResult(node, EAX);
     return;
   } else {
     // E.g., HashMap.
     TraceNotOpt(node, kMessage);
   }
   CodeGenerator::VisitLoadIndexedNode(node);
@@ skipping 61 matching lines @@
     __ cmpl(EBX, FieldAddress(EAX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());  // Range error -> deopt.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EAX,
                        FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
     HandleResult(node, ECX);
     return;
   }
 
-  const String& growable_object_array_class_name = String::Handle(
-      String::NewSymbol(kGrowableArrayClassName));
-  const Class& growable_array_class = Class::ZoneHandle(
-      Library::Handle(Library::CoreImplLibrary()).
-          LookupClass(growable_object_array_class_name));
-  ASSERT(!growable_array_class.IsNull());
-  if (AtIdNodeHasClassAt(node, node->id(), growable_array_class, 0)) {
-    const String& growable_array_length_field_name =
-        String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName));
-    const String& growable_array_array_field_name =
-        String::Handle(String::NewSymbol(kGrowableArrayArrayFieldName));
-    intptr_t length_offset = GetFieldOffset(growable_array_class,
-                                            growable_array_length_field_name);
-    intptr_t array_offset = GetFieldOffset(growable_array_class,
-                                           growable_array_array_field_name);
+  if (AtIdNodeHasClassAt(node, node->id(), growable_object_array_class_, 0)) {
     bool index_is_smi = false;
     // Release CodeGenInfo of index quickly as it may be used in the value,
     // e.g. a[i] += 3. Fixes issue 1570.
     {
       CodeGenInfo index_info(node->index_expr());
       node->index_expr()->Visit(this);
       index_is_smi = index_info.IsClass(smi_class_);
     }
     VisitLoadOne(node->value(), ECX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EBX, ECX, kDeoptStoreIndexed);
     __ popl(EBX);  // index.
     __ popl(EAX);  // array.
     // ECX: value, EBX:index, EAX: array, EDX: scratch.
     // Check class of array.
-    if (class_of_this_array.raw() != growable_array_class.raw()) {
+    if (class_of_this_array.raw() != growable_object_array_class_.raw()) {
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
       __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
-      __ CompareObject(EDX, growable_array_class);
+      __ CompareObject(EDX, growable_object_array_class_);
       __ j(NOT_EQUAL, deopt_blob->label());  // Not GrowableObjectArray.
-      PropagateBackLocalClass(node->array(), growable_array_class);
+      PropagateBackLocalClass(node->array(), growable_object_array_class_);
     }
     // Check class of index.
     if (!index_is_smi) {
       __ testl(EBX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Index not Smi -> deopt.
       PropagateBackLocalClass(node->index_expr(), smi_class_);
     }
     // Range check: deoptimize if out of bounds.
-    __ cmpl(EBX, FieldAddress(EAX, length_offset));
+    __ cmpl(EBX, FieldAddress(EAX, GrowableObjectArray::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());
-    __ movl(EDX, FieldAddress(EAX, array_offset));  // backingArray.
+    __ movl(EDX, FieldAddress(EAX, GrowableObjectArray::data_offset()));
     // Note that EAX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EDX,
                        FieldAddress(EDX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
     HandleResult(node, ECX);
     return;
   }
   node->index_expr()->Visit(this);
   node->value()->Visit(this);
@@ skipping 545 matching lines @@
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32