Add alias disambiguation for VM fields.

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 4871 matching lines @@
   // AliasedSet assigns ids to a combination of instance and field during
   // the optimization phase.
   static Alias Field(intptr_t id) {
     ASSERT(id != 0);
     return Alias(kFieldAlias, id);
   }
 
   // VMField load/stores alias each other when field offset matches.
   // TODO(vegorov) storing a context variable does not alias loading array
   // length.
-  static Alias VMField(intptr_t offset_in_bytes) {
-    ASSERT(offset_in_bytes >= 0);
-    const intptr_t idx = offset_in_bytes / kWordSize;
-    return Alias(kVMFieldAlias, idx);
+  static Alias VMField(intptr_t id) {
+    ASSERT(id != 0);
+    return Alias(kVMFieldAlias, id);
   }
 
   // Current context load/stores alias each other.
   static Alias CurrentContext() {
     return Alias(kCurrentContextAlias, 0);
   }
 
   // Operation does not alias anything.
   static Alias None() {
     return Alias(kNoneAlias);
@@ skipping 351 matching lines @@
  public:
   explicit AliasedSet(ZoneGrowableArray<Place*>* places,
                       PhiPlaceMoves* phi_moves)
       : places_(*places),
         phi_moves_(phi_moves),
         sets_(),
         aliased_by_effects_(new BitVector(places->length())),
         max_field_id_(0),
         field_ids_(),
         max_index_id_(0),
-        index_ids_() { }
+        index_ids_(),
+        max_vm_field_id_(0),
+        vm_field_ids_() { }
 
   Alias ComputeAlias(Place* place) {
     switch (place->kind()) {
       case Place::kIndexed:
         if (place->index()->IsConstant()) {
           const Object& index = place->index()->AsConstant()->value();
           if (index.IsSmi()) {
             return Alias::ConstantIndex(GetIndexId(Smi::Cast(index).Value()));
           }
         }
         return Alias::Indexes();
       case Place::kField:
         return Alias::Field(
             GetInstanceFieldId(place->instance(), place->field()));
       case Place::kVMField:
-        return Alias::VMField(place->offset_in_bytes());
+        return Alias::VMField(
+            GetVMFieldId(place->instance(), place->offset_in_bytes()));
       case Place::kContext:
         return Alias::CurrentContext();
       case Place::kNone:
         UNREACHABLE();
     }
 
     UNREACHABLE();
     return Alias::None();
   }
 
   Alias ComputeAliasForStore(Instruction* instr) {
     StoreIndexedInstr* store_indexed = instr->AsStoreIndexed();
     if (store_indexed != NULL) {
       if (store_indexed->index()->definition()->IsConstant()) {
         const Object& index =
             store_indexed->index()->definition()->AsConstant()->value();
         if (index.IsSmi()) {
           return Alias::ConstantIndex(GetIndexId(Smi::Cast(index).Value()));
         }
       }
       return Alias::Indexes();
     }
 
     StoreInstanceFieldInstr* store_instance_field =
         instr->AsStoreInstanceField();
     if (store_instance_field != NULL) {
       Definition* instance = store_instance_field->instance()->definition();
       if (!store_instance_field->field().IsNull()) {
-        return Alias::Field(GetInstanceFieldId(instance,
-                                               store_instance_field->field()));
+        return Alias::Field(
+            GetInstanceFieldId(instance, store_instance_field->field()));
       }
-      return Alias::VMField(store_instance_field->offset_in_bytes());
+      return Alias::VMField(
+          GetVMFieldId(instance, store_instance_field->offset_in_bytes()));
     }
 
     if (instr->IsStoreContext()) {
       return Alias::CurrentContext();
     }
 
     StoreStaticFieldInstr* store_static_field = instr->AsStoreStaticField();
     if (store_static_field != NULL) {
       return Alias::Field(GetStaticFieldId(store_static_field->field()));
     }
@@ skipping 154 matching lines @@
       AllocateObjectInstr* alloc = defn->AsAllocateObject();
       if ((alloc != NULL) && !CanBeAliased(alloc)) {
         instance_id = alloc->ssa_temp_index();
         ASSERT(instance_id != kAnyInstance);
       }
     }
 
     return GetFieldId(instance_id, field);
   }
 
+  intptr_t GetVMFieldId(Definition* defn, intptr_t offset) {
+    intptr_t instance_id = kAnyInstance;
+
+    if (defn != NULL) {
+      AllocateObjectInstr* alloc = defn->AsAllocateObject();
+      if ((alloc != NULL) && !CanBeAliased(alloc)) {
+        instance_id = alloc->ssa_temp_index();
+        ASSERT(instance_id != kAnyInstance);
+      }
+    }
+
+    intptr_t id = vm_field_ids_.Lookup(VMFieldIdPair::Key(instance_id, offset));
+    if (id == 0) {
+      id = ++max_vm_field_id_;
+      vm_field_ids_.Insert(
+          VMFieldIdPair(VMFieldIdPair::Key(instance_id, offset), id));
+    }
+    return id;
+  }
+
   // Get or create an identifier for a static field.
   intptr_t GetStaticFieldId(const Field& field) {
     ASSERT(field.is_static());
     return GetFieldId(kAnyInstance, field);
   }
 
   // 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) {
@@ skipping 82 matching lines @@
 
     static inline bool IsKeyEqual(IndexIdPair kv, Key key) {
       return KeyOf(kv) == key;
     }
 
    private:
     Key key_;
     Value value_;
   };
 
+  class VMFieldIdPair {
+   public:
+    struct Key {
+      Key(intptr_t instance_id, intptr_t offset)
+          : instance_id_(instance_id), offset_(offset) { }
+
+      intptr_t instance_id_;
+      intptr_t offset_;
+    };
+
+    typedef intptr_t Value;
+    typedef VMFieldIdPair Pair;
+
+    VMFieldIdPair(Key key, Value value) : key_(key), value_(value) { }
+
+    static Key KeyOf(Pair kv) {
+      return kv.key_;
+    }
+
+    static Value ValueOf(Pair kv) {
+      return kv.value_;
+    }
+
+    static intptr_t Hashcode(Key key) {
+      return (key.instance_id_ + 1) * 1024 + key.offset_;
+    }
+
+    static inline bool IsKeyEqual(Pair kv, Key key) {
+      return (KeyOf(kv).offset_ == key.offset_) &&
+          (KeyOf(kv).instance_id_ == key.instance_id_);
+    }
+
+   private:
+    Key key_;
+    Value value_;
+  };
+
   const ZoneGrowableArray<Place*>& places_;
 
   const PhiPlaceMoves* phi_moves_;
 
   // Maps alias index to a set of ssa indexes corresponding to loads with the
   // given alias.
   GrowableArray<BitVector*> sets_;
 
   BitVector* aliased_by_effects_;
 
   // Table mapping static field to their id used during optimization pass.
   intptr_t max_field_id_;
   DirectChainedHashMap<FieldIdPair> field_ids_;
 
   intptr_t max_index_id_;
   DirectChainedHashMap<IndexIdPair> index_ids_;
+
+  intptr_t max_vm_field_id_;
+  DirectChainedHashMap<VMFieldIdPair> vm_field_ids_;
 };
 
 
 static Definition* GetStoredValue(Instruction* instr) {
   if (instr->IsStoreIndexed()) {
     return instr->AsStoreIndexed()->value()->definition();
   }
 
   StoreInstanceFieldInstr* store_instance_field = instr->AsStoreInstanceField();
   if (store_instance_field != NULL) {
@@ skipping 2931 matching lines @@
 // Remove materializations from the graph. Register allocator will treat them
 // as part of the environment not as a real instruction.
 void AllocationSinking::DetachMaterializations() {
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     ASSERT(materializations_[i]->input_use_list() == NULL);
     materializations_[i]->previous()->LinkTo(materializations_[i]->next());
   }
 }
 
 
-// Add the given field to the list of fields if it is not yet present there.
-static void AddField(ZoneGrowableArray<const Field*>* fields,
-                     const Field& field) {
+// Add a field/offset to the list of fields if it is not yet present there.
+static void AddField(ZoneGrowableArray<const Object*>* fields,
+                     const Object& field) {
   for (intptr_t i = 0; i < fields->length(); i++) {
     if ((*fields)[i]->raw() == field.raw()) {
       return;
     }
   }
   fields->Add(&field);
 }
 
 
 // Add given instruction to the list of the instructions if it is not yet
 // present there.
 static void AddInstruction(GrowableArray<Instruction*>* exits,
                            Instruction* exit) {
   ASSERT(!exit->IsGraphEntry());
   for (intptr_t i = 0; i < exits->length(); i++) {
     if ((*exits)[i] == exit) {
       return;
     }
   }
   exits->Add(exit);
 }
 
 
 // Insert MaterializeObject instruction for the given allocation before
 // the given instruction that can deoptimize.
 void AllocationSinking::CreateMaterializationAt(
     Instruction* exit,
     AllocateObjectInstr* alloc,
     const Class& cls,
-    const ZoneGrowableArray<const Field*>& fields) {
+    const ZoneGrowableArray<const Object*>& fields) {
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(fields.length());
 
   // Insert load instruction for every field.
   for (intptr_t i = 0; i < fields.length(); i++) {
-    const Field* field = fields[i];
-    LoadFieldInstr* load = new LoadFieldInstr(new Value(alloc),
-                                              field,
-                                              AbstractType::ZoneHandle());
+    LoadFieldInstr* load = fields[i]->IsField()
+        ? new LoadFieldInstr(new Value(alloc),
+                             &Field::Cast(*fields[i]),
+                             AbstractType::ZoneHandle())
+        : new LoadFieldInstr(new Value(alloc),
+                             Smi::Cast(*fields[i]).Value(),
+                             AbstractType::ZoneHandle());
     flow_graph_->InsertBefore(
         exit, load, NULL, Definition::kValue);
     values->Add(new Value(load));
   }
 
   MaterializeObjectInstr* mat = new MaterializeObjectInstr(cls, fields, values);
   flow_graph_->InsertBefore(exit, mat, NULL, Definition::kValue);
 
   // Replace all mentions of this allocation with a newly inserted
   // MaterializeObject instruction.
@@ skipping 10 matching lines @@
     }
   }
 
   // Record inserted materialization.
   materializations_.Add(mat);
 }
 
 
 void AllocationSinking::InsertMaterializations(AllocateObjectInstr* alloc) {
   // Collect all fields that are written for this instance.
-  ZoneGrowableArray<const Field*>* fields =
-      new ZoneGrowableArray<const Field*>(5);
+  ZoneGrowableArray<const Object*>* fields =
+      new ZoneGrowableArray<const Object*>(5);
 
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = use->next_use()) {
-    ASSERT(use->instruction()->IsStoreInstanceField());
-    AddField(fields, use->instruction()->AsStoreInstanceField()->field());
+    StoreInstanceFieldInstr* store = use->instruction()->AsStoreInstanceField();
+    if (!store->field().IsNull()) {
+      AddField(fields, store->field());
+    } else {
+      AddField(fields, Smi::ZoneHandle(Smi::New(store->offset_in_bytes())));
+    }
   }
 
   if (alloc->ArgumentCount() > 0) {
     ASSERT(alloc->ArgumentCount() == 1);
-    const String& name = String::Handle(Symbols::New(":type_args"));
-    const Field& type_args_field =
-        Field::ZoneHandle(Field::New(
-            name,
-            false,  // !static
-            false,  // !final
-            false,  // !const
-            alloc->cls(),
-            0));  // No token position.
-    type_args_field.SetOffset(alloc->cls().type_arguments_field_offset());
-    AddField(fields, type_args_field);
+    intptr_t type_args_offset = alloc->cls().type_arguments_field_offset();
+    AddField(fields, Smi::ZoneHandle(Smi::New(type_args_offset)));
   }
 
   // Collect all instructions that mention this object in the environment.
   GrowableArray<Instruction*> exits(10);
   for (Value* use = alloc->env_use_list();
        use != NULL;
        use = use->next_use()) {
     AddInstruction(&exits, use->instruction());
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart