Improve dead code elimination by transitively marking live code and removing all dead code. Replace…

src/hydrogen.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 86 matching lines @@
 void HBasicBlock::AddPhi(HPhi* phi) {
   ASSERT(!IsStartBlock());
   phis_.Add(phi, zone());
   phi->SetBlock(this);
 }
 
 
 void HBasicBlock::RemovePhi(HPhi* phi) {
   ASSERT(phi->block() == this);
   ASSERT(phis_.Contains(phi));
-  ASSERT(phi->HasNoUses() || !phi->is_live());
   phi->Kill();
   phis_.RemoveElement(phi);
   phi->SetBlock(NULL);
 }
 
 
 void HBasicBlock::AddInstruction(HInstruction* instr) {
   ASSERT(!IsStartBlock() || !IsFinished());
   ASSERT(!instr->IsLinked());
   ASSERT(!IsFinished());
@@ skipping 2469 matching lines @@
   // Make sure that we *really* removed all redundant phis.
   for (int i = 0; i < blocks_.length(); ++i) {
     for (int j = 0; j < blocks_[i]->phis()->length(); j++) {
       ASSERT(blocks_[i]->phis()->at(j)->GetRedundantReplacement() == NULL);
     }
   }
 #endif
 }
 
 
-void HGraph::EliminateUnreachablePhis() {
-  HPhase phase("H_Unreachable phi elimination", this);
-
-  // Initialize worklist.
-  ZoneList<HPhi*> phi_list(blocks_.length(), zone());
-  ZoneList<HPhi*> worklist(blocks_.length(), zone());
-  for (int i = 0; i < blocks_.length(); ++i) {
-    for (int j = 0; j < blocks_[i]->phis()->length(); j++) {
-      HPhi* phi = blocks_[i]->phis()->at(j);
-      phi_list.Add(phi, zone());
-      // We can't eliminate phis in the receiver position in the environment
-      // because in case of throwing an error we need this value to
-      // construct a stack trace.
-      if (phi->HasRealUses() || phi->IsReceiver())  {
-        phi->set_is_live(true);
-        worklist.Add(phi, zone());
-      }
-    }
-  }
-
-  // Iteratively mark live phis.
-  while (!worklist.is_empty()) {
-    HPhi* phi = worklist.RemoveLast();
-    for (int i = 0; i < phi->OperandCount(); i++) {
-      HValue* operand = phi->OperandAt(i);
-      if (operand->IsPhi() && !HPhi::cast(operand)->is_live()) {
-        HPhi::cast(operand)->set_is_live(true);
-        worklist.Add(HPhi::cast(operand), zone());
-      }
-    }
-  }
-
-  // Remove unreachable phis.
-  for (int i = 0; i < phi_list.length(); i++) {
-    HPhi* phi = phi_list[i];
-    if (!phi->is_live()) {
-      HBasicBlock* block = phi->block();
-      block->RemovePhi(phi);
-      block->RecordDeletedPhi(phi->merged_index());
-    }
-  }
-}
-
-
 bool HGraph::CheckArgumentsPhiUses() {
   int block_count = blocks_.length();
   for (int i = 0; i < block_count; ++i) {
     for (int j = 0; j < blocks_[i]->phis()->length(); ++j) {
       HPhi* phi = blocks_[i]->phis()->at(j);
       // We don't support phi uses of arguments for now.
       if (phi->CheckFlag(HValue::kIsArguments)) return false;
     }
   }
   return true;
@@ skipping 2240 matching lines @@
     *bailout_reason = SmartArrayPointer<char>(StrDup(
         "Unsupported phi use of const variable"));
     return false;
   }
   EliminateRedundantPhis();
   if (!CheckArgumentsPhiUses()) {
     *bailout_reason = SmartArrayPointer<char>(StrDup(
         "Unsupported phi use of arguments"));
     return false;
   }
-  if (FLAG_eliminate_dead_phis) EliminateUnreachablePhis();
+
+  // Remove dead code and phis
+  if (FLAG_dead_code_elimination) DeadCodeElimination();

[Sven Panne, 2013/05/07 13:32:10]

I am not sure if this is what we want: Almost all our bots run without DCE,
because our tests consist of a lot of dead code. If we don't do this phase here,
we fundamentally change things. Perhaps keep the old flag for this DCE phase?
I'm a bit torn, adding Jakob for a 2nd opinion...

[Jakob Kummerow, 2013/05/08 12:07:24]

As discussed offline, it's probably OK to leave this as it is. We'll have more
dead phis when running tests, but that shouldn't affect coverage negatively.

[titzer, 2013/05/13 13:29:38]

Leaving as one flag.

   CollectPhis();
 
   if (has_osr_loop_entry()) {
     const ZoneList<HPhi*>* phis = osr_loop_entry()->phis();
     for (int j = 0; j < phis->length(); j++) {
       HPhi* phi = phis->at(j);
       osr_values()->at(phi->merged_index())->set_incoming_value(phi);
     }
   }
 
@@ skipping 504 matching lines @@
         array_instruction = static_cast<ArrayInstructionInterface*>(op);
       } else {
         continue;
       }
       DehoistArrayIndex(array_instruction);
     }
   }
 }
 
 
+void HGraph::MarkNotDead(HValue *ref, HValue* instr,
+    ZoneList<HValue*>* worklist) {
+  if (!instr->CheckFlag(HValue::kIsNotDead)) {
+    instr->SetFlag(HValue::kIsNotDead);
+    worklist->Add(instr, zone());
+
+    if (FLAG_trace_dead_code_elimination) {
+      ALLOW_HANDLE_DEREF(isolate(), "trace mode for deadcode");

[Sven Panne, 2013/05/07 13:32:10]

Why exactly do we need this and why is this safe?

[titzer, 2013/05/13 13:29:38]

I was debugging and printing the entire instruction, but I guess it is not
necessary to print only the name. Removed.

+      HeapStringAllocator allocator;
+      StringStream stream(&allocator);
+      if (ref != NULL) ref->PrintNameTo(&stream);
+      stream.Add(" -> ");
+      instr->PrintNameTo(&stream);
+      PrintF("[MarkNotDead %s]\n", *stream.ToCString());
+    }
+  }
+}
+
+
+bool HGraph::TryDeadCodeElimination(HValue* instr) {
+  if (!instr->CheckFlag(HValue::kIsNotDead)) {
+    // instruction has not been marked live. assume it is dead and remove.
+    // TODO(titzer): we don't remove constants because some special constants
+    // might be used by later phases and are assumed to be in the graph
+    if (!instr->IsConstant()) instr->DeleteAndReplaceWith(NULL);
+    return true;
+  } else {
+    // clear the liveness flag to leave the graph clean for the next DCE
+    instr->ClearFlag(HValue::kIsNotDead);
+    return false;
+  }
+}
+
+
 void HGraph::DeadCodeElimination() {
   HPhase phase("H_Dead code elimination", this);
-  ZoneList<HInstruction*> worklist(blocks_.length(), zone());
+  ZoneList<HValue*> worklist(blocks_.length(), zone());
+  ZoneList<HPhi*> philist(blocks_.length(), zone());

[Jakob Kummerow, 2013/05/08 12:07:24]

Why do we need this phi list at all? Can't we simply iterate through all blocks
and each block's phi list when trying to eliminate dead phis? (I.e. have a loop
similar to the one in lines 5431-5435 inserted before 5454, instead of the loop
in 5457-5463). 
Remember, zone memory can't be freed unless the entire zone is nuked. Zone
allocation is fast, but the memory used by the objects stays around when the C++
variables go out of scope.

[titzer, 2013/05/13 13:29:38]

Because if the code iterates over the phi list as it deletes phis, the list
changes and it misses some.

+
+  // mark initial root instructions for dead code elimination
   for (int i = 0; i < blocks()->length(); ++i) {
-    for (HInstruction* instr = blocks()->at(i)->first();
+    HBasicBlock* block = blocks()->at(i);
+    for (HInstruction* instr = block->first();
          instr != NULL;
          instr = instr->next()) {
-      if (instr->IsDead()) worklist.Add(instr, zone());
+      if (instr->IsNotDeletable()) MarkNotDead(NULL, instr, &worklist);
+    }
+    // TODO(titzer): we can't eliminate the receiver for generating backtraces
+    for (int j = 0; j < block->phis()->length(); j++) {
+      HPhi* phi = block->phis()->at(j);
+      if (phi->IsReceiver()) MarkNotDead(NULL, phi, &worklist);
+      philist.Add(phi, zone());
     }
   }
 
+  // transitively mark all inputs of live instructions live
   while (!worklist.is_empty()) {
-    HInstruction* instr = worklist.RemoveLast();
-    // This happens when an instruction is used multiple times as operand. That
-    // in turn could happen through GVN.
-    if (!instr->IsLinked()) continue;
-    if (FLAG_trace_dead_code_elimination) {
-      HeapStringAllocator allocator;
-      StringStream stream(&allocator);
-      instr->PrintNameTo(&stream);
-      stream.Add(" = ");
-      instr->PrintTo(&stream);
-      PrintF("[removing dead instruction %s]\n", *stream.ToCString());
+    HValue* instr = worklist.RemoveLast();
+    for (int i = 0; i < instr->OperandCount(); ++i) {
+      MarkNotDead(instr, instr->OperandAt(i), &worklist);
     }
-    instr->DeleteAndReplaceWith(NULL);
-    for (int i = 0; i < instr->OperandCount(); ++i) {
-      HValue* operand = instr->OperandAt(i);
-      if (operand->IsDead()) worklist.Add(HInstruction::cast(operand), zone());
+  }
+
+  // remove any instruction not marked in the previous phase
+  for (int i = 0; i < blocks()->length(); ++i) {
+    HBasicBlock* block = blocks()->at(i);
+    for (HInstruction* instr = block->first();
+         instr != NULL;
+         instr = instr->next()) {
+      TryDeadCodeElimination(instr);
+    }
+  }
+
+  // process phis separately because dead ones need to be recorded
+  while (!philist.is_empty()) {
+    HPhi* phi = philist.RemoveLast();
+    HBasicBlock* block = phi->block();
+    if (TryDeadCodeElimination(phi)) {
+      block->RecordDeletedPhi(phi->merged_index());
     }
   }
 }
 
 
 void HGraph::RestoreActualValues() {
   HPhase phase("H_Restore actual values", this);
 
   for (int block_index = 0; block_index < blocks()->length(); block_index++) {
     HBasicBlock* block = blocks()->at(block_index);
@@ skipping 6809 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal