1082 return false;
1083 }
1084 if (srck->is_interface()) {
1085 // interface arguments must be viewed as untyped
1086 //srck = Klass::cast(SystemDictionary::Object_klass());
1087 return true;
1088 }
1089 if (is_always_null_type(src)) {
1090 // some source types are known to be never instantiated;
1091 // they represent references which are always null
1092 // such null references never fail to convert safely
1093 return false;
1094 }
1095 return !srck->is_subclass_of(dstk->as_klassOop());
1096 }
1097
1098 static oop object_java_mirror() {
1099 return Klass::cast(SystemDictionary::Object_klass())->java_mirror();
1100 }
1101
1102 bool MethodHandles::same_basic_type_for_arguments(BasicType src,
1103 BasicType dst,
1104 bool raw,
1105 bool for_return) {
1106 if (for_return) {
1107 // return values can always be forgotten:
1108 if (dst == T_VOID) return true;
1109 if (src == T_VOID) return raw && (dst == T_INT);
1110 // We allow caller to receive a garbage int, which is harmless.
1111 // This trick is pulled by trusted code (see VerifyType.canPassRaw).
1112 }
1113 assert(src != T_VOID && dst != T_VOID, "should not be here");
1114 if (src == dst) return true;
1115 if (type2size[src] != type2size[dst]) return false;
1116 if (src == T_OBJECT || dst == T_OBJECT) return false;
1117 if (raw) return true; // bitwise reinterpretation; caller guarantees safety
1118 // allow reinterpretation casts for integral widening
1119 if (is_subword_type(src)) { // subwords can fit in int or other subwords
1120 if (dst == T_INT) // any subword fits in an int
1121 return true;
1122 if (src == T_BOOLEAN) // boolean fits in any subword
1123 return is_subword_type(dst);
1124 if (src == T_BYTE && dst == T_SHORT)
1125 return true; // remaining case: byte fits in short
1126 }
1127 // allow float/fixed reinterpretation casts
1128 if (src == T_FLOAT) return dst == T_INT;
1129 if (src == T_INT) return dst == T_FLOAT;
1130 if (src == T_DOUBLE) return dst == T_LONG;
1131 if (src == T_LONG) return dst == T_DOUBLE;
1132 return false;
1133 }
1134
1135 const char* MethodHandles::check_method_receiver(methodOop m,
1136 klassOop passed_recv_type) {
1137 assert(!m->is_static(), "caller resp.");
1138 if (passed_recv_type == NULL)
1139 return "receiver type is primitive";
1140 if (class_cast_needed(passed_recv_type, m->method_holder())) {
1141 Klass* formal = Klass::cast(m->method_holder());
1142 return SharedRuntime::generate_class_cast_message("receiver type",
1143 formal->external_name());
1144 }
1145 return NULL; // checks passed
1146 }
1147
1148 // Verify that m's signature can be called type-safely by a method handle
1149 // of the given method type 'mtype'.
1150 // It takes a TRAPS argument because it must perform symbol lookups.
1151 void MethodHandles::verify_method_signature(methodHandle m,
1382 // Now compare return types also.
1383 oop src_rtype = java_lang_invoke_MethodType::rtype(src_mtype);
1384 oop dst_rtype = java_lang_invoke_MethodType::rtype(dst_mtype);
1385 if (src_rtype != dst_rtype) {
1386 err = check_return_type_change(dst_rtype, src_rtype, raw); // note reversal!
1387 if (err != NULL) return err;
1388 }
1389
1390 assert(err == NULL, "");
1391 return NULL; // all is well
1392 }
1393
1394
1395 const char* MethodHandles::check_argument_type_change(BasicType src_type,
1396 klassOop src_klass,
1397 BasicType dst_type,
1398 klassOop dst_klass,
1399 int argnum,
1400 bool raw) {
1401 const char* err = NULL;
1402 bool for_return = (argnum < 0);
1403
1404 // just in case:
1405 if (src_type == T_ARRAY) src_type = T_OBJECT;
1406 if (dst_type == T_ARRAY) dst_type = T_OBJECT;
1407
1408 // Produce some nice messages if VerifyMethodHandles is turned on:
1409 if (!same_basic_type_for_arguments(src_type, dst_type, raw, for_return)) {
1410 if (src_type == T_OBJECT) {
1411 if (raw && dst_type == T_INT && is_always_null_type(src_klass))
1412 return NULL; // OK to convert a null pointer to a garbage int
1413 err = ((argnum >= 0)
1414 ? "type mismatch: passing a %s for method argument #%d, which expects primitive %s"
1415 : "type mismatch: returning a %s, but caller expects primitive %s");
1416 } else if (dst_type == T_OBJECT) {
1417 err = ((argnum >= 0)
1418 ? "type mismatch: passing a primitive %s for method argument #%d, which expects %s"
1419 : "type mismatch: returning a primitive %s, but caller expects %s");
1420 } else {
1421 err = ((argnum >= 0)
1422 ? "type mismatch: passing a %s for method argument #%d, which expects %s"
1423 : "type mismatch: returning a %s, but caller expects %s");
1424 }
1425 } else if (src_type == T_OBJECT && dst_type == T_OBJECT &&
1426 class_cast_needed(src_klass, dst_klass)) {
1427 if (!class_cast_needed(dst_klass, src_klass)) {
1428 if (raw)
1429 return NULL; // reverse cast is OK; the MH target is trusted to enforce it
1430 err = ((argnum >= 0)
1431 ? "cast required: passing a %s for method argument #%d, which expects %s"
1432 : "cast required: returning a %s, but caller expects %s");
1433 } else {
1434 err = ((argnum >= 0)
1435 ? "reference mismatch: passing a %s for method argument #%d, which expects %s"
1436 : "reference mismatch: returning a %s, but caller expects %s");
1437 }
1438 } else {
1439 // passed the obstacle course
1440 return NULL;
1441 }
1442
1443 // format, format, format
1444 const char* src_name = type2name(src_type);
1445 const char* dst_name = type2name(dst_type);
1446 if (src_name == NULL) src_name = "unknown type";
1447 if (dst_name == NULL) dst_name = "unknown type";
1448 if (src_type == T_OBJECT)
1449 src_name = (src_klass != NULL) ? Klass::cast(src_klass)->external_name() : "an unresolved class";
1450 if (dst_type == T_OBJECT)
1451 dst_name = (dst_klass != NULL) ? Klass::cast(dst_klass)->external_name() : "an unresolved class";
1452
1453 size_t msglen = strlen(err) + strlen(src_name) + strlen(dst_name) + (argnum < 10 ? 1 : 11);
1454 char* msg = NEW_RESOURCE_ARRAY(char, msglen + 1);
1455 if (argnum >= 0) {
1456 assert(strstr(err, "%d") != NULL, "");
1457 jio_snprintf(msg, msglen, err, src_name, argnum, dst_name);
1458 } else {
1459 assert(strstr(err, "%d") == NULL, "");
1460 jio_snprintf(msg, msglen, err, src_name, dst_name);
1461 }
1462 return msg;
1463 }
1464
1465 // Compute the depth within the stack of the given argument, i.e.,
1466 // the combined size of arguments to the right of the given argument.
1467 // For the last argument (ptypes.length-1) this will be zero.
1468 // For the first argument (0) this will be the size of all
1469 // arguments but that one. For the special number -1, this
1470 // will be the size of all arguments, including the first.
1471 // If the argument is neither -1 nor a valid argument index,
1472 // then return a negative number. Otherwise, the result
1473 // is in the range [0..vmslots] inclusive.
1474 int MethodHandles::argument_slot(oop method_type, int arg) {
1475 objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(method_type);
2163 // The output of the cast must fit with the destination argument:
2164 Handle cast_class = argument;
2165 err = check_method_type_conversion(src_mtype(),
2166 argnum, cast_class(),
2167 dst_mtype());
2168 }
2169 break;
2170
2171 // %%% TO DO: continue in remaining cases to verify src/dst_mtype if VerifyMethodHandles
2172 }
2173 }
2174
2175 if (err != NULL) {
2176 throw_InternalError_for_bad_conversion(conversion, err, THREAD);
2177 return;
2178 }
2179
2180 }
2181
2182 void MethodHandles::init_AdapterMethodHandle(Handle mh, Handle target, int argnum, TRAPS) {
2183 int argslot = java_lang_invoke_AdapterMethodHandle::vmargslot(mh());
2184 jint conversion = java_lang_invoke_AdapterMethodHandle::conversion(mh());
2185 jint conv_op = adapter_conversion_op(conversion);
2186
2187 // adjust the adapter code to the internal EntryKind enumeration:
2188 EntryKind ek_orig = adapter_entry_kind(conv_op);
2189 EntryKind ek_opt = ek_orig; // may be optimized
2190 EntryKind ek_try; // temp
2191
2192 // Finalize the vmtarget field (Java initialized it to null).
2193 if (!java_lang_invoke_MethodHandle::is_instance(target())) {
2194 throw_InternalError_for_bad_conversion(conversion, "bad target", THREAD);
2195 return;
2196 }
2197 java_lang_invoke_AdapterMethodHandle::set_vmtarget(mh(), target());
2198
2199 int stack_move = adapter_conversion_stack_move(conversion);
2200 BasicType src = adapter_conversion_src_type(conversion);
2201 BasicType dest = adapter_conversion_dest_type(conversion);
2202 int vminfo = adapter_conversion_vminfo(conversion); // should be zero
2224 break;
2225
2226 case _adapter_prim_to_prim:
2227 {
2228 // Non-subword cases are {int,float,long,double} -> {int,float,long,double}.
2229 // And, the {float,double} -> {int,long} cases must be handled by Java.
2230 switch (type2size[src] *4+ type2size[dest]) {
2231 case 1 *4+ 1:
2232 assert(src == T_INT || is_subword_type(src), "source is not float");
2233 // Subword-related cases are int -> {boolean,byte,char,short}.
2234 ek_opt = _adapter_opt_i2i;
2235 vminfo = adapter_prim_to_prim_subword_vminfo(dest);
2236 break;
2237 case 2 *4+ 1:
2238 if (src == T_LONG && (dest == T_INT || is_subword_type(dest))) {
2239 ek_opt = _adapter_opt_l2i;
2240 vminfo = adapter_prim_to_prim_subword_vminfo(dest);
2241 } else if (src == T_DOUBLE && dest == T_FLOAT) {
2242 ek_opt = _adapter_opt_d2f;
2243 } else {
2244 assert(false, "");
2245 }
2246 break;
2247 case 1 *4+ 2:
2248 if ((src == T_INT || is_subword_type(src)) && dest == T_LONG) {
2249 ek_opt = _adapter_opt_i2l;
2250 } else if (src == T_FLOAT && dest == T_DOUBLE) {
2251 ek_opt = _adapter_opt_f2d;
2252 } else {
2253 assert(false, "");
2254 }
2255 break;
2256 default:
2257 assert(false, "");
2258 break;
2259 }
2260 }
2261 break;
2262
2263 case _adapter_ref_to_prim:
2264 {
2265 switch (type2size[dest]) {
2266 case 1:
2267 ek_opt = _adapter_opt_unboxi;
2268 vminfo = adapter_unbox_subword_vminfo(dest);
2269 break;
2270 case 2:
2271 ek_opt = _adapter_opt_unboxl;
2272 break;
2273 default:
2274 assert(false, "");
2275 break;
2276 }
2277 }
2278 break;
2279
2280 case _adapter_prim_to_ref:
2281 {
2282 assert(UseRicochetFrames, "else don't come here");
2283 // vminfo will be the location to insert the return value
2284 vminfo = argslot;
2285 ek_opt = _adapter_opt_collect_ref;
2286 ensure_vmlayout_field(target, CHECK);
2287 if (!OptimizeMethodHandles) break;
2288 switch (type2size[src]) {
2289 case 1:
2290 ek_try = EntryKind(_adapter_opt_filter_S0_ref + argslot);
2291 if (ek_try < _adapter_opt_collect_LAST &&
2292 ek_adapter_opt_collect_slot(ek_try) == argslot) {
2293 assert(ek_adapter_opt_collect_count(ek_try) == 1 &&
2294 ek_adapter_opt_collect_type(ek_try) == T_OBJECT, "");
2295 ek_opt = ek_try;
2296 break;
2297 }
2298 // else downgrade to variable slot:
2299 ek_opt = _adapter_opt_collect_1_ref;
2300 break;
2301 case 2:
2302 ek_try = EntryKind(_adapter_opt_collect_2_S0_ref + argslot);
2303 if (ek_try < _adapter_opt_collect_LAST &&
2304 ek_adapter_opt_collect_slot(ek_try) == argslot) {
2305 assert(ek_adapter_opt_collect_count(ek_try) == 2 &&
2306 ek_adapter_opt_collect_type(ek_try) == T_OBJECT, "");
2307 ek_opt = ek_try;
2308 break;
2309 }
2310 // else downgrade to variable slot:
2311 ek_opt = _adapter_opt_collect_2_ref;
2312 break;
2313 default:
2314 assert(false, "");
2315 break;
2316 }
2317 }
2318 break;
2319
2320 case _adapter_swap_args:
2321 case _adapter_rot_args:
2322 {
2323 int swap_slots = type2size[src];
2324 int slot_limit = java_lang_invoke_AdapterMethodHandle::vmslots(mh());
2325 int src_slot = argslot;
2326 int dest_slot = vminfo;
2327 int rotate = (ek_orig == _adapter_swap_args) ? 0 : (src_slot > dest_slot) ? 1 : -1;
2328 switch (swap_slots) {
2329 case 1:
2330 ek_opt = (!rotate ? _adapter_opt_swap_1 :
2331 rotate > 0 ? _adapter_opt_rot_1_up : _adapter_opt_rot_1_down);
2332 break;
2333 case 2:
2334 ek_opt = (!rotate ? _adapter_opt_swap_2 :
2335 rotate > 0 ? _adapter_opt_rot_2_up : _adapter_opt_rot_2_down);
2336 break;
2337 default:
2338 assert(false, "");
2339 break;
2340 }
2341 }
2342 break;
2343
2344 case _adapter_spread_args:
2345 {
2346 #ifdef TARGET_ARCH_NYI_6939861
2347 // ports before 6939861 supported only three kinds of spread ops
2348 if (!UseRicochetFrames) {
2349 int array_size = slots_pushed + 1;
2350 assert(array_size >= 0, "");
2351 vminfo = array_size;
2352 switch (array_size) {
2353 case 0: ek_opt = _adapter_opt_spread_0; break;
2354 case 1: ek_opt = _adapter_opt_spread_1; break;
2355 default: ek_opt = _adapter_opt_spread_more; break;
2356 }
2357 break;
2358 }
2385 // since the general case does not handle length 0, this case is required:
2386 ek_opt = _adapter_opt_spread_0;
2387 break;
2388 }
2389 if (dest == T_OBJECT) {
2390 ek_try = EntryKind(_adapter_opt_spread_1_ref - 1 + array_size);
2391 if (ek_try < _adapter_opt_spread_LAST &&
2392 ek_adapter_opt_spread_count(ek_try) == array_size) {
2393 assert(ek_adapter_opt_spread_type(ek_try) == dest, "");
2394 ek_opt = ek_try;
2395 break;
2396 }
2397 }
2398 break;
2399 }
2400 break;
2401
2402 case _adapter_collect_args:
2403 {
2404 assert(UseRicochetFrames, "else don't come here");
2405 int elem_slots = argument_slot_count(
2406 java_lang_invoke_MethodHandle::type(
2407 java_lang_invoke_AdapterMethodHandle::argument(mh()) ) );
2408 // vminfo will be the location to insert the return value
2409 vminfo = argslot;
2410 ensure_vmlayout_field(target, CHECK);
2411
2412 // general case:
2413 switch (dest) {
2414 default : if (!is_subword_type(dest)) goto throw_not_impl;
2415 // else fall through:
2416 case T_INT : ek_opt = _adapter_opt_collect_int; break;
2417 case T_LONG : ek_opt = _adapter_opt_collect_long; break;
2418 case T_FLOAT : ek_opt = _adapter_opt_collect_float; break;
2419 case T_DOUBLE : ek_opt = _adapter_opt_collect_double; break;
2420 case T_OBJECT : ek_opt = _adapter_opt_collect_ref; break;
2421 case T_VOID : ek_opt = _adapter_opt_collect_void; break;
2422 }
2423 assert(ek_adapter_opt_collect_slot(ek_opt) == -1 &&
2424 ek_adapter_opt_collect_count(ek_opt) == -1 &&
2425 (ek_adapter_opt_collect_type(ek_opt) == dest ||
2426 ek_adapter_opt_collect_type(ek_opt) == T_INT && is_subword_type(dest)),
2427 "");
2428
2429 if (dest == T_OBJECT && elem_slots == 1 && OptimizeMethodHandles) {
2430 // filter operation on a ref
2455 }
2456
2457 if (dest == T_OBJECT && OptimizeMethodHandles) {
2458 // try to use a fixed length adapter
2459 ek_try = EntryKind(_adapter_opt_collect_0_ref + elem_slots);
2460 if (ek_try < _adapter_opt_collect_LAST &&
2461 ek_adapter_opt_collect_count(ek_try) == elem_slots) {
2462 assert(ek_adapter_opt_collect_slot(ek_try) == -1 &&
2463 ek_adapter_opt_collect_type(ek_try) == dest, "");
2464 ek_opt = ek_try;
2465 break;
2466 }
2467 }
2468
2469 break;
2470 }
2471
2472 case _adapter_fold_args:
2473 {
2474 assert(UseRicochetFrames, "else don't come here");
2475 int elem_slots = argument_slot_count(
2476 java_lang_invoke_MethodHandle::type(
2477 java_lang_invoke_AdapterMethodHandle::argument(mh()) ) );
2478 // vminfo will be the location to insert the return value
2479 vminfo = argslot + elem_slots;
2480 ensure_vmlayout_field(target, CHECK);
2481
2482 switch (dest) {
2483 default : if (!is_subword_type(dest)) goto throw_not_impl;
2484 // else fall through:
2485 case T_INT : ek_opt = _adapter_opt_fold_int; break;
2486 case T_LONG : ek_opt = _adapter_opt_fold_long; break;
2487 case T_FLOAT : ek_opt = _adapter_opt_fold_float; break;
2488 case T_DOUBLE : ek_opt = _adapter_opt_fold_double; break;
2489 case T_OBJECT : ek_opt = _adapter_opt_fold_ref; break;
2490 case T_VOID : ek_opt = _adapter_opt_fold_void; break;
2491 }
2492 assert(ek_adapter_opt_collect_slot(ek_opt) == -1 &&
2493 ek_adapter_opt_collect_count(ek_opt) == -1 &&
2494 (ek_adapter_opt_collect_type(ek_opt) == dest ||
2495 ek_adapter_opt_collect_type(ek_opt) == T_INT && is_subword_type(dest)),
2496 "");
2497
2498 if (dest == T_OBJECT && elem_slots == 0 && OptimizeMethodHandles) {
2499 // if there are no args, just pretend it's a collect
2500 ek_opt = _adapter_opt_collect_0_ref;
2510 ek_adapter_opt_collect_type(ek_try) == dest, "");
2511 ek_opt = ek_try;
2512 break;
2513 }
2514 }
2515
2516 break;
2517 }
2518
2519 default:
2520 // should have failed much earlier; must be a missing case here
2521 assert(false, "incomplete switch");
2522 // and fall through:
2523
2524 throw_not_impl:
2525 if (err == NULL)
2526 err = "unknown adapter type";
2527 break;
2528 }
2529
2530 if (err != NULL && (vminfo & CONV_VMINFO_MASK) != vminfo) {
2531 // should not happen, since vminfo is used to encode arg/slot indexes < 255
2532 err = "vminfo overflow";
2533 }
2534
2535 if (err != NULL && !have_entry(ek_opt)) {
2536 err = "adapter stub for this kind of method handle is missing";
2537 }
2538
2539 if (err != NULL) {
2540 throw_InternalError_for_bad_conversion(conversion, err, THREAD);
2541 return;
2542 }
2543
2544 // Rebuild the conversion value; maybe parts of it were changed.
2545 jint new_conversion = adapter_conversion(conv_op, src, dest, stack_move, vminfo);
2546
2547 // Finalize the conversion field. (Note that it is final to Java code.)
2548 java_lang_invoke_AdapterMethodHandle::set_conversion(mh(), new_conversion);
2549
2550 // Done!
2551 java_lang_invoke_MethodHandle::set_vmentry(mh(), entry(ek_opt));
2552
2553 // There should be enough memory barriers on exit from native methods
2554 // to ensure that the MH is fully initialized to all threads before
2555 // Java code can publish it in global data structures.
2556 }
2557
2558 void MethodHandles::ensure_vmlayout_field(Handle target, TRAPS) {
|
1082 return false;
1083 }
1084 if (srck->is_interface()) {
1085 // interface arguments must be viewed as untyped
1086 //srck = Klass::cast(SystemDictionary::Object_klass());
1087 return true;
1088 }
1089 if (is_always_null_type(src)) {
1090 // some source types are known to be never instantiated;
1091 // they represent references which are always null
1092 // such null references never fail to convert safely
1093 return false;
1094 }
1095 return !srck->is_subclass_of(dstk->as_klassOop());
1096 }
1097
1098 static oop object_java_mirror() {
1099 return Klass::cast(SystemDictionary::Object_klass())->java_mirror();
1100 }
1101
1102 bool MethodHandles::is_float_fixed_reinterpretation_cast(BasicType src, BasicType dst) {
1103 if (src == T_FLOAT) return dst == T_INT;
1104 if (src == T_INT) return dst == T_FLOAT;
1105 if (src == T_DOUBLE) return dst == T_LONG;
1106 if (src == T_LONG) return dst == T_DOUBLE;
1107 return false;
1108 }
1109
1110 bool MethodHandles::same_basic_type_for_arguments(BasicType src,
1111 BasicType dst,
1112 bool raw,
1113 bool for_return) {
1114 if (for_return) {
1115 // return values can always be forgotten:
1116 if (dst == T_VOID) return true;
1117 if (src == T_VOID) return raw && (dst == T_INT);
1118 // We allow caller to receive a garbage int, which is harmless.
1119 // This trick is pulled by trusted code (see VerifyType.canPassRaw).
1120 }
1121 assert(src != T_VOID && dst != T_VOID, "should not be here");
1122 if (src == dst) return true;
1123 if (type2size[src] != type2size[dst]) return false;
1124 if (src == T_OBJECT || dst == T_OBJECT) return false;
1125 if (raw) return true; // bitwise reinterpretation; caller guarantees safety
1126 // allow reinterpretation casts for integral widening
1127 if (is_subword_type(src)) { // subwords can fit in int or other subwords
1128 if (dst == T_INT) // any subword fits in an int
1129 return true;
1130 if (src == T_BOOLEAN) // boolean fits in any subword
1131 return is_subword_type(dst);
1132 if (src == T_BYTE && dst == T_SHORT)
1133 return true; // remaining case: byte fits in short
1134 }
1135 // allow float/fixed reinterpretation casts
1136 if (is_float_fixed_reinterpretation_cast(src, dst))
1137 return true;
1138 return false;
1139 }
1140
1141 const char* MethodHandles::check_method_receiver(methodOop m,
1142 klassOop passed_recv_type) {
1143 assert(!m->is_static(), "caller resp.");
1144 if (passed_recv_type == NULL)
1145 return "receiver type is primitive";
1146 if (class_cast_needed(passed_recv_type, m->method_holder())) {
1147 Klass* formal = Klass::cast(m->method_holder());
1148 return SharedRuntime::generate_class_cast_message("receiver type",
1149 formal->external_name());
1150 }
1151 return NULL; // checks passed
1152 }
1153
1154 // Verify that m's signature can be called type-safely by a method handle
1155 // of the given method type 'mtype'.
1156 // It takes a TRAPS argument because it must perform symbol lookups.
1157 void MethodHandles::verify_method_signature(methodHandle m,
1388 // Now compare return types also.
1389 oop src_rtype = java_lang_invoke_MethodType::rtype(src_mtype);
1390 oop dst_rtype = java_lang_invoke_MethodType::rtype(dst_mtype);
1391 if (src_rtype != dst_rtype) {
1392 err = check_return_type_change(dst_rtype, src_rtype, raw); // note reversal!
1393 if (err != NULL) return err;
1394 }
1395
1396 assert(err == NULL, "");
1397 return NULL; // all is well
1398 }
1399
1400
1401 const char* MethodHandles::check_argument_type_change(BasicType src_type,
1402 klassOop src_klass,
1403 BasicType dst_type,
1404 klassOop dst_klass,
1405 int argnum,
1406 bool raw) {
1407 const char* err = NULL;
1408 const bool for_return = (argnum < 0);
1409
1410 // just in case:
1411 if (src_type == T_ARRAY) src_type = T_OBJECT;
1412 if (dst_type == T_ARRAY) dst_type = T_OBJECT;
1413
1414 // Produce some nice messages if VerifyMethodHandles is turned on:
1415 if (!same_basic_type_for_arguments(src_type, dst_type, raw, for_return)) {
1416 if (src_type == T_OBJECT) {
1417 if (raw && is_java_primitive(dst_type))
1418 return NULL; // ref-to-prim discards ref and returns zero
1419 err = (!for_return
1420 ? "type mismatch: passing a %s for method argument #%d, which expects primitive %s"
1421 : "type mismatch: returning a %s, but caller expects primitive %s");
1422 } else if (dst_type == T_OBJECT) {
1423 err = (!for_return
1424 ? "type mismatch: passing a primitive %s for method argument #%d, which expects %s"
1425 : "type mismatch: returning a primitive %s, but caller expects %s");
1426 } else {
1427 err = (!for_return
1428 ? "type mismatch: passing a %s for method argument #%d, which expects %s"
1429 : "type mismatch: returning a %s, but caller expects %s");
1430 }
1431 } else if (src_type == T_OBJECT && dst_type == T_OBJECT &&
1432 class_cast_needed(src_klass, dst_klass)) {
1433 if (!class_cast_needed(dst_klass, src_klass)) {
1434 if (raw)
1435 return NULL; // reverse cast is OK; the MH target is trusted to enforce it
1436 err = (!for_return
1437 ? "cast required: passing a %s for method argument #%d, which expects %s"
1438 : "cast required: returning a %s, but caller expects %s");
1439 } else {
1440 err = (!for_return
1441 ? "reference mismatch: passing a %s for method argument #%d, which expects %s"
1442 : "reference mismatch: returning a %s, but caller expects %s");
1443 }
1444 } else {
1445 // passed the obstacle course
1446 return NULL;
1447 }
1448
1449 // format, format, format
1450 const char* src_name = type2name(src_type);
1451 const char* dst_name = type2name(dst_type);
1452 if (src_name == NULL) src_name = "unknown type";
1453 if (dst_name == NULL) dst_name = "unknown type";
1454 if (src_type == T_OBJECT)
1455 src_name = (src_klass != NULL) ? Klass::cast(src_klass)->external_name() : "an unresolved class";
1456 if (dst_type == T_OBJECT)
1457 dst_name = (dst_klass != NULL) ? Klass::cast(dst_klass)->external_name() : "an unresolved class";
1458
1459 size_t msglen = strlen(err) + strlen(src_name) + strlen(dst_name) + (argnum < 10 ? 1 : 11);
1460 char* msg = NEW_RESOURCE_ARRAY(char, msglen + 1);
1461 if (!for_return) {
1462 assert(strstr(err, "%d") != NULL, "");
1463 jio_snprintf(msg, msglen, err, src_name, argnum, dst_name);
1464 } else {
1465 assert(strstr(err, "%d") == NULL, "");
1466 jio_snprintf(msg, msglen, err, src_name, dst_name);
1467 }
1468 return msg;
1469 }
1470
1471 // Compute the depth within the stack of the given argument, i.e.,
1472 // the combined size of arguments to the right of the given argument.
1473 // For the last argument (ptypes.length-1) this will be zero.
1474 // For the first argument (0) this will be the size of all
1475 // arguments but that one. For the special number -1, this
1476 // will be the size of all arguments, including the first.
1477 // If the argument is neither -1 nor a valid argument index,
1478 // then return a negative number. Otherwise, the result
1479 // is in the range [0..vmslots] inclusive.
1480 int MethodHandles::argument_slot(oop method_type, int arg) {
1481 objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(method_type);
2169 // The output of the cast must fit with the destination argument:
2170 Handle cast_class = argument;
2171 err = check_method_type_conversion(src_mtype(),
2172 argnum, cast_class(),
2173 dst_mtype());
2174 }
2175 break;
2176
2177 // %%% TO DO: continue in remaining cases to verify src/dst_mtype if VerifyMethodHandles
2178 }
2179 }
2180
2181 if (err != NULL) {
2182 throw_InternalError_for_bad_conversion(conversion, err, THREAD);
2183 return;
2184 }
2185
2186 }
2187
2188 void MethodHandles::init_AdapterMethodHandle(Handle mh, Handle target, int argnum, TRAPS) {
2189 Handle argument = java_lang_invoke_AdapterMethodHandle::argument(mh());
2190 int argslot = java_lang_invoke_AdapterMethodHandle::vmargslot(mh());
2191 jint conversion = java_lang_invoke_AdapterMethodHandle::conversion(mh());
2192 jint conv_op = adapter_conversion_op(conversion);
2193
2194 // adjust the adapter code to the internal EntryKind enumeration:
2195 EntryKind ek_orig = adapter_entry_kind(conv_op);
2196 EntryKind ek_opt = ek_orig; // may be optimized
2197 EntryKind ek_try; // temp
2198
2199 // Finalize the vmtarget field (Java initialized it to null).
2200 if (!java_lang_invoke_MethodHandle::is_instance(target())) {
2201 throw_InternalError_for_bad_conversion(conversion, "bad target", THREAD);
2202 return;
2203 }
2204 java_lang_invoke_AdapterMethodHandle::set_vmtarget(mh(), target());
2205
2206 int stack_move = adapter_conversion_stack_move(conversion);
2207 BasicType src = adapter_conversion_src_type(conversion);
2208 BasicType dest = adapter_conversion_dest_type(conversion);
2209 int vminfo = adapter_conversion_vminfo(conversion); // should be zero
2231 break;
2232
2233 case _adapter_prim_to_prim:
2234 {
2235 // Non-subword cases are {int,float,long,double} -> {int,float,long,double}.
2236 // And, the {float,double} -> {int,long} cases must be handled by Java.
2237 switch (type2size[src] *4+ type2size[dest]) {
2238 case 1 *4+ 1:
2239 assert(src == T_INT || is_subword_type(src), "source is not float");
2240 // Subword-related cases are int -> {boolean,byte,char,short}.
2241 ek_opt = _adapter_opt_i2i;
2242 vminfo = adapter_prim_to_prim_subword_vminfo(dest);
2243 break;
2244 case 2 *4+ 1:
2245 if (src == T_LONG && (dest == T_INT || is_subword_type(dest))) {
2246 ek_opt = _adapter_opt_l2i;
2247 vminfo = adapter_prim_to_prim_subword_vminfo(dest);
2248 } else if (src == T_DOUBLE && dest == T_FLOAT) {
2249 ek_opt = _adapter_opt_d2f;
2250 } else {
2251 goto throw_not_impl; // runs user code, hence could block
2252 }
2253 break;
2254 case 1 *4+ 2:
2255 if ((src == T_INT || is_subword_type(src)) && dest == T_LONG) {
2256 ek_opt = _adapter_opt_i2l;
2257 } else if (src == T_FLOAT && dest == T_DOUBLE) {
2258 ek_opt = _adapter_opt_f2d;
2259 } else {
2260 goto throw_not_impl; // runs user code, hence could block
2261 }
2262 break;
2263 default:
2264 goto throw_not_impl; // runs user code, hence could block
2265 break;
2266 }
2267 }
2268 break;
2269
2270 case _adapter_ref_to_prim:
2271 {
2272 switch (type2size[dest]) {
2273 case 1:
2274 ek_opt = _adapter_opt_unboxi;
2275 vminfo = adapter_unbox_subword_vminfo(dest);
2276 break;
2277 case 2:
2278 ek_opt = _adapter_opt_unboxl;
2279 break;
2280 default:
2281 goto throw_not_impl;
2282 break;
2283 }
2284 }
2285 break;
2286
2287 case _adapter_prim_to_ref:
2288 {
2289 assert(UseRicochetFrames, "else don't come here");
2290 // vminfo will be the location to insert the return value
2291 vminfo = argslot;
2292 ek_opt = _adapter_opt_collect_ref;
2293 ensure_vmlayout_field(target, CHECK);
2294 // for MethodHandleWalk:
2295 if (java_lang_invoke_AdapterMethodHandle::is_instance(argument()))
2296 ensure_vmlayout_field(argument, CHECK);
2297 if (!OptimizeMethodHandles) break;
2298 switch (type2size[src]) {
2299 case 1:
2300 ek_try = EntryKind(_adapter_opt_filter_S0_ref + argslot);
2301 if (ek_try < _adapter_opt_collect_LAST &&
2302 ek_adapter_opt_collect_slot(ek_try) == argslot) {
2303 assert(ek_adapter_opt_collect_count(ek_try) == 1 &&
2304 ek_adapter_opt_collect_type(ek_try) == T_OBJECT, "");
2305 ek_opt = ek_try;
2306 break;
2307 }
2308 // else downgrade to variable slot:
2309 ek_opt = _adapter_opt_collect_1_ref;
2310 break;
2311 case 2:
2312 ek_try = EntryKind(_adapter_opt_collect_2_S0_ref + argslot);
2313 if (ek_try < _adapter_opt_collect_LAST &&
2314 ek_adapter_opt_collect_slot(ek_try) == argslot) {
2315 assert(ek_adapter_opt_collect_count(ek_try) == 2 &&
2316 ek_adapter_opt_collect_type(ek_try) == T_OBJECT, "");
2317 ek_opt = ek_try;
2318 break;
2319 }
2320 // else downgrade to variable slot:
2321 ek_opt = _adapter_opt_collect_2_ref;
2322 break;
2323 default:
2324 goto throw_not_impl;
2325 break;
2326 }
2327 }
2328 break;
2329
2330 case _adapter_swap_args:
2331 case _adapter_rot_args:
2332 {
2333 int swap_slots = type2size[src];
2334 int slot_limit = java_lang_invoke_AdapterMethodHandle::vmslots(mh());
2335 int src_slot = argslot;
2336 int dest_slot = vminfo;
2337 int rotate = (ek_orig == _adapter_swap_args) ? 0 : (src_slot > dest_slot) ? 1 : -1;
2338 switch (swap_slots) {
2339 case 1:
2340 ek_opt = (!rotate ? _adapter_opt_swap_1 :
2341 rotate > 0 ? _adapter_opt_rot_1_up : _adapter_opt_rot_1_down);
2342 break;
2343 case 2:
2344 ek_opt = (!rotate ? _adapter_opt_swap_2 :
2345 rotate > 0 ? _adapter_opt_rot_2_up : _adapter_opt_rot_2_down);
2346 break;
2347 default:
2348 goto throw_not_impl;
2349 break;
2350 }
2351 }
2352 break;
2353
2354 case _adapter_spread_args:
2355 {
2356 #ifdef TARGET_ARCH_NYI_6939861
2357 // ports before 6939861 supported only three kinds of spread ops
2358 if (!UseRicochetFrames) {
2359 int array_size = slots_pushed + 1;
2360 assert(array_size >= 0, "");
2361 vminfo = array_size;
2362 switch (array_size) {
2363 case 0: ek_opt = _adapter_opt_spread_0; break;
2364 case 1: ek_opt = _adapter_opt_spread_1; break;
2365 default: ek_opt = _adapter_opt_spread_more; break;
2366 }
2367 break;
2368 }
2395 // since the general case does not handle length 0, this case is required:
2396 ek_opt = _adapter_opt_spread_0;
2397 break;
2398 }
2399 if (dest == T_OBJECT) {
2400 ek_try = EntryKind(_adapter_opt_spread_1_ref - 1 + array_size);
2401 if (ek_try < _adapter_opt_spread_LAST &&
2402 ek_adapter_opt_spread_count(ek_try) == array_size) {
2403 assert(ek_adapter_opt_spread_type(ek_try) == dest, "");
2404 ek_opt = ek_try;
2405 break;
2406 }
2407 }
2408 break;
2409 }
2410 break;
2411
2412 case _adapter_collect_args:
2413 {
2414 assert(UseRicochetFrames, "else don't come here");
2415 int elem_slots = argument_slot_count(java_lang_invoke_MethodHandle::type(argument()));
2416 // vminfo will be the location to insert the return value
2417 vminfo = argslot;
2418 ensure_vmlayout_field(target, CHECK);
2419 ensure_vmlayout_field(argument, CHECK);
2420
2421 // general case:
2422 switch (dest) {
2423 default : if (!is_subword_type(dest)) goto throw_not_impl;
2424 // else fall through:
2425 case T_INT : ek_opt = _adapter_opt_collect_int; break;
2426 case T_LONG : ek_opt = _adapter_opt_collect_long; break;
2427 case T_FLOAT : ek_opt = _adapter_opt_collect_float; break;
2428 case T_DOUBLE : ek_opt = _adapter_opt_collect_double; break;
2429 case T_OBJECT : ek_opt = _adapter_opt_collect_ref; break;
2430 case T_VOID : ek_opt = _adapter_opt_collect_void; break;
2431 }
2432 assert(ek_adapter_opt_collect_slot(ek_opt) == -1 &&
2433 ek_adapter_opt_collect_count(ek_opt) == -1 &&
2434 (ek_adapter_opt_collect_type(ek_opt) == dest ||
2435 ek_adapter_opt_collect_type(ek_opt) == T_INT && is_subword_type(dest)),
2436 "");
2437
2438 if (dest == T_OBJECT && elem_slots == 1 && OptimizeMethodHandles) {
2439 // filter operation on a ref
2464 }
2465
2466 if (dest == T_OBJECT && OptimizeMethodHandles) {
2467 // try to use a fixed length adapter
2468 ek_try = EntryKind(_adapter_opt_collect_0_ref + elem_slots);
2469 if (ek_try < _adapter_opt_collect_LAST &&
2470 ek_adapter_opt_collect_count(ek_try) == elem_slots) {
2471 assert(ek_adapter_opt_collect_slot(ek_try) == -1 &&
2472 ek_adapter_opt_collect_type(ek_try) == dest, "");
2473 ek_opt = ek_try;
2474 break;
2475 }
2476 }
2477
2478 break;
2479 }
2480
2481 case _adapter_fold_args:
2482 {
2483 assert(UseRicochetFrames, "else don't come here");
2484 int elem_slots = argument_slot_count(java_lang_invoke_MethodHandle::type(argument()));
2485 // vminfo will be the location to insert the return value
2486 vminfo = argslot + elem_slots;
2487 ensure_vmlayout_field(target, CHECK);
2488 ensure_vmlayout_field(argument, CHECK);
2489
2490 switch (dest) {
2491 default : if (!is_subword_type(dest)) goto throw_not_impl;
2492 // else fall through:
2493 case T_INT : ek_opt = _adapter_opt_fold_int; break;
2494 case T_LONG : ek_opt = _adapter_opt_fold_long; break;
2495 case T_FLOAT : ek_opt = _adapter_opt_fold_float; break;
2496 case T_DOUBLE : ek_opt = _adapter_opt_fold_double; break;
2497 case T_OBJECT : ek_opt = _adapter_opt_fold_ref; break;
2498 case T_VOID : ek_opt = _adapter_opt_fold_void; break;
2499 }
2500 assert(ek_adapter_opt_collect_slot(ek_opt) == -1 &&
2501 ek_adapter_opt_collect_count(ek_opt) == -1 &&
2502 (ek_adapter_opt_collect_type(ek_opt) == dest ||
2503 ek_adapter_opt_collect_type(ek_opt) == T_INT && is_subword_type(dest)),
2504 "");
2505
2506 if (dest == T_OBJECT && elem_slots == 0 && OptimizeMethodHandles) {
2507 // if there are no args, just pretend it's a collect
2508 ek_opt = _adapter_opt_collect_0_ref;
2518 ek_adapter_opt_collect_type(ek_try) == dest, "");
2519 ek_opt = ek_try;
2520 break;
2521 }
2522 }
2523
2524 break;
2525 }
2526
2527 default:
2528 // should have failed much earlier; must be a missing case here
2529 assert(false, "incomplete switch");
2530 // and fall through:
2531
2532 throw_not_impl:
2533 if (err == NULL)
2534 err = "unknown adapter type";
2535 break;
2536 }
2537
2538 if (err == NULL && (vminfo & CONV_VMINFO_MASK) != vminfo) {
2539 // should not happen, since vminfo is used to encode arg/slot indexes < 255
2540 err = "vminfo overflow";
2541 }
2542
2543 if (err == NULL && !have_entry(ek_opt)) {
2544 err = "adapter stub for this kind of method handle is missing";
2545 }
2546
2547 if (err == NULL && ek_opt == ek_orig) {
2548 switch (ek_opt) {
2549 case _adapter_prim_to_prim:
2550 case _adapter_ref_to_prim:
2551 case _adapter_prim_to_ref:
2552 case _adapter_swap_args:
2553 case _adapter_rot_args:
2554 case _adapter_collect_args:
2555 case _adapter_fold_args:
2556 case _adapter_spread_args:
2557 // should be handled completely by optimized cases; see above
2558 err = "init_AdapterMethodHandle should not issue this";
2559 break;
2560 }
2561 }
2562
2563 if (err != NULL) {
2564 throw_InternalError_for_bad_conversion(conversion, err, THREAD);
2565 return;
2566 }
2567
2568 // Rebuild the conversion value; maybe parts of it were changed.
2569 jint new_conversion = adapter_conversion(conv_op, src, dest, stack_move, vminfo);
2570
2571 // Finalize the conversion field. (Note that it is final to Java code.)
2572 java_lang_invoke_AdapterMethodHandle::set_conversion(mh(), new_conversion);
2573
2574 // Done!
2575 java_lang_invoke_MethodHandle::set_vmentry(mh(), entry(ek_opt));
2576
2577 // There should be enough memory barriers on exit from native methods
2578 // to ensure that the MH is fully initialized to all threads before
2579 // Java code can publish it in global data structures.
2580 }
2581
2582 void MethodHandles::ensure_vmlayout_field(Handle target, TRAPS) {
|