More check elimination improvements including partial learning on false branches of CompareMap and b

src/hydrogen-flow-engine.h

 // 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 104 matching lines @@
   void AnalyzeDominatedBlocks(HBasicBlock* root, State* initial) {
     InitializeStates();
     SetStateAt(root, initial);
 
     // Iterate all dominated blocks starting from the given start block.
     for (int i = root->block_id(); i < graph_->blocks()->length(); i++) {
       HBasicBlock* block = graph_->blocks()->at(i);
 
       // Skip blocks not dominated by the root node.
       if (SkipNonDominatedBlock(root, block)) continue;
-      State* state = StateAt(block);
+      State* state = State::Finish(StateAt(block), block, zone_);
 
       if (block->IsReachable()) {
+        ASSERT(state != NULL);
         if (block->IsLoopHeader()) {
           // Apply loop effects before analyzing loop body.
           ComputeLoopEffects(block)->Apply(state);
         } else {
           // Must have visited all predecessors before this block.
           CheckPredecessorCount(block);
         }
 
         // Go through all instructions of the current block, updating the state.
         for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
           state = state->Process(it.Current(), zone_);
         }
       }
 
       // Propagate the block state forward to all successor blocks.
       int max = block->end()->SuccessorCount();
       for (int i = 0; i < max; i++) {
         HBasicBlock* succ = block->end()->SuccessorAt(i);
         IncrementPredecessorCount(succ);
-        if (StateAt(succ) == NULL) {
-          // This is the first state to reach the successor.
-          if (max == 1 && succ->predecessors()->length() == 1) {
-            // Optimization: successor can inherit this state.
-            SetStateAt(succ, state);
-          } else {
-            // Successor needs a copy of the state.
-            SetStateAt(succ, state->Copy(succ, block, zone_));
-          }
+
+        if (max == 1 && succ->predecessors()->length() == 1) {
+          // Optimization: successor can inherit this state.
+          SetStateAt(succ, state);
         } else {
           // Merge the current state with the state already at the successor.
-          SetStateAt(succ, StateAt(succ)->Merge(succ, state, block, zone_));
+          SetStateAt(succ,
+                     State::Merge(StateAt(succ), succ, state, block, zone_));
         }
       }
     }
   }
 
  private:
   // Computes and caches the loop effects for the loop which has the given
   // block as its loop header.
   Effects* ComputeLoopEffects(HBasicBlock* block) {
     ASSERT(block->IsLoopHeader());
@@ skipping 67 matching lines @@
   ZoneList<int> pred_counts_;        // Finished predecessors (by block id).
 #endif
   ZoneList<State*> block_states_;    // Block states (by block id).
   ZoneList<Effects*> loop_effects_;  // Loop effects (by block id).
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_FLOW_ENGINE_H_