Split array loads/stores for growable arrays into two IL instructions.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/hash_map.h"
@@ skipping 330 matching lines @@
                    call->env(),
                    Definition::kEffect);
       // Insert array bounds check.
       InsertBefore(call,
                    new CheckArrayBoundInstr(array->Copy(),
                                             index->Copy(),
                                             class_id,
                                             call),
                    call->env(),
                    Definition::kEffect);
+      if (class_id == kGrowableObjectArrayCid) {
+        // Insert data elements load.
+        // TODO(fschneider): type of load should be GrowableObjectArrayType.
+        LoadVMFieldInstr* elements =
+            new LoadVMFieldInstr(array->Copy(),
+                                 GrowableObjectArray::data_offset(),
+                                 AbstractType::ZoneHandle());

[srdjan, 2012/09/12 07:06:40]

Add:
    elements->set_result_cid(kArrayCid);

As type of elements use:
   Type::ZoneHandle(Type::DynamicType())

[Florian Schneider, 2012/09/12 08:27:29]

Done.

+        InsertBefore(call, elements, NULL, Definition::kValue);
+        array = new Value(elements);
+      }
       Definition* array_op = NULL;
       if (op_kind == Token::kINDEX) {
         array_op = new LoadIndexedInstr(array, index, class_id);
       } else {
         Value* value = call->ArgumentAt(2)->value();
         array_op = new StoreIndexedInstr(array, index, value, class_id);
       }
       call->ReplaceWith(array_op, current_iterator());
       RemovePushArguments(call);
       return true;
@@ skipping 246 matching lines @@
 
   // VM objects length getter.
   if ((recognized_kind == MethodRecognizer::kObjectArrayLength) ||
       (recognized_kind == MethodRecognizer::kImmutableArrayLength) ||
       (recognized_kind == MethodRecognizer::kGrowableArrayLength)) {
     if (!HasOneTarget(ic_data)) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     intptr_t length_offset = -1;
+    bool is_immutable = false;
     switch (recognized_kind) {
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
         length_offset = Array::length_offset();
+        is_immutable = true;
         break;
       case MethodRecognizer::kGrowableArrayLength:
         length_offset = GrowableObjectArray::length_offset();
         break;
       default:
         UNREACHABLE();
     }
     // Check receiver class.
     AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
 
     LoadVMFieldInstr* load = new LoadVMFieldInstr(
         call->ArgumentAt(0)->value(),
         length_offset,
-        Type::ZoneHandle(Type::SmiType()));
+        Type::ZoneHandle(Type::SmiType()),
+        is_immutable);
     load->set_result_cid(kSmiCid);
     call->ReplaceWith(load, current_iterator());
     RemovePushArguments(call);
     return true;
   }
 
   if (recognized_kind == MethodRecognizer::kGrowableArrayCapacity) {
     // Check receiver class.
     AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
 
@@ skipping 17 matching lines @@
   }
 
   if (recognized_kind == MethodRecognizer::kStringBaseLength) {
     if (!HasOneTarget(ic_data)) {
       // Target is not only StringBase_get_length.
       return false;
     }
     // Check receiver class.
     AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
 
+    const bool is_immutable = true;  // String length is immutable.
     LoadVMFieldInstr* load = new LoadVMFieldInstr(
         call->ArgumentAt(0)->value(),
         String::length_offset(),
-        Type::ZoneHandle(Type::SmiType()));
+        Type::ZoneHandle(Type::SmiType()),
+        is_immutable);
     load->set_result_cid(kSmiCid);
     call->ReplaceWith(load, current_iterator());
     RemovePushArguments(call);
     return true;
   }
   return false;
 }
 
 
 // Inline only simple, frequently called core library methods.
@@ skipping 615 matching lines @@
     for (BitVector::Iterator loop_it(header->loop_info());
          !loop_it.Done();
          loop_it.Advance()) {
       BlockEntryInstr* block = flow_graph->preorder()[loop_it.Current()];
       for (ForwardInstructionIterator it(block);
            !it.Done();
            it.Advance()) {
         Definition* current = it.Current()->AsDefinition();
         if (current != NULL &&
             !current->IsPushArgument() &&
-            !current->HasSideEffect()) {
+            !current->AffectedBySideEffect()) {
           bool inputs_loop_invariant = true;
           for (int i = 0; i < current->InputCount(); ++i) {
             Definition* input_def = current->InputAt(i)->definition();
             if (!input_def->GetBlock()->Dominates(pre_header)) {
               inputs_loop_invariant = false;
               break;
             }
           }
           if (inputs_loop_invariant) {
             Hoist(&it, pre_header, current);
@@ skipping 13 matching lines @@
   DirectChainedHashMap<Definition*> map;
   OptimizeRecursive(graph_entry, &map);
 }
 
 
 void DominatorBasedCSE::OptimizeRecursive(
     BlockEntryInstr* block,
     DirectChainedHashMap<Definition*>* map) {
   for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
     Definition* defn = it.Current()->AsDefinition();
-    if ((defn == NULL) || defn->HasSideEffect()) continue;
+    if ((defn == NULL) || defn->AffectedBySideEffect()) continue;
     Definition* result = map->Lookup(defn);
     if (result == NULL) {
       map->Insert(defn);
       continue;
     }
     // Replace current with lookup result.
     defn->ReplaceUsesWith(result);
     it.RemoveCurrentFromGraph();
     if (FLAG_trace_optimization) {
       OS::Print("Replacing v%"Pd" with v%"Pd"\n",
@@ skipping 10 matching lines @@
       DirectChainedHashMap<Definition*> child_map(*map);  // Copy map.
       OptimizeRecursive(child, &child_map);
     } else {
       OptimizeRecursive(child, map);  // Reuse map for the last child.
     }
   }
 }
 
 
 }  // namespace dart