Fix bugs in load elimination and type propagation.

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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 4109 matching lines @@
     // Indexed location.
     kIndexed,
 
     // Current context.
     kContext
   };
 
   Place(const Place& other)
       : ValueObject(),
         kind_(other.kind_),
+        representation_(other.representation_),
         instance_(other.instance_),
         raw_selector_(other.raw_selector_),
         id_(other.id_) {
   }
 
   // Construct a place from instruction if instruction accesses any place.
   // Otherwise constructs kNone place.
   Place(Instruction* instr, bool* is_load)
-      : kind_(kNone), instance_(NULL), raw_selector_(0), id_(0) {
+      : kind_(kNone),
+        representation_(kNoRepresentation),
+        instance_(NULL),
+        raw_selector_(0),
+        id_(0) {
     switch (instr->tag()) {
       case Instruction::kLoadField: {
         LoadFieldInstr* load_field = instr->AsLoadField();
+        representation_ = load_field->representation();
         instance_ = OriginalDefinition(load_field->instance()->definition());
         if (load_field->field() != NULL) {
           kind_ = kField;
           field_ = load_field->field();
         } else {
           kind_ = kVMField;
           offset_in_bytes_ = load_field->offset_in_bytes();
         }
         *is_load = true;
         break;
       }
 
       case Instruction::kStoreInstanceField: {
         StoreInstanceFieldInstr* store_instance_field =
             instr->AsStoreInstanceField();
         kind_ = kField;
+        // Value is at input index 1.
+        representation_ = store_instance_field->RequiredInputRepresentation(1);

[srdjan, 2013/10/21 17:42:35]

Please factor repeated use of 0, 1 and 2 into constants.

         instance_ =
             OriginalDefinition(store_instance_field->instance()->definition());
         field_ = &store_instance_field->field();
         break;
       }
 
       case Instruction::kStoreVMField: {
         StoreVMFieldInstr* store_vm_field = instr->AsStoreVMField();
         kind_ = kVMField;
+        // Value is at input index 0.
+        representation_ = store_vm_field->RequiredInputRepresentation(0);
         instance_ = OriginalDefinition(store_vm_field->dest()->definition());
         offset_in_bytes_ = store_vm_field->offset_in_bytes();
         break;
       }
 
       case Instruction::kLoadStaticField:
         kind_ = kField;
+        representation_ = instr->AsLoadStaticField()->representation();
         field_ = &instr->AsLoadStaticField()->StaticField();
         *is_load = true;
         break;
 
       case Instruction::kStoreStaticField:
         kind_ = kField;
+        // Value is at input index 0.
+        representation_ =
+            instr->AsStoreStaticField()->RequiredInputRepresentation(0);
         field_ = &instr->AsStoreStaticField()->field();
         break;
 
       case Instruction::kLoadIndexed: {
         LoadIndexedInstr* load_indexed = instr->AsLoadIndexed();
         kind_ = kIndexed;
+        representation_ = load_indexed->representation();
         instance_ = OriginalDefinition(load_indexed->array()->definition());
         index_ = load_indexed->index()->definition();
         *is_load = true;
         break;
       }
 
       case Instruction::kStoreIndexed: {
         StoreIndexedInstr* store_indexed = instr->AsStoreIndexed();
         kind_ = kIndexed;
+        // Value is at input index 2.
+        representation_ = store_indexed->RequiredInputRepresentation(2);
         instance_ = OriginalDefinition(store_indexed->array()->definition());
         index_ = store_indexed->index()->definition();
         break;
       }
 
       case Instruction::kCurrentContext:
         kind_ = kContext;
+        ASSERT(instr->AsCurrentContext()->representation() == kTagged);
+        representation_ = kTagged;
         *is_load = true;
         break;
 
       case Instruction::kStoreContext:
         kind_ = kContext;
+        ASSERT(instr->AsStoreContext()->RequiredInputRepresentation(0) ==
+               kTagged);
+        representation_ = kTagged;
         break;
 
       default:
         break;
     }
   }
 
   intptr_t id() const { return id_; }
   void set_id(intptr_t id) { id_ = id; }
 
   Kind kind() const { return kind_; }
 
+  Representation representation() const { return representation_; }
+
   Definition* instance() const {
     ASSERT((kind_ == kField) || (kind_ == kVMField) || (kind_ == kIndexed));
     return instance_;
   }
 
   void set_instance(Definition* def) {
     ASSERT((kind_ == kField) || (kind_ == kVMField) || (kind_ == kIndexed));
     instance_ = OriginalDefinition(def);
   }
 
@@ skipping 45 matching lines @@
     UNREACHABLE();
     return "<?>";
   }
 
   bool IsFinalField() const {
     return (kind() == kField) && field().is_final();
   }
 
   intptr_t Hashcode() const {
     return (kind_ * 63 + reinterpret_cast<intptr_t>(instance_)) * 31 +
-        FieldHashcode();
+        representation_ * 15 + FieldHashcode();
   }
 
   bool Equals(Place* other) const {
     return (kind_ == other->kind_) &&
+        (representation_ == other->representation_) &&
         (instance_ == other->instance_) &&
         SameField(other);
   }
 
   // Create a zone allocated copy of this place.
   static Place* Wrap(const Place& place);
 
  private:
   static Definition* OriginalDefinition(Definition* defn) {
     while (defn->IsRedefinition()) {
       defn = defn->AsRedefinition()->value()->definition();
     }
     return defn;
   }
 
   bool SameField(Place* other) const {
     return (kind_ == kField) ? (field().raw() == other->field().raw())
                              : (offset_in_bytes_ == other->offset_in_bytes_);
   }
 
   intptr_t FieldHashcode() const {
     return (kind_ == kField) ? reinterpret_cast<intptr_t>(field().raw())
                              : offset_in_bytes_;
   }
 
   Kind kind_;
+  Representation representation_;
   Definition* instance_;
   union {
     intptr_t raw_selector_;
     const Field* field_;
     intptr_t offset_in_bytes_;
     Definition* index_;
   };
 
   intptr_t id_;
 };
@@ skipping 3407 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart