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

src/compiler/graph-visualizer.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/graph-visualizer.h"
 
 #include <sstream>
 #include <string>
 
 #include "src/code-stubs.h"
@@ skipping 23 matching lines @@
     SNPrintF(filename, "turbo-%s", debug_name.get());
   } else if (info->has_shared_info()) {
     SNPrintF(filename, "turbo-%p", static_cast<void*>(info));
   } else {
     SNPrintF(filename, "turbo-none-%s", phase);
   }
   std::replace(filename.start(), filename.start() + filename.length(), ' ',
                '_');
 
   EmbeddedVector<char, 256> full_filename;
-  if (phase == NULL) {
+  if (phase == nullptr) {
     SNPrintF(full_filename, "%s.%s", filename.start(), suffix);
   } else {
     SNPrintF(full_filename, "%s-%s.%s", filename.start(), phase, suffix);
   }
   return base::OS::FOpen(full_filename.start(), mode);
 }
 
 
-static int SafeId(Node* node) { return node == NULL ? -1 : node->id(); }
+static int SafeId(Node* node) { return node == nullptr ? -1 : node->id(); }
 static const char* SafeMnemonic(Node* node) {
-  return node == NULL ? "null" : node->op()->mnemonic();
+  return node == nullptr ? "null" : node->op()->mnemonic();
 }
 
 #define DEAD_COLOR "#999999"
 
 class Escaped {
  public:
   explicit Escaped(const std::ostringstream& os,
                    const char* escaped_chars = "<>|{}")
       : str_(os.str()), escaped_chars_(escaped_chars) {}
 
@@ skipping 85 matching lines @@
       : os_(os), all_(zone, graph), first_edge_(true) {}
 
   void Print() {
     for (Node* const node : all_.live) PrintEdges(node);
     os_ << "\n";
   }
 
   void PrintEdges(Node* node) {
     for (int i = 0; i < node->InputCount(); i++) {
       Node* input = node->InputAt(i);
-      if (input == NULL) continue;
+      if (input == nullptr) continue;
       PrintEdge(node, i, input);
     }
   }
 
   void PrintEdge(Node* from, int index, Node* to) {
     if (first_edge_) {
       first_edge_ = false;
     } else {
       os_ << ",\n";
     }
-    const char* edge_type = NULL;
+    const char* edge_type = nullptr;
     if (index < NodeProperties::FirstValueIndex(from)) {
       edge_type = "unknown";
     } else if (index < NodeProperties::FirstContextIndex(from)) {
       edge_type = "value";
     } else if (index < NodeProperties::FirstFrameStateIndex(from)) {
       edge_type = "context";
     } else if (index < NodeProperties::FirstEffectIndex(from)) {
       edge_type = "frame-state";
     } else if (index < NodeProperties::FirstControlIndex(from)) {
       edge_type = "effect";
@@ skipping 207 matching lines @@
       os_ << " \"B" << successor->rpo_number() << "\"";
     }
     os_ << "\n";
 
     PrintIndent();
     os_ << "xhandlers\n";
 
     PrintIndent();
     os_ << "flags\n";
 
-    if (current->dominator() != NULL) {
+    if (current->dominator() != nullptr) {
       PrintBlockProperty("dominator", current->dominator()->rpo_number());
     }
 
     PrintIntProperty("loop_depth", current->loop_depth());
 
     const InstructionBlock* instruction_block =
         instructions->InstructionBlockAt(
             RpoNumber::FromInt(current->rpo_number()));
     if (instruction_block->code_start() >= 0) {
       int first_index = instruction_block->first_instruction_index();
@@ skipping 37 matching lines @@
         Node* node = *i;
         if (node->opcode() == IrOpcode::kPhi) continue;
         int uses = node->UseCount();
         PrintIndent();
         os_ << "0 " << uses << " ";
         PrintNode(node);
         if (FLAG_trace_turbo_types) {
           os_ << " ";
           PrintType(node);
         }
-        if (positions != NULL) {
+        if (positions != nullptr) {
           SourcePosition position = positions->GetSourcePosition(node);
           if (position.IsKnown()) {
             os_ << " pos:" << position.raw();
           }
         }
         os_ << " <|@\n";
       }
 
       BasicBlock::Control control = current->control();
       if (control != BasicBlock::kNone) {
         PrintIndent();
         os_ << "0 0 ";
-        if (current->control_input() != NULL) {
+        if (current->control_input() != nullptr) {
           PrintNode(current->control_input());
         } else {
           os_ << -1 - current->rpo_number() << " Goto";
         }
         os_ << " ->";
         for (BasicBlock* successor : current->successors()) {
           os_ << " B" << successor->rpo_number();
         }
-        if (FLAG_trace_turbo_types && current->control_input() != NULL) {
+        if (FLAG_trace_turbo_types && current->control_input() != nullptr) {
           os_ << " ";
           PrintType(current->control_input());
         }
         os_ << " <|@\n";
       }
     }
 
-    if (instructions != NULL) {
+    if (instructions != nullptr) {
       Tag LIR_tag(this, "LIR");
       for (int j = instruction_block->first_instruction_index();
            j <= instruction_block->last_instruction_index(); j++) {
         PrintIndent();
         PrintableInstruction printable = {
             RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN),
             instructions->InstructionAt(j)};
         os_ << j << " " << printable << " <|@\n";
       }
     }
@@ skipping 25 matching lines @@
   if (range == nullptr || range->IsEmpty()) return;
   int vreg = range->vreg();
   for (LiveRange* child = range; child != nullptr; child = child->next()) {
     PrintLiveRange(child, type, vreg);
   }
 }
 
 
 void GraphC1Visualizer::PrintLiveRange(LiveRange* range, const char* type,
                                        int vreg) {
-  if (range != NULL && !range->IsEmpty()) {
+  if (range != nullptr && !range->IsEmpty()) {
     PrintIndent();
     os_ << vreg << ":" << range->relative_id() << " " << type;
     if (range->HasRegisterAssigned()) {
       AllocatedOperand op = AllocatedOperand::cast(range->GetAssignedOperand());
       if (op.IsDoubleRegister()) {
         DoubleRegister assigned_reg = op.GetDoubleRegister();
         os_ << " \"" << assigned_reg.ToString() << "\"";
       } else {
         DCHECK(op.IsRegister());
         Register assigned_reg = op.GetRegister();
@@ skipping 19 matching lines @@
     }
 
     os_ << " " << vreg;
     for (auto interval = range->first_interval(); interval != nullptr;
          interval = interval->next()) {
       os_ << " [" << interval->start().value() << ", "
           << interval->end().value() << "[";
     }
 
     UsePosition* current_pos = range->first_pos();
-    while (current_pos != NULL) {
+    while (current_pos != nullptr) {
       if (current_pos->RegisterIsBeneficial() || FLAG_trace_all_uses) {
         os_ << " " << current_pos->pos().value() << " M";
       }
       current_pos = current_pos->next();
     }
 
     os_ << " \"\"\n";
   }
 }
 
@@ skipping 52 matching lines @@
         os << "#" << SafeId(i) << ":" << SafeMnemonic(i);
       }
       os << ")" << std::endl;
     }
   }
   return os;
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8