--- a/hotspot/src/share/vm/prims/methodHandles.cpp Fri Oct 16 16:14:12 2009 -0700
+++ b/hotspot/src/share/vm/prims/methodHandles.cpp Sat Oct 17 19:51:05 2009 -0700
@@ -33,8 +33,7 @@
MethodHandleEntry* MethodHandles::_entries[MethodHandles::_EK_LIMIT] = {NULL};
const char* MethodHandles::_entry_names[_EK_LIMIT+1] = {
- "check_mtype",
- "wrong_method_type", // what happens when there is a type mismatch
+ "raise_exception",
"invokestatic", // how a MH emulates invokestatic
"invokespecial", // ditto for the other invokes...
"invokevirtual",
@@ -48,6 +47,7 @@
// starting at _adapter_mh_first:
"adapter_retype_only", // these are for AMH...
+ "adapter_retype_raw",
"adapter_check_cast",
"adapter_prim_to_prim",
"adapter_ref_to_prim",
@@ -82,6 +82,8 @@
NULL
};
+jobject MethodHandles::_raise_exception_method;
+
#ifdef ASSERT
bool MethodHandles::spot_check_entry_names() {
assert(!strcmp(entry_name(_invokestatic_mh), "invokestatic"), "");
@@ -157,7 +159,8 @@
}
methodOop MethodHandles::decode_BoundMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
- assert(mh->klass() == SystemDictionary::BoundMethodHandle_klass(), "");
+ assert(sun_dyn_BoundMethodHandle::is_instance(mh), "");
+ assert(mh->klass() != SystemDictionary::AdapterMethodHandle_klass(), "");
for (oop bmh = mh;;) {
// Bound MHs can be stacked to bind several arguments.
oop target = java_dyn_MethodHandle::vmtarget(bmh);
@@ -174,10 +177,9 @@
} else {
// Optimized case: binding a receiver to a non-dispatched DMH
// short-circuits directly to the methodOop.
+ // (It might be another argument besides a receiver also.)
assert(target->is_method(), "must be a simple method");
methodOop m = (methodOop) target;
- DEBUG_ONLY(int argslot = sun_dyn_BoundMethodHandle::vmargslot(bmh));
- assert(argslot == m->size_of_parameters() - 1, "must be initial argument (receiver)");
decode_flags_result |= MethodHandles::_dmf_binds_method;
return m;
}
@@ -214,6 +216,9 @@
return decode_BoundMethodHandle(mh, receiver_limit_result, decode_flags_result);
} else if (mhk == SystemDictionary::AdapterMethodHandle_klass()) {
return decode_AdapterMethodHandle(mh, receiver_limit_result, decode_flags_result);
+ } else if (sun_dyn_BoundMethodHandle::is_subclass(mhk)) {
+ // could be a JavaMethodHandle (but not an adapter MH)
+ return decode_BoundMethodHandle(mh, receiver_limit_result, decode_flags_result);
} else {
assert(false, "cannot parse this MH");
return NULL; // random MH?
@@ -366,7 +371,13 @@
oop vmtarget = sun_dyn_MemberName::vmtarget(mname);
int vmindex = sun_dyn_MemberName::vmindex(mname);
if (vmindex == VM_INDEX_UNINITIALIZED) return NULL; // not resolved
- return decode_vmtarget(vmtarget, vmindex, NULL, receiver_limit_result, decode_flags_result);
+ methodOop m = decode_vmtarget(vmtarget, vmindex, NULL, receiver_limit_result, decode_flags_result);
+ oop clazz = sun_dyn_MemberName::clazz(mname);
+ if (clazz != NULL && java_lang_Class::is_instance(clazz)) {
+ klassOop klass = java_lang_Class::as_klassOop(clazz);
+ if (klass != NULL) receiver_limit_result = klass;
+ }
+ return m;
}
// An unresolved member name is a mere symbolic reference.
@@ -789,6 +800,30 @@
THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), msg);
}
+static const char* always_null_names[] = {
+ "java/lang/Void",
+ "java/lang/Null",
+ //"java/lang/Nothing",
+ "sun/dyn/empty/Empty",
+ NULL
+};
+
+static bool is_always_null_type(klassOop klass) {
+ if (!Klass::cast(klass)->oop_is_instance()) return false;
+ instanceKlass* ik = instanceKlass::cast(klass);
+ // Must be on the boot class path:
+ if (ik->class_loader() != NULL) return false;
+ // Check the name.
+ symbolOop name = ik->name();
+ for (int i = 0; ; i++) {
+ const char* test_name = always_null_names[i];
+ if (test_name == NULL) break;
+ if (name->equals(test_name, (int) strlen(test_name)))
+ return true;
+ }
+ return false;
+}
+
bool MethodHandles::class_cast_needed(klassOop src, klassOop dst) {
if (src == dst || dst == SystemDictionary::object_klass())
return false; // quickest checks
@@ -805,6 +840,12 @@
//srck = Klass::cast(SystemDictionary::object_klass());
return true;
}
+ if (is_always_null_type(src)) {
+ // some source types are known to be never instantiated;
+ // they represent references which are always null
+ // such null references never fail to convert safely
+ return false;
+ }
return !srck->is_subclass_of(dstk->as_klassOop());
}
@@ -814,9 +855,15 @@
bool MethodHandles::same_basic_type_for_arguments(BasicType src,
BasicType dst,
+ bool raw,
bool for_return) {
- // return values can always be forgotten:
- if (for_return && dst == T_VOID) return true;
+ if (for_return) {
+ // return values can always be forgotten:
+ if (dst == T_VOID) return true;
+ if (src == T_VOID) return raw && (dst == T_INT);
+ // We allow caller to receive a garbage int, which is harmless.
+ // This trick is pulled by trusted code (see VerifyType.canPassRaw).
+ }
assert(src != T_VOID && dst != T_VOID, "should not be here");
if (src == dst) return true;
if (type2size[src] != type2size[dst]) return false;
@@ -929,8 +976,8 @@
const char* err = NULL;
int first_ptype_pos = m_needs_receiver ? 1 : 0;
- if (has_bound_recv && err == NULL) {
- first_ptype_pos -= 1;
+ if (has_bound_recv) {
+ first_ptype_pos -= 1; // ptypes do not include the bound argument; start earlier in them
if (m_needs_receiver && bound_recv_type.is_null())
{ err = "bound receiver is not an object"; goto die; }
}
@@ -939,10 +986,10 @@
objArrayOop ptypes = java_dyn_MethodType::ptypes(mtype());
if (ptypes->length() < first_ptype_pos)
{ err = "receiver argument is missing"; goto die; }
- if (first_ptype_pos == -1)
+ if (has_bound_recv)
err = check_method_receiver(m(), bound_recv_type->as_klassOop());
else
- err = check_method_receiver(m(), java_lang_Class::as_klassOop(ptypes->obj_at(0)));
+ err = check_method_receiver(m(), java_lang_Class::as_klassOop(ptypes->obj_at(first_ptype_pos-1)));
if (err != NULL) goto die;
}
@@ -983,7 +1030,8 @@
int insert_argnum, oop insert_type,
int change_argnum, oop change_type,
int delete_argnum,
- oop dst_mtype, int dst_beg, int dst_end) {
+ oop dst_mtype, int dst_beg, int dst_end,
+ bool raw) {
objArrayOop src_ptypes = java_dyn_MethodType::ptypes(src_mtype);
objArrayOop dst_ptypes = java_dyn_MethodType::ptypes(dst_mtype);
@@ -1042,7 +1090,7 @@
if (src_type != dst_type) {
if (src_type == NULL) return "not enough arguments";
if (dst_type == NULL) return "too many arguments";
- err = check_argument_type_change(src_type, dst_type, dst_idx);
+ err = check_argument_type_change(src_type, dst_type, dst_idx, raw);
if (err != NULL) return err;
}
}
@@ -1051,7 +1099,7 @@
oop src_rtype = java_dyn_MethodType::rtype(src_mtype);
oop dst_rtype = java_dyn_MethodType::rtype(dst_mtype);
if (src_rtype != dst_rtype) {
- err = check_return_type_change(dst_rtype, src_rtype); // note reversal!
+ err = check_return_type_change(dst_rtype, src_rtype, raw); // note reversal!
if (err != NULL) return err;
}
@@ -1061,38 +1109,45 @@
const char* MethodHandles::check_argument_type_change(BasicType src_type,
- klassOop src_klass,
- BasicType dst_type,
- klassOop dst_klass,
- int argnum) {
+ klassOop src_klass,
+ BasicType dst_type,
+ klassOop dst_klass,
+ int argnum,
+ bool raw) {
const char* err = NULL;
+ bool for_return = (argnum < 0);
// just in case:
if (src_type == T_ARRAY) src_type = T_OBJECT;
if (dst_type == T_ARRAY) dst_type = T_OBJECT;
// Produce some nice messages if VerifyMethodHandles is turned on:
- if (!same_basic_type_for_arguments(src_type, dst_type, (argnum < 0))) {
+ if (!same_basic_type_for_arguments(src_type, dst_type, raw, for_return)) {
if (src_type == T_OBJECT) {
+ if (raw && dst_type == T_INT && is_always_null_type(src_klass))
+ return NULL; // OK to convert a null pointer to a garbage int
err = ((argnum >= 0)
? "type mismatch: passing a %s for method argument #%d, which expects primitive %s"
: "type mismatch: returning a %s, but caller expects primitive %s");
} else if (dst_type == T_OBJECT) {
- err = ((argnum < 0)
+ err = ((argnum >= 0)
? "type mismatch: passing a primitive %s for method argument #%d, which expects %s"
: "type mismatch: returning a primitive %s, but caller expects %s");
} else {
- err = ((argnum < 0)
+ err = ((argnum >= 0)
? "type mismatch: passing a %s for method argument #%d, which expects %s"
: "type mismatch: returning a %s, but caller expects %s");
}
- } else if (src_type == T_OBJECT && class_cast_needed(src_klass, dst_klass)) {
+ } else if (src_type == T_OBJECT && dst_type == T_OBJECT &&
+ class_cast_needed(src_klass, dst_klass)) {
if (!class_cast_needed(dst_klass, src_klass)) {
- err = ((argnum < 0)
+ if (raw)
+ return NULL; // reverse cast is OK; the MH target is trusted to enforce it
+ err = ((argnum >= 0)
? "cast required: passing a %s for method argument #%d, which expects %s"
: "cast required: returning a %s, but caller expects %s");
} else {
- err = ((argnum < 0)
+ err = ((argnum >= 0)
? "reference mismatch: passing a %s for method argument #%d, which expects %s"
: "reference mismatch: returning a %s, but caller expects %s");
}
@@ -1429,10 +1484,10 @@
assert(this_pushes == slots_pushed, "BMH pushes one or two stack slots");
assert(slots_pushed <= MethodHandlePushLimit, "");
} else {
- int prev_pushes = decode_MethodHandle_stack_pushes(target());
- assert(this_pushes == slots_pushed + prev_pushes, "BMH stack motion must be correct");
+ int target_pushes = decode_MethodHandle_stack_pushes(target());
+ assert(this_pushes == slots_pushed + target_pushes, "BMH stack motion must be correct");
// do not blow the stack; use a Java-based adapter if this limit is exceeded
- if (slots_pushed + prev_pushes > MethodHandlePushLimit)
+ if (slots_pushed + target_pushes > MethodHandlePushLimit)
err = "too many bound parameters";
}
}
@@ -1588,6 +1643,11 @@
if (err == NULL) {
// Check that the src/dest types are supplied if needed.
switch (ek) {
+ case _adapter_check_cast:
+ if (src != T_OBJECT || dest != T_OBJECT) {
+ err = "adapter requires object src/dest conversion subfields";
+ }
+ break;
case _adapter_prim_to_prim:
if (!is_java_primitive(src) || !is_java_primitive(dest) || src == dest) {
err = "adapter requires primitive src/dest conversion subfields"; break;
@@ -1616,9 +1676,9 @@
err = "adapter requires src/dest conversion subfields for swap"; break;
}
int swap_size = type2size[src];
- oop src_mtype = sun_dyn_AdapterMethodHandle::type(target());
- oop dest_mtype = sun_dyn_AdapterMethodHandle::type(mh());
- int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(src_mtype);
+ oop src_mtype = sun_dyn_AdapterMethodHandle::type(mh());
+ oop dest_mtype = sun_dyn_AdapterMethodHandle::type(target());
+ int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(target());
int src_slot = argslot;
int dest_slot = vminfo;
bool rotate_up = (src_slot > dest_slot); // upward rotation
@@ -1729,22 +1789,22 @@
// Make sure this adapter does not push too deeply.
int slots_pushed = stack_move / stack_move_unit();
int this_vmslots = java_dyn_MethodHandle::vmslots(mh());
- int prev_vmslots = java_dyn_MethodHandle::vmslots(target());
- if (slots_pushed != (this_vmslots - prev_vmslots)) {
+ int target_vmslots = java_dyn_MethodHandle::vmslots(target());
+ if (slots_pushed != (target_vmslots - this_vmslots)) {
err = "stack_move inconsistent with previous and current MethodType vmslots";
} else if (slots_pushed > 0) {
// verify stack_move against MethodHandlePushLimit
- int prev_pushes = decode_MethodHandle_stack_pushes(target());
+ int target_pushes = decode_MethodHandle_stack_pushes(target());
// do not blow the stack; use a Java-based adapter if this limit is exceeded
- if (slots_pushed + prev_pushes > MethodHandlePushLimit) {
+ if (slots_pushed + target_pushes > MethodHandlePushLimit) {
err = "adapter pushes too many parameters";
}
}
// While we're at it, check that the stack motion decoder works:
- DEBUG_ONLY(int prev_pushes = decode_MethodHandle_stack_pushes(target()));
+ DEBUG_ONLY(int target_pushes = decode_MethodHandle_stack_pushes(target()));
DEBUG_ONLY(int this_pushes = decode_MethodHandle_stack_pushes(mh()));
- assert(this_pushes == slots_pushed + prev_pushes, "AMH stack motion must be correct");
+ assert(this_pushes == slots_pushed + target_pushes, "AMH stack motion must be correct");
}
if (err == NULL && vminfo != 0) {
@@ -1761,7 +1821,11 @@
if (err == NULL) {
switch (ek) {
case _adapter_retype_only:
- err = check_method_type_passthrough(src_mtype(), dst_mtype());
+ err = check_method_type_passthrough(src_mtype(), dst_mtype(), false);
+ break;
+
+ case _adapter_retype_raw:
+ err = check_method_type_passthrough(src_mtype(), dst_mtype(), true);
break;
case _adapter_check_cast:
@@ -1821,6 +1885,7 @@
// Now it's time to finish the case analysis and pick a MethodHandleEntry.
switch (ek_orig) {
case _adapter_retype_only:
+ case _adapter_retype_raw:
case _adapter_check_cast:
case _adapter_dup_args:
case _adapter_drop_args:
@@ -1888,8 +1953,7 @@
case _adapter_rot_args:
{
int swap_slots = type2size[src];
- oop mtype = sun_dyn_AdapterMethodHandle::type(mh());
- int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(mtype);
+ int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(mh());
int src_slot = argslot;
int dest_slot = vminfo;
int rotate = (ek_orig == _adapter_swap_args) ? 0 : (src_slot > dest_slot) ? 1 : -1;
@@ -2133,7 +2197,7 @@
guarantee(MethodHandlePushLimit >= 2 && MethodHandlePushLimit <= 0xFF,
"MethodHandlePushLimit parameter must be in valid range");
return MethodHandlePushLimit;
- case MethodHandles::GC_JVM_STACK_MOVE_LIMIT:
+ case MethodHandles::GC_JVM_STACK_MOVE_UNIT:
// return number of words per slot, signed according to stack direction
return MethodHandles::stack_move_unit();
}
@@ -2144,7 +2208,7 @@
#ifndef PRODUCT
#define EACH_NAMED_CON(template) \
template(MethodHandles,GC_JVM_PUSH_LIMIT) \
- template(MethodHandles,GC_JVM_STACK_MOVE_LIMIT) \
+ template(MethodHandles,GC_JVM_STACK_MOVE_UNIT) \
template(MethodHandles,ETF_HANDLE_OR_METHOD_NAME) \
template(MethodHandles,ETF_DIRECT_HANDLE) \
template(MethodHandles,ETF_METHOD_NAME) \
@@ -2157,6 +2221,7 @@
template(sun_dyn_MemberName,MN_SEARCH_INTERFACES) \
template(sun_dyn_MemberName,VM_INDEX_UNINITIALIZED) \
template(sun_dyn_AdapterMethodHandle,OP_RETYPE_ONLY) \
+ template(sun_dyn_AdapterMethodHandle,OP_RETYPE_RAW) \
template(sun_dyn_AdapterMethodHandle,OP_CHECK_CAST) \
template(sun_dyn_AdapterMethodHandle,OP_PRIM_TO_PRIM) \
template(sun_dyn_AdapterMethodHandle,OP_REF_TO_PRIM) \
@@ -2345,10 +2410,12 @@
// note: this explicit warning-producing stuff will be replaced by auto-detection of the JSR 292 classes
if (!EnableMethodHandles) {
- warning("JSR 292 method handles are disabled in this JVM. Use -XX:+EnableMethodHandles to enable.");
+ warning("JSR 292 method handles are disabled in this JVM. Use -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles to enable.");
return; // bind nothing
}
+ bool enable_MH = true;
+
{
ThreadToNativeFromVM ttnfv(thread);
@@ -2356,14 +2423,33 @@
if (env->ExceptionOccurred()) {
MethodHandles::set_enabled(false);
warning("JSR 292 method handle code is mismatched to this JVM. Disabling support.");
+ enable_MH = false;
env->ExceptionClear();
- } else {
- MethodHandles::set_enabled(true);
}
}
+ if (enable_MH) {
+ KlassHandle MHI_klass = SystemDictionaryHandles::MethodHandleImpl_klass();
+ if (MHI_klass.not_null()) {
+ symbolHandle raiseException_name = oopFactory::new_symbol_handle("raiseException", CHECK);
+ symbolHandle raiseException_sig = oopFactory::new_symbol_handle("(ILjava/lang/Object;Ljava/lang/Object;)V", CHECK);
+ methodOop raiseException_method = instanceKlass::cast(MHI_klass->as_klassOop())
+ ->find_method(raiseException_name(), raiseException_sig());
+ if (raiseException_method != NULL && raiseException_method->is_static()) {
+ MethodHandles::set_raise_exception_method(raiseException_method);
+ } else {
+ warning("JSR 292 method handle code is mismatched to this JVM. Disabling support.");
+ enable_MH = false;
+ }
+ }
+ }
+
+ if (enable_MH) {
+ MethodHandles::set_enabled(true);
+ }
+
if (!EnableInvokeDynamic) {
- warning("JSR 292 invokedynamic is disabled in this JVM. Use -XX:+EnableInvokeDynamic to enable.");
+ warning("JSR 292 invokedynamic is disabled in this JVM. Use -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic to enable.");
return; // bind nothing
}