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

8300244: Replace NULL with nullptr in share/interpreter/

Browse Source 
Reviewed-by: coleenp, dholmes
This commit is contained in:
Johan Sjölen 2023-01-25 10:31:51 +00:00
parent 71107f4648
commit a5d8e12872
25 changed files with 553 additions and 553 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/hotspot/share/interpreter/abstractInterpreter.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -83,12 +83,12 @@ void AbstractInterpreter::print() {
//------------------------------------------------------------------------------------------------------------------------
// Implementation of interpreter
StubQueue* AbstractInterpreter::_code = NULL;
StubQueue* AbstractInterpreter::_code = nullptr;
bool AbstractInterpreter::_notice_safepoints = false;
address AbstractInterpreter::_rethrow_exception_entry = NULL;
address AbstractInterpreter::_rethrow_exception_entry = nullptr;
address AbstractInterpreter::_native_entry_begin = NULL;
address AbstractInterpreter::_native_entry_end = NULL;
address AbstractInterpreter::_native_entry_begin = nullptr;
address AbstractInterpreter::_native_entry_end = nullptr;
address AbstractInterpreter::_slow_signature_handler;
address AbstractInterpreter::_entry_table [AbstractInterpreter::number_of_method_entries];
address AbstractInterpreter::_native_abi_to_tosca [AbstractInterpreter::number_of_result_handlers];
@ -97,7 +97,7 @@ address AbstractInterpreter::_native_abi_to_tosca [AbstractInterpreter::nu
// Generation of complete interpreter
AbstractInterpreterGenerator::AbstractInterpreterGenerator() {
_masm = NULL;
_masm = nullptr;
}
@ -231,7 +231,7 @@ bool AbstractInterpreter::is_not_reached(const methodHandle& method, int bci) {
int method_index = invoke_bc.get_index_u2_cpcache(code);
constantPoolHandle cp(Thread::current(), cpool);
Method* resolved_method = ConstantPool::method_at_if_loaded(cp, method_index);
return (resolved_method == NULL);
return (resolved_method == nullptr);
}
default: ShouldNotReachHere();
}

6
src/hotspot/share/interpreter/abstractInterpreter.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -168,8 +168,8 @@ class AbstractInterpreter: AllStatic {
// Runtime support
// length = invoke bytecode length (to advance to next bytecode)
static address deopt_entry(TosState state, int length) { ShouldNotReachHere(); return NULL; }
static address return_entry(TosState state, int length, Bytecodes::Code code) { ShouldNotReachHere(); return NULL; }
static address deopt_entry(TosState state, int length) { ShouldNotReachHere(); return nullptr; }
static address return_entry(TosState state, int length, Bytecodes::Code code) { ShouldNotReachHere(); return nullptr; }
static address rethrow_exception_entry() { return _rethrow_exception_entry; }

10
src/hotspot/share/interpreter/bootstrapInfo.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.
*
* This code is free software; you can redistribute it and/or modify it
@ -188,9 +188,9 @@ void BootstrapInfo::resolve_args(TRAPS) {
objArrayOop args_oop = oopFactory::new_objArray(vmClasses::Object_klass(), _argc, CHECK);
objArrayHandle args(THREAD, args_oop);
_pool->copy_bootstrap_arguments_at(_bss_index, 0, _argc, args, 0, true, Handle(), CHECK);
oop arg_oop = ((_argc == 1) ? args->obj_at(0) : (oop)NULL);
oop arg_oop = ((_argc == 1) ? args->obj_at(0) : (oop)nullptr);
// try to discard the singleton array
if (arg_oop != NULL && !arg_oop->is_array()) {
if (arg_oop != nullptr && !arg_oop->is_array()) {
// JVM treats arrays and nulls specially in this position,
// but other things are just single arguments
_arg_values = Handle(THREAD, arg_oop);
@ -233,7 +233,7 @@ void BootstrapInfo::print_msg_on(outputStream* st, const char* msg) {
os::snprintf_checked(what, sizeof(what), "indy#%d", decode_indy_index());
else
os::snprintf_checked(what, sizeof(what), "condy");
bool have_msg = (msg != NULL && strlen(msg) > 0);
bool have_msg = (msg != nullptr && strlen(msg) > 0);
st->print_cr("%s%sBootstrap in %s %s@CP[%d] %s:%s%s BSMS[%d] BSM@CP[%d]%s argc=%d%s",
(have_msg ? msg : ""), (have_msg ? " " : ""),
caller()->name()->as_C_string(),
@ -276,7 +276,7 @@ void BootstrapInfo::print_msg_on(outputStream* st, const char* msg) {
int lines = 0;
for (int i = 0; i < _argc; i++) {
oop x = static_args->obj_at(i);
if (x != NULL) {
if (x != nullptr) {
if (++lines > 6) {
st->print_cr(" resolved arg[%d]: ...", i);
break;

4
src/hotspot/share/interpreter/bootstrapInfo.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.
*
* This code is free software; you can redistribute it and/or modify it
@ -114,7 +114,7 @@ class BootstrapInfo : public StackObj {
}
void print() { print_msg_on(tty); }
void print_msg_on(outputStream* st, const char* msg = NULL);
void print_msg_on(outputStream* st, const char* msg = nullptr);
};
#endif // SHARE_INTERPRETER_BOOTSTRAPINFO_HPP

6
src/hotspot/share/interpreter/bytecode.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -120,7 +120,7 @@ int Bytecode_tableswitch::dest_offset_at(int i) const {
void Bytecode_invoke::verify() const {
assert(is_valid(), "check invoke");
assert(cpcache() != NULL, "do not call this from verifier or rewriter");
assert(cpcache() != nullptr, "do not call this from verifier or rewriter");
}
int Bytecode_invoke::size_of_parameters() const {
@ -208,7 +208,7 @@ BasicType Bytecode_loadconstant::result_type() const {
}
oop Bytecode_loadconstant::resolve_constant(TRAPS) const {
assert(_method != NULL, "must supply method to resolve constant");
assert(_method != nullptr, "must supply method to resolve constant");
int index = raw_index();
ConstantPool* constants = _method->constants();
if (has_cache_index()) {

8
src/hotspot/share/interpreter/bytecode.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -56,10 +56,10 @@ class Bytecode: public StackObj {
public:
Bytecode(Method* method, address bcp): _bcp(bcp), _code(Bytecodes::code_at(method, addr_at(0))) {
assert(method != NULL, "this form requires a valid Method*");
assert(method != nullptr, "this form requires a valid Method*");
}
// Defined in ciStreams.hpp
inline Bytecode(const ciBytecodeStream* stream, address bcp = NULL);
inline Bytecode(const ciBytecodeStream* stream, address bcp = nullptr);
// Attributes
address bcp() const { return _bcp; }
@ -323,7 +323,7 @@ class Bytecode_loadconstant: public Bytecode {
Bytecode_loadconstant(const methodHandle& method, int bci): Bytecode(method(), method->bcp_from(bci)), _method(method()) { verify(); }
void verify() const {
assert(_method != NULL, "must supply method");
assert(_method != nullptr, "must supply method");
Bytecodes::Code stdc = Bytecodes::java_code(code());
assert(stdc == Bytecodes::_ldc ||
stdc == Bytecodes::_ldc_w ||

14
src/hotspot/share/interpreter/bytecodeTracer.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -201,8 +201,8 @@ void print_symbol(Symbol* sym, outputStream* st) {
}
void print_oop(oop value, outputStream* st) {
if (value == NULL) {
st->print_cr(" NULL");
if (value == nullptr) {
st->print_cr(" null");
} else if (java_lang_String::is_instance(value)) {
char buf[40];
int len = java_lang_String::utf8_length(value);
@ -256,7 +256,7 @@ bool BytecodePrinter::check_cp_cache_index(int i, int& cp_index, outputStream* s
ConstantPoolCache* cache = constants->cache();
// If rewriter hasn't run, the index is the cp_index
if (cache == NULL) {
if (cache == nullptr) {
cp_index = i;
return true;
}
@ -503,7 +503,7 @@ void BytecodePrinter::print_attributes(int bci, outputStream* st) {
case Bytecodes::_newarray: {
BasicType atype = (BasicType)get_index_u1();
const char* str = type2name(atype);
if (str == NULL || is_reference_type(atype)) {
if (str == nullptr || is_reference_type(atype)) {
assert(false, "Unidentified basic type");
}
st->print_cr(" %s", str);
@ -649,9 +649,9 @@ void BytecodePrinter::print_attributes(int bci, outputStream* st) {
void BytecodePrinter::bytecode_epilog(int bci, outputStream* st) {
MethodData* mdo = method()->method_data();
if (mdo != NULL) {
if (mdo != nullptr) {
ProfileData* data = mdo->bci_to_data(bci);
if (data != NULL) {
if (data != nullptr) {
st->print(" %d", mdo->dp_to_di(data->dp()));
st->fill_to(6);
data->print_data_on(st, mdo);

26
src/hotspot/share/interpreter/bytecodeUtils.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2019, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2019 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -193,7 +193,7 @@ class ExceptionMessageBuilder : public StackObj {
int do_instruction(int bci);
bool print_NPE_cause0(outputStream *os, int bci, int slot, int max_detail,
bool inner_expr = false, const char *prefix = NULL);
bool inner_expr = false, const char *prefix = nullptr);
public:
@ -469,7 +469,7 @@ ExceptionMessageBuilder::ExceptionMessageBuilder(Method* method, int bci) :
_stacks = new GrowableArray<SimulatedOperandStack*> (len + 1);
for (int i = 0; i <= len; ++i) {
_stacks->push(NULL);
_stacks->push(nullptr);
}
// Initialize stack a bci 0.
@ -481,7 +481,7 @@ ExceptionMessageBuilder::ExceptionMessageBuilder(Method* method, int bci) :
for (int i = 0; i < const_method->exception_table_length(); ++i) {
u2 index = et[i].handler_pc;
if (_stacks->at(index) == NULL) {
if (_stacks->at(index) == nullptr) {
_stacks->at_put(index, new SimulatedOperandStack());
_stacks->at(index)->push(index, T_OBJECT);
}
@ -499,7 +499,7 @@ ExceptionMessageBuilder::ExceptionMessageBuilder(Method* method, int bci) :
i += do_instruction(i);
// If we want the data only for a certain bci, we can possibly end early.
if ((bci == i) && (_stacks->at(i) != NULL)) {
if ((bci == i) && (_stacks->at(i) != nullptr)) {
_all_processed = true;
break;
}
@ -512,7 +512,7 @@ ExceptionMessageBuilder::ExceptionMessageBuilder(Method* method, int bci) :
}
ExceptionMessageBuilder::~ExceptionMessageBuilder() {
if (_stacks != NULL) {
if (_stacks != nullptr) {
for (int i = 0; i < _stacks->length(); ++i) {
delete _stacks->at(i);
}
@ -522,7 +522,7 @@ ExceptionMessageBuilder::~ExceptionMessageBuilder() {
void ExceptionMessageBuilder::merge(int bci, SimulatedOperandStack* stack) {
assert(stack != _stacks->at(bci), "Cannot merge itself");
if (_stacks->at(bci) != NULL) {
if (_stacks->at(bci) != nullptr) {
stack->merge(*_stacks->at(bci));
} else {
// Got a new stack, so count the entries.
@ -542,7 +542,7 @@ int ExceptionMessageBuilder::do_instruction(int bci) {
int len = Bytecodes::java_length_at(_method, code_base + bci);
// If we have no stack for this bci, we cannot process the bytecode now.
if (_stacks->at(bci) == NULL) {
if (_stacks->at(bci) == nullptr) {
_all_processed = false;
return len;
}
@ -1066,7 +1066,7 @@ int ExceptionMessageBuilder::do_instruction(int bci) {
// Put new stack to the next instruction, if we might reach it from
// this bci.
if (!flow_ended) {
if (_stacks->at(bci + len) == NULL) {
if (_stacks->at(bci + len) == nullptr) {
_added_one = true;
}
merge(bci + len, stack);
@ -1074,7 +1074,7 @@ int ExceptionMessageBuilder::do_instruction(int bci) {
// Put the stack to the branch target too.
if (dest_bci != -1) {
if (_stacks->at(dest_bci) == NULL) {
if (_stacks->at(dest_bci) == nullptr) {
_added_one = true;
}
merge(dest_bci, stack);
@ -1082,7 +1082,7 @@ int ExceptionMessageBuilder::do_instruction(int bci) {
// If we have more than one branch target, process these too.
for (int64_t i = 0; i < dests.length(); ++i) {
if (_stacks->at(dests.at(i)) == NULL) {
if (_stacks->at(dests.at(i)) == nullptr) {
_added_one = true;
}
merge(dests.at(i), stack);
@ -1200,7 +1200,7 @@ bool ExceptionMessageBuilder::print_NPE_cause0(outputStream* os, int bci, int sl
return false;
}
if (_stacks->at(bci) == NULL) {
if (_stacks->at(bci) == nullptr) {
return false;
}
@ -1228,7 +1228,7 @@ bool ExceptionMessageBuilder::print_NPE_cause0(outputStream* os, int bci, int sl
}
if (max_detail == _max_cause_detail &&
prefix != NULL &&
prefix != nullptr &&
code != Bytecodes::_invokevirtual &&
code != Bytecodes::_invokespecial &&
code != Bytecodes::_invokestatic &&

502
src/hotspot/share/interpreter/bytecodes.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -72,7 +72,7 @@ Bytecodes::Code Bytecodes::code_at(Method* method, int bci) {
}
Bytecodes::Code Bytecodes::non_breakpoint_code_at(const Method* method, address bcp) {
assert(method != NULL, "must have the method for breakpoint conversion");
assert(method != nullptr, "must have the method for breakpoint conversion");
assert(method->contains(bcp), "must be valid bcp in method");
return method->orig_bytecode_at(method->bci_from(bcp));
}
@ -80,13 +80,13 @@ Bytecodes::Code Bytecodes::non_breakpoint_code_at(const Method* method, address
int Bytecodes::special_length_at(Bytecodes::Code code, address bcp, address end) {
switch (code) {
case _wide:
if (end != NULL && bcp + 1 >= end) {
if (end != nullptr && bcp + 1 >= end) {
return -1; // don't read past end of code buffer
}
return wide_length_for(cast(*(bcp + 1)));
case _tableswitch:
{ address aligned_bcp = align_up(bcp + 1, jintSize);
if (end != NULL && aligned_bcp + 3*jintSize >= end) {
if (end != nullptr && aligned_bcp + 3*jintSize >= end) {
return -1; // don't read past end of code buffer
}
jlong lo = (jint)Bytes::get_Java_u4(aligned_bcp + 1*jintSize);
@ -101,7 +101,7 @@ int Bytecodes::special_length_at(Bytecodes::Code code, address bcp, address end)
case _fast_binaryswitch: // fall through
case _fast_linearswitch:
{ address aligned_bcp = align_up(bcp + 1, jintSize);
if (end != NULL && aligned_bcp + 2*jintSize >= end) {
if (end != nullptr && aligned_bcp + 2*jintSize >= end) {
return -1; // don't read past end of code buffer
}
jlong npairs = (jint)Bytes::get_Java_u4(aligned_bcp + jintSize);
@ -145,9 +145,9 @@ void Bytecodes::def(Code code, const char* name, const char* format, const char*
void Bytecodes::def(Code code, const char* name, const char* format, const char* wide_format, BasicType result_type, int depth, bool can_trap, Code java_code) {
assert(wide_format == NULL || format != NULL, "short form must exist if there's a wide form");
int len = (format != NULL ? (int) strlen(format) : 0);
int wlen = (wide_format != NULL ? (int) strlen(wide_format) : 0);
assert(wide_format == nullptr || format != nullptr, "short form must exist if there's a wide form");
int len = (format != nullptr ? (int) strlen(format) : 0);
int wlen = (wide_format != nullptr ? (int) strlen(wide_format) : 0);
_name [code] = name;
_result_type [code] = result_type;
_depth [code] = depth;
@ -158,8 +158,8 @@ void Bytecodes::def(Code code, const char* name, const char* format, const char*
if (java_code != code) bc_flags |= _bc_can_rewrite;
_flags[(u1)code+0*(1<<BitsPerByte)] = compute_flags(format, bc_flags);
_flags[(u1)code+1*(1<<BitsPerByte)] = compute_flags(wide_format, bc_flags);
assert(is_defined(code) == (format != NULL), "");
assert(wide_is_defined(code) == (wide_format != NULL), "");
assert(is_defined(code) == (format != nullptr), "");
assert(wide_is_defined(code) == (wide_format != nullptr), "");
assert(length_for(code) == len, "");
assert(wide_length_for(code) == wlen, "");
}
@ -184,7 +184,7 @@ void Bytecodes::def(Code code, const char* name, const char* format, const char*
// Note: For bytecodes with variable length, the format string is the empty string.
int Bytecodes::compute_flags(const char* format, int more_flags) {
if (format == NULL) return 0; // not even more_flags
if (format == nullptr) return 0; // not even more_flags
int flags = more_flags;
const char* fp = format;
switch (*fp) {
@ -263,7 +263,7 @@ void Bytecodes::initialize() {
// (such as {}) so we can do additional consistency checks and init-
// code is independent of actual bytecode numbering.
//
// Note 1: NULL for the format string means the bytecode doesn't exist
// Note 1: nullptr for the format string means the bytecode doesn't exist
// in that form.
//
// Note 2: The result type is T_ILLEGAL for bytecodes where the top of stack
@ -271,261 +271,261 @@ void Bytecodes::initialize() {
// Java bytecodes
// bytecode bytecode name format wide f. result tp stk traps
def(_nop , "nop" , "b" , NULL , T_VOID , 0, false);
def(_aconst_null , "aconst_null" , "b" , NULL , T_OBJECT , 1, false);
def(_iconst_m1 , "iconst_m1" , "b" , NULL , T_INT , 1, false);
def(_iconst_0 , "iconst_0" , "b" , NULL , T_INT , 1, false);
def(_iconst_1 , "iconst_1" , "b" , NULL , T_INT , 1, false);
def(_iconst_2 , "iconst_2" , "b" , NULL , T_INT , 1, false);
def(_iconst_3 , "iconst_3" , "b" , NULL , T_INT , 1, false);
def(_iconst_4 , "iconst_4" , "b" , NULL , T_INT , 1, false);
def(_iconst_5 , "iconst_5" , "b" , NULL , T_INT , 1, false);
def(_lconst_0 , "lconst_0" , "b" , NULL , T_LONG , 2, false);
def(_lconst_1 , "lconst_1" , "b" , NULL , T_LONG , 2, false);
def(_fconst_0 , "fconst_0" , "b" , NULL , T_FLOAT , 1, false);
def(_fconst_1 , "fconst_1" , "b" , NULL , T_FLOAT , 1, false);
def(_fconst_2 , "fconst_2" , "b" , NULL , T_FLOAT , 1, false);
def(_dconst_0 , "dconst_0" , "b" , NULL , T_DOUBLE , 2, false);
def(_dconst_1 , "dconst_1" , "b" , NULL , T_DOUBLE , 2, false);
def(_bipush , "bipush" , "bc" , NULL , T_INT , 1, false);
def(_sipush , "sipush" , "bcc" , NULL , T_INT , 1, false);
def(_ldc , "ldc" , "bk" , NULL , T_ILLEGAL, 1, true );
def(_ldc_w , "ldc_w" , "bkk" , NULL , T_ILLEGAL, 1, true );
def(_ldc2_w , "ldc2_w" , "bkk" , NULL , T_ILLEGAL, 2, true );
def(_iload , "iload" , "bi" , "wbii" , T_INT , 1, false);
def(_lload , "lload" , "bi" , "wbii" , T_LONG , 2, false);
def(_fload , "fload" , "bi" , "wbii" , T_FLOAT , 1, false);
def(_dload , "dload" , "bi" , "wbii" , T_DOUBLE , 2, false);
def(_aload , "aload" , "bi" , "wbii" , T_OBJECT , 1, false);
def(_iload_0 , "iload_0" , "b" , NULL , T_INT , 1, false);
def(_iload_1 , "iload_1" , "b" , NULL , T_INT , 1, false);
def(_iload_2 , "iload_2" , "b" , NULL , T_INT , 1, false);
def(_iload_3 , "iload_3" , "b" , NULL , T_INT , 1, false);
def(_lload_0 , "lload_0" , "b" , NULL , T_LONG , 2, false);
def(_lload_1 , "lload_1" , "b" , NULL , T_LONG , 2, false);
def(_lload_2 , "lload_2" , "b" , NULL , T_LONG , 2, false);
def(_lload_3 , "lload_3" , "b" , NULL , T_LONG , 2, false);
def(_fload_0 , "fload_0" , "b" , NULL , T_FLOAT , 1, false);
def(_fload_1 , "fload_1" , "b" , NULL , T_FLOAT , 1, false);
def(_fload_2 , "fload_2" , "b" , NULL , T_FLOAT , 1, false);
def(_fload_3 , "fload_3" , "b" , NULL , T_FLOAT , 1, false);
def(_dload_0 , "dload_0" , "b" , NULL , T_DOUBLE , 2, false);
def(_dload_1 , "dload_1" , "b" , NULL , T_DOUBLE , 2, false);
def(_dload_2 , "dload_2" , "b" , NULL , T_DOUBLE , 2, false);
def(_dload_3 , "dload_3" , "b" , NULL , T_DOUBLE , 2, false);
def(_aload_0 , "aload_0" , "b" , NULL , T_OBJECT , 1, true ); // rewriting in interpreter
def(_aload_1 , "aload_1" , "b" , NULL , T_OBJECT , 1, false);
def(_aload_2 , "aload_2" , "b" , NULL , T_OBJECT , 1, false);
def(_aload_3 , "aload_3" , "b" , NULL , T_OBJECT , 1, false);
def(_iaload , "iaload" , "b" , NULL , T_INT , -1, true );
def(_laload , "laload" , "b" , NULL , T_LONG , 0, true );
def(_faload , "faload" , "b" , NULL , T_FLOAT , -1, true );
def(_daload , "daload" , "b" , NULL , T_DOUBLE , 0, true );
def(_aaload , "aaload" , "b" , NULL , T_OBJECT , -1, true );
def(_baload , "baload" , "b" , NULL , T_INT , -1, true );
def(_caload , "caload" , "b" , NULL , T_INT , -1, true );
def(_saload , "saload" , "b" , NULL , T_INT , -1, true );
def(_istore , "istore" , "bi" , "wbii" , T_VOID , -1, false);
def(_lstore , "lstore" , "bi" , "wbii" , T_VOID , -2, false);
def(_fstore , "fstore" , "bi" , "wbii" , T_VOID , -1, false);
def(_dstore , "dstore" , "bi" , "wbii" , T_VOID , -2, false);
def(_astore , "astore" , "bi" , "wbii" , T_VOID , -1, false);
def(_istore_0 , "istore_0" , "b" , NULL , T_VOID , -1, false);
def(_istore_1 , "istore_1" , "b" , NULL , T_VOID , -1, false);
def(_istore_2 , "istore_2" , "b" , NULL , T_VOID , -1, false);
def(_istore_3 , "istore_3" , "b" , NULL , T_VOID , -1, false);
def(_lstore_0 , "lstore_0" , "b" , NULL , T_VOID , -2, false);
def(_lstore_1 , "lstore_1" , "b" , NULL , T_VOID , -2, false);
def(_lstore_2 , "lstore_2" , "b" , NULL , T_VOID , -2, false);
def(_lstore_3 , "lstore_3" , "b" , NULL , T_VOID , -2, false);
def(_fstore_0 , "fstore_0" , "b" , NULL , T_VOID , -1, false);
def(_fstore_1 , "fstore_1" , "b" , NULL , T_VOID , -1, false);
def(_fstore_2 , "fstore_2" , "b" , NULL , T_VOID , -1, false);
def(_fstore_3 , "fstore_3" , "b" , NULL , T_VOID , -1, false);
def(_dstore_0 , "dstore_0" , "b" , NULL , T_VOID , -2, false);
def(_dstore_1 , "dstore_1" , "b" , NULL , T_VOID , -2, false);
def(_dstore_2 , "dstore_2" , "b" , NULL , T_VOID , -2, false);
def(_dstore_3 , "dstore_3" , "b" , NULL , T_VOID , -2, false);
def(_astore_0 , "astore_0" , "b" , NULL , T_VOID , -1, false);
def(_astore_1 , "astore_1" , "b" , NULL , T_VOID , -1, false);
def(_astore_2 , "astore_2" , "b" , NULL , T_VOID , -1, false);
def(_astore_3 , "astore_3" , "b" , NULL , T_VOID , -1, false);
def(_iastore , "iastore" , "b" , NULL , T_VOID , -3, true );
def(_lastore , "lastore" , "b" , NULL , T_VOID , -4, true );
def(_fastore , "fastore" , "b" , NULL , T_VOID , -3, true );
def(_dastore , "dastore" , "b" , NULL , T_VOID , -4, true );
def(_aastore , "aastore" , "b" , NULL , T_VOID , -3, true );
def(_bastore , "bastore" , "b" , NULL , T_VOID , -3, true );
def(_castore , "castore" , "b" , NULL , T_VOID , -3, true );
def(_sastore , "sastore" , "b" , NULL , T_VOID , -3, true );
def(_pop , "pop" , "b" , NULL , T_VOID , -1, false);
def(_pop2 , "pop2" , "b" , NULL , T_VOID , -2, false);
def(_dup , "dup" , "b" , NULL , T_VOID , 1, false);
def(_dup_x1 , "dup_x1" , "b" , NULL , T_VOID , 1, false);
def(_dup_x2 , "dup_x2" , "b" , NULL , T_VOID , 1, false);
def(_dup2 , "dup2" , "b" , NULL , T_VOID , 2, false);
def(_dup2_x1 , "dup2_x1" , "b" , NULL , T_VOID , 2, false);
def(_dup2_x2 , "dup2_x2" , "b" , NULL , T_VOID , 2, false);
def(_swap , "swap" , "b" , NULL , T_VOID , 0, false);
def(_iadd , "iadd" , "b" , NULL , T_INT , -1, false);
def(_ladd , "ladd" , "b" , NULL , T_LONG , -2, false);
def(_fadd , "fadd" , "b" , NULL , T_FLOAT , -1, false);
def(_dadd , "dadd" , "b" , NULL , T_DOUBLE , -2, false);
def(_isub , "isub" , "b" , NULL , T_INT , -1, false);
def(_lsub , "lsub" , "b" , NULL , T_LONG , -2, false);
def(_fsub , "fsub" , "b" , NULL , T_FLOAT , -1, false);
def(_dsub , "dsub" , "b" , NULL , T_DOUBLE , -2, false);
def(_imul , "imul" , "b" , NULL , T_INT , -1, false);
def(_lmul , "lmul" , "b" , NULL , T_LONG , -2, false);
def(_fmul , "fmul" , "b" , NULL , T_FLOAT , -1, false);
def(_dmul , "dmul" , "b" , NULL , T_DOUBLE , -2, false);
def(_idiv , "idiv" , "b" , NULL , T_INT , -1, true );
def(_ldiv , "ldiv" , "b" , NULL , T_LONG , -2, true );
def(_fdiv , "fdiv" , "b" , NULL , T_FLOAT , -1, false);
def(_ddiv , "ddiv" , "b" , NULL , T_DOUBLE , -2, false);
def(_irem , "irem" , "b" , NULL , T_INT , -1, true );
def(_lrem , "lrem" , "b" , NULL , T_LONG , -2, true );
def(_frem , "frem" , "b" , NULL , T_FLOAT , -1, false);
def(_drem , "drem" , "b" , NULL , T_DOUBLE , -2, false);
def(_ineg , "ineg" , "b" , NULL , T_INT , 0, false);
def(_lneg , "lneg" , "b" , NULL , T_LONG , 0, false);
def(_fneg , "fneg" , "b" , NULL , T_FLOAT , 0, false);
def(_dneg , "dneg" , "b" , NULL , T_DOUBLE , 0, false);
def(_ishl , "ishl" , "b" , NULL , T_INT , -1, false);
def(_lshl , "lshl" , "b" , NULL , T_LONG , -1, false);
def(_ishr , "ishr" , "b" , NULL , T_INT , -1, false);
def(_lshr , "lshr" , "b" , NULL , T_LONG , -1, false);
def(_iushr , "iushr" , "b" , NULL , T_INT , -1, false);
def(_lushr , "lushr" , "b" , NULL , T_LONG , -1, false);
def(_iand , "iand" , "b" , NULL , T_INT , -1, false);
def(_land , "land" , "b" , NULL , T_LONG , -2, false);
def(_ior , "ior" , "b" , NULL , T_INT , -1, false);
def(_lor , "lor" , "b" , NULL , T_LONG , -2, false);
def(_ixor , "ixor" , "b" , NULL , T_INT , -1, false);
def(_lxor , "lxor" , "b" , NULL , T_LONG , -2, false);
def(_iinc , "iinc" , "bic" , "wbiicc", T_VOID , 0, false);
def(_i2l , "i2l" , "b" , NULL , T_LONG , 1, false);
def(_i2f , "i2f" , "b" , NULL , T_FLOAT , 0, false);
def(_i2d , "i2d" , "b" , NULL , T_DOUBLE , 1, false);
def(_l2i , "l2i" , "b" , NULL , T_INT , -1, false);
def(_l2f , "l2f" , "b" , NULL , T_FLOAT , -1, false);
def(_l2d , "l2d" , "b" , NULL , T_DOUBLE , 0, false);
def(_f2i , "f2i" , "b" , NULL , T_INT , 0, false);
def(_f2l , "f2l" , "b" , NULL , T_LONG , 1, false);
def(_f2d , "f2d" , "b" , NULL , T_DOUBLE , 1, false);
def(_d2i , "d2i" , "b" , NULL , T_INT , -1, false);
def(_d2l , "d2l" , "b" , NULL , T_LONG , 0, false);
def(_d2f , "d2f" , "b" , NULL , T_FLOAT , -1, false);
def(_i2b , "i2b" , "b" , NULL , T_BYTE , 0, false);
def(_i2c , "i2c" , "b" , NULL , T_CHAR , 0, false);
def(_i2s , "i2s" , "b" , NULL , T_SHORT , 0, false);
def(_lcmp , "lcmp" , "b" , NULL , T_VOID , -3, false);
def(_fcmpl , "fcmpl" , "b" , NULL , T_VOID , -1, false);
def(_fcmpg , "fcmpg" , "b" , NULL , T_VOID , -1, false);
def(_dcmpl , "dcmpl" , "b" , NULL , T_VOID , -3, false);
def(_dcmpg , "dcmpg" , "b" , NULL , T_VOID , -3, false);
def(_ifeq , "ifeq" , "boo" , NULL , T_VOID , -1, false);
def(_ifne , "ifne" , "boo" , NULL , T_VOID , -1, false);
def(_iflt , "iflt" , "boo" , NULL , T_VOID , -1, false);
def(_ifge , "ifge" , "boo" , NULL , T_VOID , -1, false);
def(_ifgt , "ifgt" , "boo" , NULL , T_VOID , -1, false);
def(_ifle , "ifle" , "boo" , NULL , T_VOID , -1, false);
def(_if_icmpeq , "if_icmpeq" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmpne , "if_icmpne" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmplt , "if_icmplt" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmpge , "if_icmpge" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmpgt , "if_icmpgt" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmple , "if_icmple" , "boo" , NULL , T_VOID , -2, false);
def(_if_acmpeq , "if_acmpeq" , "boo" , NULL , T_VOID , -2, false);
def(_if_acmpne , "if_acmpne" , "boo" , NULL , T_VOID , -2, false);
def(_goto , "goto" , "boo" , NULL , T_VOID , 0, false);
def(_jsr , "jsr" , "boo" , NULL , T_INT , 0, false);
def(_ret , "ret" , "bi" , "wbii" , T_VOID , 0, false);
def(_tableswitch , "tableswitch" , "" , NULL , T_VOID , -1, false); // may have backward branches
def(_lookupswitch , "lookupswitch" , "" , NULL , T_VOID , -1, false); // rewriting in interpreter
def(_ireturn , "ireturn" , "b" , NULL , T_INT , -1, true);
def(_lreturn , "lreturn" , "b" , NULL , T_LONG , -2, true);
def(_freturn , "freturn" , "b" , NULL , T_FLOAT , -1, true);
def(_dreturn , "dreturn" , "b" , NULL , T_DOUBLE , -2, true);
def(_areturn , "areturn" , "b" , NULL , T_OBJECT , -1, true);
def(_return , "return" , "b" , NULL , T_VOID , 0, true);
def(_getstatic , "getstatic" , "bJJ" , NULL , T_ILLEGAL, 1, true );
def(_putstatic , "putstatic" , "bJJ" , NULL , T_ILLEGAL, -1, true );
def(_getfield , "getfield" , "bJJ" , NULL , T_ILLEGAL, 0, true );
def(_putfield , "putfield" , "bJJ" , NULL , T_ILLEGAL, -2, true );
def(_invokevirtual , "invokevirtual" , "bJJ" , NULL , T_ILLEGAL, -1, true);
def(_invokespecial , "invokespecial" , "bJJ" , NULL , T_ILLEGAL, -1, true);
def(_invokestatic , "invokestatic" , "bJJ" , NULL , T_ILLEGAL, 0, true);
def(_invokeinterface , "invokeinterface" , "bJJ__", NULL , T_ILLEGAL, -1, true);
def(_invokedynamic , "invokedynamic" , "bJJJJ", NULL , T_ILLEGAL, 0, true );
def(_new , "new" , "bkk" , NULL , T_OBJECT , 1, true );
def(_newarray , "newarray" , "bc" , NULL , T_OBJECT , 0, true );
def(_anewarray , "anewarray" , "bkk" , NULL , T_OBJECT , 0, true );
def(_arraylength , "arraylength" , "b" , NULL , T_INT , 0, true );
def(_athrow , "athrow" , "b" , NULL , T_VOID , -1, true );
def(_checkcast , "checkcast" , "bkk" , NULL , T_OBJECT , 0, true );
def(_instanceof , "instanceof" , "bkk" , NULL , T_INT , 0, true );
def(_monitorenter , "monitorenter" , "b" , NULL , T_VOID , -1, true );
def(_monitorexit , "monitorexit" , "b" , NULL , T_VOID , -1, true );
def(_wide , "wide" , "" , NULL , T_VOID , 0, false);
def(_multianewarray , "multianewarray" , "bkkc" , NULL , T_OBJECT , 1, true );
def(_ifnull , "ifnull" , "boo" , NULL , T_VOID , -1, false);
def(_ifnonnull , "ifnonnull" , "boo" , NULL , T_VOID , -1, false);
def(_goto_w , "goto_w" , "boooo", NULL , T_VOID , 0, false);
def(_jsr_w , "jsr_w" , "boooo", NULL , T_INT , 0, false);
def(_breakpoint , "breakpoint" , "" , NULL , T_VOID , 0, true);
def(_nop , "nop" , "b" , nullptr , T_VOID , 0, false);
def(_aconst_null , "aconst_null" , "b" , nullptr , T_OBJECT , 1, false);
def(_iconst_m1 , "iconst_m1" , "b" , nullptr , T_INT , 1, false);
def(_iconst_0 , "iconst_0" , "b" , nullptr , T_INT , 1, false);
def(_iconst_1 , "iconst_1" , "b" , nullptr , T_INT , 1, false);
def(_iconst_2 , "iconst_2" , "b" , nullptr , T_INT , 1, false);
def(_iconst_3 , "iconst_3" , "b" , nullptr , T_INT , 1, false);
def(_iconst_4 , "iconst_4" , "b" , nullptr , T_INT , 1, false);
def(_iconst_5 , "iconst_5" , "b" , nullptr , T_INT , 1, false);
def(_lconst_0 , "lconst_0" , "b" , nullptr , T_LONG , 2, false);
def(_lconst_1 , "lconst_1" , "b" , nullptr , T_LONG , 2, false);
def(_fconst_0 , "fconst_0" , "b" , nullptr , T_FLOAT , 1, false);
def(_fconst_1 , "fconst_1" , "b" , nullptr , T_FLOAT , 1, false);
def(_fconst_2 , "fconst_2" , "b" , nullptr , T_FLOAT , 1, false);
def(_dconst_0 , "dconst_0" , "b" , nullptr , T_DOUBLE , 2, false);
def(_dconst_1 , "dconst_1" , "b" , nullptr , T_DOUBLE , 2, false);
def(_bipush , "bipush" , "bc" , nullptr , T_INT , 1, false);
def(_sipush , "sipush" , "bcc" , nullptr , T_INT , 1, false);
def(_ldc , "ldc" , "bk" , nullptr , T_ILLEGAL, 1, true );
def(_ldc_w , "ldc_w" , "bkk" , nullptr , T_ILLEGAL, 1, true );
def(_ldc2_w , "ldc2_w" , "bkk" , nullptr , T_ILLEGAL, 2, true );
def(_iload , "iload" , "bi" , "wbii" , T_INT , 1, false);
def(_lload , "lload" , "bi" , "wbii" , T_LONG , 2, false);
def(_fload , "fload" , "bi" , "wbii" , T_FLOAT , 1, false);
def(_dload , "dload" , "bi" , "wbii" , T_DOUBLE , 2, false);
def(_aload , "aload" , "bi" , "wbii" , T_OBJECT , 1, false);
def(_iload_0 , "iload_0" , "b" , nullptr , T_INT , 1, false);
def(_iload_1 , "iload_1" , "b" , nullptr , T_INT , 1, false);
def(_iload_2 , "iload_2" , "b" , nullptr , T_INT , 1, false);
def(_iload_3 , "iload_3" , "b" , nullptr , T_INT , 1, false);
def(_lload_0 , "lload_0" , "b" , nullptr , T_LONG , 2, false);
def(_lload_1 , "lload_1" , "b" , nullptr , T_LONG , 2, false);
def(_lload_2 , "lload_2" , "b" , nullptr , T_LONG , 2, false);
def(_lload_3 , "lload_3" , "b" , nullptr , T_LONG , 2, false);
def(_fload_0 , "fload_0" , "b" , nullptr , T_FLOAT , 1, false);
def(_fload_1 , "fload_1" , "b" , nullptr , T_FLOAT , 1, false);
def(_fload_2 , "fload_2" , "b" , nullptr , T_FLOAT , 1, false);
def(_fload_3 , "fload_3" , "b" , nullptr , T_FLOAT , 1, false);
def(_dload_0 , "dload_0" , "b" , nullptr , T_DOUBLE , 2, false);
def(_dload_1 , "dload_1" , "b" , nullptr , T_DOUBLE , 2, false);
def(_dload_2 , "dload_2" , "b" , nullptr , T_DOUBLE , 2, false);
def(_dload_3 , "dload_3" , "b" , nullptr , T_DOUBLE , 2, false);
def(_aload_0 , "aload_0" , "b" , nullptr , T_OBJECT , 1, true ); // rewriting in interpreter
def(_aload_1 , "aload_1" , "b" , nullptr , T_OBJECT , 1, false);
def(_aload_2 , "aload_2" , "b" , nullptr , T_OBJECT , 1, false);
def(_aload_3 , "aload_3" , "b" , nullptr , T_OBJECT , 1, false);
def(_iaload , "iaload" , "b" , nullptr , T_INT , -1, true );
def(_laload , "laload" , "b" , nullptr , T_LONG , 0, true );
def(_faload , "faload" , "b" , nullptr , T_FLOAT , -1, true );
def(_daload , "daload" , "b" , nullptr , T_DOUBLE , 0, true );
def(_aaload , "aaload" , "b" , nullptr , T_OBJECT , -1, true );
def(_baload , "baload" , "b" , nullptr , T_INT , -1, true );
def(_caload , "caload" , "b" , nullptr , T_INT , -1, true );
def(_saload , "saload" , "b" , nullptr , T_INT , -1, true );
def(_istore , "istore" , "bi" , "wbii" , T_VOID , -1, false);
def(_lstore , "lstore" , "bi" , "wbii" , T_VOID , -2, false);
def(_fstore , "fstore" , "bi" , "wbii" , T_VOID , -1, false);
def(_dstore , "dstore" , "bi" , "wbii" , T_VOID , -2, false);
def(_astore , "astore" , "bi" , "wbii" , T_VOID , -1, false);
def(_istore_0 , "istore_0" , "b" , nullptr , T_VOID , -1, false);
def(_istore_1 , "istore_1" , "b" , nullptr , T_VOID , -1, false);
def(_istore_2 , "istore_2" , "b" , nullptr , T_VOID , -1, false);
def(_istore_3 , "istore_3" , "b" , nullptr , T_VOID , -1, false);
def(_lstore_0 , "lstore_0" , "b" , nullptr , T_VOID , -2, false);
def(_lstore_1 , "lstore_1" , "b" , nullptr , T_VOID , -2, false);
def(_lstore_2 , "lstore_2" , "b" , nullptr , T_VOID , -2, false);
def(_lstore_3 , "lstore_3" , "b" , nullptr , T_VOID , -2, false);
def(_fstore_0 , "fstore_0" , "b" , nullptr , T_VOID , -1, false);
def(_fstore_1 , "fstore_1" , "b" , nullptr , T_VOID , -1, false);
def(_fstore_2 , "fstore_2" , "b" , nullptr , T_VOID , -1, false);
def(_fstore_3 , "fstore_3" , "b" , nullptr , T_VOID , -1, false);
def(_dstore_0 , "dstore_0" , "b" , nullptr , T_VOID , -2, false);
def(_dstore_1 , "dstore_1" , "b" , nullptr , T_VOID , -2, false);
def(_dstore_2 , "dstore_2" , "b" , nullptr , T_VOID , -2, false);
def(_dstore_3 , "dstore_3" , "b" , nullptr , T_VOID , -2, false);
def(_astore_0 , "astore_0" , "b" , nullptr , T_VOID , -1, false);
def(_astore_1 , "astore_1" , "b" , nullptr , T_VOID , -1, false);
def(_astore_2 , "astore_2" , "b" , nullptr , T_VOID , -1, false);
def(_astore_3 , "astore_3" , "b" , nullptr , T_VOID , -1, false);
def(_iastore , "iastore" , "b" , nullptr , T_VOID , -3, true );
def(_lastore , "lastore" , "b" , nullptr , T_VOID , -4, true );
def(_fastore , "fastore" , "b" , nullptr , T_VOID , -3, true );
def(_dastore , "dastore" , "b" , nullptr , T_VOID , -4, true );
def(_aastore , "aastore" , "b" , nullptr , T_VOID , -3, true );
def(_bastore , "bastore" , "b" , nullptr , T_VOID , -3, true );
def(_castore , "castore" , "b" , nullptr , T_VOID , -3, true );
def(_sastore , "sastore" , "b" , nullptr , T_VOID , -3, true );
def(_pop , "pop" , "b" , nullptr , T_VOID , -1, false);
def(_pop2 , "pop2" , "b" , nullptr , T_VOID , -2, false);
def(_dup , "dup" , "b" , nullptr , T_VOID , 1, false);
def(_dup_x1 , "dup_x1" , "b" , nullptr , T_VOID , 1, false);
def(_dup_x2 , "dup_x2" , "b" , nullptr , T_VOID , 1, false);
def(_dup2 , "dup2" , "b" , nullptr , T_VOID , 2, false);
def(_dup2_x1 , "dup2_x1" , "b" , nullptr , T_VOID , 2, false);
def(_dup2_x2 , "dup2_x2" , "b" , nullptr , T_VOID , 2, false);
def(_swap , "swap" , "b" , nullptr , T_VOID , 0, false);
def(_iadd , "iadd" , "b" , nullptr , T_INT , -1, false);
def(_ladd , "ladd" , "b" , nullptr , T_LONG , -2, false);
def(_fadd , "fadd" , "b" , nullptr , T_FLOAT , -1, false);
def(_dadd , "dadd" , "b" , nullptr , T_DOUBLE , -2, false);
def(_isub , "isub" , "b" , nullptr , T_INT , -1, false);
def(_lsub , "lsub" , "b" , nullptr , T_LONG , -2, false);
def(_fsub , "fsub" , "b" , nullptr , T_FLOAT , -1, false);
def(_dsub , "dsub" , "b" , nullptr , T_DOUBLE , -2, false);
def(_imul , "imul" , "b" , nullptr , T_INT , -1, false);
def(_lmul , "lmul" , "b" , nullptr , T_LONG , -2, false);
def(_fmul , "fmul" , "b" , nullptr , T_FLOAT , -1, false);
def(_dmul , "dmul" , "b" , nullptr , T_DOUBLE , -2, false);
def(_idiv , "idiv" , "b" , nullptr , T_INT , -1, true );
def(_ldiv , "ldiv" , "b" , nullptr , T_LONG , -2, true );
def(_fdiv , "fdiv" , "b" , nullptr , T_FLOAT , -1, false);
def(_ddiv , "ddiv" , "b" , nullptr , T_DOUBLE , -2, false);
def(_irem , "irem" , "b" , nullptr , T_INT , -1, true );
def(_lrem , "lrem" , "b" , nullptr , T_LONG , -2, true );
def(_frem , "frem" , "b" , nullptr , T_FLOAT , -1, false);
def(_drem , "drem" , "b" , nullptr , T_DOUBLE , -2, false);
def(_ineg , "ineg" , "b" , nullptr , T_INT , 0, false);
def(_lneg , "lneg" , "b" , nullptr , T_LONG , 0, false);
def(_fneg , "fneg" , "b" , nullptr , T_FLOAT , 0, false);
def(_dneg , "dneg" , "b" , nullptr , T_DOUBLE , 0, false);
def(_ishl , "ishl" , "b" , nullptr , T_INT , -1, false);
def(_lshl , "lshl" , "b" , nullptr , T_LONG , -1, false);
def(_ishr , "ishr" , "b" , nullptr , T_INT , -1, false);
def(_lshr , "lshr" , "b" , nullptr , T_LONG , -1, false);
def(_iushr , "iushr" , "b" , nullptr , T_INT , -1, false);
def(_lushr , "lushr" , "b" , nullptr , T_LONG , -1, false);
def(_iand , "iand" , "b" , nullptr , T_INT , -1, false);
def(_land , "land" , "b" , nullptr , T_LONG , -2, false);
def(_ior , "ior" , "b" , nullptr , T_INT , -1, false);
def(_lor , "lor" , "b" , nullptr , T_LONG , -2, false);
def(_ixor , "ixor" , "b" , nullptr , T_INT , -1, false);
def(_lxor , "lxor" , "b" , nullptr , T_LONG , -2, false);
def(_iinc , "iinc" , "bic" , "wbiicc", T_VOID , 0, false);
def(_i2l , "i2l" , "b" , nullptr , T_LONG , 1, false);
def(_i2f , "i2f" , "b" , nullptr , T_FLOAT , 0, false);
def(_i2d , "i2d" , "b" , nullptr , T_DOUBLE , 1, false);
def(_l2i , "l2i" , "b" , nullptr , T_INT , -1, false);
def(_l2f , "l2f" , "b" , nullptr , T_FLOAT , -1, false);
def(_l2d , "l2d" , "b" , nullptr , T_DOUBLE , 0, false);
def(_f2i , "f2i" , "b" , nullptr , T_INT , 0, false);
def(_f2l , "f2l" , "b" , nullptr , T_LONG , 1, false);
def(_f2d , "f2d" , "b" , nullptr , T_DOUBLE , 1, false);
def(_d2i , "d2i" , "b" , nullptr , T_INT , -1, false);
def(_d2l , "d2l" , "b" , nullptr , T_LONG , 0, false);
def(_d2f , "d2f" , "b" , nullptr , T_FLOAT , -1, false);
def(_i2b , "i2b" , "b" , nullptr , T_BYTE , 0, false);
def(_i2c , "i2c" , "b" , nullptr , T_CHAR , 0, false);
def(_i2s , "i2s" , "b" , nullptr , T_SHORT , 0, false);
def(_lcmp , "lcmp" , "b" , nullptr , T_VOID , -3, false);
def(_fcmpl , "fcmpl" , "b" , nullptr , T_VOID , -1, false);
def(_fcmpg , "fcmpg" , "b" , nullptr , T_VOID , -1, false);
def(_dcmpl , "dcmpl" , "b" , nullptr , T_VOID , -3, false);
def(_dcmpg , "dcmpg" , "b" , nullptr , T_VOID , -3, false);
def(_ifeq , "ifeq" , "boo" , nullptr , T_VOID , -1, false);
def(_ifne , "ifne" , "boo" , nullptr , T_VOID , -1, false);
def(_iflt , "iflt" , "boo" , nullptr , T_VOID , -1, false);
def(_ifge , "ifge" , "boo" , nullptr , T_VOID , -1, false);
def(_ifgt , "ifgt" , "boo" , nullptr , T_VOID , -1, false);
def(_ifle , "ifle" , "boo" , nullptr , T_VOID , -1, false);
def(_if_icmpeq , "if_icmpeq" , "boo" , nullptr , T_VOID , -2, false);
def(_if_icmpne , "if_icmpne" , "boo" , nullptr , T_VOID , -2, false);
def(_if_icmplt , "if_icmplt" , "boo" , nullptr , T_VOID , -2, false);
def(_if_icmpge , "if_icmpge" , "boo" , nullptr , T_VOID , -2, false);
def(_if_icmpgt , "if_icmpgt" , "boo" , nullptr , T_VOID , -2, false);
def(_if_icmple , "if_icmple" , "boo" , nullptr , T_VOID , -2, false);
def(_if_acmpeq , "if_acmpeq" , "boo" , nullptr , T_VOID , -2, false);
def(_if_acmpne , "if_acmpne" , "boo" , nullptr , T_VOID , -2, false);
def(_goto , "goto" , "boo" , nullptr , T_VOID , 0, false);
def(_jsr , "jsr" , "boo" , nullptr , T_INT , 0, false);
def(_ret , "ret" , "bi" , "wbii" , T_VOID , 0, false);
def(_tableswitch , "tableswitch" , "" , nullptr , T_VOID , -1, false); // may have backward branches
def(_lookupswitch , "lookupswitch" , "" , nullptr , T_VOID , -1, false); // rewriting in interpreter
def(_ireturn , "ireturn" , "b" , nullptr , T_INT , -1, true);
def(_lreturn , "lreturn" , "b" , nullptr , T_LONG , -2, true);
def(_freturn , "freturn" , "b" , nullptr , T_FLOAT , -1, true);
def(_dreturn , "dreturn" , "b" , nullptr , T_DOUBLE , -2, true);
def(_areturn , "areturn" , "b" , nullptr , T_OBJECT , -1, true);
def(_return , "return" , "b" , nullptr , T_VOID , 0, true);
def(_getstatic , "getstatic" , "bJJ" , nullptr , T_ILLEGAL, 1, true );
def(_putstatic , "putstatic" , "bJJ" , nullptr , T_ILLEGAL, -1, true );
def(_getfield , "getfield" , "bJJ" , nullptr , T_ILLEGAL, 0, true );
def(_putfield , "putfield" , "bJJ" , nullptr , T_ILLEGAL, -2, true );
def(_invokevirtual , "invokevirtual" , "bJJ" , nullptr , T_ILLEGAL, -1, true);
def(_invokespecial , "invokespecial" , "bJJ" , nullptr , T_ILLEGAL, -1, true);
def(_invokestatic , "invokestatic" , "bJJ" , nullptr , T_ILLEGAL, 0, true);
def(_invokeinterface , "invokeinterface" , "bJJ__", nullptr , T_ILLEGAL, -1, true);
def(_invokedynamic , "invokedynamic" , "bJJJJ", nullptr , T_ILLEGAL, 0, true );
def(_new , "new" , "bkk" , nullptr , T_OBJECT , 1, true );
def(_newarray , "newarray" , "bc" , nullptr , T_OBJECT , 0, true );
def(_anewarray , "anewarray" , "bkk" , nullptr , T_OBJECT , 0, true );
def(_arraylength , "arraylength" , "b" , nullptr , T_INT , 0, true );
def(_athrow , "athrow" , "b" , nullptr , T_VOID , -1, true );
def(_checkcast , "checkcast" , "bkk" , nullptr , T_OBJECT , 0, true );
def(_instanceof , "instanceof" , "bkk" , nullptr , T_INT , 0, true );
def(_monitorenter , "monitorenter" , "b" , nullptr , T_VOID , -1, true );
def(_monitorexit , "monitorexit" , "b" , nullptr , T_VOID , -1, true );
def(_wide , "wide" , "" , nullptr , T_VOID , 0, false);
def(_multianewarray , "multianewarray" , "bkkc" , nullptr , T_OBJECT , 1, true );
def(_ifnull , "ifnull" , "boo" , nullptr , T_VOID , -1, false);
def(_ifnonnull , "ifnonnull" , "boo" , nullptr , T_VOID , -1, false);
def(_goto_w , "goto_w" , "boooo", nullptr , T_VOID , 0, false);
def(_jsr_w , "jsr_w" , "boooo", nullptr , T_INT , 0, false);
def(_breakpoint , "breakpoint" , "" , nullptr , T_VOID , 0, true);
// JVM bytecodes
// bytecode bytecode name format wide f. result tp stk traps std code
def(_fast_agetfield , "fast_agetfield" , "bJJ" , NULL , T_OBJECT , 0, true , _getfield );
def(_fast_bgetfield , "fast_bgetfield" , "bJJ" , NULL , T_INT , 0, true , _getfield );
def(_fast_cgetfield , "fast_cgetfield" , "bJJ" , NULL , T_CHAR , 0, true , _getfield );
def(_fast_dgetfield , "fast_dgetfield" , "bJJ" , NULL , T_DOUBLE , 0, true , _getfield );
def(_fast_fgetfield , "fast_fgetfield" , "bJJ" , NULL , T_FLOAT , 0, true , _getfield );
def(_fast_igetfield , "fast_igetfield" , "bJJ" , NULL , T_INT , 0, true , _getfield );
def(_fast_lgetfield , "fast_lgetfield" , "bJJ" , NULL , T_LONG , 0, true , _getfield );
def(_fast_sgetfield , "fast_sgetfield" , "bJJ" , NULL , T_SHORT , 0, true , _getfield );
def(_fast_agetfield , "fast_agetfield" , "bJJ" , nullptr , T_OBJECT , 0, true , _getfield );
def(_fast_bgetfield , "fast_bgetfield" , "bJJ" , nullptr , T_INT , 0, true , _getfield );
def(_fast_cgetfield , "fast_cgetfield" , "bJJ" , nullptr , T_CHAR , 0, true , _getfield );
def(_fast_dgetfield , "fast_dgetfield" , "bJJ" , nullptr , T_DOUBLE , 0, true , _getfield );
def(_fast_fgetfield , "fast_fgetfield" , "bJJ" , nullptr , T_FLOAT , 0, true , _getfield );
def(_fast_igetfield , "fast_igetfield" , "bJJ" , nullptr , T_INT , 0, true , _getfield );
def(_fast_lgetfield , "fast_lgetfield" , "bJJ" , nullptr , T_LONG , 0, true , _getfield );
def(_fast_sgetfield , "fast_sgetfield" , "bJJ" , nullptr , T_SHORT , 0, true , _getfield );
def(_fast_aputfield , "fast_aputfield" , "bJJ" , NULL , T_OBJECT , 0, true , _putfield );
def(_fast_bputfield , "fast_bputfield" , "bJJ" , NULL , T_INT , 0, true , _putfield );
def(_fast_zputfield , "fast_zputfield" , "bJJ" , NULL , T_INT , 0, true , _putfield );
def(_fast_cputfield , "fast_cputfield" , "bJJ" , NULL , T_CHAR , 0, true , _putfield );
def(_fast_dputfield , "fast_dputfield" , "bJJ" , NULL , T_DOUBLE , 0, true , _putfield );
def(_fast_fputfield , "fast_fputfield" , "bJJ" , NULL , T_FLOAT , 0, true , _putfield );
def(_fast_iputfield , "fast_iputfield" , "bJJ" , NULL , T_INT , 0, true , _putfield );
def(_fast_lputfield , "fast_lputfield" , "bJJ" , NULL , T_LONG , 0, true , _putfield );
def(_fast_sputfield , "fast_sputfield" , "bJJ" , NULL , T_SHORT , 0, true , _putfield );
def(_fast_aputfield , "fast_aputfield" , "bJJ" , nullptr , T_OBJECT , 0, true , _putfield );
def(_fast_bputfield , "fast_bputfield" , "bJJ" , nullptr , T_INT , 0, true , _putfield );
def(_fast_zputfield , "fast_zputfield" , "bJJ" , nullptr , T_INT , 0, true , _putfield );
def(_fast_cputfield , "fast_cputfield" , "bJJ" , nullptr , T_CHAR , 0, true , _putfield );
def(_fast_dputfield , "fast_dputfield" , "bJJ" , nullptr , T_DOUBLE , 0, true , _putfield );
def(_fast_fputfield , "fast_fputfield" , "bJJ" , nullptr , T_FLOAT , 0, true , _putfield );
def(_fast_iputfield , "fast_iputfield" , "bJJ" , nullptr , T_INT , 0, true , _putfield );
def(_fast_lputfield , "fast_lputfield" , "bJJ" , nullptr , T_LONG , 0, true , _putfield );
def(_fast_sputfield , "fast_sputfield" , "bJJ" , nullptr , T_SHORT , 0, true , _putfield );
def(_fast_aload_0 , "fast_aload_0" , "b" , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_iaccess_0 , "fast_iaccess_0" , "b_JJ" , NULL , T_INT , 1, true , _aload_0 );
def(_fast_aaccess_0 , "fast_aaccess_0" , "b_JJ" , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_faccess_0 , "fast_faccess_0" , "b_JJ" , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_aload_0 , "fast_aload_0" , "b" , nullptr , T_OBJECT , 1, true , _aload_0 );
def(_fast_iaccess_0 , "fast_iaccess_0" , "b_JJ" , nullptr , T_INT , 1, true , _aload_0 );
def(_fast_aaccess_0 , "fast_aaccess_0" , "b_JJ" , nullptr , T_OBJECT , 1, true , _aload_0 );
def(_fast_faccess_0 , "fast_faccess_0" , "b_JJ" , nullptr , T_OBJECT , 1, true , _aload_0 );
def(_fast_iload , "fast_iload" , "bi" , NULL , T_INT , 1, false, _iload);
def(_fast_iload2 , "fast_iload2" , "bi_i" , NULL , T_INT , 2, false, _iload);
def(_fast_icaload , "fast_icaload" , "bi_" , NULL , T_INT , 0, false, _iload);
def(_fast_iload , "fast_iload" , "bi" , nullptr , T_INT , 1, false, _iload);
def(_fast_iload2 , "fast_iload2" , "bi_i" , nullptr , T_INT , 2, false, _iload);
def(_fast_icaload , "fast_icaload" , "bi_" , nullptr , T_INT , 0, false, _iload);
// Faster method invocation.
def(_fast_invokevfinal , "fast_invokevfinal" , "bJJ" , NULL , T_ILLEGAL, -1, true, _invokevirtual );
def(_fast_invokevfinal , "fast_invokevfinal" , "bJJ" , nullptr , T_ILLEGAL, -1, true, _invokevirtual );
def(_fast_linearswitch , "fast_linearswitch" , "" , NULL , T_VOID , -1, false, _lookupswitch );
def(_fast_binaryswitch , "fast_binaryswitch" , "" , NULL , T_VOID , -1, false, _lookupswitch );
def(_fast_linearswitch , "fast_linearswitch" , "" , nullptr , T_VOID , -1, false, _lookupswitch );
def(_fast_binaryswitch , "fast_binaryswitch" , "" , nullptr , T_VOID , -1, false, _lookupswitch );
def(_return_register_finalizer , "return_register_finalizer" , "b" , NULL , T_VOID , 0, true, _return);
def(_return_register_finalizer , "return_register_finalizer" , "b" , nullptr , T_VOID , 0, true, _return);
def(_invokehandle , "invokehandle" , "bJJ" , NULL , T_ILLEGAL, -1, true, _invokevirtual );
def(_invokehandle , "invokehandle" , "bJJ" , nullptr , T_ILLEGAL, -1, true, _invokevirtual );
def(_fast_aldc , "fast_aldc" , "bj" , NULL , T_OBJECT, 1, true, _ldc );
def(_fast_aldc_w , "fast_aldc_w" , "bJJ" , NULL , T_OBJECT, 1, true, _ldc_w );
def(_fast_aldc , "fast_aldc" , "bj" , nullptr , T_OBJECT, 1, true, _ldc );
def(_fast_aldc_w , "fast_aldc_w" , "bJJ" , nullptr , T_OBJECT, 1, true, _ldc_w );
def(_nofast_getfield , "nofast_getfield" , "bJJ" , NULL , T_ILLEGAL, 0, true, _getfield );
def(_nofast_putfield , "nofast_putfield" , "bJJ" , NULL , T_ILLEGAL, -2, true , _putfield );
def(_nofast_getfield , "nofast_getfield" , "bJJ" , nullptr , T_ILLEGAL, 0, true, _getfield );
def(_nofast_putfield , "nofast_putfield" , "bJJ" , nullptr , T_ILLEGAL, -2, true , _putfield );
def(_nofast_aload_0 , "nofast_aload_0" , "b" , NULL , T_OBJECT, 1, true , _aload_0 );
def(_nofast_iload , "nofast_iload" , "bi" , NULL , T_INT, 1, false, _iload );
def(_nofast_aload_0 , "nofast_aload_0" , "b" , nullptr , T_OBJECT, 1, true , _aload_0 );
def(_nofast_iload , "nofast_iload" , "bi" , nullptr , T_INT, 1, false, _iload );
def(_shouldnotreachhere , "_shouldnotreachhere" , "b" , NULL , T_VOID , 0, false);
def(_shouldnotreachhere , "_shouldnotreachhere" , "b" , nullptr , T_VOID , 0, false);
// compare can_trap information for each bytecode with the
// can_trap information for the corresponding base bytecode

12
src/hotspot/share/interpreter/bytecodes.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -365,12 +365,12 @@ class Bytecodes: AllStatic {
// argument is used for conversion of breakpoints into the original
// bytecode. The CI uses these methods but guarantees that
// breakpoints are hidden so the method argument should be passed as
// NULL since in that case the bcp and Method* are unrelated
// null since in that case the bcp and Method* are unrelated
// memory.
static Code code_at(const Method* method, address bcp) {
assert(method == NULL || check_method(method, bcp), "bcp must point into method");
assert(method == nullptr || check_method(method, bcp), "bcp must point into method");
Code code = cast(*bcp);
assert(code != _breakpoint || method != NULL, "need Method* to decode breakpoint");
assert(code != _breakpoint || method != nullptr, "need Method* to decode breakpoint");
return (code != _breakpoint) ? code : non_breakpoint_code_at(method, bcp);
}
static Code java_code_at(const Method* method, address bcp) {
@ -404,8 +404,8 @@ class Bytecodes: AllStatic {
static bool uses_cp_cache (Code code) { check(code); return has_all_flags(code, _fmt_has_j, false); }
// if 'end' is provided, it indicates the end of the code buffer which
// should not be read past when parsing.
static int special_length_at(Bytecodes::Code code, address bcp, address end = NULL);
static int raw_special_length_at(address bcp, address end = NULL);
static int special_length_at(Bytecodes::Code code, address bcp, address end = nullptr);
static int raw_special_length_at(address bcp, address end = nullptr);
static int length_for_code_at(Bytecodes::Code code, address bcp) { int l = length_for(code); return l > 0 ? l : special_length_at(code, bcp); }
static int length_at (Method* method, address bcp) { return length_for_code_at(code_at(method, bcp), bcp); }
static int java_length_at (Method* method, address bcp) { return length_for_code_at(java_code_at(method, bcp), bcp); }

8
src/hotspot/share/interpreter/interpreter.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -71,7 +71,7 @@ void InterpreterCodelet::print_on(outputStream* st) const {
st->print_cr("----------------------------------------------------------------------");
}
if (description() != NULL) st->print("%s ", description());
if (description() != nullptr) st->print("%s ", description());
if (bytecode() >= 0 ) st->print("%d %s ", bytecode(), Bytecodes::name(bytecode()));
st->print_cr("[" INTPTR_FORMAT ", " INTPTR_FORMAT "] %d bytes",
p2i(code_begin()), p2i(code_end()), code_size());
@ -90,7 +90,7 @@ CodeletMark::CodeletMark(InterpreterMacroAssembler*& masm,
_clet((InterpreterCodelet*)AbstractInterpreter::code()->request(codelet_size())),
_cb(_clet->code_begin(), _clet->code_size()) {
// Request all space (add some slack for Codelet data).
assert(_clet != NULL, "we checked not enough space already");
assert(_clet != nullptr, "we checked not enough space already");
// Initialize Codelet attributes.
_clet->initialize(description, bytecode);
@ -116,7 +116,7 @@ CodeletMark::~CodeletMark() {
AbstractInterpreter::code()->commit(committed_code_size);
}
// Make sure nobody can use _masm outside a CodeletMark lifespan.
*_masm = NULL;
*_masm = nullptr;
}
// The reason that interpreter initialization is split into two parts is that the first part

106
src/hotspot/share/interpreter/interpreterRuntime.cpp
View File

@ -134,9 +134,9 @@ void InterpreterRuntime::set_bcp_and_mdp(address bcp, JavaThread* current) {
last_frame.set_bcp(bcp);
if (ProfileInterpreter) {
// ProfileTraps uses MDOs independently of ProfileInterpreter.
// That is why we must check both ProfileInterpreter and mdo != NULL.
// That is why we must check both ProfileInterpreter and mdo != nullptr.
MethodData* mdo = last_frame.method()->method_data();
if (mdo != NULL) {
if (mdo != nullptr) {
NEEDS_CLEANUP;
last_frame.set_mdp(mdo->bci_to_dp(last_frame.bci()));
}
@ -184,7 +184,7 @@ JRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* current, Bytecodes::
// Resolve the constant. This does not do unboxing.
// But it does replace Universe::the_null_sentinel by null.
oop result = ldc.resolve_constant(CHECK);
assert(result != NULL || is_fast_aldc, "null result only valid for fast_aldc");
assert(result != nullptr || is_fast_aldc, "null result only valid for fast_aldc");
#ifdef ASSERT
{
@ -195,7 +195,7 @@ JRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* current, Bytecodes::
rindex = m->constants()->cp_to_object_index(ldc2.pool_index());
if (rindex >= 0) {
oop coop = m->constants()->resolved_reference_at(rindex);
oop roop = (result == NULL ? Universe::the_null_sentinel() : result);
oop roop = (result == nullptr ? Universe::the_null_sentinel() : result);
assert(roop == coop, "expected result for assembly code");
}
}
@ -315,7 +315,7 @@ void InterpreterRuntime::note_trap_inner(JavaThread* current, int reason,
const methodHandle& trap_method, int trap_bci) {
if (trap_method.not_null()) {
MethodData* trap_mdo = trap_method->method_data();
if (trap_mdo == NULL) {
if (trap_mdo == nullptr) {
ExceptionMark em(current);
JavaThread* THREAD = current; // For exception macros.
Method::build_profiling_method_data(trap_method, THREAD);
@ -328,7 +328,7 @@ void InterpreterRuntime::note_trap_inner(JavaThread* current, int reason,
trap_mdo = trap_method->method_data();
// and fall through...
}
if (trap_mdo != NULL) {
if (trap_mdo != nullptr) {
// Update per-method count of trap events. The interpreter
// is updating the MDO to simulate the effect of compiler traps.
Deoptimization::update_method_data_from_interpreter(trap_mdo, trap_bci, reason);
@ -504,7 +504,7 @@ JRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThrea
should_repeat = false;
// assertions
assert(h_exception.not_null(), "NULL exceptions should be handled by athrow");
assert(h_exception.not_null(), "null exceptions should be handled by athrow");
// Check that exception is a subclass of Throwable.
assert(h_exception->is_a(vmClasses::Throwable_klass()),
"Exception not subclass of Throwable");
@ -547,10 +547,10 @@ JRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThrea
} while (should_repeat == true);
#if INCLUDE_JVMCI
if (EnableJVMCI && h_method->method_data() != NULL) {
if (EnableJVMCI && h_method->method_data() != nullptr) {
ResourceMark rm(current);
ProfileData* pdata = h_method->method_data()->allocate_bci_to_data(current_bci, NULL);
if (pdata != NULL && pdata->is_BitData()) {
ProfileData* pdata = h_method->method_data()->allocate_bci_to_data(current_bci, nullptr);
if (pdata != nullptr && pdata->is_BitData()) {
BitData* bit_data = (BitData*) pdata;
bit_data->set_exception_seen();
}
@ -563,8 +563,8 @@ JRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThrea
JvmtiExport::post_exception_throw(current, h_method(), last_frame.bcp(), h_exception());
}
address continuation = NULL;
address handler_pc = NULL;
address continuation = nullptr;
address handler_pc = nullptr;
if (handler_bci < 0 || !current->stack_overflow_state()->reguard_stack((address) &continuation)) {
// Forward exception to callee (leaving bci/bcp untouched) because (a) no
// handler in this method, or (b) after a stack overflow there is not yet
@ -588,7 +588,7 @@ JRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThrea
// notify debugger of an exception catch
// (this is good for exceptions caught in native methods as well)
if (JvmtiExport::can_post_on_exceptions()) {
JvmtiExport::notice_unwind_due_to_exception(current, h_method(), handler_pc, h_exception(), (handler_pc != NULL));
JvmtiExport::notice_unwind_due_to_exception(current, h_method(), handler_pc, h_exception(), (handler_pc != nullptr));
}
current->set_vm_result(h_exception());
@ -615,7 +615,7 @@ JRT_END
JRT_ENTRY(void, InterpreterRuntime::throw_AbstractMethodErrorWithMethod(JavaThread* current,
Method* missingMethod))
ResourceMark rm(current);
assert(missingMethod != NULL, "sanity");
assert(missingMethod != nullptr, "sanity");
methodHandle m(current, missingMethod);
LinkResolver::throw_abstract_method_error(m, THREAD);
JRT_END
@ -641,8 +641,8 @@ JRT_ENTRY(void, InterpreterRuntime::throw_IncompatibleClassChangeErrorVerbose(Ja
buf[0] = '\0';
jio_snprintf(buf, sizeof(buf),
"Class %s does not implement the requested interface %s",
recvKlass ? recvKlass->external_name() : "NULL",
interfaceKlass ? interfaceKlass->external_name() : "NULL");
recvKlass ? recvKlass->external_name() : "nullptr",
interfaceKlass ? interfaceKlass->external_name() : "nullptr");
THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
JRT_END
@ -740,10 +740,10 @@ JRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* current, B
#endif
Handle h_obj(current, elem->obj());
assert(Universe::heap()->is_in_or_null(h_obj()),
"must be NULL or an object");
"must be null or an object");
ObjectSynchronizer::enter(h_obj, elem->lock(), current);
assert(Universe::heap()->is_in_or_null(elem->obj()),
"must be NULL or an object");
"must be null or an object");
#ifdef ASSERT
current->last_frame().interpreter_frame_verify_monitor(elem);
#endif
@ -764,7 +764,7 @@ JRT_LEAF(void, InterpreterRuntime::monitorexit(BasicObjectLock* elem))
ObjectSynchronizer::exit(obj, elem->lock(), JavaThread::current());
// Free entry. If it is not cleared, the exception handling code will try to unlock the monitor
// again at method exit or in the case of an exception.
elem->set_obj(NULL);
elem->set_obj(nullptr);
JRT_END
@ -781,8 +781,8 @@ JRT_ENTRY(void, InterpreterRuntime::new_illegal_monitor_state_exception(JavaThre
assert(!HAS_PENDING_EXCEPTION, "no pending exception");
Handle exception(current, current->vm_result());
assert(exception() != NULL, "vm result should be set");
current->set_vm_result(NULL); // clear vm result before continuing (may cause memory leaks and assert failures)
assert(exception() != nullptr, "vm result should be set");
current->set_vm_result(nullptr); // clear vm result before continuing (may cause memory leaks and assert failures)
exception = get_preinitialized_exception(vmClasses::IllegalMonitorStateException_klass(), CATCH);
current->set_vm_result(exception());
JRT_END
@ -806,7 +806,7 @@ JRT_END
void InterpreterRuntime::resolve_invoke(JavaThread* current, Bytecodes::Code bytecode) {
LastFrameAccessor last_frame(current);
// extract receiver from the outgoing argument list if necessary
Handle receiver(current, NULL);
Handle receiver(current, nullptr);
if (bytecode == Bytecodes::_invokevirtual || bytecode == Bytecodes::_invokeinterface ||
bytecode == Bytecodes::_invokespecial) {
ResourceMark rm(current);
@ -991,8 +991,8 @@ nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* current, add
// frequency_counter_overflow_inner can throw async exception.
nmethod* nm = frequency_counter_overflow_inner(current, branch_bcp);
assert(branch_bcp != NULL || nm == NULL, "always returns null for non OSR requests");
if (branch_bcp != NULL && nm != NULL) {
assert(branch_bcp != nullptr || nm == nullptr, "always returns null for non OSR requests");
if (branch_bcp != nullptr && nm != nullptr) {
// This was a successful request for an OSR nmethod. Because
// frequency_counter_overflow_inner ends with a safepoint check,
// nm could have been unloaded so look it up again. It's unsafe
@ -1003,24 +1003,24 @@ nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* current, add
int bci = method->bci_from(last_frame.bcp());
nm = method->lookup_osr_nmethod_for(bci, CompLevel_none, false);
BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod();
if (nm != NULL && bs_nm != NULL) {
if (nm != nullptr && bs_nm != nullptr) {
// in case the transition passed a safepoint we need to barrier this again
if (!bs_nm->nmethod_osr_entry_barrier(nm)) {
nm = NULL;
nm = nullptr;
}
}
}
if (nm != NULL && current->is_interp_only_mode()) {
if (nm != nullptr && current->is_interp_only_mode()) {
// Normally we never get an nm if is_interp_only_mode() is true, because
// policy()->event has a check for this and won't compile the method when
// true. However, it's possible for is_interp_only_mode() to become true
// during the compilation. We don't want to return the nm in that case
// because we want to continue to execute interpreted.
nm = NULL;
nm = nullptr;
}
#ifndef PRODUCT
if (TraceOnStackReplacement) {
if (nm != NULL) {
if (nm != nullptr) {
tty->print("OSR entry @ pc: " INTPTR_FORMAT ": ", p2i(nm->osr_entry()));
nm->print();
}
@ -1038,15 +1038,15 @@ JRT_ENTRY(nmethod*,
LastFrameAccessor last_frame(current);
assert(last_frame.is_interpreted_frame(), "must come from interpreter");
methodHandle method(current, last_frame.method());
const int branch_bci = branch_bcp != NULL ? method->bci_from(branch_bcp) : InvocationEntryBci;
const int bci = branch_bcp != NULL ? method->bci_from(last_frame.bcp()) : InvocationEntryBci;
const int branch_bci = branch_bcp != nullptr ? method->bci_from(branch_bcp) : InvocationEntryBci;
const int bci = branch_bcp != nullptr ? method->bci_from(last_frame.bcp()) : InvocationEntryBci;
nmethod* osr_nm = CompilationPolicy::event(method, method, branch_bci, bci, CompLevel_none, NULL, CHECK_NULL);
nmethod* osr_nm = CompilationPolicy::event(method, method, branch_bci, bci, CompLevel_none, nullptr, CHECK_NULL);
BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod();
if (osr_nm != NULL && bs_nm != NULL) {
if (osr_nm != nullptr && bs_nm != nullptr) {
if (!bs_nm->nmethod_osr_entry_barrier(osr_nm)) {
osr_nm = NULL;
osr_nm = nullptr;
}
}
return osr_nm;
@ -1056,7 +1056,7 @@ JRT_LEAF(jint, InterpreterRuntime::bcp_to_di(Method* method, address cur_bcp))
assert(ProfileInterpreter, "must be profiling interpreter");
int bci = method->bci_from(cur_bcp);
MethodData* mdo = method->method_data();
if (mdo == NULL) return 0;
if (mdo == nullptr) return 0;
return mdo->bci_to_di(bci);
JRT_END
@ -1065,7 +1065,7 @@ JRT_LEAF(void, InterpreterRuntime::verify_mdp(Method* method, address bcp, addre
assert(ProfileInterpreter, "must be profiling interpreter");
MethodData* mdo = method->method_data();
assert(mdo != NULL, "must not be null");
assert(mdo != nullptr, "must not be null");
int bci = method->bci_from(bcp);
@ -1103,7 +1103,7 @@ JRT_ENTRY(void, InterpreterRuntime::update_mdp_for_ret(JavaThread* current, int
// ProfileData is essentially a wrapper around a derived oop, so we
// need to take the lock before making any ProfileData structures.
ProfileData* data = h_mdo->data_at(h_mdo->dp_to_di(last_frame.mdp()));
guarantee(data != NULL, "profile data must be valid");
guarantee(data != nullptr, "profile data must be valid");
RetData* rdata = data->as_RetData();
address new_mdp = rdata->fixup_ret(return_bci, h_mdo);
last_frame.set_mdp(new_mdp);
@ -1161,7 +1161,7 @@ JRT_ENTRY(void, InterpreterRuntime::post_field_access(JavaThread* current, oopDe
int index = cp_entry->field_index();
if ((ik->field_access_flags(index) & JVM_ACC_FIELD_ACCESS_WATCHED) == 0) return;
bool is_static = (obj == NULL);
bool is_static = (obj == nullptr);
HandleMark hm(current);
Handle h_obj;
@ -1200,7 +1200,7 @@ JRT_ENTRY(void, InterpreterRuntime::post_field_modification(JavaThread* current,
case dtos: sig_type = JVM_SIGNATURE_DOUBLE; break;
default: ShouldNotReachHere(); return;
}
bool is_static = (obj == NULL);
bool is_static = (obj == nullptr);
HandleMark hm(current);
jfieldID fid = jfieldIDWorkaround::to_jfieldID(ik, cp_entry->f2_as_index(), is_static);
@ -1265,8 +1265,8 @@ uint64_t InterpreterRuntime::normalize_fast_native_fingerprint(uint64_t fingerpr
address SignatureHandlerLibrary::set_handler_blob() {
BufferBlob* handler_blob = BufferBlob::create("native signature handlers", blob_size);
if (handler_blob == NULL) {
return NULL;
if (handler_blob == nullptr) {
return nullptr;
}
address handler = handler_blob->code_begin();
_handler_blob = handler_blob;
@ -1275,10 +1275,10 @@ address SignatureHandlerLibrary::set_handler_blob() {
}
void SignatureHandlerLibrary::initialize() {
if (_fingerprints != NULL) {
if (_fingerprints != nullptr) {
return;
}
if (set_handler_blob() == NULL) {
if (set_handler_blob() == nullptr) {
vm_exit_out_of_memory(blob_size, OOM_MALLOC_ERROR, "native signature handlers");
}
@ -1297,7 +1297,7 @@ address SignatureHandlerLibrary::set_handler(CodeBuffer* buffer) {
// get a new handler blob
handler = set_handler_blob();
}
if (handler != NULL) {
if (handler != nullptr) {
memcpy(handler, buffer->insts_begin(), insts_size);
pd_set_handler(handler);
ICache::invalidate_range(handler, insts_size);
@ -1307,7 +1307,7 @@ address SignatureHandlerLibrary::set_handler(CodeBuffer* buffer) {
}
void SignatureHandlerLibrary::add(const methodHandle& method) {
if (method->signature_handler() == NULL) {
if (method->signature_handler() == nullptr) {
// use slow signature handler if we can't do better
int handler_index = -1;
// check if we can use customized (fast) signature handler
@ -1330,7 +1330,7 @@ void SignatureHandlerLibrary::add(const methodHandle& method) {
InterpreterRuntime::SignatureHandlerGenerator(method, &buffer).generate(fingerprint);
// copy into code heap
address handler = set_handler(&buffer);
if (handler == NULL) {
if (handler == nullptr) {
// use slow signature handler (without memorizing it in the fingerprints)
} else {
// debugging support
@ -1393,7 +1393,7 @@ void SignatureHandlerLibrary::add(const methodHandle& method) {
// thread which may change the arrays in the above, mutex protected block, we
// have to protect this read access here with the same mutex as well!
MutexLocker mu(SignatureHandlerLibrary_lock);
if (_handlers != NULL) {
if (_handlers != nullptr) {
handler_index = _handlers->find(method->signature_handler());
uint64_t fingerprint = Fingerprinter(method).fingerprint();
fingerprint = InterpreterRuntime::normalize_fast_native_fingerprint(fingerprint);
@ -1437,11 +1437,11 @@ void SignatureHandlerLibrary::add(uint64_t fingerprint, address handler) {
}
BufferBlob* SignatureHandlerLibrary::_handler_blob = NULL;
address SignatureHandlerLibrary::_handler = NULL;
GrowableArray<uint64_t>* SignatureHandlerLibrary::_fingerprints = NULL;
GrowableArray<address>* SignatureHandlerLibrary::_handlers = NULL;
address SignatureHandlerLibrary::_buffer = NULL;
BufferBlob* SignatureHandlerLibrary::_handler_blob = nullptr;
address SignatureHandlerLibrary::_handler = nullptr;
GrowableArray<uint64_t>* SignatureHandlerLibrary::_fingerprints = nullptr;
GrowableArray<address>* SignatureHandlerLibrary::_handlers = nullptr;
address SignatureHandlerLibrary::_buffer = nullptr;
JRT_ENTRY(void, InterpreterRuntime::prepare_native_call(JavaThread* current, Method* method))
@ -1504,7 +1504,7 @@ JRT_ENTRY(void, InterpreterRuntime::member_name_arg_or_null(JavaThread* current,
}
current->set_vm_result(member_name_oop);
} else {
current->set_vm_result(NULL);
current->set_vm_result(nullptr);
}
JRT_END
#endif // INCLUDE_JVMTI

112
src/hotspot/share/interpreter/linkResolver.cpp
View File

@ -132,7 +132,7 @@ void CallInfo::set_common(Klass* resolved_klass,
// utility query for unreflecting a method
CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
Klass* resolved_method_holder = resolved_method->method_holder();
if (resolved_klass == NULL) { // 2nd argument defaults to holder of 1st
if (resolved_klass == nullptr) { // 2nd argument defaults to holder of 1st
resolved_klass = resolved_method_holder;
}
_resolved_klass = resolved_klass;
@ -184,7 +184,7 @@ CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
}
void CallInfo::set_resolved_method_name(TRAPS) {
assert(_resolved_method() != NULL, "Should already have a Method*");
assert(_resolved_method() != nullptr, "Should already have a Method*");
oop rmethod_name = java_lang_invoke_ResolvedMethodName::find_resolved_method(_resolved_method, CHECK);
_resolved_method_name = Handle(THREAD, rmethod_name);
}
@ -267,7 +267,7 @@ void LinkInfo::print() {
_resolved_klass->name()->as_C_string(),
_name->as_C_string(),
_signature->as_C_string(),
_current_klass == NULL ? "(none)" : _current_klass->name()->as_C_string(),
_current_klass == nullptr ? "(none)" : _current_klass->name()->as_C_string(),
_check_access ? "true" : "false",
_check_loader_constraints ? "true" : "false");
@ -295,7 +295,7 @@ void LinkResolver::check_klass_accessibility(Klass* ref_klass, Klass* sel_klass,
InstanceKlass::cast(base_klass),
vca_result);
bool same_module = (base_klass->module() == ref_klass->module());
if (msg == NULL) {
if (msg == nullptr) {
Exceptions::fthrow(
THREAD_AND_LOCATION,
vmSymbols::java_lang_IllegalAccessError(),
@ -345,31 +345,31 @@ Method* LinkResolver::lookup_method_in_klasses(const LinkInfo& link_info,
// ignore static and non-public methods of java.lang.Object,
// like clone and finalize.
if (in_imethod_resolve &&
result != NULL &&
result != nullptr &&
ik->is_interface() &&
(result->is_static() || !result->is_public()) &&
result->method_holder() == vmClasses::Object_klass()) {
result = NULL;
result = nullptr;
}
// Before considering default methods, check for an overpass in the
// current class if a method has not been found.
if (result == NULL) {
if (result == nullptr) {
result = ik->find_method(name, signature);
}
if (result == NULL) {
if (result == nullptr) {
Array<Method*>* default_methods = ik->default_methods();
if (default_methods != NULL) {
if (default_methods != nullptr) {
result = InstanceKlass::find_method(default_methods, name, signature);
}
}
if (checkpolymorphism && result != NULL) {
if (checkpolymorphism && result != nullptr) {
vmIntrinsics::ID iid = result->intrinsic_id();
if (MethodHandles::is_signature_polymorphic(iid)) {
// Do not link directly to these. The VM must produce a synthetic one using lookup_polymorphic_method.
return NULL;
return nullptr;
}
}
return result;
@ -383,7 +383,7 @@ Method* LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
Klass::PrivateLookupMode private_mode) {
Method* result = klass->uncached_lookup_method(name, signature, Klass::OverpassLookupMode::find, private_mode);
while (result != NULL && result->is_static() && result->method_holder()->super() != NULL) {
while (result != nullptr && result->is_static() && result->method_holder()->super() != nullptr) {
Klass* super_klass = result->method_holder()->super();
result = super_klass->uncached_lookup_method(name, signature, Klass::OverpassLookupMode::find, private_mode);
}
@ -393,11 +393,11 @@ Method* LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
return result;
}
if (result == NULL) {
if (result == nullptr) {
Array<Method*>* default_methods = InstanceKlass::cast(klass)->default_methods();
if (default_methods != NULL) {
if (default_methods != nullptr) {
result = InstanceKlass::find_method(default_methods, name, signature);
assert(result == NULL || !result->is_static(), "static defaults not allowed");
assert(result == nullptr || !result->is_static(), "static defaults not allowed");
}
}
return result;
@ -446,7 +446,7 @@ Method* LinkResolver::lookup_polymorphic_method(const LinkInfo& link_info,
Method* result = SystemDictionary::find_method_handle_intrinsic(iid,
basic_signature,
CHECK_NULL);
if (result != NULL) {
if (result != nullptr) {
assert(result->is_method_handle_intrinsic(), "MH.invokeBasic or MH.linkTo* intrinsic");
assert(result->intrinsic_id() != vmIntrinsics::_invokeGeneric, "wrong place to find this");
assert(basic_signature == result->signature(), "predict the result signature");
@ -459,13 +459,13 @@ Method* LinkResolver::lookup_polymorphic_method(const LinkInfo& link_info,
return result;
} else if (iid == vmIntrinsics::_invokeGeneric
&& THREAD->can_call_java()
&& appendix_result_or_null != NULL) {
&& appendix_result_or_null != nullptr) {
// This is a method with type-checking semantics.
// We will ask Java code to spin an adapter method for it.
if (!MethodHandles::enabled()) {
// Make sure the Java part of the runtime has been booted up.
Klass* natives = vmClasses::MethodHandleNatives_klass();
if (natives == NULL || InstanceKlass::cast(natives)->is_not_initialized()) {
if (natives == nullptr || InstanceKlass::cast(natives)->is_not_initialized()) {
SystemDictionary::resolve_or_fail(vmSymbols::java_lang_invoke_MethodHandleNatives(),
Handle(),
Handle(),
@ -488,7 +488,7 @@ Method* LinkResolver::lookup_polymorphic_method(const LinkInfo& link_info,
ls.print(" lookup_polymorphic_method => appendix = ");
appendix.is_null() ? ls.print_cr("(none)") : appendix->print_on(&ls);
}
if (result != NULL) {
if (result != nullptr) {
#ifdef ASSERT
ResourceMark rm(THREAD);
@ -508,13 +508,13 @@ Method* LinkResolver::lookup_polymorphic_method(const LinkInfo& link_info,
"%d != %d", actual_size_of_params, expected_size_of_params);
#endif //ASSERT
assert(appendix_result_or_null != NULL, "");
assert(appendix_result_or_null != nullptr, "");
(*appendix_result_or_null) = appendix;
}
return result;
}
}
return NULL;
return nullptr;
}
static void print_nest_host_error_on(stringStream* ss, Klass* ref_klass, Klass* sel_klass) {
@ -524,11 +524,11 @@ static void print_nest_host_error_on(stringStream* ss, Klass* ref_klass, Klass*
InstanceKlass* sel_ik = InstanceKlass::cast(sel_klass);
const char* nest_host_error_1 = ref_ik->nest_host_error();
const char* nest_host_error_2 = sel_ik->nest_host_error();
if (nest_host_error_1 != NULL || nest_host_error_2 != NULL) {
if (nest_host_error_1 != nullptr || nest_host_error_2 != nullptr) {
ss->print(", (%s%s%s)",
(nest_host_error_1 != NULL) ? nest_host_error_1 : "",
(nest_host_error_1 != NULL && nest_host_error_2 != NULL) ? ", " : "",
(nest_host_error_2 != NULL) ? nest_host_error_2 : "");
(nest_host_error_1 != nullptr) ? nest_host_error_1 : "",
(nest_host_error_1 != nullptr && nest_host_error_2 != nullptr) ? ", " : "",
(nest_host_error_2 != nullptr) ? nest_host_error_2 : "");
}
}
@ -557,7 +557,7 @@ void LinkResolver::check_method_accessability(Klass* ref_klass,
new_flags = new_flags | JVM_ACC_PUBLIC;
flags.set_flags(new_flags);
}
// assert(extra_arg_result_or_null != NULL, "must be able to return extra argument");
// assert(extra_arg_result_or_null != nullptr, "must be able to return extra argument");
bool can_access = Reflection::verify_member_access(ref_klass,
resolved_klass,
@ -631,7 +631,7 @@ Method* LinkResolver::resolve_method_statically(Bytecodes::Code code,
|| ((resolved_klass == vmClasses::MethodHandle_klass() || resolved_klass == vmClasses::VarHandle_klass()) &&
MethodHandles::is_signature_polymorphic_name(resolved_klass, link_info.name()))) {
Method* result = ConstantPool::method_at_if_loaded(pool, index);
if (result != NULL) {
if (result != nullptr) {
return result;
}
}
@ -657,16 +657,16 @@ void LinkResolver::check_method_loader_constraints(const LinkInfo& link_info,
ResourceMark rm(THREAD);
Symbol* failed_type_symbol =
SystemDictionary::check_signature_loaders(link_info.signature(),
/*klass_being_linked*/ NULL, // We are not linking class
/*klass_being_linked*/ nullptr, // We are not linking class
current_loader,
resolved_loader, true);
if (failed_type_symbol != NULL) {
if (failed_type_symbol != nullptr) {
Klass* current_class = link_info.current_klass();
ClassLoaderData* current_loader_data = current_class->class_loader_data();
assert(current_loader_data != NULL, "current class has no class loader data");
assert(current_loader_data != nullptr, "current class has no class loader data");
Klass* resolved_method_class = resolved_method->method_holder();
ClassLoaderData* target_loader_data = resolved_method_class->class_loader_data();
assert(target_loader_data != NULL, "resolved method's class has no class loader data");
assert(target_loader_data != nullptr, "resolved method's class has no class loader data");
stringStream ss;
ss.print("loader constraint violation: when resolving %s '", method_type);
@ -694,10 +694,10 @@ void LinkResolver::check_field_loader_constraints(Symbol* field, Symbol* sig,
ResourceMark rm(THREAD); // needed for check_signature_loaders
Symbol* failed_type_symbol =
SystemDictionary::check_signature_loaders(sig,
/*klass_being_linked*/ NULL, // We are not linking class
/*klass_being_linked*/ nullptr, // We are not linking class
ref_loader, sel_loader,
false);
if (failed_type_symbol != NULL) {
if (failed_type_symbol != nullptr) {
stringStream ss;
const char* failed_type_name = failed_type_symbol->as_klass_external_name();
@ -753,7 +753,7 @@ Method* LinkResolver::resolve_method(const LinkInfo& link_info,
if (resolved_method.is_null()) {
// JSR 292: see if this is an implicitly generated method MethodHandle.linkToVirtual(*...), etc
Method* method = lookup_polymorphic_method(link_info, (Handle*)NULL, THREAD);
Method* method = lookup_polymorphic_method(link_info, (Handle*)nullptr, THREAD);
resolved_method = methodHandle(THREAD, method);
if (HAS_PENDING_EXCEPTION) {
nested_exception = Handle(THREAD, PENDING_EXCEPTION);
@ -770,13 +770,13 @@ Method* LinkResolver::resolve_method(const LinkInfo& link_info,
Method::print_external_name(&ss, resolved_klass, link_info.name(), link_info.signature());
ss.print("'");
THROW_MSG_CAUSE_(vmSymbols::java_lang_NoSuchMethodError(),
ss.as_string(), nested_exception, NULL);
ss.as_string(), nested_exception, nullptr);
}
// 6. access checks, access checking may be turned off when calling from within the VM.
Klass* current_klass = link_info.current_klass();
if (link_info.check_access()) {
assert(current_klass != NULL , "current_klass should not be null");
assert(current_klass != nullptr , "current_klass should not be null");
// check if method can be accessed by the referring class
check_method_accessability(current_klass,
@ -813,7 +813,7 @@ static void trace_method_resolution(const char* prefix,
}
st->print("%s%s, compile-time-class:%s, method:%s, method_holder:%s, access_flags: ",
prefix,
(klass == NULL ? "<NULL>" : klass->internal_name()),
(klass == nullptr ? "<nullptr>" : klass->internal_name()),
resolved_klass->internal_name(),
Method::name_and_sig_as_C_string(resolved_klass,
method->name(),
@ -873,7 +873,7 @@ Method* LinkResolver::resolve_interface_method(const LinkInfo& link_info, Byteco
// JDK8 adds non-public interface methods, and accessability check requirement
Klass* current_klass = link_info.current_klass();
assert(current_klass != NULL , "current_klass should not be null");
assert(current_klass != nullptr , "current_klass should not be null");
// check if method can be accessed by the referring class
check_method_accessability(current_klass,
@ -973,7 +973,7 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
// Resolve instance field
Klass* sel_klass = resolved_klass->find_field(field, sig, &fd);
// check if field exists; i.e., if a klass containing the field def has been selected
if (sel_klass == NULL) {
if (sel_klass == nullptr) {
ResourceMark rm(THREAD);
stringStream ss;
ss.print("Class %s does not have member field '", resolved_klass->external_name());
@ -1014,7 +1014,7 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
if (fd.constants()->pool_holder()->major_version() >= 53) {
Method* m = link_info.current_method();
assert(m != NULL, "information about the current method must be available for 'put' bytecodes");
assert(m != nullptr, "information about the current method must be available for 'put' bytecodes");
bool is_initialized_static_final_update = (byte == Bytecodes::_putstatic &&
fd.is_static() &&
!m->is_static_initializer());
@ -1045,7 +1045,7 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
}
}
if (link_info.check_loader_constraints() && (sel_klass != current_klass) && (current_klass != NULL)) {
if (link_info.check_loader_constraints() && (sel_klass != current_klass) && (current_klass != nullptr)) {
check_field_loader_constraints(field, sig, current_klass, sel_klass, CHECK);
}
@ -1085,7 +1085,7 @@ void LinkResolver::resolve_static_call(CallInfo& result,
}
if (resolved_method->is_continuation_native_intrinsic()
&& resolved_method->from_interpreted_entry() == NULL) { // does a load_acquire
&& resolved_method->from_interpreted_entry() == nullptr) { // does a load_acquire
methodHandle mh(THREAD, resolved_method);
// Generate a compiled form of the enterSpecial intrinsic.
AdapterHandlerLibrary::create_native_wrapper(mh);
@ -1139,7 +1139,7 @@ Method* LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info,
// and the selected method is recalculated relative to the direct superclass
// superinterface.method, which explicitly does not check shadowing
Klass* resolved_klass = link_info.resolved_klass();
Method* resolved_method = NULL;
Method* resolved_method = nullptr;
if (!resolved_klass->is_interface()) {
resolved_method = resolve_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
@ -1161,13 +1161,13 @@ Method* LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info,
THREAD_AND_LOCATION,
vmSymbols::java_lang_NoSuchMethodError(),
"%s", ss.as_string());
return NULL;
return nullptr;
}
// ensure that invokespecial's interface method reference is in
// a direct superinterface, not an indirect superinterface
Klass* current_klass = link_info.current_klass();
if (current_klass != NULL && resolved_klass->is_interface()) {
if (current_klass != nullptr && resolved_klass->is_interface()) {
InstanceKlass* klass_to_check = InstanceKlass::cast(current_klass);
// Disable verification for the dynamically-generated reflection bytecodes.
bool is_reflect = klass_to_check->is_subclass_of(
@ -1332,7 +1332,7 @@ Method* LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
ss.print("private interface method requires invokespecial, not invokevirtual: method '");
resolved_method->print_external_name(&ss);
ss.print("', caller-class: %s",
(current_klass == NULL ? "<null>" : current_klass->internal_name()));
(current_klass == nullptr ? "<null>" : current_klass->internal_name()));
THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
}
@ -1542,7 +1542,7 @@ Method* LinkResolver::linktime_resolve_interface_method_or_null(
Method* method_result = linktime_resolve_interface_method(link_info, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return NULL;
return nullptr;
} else {
return method_result;
}
@ -1554,7 +1554,7 @@ Method* LinkResolver::linktime_resolve_virtual_method_or_null(
Method* method_result = linktime_resolve_virtual_method(link_info, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return NULL;
return nullptr;
} else {
return method_result;
}
@ -1568,7 +1568,7 @@ Method* LinkResolver::resolve_virtual_call_or_null(
resolve_virtual_call(info, Handle(), receiver_klass, link_info, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return NULL;
return nullptr;
}
return info.selected_method();
}
@ -1581,7 +1581,7 @@ Method* LinkResolver::resolve_interface_call_or_null(
resolve_interface_call(info, Handle(), receiver_klass, link_info, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return NULL;
return nullptr;
}
return info.selected_method();
}
@ -1605,7 +1605,7 @@ Method* LinkResolver::resolve_static_call_or_null(const LinkInfo& link_info) {
resolve_static_call(info, link_info, /*initialize_class*/false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return NULL;
return nullptr;
}
return info.selected_method();
}
@ -1616,7 +1616,7 @@ Method* LinkResolver::resolve_special_call_or_null(const LinkInfo& link_info) {
resolve_special_call(info, Handle(), link_info, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return NULL;
return nullptr;
}
return info.selected_method();
}
@ -1685,14 +1685,14 @@ void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv,
TRAPS) {
LinkInfo link_info(pool, index, CHECK);
Klass* recvrKlass = recv.is_null() ? (Klass*)NULL : recv->klass();
Klass* recvrKlass = recv.is_null() ? (Klass*)nullptr : recv->klass();
resolve_virtual_call(result, recv, recvrKlass, link_info, /*check_null_or_abstract*/true, CHECK);
}
void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, const constantPoolHandle& pool, int index, TRAPS) {
LinkInfo link_info(pool, index, CHECK);
Klass* recvrKlass = recv.is_null() ? (Klass*)NULL : recv->klass();
Klass* recvrKlass = recv.is_null() ? (Klass*)nullptr : recv->klass();
resolve_interface_call(result, recv, recvrKlass, link_info, true, CHECK);
}
@ -1746,7 +1746,7 @@ void LinkResolver::resolve_handle_call(CallInfo& result,
assert(iid == vmIntrinsicID::_invokeBasic, "%s", vmIntrinsics::name_at(iid));
Klass* current_klass = link_info.current_klass();
assert(current_klass != NULL , "current_klass should not be null");
assert(current_klass != nullptr , "current_klass should not be null");
check_method_accessability(current_klass,
resolved_klass,
resolved_method->method_holder(),
@ -1852,7 +1852,7 @@ void LinkResolver::throw_abstract_method_error(const methodHandle& resolved_meth
ResourceMark rm(THREAD);
stringStream ss;
if (recv_klass != NULL) {
if (recv_klass != nullptr) {
ss.print("Receiver class %s does not define or inherit an "
"implementation of the",
recv_klass->external_name());

2
src/hotspot/share/interpreter/linkResolver.hpp
View File

@ -347,7 +347,7 @@ class LinkResolver: AllStatic {
// Only resolved method known.
static void throw_abstract_method_error(const methodHandle& resolved_method, TRAPS) {
throw_abstract_method_error(resolved_method, methodHandle(), NULL, CHECK);
throw_abstract_method_error(resolved_method, methodHandle(), nullptr, CHECK);
}
// Resolved method and receiver klass know.
static void throw_abstract_method_error(const methodHandle& resolved_method, Klass *recv_klass, TRAPS) {

36
src/hotspot/share/interpreter/oopMapCache.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -60,7 +60,7 @@ class OopMapCacheEntry: private InterpreterOopMap {
public:
OopMapCacheEntry() : InterpreterOopMap() {
_next = NULL;
_next = nullptr;
#ifdef ASSERT
_resource_allocate_bit_mask = false;
#endif
@ -190,15 +190,15 @@ InterpreterOopMap::~InterpreterOopMap() {
}
bool InterpreterOopMap::is_empty() const {
bool result = _method == NULL;
assert(_method != NULL || (_bci == 0 &&
bool result = _method == nullptr;
assert(_method != nullptr || (_bci == 0 &&
(_mask_size == 0 || _mask_size == USHRT_MAX) &&
_bit_mask[0] == 0), "Should be completely empty");
return result;
}
void InterpreterOopMap::initialize() {
_method = NULL;
_method = nullptr;
_mask_size = USHRT_MAX; // This value should cause a failure quickly
_bci = 0;
_expression_stack_size = 0;
@ -443,16 +443,16 @@ inline unsigned int OopMapCache::hash_value_for(const methodHandle& method, int
^ ((unsigned int) method->size_of_parameters() << 6);
}
OopMapCacheEntry* volatile OopMapCache::_old_entries = NULL;
OopMapCacheEntry* volatile OopMapCache::_old_entries = nullptr;
OopMapCache::OopMapCache() {
_array = NEW_C_HEAP_ARRAY(OopMapCacheEntry*, _size, mtClass);
for(int i = 0; i < _size; i++) _array[i] = NULL;
for(int i = 0; i < _size; i++) _array[i] = nullptr;
}
OopMapCache::~OopMapCache() {
assert(_array != NULL, "sanity check");
assert(_array != nullptr, "sanity check");
// Deallocate oop maps that are allocated out-of-line
flush();
// Deallocate array
@ -470,8 +470,8 @@ bool OopMapCache::put_at(int i, OopMapCacheEntry* entry, OopMapCacheEntry* old)
void OopMapCache::flush() {
for (int i = 0; i < _size; i++) {
OopMapCacheEntry* entry = _array[i];
if (entry != NULL) {
_array[i] = NULL; // no barrier, only called in OopMapCache destructor
if (entry != nullptr) {
_array[i] = nullptr; // no barrier, only called in OopMapCache destructor
entry->flush();
FREE_C_HEAP_OBJ(entry);
}
@ -482,7 +482,7 @@ void OopMapCache::flush_obsolete_entries() {
assert(SafepointSynchronize::is_at_safepoint(), "called by RedefineClasses in a safepoint");
for (int i = 0; i < _size; i++) {
OopMapCacheEntry* entry = _array[i];
if (entry != NULL && !entry->is_empty() && entry->method()->is_old()) {
if (entry != nullptr && !entry->is_empty() && entry->method()->is_old()) {
// Cache entry is occupied by an old redefined method and we don't want
// to pin it down so flush the entry.
if (log_is_enabled(Debug, redefine, class, oopmap)) {
@ -491,7 +491,7 @@ void OopMapCache::flush_obsolete_entries() {
("flush: %s(%s): cached entry @%d",
entry->method()->name()->as_C_string(), entry->method()->signature()->as_C_string(), i);
}
_array[i] = NULL;
_array[i] = nullptr;
entry->flush();
FREE_C_HEAP_OBJ(entry);
}
@ -506,7 +506,7 @@ void OopMapCache::lookup(const methodHandle& method,
assert(SafepointSynchronize::is_at_safepoint(), "called by GC in a safepoint");
int probe = hash_value_for(method, bci);
int i;
OopMapCacheEntry* entry = NULL;
OopMapCacheEntry* entry = nullptr;
if (log_is_enabled(Debug, interpreter, oopmap)) {
static int count = 0;
@ -519,7 +519,7 @@ void OopMapCache::lookup(const methodHandle& method,
// Search hashtable for match
for(i = 0; i < _probe_depth; i++) {
entry = entry_at(probe + i);
if (entry != NULL && !entry->is_empty() && entry->match(method, bci)) {
if (entry != nullptr && !entry->is_empty() && entry->match(method, bci)) {
entry_for->resource_copy(entry);
assert(!entry_for->is_empty(), "A non-empty oop map should be returned");
log_debug(interpreter, oopmap)("- found at hash %d", probe + i);
@ -547,8 +547,8 @@ void OopMapCache::lookup(const methodHandle& method,
// First search for an empty slot
for(i = 0; i < _probe_depth; i++) {
entry = entry_at(probe + i);
if (entry == NULL) {
if (put_at(probe + i, tmp, NULL)) {
if (entry == nullptr) {
if (put_at(probe + i, tmp, nullptr)) {
assert(!entry_for->is_empty(), "A non-empty oop map should be returned");
return;
}
@ -590,8 +590,8 @@ void OopMapCache::enqueue_for_cleanup(OopMapCacheEntry* entry) {
// list, so no synchronization needed.
void OopMapCache::cleanup_old_entries() {
OopMapCacheEntry* entry = _old_entries;
_old_entries = NULL;
while (entry != NULL) {
_old_entries = nullptr;
while (entry != nullptr) {
if (log_is_enabled(Debug, interpreter, oopmap)) {
ResourceMark rm;
log_debug(interpreter, oopmap)("cleanup entry %s at bci %d",

8
src/hotspot/share/interpreter/rewriter.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -127,7 +127,7 @@ void Rewriter::make_constant_pool_cache(TRAPS) {
// Clean up constant pool cache if initialize_resolved_references() failed.
if (HAS_PENDING_EXCEPTION) {
MetadataFactory::free_metadata(loader_data, cache);
_pool->set_cache(NULL); // so the verifier isn't confused
_pool->set_cache(nullptr); // so the verifier isn't confused
}
}
@ -457,7 +457,7 @@ void Rewriter::scan_method(Thread* thread, Method* method, bool reverse, bool* i
Symbol* field_sig = cp->signature_ref_at(bc_index);
fieldDescriptor fd;
if (klass->find_field(field_name, field_sig, &fd) != NULL) {
if (klass->find_field(field_name, field_sig, &fd) != nullptr) {
if (fd.access_flags().is_final()) {
if (fd.access_flags().is_static()) {
if (!method->is_static_initializer()) {
@ -530,7 +530,7 @@ methodHandle Rewriter::rewrite_jsrs(const methodHandle& method, TRAPS) {
}
void Rewriter::rewrite_bytecodes(TRAPS) {
assert(_pool->cache() == NULL, "constant pool cache must not be set yet");
assert(_pool->cache() == nullptr, "constant pool cache must not be set yet");
// determine index maps for Method* rewriting
compute_index_maps();

50
src/hotspot/share/interpreter/templateInterpreter.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -40,7 +40,7 @@
void TemplateInterpreter::initialize_stub() {
// assertions
assert(_code == NULL, "must only initialize once");
assert(_code == nullptr, "must only initialize once");
assert((int)Bytecodes::number_of_codes <= (int)DispatchTable::length,
"dispatch table too small");
@ -51,7 +51,7 @@ void TemplateInterpreter::initialize_stub() {
// plus their code section is aligned to CodeEntryAlignement. So we need additional size due to alignment.
int max_aligned_codelets = 280;
int max_aligned_bytes = max_aligned_codelets * (HeapWordSize + CodeEntryAlignment);
_code = new StubQueue(new InterpreterCodeletInterface, code_size + max_aligned_bytes, NULL,
_code = new StubQueue(new InterpreterCodeletInterface, code_size + max_aligned_bytes, nullptr,
"Interpreter");
}
@ -82,16 +82,16 @@ void TemplateInterpreter::initialize_code() {
EntryPoint::EntryPoint() {
assert(number_of_states == 10, "check the code below");
_entry[btos] = NULL;
_entry[ztos] = NULL;
_entry[ctos] = NULL;
_entry[stos] = NULL;
_entry[atos] = NULL;
_entry[itos] = NULL;
_entry[ltos] = NULL;
_entry[ftos] = NULL;
_entry[dtos] = NULL;
_entry[vtos] = NULL;
_entry[btos] = nullptr;
_entry[ztos] = nullptr;
_entry[ctos] = nullptr;
_entry[stos] = nullptr;
_entry[atos] = nullptr;
_entry[itos] = nullptr;
_entry[ltos] = nullptr;
_entry[ftos] = nullptr;
_entry[dtos] = nullptr;
_entry[vtos] = nullptr;
}
@ -200,17 +200,17 @@ bool DispatchTable::operator == (DispatchTable& y) {
return true;
}
address TemplateInterpreter::_remove_activation_entry = NULL;
address TemplateInterpreter::_remove_activation_preserving_args_entry = NULL;
address TemplateInterpreter::_remove_activation_entry = nullptr;
address TemplateInterpreter::_remove_activation_preserving_args_entry = nullptr;
address TemplateInterpreter::_throw_ArrayIndexOutOfBoundsException_entry = NULL;
address TemplateInterpreter::_throw_ArrayStoreException_entry = NULL;
address TemplateInterpreter::_throw_ArithmeticException_entry = NULL;
address TemplateInterpreter::_throw_ClassCastException_entry = NULL;
address TemplateInterpreter::_throw_NullPointerException_entry = NULL;
address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
address TemplateInterpreter::_throw_exception_entry = NULL;
address TemplateInterpreter::_throw_ArrayIndexOutOfBoundsException_entry = nullptr;
address TemplateInterpreter::_throw_ArrayStoreException_entry = nullptr;
address TemplateInterpreter::_throw_ArithmeticException_entry = nullptr;
address TemplateInterpreter::_throw_ClassCastException_entry = nullptr;
address TemplateInterpreter::_throw_NullPointerException_entry = nullptr;
address TemplateInterpreter::_throw_StackOverflowError_entry = nullptr;
address TemplateInterpreter::_throw_exception_entry = nullptr;
#ifndef PRODUCT
EntryPoint TemplateInterpreter::_trace_code;
@ -250,7 +250,7 @@ address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code
return Interpreter::invokedynamic_return_entry_table();
default:
fatal("invalid bytecode: %s", Bytecodes::name(code));
return NULL;
return nullptr;
}
}
@ -273,7 +273,7 @@ address TemplateInterpreter::return_entry(TosState state, int length, Bytecodes:
default:
assert(!Bytecodes::is_invoke(code), "invoke instructions should be handled separately: %s", Bytecodes::name(code));
address entry = _return_entry[length].entry(state);
vmassert(entry != NULL, "unsupported return entry requested, length=%d state=%d", length, index);
vmassert(entry != nullptr, "unsupported return entry requested, length=%d state=%d", length, index);
return entry;
}
}
@ -282,7 +282,7 @@ address TemplateInterpreter::return_entry(TosState state, int length, Bytecodes:
address TemplateInterpreter::deopt_entry(TosState state, int length) {
guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length");
address entry = _deopt_entry[length].entry(state);
vmassert(entry != NULL, "unsupported deopt entry requested, length=%d state=%d", length, TosState_as_index(state));
vmassert(entry != nullptr, "unsupported deopt entry requested, length=%d state=%d", length, TosState_as_index(state));
return entry;
}

4
src/hotspot/share/interpreter/templateInterpreter.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -138,7 +138,7 @@ class TemplateInterpreter: public AbstractInterpreter {
static void initialize_stub();
static void initialize_code();
// this only returns whether a pc is within generated code for the interpreter.
static bool contains(address pc) { return _code != NULL && _code->contains(pc); }
static bool contains(address pc) { return _code != nullptr && _code->contains(pc); }
// Debugging/printing
static InterpreterCodelet* codelet_containing(address pc);

20
src/hotspot/share/interpreter/templateInterpreterGenerator.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -35,8 +35,8 @@
#define __ Disassembler::hook<InterpreterMacroAssembler>(__FILE__, __LINE__, _masm)->
TemplateInterpreterGenerator::TemplateInterpreterGenerator(): AbstractInterpreterGenerator() {
_unimplemented_bytecode = NULL;
_illegal_bytecode_sequence = NULL;
_unimplemented_bytecode = nullptr;
_illegal_bytecode_sequence = nullptr;
generate_all();
}
@ -171,7 +171,7 @@ void TemplateInterpreterGenerator::generate_all() {
Interpreter::_throw_ArrayStoreException_entry = generate_klass_exception_handler("java/lang/ArrayStoreException");
Interpreter::_throw_ArithmeticException_entry = generate_exception_handler("java/lang/ArithmeticException", "/ by zero");
Interpreter::_throw_ClassCastException_entry = generate_ClassCastException_handler();
Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException", NULL);
Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException", nullptr);
Interpreter::_throw_StackOverflowError_entry = generate_StackOverflowError_handler();
}
@ -247,7 +247,7 @@ void TemplateInterpreterGenerator::generate_all() {
);
}
address return_continuation = Interpreter::_normal_table.entry(Bytecodes::_return).entry(vtos);
vmassert(return_continuation != NULL, "return entry not generated yet");
vmassert(return_continuation != nullptr, "return entry not generated yet");
Interpreter::_deopt_reexecute_return_entry = generate_deopt_entry_for(vtos, 0, return_continuation);
}
@ -295,8 +295,8 @@ void TemplateInterpreterGenerator::set_unimplemented(int i) {
void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) {
CodeletMark cm(_masm, Bytecodes::name(code), code);
// initialize entry points
assert(_unimplemented_bytecode != NULL, "should have been generated before");
assert(_illegal_bytecode_sequence != NULL, "should have been generated before");
assert(_unimplemented_bytecode != nullptr, "should have been generated before");
assert(_illegal_bytecode_sequence != nullptr, "should have been generated before");
address bep = _illegal_bytecode_sequence;
address zep = _illegal_bytecode_sequence;
address cep = _illegal_bytecode_sequence;
@ -398,7 +398,7 @@ address TemplateInterpreterGenerator::generate_method_entry(
// determine code generation flags
bool native = false;
bool synchronized = false;
address entry_point = NULL;
address entry_point = nullptr;
switch (kind) {
case Interpreter::zerolocals : break;
@ -469,12 +469,12 @@ address TemplateInterpreterGenerator::generate_method_entry(
// We expect the normal and native entry points to be generated first so we can reuse them.
if (native) {
entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
if (entry_point == NULL) {
if (entry_point == nullptr) {
entry_point = generate_native_entry(synchronized);
}
} else {
entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);
if (entry_point == NULL) {
if (entry_point == nullptr) {
entry_point = generate_normal_entry(synchronized);
}
}

6
src/hotspot/share/interpreter/templateInterpreterGenerator.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -47,14 +47,14 @@ class TemplateInterpreterGenerator: public AbstractInterpreterGenerator {
return generate_exception_handler_common(name, message, false);
}
address generate_klass_exception_handler(const char* name) {
return generate_exception_handler_common(name, NULL, true);
return generate_exception_handler_common(name, nullptr, true);
}
address generate_exception_handler_common(const char* name, const char* message, bool pass_oop);
address generate_ClassCastException_handler();
address generate_ArrayIndexOutOfBounds_handler();
address generate_return_entry_for(TosState state, int step, size_t index_size);
address generate_earlyret_entry_for(TosState state);
address generate_deopt_entry_for(TosState state, int step, address continuation = NULL);
address generate_deopt_entry_for(TosState state, int step, address continuation = nullptr);
address generate_safept_entry_for(TosState state, address runtime_entry);
void generate_throw_exception();

4
src/hotspot/share/interpreter/templateTable.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -64,7 +64,7 @@ class Template {
public:
Bytecodes::Code bytecode() const;
bool is_valid() const { return _gen != NULL; }
bool is_valid() const { return _gen != nullptr; }
bool uses_bcp() const { return (_flags & (1 << uses_bcp_bit )) != 0; }
bool does_dispatch() const { return (_flags & (1 << does_dispatch_bit)) != 0; }
bool calls_vm() const { return (_flags & (1 << calls_vm_bit )) != 0; }

118
src/hotspot/share/interpreter/zero/bytecodeInterpreter.cpp
View File

@ -340,8 +340,8 @@ JRT_END
*/
#undef CHECK_NULL
#define CHECK_NULL(obj_) \
if ((obj_) == NULL) { \
VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), NULL); \
if ((obj_) == nullptr) { \
VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), nullptr); \
} \
VERIFY_OOP(obj_)
@ -400,7 +400,7 @@ JRT_END
if (*count_addr > 0) { \
oop target; \
if ((Bytecodes::Code)opcode == Bytecodes::_getstatic) { \
target = NULL; \
target = nullptr; \
} else { \
target = obj; \
} \
@ -420,7 +420,7 @@ JRT_END
if (*count_addr > 0) { \
oop target; \
if ((Bytecodes::Code)opcode == Bytecodes::_putstatic) { \
target = NULL; \
target = nullptr; \
} else { \
target = obj; \
} \
@ -506,7 +506,7 @@ void BytecodeInterpreter::run(interpreterState istate) {
do {
assert(l == l->_self_link, "bad link");
l = l->_prev_link;
} while (l != NULL);
} while (l != nullptr);
// Screwups with stack management usually cause us to overwrite istate
// save a copy so we can verify it.
interpreterState orig = istate;
@ -629,7 +629,7 @@ void BytecodeInterpreter::run(interpreterState istate) {
if (call_vm || rcvr->cas_set_mark(markWord::from_pointer(mon), displaced) != displaced) {
// Is it simple recursive case?
if (!call_vm && THREAD->is_lock_owned((address) displaced.clear_lock_bits().to_pointer())) {
mon->lock()->set_displaced_header(markWord::from_pointer(NULL));
mon->lock()->set_displaced_header(markWord::from_pointer(nullptr));
} else {
inc_monitor_count = false;
CALL_VM(InterpreterRuntime::monitorenter(THREAD, mon), handle_exception);
@ -717,7 +717,7 @@ void BytecodeInterpreter::run(interpreterState istate) {
// derefing's lockee ought to provoke implicit null check
// find a free monitor
BasicObjectLock* entry = (BasicObjectLock*) istate->stack_base();
assert(entry->obj() == NULL, "Frame manager didn't allocate the monitor");
assert(entry->obj() == nullptr, "Frame manager didn't allocate the monitor");
entry->set_obj(lockee);
// traditional lightweight locking
@ -728,7 +728,7 @@ void BytecodeInterpreter::run(interpreterState istate) {
if (call_vm || lockee->cas_set_mark(markWord::from_pointer(entry), displaced) != displaced) {
// Is it simple recursive case?
if (!call_vm && THREAD->is_lock_owned((address) displaced.clear_lock_bits().to_pointer())) {
entry->lock()->set_displaced_header(markWord::from_pointer(NULL));
entry->lock()->set_displaced_header(markWord::from_pointer(nullptr));
} else {
inc_monitor_count = false;
CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
@ -784,7 +784,7 @@ run:
/* Push miscellaneous constants onto the stack. */
CASE(_aconst_null):
SET_STACK_OBJECT(NULL, 0);
SET_STACK_OBJECT(nullptr, 0);
UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
#undef OPC_CONST_n
@ -1367,7 +1367,7 @@ run:
#define NULL_COMPARISON_NOT_OP(name) \
CASE(_if##name): { \
int skip = (!(STACK_OBJECT(-1) == NULL)) \
int skip = (!(STACK_OBJECT(-1) == nullptr)) \
? (int16_t)Bytes::get_Java_u2(pc + 1) : 3; \
address branch_pc = pc; \
UPDATE_PC_AND_TOS(skip, -1); \
@ -1377,7 +1377,7 @@ run:
#define NULL_COMPARISON_OP(name) \
CASE(_if##name): { \
int skip = ((STACK_OBJECT(-1) == NULL)) \
int skip = ((STACK_OBJECT(-1) == nullptr)) \
? (int16_t)Bytes::get_Java_u2(pc + 1) : 3; \
address branch_pc = pc; \
UPDATE_PC_AND_TOS(skip, -1); \
@ -1585,7 +1585,7 @@ run:
VERIFY_OOP(rhsObject);
ARRAY_INTRO( -3);
// arrObj, index are set
if (rhsObject != NULL) {
if (rhsObject != nullptr) {
/* Check assignability of rhsObject into arrObj */
Klass* rhsKlass = rhsObject->klass(); // EBX (subclass)
Klass* elemKlass = ObjArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
@ -1641,13 +1641,13 @@ run:
// since this is recursive enter
BasicObjectLock* limit = istate->monitor_base();
BasicObjectLock* most_recent = (BasicObjectLock*) istate->stack_base();
BasicObjectLock* entry = NULL;
BasicObjectLock* entry = nullptr;
while (most_recent != limit ) {
if (most_recent->obj() == NULL) entry = most_recent;
if (most_recent->obj() == nullptr) entry = most_recent;
else if (most_recent->obj() == lockee) break;
most_recent++;
}
if (entry != NULL) {
if (entry != nullptr) {
entry->set_obj(lockee);
// traditional lightweight locking
@ -1658,7 +1658,7 @@ run:
if (call_vm || lockee->cas_set_mark(markWord::from_pointer(entry), displaced) != displaced) {
// Is it simple recursive case?
if (!call_vm && THREAD->is_lock_owned((address) displaced.clear_lock_bits().to_pointer())) {
entry->lock()->set_displaced_header(markWord::from_pointer(NULL));
entry->lock()->set_displaced_header(markWord::from_pointer(nullptr));
} else {
inc_monitor_count = false;
CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
@ -1685,12 +1685,12 @@ run:
if ((most_recent)->obj() == lockee) {
BasicLock* lock = most_recent->lock();
markWord header = lock->displaced_header();
most_recent->set_obj(NULL);
most_recent->set_obj(nullptr);
// If it isn't recursive we either must swap old header or call the runtime
bool dec_monitor_count = true;
bool call_vm = UseHeavyMonitors;
if (header.to_pointer() != NULL || call_vm) {
if (header.to_pointer() != nullptr || call_vm) {
markWord old_header = markWord::encode(lock);
if (call_vm || lockee->cas_set_mark(header, old_header) != old_header) {
// restore object for the slow case
@ -1988,7 +1988,7 @@ run:
if (ik->is_initialized() && ik->can_be_fastpath_allocated()) {
size_t obj_size = ik->size_helper();
HeapWord* result = THREAD->tlab().allocate(obj_size);
if (result != NULL) {
if (result != nullptr) {
// Initialize object field block:
// - if TLAB is pre-zeroed, we can skip this path
// - in debug mode, ThreadLocalAllocBuffer::allocate mangles
@ -2020,7 +2020,7 @@ run:
// with stores that publish the new object.
OrderAccess::storestore();
SET_STACK_OBJECT(THREAD->vm_result(), 0);
THREAD->set_vm_result(NULL);
THREAD->set_vm_result(nullptr);
UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
}
CASE(_anewarray): {
@ -2032,7 +2032,7 @@ run:
// with stores that publish the new object.
OrderAccess::storestore();
SET_STACK_OBJECT(THREAD->vm_result(), -1);
THREAD->set_vm_result(NULL);
THREAD->set_vm_result(nullptr);
UPDATE_PC_AND_CONTINUE(3);
}
CASE(_multianewarray): {
@ -2049,11 +2049,11 @@ run:
// with stores that publish the new object.
OrderAccess::storestore();
SET_STACK_OBJECT(THREAD->vm_result(), -dims);
THREAD->set_vm_result(NULL);
THREAD->set_vm_result(nullptr);
UPDATE_PC_AND_TOS_AND_CONTINUE(4, -(dims-1));
}
CASE(_checkcast):
if (STACK_OBJECT(-1) != NULL) {
if (STACK_OBJECT(-1) != nullptr) {
VERIFY_OOP(STACK_OBJECT(-1));
u2 index = Bytes::get_Java_u2(pc+1);
// Constant pool may have actual klass or unresolved klass. If it is
@ -2077,7 +2077,7 @@ run:
UPDATE_PC_AND_CONTINUE(3);
CASE(_instanceof):
if (STACK_OBJECT(-1) == NULL) {
if (STACK_OBJECT(-1) == nullptr) {
SET_STACK_INT(0, -1);
} else {
VERIFY_OOP(STACK_OBJECT(-1));
@ -2128,10 +2128,10 @@ run:
case JVM_CONSTANT_String:
{
oop result = constants->resolved_reference_at(index);
if (result == NULL) {
if (result == nullptr) {
CALL_VM(InterpreterRuntime::resolve_ldc(THREAD, (Bytecodes::Code) opcode), handle_exception);
SET_STACK_OBJECT(THREAD->vm_result(), 0);
THREAD->set_vm_result(NULL);
THREAD->set_vm_result(nullptr);
} else {
VERIFY_OOP(result);
SET_STACK_OBJECT(result, 0);
@ -2148,7 +2148,7 @@ run:
case JVM_CONSTANT_UnresolvedClassInError:
CALL_VM(InterpreterRuntime::ldc(THREAD, wide), handle_exception);
SET_STACK_OBJECT(THREAD->vm_result(), 0);
THREAD->set_vm_result(NULL);
THREAD->set_vm_result(nullptr);
break;
case JVM_CONSTANT_Dynamic:
@ -2233,13 +2233,13 @@ run:
// there is a 1-1 relation between bytecode type and CP entry type.
ConstantPool* constants = METHOD->constants();
oop result = constants->resolved_reference_at(index);
if (result == NULL) {
if (result == nullptr) {
CALL_VM(InterpreterRuntime::resolve_ldc(THREAD, (Bytecodes::Code) opcode),
handle_exception);
result = THREAD->vm_result();
}
if (result == Universe::the_null_sentinel())
result = NULL;
result = nullptr;
VERIFY_OOP(result);
SET_STACK_OBJECT(result, 0);
@ -2322,7 +2322,7 @@ run:
// Special case of invokeinterface called for virtual method of
// java.lang.Object. See cpCache.cpp for details.
Method* callee = NULL;
Method* callee = nullptr;
if (cache->is_forced_virtual()) {
CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
if (cache->is_vfinal()) {
@ -2358,7 +2358,7 @@ run:
}
callee = cache->f2_as_vfinal_method();
}
if (callee != NULL) {
if (callee != nullptr) {
istate->set_callee(callee);
istate->set_callee_entry_point(callee->from_interpreted_entry());
if (JVMTI_ENABLED && THREAD->is_interp_only_mode()) {
@ -2383,7 +2383,7 @@ run:
Klass* refc = cache->f1_as_klass();
itableOffsetEntry* scan;
for (scan = (itableOffsetEntry*) int2->start_of_itable();
scan->interface_klass() != NULL;
scan->interface_klass() != nullptr;
scan++) {
if (scan->interface_klass() == refc) {
break;
@ -2393,7 +2393,7 @@ run:
// that the receiver class doesn't implement the
// interface, and wasn't the same as when the caller was
// compiled.
if (scan->interface_klass() == NULL) {
if (scan->interface_klass() == nullptr) {
VM_JAVA_ERROR(vmSymbols::java_lang_IncompatibleClassChangeError(), "");
}
}
@ -2414,7 +2414,7 @@ run:
itableMethodEntry* im = ki->first_method_entry(rcvr->klass());
callee = im[mindex].method();
if (callee == NULL) {
if (callee == nullptr) {
CALL_VM(InterpreterRuntime::throw_AbstractMethodErrorVerbose(THREAD, rcvr->klass(), interface_method),
handle_exception);
}
@ -2512,7 +2512,7 @@ run:
// with stores that publish the new object.
OrderAccess::storestore();
SET_STACK_OBJECT(THREAD->vm_result(), -1);
THREAD->set_vm_result(NULL);
THREAD->set_vm_result(nullptr);
UPDATE_PC_AND_CONTINUE(2);
}
@ -2523,7 +2523,7 @@ run:
oop except_oop = STACK_OBJECT(-1);
CHECK_NULL(except_oop);
// set pending_exception so we use common code
THREAD->set_pending_exception(except_oop, NULL, 0);
THREAD->set_pending_exception(except_oop, nullptr, 0);
goto handle_exception;
}
@ -2945,7 +2945,7 @@ run:
HandleMark __hm(THREAD);
THREAD->clear_pending_exception();
assert(except_oop() != NULL, "No exception to process");
assert(except_oop() != nullptr, "No exception to process");
intptr_t continuation_bci;
// expression stack is emptied
topOfStack = istate->stack_base() - Interpreter::stackElementWords;
@ -2953,7 +2953,7 @@ run:
handle_exception);
except_oop = Handle(THREAD, THREAD->vm_result());
THREAD->set_vm_result(NULL);
THREAD->set_vm_result(nullptr);
if (continuation_bci >= 0) {
// Place exception on top of stack
SET_STACK_OBJECT(except_oop(), 0);
@ -2987,7 +2987,7 @@ run:
Exceptions::debug_check_abort(except_oop);
// No handler in this activation, unwind and try again
THREAD->set_pending_exception(except_oop(), NULL, 0);
THREAD->set_pending_exception(except_oop(), nullptr, 0);
goto handle_return;
} // handle_exception:
@ -3054,7 +3054,7 @@ run:
}
ts->clr_earlyret_value();
ts->set_earlyret_oop(NULL);
ts->set_earlyret_oop(nullptr);
ts->clr_earlyret_pending();
// Fall through to handle_return.
@ -3073,14 +3073,14 @@ run:
bool suppress_error = istate->msg() == popping_frame || istate->msg() == early_return;
bool suppress_exit_event = THREAD->has_pending_exception() || istate->msg() == popping_frame;
Handle original_exception(THREAD, THREAD->pending_exception());
Handle illegal_state_oop(THREAD, NULL);
Handle illegal_state_oop(THREAD, nullptr);
// We'd like a HandleMark here to prevent any subsequent HandleMarkCleaner
// in any following VM entries from freeing our live handles, but illegal_state_oop
// isn't really allocated yet and so doesn't become live until later and
// in unpredictable places. Instead we must protect the places where we enter the
// VM. It would be much simpler (and safer) if we could allocate a real handle with
// a NULL oop in it and then overwrite the oop later as needed. This isn't
// a null oop in it and then overwrite the oop later as needed. This isn't
// unfortunately isn't possible.
if (THREAD->has_pending_exception()) {
@ -3130,14 +3130,14 @@ run:
// Check all the monitors to see they are unlocked. Install exception if found to be locked.
while (end < base) {
oop lockee = end->obj();
if (lockee != NULL) {
if (lockee != nullptr) {
BasicLock* lock = end->lock();
markWord header = lock->displaced_header();
end->set_obj(NULL);
end->set_obj(nullptr);
// If it isn't recursive we either must swap old header or call the runtime
bool dec_monitor_count = true;
if (header.to_pointer() != NULL) {
if (header.to_pointer() != nullptr) {
markWord old_header = markWord::encode(lock);
if (lockee->cas_set_mark(header, old_header) != old_header) {
// restore object for the slow case
@ -3151,7 +3151,7 @@ run:
}
// One error is plenty
if (illegal_state_oop() == NULL && !suppress_error) {
if (illegal_state_oop() == nullptr && !suppress_error) {
{
// Prevent any HandleMarkCleaner from freeing our live handles
HandleMark __hm(THREAD);
@ -3166,9 +3166,9 @@ run:
}
// Unlock the method if needed
if (method_unlock_needed) {
if (base->obj() == NULL) {
if (base->obj() == nullptr) {
// The method is already unlocked this is not good.
if (illegal_state_oop() == NULL && !suppress_error) {
if (illegal_state_oop() == nullptr && !suppress_error) {
{
// Prevent any HandleMarkCleaner from freeing our live handles
HandleMark __hm(THREAD);
@ -3189,7 +3189,7 @@ run:
// and must use first monitor slot.
//
oop rcvr = base->obj();
if (rcvr == NULL) {
if (rcvr == nullptr) {
if (!suppress_error) {
VM_JAVA_ERROR_NO_JUMP(vmSymbols::java_lang_NullPointerException(), "");
illegal_state_oop = Handle(THREAD, THREAD->pending_exception());
@ -3204,11 +3204,11 @@ run:
} else {
BasicLock* lock = base->lock();
markWord header = lock->displaced_header();
base->set_obj(NULL);
base->set_obj(nullptr);
// If it isn't recursive we either must swap old header or call the runtime
bool dec_monitor_count = true;
if (header.to_pointer() != NULL) {
if (header.to_pointer() != nullptr) {
markWord old_header = markWord::encode(lock);
if (rcvr->cas_set_mark(header, old_header) != old_header) {
// restore object for the slow case
@ -3249,7 +3249,7 @@ run:
// (with this note) in anticipation of changing the vm and the tests
// simultaneously.
suppress_exit_event = suppress_exit_event || illegal_state_oop() != NULL;
suppress_exit_event = suppress_exit_event || illegal_state_oop() != nullptr;
// Whenever JVMTI puts a thread in interp_only_mode, method
// entry/exit events are sent for that thread to track stack depth.
@ -3265,21 +3265,21 @@ run:
// A pending exception that was pending prior to a possible popping frame
// overrides the popping frame.
//
assert(!suppress_error || (suppress_error && illegal_state_oop() == NULL), "Error was not suppressed");
if (illegal_state_oop() != NULL || original_exception() != NULL) {
assert(!suppress_error || (suppress_error && illegal_state_oop() == nullptr), "Error was not suppressed");
if (illegal_state_oop() != nullptr || original_exception() != nullptr) {
// Inform the frame manager we have no result.
istate->set_msg(throwing_exception);
if (illegal_state_oop() != NULL)
THREAD->set_pending_exception(illegal_state_oop(), NULL, 0);
if (illegal_state_oop() != nullptr)
THREAD->set_pending_exception(illegal_state_oop(), nullptr, 0);
else
THREAD->set_pending_exception(original_exception(), NULL, 0);
THREAD->set_pending_exception(original_exception(), nullptr, 0);
UPDATE_PC_AND_RETURN(0);
}
if (istate->msg() == popping_frame) {
// Make it simpler on the assembly code and set the message for the frame pop.
// returns
if (istate->prev() == NULL) {
if (istate->prev() == nullptr) {
// We must be returning to a deoptimized frame (because popframe only happens between
// two interpreted frames). We need to save the current arguments in C heap so that
// the deoptimized frame when it restarts can copy the arguments to its expression
@ -3316,7 +3316,7 @@ BytecodeInterpreter::BytecodeInterpreter(messages msg) {
if (msg != initialize) ShouldNotReachHere();
_msg = msg;
_self_link = this;
_prev_link = NULL;
_prev_link = nullptr;
}
void BytecodeInterpreter::astore(intptr_t* tos, int stack_offset,

4
src/hotspot/share/interpreter/zero/bytecodeInterpreter.inline.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -35,7 +35,7 @@
#ifdef ASSERT
#define VERIFY_OOP(o_) \
if (VerifyOops) { \
assert(oopDesc::is_oop_or_null(oop(o_)), "Expected an oop or NULL at " PTR_FORMAT, p2i(oop(o_))); \
assert(oopDesc::is_oop_or_null(oop(o_)), "Expected an oop or null at " PTR_FORMAT, p2i(oop(o_))); \
StubRoutines::_verify_oop_count++; \
}
#else

8
src/hotspot/share/interpreter/zero/zeroInterpreter.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -68,9 +68,9 @@ class ZeroInterpreter: public AbstractInterpreter {
address osr_buf,
TRAPS);
static address throw_NullPointerException_entry() { return NULL; }
static address throw_ArithmeticException_entry() { return NULL; }
static address throw_StackOverflowError_entry() { return NULL; }
static address throw_NullPointerException_entry() { return nullptr; }
static address throw_ArithmeticException_entry() { return nullptr; }
static address throw_StackOverflowError_entry() { return nullptr; }
# include "zeroInterpreter_zero.hpp"
};

18
src/hotspot/share/interpreter/zero/zeroInterpreterGenerator.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright 2007, 2008, 2009, 2010, 2011 Red Hat, Inc.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -81,7 +81,7 @@ address ZeroInterpreterGenerator::generate_method_entry(
// determine code generation flags
bool native = false;
bool synchronized = false;
address entry_point = NULL;
address entry_point = nullptr;
switch (kind) {
case Interpreter::zerolocals : break;
@ -118,12 +118,12 @@ address ZeroInterpreterGenerator::generate_method_entry(
// We expect the normal and native entry points to be generated first so we can reuse them.
if (native) {
entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
if (entry_point == NULL) {
if (entry_point == nullptr) {
entry_point = generate_native_entry(synchronized);
}
} else {
entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);
if (entry_point == NULL) {
if (entry_point == nullptr) {
entry_point = generate_normal_entry(synchronized);
}
}
@ -139,10 +139,10 @@ address ZeroInterpreterGenerator::generate_slow_signature_handler() {
address ZeroInterpreterGenerator::generate_math_entry(
AbstractInterpreter::MethodKind kind) {
if (!InlineIntrinsics)
return NULL;
return nullptr;
Unimplemented();
return NULL;
return nullptr;
}
address ZeroInterpreterGenerator::generate_abstract_entry() {
@ -151,21 +151,21 @@ address ZeroInterpreterGenerator::generate_abstract_entry() {
address ZeroInterpreterGenerator::generate_empty_entry() {
if (!UseFastEmptyMethods)
return NULL;
return nullptr;
return generate_entry((address) ZeroInterpreter::empty_entry);
}
address ZeroInterpreterGenerator::generate_getter_entry() {
if (!UseFastAccessorMethods)
return NULL;
return nullptr;
return generate_entry((address) ZeroInterpreter::getter_entry);
}
address ZeroInterpreterGenerator::generate_setter_entry() {
if (!UseFastAccessorMethods)
return NULL;
return nullptr;
return generate_entry((address) ZeroInterpreter::setter_entry);
}