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

8233913: Remove implicit conversion from Method* to methodHandle

Browse Source 
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
This commit is contained in:
Coleen Phillimore 2019-11-13 08:23:23 -05:00
parent 25d3cf9216
commit ed21b56269
82 changed files with 610 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/hotspot/os/windows/os_windows.cpp
View File

@ -5688,7 +5688,7 @@ static void call_wrapper_dummy() {}
// 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() {

5
src/hotspot/share/aot/aotCompiledMethod.cpp
View File

@ -160,8 +160,6 @@ void AOTCompiledMethod::do_unloading(bool unloading_occurred) {
}
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_not_entrant_helper(int new_state) {
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);

4
src/hotspot/share/c1/c1_Runtime1.cpp
View File

@ -1422,7 +1422,7 @@ JRT_ENTRY(void, Runtime1::predicate_failed_trap(JavaThread* thread))
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 @@ JRT_ENTRY(void, Runtime1::predicate_failed_trap(JavaThread* thread))
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()));

4
src/hotspot/share/ci/ciEnv.cpp
View File

@ -760,7 +760,7 @@ Method* ciEnv::lookup_method(ciInstanceKlass* accessor,
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 @@ Method* ciEnv::lookup_method(ciInstanceKlass* accessor,
default: ShouldNotReachHere();
}
return dest_method();
return dest_method;
}

4
src/hotspot/share/ci/ciExceptionHandler.cpp
View File

@ -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 @@ ciInstanceKlass* ciExceptionHandler::catch_klass() {
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,

2
src/hotspot/share/ci/ciField.cpp
View File

@ -391,7 +391,7 @@ bool ciField::will_link(ciMethod* accessing_method,
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));

2
src/hotspot/share/ci/ciInstanceKlass.cpp
View File

@ -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"

67
src/hotspot/share/ci/ciMethod.cpp
View File

@ -72,25 +72,25 @@ ciMethod::ciMethod(const methodHandle& h_m, ciInstanceKlass* holder) :
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 @@ ciMethod::ciMethod(const methodHandle& h_m, ciInstanceKlass* holder) :
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 @@ ciMethod::ciMethod(const methodHandle& h_m, ciInstanceKlass* holder) :
// 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 @@ MethodLivenessResult ciMethod::liveness_at_bci(int bci) {
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 @@ ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,
{
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 @@ ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, boo
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 @@ ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, boo
}
}
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 ciMethod::ensure_method_data() {
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 @@ bool ciMethod::check_call(int refinfo_index, bool is_static) const {
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;

4
src/hotspot/share/ci/ciReplay.cpp
View File

@ -597,7 +597,7 @@ class CompileReplay : public StackObj {
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 @@ class CompileReplay : public StackObj {
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);
}
}

16
src/hotspot/share/ci/ciStreams.cpp
View File

@ -186,7 +186,7 @@ int ciBytecodeStream::get_klass_index() const {
// 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 ciBytecodeStream::get_constant_pool_index() const {
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 @@ ciConstant ciBytecodeStream::get_constant() {
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 @@ ciField* ciBytecodeStream::get_field(bool& will_link) {
// 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 @@ ciMethod* ciBytecodeStream::get_method(bool& will_link, ciSignature* *declared_s
// 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 @@ bool ciBytecodeStream::has_appendix() {
// 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 @@ ciObject* ciBytecodeStream::get_appendix() {
// 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 @@ bool ciBytecodeStream::has_local_signature() {
// 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)

3
src/hotspot/share/classfile/bytecodeAssembler.cpp
View File

@ -54,7 +54,8 @@ ConstantPool* BytecodeConstantPool::create_constant_pool(TRAPS) const {
_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()) {

10
src/hotspot/share/classfile/classFileParser.cpp
View File

@ -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 @@ void ClassFileParser::parse_constant_pool_entries(const ClassFileStream* const s
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 @@ void ClassFileParser::parse_constant_pool_entries(const ClassFileStream* const s
// 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 @@ Method* ClassFileParser::parse_method(const ClassFileStream* const cfs,
}
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 @@ static unsigned int compute_oop_map_count(const InstanceKlass* super,
#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,

17
src/hotspot/share/classfile/javaClasses.cpp
View File

@ -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 @@ static void print_stack_element_to_stream(outputStream* st, Handle mirror, int m
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 @@ void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHand
// 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 @@ void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHand
}
}
#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 @@ void java_lang_StackTraceElement::fill_in(Handle element,
}
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 @@ void java_lang_StackFrameInfo::to_stack_trace_element(Handle stackFrame, Handle
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) \

4
src/hotspot/share/classfile/javaClasses.hpp
View File

@ -561,7 +561,7 @@ class java_lang_Throwable: AllStatic {
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 @@ class Backtrace: AllStatic {
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

2
src/hotspot/share/classfile/javaClasses.inline.hpp
View File

@ -264,7 +264,7 @@ inline int Backtrace::cpref_at(unsigned int merged) {
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

63
src/hotspot/share/classfile/systemDictionary.cpp
View File

@ -2338,9 +2338,9 @@ Symbol* SystemDictionary::check_signature_loaders(Symbol* signature,
}
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 @@ methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid
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 @@ methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid
}
// 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 @@ static methodHandle unpack_method_and_appendix(Handle mname,
// 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 @@ methodHandle SystemDictionary::find_method_handle_invoker(Klass* klass,
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 @@ void SystemDictionary::invoke_bootstrap_method(BootstrapInfo& bootstrap_specifie
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);
}

18
src/hotspot/share/classfile/systemDictionary.hpp
View File

@ -464,17 +464,17 @@ public:
// 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.

5
src/hotspot/share/classfile/vmSymbols.cpp
View File

@ -1069,19 +1069,18 @@ void vmIntrinsics::verify_method(ID actual_id, Method* m) {
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();
}
}

2
src/hotspot/share/code/compiledIC.cpp
View File

@ -287,7 +287,7 @@ bool CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecod
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));
}

2
src/hotspot/share/code/compiledMethod.cpp
View File

@ -355,7 +355,7 @@ void CompiledMethod::preserve_callee_argument_oops(frame fr, const RegisterMap *
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();

24
src/hotspot/share/code/nmethod.cpp
View File

@ -964,15 +964,16 @@ void nmethod::print_nmethod(bool printmethod) {
#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 @@ bool nmethod::make_not_entrant_or_zombie(int state) {
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 @@ void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bo
}
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 @@ void nmethod::print_code_comment_on(outputStream* st, int column, address begin,
}
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 @@ void nmethod::print_code_comment_on(outputStream* st, int column, address begin,
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 @@ void nmethod::print_code_comment_on(outputStream* st, int column, address begin,
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 @@ public:
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;
}
}

5
src/hotspot/share/compiler/compileBroker.cpp
View File

@ -465,8 +465,9 @@ CompileTask* CompileQueue::get() {
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);
}

13
src/hotspot/share/compiler/compileTask.cpp
View File

@ -340,7 +340,7 @@ void CompileTask::log_task(xmlStream* log) {
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 @@ void CompileTask::log_task(xmlStream* log) {
// ------------------------------------------------------------------
// 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);

94
src/hotspot/share/compiler/tieredThresholdPolicy.cpp
View File

@ -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::call_predicate_helper(Method* method, CompLevel cur_
}
}
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 @@ bool TieredThresholdPolicy::is_trivial(Method* method) {
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 @@ CompLevel TieredThresholdPolicy::comp_level(Method* method) {
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 @@ void TieredThresholdPolicy::print_counters(const char* prefix, const methodHandl
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 @@ void TieredThresholdPolicy::print_event(EventType type, const methodHandle& mh,
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 @@ void TieredThresholdPolicy::print_event(EventType type, const methodHandle& mh,
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 @@ CompileTask* TieredThresholdPolicy::select_task(CompileQueue* compile_queue) {
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 @@ CompileTask* TieredThresholdPolicy::select_task(CompileQueue* compile_queue) {
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 @@ nmethod* TieredThresholdPolicy::event(const methodHandle& method, const methodHa
}
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 @@ void TieredThresholdPolicy::compile(const methodHandle& mh, int bci, CompLevel l
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 @@ void TieredThresholdPolicy::compile(const methodHandle& mh, int bci, CompLevel l
}
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 @@ bool TieredThresholdPolicy::compare_methods(Method* x, Method* y) {
}
// 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 @@ double TieredThresholdPolicy::threshold_scale(CompLevel level, int feedback_k) {
// 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 @@ bool TieredThresholdPolicy::loop_predicate(int i, int b, CompLevel cur_level, Me
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 @@ bool TieredThresholdPolicy::call_predicate(int i, int b, CompLevel cur_level, Me
// 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 @@ bool TieredThresholdPolicy::is_mature(Method* method) {
// 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 @@ void TieredThresholdPolicy::create_mdo(const methodHandle& mh, JavaThread* THREA
*/
// 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 @@ CompLevel TieredThresholdPolicy::common(Predicate p, Method* method, CompLevel c
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 @@ CompLevel TieredThresholdPolicy::common(Predicate p, Method* method, CompLevel c
}
// 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 @@ CompLevel TieredThresholdPolicy::call_event(Method* method, CompLevel cur_level,
}
// 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 @@ bool TieredThresholdPolicy::maybe_switch_to_aot(const methodHandle& mh, CompLeve
// 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 @@ void TieredThresholdPolicy::method_invocation_event(const methodHandle& mh, cons
// 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 @@ void TieredThresholdPolicy::method_back_branch_event(const methodHandle& mh, con
// 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 @@ void TieredThresholdPolicy::method_back_branch_event(const methodHandle& mh, con
}
} 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);

26
src/hotspot/share/compiler/tieredThresholdPolicy.hpp
View File

@ -173,19 +173,19 @@ class TieredThresholdPolicy : public CompilationPolicy {
// 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 @@ class TieredThresholdPolicy : public CompilationPolicy {
// 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 @@ class TieredThresholdPolicy : public CompilationPolicy {
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);

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

@ -267,7 +267,8 @@ bool AbstractInterpreter::is_not_reached(const methodHandle& method, int bci) {
}
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();

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

@ -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 @@ BasicType Bytecode_member_ref::result_type() const {
}
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 @@ methodHandle Bytecode_invoke::static_target(TRAPS) {
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
}

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

@ -209,7 +209,7 @@ class Bytecode_invoke: public Bytecode_member_ref {
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

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

@ -897,7 +897,7 @@ void InterpreterRuntime::resolve_invoke(JavaThread* thread, Bytecodes::Code byte
// (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 @@ void InterpreterRuntime::resolve_invoke(JavaThread* thread, Bytecodes::Code byte
// 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();

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

@ -140,8 +140,8 @@ CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
}
_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 @@ CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
} 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 @@ CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
}
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 @@ Method* LinkResolver::lookup_method_in_klasses(const LinkInfo& link_info,
// 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 @@ methodHandle LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
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 @@ methodHandle LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
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 @@ Method* LinkResolver::lookup_method_in_interfaces(const LinkInfo& cp_info) {
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 @@ methodHandle LinkResolver::lookup_polymorphic_method(
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 @@ methodHandle LinkResolver::lookup_polymorphic_method(
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 @@ methodHandle LinkResolver::lookup_polymorphic_method(
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 @@ void LinkResolver::check_method_accessability(Klass* ref_klass,
}
}
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 @@ methodHandle LinkResolver::resolve_method_statically(Bytecodes::Code code,
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 @@ void LinkResolver::check_field_loader_constraints(Symbol* field, Symbol* sig,
}
}
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 @@ methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
if (resolved_method.is_null()) {
// JSR 292: see if this is an implicitly generated method MethodHandle.linkToVirtual(*...), etc
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 @@ methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
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 @@ static void trace_method_resolution(const char* prefix,
}
// 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 @@ methodHandle LinkResolver::resolve_interface_method(const LinkInfo& link_info, B
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 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
}
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 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
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_field(fieldDescriptor& fd,
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 @@ void LinkResolver::resolve_static_call(CallInfo& result,
}
// 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 @@ methodHandle LinkResolver::linktime_resolve_static_method(const LinkInfo& link_i
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 @@ void LinkResolver::resolve_special_call(CallInfo& result,
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 @@ methodHandle LinkResolver::linktime_resolve_special_method(const LinkInfo& link_
// 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 @@ void LinkResolver::runtime_resolve_special_method(CallInfo& result,
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 @@ void LinkResolver::runtime_resolve_special_method(CallInfo& result,
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::runtime_resolve_special_method(CallInfo& result,
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 @@ void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
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 @@ void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, Klass*
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 @@ void LinkResolver::runtime_resolve_interface_method(CallInfo& result,
// 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 @@ void LinkResolver::runtime_resolve_interface_method(CallInfo& result,
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 @@ void LinkResolver::runtime_resolve_interface_method(CallInfo& result,
}
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 @@ methodHandle LinkResolver::resolve_virtual_call_or_null(
resolve_virtual_call(info, Handle(), receiver_klass, link_info, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return 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 @@ methodHandle LinkResolver::resolve_interface_call_or_null(
resolve_interface_call(info, Handle(), receiver_klass, link_info, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
return methodHandle();
return NULL;
}
return info.selected_method();
}
@ -1572,24 +1573,24 @@ int LinkResolver::resolve_virtual_vtable_index(Klass* receiver_klass,
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 @@ void LinkResolver::resolve_handle_call(CallInfo& result,
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) {

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

@ -96,8 +96,8 @@ class CallInfo : public StackObj {
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 @@ class LinkInfo : public StackObj {
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 @@ class LinkResolver: AllStatic {
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 @@ class LinkResolver: AllStatic {
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 @@ class LinkResolver: AllStatic {
// 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 @@ class LinkResolver: AllStatic {
// 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 @@ class LinkResolver: AllStatic {
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 @@ class LinkResolver: AllStatic {
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,

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

@ -80,13 +80,13 @@ void Rewriter::compute_index_maps() {
}
// 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 @@ void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide,
// 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 @@ void Rewriter::scan_method(Method* method, bool reverse, bool* invokespecial_err
// 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 @@ void Rewriter::rewrite_bytecodes(TRAPS) {
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 @@ void Rewriter::rewrite(InstanceKlass* klass, TRAPS) {
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 @@ Rewriter::Rewriter(InstanceKlass* klass, const constantPoolHandle& cpool, Array<
// Stress restoring bytecodes
if (StressRewriter) {
restore_bytecodes();
restore_bytecodes(THREAD);
rewrite_bytecodes(CHECK);
}
@ -602,7 +603,7 @@ Rewriter::Rewriter(InstanceKlass* klass, const constantPoolHandle& cpool, Array<
// 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 @@ Rewriter::Rewriter(InstanceKlass* klass, const constantPoolHandle& cpool, Array<
// 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.

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

@ -184,7 +184,7 @@ class Rewriter: public StackObj {
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 @@ class Rewriter: public StackObj {
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:

2
src/hotspot/share/jfr/leakprofiler/chains/edgeUtils.cpp
View File

@ -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"

4
src/hotspot/share/jvmci/compilerRuntime.cpp
View File

@ -141,7 +141,7 @@ JRT_BLOCK_ENTRY(void, CompilerRuntime::resolve_dynamic_invoke(JavaThread *thread
// 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 @@ JRT_BLOCK_ENTRY(void, CompilerRuntime::resolve_dynamic_invoke(JavaThread *thread
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()) {

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

@ -203,8 +203,8 @@ int AOTOopRecorder::find_index(Metadata* h) {
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 @@ void CodeInstaller::initialize_dependencies(JVMCIObject compiled_code, OopRecord
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::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
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 @@ JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
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 @@ void CodeInstaller::assumption_ConcreteMethod(JVMCIObject assumption) {
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 @@ void CodeInstaller::record_scope(jint pc_offset, JVMCIObject position, ScopeMode
}
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 @@ void CodeInstaller::record_scope(jint pc_offset, JVMCIObject position, ScopeMode
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);

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

@ -67,7 +67,7 @@ void JVMCICompiler::bootstrap(TRAPS) {
// 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 @@ void JVMCICompiler::bootstrap(TRAPS) {
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

2
src/hotspot/share/jvmci/jvmciCompiler.hpp
View File

@ -84,7 +84,7 @@ public:
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; }

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

@ -254,7 +254,7 @@ C2V_VMENTRY_NULL(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong
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_VMENTRY_NULL(jbyteArray, getBytecode, (JNIEnv* env, jobject, jobject jvmci_m
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 @@ C2V_VMENTRY_NULL(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject e
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 @@ C2V_VMENTRY_NULL(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject
} 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 @@ C2V_VMENTRY_NULL(jobject, getConstantPool, (JNIEnv* env, jobject, jobject object
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, getResolvedJavaType0, (JNIEnv* env, jobject, jobject b
}
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 @@ C2V_VMENTRY_NULL(jobject, findUniqueConcreteMethod, (JNIEnv* env, jobject, jobje
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_VMENTRY_NULL(jobject, getImplementor, (JNIEnv* env, jobject, jobject jvmci_t
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, lookupClass, (JNIEnv* env, jobject, jclass mirror))
}
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_VMENTRY_NULL(jobject, resolveTypeInPool, (JNIEnv* env, jobject, jobject jvmc
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_VMENTRY_NULL(jobject, lookupKlassInPool, (JNIEnv* env, jobject, jobject jvmc
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_END
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_END
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 @@ C2V_VMENTRY_NULL(jobject, resolveMethod, (JNIEnv* env, jobject, jobject receiver
}
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 @@ C2V_VMENTRY_NULL(jobject, resolveMethod, (JNIEnv* env, jobject, jobject receiver
}
}
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 @@ C2V_VMENTRY_NULL(jobject, getClassInitializer, (JNIEnv* env, jobject, jobject jv
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_VMENTRY_0(jlong, getMaxCallTargetOffset, (JNIEnv* env, jobject, jlong addr))
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_END
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 @@ C2V_VMENTRY_NULL(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject
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_VMENTRY_0(jint, getLocalVariableTableLength, (JNIEnv* env, jobject, jobject
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 @@ C2V_VMENTRY_0(jint, allocateCompileId, (JNIEnv* env, jobject, jobject jvmci_meth
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 @@ void call_interface(JavaValue* result, Klass* spec_klass, Symbol* name, Symbol*
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 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
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 @@ C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
} 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_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, job
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_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv* env, jobject, jobject jvm
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_VMENTRY(void, resolveInvokeHandleInPool, (JNIEnv* env, jobject, jobject jvmc
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 @@ C2V_VMENTRY_0(jint, isResolvedInvokeHandleInPool, (JNIEnv* env, jobject, jobject
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 @@ C2V_VMENTRY_0(jint, isResolvedInvokeHandleInPool, (JNIEnv* env, jobject, jobject
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 @@ C2V_VMENTRY_NULL(jobjectArray, getDeclaredConstructors, (JNIEnv* env, jobject, j
}
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 @@ C2V_VMENTRY_NULL(jobjectArray, getDeclaredMethods, (JNIEnv* env, jobject, jobjec
}
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 @@ C2V_VMENTRY_NULL(jlongArray, registerNativeMethods, (JNIEnv* env, jobject, jclas
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 @@ C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle))
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 @@ C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle))
}
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(jbyteArray, getCode, (JNIEnv* env, jobject, jobject code_handle
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_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlo
}
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();

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

@ -952,7 +952,7 @@ JVMCIObject JVMCIEnv::new_StackTraceElement(const methodHandle& method, int bci,
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());

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

@ -87,7 +87,7 @@ void HotSpotJVMCI::compute_offset(int &dest_offset, Klass* klass, const char* na
#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 @@ static void check_resolve_method(const char* call_type, Klass* resolved_klass, S
} 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());
}
}

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

@ -1150,16 +1150,16 @@ void JVMCIRuntime::get_field_by_index(InstanceKlass* accessor, fieldDescriptor&
// ------------------------------------------------------------------
// 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::lookup_method(InstanceKlass* accessor,
// ------------------------------------------------------------------
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 @@ methodHandle JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cp
// 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 @@ methodHandle JVMCIRuntime::get_method_by_index_impl(const constantPoolHandle& cp
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 @@ InstanceKlass* JVMCIRuntime::get_instance_klass_for_declared_method_holder(Klass
// ------------------------------------------------------------------
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;

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

@ -117,18 +117,18 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
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 @@ class JVMCIRuntime: public CHeapObj<mtJVMCI> {
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

2
src/hotspot/share/memory/dynamicArchive.cpp
View File

@ -806,7 +806,7 @@ void DynamicArchiveBuilder::make_klasses_shareable() {
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");

2
src/hotspot/share/memory/heapShared.cpp
View File

@ -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"

12
src/hotspot/share/memory/metaspaceShared.cpp
View File

@ -596,7 +596,7 @@ static void clear_basic_type_mirrors() {
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 @@ static void rewrite_nofast_bytecode(Method* method) {
// [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 @@ void VM_PopulateDumpSharedSpace::doit() {
// 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

2
src/hotspot/share/memory/metaspaceShared.hpp
View File

@ -307,7 +307,7 @@ class MetaspaceShared : AllStatic {
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.

10
src/hotspot/share/oops/cpCache.cpp
View File

@ -401,7 +401,7 @@ void ConstantPoolCacheEntry::set_method_handle_common(const constantPoolHandle&
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 @@ void ConstantPoolCacheEntry::set_method_handle_common(const constantPoolHandle&
invoke_code,
p2i(appendix()),
(has_appendix ? "" : " (unused)"),
p2i(adapter()));
p2i(adapter));
adapter->print();
if (has_appendix) appendix()->print();
}
@ -451,7 +451,7 @@ void ConstantPoolCacheEntry::set_method_handle_common(const constantPoolHandle&
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 @@ void ConstantPoolCache::walk_entries_for_initialization(bool check_only) {
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) {

4
src/hotspot/share/oops/fieldInfo.hpp
View File

@ -176,7 +176,7 @@ class FieldInfo {
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 @@ class FieldInfo {
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);

35
src/hotspot/share/oops/fieldStreams.hpp
View File

@ -79,34 +79,11 @@ class FieldStreamBase : public StackObj {
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;
}
}
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, int start, int limit);
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 @@ class FieldStreamBase : public StackObj {
}
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 InternalFieldStream : public FieldStreamBase {
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()) {}
};

54
src/hotspot/share/oops/fieldStreams.inline.hpp Normal file
View File

@ -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

2
src/hotspot/share/oops/generateOopMap.cpp
View File

@ -1875,7 +1875,7 @@ void GenerateOopMap::do_jsr(int targ_bci) {
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();

2
src/hotspot/share/oops/instanceKlass.cpp
View File

@ -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"

27
src/hotspot/share/oops/klassVtable.cpp
View File

@ -300,7 +300,7 @@ InstanceKlass* klassVtable::find_transitive_override(InstanceKlass* initialsuper
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 @@ bool klassVtable::update_inherited_vtable(InstanceKlass* klass, const methodHand
// 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 @@ bool klassVtable::needs_new_vtable_entry(const methodHandle& target_method,
// 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 @@ void klassItable::initialize_itable_for_interface(int method_table_offset, Insta
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 @@ void klassItable::initialize_itable_for_interface(int method_table_offset, Insta
// 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 @@ void klassItable::initialize_itable_for_interface(int method_table_offset, Insta
" 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 @@ void klassItable::initialize_itable_for_interface(int method_table_offset, Insta
// 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();
}
}

19
src/hotspot/share/oops/method.cpp
View File

@ -546,7 +546,7 @@ MethodCounters* Method::build_method_counters(Method* m, TRAPS) {
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::is_vanilla_constructor() const {
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 @@ void Method::set_not_compilable(const char* reason, int comp_level, bool report)
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 @@ void Method::set_not_osr_compilable(const char* reason, int comp_level, bool rep
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 @@ void Method::unlink_method() {
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 @@ methodHandle Method::clone_with_new_data(const methodHandle& m, u_char* new_code
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::make_jmethod_id(ClassLoaderData* loader_data, Method* m) {
}
}
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) {

2
src/hotspot/share/oops/method.hpp
View File

@ -856,7 +856,7 @@ public:
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

18
src/hotspot/share/oops/methodData.cpp
View File

@ -668,7 +668,7 @@ void ArgInfoData::print_data_on(outputStream* st, const char* extra) const {
}
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 @@ MethodData* MethodData::allocate(ClassLoaderData* loader_data, const methodHandl
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 @@ MethodData::MethodData(const methodHandle& method, int size, TRAPS)
}
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 @@ void MethodData::initialize() {
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 @@ void MethodData::initialize() {
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 @@ void MethodData::init() {
// 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 @@ void MethodData::init() {
#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) {

5
src/hotspot/share/prims/jvm.cpp
View File

@ -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 @@ JVM_ENTRY(jobjectArray, JVM_GetMethodParameters(JNIEnv *env, jobject method))
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(),

4
src/hotspot/share/prims/jvmtiClassFileReconstituter.cpp
View File

@ -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"

2
src/hotspot/share/prims/jvmtiCodeBlobEvents.cpp
View File

@ -253,7 +253,7 @@ void JvmtiCodeBlobEvents::build_jvmti_addr_location_map(nmethod *nm,
// Generate line numbers using PcDesc and ScopeDesc info
methodHandle mh(nm->method());
methodHandle mh(Thread::current(), nm->method());
if (!mh->is_native()) {
PcDesc *pcd;

2
src/hotspot/share/prims/jvmtiEnv.cpp
View File

@ -3152,7 +3152,7 @@ JvmtiEnv::GetBytecodes(Method* method_oop, jint* bytecode_count_ptr, unsigned ch
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) {

11
src/hotspot/share/prims/jvmtiRedefineClasses.cpp
View File

@ -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 @@ void VM_RedefineClasses::AdjustAndCleanMetadata::do_klass(Klass* k) {
// 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::AdjustAndCleanMetadata::do_klass(Klass* k) {
}
}
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 @@ void VM_RedefineClasses::redefine_single_class(jclass the_jclass,
_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;

2
src/hotspot/share/prims/jvmtiRedefineClasses.hpp
View File

@ -407,7 +407,7 @@ class VM_RedefineClasses: public VM_Operation {
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).

5
src/hotspot/share/prims/methodComparator.cpp
View File

@ -52,8 +52,9 @@ bool MethodComparator::methods_EMCP(Method* old_method, Method* new_method) {
_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;

2
src/hotspot/share/prims/methodHandles.cpp
View File

@ -222,7 +222,7 @@ oop MethodHandles::init_MemberName(Handle mname, Handle target, TRAPS) {
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");

2
src/hotspot/share/prims/nativeLookup.cpp
View File

@ -380,7 +380,7 @@ address NativeLookup::lookup_entry_prefixed(const methodHandle& method, bool& in
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);
}
}
}

2
src/hotspot/share/prims/stackwalk.cpp
View File

@ -156,7 +156,7 @@ int StackWalk::fill_in_frames(jlong mode, BaseFrameStream& stream,
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;

2
src/hotspot/share/prims/unsafe.cpp
View File

@ -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"

10
src/hotspot/share/runtime/deoptimization.cpp
View File

@ -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 @@ Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread
// 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 @@ address Deoptimization::deoptimize_for_missing_exception_handler(CompiledMethod*
assert(caller_frame.cb()->as_compiled_method_or_null() == cm, "expect top frame compiled method");
Deoptimization::deoptimize(thread, caller_frame, &reg_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 @@ JRT_ENTRY(void, Deoptimization::uncommon_trap_inner(JavaThread* thread, jint tra
);
}
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 @@ JRT_ENTRY(void, Deoptimization::uncommon_trap_inner(JavaThread* thread, jint tra
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;
}

2
src/hotspot/share/runtime/fieldDescriptor.cpp
View File

@ -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"

4
src/hotspot/share/runtime/fieldDescriptor.inline.hpp
View File

@ -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 {

2
src/hotspot/share/runtime/frame.cpp
View File

@ -1164,7 +1164,7 @@ void frame::describe(FrameValues& values, int frame_no) {
// 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++) {

1
src/hotspot/share/runtime/handles.hpp
View File

@ -143,7 +143,6 @@ DEF_HANDLE(typeArray , is_typeArray_noinline )
public: \
/* Constructors */ \
name##Handle () : _value(NULL), _thread(NULL) {} \
name##Handle (type* obj); \
name##Handle (Thread* thread, type* obj); \
\
name##Handle (const name##Handle &h); \

8
src/hotspot/share/runtime/handles.inline.hpp
View File

@ -55,14 +55,6 @@ DEF_HANDLE_CONSTR(typeArray, is_typeArray_noinline)
// 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"); \

6
src/hotspot/share/runtime/javaCalls.cpp
View File

@ -186,7 +186,7 @@ void JavaCalls::call_virtual(JavaValue* result, Klass* spec_klass, Symbol* name,
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 @@ void JavaCalls::call_special(JavaValue* result, Klass* klass, Symbol* name, Symb
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 @@ void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbo
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

2
src/hotspot/share/runtime/reflection.cpp
View File

@ -978,7 +978,7 @@ static methodHandle resolve_interface_call(InstanceKlass* klass,
LinkInfo(klass, name, signature),
true,
CHECK_(methodHandle()));
return info.selected_method();
return methodHandle(THREAD, info.selected_method());
}
// Conversion

21
src/hotspot/share/runtime/sharedRuntime.cpp
View File

@ -1022,7 +1022,7 @@ Handle SharedRuntime::find_callee_info(JavaThread* thread, Bytecodes::Code& bc,
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 @@ Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
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 @@ Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
frame callerFrame = stubFrame.sender(&reg_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 @@ Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
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 @@ methodHandle SharedRuntime::find_callee_method(JavaThread* thread, TRAPS) {
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 @@ methodHandle SharedRuntime::resolve_sub_helper(JavaThread *thread,
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 @@ JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method_abstract(JavaThread*
// 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 @@ JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method_abstract(JavaThread*
// 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(&reg_map);
Klass *recv_klass = (recv != NULL) ? recv->klass() : NULL;
@ -1657,7 +1656,7 @@ methodHandle SharedRuntime::handle_ic_miss_helper(JavaThread *thread, TRAPS) {
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);

2
src/hotspot/share/runtime/sharedRuntime.hpp
View File

@ -351,7 +351,7 @@ class SharedRuntime: AllStatic {
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();

6
src/hotspot/share/runtime/vframeArray.cpp
View File

@ -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 @@ void vframeArray::unpack_to_stack(frame &unpack_frame, int exec_mode, int caller
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.

2
src/hotspot/share/utilities/exceptions.cpp
View File

@ -229,7 +229,7 @@ void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file
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);

8
src/hotspot/share/utilities/xmlstream.cpp
View File

@ -385,9 +385,9 @@ void xmlStream::stamp() {
// ------------------------------------------------------------------
// 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(const methodHandle& method) {
}
}
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());

4
src/hotspot/share/utilities/xmlstream.hpp
View File

@ -137,14 +137,14 @@ class xmlStream : public outputStream {
// 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);