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

src/compiler/instruction-selector.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/instruction-selector.h"
 
 #include <limits>
 
 #include "src/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
@@ skipping 68 matching lines @@
       AddInstruction(instructions_[start]);
     }
     EndBlock(RpoNumber::FromInt(block->rpo_number()));
   }
 }
 
 
 void InstructionSelector::StartBlock(RpoNumber rpo) {
   if (FLAG_turbo_instruction_scheduling &&
       InstructionScheduler::SchedulerSupported()) {
-    DCHECK(scheduler_ != nullptr);
+    DCHECK_NOT_NULL(scheduler_);
     scheduler_->StartBlock(rpo);
   } else {
     sequence()->StartBlock(rpo);
   }
 }
 
 
 void InstructionSelector::EndBlock(RpoNumber rpo) {
   if (FLAG_turbo_instruction_scheduling &&
       InstructionScheduler::SchedulerSupported()) {
-    DCHECK(scheduler_ != nullptr);
+    DCHECK_NOT_NULL(scheduler_);
     scheduler_->EndBlock(rpo);
   } else {
     sequence()->EndBlock(rpo);
   }
 }
 
 
 void InstructionSelector::AddInstruction(Instruction* instr) {
   if (FLAG_turbo_instruction_scheduling &&
       InstructionScheduler::SchedulerSupported()) {
-    DCHECK(scheduler_ != nullptr);
+    DCHECK_NOT_NULL(scheduler_);
     scheduler_->AddInstruction(instr);
   } else {
     sequence()->AddInstruction(instr);
   }
 }
 
 
 Instruction* InstructionSelector::Emit(InstructionCode opcode,
                                        InstructionOperand output,
                                        size_t temp_count,
                                        InstructionOperand* temps) {
   size_t output_count = output.IsInvalid() ? 0 : 1;
-  return Emit(opcode, output_count, &output, 0, NULL, temp_count, temps);
+  return Emit(opcode, output_count, &output, 0, nullptr, temp_count, temps);
 }
 
 
 Instruction* InstructionSelector::Emit(InstructionCode opcode,
                                        InstructionOperand output,
                                        InstructionOperand a, size_t temp_count,
                                        InstructionOperand* temps) {
   size_t output_count = output.IsInvalid() ? 0 : 1;
   return Emit(opcode, output_count, &output, 1, &a, temp_count, temps);
 }
@@ skipping 340 matching lines @@
   NodeVector output_nodes;
   InstructionOperandVector outputs;
   InstructionOperandVector instruction_args;
   ZoneVector<PushParameter> pushed_nodes;
 
   size_t input_count() const { return descriptor->InputCount(); }
 
   size_t frame_state_count() const { return descriptor->FrameStateCount(); }
 
   size_t frame_state_value_count() const {
-    return (frame_state_descriptor == NULL)
+    return (frame_state_descriptor == nullptr)
                ? 0
                : (frame_state_descriptor->GetTotalSize() +
                   1);  // Include deopt id.
   }
 };
 
 
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
 void InstructionSelector::InitializeCallBuffer(Node* call, CallBuffer* buffer,
@@ skipping 16 matching lines @@
         if (use->opcode() != IrOpcode::kProjection) continue;
         size_t const index = ProjectionIndexOf(use->op());
         DCHECK_LT(index, buffer->output_nodes.size());
         DCHECK(!buffer->output_nodes[index]);
         buffer->output_nodes[index] = use;
       }
     }
 
     // Filter out the outputs that aren't live because no projection uses them.
     size_t outputs_needed_by_framestate =
-        buffer->frame_state_descriptor == NULL
+        buffer->frame_state_descriptor == nullptr
             ? 0
             : buffer->frame_state_descriptor->state_combine()
                   .ConsumedOutputCount();
     for (size_t i = 0; i < buffer->output_nodes.size(); i++) {
-      bool output_is_live =
-          buffer->output_nodes[i] != NULL || i < outputs_needed_by_framestate;
+      bool output_is_live = buffer->output_nodes[i] != nullptr ||
+                            i < outputs_needed_by_framestate;
       if (output_is_live) {
         MachineType type =
             buffer->descriptor->GetReturnType(static_cast<int>(i));
         LinkageLocation location =
             buffer->descriptor->GetReturnLocation(static_cast<int>(i));
 
         Node* output = buffer->output_nodes[i];
         InstructionOperand op =
-            output == NULL
+            output == nullptr
                 ? g.TempLocation(location, type.representation())
                 : g.DefineAsLocation(output, location, type.representation());
         MarkAsRepresentation(type.representation(), op);
 
         buffer->outputs.push_back(op);
       }
     }
   }
 
   // The first argument is always the callee code.
@@ skipping 25 matching lines @@
       break;
   }
   DCHECK_EQ(1u, buffer->instruction_args.size());
 
   // If the call needs a frame state, we insert the state information as
   // follows (n is the number of value inputs to the frame state):
   // arg 1               : deoptimization id.
   // arg 2 - arg (n + 1) : value inputs to the frame state.
   size_t frame_state_entries = 0;
   USE(frame_state_entries);  // frame_state_entries is only used for debug.
-  if (buffer->frame_state_descriptor != NULL) {
+  if (buffer->frame_state_descriptor != nullptr) {
     InstructionSequence::StateId state_id =
         sequence()->AddFrameStateDescriptor(buffer->frame_state_descriptor);
     buffer->instruction_args.push_back(g.TempImmediate(state_id.ToInt()));
 
     Node* frame_state =
         call->InputAt(static_cast<int>(buffer->descriptor->InputCount()));
 
     StateObjectDeduplicator deduplicator(instruction_zone());
 
     frame_state_entries =
@@ skipping 87 matching lines @@
                                     source_position);
     }
   }
 
   // We're done with the block.
   InstructionBlock* instruction_block =
       sequence()->InstructionBlockAt(RpoNumber::FromInt(block->rpo_number()));
   instruction_block->set_code_start(static_cast<int>(instructions_.size()));
   instruction_block->set_code_end(current_block_end);
 
-  current_block_ = NULL;
+  current_block_ = nullptr;
 }
 
 
 void InstructionSelector::VisitControl(BasicBlock* block) {
 #ifdef DEBUG
   // SSA deconstruction requires targets of branches not to have phis.
   // Edge split form guarantees this property, but is more strict.
   if (block->SuccessorCount() > 1) {
     for (BasicBlock* const successor : block->successors()) {
       for (Node* const node : *successor) {
@@ skipping 896 matching lines @@
   int parameters = static_cast<int>(
       StateValuesAccess(state->InputAt(kFrameStateParametersInput)).size());
   int locals = static_cast<int>(
       StateValuesAccess(state->InputAt(kFrameStateLocalsInput)).size());
   int stack = static_cast<int>(
       StateValuesAccess(state->InputAt(kFrameStateStackInput)).size());
 
   DCHECK_EQ(parameters, state_info.parameter_count());
   DCHECK_EQ(locals, state_info.local_count());
 
-  FrameStateDescriptor* outer_state = NULL;
+  FrameStateDescriptor* outer_state = nullptr;
   Node* outer_node = state->InputAt(kFrameStateOuterStateInput);
   if (outer_node->opcode() == IrOpcode::kFrameState) {
     outer_state = GetFrameStateDescriptor(outer_node);
   }
 
   return new (instruction_zone()) FrameStateDescriptor(
       instruction_zone(), state_info.type(), state_info.bailout_id(),
       state_info.state_combine(), parameters, locals, stack,
       state_info.shared_info(), outer_state);
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8