8233913: Remove implicit conversion from Method* to methodHandle
Summary: Fix call sites to use existing THREAD local or pass down THREAD local for shallower callsites. Make linkResolver methods return Method* for caller to handleize if needed.
Reviewed-by: iklam, thartmann, hseigel
--- a/src/hotspot/os/windows/os_windows.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/os/windows/os_windows.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -5688,7 +5688,7 @@
// up the offset from FS of the thread pointer.
void os::win32::initialize_thread_ptr_offset() {
os::os_exception_wrapper((java_call_t)call_wrapper_dummy,
- NULL, NULL, NULL, NULL);
+ NULL, methodHandle(), NULL, NULL);
}
bool os::supports_map_sync() {
--- a/src/hotspot/share/aot/aotCompiledMethod.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/aot/aotCompiledMethod.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -160,8 +160,6 @@
}
bool AOTCompiledMethod::make_not_entrant_helper(int new_state) {
- // Make sure the method is not flushed in case of a safepoint in code below.
- methodHandle the_method(method());
NoSafepointVerifier nsv;
{
@@ -208,10 +206,7 @@
bool AOTCompiledMethod::make_entrant() {
assert(!method()->is_old(), "reviving evolved method!");
- // Make sure the method is not flushed in case of a safepoint in code below.
- methodHandle the_method(method());
NoSafepointVerifier nsv;
-
{
// Enter critical section. Does not block for safepoint.
MutexLocker pl(CompiledMethod_lock, Mutex::_no_safepoint_check_flag);
--- a/src/hotspot/share/c1/c1_Runtime1.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/c1/c1_Runtime1.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1422,7 +1422,7 @@
assert (nm != NULL, "no more nmethod?");
nm->make_not_entrant();
- methodHandle m(nm->method());
+ methodHandle m(thread, nm->method());
MethodData* mdo = m->method_data();
if (mdo == NULL && !HAS_PENDING_EXCEPTION) {
@@ -1443,7 +1443,7 @@
if (TracePredicateFailedTraps) {
stringStream ss1, ss2;
vframeStream vfst(thread);
- methodHandle inlinee = methodHandle(vfst.method());
+ Method* inlinee = vfst.method();
inlinee->print_short_name(&ss1);
m->print_short_name(&ss2);
tty->print_cr("Predicate failed trap in method %s at bci %d inlined in %s at pc " INTPTR_FORMAT, ss1.as_string(), vfst.bci(), ss2.as_string(), p2i(caller_frame.pc()));
--- a/src/hotspot/share/ci/ciEnv.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/ci/ciEnv.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -760,7 +760,7 @@
InstanceKlass* accessor_klass = accessor->get_instanceKlass();
Klass* holder_klass = holder->get_Klass();
- methodHandle dest_method;
+ Method* dest_method;
LinkInfo link_info(holder_klass, name, sig, accessor_klass, LinkInfo::needs_access_check, tag);
switch (bc) {
case Bytecodes::_invokestatic:
@@ -782,7 +782,7 @@
default: ShouldNotReachHere();
}
- return dest_method();
+ return dest_method;
}
--- a/src/hotspot/share/ci/ciExceptionHandler.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/ci/ciExceptionHandler.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2019, 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
@@ -41,7 +41,7 @@
if (_catch_klass == NULL) {
bool will_link;
assert(_loading_klass->get_instanceKlass()->is_linked(), "must be linked before accessing constant pool");
- constantPoolHandle cpool(_loading_klass->get_instanceKlass()->constants());
+ constantPoolHandle cpool(THREAD, _loading_klass->get_instanceKlass()->constants());
ciKlass* k = CURRENT_ENV->get_klass_by_index(cpool,
_catch_klass_index,
will_link,
--- a/src/hotspot/share/ci/ciField.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/ci/ciField.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -391,7 +391,7 @@
LinkInfo link_info(_holder->get_instanceKlass(),
_name->get_symbol(), _signature->get_symbol(),
- accessing_method->get_Method());
+ methodHandle(THREAD, accessing_method->get_Method()));
fieldDescriptor result;
LinkResolver::resolve_field(result, link_info, bc, false, KILL_COMPILE_ON_FATAL_(false));
--- a/src/hotspot/share/ci/ciInstanceKlass.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/ci/ciInstanceKlass.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -32,7 +32,7 @@
#include "memory/allocation.inline.hpp"
#include "memory/resourceArea.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "runtime/fieldDescriptor.inline.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/jniHandles.inline.hpp"
--- a/src/hotspot/share/ci/ciMethod.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/ci/ciMethod.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -72,25 +72,25 @@
assert(h_m() != NULL, "no null method");
if (LogTouchedMethods) {
- h_m()->log_touched(Thread::current());
+ h_m->log_touched(Thread::current());
}
// These fields are always filled in in loaded methods.
- _flags = ciFlags(h_m()->access_flags());
+ _flags = ciFlags(h_m->access_flags());
// Easy to compute, so fill them in now.
- _max_stack = h_m()->max_stack();
- _max_locals = h_m()->max_locals();
- _code_size = h_m()->code_size();
- _intrinsic_id = h_m()->intrinsic_id();
- _handler_count = h_m()->exception_table_length();
- _size_of_parameters = h_m()->size_of_parameters();
- _uses_monitors = h_m()->access_flags().has_monitor_bytecodes();
- _balanced_monitors = !_uses_monitors || h_m()->access_flags().is_monitor_matching();
- _is_c1_compilable = !h_m()->is_not_c1_compilable();
- _is_c2_compilable = !h_m()->is_not_c2_compilable();
+ _max_stack = h_m->max_stack();
+ _max_locals = h_m->max_locals();
+ _code_size = h_m->code_size();
+ _intrinsic_id = h_m->intrinsic_id();
+ _handler_count = h_m->exception_table_length();
+ _size_of_parameters = h_m->size_of_parameters();
+ _uses_monitors = h_m->access_flags().has_monitor_bytecodes();
+ _balanced_monitors = !_uses_monitors || h_m->access_flags().is_monitor_matching();
+ _is_c1_compilable = !h_m->is_not_c1_compilable();
+ _is_c2_compilable = !h_m->is_not_c2_compilable();
_can_be_parsed = true;
- _has_reserved_stack_access = h_m()->has_reserved_stack_access();
- _is_overpass = h_m()->is_overpass();
+ _has_reserved_stack_access = h_m->has_reserved_stack_access();
+ _is_overpass = h_m->is_overpass();
// Lazy fields, filled in on demand. Require allocation.
_code = NULL;
_exception_handlers = NULL;
@@ -114,8 +114,8 @@
DEBUG_ONLY(CompilerThread::current()->check_possible_safepoint());
}
- if (h_m()->method_holder()->is_linked()) {
- _can_be_statically_bound = h_m()->can_be_statically_bound();
+ if (h_m->method_holder()->is_linked()) {
+ _can_be_statically_bound = h_m->can_be_statically_bound();
} else {
// Have to use a conservative value in this case.
_can_be_statically_bound = false;
@@ -123,25 +123,25 @@
// Adjust the definition of this condition to be more useful:
// %%% take these conditions into account in vtable generation
- if (!_can_be_statically_bound && h_m()->is_private())
+ if (!_can_be_statically_bound && h_m->is_private())
_can_be_statically_bound = true;
- if (_can_be_statically_bound && h_m()->is_abstract())
+ if (_can_be_statically_bound && h_m->is_abstract())
_can_be_statically_bound = false;
// generating _signature may allow GC and therefore move m.
// These fields are always filled in.
- _name = env->get_symbol(h_m()->name());
- ciSymbol* sig_symbol = env->get_symbol(h_m()->signature());
- constantPoolHandle cpool = h_m()->constants();
+ _name = env->get_symbol(h_m->name());
+ ciSymbol* sig_symbol = env->get_symbol(h_m->signature());
+ constantPoolHandle cpool(Thread::current(), h_m->constants());
_signature = new (env->arena()) ciSignature(_holder, cpool, sig_symbol);
_method_data = NULL;
- _nmethod_age = h_m()->nmethod_age();
+ _nmethod_age = h_m->nmethod_age();
// Take a snapshot of these values, so they will be commensurate with the MDO.
if (ProfileInterpreter || TieredCompilation) {
- int invcnt = h_m()->interpreter_invocation_count();
+ int invcnt = h_m->interpreter_invocation_count();
// if the value overflowed report it as max int
_interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ;
- _interpreter_throwout_count = h_m()->interpreter_throwout_count();
+ _interpreter_throwout_count = h_m->interpreter_throwout_count();
} else {
_interpreter_invocation_count = 0;
_interpreter_throwout_count = 0;
@@ -431,7 +431,7 @@
ResourceBitMap ciMethod::live_local_oops_at_bci(int bci) {
VM_ENTRY_MARK;
InterpreterOopMap mask;
- OopMapCache::compute_one_oop_map(get_Method(), bci, &mask);
+ OopMapCache::compute_one_oop_map(methodHandle(THREAD, get_Method()), bci, &mask);
int mask_size = max_locals();
ResourceBitMap result(mask_size);
int i;
@@ -749,8 +749,8 @@
{
MutexLocker locker(Compile_lock);
Klass* context = actual_recv->get_Klass();
- target = Dependencies::find_unique_concrete_method(context,
- root_m->get_Method());
+ target = methodHandle(THREAD, Dependencies::find_unique_concrete_method(context,
+ root_m->get_Method()));
// %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
}
@@ -810,7 +810,7 @@
LinkInfo link_info(resolved, h_name, h_signature, caller_klass,
check_access ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
- methodHandle m;
+ Method* m = NULL;
// Only do exact lookup if receiver klass has been linked. Otherwise,
// the vtable has not been setup, and the LinkResolver will fail.
if (recv->is_array_klass()
@@ -823,14 +823,14 @@
}
}
- if (m.is_null()) {
+ if (m == NULL) {
// Return NULL only if there was a problem with lookup (uninitialized class, etc.)
return NULL;
}
ciMethod* result = this;
- if (m() != get_Method()) {
- result = CURRENT_THREAD_ENV->get_method(m());
+ if (m != get_Method()) {
+ result = CURRENT_THREAD_ENV->get_method(m);
}
// Don't return abstract methods because they aren't
@@ -1035,7 +1035,8 @@
bool result = true;
if (_method_data == NULL || _method_data->is_empty()) {
GUARDED_VM_ENTRY({
- result = ensure_method_data(get_Method());
+ methodHandle mh(Thread::current(), get_Method());
+ result = ensure_method_data(mh);
});
}
return result;
@@ -1268,7 +1269,7 @@
HandleMark hm(THREAD);
constantPoolHandle pool (THREAD, get_Method()->constants());
Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual);
- methodHandle spec_method = LinkResolver::resolve_method_statically(code, pool, refinfo_index, THREAD);
+ Method* spec_method = LinkResolver::resolve_method_statically(code, pool, refinfo_index, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return false;
--- a/src/hotspot/share/ci/ciReplay.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/ci/ciReplay.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -597,7 +597,7 @@
nm->make_not_entrant();
}
replay_state = this;
- CompileBroker::compile_method(method, entry_bci, comp_level,
+ CompileBroker::compile_method(methodHandle(THREAD, method), entry_bci, comp_level,
methodHandle(), 0, CompileTask::Reason_Replay, THREAD);
replay_state = NULL;
reset();
@@ -634,7 +634,7 @@
MutexLocker ml(MethodData_lock, THREAD);
if (method->method_data() == NULL) {
ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
- MethodData* method_data = MethodData::allocate(loader_data, method, CHECK);
+ MethodData* method_data = MethodData::allocate(loader_data, methodHandle(THREAD, method), CHECK);
method->set_method_data(method_data);
}
}
--- a/src/hotspot/share/ci/ciStreams.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/ci/ciStreams.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -186,7 +186,7 @@
// or checkcast, get the referenced klass.
ciKlass* ciBytecodeStream::get_klass(bool& will_link) {
VM_ENTRY_MARK;
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
return CURRENT_ENV->get_klass_by_index(cpool, get_klass_index(), will_link, _holder);
}
@@ -217,7 +217,7 @@
int index = get_constant_raw_index();
if (has_cache_index()) {
VM_ENTRY_MARK;
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
return cpool->object_to_cp_index(index);
}
return index;
@@ -236,7 +236,7 @@
pool_index = -1;
}
VM_ENTRY_MARK;
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
return CURRENT_ENV->get_constant_by_index(cpool, pool_index, cache_index, _holder);
}
@@ -289,7 +289,7 @@
// for checking linkability when retrieving the associated field.
ciInstanceKlass* ciBytecodeStream::get_declared_field_holder() {
VM_ENTRY_MARK;
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
int holder_index = get_field_holder_index();
bool ignore;
return CURRENT_ENV->get_klass_by_index(cpool, holder_index, ignore, _holder)
@@ -431,7 +431,7 @@
// constant pool cache at the current bci.
bool ciBytecodeStream::has_appendix() {
VM_ENTRY_MARK;
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
return ConstantPool::has_appendix_at_if_loaded(cpool, get_method_index());
}
@@ -442,7 +442,7 @@
// the current bci.
ciObject* ciBytecodeStream::get_appendix() {
VM_ENTRY_MARK;
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
oop appendix_oop = ConstantPool::appendix_at_if_loaded(cpool, get_method_index());
return CURRENT_ENV->get_object(appendix_oop);
}
@@ -454,7 +454,7 @@
// pool cache at the current bci has a local signature.
bool ciBytecodeStream::has_local_signature() {
GUARDED_VM_ENTRY(
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(Thread::current(), _method->get_Method()->constants());
return ConstantPool::has_local_signature_at_if_loaded(cpool, get_method_index());
)
}
@@ -472,7 +472,7 @@
// for checking linkability when retrieving the associated method.
ciKlass* ciBytecodeStream::get_declared_method_holder() {
VM_ENTRY_MARK;
- constantPoolHandle cpool(_method->get_Method()->constants());
+ constantPoolHandle cpool(THREAD, _method->get_Method()->constants());
bool ignore;
// report as MethodHandle for invokedynamic, which is syntactically classless
if (cur_bc() == Bytecodes::_invokedynamic)
--- a/src/hotspot/share/classfile/bytecodeAssembler.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/bytecodeAssembler.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -54,7 +54,8 @@
_orig->length() + _entries.length(), CHECK_NULL);
cp->set_pool_holder(_orig->pool_holder());
- _orig->copy_cp_to(1, _orig->length() - 1, cp, 1, CHECK_NULL);
+ constantPoolHandle cp_h(THREAD, cp);
+ _orig->copy_cp_to(1, _orig->length() - 1, cp_h, 1, CHECK_NULL);
// Preserve dynamic constant information from the original pool
if (_orig->has_dynamic_constant()) {
--- a/src/hotspot/share/classfile/classFileParser.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/classFileParser.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -47,7 +47,7 @@
#include "memory/universe.hpp"
#include "oops/annotations.hpp"
#include "oops/constantPool.inline.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/instanceMirrorKlass.hpp"
#include "oops/klass.inline.hpp"
@@ -332,7 +332,7 @@
hashValues[names_count++] = hash;
if (names_count == SymbolTable::symbol_alloc_batch_size) {
SymbolTable::new_symbols(_loader_data,
- cp,
+ constantPoolHandle(THREAD, cp),
names_count,
names,
lengths,
@@ -369,7 +369,7 @@
// Allocate the remaining symbols
if (names_count > 0) {
SymbolTable::new_symbols(_loader_data,
- cp,
+ constantPoolHandle(THREAD, cp),
names_count,
names,
lengths,
@@ -2870,7 +2870,7 @@
}
if (parsed_annotations.has_any_annotations())
- parsed_annotations.apply_to(m);
+ parsed_annotations.apply_to(methodHandle(THREAD, m));
// Copy annotations
copy_method_annotations(m->constMethod(),
@@ -3753,7 +3753,7 @@
#ifndef PRODUCT
static void print_field_layout(const Symbol* name,
Array<u2>* fields,
- const constantPoolHandle& cp,
+ ConstantPool* cp,
int instance_size,
int instance_fields_start,
int instance_fields_end,
--- a/src/hotspot/share/classfile/javaClasses.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/javaClasses.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -42,7 +42,7 @@
#include "memory/oopFactory.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/instanceMirrorKlass.hpp"
#include "oops/klass.hpp"
@@ -2270,7 +2270,7 @@
st->print_cr("%s", buf);
}
-void java_lang_Throwable::print_stack_element(outputStream *st, const methodHandle& method, int bci) {
+void java_lang_Throwable::print_stack_element(outputStream *st, Method* method, int bci) {
Handle mirror (Thread::current(), method->method_holder()->java_mirror());
int method_id = method->orig_method_idnum();
int version = method->constants()->version();
@@ -2376,7 +2376,6 @@
// trace as utilizing vframe.
#ifdef ASSERT
vframeStream st(thread);
- methodHandle st_method(THREAD, st.method());
#endif
int total_count = 0;
RegisterMap map(thread, false);
@@ -2426,14 +2425,9 @@
}
}
#ifdef ASSERT
- assert(st_method() == method && st.bci() == bci,
+ assert(st.method() == method && st.bci() == bci,
"Wrong stack trace");
st.next();
- // vframeStream::method isn't GC-safe so store off a copy
- // of the Method* in case we GC.
- if (!st.at_end()) {
- st_method = st.method();
- }
#endif
// the format of the stacktrace will be:
@@ -2696,7 +2690,7 @@
}
java_lang_StackTraceElement::set_fileName(element(), source_file);
- int line_number = Backtrace::get_line_number(method, bci);
+ int line_number = Backtrace::get_line_number(method(), bci);
java_lang_StackTraceElement::set_lineNumber(element(), line_number);
}
}
@@ -2771,7 +2765,8 @@
short version = stackFrame->short_field(_version_offset);
int bci = stackFrame->int_field(_bci_offset);
Symbol* name = method->name();
- java_lang_StackTraceElement::fill_in(stack_trace_element, holder, method, version, bci, name, CHECK);
+ java_lang_StackTraceElement::fill_in(stack_trace_element, holder, methodHandle(THREAD, method),
+ version, bci, name, CHECK);
}
#define STACKFRAMEINFO_FIELDS_DO(macro) \
--- a/src/hotspot/share/classfile/javaClasses.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/javaClasses.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -561,7 +561,7 @@
static oop message(oop throwable);
static void set_message(oop throwable, oop value);
static Symbol* detail_message(oop throwable);
- static void print_stack_element(outputStream *st, const methodHandle& method, int bci);
+ static void print_stack_element(outputStream *st, Method* method, int bci);
static void print_stack_usage(Handle stream);
static void compute_offsets();
@@ -1402,7 +1402,7 @@
static int version_at(unsigned int merged);
static int mid_at(unsigned int merged);
static int cpref_at(unsigned int merged);
- static int get_line_number(const methodHandle& method, int bci);
+ static int get_line_number(Method* method, int bci);
static Symbol* get_source_file_name(InstanceKlass* holder, int version);
// Debugging
--- a/src/hotspot/share/classfile/javaClasses.inline.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/javaClasses.inline.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -264,7 +264,7 @@
return extract_low_short_from_int(merged);
}
-inline int Backtrace::get_line_number(const methodHandle& method, int bci) {
+inline int Backtrace::get_line_number(Method* method, int bci) {
int line_number = 0;
if (method->is_native()) {
// Negative value different from -1 below, enabling Java code in
--- a/src/hotspot/share/classfile/systemDictionary.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/systemDictionary.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -2338,9 +2338,9 @@
}
-methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid,
- Symbol* signature,
- TRAPS) {
+Method* SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid,
+ Symbol* signature,
+ TRAPS) {
methodHandle empty;
assert(MethodHandles::is_signature_polymorphic(iid) &&
MethodHandles::is_signature_polymorphic_intrinsic(iid) &&
@@ -2354,14 +2354,14 @@
if (spe == NULL || spe->method() == NULL) {
spe = NULL;
// Must create lots of stuff here, but outside of the SystemDictionary lock.
- m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty));
+ m = Method::make_method_handle_intrinsic(iid, signature, CHECK_NULL);
if (!Arguments::is_interpreter_only()) {
// Generate a compiled form of the MH intrinsic.
AdapterHandlerLibrary::create_native_wrapper(m);
// Check if have the compiled code.
if (!m->has_compiled_code()) {
- THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
- "Out of space in CodeCache for method handle intrinsic", empty);
+ THROW_MSG_NULL(vmSymbols::java_lang_VirtualMachineError(),
+ "Out of space in CodeCache for method handle intrinsic");
}
}
// Now grab the lock. We might have to throw away the new method,
@@ -2384,12 +2384,11 @@
}
// Helper for unpacking the return value from linkMethod and linkCallSite.
-static methodHandle unpack_method_and_appendix(Handle mname,
- Klass* accessing_klass,
- objArrayHandle appendix_box,
- Handle* appendix_result,
- TRAPS) {
- methodHandle empty;
+static Method* unpack_method_and_appendix(Handle mname,
+ Klass* accessing_klass,
+ objArrayHandle appendix_box,
+ Handle* appendix_result,
+ TRAPS) {
if (mname.not_null()) {
Method* m = java_lang_invoke_MemberName::vmtarget(mname());
if (m != NULL) {
@@ -2407,35 +2406,34 @@
// the target is stored in the cpCache and if a reference to this
// MemberName is dropped we need a way to make sure the
// class_loader containing this method is kept alive.
+ methodHandle mh(THREAD, m); // record_dependency can safepoint.
ClassLoaderData* this_key = accessing_klass->class_loader_data();
this_key->record_dependency(m->method_holder());
- return methodHandle(THREAD, m);
+ return mh();
}
}
- THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives", empty);
- return empty;
+ THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives");
}
-methodHandle SystemDictionary::find_method_handle_invoker(Klass* klass,
- Symbol* name,
- Symbol* signature,
- Klass* accessing_klass,
- Handle *appendix_result,
- TRAPS) {
- methodHandle empty;
+Method* SystemDictionary::find_method_handle_invoker(Klass* klass,
+ Symbol* name,
+ Symbol* signature,
+ Klass* accessing_klass,
+ Handle *appendix_result,
+ TRAPS) {
assert(THREAD->can_call_java() ,"");
Handle method_type =
- SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_(empty));
+ SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_NULL);
int ref_kind = JVM_REF_invokeVirtual;
- oop name_oop = StringTable::intern(name, CHECK_(empty));
+ oop name_oop = StringTable::intern(name, CHECK_NULL);
Handle name_str (THREAD, name_oop);
- objArrayHandle appendix_box = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), 1, CHECK_(empty));
+ objArrayHandle appendix_box = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), 1, CHECK_NULL);
assert(appendix_box->obj_at(0) == NULL, "");
// This should not happen. JDK code should take care of that.
if (accessing_klass == NULL || method_type.is_null()) {
- THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad invokehandle", empty);
+ THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "bad invokehandle");
}
// call java.lang.invoke.MethodHandleNatives::linkMethod(... String, MethodType) -> MemberName
@@ -2451,7 +2449,7 @@
SystemDictionary::MethodHandleNatives_klass(),
vmSymbols::linkMethod_name(),
vmSymbols::linkMethod_signature(),
- &args, CHECK_(empty));
+ &args, CHECK_NULL);
Handle mname(THREAD, (oop) result.get_jobject());
return unpack_method_and_appendix(mname, accessing_klass, appendix_box, appendix_result, THREAD);
}
@@ -2755,11 +2753,12 @@
Handle value(THREAD, (oop) result.get_jobject());
if (is_indy) {
Handle appendix;
- methodHandle method = unpack_method_and_appendix(value,
- bootstrap_specifier.caller(),
- appendix_box,
- &appendix, CHECK);
- bootstrap_specifier.set_resolved_method(method, appendix);
+ Method* method = unpack_method_and_appendix(value,
+ bootstrap_specifier.caller(),
+ appendix_box,
+ &appendix, CHECK);
+ methodHandle mh(THREAD, method);
+ bootstrap_specifier.set_resolved_method(mh, appendix);
} else {
bootstrap_specifier.set_resolved_value(value);
}
--- a/src/hotspot/share/classfile/systemDictionary.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/systemDictionary.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -464,17 +464,17 @@
// JSR 292
// find a java.lang.invoke.MethodHandle.invoke* method for a given signature
// (asks Java to compute it if necessary, except in a compiler thread)
- static methodHandle find_method_handle_invoker(Klass* klass,
- Symbol* name,
- Symbol* signature,
- Klass* accessing_klass,
- Handle *appendix_result,
- TRAPS);
+ static Method* find_method_handle_invoker(Klass* klass,
+ Symbol* name,
+ Symbol* signature,
+ Klass* accessing_klass,
+ Handle *appendix_result,
+ TRAPS);
// for a given signature, find the internal MethodHandle method (linkTo* or invokeBasic)
// (does not ask Java, since this is a low-level intrinsic defined by the JVM)
- static methodHandle find_method_handle_intrinsic(vmIntrinsics::ID iid,
- Symbol* signature,
- TRAPS);
+ static Method* find_method_handle_intrinsic(vmIntrinsics::ID iid,
+ Symbol* signature,
+ TRAPS);
// compute java_mirror (java.lang.Class instance) for a type ("I", "[[B", "LFoo;", etc.)
// Either the accessing_klass or the CL/PD can be non-null, but not both.
--- a/src/hotspot/share/classfile/vmSymbols.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/classfile/vmSymbols.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1069,19 +1069,18 @@
const char* declared_name = name_at(declared_id);
const char* actual_name = name_at(actual_id);
- methodHandle mh = m;
m = NULL;
ttyLocker ttyl;
if (xtty != NULL) {
xtty->begin_elem("intrinsic_misdeclared actual='%s' declared='%s'",
actual_name, declared_name);
- xtty->method(mh);
+ xtty->method(m);
xtty->end_elem("%s", "");
}
if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("*** misidentified method; %s(%d) should be %s(%d):",
declared_name, declared_id, actual_name, actual_id);
- mh()->print_short_name(tty);
+ m->print_short_name(tty);
tty->cr();
}
}
--- a/src/hotspot/share/code/compiledIC.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/code/compiledIC.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -287,7 +287,7 @@
if (TraceICs) {
ResourceMark rm;
- assert(!call_info->selected_method().is_null(), "Unexpected null selected method");
+ assert(call_info->selected_method() != NULL, "Unexpected null selected method");
tty->print_cr ("IC@" INTPTR_FORMAT ": to megamorphic %s entry: " INTPTR_FORMAT,
p2i(instruction_address()), call_info->selected_method()->print_value_string(), p2i(entry));
}
--- a/src/hotspot/share/code/compiledMethod.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/code/compiledMethod.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -355,7 +355,7 @@
if (method() != NULL && !method()->is_native()) {
address pc = fr.pc();
SimpleScopeDesc ssd(this, pc);
- Bytecode_invoke call(ssd.method(), ssd.bci());
+ Bytecode_invoke call(methodHandle(Thread::current(), ssd.method()), ssd.bci());
bool has_receiver = call.has_receiver();
bool has_appendix = call.has_appendix();
Symbol* signature = call.signature();
--- a/src/hotspot/share/code/nmethod.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/code/nmethod.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -964,15 +964,16 @@
#if defined(SUPPORT_DATA_STRUCTS)
if (AbstractDisassembler::show_structs()) {
- if (printmethod || PrintDebugInfo || CompilerOracle::has_option_string(_method, "PrintDebugInfo")) {
+ methodHandle mh(Thread::current(), _method);
+ if (printmethod || PrintDebugInfo || CompilerOracle::has_option_string(mh, "PrintDebugInfo")) {
print_scopes();
tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
}
- if (printmethod || PrintRelocations || CompilerOracle::has_option_string(_method, "PrintRelocations")) {
+ if (printmethod || PrintRelocations || CompilerOracle::has_option_string(mh, "PrintRelocations")) {
print_relocations();
tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
}
- if (printmethod || PrintDependencies || CompilerOracle::has_option_string(_method, "PrintDependencies")) {
+ if (printmethod || PrintDependencies || CompilerOracle::has_option_string(mh, "PrintDependencies")) {
print_dependencies();
tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
}
@@ -1302,9 +1303,8 @@
return false;
}
- // Make sure neither the nmethod nor the method is flushed in case of a safepoint in code below.
+ // Make sure the nmethod is not flushed.
nmethodLocker nml(this);
- methodHandle the_method(method());
// This can be called while the system is already at a safepoint which is ok
NoSafepointVerifier nsv;
@@ -3079,13 +3079,13 @@
}
if (block_begin == entry_point()) {
- methodHandle m = method();
- if (m.not_null()) {
+ Method* m = method();
+ if (m != NULL) {
stream->print(" # ");
m->print_value_on(stream);
stream->cr();
}
- if (m.not_null() && !is_osr_method()) {
+ if (m != NULL && !is_osr_method()) {
ResourceMark rm;
int sizeargs = m->size_of_parameters();
BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
@@ -3237,6 +3237,8 @@
}
assert(!oop_map_required, "missed oopmap");
+ Thread* thread = Thread::current();
+
// Print any debug info present at this pc.
ScopeDesc* sd = scope_desc_in(begin, end);
if (sd != NULL) {
@@ -3267,7 +3269,7 @@
case Bytecodes::_invokestatic:
case Bytecodes::_invokeinterface:
{
- Bytecode_invoke invoke(sd->method(), sd->bci());
+ Bytecode_invoke invoke(methodHandle(thread, sd->method()), sd->bci());
st->print(" ");
if (invoke.name() != NULL)
invoke.name()->print_symbol_on(st);
@@ -3280,7 +3282,7 @@
case Bytecodes::_getstatic:
case Bytecodes::_putstatic:
{
- Bytecode_field field(sd->method(), sd->bci());
+ Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
st->print(" ");
if (field.name() != NULL)
field.name()->print_symbol_on(st);
@@ -3356,7 +3358,7 @@
if (cm != NULL && cm->is_far_code()) {
// Temporary fix, see JDK-8143106
CompiledDirectStaticCall* csc = CompiledDirectStaticCall::at(instruction_address());
- csc->set_to_far(methodHandle(cm->method()), dest);
+ csc->set_to_far(methodHandle(Thread::current(), cm->method()), dest);
return;
}
}
--- a/src/hotspot/share/compiler/compileBroker.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/compiler/compileBroker.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -465,8 +465,9 @@
if (task != NULL) {
// Save method pointers across unlock safepoint. The task is removed from
// the compilation queue, which is walked during RedefineClasses.
- save_method = methodHandle(task->method());
- save_hot_method = methodHandle(task->hot_method());
+ Thread* thread = Thread::current();
+ save_method = methodHandle(thread, task->method());
+ save_hot_method = methodHandle(thread, task->hot_method());
remove(task);
}
--- a/src/hotspot/share/compiler/compileTask.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/compiler/compileTask.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -340,7 +340,7 @@
if (_osr_bci != CompileBroker::standard_entry_bci) {
log->print(" compile_kind='osr'"); // same as nmethod::compile_kind
} // else compile_kind='c2c'
- if (!method.is_null()) log->method(method);
+ if (!method.is_null()) log->method(method());
if (_osr_bci != CompileBroker::standard_entry_bci) {
log->print(" osr_bci='%d'", _osr_bci);
}
@@ -356,21 +356,16 @@
// ------------------------------------------------------------------
// CompileTask::log_task_queued
void CompileTask::log_task_queued() {
- Thread* thread = Thread::current();
ttyLocker ttyl;
- ResourceMark rm(thread);
+ ResourceMark rm;
xtty->begin_elem("task_queued");
log_task(xtty);
assert(_compile_reason > CompileTask::Reason_None && _compile_reason < CompileTask::Reason_Count, "Valid values");
xtty->print(" comment='%s'", reason_name(_compile_reason));
- if (_hot_method != NULL) {
- methodHandle hot(thread, _hot_method);
- methodHandle method(thread, _method);
- if (hot() != method()) {
- xtty->method(hot);
- }
+ if (_hot_method != NULL && _hot_method != _method) {
+ xtty->method(_hot_method);
}
if (_hot_count != 0) {
xtty->print(" hot_count='%d'", _hot_count);
--- a/src/hotspot/share/compiler/tieredThresholdPolicy.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/compiler/tieredThresholdPolicy.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -43,7 +43,7 @@
#include "c1/c1_Compiler.hpp"
#include "opto/c2compiler.hpp"
-bool TieredThresholdPolicy::call_predicate_helper(Method* method, CompLevel cur_level, int i, int b, double scale) {
+bool TieredThresholdPolicy::call_predicate_helper(const methodHandle& method, CompLevel cur_level, int i, int b, double scale) {
double threshold_scaling;
if (CompilerOracle::has_option_value(method, "CompileThresholdScaling", threshold_scaling)) {
scale *= threshold_scaling;
@@ -74,7 +74,7 @@
}
}
-bool TieredThresholdPolicy::loop_predicate_helper(Method* method, CompLevel cur_level, int i, int b, double scale) {
+bool TieredThresholdPolicy::loop_predicate_helper(const methodHandle& method, CompLevel cur_level, int i, int b, double scale) {
double threshold_scaling;
if (CompilerOracle::has_option_value(method, "CompileThresholdScaling", threshold_scaling)) {
scale *= threshold_scaling;
@@ -110,7 +110,7 @@
return false;
}
-bool TieredThresholdPolicy::force_comp_at_level_simple(Method* method) {
+bool TieredThresholdPolicy::force_comp_at_level_simple(const methodHandle& method) {
if (CompilationModeFlag::quick_internal()) {
#if INCLUDE_JVMCI
if (UseJVMCICompiler) {
@@ -132,10 +132,10 @@
return CompLevel_none;
}
-void TieredThresholdPolicy::print_counters(const char* prefix, const methodHandle& mh) {
- int invocation_count = mh->invocation_count();
- int backedge_count = mh->backedge_count();
- MethodData* mdh = mh->method_data();
+void TieredThresholdPolicy::print_counters(const char* prefix, Method* m) {
+ int invocation_count = m->invocation_count();
+ int backedge_count = m->backedge_count();
+ MethodData* mdh = m->method_data();
int mdo_invocations = 0, mdo_backedges = 0;
int mdo_invocations_start = 0, mdo_backedges_start = 0;
if (mdh != NULL) {
@@ -149,13 +149,13 @@
mdo_invocations, mdo_invocations_start,
mdo_backedges, mdo_backedges_start);
tty->print(" %smax levels=%d,%d", prefix,
- mh->highest_comp_level(), mh->highest_osr_comp_level());
+ m->highest_comp_level(), m->highest_osr_comp_level());
}
// Print an event.
-void TieredThresholdPolicy::print_event(EventType type, const methodHandle& mh, const methodHandle& imh,
+void TieredThresholdPolicy::print_event(EventType type, Method* m, Method* im,
int bci, CompLevel level) {
- bool inlinee_event = mh() != imh();
+ bool inlinee_event = m != im;
ttyLocker tty_lock;
tty->print("%lf: [", os::elapsedTime());
@@ -189,10 +189,10 @@
tty->print(" level=%d ", level);
ResourceMark rm;
- char *method_name = mh->name_and_sig_as_C_string();
+ char *method_name = m->name_and_sig_as_C_string();
tty->print("[%s", method_name);
if (inlinee_event) {
- char *inlinee_name = imh->name_and_sig_as_C_string();
+ char *inlinee_name = im->name_and_sig_as_C_string();
tty->print(" [%s]] ", inlinee_name);
}
else tty->print("] ");
@@ -200,39 +200,39 @@
CompileBroker::queue_size(CompLevel_full_optimization));
tty->print(" rate=");
- if (mh->prev_time() == 0) tty->print("n/a");
- else tty->print("%f", mh->rate());
+ if (m->prev_time() == 0) tty->print("n/a");
+ else tty->print("%f", m->rate());
tty->print(" k=%.2lf,%.2lf", threshold_scale(CompLevel_full_profile, Tier3LoadFeedback),
threshold_scale(CompLevel_full_optimization, Tier4LoadFeedback));
if (type != COMPILE) {
- print_counters("", mh);
+ print_counters("", m);
if (inlinee_event) {
- print_counters("inlinee ", imh);
+ print_counters("inlinee ", im);
}
tty->print(" compilable=");
bool need_comma = false;
- if (!mh->is_not_compilable(CompLevel_full_profile)) {
+ if (!m->is_not_compilable(CompLevel_full_profile)) {
tty->print("c1");
need_comma = true;
}
- if (!mh->is_not_osr_compilable(CompLevel_full_profile)) {
+ if (!m->is_not_osr_compilable(CompLevel_full_profile)) {
if (need_comma) tty->print(",");
tty->print("c1-osr");
need_comma = true;
}
- if (!mh->is_not_compilable(CompLevel_full_optimization)) {
+ if (!m->is_not_compilable(CompLevel_full_optimization)) {
if (need_comma) tty->print(",");
tty->print("c2");
need_comma = true;
}
- if (!mh->is_not_osr_compilable(CompLevel_full_optimization)) {
+ if (!m->is_not_osr_compilable(CompLevel_full_optimization)) {
if (need_comma) tty->print(",");
tty->print("c2-osr");
}
tty->print(" status=");
- if (mh->queued_for_compilation()) {
+ if (m->queued_for_compilation()) {
tty->print("in-queue");
} else tty->print("idle");
}
@@ -376,12 +376,14 @@
max_method = max_task->method();
}
+ methodHandle max_method_h(Thread::current(), max_method);
+
if (max_task != NULL && max_task->comp_level() == CompLevel_full_profile &&
TieredStopAtLevel > CompLevel_full_profile &&
- max_method != NULL && is_method_profiled(max_method)) {
+ max_method != NULL && is_method_profiled(max_method_h)) {
max_task->set_comp_level(CompLevel_limited_profile);
- if (CompileBroker::compilation_is_complete(max_method, max_task->osr_bci(), CompLevel_limited_profile)) {
+ if (CompileBroker::compilation_is_complete(max_method_h, max_task->osr_bci(), CompLevel_limited_profile)) {
if (PrintTieredEvents) {
print_event(REMOVE_FROM_QUEUE, max_method, max_method, max_task->osr_bci(), (CompLevel)max_task->comp_level());
}
@@ -401,8 +403,7 @@
void TieredThresholdPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) {
for (ScopeDesc* sd = trap_scope;; sd = sd->sender()) {
if (PrintTieredEvents) {
- methodHandle mh(sd->method());
- print_event(REPROFILE, mh, mh, InvocationEntryBci, CompLevel_none);
+ print_event(REPROFILE, sd->method(), sd->method(), InvocationEntryBci, CompLevel_none);
}
MethodData* mdo = sd->method()->method_data();
if (mdo != NULL) {
@@ -430,7 +431,7 @@
}
if (PrintTieredEvents) {
- print_event(bci == InvocationEntryBci ? CALL : LOOP, method, inlinee, bci, comp_level);
+ print_event(bci == InvocationEntryBci ? CALL : LOOP, method(), inlinee(), bci, comp_level);
}
if (bci == InvocationEntryBci) {
@@ -481,7 +482,7 @@
if (level == CompLevel_aot) {
if (mh->has_aot_code()) {
if (PrintTieredEvents) {
- print_event(COMPILE, mh, mh, bci, level);
+ print_event(COMPILE, mh(), mh(), bci, level);
}
MutexLocker ml(Compile_lock);
NoSafepointVerifier nsv;
@@ -525,7 +526,7 @@
}
if (!CompileBroker::compilation_is_in_queue(mh)) {
if (PrintTieredEvents) {
- print_event(COMPILE, mh, mh, bci, level);
+ print_event(COMPILE, mh(), mh(), bci, level);
}
int hot_count = (bci == InvocationEntryBci) ? mh->invocation_count() : mh->backedge_count();
update_rate(os::javaTimeMillis(), mh());
@@ -610,7 +611,7 @@
}
// Is method profiled enough?
-bool TieredThresholdPolicy::is_method_profiled(Method* method) {
+bool TieredThresholdPolicy::is_method_profiled(const methodHandle& method) {
MethodData* mdo = method->method_data();
if (mdo != NULL) {
int i = mdo->invocation_count_delta();
@@ -647,7 +648,7 @@
// Tier?LoadFeedback is basically a coefficient that determines of
// how many methods per compiler thread can be in the queue before
// the threshold values double.
-bool TieredThresholdPolicy::loop_predicate(int i, int b, CompLevel cur_level, Method* method) {
+bool TieredThresholdPolicy::loop_predicate(int i, int b, CompLevel cur_level, const methodHandle& method) {
double k = 1;
switch(cur_level) {
case CompLevel_aot: {
@@ -672,10 +673,10 @@
default:
return true;
}
- return loop_predicate_helper(method, cur_level, i, b, k);
+ return loop_predicate_helper(method, cur_level, i, b, k);
}
-bool TieredThresholdPolicy::call_predicate(int i, int b, CompLevel cur_level, Method* method) {
+bool TieredThresholdPolicy::call_predicate(int i, int b, CompLevel cur_level, const methodHandle& method) {
double k = 1;
switch(cur_level) {
case CompLevel_aot: {
@@ -705,14 +706,15 @@
// Determine is a method is mature.
bool TieredThresholdPolicy::is_mature(Method* method) {
- if (is_trivial(method) || force_comp_at_level_simple(method)) return true;
+ methodHandle mh(Thread::current(), method);
+ if (is_trivial(method) || force_comp_at_level_simple(mh)) return true;
MethodData* mdo = method->method_data();
if (mdo != NULL) {
int i = mdo->invocation_count();
int b = mdo->backedge_count();
double k = ProfileMaturityPercentage / 100.0;
CompLevel main_profile_level = CompilationModeFlag::disable_intermediate() ? CompLevel_none : CompLevel_full_profile;
- return call_predicate_helper(method, main_profile_level, i, b, k) || loop_predicate_helper(method, main_profile_level, i, b, k);
+ return call_predicate_helper(mh, main_profile_level, i, b, k) || loop_predicate_helper(mh, main_profile_level, i, b, k);
}
return false;
}
@@ -720,7 +722,7 @@
// If a method is old enough and is still in the interpreter we would want to
// start profiling without waiting for the compiled method to arrive.
// We also take the load on compilers into the account.
-bool TieredThresholdPolicy::should_create_mdo(Method* method, CompLevel cur_level) {
+bool TieredThresholdPolicy::should_create_mdo(const methodHandle& method, CompLevel cur_level) {
if (cur_level != CompLevel_none || force_comp_at_level_simple(method)) {
return false;
}
@@ -799,7 +801,7 @@
*/
// Common transition function. Given a predicate determines if a method should transition to another level.
-CompLevel TieredThresholdPolicy::common(Predicate p, Method* method, CompLevel cur_level, bool disable_feedback) {
+CompLevel TieredThresholdPolicy::common(Predicate p, const methodHandle& method, CompLevel cur_level, bool disable_feedback) {
CompLevel next_level = cur_level;
int i = method->invocation_count();
int b = method->backedge_count();
@@ -807,7 +809,7 @@
if (force_comp_at_level_simple(method)) {
next_level = CompLevel_simple;
} else {
- if (!CompilationModeFlag::disable_intermediate() && is_trivial(method)) {
+ if (!CompilationModeFlag::disable_intermediate() && is_trivial(method())) {
next_level = CompLevel_simple;
} else {
switch(cur_level) {
@@ -926,7 +928,7 @@
}
// Determine if a method should be compiled with a normal entry point at a different level.
-CompLevel TieredThresholdPolicy::call_event(Method* method, CompLevel cur_level, JavaThread* thread) {
+CompLevel TieredThresholdPolicy::call_event(const methodHandle& method, CompLevel cur_level, JavaThread* thread) {
CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(),
common(&TieredThresholdPolicy::loop_predicate, method, cur_level, true));
CompLevel next_level = common(&TieredThresholdPolicy::call_predicate, method, cur_level);
@@ -947,7 +949,7 @@
}
// Determine if we should do an OSR compilation of a given method.
-CompLevel TieredThresholdPolicy::loop_event(Method* method, CompLevel cur_level, JavaThread* thread) {
+CompLevel TieredThresholdPolicy::loop_event(const methodHandle& method, CompLevel cur_level, JavaThread* thread) {
CompLevel next_level = common(&TieredThresholdPolicy::loop_predicate, method, cur_level, true);
if (cur_level == CompLevel_none) {
// If there is a live OSR method that means that we deopted to the interpreter
@@ -983,10 +985,10 @@
// Handle the invocation event.
void TieredThresholdPolicy::method_invocation_event(const methodHandle& mh, const methodHandle& imh,
CompLevel level, CompiledMethod* nm, JavaThread* thread) {
- if (should_create_mdo(mh(), level)) {
+ if (should_create_mdo(mh, level)) {
create_mdo(mh, thread);
}
- CompLevel next_level = call_event(mh(), level, thread);
+ CompLevel next_level = call_event(mh, level, thread);
if (next_level != level) {
if (maybe_switch_to_aot(mh, level, next_level, thread)) {
// No JITting necessary
@@ -1002,16 +1004,16 @@
// with a regular entry from here.
void TieredThresholdPolicy::method_back_branch_event(const methodHandle& mh, const methodHandle& imh,
int bci, CompLevel level, CompiledMethod* nm, JavaThread* thread) {
- if (should_create_mdo(mh(), level)) {
+ if (should_create_mdo(mh, level)) {
create_mdo(mh, thread);
}
// Check if MDO should be created for the inlined method
- if (should_create_mdo(imh(), level)) {
+ if (should_create_mdo(imh, level)) {
create_mdo(imh, thread);
}
if (is_compilation_enabled()) {
- CompLevel next_osr_level = loop_event(imh(), level, thread);
+ CompLevel next_osr_level = loop_event(imh, level, thread);
CompLevel max_osr_level = (CompLevel)imh->highest_osr_comp_level();
// At the very least compile the OSR version
if (!CompileBroker::compilation_is_in_queue(imh) && (next_osr_level != level)) {
@@ -1032,7 +1034,7 @@
// Current loop event level is not AOT
guarantee(nm != NULL, "Should have nmethod here");
cur_level = comp_level(mh());
- next_level = call_event(mh(), cur_level, thread);
+ next_level = call_event(mh, cur_level, thread);
if (max_osr_level == CompLevel_full_optimization) {
// The inlinee OSRed to full opt, we need to modify the enclosing method to avoid deopts
@@ -1068,7 +1070,7 @@
}
} else {
cur_level = comp_level(mh());
- next_level = call_event(mh(), cur_level, thread);
+ next_level = call_event(mh, cur_level, thread);
if (next_level != cur_level) {
if (!maybe_switch_to_aot(mh, cur_level, next_level, thread) && !CompileBroker::compilation_is_in_queue(mh)) {
compile(mh, InvocationEntryBci, next_level, thread);
--- a/src/hotspot/share/compiler/tieredThresholdPolicy.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/compiler/tieredThresholdPolicy.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -173,19 +173,19 @@
// Call and loop predicates determine whether a transition to a higher compilation
// level should be performed (pointers to predicate functions are passed to common_TF().
// Predicates also take compiler load into account.
- typedef bool (TieredThresholdPolicy::*Predicate)(int i, int b, CompLevel cur_level, Method* method);
- bool call_predicate(int i, int b, CompLevel cur_level, Method* method);
- bool loop_predicate(int i, int b, CompLevel cur_level, Method* method);
+ typedef bool (TieredThresholdPolicy::*Predicate)(int i, int b, CompLevel cur_level, const methodHandle& method);
+ bool call_predicate(int i, int b, CompLevel cur_level, const methodHandle& method);
+ bool loop_predicate(int i, int b, CompLevel cur_level, const methodHandle& method);
// Common transition function. Given a predicate determines if a method should transition to another level.
- CompLevel common(Predicate p, Method* method, CompLevel cur_level, bool disable_feedback = false);
+ CompLevel common(Predicate p, const methodHandle& method, CompLevel cur_level, bool disable_feedback = false);
// Transition functions.
// call_event determines if a method should be compiled at a different
// level with a regular invocation entry.
- CompLevel call_event(Method* method, CompLevel cur_level, JavaThread* thread);
+ CompLevel call_event(const methodHandle& method, CompLevel cur_level, JavaThread* thread);
// loop_event checks if a method should be OSR compiled at a different
// level.
- CompLevel loop_event(Method* method, CompLevel cur_level, JavaThread* thread);
- void print_counters(const char* prefix, const methodHandle& mh);
+ CompLevel loop_event(const methodHandle& method, CompLevel cur_level, JavaThread* thread);
+ void print_counters(const char* prefix, Method* m);
// Has a method been long around?
// We don't remove old methods from the compile queue even if they have
// very low activity (see select_task()).
@@ -205,11 +205,11 @@
// If a method is old enough and is still in the interpreter we would want to
// start profiling without waiting for the compiled method to arrive. This function
// determines whether we should do that.
- inline bool should_create_mdo(Method* method, CompLevel cur_level);
+ inline bool should_create_mdo(const methodHandle& method, CompLevel cur_level);
// Create MDO if necessary.
void create_mdo(const methodHandle& mh, JavaThread* thread);
// Is method profiled enough?
- bool is_method_profiled(Method* method);
+ bool is_method_profiled(const methodHandle& method);
double _increase_threshold_at_ratio;
@@ -221,19 +221,19 @@
void set_c2_count(int x) { _c2_count = x; }
enum EventType { CALL, LOOP, COMPILE, REMOVE_FROM_QUEUE, UPDATE_IN_QUEUE, REPROFILE, MAKE_NOT_ENTRANT };
- void print_event(EventType type, const methodHandle& mh, const methodHandle& imh, int bci, CompLevel level);
+ void print_event(EventType type, Method* m, Method* im, int bci, CompLevel level);
// Check if the method can be compiled, change level if necessary
void compile(const methodHandle& mh, int bci, CompLevel level, JavaThread* thread);
// Simple methods are as good being compiled with C1 as C2.
// This function tells if it's such a function.
inline static bool is_trivial(Method* method);
// Force method to be compiled at CompLevel_simple?
- inline bool force_comp_at_level_simple(Method* method);
+ inline bool force_comp_at_level_simple(const methodHandle& method);
// Predicate helpers are used by .*_predicate() methods as well as others.
// They check the given counter values, multiplied by the scale against the thresholds.
- inline bool call_predicate_helper(Method* method, CompLevel cur_level, int i, int b, double scale);
- inline bool loop_predicate_helper(Method* method, CompLevel cur_level, int i, int b, double scale);
+ inline bool call_predicate_helper(const methodHandle& method, CompLevel cur_level, int i, int b, double scale);
+ inline bool loop_predicate_helper(const methodHandle& method, CompLevel cur_level, int i, int b, double scale);
// Get a compilation level for a given method.
static CompLevel comp_level(Method* method);
--- a/src/hotspot/share/interpreter/abstractInterpreter.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/abstractInterpreter.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -267,7 +267,8 @@
}
assert(!invoke_bc.has_index_u4(code), "sanity");
int method_index = invoke_bc.get_index_u2_cpcache(code);
- Method* resolved_method = ConstantPool::method_at_if_loaded(cpool, method_index);
+ constantPoolHandle cp(Thread::current(), cpool);
+ Method* resolved_method = ConstantPool::method_at_if_loaded(cp, method_index);
return (resolved_method == NULL);
}
default: ShouldNotReachHere();
--- a/src/hotspot/share/interpreter/bytecode.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/bytecode.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2019, 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
@@ -151,7 +151,7 @@
}
-methodHandle Bytecode_invoke::static_target(TRAPS) {
+Method* Bytecode_invoke::static_target(TRAPS) {
constantPoolHandle constants(THREAD, this->constants());
Bytecodes::Code bc = invoke_code();
@@ -160,8 +160,10 @@
Handle Bytecode_invoke::appendix(TRAPS) {
ConstantPoolCacheEntry* cpce = cpcache_entry();
- if (cpce->has_appendix())
- return Handle(THREAD, cpce->appendix_if_resolved(constants()));
+ if (cpce->has_appendix()) {
+ constantPoolHandle cp(THREAD, constants());
+ return Handle(THREAD, cpce->appendix_if_resolved(cp));
+ }
return Handle(); // usual case
}
--- a/src/hotspot/share/interpreter/bytecode.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/bytecode.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -209,7 +209,7 @@
void verify() const;
// Attributes
- methodHandle static_target(TRAPS); // "specified" method (from constant pool)
+ Method* static_target(TRAPS); // "specified" method (from constant pool)
Handle appendix(TRAPS); // if CPCE::has_appendix (from constant pool)
// Testers
--- a/src/hotspot/share/interpreter/interpreterRuntime.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/interpreterRuntime.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -897,7 +897,7 @@
// (see also CallInfo::set_interface for details)
assert(info.call_kind() == CallInfo::vtable_call ||
info.call_kind() == CallInfo::direct_call, "");
- methodHandle rm = info.resolved_method();
+ Method* rm = info.resolved_method();
assert(rm->is_final() || info.has_vtable_index(),
"should have been set already");
} else if (!info.resolved_method()->has_itable_index()) {
@@ -921,25 +921,26 @@
// methods must be checked for every call.
InstanceKlass* sender = pool->pool_holder();
sender = sender->is_unsafe_anonymous() ? sender->unsafe_anonymous_host() : sender;
+ methodHandle resolved_method(THREAD, info.resolved_method());
switch (info.call_kind()) {
case CallInfo::direct_call:
cp_cache_entry->set_direct_call(
bytecode,
- info.resolved_method(),
+ resolved_method,
sender->is_interface());
break;
case CallInfo::vtable_call:
cp_cache_entry->set_vtable_call(
bytecode,
- info.resolved_method(),
+ resolved_method,
info.vtable_index());
break;
case CallInfo::itable_call:
cp_cache_entry->set_itable_call(
bytecode,
info.resolved_klass(),
- info.resolved_method(),
+ resolved_method,
info.itable_index());
break;
default: ShouldNotReachHere();
--- a/src/hotspot/share/interpreter/linkResolver.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/linkResolver.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -140,8 +140,8 @@
}
_resolved_klass = resolved_klass;
_selected_klass = resolved_klass;
- _resolved_method = resolved_method;
- _selected_method = resolved_method;
+ _resolved_method = methodHandle(THREAD, resolved_method);
+ _selected_method = methodHandle(THREAD, resolved_method);
// classify:
CallKind kind = CallInfo::unknown_kind;
int index = resolved_method->vtable_index();
@@ -153,7 +153,7 @@
} else if (!resolved_klass->is_interface()) {
// A default or miranda method. Compute the vtable index.
index = LinkResolver::vtable_index_of_interface_method(resolved_klass,
- resolved_method);
+ _resolved_method);
assert(index >= 0 , "we should have valid vtable index at this point");
kind = CallInfo::vtable_call;
@@ -189,9 +189,8 @@
}
void CallInfo::set_resolved_method_name(TRAPS) {
- Method* m = _resolved_method();
- assert(m != NULL, "Should already have a Method*");
- oop rmethod_name = java_lang_invoke_ResolvedMethodName::find_resolved_method(m, CHECK);
+ assert(_resolved_method() != NULL, "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);
}
@@ -381,10 +380,10 @@
// returns first instance method
// Looks up method in classes, then looks up local default methods
-methodHandle LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
- Symbol* name,
- Symbol* signature,
- Klass::PrivateLookupMode private_mode, TRAPS) {
+Method* LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
+ Symbol* name,
+ Symbol* signature,
+ Klass::PrivateLookupMode private_mode, TRAPS) {
Method* result = klass->uncached_lookup_method(name, signature, Klass::find_overpass, private_mode);
while (result != NULL && result->is_static() && result->method_holder()->super() != NULL) {
@@ -394,7 +393,7 @@
if (klass->is_array_klass()) {
// Only consider klass and super klass for arrays
- return methodHandle(THREAD, result);
+ return result;
}
if (result == NULL) {
@@ -404,7 +403,7 @@
assert(result == NULL || !result->is_static(), "static defaults not allowed");
}
}
- return methodHandle(THREAD, result);
+ return result;
}
int LinkResolver::vtable_index_of_interface_method(Klass* klass,
@@ -441,10 +440,9 @@
return ik->lookup_method_in_all_interfaces(cp_info.name(), cp_info.signature(), Klass::skip_defaults);
}
-methodHandle LinkResolver::lookup_polymorphic_method(
- const LinkInfo& link_info,
- Handle *appendix_result_or_null,
- TRAPS) {
+Method* LinkResolver::lookup_polymorphic_method(const LinkInfo& link_info,
+ Handle *appendix_result_or_null,
+ TRAPS) {
Klass* klass = link_info.resolved_klass();
Symbol* name = link_info.name();
Symbol* full_signature = link_info.signature();
@@ -472,10 +470,10 @@
full_signature->as_C_string(),
basic_signature->as_C_string());
}
- methodHandle result = SystemDictionary::find_method_handle_intrinsic(iid,
+ Method* result = SystemDictionary::find_method_handle_intrinsic(iid,
basic_signature,
CHECK_NULL);
- if (result.not_null()) {
+ if (result != NULL) {
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");
@@ -505,7 +503,7 @@
Handle appendix;
Handle method_type;
- methodHandle result = SystemDictionary::find_method_handle_invoker(
+ Method* result = SystemDictionary::find_method_handle_invoker(
klass,
name,
full_signature,
@@ -520,7 +518,7 @@
if (appendix.is_null()) tty->print_cr("(none)");
else appendix->print_on(tty);
}
- if (result.not_null()) {
+ if (result != NULL) {
#ifdef ASSERT
ResourceMark rm(THREAD);
@@ -603,8 +601,8 @@
}
}
-methodHandle LinkResolver::resolve_method_statically(Bytecodes::Code code,
- const constantPoolHandle& pool, int index, TRAPS) {
+Method* LinkResolver::resolve_method_statically(Bytecodes::Code code,
+ const constantPoolHandle& pool, int index, TRAPS) {
// This method is used only
// (1) in C2 from InlineTree::ok_to_inline (via ciMethod::check_call),
// and
@@ -629,7 +627,7 @@
MethodHandles::is_signature_polymorphic_name(resolved_klass, link_info.name()))) {
Method* result = ConstantPool::method_at_if_loaded(pool, index);
if (result != NULL) {
- return methodHandle(THREAD, result);
+ return result;
}
}
@@ -714,8 +712,8 @@
}
}
-methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
- Bytecodes::Code code, TRAPS) {
+Method* LinkResolver::resolve_method(const LinkInfo& link_info,
+ Bytecodes::Code code, TRAPS) {
Handle nested_exception;
Klass* resolved_klass = link_info.resolved_klass();
@@ -748,7 +746,8 @@
if (resolved_method.is_null()) {
// JSR 292: see if this is an implicitly generated method MethodHandle.linkToVirtual(*...), etc
- resolved_method = lookup_polymorphic_method(link_info, (Handle*)NULL, THREAD);
+ Method* method = lookup_polymorphic_method(link_info, (Handle*)NULL, THREAD);
+ resolved_method = methodHandle(THREAD, method);
if (HAS_PENDING_EXCEPTION) {
nested_exception = Handle(THREAD, PENDING_EXCEPTION);
CLEAR_PENDING_EXCEPTION;
@@ -783,13 +782,13 @@
check_method_loader_constraints(link_info, resolved_method, "method", CHECK_NULL);
}
- return resolved_method;
+ return resolved_method();
}
static void trace_method_resolution(const char* prefix,
Klass* klass,
Klass* resolved_klass,
- const methodHandle& method,
+ Method* method,
bool logitables,
int index = -1) {
#ifndef PRODUCT
@@ -821,7 +820,7 @@
}
// Do linktime resolution of a method in the interface within the context of the specied bytecode.
-methodHandle LinkResolver::resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS) {
+Method* LinkResolver::resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS) {
Klass* resolved_klass = link_info.resolved_klass();
@@ -892,11 +891,10 @@
char buf[200];
jio_snprintf(buf, sizeof(buf), "%s resolved interface method: caller-class:",
Bytecodes::name(code));
- trace_method_resolution(buf, link_info.current_klass(), resolved_klass,
- resolved_method, true);
+ trace_method_resolution(buf, link_info.current_klass(), resolved_klass, resolved_method(), true);
}
- return resolved_method;
+ return resolved_method();
}
//------------------------------------------------------------------------------------------------------------------------
@@ -999,11 +997,11 @@
}
if (fd.constants()->pool_holder()->major_version() >= 53) {
- methodHandle m = link_info.current_method();
- assert(!m.is_null(), "information about the current method must be available for 'put' bytecodes");
+ Method* m = link_info.current_method();
+ assert(m != NULL, "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());
+ !m->is_static_initializer());
bool is_initialized_instance_final_update = ((byte == Bytecodes::_putfield || byte == Bytecodes::_nofast_putfield) &&
!fd.is_static() &&
!m->is_object_initializer());
@@ -1011,7 +1009,7 @@
if (is_initialized_static_final_update || is_initialized_instance_final_update) {
ss.print("Update to %s final field %s.%s attempted from a different method (%s) than the initializer method %s ",
is_static ? "static" : "non-static", resolved_klass->external_name(), fd.name()->as_C_string(),
- m()->name()->as_C_string(),
+ m->name()->as_C_string(),
is_static ? "<clinit>" : "<init>");
THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
}
@@ -1052,7 +1050,7 @@
void LinkResolver::resolve_static_call(CallInfo& result,
const LinkInfo& link_info,
bool initialize_class, TRAPS) {
- methodHandle resolved_method = linktime_resolve_static_method(link_info, CHECK);
+ Method* resolved_method = linktime_resolve_static_method(link_info, CHECK);
// The resolved class can change as a result of this resolution.
Klass* resolved_klass = resolved_method->method_holder();
@@ -1068,14 +1066,14 @@
}
// setup result
- result.set_static(resolved_klass, resolved_method, CHECK);
+ result.set_static(resolved_klass, methodHandle(THREAD, resolved_method), CHECK);
}
// throws linktime exceptions
-methodHandle LinkResolver::linktime_resolve_static_method(const LinkInfo& link_info, TRAPS) {
+Method* LinkResolver::linktime_resolve_static_method(const LinkInfo& link_info, TRAPS) {
Klass* resolved_klass = link_info.resolved_klass();
- methodHandle resolved_method;
+ Method* resolved_method;
if (!resolved_klass->is_interface()) {
resolved_method = resolve_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
} else {
@@ -1088,7 +1086,7 @@
ResourceMark rm(THREAD);
stringStream ss;
ss.print("Expected static method '");
- resolved_method()->print_external_name(&ss);
+ resolved_method->print_external_name(&ss);
ss.print("'");
THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
}
@@ -1100,13 +1098,12 @@
Handle recv,
const LinkInfo& link_info,
TRAPS) {
- methodHandle resolved_method = linktime_resolve_special_method(link_info, CHECK);
- runtime_resolve_special_method(result, link_info, resolved_method, recv, CHECK);
+ Method* resolved_method = linktime_resolve_special_method(link_info, CHECK);
+ runtime_resolve_special_method(result, link_info, methodHandle(THREAD, resolved_method), recv, CHECK);
}
// throws linktime exceptions
-methodHandle LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info,
- TRAPS) {
+Method* LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info, TRAPS) {
// Invokespecial is called for multiple special reasons:
// <init>
@@ -1115,7 +1112,7 @@
// 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();
- methodHandle resolved_method;
+ Method* resolved_method;
if (!resolved_klass->is_interface()) {
resolved_method = resolve_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
@@ -1210,10 +1207,12 @@
current_klass != resolved_klass) {
// Lookup super method
Klass* super_klass = current_klass->super();
- sel_method = lookup_instance_method_in_klasses(super_klass,
+ Method* instance_method = lookup_instance_method_in_klasses(super_klass,
resolved_method->name(),
resolved_method->signature(),
Klass::find_private, CHECK);
+ sel_method = methodHandle(THREAD, instance_method);
+
// check if found
if (sel_method.is_null()) {
ResourceMark rm(THREAD);
@@ -1272,7 +1271,7 @@
if (log_develop_is_enabled(Trace, itables)) {
trace_method_resolution("invokespecial selected method: resolved-class:",
- resolved_klass, resolved_klass, sel_method, true);
+ resolved_klass, resolved_klass, sel_method(), true);
}
// setup result
@@ -1282,18 +1281,18 @@
void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, Klass* receiver_klass,
const LinkInfo& link_info,
bool check_null_and_abstract, TRAPS) {
- methodHandle resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
- runtime_resolve_virtual_method(result, resolved_method,
+ Method* resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
+ runtime_resolve_virtual_method(result, methodHandle(THREAD, resolved_method),
link_info.resolved_klass(),
recv, receiver_klass,
check_null_and_abstract, CHECK);
}
// throws linktime exceptions
-methodHandle LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
+Method* LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
TRAPS) {
// normal method resolution
- methodHandle resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
+ Method* resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
@@ -1392,7 +1391,7 @@
if (log_develop_is_enabled(Trace, vtables)) {
trace_method_resolution("invokevirtual selected method: receiver-class:",
- recv_klass, resolved_klass, selected_method,
+ recv_klass, resolved_klass, selected_method(),
false, vtable_index);
}
// setup result
@@ -1403,15 +1402,16 @@
const LinkInfo& link_info,
bool check_null_and_abstract, TRAPS) {
// throws linktime exceptions
- methodHandle resolved_method = linktime_resolve_interface_method(link_info, CHECK);
- runtime_resolve_interface_method(result, resolved_method,link_info.resolved_klass(),
+ Method* resolved_method = linktime_resolve_interface_method(link_info, CHECK);
+ methodHandle mh(THREAD, resolved_method);
+ runtime_resolve_interface_method(result, mh, link_info.resolved_klass(),
recv, recv_klass, check_null_and_abstract, CHECK);
}
-methodHandle LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
+Method* LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
TRAPS) {
// normal interface method resolution
- methodHandle resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
+ Method* resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
@@ -1449,10 +1449,11 @@
// This search must match the linktime preparation search for itable initialization
// to correctly enforce loader constraints for interface method inheritance.
// Private methods are skipped as the resolved method was not private.
- selected_method = lookup_instance_method_in_klasses(recv_klass,
- resolved_method->name(),
- resolved_method->signature(),
- Klass::skip_private, CHECK);
+ Method* method = lookup_instance_method_in_klasses(recv_klass,
+ resolved_method->name(),
+ resolved_method->signature(),
+ Klass::skip_private, CHECK);
+ selected_method = methodHandle(THREAD, method);
if (selected_method.is_null() && !check_null_and_abstract) {
// In theory this is a harmless placeholder value, but
@@ -1483,7 +1484,7 @@
if (log_develop_is_enabled(Trace, itables)) {
trace_method_resolution("invokeinterface selected method: receiver-class:",
- recv_klass, resolved_klass, selected_method, true);
+ recv_klass, resolved_klass, selected_method(), true);
}
// setup result
if (resolved_method->has_vtable_index()) {
@@ -1509,31 +1510,31 @@
}
-methodHandle LinkResolver::linktime_resolve_interface_method_or_null(
+Method* LinkResolver::linktime_resolve_interface_method_or_null(
const LinkInfo& link_info) {
EXCEPTION_MARK;
- methodHandle method_result = linktime_resolve_interface_method(link_info, THREAD);
+ Method* method_result = linktime_resolve_interface_method(link_info, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
- return methodHandle();
+ return NULL;
} else {
return method_result;
}
}
-methodHandle LinkResolver::linktime_resolve_virtual_method_or_null(
+Method* LinkResolver::linktime_resolve_virtual_method_or_null(
const LinkInfo& link_info) {
EXCEPTION_MARK;
- methodHandle method_result = linktime_resolve_virtual_method(link_info, THREAD);
+ Method* method_result = linktime_resolve_virtual_method(link_info, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
- return methodHandle();
+ return NULL;
} else {
return method_result;
}
}
-methodHandle LinkResolver::resolve_virtual_call_or_null(
+Method* LinkResolver::resolve_virtual_call_or_null(
Klass* receiver_klass,
const LinkInfo& link_info) {
EXCEPTION_MARK;
@@ -1541,12 +1542,12 @@
resolve_virtual_call(info, Handle(), receiver_klass, link_info, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
- return methodHandle();
+ return NULL;
}
return info.selected_method();
}
-methodHandle LinkResolver::resolve_interface_call_or_null(
+Method* LinkResolver::resolve_interface_call_or_null(
Klass* receiver_klass,
const LinkInfo& link_info) {
EXCEPTION_MARK;
@@ -1554,7 +1555,7 @@
resolve_interface_call(info, Handle(), receiver_klass, link_info, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
- return methodHandle();
+ return NULL;
}
return info.selected_method();
}
@@ -1572,24 +1573,24 @@
return info.vtable_index();
}
-methodHandle LinkResolver::resolve_static_call_or_null(const LinkInfo& link_info) {
+Method* LinkResolver::resolve_static_call_or_null(const LinkInfo& link_info) {
EXCEPTION_MARK;
CallInfo info;
resolve_static_call(info, link_info, /*initialize_class*/false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
- return methodHandle();
+ return NULL;
}
return info.selected_method();
}
-methodHandle LinkResolver::resolve_special_call_or_null(const LinkInfo& link_info) {
+Method* LinkResolver::resolve_special_call_or_null(const LinkInfo& link_info) {
EXCEPTION_MARK;
CallInfo info;
resolve_special_call(info, Handle(), link_info, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
- return methodHandle();
+ return NULL;
}
return info.selected_method();
}
@@ -1690,8 +1691,8 @@
resolved_klass == SystemDictionary::VarHandle_klass(), "");
assert(MethodHandles::is_signature_polymorphic_name(link_info.name()), "");
Handle resolved_appendix;
- methodHandle resolved_method = lookup_polymorphic_method(link_info, &resolved_appendix, CHECK);
- result.set_handle(resolved_klass, resolved_method, resolved_appendix, CHECK);
+ Method* resolved_method = lookup_polymorphic_method(link_info, &resolved_appendix, CHECK);
+ result.set_handle(resolved_klass, methodHandle(THREAD, resolved_method), resolved_appendix, CHECK);
}
void LinkResolver::resolve_invokedynamic(CallInfo& result, const constantPoolHandle& pool, int indy_index, TRAPS) {
--- a/src/hotspot/share/interpreter/linkResolver.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/linkResolver.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -96,8 +96,8 @@
Klass* resolved_klass() const { return _resolved_klass; }
Klass* selected_klass() const { return _selected_klass; }
- methodHandle resolved_method() const { return _resolved_method; }
- methodHandle selected_method() const { return _selected_method; }
+ Method* resolved_method() const { return _resolved_method(); }
+ Method* selected_method() const { return _selected_method(); }
Handle resolved_appendix() const { return _resolved_appendix; }
Handle resolved_method_name() const { return _resolved_method_name; }
// Materialize a java.lang.invoke.ResolvedMethodName for this resolved_method
@@ -181,7 +181,7 @@
Symbol* signature() const { return _signature; }
Klass* resolved_klass() const { return _resolved_klass; }
Klass* current_klass() const { return _current_klass; }
- methodHandle current_method() const { return _current_method; }
+ Method* current_method() const { return _current_method(); }
constantTag tag() const { return _tag; }
bool check_access() const { return _check_access; }
@@ -205,12 +205,12 @@
bool in_imethod_resolve);
static Method* lookup_method_in_interfaces(const LinkInfo& link_info);
- static methodHandle lookup_polymorphic_method(const LinkInfo& link_info,
- Handle *appendix_result_or_null, TRAPS);
+ static Method* lookup_polymorphic_method(const LinkInfo& link_info,
+ Handle *appendix_result_or_null, TRAPS);
JVMCI_ONLY(public:) // Needed for CompilerToVM.resolveMethod()
// Not Linktime so doesn't take LinkInfo
- static methodHandle lookup_instance_method_in_klasses (Klass* klass, Symbol* name, Symbol* signature,
- Klass::PrivateLookupMode private_mode, TRAPS);
+ static Method* lookup_instance_method_in_klasses (Klass* klass, Symbol* name, Symbol* signature,
+ Klass::PrivateLookupMode private_mode, TRAPS);
JVMCI_ONLY(private:)
// Similar loader constraint checking functions that throw
@@ -222,13 +222,13 @@
Klass* current_klass,
Klass* sel_klass, TRAPS);
- static methodHandle resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
- static methodHandle resolve_method (const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
+ static Method* resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
+ static Method* resolve_method (const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
- static methodHandle linktime_resolve_static_method (const LinkInfo& link_info, TRAPS);
- static methodHandle linktime_resolve_special_method (const LinkInfo& link_info, TRAPS);
- static methodHandle linktime_resolve_virtual_method (const LinkInfo& link_info, TRAPS);
- static methodHandle linktime_resolve_interface_method (const LinkInfo& link_info, TRAPS);
+ static Method* linktime_resolve_static_method (const LinkInfo& link_info, TRAPS);
+ static Method* linktime_resolve_special_method (const LinkInfo& link_info, TRAPS);
+ static Method* linktime_resolve_virtual_method (const LinkInfo& link_info, TRAPS);
+ static Method* linktime_resolve_interface_method (const LinkInfo& link_info, TRAPS);
static void runtime_resolve_special_method (CallInfo& result,
const LinkInfo& link_info,
@@ -285,9 +285,9 @@
// static resolving calls (will not run any Java code);
// used only from Bytecode_invoke::static_target
- static methodHandle resolve_method_statically(Bytecodes::Code code,
- const constantPoolHandle& pool,
- int index, TRAPS);
+ static Method* resolve_method_statically(Bytecodes::Code code,
+ const constantPoolHandle& pool,
+ int index, TRAPS);
static void resolve_field_access(fieldDescriptor& result,
const constantPoolHandle& pool,
@@ -318,12 +318,12 @@
// same as above for compile-time resolution; but returns null handle instead of throwing
// an exception on error also, does not initialize klass (i.e., no side effects)
- static methodHandle resolve_virtual_call_or_null (Klass* receiver_klass,
- const LinkInfo& link_info);
- static methodHandle resolve_interface_call_or_null(Klass* receiver_klass,
- const LinkInfo& link_info);
- static methodHandle resolve_static_call_or_null (const LinkInfo& link_info);
- static methodHandle resolve_special_call_or_null (const LinkInfo& link_info);
+ static Method* resolve_virtual_call_or_null(Klass* receiver_klass,
+ const LinkInfo& link_info);
+ static Method* resolve_interface_call_or_null(Klass* receiver_klass,
+ const LinkInfo& link_info);
+ static Method* resolve_static_call_or_null(const LinkInfo& link_info);
+ static Method* resolve_special_call_or_null(const LinkInfo& link_info);
static int vtable_index_of_interface_method(Klass* klass, const methodHandle& resolved_method);
@@ -332,8 +332,8 @@
const LinkInfo& link_info);
// static resolving for compiler (does not throw exceptions, returns null handle if unsuccessful)
- static methodHandle linktime_resolve_virtual_method_or_null (const LinkInfo& link_info);
- static methodHandle linktime_resolve_interface_method_or_null(const LinkInfo& link_info);
+ static Method* linktime_resolve_virtual_method_or_null (const LinkInfo& link_info);
+ static Method* linktime_resolve_interface_method_or_null(const LinkInfo& link_info);
// runtime resolving from constant pool
static void resolve_invoke(CallInfo& result, Handle recv,
@@ -348,11 +348,11 @@
public:
// Only resolved method known.
static void throw_abstract_method_error(const methodHandle& resolved_method, TRAPS) {
- throw_abstract_method_error(resolved_method, NULL, NULL, CHECK);
+ throw_abstract_method_error(resolved_method, methodHandle(), NULL, CHECK);
}
// Resolved method and receiver klass know.
static void throw_abstract_method_error(const methodHandle& resolved_method, Klass *recv_klass, TRAPS) {
- throw_abstract_method_error(resolved_method, NULL, recv_klass, CHECK);
+ throw_abstract_method_error(resolved_method, methodHandle(), recv_klass, CHECK);
}
// Selected method is abstract.
static void throw_abstract_method_error(const methodHandle& resolved_method,
--- a/src/hotspot/share/interpreter/rewriter.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/rewriter.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -80,13 +80,13 @@
}
// Unrewrite the bytecodes if an error occurs.
-void Rewriter::restore_bytecodes() {
+void Rewriter::restore_bytecodes(Thread* thread) {
int len = _methods->length();
bool invokespecial_error = false;
for (int i = len-1; i >= 0; i--) {
Method* method = _methods->at(i);
- scan_method(method, true, &invokespecial_error);
+ scan_method(thread, method, true, &invokespecial_error);
assert(!invokespecial_error, "reversing should not get an invokespecial error");
}
}
@@ -365,7 +365,7 @@
// Rewrites a method given the index_map information
-void Rewriter::scan_method(Method* method, bool reverse, bool* invokespecial_error) {
+void Rewriter::scan_method(Thread* thread, Method* method, bool reverse, bool* invokespecial_error) {
int nof_jsrs = 0;
bool has_monitor_bytecodes = false;
@@ -439,7 +439,7 @@
// succeeded. Therefore, the class is guaranteed to be well-formed.
InstanceKlass* klass = method->method_holder();
u2 bc_index = Bytes::get_Java_u2(bcp + prefix_length + 1);
- constantPoolHandle cp(method->constants());
+ constantPoolHandle cp(thread, method->constants());
Symbol* ref_class_name = cp->klass_name_at(cp->klass_ref_index_at(bc_index));
if (klass->name() == ref_class_name) {
@@ -548,7 +548,7 @@
for (int i = len-1; i >= 0; i--) {
Method* method = _methods->at(i);
- scan_method(method, false, &invokespecial_error);
+ scan_method(THREAD, method, false, &invokespecial_error);
if (invokespecial_error) {
// If you get an error here, there is no reversing bytecodes
// This exception is stored for this class and no further attempt is
@@ -570,7 +570,8 @@
assert(!klass->is_shared(), "archive methods must not be rewritten at run time");
}
ResourceMark rm(THREAD);
- Rewriter rw(klass, klass->constants(), klass->methods(), CHECK);
+ constantPoolHandle cpool(THREAD, klass->constants());
+ Rewriter rw(klass, cpool, klass->methods(), CHECK);
// (That's all, folks.)
}
@@ -592,7 +593,7 @@
// Stress restoring bytecodes
if (StressRewriter) {
- restore_bytecodes();
+ restore_bytecodes(THREAD);
rewrite_bytecodes(CHECK);
}
@@ -602,7 +603,7 @@
// Restore bytecodes to their unrewritten state if there are exceptions
// rewriting bytecodes or allocating the cpCache
if (HAS_PENDING_EXCEPTION) {
- restore_bytecodes();
+ restore_bytecodes(THREAD);
return;
}
@@ -620,7 +621,7 @@
// relocating bytecodes. If some are relocated, that is ok because that
// doesn't affect constant pool to cpCache rewriting.
if (HAS_PENDING_EXCEPTION) {
- restore_bytecodes();
+ restore_bytecodes(THREAD);
return;
}
// Method might have gotten rewritten.
--- a/src/hotspot/share/interpreter/rewriter.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/interpreter/rewriter.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -184,7 +184,7 @@
void compute_index_maps();
void make_constant_pool_cache(TRAPS);
- void scan_method(Method* m, bool reverse, bool* invokespecial_error);
+ void scan_method(Thread* thread, Method* m, bool reverse, bool* invokespecial_error);
void rewrite_Object_init(const methodHandle& m, TRAPS);
void rewrite_member_reference(address bcp, int offset, bool reverse);
void maybe_rewrite_invokehandle(address opc, int cp_index, int cache_index, bool reverse);
@@ -198,7 +198,7 @@
void rewrite_bytecodes(TRAPS);
// Revert bytecodes in case of an exception.
- void restore_bytecodes();
+ void restore_bytecodes(Thread* thread);
static methodHandle rewrite_jsrs(const methodHandle& m, TRAPS);
public:
--- a/src/hotspot/share/jfr/leakprofiler/chains/edgeUtils.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jfr/leakprofiler/chains/edgeUtils.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -28,7 +28,7 @@
#include "jfr/leakprofiler/chains/edgeStore.hpp"
#include "jfr/leakprofiler/chains/edgeUtils.hpp"
#include "jfr/leakprofiler/utilities/unifiedOop.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/objArrayOop.inline.hpp"
#include "oops/oopsHierarchy.hpp"
--- a/src/hotspot/share/jvmci/compilerRuntime.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/compilerRuntime.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -141,7 +141,7 @@
// Make sure it's resolved first
CallInfo callInfo;
- constantPoolHandle cp(holder->constants());
+ constantPoolHandle cp(THREAD, holder->constants());
ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index, true));
Bytecodes::Code invoke_code = bytecode.invoke_code();
if (!cp_cache_entry->is_resolved(invoke_code)) {
@@ -157,7 +157,7 @@
Handle appendix(THREAD, cp_cache_entry->appendix_if_resolved(cp));
Klass *appendix_klass = appendix.is_null() ? NULL : appendix->klass();
- methodHandle adapter_method(cp_cache_entry->f1_as_method());
+ methodHandle adapter_method(THREAD, cp_cache_entry->f1_as_method());
InstanceKlass *adapter_klass = adapter_method->method_holder();
if (appendix_klass != NULL && appendix_klass->is_instance_klass()) {
--- a/src/hotspot/share/jvmci/jvmciCodeInstaller.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciCodeInstaller.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -203,8 +203,8 @@
result = JVMCIENV->get_jvmci_type(klass, JVMCI_CATCH);
} else if (h->is_method()) {
Method* method = (Method*) h;
- methodHandle mh(method);
- result = JVMCIENV->get_jvmci_method(method, JVMCI_CATCH);
+ methodHandle mh(THREAD, method);
+ result = JVMCIENV->get_jvmci_method(mh, JVMCI_CATCH);
}
jobject ref = JVMCIENV->get_jobject(result);
record_meta_ref(ref, index);
@@ -501,8 +501,8 @@
int length = JVMCIENV->get_length(methods);
for (int i = 0; i < length; ++i) {
JVMCIObject method_handle = JVMCIENV->get_object_at(methods, i);
- methodHandle method = jvmci_env()->asMethod(method_handle);
- _dependencies->assert_evol_method(method());
+ Method* method = jvmci_env()->asMethod(method_handle);
+ _dependencies->assert_evol_method(method);
}
}
}
@@ -620,13 +620,15 @@
jvmci_env()->set_compile_state(compile_state);
}
- methodHandle method = jvmci_env()->asMethod(jvmci_env()->get_HotSpotCompiledNmethod_method(compiled_code));
+ Thread* thread = Thread::current();
+
+ methodHandle method(thread, jvmci_env()->asMethod(jvmci_env()->get_HotSpotCompiledNmethod_method(compiled_code)));
jint entry_bci = jvmci_env()->get_HotSpotCompiledNmethod_entryBCI(compiled_code);
bool has_unsafe_access = jvmci_env()->get_HotSpotCompiledNmethod_hasUnsafeAccess(compiled_code) == JNI_TRUE;
jint id = jvmci_env()->get_HotSpotCompiledNmethod_id(compiled_code);
if (id == -1) {
// Make sure a valid compile_id is associated with every compile
- id = CompileBroker::assign_compile_id_unlocked(Thread::current(), method, entry_bci);
+ id = CompileBroker::assign_compile_id_unlocked(thread, method, entry_bci);
jvmci_env()->set_HotSpotCompiledNmethod_id(compiled_code, id);
}
if (!jvmci_env()->isa_HotSpotNmethod(installed_code)) {
@@ -659,7 +661,8 @@
void CodeInstaller::initialize_fields(JVMCIObject target, JVMCIObject compiled_code, JVMCI_TRAPS) {
if (jvmci_env()->isa_HotSpotCompiledNmethod(compiled_code)) {
JVMCIObject hotspotJavaMethod = jvmci_env()->get_HotSpotCompiledNmethod_method(compiled_code);
- methodHandle method = jvmci_env()->asMethod(hotspotJavaMethod);
+ Thread* thread = Thread::current();
+ methodHandle method(thread, jvmci_env()->asMethod(hotspotJavaMethod));
_parameter_count = method->size_of_parameters();
TRACE_jvmci_2("installing code for %s", method->name_and_sig_as_C_string());
} else {
@@ -937,10 +940,10 @@
JVMCIObject impl_handle = jvmci_env()->get_Assumptions_ConcreteMethod_impl(assumption);
JVMCIObject context_handle = jvmci_env()->get_Assumptions_ConcreteMethod_context(assumption);
- methodHandle impl = jvmci_env()->asMethod(impl_handle);
+ Method* impl = jvmci_env()->asMethod(impl_handle);
Klass* context = jvmci_env()->asKlass(context_handle);
- _dependencies->assert_unique_concrete_method(context, impl());
+ _dependencies->assert_unique_concrete_method(context, impl);
}
void CodeInstaller::assumption_CallSiteTargetValue(JVMCIObject assumption, JVMCI_TRAPS) {
@@ -1064,7 +1067,8 @@
}
JVMCIObject hotspot_method = jvmci_env()->get_BytecodePosition_method(position);
- Method* method = jvmci_env()->asMethod(hotspot_method);
+ Thread* thread = Thread::current();
+ methodHandle method(thread, jvmci_env()->asMethod(hotspot_method));
jint bci = map_jvmci_bci(jvmci_env()->get_BytecodePosition_bci(position));
if (bci == jvmci_env()->get_BytecodeFrame_BEFORE_BCI()) {
bci = SynchronizationEntryBCI;
@@ -1077,7 +1081,7 @@
if (bci < 0){
reexecute = false;
} else {
- Bytecodes::Code code = Bytecodes::java_code_at(method, method->bcp_from(bci));
+ Bytecodes::Code code = Bytecodes::java_code_at(method(), method->bcp_from(bci));
reexecute = bytecode_should_reexecute(code);
if (frame.is_non_null()) {
reexecute = (jvmci_env()->get_BytecodeFrame_duringCall(frame) == JNI_FALSE);
--- a/src/hotspot/share/jvmci/jvmciCompiler.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciCompiler.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -67,7 +67,7 @@
// Initialize compile queue with a selected set of methods.
int len = objectMethods->length();
for (int i = 0; i < len; i++) {
- methodHandle mh = objectMethods->at(i);
+ methodHandle mh(THREAD, objectMethods->at(i));
if (!mh->is_native() && !mh->is_static() && !mh->is_initializer()) {
ResourceMark rm;
int hot_count = 10; // TODO: what's the appropriate value?
@@ -100,7 +100,7 @@
JVMCI::compiler_runtime()->bootstrap_finished(CHECK);
}
-bool JVMCICompiler::force_comp_at_level_simple(Method *method) {
+bool JVMCICompiler::force_comp_at_level_simple(const methodHandle& method) {
if (UseJVMCINativeLibrary) {
// This mechanism exists to force compilation of a JVMCI compiler by C1
// to reduces the compilation time spent on the JVMCI compiler itself. In
--- a/src/hotspot/share/jvmci/jvmciCompiler.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciCompiler.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -84,7 +84,7 @@
void bootstrap(TRAPS);
// Should force compilation of method at CompLevel_simple?
- bool force_comp_at_level_simple(Method* method);
+ bool force_comp_at_level_simple(const methodHandle& method);
bool is_bootstrapping() const { return _bootstrapping; }
--- a/src/hotspot/share/jvmci/jvmciCompilerToVM.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciCompilerToVM.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -254,7 +254,7 @@
C2V_END
C2V_VMENTRY_NULL(jbyteArray, getBytecode, (JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
int code_size = method->code_size();
jbyte* reconstituted_code = NEW_RESOURCE_ARRAY(jbyte, code_size);
@@ -332,12 +332,12 @@
C2V_END
C2V_VMENTRY_0(jint, getExceptionTableLength, (JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ Method* method = JVMCIENV->asMethod(jvmci_method);
return method->exception_table_length();
C2V_END
C2V_VMENTRY_0(jlong, getExceptionTableStart, (JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ Method* method = JVMCIENV->asMethod(jvmci_method);
if (method->exception_table_length() == 0) {
return 0L;
}
@@ -359,13 +359,13 @@
slot = java_lang_reflect_Method::slot(executable);
}
Klass* holder = java_lang_Class::as_Klass(mirror);
- methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot);
+ methodHandle method (THREAD, InstanceKlass::cast(holder)->method_with_idnum(slot));
JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result);
}
C2V_VMENTRY_NULL(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject base, jlong offset))
- methodHandle method;
+ Method* method;
JVMCIObject base_object = JVMCIENV->wrap(base);
if (base_object.is_null()) {
method = *((Method**)(offset));
@@ -379,16 +379,16 @@
} else if (JVMCIENV->isa_HotSpotResolvedJavaMethodImpl(base_object)) {
method = JVMCIENV->asMethod(base_object);
}
- if (method.is_null()) {
+ if (method == NULL) {
JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", JVMCIENV->klass_name(base_object)));
}
- assert (method.is_null() || method->is_method(), "invalid read");
- JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
+ assert (method->is_method(), "invalid read");
+ JVMCIObject result = JVMCIENV->get_jvmci_method(methodHandle(THREAD, method), JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result);
}
C2V_VMENTRY_NULL(jobject, getConstantPool, (JNIEnv* env, jobject, jobject object_handle))
- constantPoolHandle cp;
+ ConstantPool* cp = NULL;
JVMCIObject object = JVMCIENV->wrap(object_handle);
if (object.is_null()) {
JVMCI_THROW_NULL(NullPointerException);
@@ -401,9 +401,9 @@
JVMCI_THROW_MSG_NULL(IllegalArgumentException,
err_msg("Unexpected type: %s", JVMCIENV->klass_name(object)));
}
- assert(!cp.is_null(), "npe");
+ assert(cp != NULL, "npe");
- JVMCIObject result = JVMCIENV->get_jvmci_constant_pool(cp, JVMCI_CHECK_NULL);
+ JVMCIObject result = JVMCIENV->get_jvmci_constant_pool(constantPoolHandle(THREAD, cp), JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result);
}
@@ -451,7 +451,7 @@
}
C2V_VMENTRY_NULL(jobject, findUniqueConcreteMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method (THREAD, JVMCIENV->asMethod(jvmci_method));
Klass* holder = JVMCIENV->asKlass(jvmci_type);
if (holder->is_interface()) {
JVMCI_THROW_MSG_NULL(InternalError, err_msg("Interface %s should be handled in Java code", holder->external_name()));
@@ -463,7 +463,7 @@
methodHandle ucm;
{
MutexLocker locker(Compile_lock);
- ucm = Dependencies::find_unique_concrete_method(holder, method());
+ ucm = methodHandle(THREAD, Dependencies::find_unique_concrete_method(holder, method()));
}
JVMCIObject result = JVMCIENV->get_jvmci_method(ucm, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result);
@@ -487,25 +487,25 @@
C2V_END
C2V_VMENTRY_0(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ Method* method = JVMCIENV->asMethod(jvmci_method);
return method->is_ignored_by_security_stack_walk();
C2V_END
C2V_VMENTRY_0(jboolean, isCompilable,(JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
- constantPoolHandle cp = method->constMethod()->constants();
- assert(!cp.is_null(), "npe");
+ Method* method = JVMCIENV->asMethod(jvmci_method);
+ ConstantPool* cp = method->constMethod()->constants();
+ assert(cp != NULL, "npe");
// don't inline method when constant pool contains a CONSTANT_Dynamic
return !method->is_not_compilable(CompLevel_full_optimization) && !cp->has_dynamic_constant();
C2V_END
C2V_VMENTRY_0(jboolean, hasNeverInlineDirective,(JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method (THREAD, JVMCIENV->asMethod(jvmci_method));
return !Inline || CompilerOracle::should_not_inline(method) || method->dont_inline();
C2V_END
C2V_VMENTRY_0(jboolean, shouldInlineMethod,(JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method (THREAD, JVMCIENV->asMethod(jvmci_method));
return CompilerOracle::should_inline(method) || method->force_inline();
C2V_END
@@ -613,35 +613,35 @@
}
C2V_VMENTRY_NULL(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL);
return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(result));
C2V_END
C2V_VMENTRY_0(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
return cp->name_and_type_ref_index_at(index);
C2V_END
C2V_VMENTRY_NULL(jobject, lookupNameInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
JVMCIObject sym = JVMCIENV->create_string(cp->name_ref_at(which), JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(sym);
C2V_END
C2V_VMENTRY_NULL(jobject, lookupSignatureInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
JVMCIObject sym = JVMCIENV->create_string(cp->signature_ref_at(which), JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(sym);
C2V_END
C2V_VMENTRY_0(jint, lookupKlassRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
return cp->klass_ref_index_at(index);
C2V_END
C2V_VMENTRY_NULL(jobject, resolveTypeInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
Klass* klass = cp->klass_at(index, CHECK_NULL);
JVMCIKlassHandle resolved_klass(THREAD, klass);
if (resolved_klass->is_instance_klass()) {
@@ -656,7 +656,7 @@
C2V_END
C2V_VMENTRY_NULL(jobject, lookupKlassInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
Klass* loading_klass = cp->pool_holder();
bool is_accessible = false;
JVMCIKlassHandle klass(THREAD, JVMCIRuntime::get_klass_by_index(cp, index, is_accessible, loading_klass));
@@ -684,30 +684,31 @@
C2V_END
C2V_VMENTRY_NULL(jobject, lookupAppendixInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(appendix_oop));
C2V_END
C2V_VMENTRY_NULL(jobject, lookupMethodInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
InstanceKlass* pool_holder = cp->pool_holder();
Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF);
- methodHandle method = JVMCIRuntime::get_method_by_index(cp, index, bc, pool_holder);
+ methodHandle method(THREAD, JVMCIRuntime::get_method_by_index(cp, index, bc, pool_holder));
JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result);
C2V_END
C2V_VMENTRY_0(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
return cp->remap_instruction_operand_from_cache(index);
C2V_END
C2V_VMENTRY_NULL(jobject, resolveFieldInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jobject jvmci_method, jbyte opcode, jintArray info_handle))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF);
fieldDescriptor fd;
- LinkInfo link_info(cp, index, (jvmci_method != NULL) ? JVMCIENV->asMethod(jvmci_method) : NULL, CHECK_0);
+ methodHandle mh(THREAD, (jvmci_method != NULL) ? JVMCIENV->asMethod(jvmci_method) : NULL);
+ LinkInfo link_info(cp, index, mh, CHECK_0);
LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), false, CHECK_0);
JVMCIPrimitiveArray info = JVMCIENV->wrap(info_handle);
if (info.is_null() || JVMCIENV->get_length(info) != 3) {
@@ -723,7 +724,7 @@
C2V_VMENTRY_0(jint, getVtableIndexForInterfaceMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
Klass* klass = JVMCIENV->asKlass(jvmci_type);
- Method* method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
if (klass->is_interface()) {
JVMCI_THROW_MSG_0(InternalError, err_msg("Interface %s should be handled in Java code", klass->external_name()));
}
@@ -742,7 +743,7 @@
C2V_VMENTRY_NULL(jobject, resolveMethod, (JNIEnv* env, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type))
Klass* recv_klass = JVMCIENV->asKlass(receiver_jvmci_type);
Klass* caller_klass = JVMCIENV->asKlass(caller_jvmci_type);
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
Klass* resolved = method->method_holder();
Symbol* h_name = method->name();
@@ -765,7 +766,7 @@
}
LinkInfo link_info(resolved, h_name, h_signature, caller_klass);
- methodHandle m;
+ Method* m = NULL;
// Only do exact lookup if receiver klass has been linked. Otherwise,
// the vtable has not been setup, and the LinkResolver will fail.
if (recv_klass->is_array_klass() ||
@@ -777,12 +778,12 @@
}
}
- if (m.is_null()) {
+ if (m == NULL) {
// Return NULL if there was a problem with lookup (uninitialized class, etc.)
return NULL;
}
- JVMCIObject result = JVMCIENV->get_jvmci_method(m, JVMCI_CHECK_NULL);
+ JVMCIObject result = JVMCIENV->get_jvmci_method(methodHandle(THREAD, m), JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result);
C2V_END
@@ -798,7 +799,8 @@
return NULL;
}
InstanceKlass* iklass = InstanceKlass::cast(klass);
- JVMCIObject result = JVMCIENV->get_jvmci_method(iklass->class_initializer(), JVMCI_CHECK_NULL);
+ methodHandle clinit(THREAD, iklass->class_initializer());
+ JVMCIObject result = JVMCIENV->get_jvmci_method(clinit, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(result);
C2V_END
@@ -813,7 +815,7 @@
C2V_END
C2V_VMENTRY(void, setNotInlinableOrCompilable,(JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
method->set_not_c1_compilable();
method->set_not_c2_compilable();
method->set_dont_inline(true);
@@ -1009,7 +1011,7 @@
C2V_VMENTRY_NULL(jobject, getStackTraceElement, (JNIEnv* env, jobject, jobject jvmci_method, int bci))
HandleMark hm;
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
JVMCIObject element = JVMCIENV->new_StackTraceElement(method, bci, JVMCI_CHECK_NULL);
return JVMCIENV->get_jobject(element);
C2V_END
@@ -1026,7 +1028,7 @@
if (nm == NULL) {
JVMCI_THROW_NULL(InvalidInstalledCodeException);
}
- methodHandle mh = nm->method();
+ methodHandle mh(THREAD, nm->method());
Symbol* signature = mh->signature();
JavaCallArguments jca(mh->size_of_parameters());
@@ -1104,7 +1106,7 @@
C2V_END
C2V_VMENTRY(void, reprofile, (JNIEnv* env, jobject, jobject jvmci_method))
- Method* method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
MethodCounters* mcs = method->method_counters();
if (mcs != NULL) {
mcs->clear_counters();
@@ -1161,7 +1163,7 @@
if (jvmci_method == NULL) {
JVMCI_THROW_0(NullPointerException);
}
- Method* method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
if (entry_bci >= method->code_size() || entry_bci < -1) {
JVMCI_THROW_MSG_0(IllegalArgumentException, err_msg("Unexpected bci %d", entry_bci));
}
@@ -1203,7 +1205,7 @@
LinkInfo link_info(spec_klass, name, signature);
LinkResolver::resolve_interface_call(
callinfo, receiver, recvrKlass, link_info, true, CHECK);
- methodHandle method = callinfo.selected_method();
+ methodHandle method(THREAD, callinfo.selected_method());
assert(method.not_null(), "should have thrown exception");
// Invoke the method
@@ -1277,7 +1279,8 @@
locals = cvf->locals();
HotSpotJVMCI::HotSpotStackFrameReference::set_bci(JVMCIENV, frame_reference(), cvf->bci());
- JVMCIObject method = JVMCIENV->get_jvmci_method(cvf->method(), JVMCI_CHECK_NULL);
+ methodHandle mh(THREAD, cvf->method());
+ JVMCIObject method = JVMCIENV->get_jvmci_method(mh, JVMCI_CHECK_NULL);
HotSpotJVMCI::HotSpotStackFrameReference::set_method(JVMCIENV, frame_reference(), JNIHandles::resolve(method.as_jobject()));
}
}
@@ -1290,7 +1293,8 @@
} else {
locals = ivf->locals();
HotSpotJVMCI::HotSpotStackFrameReference::set_bci(JVMCIENV, frame_reference(), ivf->bci());
- JVMCIObject method = JVMCIENV->get_jvmci_method(ivf->method(), JVMCI_CHECK_NULL);
+ methodHandle mh(THREAD, ivf->method());
+ JVMCIObject method = JVMCIENV->get_jvmci_method(mh, JVMCI_CHECK_NULL);
HotSpotJVMCI::HotSpotStackFrameReference::set_method(JVMCIENV, frame_reference(), JNIHandles::resolve(method.as_jobject()));
HotSpotJVMCI::HotSpotStackFrameReference::set_localIsVirtual(JVMCIENV, frame_reference(), NULL);
}
@@ -1370,7 +1374,7 @@
C2V_END
C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
CallInfo callInfo;
LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, Bytecodes::_invokedynamic, CHECK);
ConstantPoolCacheEntry* cp_cache_entry = cp->invokedynamic_cp_cache_entry_at(index);
@@ -1378,7 +1382,7 @@
C2V_END
C2V_VMENTRY(void, resolveInvokeHandleInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
Klass* holder = cp->klass_ref_at(index, CHECK);
Symbol* name = cp->name_ref_at(index);
if (MethodHandles::is_signature_polymorphic_name(holder, name)) {
@@ -1390,7 +1394,7 @@
C2V_END
C2V_VMENTRY_0(jint, isResolvedInvokeHandleInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
- constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
+ constantPoolHandle cp(THREAD, JVMCIENV->asConstantPool(jvmci_constant_pool));
ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index));
if (cp_cache_entry->is_resolved(Bytecodes::_invokehandle)) {
// MethodHandle.invoke* --> LambdaForm?
@@ -1405,7 +1409,7 @@
vmassert(MethodHandles::is_method_handle_invoke_name(resolved_klass, name_sym), "!");
vmassert(MethodHandles::is_signature_polymorphic_name(resolved_klass, name_sym), "!");
- methodHandle adapter_method(cp_cache_entry->f1_as_method());
+ methodHandle adapter_method(THREAD, cp_cache_entry->f1_as_method());
methodHandle resolved_method(adapter_method);
@@ -1416,7 +1420,7 @@
vmassert(!MethodHandles::is_signature_polymorphic_static(resolved_method->intrinsic_id()), "!");
vmassert(cp_cache_entry->appendix_if_resolved(cp) == NULL, "!");
- methodHandle m(LinkResolver::linktime_resolve_virtual_method_or_null(link_info));
+ methodHandle m(THREAD, LinkResolver::linktime_resolve_virtual_method_or_null(link_info));
vmassert(m == resolved_method, "!!");
return -1;
}
@@ -1909,7 +1913,8 @@
}
JVMCIObjectArray methods = JVMCIENV->new_ResolvedJavaMethod_array(constructors_array.length(), JVMCI_CHECK_NULL);
for (int i = 0; i < constructors_array.length(); i++) {
- JVMCIObject method = JVMCIENV->get_jvmci_method(constructors_array.at(i), JVMCI_CHECK_NULL);
+ methodHandle ctor(THREAD, constructors_array.at(i));
+ JVMCIObject method = JVMCIENV->get_jvmci_method(ctor, JVMCI_CHECK_NULL);
JVMCIENV->put_object_at(methods, i, method);
}
return JVMCIENV->get_jobjectArray(methods);
@@ -1938,7 +1943,8 @@
}
JVMCIObjectArray methods = JVMCIENV->new_ResolvedJavaMethod_array(methods_array.length(), JVMCI_CHECK_NULL);
for (int i = 0; i < methods_array.length(); i++) {
- JVMCIObject method = JVMCIENV->get_jvmci_method(methods_array.at(i), JVMCI_CHECK_NULL);
+ methodHandle mh(THREAD, methods_array.at(i));
+ JVMCIObject method = JVMCIENV->get_jvmci_method(mh, JVMCI_CHECK_NULL);
JVMCIENV->put_object_at(methods, i, method);
}
return JVMCIENV->get_jobjectArray(methods);
@@ -2259,7 +2265,7 @@
InstanceKlass* iklass = InstanceKlass::cast(klass);
for (int i = 0; i < iklass->methods()->length(); i++) {
- Method* method = iklass->methods()->at(i);
+ methodHandle method(THREAD, iklass->methods()->at(i));
if (method->is_native()) {
// Compute argument size
@@ -2425,7 +2431,7 @@
JVMCIObject obj = thisEnv->wrap(obj_handle);
JVMCIObject result;
if (thisEnv->isa_HotSpotResolvedJavaMethodImpl(obj)) {
- Method* method = thisEnv->asMethod(obj);
+ methodHandle method(THREAD, thisEnv->asMethod(obj));
result = peerEnv->get_jvmci_method(method, JVMCI_CHECK_0);
} else if (thisEnv->isa_HotSpotResolvedObjectTypeImpl(obj)) {
Klass* klass = thisEnv->asKlass(obj);
@@ -2456,13 +2462,13 @@
}
if (result.is_null()) {
JVMCIObject methodObject = thisEnv->get_HotSpotNmethod_method(obj);
- methodHandle mh = thisEnv->asMethod(methodObject);
+ methodHandle mh(THREAD, thisEnv->asMethod(methodObject));
jboolean isDefault = thisEnv->get_HotSpotNmethod_isDefault(obj);
jlong compileIdSnapshot = thisEnv->get_HotSpotNmethod_compileIdSnapshot(obj);
JVMCIObject name_string = thisEnv->get_InstalledCode_name(obj);
const char* cstring = name_string.is_null() ? NULL : thisEnv->as_utf8_string(name_string);
// Create a new HotSpotNmethod instance in the peer runtime
- result = peerEnv->new_HotSpotNmethod(mh(), cstring, isDefault, compileIdSnapshot, JVMCI_CHECK_0);
+ result = peerEnv->new_HotSpotNmethod(mh, cstring, isDefault, compileIdSnapshot, JVMCI_CHECK_0);
if (nm == NULL) {
// nmethod must have been unloaded
} else {
@@ -2522,7 +2528,7 @@
C2V_VMENTRY_NULL(jobject, asReflectionExecutable, (JNIEnv* env, jobject, jobject jvmci_method))
requireInHotSpot("asReflectionExecutable", JVMCI_CHECK_NULL);
- methodHandle m = JVMCIENV->asMethod(jvmci_method);
+ methodHandle m(THREAD, JVMCIENV->asMethod(jvmci_method));
oop executable;
if (m->is_initializer()) {
if (m->is_static_initializer()) {
@@ -2587,7 +2593,7 @@
}
C2V_VMENTRY_0(jlong, getFailedSpeculationsAddress, (JNIEnv* env, jobject, jobject jvmci_method))
- methodHandle method = JVMCIENV->asMethod(jvmci_method);
+ methodHandle method(THREAD, JVMCIENV->asMethod(jvmci_method));
MethodData* method_data = method->method_data();
if (method_data == NULL) {
ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
--- a/src/hotspot/share/jvmci/jvmciEnv.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciEnv.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -952,7 +952,7 @@
JVMCIObject JVMCIEnv::new_HotSpotNmethod(const methodHandle& method, const char* name, jboolean isDefault, jlong compileId, JVMCI_TRAPS) {
JavaThread* THREAD = JavaThread::current();
- JVMCIObject methodObject = get_jvmci_method(method(), JVMCI_CHECK_(JVMCIObject()));
+ JVMCIObject methodObject = get_jvmci_method(method, JVMCI_CHECK_(JVMCIObject()));
if (is_hotspot()) {
InstanceKlass* ik = InstanceKlass::cast(HotSpotJVMCI::HotSpotNmethod::klass());
--- a/src/hotspot/share/jvmci/jvmciJavaClasses.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciJavaClasses.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -87,7 +87,7 @@
#ifndef PRODUCT
static void check_resolve_method(const char* call_type, Klass* resolved_klass, Symbol* method_name, Symbol* method_signature, TRAPS) {
- methodHandle method;
+ Method* method;
LinkInfo link_info(resolved_klass, method_name, method_signature, NULL, LinkInfo::skip_access_check);
if (strcmp(call_type, "call_static") == 0) {
method = LinkResolver::resolve_static_call_or_null(link_info);
@@ -98,7 +98,7 @@
} else {
fatal("Unknown or unsupported call type: %s", call_type);
}
- if (method.is_null()) {
+ if (method == NULL) {
fatal("Could not resolve %s.%s%s", resolved_klass->external_name(), method_name->as_C_string(), method_signature->as_C_string());
}
}
--- a/src/hotspot/share/jvmci/jvmciRuntime.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciRuntime.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1150,16 +1150,16 @@
// ------------------------------------------------------------------
// Perform an appropriate method lookup based on accessor, holder,
// name, signature, and bytecode.
-methodHandle JVMCIRuntime::lookup_method(InstanceKlass* accessor,
- Klass* holder,
- Symbol* name,
- Symbol* sig,
- Bytecodes::Code bc,
- constantTag tag) {
+Method* JVMCIRuntime::lookup_method(InstanceKlass* accessor,
+ Klass* holder,
+ Symbol* name,
+ Symbol* sig,
+ Bytecodes::Code bc,
+ constantTag tag) {
// Accessibility checks are performed in JVMCIEnv::get_method_by_index_impl().
assert(check_klass_accessibility(accessor, holder), "holder not accessible");
- methodHandle dest_method;
+ Method* dest_method;
LinkInfo link_info(holder, name, sig, accessor, LinkInfo::needs_access_check, tag);
switch (bc) {
case Bytecodes::_invokestatic:
@@ -1186,9 +1186,9 @@
// ------------------------------------------------------------------
-methodHandle JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cpool,
- int index, Bytecodes::Code bc,
- InstanceKlass* accessor) {
+Method* JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cpool,
+ int index, Bytecodes::Code bc,
+ InstanceKlass* accessor) {
if (bc == Bytecodes::_invokedynamic) {
ConstantPoolCacheEntry* cpce = cpool->invokedynamic_cp_cache_entry_at(index);
bool is_resolved = !cpce->is_f1_null();
@@ -1196,7 +1196,7 @@
// Get the invoker Method* from the constant pool.
// (The appendix argument, if any, will be noted in the method's signature.)
Method* adapter = cpce->f1_as_method();
- return methodHandle(adapter);
+ return adapter;
}
return NULL;
@@ -1235,8 +1235,8 @@
if (holder_is_accessible) { // Our declared holder is loaded.
constantTag tag = cpool->tag_ref_at(index);
- methodHandle m = lookup_method(accessor, holder, name_sym, sig_sym, bc, tag);
- if (!m.is_null()) {
+ Method* m = lookup_method(accessor, holder, name_sym, sig_sym, bc, tag);
+ if (m != NULL) {
// We found the method.
return m;
}
@@ -1265,7 +1265,7 @@
// ------------------------------------------------------------------
-methodHandle JVMCIRuntime::get_method_by_index(const constantPoolHandle& cpool,
+Method* JVMCIRuntime::get_method_by_index(const constantPoolHandle& cpool,
int index, Bytecodes::Code bc,
InstanceKlass* accessor) {
ResourceMark rm;
--- a/src/hotspot/share/jvmci/jvmciRuntime.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/jvmci/jvmciRuntime.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -117,18 +117,18 @@
Klass* loading_klass);
static void get_field_by_index_impl(InstanceKlass* loading_klass, fieldDescriptor& fd,
int field_index);
- static methodHandle get_method_by_index_impl(const constantPoolHandle& cpool,
- int method_index, Bytecodes::Code bc,
- InstanceKlass* loading_klass);
+ static Method* get_method_by_index_impl(const constantPoolHandle& cpool,
+ int method_index, Bytecodes::Code bc,
+ InstanceKlass* loading_klass);
// Helper methods
static bool check_klass_accessibility(Klass* accessing_klass, Klass* resolved_klass);
- static methodHandle lookup_method(InstanceKlass* accessor,
- Klass* holder,
- Symbol* name,
- Symbol* sig,
- Bytecodes::Code bc,
- constantTag tag);
+ static Method* lookup_method(InstanceKlass* accessor,
+ Klass* holder,
+ Symbol* name,
+ Symbol* sig,
+ Bytecodes::Code bc,
+ constantTag tag);
public:
JVMCIRuntime() {
@@ -194,9 +194,9 @@
Klass* loading_klass);
static void get_field_by_index(InstanceKlass* loading_klass, fieldDescriptor& fd,
int field_index);
- static methodHandle get_method_by_index(const constantPoolHandle& cpool,
- int method_index, Bytecodes::Code bc,
- InstanceKlass* loading_klass);
+ static Method* get_method_by_index(const constantPoolHandle& cpool,
+ int method_index, Bytecodes::Code bc,
+ InstanceKlass* loading_klass);
// converts the Klass* representing the holder of a method into a
// InstanceKlass*. This is needed since the holder of a method in
--- a/src/hotspot/share/memory/dynamicArchive.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/memory/dynamicArchive.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -806,7 +806,7 @@
ik->set_class_loader_type(ClassLoader::APP_LOADER);
}
- MetaspaceShared::rewrite_nofast_bytecodes_and_calculate_fingerprints(ik);
+ MetaspaceShared::rewrite_nofast_bytecodes_and_calculate_fingerprints(Thread::current(), ik);
ik->remove_unshareable_info();
assert(ik->array_klasses() == NULL, "sanity");
--- a/src/hotspot/share/memory/heapShared.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/memory/heapShared.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -38,7 +38,7 @@
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
#include "oops/compressedOops.inline.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/fieldDescriptor.inline.hpp"
#include "runtime/safepointVerifiers.hpp"
--- a/src/hotspot/share/memory/metaspaceShared.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/memory/metaspaceShared.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -596,7 +596,7 @@
Universe::set_void_mirror(NULL);
}
-static void rewrite_nofast_bytecode(Method* method) {
+static void rewrite_nofast_bytecode(const methodHandle& method) {
BytecodeStream bcs(method);
while (!bcs.is_last_bytecode()) {
Bytecodes::Code opcode = bcs.next();
@@ -620,19 +620,19 @@
// [1] Rewrite all bytecodes as needed, so that the ConstMethod* will not be modified
// at run time by RewriteBytecodes/RewriteFrequentPairs
// [2] Assign a fingerprint, so one doesn't need to be assigned at run-time.
-static void rewrite_nofast_bytecodes_and_calculate_fingerprints() {
+static void rewrite_nofast_bytecodes_and_calculate_fingerprints(Thread* thread) {
for (int i = 0; i < _global_klass_objects->length(); i++) {
Klass* k = _global_klass_objects->at(i);
if (k->is_instance_klass()) {
InstanceKlass* ik = InstanceKlass::cast(k);
- MetaspaceShared::rewrite_nofast_bytecodes_and_calculate_fingerprints(ik);
+ MetaspaceShared::rewrite_nofast_bytecodes_and_calculate_fingerprints(thread, ik);
}
}
}
-void MetaspaceShared::rewrite_nofast_bytecodes_and_calculate_fingerprints(InstanceKlass* ik) {
+void MetaspaceShared::rewrite_nofast_bytecodes_and_calculate_fingerprints(Thread* thread, InstanceKlass* ik) {
for (int i = 0; i < ik->methods()->length(); i++) {
- Method* m = ik->methods()->at(i);
+ methodHandle m(thread, ik->methods()->at(i));
rewrite_nofast_bytecode(m);
Fingerprinter fp(m);
// The side effect of this call sets method's fingerprint field.
@@ -1493,7 +1493,7 @@
// Ensure the ConstMethods won't be modified at run-time
tty->print("Updating ConstMethods ... ");
- rewrite_nofast_bytecodes_and_calculate_fingerprints();
+ rewrite_nofast_bytecodes_and_calculate_fingerprints(THREAD);
tty->print_cr("done. ");
// Remove all references outside the metadata
--- a/src/hotspot/share/memory/metaspaceShared.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/memory/metaspaceShared.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -307,7 +307,7 @@
static void pack_dump_space(DumpRegion* current, DumpRegion* next,
ReservedSpace* rs);
- static void rewrite_nofast_bytecodes_and_calculate_fingerprints(InstanceKlass* ik);
+ static void rewrite_nofast_bytecodes_and_calculate_fingerprints(Thread* thread, InstanceKlass* ik);
#endif
// Allocate a block of memory from the "mc", "ro", or "rw" regions.
--- a/src/hotspot/share/oops/cpCache.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/cpCache.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -401,7 +401,7 @@
return;
}
- const methodHandle adapter = call_info.resolved_method();
+ Method* adapter = call_info.resolved_method();
const Handle appendix = call_info.resolved_appendix();
const bool has_appendix = appendix.not_null();
@@ -419,7 +419,7 @@
invoke_code,
p2i(appendix()),
(has_appendix ? "" : " (unused)"),
- p2i(adapter()));
+ p2i(adapter));
adapter->print();
if (has_appendix) appendix()->print();
}
@@ -451,7 +451,7 @@
resolved_references->obj_at_put(appendix_index, appendix());
}
- release_set_f1(adapter()); // This must be the last one to set (see NOTE above)!
+ release_set_f1(adapter); // This must be the last one to set (see NOTE above)!
// The interpreter assembly code does not check byte_2,
// but it is used by is_resolved, method_if_resolved, etc.
@@ -723,10 +723,12 @@
bool* f2_used = NEW_RESOURCE_ARRAY(bool, length());
memset(f2_used, 0, sizeof(bool) * length());
+ Thread* THREAD = Thread::current();
+
// Find all the slots that we need to preserve f2
for (int i = 0; i < ik->methods()->length(); i++) {
Method* m = ik->methods()->at(i);
- RawBytecodeStream bcs(m);
+ RawBytecodeStream bcs(methodHandle(THREAD, m));
while (!bcs.is_last_bytecode()) {
Bytecodes::Code opcode = bcs.raw_next();
switch (opcode) {
--- a/src/hotspot/share/oops/fieldInfo.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/fieldInfo.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -176,7 +176,7 @@
return (_shorts[low_packed_offset] & FIELDINFO_TAG_MASK) == FIELDINFO_TAG_OFFSET;
}
- Symbol* name(const constantPoolHandle& cp) const {
+ Symbol* name(ConstantPool* cp) const {
int index = name_index();
if (is_internal()) {
return lookup_symbol(index);
@@ -184,7 +184,7 @@
return cp->symbol_at(index);
}
- Symbol* signature(const constantPoolHandle& cp) const {
+ Symbol* signature(ConstantPool* cp) const {
int index = signature_index();
if (is_internal()) {
return lookup_symbol(index);
--- a/src/hotspot/share/oops/fieldStreams.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/fieldStreams.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -79,34 +79,11 @@
return num_fields;
}
- FieldStreamBase(Array<u2>* fields, const constantPoolHandle& constants, int start, int limit) {
- _fields = fields;
- _constants = constants;
- _index = start;
- int num_fields = init_generic_signature_start_slot();
- if (limit < start) {
- _limit = num_fields;
- } else {
- _limit = limit;
- }
- }
+ inline FieldStreamBase(Array<u2>* fields, ConstantPool* constants, int start, int limit);
- FieldStreamBase(Array<u2>* fields, const constantPoolHandle& constants) {
- _fields = fields;
- _constants = constants;
- _index = 0;
- _limit = init_generic_signature_start_slot();
- }
-
+ inline FieldStreamBase(Array<u2>* fields, ConstantPool* constants);
public:
- FieldStreamBase(InstanceKlass* klass) {
- _fields = klass->fields();
- _constants = klass->constants();
- _index = 0;
- _limit = klass->java_fields_count();
- init_generic_signature_start_slot();
- assert(klass == field_holder(), "");
- }
+ inline FieldStreamBase(InstanceKlass* klass);
// accessors
int index() const { return _index; }
@@ -136,11 +113,11 @@
}
Symbol* name() const {
- return field()->name(_constants);
+ return field()->name(_constants());
}
Symbol* signature() const {
- return field()->signature(_constants);
+ return field()->signature(_constants());
}
Symbol* generic_signature() const {
@@ -242,7 +219,7 @@
class AllFieldStream : public FieldStreamBase {
public:
- AllFieldStream(Array<u2>* fields, const constantPoolHandle& constants): FieldStreamBase(fields, constants) {}
+ AllFieldStream(Array<u2>* fields, ConstantPool* constants): FieldStreamBase(fields, constants) {}
AllFieldStream(InstanceKlass* k): FieldStreamBase(k->fields(), k->constants()) {}
};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/oops/fieldStreams.inline.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2019, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_OOPS_FIELDSTREAMS_INLINE_HPP
+#define SHARE_OOPS_FIELDSTREAMS_INLINE_HPP
+
+#include "oops/fieldStreams.hpp"
+#include "runtime/thread.inline.hpp"
+
+FieldStreamBase::FieldStreamBase(Array<u2>* fields, ConstantPool* constants, int start, int limit) : _fields(fields),
+ _constants(constantPoolHandle(Thread::current(), constants)), _index(start) {
+ _index = start;
+ int num_fields = init_generic_signature_start_slot();
+ if (limit < start) {
+ _limit = num_fields;
+ } else {
+ _limit = limit;
+ }
+}
+
+FieldStreamBase::FieldStreamBase(Array<u2>* fields, ConstantPool* constants) : _fields(fields),
+ _constants(constantPoolHandle(Thread::current(), constants)), _index(0) {
+ _limit = init_generic_signature_start_slot();
+}
+
+FieldStreamBase::FieldStreamBase(InstanceKlass* klass) : _fields(klass->fields()),
+ _constants(constantPoolHandle(Thread::current(), klass->constants())), _index(0),
+ _limit(klass->java_fields_count()) {
+ init_generic_signature_start_slot();
+ assert(klass == field_holder(), "");
+}
+
+#endif // SHARE_OOPS_FIELDSTREAMS_INLINE_HPP
--- a/src/hotspot/share/oops/generateOopMap.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/generateOopMap.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1875,7 +1875,7 @@
void GenerateOopMap::do_ldc(int bci) {
- Bytecode_loadconstant ldc(method(), bci);
+ Bytecode_loadconstant ldc(methodHandle(Thread::current(), method()), bci);
ConstantPool* cp = method()->constants();
constantTag tag = cp->tag_at(ldc.pool_index()); // idx is index in resolved_references
BasicType bt = ldc.result_type();
--- a/src/hotspot/share/oops/instanceKlass.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/instanceKlass.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -54,7 +54,7 @@
#include "memory/oopFactory.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/constantPool.hpp"
#include "oops/instanceClassLoaderKlass.hpp"
#include "oops/instanceKlass.inline.hpp"
--- a/src/hotspot/share/oops/klassVtable.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/klassVtable.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -300,7 +300,7 @@
Symbol* signature = target_method()->signature();
assert(super_method->name() == name && super_method->signature() == signature, "vtable entry name/sig mismatch");
#endif
- if (supersuperklass->is_override(super_method, target_loader, target_classname, THREAD)) {
+ if (supersuperklass->is_override(methodHandle(THREAD, super_method), target_loader, target_classname, THREAD)) {
if (log_develop_is_enabled(Trace, vtables)) {
ResourceMark rm(THREAD);
LogTarget(Trace, vtables) lt;
@@ -461,7 +461,7 @@
// private methods are also never overridden
if (!super_method->is_private() &&
(is_default
- || ((super_klass->is_override(super_method, target_loader, target_classname, THREAD))
+ || ((super_klass->is_override(methodHandle(THREAD, super_method), target_loader, target_classname, THREAD))
|| ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
&& ((super_klass = find_transitive_override(super_klass,
target_method, i, target_loader,
@@ -650,7 +650,7 @@
// methods that have less accessibility
if ((!super_method->is_static()) &&
(!super_method->is_private())) {
- if (superk->is_override(super_method, classloader, classname, THREAD)) {
+ if (superk->is_override(methodHandle(THREAD, super_method), classloader, classname, THREAD)) {
return false;
// else keep looking for transitive overrides
}
@@ -1197,7 +1197,7 @@
int ime_count = method_count_for_interface(interf);
for (int i = 0; i < nof_methods; i++) {
Method* m = methods->at(i);
- methodHandle target;
+ Method* target = NULL;
if (m->has_itable_index()) {
// This search must match the runtime resolution, i.e. selection search for invokeinterface
// to correctly enforce loader constraints for interface method inheritance.
@@ -1222,6 +1222,7 @@
// if checkconstraints requested
if (checkconstraints) {
Handle method_holder_loader (THREAD, target->method_holder()->class_loader());
+ InstanceKlass* method_holder = target->method_holder();
if (method_holder_loader() != interface_loader()) {
ResourceMark rm(THREAD);
Symbol* failed_type_symbol =
@@ -1240,12 +1241,12 @@
" different Class objects for the type %s used in the signature (%s; %s)",
interf->class_loader_data()->loader_name_and_id(),
interf->external_name(),
- target()->method_holder()->class_loader_data()->loader_name_and_id(),
- target()->method_holder()->external_kind(),
- target()->method_holder()->external_name(),
+ method_holder->class_loader_data()->loader_name_and_id(),
+ method_holder->external_kind(),
+ method_holder->external_name(),
failed_type_symbol->as_klass_external_name(),
interf->class_in_module_of_loader(false, true),
- target()->method_holder()->class_in_module_of_loader(false, true));
+ method_holder->class_in_module_of_loader(false, true));
THROW_MSG(vmSymbols::java_lang_LinkageError(), ss.as_string());
}
}
@@ -1254,18 +1255,18 @@
// ime may have moved during GC so recalculate address
int ime_num = m->itable_index();
assert(ime_num < ime_count, "oob");
- itableOffsetEntry::method_entry(_klass, method_table_offset)[ime_num].initialize(target());
+ itableOffsetEntry::method_entry(_klass, method_table_offset)[ime_num].initialize(target);
if (log_develop_is_enabled(Trace, itables)) {
ResourceMark rm(THREAD);
- if (target() != NULL) {
+ if (target != NULL) {
LogTarget(Trace, itables) lt;
LogStream ls(lt);
- char* sig = target()->name_and_sig_as_C_string();
+ char* sig = target->name_and_sig_as_C_string();
ls.print("interface: %s, ime_num: %d, target: %s, method_holder: %s ",
interf->internal_name(), ime_num, sig,
- target()->method_holder()->internal_name());
+ target->method_holder()->internal_name());
ls.print("target_method flags: ");
- target()->print_linkage_flags(&ls);
+ target->print_linkage_flags(&ls);
ls.cr();
}
}
--- a/src/hotspot/share/oops/method.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/method.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -546,7 +546,7 @@
return NULL;
}
- methodHandle mh(m);
+ methodHandle mh(THREAD, m);
MethodCounters* counters = MethodCounters::allocate(mh, THREAD);
if (HAS_PENDING_EXCEPTION) {
CompileBroker::log_metaspace_failure();
@@ -628,7 +628,7 @@
bool Method::compute_has_loops_flag() {
- BytecodeStream bcs(this);
+ BytecodeStream bcs(methodHandle(Thread::current(), this));
Bytecodes::Code bc;
while ((bc = bcs.next()) >= 0) {
@@ -986,7 +986,7 @@
set_not_c2_compilable();
}
CompilationPolicy::policy()->disable_compilation(this);
- assert(!CompilationPolicy::can_be_compiled(this, comp_level), "sanity check");
+ assert(!CompilationPolicy::can_be_compiled(methodHandle(Thread::current(), this), comp_level), "sanity check");
}
bool Method::is_not_osr_compilable(int comp_level) const {
@@ -1013,7 +1013,7 @@
set_not_c2_osr_compilable();
}
CompilationPolicy::policy()->disable_compilation(this);
- assert(!CompilationPolicy::can_be_osr_compiled(this, comp_level), "sanity check");
+ assert(!CompilationPolicy::can_be_osr_compiled(methodHandle(Thread::current(), this), comp_level), "sanity check");
}
// Revert to using the interpreter and clear out the nmethod
@@ -1058,7 +1058,7 @@
Arguments::assert_is_dumping_archive();
// Set the values to what they should be at run time. Note that
// this Method can no longer be executed during dump time.
- _i2i_entry = Interpreter::entry_for_cds_method(this);
+ _i2i_entry = Interpreter::entry_for_cds_method(methodHandle(Thread::current(), this));
_from_interpreted_entry = _i2i_entry;
if (DynamicDumpSharedSpaces) {
@@ -1570,14 +1570,14 @@
if (m->has_stackmap_table()) {
int code_attribute_length = m->stackmap_data()->length();
Array<u1>* stackmap_data =
- MetadataFactory::new_array<u1>(loader_data, code_attribute_length, 0, CHECK_NULL);
+ MetadataFactory::new_array<u1>(loader_data, code_attribute_length, 0, CHECK_(methodHandle()));
memcpy((void*)stackmap_data->adr_at(0),
(void*)m->stackmap_data()->adr_at(0), code_attribute_length);
newm->set_stackmap_data(stackmap_data);
}
// copy annotations over to new method
- newcm->copy_annotations_from(loader_data, cm, CHECK_NULL);
+ newcm->copy_annotations_from(loader_data, cm, CHECK_(methodHandle()));
return newm;
}
@@ -2218,6 +2218,11 @@
}
}
+jmethodID Method::jmethod_id() {
+ methodHandle mh(Thread::current(), this);
+ return method_holder()->get_jmethod_id(mh);
+}
+
// Mark a jmethodID as free. This is called when there is a data race in
// InstanceKlass while creating the jmethodID cache.
void Method::destroy_jmethod_id(ClassLoaderData* loader_data, jmethodID m) {
--- a/src/hotspot/share/oops/method.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/method.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -856,7 +856,7 @@
static void print_jmethod_ids(const ClassLoaderData* loader_data, outputStream* out) PRODUCT_RETURN;
// Get this method's jmethodID -- allocate if it doesn't exist
- jmethodID jmethod_id() { return method_holder()->get_jmethod_id(this); }
+ jmethodID jmethod_id();
// Lookup the jmethodID for this method. Return NULL if not found.
// NOTE that this function can be called from a signal handler
--- a/src/hotspot/share/oops/methodData.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/oops/methodData.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -668,7 +668,7 @@
}
int ParametersTypeData::compute_cell_count(Method* m) {
- if (!MethodData::profile_parameters_for_method(m)) {
+ if (!MethodData::profile_parameters_for_method(methodHandle(Thread::current(), m))) {
return 0;
}
int max = TypeProfileParmsLimit == -1 ? INT_MAX : TypeProfileParmsLimit;
@@ -709,7 +709,7 @@
int size = MethodData::compute_allocation_size_in_words(method);
return new (loader_data, size, MetaspaceObj::MethodDataType, THREAD)
- MethodData(method(), size, THREAD);
+ MethodData(method, size, THREAD);
}
int MethodData::bytecode_cell_count(Bytecodes::Code code) {
@@ -1220,8 +1220,9 @@
}
void MethodData::initialize() {
+ Thread* thread = Thread::current();
NoSafepointVerifier no_safepoint; // init function atomic wrt GC
- ResourceMark rm;
+ ResourceMark rm(thread);
init();
set_creation_mileage(mileage_of(method()));
@@ -1231,7 +1232,7 @@
int data_size = 0;
int empty_bc_count = 0; // number of bytecodes lacking data
_data[0] = 0; // apparently not set below.
- BytecodeStream stream(method());
+ BytecodeStream stream(methodHandle(thread, method()));
Bytecodes::Code c;
bool needs_speculative_traps = false;
while ((c = stream.next()) >= 0) {
@@ -1284,7 +1285,7 @@
post_initialize(&stream);
- assert(object_size == compute_allocation_size_in_bytes(methodHandle(_method)), "MethodData: computed size != initialized size");
+ assert(object_size == compute_allocation_size_in_bytes(methodHandle(thread, _method)), "MethodData: computed size != initialized size");
set_size(object_size);
}
@@ -1296,7 +1297,8 @@
// Set per-method invoke- and backedge mask.
double scale = 1.0;
- CompilerOracle::has_option_value(_method, "CompileThresholdScaling", scale);
+ methodHandle mh(Thread::current(), _method);
+ CompilerOracle::has_option_value(mh, "CompileThresholdScaling", scale);
_invoke_mask = right_n_bits(CompilerConfig::scaled_freq_log(Tier0InvokeNotifyFreqLog, scale)) << InvocationCounter::count_shift;
_backedge_mask = right_n_bits(CompilerConfig::scaled_freq_log(Tier0BackedgeNotifyFreqLog, scale)) << InvocationCounter::count_shift;
@@ -1313,8 +1315,8 @@
#if INCLUDE_RTM_OPT
_rtm_state = NoRTM; // No RTM lock eliding by default
if (UseRTMLocking &&
- !CompilerOracle::has_option_string(_method, "NoRTMLockEliding")) {
- if (CompilerOracle::has_option_string(_method, "UseRTMLockEliding") || !UseRTMDeopt) {
+ !CompilerOracle::has_option_string(mh, "NoRTMLockEliding")) {
+ if (CompilerOracle::has_option_string(mh, "UseRTMLockEliding") || !UseRTMDeopt) {
// Generate RTM lock eliding code without abort ratio calculation code.
_rtm_state = UseRTM;
} else if (UseRTMDeopt) {
--- a/src/hotspot/share/prims/jvm.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/jvm.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -48,7 +48,7 @@
#include "memory/universe.hpp"
#include "oops/access.inline.hpp"
#include "oops/constantPool.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/method.hpp"
#include "oops/objArrayKlass.hpp"
@@ -1615,7 +1615,8 @@
for (int i = 0; i < num_params; i++) {
MethodParametersElement* params = mh->method_parameters_start();
int index = params[i].name_cp_index;
- bounds_check(mh->constants(), index, CHECK_NULL);
+ constantPoolHandle cp(THREAD, mh->constants());
+ bounds_check(cp, index, CHECK_NULL);
if (0 != index && !mh->constants()->tag_at(index).is_utf8()) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
--- a/src/hotspot/share/prims/jvmtiClassFileReconstituter.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/jvmtiClassFileReconstituter.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2019, 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
@@ -26,7 +26,7 @@
#include "classfile/symbolTable.hpp"
#include "interpreter/bytecodeStream.hpp"
#include "memory/universe.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "prims/jvmtiClassFileReconstituter.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/signature.hpp"
--- a/src/hotspot/share/prims/jvmtiCodeBlobEvents.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/jvmtiCodeBlobEvents.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -253,7 +253,7 @@
// Generate line numbers using PcDesc and ScopeDesc info
- methodHandle mh(nm->method());
+ methodHandle mh(Thread::current(), nm->method());
if (!mh->is_native()) {
PcDesc *pcd;
--- a/src/hotspot/share/prims/jvmtiEnv.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/jvmtiEnv.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -3152,7 +3152,7 @@
NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID);
HandleMark hm;
- methodHandle method(method_oop);
+ methodHandle method(Thread::current(), method_oop);
jint size = (jint)method->code_size();
jvmtiError err = allocate(size, bytecodes_ptr);
if (err != JVMTI_ERROR_NONE) {
--- a/src/hotspot/share/prims/jvmtiRedefineClasses.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/jvmtiRedefineClasses.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -41,7 +41,7 @@
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
#include "oops/constantPool.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/klassVtable.hpp"
#include "oops/oop.inline.hpp"
#include "prims/jvmtiImpl.hpp"
@@ -3492,12 +3492,11 @@
// cached references to old methods so it doesn't need to be
// updated. We can simply start with the previous version(s) in
// that case.
- constantPoolHandle other_cp;
ConstantPoolCache* cp_cache;
if (!ik->is_being_redefined()) {
// this klass' constant pool cache may need adjustment
- other_cp = constantPoolHandle(ik->constants());
+ ConstantPool* other_cp = ik->constants();
cp_cache = other_cp->cache();
if (cp_cache != NULL) {
cp_cache->adjust_method_entries(&trace_name_printed);
@@ -3516,13 +3515,13 @@
}
}
-void VM_RedefineClasses::update_jmethod_ids() {
+void VM_RedefineClasses::update_jmethod_ids(Thread* thread) {
for (int j = 0; j < _matching_methods_length; ++j) {
Method* old_method = _matching_old_methods[j];
jmethodID jmid = old_method->find_jmethod_id_or_null();
if (jmid != NULL) {
// There is a jmethodID, change it to point to the new method
- methodHandle new_method_h(_matching_new_methods[j]);
+ methodHandle new_method_h(thread, _matching_new_methods[j]);
Method::change_method_associated_with_jmethod_id(jmid, new_method_h());
assert(Method::resolve_jmethod_id(jmid) == _matching_new_methods[j],
"should be replaced");
@@ -3961,7 +3960,7 @@
_new_methods = scratch_class->methods();
_the_class = the_class;
compute_added_deleted_matching_methods();
- update_jmethod_ids();
+ update_jmethod_ids(THREAD);
_any_class_has_resolved_methods = the_class->has_resolved_methods() || _any_class_has_resolved_methods;
--- a/src/hotspot/share/prims/jvmtiRedefineClasses.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/jvmtiRedefineClasses.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -407,7 +407,7 @@
void compute_added_deleted_matching_methods();
// Change jmethodIDs to point to the new methods
- void update_jmethod_ids();
+ void update_jmethod_ids(Thread* thread);
// In addition to marking methods as old and/or obsolete, this routine
// counts the number of methods that are EMCP (Equivalent Module Constant Pool).
--- a/src/hotspot/share/prims/methodComparator.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/methodComparator.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -52,8 +52,9 @@
_old_cp = old_method->constants();
_new_cp = new_method->constants();
- BytecodeStream s_old(old_method);
- BytecodeStream s_new(new_method);
+ Thread* THREAD = Thread::current();
+ BytecodeStream s_old(methodHandle(THREAD, old_method));
+ BytecodeStream s_new(methodHandle(THREAD, new_method));
_s_old = &s_old;
_s_new = &s_new;
Bytecodes::Code c_old, c_new;
--- a/src/hotspot/share/prims/methodHandles.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/methodHandles.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -222,7 +222,7 @@
oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
assert(info.resolved_appendix().is_null(), "only normal methods here");
- methodHandle m = info.resolved_method();
+ methodHandle m(Thread::current(), info.resolved_method());
assert(m.not_null(), "null method handle");
InstanceKlass* m_klass = m->method_holder();
assert(m_klass != NULL, "null holder for method handle");
--- a/src/hotspot/share/prims/nativeLookup.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/nativeLookup.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -380,7 +380,7 @@
if (wrapper_method != NULL && !wrapper_method->is_native()) {
// we found a wrapper method, use its native entry
method->set_is_prefixed_native();
- return lookup_entry(wrapper_method, in_base_library, THREAD);
+ return lookup_entry(methodHandle(THREAD, wrapper_method), in_base_library, THREAD);
}
}
}
--- a/src/hotspot/share/prims/stackwalk.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/stackwalk.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -156,7 +156,7 @@
method->external_name()));
}
// fill in StackFrameInfo and initialize MemberName
- stream.fill_frame(index, frames_array, method, CHECK_0);
+ stream.fill_frame(index, frames_array, methodHandle(THREAD, method), CHECK_0);
if (++frames_decoded >= max_nframes) break;
}
return frames_decoded;
--- a/src/hotspot/share/prims/unsafe.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/prims/unsafe.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -32,7 +32,7 @@
#include "memory/allocation.inline.hpp"
#include "memory/resourceArea.hpp"
#include "oops/access.inline.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/objArrayOop.inline.hpp"
#include "oops/oop.inline.hpp"
#include "oops/typeArrayOop.inline.hpp"
--- a/src/hotspot/share/runtime/deoptimization.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/deoptimization.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -44,7 +44,7 @@
#include "oops/objArrayKlass.hpp"
#include "oops/objArrayOop.inline.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "oops/typeArrayOop.inline.hpp"
#include "oops/verifyOopClosure.hpp"
#include "prims/jvmtiThreadState.hpp"
@@ -428,7 +428,7 @@
// frame.
bool caller_was_method_handle = false;
if (deopt_sender.is_interpreted_frame()) {
- methodHandle method = deopt_sender.interpreter_frame_method();
+ methodHandle method(thread, deopt_sender.interpreter_frame_method());
Bytecode_invoke cur = Bytecode_invoke_check(method, deopt_sender.interpreter_frame_bci());
if (cur.is_invokedynamic() || cur.is_invokehandle()) {
// Method handle invokes may involve fairly arbitrary chains of
@@ -1536,7 +1536,7 @@
assert(caller_frame.cb()->as_compiled_method_or_null() == cm, "expect top frame compiled method");
Deoptimization::deoptimize(thread, caller_frame, ®_map, Deoptimization::Reason_not_compiled_exception_handler);
- MethodData* trap_mdo = get_method_data(thread, cm->method(), true);
+ MethodData* trap_mdo = get_method_data(thread, methodHandle(thread, cm->method()), true);
if (trap_mdo != NULL) {
trap_mdo->inc_trap_count(Deoptimization::Reason_not_compiled_exception_handler);
}
@@ -1701,7 +1701,7 @@
);
}
- methodHandle trap_method = trap_scope->method();
+ methodHandle trap_method(THREAD, trap_scope->method());
int trap_bci = trap_scope->bci();
#if INCLUDE_JVMCI
jlong speculation = thread->pending_failed_speculation();
@@ -1732,7 +1732,7 @@
methodHandle profiled_method;
#if INCLUDE_JVMCI
if (nm->is_compiled_by_jvmci()) {
- profiled_method = nm->method();
+ profiled_method = methodHandle(THREAD, nm->method());
} else {
profiled_method = trap_method;
}
--- a/src/hotspot/share/runtime/fieldDescriptor.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/fieldDescriptor.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -30,7 +30,7 @@
#include "oops/constantPool.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/fieldStreams.hpp"
+#include "oops/fieldStreams.inline.hpp"
#include "runtime/fieldDescriptor.inline.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/signature.hpp"
--- a/src/hotspot/share/runtime/fieldDescriptor.inline.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/fieldDescriptor.inline.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -31,11 +31,11 @@
// must be put in this file, as they require runtime/handles.inline.hpp.
inline Symbol* fieldDescriptor::name() const {
- return field()->name(_cp);
+ return field()->name(_cp());
}
inline Symbol* fieldDescriptor::signature() const {
- return field()->signature(_cp);
+ return field()->signature(_cp());
}
inline InstanceKlass* fieldDescriptor::field_holder() const {
--- a/src/hotspot/share/runtime/frame.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/frame.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1164,7 +1164,7 @@
// Compute the actual expression stack size
InterpreterOopMap mask;
- OopMapCache::compute_one_oop_map(m, bci, &mask);
+ OopMapCache::compute_one_oop_map(methodHandle(Thread::current(), m), bci, &mask);
intptr_t* tos = NULL;
// Report each stack element and mark as owned by this frame
for (int e = 0; e < mask.expression_stack_size(); e++) {
--- a/src/hotspot/share/runtime/handles.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/handles.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -143,7 +143,6 @@
public: \
/* Constructors */ \
name##Handle () : _value(NULL), _thread(NULL) {} \
- name##Handle (type* obj); \
name##Handle (Thread* thread, type* obj); \
\
name##Handle (const name##Handle &h); \
--- a/src/hotspot/share/runtime/handles.inline.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/handles.inline.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -55,14 +55,6 @@
// Constructor for metadata handles
#define DEF_METADATA_HANDLE_FN(name, type) \
-inline name##Handle::name##Handle(type* obj) : _value(obj), _thread(NULL) { \
- if (obj != NULL) { \
- assert(((Metadata*)obj)->is_valid(), "obj is valid"); \
- _thread = Thread::current(); \
- assert (_thread->is_in_stack((address)this), "not on stack?"); \
- _thread->metadata_handles()->push((Metadata*)obj); \
- } \
-} \
inline name##Handle::name##Handle(Thread* thread, type* obj) : _value(obj), _thread(thread) { \
if (obj != NULL) { \
assert(((Metadata*)obj)->is_valid(), "obj is valid"); \
--- a/src/hotspot/share/runtime/javaCalls.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/javaCalls.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -186,7 +186,7 @@
LinkInfo link_info(spec_klass, name, signature);
LinkResolver::resolve_virtual_call(
callinfo, receiver, recvrKlass, link_info, true, CHECK);
- methodHandle method = callinfo.selected_method();
+ methodHandle method(THREAD, callinfo.selected_method());
assert(method.not_null(), "should have thrown exception");
// Invoke the method
@@ -222,7 +222,7 @@
CallInfo callinfo;
LinkInfo link_info(klass, name, signature);
LinkResolver::resolve_special_call(callinfo, args->receiver(), link_info, CHECK);
- methodHandle method = callinfo.selected_method();
+ methodHandle method(THREAD, callinfo.selected_method());
assert(method.not_null(), "should have thrown exception");
// Invoke the method
@@ -257,7 +257,7 @@
CallInfo callinfo;
LinkInfo link_info(klass, name, signature);
LinkResolver::resolve_static_call(callinfo, link_info, true, CHECK);
- methodHandle method = callinfo.selected_method();
+ methodHandle method(THREAD, callinfo.selected_method());
assert(method.not_null(), "should have thrown exception");
// Invoke the method
--- a/src/hotspot/share/runtime/reflection.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/reflection.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -978,7 +978,7 @@
LinkInfo(klass, name, signature),
true,
CHECK_(methodHandle()));
- return info.selected_method();
+ return methodHandle(THREAD, info.selected_method());
}
// Conversion
--- a/src/hotspot/share/runtime/sharedRuntime.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/sharedRuntime.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1022,7 +1022,7 @@
return find_callee_info_helper(thread, vfst, bc, callinfo, THREAD);
}
-methodHandle SharedRuntime::extract_attached_method(vframeStream& vfst) {
+Method* SharedRuntime::extract_attached_method(vframeStream& vfst) {
CompiledMethod* caller = vfst.nm();
nmethodLocker caller_lock(caller);
@@ -1055,9 +1055,9 @@
int bytecode_index = bytecode.index();
bc = bytecode.invoke_code();
- methodHandle attached_method = extract_attached_method(vfst);
+ methodHandle attached_method(THREAD, extract_attached_method(vfst));
if (attached_method.not_null()) {
- methodHandle callee = bytecode.static_target(CHECK_NH);
+ Method* callee = bytecode.static_target(CHECK_NH);
vmIntrinsics::ID id = callee->intrinsic_id();
// When VM replaces MH.invokeBasic/linkTo* call with a direct/virtual call,
// it attaches statically resolved method to the call site.
@@ -1105,8 +1105,8 @@
frame callerFrame = stubFrame.sender(®_map2);
if (attached_method.is_null()) {
- methodHandle callee = bytecode.static_target(CHECK_NH);
- if (callee.is_null()) {
+ Method* callee = bytecode.static_target(CHECK_NH);
+ if (callee == NULL) {
THROW_(vmSymbols::java_lang_NoSuchMethodException(), nullHandle);
}
}
@@ -1144,7 +1144,6 @@
rk = constants->klass_ref_at(bytecode_index, CHECK_NH);
}
Klass* static_receiver_klass = rk;
- methodHandle callee = callinfo.selected_method();
assert(receiver_klass->is_subtype_of(static_receiver_klass),
"actual receiver must be subclass of static receiver klass");
if (receiver_klass->is_instance_klass()) {
@@ -1182,7 +1181,7 @@
Bytecodes::Code bc;
CallInfo callinfo;
find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(methodHandle()));
- callee_method = callinfo.selected_method();
+ callee_method = methodHandle(THREAD, callinfo.selected_method());
}
assert(callee_method()->is_method(), "must be");
return callee_method;
@@ -1325,7 +1324,7 @@
Bytecodes::Code invoke_code = Bytecodes::_illegal;
Handle receiver = find_callee_info(thread, invoke_code,
call_info, CHECK_(methodHandle()));
- methodHandle callee_method = call_info.selected_method();
+ methodHandle callee_method(THREAD, call_info.selected_method());
assert((!is_virtual && invoke_code == Bytecodes::_invokestatic ) ||
(!is_virtual && invoke_code == Bytecodes::_invokespecial) ||
@@ -1479,7 +1478,7 @@
// Get the called method from the invoke bytecode.
vframeStream vfst(thread, true);
assert(!vfst.at_end(), "Java frame must exist");
- methodHandle caller(vfst.method());
+ methodHandle caller(thread, vfst.method());
Bytecode_invoke invoke(caller, vfst.bci());
DEBUG_ONLY( invoke.verify(); )
@@ -1493,7 +1492,7 @@
// Install exception and return forward entry.
address res = StubRoutines::throw_AbstractMethodError_entry();
JRT_BLOCK
- methodHandle callee = invoke.static_target(thread);
+ methodHandle callee(thread, invoke.static_target(thread));
if (!callee.is_null()) {
oop recv = callerFrame.retrieve_receiver(®_map);
Klass *recv_klass = (recv != NULL) ? recv->klass() : NULL;
@@ -1657,7 +1656,7 @@
return callee_method;
}
- methodHandle callee_method = call_info.selected_method();
+ methodHandle callee_method(thread, call_info.selected_method());
#ifndef PRODUCT
Atomic::inc(&_ic_miss_ctr);
--- a/src/hotspot/share/runtime/sharedRuntime.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/sharedRuntime.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -351,7 +351,7 @@
Bytecodes::Code& bc,
CallInfo& callinfo, TRAPS);
- static methodHandle extract_attached_method(vframeStream& vfst);
+ static Method* extract_attached_method(vframeStream& vfst);
static address clean_virtual_call_entry();
static address clean_opt_virtual_call_entry();
--- a/src/hotspot/share/runtime/vframeArray.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/runtime/vframeArray.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2019, 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
@@ -589,8 +589,8 @@
if (index == 0) {
callee_parameters = callee_locals = 0;
} else {
- methodHandle caller = elem->method();
- methodHandle callee = element(index - 1)->method();
+ methodHandle caller(THREAD, elem->method());
+ methodHandle callee(THREAD, element(index - 1)->method());
Bytecode_invoke inv(caller, elem->bci());
// invokedynamic instructions don't have a class but obviously don't have a MemberName appendix.
// NOTE: Use machinery here that avoids resolving of any kind.
--- a/src/hotspot/share/utilities/exceptions.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/utilities/exceptions.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -229,7 +229,7 @@
exception = Handle(THREAD, e); // fill_in_stack trace does gc
assert(k->is_initialized(), "need to increase java_thread_min_stack_allowed calculation");
if (StackTraceInThrowable) {
- java_lang_Throwable::fill_in_stack_trace(exception, method());
+ java_lang_Throwable::fill_in_stack_trace(exception, method);
}
// Increment counter for hs_err file reporting
Atomic::inc(&Exceptions::_stack_overflow_errors);
--- a/src/hotspot/share/utilities/xmlstream.cpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/utilities/xmlstream.cpp Wed Nov 13 08:23:23 2019 -0500
@@ -385,9 +385,9 @@
// ------------------------------------------------------------------
// Output a method attribute, in the form " method='pkg/cls name sig'".
// This is used only when there is no ciMethod available.
-void xmlStream::method(const methodHandle& method) {
+void xmlStream::method(Method* method) {
assert_if_no_error(inside_attrs(), "printing attributes");
- if (method.is_null()) return;
+ if (method == NULL) return;
print_raw(" method='");
method_text(method);
print("' bytes='%d'", method->code_size());
@@ -413,10 +413,10 @@
}
}
-void xmlStream::method_text(const methodHandle& method) {
+void xmlStream::method_text(Method* method) {
ResourceMark rm;
assert_if_no_error(inside_attrs(), "printing attributes");
- if (method.is_null()) return;
+ if (method == NULL) return;
text()->print("%s", method->method_holder()->external_name());
print_raw(" "); // " " is easier for tools to parse than "::"
method->name()->print_symbol_on(text());
--- a/src/hotspot/share/utilities/xmlstream.hpp Wed Nov 13 11:27:50 2019 +0000
+++ b/src/hotspot/share/utilities/xmlstream.hpp Wed Nov 13 08:23:23 2019 -0500
@@ -137,14 +137,14 @@
// commonly used XML attributes
void stamp(); // stamp='1.234'
- void method(const methodHandle& m); // method='k n s' ...
+ void method(Method* m); // method='k n s' ...
void klass(Klass* k); // klass='name'
void name(const Symbol* s); // name='name'
void object(const char* attr, Metadata* val);
void object(const char* attr, Handle val);
// print the text alone (sans ''):
- void method_text(const methodHandle& m);
+ void method_text(Method* m);
void klass_text(Klass* k); // klass='name'
void name_text(const Symbol* s); // name='name'
void object_text(Metadata* x);