Improve and simplify removal of unreachable code

src/lithium.cc

 // Copyright 2012 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 474 matching lines @@
         spill_slot_count_ += 2;
       } else {
         spill_slot_count_++;
       }
     }
     iterator.Advance();
   }
 }
 
 
+LInstruction* LChunkBuilder::ElideControlInstruction(
+    HControlInstruction* instr,
+    bool condition) {
+  HBasicBlock* successor = condition
+      ? instr->FirstSuccessor()
+      : instr->SecondSuccessor();
+  HBasicBlock* unreachable = condition
+      ? instr->SecondSuccessor()
+      : instr->FirstSuccessor();
+  unreachable->MarkUnreachable();
+  return new(zone()) LGoto(successor->block_id());
+}
+
+
+void LChunkBuilder::PropagateUnreachableBlockMarks() {

[Michael Starzinger, 2013/08/16 15:02:20]

As discussed offline: This looks like it should be done as a separate hydrogen
phase (similar to HPropagateDeoptimizingMarkPhase) instead of as part of the
lithium chunk builder. But I am totally fine with leaving this for a follow-up
CL to cleanup, in which case I would put a TODO here.

[Jakob Kummerow, 2013/08/30 11:52:43]

Am I missing something, or is this method never called?

+  // If there is unreachable code in the graph, propagate the unreachable marks
+  // using a fixed-point iteration.
+  if (graph()->HasUnreachableCode()) {

[Jakob Kummerow, 2013/08/20 08:46:56]

You can avoid a level of indentation by turning this into an early return:
if (!graph()->HasUnreachableCode()) return;

+    bool changed = true;
+    const ZoneList<HBasicBlock*>* blocks = graph()->blocks();
+    while (changed) {
+      changed = false;
+      for (int i = 0; i < blocks->length(); i++) {
+        HBasicBlock* block = blocks->at(i);
+        if (block->IsReachable()) {
+          bool is_reachable = blocks->at(0) == block;
+          for (HPredecessorIterator it(block); !it.Done(); it.Advance()) {
+            HBasicBlock* predecessor = it.Current();
+            if (predecessor->IsReachable() &&
+                !predecessor->IsDeoptimizing()) {
+              is_reachable = true;
+              break;
+            }
+          }
+          if (!is_reachable) {
+            block->MarkUnreachable();
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+}
+
+
 LPhase::~LPhase() {
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceLithium(name(), chunk_);
   }
 }
 
 
 } }  // namespace v8::internal