Really skip dead blocks in GVN

src/hydrogen-gvn.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 574 matching lines @@
     }
   }
 }
 
 
 void HGlobalValueNumberingPhase::LoopInvariantCodeMotion() {
   TRACE_GVN_1("Using optimistic loop invariant code motion: %s\n",
               graph()->use_optimistic_licm() ? "yes" : "no");
   for (int i = graph()->blocks()->length() - 1; i >= 0; --i) {
     HBasicBlock* block = graph()->blocks()->at(i);
-    if (block->IsLoopHeader()) {
+    if (block->IsLoopHeader() &&
+        block->IsReachable() &&
+        !block->IsDeoptimizing()) {
       SideEffects side_effects = loop_side_effects_[block->block_id()];
       if (FLAG_trace_gvn) {
         HeapStringAllocator allocator;
         StringStream stream(&allocator);
         stream.Add("Try loop invariant motion for block B%d changes ",
                    block->block_id());
         side_effects_tracker_.PrintSideEffectsTo(&stream, side_effects);
         stream.Add("\n");
         stream.OutputToStdOut();
       }
       HBasicBlock* last = block->loop_information()->GetLastBackEdge();
       for (int j = block->block_id(); j <= last->block_id(); ++j) {
         ProcessLoopBlock(graph()->blocks()->at(j), block, side_effects);
       }
     }
   }
 }
 
 
 void HGlobalValueNumberingPhase::ProcessLoopBlock(
     HBasicBlock* block,
     HBasicBlock* loop_header,
     SideEffects loop_kills) {
+  if (!block->IsReachable() || block->IsDeoptimizing()) return;
   HBasicBlock* pre_header = loop_header->predecessors()->at(0);
   if (FLAG_trace_gvn) {
     HeapStringAllocator allocator;
     StringStream stream(&allocator);
     stream.Add("Loop invariant code motion for B%d depends on ",
                block->block_id());
     side_effects_tracker_.PrintSideEffectsTo(&stream, loop_kills);
     stream.Add("\n");
     stream.OutputToStdOut();
   }
@@ skipping 44 matching lines @@
 }
 
 
 bool HGlobalValueNumberingPhase::AllowCodeMotion() {
   return info()->IsStub() || info()->opt_count() + 1 < FLAG_max_opt_count;
 }
 
 
 bool HGlobalValueNumberingPhase::ShouldMove(HInstruction* instr,
                                             HBasicBlock* loop_header) {
-  // If we've disabled code motion or we're in a block that unconditionally
-  // deoptimizes, don't move any instructions.
-  return AllowCodeMotion() && !instr->block()->IsDeoptimizing() &&
-      instr->block()->IsReachable();
+  // If we've disabled code motion, don't move any instructions.
+  return AllowCodeMotion();
 }
 
 
 SideEffects
 HGlobalValueNumberingPhase::CollectSideEffectsOnPathsToDominatedBlock(
     HBasicBlock* dominator, HBasicBlock* dominated) {
   SideEffects side_effects;
   for (int i = 0; i < dominated->predecessors()->length(); ++i) {
     HBasicBlock* block = dominated->predecessors()->at(i);
     if (dominator->block_id() < block->block_id() &&
@@ skipping 72 matching lines @@
   GvnBasicBlockState(GvnBasicBlockState* previous,
                      HBasicBlock* block,
                      HInstructionMap* map,
                      HSideEffectMap* dominators,
                      Zone* zone)
       : previous_(previous), next_(NULL) {
     Initialize(block, map, dominators, true, zone);
   }
 
   GvnBasicBlockState* next_dominated(Zone* zone) {
-    dominated_index_++;
-    if (dominated_index_ == length_ - 1) {
-      // No need to copy the map for the last child in the dominator tree.
-      Initialize(block_->dominated_blocks()->at(dominated_index_),
-                 map(),
-                 dominators(),
-                 false,
-                 zone);
-      return this;
-    } else if (dominated_index_ < length_) {
-      return push(zone, block_->dominated_blocks()->at(dominated_index_));
-    } else {
-      return NULL;
+    while (++dominated_index_ < length_) {
+      HBasicBlock* block = block_->dominated_blocks()->at(dominated_index_);
+      if (block->IsReachable()) {
+        if (dominated_index_ == length_ - 1) {
+          // No need to copy the map for the last child in the dominator tree.
+          Initialize(block, map(), dominators(), false, zone);
+          return this;
+        }
+        return push(zone, block);
+      }
     }
+    return NULL;
   }
 
   GvnBasicBlockState* push(Zone* zone, HBasicBlock* block) {
     if (next_ == NULL) {
       next_ =
           new(zone) GvnBasicBlockState(this, block, map(), dominators(), zone);
     } else {
       next_->Initialize(block, map(), dominators(), true, zone);
     }
     return next_;
@@ skipping 124 matching lines @@
                                                       dominated);
         successor_map->Kill(side_effects_on_all_paths);
         successor_dominators->Kill(side_effects_on_all_paths);
       }
     }
     current = next;
   }
 }
 
 } }  // namespace v8::internal