jdk8-mips64-public/hotspot: comparison src/share/vm/prims/methodHandles.cpp

-:71fdc5052e49
+:987e948ebbc8
 bool MethodHandles::_enabled = false; // set true after successful native linkage
 MethodHandleEntry* MethodHandles::_entries[MethodHandles::_EK_LIMIT] = {NULL};
 const char*        MethodHandles::_entry_names[_EK_LIMIT+1] = {
-"check_mtype",
+"raise_exception",
-"wrong_method_type",          // what happens when there is a type mismatch
 "invokestatic",               // how a MH emulates invokestatic
 "invokespecial",              // ditto for the other invokes...
 "invokevirtual",
 "invokeinterface",
 "bound_ref",                  // these are for BMH...
 "bound_int_direct",
 "bound_long_direct",
 // 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",
 "adapter_prim_to_ref",
 "adapter_swap_args",
 "adapter_spread_args/more",
 NULL
 };
+jobject MethodHandles::_raise_exception_method;
 #ifdef ASSERT
 bool MethodHandles::spot_check_entry_names() {
 assert(!strcmp(entry_name(_invokestatic_mh), "invokestatic"), "");
 assert(!strcmp(entry_name(_bound_ref_mh), "bound_ref"), "");
 assert(!strcmp(entry_name(_adapter_retype_only), "adapter_retype_only"), "");
 oop mtype    = sun_dyn_DirectMethodHandle::type(mh);
 return decode_vmtarget(vmtarget, vmindex, mtype, receiver_limit_result, decode_flags_result);
 }
 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);
 if (target == NULL)  return NULL;
 decode_flags_result |= MethodHandles::_dmf_binds_argument;
 //assert(tk == SystemDictionary::DirectMethodHandle_klass(), "end of BMH chain must be DMH");
 return decode_MethodHandle(target, receiver_limit_result, decode_flags_result);
 } 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;
 }
 }
 }
 return decode_DirectMethodHandle(mh, receiver_limit_result, decode_flags_result);
 } else if (mhk == SystemDictionary::BoundMethodHandle_klass()) {
 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?
 }
 }
 int flags  = sun_dyn_MemberName::flags(mname);
 if ((flags & (IS_METHOD | IS_CONSTRUCTOR)) == 0)  return NULL;  // not invocable
 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.
 // Resolving it plants a vmtarget/vmindex in it,
 // which refers dirctly to JVM internals.
 char msg[50];
 jio_snprintf(msg, sizeof(msg), "unknown getTarget format=%d", format);
 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
 Klass* srck = Klass::cast(src);
 Klass* dstk = Klass::cast(dst);
 if (srck->is_interface()) {
 // interface arguments must be viewed as untyped
 //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());
 }
 static oop object_java_mirror() {
 return Klass::cast(SystemDictionary::object_klass())->java_mirror();
 }
 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) {
-if (for_return && dst == T_VOID)  return true;
+// 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;
 // allow reinterpretation casts for integral widening
 if (is_subword_type(src)) { // subwords can fit in int or other subwords
 bool m_needs_receiver = !m->is_static();
 const char* err = NULL;
 int first_ptype_pos = m_needs_receiver ? 1 : 0;
-if (has_bound_recv && err == NULL) {
+if (has_bound_recv) {
-first_ptype_pos -= 1;
+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; }
 }
 if (m_needs_receiver && err == NULL) {
 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;
 }
 // Check the other arguments for mistypes.
 verify_method_signature(m, mtype, first_ptype_pos, bound_recv_type, CHECK);
 // Return NULL if all is well, else a short error message.
 const char* MethodHandles::check_method_type_change(oop src_mtype, int src_beg, int src_end,
 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);
 int src_max = src_ptypes->length();
 int dst_max = dst_ptypes->length();
 // Compare the two argument types.
 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;
 }
 }
 // Now compare return types also.
 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;
 }
 assert(err == NULL, "");
 return NULL;  // all is well
 }
 const char* MethodHandles::check_argument_type_change(BasicType src_type,
 klassOop src_klass,
 BasicType dst_type,
 klassOop dst_klass,
-int argnum) {
+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");
 }
 } else {
 // passed the obstacle course
 DEBUG_ONLY(int this_pushes = decode_MethodHandle_stack_pushes(mh()));
 if (direct_to_method) {
 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());
+int target_pushes = decode_MethodHandle_stack_pushes(target());
-assert(this_pushes == slots_pushed + prev_pushes, "BMH stack motion must be correct");
+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";
 }
 }
 if (err == NULL) {
 }
 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;
 }
 if ( (src == T_FLOAT || src == T_DOUBLE) && !(dest == T_FLOAT || dest == T_DOUBLE) ||
 {
 if (!src || src != dest) {
 err = "adapter requires src/dest conversion subfields for swap"; break;
 }
 int swap_size = type2size[src];
-oop src_mtype  = sun_dyn_AdapterMethodHandle::type(target());
+oop src_mtype  = sun_dyn_AdapterMethodHandle::type(mh());
-oop dest_mtype = sun_dyn_AdapterMethodHandle::type(mh());
+oop dest_mtype = sun_dyn_AdapterMethodHandle::type(target());
-int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(src_mtype);
+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
 int src_arg    = argnum;
 int dest_arg   = argument_slot_to_argnum(dest_mtype, dest_slot);
 if (err == NULL) {
 // 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());
+int target_vmslots = java_dyn_MethodHandle::vmslots(target());
-if (slots_pushed != (this_vmslots - prev_vmslots)) {
+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) {
 switch (ek) {
 case _adapter_swap_args:
 // Do additional ad hoc checks.
 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:
 {
 // The actual value being checked must be a reference:
 const char* err = NULL;
 // 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:
 // these work fine via general case code
 break;
 case _adapter_swap_args:
 case _adapter_rot_args:
 {
 int swap_slots = type2size[src];
-oop mtype      = sun_dyn_AdapterMethodHandle::type(mh());
+int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(mh());
-int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(mtype);
 int src_slot   = argslot;
 int dest_slot  = vminfo;
 int rotate     = (ek_orig == _adapter_swap_args) ? 0 : (src_slot > dest_slot) ? 1 : -1;
 switch (swap_slots) {
 case 1:
 switch (which) {
 case MethodHandles::GC_JVM_PUSH_LIMIT:
 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();
 }
 return 0;
 }
 JVM_END
 #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) \
 template(MethodHandles,ETF_REFLECT_METHOD) \
 template(sun_dyn_MemberName,MN_IS_METHOD) \
 template(sun_dyn_MemberName,MN_IS_TYPE) \
 template(sun_dyn_MemberName,MN_SEARCH_SUPERCLASSES) \
 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) \
 template(sun_dyn_AdapterMethodHandle,OP_PRIM_TO_REF) \
 template(sun_dyn_AdapterMethodHandle,OP_SWAP_ARGS) \
 assert(MethodHandles::spot_check_entry_names(), "entry enum is OK");
 // 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);
 int status = env->RegisterNatives(MHN_class, methods, sizeof(methods)/sizeof(JNINativeMethod));
 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
 }
 {
 ThreadToNativeFromVM ttnfv(thread);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/prims/methodHandles.cpp

src/share/vm/prims/methodHandles.cpp