Split LoadStatic into two instructions: load static filed, load value.

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 3652 matching lines @@
         return Alias::VMField(load_field->offset_in_bytes());
       }
     }
 
     if (defn->IsCurrentContext()) {
       return Alias::CurrentContext();
     }
 
     LoadStaticFieldInstr* load_static_field = defn->AsLoadStaticField();
     if (load_static_field != NULL) {
-      return Alias::Field(GetFieldId(kAnyInstance, load_static_field->field()));
+      return Alias::Field(GetFieldId(kAnyInstance,
+                                     load_static_field->StaticField()));
     }
 
     UNREACHABLE();
     return Alias::None();
   }
 
   Alias ComputeAliasForStore(Instruction* instr) {
     if (instr->IsStoreIndexed()) {
       return Alias::Indexes();
     }
@@ skipping 155 matching lines @@
         return true;
       }
 
       AllocateObjectInstr* alloc =
           load_field->instance()->definition()->AsAllocateObject();
       return (alloc != NULL) && !CanBeAliased(alloc);
     }
 
     LoadStaticFieldInstr* load_static_field = defn->AsLoadStaticField();
     if (load_static_field != NULL) {
-      return load_static_field->field().is_final();
+      return load_static_field->StaticField().is_final();
     }
 
     return false;
   }
 
   class FieldIdPair {
    public:
     struct Key {
       Key(intptr_t instance_id, const Field* field)
           : instance_id_(instance_id), field_(field) { }
@@ skipping 107 matching lines @@
     } else if (key->IsStoreInstanceField()) {
       StoreInstanceFieldInstr* store_field = key->AsStoreInstanceField();
       object = store_field->instance()->definition()->ssa_temp_index();
       location = store_field->field().Offset();
     } else if (key->IsStoreVMField()) {
       StoreVMFieldInstr* store_field = key->AsStoreVMField();
       object = store_field->dest()->definition()->ssa_temp_index();
       location = store_field->offset_in_bytes();
     } else if (key->IsLoadStaticField()) {
       LoadStaticFieldInstr* load_static_field = key->AsLoadStaticField();
-      object = String::Handle(load_static_field->field().name()).Hash();
+      object = String::Handle(load_static_field->StaticField().name()).Hash();
     } else if (key->IsStoreStaticField()) {
       StoreStaticFieldInstr* store_static_field = key->AsStoreStaticField();
       object = String::Handle(store_static_field->field().name()).Hash();
     } else {
       ASSERT(key->IsStoreContext() ||
              key->IsCurrentContext() ||
              key->IsChainContext());
     }
 
     return object * 31 + location;
   }
 
   static inline bool IsKeyEqual(Pair kv, Key key) {
     if (kv->Equals(key)) return true;
 
     if (kv->IsLoadIndexed()) {
       if (key->IsStoreIndexed()) {
         LoadIndexedInstr* load_indexed = kv->AsLoadIndexed();
         StoreIndexedInstr* store_indexed = key->AsStoreIndexed();
         return load_indexed->array()->Equals(store_indexed->array()) &&
                load_indexed->index()->Equals(store_indexed->index());
       }
       return false;
     }
 
     if (kv->IsLoadStaticField()) {
       if (key->IsStoreStaticField()) {
         LoadStaticFieldInstr* load_static_field = kv->AsLoadStaticField();
         StoreStaticFieldInstr* store_static_field = key->AsStoreStaticField();
-        return load_static_field->field().raw() ==
+        return load_static_field->StaticField().raw() ==
             store_static_field->field().raw();
       }
       return false;
     }
 
     if (kv->IsCurrentContext()) {
       return key->IsStoreContext() || key->IsChainContext();
     }
 
     ASSERT(kv->IsLoadField());
@@ skipping 1211 matching lines @@
 }
 
 
 void ConstantPropagator::VisitStoreInstanceField(
     StoreInstanceFieldInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
 void ConstantPropagator::VisitLoadStaticField(LoadStaticFieldInstr* instr) {
-  const Field& field = instr->field();
+  const Field& field = instr->StaticField();
   ASSERT(field.is_static());
   if (field.is_final()) {
     Instance& obj = Instance::Handle(field.value());
     if (obj.IsSmi() || obj.IsOld()) {
       SetValue(instr, obj);
       return;
     }
   }
   SetValue(instr, non_constant_);
 }
@@ skipping 1320 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart