Improve computation of effects for load elimination.

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 435 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),
-      maps_stored_(false),
-      fields_stored_(false),
-      elements_stored_(false),
-      stores_(5, zone) { }
+    : zone_(zone), stores_(5, zone) { }
 
   inline bool Disabled() {
     return false;  // Effects are _not_ disabled.
   }
 
   // Process a possibly side-effecting instruction.
   void Process(HInstruction* instr, Zone* zone) {
-    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->CheckChangesFlag(kInobjectFields);
-        maps_stored_ |= instr->CheckChangesFlag(kMaps);
-        maps_stored_ |= instr->CheckChangesFlag(kElementsKind);
-        elements_stored_ |= instr->CheckChangesFlag(kElementsKind);
-        elements_stored_ |= instr->CheckChangesFlag(kElementsPointer);
-      }
+    if (instr->IsStoreNamedField()) {
+      stores_.Add(HStoreNamedField::cast(instr), zone_);
+    } else {
+      flags_.Add(instr->ChangesFlags());
     }
   }
 
   // Apply these effects to the given load elimination table.
   void Apply(HLoadEliminationTable* table) {
-    if (fields_stored_) {
+    // 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)) {
       table->Kill();
       return;
     }
-    if (maps_stored_) {
+    if (flags_.Contains(kElementsKind) || flags_.Contains(kMaps)) {
       table->KillOffset(JSObject::kMapOffset);
     }
-    if (elements_stored_) {
+    if (flags_.Contains(kElementsKind) || flags_.Contains(kElementsPointer)) {
       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) {
-    maps_stored_ |= that->maps_stored_;
-    fields_stored_ |= that->fields_stored_;
-    elements_stored_ |= that->elements_stored_;
+    flags_.Add(that->flags_);
     for (int i = 0; i < that->stores_.length(); i++) {
       stores_.Add(that->stores_[i], zone);
     }
   }
 
  private:
   Zone* zone_;
-  bool maps_stored_ : 1;
-  bool fields_stored_ : 1;
-  bool elements_stored_ : 1;
+  GVNFlagSet flags_;
   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