[vm] Update NULL to nullptr in runtime/vm/compiler.

TEST=build
Change-Id: I54cd75bbc942e11c4d719edcc64640da67077634
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/291965
Reviewed-by: Alexander Markov <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

runtime/vm/compiler/aot/aot_call_specializer.cc

@@ -105,7 +105,7 @@ bool AotCallSpecializer::TryCreateICDataForUniqueTarget(
       !target_function.AreValidArgumentCounts(
           call->type_args_len(), call->ArgumentCountWithoutTypeArgs(),
           call->argument_names().IsNull() ? 0 : call->argument_names().Length(),
-          /* error_message = */ NULL)) {
+          /* error_message = */ nullptr)) {
     return false;
   }
 
@@ -151,7 +151,8 @@ bool AotCallSpecializer::TryCreateICData(InstanceCallInstr* call) {
 }
 
 bool AotCallSpecializer::RecognizeRuntimeTypeGetter(InstanceCallInstr* call) {
-  if ((precompiler_ == NULL) || !precompiler_->get_runtime_type_is_unique()) {
+  if ((precompiler_ == nullptr) ||
+      !precompiler_->get_runtime_type_is_unique()) {
     return false;
   }
 
@@ -175,8 +176,8 @@ bool AotCallSpecializer::RecognizeRuntimeTypeGetter(InstanceCallInstr* call) {
 
 static bool IsGetRuntimeType(Definition* defn) {
   StaticCallInstr* call = defn->AsStaticCall();
-  return (call != NULL) && (call->function().recognized_kind() ==
-                            MethodRecognizer::kObjectRuntimeType);
+  return (call != nullptr) && (call->function().recognized_kind() ==
+                               MethodRecognizer::kObjectRuntimeType);
 }
 
 // Recognize a.runtimeType == b.runtimeType and fold it into
@@ -284,7 +285,7 @@ Value* AotCallSpecializer::PrepareStaticOpInput(Value* input,
   input = input->CopyWithType(Z);
 
   if (cid == kDoubleCid && input->Type()->IsNullableInt()) {
-    Definition* conversion = NULL;
+    Definition* conversion = nullptr;
 
     if (input->Type()->ToNullableCid() == kSmiCid) {
       conversion = new (Z) SmiToDoubleInstr(input, call->source());
@@ -298,7 +299,7 @@ Value* AotCallSpecializer::PrepareStaticOpInput(Value* input,
     if (FLAG_trace_strong_mode_types) {
       THR_Print("[Strong mode] Inserted %s\n", conversion->ToCString());
     }
-    InsertBefore(call, conversion, /* env = */ NULL, FlowGraph::kValue);
+    InsertBefore(call, conversion, /* env = */ nullptr, FlowGraph::kValue);
     return new (Z) Value(conversion);
   }
 
@@ -419,7 +420,7 @@ Definition* AotCallSpecializer::TryOptimizeMod(TemplateDartCall<0>* instr,
 #if defined(TARGET_ARCH_ARM)
   Definition* right_definition = new (Z) UnboxedConstantInstr(
       Smi::ZoneHandle(Z, Smi::New(modulus - 1)), kUnboxedInt32);
-  InsertBefore(instr, right_definition, /*env=*/NULL, FlowGraph::kValue);
+  InsertBefore(instr, right_definition, /*env=*/nullptr, FlowGraph::kValue);
   right_definition = new (Z)
       IntConverterInstr(kUnboxedInt32, kUnboxedInt64,
                         new (Z) Value(right_definition), DeoptId::kNone);
@@ -428,7 +429,7 @@ Definition* AotCallSpecializer::TryOptimizeMod(TemplateDartCall<0>* instr,
       Smi::ZoneHandle(Z, Smi::New(modulus - 1)), kUnboxedInt64);
 #endif
   if (modulus == 1) return right_definition;
-  InsertBefore(instr, right_definition, /*env=*/NULL, FlowGraph::kValue);
+  InsertBefore(instr, right_definition, /*env=*/nullptr, FlowGraph::kValue);
   right_value = new (Z) Value(right_definition);
   return new (Z)
       BinaryInt64OpInstr(Token::kBIT_AND, left_value, right_value,
@@ -442,7 +443,7 @@ bool AotCallSpecializer::TryOptimizeIntegerOperation(TemplateDartCall<0>* instr,
     return false;
   }
 
-  Definition* replacement = NULL;
+  Definition* replacement = nullptr;
   if (instr->ArgumentCount() == 2) {
     Value* left_value = instr->ArgumentValueAt(0);
     Value* right_value = instr->ArgumentValueAt(1);
@@ -592,7 +593,7 @@ bool AotCallSpecializer::TryOptimizeDoubleOperation(TemplateDartCall<0>* instr,
     return false;
   }
 
-  Definition* replacement = NULL;
+  Definition* replacement = nullptr;
 
   if (instr->ArgumentCount() == 2) {
     Value* left_value = instr->ArgumentValueAt(0);
@@ -685,7 +686,7 @@ bool AotCallSpecializer::TryOptimizeDoubleOperation(TemplateDartCall<0>* instr,
     }
   }
 
-  if (replacement != NULL && !replacement->ComputeCanDeoptimize()) {
+  if (replacement != nullptr && !replacement->ComputeCanDeoptimize()) {
     if (FLAG_trace_strong_mode_types) {
       THR_Print("[Strong mode] Optimization: replacing %s with %s\n",
                 instr->ToCString(), replacement->ToCString());
@@ -1060,13 +1061,13 @@ void AotCallSpecializer::VisitPolymorphicInstanceCall(
 bool AotCallSpecializer::TryReplaceInstanceOfWithRangeCheck(
     InstanceCallInstr* call,
     const AbstractType& type) {
-  if (precompiler_ == NULL) {
+  if (precompiler_ == nullptr) {
     // Loading not complete, can't do CHA yet.
     return false;
   }
 
   HierarchyInfo* hi = thread()->hierarchy_info();
-  if (hi == NULL) {
+  if (hi == nullptr) {
     return false;
   }
 
@@ -1080,7 +1081,7 @@ bool AotCallSpecializer::TryReplaceInstanceOfWithRangeCheck(
   // left.instanceof(type) =>
   //     _classRangeCheck(left.cid, lower_limit, upper_limit)
   LoadClassIdInstr* left_cid = new (Z) LoadClassIdInstr(new (Z) Value(left));
-  InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
+  InsertBefore(call, left_cid, nullptr, FlowGraph::kValue);
   ConstantInstr* lower_cid =
       flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(lower_limit)));
 

runtime/vm/compiler/aot/precompiler.cc

@@ -386,7 +386,7 @@ void Precompiler::ReportStats() {
 
 Precompiler::Precompiler(Thread* thread)
     : thread_(thread),
-      zone_(NULL),
+      zone_(nullptr),
       changed_(false),
       retain_root_library_caches_(false),
       function_count_(0),
@@ -426,7 +426,7 @@ Precompiler::Precompiler(Thread* thread)
       api_uses_(),
       error_(Error::Handle()),
       get_runtime_type_is_unique_(false) {
-  ASSERT(Precompiler::singleton_ == NULL);
+  ASSERT(Precompiler::singleton_ == nullptr);
   Precompiler::singleton_ = this;
 
   if (FLAG_print_precompiler_timings) {
@@ -443,7 +443,7 @@ Precompiler::~Precompiler() {
   functions_to_retain_.Release();
 
   ASSERT(Precompiler::singleton_ == this);
-  Precompiler::singleton_ = NULL;
+  Precompiler::singleton_ = nullptr;
 
   delete thread()->compiler_timings();
   thread()->set_compiler_timings(nullptr);
@@ -673,7 +673,7 @@ void Precompiler::DoCompileAll() {
       retained_reasons_writer_ = nullptr;
     }
 
-    zone_ = NULL;
+    zone_ = nullptr;
   }
 
   intptr_t symbols_before = -1;
@@ -3555,7 +3555,7 @@ bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
           precompiler_->global_object_pool_builder());
       compiler::Assembler assembler(&object_pool_builder, far_branch_level);
 
-      CodeStatistics* function_stats = NULL;
+      CodeStatistics* function_stats = nullptr;
       if (FLAG_print_instruction_stats) {
         // At the moment we are leaking CodeStatistics objects for
         // simplicity because this is just a development mode flag.
@@ -3760,7 +3760,7 @@ ErrorPtr Precompiler::CompileFunction(Precompiler* precompiler,
 }
 
 Obfuscator::Obfuscator(Thread* thread, const String& private_key)
-    : state_(NULL) {
+    : state_(nullptr) {
   auto isolate_group = thread->isolate_group();
   if (!isolate_group->obfuscate()) {
     // Nothing to do.
@@ -3791,7 +3791,7 @@ Obfuscator::Obfuscator(Thread* thread, const String& private_key)
 }
 
 Obfuscator::~Obfuscator() {
-  if (state_ != NULL) {
+  if (state_ != nullptr) {
     state_->SaveState();
   }
 }
@@ -3912,7 +3912,7 @@ static const intptr_t kSetterPrefixLength = strlen(kSetterPrefix);
 void Obfuscator::PreventRenaming(const char* name) {
   // For constructor names Class.name skip class name (if any) and a dot.
   const char* dot = strchr(name, '.');
-  if (dot != NULL) {
+  if (dot != nullptr) {
     name = dot + 1;
   }
 
@@ -4095,7 +4095,7 @@ const char** Obfuscator::SerializeMap(Thread* thread) {
       Array::Handle(thread->zone(),
                     thread->isolate_group()->object_store()->obfuscation_map());
   if (obfuscation_state.IsNull()) {
-    return NULL;
+    return nullptr;
   }
 
   const Array& renames = Array::Handle(
@@ -4114,7 +4114,7 @@ const char** Obfuscator::SerializeMap(Thread* thread) {
     str ^= renames_map.GetPayload(entry, 0);
     result[idx++] = StringToCString(str);
   }
-  result[idx++] = NULL;
+  result[idx++] = nullptr;
   renames_map.Release();
 
   return result;

runtime/vm/compiler/aot/precompiler.h

@@ -483,7 +483,7 @@ class Obfuscator : public ValueObject {
   // This method is guaranteed to return the same value for the same
   // input and it always preserves leading '_' even for atomic renames.
   StringPtr Rename(const String& name, bool atomic = false) {
-    if (state_ == NULL) {
+    if (state_ == nullptr) {
       return name.ptr();
     }
 
@@ -610,7 +610,7 @@ class Obfuscator : public ValueObject {
     String& renamed_;
   };
 
-  // Current obfuscation state or NULL if obfuscation is not enabled.
+  // Current obfuscation state or nullptr if obfuscation is not enabled.
   ObfuscationState* state_;
 };
 #else

runtime/vm/compiler/aot/precompiler_tracer.cc

@@ -29,7 +29,7 @@ PrecompilerTracer* PrecompilerTracer::StartTracingIfRequested(
     return nullptr;
   }
   void* file = Dart::file_open_callback()(filename, /*write=*/true);
-  if (file == NULL) {
+  if (file == nullptr) {
     OS::PrintErr("warning: Failed to write precompiler trace: %s\n", filename);
     return nullptr;
   }

runtime/vm/compiler/assembler/assembler_arm.cc

@@ -3544,7 +3544,7 @@ void Assembler::TryAllocateObject(intptr_t cid,
                                   JumpDistance distance,
                                   Register instance_reg,
                                   Register temp_reg) {
-  ASSERT(failure != NULL);
+  ASSERT(failure != nullptr);
   ASSERT(instance_reg != kNoRegister);
   ASSERT(instance_reg != temp_reg);
   ASSERT(instance_reg != IP);

runtime/vm/compiler/assembler/assembler_arm64.cc

@@ -297,7 +297,7 @@ static int CountOneBits(uint64_t value, int width) {
 // If it can't be encoded, the function returns false, and the operand is
 // undefined.
 bool Operand::IsImmLogical(uint64_t value, uint8_t width, Operand* imm_op) {
-  ASSERT(imm_op != NULL);
+  ASSERT(imm_op != nullptr);
   ASSERT((width == kWRegSizeInBits) || (width == kXRegSizeInBits));
   if (width == kWRegSizeInBits) {
     value &= 0xffffffffUL;
@@ -2008,7 +2008,7 @@ void Assembler::TryAllocateObject(intptr_t cid,
                                   JumpDistance distance,
                                   Register instance_reg,
                                   Register temp_reg) {
-  ASSERT(failure != NULL);
+  ASSERT(failure != nullptr);
   ASSERT(instance_size != 0);
   ASSERT(instance_reg != temp_reg);
   ASSERT(temp_reg != kNoRegister);

runtime/vm/compiler/assembler/assembler_arm64.h

@@ -482,7 +482,7 @@ class Operand : public ValueObject {
   // used as an operand in either instruction. The encoded operand is written
   // to op.
   static OperandType CanHold(int64_t imm, uint8_t sz, Operand* op) {
-    ASSERT(op != NULL);
+    ASSERT(op != nullptr);
     ASSERT((sz == kXRegSizeInBits) || (sz == kWRegSizeInBits));
     if (Utils::IsUint(12, imm)) {
       op->encoding_ = imm << kImm12Shift;