VM: Load-forwarding of non-final field values at allocations.

runtime/vm/flow_graph_optimizer.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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 6295 matching lines @@
           gen->RemoveAll(aliased_set_->aliased_by_effects());
           continue;
         }
 
         Definition* defn = instr->AsDefinition();
         if (defn == NULL) {
           continue;
         }
 
         // For object allocation forward initial values of the fields to
-        // subsequent loads. For simplicity we ignore escaping objects.
-        //
-        // The reason to ignore escaping objects is that final fields are
+        // subsequent loads. For skip final fields.  Final fields are
         // initialized in constructor that potentially can be not inlined into
         // the function that we are currently optimizing. However at the same
         // time we assume that values of the final fields can be forwarded
         // across side-effects. If we add 'null' as known values for these
         // fields here we will incorrectly propagate this null across
         // constructor invocation.
-        // TODO(vegorov): record null-values at least for not final fields of
-        // escaping object.
         AllocateObjectInstr* alloc = instr->AsAllocateObject();
-        if ((alloc != NULL) && !aliased_set_->CanBeAliased(alloc)) {
+        if ((alloc != NULL)) {
           for (Value* use = alloc->input_use_list();
                use != NULL;
                use = use->next_use()) {
             // Look for all immediate loads from this object.
             if (use->use_index() != 0) {
               continue;
             }
 
             LoadFieldInstr* load = use->instruction()->AsLoadField();
             if (load != NULL) {
               // Found a load. Initialize current value of the field to null for
               // normal fields, or with type arguments.
-              gen->Add(load->place_id());
-              if (out_values == NULL) out_values = CreateBlockOutValues();
 
+              // Forward for all fields for non-escaping objects and only
+              // non-final fields and type arguments for escaping ones.
+              if (aliased_set_->CanBeAliased(alloc) &&
+                  (load->field() != NULL) &&
+                  load->field()->is_final()) {
+                continue;
+              }
+
+              Definition* forward_def = graph_->constant_null();
               if (alloc->ArgumentCount() > 0) {
                 ASSERT(alloc->ArgumentCount() == 1);
                 intptr_t type_args_offset =
                     alloc->cls().type_arguments_field_offset();
                 if (load->offset_in_bytes() == type_args_offset) {
-                  (*out_values)[load->place_id()] =
-                      alloc->PushArgumentAt(0)->value()->definition();
-                  continue;
+                  forward_def = alloc->PushArgumentAt(0)->value()->definition();
                 }
               }
-              (*out_values)[load->place_id()] = graph_->constant_null();
+              gen->Add(load->place_id());
+              if (out_values == NULL) out_values = CreateBlockOutValues();
+              (*out_values)[load->place_id()] = forward_def;
             }
           }
           continue;
         }
 
         if (!IsLoadEliminationCandidate(defn)) {
           continue;
         }
 
         const intptr_t place_id = defn->place_id();
@@ skipping 3559 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart