Reset trunk to 3.24.35.4

src/hydrogen-load-elimination.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 58 matching lines @@
   // The main processing of instructions.
   HLoadEliminationTable* Process(HInstruction* instr, Zone* zone) {
     switch (instr->opcode()) {
       case HValue::kLoadNamedField: {
         HLoadNamedField* l = HLoadNamedField::cast(instr);
         TRACE((" process L%d field %d (o%d)\n",
                instr->id(),
                FieldOf(l->access()),
                l->object()->ActualValue()->id()));
         HValue* result = load(l);
-        if (result != instr &&
-            result->type().Equals(instr->type()) &&
-            result->representation().Equals(instr->representation())) {
+        if (result != instr) {
           // The load can be replaced with a previous load or a value.
           TRACE(("  replace L%d -> v%d\n", instr->id(), result->id()));
           instr->DeleteAndReplaceWith(result);
         }
         break;
       }
       case HValue::kStoreNamedField: {
         HStoreNamedField* s = HStoreNamedField::cast(instr);
         TRACE((" process S%d field %d (o%d) = v%d\n",
                instr->id(),
                FieldOf(s->access()),
                s->object()->ActualValue()->id(),
                s->value()->id()));
         HValue* result = store(s);
         if (result == NULL) {
           // The store is redundant. Remove it.
           TRACE(("  remove S%d\n", instr->id()));
           instr->DeleteAndReplaceWith(NULL);
         }
         break;
       }
-      case HValue::kTransitionElementsKind: {
-        HTransitionElementsKind* t = HTransitionElementsKind::cast(instr);
-        HValue* object = t->object()->ActualValue();
-        KillFieldInternal(object, FieldOf(JSArray::kElementsOffset), NULL);
-        KillFieldInternal(object, FieldOf(JSObject::kMapOffset), NULL);
-        break;
-      }
       default: {
-        if (instr->CheckChangesFlag(kInobjectFields)) {
+        if (instr->CheckGVNFlag(kChangesInobjectFields)) {
           TRACE((" kill-all i%d\n", instr->id()));
           Kill();
           break;
         }
-        if (instr->CheckChangesFlag(kMaps)) {
+        if (instr->CheckGVNFlag(kChangesMaps)) {
           TRACE((" kill-maps i%d\n", instr->id()));
           KillOffset(JSObject::kMapOffset);
         }
-        if (instr->CheckChangesFlag(kElementsKind)) {
+        if (instr->CheckGVNFlag(kChangesElementsKind)) {
           TRACE((" kill-elements-kind i%d\n", instr->id()));
           KillOffset(JSObject::kMapOffset);
           KillOffset(JSObject::kElementsOffset);
         }
-        if (instr->CheckChangesFlag(kElementsPointer)) {
+        if (instr->CheckGVNFlag(kChangesElementsPointer)) {
           TRACE((" kill-elements i%d\n", instr->id()));
           KillOffset(JSObject::kElementsOffset);
         }
-        if (instr->CheckChangesFlag(kOsrEntries)) {
+        if (instr->CheckGVNFlag(kChangesOsrEntries)) {
           TRACE((" kill-osr i%d\n", instr->id()));
           Kill();
         }
       }
       // Improvements possible:
       // - learn from HCheckMaps for field 0
       // - remove unobservable stores (write-after-write)
       // - track cells
       // - track globals
       // - track roots
     }
     return this;
   }
 
-  // Support for global analysis with HFlowEngine: Merge given state with
-  // the other incoming state.
-  static HLoadEliminationTable* Merge(HLoadEliminationTable* succ_state,
-                                      HBasicBlock* succ_block,
-                                      HLoadEliminationTable* pred_state,
-                                      HBasicBlock* pred_block,
-                                      Zone* zone) {
-    ASSERT(pred_state != NULL);
-    if (succ_state == NULL) {
-      return pred_state->Copy(succ_block, pred_block, zone);
-    } else {
-      return succ_state->Merge(succ_block, pred_state, pred_block, zone);
-    }
-  }
-
-  // Support for global analysis with HFlowEngine: Given state merged with all
-  // the other incoming states, prepare it for use.
-  static HLoadEliminationTable* Finish(HLoadEliminationTable* state,
-                                       HBasicBlock* block,
-                                       Zone* zone) {
-    ASSERT(state != NULL);
-    return state;
-  }
-
- private:
-  // Copy state to successor block.
+  // Support for global analysis with HFlowEngine: Copy state to successor
+  // block.
   HLoadEliminationTable* Copy(HBasicBlock* succ, HBasicBlock* from_block,
                               Zone* zone) {
     HLoadEliminationTable* copy =
         new(zone) HLoadEliminationTable(zone, aliasing_);
     copy->EnsureFields(fields_.length());
     for (int i = 0; i < fields_.length(); i++) {
       copy->fields_[i] = fields_[i]->Copy(zone);
     }
     if (FLAG_trace_load_elimination) {
       TRACE((" copy-to B%d\n", succ->block_id()));
       copy->Print();
     }
     return copy;
   }
 
-  // Merge this state with the other incoming state.
+  // Support for global analysis with HFlowEngine: Merge this state with
+  // the other incoming state.
   HLoadEliminationTable* Merge(HBasicBlock* succ, HLoadEliminationTable* that,
                                HBasicBlock* that_block, Zone* zone) {
     if (that->fields_.length() < fields_.length()) {
       // Drop fields not in the other table.
       fields_.Rewind(that->fields_.length());
     }
     for (int i = 0; i < fields_.length(); i++) {
       // Merge the field approximations for like fields.
       HFieldApproximation* approx = fields_[i];
       HFieldApproximation* prev = NULL;
@@ skipping 259 matching lines @@
   Zone* zone_;
   ZoneList<HFieldApproximation*> fields_;
   HAliasAnalyzer* aliasing_;
 };
 
 
 // Support for HFlowEngine: collect store effects within loops.
 class HLoadEliminationEffects : public ZoneObject {
  public:
   explicit HLoadEliminationEffects(Zone* zone)
-    : zone_(zone), stores_(5, zone) { }
+    : zone_(zone),
+      maps_stored_(false),
+      fields_stored_(false),
+      elements_stored_(false),
+      stores_(5, zone) { }
 
   inline bool Disabled() {
     return false;  // Effects are _not_ disabled.
   }
 
   // Process a possibly side-effecting instruction.
   void Process(HInstruction* instr, Zone* zone) {
-    if (instr->IsStoreNamedField()) {
-      stores_.Add(HStoreNamedField::cast(instr), zone_);
-    } else {
-      flags_.Add(instr->ChangesFlags());
+    switch (instr->opcode()) {
+      case HValue::kStoreNamedField: {
+        stores_.Add(HStoreNamedField::cast(instr), zone_);
+        break;
+      }
+      case HValue::kOsrEntry: {
+        // Kill everything. Loads must not be hoisted past the OSR entry.
+        maps_stored_ = true;
+        fields_stored_ = true;
+        elements_stored_ = true;
+      }
+      default: {
+        fields_stored_ |= instr->CheckGVNFlag(kChangesInobjectFields);
+        maps_stored_ |= instr->CheckGVNFlag(kChangesMaps);
+        maps_stored_ |= instr->CheckGVNFlag(kChangesElementsKind);
+        elements_stored_ |= instr->CheckGVNFlag(kChangesElementsKind);
+        elements_stored_ |= instr->CheckGVNFlag(kChangesElementsPointer);
+      }
     }
   }
 
   // Apply these effects to the given load elimination table.
   void Apply(HLoadEliminationTable* table) {
-    // Loads must not be hoisted past the OSR entry, therefore we kill
-    // everything if we see an OSR entry.
-    if (flags_.Contains(kInobjectFields) || flags_.Contains(kOsrEntries)) {
+    if (fields_stored_) {
       table->Kill();
       return;
     }
-    if (flags_.Contains(kElementsKind) || flags_.Contains(kMaps)) {
+    if (maps_stored_) {
       table->KillOffset(JSObject::kMapOffset);
     }
-    if (flags_.Contains(kElementsKind) || flags_.Contains(kElementsPointer)) {
+    if (elements_stored_) {
       table->KillOffset(JSObject::kElementsOffset);
     }
 
     // Kill non-agreeing fields for each store contained in these effects.
     for (int i = 0; i < stores_.length(); i++) {
       table->KillStore(stores_[i]);
     }
   }
 
   // Union these effects with the other effects.
   void Union(HLoadEliminationEffects* that, Zone* zone) {
-    flags_.Add(that->flags_);
+    maps_stored_ |= that->maps_stored_;
+    fields_stored_ |= that->fields_stored_;
+    elements_stored_ |= that->elements_stored_;
     for (int i = 0; i < that->stores_.length(); i++) {
       stores_.Add(that->stores_[i], zone);
     }
   }
 
  private:
   Zone* zone_;
-  GVNFlagSet flags_;
+  bool maps_stored_ : 1;
+  bool fields_stored_ : 1;
+  bool elements_stored_ : 1;
   ZoneList<HStoreNamedField*> stores_;
 };
 
 
 // The main routine of the analysis phase. Use the HFlowEngine for either a
 // local or a global analysis.
 void HLoadEliminationPhase::Run() {
   HFlowEngine<HLoadEliminationTable, HLoadEliminationEffects>
     engine(graph(), zone());
   HAliasAnalyzer aliasing;
   HLoadEliminationTable* table =
       new(zone()) HLoadEliminationTable(zone(), &aliasing);
 
   if (GLOBAL) {
     // Perform a global analysis.
     engine.AnalyzeDominatedBlocks(graph()->blocks()->at(0), table);
   } else {
     // Perform only local analysis.
     for (int i = 0; i < graph()->blocks()->length(); i++) {
       table->Kill();
       engine.AnalyzeOneBlock(graph()->blocks()->at(i), table);
     }
   }
 }
 
 } }  // namespace v8::internal