[turbofan] Build s/NULL/nullptr/g and CHECK(x != nullptr) to CHECK_NOT_NULL(x).

src/compiler/schedule.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/schedule.h"
 
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
 #include "src/ostreams.h"
 
@@ skipping 16 matching lines @@
       nodes_(zone),
       successors_(zone),
       predecessors_(zone),
       id_(id) {}
 
 
 bool BasicBlock::LoopContains(BasicBlock* block) const {
   // RPO numbers must be initialized.
   DCHECK(rpo_number_ >= 0);
   DCHECK(block->rpo_number_ >= 0);
-  if (loop_end_ == NULL) return false;  // This is not a loop.
+  if (loop_end_ == nullptr) return false;  // This is not a loop.
   return block->rpo_number_ >= rpo_number_ &&
          block->rpo_number_ < loop_end_->rpo_number_;
 }
 
 
 void BasicBlock::AddSuccessor(BasicBlock* successor) {
   successors_.push_back(successor);
 }
 
 
@@ skipping 85 matching lines @@
       start_(NewBasicBlock()),
       end_(NewBasicBlock()) {
   nodeid_to_block_.reserve(node_count_hint);
 }
 
 
 BasicBlock* Schedule::block(Node* node) const {
   if (node->id() < static_cast<NodeId>(nodeid_to_block_.size())) {
     return nodeid_to_block_[node->id()];
   }
-  return NULL;
+  return nullptr;
 }
 
 
 bool Schedule::IsScheduled(Node* node) {
   if (node->id() >= nodeid_to_block_.size()) return false;
-  return nodeid_to_block_[node->id()] != NULL;
+  return nodeid_to_block_[node->id()] != nullptr;
 }
 
 
 BasicBlock* Schedule::GetBlockById(BasicBlock::Id block_id) {
   DCHECK(block_id.ToSize() < all_blocks_.size());
   return all_blocks_[block_id.ToSize()];
 }
 
 
 bool Schedule::SameBasicBlock(Node* a, Node* b) const {
   BasicBlock* block = this->block(a);
-  return block != NULL && block == this->block(b);
+  return block != nullptr && block == this->block(b);
 }
 
 
 BasicBlock* Schedule::NewBasicBlock() {
   BasicBlock* block = new (zone_)
       BasicBlock(zone_, BasicBlock::Id::FromSize(all_blocks_.size()));
   all_blocks_.push_back(block);
   return block;
 }
 
 
 void Schedule::PlanNode(BasicBlock* block, Node* node) {
   if (FLAG_trace_turbo_scheduler) {
     OFStream os(stdout);
     os << "Planning #" << node->id() << ":" << node->op()->mnemonic()
        << " for future add to B" << block->id() << "\n";
   }
-  DCHECK(this->block(node) == NULL);
+  DCHECK(this->block(node) == nullptr);
   SetBlockForNode(block, node);
 }
 
 
 void Schedule::AddNode(BasicBlock* block, Node* node) {
   if (FLAG_trace_turbo_scheduler) {
     OFStream os(stdout);
     os << "Adding #" << node->id() << ":" << node->op()->mnemonic() << " to B"
        << block->id() << "\n";
   }
-  DCHECK(this->block(node) == NULL || this->block(node) == block);
+  DCHECK(this->block(node) == nullptr || this->block(node) == block);
   block->AddNode(node);
   SetBlockForNode(block, node);
 }
 
 
 void Schedule::AddGoto(BasicBlock* block, BasicBlock* succ) {
   DCHECK_EQ(BasicBlock::kNone, block->control());
   block->set_control(BasicBlock::kGoto);
   AddSuccessor(block, succ);
 }
@@ skipping 146 matching lines @@
       if (NodeProperties::IsTyped(node)) {
         Type* type = NodeProperties::GetType(node);
         os << " : ";
         type->PrintTo(os);
       }
       os << "\n";
     }
     BasicBlock::Control control = block->control();
     if (control != BasicBlock::kNone) {
       os << "  ";
-      if (block->control_input() != NULL) {
+      if (block->control_input() != nullptr) {
         os << *block->control_input();
       } else {
         os << "Goto";
       }
       os << " -> ";
       comma = false;
       for (BasicBlock const* successor : block->successors()) {
         if (comma) os << ", ";
         comma = true;
         os << "B" << successor->rpo_number();
       }
       os << "\n";
     }
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8