Revert "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() &&
-        block->IsReachable() &&
-        !block->IsDeoptimizing()) {
+    if (block->IsLoopHeader()) {
       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, don't move any instructions.
-  return AllowCodeMotion();
+  // 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();
 }
 
 
 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) {
-    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);
-      }
+    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;
     }
-    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