mirror of
https://github.com/openjdk/jdk.git
synced 2025-09-21 03:24:38 +02:00
6964458: Reimplement class meta-data storage to use native memory
Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Co-authored-by: Stefan Karlsson <stefan.karlsson@oracle.com> Co-authored-by: Mikael Gerdin <mikael.gerdin@oracle.com> Co-authored-by: Tom Rodriguez <tom.rodriguez@oracle.com> Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
This commit is contained in:
Jon Masamitsu
Coleen Phillimore
parent
36eee7c8c8
commit
5c58d27aac
853 changed files with 26124 additions and 82956 deletions
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 2012, 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
|
||||
|
|
@ -75,7 +75,7 @@ BasicType field_type, AccessFlags access_flags) {
|
|||
|
||||
|
||||
void CallInfo::set_static(KlassHandle resolved_klass, methodHandle resolved_method, TRAPS) {
|
||||
int vtable_index = methodOopDesc::nonvirtual_vtable_index;
|
||||
int vtable_index = Method::nonvirtual_vtable_index;
|
||||
set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK);
|
||||
}
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_kl
|
|||
// comes from java/lang/Object, it can be the subject of a virtual call, so
|
||||
// we should pick the vtable index from the resolved method.
|
||||
// Other than that case, there is no valid vtable index to specify.
|
||||
int vtable_index = methodOopDesc::invalid_vtable_index;
|
||||
int vtable_index = Method::invalid_vtable_index;
|
||||
if (resolved_method->method_holder() == SystemDictionary::Object_klass()) {
|
||||
assert(resolved_method->vtable_index() == selected_method->vtable_index(), "sanity check");
|
||||
vtable_index = resolved_method->vtable_index();
|
||||
|
|
@ -94,7 +94,7 @@ void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_kl
|
|||
}
|
||||
|
||||
void CallInfo::set_virtual(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) {
|
||||
assert(vtable_index >= 0 || vtable_index == methodOopDesc::nonvirtual_vtable_index, "valid index");
|
||||
assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index");
|
||||
set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK);
|
||||
assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call");
|
||||
}
|
||||
|
|
@ -103,11 +103,11 @@ void CallInfo::set_handle(methodHandle resolved_method, Handle resolved_appendix
|
|||
if (resolved_method.is_null()) {
|
||||
THROW_MSG(vmSymbols::java_lang_InternalError(), "resolved method is null");
|
||||
}
|
||||
KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass();
|
||||
KlassHandle resolved_klass = SystemDictionary::MethodHandle_klass();
|
||||
assert(resolved_method->intrinsic_id() == vmIntrinsics::_invokeBasic ||
|
||||
resolved_method->is_compiled_lambda_form(),
|
||||
"linkMethod must return one of these");
|
||||
int vtable_index = methodOopDesc::nonvirtual_vtable_index;
|
||||
int vtable_index = Method::nonvirtual_vtable_index;
|
||||
assert(resolved_method->vtable_index() == vtable_index, "");
|
||||
set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK);
|
||||
_resolved_appendix = resolved_appendix;
|
||||
|
|
@ -131,7 +131,7 @@ void CallInfo::set_common(KlassHandle resolved_klass, KlassHandle selected_klass
|
|||
// don't force compilation, resolve was on behalf of compiler
|
||||
return;
|
||||
}
|
||||
if (instanceKlass::cast(selected_method->method_holder())->is_not_initialized()) {
|
||||
if (InstanceKlass::cast(selected_method->method_holder())->is_not_initialized()) {
|
||||
// 'is_not_initialized' means not only '!is_initialized', but also that
|
||||
// initialization has not been started yet ('!being_initialized')
|
||||
// Do not force compilation of methods in uninitialized classes.
|
||||
|
|
@ -152,8 +152,8 @@ void CallInfo::set_common(KlassHandle resolved_klass, KlassHandle selected_klass
|
|||
// Klass resolution
|
||||
|
||||
void LinkResolver::check_klass_accessability(KlassHandle ref_klass, KlassHandle sel_klass, TRAPS) {
|
||||
if (!Reflection::verify_class_access(ref_klass->as_klassOop(),
|
||||
sel_klass->as_klassOop(),
|
||||
if (!Reflection::verify_class_access(ref_klass(),
|
||||
sel_klass(),
|
||||
true)) {
|
||||
ResourceMark rm(THREAD);
|
||||
Exceptions::fthrow(
|
||||
|
|
@ -168,13 +168,13 @@ void LinkResolver::check_klass_accessability(KlassHandle ref_klass, KlassHandle
|
|||
}
|
||||
|
||||
void LinkResolver::resolve_klass(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) {
|
||||
klassOop result_oop = pool->klass_ref_at(index, CHECK);
|
||||
Klass* result_oop = pool->klass_ref_at(index, CHECK);
|
||||
result = KlassHandle(THREAD, result_oop);
|
||||
}
|
||||
|
||||
void LinkResolver::resolve_klass_no_update(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) {
|
||||
klassOop result_oop =
|
||||
constantPoolOopDesc::klass_ref_at_if_loaded_check(pool, index, CHECK);
|
||||
Klass* result_oop =
|
||||
ConstantPool::klass_ref_at_if_loaded_check(pool, index, CHECK);
|
||||
result = KlassHandle(THREAD, result_oop);
|
||||
}
|
||||
|
||||
|
|
@ -185,7 +185,7 @@ void LinkResolver::resolve_klass_no_update(KlassHandle& result, constantPoolHand
|
|||
// According to JVM spec. $5.4.3c & $5.4.3d
|
||||
|
||||
void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
|
||||
methodOop result_oop = klass->uncached_lookup_method(name, signature);
|
||||
Method* result_oop = klass->uncached_lookup_method(name, signature);
|
||||
if (EnableInvokeDynamic && result_oop != NULL) {
|
||||
vmIntrinsics::ID iid = result_oop->intrinsic_id();
|
||||
if (MethodHandles::is_signature_polymorphic(iid)) {
|
||||
|
|
@ -198,7 +198,7 @@ void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle kl
|
|||
|
||||
// returns first instance method
|
||||
void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
|
||||
methodOop result_oop = klass->uncached_lookup_method(name, signature);
|
||||
Method* result_oop = klass->uncached_lookup_method(name, signature);
|
||||
result = methodHandle(THREAD, result_oop);
|
||||
while (!result.is_null() && result->is_static()) {
|
||||
klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super());
|
||||
|
|
@ -209,12 +209,12 @@ void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, Klass
|
|||
|
||||
int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
|
||||
ResourceMark rm(THREAD);
|
||||
klassVtable *vt = instanceKlass::cast(klass())->vtable();
|
||||
klassVtable *vt = InstanceKlass::cast(klass())->vtable();
|
||||
return vt->index_of_miranda(name, signature);
|
||||
}
|
||||
|
||||
void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
|
||||
instanceKlass *ik = instanceKlass::cast(klass());
|
||||
InstanceKlass *ik = InstanceKlass::cast(klass());
|
||||
result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name, signature));
|
||||
}
|
||||
|
||||
|
|
@ -264,8 +264,8 @@ void LinkResolver::lookup_polymorphic_method(methodHandle& result,
|
|||
// We will ask Java code to spin an adapter method for it.
|
||||
if (!MethodHandles::enabled()) {
|
||||
// Make sure the Java part of the runtime has been booted up.
|
||||
klassOop natives = SystemDictionary::MethodHandleNatives_klass();
|
||||
if (natives == NULL || instanceKlass::cast(natives)->is_not_initialized()) {
|
||||
Klass* natives = SystemDictionary::MethodHandleNatives_klass();
|
||||
if (natives == NULL || InstanceKlass::cast(natives)->is_not_initialized()) {
|
||||
SystemDictionary::resolve_or_fail(vmSymbols::java_lang_invoke_MethodHandleNatives(),
|
||||
Handle(),
|
||||
Handle(),
|
||||
|
|
@ -340,9 +340,9 @@ void LinkResolver::check_method_accessability(KlassHandle ref_klass,
|
|||
}
|
||||
// assert(extra_arg_result_or_null != NULL, "must be able to return extra argument");
|
||||
|
||||
if (!Reflection::verify_field_access(ref_klass->as_klassOop(),
|
||||
resolved_klass->as_klassOop(),
|
||||
sel_klass->as_klassOop(),
|
||||
if (!Reflection::verify_field_access(ref_klass(),
|
||||
resolved_klass(),
|
||||
sel_klass(),
|
||||
flags,
|
||||
true)) {
|
||||
ResourceMark rm(THREAD);
|
||||
|
|
@ -364,7 +364,7 @@ void LinkResolver::resolve_method_statically(methodHandle& resolved_method, Klas
|
|||
|
||||
// resolve klass
|
||||
if (code == Bytecodes::_invokedynamic) {
|
||||
resolved_klass = SystemDictionaryHandles::MethodHandle_klass();
|
||||
resolved_klass = SystemDictionary::MethodHandle_klass();
|
||||
Symbol* method_name = vmSymbols::invoke_name();
|
||||
Symbol* method_signature = pool->signature_ref_at(index);
|
||||
KlassHandle current_klass(THREAD, pool->pool_holder());
|
||||
|
|
@ -381,7 +381,7 @@ void LinkResolver::resolve_method_statically(methodHandle& resolved_method, Klas
|
|||
if (pool->has_preresolution()
|
||||
|| (resolved_klass() == SystemDictionary::MethodHandle_klass() &&
|
||||
MethodHandles::is_signature_polymorphic_name(resolved_klass(), method_name))) {
|
||||
methodOop result_oop = constantPoolOopDesc::method_at_if_loaded(pool, index);
|
||||
Method* result_oop = ConstantPool::method_at_if_loaded(pool, index);
|
||||
if (result_oop != NULL) {
|
||||
resolved_method = methodHandle(THREAD, result_oop);
|
||||
return;
|
||||
|
|
@ -430,7 +430,7 @@ void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle res
|
|||
// 4. method lookup failed
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG_CAUSE(vmSymbols::java_lang_NoSuchMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
method_name,
|
||||
method_signature),
|
||||
nested_exception);
|
||||
|
|
@ -441,7 +441,7 @@ void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle res
|
|||
if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
method_name,
|
||||
method_signature));
|
||||
}
|
||||
|
|
@ -458,8 +458,8 @@ void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle res
|
|||
CHECK);
|
||||
|
||||
// check loader constraints
|
||||
Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader());
|
||||
Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader());
|
||||
Handle loader (THREAD, InstanceKlass::cast(current_klass())->class_loader());
|
||||
Handle class_loader (THREAD, InstanceKlass::cast(resolved_method->method_holder())->class_loader());
|
||||
{
|
||||
ResourceMark rm(THREAD);
|
||||
char* failed_type_name =
|
||||
|
|
@ -470,11 +470,11 @@ void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle res
|
|||
" \"%s\" the class loader (instance of %s) of the current class, %s,"
|
||||
" and the class loader (instance of %s) for resolved class, %s, have"
|
||||
" different Class objects for the type %s used in the signature";
|
||||
char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature);
|
||||
char* sig = Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature);
|
||||
const char* loader1 = SystemDictionary::loader_name(loader());
|
||||
char* current = instanceKlass::cast(current_klass())->name()->as_C_string();
|
||||
char* current = InstanceKlass::cast(current_klass())->name()->as_C_string();
|
||||
const char* loader2 = SystemDictionary::loader_name(class_loader());
|
||||
char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string();
|
||||
char* resolved = InstanceKlass::cast(resolved_klass())->name()->as_C_string();
|
||||
size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
|
||||
strlen(current) + strlen(loader2) + strlen(resolved) +
|
||||
strlen(failed_type_name);
|
||||
|
|
@ -512,7 +512,7 @@ void LinkResolver::resolve_interface_method(methodHandle& resolved_method,
|
|||
// no method found
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
method_name,
|
||||
method_signature));
|
||||
}
|
||||
|
|
@ -520,8 +520,8 @@ void LinkResolver::resolve_interface_method(methodHandle& resolved_method,
|
|||
|
||||
if (check_access) {
|
||||
HandleMark hm(THREAD);
|
||||
Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader());
|
||||
Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader());
|
||||
Handle loader (THREAD, InstanceKlass::cast(current_klass())->class_loader());
|
||||
Handle class_loader (THREAD, InstanceKlass::cast(resolved_method->method_holder())->class_loader());
|
||||
{
|
||||
ResourceMark rm(THREAD);
|
||||
char* failed_type_name =
|
||||
|
|
@ -533,11 +533,11 @@ void LinkResolver::resolve_interface_method(methodHandle& resolved_method,
|
|||
"current class, %s, and the class loader (instance of %s) for "
|
||||
"resolved class, %s, have different Class objects for the type %s "
|
||||
"used in the signature";
|
||||
char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature);
|
||||
char* sig = Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature);
|
||||
const char* loader1 = SystemDictionary::loader_name(loader());
|
||||
char* current = instanceKlass::cast(current_klass())->name()->as_C_string();
|
||||
char* current = InstanceKlass::cast(current_klass())->name()->as_C_string();
|
||||
const char* loader2 = SystemDictionary::loader_name(class_loader());
|
||||
char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string();
|
||||
char* resolved = InstanceKlass::cast(resolved_klass())->name()->as_C_string();
|
||||
size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
|
||||
strlen(current) + strlen(loader2) + strlen(resolved) +
|
||||
strlen(failed_type_name);
|
||||
|
|
@ -558,9 +558,9 @@ void LinkResolver::check_field_accessability(KlassHandle ref_klass,
|
|||
KlassHandle sel_klass,
|
||||
fieldDescriptor& fd,
|
||||
TRAPS) {
|
||||
if (!Reflection::verify_field_access(ref_klass->as_klassOop(),
|
||||
resolved_klass->as_klassOop(),
|
||||
sel_klass->as_klassOop(),
|
||||
if (!Reflection::verify_field_access(ref_klass(),
|
||||
resolved_klass(),
|
||||
sel_klass(),
|
||||
fd.access_flags(),
|
||||
true)) {
|
||||
ResourceMark rm(THREAD);
|
||||
|
|
@ -605,7 +605,7 @@ void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle poo
|
|||
|
||||
// Resolve instance field
|
||||
fieldDescriptor fd; // find_field initializes fd if found
|
||||
KlassHandle sel_klass(THREAD, instanceKlass::cast(resolved_klass())->find_field(field, sig, &fd));
|
||||
KlassHandle sel_klass(THREAD, InstanceKlass::cast(resolved_klass())->find_field(field, sig, &fd));
|
||||
// check if field exists; i.e., if a klass containing the field def has been selected
|
||||
if (sel_klass.is_null()){
|
||||
ResourceMark rm(THREAD);
|
||||
|
|
@ -641,8 +641,8 @@ void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle poo
|
|||
|
||||
{
|
||||
HandleMark hm(THREAD);
|
||||
Handle ref_loader (THREAD, instanceKlass::cast(ref_klass())->class_loader());
|
||||
Handle sel_loader (THREAD, instanceKlass::cast(sel_klass())->class_loader());
|
||||
Handle ref_loader (THREAD, InstanceKlass::cast(ref_klass())->class_loader());
|
||||
Handle sel_loader (THREAD, InstanceKlass::cast(sel_klass())->class_loader());
|
||||
Symbol* signature_ref = pool->signature_ref_at(index);
|
||||
{
|
||||
ResourceMark rm(THREAD);
|
||||
|
|
@ -658,7 +658,7 @@ void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle poo
|
|||
"type, %s, have different Class objects for that type";
|
||||
char* field_name = field->as_C_string();
|
||||
const char* loader1 = SystemDictionary::loader_name(ref_loader());
|
||||
char* sel = instanceKlass::cast(sel_klass())->name()->as_C_string();
|
||||
char* sel = InstanceKlass::cast(sel_klass())->name()->as_C_string();
|
||||
const char* loader2 = SystemDictionary::loader_name(sel_loader());
|
||||
size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) +
|
||||
strlen(sel) + strlen(loader2) + strlen(failed_type_name);
|
||||
|
|
@ -718,7 +718,7 @@ void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method,
|
|||
if (!resolved_method->is_static()) {
|
||||
ResourceMark rm(THREAD);
|
||||
char buf[200];
|
||||
jio_snprintf(buf, sizeof(buf), "Expected static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
jio_snprintf(buf, sizeof(buf), "Expected static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
resolved_method->name(),
|
||||
resolved_method->signature()));
|
||||
THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
|
||||
|
|
@ -761,7 +761,7 @@ void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method
|
|||
char buf[200];
|
||||
jio_snprintf(buf, sizeof(buf),
|
||||
"Expecting non-static method %s",
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
resolved_method->name(),
|
||||
resolved_method->signature()));
|
||||
THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
|
||||
|
|
@ -795,7 +795,7 @@ void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle
|
|||
if (sel_method.is_null()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
resolved_method->name(),
|
||||
resolved_method->signature()));
|
||||
}
|
||||
|
|
@ -806,7 +806,7 @@ void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle
|
|||
if (sel_method->is_static()) {
|
||||
ResourceMark rm(THREAD);
|
||||
char buf[200];
|
||||
jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
resolved_method->name(),
|
||||
resolved_method->signature()));
|
||||
THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
|
||||
|
|
@ -816,7 +816,7 @@ void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle
|
|||
if (sel_method->is_abstract()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
sel_method->name(),
|
||||
sel_method->signature()));
|
||||
}
|
||||
|
|
@ -847,7 +847,7 @@ void LinkResolver::linktime_resolve_virtual_method(methodHandle &resolved_method
|
|||
if (resolved_method->is_static()) {
|
||||
ResourceMark rm(THREAD);
|
||||
char buf[200];
|
||||
jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
resolved_method->name(),
|
||||
resolved_method->signature()));
|
||||
THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
|
||||
|
|
@ -864,7 +864,7 @@ void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
|
|||
TRAPS) {
|
||||
|
||||
// setup default return values
|
||||
int vtable_index = methodOopDesc::invalid_vtable_index;
|
||||
int vtable_index = Method::invalid_vtable_index;
|
||||
methodHandle selected_method;
|
||||
|
||||
assert(recv.is_null() || recv->is_oop(), "receiver is not an oop");
|
||||
|
|
@ -874,23 +874,23 @@ void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
|
|||
THROW(vmSymbols::java_lang_NullPointerException());
|
||||
}
|
||||
|
||||
// Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's
|
||||
// Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s
|
||||
// has not been rewritten, and the vtable initialized.
|
||||
assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked");
|
||||
assert(InstanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked");
|
||||
|
||||
// Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's
|
||||
// Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s
|
||||
// has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since
|
||||
// a missing receiver might result in a bogus lookup.
|
||||
assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked");
|
||||
assert(InstanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked");
|
||||
|
||||
// do lookup based on receiver klass using the vtable index
|
||||
if (resolved_method->method_holder()->klass_part()->is_interface()) { // miranda method
|
||||
if (resolved_method->method_holder()->is_interface()) { // miranda method
|
||||
vtable_index = vtable_index_of_miranda_method(resolved_klass,
|
||||
resolved_method->name(),
|
||||
resolved_method->signature(), CHECK);
|
||||
assert(vtable_index >= 0 , "we should have valid vtable index at this point");
|
||||
|
||||
instanceKlass* inst = instanceKlass::cast(recv_klass());
|
||||
InstanceKlass* inst = InstanceKlass::cast(recv_klass());
|
||||
selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index));
|
||||
} else {
|
||||
// at this point we are sure that resolved_method is virtual and not
|
||||
|
|
@ -901,13 +901,13 @@ void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
|
|||
// unless they override an existing method.
|
||||
// If we do get a negative, it means the resolved method is the the selected
|
||||
// method, and it can never be changed by an override.
|
||||
if (vtable_index == methodOopDesc::nonvirtual_vtable_index) {
|
||||
if (vtable_index == Method::nonvirtual_vtable_index) {
|
||||
assert(resolved_method->can_be_statically_bound(), "cannot override this method");
|
||||
selected_method = resolved_method;
|
||||
} else {
|
||||
// recv_klass might be an arrayKlassOop but all vtables start at
|
||||
// the same place. The cast is to avoid virtual call and assertion.
|
||||
instanceKlass* inst = (instanceKlass*)recv_klass()->klass_part();
|
||||
InstanceKlass* inst = (InstanceKlass*)recv_klass();
|
||||
selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index));
|
||||
}
|
||||
}
|
||||
|
|
@ -916,7 +916,7 @@ void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
|
|||
if (selected_method.is_null()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
resolved_method->name(),
|
||||
resolved_method->signature()));
|
||||
}
|
||||
|
|
@ -925,7 +925,7 @@ void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
|
|||
if (check_null_and_abstract && selected_method->is_abstract()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),
|
||||
selected_method->name(),
|
||||
selected_method->signature()));
|
||||
}
|
||||
|
|
@ -978,7 +978,7 @@ void LinkResolver::runtime_resolve_interface_method(CallInfo& result, methodHand
|
|||
if (sel_method.is_null()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(recv_klass()),
|
||||
resolved_method->name(),
|
||||
resolved_method->signature()));
|
||||
}
|
||||
|
|
@ -986,7 +986,7 @@ void LinkResolver::runtime_resolve_interface_method(CallInfo& result, methodHand
|
|||
if (!sel_method->is_public()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_IllegalAccessError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(recv_klass()),
|
||||
sel_method->name(),
|
||||
sel_method->signature()));
|
||||
}
|
||||
|
|
@ -994,7 +994,7 @@ void LinkResolver::runtime_resolve_interface_method(CallInfo& result, methodHand
|
|||
if (check_null_and_abstract && sel_method->is_abstract()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()),
|
||||
Method::name_and_sig_as_C_string(Klass::cast(recv_klass()),
|
||||
sel_method->name(),
|
||||
sel_method->signature()));
|
||||
}
|
||||
|
|
@ -1080,7 +1080,7 @@ int LinkResolver::resolve_virtual_vtable_index(
|
|||
resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD);
|
||||
if (HAS_PENDING_EXCEPTION) {
|
||||
CLEAR_PENDING_EXCEPTION;
|
||||
return methodOopDesc::invalid_vtable_index;
|
||||
return Method::invalid_vtable_index;
|
||||
}
|
||||
return info.vtable_index();
|
||||
}
|
||||
|
|
@ -1170,7 +1170,7 @@ void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv,
|
|||
Symbol* method_signature = NULL;
|
||||
KlassHandle current_klass;
|
||||
resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK);
|
||||
KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass());
|
||||
KlassHandle recvrKlass (THREAD, recv.is_null() ? (Klass*)NULL : recv->klass());
|
||||
resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
|
||||
}
|
||||
|
||||
|
|
@ -1181,7 +1181,7 @@ void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, consta
|
|||
Symbol* method_signature = NULL;
|
||||
KlassHandle current_klass;
|
||||
resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK);
|
||||
KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass());
|
||||
KlassHandle recvrKlass (THREAD, recv.is_null() ? (Klass*)NULL : recv->klass());
|
||||
resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
|
||||
}
|
||||
|
||||
|
|
@ -1227,24 +1227,24 @@ void LinkResolver::resolve_invokedynamic(CallInfo& result, constantPoolHandle po
|
|||
// Resolve the bootstrap specifier (BSM + optional arguments).
|
||||
Handle bootstrap_specifier;
|
||||
// Check if CallSite has been bound already:
|
||||
ConstantPoolCacheEntry* cpce = pool->cache()->secondary_entry_at(index);
|
||||
ConstantPoolCacheEntry* cpce = pool->invokedynamic_cp_cache_entry_at(index);
|
||||
if (cpce->is_f1_null()) {
|
||||
int pool_index = pool->cache()->main_entry_at(index)->constant_pool_index();
|
||||
int pool_index = cpce->constant_pool_index();
|
||||
oop bsm_info = pool->resolve_bootstrap_specifier_at(pool_index, CHECK);
|
||||
assert(bsm_info != NULL, "");
|
||||
// FIXME: Cache this once per BootstrapMethods entry, not once per CONSTANT_InvokeDynamic.
|
||||
bootstrap_specifier = Handle(THREAD, bsm_info);
|
||||
}
|
||||
if (!cpce->is_f1_null()) {
|
||||
methodHandle method(THREAD, cpce->f2_as_vfinal_method());
|
||||
Handle appendix(THREAD, cpce->has_appendix() ? cpce->f1_appendix() : (oop)NULL);
|
||||
methodHandle method(THREAD, cpce->f1_as_method());
|
||||
Handle appendix(THREAD, cpce->appendix_if_resolved(pool));
|
||||
result.set_handle(method, appendix, CHECK);
|
||||
return;
|
||||
}
|
||||
|
||||
if (TraceMethodHandles) {
|
||||
tty->print_cr("resolve_invokedynamic #%d %s %s",
|
||||
constantPoolCacheOopDesc::decode_secondary_index(index),
|
||||
ConstantPool::decode_invokedynamic_index(index),
|
||||
method_name->as_C_string(), method_signature->as_C_string());
|
||||
tty->print(" BSM info: "); bootstrap_specifier->print();
|
||||
}
|
||||
|
|
@ -1265,7 +1265,7 @@ void LinkResolver::resolve_dynamic_call(CallInfo& result,
|
|||
bootstrap_specifier,
|
||||
method_name, method_signature,
|
||||
&resolved_appendix,
|
||||
THREAD);
|
||||
CHECK);
|
||||
if (HAS_PENDING_EXCEPTION) {
|
||||
if (TraceMethodHandles) {
|
||||
tty->print_cr("invokedynamic throws BSME for "INTPTR_FORMAT, PENDING_EXCEPTION);
|
||||
|
|
@ -1282,7 +1282,8 @@ void LinkResolver::resolve_dynamic_call(CallInfo& result,
|
|||
// See the "Linking Exceptions" section for the invokedynamic instruction in the JVMS.
|
||||
Handle nested_exception(THREAD, PENDING_EXCEPTION);
|
||||
CLEAR_PENDING_EXCEPTION;
|
||||
THROW_CAUSE(vmSymbols::java_lang_BootstrapMethodError(), nested_exception)
|
||||
THROW_MSG_CAUSE(vmSymbols::java_lang_BootstrapMethodError(),
|
||||
"BootstrapMethodError", nested_exception)
|
||||
}
|
||||
result.set_handle(resolved_method, resolved_appendix, CHECK);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue