Fix optimizations on static fields in precompiled code.

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/compiler.h"
 #include "vm/cpu.h"
@@ skipping 37 matching lines @@
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_IA32)
 DEFINE_FLAG(bool, trace_smi_widening, false, "Trace Smi->Int32 widening pass.");
 #endif
 
 DECLARE_FLAG(bool, polymorphic_with_deopt);
 DECLARE_FLAG(bool, source_lines);
 DECLARE_FLAG(bool, trace_cha);
 DECLARE_FLAG(bool, trace_field_guards);
 DECLARE_FLAG(bool, trace_type_check_elimination);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
+DECLARE_FLAG(bool, fields_may_be_reset);
 
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
@@ skipping 5578 matching lines @@
               "<%s[%" Pd "|%" Pd "]>",
               DefinitionName(instance()),
               index_constant(),
               ElementSizeMultiplier(element_size()));
         }
     }
     UNREACHABLE();
     return "<?>";
   }
 
-  bool IsFinalField() const {
-    return (kind() == kField) && field().is_final();
+  // Fields that are considered immutable by load optimization.
+  // Handle static finals as non-final with precompilation because
+  // they may be reset to uninitialized after compilation.
+  bool IsImmutableField() const {
+    return (kind() == kField)
+        && field().is_final()
+        && (!field().is_static() || !FLAG_fields_may_be_reset);
   }
 
   intptr_t Hashcode() const {
     return (flags_ * 63 + reinterpret_cast<intptr_t>(instance_)) * 31 +
         FieldHashcode();
   }
 
   bool Equals(const Place* other) const {
     return (flags_ == other->flags_) &&
         (instance_ == other->instance_) &&
@@ skipping 316 matching lines @@
     // Artificial alias that is used to collect all representatives of
     // X[*] alias for all X.
     kAnyAllocationIndexedAlias = 3,
 
     // *[*] alias.
     kAnyInstanceAnyIndexAlias = 4
   };
 
   // Compute least generic alias for the place and assign alias id to it.
   void AddRepresentative(Place* place) {
-    if (!place->IsFinalField()) {
+    if (!place->IsImmutableField()) {
       const Place* alias = CanonicalizeAlias(place->ToAlias());
       EnsureSet(&representatives_, alias->id())->Add(place->id());
 
       // Update cumulative representative sets that are used during
       // killed sets computation.
       if (alias->kind() == Place::kConstantIndexed) {
         if (CanBeAliased(alias->instance())) {
           EnsureSet(&representatives_, kAnyConstantIndexedAlias)->
               Add(place->id());
         }
@@ skipping 185 matching lines @@
 
       case Place::kNone:
         UNREACHABLE();
     }
   }
 
   // Returns true if the given load is unaffected by external side-effects.
   // This essentially means that no stores to the same location can
   // occur in other functions.
   bool IsIndependentFromEffects(Place* place) {
-    if (place->IsFinalField()) {
+    if (place->IsImmutableField()) {
       // Note that we can't use LoadField's is_immutable attribute here because
       // some VM-fields (those that have no corresponding Field object and
       // accessed through offset alone) can share offset but have different
       // immutability properties.
       // One example is the length property of growable and fixed size list. If
       // loads of these two properties occur in the same function for the same
       // receiver then they will get the same expression number. However
       // immutability of the length of fixed size list does not mean that
       // growable list also has immutable property. Thus we will make a
       // conservative assumption for the VM-properties.
@@ skipping 413 matching lines @@
 
         bool is_load = false, is_store = false;
         Place place(instr, &is_load, &is_store);
 
         BitVector* killed = NULL;
         if (is_store) {
           const intptr_t alias_id =
               aliased_set_->LookupAliasId(place.ToAlias());
           if (alias_id != AliasedSet::kNoAlias) {
             killed = aliased_set_->GetKilledSet(alias_id);
-          } else if (!place.IsFinalField()) {
+          } else if (!place.IsImmutableField()) {
             // We encountered unknown alias: this means intrablock load
             // forwarding refined parameter of this store, for example
             //
             //     o   <- alloc()
             //     a.f <- o
             //     u   <- a.f
             //     u.x <- null ;; this store alias is *.x
             //
             // after intrablock load forwarding
             //
@@ skipping 883 matching lines @@
 
       // Iterate backwards starting at the last instruction.
       for (BackwardInstructionIterator instr_it(block);
            !instr_it.Done();
            instr_it.Advance()) {
         Instruction* instr = instr_it.Current();
 
         bool is_load = false;
         bool is_store = false;
         Place place(instr, &is_load, &is_store);
-        if (place.IsFinalField()) {
+        if (place.IsImmutableField()) {
           // Loads/stores of final fields do not participate.
           continue;
         }
 
         // Handle stores.
         if (is_store) {
           if (kill->Contains(instr->place_id())) {
             if (!live_in->Contains(instr->place_id()) &&
                 CanEliminateStore(instr)) {
               if (FLAG_trace_optimization) {
@@ skipping 68 matching lines @@
         exposed_stores_[postorder_number];
       if (exposed_stores == NULL) continue;  // No exposed stores.
 
       // Iterate over candidate stores.
       for (intptr_t i = 0; i < exposed_stores->length(); ++i) {
         Instruction* instr = (*exposed_stores)[i];
         bool is_load = false;
         bool is_store = false;
         Place place(instr, &is_load, &is_store);
         ASSERT(!is_load && is_store);
-        if (place.IsFinalField()) {
+        if (place.IsImmutableField()) {
           // Final field do not participate in dead store elimination.
           continue;
         }
         // Eliminate a downward exposed store if the corresponding place is not
         // in live-out.
         if (!live_out->Contains(instr->place_id()) &&
             CanEliminateStore(instr)) {
           if (FLAG_trace_optimization) {
             THR_Print("Removing dead store to place %" Pd " block B%" Pd "\n",
                       instr->place_id(), block->block_id());
@@ skipping 1187 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
 
 }  // namespace dart