8301068: Replace NULL with nullptr in share/jvmci/

Reviewed-by: kvn, never

Author: jdksjolen

src/hotspot/share/jvmci/jvmci.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -60,7 +60,7 @@ bool JVMCI::can_initialize_JVMCI() {
   // The JVMCI API itself isn't available until phase 2 and ServiceLoader (which
   // JVMCI initialization requires) isn't usable until after phase 3. Testing
   // whether the system loader is initialized satisfies all these invariants.
-  if (SystemDictionary::java_system_loader() == NULL) {
+  if (SystemDictionary::java_system_loader() == nullptr) {
     return false;
   }
   assert(Universe::is_module_initialized(), "must be");
@@ -69,16 +69,16 @@ bool JVMCI::can_initialize_JVMCI() {
 
 void* JVMCI::get_shared_library(char*& path, bool load) {
   void* sl_handle = _shared_library_handle;
-  if (sl_handle != NULL || !load) {
+  if (sl_handle != nullptr || !load) {
     path = _shared_library_path;
     return sl_handle;
   }
   MutexLocker locker(JVMCI_lock);
-  path = NULL;
-  if (_shared_library_handle == NULL) {
+  path = nullptr;
+  if (_shared_library_handle == nullptr) {
     char path[JVM_MAXPATHLEN];
     char ebuf[1024];
-    if (JVMCILibPath != NULL) {
+    if (JVMCILibPath != nullptr) {
       if (!os::dll_locate_lib(path, sizeof(path), JVMCILibPath, JVMCI_SHARED_LIBRARY_NAME)) {
         fatal("Unable to create path to JVMCI shared library based on value of JVMCILibPath (%s)", JVMCILibPath);
       }
@@ -89,7 +89,7 @@ void* JVMCI::get_shared_library(char*& path, bool load) {
     }
 
     void* handle = os::dll_load(path, ebuf, sizeof ebuf);
-    if (handle == NULL) {
+    if (handle == nullptr) {
       fatal("Unable to load JVMCI shared library from %s: %s", path, ebuf);
     }
     _shared_library_handle = handle;
@@ -103,7 +103,7 @@ void* JVMCI::get_shared_library(char*& path, bool load) {
 
 void JVMCI::initialize_compiler(TRAPS) {
   if (JVMCILibDumpJNIConfig) {
-    JNIJVMCI::initialize_ids(NULL);
+    JNIJVMCI::initialize_ids(nullptr);
     ShouldNotReachHere();
   }
   JVMCIRuntime* runtime;
@@ -175,9 +175,9 @@ JVMCIRuntime* JVMCI::compiler_runtime(JavaThread* thread, bool create) {
 JavaThread* JVMCI::compilation_tick(JavaThread* thread) {
   if (thread->is_Compiler_thread()) {
     CompileTask *task = CompilerThread::cast(thread)->task();
-    if (task != NULL) {
+    if (task != nullptr) {
       JVMCICompileState *state = task->blocking_jvmci_compile_state();
-      if (state != NULL) {
+      if (state != nullptr) {
         state->inc_compilation_ticks();
       }
     }

src/hotspot/share/jvmci/jvmci.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -58,7 +58,7 @@ class JVMCI : public AllStatic {
   // Special libjvmci based JVMCIRuntime reserved for
   // threads trying to attach when in JVMCI shutdown.
   // This preserves the invariant that JVMCIRuntime::for_thread()
-  // never returns nullptr.
+  // never returns null.
   static JVMCIRuntime* _shutdown_compiler_runtime;
 
   // True when at least one JVMCIRuntime::initialize_HotSpotJVMCIRuntime()
@@ -98,7 +98,7 @@ class JVMCI : public AllStatic {
     max_EventLog_level = 4
   };
 
-  // Gets the Thread* value for the current thread or NULL if it's not available.
+  // Gets the Thread* value for the current thread or null if it's not available.
   static Thread* current_thread_or_null();
 
  public:
@@ -130,7 +130,7 @@ class JVMCI : public AllStatic {
   // Logs the fatal crash data in `buf` to the appropriate stream.
   static void fatal_log(const char* buf, size_t count);
 
-  // Gets the name of the opened JVMCI shared library crash data file or NULL
+  // Gets the name of the opened JVMCI shared library crash data file or null
   // if this file has not been created.
   static const char* fatal_log_filename() { return _fatal_log_filename; }
 

src/hotspot/share/jvmci/jvmciCodeInstaller.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -45,7 +45,7 @@
 // Allocate them with new so they are never destroyed (otherwise, a
 // forced exit could destroy these objects while they are still in
 // use).
-ConstantOopWriteValue* CodeInstaller::_oop_null_scope_value = new (mtJVMCI) ConstantOopWriteValue(NULL);
+ConstantOopWriteValue* CodeInstaller::_oop_null_scope_value = new (mtJVMCI) ConstantOopWriteValue(nullptr);
 ConstantIntValue*      CodeInstaller::_int_m1_scope_value = new (mtJVMCI) ConstantIntValue(-1);
 ConstantIntValue*      CodeInstaller::_int_0_scope_value =  new (mtJVMCI) ConstantIntValue((jint)0);
 ConstantIntValue*      CodeInstaller::_int_1_scope_value =  new (mtJVMCI) ConstantIntValue(1);
@@ -252,7 +252,7 @@ OopMap* CodeInstaller::create_oop_map(HotSpotCompiledCodeStream* stream, u1 debu
   assert(is_set(debug_info_flags, DI_HAS_REFERENCE_MAP), "must be");
   u2 max_register_size = stream->read_u2("maxRegisterSize");
   if (!_has_wide_vector && SharedRuntime::is_wide_vector(max_register_size)) {
-    if (SharedRuntime::polling_page_vectors_safepoint_handler_blob() == NULL) {
+    if (SharedRuntime::polling_page_vectors_safepoint_handler_blob() == nullptr) {
       JVMCI_ERROR_NULL("JVMCI is producing code using vectors larger than the runtime supports%s", stream->context());
     }
     _has_wide_vector = true;
@@ -377,15 +377,15 @@ Handle CodeInstaller::read_oop(HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_
     JVMCI_ERROR_(Handle(), "unexpected oop tag: %d", tag)
   }
   if (obj == nullptr) {
-    JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly NULL", Handle());
+    JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly null", Handle());
   } else {
     oopDesc::verify(obj);
   }
   return Handle(stream->thread(), obj);
 }
 
 ScopeValue* CodeInstaller::get_scope_value(HotSpotCompiledCodeStream* stream, u1 tag, BasicType type, ScopeValue* &second, JVMCI_TRAPS) {
-  second = NULL;
+  second = nullptr;
   switch (tag) {
     case ILLEGAL: {
       if (type != T_ILLEGAL) {
@@ -484,7 +484,7 @@ void CodeInstaller::record_object_value(ObjectValue* sv, HotSpotCompiledCodeStre
 
   u2 length = stream->read_u2("values:length");
   for (jint i = 0; i < length; i++) {
-    ScopeValue* cur_second = NULL;
+    ScopeValue* cur_second = nullptr;
     BasicType type = (BasicType) stream->read_u1("basicType");
     ScopeValue* value;
     u1 tag = stream->read_u1("tag");
@@ -506,22 +506,22 @@ void CodeInstaller::record_object_value(ObjectValue* sv, HotSpotCompiledCodeStre
       value = get_scope_value(stream, tag, type, cur_second, JVMCI_CHECK);
     }
 
-    if (isLongArray && cur_second == NULL) {
+    if (isLongArray && cur_second == nullptr) {
       // we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations.
       // add an int 0 constant
       cur_second = _int_0_scope_value;
     }
 
-    if (isByteArray && cur_second != NULL && (type == T_DOUBLE || type == T_LONG)) {
+    if (isByteArray && cur_second != nullptr && (type == T_DOUBLE || type == T_LONG)) {
       // we are trying to write a long in a byte Array. We will need to count the illegals to restore the type of
       // the thing we put inside.
-      cur_second = NULL;
+      cur_second = nullptr;
     }
 
-    if (cur_second != NULL) {
+    if (cur_second != nullptr) {
       sv->field_values()->append(cur_second);
     }
-    assert(value != NULL, "missing value");
+    assert(value != nullptr, "missing value");
     sv->field_values()->append(value);
   }
 }
@@ -573,9 +573,9 @@ GrowableArray<MonitorValue*>* CodeInstaller::read_monitor_values(HotSpotCompiled
   GrowableArray<MonitorValue*>* monitors = new GrowableArray<MonitorValue*>(length);
   for (int i = 0; i < length; i++) {
     bool eliminated = stream->read_bool("isEliminated");
-    ScopeValue* second = NULL;
+    ScopeValue* second = nullptr;
     ScopeValue* owner_value = get_scope_value(stream, stream->read_u1("tag"), T_OBJECT, second, JVMCI_CHECK_NULL);
-    assert(second == NULL, "monitor cannot occupy two stack slots");
+    assert(second == nullptr, "monitor cannot occupy two stack slots");
 
     ScopeValue* lock_data_value = get_scope_value(stream, stream->read_u1("tag"), T_LONG, second, JVMCI_CHECK_NULL);
     assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots");
@@ -589,9 +589,9 @@ GrowableArray<MonitorValue*>* CodeInstaller::read_monitor_values(HotSpotCompiled
 
 void CodeInstaller::initialize_dependencies(HotSpotCompiledCodeStream* stream, u1 code_flags, OopRecorder* oop_recorder, JVMCI_TRAPS) {
   JavaThread* thread = stream->thread();
-  CompilerThread* compilerThread = thread->is_Compiler_thread() ? CompilerThread::cast(thread) : NULL;
+  CompilerThread* compilerThread = thread->is_Compiler_thread() ? CompilerThread::cast(thread) : nullptr;
   _oop_recorder = oop_recorder;
-  _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != NULL ? compilerThread->log() : NULL);
+  _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != nullptr ? compilerThread->log() : nullptr);
   if (is_set(code_flags, HCC_HAS_ASSUMPTIONS)) {
     u2 length = stream->read_u2("assumptions:length");
     for (int i = 0; i < length; ++i) {
@@ -714,7 +714,7 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
                                        false);
     result = JVMCI::ok;
   } else {
-    if (compile_state != NULL) {
+    if (compile_state != nullptr) {
       jvmci_env()->set_compile_state(compile_state);
     }
 
@@ -728,7 +728,7 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
     }
 
     JVMCIObject mirror = installed_code;
-    nmethod* nm = NULL; // nm is an out parameter of register_method
+    nmethod* nm = nullptr; // nm is an out parameter of register_method
     result = runtime()->register_method(jvmci_env(),
                                         method,
                                         nm,
@@ -754,7 +754,7 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
                                         speculations_len);
     if (result == JVMCI::ok) {
       cb = nm;
-      if (compile_state == NULL) {
+      if (compile_state == nullptr) {
         // This compile didn't come through the CompileBroker so perform the printing here
         DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, compiler);
         nm->maybe_print_nmethod(directive);
@@ -763,7 +763,7 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
     }
   }
 
-  if (cb != NULL) {
+  if (cb != nullptr) {
     // Make sure the pre-calculated constants section size was correct.
     guarantee((cb->code_begin() - cb->content_begin()) >= _constants_size, "%d < %d", (int)(cb->code_begin() - cb->content_begin()), _constants_size);
   }
@@ -861,7 +861,7 @@ JVMCI::CodeInstallResult CodeInstaller::initialize_buffer(JVMCIObject compiled_c
   }
 
   buffer.initialize(total_size, locs_buffer_size);
-  if (buffer.blob() == NULL) {
+  if (buffer.blob() == nullptr) {
     return JVMCI::cache_full;
   }
   buffer.initialize_stubs_size(stubs_size);
@@ -1017,7 +1017,7 @@ void CodeInstaller::read_virtual_objects(HotSpotCompiledCodeStream* stream, JVMC
   if (length == 0) {
     return;
   }
-  GrowableArray<ScopeValue*> *objects = new GrowableArray<ScopeValue*>(length, length, NULL);
+  GrowableArray<ScopeValue*> *objects = new GrowableArray<ScopeValue*>(length, length, nullptr);
   stream->set_virtual_objects(objects);
   // Create the unique ObjectValues
   JavaThread* thread = stream->thread();
@@ -1076,9 +1076,9 @@ void CodeInstaller::record_scope(jint pc_offset, HotSpotCompiledCodeStream* stre
       bool reexecute = false;
       bool rethrow_exception = false;
 
-      DebugToken* locals_token = NULL;
-      DebugToken* stack_token = NULL;
-      DebugToken* monitors_token = NULL;
+      DebugToken* locals_token = nullptr;
+      DebugToken* stack_token = nullptr;
+      DebugToken* monitors_token = nullptr;
 
       if (full_info) {
         u1 frame_flags = stream->read_u1("flags");
@@ -1100,7 +1100,7 @@ void CodeInstaller::record_scope(jint pc_offset, HotSpotCompiledCodeStream* stre
       // has_ea_local_in_scope and arg_escape should be added to JVMCI
       const bool has_ea_local_in_scope = false;
       const bool arg_escape            = false;
-      _debug_recorder->describe_scope(pc_offset, method, NULL, bci, reexecute, rethrow_exception, is_mh_invoke, return_oop,
+      _debug_recorder->describe_scope(pc_offset, method, nullptr, bci, reexecute, rethrow_exception, is_mh_invoke, return_oop,
                                       has_ea_local_in_scope, arg_escape,
                                       locals_token, stack_token, monitors_token);
     }

src/hotspot/share/jvmci/jvmciCompiler.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -33,22 +33,22 @@
 #include "runtime/arguments.hpp"
 #include "runtime/handles.inline.hpp"
 
-JVMCICompiler* JVMCICompiler::_instance = NULL;
+JVMCICompiler* JVMCICompiler::_instance = nullptr;
 
 JVMCICompiler::JVMCICompiler() : AbstractCompiler(compiler_jvmci) {
   _bootstrapping = false;
   _bootstrap_compilation_request_handled = false;
   _methods_compiled = 0;
   _global_compilation_ticks = 0;
-  assert(_instance == NULL, "only one instance allowed");
+  assert(_instance == nullptr, "only one instance allowed");
   _instance = this;
 }
 
 JVMCICompiler* JVMCICompiler::instance(bool require_non_null, TRAPS) {
   if (!EnableJVMCI) {
     THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVMCI is not enabled")
   }
-  if (_instance == NULL && require_non_null) {
+  if (_instance == nullptr && require_non_null) {
     THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "The JVMCI compiler instance has not been created");
   }
   return _instance;
@@ -127,12 +127,12 @@ bool JVMCICompiler::force_comp_at_level_simple(const methodHandle& method) {
     return false;
   } else {
     JVMCIRuntime* runtime = JVMCI::java_runtime();
-    if (runtime != NULL) {
+    if (runtime != nullptr) {
       JVMCIObject receiver = runtime->probe_HotSpotJVMCIRuntime();
       if (receiver.is_null()) {
         return false;
       }
-      JVMCIEnv* ignored_env = NULL;
+      JVMCIEnv* ignored_env = nullptr;
       objArrayHandle excludeModules(JavaThread::current(), HotSpotJVMCI::HotSpotJVMCIRuntime::excludeFromJVMCICompilation(ignored_env, HotSpotJVMCI::resolve(receiver)));
       if (excludeModules.not_null()) {
         ModuleEntry* moduleEntry = method->method_holder()->module();