[turbofan] Clean up TRACE macros and use variadic macros.

src/compiler/control-reducer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/control-reducer.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-marker.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/zone-containers.h"
 
+#define TRACE(...)                                       \

[Michael Starzinger, 2015/03/17 17:08:07]

nit: Can we move it into the namespaces for consistency with other code?

[titzer, 2015/03/17 17:32:42]

Done.

+  do {                                                   \
+    if (FLAG_trace_turbo_reduction) PrintF(__VA_ARGS__); \
+  } while (false)
+
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 enum VisitState { kUnvisited = 0, kOnStack = 1, kRevisit = 2, kVisited = 3 };
 enum Decision { kFalse, kUnknown, kTrue };
 
 class ReachabilityMarker : public NodeMarker<uint8_t> {
  public:
   explicit ReachabilityMarker(Graph* graph) : NodeMarker<uint8_t>(graph, 8) {}
@@ skipping 11 matching lines @@
   bool IsReachableFromStart(Node* node) { return Get(node) & kFromStart; }
   void Push(Node* node) { Set(node, Get(node) | kFwStack); }
   void Pop(Node* node) { Set(node, Get(node) & ~kFwStack); }
   bool IsOnStack(Node* node) { return Get(node) & kFwStack; }
 
  private:
   enum Bit { kFromEnd = 1, kFromStart = 2, kFwStack = 4 };
 };
 
 
-#define TRACE(x) \
-  if (FLAG_trace_turbo_reduction) PrintF x
-
 class ControlReducerImpl {
  public:
   ControlReducerImpl(Zone* zone, JSGraph* jsgraph,
                      CommonOperatorBuilder* common)
       : zone_(zone),
         jsgraph_(jsgraph),
         common_(common),
         state_(jsgraph->graph()->NodeCount(), kUnvisited, zone_),
         stack_(zone_),
         revisit_(zone_) {}
@@ skipping 47 matching lines @@
     marked.SetReachableFromStart(start);
 
     // We use a stack of (Node, Node::Uses::const_iterator) pairs to avoid
     // O(n^2) traversal.
     typedef std::pair<Node*, Node::Uses::const_iterator> FwIter;
     ZoneVector<FwIter> fw_stack(zone_);
     fw_stack.push_back(FwIter(start, start->uses().begin()));
 
     while (!fw_stack.empty()) {
       Node* node = fw_stack.back().first;
-      TRACE(("ControlFw: #%d:%s\n", node->id(), node->op()->mnemonic()));
+      TRACE("ControlFw: #%d:%s\n", node->id(), node->op()->mnemonic());
       bool pop = true;
       while (fw_stack.back().second != node->uses().end()) {
         Node* succ = *(fw_stack.back().second);
         if (marked.IsOnStack(succ) && !marked.IsReachableFromEnd(succ)) {
           // {succ} is on stack and not reachable from end.
           Node* added = ConnectNTL(succ);
           nodes.push_back(added);
           marked.SetReachableFromEnd(added);
           AddBackwardsReachableNodes(marked, nodes, nodes.size() - 1);
 
@@ skipping 32 matching lines @@
       if (node->op()->ControlOutputCount() > 0 &&
           !marked.IsReachableFromStart(node)) {
         ReplaceNode(node, dead());  // uses will be added to revisit queue.
       }
     }
     return TryRevisit();  // try to push a node onto the stack.
   }
 
   // Connect {loop}, the header of a non-terminating loop, to the end node.
   Node* ConnectNTL(Node* loop) {
-    TRACE(("ConnectNTL: #%d:%s\n", loop->id(), loop->op()->mnemonic()));
+    TRACE("ConnectNTL: #%d:%s\n", loop->id(), loop->op()->mnemonic());
 
     Node* always = graph()->NewNode(common_->Always());
     // Mark the node as visited so that we can revisit later.
     MarkAsVisited(always);
 
     Node* branch = graph()->NewNode(common_->Branch(), always, loop);
     // Mark the node as visited so that we can revisit later.
     MarkAsVisited(branch);
 
     Node* if_true = graph()->NewNode(common_->IfTrue(), branch);
@@ skipping 94 matching lines @@
     TrimNodes(marked, nodes);
   }
 
   void TrimNodes(ReachabilityMarker& marked, NodeVector& nodes) {
     // Remove dead->live edges.
     for (size_t j = 0; j < nodes.size(); j++) {
       Node* node = nodes[j];
       for (Edge edge : node->use_edges()) {
         Node* use = edge.from();
         if (!marked.IsReachableFromEnd(use)) {
-          TRACE(("DeadLink: #%d:%s(%d) -> #%d:%s\n", use->id(),
-                 use->op()->mnemonic(), edge.index(), node->id(),
-                 node->op()->mnemonic()));
+          TRACE("DeadLink: #%d:%s(%d) -> #%d:%s\n", use->id(),
+                use->op()->mnemonic(), edge.index(), node->id(),
+                node->op()->mnemonic());
           edge.UpdateTo(NULL);
         }
       }
     }
 #if DEBUG
     // Verify that no inputs to live nodes are NULL.
     for (Node* node : nodes) {
       for (int index = 0; index < node->InputCount(); index++) {
         Node* input = node->InputAt(index);
         if (input == nullptr) {
@@ skipping 19 matching lines @@
   // Reduce the node on the top of the stack.
   // If an input {i} is not yet visited or needs to be revisited, push {i} onto
   // the stack and return. Otherwise, all inputs are visited, so apply
   // reductions for {node} and pop it off the stack.
   void ReduceTop() {
     size_t height = stack_.size();
     Node* node = stack_.back();
 
     if (node->IsDead()) return Pop();  // Node was killed while on stack.
 
-    TRACE(("ControlReduce: #%d:%s\n", node->id(), node->op()->mnemonic()));
+    TRACE("ControlReduce: #%d:%s\n", node->id(), node->op()->mnemonic());
 
     // Recurse on an input if necessary.
     for (Node* const input : node->inputs()) {
       DCHECK(input);
       if (Recurse(input)) return;
     }
 
     // All inputs should be visited or on stack. Apply reductions to node.
     Node* replacement = ReduceNode(node);
     if (replacement != node) ReplaceNode(node, replacement);
@@ skipping 31 matching lines @@
     DCHECK_GE(pos, 0);
     DCHECK_EQ(kOnStack, state_[stack_[pos]->id()]);
     state_[stack_[pos]->id()] = kVisited;
     stack_.pop_back();
   }
 
   // Queue a node to be revisited if it has been visited once already.
   void Revisit(Node* node) {
     size_t id = static_cast<size_t>(node->id());
     if (id < state_.size() && state_[id] == kVisited) {
-      TRACE(("  Revisit #%d:%s\n", node->id(), node->op()->mnemonic()));
+      TRACE("  Revisit #%d:%s\n", node->id(), node->op()->mnemonic());
       state_[id] = kRevisit;
       revisit_.push_back(node);
     }
   }
 
   // Mark {node} as visited.
   void MarkAsVisited(Node* node) {
     size_t id = static_cast<size_t>(node->id());
     EnsureStateSize(id);
     state_[id] = kVisited;
   }
 
   Node* dead() { return jsgraph_->DeadControl(); }
 
   //===========================================================================
   // Reducer implementation: perform reductions on a node.
   //===========================================================================
   Node* ReduceNode(Node* node) {
     if (node->op()->ControlInputCount() == 1 ||
         node->opcode() == IrOpcode::kLoop) {
       // If a node has only one control input and it is dead, replace with dead.
       Node* control = NodeProperties::GetControlInput(node);
       if (control->opcode() == IrOpcode::kDead) {
-        TRACE(("ControlDead: #%d:%s\n", node->id(), node->op()->mnemonic()));
+        TRACE("ControlDead: #%d:%s\n", node->id(), node->op()->mnemonic());
         return control;
       }
     }
 
     // Reduce branches, phis, and merges.
     switch (node->opcode()) {
       case IrOpcode::kBranch:
         return ReduceBranch(node);
       case IrOpcode::kIfTrue:
         return ReduceIfTrue(node);
@@ skipping 88 matching lines @@
     int index = 0;
     int live_index = 0;
     for (Node* const input : node->inputs()) {
       if (input->opcode() != IrOpcode::kDead) {
         live++;
         live_index = index;
       }
       index++;
     }
 
-    TRACE(("ReduceMerge: #%d:%s (%d live)\n", node->id(),
-           node->op()->mnemonic(), live));
+    TRACE("ReduceMerge: #%d:%s (%d live)\n", node->id(), node->op()->mnemonic(),
+          live);
 
     if (live == 0) return dead();  // no remaining inputs.
 
     // Gather phis and effect phis to be edited.
     ZoneVector<Node*> phis(zone_);
     for (Node* const use : node->uses()) {
       if (NodeProperties::IsPhi(use)) phis.push_back(use);
     }
 
     if (live == 1) {
       // All phis are redundant. Replace them with their live input.
       for (Node* const phi : phis) ReplaceNode(phi, phi->InputAt(live_index));
       // The merge itself is redundant.
       return node->InputAt(live_index);
     }
 
     DCHECK_LE(2, live);
 
     if (live < node->InputCount()) {
       // Edit phis in place, removing dead inputs and revisiting them.
       for (Node* const phi : phis) {
-        TRACE(("  PhiInMerge: #%d:%s (%d live)\n", phi->id(),
-               phi->op()->mnemonic(), live));
+        TRACE("  PhiInMerge: #%d:%s (%d live)\n", phi->id(),
+              phi->op()->mnemonic(), live);
         RemoveDeadInputs(node, phi);
         Revisit(phi);
       }
       // Edit the merge in place, removing dead inputs.
       RemoveDeadInputs(node, node);
     }
 
     DCHECK_EQ(live, node->InputCount());
 
     // Check if it's an unused diamond.
     if (live == 2 && phis.empty()) {
       Node* node0 = node->InputAt(0);
       Node* node1 = node->InputAt(1);
       if (((node0->opcode() == IrOpcode::kIfTrue &&
             node1->opcode() == IrOpcode::kIfFalse) ||
            (node1->opcode() == IrOpcode::kIfTrue &&
             node0->opcode() == IrOpcode::kIfFalse)) &&
           node0->OwnedBy(node) && node1->OwnedBy(node)) {
         Node* branch0 = NodeProperties::GetControlInput(node0);
         Node* branch1 = NodeProperties::GetControlInput(node1);
         if (branch0 == branch1) {
           // It's a dead diamond, i.e. neither the IfTrue nor the IfFalse nodes
           // have users except for the Merge and the Merge has no Phi or
           // EffectPhi uses, so replace the Merge with the control input of the
           // diamond.
-          TRACE(("  DeadDiamond: #%d:%s #%d:%s #%d:%s\n", node0->id(),
-                 node0->op()->mnemonic(), node1->id(), node1->op()->mnemonic(),
-                 branch0->id(), branch0->op()->mnemonic()));
+          TRACE("  DeadDiamond: #%d:%s #%d:%s #%d:%s\n", node0->id(),
+                node0->op()->mnemonic(), node1->id(), node1->op()->mnemonic(),
+                branch0->id(), branch0->op()->mnemonic());
           return NodeProperties::GetControlInput(branch0);
         }
       }
     }
 
     return node;
   }
 
   // Reduce branches if they have constant inputs.
   Node* ReduceIfTrue(Node* node) {
     Node* branch = node->InputAt(0);
     DCHECK_EQ(IrOpcode::kBranch, branch->opcode());
     Decision result = DecideCondition(branch->InputAt(0));
     if (result == kTrue) {
       // fold a true branch by replacing IfTrue with the branch control.
-      TRACE(("BranchReduce: #%d:%s => #%d:%s\n", branch->id(),
-             branch->op()->mnemonic(), node->id(), node->op()->mnemonic()));
+      TRACE("BranchReduce: #%d:%s => #%d:%s\n", branch->id(),
+            branch->op()->mnemonic(), node->id(), node->op()->mnemonic());
       return branch->InputAt(1);
     }
     return result == kUnknown ? node : dead();
   }
 
   // Reduce branches if they have constant inputs.
   Node* ReduceIfFalse(Node* node) {
     Node* branch = node->InputAt(0);
     DCHECK_EQ(IrOpcode::kBranch, branch->opcode());
     Decision result = DecideCondition(branch->InputAt(0));
     if (result == kFalse) {
       // fold a false branch by replacing IfFalse with the branch control.
-      TRACE(("BranchReduce: #%d:%s => #%d:%s\n", branch->id(),
-             branch->op()->mnemonic(), node->id(), node->op()->mnemonic()));
+      TRACE("BranchReduce: #%d:%s => #%d:%s\n", branch->id(),
+            branch->op()->mnemonic(), node->id(), node->op()->mnemonic());
       return branch->InputAt(1);
     }
     return result == kUnknown ? node : dead();
   }
 
   // Remove inputs to {node} corresponding to the dead inputs to {merge}
   // and compact the remaining inputs, updating the operator.
   void RemoveDeadInputs(Node* merge, Node* node) {
     int live = 0;
     for (int i = 0; i < merge->InputCount(); i++) {
@@ skipping 11 matching lines @@
     }
     DCHECK_EQ(total, live + node->InputCount() - merge->InputCount());
     DCHECK_NE(total, node->InputCount());
     node->TrimInputCount(total);
     node->set_op(common_->ResizeMergeOrPhi(node->op(), live));
   }
 
   // Replace uses of {node} with {replacement} and revisit the uses.
   void ReplaceNode(Node* node, Node* replacement) {
     if (node == replacement) return;
-    TRACE(("  Replace: #%d:%s with #%d:%s\n", node->id(),
-           node->op()->mnemonic(), replacement->id(),
-           replacement->op()->mnemonic()));
+    TRACE("  Replace: #%d:%s with #%d:%s\n", node->id(), node->op()->mnemonic(),
+          replacement->id(), replacement->op()->mnemonic());
     for (Node* const use : node->uses()) {
       // Don't revisit this node if it refers to itself.
       if (use != node) Revisit(use);
     }
     node->ReplaceUses(replacement);
     node->Kill();
   }
 
   Graph* graph() { return jsgraph_->graph(); }
 };
@@ skipping 39 matching lines @@
       return impl.ReduceIfTrue(node);
     case IrOpcode::kIfFalse:
       return impl.ReduceIfFalse(node);
     default:
       return node;
   }
 }
 }
 }
 }  // namespace v8::internal::compiler