Revert "Make GCC happy again." and "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.".

src/compiler/scheduler.cc

 // Copyright 2013 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/scheduler.h"
 
 #include "src/bit-vector.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/control-equivalence.h"
 #include "src/compiler/graph.h"
@@ skipping 248 matching lines @@
     component_end_ = schedule_->block(exit);
     scheduler_->equivalence_->Run(exit);
     while (!queue_.empty()) {  // Breadth-first backwards traversal.
       Node* node = queue_.front();
       queue_.pop();
 
       // Use control dependence equivalence to find a canonical single-entry
       // single-exit region that makes up a minimal component to be scheduled.
       if (IsSingleEntrySingleExitRegion(node, exit)) {
         Trace("Found SESE at #%d:%s\n", node->id(), node->op()->mnemonic());
-        DCHECK(!component_entry_);
+        DCHECK_EQ(NULL, component_entry_);
         component_entry_ = node;
         continue;
       }
 
       int max = NodeProperties::PastControlIndex(node);
       for (int i = NodeProperties::FirstControlIndex(node); i < max; i++) {
         Queue(node->InputAt(i));
       }
     }
-    DCHECK(component_entry_);
+    DCHECK_NE(NULL, component_entry_);
 
     for (NodeVector::iterator i = control_.begin(); i != control_.end(); ++i) {
       ConnectBlocks(*i);  // Connect block to its predecessor/successors.
     }
   }
 
  private:
   // TODO(mstarzinger): Only for Scheduler::FuseFloatingControl.
   friend class Scheduler;
 
@@ skipping 73 matching lines @@
   // Collect the branch-related projections from a node, such as IfTrue,
   // IfFalse.
   // TODO(titzer): consider moving this to node.h
   void CollectSuccessorProjections(Node* node, Node** buffer,
                                    IrOpcode::Value true_opcode,
                                    IrOpcode::Value false_opcode) {
     buffer[0] = NULL;
     buffer[1] = NULL;
     for (Node* use : node->uses()) {
       if (use->opcode() == true_opcode) {
-        DCHECK(!buffer[0]);
+        DCHECK_EQ(NULL, buffer[0]);
         buffer[0] = use;
       }
       if (use->opcode() == false_opcode) {
-        DCHECK(!buffer[1]);
+        DCHECK_EQ(NULL, buffer[1]);
         buffer[1] = use;
       }
     }
-    DCHECK(buffer[0]);
-    DCHECK(buffer[1]);
+    DCHECK_NE(NULL, buffer[0]);
+    DCHECK_NE(NULL, buffer[1]);
   }
 
   void CollectSuccessorBlocks(Node* node, BasicBlock** buffer,
                               IrOpcode::Value true_opcode,
                               IrOpcode::Value false_opcode) {
     Node* successors[2];
     CollectSuccessorProjections(node, successors, true_opcode, false_opcode);
     buffer[0] = schedule_->block(successors[0]);
     buffer[1] = schedule_->block(successors[1]);
   }
@@ skipping 48 matching lines @@
   }
 
   void ConnectReturn(Node* ret) {
     Node* return_block_node = NodeProperties::GetControlInput(ret);
     BasicBlock* return_block = schedule_->block(return_block_node);
     TraceConnect(ret, return_block, NULL);
     schedule_->AddReturn(return_block, ret);
   }
 
   void TraceConnect(Node* node, BasicBlock* block, BasicBlock* succ) {
-    DCHECK(block);
+    DCHECK_NE(NULL, block);
     if (succ == NULL) {
       Trace("Connect #%d:%s, B%d -> end\n", node->id(), node->op()->mnemonic(),
             block->id().ToInt());
     } else {
       Trace("Connect #%d:%s, B%d -> B%d\n", node->id(), node->op()->mnemonic(),
             block->id().ToInt(), succ->id().ToInt());
     }
   }
 
   bool IsFinalMerge(Node* node) {
@@ skipping 64 matching lines @@
         beyond_end_(NULL),
         loops_(zone),
         backedges_(zone),
         stack_(zone),
         previous_block_count_(0) {}
 
   // Computes the special reverse-post-order for the main control flow graph,
   // that is for the graph spanned between the schedule's start and end blocks.
   void ComputeSpecialRPO() {
     DCHECK(schedule_->end()->SuccessorCount() == 0);
-    DCHECK(!order_);  // Main order does not exist yet.
+    DCHECK_EQ(NULL, order_);  // Main order does not exist yet.
     ComputeAndInsertSpecialRPO(schedule_->start(), schedule_->end());
   }
 
   // Computes the special reverse-post-order for a partial control flow graph,
   // that is for the graph spanned between the given {entry} and {end} blocks,
   // then updates the existing ordering with this new information.
   void UpdateSpecialRPO(BasicBlock* entry, BasicBlock* end) {
-    DCHECK(order_);  // Main order to be updated is present.
+    DCHECK_NE(NULL, order_);  // Main order to be updated is present.
     ComputeAndInsertSpecialRPO(entry, end);
   }
 
   // Serialize the previously computed order as a special reverse-post-order
   // numbering for basic blocks into the final schedule.
   void SerializeRPOIntoSchedule() {
     int32_t number = 0;
     for (BasicBlock* b = order_; b != NULL; b = b->rpo_next()) {
       b->set_rpo_number(number++);
       schedule_->rpo_order()->push_back(b);
@@ skipping 911 matching lines @@
   for (Node* const node : *nodes) {
     schedule_->SetBlockForNode(to, node);
     scheduled_nodes_[to->id().ToSize()].push_back(node);
   }
   nodes->clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8