stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8301068: Replace NULL with nullptr in share/jvmci/

Browse Source 
Reviewed-by: kvn, never
This commit is contained in:
Johan Sjölen 2023-01-31 12:19:42 +00:00
parent 419409bcf6
commit 90ec19efed
19 changed files with 403 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/hotspot/share/jvmci/jvmci.cpp
View File

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

8
src/hotspot/share/jvmci/jvmci.hpp
View File

@ -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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * 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 // Special libjvmci based JVMCIRuntime reserved for
// threads trying to attach when in JVMCI shutdown. // threads trying to attach when in JVMCI shutdown.
// This preserves the invariant that JVMCIRuntime::for_thread() // This preserves the invariant that JVMCIRuntime::for_thread()
// never returns nullptr. // never returns null.
static JVMCIRuntime* _shutdown_compiler_runtime; static JVMCIRuntime* _shutdown_compiler_runtime;
// True when at least one JVMCIRuntime::initialize_HotSpotJVMCIRuntime() // True when at least one JVMCIRuntime::initialize_HotSpotJVMCIRuntime()
@ -98,7 +98,7 @@ class JVMCI : public AllStatic {
max_EventLog_level = 4 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(); static Thread* current_thread_or_null();
public: public:
@ -130,7 +130,7 @@ class JVMCI : public AllStatic {
// Logs the fatal crash data in `buf` to the appropriate stream. // Logs the fatal crash data in `buf` to the appropriate stream.
static void fatal_log(const char* buf, size_t count); 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. // if this file has not been created.
static const char* fatal_log_filename() { return _fatal_log_filename; } static const char* fatal_log_filename() { return _fatal_log_filename; }

50
src/hotspot/share/jvmci/jvmciCodeInstaller.cpp
View File

@ -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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * 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 // Allocate them with new so they are never destroyed (otherwise, a
// forced exit could destroy these objects while they are still in // forced exit could destroy these objects while they are still in
// use). // 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_m1_scope_value = new (mtJVMCI) ConstantIntValue(-1);
ConstantIntValue* CodeInstaller::_int_0_scope_value = new (mtJVMCI) ConstantIntValue((jint)0); ConstantIntValue* CodeInstaller::_int_0_scope_value = new (mtJVMCI) ConstantIntValue((jint)0);
ConstantIntValue* CodeInstaller::_int_1_scope_value = new (mtJVMCI) ConstantIntValue(1); 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"); assert(is_set(debug_info_flags, DI_HAS_REFERENCE_MAP), "must be");
u2 max_register_size = stream->read_u2("maxRegisterSize"); u2 max_register_size = stream->read_u2("maxRegisterSize");
if (!_has_wide_vector && SharedRuntime::is_wide_vector(max_register_size)) { 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()); JVMCI_ERROR_NULL("JVMCI is producing code using vectors larger than the runtime supports%s", stream->context());
} }
_has_wide_vector = true; _has_wide_vector = true;
@ -377,7 +377,7 @@ Handle CodeInstaller::read_oop(HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_
JVMCI_ERROR_(Handle(), "unexpected oop tag: %d", tag) JVMCI_ERROR_(Handle(), "unexpected oop tag: %d", tag)
} }
if (obj == nullptr) { if (obj == nullptr) {
JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly NULL", Handle()); JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly null", Handle());
} else { } else {
oopDesc::verify(obj); oopDesc::verify(obj);
} }
@ -385,7 +385,7 @@ Handle CodeInstaller::read_oop(HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_
} }
ScopeValue* CodeInstaller::get_scope_value(HotSpotCompiledCodeStream* stream, u1 tag, BasicType type, ScopeValue* &second, JVMCI_TRAPS) { ScopeValue* CodeInstaller::get_scope_value(HotSpotCompiledCodeStream* stream, u1 tag, BasicType type, ScopeValue* &second, JVMCI_TRAPS) {
second = NULL; second = nullptr;
switch (tag) { switch (tag) {
case ILLEGAL: { case ILLEGAL: {
if (type != T_ILLEGAL) { if (type != T_ILLEGAL) {
@ -484,7 +484,7 @@ void CodeInstaller::record_object_value(ObjectValue* sv, HotSpotCompiledCodeStre
u2 length = stream->read_u2("values:length"); u2 length = stream->read_u2("values:length");
for (jint i = 0; i < length; i++) { for (jint i = 0; i < length; i++) {
ScopeValue* cur_second = NULL; ScopeValue* cur_second = nullptr;
BasicType type = (BasicType) stream->read_u1("basicType"); BasicType type = (BasicType) stream->read_u1("basicType");
ScopeValue* value; ScopeValue* value;
u1 tag = stream->read_u1("tag"); 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); 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. // 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 // add an int 0 constant
cur_second = _int_0_scope_value; 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 // 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. // 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); sv->field_values()->append(cur_second);
} }
assert(value != NULL, "missing value"); assert(value != nullptr, "missing value");
sv->field_values()->append(value); sv->field_values()->append(value);
} }
} }
@ -573,9 +573,9 @@ GrowableArray<MonitorValue*>* CodeInstaller::read_monitor_values(HotSpotCompiled
GrowableArray<MonitorValue*>* monitors = new GrowableArray<MonitorValue*>(length); GrowableArray<MonitorValue*>* monitors = new GrowableArray<MonitorValue*>(length);
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
bool eliminated = stream->read_bool("isEliminated"); 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); 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); 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"); 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) { void CodeInstaller::initialize_dependencies(HotSpotCompiledCodeStream* stream, u1 code_flags, OopRecorder* oop_recorder, JVMCI_TRAPS) {
JavaThread* thread = stream->thread(); 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; _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)) { if (is_set(code_flags, HCC_HAS_ASSUMPTIONS)) {
u2 length = stream->read_u2("assumptions:length"); u2 length = stream->read_u2("assumptions:length");
for (int i = 0; i < length; ++i) { for (int i = 0; i < length; ++i) {
@ -714,7 +714,7 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
false); false);
result = JVMCI::ok; result = JVMCI::ok;
} else { } else {
if (compile_state != NULL) { if (compile_state != nullptr) {
jvmci_env()->set_compile_state(compile_state); jvmci_env()->set_compile_state(compile_state);
} }
@ -728,7 +728,7 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
} }
JVMCIObject mirror = installed_code; 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(), result = runtime()->register_method(jvmci_env(),
method, method,
nm, nm,
@ -754,7 +754,7 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
speculations_len); speculations_len);
if (result == JVMCI::ok) { if (result == JVMCI::ok) {
cb = nm; cb = nm;
if (compile_state == NULL) { if (compile_state == nullptr) {
// This compile didn't come through the CompileBroker so perform the printing here // This compile didn't come through the CompileBroker so perform the printing here
DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, compiler); DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, compiler);
nm->maybe_print_nmethod(directive); 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. // 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); 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); buffer.initialize(total_size, locs_buffer_size);
if (buffer.blob() == NULL) { if (buffer.blob() == nullptr) {
return JVMCI::cache_full; return JVMCI::cache_full;
} }
buffer.initialize_stubs_size(stubs_size); buffer.initialize_stubs_size(stubs_size);
@ -1017,7 +1017,7 @@ void CodeInstaller::read_virtual_objects(HotSpotCompiledCodeStream* stream, JVMC
if (length == 0) { if (length == 0) {
return; return;
} }
GrowableArray<ScopeValue*> *objects = new GrowableArray<ScopeValue*>(length, length, NULL); GrowableArray<ScopeValue*> *objects = new GrowableArray<ScopeValue*>(length, length, nullptr);
stream->set_virtual_objects(objects); stream->set_virtual_objects(objects);
// Create the unique ObjectValues // Create the unique ObjectValues
JavaThread* thread = stream->thread(); JavaThread* thread = stream->thread();
@ -1076,9 +1076,9 @@ void CodeInstaller::record_scope(jint pc_offset, HotSpotCompiledCodeStream* stre
bool reexecute = false; bool reexecute = false;
bool rethrow_exception = false; bool rethrow_exception = false;
DebugToken* locals_token = NULL; DebugToken* locals_token = nullptr;
DebugToken* stack_token = NULL; DebugToken* stack_token = nullptr;
DebugToken* monitors_token = NULL; DebugToken* monitors_token = nullptr;
if (full_info) { if (full_info) {
u1 frame_flags = stream->read_u1("flags"); 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 // has_ea_local_in_scope and arg_escape should be added to JVMCI
const bool has_ea_local_in_scope = false; const bool has_ea_local_in_scope = false;
const bool arg_escape = 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, has_ea_local_in_scope, arg_escape,
locals_token, stack_token, monitors_token); locals_token, stack_token, monitors_token);
} }

12
src/hotspot/share/jvmci/jvmciCompiler.cpp
View File

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

204
src/hotspot/share/jvmci/jvmciCompilerToVM.cpp
View File

@ -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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -70,14 +70,14 @@
JVMCIKlassHandle::JVMCIKlassHandle(Thread* thread, Klass* klass) { JVMCIKlassHandle::JVMCIKlassHandle(Thread* thread, Klass* klass) {
_thread = thread; _thread = thread;
_klass = klass; _klass = klass;
if (klass != NULL) { if (klass != nullptr) {
_holder = Handle(_thread, klass->klass_holder()); _holder = Handle(_thread, klass->klass_holder());
} }
} }
JVMCIKlassHandle& JVMCIKlassHandle::operator=(Klass* klass) { JVMCIKlassHandle& JVMCIKlassHandle::operator=(Klass* klass) {
_klass = klass; _klass = klass;
if (klass != NULL) { if (klass != nullptr) {
_holder = Handle(_thread, klass->klass_holder()); _holder = Handle(_thread, klass->klass_holder());
} }
return *this; return *this;
@ -125,9 +125,9 @@ Handle JavaArgumentUnboxer::next_arg(BasicType expectedType) {
static JavaThread* get_current_thread(bool allow_null=true) { static JavaThread* get_current_thread(bool allow_null=true) {
Thread* thread = Thread::current_or_null_safe(); Thread* thread = Thread::current_or_null_safe();
if (thread == NULL) { if (thread == nullptr) {
assert(allow_null, "npe"); assert(allow_null, "npe");
return NULL; return nullptr;
} }
return JavaThread::cast(thread); return JavaThread::cast(thread);
} }
@ -137,7 +137,7 @@ static JavaThread* get_current_thread(bool allow_null=true) {
#define C2V_VMENTRY(result_type, name, signature) \ #define C2V_VMENTRY(result_type, name, signature) \
JNIEXPORT result_type JNICALL c2v_ ## name signature { \ JNIEXPORT result_type JNICALL c2v_ ## name signature { \
JavaThread* thread = get_current_thread(); \ JavaThread* thread = get_current_thread(); \
if (thread == NULL) { \ if (thread == nullptr) { \
env->ThrowNew(JNIJVMCI::InternalError::clazz(), \ env->ThrowNew(JNIJVMCI::InternalError::clazz(), \
err_msg("Cannot call into HotSpot from JVMCI shared library without attaching current thread")); \ err_msg("Cannot call into HotSpot from JVMCI shared library without attaching current thread")); \
return; \ return; \
@ -148,7 +148,7 @@ static JavaThread* get_current_thread(bool allow_null=true) {
#define C2V_VMENTRY_(result_type, name, signature, result) \ #define C2V_VMENTRY_(result_type, name, signature, result) \
JNIEXPORT result_type JNICALL c2v_ ## name signature { \ JNIEXPORT result_type JNICALL c2v_ ## name signature { \
JavaThread* thread = get_current_thread(); \ JavaThread* thread = get_current_thread(); \
if (thread == NULL) { \ if (thread == nullptr) { \
env->ThrowNew(JNIJVMCI::InternalError::clazz(), \ env->ThrowNew(JNIJVMCI::InternalError::clazz(), \
err_msg("Cannot call into HotSpot from JVMCI shared library without attaching current thread")); \ err_msg("Cannot call into HotSpot from JVMCI shared library without attaching current thread")); \
return result; \ return result; \
@ -156,7 +156,7 @@ static JavaThread* get_current_thread(bool allow_null=true) {
C2V_BLOCK(result_type, name, signature) \ C2V_BLOCK(result_type, name, signature) \
JVMCITraceMark jtm("CompilerToVM::" #name); JVMCITraceMark jtm("CompilerToVM::" #name);
#define C2V_VMENTRY_NULL(result_type, name, signature) C2V_VMENTRY_(result_type, name, signature, NULL) #define C2V_VMENTRY_NULL(result_type, name, signature) C2V_VMENTRY_(result_type, name, signature, nullptr)
#define C2V_VMENTRY_0(result_type, name, signature) C2V_VMENTRY_(result_type, name, signature, 0) #define C2V_VMENTRY_0(result_type, name, signature) C2V_VMENTRY_(result_type, name, signature, 0)
// Entry to native method implementation that does not transition // Entry to native method implementation that does not transition
@ -199,7 +199,7 @@ C2V_VMENTRY_NULL(jobject, getFlagValue, (JNIEnv* env, jobject c2vm, jobject name
} }
const char* cstring = JVMCIENV->as_utf8_string(name); const char* cstring = JVMCIENV->as_utf8_string(name);
const JVMFlag* flag = JVMFlag::find_declared_flag(cstring); const JVMFlag* flag = JVMFlag::find_declared_flag(cstring);
if (flag == NULL) { if (flag == nullptr) {
return c2vm; return c2vm;
} }
if (flag->is_bool()) { if (flag->is_bool()) {
@ -329,7 +329,7 @@ C2V_END
C2V_VMENTRY_NULL(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle)) C2V_VMENTRY_NULL(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle))
requireInHotSpot("asResolvedJavaMethod", JVMCI_CHECK_NULL); requireInHotSpot("asResolvedJavaMethod", JVMCI_CHECK_NULL);
oop executable = JNIHandles::resolve(executable_handle); oop executable = JNIHandles::resolve(executable_handle);
oop mirror = NULL; oop mirror = nullptr;
int slot = 0; int slot = 0;
if (executable->klass() == vmClasses::reflect_Constructor_klass()) { if (executable->klass() == vmClasses::reflect_Constructor_klass()) {
@ -347,7 +347,7 @@ C2V_VMENTRY_NULL(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject e
} }
C2V_VMENTRY_NULL(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject base, jlong offset)) C2V_VMENTRY_NULL(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject base, jlong offset))
Method* method = NULL; Method* method = nullptr;
JVMCIObject base_object = JVMCIENV->wrap(base); JVMCIObject base_object = JVMCIENV->wrap(base);
if (base_object.is_null()) { if (base_object.is_null()) {
method = *((Method**)(offset)); method = *((Method**)(offset));
@ -359,7 +359,7 @@ C2V_VMENTRY_NULL(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject
JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", obj->klass()->external_name())); JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", obj->klass()->external_name()));
} }
} }
if (method == NULL) { if (method == nullptr) {
JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", JVMCIENV->klass_name(base_object))); JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", JVMCIENV->klass_name(base_object)));
} }
assert (method->is_method(), "invalid read"); assert (method->is_method(), "invalid read");
@ -368,7 +368,7 @@ C2V_VMENTRY_NULL(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject
} }
C2V_VMENTRY_NULL(jobject, getConstantPool, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass_or_method), jboolean is_klass)) C2V_VMENTRY_NULL(jobject, getConstantPool, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass_or_method), jboolean is_klass))
ConstantPool* cp = NULL; ConstantPool* cp = nullptr;
if (UNPACK_PAIR(address, klass_or_method) == 0) { if (UNPACK_PAIR(address, klass_or_method) == 0) {
JVMCI_THROW_NULL(NullPointerException); JVMCI_THROW_NULL(NullPointerException);
} }
@ -419,7 +419,7 @@ C2V_VMENTRY_NULL(jobject, getResolvedJavaType0, (JNIEnv* env, jobject, jobject b
base_object.is_non_null() ? JVMCIENV->klass_name(base_object) : "null", base_object.is_non_null() ? JVMCIENV->klass_name(base_object) : "null",
offset, compressed ? "true" : "false")); offset, compressed ? "true" : "false"));
} }
assert (klass == NULL || klass->is_klass(), "invalid read"); assert (klass == nullptr || klass->is_klass(), "invalid read");
JVMCIObject result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL); JVMCIObject result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result); return JVMCIENV->get_jobject(result);
} }
@ -834,7 +834,7 @@ C2V_VMENTRY_NULL(jobject, resolveMethod, (JNIEnv* env, jobject, ARGUMENT_PAIR(re
Symbol* h_signature = method->signature(); Symbol* h_signature = method->signature();
if (MethodHandles::is_signature_polymorphic_method(method())) { if (MethodHandles::is_signature_polymorphic_method(method())) {
// Signature polymorphic methods are already resolved, JVMCI just returns NULL in this case. // Signature polymorphic methods are already resolved, JVMCI just returns null in this case.
return nullptr; return nullptr;
} }
@ -863,7 +863,7 @@ C2V_VMENTRY_NULL(jobject, resolveMethod, (JNIEnv* env, jobject, ARGUMENT_PAIR(re
} }
if (m == nullptr) { if (m == nullptr) {
// Return NULL if there was a problem with lookup (uninitialized class, etc.) // Return null if there was a problem with lookup (uninitialized class, etc.)
return nullptr; return nullptr;
} }
@ -937,7 +937,7 @@ C2V_VMENTRY_0(jint, installCode0, (JNIEnv *env, jobject,
JVMCIObject compiled_code_handle = JVMCIENV->wrap(compiled_code); JVMCIObject compiled_code_handle = JVMCIENV->wrap(compiled_code);
objArrayHandle object_pool_handle(thread, JVMCIENV->is_hotspot() ? (objArrayOop) JNIHandles::resolve(object_pool) : nullptr); objArrayHandle object_pool_handle(thread, JVMCIENV->is_hotspot() ? (objArrayOop) JNIHandles::resolve(object_pool) : nullptr);
CodeBlob* cb = NULL; CodeBlob* cb = nullptr;
JVMCIObject installed_code_handle = JVMCIENV->wrap(installed_code); JVMCIObject installed_code_handle = JVMCIENV->wrap(installed_code);
JVMCIPrimitiveArray speculations_handle = JVMCIENV->wrap(speculations_obj); JVMCIPrimitiveArray speculations_handle = JVMCIENV->wrap(speculations_obj);
@ -977,7 +977,7 @@ C2V_VMENTRY_0(jint, installCode0, (JNIEnv *env, jobject,
} }
if (result != JVMCI::ok) { if (result != JVMCI::ok) {
assert(cb == NULL, "should be"); assert(cb == nullptr, "should be");
} else { } else {
stats->on_install(cb); stats->on_install(cb);
if (installed_code_handle.is_non_null()) { if (installed_code_handle.is_non_null()) {
@ -1006,14 +1006,14 @@ C2V_END
C2V_VMENTRY_NULL(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject installedCode)) C2V_VMENTRY_NULL(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject installedCode))
HandleMark hm(THREAD); HandleMark hm(THREAD);
if (installedCode == NULL) { if (installedCode == nullptr) {
JVMCI_THROW_MSG_NULL(NullPointerException, "installedCode is null"); JVMCI_THROW_MSG_NULL(NullPointerException, "installedCode is null");
} }
JVMCIObject installedCodeObject = JVMCIENV->wrap(installedCode); JVMCIObject installedCodeObject = JVMCIENV->wrap(installedCode);
CodeBlob* cb = JVMCIENV->get_code_blob(installedCodeObject); CodeBlob* cb = JVMCIENV->get_code_blob(installedCodeObject);
if (cb == NULL) { if (cb == nullptr) {
return NULL; return nullptr;
} }
// We don't want the stringStream buffer to resize during disassembly as it // We don't want the stringStream buffer to resize during disassembly as it
@ -1027,7 +1027,7 @@ C2V_VMENTRY_NULL(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject in
stringStream st(buffer, bufferSize); stringStream st(buffer, bufferSize);
Disassembler::decode(cb, &st); Disassembler::decode(cb, &st);
if (st.size() <= 0) { if (st.size() <= 0) {
return NULL; return nullptr;
} }
JVMCIObject result = JVMCIENV->create_string(st.as_string(), JVMCI_CHECK_NULL); JVMCIObject result = JVMCIENV->create_string(st.as_string(), JVMCI_CHECK_NULL);
@ -1051,7 +1051,7 @@ C2V_VMENTRY_NULL(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject
JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod); JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
nmethod* nm = JVMCIENV->get_nmethod(nmethod_mirror); nmethod* nm = JVMCIENV->get_nmethod(nmethod_mirror);
if (nm == NULL || !nm->is_in_use()) { if (nm == nullptr || !nm->is_in_use()) {
JVMCI_THROW_NULL(InvalidInstalledCodeException); JVMCI_THROW_NULL(InvalidInstalledCodeException);
} }
methodHandle mh(THREAD, nm->method()); methodHandle mh(THREAD, nm->method());
@ -1064,7 +1064,7 @@ C2V_VMENTRY_NULL(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject
JavaCalls::call(&result, mh, &jca, CHECK_NULL); JavaCalls::call(&result, mh, &jca, CHECK_NULL);
if (jap.return_type() == T_VOID) { if (jap.return_type() == T_VOID) {
return NULL; return nullptr;
} else if (is_reference_type(jap.return_type())) { } else if (is_reference_type(jap.return_type())) {
return JNIHandles::make_local(THREAD, result.get_oop()); return JNIHandles::make_local(THREAD, result.get_oop());
} else { } else {
@ -1094,7 +1094,7 @@ C2V_END
C2V_VMENTRY_NULL(jlongArray, getLineNumberTable, (JNIEnv* env, jobject, ARGUMENT_PAIR(method))) C2V_VMENTRY_NULL(jlongArray, getLineNumberTable, (JNIEnv* env, jobject, ARGUMENT_PAIR(method)))
Method* method = UNPACK_PAIR(Method, method); Method* method = UNPACK_PAIR(Method, method);
if (!method->has_linenumber_table()) { if (!method->has_linenumber_table()) {
return NULL; return nullptr;
} }
u2 num_entries = 0; u2 num_entries = 0;
CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table()); CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table());
@ -1134,18 +1134,18 @@ C2V_END
C2V_VMENTRY(void, reprofile, (JNIEnv* env, jobject, ARGUMENT_PAIR(method))) C2V_VMENTRY(void, reprofile, (JNIEnv* env, jobject, ARGUMENT_PAIR(method)))
methodHandle method(THREAD, UNPACK_PAIR(Method, method)); methodHandle method(THREAD, UNPACK_PAIR(Method, method));
MethodCounters* mcs = method->method_counters(); MethodCounters* mcs = method->method_counters();
if (mcs != NULL) { if (mcs != nullptr) {
mcs->clear_counters(); mcs->clear_counters();
} }
NOT_PRODUCT(method->set_compiled_invocation_count(0)); NOT_PRODUCT(method->set_compiled_invocation_count(0));
CompiledMethod* code = method->code(); CompiledMethod* code = method->code();
if (code != NULL) { if (code != nullptr) {
code->make_not_entrant(); code->make_not_entrant();
} }
MethodData* method_data = method->method_data(); MethodData* method_data = method->method_data();
if (method_data == NULL) { if (method_data == nullptr) {
ClassLoaderData* loader_data = method->method_holder()->class_loader_data(); ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
method_data = MethodData::allocate(loader_data, method, CHECK); method_data = MethodData::allocate(loader_data, method, CHECK);
method->set_method_data(method_data); method->set_method_data(method_data);
@ -1194,12 +1194,12 @@ C2V_END
C2V_VMENTRY_0(jboolean, isMature, (JNIEnv* env, jobject, jlong method_data_pointer)) C2V_VMENTRY_0(jboolean, isMature, (JNIEnv* env, jobject, jlong method_data_pointer))
MethodData* mdo = (MethodData*) method_data_pointer; MethodData* mdo = (MethodData*) method_data_pointer;
return mdo != NULL && mdo->is_mature(); return mdo != nullptr && mdo->is_mature();
C2V_END C2V_END
C2V_VMENTRY_0(jboolean, hasCompiledCodeForOSR, (JNIEnv* env, jobject, ARGUMENT_PAIR(method), int entry_bci, int comp_level)) C2V_VMENTRY_0(jboolean, hasCompiledCodeForOSR, (JNIEnv* env, jobject, ARGUMENT_PAIR(method), int entry_bci, int comp_level))
Method* method = UNPACK_PAIR(Method, method); Method* method = UNPACK_PAIR(Method, method);
return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL; return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != nullptr;
C2V_END C2V_END
C2V_VMENTRY_NULL(jobject, getSymbol, (JNIEnv* env, jobject, jlong symbol)) C2V_VMENTRY_NULL(jobject, getSymbol, (JNIEnv* env, jobject, jlong symbol))
@ -1221,7 +1221,7 @@ GrowableArray<Method*>* init_resolved_methods(jobjectArray methods, JVMCIEnv* JV
GrowableArray<Method*>* resolved_methods = new GrowableArray<Method*>(methods_oop->length()); GrowableArray<Method*>* resolved_methods = new GrowableArray<Method*>(methods_oop->length());
for (int i = 0; i < methods_oop->length(); i++) { for (int i = 0; i < methods_oop->length(); i++) {
oop resolved = methods_oop->obj_at(i); oop resolved = methods_oop->obj_at(i);
Method* resolved_method = NULL; Method* resolved_method = nullptr;
if (resolved->klass() == HotSpotJVMCI::HotSpotResolvedJavaMethodImpl::klass()) { if (resolved->klass() == HotSpotJVMCI::HotSpotResolvedJavaMethodImpl::klass()) {
resolved_method = HotSpotJVMCI::asMethod(JVMCIENV, resolved); resolved_method = HotSpotJVMCI::asMethod(JVMCIENV, resolved);
} }
@ -1237,11 +1237,11 @@ GrowableArray<Method*>* init_resolved_methods(jobjectArray methods, JVMCIEnv* JV
*/ */
bool matches(jobjectArray methods, Method* method, GrowableArray<Method*>** resolved_methods_ref, Handle* matched_jvmci_method_ref, Thread* THREAD, JVMCIEnv* JVMCIENV) { bool matches(jobjectArray methods, Method* method, GrowableArray<Method*>** resolved_methods_ref, Handle* matched_jvmci_method_ref, Thread* THREAD, JVMCIEnv* JVMCIENV) {
GrowableArray<Method*>* resolved_methods = *resolved_methods_ref; GrowableArray<Method*>* resolved_methods = *resolved_methods_ref;
if (resolved_methods == NULL) { if (resolved_methods == nullptr) {
resolved_methods = init_resolved_methods(methods, JVMCIENV); resolved_methods = init_resolved_methods(methods, JVMCIENV);
*resolved_methods_ref = resolved_methods; *resolved_methods_ref = resolved_methods;
} }
assert(method != NULL, "method should not be NULL"); assert(method != nullptr, "method should not be null");
assert(resolved_methods->length() == ((objArrayOop) JNIHandles::resolve(methods))->length(), "arrays must have the same length"); assert(resolved_methods->length() == ((objArrayOop) JNIHandles::resolve(methods))->length(), "arrays must have the same length");
for (int i = 0; i < resolved_methods->length(); i++) { for (int i = 0; i < resolved_methods->length(); i++) {
Method* m = resolved_methods->at(i); Method* m = resolved_methods->at(i);
@ -1259,7 +1259,7 @@ bool matches(jobjectArray methods, Method* method, GrowableArray<Method*>** reso
methodHandle resolve_interface_call(Klass* spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { methodHandle resolve_interface_call(Klass* spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
CallInfo callinfo; CallInfo callinfo;
Handle receiver = args->receiver(); Handle receiver = args->receiver();
Klass* recvrKlass = receiver.is_null() ? (Klass*)NULL : receiver->klass(); Klass* recvrKlass = receiver.is_null() ? (Klass*)nullptr : receiver->klass();
LinkInfo link_info(spec_klass, name, signature); LinkInfo link_info(spec_klass, name, signature);
LinkResolver::resolve_interface_call( LinkResolver::resolve_interface_call(
callinfo, receiver, recvrKlass, link_info, true, CHECK_(methodHandle())); callinfo, receiver, recvrKlass, link_info, true, CHECK_(methodHandle()));
@ -1292,14 +1292,14 @@ void resync_vframestream_to_compiled_frame(vframeStream& vfst, intptr_t* stack_p
} }
/* /*
* Used by c2v_iterateFrames. Returns an array of any unallocated scope objects or NULL if none. * Used by c2v_iterateFrames. Returns an array of any unallocated scope objects or null if none.
*/ */
GrowableArray<ScopeValue*>* get_unallocated_objects_or_null(GrowableArray<ScopeValue*>* scope_objects) { GrowableArray<ScopeValue*>* get_unallocated_objects_or_null(GrowableArray<ScopeValue*>* scope_objects) {
GrowableArray<ScopeValue*>* unallocated = NULL; GrowableArray<ScopeValue*>* unallocated = nullptr;
for (int i = 0; i < scope_objects->length(); i++) { for (int i = 0; i < scope_objects->length(); i++) {
ObjectValue* sv = (ObjectValue*) scope_objects->at(i); ObjectValue* sv = (ObjectValue*) scope_objects->at(i);
if (sv->value().is_null()) { if (sv->value().is_null()) {
if (unallocated == NULL) { if (unallocated == nullptr) {
unallocated = new GrowableArray<ScopeValue*>(scope_objects->length()); unallocated = new GrowableArray<ScopeValue*>(scope_objects->length());
} }
unallocated->append(sv); unallocated->append(sv);
@ -1311,7 +1311,7 @@ GrowableArray<ScopeValue*>* get_unallocated_objects_or_null(GrowableArray<ScopeV
C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, jobjectArray initial_methods, jobjectArray match_methods, jint initialSkip, jobject visitor_handle)) C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, jobjectArray initial_methods, jobjectArray match_methods, jint initialSkip, jobject visitor_handle))
if (!thread->has_last_Java_frame()) { if (!thread->has_last_Java_frame()) {
return NULL; return nullptr;
} }
Handle visitor(THREAD, JNIHandles::resolve_non_null(visitor_handle)); Handle visitor(THREAD, JNIHandles::resolve_non_null(visitor_handle));
@ -1322,14 +1322,14 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
vframeStream vfst(thread); vframeStream vfst(thread);
jobjectArray methods = initial_methods; jobjectArray methods = initial_methods;
methodHandle visitor_method; methodHandle visitor_method;
GrowableArray<Method*>* resolved_methods = NULL; GrowableArray<Method*>* resolved_methods = nullptr;
while (!vfst.at_end()) { // frame loop while (!vfst.at_end()) { // frame loop
bool realloc_called = false; bool realloc_called = false;
intptr_t* frame_id = vfst.frame_id(); intptr_t* frame_id = vfst.frame_id();
// Previous compiledVFrame of this frame; use with at_scope() to reuse scope object pool. // Previous compiledVFrame of this frame; use with at_scope() to reuse scope object pool.
compiledVFrame* prev_cvf = NULL; compiledVFrame* prev_cvf = nullptr;
for (; !vfst.at_end() && vfst.frame_id() == frame_id; vfst.next()) { // vframe loop for (; !vfst.at_end() && vfst.frame_id() == frame_id; vfst.next()) { // vframe loop
int frame_number = 0; int frame_number = 0;
@ -1337,20 +1337,20 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
int bci = vfst.bci(); int bci = vfst.bci();
Handle matched_jvmci_method; Handle matched_jvmci_method;
if (methods == NULL || matches(methods, method, &resolved_methods, &matched_jvmci_method, THREAD, JVMCIENV)) { if (methods == nullptr || matches(methods, method, &resolved_methods, &matched_jvmci_method, THREAD, JVMCIENV)) {
if (initialSkip > 0) { if (initialSkip > 0) {
initialSkip--; initialSkip--;
continue; continue;
} }
javaVFrame* vf; javaVFrame* vf;
if (prev_cvf != NULL && prev_cvf->frame_pointer()->id() == frame_id) { if (prev_cvf != nullptr && prev_cvf->frame_pointer()->id() == frame_id) {
assert(prev_cvf->is_compiled_frame(), "expected compiled Java frame"); assert(prev_cvf->is_compiled_frame(), "expected compiled Java frame");
vf = prev_cvf->at_scope(vfst.decode_offset(), vfst.vframe_id()); vf = prev_cvf->at_scope(vfst.decode_offset(), vfst.vframe_id());
} else { } else {
vf = vfst.asJavaVFrame(); vf = vfst.asJavaVFrame();
} }
StackValueCollection* locals = NULL; StackValueCollection* locals = nullptr;
typeArrayHandle localIsVirtual_h; typeArrayHandle localIsVirtual_h;
if (vf->is_compiled_frame()) { if (vf->is_compiled_frame()) {
// compiled method frame // compiled method frame
@ -1358,10 +1358,10 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
ScopeDesc* scope = cvf->scope(); ScopeDesc* scope = cvf->scope();
// native wrappers do not have a scope // native wrappers do not have a scope
if (scope != NULL && scope->objects() != NULL) { if (scope != nullptr && scope->objects() != nullptr) {
prev_cvf = cvf; prev_cvf = cvf;
GrowableArray<ScopeValue*>* objects = NULL; GrowableArray<ScopeValue*>* objects = nullptr;
if (!realloc_called) { if (!realloc_called) {
objects = scope->objects(); objects = scope->objects();
} else { } else {
@ -1369,7 +1369,7 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
objects = get_unallocated_objects_or_null(scope->objects()); objects = get_unallocated_objects_or_null(scope->objects());
} }
if (objects != NULL) { if (objects != nullptr) {
RegisterMap reg_map(vf->register_map()); RegisterMap reg_map(vf->register_map());
bool realloc_failures = Deoptimization::realloc_objects(thread, vf->frame_pointer(), &reg_map, objects, CHECK_NULL); bool realloc_failures = Deoptimization::realloc_objects(thread, vf->frame_pointer(), &reg_map, objects, CHECK_NULL);
Deoptimization::reassign_fields(vf->frame_pointer(), &reg_map, objects, realloc_failures, false); Deoptimization::reassign_fields(vf->frame_pointer(), &reg_map, objects, realloc_failures, false);
@ -1434,19 +1434,19 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
args.push_oop(frame_reference); args.push_oop(frame_reference);
JavaCalls::call(&result, visitor_method, &args, CHECK_NULL); JavaCalls::call(&result, visitor_method, &args, CHECK_NULL);
if (result.get_oop() != NULL) { if (result.get_oop() != nullptr) {
return JNIHandles::make_local(thread, result.get_oop()); return JNIHandles::make_local(thread, result.get_oop());
} }
if (methods == initial_methods) { if (methods == initial_methods) {
methods = match_methods; methods = match_methods;
if (resolved_methods != NULL && JNIHandles::resolve(match_methods) != JNIHandles::resolve(initial_methods)) { if (resolved_methods != nullptr && JNIHandles::resolve(match_methods) != JNIHandles::resolve(initial_methods)) {
resolved_methods = NULL; resolved_methods = nullptr;
} }
} }
assert(initialSkip == 0, "There should be no match before initialSkip == 0"); assert(initialSkip == 0, "There should be no match before initialSkip == 0");
if (HotSpotJVMCI::HotSpotStackFrameReference::objectsMaterialized(JVMCIENV, frame_reference()) == JNI_TRUE) { if (HotSpotJVMCI::HotSpotStackFrameReference::objectsMaterialized(JVMCIENV, frame_reference()) == JNI_TRUE) {
// the frame has been deoptimized, we need to re-synchronize the frame and vframe // the frame has been deoptimized, we need to re-synchronize the frame and vframe
prev_cvf = NULL; prev_cvf = nullptr;
intptr_t* stack_pointer = (intptr_t*) HotSpotJVMCI::HotSpotStackFrameReference::stackPointer(JVMCIENV, frame_reference()); intptr_t* stack_pointer = (intptr_t*) HotSpotJVMCI::HotSpotStackFrameReference::stackPointer(JVMCIENV, frame_reference());
resync_vframestream_to_compiled_frame(vfst, stack_pointer, frame_number, thread, CHECK_NULL); resync_vframestream_to_compiled_frame(vfst, stack_pointer, frame_number, thread, CHECK_NULL);
} }
@ -1455,7 +1455,7 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
} // end of frame loop } // end of frame loop
// the end was reached without finding a matching method // the end was reached without finding a matching method
return NULL; return nullptr;
C2V_END C2V_END
C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv* env, jobject, ARGUMENT_PAIR(cp), jint index)) C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv* env, jobject, ARGUMENT_PAIR(cp), jint index))
@ -1503,7 +1503,7 @@ C2V_VMENTRY_0(jint, isResolvedInvokeHandleInPool, (JNIEnv* env, jobject, ARGUMEN
vmassert(!resolved_method->is_static(),"!"); vmassert(!resolved_method->is_static(),"!");
vmassert(MethodHandles::is_signature_polymorphic_method(resolved_method()),"!"); vmassert(MethodHandles::is_signature_polymorphic_method(resolved_method()),"!");
vmassert(!MethodHandles::is_signature_polymorphic_static(resolved_method->intrinsic_id()), "!"); vmassert(!MethodHandles::is_signature_polymorphic_static(resolved_method->intrinsic_id()), "!");
vmassert(cp_cache_entry->appendix_if_resolved(cp) == NULL, "!"); vmassert(cp_cache_entry->appendix_if_resolved(cp) == nullptr, "!");
methodHandle m(THREAD, LinkResolver::linktime_resolve_virtual_method_or_null(link_info)); methodHandle m(THREAD, LinkResolver::linktime_resolve_virtual_method_or_null(link_info));
vmassert(m == resolved_method, "!!"); vmassert(m == resolved_method, "!!");
@ -1595,10 +1595,10 @@ C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv* env, jobject, jobject _hs_
} }
// Reallocate the non-escaping objects and restore their fields. // Reallocate the non-escaping objects and restore their fields.
assert (virtualFrames->at(last_frame_number)->scope() != NULL,"invalid scope"); assert (virtualFrames->at(last_frame_number)->scope() != nullptr,"invalid scope");
GrowableArray<ScopeValue*>* objects = virtualFrames->at(last_frame_number)->scope()->objects(); GrowableArray<ScopeValue*>* objects = virtualFrames->at(last_frame_number)->scope()->objects();
if (objects == NULL) { if (objects == nullptr) {
// no objects to materialize // no objects to materialize
return; return;
} }
@ -1611,7 +1611,7 @@ C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv* env, jobject, jobject _hs_
GrowableArray<ScopeValue*>* scopedValues = cvf->scope()->locals(); GrowableArray<ScopeValue*>* scopedValues = cvf->scope()->locals();
StackValueCollection* locals = cvf->locals(); StackValueCollection* locals = cvf->locals();
if (locals != NULL) { if (locals != nullptr) {
for (int i2 = 0; i2 < locals->size(); i2++) { for (int i2 = 0; i2 < locals->size(); i2++) {
StackValue* var = locals->at(i2); StackValue* var = locals->at(i2);
if (var->type() == T_OBJECT && scopedValues->at(i2)->is_object()) { if (var->type() == T_OBJECT && scopedValues->at(i2)->is_object()) {
@ -1624,7 +1624,7 @@ C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv* env, jobject, jobject _hs_
GrowableArray<ScopeValue*>* scopeExpressions = cvf->scope()->expressions(); GrowableArray<ScopeValue*>* scopeExpressions = cvf->scope()->expressions();
StackValueCollection* expressions = cvf->expressions(); StackValueCollection* expressions = cvf->expressions();
if (expressions != NULL) { if (expressions != nullptr) {
for (int i2 = 0; i2 < expressions->size(); i2++) { for (int i2 = 0; i2 < expressions->size(); i2++) {
StackValue* var = expressions->at(i2); StackValue* var = expressions->at(i2);
if (var->type() == T_OBJECT && scopeExpressions->at(i2)->is_object()) { if (var->type() == T_OBJECT && scopeExpressions->at(i2)->is_object()) {
@ -1637,7 +1637,7 @@ C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv* env, jobject, jobject _hs_
GrowableArray<MonitorValue*>* scopeMonitors = cvf->scope()->monitors(); GrowableArray<MonitorValue*>* scopeMonitors = cvf->scope()->monitors();
GrowableArray<MonitorInfo*>* monitors = cvf->monitors(); GrowableArray<MonitorInfo*>* monitors = cvf->monitors();
if (monitors != NULL) { if (monitors != nullptr) {
for (int i2 = 0; i2 < monitors->length(); i2++) { for (int i2 = 0; i2 < monitors->length(); i2++) {
cvf->update_monitor(i2, monitors->at(i2)); cvf->update_monitor(i2, monitors->at(i2));
} }
@ -1645,7 +1645,7 @@ C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv* env, jobject, jobject _hs_
} }
// all locals are materialized by now // all locals are materialized by now
JVMCIENV->set_HotSpotStackFrameReference_localIsVirtual(hs_frame, NULL); JVMCIENV->set_HotSpotStackFrameReference_localIsVirtual(hs_frame, nullptr);
// update the locals array // update the locals array
JVMCIObjectArray array = JVMCIENV->get_HotSpotStackFrameReference_locals(hs_frame); JVMCIObjectArray array = JVMCIENV->get_HotSpotStackFrameReference_locals(hs_frame);
StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals(); StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals();
@ -1736,7 +1736,7 @@ C2V_VMENTRY_NULL(jobject, getComponentType, (JNIEnv* env, jobject, ARGUMENT_PAIR
} }
Klass* component_klass = java_lang_Class::as_Klass(component_mirror); Klass* component_klass = java_lang_Class::as_Klass(component_mirror);
if (component_klass != NULL) { if (component_klass != nullptr) {
JVMCIKlassHandle klass_handle(THREAD, component_klass); JVMCIKlassHandle klass_handle(THREAD, component_klass);
JVMCIObject result = JVMCIENV->get_jvmci_type(klass_handle, JVMCI_CHECK_NULL); JVMCIObject result = JVMCIENV->get_jvmci_type(klass_handle, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result); return JVMCIENV->get_jobject(result);
@ -1769,7 +1769,7 @@ C2V_VMENTRY(void, ensureLinked, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass)))
C2V_END C2V_END
C2V_VMENTRY_0(jint, interpreterFrameSize, (JNIEnv* env, jobject, jobject bytecode_frame_handle)) C2V_VMENTRY_0(jint, interpreterFrameSize, (JNIEnv* env, jobject, jobject bytecode_frame_handle))
if (bytecode_frame_handle == NULL) { if (bytecode_frame_handle == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
@ -1828,38 +1828,38 @@ C2V_VMENTRY_0(jboolean, isInternedString, (JNIEnv* env, jobject, jobject object)
} }
int len; int len;
jchar* name = java_lang_String::as_unicode_string(str(), len, CHECK_false); jchar* name = java_lang_String::as_unicode_string(str(), len, CHECK_false);
return (StringTable::lookup(name, len) != NULL); return (StringTable::lookup(name, len) != nullptr);
C2V_END C2V_END
C2V_VMENTRY_NULL(jobject, unboxPrimitive, (JNIEnv* env, jobject, jobject object)) C2V_VMENTRY_NULL(jobject, unboxPrimitive, (JNIEnv* env, jobject, jobject object))
if (object == NULL) { if (object == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
Handle box = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL); Handle box = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
BasicType type = java_lang_boxing_object::basic_type(box()); BasicType type = java_lang_boxing_object::basic_type(box());
jvalue result; jvalue result;
if (java_lang_boxing_object::get_value(box(), &result) == T_ILLEGAL) { if (java_lang_boxing_object::get_value(box(), &result) == T_ILLEGAL) {
return NULL; return nullptr;
} }
JVMCIObject boxResult = JVMCIENV->create_box(type, &result, JVMCI_CHECK_NULL); JVMCIObject boxResult = JVMCIENV->create_box(type, &result, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(boxResult); return JVMCIENV->get_jobject(boxResult);
C2V_END C2V_END
C2V_VMENTRY_NULL(jobject, boxPrimitive, (JNIEnv* env, jobject, jobject object)) C2V_VMENTRY_NULL(jobject, boxPrimitive, (JNIEnv* env, jobject, jobject object))
if (object == NULL) { if (object == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
JVMCIObject box = JVMCIENV->wrap(object); JVMCIObject box = JVMCIENV->wrap(object);
BasicType type = JVMCIENV->get_box_type(box); BasicType type = JVMCIENV->get_box_type(box);
if (type == T_ILLEGAL) { if (type == T_ILLEGAL) {
return NULL; return nullptr;
} }
jvalue value = JVMCIENV->get_boxed_value(type, box); jvalue value = JVMCIENV->get_boxed_value(type, box);
JavaValue box_result(T_OBJECT); JavaValue box_result(T_OBJECT);
JavaCallArguments jargs; JavaCallArguments jargs;
Klass* box_klass = NULL; Klass* box_klass = nullptr;
Symbol* box_signature = NULL; Symbol* box_signature = nullptr;
#define BOX_CASE(bt, v, argtype, name) \ #define BOX_CASE(bt, v, argtype, name) \
case bt: \ case bt: \
jargs.push_##argtype(value.v); \ jargs.push_##argtype(value.v); \
@ -2056,7 +2056,7 @@ C2V_VMENTRY_NULL(jobject, readFieldValue, (JNIEnv* env, jobject, jobject object,
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
// asConstant will throw an NPE if a constant contains NULL // asConstant will throw an NPE if a constant contains null
Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL); Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
Klass* expected_klass = UNPACK_PAIR(Klass, expected_type); Klass* expected_klass = UNPACK_PAIR(Klass, expected_type);
@ -2073,7 +2073,7 @@ C2V_END
C2V_VMENTRY_0(jboolean, isInstance, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jobject object)) C2V_VMENTRY_0(jboolean, isInstance, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jobject object))
Klass* klass = UNPACK_PAIR(Klass, klass); Klass* klass = UNPACK_PAIR(Klass, klass);
if (object == NULL || klass == nullptr) { if (object == nullptr || klass == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0); Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0);
@ -2102,7 +2102,7 @@ C2V_VMENTRY_0(jboolean, isTrustedForIntrinsics, (JNIEnv* env, jobject, ARGUMENT_
C2V_END C2V_END
C2V_VMENTRY_NULL(jobject, asJavaType, (JNIEnv* env, jobject, jobject object)) C2V_VMENTRY_NULL(jobject, asJavaType, (JNIEnv* env, jobject, jobject object))
if (object == NULL) { if (object == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL); Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
@ -2117,12 +2117,12 @@ C2V_VMENTRY_NULL(jobject, asJavaType, (JNIEnv* env, jobject, jobject object))
JVMCIObject type = JVMCIENV->get_jvmci_type(klass_handle, JVMCI_CHECK_NULL); JVMCIObject type = JVMCIENV->get_jvmci_type(klass_handle, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(type); return JVMCIENV->get_jobject(type);
} }
return NULL; return nullptr;
C2V_END C2V_END
C2V_VMENTRY_NULL(jobject, asString, (JNIEnv* env, jobject, jobject object)) C2V_VMENTRY_NULL(jobject, asString, (JNIEnv* env, jobject, jobject object))
if (object == NULL) { if (object == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL); Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
@ -2133,7 +2133,7 @@ C2V_END
C2V_VMENTRY_0(jboolean, equals, (JNIEnv* env, jobject, jobject x, jlong xHandle, jobject y, jlong yHandle)) C2V_VMENTRY_0(jboolean, equals, (JNIEnv* env, jobject, jobject x, jlong xHandle, jobject y, jlong yHandle))
if (x == NULL || y == NULL) { if (x == nullptr || y == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
return JVMCIENV->resolve_oop_handle(xHandle) == JVMCIENV->resolve_oop_handle(yHandle); return JVMCIENV->resolve_oop_handle(xHandle) == JVMCIENV->resolve_oop_handle(yHandle);
@ -2151,7 +2151,7 @@ C2V_END
C2V_VMENTRY_0(jint, getArrayLength, (JNIEnv* env, jobject, jobject x)) C2V_VMENTRY_0(jint, getArrayLength, (JNIEnv* env, jobject, jobject x))
if (x == NULL) { if (x == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0); Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
@ -2163,7 +2163,7 @@ C2V_VMENTRY_0(jint, getArrayLength, (JNIEnv* env, jobject, jobject x))
C2V_VMENTRY_NULL(jobject, readArrayElement, (JNIEnv* env, jobject, jobject x, int index)) C2V_VMENTRY_NULL(jobject, readArrayElement, (JNIEnv* env, jobject, jobject x, int index))
if (x == NULL) { if (x == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_NULL); Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_NULL);
@ -2171,7 +2171,7 @@ C2V_VMENTRY_NULL(jobject, readArrayElement, (JNIEnv* env, jobject, jobject x, in
arrayOop array = arrayOop(xobj()); arrayOop array = arrayOop(xobj());
BasicType element_type = ArrayKlass::cast(array->klass())->element_type(); BasicType element_type = ArrayKlass::cast(array->klass())->element_type();
if (index < 0 || index >= array->length()) { if (index < 0 || index >= array->length()) {
return NULL; return nullptr;
} }
JVMCIObject result; JVMCIObject result;
@ -2198,7 +2198,7 @@ C2V_VMENTRY_NULL(jobject, readArrayElement, (JNIEnv* env, jobject, jobject x, in
assert(!result.is_null(), "must have a value"); assert(!result.is_null(), "must have a value");
return JVMCIENV->get_jobject(result); return JVMCIENV->get_jobject(result);
} }
return NULL;; return nullptr;;
C2V_END C2V_END
@ -2238,16 +2238,16 @@ C2V_VMENTRY_NULL(jlongArray, registerNativeMethods, (JNIEnv* env, jobject, jclas
peerEnv->describe_pending_exception(true); peerEnv->describe_pending_exception(true);
} }
sl_handle = JVMCI::get_shared_library(sl_path, false); sl_handle = JVMCI::get_shared_library(sl_path, false);
if (sl_handle == NULL) { if (sl_handle == nullptr) {
JVMCI_THROW_MSG_0(InternalError, err_msg("Error initializing JVMCI runtime %d", runtime->id())); JVMCI_THROW_MSG_0(InternalError, err_msg("Error initializing JVMCI runtime %d", runtime->id()));
} }
} }
if (mirror == NULL) { if (mirror == nullptr) {
JVMCI_THROW_0(NullPointerException); JVMCI_THROW_0(NullPointerException);
} }
Klass* klass = java_lang_Class::as_Klass(JNIHandles::resolve(mirror)); Klass* klass = java_lang_Class::as_Klass(JNIHandles::resolve(mirror));
if (klass == NULL || !klass->is_instance_klass()) { if (klass == nullptr || !klass->is_instance_klass()) {
JVMCI_THROW_MSG_0(IllegalArgumentException, "clazz is for primitive type"); JVMCI_THROW_MSG_0(IllegalArgumentException, "clazz is for primitive type");
} }
@ -2264,25 +2264,25 @@ C2V_VMENTRY_NULL(jlongArray, registerNativeMethods, (JNIEnv* env, jobject, jclas
// 1) Try JNI short style // 1) Try JNI short style
stringStream st; stringStream st;
char* pure_name = NativeLookup::pure_jni_name(method); char* pure_name = NativeLookup::pure_jni_name(method);
guarantee(pure_name != NULL, "Illegal native method name encountered"); guarantee(pure_name != nullptr, "Illegal native method name encountered");
os::print_jni_name_prefix_on(&st, args_size); os::print_jni_name_prefix_on(&st, args_size);
st.print_raw(pure_name); st.print_raw(pure_name);
os::print_jni_name_suffix_on(&st, args_size); os::print_jni_name_suffix_on(&st, args_size);
char* jni_name = st.as_string(); char* jni_name = st.as_string();
address entry = (address) os::dll_lookup(sl_handle, jni_name); address entry = (address) os::dll_lookup(sl_handle, jni_name);
if (entry == NULL) { if (entry == nullptr) {
// 2) Try JNI long style // 2) Try JNI long style
st.reset(); st.reset();
char* long_name = NativeLookup::long_jni_name(method); char* long_name = NativeLookup::long_jni_name(method);
guarantee(long_name != NULL, "Illegal native method name encountered"); guarantee(long_name != nullptr, "Illegal native method name encountered");
os::print_jni_name_prefix_on(&st, args_size); os::print_jni_name_prefix_on(&st, args_size);
st.print_raw(pure_name); st.print_raw(pure_name);
st.print_raw(long_name); st.print_raw(long_name);
os::print_jni_name_suffix_on(&st, args_size); os::print_jni_name_suffix_on(&st, args_size);
char* jni_long_name = st.as_string(); char* jni_long_name = st.as_string();
entry = (address) os::dll_lookup(sl_handle, jni_long_name); entry = (address) os::dll_lookup(sl_handle, jni_long_name);
if (entry == NULL) { if (entry == nullptr) {
JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("%s [neither %s nor %s exist in %s]", JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("%s [neither %s nor %s exist in %s]",
method->name_and_sig_as_C_string(), method->name_and_sig_as_C_string(),
jni_name, jni_long_name, sl_path)); jni_name, jni_long_name, sl_path));
@ -2327,7 +2327,7 @@ C2V_VMENTRY_PREFIX(jboolean, isCurrentThreadAttached, (JNIEnv* env, jobject c2vm
C2V_END C2V_END
C2V_VMENTRY_PREFIX(jlong, getCurrentJavaThread, (JNIEnv* env, jobject c2vm)) C2V_VMENTRY_PREFIX(jlong, getCurrentJavaThread, (JNIEnv* env, jobject c2vm))
if (thread == NULL) { if (thread == nullptr) {
// Called from unattached JVMCI shared library thread // Called from unattached JVMCI shared library thread
return 0L; return 0L;
} }
@ -2486,7 +2486,7 @@ C2V_END
C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle, jboolean callPostTranslation)) C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle, jboolean callPostTranslation))
requireJVMCINativeLibrary(JVMCI_CHECK_0); requireJVMCINativeLibrary(JVMCI_CHECK_0);
if (obj_handle == NULL) { if (obj_handle == nullptr) {
return 0L; return 0L;
} }
JVMCIEnv __peer_jvmci_env__(thread, !JVMCIENV->is_hotspot(), __FILE__, __LINE__); JVMCIEnv __peer_jvmci_env__(thread, !JVMCIENV->is_hotspot(), __FILE__, __LINE__);
@ -2513,13 +2513,13 @@ C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle, jbool
} else if (thisEnv->isa_HotSpotNmethod(obj)) { } else if (thisEnv->isa_HotSpotNmethod(obj)) {
if (peerEnv->is_hotspot()) { if (peerEnv->is_hotspot()) {
nmethod* nm = JVMCIENV->get_nmethod(obj); nmethod* nm = JVMCIENV->get_nmethod(obj);
if (nm != NULL) { if (nm != nullptr) {
JVMCINMethodData* data = nm->jvmci_nmethod_data(); JVMCINMethodData* data = nm->jvmci_nmethod_data();
if (data != NULL) { if (data != nullptr) {
// Only the mirror in the HotSpot heap is accessible // Only the mirror in the HotSpot heap is accessible
// through JVMCINMethodData // through JVMCINMethodData
oop nmethod_mirror = data->get_nmethod_mirror(nm, /* phantom_ref */ true); oop nmethod_mirror = data->get_nmethod_mirror(nm, /* phantom_ref */ true);
if (nmethod_mirror != NULL) { if (nmethod_mirror != nullptr) {
result = HotSpotJVMCI::wrap(nmethod_mirror); result = HotSpotJVMCI::wrap(nmethod_mirror);
} }
} }
@ -2532,13 +2532,13 @@ C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle, jbool
jboolean isDefault = thisEnv->get_HotSpotNmethod_isDefault(obj); jboolean isDefault = thisEnv->get_HotSpotNmethod_isDefault(obj);
jlong compileIdSnapshot = thisEnv->get_HotSpotNmethod_compileIdSnapshot(obj); jlong compileIdSnapshot = thisEnv->get_HotSpotNmethod_compileIdSnapshot(obj);
JVMCIObject name_string = thisEnv->get_InstalledCode_name(obj); JVMCIObject name_string = thisEnv->get_InstalledCode_name(obj);
const char* cstring = name_string.is_null() ? NULL : thisEnv->as_utf8_string(name_string); const char* cstring = name_string.is_null() ? nullptr : thisEnv->as_utf8_string(name_string);
// Create a new HotSpotNmethod instance in the peer runtime // Create a new HotSpotNmethod instance in the peer runtime
result = peerEnv->new_HotSpotNmethod(mh, cstring, isDefault, compileIdSnapshot, JVMCI_CHECK_0); result = peerEnv->new_HotSpotNmethod(mh, cstring, isDefault, compileIdSnapshot, JVMCI_CHECK_0);
nmethod* nm = JVMCIENV->get_nmethod(obj); nmethod* nm = JVMCIENV->get_nmethod(obj);
if (result.is_null()) { if (result.is_null()) {
// exception occurred (e.g. OOME) creating a new HotSpotNmethod // exception occurred (e.g. OOME) creating a new HotSpotNmethod
} else if (nm == NULL) { } else if (nm == nullptr) {
// nmethod must have been unloaded // nmethod must have been unloaded
} else { } else {
// Link the new HotSpotNmethod to the nmethod // Link the new HotSpotNmethod to the nmethod
@ -2546,10 +2546,10 @@ C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle, jbool
// Only HotSpotNmethod instances in the HotSpot heap are tracked directly by the runtime. // Only HotSpotNmethod instances in the HotSpot heap are tracked directly by the runtime.
if (peerEnv->is_hotspot()) { if (peerEnv->is_hotspot()) {
JVMCINMethodData* data = nm->jvmci_nmethod_data(); JVMCINMethodData* data = nm->jvmci_nmethod_data();
if (data == NULL) { if (data == nullptr) {
JVMCI_THROW_MSG_0(IllegalArgumentException, "Cannot set HotSpotNmethod mirror for default nmethod"); JVMCI_THROW_MSG_0(IllegalArgumentException, "Cannot set HotSpotNmethod mirror for default nmethod");
} }
if (data->get_nmethod_mirror(nm, /* phantom_ref */ false) != NULL) { if (data->get_nmethod_mirror(nm, /* phantom_ref */ false) != nullptr) {
JVMCI_THROW_MSG_0(IllegalArgumentException, "Cannot overwrite existing HotSpotNmethod mirror for nmethod"); JVMCI_THROW_MSG_0(IllegalArgumentException, "Cannot overwrite existing HotSpotNmethod mirror for nmethod");
} }
oop nmethod_mirror = HotSpotJVMCI::resolve(result); oop nmethod_mirror = HotSpotJVMCI::resolve(result);
@ -2574,7 +2574,7 @@ C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle, jbool
C2V_VMENTRY_NULL(jobject, unhand, (JNIEnv* env, jobject, jlong obj_handle)) C2V_VMENTRY_NULL(jobject, unhand, (JNIEnv* env, jobject, jlong obj_handle))
requireJVMCINativeLibrary(JVMCI_CHECK_NULL); requireJVMCINativeLibrary(JVMCI_CHECK_NULL);
if (obj_handle == 0L) { if (obj_handle == 0L) {
return NULL; return nullptr;
} }
jobject global_handle = (jobject) obj_handle; jobject global_handle = (jobject) obj_handle;
JVMCIObject global_handle_obj = JVMCIENV->wrap(global_handle); JVMCIObject global_handle_obj = JVMCIENV->wrap(global_handle);
@ -2593,8 +2593,8 @@ C2V_VMENTRY(void, updateHotSpotNmethod, (JNIEnv* env, jobject, jobject code_hand
C2V_VMENTRY_NULL(jbyteArray, getCode, (JNIEnv* env, jobject, jobject code_handle)) C2V_VMENTRY_NULL(jbyteArray, getCode, (JNIEnv* env, jobject, jobject code_handle))
JVMCIObject code = JVMCIENV->wrap(code_handle); JVMCIObject code = JVMCIENV->wrap(code_handle);
CodeBlob* cb = JVMCIENV->get_code_blob(code); CodeBlob* cb = JVMCIENV->get_code_blob(code);
if (cb == NULL) { if (cb == nullptr) {
return NULL; return nullptr;
} }
// Make a resource copy of code before the allocation causes a safepoint // Make a resource copy of code before the allocation causes a safepoint
int code_size = cb->code_size(); int code_size = cb->code_size();
@ -2643,12 +2643,12 @@ C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, ARGUMENT_PAI
C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current)) C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current))
FailedSpeculation* head = *((FailedSpeculation**)(address) failed_speculations_address); FailedSpeculation* head = *((FailedSpeculation**)(address) failed_speculations_address);
int result_length = 0; int result_length = 0;
for (FailedSpeculation* fs = head; fs != NULL; fs = fs->next()) { for (FailedSpeculation* fs = head; fs != nullptr; fs = fs->next()) {
result_length++; result_length++;
} }
int current_length = 0; int current_length = 0;
JVMCIObjectArray current_array = NULL; JVMCIObjectArray current_array = nullptr;
if (current != NULL) { if (current != nullptr) {
current_array = JVMCIENV->wrap(current); current_array = JVMCIENV->wrap(current);
current_length = JVMCIENV->get_length(current_array); current_length = JVMCIENV->get_length(current_array);
if (current_length == result_length) { if (current_length == result_length) {
@ -2659,7 +2659,7 @@ C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlo
JVMCIObjectArray result = JVMCIENV->new_byte_array_array(result_length, JVMCI_CHECK_NULL); JVMCIObjectArray result = JVMCIENV->new_byte_array_array(result_length, JVMCI_CHECK_NULL);
int result_index = 0; int result_index = 0;
for (FailedSpeculation* fs = head; result_index < result_length; fs = fs->next()) { for (FailedSpeculation* fs = head; result_index < result_length; fs = fs->next()) {
assert(fs != NULL, "npe"); assert(fs != nullptr, "npe");
JVMCIPrimitiveArray entry; JVMCIPrimitiveArray entry;
if (result_index < current_length) { if (result_index < current_length) {
entry = (JVMCIPrimitiveArray) JVMCIENV->get_object_at(current_array, result_index); entry = (JVMCIPrimitiveArray) JVMCIENV->get_object_at(current_array, result_index);
@ -2675,7 +2675,7 @@ C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlo
C2V_VMENTRY_0(jlong, getFailedSpeculationsAddress, (JNIEnv* env, jobject, ARGUMENT_PAIR(method))) C2V_VMENTRY_0(jlong, getFailedSpeculationsAddress, (JNIEnv* env, jobject, ARGUMENT_PAIR(method)))
methodHandle method(THREAD, UNPACK_PAIR(Method, method)); methodHandle method(THREAD, UNPACK_PAIR(Method, method));
MethodData* method_data = method->method_data(); MethodData* method_data = method->method_data();
if (method_data == NULL) { if (method_data == nullptr) {
ClassLoaderData* loader_data = method->method_holder()->class_loader_data(); ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
method_data = MethodData::allocate(loader_data, method, CHECK_0); method_data = MethodData::allocate(loader_data, method, CHECK_0);
method->set_method_data(method_data); method->set_method_data(method_data);
@ -2692,7 +2692,7 @@ C2V_VMENTRY_0(jboolean, addFailedSpeculation, (JNIEnv* env, jobject, jlong faile
int speculation_len = JVMCIENV->get_length(speculation_handle); int speculation_len = JVMCIENV->get_length(speculation_handle);
char* speculation = NEW_RESOURCE_ARRAY(char, speculation_len); char* speculation = NEW_RESOURCE_ARRAY(char, speculation_len);
JVMCIENV->copy_bytes_to(speculation_handle, (jbyte*) speculation, 0, speculation_len); JVMCIENV->copy_bytes_to(speculation_handle, (jbyte*) speculation, 0, speculation_len);
return FailedSpeculation::add_failed_speculation(NULL, (FailedSpeculation**)(address) failed_speculations_address, (address) speculation, speculation_len); return FailedSpeculation::add_failed_speculation(nullptr, (FailedSpeculation**)(address) failed_speculations_address, (address) speculation, speculation_len);
} }
C2V_VMENTRY(void, callSystemExit, (JNIEnv* env, jobject, jint status)) C2V_VMENTRY(void, callSystemExit, (JNIEnv* env, jobject, jint status))

16
src/hotspot/share/jvmci/jvmciCompilerToVMInit.cpp
View File

@ -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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -140,7 +140,7 @@ void CompilerToVM::Data::initialize(JVMCI_TRAPS) {
BarrierSet* bs = BarrierSet::barrier_set(); BarrierSet* bs = BarrierSet::barrier_set();
if (bs->is_a(BarrierSet::CardTableBarrierSet)) { if (bs->is_a(BarrierSet::CardTableBarrierSet)) {
CardTable::CardValue* base = ci_card_table_address(); CardTable::CardValue* base = ci_card_table_address();
assert(base != NULL, "unexpected byte_map_base"); assert(base != nullptr, "unexpected byte_map_base");
cardtable_start_address = base; cardtable_start_address = base;
cardtable_shift = CardTable::card_shift(); cardtable_shift = CardTable::card_shift();
} else { } else {
@ -152,7 +152,7 @@ void CompilerToVM::Data::initialize(JVMCI_TRAPS) {
vm_page_size = os::vm_page_size(); vm_page_size = os::vm_page_size();
#define SET_TRIGFUNC(name) \ #define SET_TRIGFUNC(name) \
if (StubRoutines::name() != NULL) { \ if (StubRoutines::name() != nullptr) { \
name = StubRoutines::name(); \ name = StubRoutines::name(); \
} else { \ } else { \
name = CAST_FROM_FN_PTR(address, SharedRuntime::name); \ name = CAST_FROM_FN_PTR(address, SharedRuntime::name); \
@ -263,7 +263,7 @@ JVMCIObjectArray CompilerToVM::initialize_intrinsics(JVMCI_TRAPS) {
do { \ do { \
jvalue p; p.j = (jlong) (value); \ jvalue p; p.j = (jlong) (value); \
JVMCIObject* e = longs.get(p.j); \ JVMCIObject* e = longs.get(p.j); \
if (e == NULL) { \ if (e == nullptr) { \
JVMCIObject h = JVMCIENV->create_box(T_LONG, &p, JVMCI_CHECK_NULL); \ JVMCIObject h = JVMCIENV->create_box(T_LONG, &p, JVMCI_CHECK_NULL); \
longs.put(p.j, h); \ longs.put(p.j, h); \
name = h; \ name = h; \
@ -275,9 +275,9 @@ JVMCIObjectArray CompilerToVM::initialize_intrinsics(JVMCI_TRAPS) {
#define CSTRING_TO_JSTRING(name, value) \ #define CSTRING_TO_JSTRING(name, value) \
JVMCIObject name; \ JVMCIObject name; \
do { \ do { \
if (value != NULL) { \ if (value != nullptr) { \
JVMCIObject* e = strings.get(value); \ JVMCIObject* e = strings.get(value); \
if (e == NULL) { \ if (e == nullptr) { \
JVMCIObject h = JVMCIENV->create_string(value, JVMCI_CHECK_NULL); \ JVMCIObject h = JVMCIENV->create_string(value, JVMCI_CHECK_NULL); \
strings.put(value, h); \ strings.put(value, h); \
name = h; \ name = h; \
@ -314,7 +314,7 @@ jobjectArray readConfiguration0(JNIEnv *env, JVMCI_TRAPS) {
CSTRING_TO_JSTRING(name, name_buf); CSTRING_TO_JSTRING(name, name_buf);
CSTRING_TO_JSTRING(type, vmField.typeString); CSTRING_TO_JSTRING(type, vmField.typeString);
JVMCIObject box; JVMCIObject box;
if (vmField.isStatic && vmField.typeString != NULL) { if (vmField.isStatic && vmField.typeString != nullptr) {
if (strcmp(vmField.typeString, "bool") == 0) { if (strcmp(vmField.typeString, "bool") == 0) {
BOXED_BOOLEAN(box, *(jbyte*) vmField.address); BOXED_BOOLEAN(box, *(jbyte*) vmField.address);
assert(box.is_non_null(), "must have a box"); assert(box.is_non_null(), "must have a box");
@ -381,7 +381,7 @@ jobjectArray readConfiguration0(JNIEnv *env, JVMCI_TRAPS) {
#ifdef ASSERT #ifdef ASSERT
#define CHECK_FLAG(type, name) { \ #define CHECK_FLAG(type, name) { \
const JVMFlag* flag = JVMFlag::find_declared_flag(#name); \ const JVMFlag* flag = JVMFlag::find_declared_flag(#name); \
assert(flag != NULL, "No such flag named " #name); \ assert(flag != nullptr, "No such flag named " #name); \
assert(flag->is_##type(), "JVMFlag " #name " is not of type " #type); \ assert(flag->is_##type(), "JVMFlag " #name " is not of type " #type); \
} }
#else #else

96
src/hotspot/share/jvmci/jvmciEnv.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 1999, 2022, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1999, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -52,7 +52,7 @@ JVMCICompileState::JVMCICompileState(CompileTask* task, JVMCICompiler* compiler)
_task(task), _task(task),
_compiler(compiler), _compiler(compiler),
_retryable(true), _retryable(true),
_failure_reason(NULL), _failure_reason(nullptr),
_failure_reason_on_C_heap(false) { _failure_reason_on_C_heap(false) {
// Get Jvmti capabilities under lock to get consistent values. // Get Jvmti capabilities under lock to get consistent values.
MutexLocker mu(JvmtiThreadState_lock); MutexLocker mu(JvmtiThreadState_lock);
@ -61,7 +61,7 @@ JVMCICompileState::JVMCICompileState(CompileTask* task, JVMCICompiler* compiler)
_jvmti_can_access_local_variables = JvmtiExport::can_access_local_variables() ? 1 : 0; _jvmti_can_access_local_variables = JvmtiExport::can_access_local_variables() ? 1 : 0;
_jvmti_can_post_on_exceptions = JvmtiExport::can_post_on_exceptions() ? 1 : 0; _jvmti_can_post_on_exceptions = JvmtiExport::can_post_on_exceptions() ? 1 : 0;
_jvmti_can_pop_frame = JvmtiExport::can_pop_frame() ? 1 : 0; _jvmti_can_pop_frame = JvmtiExport::can_pop_frame() ? 1 : 0;
_target_method_is_old = _task != NULL && _task->method()->is_old(); _target_method_is_old = _task != nullptr && _task->method()->is_old();
if (task->is_blocking()) { if (task->is_blocking()) {
task->set_blocking_jvmci_compile_state(this); task->set_blocking_jvmci_compile_state(this);
} }
@ -173,8 +173,8 @@ void JVMCIEnv::copy_saved_properties(jbyte* properties, int properties_len, JVMC
} }
void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env, bool attach_OOME_is_fatal) { void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env, bool attach_OOME_is_fatal) {
assert(thread != NULL, "npe"); assert(thread != nullptr, "npe");
_env = NULL; _env = nullptr;
_pop_frame_on_close = false; _pop_frame_on_close = false;
_detach_on_close = false; _detach_on_close = false;
if (!UseJVMCINativeLibrary) { if (!UseJVMCINativeLibrary) {
@ -184,7 +184,7 @@ void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env, boo
return; return;
} }
if (parent_env != NULL) { if (parent_env != nullptr) {
// If the parent JNI environment is non-null then figure out whether it // If the parent JNI environment is non-null then figure out whether it
// is a HotSpot or shared library JNIEnv and set the state appropriately. // is a HotSpot or shared library JNIEnv and set the state appropriately.
_is_hotspot = thread->jni_environment() == parent_env; _is_hotspot = thread->jni_environment() == parent_env;
@ -194,7 +194,7 @@ void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env, boo
return; return;
} }
_runtime = thread->libjvmci_runtime(); _runtime = thread->libjvmci_runtime();
assert(_runtime != NULL, "npe"); assert(_runtime != nullptr, "npe");
_env = parent_env; _env = parent_env;
return; return;
} }
@ -206,12 +206,12 @@ void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env, boo
_runtime = JVMCI::compiler_runtime(thread); _runtime = JVMCI::compiler_runtime(thread);
_env = _runtime->init_shared_library_javavm(); _env = _runtime->init_shared_library_javavm();
if (_env != NULL) { if (_env != nullptr) {
// Creating the JVMCI shared library VM also attaches the current thread // Creating the JVMCI shared library VM also attaches the current thread
_detach_on_close = true; _detach_on_close = true;
} else { } else {
_runtime->GetEnv(thread, (void**)&parent_env, JNI_VERSION_1_2); _runtime->GetEnv(thread, (void**)&parent_env, JNI_VERSION_1_2);
if (parent_env != NULL) { if (parent_env != nullptr) {
// Even though there's a parent JNI env, there's no guarantee // Even though there's a parent JNI env, there's no guarantee
// it was opened by a JVMCIEnv scope and thus may not have // it was opened by a JVMCIEnv scope and thus may not have
// pushed a local JNI frame. As such, we use a new JNI local // pushed a local JNI frame. As such, we use a new JNI local
@ -223,12 +223,12 @@ void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env, boo
JavaVMAttachArgs attach_args; JavaVMAttachArgs attach_args;
attach_args.version = JNI_VERSION_1_2; attach_args.version = JNI_VERSION_1_2;
attach_args.name = const_cast<char*>(thread->name()); attach_args.name = const_cast<char*>(thread->name());
attach_args.group = NULL; attach_args.group = nullptr;
jint attach_result = _runtime->AttachCurrentThread(thread, (void**) &_env, &attach_args); jint attach_result = _runtime->AttachCurrentThread(thread, (void**) &_env, &attach_args);
if (attach_result == JNI_OK) { if (attach_result == JNI_OK) {
_detach_on_close = true; _detach_on_close = true;
} else if (!attach_OOME_is_fatal && attach_result == JNI_ENOMEM) { } else if (!attach_OOME_is_fatal && attach_result == JNI_ENOMEM) {
_env = NULL; _env = nullptr;
_attach_threw_OOME = true; _attach_threw_OOME = true;
return; return;
} else { } else {
@ -237,7 +237,7 @@ void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env, boo
} }
} }
assert(_env != NULL, "missing env"); assert(_env != nullptr, "missing env");
assert(_throw_to_caller == false, "must be"); assert(_throw_to_caller == false, "must be");
JNIAccessMark jni(this, thread); JNIAccessMark jni(this, thread);
@ -254,37 +254,37 @@ JVMCIEnv::JVMCIEnv(JavaThread* thread, JVMCICompileState* compile_state, const c
_throw_to_caller(false), _file(file), _line(line), _attach_threw_OOME(false), _compile_state(compile_state) { _throw_to_caller(false), _file(file), _line(line), _attach_threw_OOME(false), _compile_state(compile_state) {
// In case of OOME, there's a good chance a subsequent attempt to attach might succeed. // In case of OOME, there's a good chance a subsequent attempt to attach might succeed.
// Other errors most likely indicate a non-recoverable error in the JVMCI runtime. // Other errors most likely indicate a non-recoverable error in the JVMCI runtime.
init_env_mode_runtime(thread, NULL, false); init_env_mode_runtime(thread, nullptr, false);
if (_attach_threw_OOME) { if (_attach_threw_OOME) {
compile_state->set_failure(true, "Out of memory while attaching JVMCI compiler to current thread"); compile_state->set_failure(true, "Out of memory while attaching JVMCI compiler to current thread");
} }
} }
JVMCIEnv::JVMCIEnv(JavaThread* thread, const char* file, int line): JVMCIEnv::JVMCIEnv(JavaThread* thread, const char* file, int line):
_throw_to_caller(false), _file(file), _line(line), _attach_threw_OOME(false), _compile_state(NULL) { _throw_to_caller(false), _file(file), _line(line), _attach_threw_OOME(false), _compile_state(nullptr) {
init_env_mode_runtime(thread, NULL); init_env_mode_runtime(thread, nullptr);
} }
JVMCIEnv::JVMCIEnv(JavaThread* thread, JNIEnv* parent_env, const char* file, int line): JVMCIEnv::JVMCIEnv(JavaThread* thread, JNIEnv* parent_env, const char* file, int line):
_throw_to_caller(true), _file(file), _line(line), _attach_threw_OOME(false), _compile_state(NULL) { _throw_to_caller(true), _file(file), _line(line), _attach_threw_OOME(false), _compile_state(nullptr) {
init_env_mode_runtime(thread, parent_env); init_env_mode_runtime(thread, parent_env);
assert(_env == NULL || parent_env == _env, "mismatched JNIEnvironment"); assert(_env == nullptr || parent_env == _env, "mismatched JNIEnvironment");
} }
void JVMCIEnv::init(JavaThread* thread, bool is_hotspot, const char* file, int line) { void JVMCIEnv::init(JavaThread* thread, bool is_hotspot, const char* file, int line) {
_compile_state = NULL; _compile_state = nullptr;
_throw_to_caller = false; _throw_to_caller = false;
_file = file; _file = file;
_line = line; _line = line;
_attach_threw_OOME = false; _attach_threw_OOME = false;
if (is_hotspot) { if (is_hotspot) {
_env = NULL; _env = nullptr;
_pop_frame_on_close = false; _pop_frame_on_close = false;
_detach_on_close = false; _detach_on_close = false;
_is_hotspot = true; _is_hotspot = true;
_runtime = JVMCI::java_runtime(); _runtime = JVMCI::java_runtime();
} else { } else {
init_env_mode_runtime(thread, NULL); init_env_mode_runtime(thread, nullptr);
} }
} }
@ -294,9 +294,9 @@ void JVMCIEnv::describe_pending_exception(bool clear) {
if (!is_hotspot()) { if (!is_hotspot()) {
JNIAccessMark jni(this, THREAD); JNIAccessMark jni(this, THREAD);
if (jni()->ExceptionCheck()) { if (jni()->ExceptionCheck()) {
jthrowable ex = !clear ? jni()->ExceptionOccurred() : NULL; jthrowable ex = !clear ? jni()->ExceptionOccurred() : nullptr;
jni()->ExceptionDescribe(); jni()->ExceptionDescribe();
if (ex != NULL) { if (ex != nullptr) {
jni()->Throw(ex); jni()->Throw(ex);
} }
} }
@ -310,8 +310,8 @@ void JVMCIEnv::describe_pending_exception(bool clear) {
// Shared code for translating an exception from HotSpot to libjvmci or vice versa. // Shared code for translating an exception from HotSpot to libjvmci or vice versa.
class ExceptionTranslation: public StackObj { class ExceptionTranslation: public StackObj {
protected: protected:
JVMCIEnv* _from_env; // Source of translation. Can be nullptr. JVMCIEnv* _from_env; // Source of translation. Can be null.
JVMCIEnv* _to_env; // Destination of translation. Never nullptr. JVMCIEnv* _to_env; // Destination of translation. Never null.
ExceptionTranslation(JVMCIEnv* from_env, JVMCIEnv* to_env) : _from_env(from_env), _to_env(to_env) {} ExceptionTranslation(JVMCIEnv* from_env, JVMCIEnv* to_env) : _from_env(from_env), _to_env(to_env) {}
@ -484,7 +484,7 @@ JVMCIEnv::~JVMCIEnv() {
if (_pop_frame_on_close) { if (_pop_frame_on_close) {
// Pop the JNI local frame that was pushed when entering this JVMCIEnv scope. // Pop the JNI local frame that was pushed when entering this JVMCIEnv scope.
JNIAccessMark jni(this); JNIAccessMark jni(this);
jni()->PopLocalFrame(NULL); jni()->PopLocalFrame(nullptr);
} }
if (has_pending_exception()) { if (has_pending_exception()) {
@ -737,7 +737,7 @@ JVMCIObject JVMCIEnv::create_box(BasicType type, jvalue* value, JVMCI_TRAPS) {
} else { } else {
JNIAccessMark jni(this, THREAD); JNIAccessMark jni(this, THREAD);
jobject box = jni()->NewObjectA(JNIJVMCI::box_class(type), JNIJVMCI::box_constructor(type), value); jobject box = jni()->NewObjectA(JNIJVMCI::box_class(type), JNIJVMCI::box_constructor(type), value);
assert(box != NULL, ""); assert(box != nullptr, "");
return wrap(box); return wrap(box);
} }
} }
@ -1028,7 +1028,7 @@ JVMCIObject JVMCIEnv::new_StackTraceElement(const methodHandle& method, int bci,
oop method_name = StringTable::intern(method_name_sym, CHECK_(JVMCIObject())); oop method_name = StringTable::intern(method_name_sym, CHECK_(JVMCIObject()));
HotSpotJVMCI::StackTraceElement::set_methodName(this, obj(), method_name); HotSpotJVMCI::StackTraceElement::set_methodName(this, obj(), method_name);
if (file_name_sym != NULL) { if (file_name_sym != nullptr) {
oop file_name = StringTable::intern(file_name_sym, CHECK_(JVMCIObject())); oop file_name = StringTable::intern(file_name_sym, CHECK_(JVMCIObject()));
HotSpotJVMCI::StackTraceElement::set_fileName(this, obj(), file_name); HotSpotJVMCI::StackTraceElement::set_fileName(this, obj(), file_name);
} }
@ -1044,8 +1044,8 @@ JVMCIObject JVMCIEnv::new_StackTraceElement(const methodHandle& method, int bci,
if (jni()->ExceptionCheck()) { if (jni()->ExceptionCheck()) {
return JVMCIObject(); return JVMCIObject();
} }
jobject file_name = NULL; jobject file_name = nullptr;
if (file_name_sym != NULL) { if (file_name_sym != nullptr) {
file_name = jni()->NewStringUTF(file_name_sym->as_C_string()); file_name = jni()->NewStringUTF(file_name_sym->as_C_string());
if (jni()->ExceptionCheck()) { if (jni()->ExceptionCheck()) {
return JVMCIObject(); return JVMCIObject();
@ -1088,7 +1088,7 @@ JVMCIObject JVMCIEnv::new_HotSpotNmethod(const methodHandle& method, const char*
return wrap(obj_h()); return wrap(obj_h());
} else { } else {
JNIAccessMark jni(this, THREAD); JNIAccessMark jni(this, THREAD);
jobject nameStr = name == NULL ? NULL : jni()->NewStringUTF(name); jobject nameStr = name == nullptr ? nullptr : jni()->NewStringUTF(name);
if (jni()->ExceptionCheck()) { if (jni()->ExceptionCheck()) {
return JVMCIObject(); return JVMCIObject();
} }
@ -1159,7 +1159,7 @@ const char* JVMCIEnv::klass_name(JVMCIObject object) {
JVMCIObject JVMCIEnv::get_jvmci_method(const methodHandle& method, JVMCI_TRAPS) { JVMCIObject JVMCIEnv::get_jvmci_method(const methodHandle& method, JVMCI_TRAPS) {
JVMCIObject method_object; JVMCIObject method_object;
if (method() == NULL) { if (method() == nullptr) {
return method_object; return method_object;
} }
@ -1310,7 +1310,7 @@ JVMCIObjectArray JVMCIEnv::new_byte_array_array(int length, JVMCI_TRAPS) {
return wrap(result); return wrap(result);
} else { } else {
JNIAccessMark jni(this, THREAD); JNIAccessMark jni(this, THREAD);
jobjectArray result = jni()->NewObjectArray(length, JNIJVMCI::byte_array(), NULL); jobjectArray result = jni()->NewObjectArray(length, JNIJVMCI::byte_array(), nullptr);
return wrap(result); return wrap(result);
} }
} }
@ -1458,8 +1458,8 @@ Handle JVMCIEnv::asConstant(JVMCIObject constant, JVMCI_TRAPS) {
JVMCI_THROW_MSG_(NullPointerException, "Foreign object reference has been cleared", Handle()); JVMCI_THROW_MSG_(NullPointerException, "Foreign object reference has been cleared", Handle());
} }
oop result = resolve_oop_handle(object_handle); oop result = resolve_oop_handle(object_handle);
if (result == NULL) { if (result == nullptr) {
JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly NULL", Handle()); JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly null", Handle());
} }
return Handle(THREAD, result); return Handle(THREAD, result);
} else { } else {
@ -1472,14 +1472,14 @@ JVMCIObject JVMCIEnv::wrap(jobject object) {
} }
jlong JVMCIEnv::make_oop_handle(const Handle& obj) { jlong JVMCIEnv::make_oop_handle(const Handle& obj) {
assert(!obj.is_null(), "should only create handle for non-NULL oops"); assert(!obj.is_null(), "should only create handle for non-null oops");
return _runtime->make_oop_handle(obj); return _runtime->make_oop_handle(obj);
} }
oop JVMCIEnv::resolve_oop_handle(jlong oopHandle) { oop JVMCIEnv::resolve_oop_handle(jlong oopHandle) {
assert(oopHandle != 0, "should be a valid handle"); assert(oopHandle != 0, "should be a valid handle");
oop obj = *((oopDesc**) oopHandle); oop obj = *((oopDesc**) oopHandle);
if (obj != NULL) { if (obj != nullptr) {
oopDesc::verify(obj); oopDesc::verify(obj);
} }
return obj; return obj;
@ -1568,7 +1568,7 @@ void JVMCIEnv::invalidate_nmethod_mirror(JVMCIObject mirror, bool deoptimize, JV
} }
nmethod* nm = JVMCIENV->get_nmethod(mirror); nmethod* nm = JVMCIENV->get_nmethod(mirror);
if (nm == NULL) { if (nm == nullptr) {
// Nothing to do // Nothing to do
return; return;
} }
@ -1615,30 +1615,30 @@ ConstantPool* JVMCIEnv::asConstantPool(JVMCIObject obj) {
// Lookup an nmethod with a matching base and compile id // Lookup an nmethod with a matching base and compile id
nmethod* JVMCIEnv::lookup_nmethod(address code, jlong compile_id_snapshot) { nmethod* JVMCIEnv::lookup_nmethod(address code, jlong compile_id_snapshot) {
if (code == NULL) { if (code == nullptr) {
return NULL; return nullptr;
} }
CodeBlob* cb = CodeCache::find_blob(code); CodeBlob* cb = CodeCache::find_blob(code);
if (cb == (CodeBlob*) code) { if (cb == (CodeBlob*) code) {
nmethod* nm = cb->as_nmethod_or_null(); nmethod* nm = cb->as_nmethod_or_null();
if (nm != NULL && (compile_id_snapshot == 0 || nm->compile_id() == compile_id_snapshot)) { if (nm != nullptr && (compile_id_snapshot == 0 || nm->compile_id() == compile_id_snapshot)) {
return nm; return nm;
} }
} }
return NULL; return nullptr;
} }
CodeBlob* JVMCIEnv::get_code_blob(JVMCIObject obj) { CodeBlob* JVMCIEnv::get_code_blob(JVMCIObject obj) {
address code = (address) get_InstalledCode_address(obj); address code = (address) get_InstalledCode_address(obj);
if (code == NULL) { if (code == nullptr) {
return NULL; return nullptr;
} }
if (isa_HotSpotNmethod(obj)) { if (isa_HotSpotNmethod(obj)) {
jlong compile_id_snapshot = get_HotSpotNmethod_compileIdSnapshot(obj); jlong compile_id_snapshot = get_HotSpotNmethod_compileIdSnapshot(obj);
nmethod* nm = lookup_nmethod(code, compile_id_snapshot); nmethod* nm = lookup_nmethod(code, compile_id_snapshot);
if (nm != NULL && compile_id_snapshot != 0L && nm->is_not_entrant()) { if (nm != nullptr && compile_id_snapshot != 0L && nm->is_not_entrant()) {
// Zero the entry point so that the nmethod // Zero the entry point so that the nmethod
// cannot be invoked by the mirror but can // cannot be invoked by the mirror but can
// still be deoptimized. // still be deoptimized.
@ -1647,7 +1647,7 @@ CodeBlob* JVMCIEnv::get_code_blob(JVMCIObject obj) {
nm = lookup_nmethod(code, compile_id_snapshot); nm = lookup_nmethod(code, compile_id_snapshot);
} }
if (nm == NULL) { if (nm == nullptr) {
// The HotSpotNmethod was pointing at some nmethod but the nmethod is no longer valid, so // The HotSpotNmethod was pointing at some nmethod but the nmethod is no longer valid, so
// clear the InstalledCode fields of this HotSpotNmethod so that it no longer refers to a // clear the InstalledCode fields of this HotSpotNmethod so that it no longer refers to a
// nmethod in the code cache. // nmethod in the code cache.
@ -1665,10 +1665,10 @@ CodeBlob* JVMCIEnv::get_code_blob(JVMCIObject obj) {
nmethod* JVMCIEnv::get_nmethod(JVMCIObject obj) { nmethod* JVMCIEnv::get_nmethod(JVMCIObject obj) {
CodeBlob* cb = get_code_blob(obj); CodeBlob* cb = get_code_blob(obj);
if (cb != NULL) { if (cb != nullptr) {
return cb->as_nmethod_or_null(); return cb->as_nmethod_or_null();
} }
return NULL; return nullptr;
} }
// Generate implementations for the initialize, new, isa, get and set methods for all the types and // Generate implementations for the initialize, new, isa, get and set methods for all the types and
@ -1689,7 +1689,7 @@ nmethod* JVMCIEnv::get_nmethod(JVMCIObject obj) {
return (JVMCIObjectArray) wrap(array); \ return (JVMCIObjectArray) wrap(array); \
} else { \ } else { \
JNIAccessMark jni(this); \ JNIAccessMark jni(this); \
jobjectArray result = jni()->NewObjectArray(length, JNIJVMCI::className::clazz(), NULL); \ jobjectArray result = jni()->NewObjectArray(length, JNIJVMCI::className::clazz(), nullptr); \
return wrap(result); \ return wrap(result); \
} \ } \
} \ } \

24
src/hotspot/share/jvmci/jvmciEnv.hpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 1999, 2022, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1999, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -47,7 +47,7 @@ class JVMCIRuntime;
if (env->ExceptionCheck()) { \ if (env->ExceptionCheck()) { \
if (env != JavaThread::current()->jni_environment()) { \ if (env != JavaThread::current()->jni_environment()) { \
char* sl_path; \ char* sl_path; \
if (::JVMCI::get_shared_library(sl_path, false) != NULL) { \ if (::JVMCI::get_shared_library(sl_path, false) != nullptr) { \
tty->print_cr("In JVMCI shared library (%s):", sl_path); \ tty->print_cr("In JVMCI shared library (%s):", sl_path); \
} \ } \
} \ } \
@ -64,11 +64,11 @@ class JVMCIKlassHandle : public StackObj {
Thread* _thread; Thread* _thread;
Klass* klass() const { return _klass; } Klass* klass() const { return _klass; }
Klass* non_null_klass() const { assert(_klass != NULL, "resolving NULL _klass"); return _klass; } Klass* non_null_klass() const { assert(_klass != nullptr, "resolving null _klass"); return _klass; }
public: public:
/* Constructors */ /* Constructors */
JVMCIKlassHandle (Thread* thread) : _klass(NULL), _thread(thread) {} JVMCIKlassHandle (Thread* thread) : _klass(nullptr), _thread(thread) {}
JVMCIKlassHandle (Thread* thread, Klass* klass); JVMCIKlassHandle (Thread* thread, Klass* klass);
JVMCIKlassHandle (const JVMCIKlassHandle &h): _klass(h._klass), _holder(h._holder), _thread(h._thread) {} JVMCIKlassHandle (const JVMCIKlassHandle &h): _klass(h._klass), _holder(h._holder), _thread(h._thread) {}
@ -83,8 +83,8 @@ class JVMCIKlassHandle : public StackObj {
bool operator == (const JVMCIKlassHandle& h) const { return klass() == h.klass(); } bool operator == (const JVMCIKlassHandle& h) const { return klass() == h.klass(); }
/* Null checks */ /* Null checks */
bool is_null() const { return _klass == NULL; } bool is_null() const { return _klass == nullptr; }
bool not_null() const { return _klass != NULL; } bool not_null() const { return _klass != nullptr; }
}; };
// A class that maintains the state needed for compilations requested // A class that maintains the state needed for compilations requested
@ -299,10 +299,10 @@ public:
bool equals(JVMCIObject a, JVMCIObject b); bool equals(JVMCIObject a, JVMCIObject b);
// Convert into a JNI handle for the appropriate runtime // Convert into a JNI handle for the appropriate runtime
jobject get_jobject(JVMCIObject object) { assert(object.as_jobject() == NULL || is_hotspot() == object.is_hotspot(), "mismatch"); return object.as_jobject(); } jobject get_jobject(JVMCIObject object) { assert(object.as_jobject() == nullptr || is_hotspot() == object.is_hotspot(), "mismatch"); return object.as_jobject(); }
jarray get_jarray(JVMCIArray array) { assert(array.as_jobject() == NULL || is_hotspot() == array.is_hotspot(), "mismatch"); return array.as_jobject(); } jarray get_jarray(JVMCIArray array) { assert(array.as_jobject() == nullptr || is_hotspot() == array.is_hotspot(), "mismatch"); return array.as_jobject(); }
jobjectArray get_jobjectArray(JVMCIObjectArray objectArray) { assert(objectArray.as_jobject() == NULL || is_hotspot() == objectArray.is_hotspot(), "mismatch"); return objectArray.as_jobject(); } jobjectArray get_jobjectArray(JVMCIObjectArray objectArray) { assert(objectArray.as_jobject() == nullptr || is_hotspot() == objectArray.is_hotspot(), "mismatch"); return objectArray.as_jobject(); }
jbyteArray get_jbyteArray(JVMCIPrimitiveArray primitiveArray) { assert(primitiveArray.as_jobject() == NULL || is_hotspot() == primitiveArray.is_hotspot(), "mismatch"); return primitiveArray.as_jbyteArray(); } jbyteArray get_jbyteArray(JVMCIPrimitiveArray primitiveArray) { assert(primitiveArray.as_jobject() == nullptr || is_hotspot() == primitiveArray.is_hotspot(), "mismatch"); return primitiveArray.as_jbyteArray(); }
JVMCIObject wrap(jobject obj); JVMCIObject wrap(jobject obj);
JVMCIObjectArray wrap(jobjectArray obj) { return (JVMCIObjectArray) wrap((jobject) obj); } JVMCIObjectArray wrap(jobjectArray obj) { return (JVMCIObjectArray) wrap((jobject) obj); }
@ -345,7 +345,7 @@ public:
BasicType kindToBasicType(JVMCIObject kind, JVMCI_TRAPS); BasicType kindToBasicType(JVMCIObject kind, JVMCI_TRAPS);
#define DO_THROW(name) \ #define DO_THROW(name) \
void throw_##name(const char* msg = NULL); void throw_##name(const char* msg = nullptr);
DO_THROW(InternalError) DO_THROW(InternalError)
DO_THROW(ArrayIndexOutOfBoundsException) DO_THROW(ArrayIndexOutOfBoundsException)
@ -447,7 +447,7 @@ public:
JVMCICompileState* compile_state() { return _compile_state; } JVMCICompileState* compile_state() { return _compile_state; }
void set_compile_state(JVMCICompileState* compile_state) { void set_compile_state(JVMCICompileState* compile_state) {
assert(_compile_state == NULL, "set only once"); assert(_compile_state == nullptr, "set only once");
_compile_state = compile_state; _compile_state = compile_state;
} }
// Generate declarations for the initialize, new, isa, get and set methods for all the types and // Generate declarations for the initialize, new, isa, get and set methods for all the types and

10
src/hotspot/share/jvmci/jvmciExceptions.hpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017, 2022, 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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -47,7 +47,7 @@ class JVMCIEnv;
#define JVMCI_CHECK JVMCIENV); if (JVMCI_HAS_PENDING_EXCEPTION) return ; (void)(0 #define JVMCI_CHECK JVMCIENV); if (JVMCI_HAS_PENDING_EXCEPTION) return ; (void)(0
#define JVMCI_CHECK_(result) JVMCIENV); if (JVMCI_HAS_PENDING_EXCEPTION) return result; (void)(0 #define JVMCI_CHECK_(result) JVMCIENV); if (JVMCI_HAS_PENDING_EXCEPTION) return result; (void)(0
#define JVMCI_CHECK_0 JVMCI_CHECK_(0) #define JVMCI_CHECK_0 JVMCI_CHECK_(0)
#define JVMCI_CHECK_NULL JVMCI_CHECK_(NULL) #define JVMCI_CHECK_NULL JVMCI_CHECK_(nullptr)
#define JVMCI_CHECK_false JVMCI_CHECK_(false) #define JVMCI_CHECK_false JVMCI_CHECK_(false)
#define JVMCI_CHECK_OK JVMCI_CHECK_(JVMCI::ok) #define JVMCI_CHECK_OK JVMCI_CHECK_(JVMCI::ok)
@ -58,13 +58,13 @@ class JVMCIEnv;
{ JVMCIENV->fthrow_error( __FILE__, __LINE__, __VA_ARGS__); return ret; } { JVMCIENV->fthrow_error( __FILE__, __LINE__, __VA_ARGS__); return ret; }
#define JVMCI_ERROR_0(...) JVMCI_ERROR_(0, __VA_ARGS__) #define JVMCI_ERROR_0(...) JVMCI_ERROR_(0, __VA_ARGS__)
#define JVMCI_ERROR_NULL(...) JVMCI_ERROR_(NULL, __VA_ARGS__) #define JVMCI_ERROR_NULL(...) JVMCI_ERROR_(nullptr, __VA_ARGS__)
#define JVMCI_ERROR_OK(...) JVMCI_ERROR_(JVMCI::ok, __VA_ARGS__) #define JVMCI_ERROR_OK(...) JVMCI_ERROR_(JVMCI::ok, __VA_ARGS__)
#define JVMCI_THROW(name) { JVMCIENV->throw_##name(); return; } #define JVMCI_THROW(name) { JVMCIENV->throw_##name(); return; }
#define JVMCI_THROW_NULL(name) { JVMCIENV->throw_##name(); return NULL; } #define JVMCI_THROW_NULL(name) { JVMCIENV->throw_##name(); return nullptr; }
#define JVMCI_THROW_0(name) { JVMCIENV->throw_##name(); return 0; } #define JVMCI_THROW_0(name) { JVMCIENV->throw_##name(); return 0; }
#define JVMCI_THROW_MSG_NULL(name, msg) { JVMCIENV->throw_##name(msg); return NULL; } #define JVMCI_THROW_MSG_NULL(name, msg) { JVMCIENV->throw_##name(msg); return nullptr; }
#define JVMCI_THROW_MSG_(name, msg, value) { JVMCIENV->throw_##name(msg); return (value); } #define JVMCI_THROW_MSG_(name, msg, value) { JVMCIENV->throw_##name(msg); return (value); }
#define JVMCI_THROW_MSG_0(name, msg) { JVMCIENV->throw_##name(msg); return 0; } #define JVMCI_THROW_MSG_0(name, msg) { JVMCIENV->throw_##name(msg); return 0; }
#define JVMCI_THROW_MSG(name, msg) { JVMCIENV->throw_##name(msg); return; } #define JVMCI_THROW_MSG(name, msg) { JVMCIENV->throw_##name(msg); return; }

60
src/hotspot/share/jvmci/jvmciJavaClasses.cpp
View File

@ -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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -67,7 +67,7 @@ void HotSpotJVMCI::compute_offset(int &dest_offset, Klass* klass, const char* na
InstanceKlass* ik = InstanceKlass::cast(klass); InstanceKlass* ik = InstanceKlass::cast(klass);
Symbol* name_symbol = SymbolTable::probe(name, (int)strlen(name)); Symbol* name_symbol = SymbolTable::probe(name, (int)strlen(name));
Symbol* signature_symbol = SymbolTable::probe(signature, (int)strlen(signature)); Symbol* signature_symbol = SymbolTable::probe(signature, (int)strlen(signature));
if (name_symbol == NULL || signature_symbol == NULL) { if (name_symbol == nullptr || signature_symbol == nullptr) {
#ifndef PRODUCT #ifndef PRODUCT
ik->print_on(tty); ik->print_on(tty);
#endif #endif
@ -97,8 +97,8 @@ void HotSpotJVMCI::compute_offset(int &dest_offset, Klass* klass, const char* na
#ifndef PRODUCT #ifndef PRODUCT
static void check_resolve_method(const char* call_type, Klass* resolved_klass, Symbol* method_name, Symbol* method_signature, TRAPS) { static void check_resolve_method(const char* call_type, Klass* resolved_klass, Symbol* method_name, Symbol* method_signature, TRAPS) {
Method* method = NULL; Method* method = nullptr;
LinkInfo link_info(resolved_klass, method_name, method_signature, NULL, LinkInfo::AccessCheck::skip, LinkInfo::LoaderConstraintCheck::skip); LinkInfo link_info(resolved_klass, method_name, method_signature, nullptr, LinkInfo::AccessCheck::skip, LinkInfo::LoaderConstraintCheck::skip);
if (strcmp(call_type, "call_static") == 0) { if (strcmp(call_type, "call_static") == 0) {
method = LinkResolver::resolve_static_call_or_null(link_info); method = LinkResolver::resolve_static_call_or_null(link_info);
} else if (strcmp(call_type, "call_virtual") == 0) { } else if (strcmp(call_type, "call_virtual") == 0) {
@ -108,7 +108,7 @@ static void check_resolve_method(const char* call_type, Klass* resolved_klass, S
} else { } else {
fatal("Unknown or unsupported call type: %s", call_type); fatal("Unknown or unsupported call type: %s", call_type);
} }
if (method == NULL) { if (method == nullptr) {
fatal("Could not resolve %s.%s%s", resolved_klass->external_name(), method_name->as_C_string(), method_signature->as_C_string()); fatal("Could not resolve %s.%s%s", resolved_klass->external_name(), method_name->as_C_string(), method_signature->as_C_string());
} }
} }
@ -199,11 +199,11 @@ void HotSpotJVMCI::compute_offsets(TRAPS) {
return resolve(object)->is_a(className::klass()); \ return resolve(object)->is_a(className::klass()); \
} \ } \
void HotSpotJVMCI::className::check(oop obj, const char* field_name, int offset) { \ void HotSpotJVMCI::className::check(oop obj, const char* field_name, int offset) { \
assert(obj != NULL, "NULL field access of %s.%s", #className, field_name); \ assert(obj != nullptr, "null field access of %s.%s", #className, field_name); \
assert(obj->is_a(className::klass()), "wrong class, " #className " expected, found %s", obj->klass()->external_name()); \ assert(obj->is_a(className::klass()), "wrong class, " #className " expected, found %s", obj->klass()->external_name()); \
assert(offset != 0, "must be valid offset"); \ assert(offset != 0, "must be valid offset"); \
} \ } \
InstanceKlass* HotSpotJVMCI::className::_klass = NULL; InstanceKlass* HotSpotJVMCI::className::_klass = nullptr;
#define END_CLASS #define END_CLASS
@ -225,28 +225,28 @@ void HotSpotJVMCI::compute_offsets(TRAPS) {
#define STATIC_OBJECTARRAY_FIELD(className, name, signature) STATIC_OOPISH_FIELD(className, name, objArrayOop) #define STATIC_OBJECTARRAY_FIELD(className, name, signature) STATIC_OOPISH_FIELD(className, name, objArrayOop)
#define STATIC_OOPISH_FIELD(className, name, type) \ #define STATIC_OOPISH_FIELD(className, name, type) \
type HotSpotJVMCI::className::name(JVMCIEnv* env) { \ type HotSpotJVMCI::className::name(JVMCIEnv* env) { \
assert(className::klass() != NULL && className::klass()->is_linked(), "Class not yet linked: " #className); \ assert(className::klass() != nullptr && className::klass()->is_linked(), "Class not yet linked: " #className); \
InstanceKlass* ik = className::klass(); \ InstanceKlass* ik = className::klass(); \
oop base = ik->static_field_base_raw(); \ oop base = ik->static_field_base_raw(); \
oop result = HeapAccess<>::oop_load_at(base, className::_##name##_offset); \ oop result = HeapAccess<>::oop_load_at(base, className::_##name##_offset); \
return type(result); \ return type(result); \
} \ } \
void HotSpotJVMCI::className::set_##name(JVMCIEnv* env, type x) { \ void HotSpotJVMCI::className::set_##name(JVMCIEnv* env, type x) { \
assert(className::klass() != NULL && className::klass()->is_linked(), "Class not yet linked: " #className); \ assert(className::klass() != nullptr && className::klass()->is_linked(), "Class not yet linked: " #className); \
assert(className::klass() != NULL, "Class not yet loaded: " #className); \ assert(className::klass() != nullptr, "Class not yet loaded: " #className); \
InstanceKlass* ik = className::klass(); \ InstanceKlass* ik = className::klass(); \
oop base = ik->static_field_base_raw(); \ oop base = ik->static_field_base_raw(); \
HeapAccess<>::oop_store_at(base, className::_##name##_offset, x); \ HeapAccess<>::oop_store_at(base, className::_##name##_offset, x); \
} }
#define STATIC_PRIMITIVE_FIELD(className, name, jtypename) \ #define STATIC_PRIMITIVE_FIELD(className, name, jtypename) \
jtypename HotSpotJVMCI::className::get_##name(JVMCIEnv* env) { \ jtypename HotSpotJVMCI::className::get_##name(JVMCIEnv* env) { \
assert(className::klass() != NULL && className::klass()->is_linked(), "Class not yet linked: " #className); \ assert(className::klass() != nullptr && className::klass()->is_linked(), "Class not yet linked: " #className); \
InstanceKlass* ik = className::klass(); \ InstanceKlass* ik = className::klass(); \
oop base = ik->static_field_base_raw(); \ oop base = ik->static_field_base_raw(); \
return *base->field_addr<jtypename>(className::_##name##_offset); \ return *base->field_addr<jtypename>(className::_##name##_offset); \
} \ } \
void HotSpotJVMCI::className::set_##name(JVMCIEnv* env, jtypename x) { \ void HotSpotJVMCI::className::set_##name(JVMCIEnv* env, jtypename x) { \
assert(className::klass() != NULL && className::klass()->is_linked(), "Class not yet linked: " #className); \ assert(className::klass() != nullptr && className::klass()->is_linked(), "Class not yet linked: " #className); \
InstanceKlass* ik = className::klass(); \ InstanceKlass* ik = className::klass(); \
oop base = ik->static_field_base_raw(); \ oop base = ik->static_field_base_raw(); \
*base->field_addr<jtypename>(className::_##name##_offset) = x; \ *base->field_addr<jtypename>(className::_##name##_offset) = x; \
@ -266,7 +266,7 @@ void HotSpotJVMCI::compute_offsets(TRAPS) {
* oop HotSpotJVMCI::Architecture::wordKind(JVMCIEnv* env, oop obj) { ... } * oop HotSpotJVMCI::Architecture::wordKind(JVMCIEnv* env, oop obj) { ... }
* void HotSpotJVMCI::Architecture::set_wordKind(JVMCIEnv* env, oop obj, oop x) { ... } * void HotSpotJVMCI::Architecture::set_wordKind(JVMCIEnv* env, oop obj, oop x) { ... }
* *
* InstanceKlass *HotSpotJVMCI::Architecture::_klass = NULL; * InstanceKlass *HotSpotJVMCI::Architecture::_klass = nullptr;
*/ */
JVMCI_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, LONG_FIELD, FLOAT_FIELD, OBJECT_FIELD, PRIMARRAY_FIELD, OBJECTARRAY_FIELD, STATIC_OBJECT_FIELD, STATIC_OBJECTARRAY_FIELD, STATIC_INT_FIELD, STATIC_BOOLEAN_FIELD, METHOD, CONSTRUCTOR) JVMCI_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, LONG_FIELD, FLOAT_FIELD, OBJECT_FIELD, PRIMARRAY_FIELD, OBJECTARRAY_FIELD, STATIC_OBJECT_FIELD, STATIC_OBJECTARRAY_FIELD, STATIC_INT_FIELD, STATIC_BOOLEAN_FIELD, METHOD, CONSTRUCTOR)
@ -296,7 +296,7 @@ JVMCI_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, L
* this ensures the declaring class is initialized. * this ensures the declaring class is initialized.
*/ */
void JNIJVMCI::initialize_field_id(JNIEnv* env, jfieldID &fieldid, jclass clazz, const char* class_name, const char* name, const char* signature, bool static_field) { void JNIJVMCI::initialize_field_id(JNIEnv* env, jfieldID &fieldid, jclass clazz, const char* class_name, const char* name, const char* signature, bool static_field) {
if (JVMCILibDumpJNIConfig != NULL) { if (JVMCILibDumpJNIConfig != nullptr) {
fileStream* st = JVMCIGlobals::get_jni_config_file(); fileStream* st = JVMCIGlobals::get_jni_config_file();
st->print_cr("field %s %s %s", class_name, name, signature); st->print_cr("field %s %s %s", class_name, name, signature);
return; return;
@ -355,7 +355,7 @@ void JNIJVMCI::initialize_field_id(JNIEnv* env, jfieldID &fieldid, jclass clazz,
} \ } \
} }
#define END_CLASS current_class_name = NULL; } #define END_CLASS current_class_name = nullptr; }
#define FIELD(className, name, signature, static_field) initialize_field_id(env, className::_##name##_field_id, className::_class, current_class_name, #name, signature, static_field); #define FIELD(className, name, signature, static_field) initialize_field_id(env, className::_##name##_field_id, className::_class, current_class_name, #name, signature, static_field);
#define CHAR_FIELD(className, name) FIELD(className, name, "C", false) #define CHAR_FIELD(className, name) FIELD(className, name, "C", false)
@ -419,21 +419,21 @@ class ThrowableInitDumper : public SymbolClosure {
void do_symbol(Symbol** p) { void do_symbol(Symbol** p) {
JavaThread* THREAD = JavaThread::current(); // For exception macros. JavaThread* THREAD = JavaThread::current(); // For exception macros.
Symbol* name = *p; Symbol* name = *p;
if (name == NULL) { if (name == nullptr) {
return; return;
} }
Klass* k = SystemDictionary::resolve_or_null(name, CHECK_EXIT); Klass* k = SystemDictionary::resolve_or_null(name, CHECK_EXIT);
if (k != NULL && k->is_instance_klass()) { if (k != nullptr && k->is_instance_klass()) {
InstanceKlass* iklass = InstanceKlass::cast(k); InstanceKlass* iklass = InstanceKlass::cast(k);
if (iklass->is_subclass_of(vmClasses::Throwable_klass()) && iklass->is_public() && !iklass->is_abstract()) { if (iklass->is_subclass_of(vmClasses::Throwable_klass()) && iklass->is_public() && !iklass->is_abstract()) {
const char* class_name = NULL; const char* class_name = nullptr;
Array<Method*>* methods = iklass->methods(); Array<Method*>* methods = iklass->methods();
for (int i = 0; i < methods->length(); i++) { for (int i = 0; i < methods->length(); i++) {
Method* m = methods->at(i); Method* m = methods->at(i);
if (m->name() == vmSymbols::object_initializer_name() && if (m->name() == vmSymbols::object_initializer_name() &&
m->is_public() && m->is_public() &&
(m->signature() == vmSymbols::void_method_signature() || m->signature() == vmSymbols::string_void_signature())) { (m->signature() == vmSymbols::void_method_signature() || m->signature() == vmSymbols::string_void_signature())) {
if (class_name == NULL) { if (class_name == nullptr) {
class_name = name->as_C_string(); class_name = name->as_C_string();
_st->print_cr("class %s", class_name); _st->print_cr("class %s", class_name);
} }
@ -451,7 +451,7 @@ class ThrowableInitDumper : public SymbolClosure {
*/ */
void JNIJVMCI::initialize_ids(JNIEnv* env) { void JNIJVMCI::initialize_ids(JNIEnv* env) {
ResourceMark rm; ResourceMark rm;
const char* current_class_name = NULL; const char* current_class_name = nullptr;
JVMCI_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, LONG_FIELD, FLOAT_FIELD, OBJECT_FIELD, OBJECT_FIELD, OBJECT_FIELD, STATIC_OBJECT_FIELD, STATIC_OBJECT_FIELD, STATIC_INT_FIELD, STATIC_BOOLEAN_FIELD, METHOD, CONSTRUCTOR) JVMCI_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, LONG_FIELD, FLOAT_FIELD, OBJECT_FIELD, OBJECT_FIELD, OBJECT_FIELD, STATIC_OBJECT_FIELD, STATIC_OBJECT_FIELD, STATIC_INT_FIELD, STATIC_BOOLEAN_FIELD, METHOD, CONSTRUCTOR)
IN_CLASS(java_lang_Class); IN_CLASS(java_lang_Class);
@ -486,11 +486,11 @@ void JNIJVMCI::initialize_ids(JNIEnv* env) {
#define DO_BOX_CLASS(klass, basicType, type) \ #define DO_BOX_CLASS(klass, basicType, type) \
current_class_name = "java/lang/" #klass; \ current_class_name = "java/lang/" #klass; \
if (JVMCILibDumpJNIConfig == NULL) { \ if (JVMCILibDumpJNIConfig == nullptr) { \
_box_classes[basicType] = env->FindClass("java/lang/" #klass); \ _box_classes[basicType] = env->FindClass("java/lang/" #klass); \
JVMCI_EXCEPTION_CHECK(env, "FindClass(%s)", #klass); \ JVMCI_EXCEPTION_CHECK(env, "FindClass(%s)", #klass); \
_box_classes[basicType] = (jclass) env->NewGlobalRef(_box_classes[basicType]); \ _box_classes[basicType] = (jclass) env->NewGlobalRef(_box_classes[basicType]); \
assert(_box_classes[basicType] != NULL, "uninitialized"); \ assert(_box_classes[basicType] != nullptr, "uninitialized"); \
_box_fields[basicType] = env->GetFieldID(_box_classes[basicType], "value", #type); \ _box_fields[basicType] = env->GetFieldID(_box_classes[basicType], "value", #type); \
JVMCI_EXCEPTION_CHECK(env, "GetFieldID(%s, value, %s)", #klass, #type); \ JVMCI_EXCEPTION_CHECK(env, "GetFieldID(%s, value, %s)", #klass, #type); \
GET_JNI_METHOD(GetMethodID, _box_constructors[basicType], _box_classes[basicType], "<init>", "(" #type ")V"); \ GET_JNI_METHOD(GetMethodID, _box_constructors[basicType], _box_classes[basicType], "<init>", "(" #type ")V"); \
@ -502,11 +502,11 @@ void JNIJVMCI::initialize_ids(JNIEnv* env) {
BOX_CLASSES(DO_BOX_CLASS); BOX_CLASSES(DO_BOX_CLASS);
if (JVMCILibDumpJNIConfig == NULL) { if (JVMCILibDumpJNIConfig == nullptr) {
_byte_array = env->FindClass("[B"); _byte_array = env->FindClass("[B");
JVMCI_EXCEPTION_CHECK(env, "FindClass([B)"); JVMCI_EXCEPTION_CHECK(env, "FindClass([B)");
_byte_array = (jclass) env->NewGlobalRef(_byte_array); _byte_array = (jclass) env->NewGlobalRef(_byte_array);
assert(_byte_array != NULL, "uninitialized"); assert(_byte_array != nullptr, "uninitialized");
} else { } else {
fileStream* st = JVMCIGlobals::get_jni_config_file(); fileStream* st = JVMCIGlobals::get_jni_config_file();
st->print_cr("class [B"); st->print_cr("class [B");
@ -525,7 +525,7 @@ void JNIJVMCI::initialize_ids(JNIEnv* env) {
} \ } \
} while(0) } while(0)
if (JVMCILibDumpJNIConfig != NULL) { if (JVMCILibDumpJNIConfig != nullptr) {
JavaThread* THREAD = JavaThread::current(); // For exception macros. JavaThread* THREAD = JavaThread::current(); // For exception macros.
fileStream* st = JVMCIGlobals::get_jni_config_file(); fileStream* st = JVMCIGlobals::get_jni_config_file();
@ -548,7 +548,7 @@ void JNIJVMCI::initialize_ids(JNIEnv* env) {
} }
static void register_natives_for_class(JNIEnv* env, jclass clazz, const char* name, const JNINativeMethod *methods, jint nMethods) { static void register_natives_for_class(JNIEnv* env, jclass clazz, const char* name, const JNINativeMethod *methods, jint nMethods) {
if (clazz == NULL) { if (clazz == nullptr) {
clazz = env->FindClass(name); clazz = env->FindClass(name);
if (env->ExceptionCheck()) { if (env->ExceptionCheck()) {
env->ExceptionDescribe(); env->ExceptionDescribe();
@ -567,7 +567,7 @@ void JNIJVMCI::register_natives(JNIEnv* env) {
JNINativeMethod CompilerToVM_nmethods[] = {{ CC"registerNatives", CC"()V", FN_PTR(JVM_RegisterJVMCINatives) }}; JNINativeMethod CompilerToVM_nmethods[] = {{ CC"registerNatives", CC"()V", FN_PTR(JVM_RegisterJVMCINatives) }};
JNINativeMethod JVMCI_nmethods[] = {{ CC"initializeRuntime", CC"()Ljdk/vm/ci/runtime/JVMCIRuntime;", FN_PTR(JVM_GetJVMCIRuntime) }}; JNINativeMethod JVMCI_nmethods[] = {{ CC"initializeRuntime", CC"()Ljdk/vm/ci/runtime/JVMCIRuntime;", FN_PTR(JVM_GetJVMCIRuntime) }};
register_natives_for_class(env, NULL, "jdk/vm/ci/hotspot/CompilerToVM", CompilerToVM_nmethods, 1); register_natives_for_class(env, nullptr, "jdk/vm/ci/hotspot/CompilerToVM", CompilerToVM_nmethods, 1);
register_natives_for_class(env, JVMCI::clazz(), "jdk/vm/ci/runtime/JVMCI", JVMCI_nmethods, 1); register_natives_for_class(env, JVMCI::clazz(), "jdk/vm/ci/runtime/JVMCI", JVMCI_nmethods, 1);
} }
} }
@ -621,11 +621,11 @@ JVMCI_CLASSES_DO(EMPTY2, EMPTY0, FIELD2, FIELD2, FIELD2, FIELD2, FIELD2, FIELD3,
return jni()->IsInstanceOf(object.as_jobject(), className::clazz()) != 0; \ return jni()->IsInstanceOf(object.as_jobject(), className::clazz()) != 0; \
} \ } \
void JNIJVMCI::className::check(JVMCIEnv* jvmciEnv, JVMCIObject obj, const char* field_name, jfieldID offset) { \ void JNIJVMCI::className::check(JVMCIEnv* jvmciEnv, JVMCIObject obj, const char* field_name, jfieldID offset) { \
assert(obj.is_non_null(), "NULL field access of %s.%s", #className, field_name); \ assert(obj.is_non_null(), "null field access of %s.%s", #className, field_name); \
assert(jvmciEnv->isa_##className(obj), "wrong class, " #className " expected, found %s", jvmciEnv->klass_name(obj)); \ assert(jvmciEnv->isa_##className(obj), "wrong class, " #className " expected, found %s", jvmciEnv->klass_name(obj)); \
assert(offset != 0, "must be valid offset"); \ assert(offset != 0, "must be valid offset"); \
} \ } \
jclass JNIJVMCI::className::_class = NULL; jclass JNIJVMCI::className::_class = nullptr;
#define END_CLASS #define END_CLASS

52
src/hotspot/share/jvmci/jvmciJavaClasses.hpp
View File

@ -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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -284,14 +284,14 @@ class JVMCIEnv;
#define STATIC_OBJECT_FIELD(simpleClassName, name, signature) STATIC_OOPISH_FIELD(simpleClassName, name, JVMCIObject, oop) #define STATIC_OBJECT_FIELD(simpleClassName, name, signature) STATIC_OOPISH_FIELD(simpleClassName, name, JVMCIObject, oop)
#define STATIC_OBJECTARRAY_FIELD(simpleClassName, name, signature) STATIC_OOPISH_FIELD(simpleClassName, name, JVMCIObjectArray, objArrayOop) #define STATIC_OBJECTARRAY_FIELD(simpleClassName, name, signature) STATIC_OOPISH_FIELD(simpleClassName, name, JVMCIObjectArray, objArrayOop)
#define HS_START_CLASS(simpleClassName, fullClassName) \ #define HS_START_CLASS(simpleClassName, fullClassName) \
START_CLASS(simpleClassName, fullClassName) \ START_CLASS(simpleClassName, fullClassName) \
friend class HotSpotJVMCI; \ friend class HotSpotJVMCI; \
private: \ private: \
static void check(oop obj, const char* field_name, int offset); \ static void check(oop obj, const char* field_name, int offset); \
static InstanceKlass* _klass; \ static InstanceKlass* _klass; \
public: \ public: \
static InstanceKlass* klass() { assert(_klass != NULL, "uninit"); return _klass; } \ static InstanceKlass* klass() { assert(_klass != nullptr, "uninit"); return _klass; } \
static Symbol* symbol() { return vmSymbols::fullClassName(); } static Symbol* symbol() { return vmSymbols::fullClassName(); }
#define FIELD(simpleClassName, name, type) \ #define FIELD(simpleClassName, name, type) \
@ -384,15 +384,15 @@ class HotSpotJVMCI {
#undef HS_START_CLASS #undef HS_START_CLASS
#define JNI_START_CLASS(simpleClassName, fullClassName) \ #define JNI_START_CLASS(simpleClassName, fullClassName) \
START_CLASS(simpleClassName, fullClassName) \ START_CLASS(simpleClassName, fullClassName) \
friend class JNIJVMCI; \ friend class JNIJVMCI; \
private: \ private: \
static void check(JVMCIEnv* jvmciEnv, JVMCIObject obj, const char* field_name, jfieldID offset); \ static void check(JVMCIEnv* jvmciEnv, JVMCIObject obj, const char* field_name, jfieldID offset); \
static jclass _class; \ static jclass _class; \
public: \ public: \
static jclass clazz() { assert(_class != NULL, #fullClassName " uninitialized"); return _class; } \ static jclass clazz() { assert(_class != nullptr, #fullClassName " uninitialized"); return _class; } \
static jclass fullClassName ##_class() { assert(_class != NULL, "uninit"); return _class; } static jclass fullClassName ##_class() { assert(_class != nullptr, "uninit"); return _class; }
#undef METHOD #undef METHOD
#undef CONSTRUCTOR #undef CONSTRUCTOR
@ -473,16 +473,16 @@ class JNIJVMCI {
public: public:
static jmethodID Class_getName_method() { return _Class_getName_method; } static jmethodID Class_getName_method() { return _Class_getName_method; }
static jclass byte_array() { assert(_byte_array != NULL, "uninit"); return _byte_array; } static jclass byte_array() { assert(_byte_array != nullptr, "uninit"); return _byte_array; }
static jclass box_class(BasicType type) { assert(_box_classes[type]!= NULL, "uninit"); return _box_classes[type]; } static jclass box_class(BasicType type) { assert(_box_classes[type]!= nullptr, "uninit"); return _box_classes[type]; }
static jfieldID box_field(BasicType type) { assert(_box_fields[type]!= NULL, "uninit"); return _box_fields[type]; } static jfieldID box_field(BasicType type) { assert(_box_fields[type]!= nullptr, "uninit"); return _box_fields[type]; }
static jmethodID box_constructor(BasicType type) { assert(_box_constructors[type]!= NULL, "uninit"); return _box_constructors[type]; } static jmethodID box_constructor(BasicType type) { assert(_box_constructors[type]!= nullptr, "uninit"); return _box_constructors[type]; }
static jmethodID HotSpotResolvedJavaMethodImpl_fromMetaspace_method() { assert(_HotSpotResolvedJavaMethodImpl_fromMetaspace_method != NULL, "uninit"); return _HotSpotResolvedJavaMethodImpl_fromMetaspace_method; } static jmethodID HotSpotResolvedJavaMethodImpl_fromMetaspace_method() { assert(_HotSpotResolvedJavaMethodImpl_fromMetaspace_method != nullptr, "uninit"); return _HotSpotResolvedJavaMethodImpl_fromMetaspace_method; }
static jmethodID HotSpotConstantPool_fromMetaspace_method() { assert(_HotSpotConstantPool_fromMetaspace_method != NULL, "uninit"); return _HotSpotConstantPool_fromMetaspace_method; } static jmethodID HotSpotConstantPool_fromMetaspace_method() { assert(_HotSpotConstantPool_fromMetaspace_method != nullptr, "uninit"); return _HotSpotConstantPool_fromMetaspace_method; }
static jmethodID HotSpotResolvedObjectTypeImpl_fromMetaspace_method() { assert(_HotSpotResolvedObjectTypeImpl_fromMetaspace_method != NULL, "uninit"); return _HotSpotResolvedObjectTypeImpl_fromMetaspace_method; } static jmethodID HotSpotResolvedObjectTypeImpl_fromMetaspace_method() { assert(_HotSpotResolvedObjectTypeImpl_fromMetaspace_method != nullptr, "uninit"); return _HotSpotResolvedObjectTypeImpl_fromMetaspace_method; }
static jmethodID HotSpotResolvedPrimitiveType_fromMetaspace_method() { assert(_HotSpotResolvedPrimitiveType_fromMetaspace_method != NULL, "uninit"); return _HotSpotResolvedPrimitiveType_fromMetaspace_method; } static jmethodID HotSpotResolvedPrimitiveType_fromMetaspace_method() { assert(_HotSpotResolvedPrimitiveType_fromMetaspace_method != nullptr, "uninit"); return _HotSpotResolvedPrimitiveType_fromMetaspace_method; }
static void initialize_ids(JNIEnv* env); static void initialize_ids(JNIEnv* env);
static void initialize_field_id(JNIEnv* env, jfieldID &dest_offset, jclass klass, const char* klass_name, const char* name, const char* signature, bool static_field); static void initialize_field_id(JNIEnv* env, jfieldID &dest_offset, jclass klass, const char* klass_name, const char* name, const char* signature, bool static_field);

12
src/hotspot/share/jvmci/jvmciObject.hpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -38,7 +38,7 @@ class JVMCIObject {
bool _is_hotspot; bool _is_hotspot;
public: public:
JVMCIObject(): _object(NULL), _is_hotspot(false) {} JVMCIObject(): _object(nullptr), _is_hotspot(false) {}
JVMCIObject(jobject o, bool is_hotspot): _object(o), _is_hotspot(is_hotspot) { } JVMCIObject(jobject o, bool is_hotspot): _object(o), _is_hotspot(is_hotspot) { }
static JVMCIObject create(jobject o, bool is_hotspot) { JVMCIObject r(o, is_hotspot); return r; } static JVMCIObject create(jobject o, bool is_hotspot) { JVMCIObject r(o, is_hotspot); return r; }
@ -47,8 +47,8 @@ class JVMCIObject {
jstring as_jstring() { return (jstring) _object; } jstring as_jstring() { return (jstring) _object; }
bool is_hotspot() { return _is_hotspot; } bool is_hotspot() { return _is_hotspot; }
bool is_null() const { return _object == NULL; } bool is_null() const { return _object == nullptr; }
bool is_non_null() const { return _object != NULL; } bool is_non_null() const { return _object != nullptr; }
operator JVMCIArray(); operator JVMCIArray();
operator JVMCIPrimitiveArray(); operator JVMCIPrimitiveArray();
@ -65,7 +65,7 @@ class JVMCIArray : public JVMCIObject {
class JVMCIObjectArray : public JVMCIArray { class JVMCIObjectArray : public JVMCIArray {
public: public:
JVMCIObjectArray() {} JVMCIObjectArray() {}
JVMCIObjectArray(void* v): JVMCIArray() { assert(v == NULL, "must be NULL"); } JVMCIObjectArray(void* v): JVMCIArray() { assert(v == nullptr, "must be null"); }
JVMCIObjectArray(jobject o, bool is_hotspot): JVMCIArray(o, is_hotspot) {} JVMCIObjectArray(jobject o, bool is_hotspot): JVMCIArray(o, is_hotspot) {}
jobjectArray as_jobject() { return (jobjectArray) JVMCIArray::as_jobject(); } jobjectArray as_jobject() { return (jobjectArray) JVMCIArray::as_jobject(); }
@ -74,7 +74,7 @@ class JVMCIObjectArray : public JVMCIArray {
class JVMCIPrimitiveArray : public JVMCIArray { class JVMCIPrimitiveArray : public JVMCIArray {
public: public:
JVMCIPrimitiveArray() {} JVMCIPrimitiveArray() {}
JVMCIPrimitiveArray(void* v): JVMCIArray() { assert(v == NULL, "must be NULL"); } JVMCIPrimitiveArray(void* v): JVMCIArray() { assert(v == nullptr, "must be null"); }
JVMCIPrimitiveArray(jobject o, bool is_hotspot): JVMCIArray(o, is_hotspot) {} JVMCIPrimitiveArray(jobject o, bool is_hotspot): JVMCIArray(o, is_hotspot) {}
jbooleanArray as_jbooleanArray() { return (jbooleanArray) as_jobject(); } jbooleanArray as_jbooleanArray() { return (jbooleanArray) as_jobject(); }

130
src/hotspot/share/jvmci/jvmciRuntime.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012, 2022, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -91,10 +91,10 @@ static void deopt_caller() {
// Manages a scope for a JVMCI runtime call that attempts a heap allocation. // Manages a scope for a JVMCI runtime call that attempts a heap allocation.
// If there is a pending nonasync exception upon closing the scope and the runtime // If there is a pending nonasync exception upon closing the scope and the runtime
// call is of the variety where allocation failure returns NULL without an // call is of the variety where allocation failure returns null without an
// exception, the following action is taken: // exception, the following action is taken:
// 1. The pending nonasync exception is cleared // 1. The pending nonasync exception is cleared
// 2. NULL is written to JavaThread::_vm_result // 2. null is written to JavaThread::_vm_result
// 3. Checks that an OutOfMemoryError is Universe::out_of_memory_error_retry(). // 3. Checks that an OutOfMemoryError is Universe::out_of_memory_error_retry().
class RetryableAllocationMark: public StackObj { class RetryableAllocationMark: public StackObj {
private: private:
@ -106,11 +106,11 @@ class RetryableAllocationMark: public StackObj {
_thread = thread; _thread = thread;
_thread->set_in_retryable_allocation(true); _thread->set_in_retryable_allocation(true);
} else { } else {
_thread = NULL; _thread = nullptr;
} }
} }
~RetryableAllocationMark() { ~RetryableAllocationMark() {
if (_thread != NULL) { if (_thread != nullptr) {
_thread->set_in_retryable_allocation(false); _thread->set_in_retryable_allocation(false);
JavaThread* THREAD = _thread; // For exception macros. JavaThread* THREAD = _thread; // For exception macros.
if (HAS_PENDING_EXCEPTION) { if (HAS_PENDING_EXCEPTION) {
@ -122,7 +122,7 @@ class RetryableAllocationMark: public StackObj {
ResourceMark rm; ResourceMark rm;
fatal("Unexpected exception in scope of retryable allocation: " INTPTR_FORMAT " of type %s", p2i(ex), ex->klass()->external_name()); fatal("Unexpected exception in scope of retryable allocation: " INTPTR_FORMAT " of type %s", p2i(ex), ex->klass()->external_name());
} }
_thread->set_vm_result(NULL); _thread->set_vm_result(nullptr);
} }
} }
} }
@ -211,7 +211,7 @@ JRT_END
JRT_ENTRY(void, JVMCIRuntime::dynamic_new_instance_common(JavaThread* current, oopDesc* type_mirror, bool null_on_fail)) JRT_ENTRY(void, JVMCIRuntime::dynamic_new_instance_common(JavaThread* current, oopDesc* type_mirror, bool null_on_fail))
InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(type_mirror)); InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(type_mirror));
if (klass == NULL) { if (klass == nullptr) {
ResourceMark rm(current); ResourceMark rm(current);
THROW(vmSymbols::java_lang_InstantiationException()); THROW(vmSymbols::java_lang_InstantiationException());
} }
@ -259,7 +259,7 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* c
Handle exception(current, ex); Handle exception(current, ex);
cm = CodeCache::find_compiled(pc); cm = CodeCache::find_compiled(pc);
assert(cm != NULL, "this is not a compiled method"); assert(cm != nullptr, "this is not a compiled method");
// Adjust the pc as needed/ // Adjust the pc as needed/
if (cm->is_deopt_pc(pc)) { if (cm->is_deopt_pc(pc)) {
RegisterMap map(current, RegisterMap map(current,
@ -271,7 +271,7 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* c
assert(exception_frame.is_deoptimized_frame(), "must be deopted"); assert(exception_frame.is_deoptimized_frame(), "must be deopted");
pc = exception_frame.pc(); pc = exception_frame.pc();
} }
assert(exception.not_null(), "NULL exceptions should be handled by throw_exception"); assert(exception.not_null(), "null exceptions should be handled by throw_exception");
assert(oopDesc::is_oop(exception()), "just checking"); assert(oopDesc::is_oop(exception()), "just checking");
// Check that exception is a subclass of Throwable // Check that exception is a subclass of Throwable
assert(exception->is_a(vmClasses::Throwable_klass()), assert(exception->is_a(vmClasses::Throwable_klass()),
@ -282,7 +282,7 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* c
if (log_is_enabled(Info, exceptions)) { if (log_is_enabled(Info, exceptions)) {
ResourceMark rm; ResourceMark rm;
stringStream tempst; stringStream tempst;
assert(cm->method() != NULL, "Unexpected null method()"); assert(cm->method() != nullptr, "Unexpected null method()");
tempst.print("JVMCI compiled method <%s>\n" tempst.print("JVMCI compiled method <%s>\n"
" at PC" INTPTR_FORMAT " for thread " INTPTR_FORMAT, " at PC" INTPTR_FORMAT " for thread " INTPTR_FORMAT,
cm->method()->print_value_string(), p2i(pc), p2i(current)); cm->method()->print_value_string(), p2i(pc), p2i(current));
@ -324,7 +324,7 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* c
// ExceptionCache is used only for exceptions at call sites and not for implicit exceptions // ExceptionCache is used only for exceptions at call sites and not for implicit exceptions
if (guard_pages_enabled) { if (guard_pages_enabled) {
address fast_continuation = cm->handler_for_exception_and_pc(exception, pc); address fast_continuation = cm->handler_for_exception_and_pc(exception, pc);
if (fast_continuation != NULL) { if (fast_continuation != nullptr) {
// Set flag if return address is a method handle call site. // Set flag if return address is a method handle call site.
current->set_is_method_handle_return(cm->is_method_handle_return(pc)); current->set_is_method_handle_return(cm->is_method_handle_return(pc));
return fast_continuation; return fast_continuation;
@ -333,8 +333,8 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* c
// If the stack guard pages are enabled, check whether there is a handler in // If the stack guard pages are enabled, check whether there is a handler in
// the current method. Otherwise (guard pages disabled), force an unwind and // the current method. Otherwise (guard pages disabled), force an unwind and
// skip the exception cache update (i.e., just leave continuation==NULL). // skip the exception cache update (i.e., just leave continuation==nullptr).
address continuation = NULL; address continuation = nullptr;
if (guard_pages_enabled) { if (guard_pages_enabled) {
// New exception handling mechanism can support inlined methods // New exception handling mechanism can support inlined methods
@ -358,7 +358,7 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* c
// (e.g., when loading the class of the catch type). // (e.g., when loading the class of the catch type).
// Checking for exception oop equality is not // Checking for exception oop equality is not
// sufficient because some exceptions are pre-allocated and reused. // sufficient because some exceptions are pre-allocated and reused.
if (continuation != NULL && !recursive_exception && !SharedRuntime::deopt_blob()->contains(continuation)) { if (continuation != nullptr && !recursive_exception && !SharedRuntime::deopt_blob()->contains(continuation)) {
cm->add_handler_for_exception_and_pc(exception, pc, continuation); cm->add_handler_for_exception_and_pc(exception, pc, continuation);
} }
} }
@ -386,8 +386,8 @@ address JVMCIRuntime::exception_handler_for_pc(JavaThread* current) {
address pc = current->exception_pc(); address pc = current->exception_pc();
// Still in Java mode // Still in Java mode
DEBUG_ONLY(NoHandleMark nhm); DEBUG_ONLY(NoHandleMark nhm);
CompiledMethod* cm = NULL; CompiledMethod* cm = nullptr;
address continuation = NULL; address continuation = nullptr;
{ {
// Enter VM mode by calling the helper // Enter VM mode by calling the helper
ResetNoHandleMark rnhm; ResetNoHandleMark rnhm;
@ -397,11 +397,11 @@ address JVMCIRuntime::exception_handler_for_pc(JavaThread* current) {
// Now check to see if the compiled method we were called from is now deoptimized. // Now check to see if the compiled method we were called from is now deoptimized.
// If so we must return to the deopt blob and deoptimize the nmethod // If so we must return to the deopt blob and deoptimize the nmethod
if (cm != NULL && caller_is_deopted()) { if (cm != nullptr && caller_is_deopted()) {
continuation = SharedRuntime::deopt_blob()->unpack_with_exception_in_tls(); continuation = SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
} }
assert(continuation != NULL, "no handler found"); assert(continuation != nullptr, "no handler found");
return continuation; return continuation;
} }
@ -583,8 +583,8 @@ JRT_END
JRT_LEAF(void, JVMCIRuntime::log_object(JavaThread* thread, oopDesc* obj, bool as_string, bool newline)) JRT_LEAF(void, JVMCIRuntime::log_object(JavaThread* thread, oopDesc* obj, bool as_string, bool newline))
ttyLocker ttyl; ttyLocker ttyl;
if (obj == NULL) { if (obj == nullptr) {
tty->print("NULL"); tty->print("null");
} else if (oopDesc::is_oop_or_null(obj, true) && (!as_string || !java_lang_String::is_instance(obj))) { } else if (oopDesc::is_oop_or_null(obj, true) && (!as_string || !java_lang_String::is_instance(obj))) {
if (oopDesc::is_oop_or_null(obj, true)) { if (oopDesc::is_oop_or_null(obj, true)) {
char buf[O_BUFLEN]; char buf[O_BUFLEN];
@ -594,7 +594,7 @@ JRT_LEAF(void, JVMCIRuntime::log_object(JavaThread* thread, oopDesc* obj, bool a
} }
} else { } else {
ResourceMark rm; ResourceMark rm;
assert(obj != NULL && java_lang_String::is_instance(obj), "must be"); assert(obj != nullptr && java_lang_String::is_instance(obj), "must be");
char *buf = java_lang_String::as_utf8_string(obj); char *buf = java_lang_String::as_utf8_string(obj);
tty->print_raw(buf); tty->print_raw(buf);
} }
@ -633,7 +633,7 @@ JRT_END
JRT_ENTRY(void, JVMCIRuntime::vm_error(JavaThread* current, jlong where, jlong format, jlong value)) JRT_ENTRY(void, JVMCIRuntime::vm_error(JavaThread* current, jlong where, jlong format, jlong value))
ResourceMark rm(current); ResourceMark rm(current);
const char *error_msg = where == 0L ? "<internal JVMCI error>" : (char*) (address) where; const char *error_msg = where == 0L ? "<internal JVMCI error>" : (char*) (address) where;
char *detail_msg = NULL; char *detail_msg = nullptr;
if (format != 0L) { if (format != 0L) {
const char* buf = (char*) (address) format; const char* buf = (char*) (address) format;
size_t detail_msg_length = strlen(buf) * 2; size_t detail_msg_length = strlen(buf) * 2;
@ -645,8 +645,8 @@ JRT_END
JRT_LEAF(oopDesc*, JVMCIRuntime::load_and_clear_exception(JavaThread* thread)) JRT_LEAF(oopDesc*, JVMCIRuntime::load_and_clear_exception(JavaThread* thread))
oop exception = thread->exception_oop(); oop exception = thread->exception_oop();
assert(exception != NULL, "npe"); assert(exception != nullptr, "npe");
thread->set_exception_oop(NULL); thread->set_exception_oop(nullptr);
thread->set_exception_pc(0); thread->set_exception_pc(0);
return exception; return exception;
JRT_END JRT_END
@ -687,12 +687,12 @@ JRT_LEAF(void, JVMCIRuntime::vm_message(jboolean vmError, jlong format, jlong v1
ResourceMark rm; ResourceMark rm;
const char *buf = (const char*) (address) format; const char *buf = (const char*) (address) format;
if (vmError) { if (vmError) {
if (buf != NULL) { if (buf != nullptr) {
fatal(buf, v1, v2, v3); fatal(buf, v1, v2, v3);
} else { } else {
fatal("<anonymous error>"); fatal("<anonymous error>");
} }
} else if (buf != NULL) { } else if (buf != nullptr) {
tty->print(buf, v1, v2, v3); tty->print(buf, v1, v2, v3);
} else { } else {
assert(v2 == 0, "v2 != 0"); assert(v2 == 0, "v2 != 0");
@ -760,7 +760,7 @@ void JVMCINMethodData::initialize(
{ {
_failed_speculations = failed_speculations; _failed_speculations = failed_speculations;
_nmethod_mirror_index = nmethod_mirror_index; _nmethod_mirror_index = nmethod_mirror_index;
if (name != NULL) { if (name != nullptr) {
_has_name = true; _has_name = true;
char* dest = (char*) this->name(); char* dest = (char*) this->name();
strcpy(dest, name); strcpy(dest, name);
@ -782,7 +782,7 @@ void JVMCINMethodData::add_failed_speculation(nmethod* nm, jlong speculation) {
oop JVMCINMethodData::get_nmethod_mirror(nmethod* nm, bool phantom_ref) { oop JVMCINMethodData::get_nmethod_mirror(nmethod* nm, bool phantom_ref) {
if (_nmethod_mirror_index == -1) { if (_nmethod_mirror_index == -1) {
return NULL; return nullptr;
} }
if (phantom_ref) { if (phantom_ref) {
return nm->oop_at_phantom(_nmethod_mirror_index); return nm->oop_at_phantom(_nmethod_mirror_index);
@ -794,8 +794,8 @@ oop JVMCINMethodData::get_nmethod_mirror(nmethod* nm, bool phantom_ref) {
void JVMCINMethodData::set_nmethod_mirror(nmethod* nm, oop new_mirror) { void JVMCINMethodData::set_nmethod_mirror(nmethod* nm, oop new_mirror) {
assert(_nmethod_mirror_index != -1, "cannot set JVMCI mirror for nmethod"); assert(_nmethod_mirror_index != -1, "cannot set JVMCI mirror for nmethod");
oop* addr = nm->oop_addr_at(_nmethod_mirror_index); oop* addr = nm->oop_addr_at(_nmethod_mirror_index);
assert(new_mirror != NULL, "use clear_nmethod_mirror to clear the mirror"); assert(new_mirror != nullptr, "use clear_nmethod_mirror to clear the mirror");
assert(*addr == NULL, "cannot overwrite non-null mirror"); assert(*addr == nullptr, "cannot overwrite non-null mirror");
*addr = new_mirror; *addr = new_mirror;
@ -807,14 +807,14 @@ void JVMCINMethodData::set_nmethod_mirror(nmethod* nm, oop new_mirror) {
void JVMCINMethodData::invalidate_nmethod_mirror(nmethod* nm) { void JVMCINMethodData::invalidate_nmethod_mirror(nmethod* nm) {
oop nmethod_mirror = get_nmethod_mirror(nm, /* phantom_ref */ false); oop nmethod_mirror = get_nmethod_mirror(nm, /* phantom_ref */ false);
if (nmethod_mirror == NULL) { if (nmethod_mirror == nullptr) {
return; return;
} }
// Update the values in the mirror if it still refers to nm. // Update the values in the mirror if it still refers to nm.
// We cannot use JVMCIObject to wrap the mirror as this is called // We cannot use JVMCIObject to wrap the mirror as this is called
// during GC, forbidding the creation of JNIHandles. // during GC, forbidding the creation of JNIHandles.
JVMCIEnv* jvmciEnv = NULL; JVMCIEnv* jvmciEnv = nullptr;
nmethod* current = (nmethod*) HotSpotJVMCI::InstalledCode::address(jvmciEnv, nmethod_mirror); nmethod* current = (nmethod*) HotSpotJVMCI::InstalledCode::address(jvmciEnv, nmethod_mirror);
if (nm == current) { if (nm == current) {
if (nm->is_unloading()) { if (nm->is_unloading()) {
@ -865,7 +865,7 @@ int JVMCIRuntime::release_and_clear_oop_handles() {
guarantee(*oop_ptr != nullptr, "unexpected cleared handle"); guarantee(*oop_ptr != nullptr, "unexpected cleared handle");
// Satisfy OopHandles::release precondition that all // Satisfy OopHandles::release precondition that all
// handles being released are null. // handles being released are null.
NativeAccess<>::oop_store(oop_ptr, (oop) NULL); NativeAccess<>::oop_store(oop_ptr, (oop) nullptr);
} }
// Do the bulk release // Do the bulk release
@ -1379,7 +1379,7 @@ void JVMCIRuntime::initialize(JVMCI_TRAPS) {
JavaThread* THREAD = JavaThread::current(); JavaThread* THREAD = JavaThread::current();
int properties_len = 0; int properties_len = 0;
jbyte* properties = NULL; jbyte* properties = nullptr;
MutexLocker locker(_lock); MutexLocker locker(_lock);
// Check again under _lock // Check again under _lock
@ -1612,7 +1612,7 @@ void JVMCIRuntime::fatal_exception(JVMCIEnv* JVMCIENV, const char* message) {
if (!report_error && Atomic::cmpxchg(&report_error, 0, 1) == 0) { if (!report_error && Atomic::cmpxchg(&report_error, 0, 1) == 0) {
// Only report an error once // Only report an error once
tty->print_raw_cr(message); tty->print_raw_cr(message);
if (JVMCIENV != NULL) { if (JVMCIENV != nullptr) {
JVMCIENV->describe_pending_exception(true); JVMCIENV->describe_pending_exception(true);
} else { } else {
describe_pending_hotspot_exception(THREAD, true); describe_pending_hotspot_exception(THREAD, true);
@ -1666,7 +1666,7 @@ Klass* JVMCIRuntime::get_klass_by_name_impl(Klass*& accessing_klass,
Handle loader; Handle loader;
Handle domain; Handle domain;
if (accessing_klass != NULL) { if (accessing_klass != nullptr) {
loader = Handle(THREAD, accessing_klass->class_loader()); loader = Handle(THREAD, accessing_klass->class_loader());
domain = Handle(THREAD, accessing_klass->protection_domain()); domain = Handle(THREAD, accessing_klass->protection_domain());
} }
@ -1701,13 +1701,13 @@ Klass* JVMCIRuntime::get_klass_by_name_impl(Klass*& accessing_klass,
cpool, cpool,
elem_sym, elem_sym,
require_local); require_local);
if (elem_klass != NULL) { if (elem_klass != nullptr) {
// Now make an array for it // Now make an array for it
return elem_klass->array_klass(THREAD); return elem_klass->array_klass(THREAD);
} }
} }
if (found_klass == NULL && !cpool.is_null() && cpool->has_preresolution()) { if (found_klass == nullptr && !cpool.is_null() && cpool->has_preresolution()) {
// Look inside the constant pool for pre-resolved class entries. // Look inside the constant pool for pre-resolved class entries.
for (int i = cpool->length() - 1; i >= 1; i--) { for (int i = cpool->length() - 1; i >= 1; i--) {
if (cpool->tag_at(i).is_klass()) { if (cpool->tag_at(i).is_klass()) {
@ -1742,22 +1742,22 @@ Klass* JVMCIRuntime::get_klass_by_index_impl(const constantPoolHandle& cpool,
Klass* accessor) { Klass* accessor) {
JVMCI_EXCEPTION_CONTEXT; JVMCI_EXCEPTION_CONTEXT;
Klass* klass = ConstantPool::klass_at_if_loaded(cpool, index); Klass* klass = ConstantPool::klass_at_if_loaded(cpool, index);
Symbol* klass_name = NULL; Symbol* klass_name = nullptr;
if (klass == NULL) { if (klass == nullptr) {
klass_name = cpool->klass_name_at(index); klass_name = cpool->klass_name_at(index);
} }
if (klass == NULL) { if (klass == nullptr) {
// Not found in constant pool. Use the name to do the lookup. // Not found in constant pool. Use the name to do the lookup.
Klass* k = get_klass_by_name_impl(accessor, Klass* k = get_klass_by_name_impl(accessor,
cpool, cpool,
klass_name, klass_name,
false); false);
// Calculate accessibility the hard way. // Calculate accessibility the hard way.
if (k == NULL) { if (k == nullptr) {
is_accessible = false; is_accessible = false;
} else if (k->class_loader() != accessor->class_loader() && } else if (k->class_loader() != accessor->class_loader() &&
get_klass_by_name_impl(accessor, cpool, k->name(), true) == NULL) { get_klass_by_name_impl(accessor, cpool, k->name(), true) == nullptr) {
// Loaded only remotely. Not linked yet. // Loaded only remotely. Not linked yet.
is_accessible = false; is_accessible = false;
} else { } else {
@ -1765,7 +1765,7 @@ Klass* JVMCIRuntime::get_klass_by_index_impl(const constantPoolHandle& cpool,
is_accessible = check_klass_accessibility(accessor, k); is_accessible = check_klass_accessibility(accessor, k);
} }
if (!is_accessible) { if (!is_accessible) {
return NULL; return nullptr;
} }
return k; return k;
} }
@ -1823,7 +1823,7 @@ void JVMCIRuntime::get_field_by_index_impl(InstanceKlass* klass, fieldDescriptor
// Perform the field lookup. // Perform the field lookup.
Klass* canonical_holder = Klass* canonical_holder =
InstanceKlass::cast(declared_holder)->find_field(name, signature, &field_desc); InstanceKlass::cast(declared_holder)->find_field(name, signature, &field_desc);
if (canonical_holder == NULL) { if (canonical_holder == nullptr) {
return; return;
} }
@ -1864,7 +1864,7 @@ Method* JVMCIRuntime::lookup_method(InstanceKlass* accessor,
return LinkResolver::linktime_resolve_virtual_method_or_null(link_info); return LinkResolver::linktime_resolve_virtual_method_or_null(link_info);
default: default:
fatal("Unhandled bytecode: %s", Bytecodes::name(bc)); fatal("Unhandled bytecode: %s", Bytecodes::name(bc));
return NULL; // silence compiler warnings return nullptr; // silence compiler warnings
} }
} }
@ -1883,7 +1883,7 @@ Method* JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cpool,
return adapter; return adapter;
} }
return NULL; return nullptr;
} }
int holder_index = cpool->klass_ref_index_at(index); int holder_index = cpool->klass_ref_index_at(index);
@ -1907,7 +1907,7 @@ Method* JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cpool,
case Bytecodes::_invokestatic: case Bytecodes::_invokestatic:
{ {
Method* m = ConstantPool::method_at_if_loaded(cpool, index); Method* m = ConstantPool::method_at_if_loaded(cpool, index);
if (m != NULL) { if (m != nullptr) {
return m; return m;
} }
} }
@ -1920,7 +1920,7 @@ Method* JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cpool,
if (holder_is_accessible) { // Our declared holder is loaded. if (holder_is_accessible) { // Our declared holder is loaded.
constantTag tag = cpool->tag_ref_at(index); constantTag tag = cpool->tag_ref_at(index);
Method* m = lookup_method(accessor, holder, name_sym, sig_sym, bc, tag); Method* m = lookup_method(accessor, holder, name_sym, sig_sym, bc, tag);
if (m != NULL) { if (m != nullptr) {
// We found the method. // We found the method.
return m; return m;
} }
@ -1929,7 +1929,7 @@ Method* JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cpool,
// Either the declared holder was not loaded, or the method could // Either the declared holder was not loaded, or the method could
// not be found. // not be found.
return NULL; return nullptr;
} }
// ------------------------------------------------------------------ // ------------------------------------------------------------------
@ -1944,7 +1944,7 @@ InstanceKlass* JVMCIRuntime::get_instance_klass_for_declared_method_holder(Klass
} else { } else {
ShouldNotReachHere(); ShouldNotReachHere();
} }
return NULL; return nullptr;
} }
@ -1961,12 +1961,12 @@ Method* JVMCIRuntime::get_method_by_index(const constantPoolHandle& cpool,
// class loads, evolution, breakpoints // class loads, evolution, breakpoints
JVMCI::CodeInstallResult JVMCIRuntime::validate_compile_task_dependencies(Dependencies* dependencies, JVMCICompileState* compile_state, char** failure_detail) { JVMCI::CodeInstallResult JVMCIRuntime::validate_compile_task_dependencies(Dependencies* dependencies, JVMCICompileState* compile_state, char** failure_detail) {
// If JVMTI capabilities were enabled during compile, the compilation is invalidated. // If JVMTI capabilities were enabled during compile, the compilation is invalidated.
if (compile_state != NULL && compile_state->jvmti_state_changed()) { if (compile_state != nullptr && compile_state->jvmti_state_changed()) {
*failure_detail = (char*) "Jvmti state change during compilation invalidated dependencies"; *failure_detail = (char*) "Jvmti state change during compilation invalidated dependencies";
return JVMCI::dependencies_failed; return JVMCI::dependencies_failed;
} }
CompileTask* task = compile_state == NULL ? NULL : compile_state->task(); CompileTask* task = compile_state == nullptr ? nullptr : compile_state->task();
Dependencies::DepType result = dependencies->validate_dependencies(task, failure_detail); Dependencies::DepType result = dependencies->validate_dependencies(task, failure_detail);
if (result == Dependencies::end_marker) { if (result == Dependencies::end_marker) {
return JVMCI::ok; return JVMCI::ok;
@ -2089,17 +2089,17 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
int speculations_len) { int speculations_len) {
JVMCI_EXCEPTION_CONTEXT; JVMCI_EXCEPTION_CONTEXT;
CompLevel comp_level = CompLevel_full_optimization; CompLevel comp_level = CompLevel_full_optimization;
char* failure_detail = NULL; char* failure_detail = nullptr;
bool install_default = JVMCIENV->get_HotSpotNmethod_isDefault(nmethod_mirror) != 0; bool install_default = JVMCIENV->get_HotSpotNmethod_isDefault(nmethod_mirror) != 0;
assert(JVMCIENV->isa_HotSpotNmethod(nmethod_mirror), "must be"); assert(JVMCIENV->isa_HotSpotNmethod(nmethod_mirror), "must be");
JVMCIObject name = JVMCIENV->get_InstalledCode_name(nmethod_mirror); JVMCIObject name = JVMCIENV->get_InstalledCode_name(nmethod_mirror);
const char* nmethod_mirror_name = name.is_null() ? NULL : JVMCIENV->as_utf8_string(name); const char* nmethod_mirror_name = name.is_null() ? nullptr : JVMCIENV->as_utf8_string(name);
int nmethod_mirror_index; int nmethod_mirror_index;
if (!install_default) { if (!install_default) {
// Reserve or initialize mirror slot in the oops table. // Reserve or initialize mirror slot in the oops table.
OopRecorder* oop_recorder = debug_info->oop_recorder(); OopRecorder* oop_recorder = debug_info->oop_recorder();
nmethod_mirror_index = oop_recorder->allocate_oop_index(nmethod_mirror.is_hotspot() ? nmethod_mirror.as_jobject() : NULL); nmethod_mirror_index = oop_recorder->allocate_oop_index(nmethod_mirror.is_hotspot() ? nmethod_mirror.as_jobject() : nullptr);
} else { } else {
// A default HotSpotNmethod mirror is never tracked by the nmethod // A default HotSpotNmethod mirror is never tracked by the nmethod
nmethod_mirror_index = -1; nmethod_mirror_index = -1;
@ -2108,7 +2108,7 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
JVMCI::CodeInstallResult result(JVMCI::ok); JVMCI::CodeInstallResult result(JVMCI::ok);
// We require method counters to store some method state (max compilation levels) required by the compilation policy. // We require method counters to store some method state (max compilation levels) required by the compilation policy.
if (method->get_method_counters(THREAD) == NULL) { if (method->get_method_counters(THREAD) == nullptr) {
result = JVMCI::cache_full; result = JVMCI::cache_full;
failure_detail = (char*) "can't create method counters"; failure_detail = (char*) "can't create method counters";
} }
@ -2139,7 +2139,7 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
if (result != JVMCI::ok) { if (result != JVMCI::ok) {
// While not a true deoptimization, it is a preemptive decompile. // While not a true deoptimization, it is a preemptive decompile.
MethodData* mdp = method()->method_data(); MethodData* mdp = method()->method_data();
if (mdp != NULL) { if (mdp != nullptr) {
mdp->inc_decompile_count(); mdp->inc_decompile_count();
#ifdef ASSERT #ifdef ASSERT
if (mdp->decompile_count() > (uint)PerMethodRecompilationCutoff) { if (mdp->decompile_count() > (uint)PerMethodRecompilationCutoff) {
@ -2168,7 +2168,7 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
// Free codeBlobs // Free codeBlobs
if (nm == NULL) { if (nm == nullptr) {
// The CodeCache is full. Print out warning and disable compilation. // The CodeCache is full. Print out warning and disable compilation.
{ {
MutexUnlocker ml(Compile_lock); MutexUnlocker ml(Compile_lock);
@ -2182,18 +2182,18 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
nm->set_has_monitors(has_monitors); nm->set_has_monitors(has_monitors);
JVMCINMethodData* data = nm->jvmci_nmethod_data(); JVMCINMethodData* data = nm->jvmci_nmethod_data();
assert(data != NULL, "must be"); assert(data != nullptr, "must be");
if (install_default) { if (install_default) {
assert(!nmethod_mirror.is_hotspot() || data->get_nmethod_mirror(nm, /* phantom_ref */ false) == NULL, "must be"); assert(!nmethod_mirror.is_hotspot() || data->get_nmethod_mirror(nm, /* phantom_ref */ false) == nullptr, "must be");
if (entry_bci == InvocationEntryBci) { if (entry_bci == InvocationEntryBci) {
// If there is an old version we're done with it // If there is an old version we're done with it
CompiledMethod* old = method->code(); CompiledMethod* old = method->code();
if (TraceMethodReplacement && old != NULL) { if (TraceMethodReplacement && old != nullptr) {
ResourceMark rm; ResourceMark rm;
char *method_name = method->name_and_sig_as_C_string(); char *method_name = method->name_and_sig_as_C_string();
tty->print_cr("Replacing method %s", method_name); tty->print_cr("Replacing method %s", method_name);
} }
if (old != NULL ) { if (old != nullptr ) {
old->make_not_entrant(); old->make_not_entrant();
} }
@ -2238,7 +2238,7 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
} }
// String creation must be done outside lock // String creation must be done outside lock
if (failure_detail != NULL) { if (failure_detail != nullptr) {
// A failure to allocate the string is silently ignored. // A failure to allocate the string is silently ignored.
JVMCIObject message = JVMCIENV->create_string(failure_detail, JVMCIENV); JVMCIObject message = JVMCIENV->create_string(failure_detail, JVMCIENV);
JVMCIENV->set_HotSpotCompiledNmethod_installationFailureMessage(compiled_code, message); JVMCIENV->set_HotSpotCompiledNmethod_installationFailureMessage(compiled_code, message);
@ -2246,7 +2246,7 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
if (result == JVMCI::ok) { if (result == JVMCI::ok) {
JVMCICompileState* state = JVMCIENV->compile_state(); JVMCICompileState* state = JVMCIENV->compile_state();
if (state != NULL) { if (state != nullptr) {
// Compilation succeeded, post what we know about it // Compilation succeeded, post what we know about it
nm->post_compiled_method(state->task()); nm->post_compiled_method(state->task());
} }

24
src/hotspot/share/jvmci/jvmciRuntime.hpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012, 2022, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -69,7 +69,7 @@ public:
// Computes the size of a JVMCINMethodData object // Computes the size of a JVMCINMethodData object
static int compute_size(const char* nmethod_mirror_name) { static int compute_size(const char* nmethod_mirror_name) {
int size = sizeof(JVMCINMethodData); int size = sizeof(JVMCINMethodData);
if (nmethod_mirror_name != NULL) { if (nmethod_mirror_name != nullptr) {
size += (int) strlen(nmethod_mirror_name) + 1; size += (int) strlen(nmethod_mirror_name) + 1;
} }
return size; return size;
@ -82,8 +82,8 @@ public:
// Adds `speculation` to the failed speculations list. // Adds `speculation` to the failed speculations list.
void add_failed_speculation(nmethod* nm, jlong speculation); void add_failed_speculation(nmethod* nm, jlong speculation);
// Gets the JVMCI name of the nmethod (which may be NULL). // Gets the JVMCI name of the nmethod (which may be null).
const char* name() { return _has_name ? (char*)(((address) this) + sizeof(JVMCINMethodData)) : NULL; } const char* name() { return _has_name ? (char*)(((address) this) + sizeof(JVMCINMethodData)) : nullptr; }
// Clears the HotSpotNmethod.address field in the mirror. If nm // Clears the HotSpotNmethod.address field in the mirror. If nm
// is dead, the HotSpotNmethod.entryPoint field is also cleared. // is dead, the HotSpotNmethod.entryPoint field is also cleared.
@ -210,7 +210,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
// If such a runtime exists, its _num_attached_threads is incremented // If such a runtime exists, its _num_attached_threads is incremented
// and the caller must subsequently attach `thread` to it. // and the caller must subsequently attach `thread` to it.
// JVMCI_lock must be held by current thread. // JVMCI_lock must be held by current thread.
// If nullptr is returned, then `*count` contains the number of JVMCIRuntimes // If null is returned, then `*count` contains the number of JVMCIRuntimes
// currently allocated. // currently allocated.
static JVMCIRuntime* select_runtime(JavaThread* thread, JVMCIRuntime* skip, int* count); static JVMCIRuntime* select_runtime(JavaThread* thread, JVMCIRuntime* skip, int* count);
@ -235,7 +235,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
// Ensures that a JVMCI shared library JavaVM exists for this runtime. // Ensures that a JVMCI shared library JavaVM exists for this runtime.
// If the JavaVM was created by this call, then the thread-local JNI // If the JavaVM was created by this call, then the thread-local JNI
// interface pointer for the JavaVM is returned otherwise nullptr is returned. // interface pointer for the JavaVM is returned otherwise null is returned.
JNIEnv* init_shared_library_javavm(); JNIEnv* init_shared_library_javavm();
// Determines if the JVMCI shared library JavaVM exists for this runtime. // Determines if the JVMCI shared library JavaVM exists for this runtime.
@ -338,7 +338,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
// Shuts down this runtime by calling HotSpotJVMCIRuntime.shutdown(). // Shuts down this runtime by calling HotSpotJVMCIRuntime.shutdown().
// If this is the last thread attached to this runtime, then // If this is the last thread attached to this runtime, then
// `_HotSpotJVMCIRuntime_instance` is set to nullptr and `_init_state` // `_HotSpotJVMCIRuntime_instance` is set to null and `_init_state`
// to uninitialized. // to uninitialized.
void shutdown(); void shutdown();
@ -349,7 +349,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
void bootstrap_finished(TRAPS); void bootstrap_finished(TRAPS);
// Look up a klass by name from a particular class loader (the accessor's). // Look up a klass by name from a particular class loader (the accessor's).
// If require_local, result must be defined in that class loader, or NULL. // If require_local, result must be defined in that class loader, or null.
// If !require_local, a result from remote class loader may be reported, // If !require_local, a result from remote class loader may be reported,
// if sufficient class loader constraints exist such that initiating // if sufficient class loader constraints exist such that initiating
// a class loading request from the given loader is bound to return // a class loading request from the given loader is bound to return
@ -429,7 +429,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
if (HAS_PENDING_EXCEPTION) { \ if (HAS_PENDING_EXCEPTION) { \
char buf[256]; \ char buf[256]; \
jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \ jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
JVMCIRuntime::fatal_exception(NULL, buf); \ JVMCIRuntime::fatal_exception(nullptr, buf); \
return; \ return; \
} \ } \
(void)(0 (void)(0
@ -438,7 +438,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
if (HAS_PENDING_EXCEPTION) { \ if (HAS_PENDING_EXCEPTION) { \
char buf[256]; \ char buf[256]; \
jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \ jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
JVMCIRuntime::fatal_exception(NULL, buf); \ JVMCIRuntime::fatal_exception(nullptr, buf); \
return v; \ return v; \
} \ } \
(void)(0 (void)(0
@ -474,7 +474,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
// When allocation fails, these stubs: // When allocation fails, these stubs:
// 1. Exercise -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError handling and also // 1. Exercise -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError handling and also
// post a JVMTI_EVENT_RESOURCE_EXHAUSTED event if the failure is an OutOfMemroyError // post a JVMTI_EVENT_RESOURCE_EXHAUSTED event if the failure is an OutOfMemroyError
// 2. Return NULL with a pending exception. // 2. Return null with a pending exception.
// Compiled code must ensure these stubs are not called twice for the same allocation // Compiled code must ensure these stubs are not called twice for the same allocation
// site due to the non-repeatable side effects in the case of OOME. // site due to the non-repeatable side effects in the case of OOME.
static void new_instance(JavaThread* current, Klass* klass) { new_instance_common(current, klass, false); } static void new_instance(JavaThread* current, Klass* klass) { new_instance_common(current, klass, false); }
@ -483,7 +483,7 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
static void dynamic_new_array(JavaThread* current, oopDesc* element_mirror, jint length) { dynamic_new_array_common(current, element_mirror, length, false); } static void dynamic_new_array(JavaThread* current, oopDesc* element_mirror, jint length) { dynamic_new_array_common(current, element_mirror, length, false); }
static void dynamic_new_instance(JavaThread* current, oopDesc* type_mirror) { dynamic_new_instance_common(current, type_mirror, false); } static void dynamic_new_instance(JavaThread* current, oopDesc* type_mirror) { dynamic_new_instance_common(current, type_mirror, false); }
// When allocation fails, these stubs return NULL and have no pending exception. Compiled code // When allocation fails, these stubs return null and have no pending exception. Compiled code
// can use these stubs if a failed allocation will be retried (e.g., by deoptimizing and // can use these stubs if a failed allocation will be retried (e.g., by deoptimizing and
// re-executing in the interpreter). // re-executing in the interpreter).
static void new_instance_or_null(JavaThread* thread, Klass* klass) { new_instance_common(thread, klass, true); } static void new_instance_or_null(JavaThread* thread, Klass* klass) { new_instance_common(thread, klass, true); }

14
src/hotspot/share/jvmci/jvmci_globals.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2000, 2021, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2000, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -34,7 +34,7 @@
#include "utilities/defaultStream.hpp" #include "utilities/defaultStream.hpp"
#include "utilities/ostream.hpp" #include "utilities/ostream.hpp"
fileStream* JVMCIGlobals::_jni_config_file = NULL; fileStream* JVMCIGlobals::_jni_config_file = nullptr;
// Return true if jvmci flags are consistent. // Return true if jvmci flags are consistent.
bool JVMCIGlobals::check_jvmci_flags_are_consistent() { bool JVMCIGlobals::check_jvmci_flags_are_consistent() {
@ -151,9 +151,9 @@ bool JVMCIGlobals::check_jvmci_flags_are_consistent() {
#endif // PRODUCT #endif // PRODUCT
#undef CHECK_NOT_SET #undef CHECK_NOT_SET
if (JVMCILibDumpJNIConfig != NULL) { if (JVMCILibDumpJNIConfig != nullptr) {
_jni_config_file = new(mtJVMCI) fileStream(JVMCILibDumpJNIConfig); _jni_config_file = new(mtJVMCI) fileStream(JVMCILibDumpJNIConfig);
if (_jni_config_file == NULL || !_jni_config_file->is_open()) { if (_jni_config_file == nullptr || !_jni_config_file->is_open()) {
jio_fprintf(defaultStream::error_stream(), jio_fprintf(defaultStream::error_stream(),
"Could not open file for dumping JVMCI shared library JNI config: %s\n", JVMCILibDumpJNIConfig); "Could not open file for dumping JVMCI shared library JNI config: %s\n", JVMCILibDumpJNIConfig);
return false; return false;
@ -184,12 +184,12 @@ bool JVMCIGlobals::enable_jvmci_product_mode(JVMFlagOrigin origin) {
"UseJVMCINativeLibrary", "UseJVMCINativeLibrary",
"JVMCINativeLibraryThreadFraction", "JVMCINativeLibraryThreadFraction",
"JVMCINativeLibraryErrorFile", "JVMCINativeLibraryErrorFile",
NULL nullptr
}; };
for (int i = 0; JVMCIFlags[i] != NULL; i++) { for (int i = 0; JVMCIFlags[i] != nullptr; i++) {
JVMFlag *jvmciFlag = (JVMFlag *)JVMFlag::find_declared_flag(JVMCIFlags[i]); JVMFlag *jvmciFlag = (JVMFlag *)JVMFlag::find_declared_flag(JVMCIFlags[i]);
if (jvmciFlag == NULL) { if (jvmciFlag == nullptr) {
return false; return false;
} }
jvmciFlag->clear_experimental(); jvmciFlag->clear_experimental();

8
src/hotspot/share/jvmci/jvmci_globals.hpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2000, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -129,10 +129,10 @@ class fileStream;
"Maximum size of a compiled method.") \ "Maximum size of a compiled method.") \
range(0, max_jint) \ range(0, max_jint) \
\ \
product(ccstr, JVMCILibPath, NULL, EXPERIMENTAL, \ product(ccstr, JVMCILibPath, nullptr, EXPERIMENTAL, \
"LD path for loading the JVMCI shared library") \ "LD path for loading the JVMCI shared library") \
\ \
product(ccstr, JVMCILibDumpJNIConfig, NULL, EXPERIMENTAL, \ product(ccstr, JVMCILibDumpJNIConfig, nullptr, EXPERIMENTAL, \
"Dumps to the given file a description of the classes, fields " \ "Dumps to the given file a description of the classes, fields " \
"and methods the JVMCI shared library must provide") \ "and methods the JVMCI shared library must provide") \
\ \
@ -147,7 +147,7 @@ class fileStream;
"The remaining compiler threads are used by C1.") \ "The remaining compiler threads are used by C1.") \
range(0.0, 1.0) \ range(0.0, 1.0) \
\ \
product(ccstr, JVMCINativeLibraryErrorFile, NULL, EXPERIMENTAL, \ product(ccstr, JVMCINativeLibraryErrorFile, nullptr, EXPERIMENTAL, \
"If an error in the JVMCI native library occurs, save the " \ "If an error in the JVMCI native library occurs, save the " \
"error data to this file" \ "error data to this file" \
"[default: ./" LIBJVMCI_ERR_FILE "] (%p replaced with pid)") \ "[default: ./" LIBJVMCI_ERR_FILE "] (%p replaced with pid)") \

28
src/hotspot/share/jvmci/metadataHandles.cpp
View File

@ -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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -29,7 +29,7 @@
jmetadata MetadataHandles::allocate_metadata_handle(Metadata* obj) { jmetadata MetadataHandles::allocate_metadata_handle(Metadata* obj) {
assert(obj->is_valid() && obj->is_metadata(), "must be"); assert(obj->is_valid() && obj->is_metadata(), "must be");
if (_head == NULL) { if (_head == nullptr) {
// This is the first allocation. // This is the first allocation.
_head = new MetadataHandleBlock(); _head = new MetadataHandleBlock();
_last = _head; _last = _head;
@ -38,7 +38,7 @@ jmetadata MetadataHandles::allocate_metadata_handle(Metadata* obj) {
HandleRecord* handle = get_handle(); HandleRecord* handle = get_handle();
if (handle != NULL) { if (handle != nullptr) {
handle->set_value(obj); handle->set_value(obj);
#ifdef METADATA_TRACK_NAMES #ifdef METADATA_TRACK_NAMES
handle->set_name(obj->print_value_string()); handle->set_name(obj->print_value_string());
@ -47,7 +47,7 @@ jmetadata MetadataHandles::allocate_metadata_handle(Metadata* obj) {
} }
// Check if an unused block follows last // Check if an unused block follows last
if (_last->_next != NULL) { if (_last->_next != nullptr) {
// update last and retry // update last and retry
_last = _last->_next; _last = _last->_next;
return allocate_metadata_handle(obj); return allocate_metadata_handle(obj);
@ -71,10 +71,10 @@ void MetadataHandles::rebuild_free_list() {
assert(_allocate_before_rebuild == 0 && _free_list == 0, "just checking"); assert(_allocate_before_rebuild == 0 && _free_list == 0, "just checking");
int free = 0; int free = 0;
int blocks = 0; int blocks = 0;
for (MetadataHandleBlock* current = _head; current != NULL; current = current->_next) { for (MetadataHandleBlock* current = _head; current != nullptr; current = current->_next) {
for (int index = 0; index < current->_top; index++) { for (int index = 0; index < current->_top; index++) {
HandleRecord* handle = &(current->_handles)[index]; HandleRecord* handle = &(current->_handles)[index];
if (handle->value() == NULL) { if (handle->value() == nullptr) {
// this handle was cleared out by a delete call, reuse it // this handle was cleared out by a delete call, reuse it
chain_free_list(handle); chain_free_list(handle);
free++; free++;
@ -100,8 +100,8 @@ void MetadataHandles::rebuild_free_list() {
void MetadataHandles::clear() { void MetadataHandles::clear() {
_free_list = 0; _free_list = 0;
_last = _head; _last = _head;
if (_head != NULL) { if (_head != nullptr) {
for (MetadataHandleBlock* block = _head; block != NULL; block = block->_next) { for (MetadataHandleBlock* block = _head; block != nullptr; block = block->_next) {
block->_top = 0; block->_top = 0;
} }
} }
@ -110,13 +110,13 @@ void MetadataHandles::clear() {
} }
void MetadataHandles::metadata_do(void f(Metadata*)) { void MetadataHandles::metadata_do(void f(Metadata*)) {
for (MetadataHandleBlock* current = _head; current != NULL; current = current->_next) { for (MetadataHandleBlock* current = _head; current != nullptr; current = current->_next) {
for (int index = 0; index < current->_top; index++) { for (int index = 0; index < current->_top; index++) {
HandleRecord* root = &(current->_handles)[index]; HandleRecord* root = &(current->_handles)[index];
Metadata* value = root->value(); Metadata* value = root->value();
// traverse heap pointers only, not deleted handles or free list // traverse heap pointers only, not deleted handles or free list
// pointers // pointers
if (value != NULL && ((intptr_t) value & ptr_tag) == 0) { if (value != nullptr && ((intptr_t) value & ptr_tag) == 0) {
assert(value->is_valid(), "invalid metadata %s", current->get_name(index)); assert(value->is_valid(), "invalid metadata %s", current->get_name(index));
f(value); f(value);
} }
@ -131,14 +131,14 @@ void MetadataHandles::metadata_do(void f(Metadata*)) {
// Visit any live metadata handles and clean them up. Since clearing of these handles is driven by // Visit any live metadata handles and clean them up. Since clearing of these handles is driven by
// weak references they will be cleared at some point in the future when the reference cleaning logic is run. // weak references they will be cleared at some point in the future when the reference cleaning logic is run.
void MetadataHandles::do_unloading() { void MetadataHandles::do_unloading() {
for (MetadataHandleBlock* current = _head; current != NULL; current = current->_next) { for (MetadataHandleBlock* current = _head; current != nullptr; current = current->_next) {
for (int index = 0; index < current->_top; index++) { for (int index = 0; index < current->_top; index++) {
HandleRecord* handle = &(current->_handles)[index]; HandleRecord* handle = &(current->_handles)[index];
Metadata* value = handle->value(); Metadata* value = handle->value();
// traverse heap pointers only, not deleted handles or free list // traverse heap pointers only, not deleted handles or free list
// pointers // pointers
if (value != NULL && ((intptr_t) value & ptr_tag) == 0) { if (value != nullptr && ((intptr_t) value & ptr_tag) == 0) {
Klass* klass = NULL; Klass* klass = nullptr;
if (value->is_klass()) { if (value->is_klass()) {
klass = (Klass*)value; klass = (Klass*)value;
} else if (value->is_method()) { } else if (value->is_method()) {
@ -153,7 +153,7 @@ void MetadataHandles::do_unloading() {
if (klass->class_loader_data()->is_unloading()) { if (klass->class_loader_data()->is_unloading()) {
// This needs to be marked so that it's no longer scanned // This needs to be marked so that it's no longer scanned
// but can't be put on the free list yet. The // but can't be put on the free list yet. The
// HandleCleaner will set this to NULL and // HandleCleaner will set this to null and
// put it on the free list. // put it on the free list.
jlong old_value = Atomic::cmpxchg((jlong*)handle, (jlong) value, (jlong) (ptr_tag)); jlong old_value = Atomic::cmpxchg((jlong*)handle, (jlong) value, (jlong) (ptr_tag));
if (old_value == (jlong) value) { if (old_value == (jlong) value) {

28
src/hotspot/share/jvmci/metadataHandles.hpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 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. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -47,8 +47,8 @@ struct _jmetadata {
#ifdef METADATA_TRACK_NAMES #ifdef METADATA_TRACK_NAMES
void initialize() { void initialize() {
_value = NULL; _value = nullptr;
_name = NULL; _name = nullptr;
} }
#endif #endif
@ -59,11 +59,11 @@ struct _jmetadata {
#ifdef METADATA_TRACK_NAMES #ifdef METADATA_TRACK_NAMES
const char* name() { return _name; } const char* name() { return _name; }
void set_name(const char* name) { void set_name(const char* name) {
if (_name != NULL) { if (_name != nullptr) {
os::free((void*) _name); os::free((void*) _name);
_name = NULL; _name = nullptr;
} }
if (name != NULL) { if (name != nullptr) {
_name = os::strdup(name); _name = os::strdup(name);
} }
} }
@ -83,7 +83,7 @@ class MetadataHandleBlock : public CHeapObj<mtJVMCI> {
// Free handles always have their low bit set so those pointers can // Free handles always have their low bit set so those pointers can
// be distinguished from handles which are in use. The last handle // be distinguished from handles which are in use. The last handle
// on the free list has a NULL pointer with the tag bit set, so it's // on the free list has a null pointer with the tag bit set, so it's
// clear that the handle has been reclaimed. The _free_list is // clear that the handle has been reclaimed. The _free_list is
// always a real pointer to a handle. // always a real pointer to a handle.
@ -93,7 +93,7 @@ class MetadataHandleBlock : public CHeapObj<mtJVMCI> {
MetadataHandleBlock() { MetadataHandleBlock() {
_top = 0; _top = 0;
_next = NULL; _next = nullptr;
#ifdef METADATA_TRACK_NAMES #ifdef METADATA_TRACK_NAMES
for (int i = 0; i < block_size_in_handles; i++) { for (int i = 0; i < block_size_in_handles; i++) {
_handles[i].initialize(); _handles[i].initialize();
@ -113,7 +113,7 @@ class MetadataHandleBlock : public CHeapObj<mtJVMCI> {
// JVMCI maintains direct references to metadata. To make these references safe in the face of // JVMCI maintains direct references to metadata. To make these references safe in the face of
// class redefinition, they are held in handles so they can be scanned during GC. They are // class redefinition, they are held in handles so they can be scanned during GC. They are
// managed in a cooperative way between the Java code and HotSpot. A handle is filled in and // managed in a cooperative way between the Java code and HotSpot. A handle is filled in and
// passed back to the Java code which is responsible for setting the handle to NULL when it // passed back to the Java code which is responsible for setting the handle to null when it
// is no longer in use. This is done by jdk.vm.ci.hotspot.HandleCleaner. The // is no longer in use. This is done by jdk.vm.ci.hotspot.HandleCleaner. The
// rebuild_free_list function notices when the handle is clear and reclaims it for re-use. // rebuild_free_list function notices when the handle is clear and reclaims it for re-use.
class MetadataHandles : public CHeapObj<mtJVMCI> { class MetadataHandles : public CHeapObj<mtJVMCI> {
@ -140,7 +140,7 @@ class MetadataHandles : public CHeapObj<mtJVMCI> {
} }
HandleRecord* get_handle() { HandleRecord* get_handle() {
assert(_last != NULL, "sanity"); assert(_last != nullptr, "sanity");
// Try last block // Try last block
if (_last->_top < MetadataHandleBlock::block_size_in_handles) { if (_last->_top < MetadataHandleBlock::block_size_in_handles) {
_num_handles++; _num_handles++;
@ -149,7 +149,7 @@ class MetadataHandles : public CHeapObj<mtJVMCI> {
// Try free list // Try free list
return get_free_handle(); return get_free_handle();
} }
return NULL; return nullptr;
} }
void rebuild_free_list(); void rebuild_free_list();
@ -158,8 +158,8 @@ class MetadataHandles : public CHeapObj<mtJVMCI> {
public: public:
MetadataHandles() { MetadataHandles() {
_head = NULL; _head = nullptr;
_last = NULL; _last = nullptr;
_free_list = 0; _free_list = 0;
_allocate_before_rebuild = 0; _allocate_before_rebuild = 0;
_num_blocks = 0; _num_blocks = 0;
@ -178,7 +178,7 @@ class MetadataHandles : public CHeapObj<mtJVMCI> {
void chain_free_list(HandleRecord* handle) { void chain_free_list(HandleRecord* handle) {
handle->set_value((Metadata*) (ptr_tag | _free_list)); handle->set_value((Metadata*) (ptr_tag | _free_list));
#ifdef METADATA_TRACK_NAMES #ifdef METADATA_TRACK_NAMES
handle->set_name(NULL); handle->set_name(nullptr);
#endif #endif
_free_list = (intptr_t) handle; _free_list = (intptr_t) handle;
_num_free_handles++; _num_free_handles++;

10
src/hotspot/share/jvmci/vmStructs_jvmci.hpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -30,24 +30,24 @@
class JVMCIVMStructs { class JVMCIVMStructs {
public: public:
/** /**
* The last entry has a NULL fieldName. * The last entry has a null fieldName.
*/ */
static VMStructEntry localHotSpotVMStructs[]; static VMStructEntry localHotSpotVMStructs[];
/** /**
* The last entry has a NULL typeName. * The last entry has a null typeName.
*/ */
static VMTypeEntry localHotSpotVMTypes[]; static VMTypeEntry localHotSpotVMTypes[];
/** /**
* Table of integer constants. * Table of integer constants.
* The last entry has a NULL typeName. * The last entry has a null typeName.
*/ */
static VMIntConstantEntry localHotSpotVMIntConstants[]; static VMIntConstantEntry localHotSpotVMIntConstants[];
/** /**
* Table of long constants. * Table of long constants.
* The last entry has a NULL typeName. * The last entry has a null typeName.
*/ */
static VMLongConstantEntry localHotSpotVMLongConstants[]; static VMLongConstantEntry localHotSpotVMLongConstants[];