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

src/compiler/control-equivalence.h

 // 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.
 
 #ifndef V8_COMPILER_CONTROL_EQUIVALENCE_H_
 #define V8_COMPILER_CONTROL_EQUIVALENCE_H_
 
 #include "src/compiler/graph.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+#define TRACE(...)                                       \
+  do {                                                   \
+    if (FLAG_trace_turbo_scheduler) PrintF(__VA_ARGS__); \
+  } while (false)
+
 // Determines control dependence equivalence classes for control nodes. Any two
 // nodes having the same set of control dependences land in one class. These
 // classes can in turn be used to:
 //  - Build a program structure tree (PST) for controls in the graph.
 //  - Determine single-entry single-exit (SESE) regions within the graph.
 //
 // Note that this implementation actually uses cycle equivalence to establish
 // class numbers. Any two nodes are cycle equivalent if they occur in the same
 // set of cycles. It can be shown that control dependence equivalence reduces
 // to undirected cycle equivalence for strongly connected control flow graphs.
@@ skipping 62 matching lines @@
     bool on_stack;        // Indicates node is on DFS stack during walk.
     bool participates;    // Indicates node participates in DFS walk.
     BracketList blist;    // List of brackets per node.
   };
 
   // The per-node data computed during the DFS walk.
   typedef ZoneVector<NodeData> Data;
 
   // Called at pre-visit during DFS walk.
   void VisitPre(Node* node) {
-    Trace("CEQ: Pre-visit of #%d:%s\n", node->id(), node->op()->mnemonic());
+    TRACE("CEQ: Pre-visit of #%d:%s\n", node->id(), node->op()->mnemonic());
 
     // Dispense a new pre-order number.
     SetNumber(node, NewDFSNumber());
-    Trace("  Assigned DFS number is %d\n", GetNumber(node));
+    TRACE("  Assigned DFS number is %zu\n", GetNumber(node));
   }
 
   // Called at mid-visit during DFS walk.
   void VisitMid(Node* node, DFSDirection direction) {
-    Trace("CEQ: Mid-visit of #%d:%s\n", node->id(), node->op()->mnemonic());
+    TRACE("CEQ: Mid-visit of #%d:%s\n", node->id(), node->op()->mnemonic());
     BracketList& blist = GetBracketList(node);
 
     // Remove brackets pointing to this node [line:19].
     BracketListDelete(blist, node, direction);
 
     // Potentially introduce artificial dependency from start to end.
     if (blist.empty()) {
       DCHECK_EQ(kInputDirection, direction);
       VisitBackedge(node, graph_->end(), kInputDirection);
     }
 
     // Potentially start a new equivalence class [line:37].
-    BracketListTrace(blist);
+    BracketListTRACE(blist);
     Bracket* recent = &blist.back();
     if (recent->recent_size != blist.size()) {
       recent->recent_size = blist.size();
       recent->recent_class = NewClassNumber();
     }
 
     // Assign equivalence class to node.
     SetClass(node, recent->recent_class);
-    Trace("  Assigned class number is %d\n", GetClass(node));
+    TRACE("  Assigned class number is %zu\n", GetClass(node));
   }
 
   // Called at post-visit during DFS walk.
   void VisitPost(Node* node, Node* parent_node, DFSDirection direction) {
-    Trace("CEQ: Post-visit of #%d:%s\n", node->id(), node->op()->mnemonic());
+    TRACE("CEQ: Post-visit of #%d:%s\n", node->id(), node->op()->mnemonic());
     BracketList& blist = GetBracketList(node);
 
     // Remove brackets pointing to this node [line:19].
     BracketListDelete(blist, node, direction);
 
     // Propagate bracket list up the DFS tree [line:13].
     if (parent_node != NULL) {
       BracketList& parent_blist = GetBracketList(parent_node);
       parent_blist.splice(parent_blist.end(), blist);
     }
   }
 
   // Called when hitting a back edge in the DFS walk.
   void VisitBackedge(Node* from, Node* to, DFSDirection direction) {
-    Trace("CEQ: Backedge from #%d:%s to #%d:%s\n", from->id(),
+    TRACE("CEQ: Backedge from #%d:%s to #%d:%s\n", from->id(),
           from->op()->mnemonic(), to->id(), to->op()->mnemonic());
 
     // Push backedge onto the bracket list [line:25].
     Bracket bracket = {direction, kInvalidClass, 0, from, to};
     GetBracketList(from).push_back(bracket);
   }
 
   // Performs and undirected DFS walk of the graph. Conceptually all nodes are
   // expanded, splitting "input" and "use" out into separate nodes. During the
   // traversal, edges towards the representative nodes are preferred.
@@ skipping 148 matching lines @@
     DCHECK_EQ(stack.top().node, node);
     GetData(node)->on_stack = false;
     GetData(node)->visited = true;
     stack.pop();
   }
 
   // TODO(mstarzinger): Optimize this to avoid linear search.
   void BracketListDelete(BracketList& blist, Node* to, DFSDirection direction) {
     for (BracketList::iterator i = blist.begin(); i != blist.end(); /*nop*/) {
       if (i->to == to && i->direction != direction) {
-        Trace("  BList erased: {%d->%d}\n", i->from->id(), i->to->id());
+        TRACE("  BList erased: {%d->%d}\n", i->from->id(), i->to->id());
         i = blist.erase(i);
       } else {
         ++i;
       }
     }
   }
 
-  void BracketListTrace(BracketList& blist) {
+  void BracketListTRACE(BracketList& blist) {
     if (FLAG_trace_turbo_scheduler) {
-      Trace("  BList: ");
+      TRACE("  BList: ");
       for (Bracket bracket : blist) {
-        Trace("{%d->%d} ", bracket.from->id(), bracket.to->id());
+        TRACE("{%d->%d} ", bracket.from->id(), bracket.to->id());
       }
-      Trace("\n");
+      TRACE("\n");
     }
   }
 
-  void Trace(const char* msg, ...) {
-    if (FLAG_trace_turbo_scheduler) {
-      va_list arguments;
-      va_start(arguments, msg);
-      base::OS::VPrint(msg, arguments);
-      va_end(arguments);
-    }
-  }
-
   Zone* zone_;
   Graph* graph_;
   int dfs_number_;    // Generates new DFS pre-order numbers on demand.
   int class_number_;  // Generates new equivalence class numbers on demand.
   Data node_data_;    // Per-node data stored as a side-table.
 };
 
+#undef TRACE
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_CONTROL_EQUIVALENCE_H_