graal-compiler: src/share/vm/prims/methodHandleWalk.cpp annotate

annotate src/share/vm/prims/methodHandleWalk.cpp @ 3992:d1bdeef3e3e2

7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing. Reviewed-by: tonyp, brutisso, ysr

author	johnc
date	Wed, 12 Oct 2011 10:25:51 -0700
parents	c26de9aef2ed
children	a786fdc79c5f

rev	line source
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1 /*
2117 70427f06ea47 7010913: JSR 292 ciMethodHandle does not handle MethodHandleCompiler exceptions properly twisti parents: 2001 diff changeset	2 * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	4 *
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	7 * published by the Free Software Foundation.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	8 *
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	13 * accompanied this code).
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	14 *
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	21 * questions.
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	22 *
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	23 */
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1793 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1793 diff changeset	26 #include "interpreter/rewriter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1793 diff changeset	27 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1793 diff changeset	28 #include "prims/methodHandleWalk.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1793 diff changeset	29
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	30 /*
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	31 * JSR 292 reference implementation: method handle structure analysis
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	32 */
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	33
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	34 #ifdef PRODUCT
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	35 #define print_method_handle(mh) {}
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	36 #else //PRODUCT
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	37 extern "C" void print_method_handle(oop mh);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	38 #endif //PRODUCT
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	39
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	40 // -----------------------------------------------------------------------------
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	41 // MethodHandleChain
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	42
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	43 void MethodHandleChain::set_method_handle(Handle mh, TRAPS) {
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	44 if (!java_lang_invoke_MethodHandle::is_instance(mh())) lose("bad method handle", CHECK);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	45
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	46 // set current method handle and unpack partially
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	47 _method_handle = mh;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	48 _is_last = false;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	49 _is_bound = false;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	50 _arg_slot = -1;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	51 _arg_type = T_VOID;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	52 _conversion = -1;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	53 _last_invoke = Bytecodes::_nop; //arbitrary non-garbage
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	54
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	55 if (java_lang_invoke_DirectMethodHandle::is_instance(mh())) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	56 set_last_method(mh(), THREAD);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	57 return;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	58 }
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	59 if (java_lang_invoke_AdapterMethodHandle::is_instance(mh())) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	60 _conversion = AdapterMethodHandle_conversion();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	61 assert(_conversion != -1, "bad conv value");
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	62 assert(java_lang_invoke_BoundMethodHandle::is_instance(mh()), "also BMH");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	63 }
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	64 if (java_lang_invoke_BoundMethodHandle::is_instance(mh())) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	65 if (!is_adapter()) // keep AMH and BMH separate in this model
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	66 _is_bound = true;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	67 _arg_slot = BoundMethodHandle_vmargslot();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	68 oop target = MethodHandle_vmtarget_oop();
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	69 if (!is_bound() \|\| java_lang_invoke_MethodHandle::is_instance(target)) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	70 _arg_type = compute_bound_arg_type(target, NULL, _arg_slot, CHECK);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	71 } else if (target != NULL && target->is_method()) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	72 methodOop m = (methodOop) target;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	73 _arg_type = compute_bound_arg_type(NULL, m, _arg_slot, CHECK);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	74 set_last_method(mh(), CHECK);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	75 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	76 _is_bound = false; // lose!
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	77 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	78 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	79 if (is_bound() && _arg_type == T_VOID) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	80 lose("bad vmargslot", CHECK);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	81 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	82 if (!is_bound() && !is_adapter()) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	83 lose("unrecognized MH type", CHECK);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	84 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	85 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	86
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	87
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	88 void MethodHandleChain::set_last_method(oop target, TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	89 _is_last = true;
3274 2a23b1b5a0a8 7018355: JSR 292: VM crash in DefNewGeneration::copy_to_survivor_space twisti parents: 2460 diff changeset	90 KlassHandle receiver_limit; int flags = 0;
2a23b1b5a0a8 7018355: JSR 292: VM crash in DefNewGeneration::copy_to_survivor_space twisti parents: 2460 diff changeset	91 _last_method = MethodHandles::decode_method(target, receiver_limit, flags);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	92 if ((flags & MethodHandles::_dmf_has_receiver) == 0)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	93 _last_invoke = Bytecodes::_invokestatic;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	94 else if ((flags & MethodHandles::_dmf_does_dispatch) == 0)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	95 _last_invoke = Bytecodes::_invokespecial;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	96 else if ((flags & MethodHandles::_dmf_from_interface) != 0)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	97 _last_invoke = Bytecodes::_invokeinterface;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	98 else
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	99 _last_invoke = Bytecodes::_invokevirtual;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	100 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	101
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	102
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	103 BasicType MethodHandleChain::compute_bound_arg_type(oop target, methodOop m, int arg_slot, TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	104 // There is no direct indication of whether the argument is primitive or not.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	105 // It is implied by the _vmentry code, and by the MethodType of the target.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	106 BasicType arg_type = T_VOID;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	107 if (target != NULL) {
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	108 oop mtype = java_lang_invoke_MethodHandle::type(target);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	109 int arg_num = MethodHandles::argument_slot_to_argnum(mtype, arg_slot);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	110 if (arg_num >= 0) {
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	111 oop ptype = java_lang_invoke_MethodType::ptype(mtype, arg_num);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	112 arg_type = java_lang_Class::as_BasicType(ptype);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	113 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	114 } else if (m != NULL) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	115 // figure out the argument type from the slot
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	116 // FIXME: make this explicit in the MH
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	117 int cur_slot = m->size_of_parameters();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	118 if (arg_slot >= cur_slot)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	119 return T_VOID;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	120 if (!m->is_static()) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	121 cur_slot -= type2size[T_OBJECT];
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	122 if (cur_slot == arg_slot)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	123 return T_OBJECT;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	124 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2117 diff changeset	125 ResourceMark rm(THREAD);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	126 for (SignatureStream ss(m->signature()); !ss.is_done(); ss.next()) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	127 BasicType bt = ss.type();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	128 cur_slot -= type2size[bt];
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	129 if (cur_slot <= arg_slot) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	130 if (cur_slot == arg_slot)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	131 arg_type = bt;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	132 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	133 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	134 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	135 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	136 if (arg_type == T_ARRAY)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	137 arg_type = T_OBJECT;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	138 return arg_type;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	139 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	140
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	141
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	142 void MethodHandleChain::lose(const char* msg, TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	143 _lose_message = msg;
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	144 #ifdef ASSERT
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	145 if (Verbose) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	146 tty->print_cr(INTPTR_FORMAT " lose: %s", _method_handle(), msg);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	147 print();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	148 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	149 #endif
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	150 if (!THREAD->is_Java_thread() \|\| ((JavaThread*)THREAD)->thread_state() != _thread_in_vm) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	151 // throw a preallocated exception
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	152 THROW_OOP(Universe::virtual_machine_error_instance());
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	153 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	154 THROW_MSG(vmSymbols::java_lang_InternalError(), msg);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	155 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	156
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	157
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	158 #ifdef ASSERT
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	159 static const char* adapter_ops[] = {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	160 "retype_only" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	161 "retype_raw" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	162 "check_cast" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	163 "prim_to_prim" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	164 "ref_to_prim" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	165 "prim_to_ref" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	166 "swap_args" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	167 "rot_args" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	168 "dup_args" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	169 "drop_args" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	170 "collect_args" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	171 "spread_args" ,
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	172 "fold_args"
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	173 };
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	174
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	175 static const char* adapter_op_to_string(int op) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	176 if (op >= 0 && op < (int)ARRAY_SIZE(adapter_ops))
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	177 return adapter_ops[op];
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	178 return "unknown_op";
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	179 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	180
3753 cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	181 void MethodHandleChain::print(oopDesc* m) {
cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	182 HandleMark hm;
cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	183 ResourceMark rm;
cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	184 Handle mh(m);
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	185 EXCEPTION_MARK;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	186 MethodHandleChain mhc(mh, THREAD);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	187 if (HAS_PENDING_EXCEPTION) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	188 oop ex = THREAD->pending_exception();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	189 CLEAR_PENDING_EXCEPTION;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	190 ex->print();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	191 return;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	192 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	193 mhc.print();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	194 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	195
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	196
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	197 void MethodHandleChain::print() {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	198 EXCEPTION_MARK;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	199 print_impl(THREAD);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	200 if (HAS_PENDING_EXCEPTION) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	201 oop ex = THREAD->pending_exception();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	202 CLEAR_PENDING_EXCEPTION;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	203 ex->print();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	204 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	205 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	206
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	207 void MethodHandleChain::print_impl(TRAPS) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	208 ResourceMark rm;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	209
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	210 MethodHandleChain chain(_root, CHECK);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	211 for (;;) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	212 tty->print(INTPTR_FORMAT ": ", chain.method_handle()());
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	213 if (chain.is_bound()) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	214 tty->print("bound: arg_type %s arg_slot %d",
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	215 type2name(chain.bound_arg_type()),
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	216 chain.bound_arg_slot());
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	217 oop o = chain.bound_arg_oop();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	218 if (o != NULL) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	219 if (o->is_instance()) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	220 tty->print(" instance %s", o->klass()->klass_part()->internal_name());
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	221 if (java_lang_invoke_CountingMethodHandle::is_instance(o)) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	222 tty->print(" vmcount: %d", java_lang_invoke_CountingMethodHandle::vmcount(o));
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	223 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	224 } else {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	225 o->print();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	226 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	227 }
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	228 oop vmt = chain.vmtarget_oop();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	229 if (vmt != NULL) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	230 if (vmt->is_method()) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	231 tty->print(" ");
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	232 methodOop(vmt)->print_short_name(tty);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	233 } else if (java_lang_invoke_MethodHandle::is_instance(vmt)) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	234 tty->print(" method handle " INTPTR_FORMAT, vmt);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	235 } else {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	236 ShouldNotReachHere();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	237 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	238 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	239 } else if (chain.is_adapter()) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	240 tty->print("adapter: arg_slot %d conversion op %s",
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	241 chain.adapter_arg_slot(),
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	242 adapter_op_to_string(chain.adapter_conversion_op()));
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	243 switch (chain.adapter_conversion_op()) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	244 case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY:
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	245 if (java_lang_invoke_CountingMethodHandle::is_instance(chain.method_handle_oop())) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	246 tty->print(" vmcount: %d", java_lang_invoke_CountingMethodHandle::vmcount(chain.method_handle_oop()));
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	247 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	248 case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	249 case java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	250 case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	251 case java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	252 break;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	253
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	254 case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF: {
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	255 tty->print(" src_type = %s", type2name(chain.adapter_conversion_src_type()));
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	256 break;
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	257 }
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	258
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	259 case java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	260 case java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS: {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	261 int dest_arg_slot = chain.adapter_conversion_vminfo();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	262 tty->print(" dest_arg_slot %d type %s", dest_arg_slot, type2name(chain.adapter_conversion_src_type()));
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	263 break;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	264 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	265
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	266 case java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	267 case java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS: {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	268 int dup_slots = chain.adapter_conversion_stack_pushes();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	269 tty->print(" pushes %d", dup_slots);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	270 break;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	271 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	272
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	273 case java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	274 case java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS: {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	275 int coll_slots = chain.MethodHandle_vmslots();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	276 tty->print(" coll_slots %d", coll_slots);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	277 break;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	278 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	279
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	280 case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	281 // Check the required length.
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	282 int spread_slots = 1 + chain.adapter_conversion_stack_pushes();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	283 tty->print(" spread_slots %d", spread_slots);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	284 break;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	285 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	286
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	287 default:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	288 tty->print_cr("bad adapter conversion");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	289 break;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	290 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	291 } else {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	292 // DMH
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	293 tty->print("direct: ");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	294 chain.last_method_oop()->print_short_name(tty);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	295 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	296
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	297 tty->print(" (");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	298 objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(chain.method_type_oop());
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	299 for (int i = ptypes->length() - 1; i >= 0; i--) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	300 BasicType t = java_lang_Class::as_BasicType(ptypes->obj_at(i));
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	301 if (t == T_ARRAY) t = T_OBJECT;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	302 tty->print("%c", type2char(t));
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	303 if (t == T_LONG \|\| t == T_DOUBLE) tty->print("_");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	304 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	305 tty->print(")");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	306 BasicType rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(chain.method_type_oop()));
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	307 if (rtype == T_ARRAY) rtype = T_OBJECT;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	308 tty->print("%c", type2char(rtype));
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	309 tty->cr();
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	310 if (!chain.is_last()) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	311 chain.next(CHECK);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	312 } else {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	313 break;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	314 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	315 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	316 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	317 #endif
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	318
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	319
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	320 // -----------------------------------------------------------------------------
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	321 // MethodHandleWalker
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	322
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	323 Bytecodes::Code MethodHandleWalker::conversion_code(BasicType src, BasicType dest) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	324 if (is_subword_type(src)) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	325 src = T_INT; // all subword src types act like int
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	326 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	327 if (src == dest) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	328 return Bytecodes::_nop;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	329 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	330
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	331 #define SRC_DEST(s,d) (((int)(s) << 4) + (int)(d))
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	332 switch (SRC_DEST(src, dest)) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	333 case SRC_DEST(T_INT, T_LONG): return Bytecodes::_i2l;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	334 case SRC_DEST(T_INT, T_FLOAT): return Bytecodes::_i2f;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	335 case SRC_DEST(T_INT, T_DOUBLE): return Bytecodes::_i2d;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	336 case SRC_DEST(T_INT, T_BYTE): return Bytecodes::_i2b;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	337 case SRC_DEST(T_INT, T_CHAR): return Bytecodes::_i2c;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	338 case SRC_DEST(T_INT, T_SHORT): return Bytecodes::_i2s;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	339
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	340 case SRC_DEST(T_LONG, T_INT): return Bytecodes::_l2i;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	341 case SRC_DEST(T_LONG, T_FLOAT): return Bytecodes::_l2f;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	342 case SRC_DEST(T_LONG, T_DOUBLE): return Bytecodes::_l2d;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	343
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	344 case SRC_DEST(T_FLOAT, T_INT): return Bytecodes::_f2i;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	345 case SRC_DEST(T_FLOAT, T_LONG): return Bytecodes::_f2l;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	346 case SRC_DEST(T_FLOAT, T_DOUBLE): return Bytecodes::_f2d;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	347
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	348 case SRC_DEST(T_DOUBLE, T_INT): return Bytecodes::_d2i;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	349 case SRC_DEST(T_DOUBLE, T_LONG): return Bytecodes::_d2l;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	350 case SRC_DEST(T_DOUBLE, T_FLOAT): return Bytecodes::_d2f;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	351 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	352 #undef SRC_DEST
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	353
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	354 // cannot do it in one step, or at all
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	355 return Bytecodes::_illegal;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	356 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	357
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	358
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	359 // -----------------------------------------------------------------------------
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	360 // MethodHandleWalker::walk
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	361 //
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	362 MethodHandleWalker::ArgToken
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	363 MethodHandleWalker::walk(TRAPS) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	364 ArgToken empty = ArgToken(); // Empty return value.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	365
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	366 walk_incoming_state(CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	367
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	368 for (;;) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	369 set_method_handle(chain().method_handle_oop());
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	370
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	371 assert(_outgoing_argc == argument_count_slow(), "empty slots under control");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	372
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	373 if (chain().is_adapter()) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	374 int conv_op = chain().adapter_conversion_op();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	375 int arg_slot = chain().adapter_arg_slot();
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	376
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	377 // Check that the arg_slot is valid. In most cases it must be
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	378 // within range of the current arguments but there are some
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	379 // exceptions. Those are sanity checked in their implemention
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	380 // below.
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	381 if ((arg_slot < 0 \|\| arg_slot >= _outgoing.length()) &&
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	382 conv_op > java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW &&
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	383 conv_op != java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS &&
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	384 conv_op != java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	385 lose(err_msg("bad argument index %d", arg_slot), CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	386 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	387
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	388 bool retain_original_args = false; // used by fold/collect logic
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	389
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	390 // perform the adapter action
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	391 switch (conv_op) {
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	392 case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY:
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	393 // No changes to arguments; pass the bits through.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	394 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	395
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	396 case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW: {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	397 // To keep the verifier happy, emit bitwise ("raw") conversions as needed.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	398 // See MethodHandles::same_basic_type_for_arguments for allowed conversions.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	399 Handle incoming_mtype(THREAD, chain().method_type_oop());
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	400 Handle outgoing_mtype;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	401 {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	402 oop outgoing_mh_oop = chain().vmtarget_oop();
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	403 if (!java_lang_invoke_MethodHandle::is_instance(outgoing_mh_oop))
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	404 lose("outgoing target not a MethodHandle", CHECK_(empty));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	405 outgoing_mtype = Handle(THREAD, java_lang_invoke_MethodHandle::type(outgoing_mh_oop));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	406 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	407
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	408 int nptypes = java_lang_invoke_MethodType::ptype_count(outgoing_mtype());
8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	409 if (nptypes != java_lang_invoke_MethodType::ptype_count(incoming_mtype()))
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	410 lose("incoming and outgoing parameter count do not agree", CHECK_(empty));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	411
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	412 // Argument types.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	413 for (int i = 0, slot = _outgoing.length() - 1; slot >= 0; slot--) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	414 if (arg_type(slot) == T_VOID) continue;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	415
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	416 klassOop src_klass = NULL;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	417 klassOop dst_klass = NULL;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	418 BasicType src = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(incoming_mtype(), i), &src_klass);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	419 BasicType dst = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(outgoing_mtype(), i), &dst_klass);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	420 retype_raw_argument_type(src, dst, slot, CHECK_(empty));
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	421 i++; // We need to skip void slots at the top of the loop.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	422 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	423
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	424 // Return type.
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	425 {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	426 BasicType src = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(incoming_mtype()));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	427 BasicType dst = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(outgoing_mtype()));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	428 retype_raw_return_type(src, dst, CHECK_(empty));
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	429 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	430 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	431 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	432
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	433 case java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	434 // checkcast the Nth outgoing argument in place
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	435 klassOop dest_klass = NULL;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	436 BasicType dest = java_lang_Class::as_BasicType(chain().adapter_arg_oop(), &dest_klass);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	437 assert(dest == T_OBJECT, "");
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	438 ArgToken arg = _outgoing.at(arg_slot);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	439 assert(dest == arg.basic_type(), "");
3753 cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	440 arg = make_conversion(T_OBJECT, dest_klass, Bytecodes::_checkcast, arg, CHECK_(empty));
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	441 // replace the object by the result of the cast, to make the compiler happy:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	442 change_argument(T_OBJECT, arg_slot, T_OBJECT, arg);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	443 debug_only(dest_klass = (klassOop)badOop);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	444 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	445 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	446
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	447 case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	448 // i2l, etc., on the Nth outgoing argument in place
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	449 BasicType src = chain().adapter_conversion_src_type(),
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	450 dest = chain().adapter_conversion_dest_type();
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	451 ArgToken arg = _outgoing.at(arg_slot);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	452 Bytecodes::Code bc = conversion_code(src, dest);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	453 if (bc == Bytecodes::_nop) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	454 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	455 } else if (bc != Bytecodes::_illegal) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	456 arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	457 } else if (is_subword_type(dest)) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	458 bc = conversion_code(src, T_INT);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	459 if (bc != Bytecodes::_illegal) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	460 arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	461 bc = conversion_code(T_INT, dest);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	462 arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	463 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	464 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	465 if (bc == Bytecodes::_illegal) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	466 lose(err_msg("bad primitive conversion for %s -> %s", type2name(src), type2name(dest)), CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	467 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	468 change_argument(src, arg_slot, dest, arg);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	469 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	470 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	471
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	472 case java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	473 // checkcast to wrapper type & call intValue, etc.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	474 BasicType dest = chain().adapter_conversion_dest_type();
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	475 ArgToken arg = _outgoing.at(arg_slot);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	476 arg = make_conversion(T_OBJECT, SystemDictionary::box_klass(dest),
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	477 Bytecodes::_checkcast, arg, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	478 vmIntrinsics::ID unboxer = vmIntrinsics::for_unboxing(dest);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	479 if (unboxer == vmIntrinsics::_none) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	480 lose("no unboxing method", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	481 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	482 ArgToken arglist[2];
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	483 arglist[0] = arg; // outgoing 'this'
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	484 arglist[1] = ArgToken(); // sentinel
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	485 arg = make_invoke(methodHandle(), unboxer, Bytecodes::_invokevirtual, false, 1, &arglist[0], CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	486 change_argument(T_OBJECT, arg_slot, dest, arg);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	487 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	488 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	489
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	490 case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	491 // call wrapper type.valueOf
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	492 BasicType src = chain().adapter_conversion_src_type();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	493 vmIntrinsics::ID boxer = vmIntrinsics::for_boxing(src);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	494 if (boxer == vmIntrinsics::_none) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	495 lose("no boxing method", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	496 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	497 ArgToken arg = _outgoing.at(arg_slot);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	498 ArgToken arglist[2];
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	499 arglist[0] = arg; // outgoing value
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	500 arglist[1] = ArgToken(); // sentinel
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	501 arg = make_invoke(methodHandle(), boxer, Bytecodes::_invokestatic, false, 1, &arglist[0], CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	502 change_argument(src, arg_slot, T_OBJECT, arg);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	503 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	504 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	505
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	506 case java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	507 int dest_arg_slot = chain().adapter_conversion_vminfo();
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	508 if (!has_argument(dest_arg_slot)) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	509 lose("bad swap index", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	510 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	511 // a simple swap between two arguments
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	512 if (arg_slot > dest_arg_slot) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	513 int tmp = arg_slot;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	514 arg_slot = dest_arg_slot;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	515 dest_arg_slot = tmp;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	516 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	517 ArgToken a1 = _outgoing.at(arg_slot);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	518 ArgToken a2 = _outgoing.at(dest_arg_slot);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	519 change_argument(a2.basic_type(), dest_arg_slot, a1);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	520 change_argument(a1.basic_type(), arg_slot, a2);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	521 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	522 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	523
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	524 case java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS: {
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	525 int limit_raw = chain().adapter_conversion_vminfo();
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	526 bool rot_down = (arg_slot < limit_raw);
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	527 int limit_bias = (rot_down ? MethodHandles::OP_ROT_ARGS_DOWN_LIMIT_BIAS : 0);
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	528 int limit_slot = limit_raw - limit_bias;
f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	529 if ((uint)limit_slot > (uint)_outgoing.length()) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	530 lose("bad rotate index", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	531 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	532 // Rotate the source argument (plus following N slots) into the
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	533 // position occupied by the dest argument (plus following N slots).
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	534 int rotate_count = type2size[chain().adapter_conversion_src_type()];
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	535 // (no other rotate counts are currently supported)
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	536 if (rot_down) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	537 for (int i = 0; i < rotate_count; i++) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	538 ArgToken temp = _outgoing.at(arg_slot);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	539 _outgoing.remove_at(arg_slot);
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	540 _outgoing.insert_before(limit_slot - 1, temp);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	541 }
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	542 } else { // arg_slot > limit_slot => rotate_up
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	543 for (int i = 0; i < rotate_count; i++) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	544 ArgToken temp = _outgoing.at(arg_slot + rotate_count - 1);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	545 _outgoing.remove_at(arg_slot + rotate_count - 1);
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	546 _outgoing.insert_before(limit_slot, temp);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	547 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	548 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	549 assert(_outgoing_argc == argument_count_slow(), "empty slots under control");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	550 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	551 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	552
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	553 case java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	554 int dup_slots = chain().adapter_conversion_stack_pushes();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	555 if (dup_slots <= 0) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	556 lose("bad dup count", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	557 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	558 for (int i = 0; i < dup_slots; i++) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	559 ArgToken dup = _outgoing.at(arg_slot + 2*i);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	560 if (dup.basic_type() != T_VOID) _outgoing_argc += 1;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	561 _outgoing.insert_before(i, dup);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	562 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	563 assert(_outgoing_argc == argument_count_slow(), "empty slots under control");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	564 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	565 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	566
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	567 case java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	568 int drop_slots = -chain().adapter_conversion_stack_pushes();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	569 if (drop_slots <= 0) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	570 lose("bad drop count", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	571 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	572 for (int i = 0; i < drop_slots; i++) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	573 ArgToken drop = _outgoing.at(arg_slot);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	574 if (drop.basic_type() != T_VOID) _outgoing_argc -= 1;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	575 _outgoing.remove_at(arg_slot);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	576 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	577 assert(_outgoing_argc == argument_count_slow(), "empty slots under control");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	578 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	579 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	580
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	581 case java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS:
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	582 retain_original_args = true; // and fall through:
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	583 case java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS: {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	584 // call argument MH recursively
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	585 //{static int x; if (!x++) print_method_handle(chain().method_handle_oop()); --x;}
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	586 Handle recursive_mh(THREAD, chain().adapter_arg_oop());
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	587 if (!java_lang_invoke_MethodHandle::is_instance(recursive_mh())) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	588 lose("recursive target not a MethodHandle", CHECK_(empty));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	589 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	590 Handle recursive_mtype(THREAD, java_lang_invoke_MethodHandle::type(recursive_mh()));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	591 int argc = java_lang_invoke_MethodType::ptype_count(recursive_mtype());
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	592 int coll_slots = java_lang_invoke_MethodHandle::vmslots(recursive_mh());
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	593 BasicType rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(recursive_mtype()));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	594 ArgToken* arglist = NEW_RESOURCE_ARRAY(ArgToken, 1 + argc + 1); // 1+: mh, +1: sentinel
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	595 arglist[0] = make_oop_constant(recursive_mh(), CHECK_(empty));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	596 if (arg_slot < 0 \|\| coll_slots < 0 \|\| arg_slot + coll_slots > _outgoing.length()) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	597 lose("bad fold/collect arg slot", CHECK_(empty));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	598 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	599 for (int i = 0, slot = arg_slot + coll_slots - 1; slot >= arg_slot; slot--) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	600 ArgToken arg_state = _outgoing.at(slot);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	601 BasicType arg_type = arg_state.basic_type();
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	602 if (arg_type == T_VOID) continue;
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	603 ArgToken arg = _outgoing.at(slot);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	604 if (i >= argc) { lose("bad fold/collect arg", CHECK_(empty)); }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	605 arglist[1+i] = arg;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	606 if (!retain_original_args)
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	607 change_argument(arg_type, slot, T_VOID, ArgToken(tt_void));
3385 33ae33516634 7045515: ARM assembly code for JSR 292 ricochet frames bdelsart parents: 3371 diff changeset	608 i++;
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	609 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	610 arglist[1+argc] = ArgToken(); // sentinel
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	611 oop invoker = java_lang_invoke_MethodTypeForm::vmlayout(
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	612 java_lang_invoke_MethodType::form(recursive_mtype()) );
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	613 if (invoker == NULL \|\| !invoker->is_method()) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	614 lose("bad vmlayout slot", CHECK_(empty));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	615 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	616 // FIXME: consider inlining the invokee at the bytecode level
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	617 ArgToken ret = make_invoke(methodHandle(THREAD, methodOop(invoker)), vmIntrinsics::_invokeGeneric,
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	618 Bytecodes::_invokevirtual, false, 1+argc, &arglist[0], CHECK_(empty));
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	619 // The iid = _invokeGeneric really means to adjust reference types as needed.
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	620 DEBUG_ONLY(invoker = NULL);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	621 if (rtype == T_OBJECT) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	622 klassOop rklass = java_lang_Class::as_klassOop( java_lang_invoke_MethodType::rtype(recursive_mtype()) );
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	623 if (rklass != SystemDictionary::Object_klass() &&
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	624 !Klass::cast(rklass)->is_interface()) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	625 // preserve type safety
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	626 ret = make_conversion(T_OBJECT, rklass, Bytecodes::_checkcast, ret, CHECK_(empty));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	627 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	628 }
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	629 if (rtype != T_VOID) {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	630 int ret_slot = arg_slot + (retain_original_args ? coll_slots : 0);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	631 change_argument(T_VOID, ret_slot, rtype, ret);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	632 }
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	633 break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	634 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	635
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	636 case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	637 klassOop array_klass_oop = NULL;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	638 BasicType array_type = java_lang_Class::as_BasicType(chain().adapter_arg_oop(),
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	639 &array_klass_oop);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	640 assert(array_type == T_OBJECT, "");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	641 assert(Klass::cast(array_klass_oop)->oop_is_array(), "");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	642 arrayKlassHandle array_klass(THREAD, array_klass_oop);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	643 debug_only(array_klass_oop = (klassOop)badOop);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	644
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	645 klassOop element_klass_oop = NULL;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	646 BasicType element_type = java_lang_Class::as_BasicType(array_klass->component_mirror(),
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	647 &element_klass_oop);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	648 KlassHandle element_klass(THREAD, element_klass_oop);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	649 debug_only(element_klass_oop = (klassOop)badOop);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	650
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	651 // Fetch the argument, which we will cast to the required array type.
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	652 ArgToken arg = _outgoing.at(arg_slot);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	653 assert(arg.basic_type() == T_OBJECT, "");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	654 ArgToken array_arg = arg;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	655 array_arg = make_conversion(T_OBJECT, array_klass(), Bytecodes::_checkcast, array_arg, CHECK_(empty));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	656 change_argument(T_OBJECT, arg_slot, T_VOID, ArgToken(tt_void));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	657
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	658 // Check the required length.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	659 int spread_slots = 1 + chain().adapter_conversion_stack_pushes();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	660 int spread_length = spread_slots;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	661 if (type2size[element_type] == 2) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	662 if (spread_slots % 2 != 0) spread_slots = -1; // force error
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	663 spread_length = spread_slots / 2;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	664 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	665 if (spread_slots < 0) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	666 lose("bad spread length", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	667 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	668
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	669 jvalue length_jvalue; length_jvalue.i = spread_length;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	670 ArgToken length_arg = make_prim_constant(T_INT, &length_jvalue, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	671 // Call a built-in method known to the JVM to validate the length.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	672 ArgToken arglist[3];
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	673 arglist[0] = array_arg; // value to check
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	674 arglist[1] = length_arg; // length to check
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	675 arglist[2] = ArgToken(); // sentinel
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	676 make_invoke(methodHandle(), vmIntrinsics::_checkSpreadArgument,
3385 33ae33516634 7045515: ARM assembly code for JSR 292 ricochet frames bdelsart parents: 3371 diff changeset	677 Bytecodes::_invokestatic, false, 2, &arglist[0], CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	678
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	679 // Spread out the array elements.
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	680 Bytecodes::Code aload_op = Bytecodes::_nop;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	681 switch (element_type) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	682 case T_INT: aload_op = Bytecodes::_iaload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	683 case T_LONG: aload_op = Bytecodes::_laload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	684 case T_FLOAT: aload_op = Bytecodes::_faload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	685 case T_DOUBLE: aload_op = Bytecodes::_daload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	686 case T_OBJECT: aload_op = Bytecodes::_aaload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	687 case T_BOOLEAN: // fall through:
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	688 case T_BYTE: aload_op = Bytecodes::_baload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	689 case T_CHAR: aload_op = Bytecodes::_caload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	690 case T_SHORT: aload_op = Bytecodes::_saload; break;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3274 diff changeset	691 default: lose("primitive array NYI", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	692 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	693 int ap = arg_slot;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	694 for (int i = 0; i < spread_length; i++) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	695 jvalue offset_jvalue; offset_jvalue.i = i;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	696 ArgToken offset_arg = make_prim_constant(T_INT, &offset_jvalue, CHECK_(empty));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	697 ArgToken element_arg = make_fetch(element_type, element_klass(), aload_op, array_arg, offset_arg, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	698 change_argument(T_VOID, ap, element_type, element_arg);
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	699 //ap += type2size[element_type]; // don't do this; insert next arg to right of previous
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	700 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	701 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	702 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	703
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	704 default:
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	705 lose("bad adapter conversion", CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	706 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	707 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	708 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	709
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	710 if (chain().is_bound()) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	711 // push a new argument
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	712 BasicType arg_type = chain().bound_arg_type();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	713 jint arg_slot = chain().bound_arg_slot();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	714 oop arg_oop = chain().bound_arg_oop();
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	715 ArgToken arg;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	716 if (arg_type == T_OBJECT) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	717 arg = make_oop_constant(arg_oop, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	718 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	719 jvalue arg_value;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	720 BasicType bt = java_lang_boxing_object::get_value(arg_oop, &arg_value);
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	721 if (bt == arg_type \|\| (bt == T_INT && is_subword_type(arg_type))) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	722 arg = make_prim_constant(arg_type, &arg_value, CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	723 } else {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	724 lose(err_msg("bad bound value: arg_type %s boxing %s", type2name(arg_type), type2name(bt)), CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	725 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	726 }
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	727 DEBUG_ONLY(arg_oop = badOop);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	728 change_argument(T_VOID, arg_slot, arg_type, arg);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	729 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	730
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	731 // this test must come after the body of the loop
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	732 if (!chain().is_last()) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	733 chain().next(CHECK_(empty));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	734 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	735 break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	736 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	737 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	738
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	739 // finish the sequence with a tail-call to the ultimate target
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	740 // parameters are passed in logical order (recv 1st), not slot order
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	741 ArgToken* arglist = NEW_RESOURCE_ARRAY(ArgToken, _outgoing.length() + 1);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	742 int ap = 0;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	743 for (int i = _outgoing.length() - 1; i >= 0; i--) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	744 ArgToken arg_state = _outgoing.at(i);
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	745 if (arg_state.basic_type() == T_VOID) continue;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	746 arglist[ap++] = _outgoing.at(i);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	747 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	748 assert(ap == _outgoing_argc, "");
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	749 arglist[ap] = ArgToken(); // add a sentinel, for the sake of asserts
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	750 return make_invoke(chain().last_method(),
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	751 vmIntrinsics::_none,
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	752 chain().last_invoke_code(), true,
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	753 ap, arglist, THREAD);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	754 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	755
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	756
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	757 // -----------------------------------------------------------------------------
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	758 // MethodHandleWalker::walk_incoming_state
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	759 //
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	760 void MethodHandleWalker::walk_incoming_state(TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	761 Handle mtype(THREAD, chain().method_type_oop());
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	762 int nptypes = java_lang_invoke_MethodType::ptype_count(mtype());
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	763 _outgoing_argc = nptypes;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	764 int argp = nptypes - 1;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	765 if (argp >= 0) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	766 _outgoing.at_grow(argp, ArgToken(tt_void)); // presize
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	767 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	768 for (int i = 0; i < nptypes; i++) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	769 klassOop arg_type_klass = NULL;
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	770 BasicType arg_type = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(mtype(), i), &arg_type_klass);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	771 int index = new_local_index(arg_type);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	772 ArgToken arg = make_parameter(arg_type, arg_type_klass, index, CHECK);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	773 DEBUG_ONLY(arg_type_klass = (klassOop) NULL);
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	774 _outgoing.at_put(argp, arg);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	775 if (type2size[arg_type] == 2) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	776 // add the extra slot, so we can model the JVM stack
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	777 _outgoing.insert_before(argp+1, ArgToken(tt_void));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	778 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	779 --argp;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	780 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	781 // call make_parameter at the end of the list for the return type
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	782 klassOop ret_type_klass = NULL;
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	783 BasicType ret_type = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(mtype()), &ret_type_klass);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	784 ArgToken ret = make_parameter(ret_type, ret_type_klass, -1, CHECK);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	785 // ignore ret; client can catch it if needed
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	786
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	787 assert(_outgoing_argc == argument_count_slow(), "empty slots under control");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	788
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	789 verify_args_and_signature(CHECK);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	790 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	791
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	792
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	793 #ifdef ASSERT
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	794 void MethodHandleWalker::verify_args_and_signature(TRAPS) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	795 int index = _outgoing.length() - 1;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	796 objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(chain().method_type_oop());
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	797 for (int i = 0, limit = ptypes->length(); i < limit; i++) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	798 BasicType t = java_lang_Class::as_BasicType(ptypes->obj_at(i));
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	799 if (t == T_ARRAY) t = T_OBJECT;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	800 if (t == T_LONG \|\| t == T_DOUBLE) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	801 assert(T_VOID == _outgoing.at(index).basic_type(), "types must match");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	802 index--;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	803 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	804 assert(t == _outgoing.at(index).basic_type(), "types must match");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	805 index--;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	806 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	807 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	808 #endif
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	809
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	810
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	811 // -----------------------------------------------------------------------------
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	812 // MethodHandleWalker::change_argument
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	813 //
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	814 // This is messy because some kinds of arguments are paired with
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	815 // companion slots containing an empty value.
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	816 void MethodHandleWalker::change_argument(BasicType old_type, int slot, const ArgToken& new_arg) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	817 BasicType new_type = new_arg.basic_type();
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	818 int old_size = type2size[old_type];
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	819 int new_size = type2size[new_type];
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	820 if (old_size == new_size) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	821 // simple case first
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	822 _outgoing.at_put(slot, new_arg);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	823 } else if (old_size > new_size) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	824 for (int i = old_size - 1; i >= new_size; i--) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	825 assert((i != 0) == (_outgoing.at(slot + i).basic_type() == T_VOID), "");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	826 _outgoing.remove_at(slot + i);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	827 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	828 if (new_size > 0)
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	829 _outgoing.at_put(slot, new_arg);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	830 else
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	831 _outgoing_argc -= 1; // deleted a real argument
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	832 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	833 for (int i = old_size; i < new_size; i++) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	834 _outgoing.insert_before(slot + i, ArgToken(tt_void));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	835 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	836 _outgoing.at_put(slot, new_arg);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	837 if (old_size == 0)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	838 _outgoing_argc += 1; // inserted a real argument
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	839 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	840 assert(_outgoing_argc == argument_count_slow(), "empty slots under control");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	841 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	842
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	843
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	844 #ifdef ASSERT
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	845 int MethodHandleWalker::argument_count_slow() {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	846 int args_seen = 0;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	847 for (int i = _outgoing.length() - 1; i >= 0; i--) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	848 if (_outgoing.at(i).basic_type() != T_VOID) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	849 ++args_seen;
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	850 if (_outgoing.at(i).basic_type() == T_LONG \|\|
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	851 _outgoing.at(i).basic_type() == T_DOUBLE) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	852 assert(_outgoing.at(i + 1).basic_type() == T_VOID, "should only follow two word");
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	853 }
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	854 } else {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	855 assert(_outgoing.at(i - 1).basic_type() == T_LONG \|\|
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	856 _outgoing.at(i - 1).basic_type() == T_DOUBLE, "should only follow two word");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	857 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	858 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	859 return args_seen;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	860 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	861 #endif
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	862
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	863
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	864 // -----------------------------------------------------------------------------
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	865 // MethodHandleWalker::retype_raw_conversion
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	866 //
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	867 // Do the raw retype conversions for OP_RETYPE_RAW.
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	868 void MethodHandleWalker::retype_raw_conversion(BasicType src, BasicType dst, bool for_return, int slot, TRAPS) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	869 if (src != dst) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	870 if (MethodHandles::same_basic_type_for_returns(src, dst, /raw/ true)) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	871 if (MethodHandles::is_float_fixed_reinterpretation_cast(src, dst)) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	872 vmIntrinsics::ID iid = vmIntrinsics::for_raw_conversion(src, dst);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	873 if (iid == vmIntrinsics::_none) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	874 lose("no raw conversion method", CHECK);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	875 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	876 ArgToken arglist[2];
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	877 if (!for_return) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	878 // argument type conversion
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	879 ArgToken arg = _outgoing.at(slot);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	880 assert(arg.token_type() >= tt_symbolic \|\| src == arg.basic_type(), "sanity");
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	881 arglist[0] = arg; // outgoing 'this'
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	882 arglist[1] = ArgToken(); // sentinel
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	883 arg = make_invoke(methodHandle(), iid, Bytecodes::_invokestatic, false, 1, &arglist[0], CHECK);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	884 change_argument(src, slot, dst, arg);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	885 } else {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	886 // return type conversion
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	887 if (_return_conv == vmIntrinsics::_none) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	888 _return_conv = iid;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	889 } else if (_return_conv == vmIntrinsics::for_raw_conversion(dst, src)) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	890 _return_conv = vmIntrinsics::_none;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	891 } else if (_return_conv != zero_return_conv()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	892 lose(err_msg("requested raw return conversion not allowed: %s -> %s (before %s)", type2name(src), type2name(dst), vmIntrinsics::name_at(_return_conv)), CHECK);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	893 }
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	894 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	895 } else {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	896 // Nothing to do.
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	897 }
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	898 } else if (for_return && (!is_subword_type(src) \|\| !is_subword_type(dst))) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	899 // This can occur in exception-throwing MHs, which have a fictitious return value encoded as Void or Empty.
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	900 _return_conv = zero_return_conv();
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	901 } else if (src == T_OBJECT && is_java_primitive(dst)) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	902 // ref-to-prim: discard ref, push zero
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	903 lose("requested ref-to-prim conversion not expected", CHECK);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	904 } else {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	905 lose(err_msg("requested raw conversion not allowed: %s -> %s", type2name(src), type2name(dst)), CHECK);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	906 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	907 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	908 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	909
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	910
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	911 // -----------------------------------------------------------------------------
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	912 // MethodHandleCompiler
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	913
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	914 MethodHandleCompiler::MethodHandleCompiler(Handle root, Symbol* name, Symbol* signature, int invoke_count, bool is_invokedynamic, TRAPS)
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	915 : MethodHandleWalker(root, is_invokedynamic, THREAD),
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	916 _invoke_count(invoke_count),
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	917 _thread(THREAD),
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	918 _bytecode(THREAD, 50),
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	919 _constants(THREAD, 10),
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	920 _non_bcp_klasses(THREAD, 5),
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	921 _cur_stack(0),
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	922 _max_stack(0),
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	923 _rtype(T_ILLEGAL),
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	924 _selectAlternative_bci(-1),
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	925 _taken_count(0),
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	926 _not_taken_count(0)
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	927 {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	928
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	929 // Element zero is always the null constant.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	930 (void) _constants.append(NULL);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	931
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	932 // Set name and signature index.
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	933 _name_index = cpool_symbol_put(name);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	934 _signature_index = cpool_symbol_put(signature);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	935
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	936 // To make the resulting methods more recognizable by
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	937 // stack walkers and compiler heuristics,
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	938 // we put them in holder class MethodHandle.
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	939 // See klass_is_method_handle_adapter_holder
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	940 // and methodOopDesc::is_method_handle_adapter.
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	941 _target_klass = SystemDictionaryHandles::MethodHandle_klass();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	942
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	943 check_non_bcp_klasses(java_lang_invoke_MethodHandle::type(root()), CHECK);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	944
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	945 // Get return type klass.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	946 Handle first_mtype(THREAD, chain().method_type_oop());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	947 // _rklass is NULL for primitives.
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	948 _rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(first_mtype()), &_rklass);
1152 cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters twisti parents: 1142 diff changeset	949 if (_rtype == T_ARRAY) _rtype = T_OBJECT;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	950
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	951 ArgumentSizeComputer args(signature);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	952 int params = args.size() + 1; // Incoming arguments plus receiver.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	953 _num_params = for_invokedynamic() ? params - 1 : params; // XXX Check if callee is static?
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	954 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	955
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	956
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	957 // -----------------------------------------------------------------------------
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	958 // MethodHandleCompiler::compile
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	959 //
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	960 // Compile this MethodHandle into a bytecode adapter and return a
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	961 // methodOop.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	962 methodHandle MethodHandleCompiler::compile(TRAPS) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	963 assert(_thread == THREAD, "must be same thread");
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	964 methodHandle nullHandle;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	965 (void) walk(CHECK_(nullHandle));
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	966 record_non_bcp_klasses();
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	967 return get_method_oop(CHECK_(nullHandle));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	968 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	969
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	970
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	971 void MethodHandleCompiler::emit_bc(Bytecodes::Code op, int index, int args_size) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	972 Bytecodes::check(op); // Are we legal?
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	973
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	974 switch (op) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	975 // b
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	976 case Bytecodes::_aconst_null:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	977 case Bytecodes::_iconst_m1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	978 case Bytecodes::_iconst_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	979 case Bytecodes::_iconst_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	980 case Bytecodes::_iconst_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	981 case Bytecodes::_iconst_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	982 case Bytecodes::_iconst_4:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	983 case Bytecodes::_iconst_5:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	984 case Bytecodes::_lconst_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	985 case Bytecodes::_lconst_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	986 case Bytecodes::_fconst_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	987 case Bytecodes::_fconst_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	988 case Bytecodes::_fconst_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	989 case Bytecodes::_dconst_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	990 case Bytecodes::_dconst_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	991 case Bytecodes::_iload_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	992 case Bytecodes::_iload_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	993 case Bytecodes::_iload_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	994 case Bytecodes::_iload_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	995 case Bytecodes::_lload_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	996 case Bytecodes::_lload_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	997 case Bytecodes::_lload_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	998 case Bytecodes::_lload_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	999 case Bytecodes::_fload_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1000 case Bytecodes::_fload_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1001 case Bytecodes::_fload_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1002 case Bytecodes::_fload_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1003 case Bytecodes::_dload_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1004 case Bytecodes::_dload_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1005 case Bytecodes::_dload_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1006 case Bytecodes::_dload_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1007 case Bytecodes::_aload_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1008 case Bytecodes::_aload_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1009 case Bytecodes::_aload_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1010 case Bytecodes::_aload_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1011 case Bytecodes::_istore_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1012 case Bytecodes::_istore_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1013 case Bytecodes::_istore_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1014 case Bytecodes::_istore_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1015 case Bytecodes::_lstore_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1016 case Bytecodes::_lstore_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1017 case Bytecodes::_lstore_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1018 case Bytecodes::_lstore_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1019 case Bytecodes::_fstore_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1020 case Bytecodes::_fstore_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1021 case Bytecodes::_fstore_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1022 case Bytecodes::_fstore_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1023 case Bytecodes::_dstore_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1024 case Bytecodes::_dstore_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1025 case Bytecodes::_dstore_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1026 case Bytecodes::_dstore_3:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1027 case Bytecodes::_astore_0:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1028 case Bytecodes::_astore_1:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1029 case Bytecodes::_astore_2:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1030 case Bytecodes::_astore_3:
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1031 case Bytecodes::_iand:
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1032 case Bytecodes::_i2l:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1033 case Bytecodes::_i2f:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1034 case Bytecodes::_i2d:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1035 case Bytecodes::_i2b:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1036 case Bytecodes::_i2c:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1037 case Bytecodes::_i2s:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1038 case Bytecodes::_l2i:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1039 case Bytecodes::_l2f:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1040 case Bytecodes::_l2d:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1041 case Bytecodes::_f2i:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1042 case Bytecodes::_f2l:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1043 case Bytecodes::_f2d:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1044 case Bytecodes::_d2i:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1045 case Bytecodes::_d2l:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1046 case Bytecodes::_d2f:
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1047 case Bytecodes::_iaload:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1048 case Bytecodes::_laload:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1049 case Bytecodes::_faload:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1050 case Bytecodes::_daload:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1051 case Bytecodes::_aaload:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1052 case Bytecodes::_baload:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1053 case Bytecodes::_caload:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1054 case Bytecodes::_saload:
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1055 case Bytecodes::_ireturn:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1056 case Bytecodes::_lreturn:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1057 case Bytecodes::_freturn:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1058 case Bytecodes::_dreturn:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1059 case Bytecodes::_areturn:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1060 case Bytecodes::_return:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1507 diff changeset	1061 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_b, "wrong bytecode format");
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1062 _bytecode.push(op);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1063 break;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1064
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1065 // bi
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1066 case Bytecodes::_ldc:
1662 e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing jrose parents: 1579 diff changeset	1067 assert(Bytecodes::format_bits(op, false) == (Bytecodes::_fmt_b\|Bytecodes::_fmt_has_k), "wrong bytecode format");
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1068 if (index == (index & 0xff)) {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1069 _bytecode.push(op);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1070 _bytecode.push(index);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1071 } else {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1072 _bytecode.push(Bytecodes::_ldc_w);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1073 _bytecode.push(index >> 8);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1074 _bytecode.push(index);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1075 }
1662 e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing jrose parents: 1579 diff changeset	1076 break;
e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing jrose parents: 1579 diff changeset	1077
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1078 case Bytecodes::_iload:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1079 case Bytecodes::_lload:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1080 case Bytecodes::_fload:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1081 case Bytecodes::_dload:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1082 case Bytecodes::_aload:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1083 case Bytecodes::_istore:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1084 case Bytecodes::_lstore:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1085 case Bytecodes::_fstore:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1086 case Bytecodes::_dstore:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1087 case Bytecodes::_astore:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1507 diff changeset	1088 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bi, "wrong bytecode format");
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1089 if (index == (index & 0xff)) {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1090 _bytecode.push(op);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1091 _bytecode.push(index);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1092 } else {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1093 // doesn't fit in a u2
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1094 _bytecode.push(Bytecodes::_wide);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1095 _bytecode.push(op);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1096 _bytecode.push(index >> 8);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1097 _bytecode.push(index);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1098 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1099 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1100
1662 e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing jrose parents: 1579 diff changeset	1101 // bkk
e0ba4e04c839 6969574: invokedynamic call sites deoptimize instead of executing jrose parents: 1579 diff changeset	1102 case Bytecodes::_ldc_w:
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1103 case Bytecodes::_ldc2_w:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1104 case Bytecodes::_checkcast:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1507 diff changeset	1105 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bkk, "wrong bytecode format");
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1106 assert((unsigned short) index == index, "index does not fit in 16-bit");
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1107 _bytecode.push(op);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1108 _bytecode.push(index >> 8);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1109 _bytecode.push(index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1110 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1111
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1507 diff changeset	1112 // bJJ
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1113 case Bytecodes::_invokestatic:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1114 case Bytecodes::_invokespecial:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1115 case Bytecodes::_invokevirtual:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1507 diff changeset	1116 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bJJ, "wrong bytecode format");
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1117 assert((unsigned short) index == index, "index does not fit in 16-bit");
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1118 _bytecode.push(op);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1119 _bytecode.push(index >> 8);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1120 _bytecode.push(index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1121 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1122
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1123 case Bytecodes::_invokeinterface:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1124 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bJJ, "wrong bytecode format");
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1125 assert((unsigned short) index == index, "index does not fit in 16-bit");
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1126 assert(args_size > 0, "valid args_size");
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1127 _bytecode.push(op);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1128 _bytecode.push(index >> 8);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1129 _bytecode.push(index);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1130 _bytecode.push(args_size);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1131 _bytecode.push(0);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1132 break;
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1133
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1134 case Bytecodes::_ifeq:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1135 assert((unsigned short) index == index, "index does not fit in 16-bit");
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1136 _bytecode.push(op);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1137 _bytecode.push(index >> 8);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1138 _bytecode.push(index);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1139 break;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1140
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1141 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1142 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1143 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1144 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1145
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1146 void MethodHandleCompiler::update_branch_dest(int src, int dst) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1147 switch (_bytecode.at(src)) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1148 case Bytecodes::_ifeq:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1149 dst -= src; // compute the offset
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1150 assert((unsigned short) dst == dst, "index does not fit in 16-bit");
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1151 _bytecode.at_put(src + 1, dst >> 8);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1152 _bytecode.at_put(src + 2, dst);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1153 break;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1154 default:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1155 ShouldNotReachHere();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1156 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1157 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1158
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1159 void MethodHandleCompiler::emit_load(ArgToken arg) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1160 TokenType tt = arg.token_type();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1161 BasicType bt = arg.basic_type();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1162
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1163 switch (tt) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1164 case tt_parameter:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1165 case tt_temporary:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1166 emit_load(bt, arg.index());
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1167 break;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1168 case tt_constant:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1169 emit_load_constant(arg);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1170 break;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1171 case tt_illegal:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1172 case tt_void:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1173 default:
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1174 ShouldNotReachHere();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1175 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1176 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1177
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1178
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1179 void MethodHandleCompiler::emit_load(BasicType bt, int index) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1180 if (index <= 3) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1181 switch (bt) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1182 case T_BOOLEAN: case T_BYTE: case T_CHAR: case T_SHORT:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1183 case T_INT: emit_bc(Bytecodes::cast(Bytecodes::_iload_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1184 case T_LONG: emit_bc(Bytecodes::cast(Bytecodes::_lload_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1185 case T_FLOAT: emit_bc(Bytecodes::cast(Bytecodes::_fload_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1186 case T_DOUBLE: emit_bc(Bytecodes::cast(Bytecodes::_dload_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1187 case T_OBJECT: emit_bc(Bytecodes::cast(Bytecodes::_aload_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1188 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1189 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1190 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1191 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1192 else {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1193 switch (bt) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1194 case T_BOOLEAN: case T_BYTE: case T_CHAR: case T_SHORT:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1195 case T_INT: emit_bc(Bytecodes::_iload, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1196 case T_LONG: emit_bc(Bytecodes::_lload, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1197 case T_FLOAT: emit_bc(Bytecodes::_fload, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1198 case T_DOUBLE: emit_bc(Bytecodes::_dload, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1199 case T_OBJECT: emit_bc(Bytecodes::_aload, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1200 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1201 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1202 }
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1203 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1204 stack_push(bt);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1205 }
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1206
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1207 void MethodHandleCompiler::emit_store(BasicType bt, int index) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1208 if (index <= 3) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1209 switch (bt) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1210 case T_BOOLEAN: case T_BYTE: case T_CHAR: case T_SHORT:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1211 case T_INT: emit_bc(Bytecodes::cast(Bytecodes::_istore_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1212 case T_LONG: emit_bc(Bytecodes::cast(Bytecodes::_lstore_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1213 case T_FLOAT: emit_bc(Bytecodes::cast(Bytecodes::_fstore_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1214 case T_DOUBLE: emit_bc(Bytecodes::cast(Bytecodes::_dstore_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1215 case T_OBJECT: emit_bc(Bytecodes::cast(Bytecodes::_astore_0 + index)); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1216 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1217 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1218 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1219 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1220 else {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1221 switch (bt) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1222 case T_BOOLEAN: case T_BYTE: case T_CHAR: case T_SHORT:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1223 case T_INT: emit_bc(Bytecodes::_istore, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1224 case T_LONG: emit_bc(Bytecodes::_lstore, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1225 case T_FLOAT: emit_bc(Bytecodes::_fstore, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1226 case T_DOUBLE: emit_bc(Bytecodes::_dstore, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1227 case T_OBJECT: emit_bc(Bytecodes::_astore, index); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1228 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1229 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1230 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1231 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1232 stack_pop(bt);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1233 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1234
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1235
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1236 void MethodHandleCompiler::emit_load_constant(ArgToken arg) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1237 BasicType bt = arg.basic_type();
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1238 if (is_subword_type(bt)) bt = T_INT;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1239 switch (bt) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1240 case T_INT: {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1241 jint value = arg.get_jint();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1242 if (-1 <= value && value <= 5)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1243 emit_bc(Bytecodes::cast(Bytecodes::_iconst_0 + value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1244 else
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1245 emit_bc(Bytecodes::_ldc, cpool_int_put(value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1246 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1247 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1248 case T_LONG: {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1249 jlong value = arg.get_jlong();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1250 if (0 <= value && value <= 1)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1251 emit_bc(Bytecodes::cast(Bytecodes::_lconst_0 + (int) value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1252 else
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1253 emit_bc(Bytecodes::_ldc2_w, cpool_long_put(value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1254 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1255 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1256 case T_FLOAT: {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1257 jfloat value = arg.get_jfloat();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1258 if (value == 0.0 \|\| value == 1.0 \|\| value == 2.0)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1259 emit_bc(Bytecodes::cast(Bytecodes::_fconst_0 + (int) value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1260 else
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1261 emit_bc(Bytecodes::_ldc, cpool_float_put(value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1262 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1263 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1264 case T_DOUBLE: {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1265 jdouble value = arg.get_jdouble();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1266 if (value == 0.0 \|\| value == 1.0)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1267 emit_bc(Bytecodes::cast(Bytecodes::_dconst_0 + (int) value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1268 else
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1269 emit_bc(Bytecodes::_ldc2_w, cpool_double_put(value));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1270 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1271 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1272 case T_OBJECT: {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1273 Handle value = arg.object();
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1274 if (value.is_null()) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1275 emit_bc(Bytecodes::_aconst_null);
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1276 break;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1277 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1278 if (java_lang_Class::is_instance(value())) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1279 klassOop k = java_lang_Class::as_klassOop(value());
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1280 if (k != NULL) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1281 emit_bc(Bytecodes::_ldc, cpool_klass_put(k));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1282 break;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1283 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1284 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1285 emit_bc(Bytecodes::_ldc, cpool_object_put(value));
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1286 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1287 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1288 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1289 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1290 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1291 stack_push(bt);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1292 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1293
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1294
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1295 MethodHandleWalker::ArgToken
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1296 MethodHandleCompiler::make_conversion(BasicType type, klassOop tk, Bytecodes::Code op,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1297 const ArgToken& src, TRAPS) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1298
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1299 BasicType srctype = src.basic_type();
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1300 TokenType tt = src.token_type();
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1301 int index = -1;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1302
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1303 switch (op) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1304 case Bytecodes::_i2l:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1305 case Bytecodes::_i2f:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1306 case Bytecodes::_i2d:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1307 case Bytecodes::_i2b:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1308 case Bytecodes::_i2c:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1309 case Bytecodes::_i2s:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1310
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1311 case Bytecodes::_l2i:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1312 case Bytecodes::_l2f:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1313 case Bytecodes::_l2d:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1314
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1315 case Bytecodes::_f2i:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1316 case Bytecodes::_f2l:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1317 case Bytecodes::_f2d:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1318
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1319 case Bytecodes::_d2i:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1320 case Bytecodes::_d2l:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1321 case Bytecodes::_d2f:
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1322 if (tt == tt_constant) {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1323 emit_load_constant(src);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1324 } else {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1325 emit_load(srctype, src.index());
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1326 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1327 stack_pop(srctype); // pop the src type
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1328 emit_bc(op);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1329 stack_push(type); // push the dest value
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1330 if (tt != tt_constant)
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1331 index = src.index();
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1332 if (srctype != type \|\| index == -1)
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1333 index = new_local_index(type);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1334 emit_store(type, index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1335 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1336
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1337 case Bytecodes::_checkcast:
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1338 if (tt == tt_constant) {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1339 emit_load_constant(src);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1340 } else {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1341 emit_load(srctype, src.index());
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1342 index = src.index();
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1343 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1344 emit_bc(op, cpool_klass_put(tk));
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1345 check_non_bcp_klass(tk, CHECK_(src));
3753 cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	1346 // Allocate a new local for the type so that we don't hide the
cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	1347 // previous type from the verifier.
cba7b5c2d53f 7045514: SPARC assembly code for JSR 292 ricochet frames never parents: 3740 diff changeset	1348 index = new_local_index(type);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1349 emit_store(srctype, index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1350 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1351
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1352 case Bytecodes::_nop:
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1353 // nothing to do
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1354 return src;
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1355
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1356 default:
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1357 if (op == Bytecodes::_illegal)
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1358 lose(err_msg("no such primitive conversion: %s -> %s", type2name(src.basic_type()), type2name(type)), THREAD);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1359 else
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1360 lose(err_msg("bad primitive conversion op: %s", Bytecodes::name(op)), THREAD);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1361 return make_prim_constant(type, &zero_jvalue, THREAD);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1362 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1363
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1364 return make_parameter(type, tk, index, THREAD);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1365 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1366
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1367
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1368 // -----------------------------------------------------------------------------
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1369 // MethodHandleCompiler
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1370 //
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1371
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1372 // Values used by the compiler.
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1373 jvalue MethodHandleCompiler::zero_jvalue = { 0 };
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1374 jvalue MethodHandleCompiler::one_jvalue = { 1 };
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1375
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1376 // Fetch any values from CountingMethodHandles and capture them for profiles
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1377 bool MethodHandleCompiler::fetch_counts(ArgToken arg1, ArgToken arg2) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1378 int count1 = -1, count2 = -1;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1379 if (arg1.token_type() == tt_constant && arg1.basic_type() == T_OBJECT &&
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1380 java_lang_invoke_CountingMethodHandle::is_instance(arg1.object()())) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1381 count1 = java_lang_invoke_CountingMethodHandle::vmcount(arg1.object()());
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1382 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1383 if (arg2.token_type() == tt_constant && arg2.basic_type() == T_OBJECT &&
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1384 java_lang_invoke_CountingMethodHandle::is_instance(arg2.object()())) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1385 count2 = java_lang_invoke_CountingMethodHandle::vmcount(arg2.object()());
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1386 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1387 int total = count1 + count2;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1388 if (count1 != -1 && count2 != -1 && total != 0) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1389 // Normalize the collect counts to the invoke_count
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1390 tty->print("counts %d %d scaled by %d = ", count2, count1, _invoke_count);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1391 if (count1 != 0) _not_taken_count = (int)(_invoke_count * count1 / (double)total);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1392 if (count2 != 0) _taken_count = (int)(_invoke_count * count2 / (double)total);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1393 tty->print_cr("%d %d", _taken_count, _not_taken_count);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1394 return true;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1395 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1396 return false;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1397 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1398
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1399 // Emit bytecodes for the given invoke instruction.
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1400 MethodHandleWalker::ArgToken
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1401 MethodHandleCompiler::make_invoke(methodHandle m, vmIntrinsics::ID iid,
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1402 Bytecodes::Code op, bool tailcall,
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1403 int argc, MethodHandleWalker::ArgToken* argv,
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1404 TRAPS) {
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1405 ArgToken zero;
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1406 if (m.is_null()) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1407 // Get the intrinsic methodOop.
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1408 m = methodHandle(THREAD, vmIntrinsics::method_for(iid));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1409 if (m.is_null()) {
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2226 diff changeset	1410 lose(vmIntrinsics::name_at(iid), CHECK_(zero));
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2226 diff changeset	1411 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1412 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1413
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1414 klassOop klass = m->method_holder();
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1415 Symbol* name = m->name();
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1416 Symbol* signature = m->signature();
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1417
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1418 if (iid == vmIntrinsics::_invokeGeneric &&
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1419 argc >= 1 && argv[0].token_type() == tt_constant) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1420 assert(m->intrinsic_id() == vmIntrinsics::_invokeExact, "");
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1421 Handle receiver = argv[0].object();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1422 Handle rtype(THREAD, java_lang_invoke_MethodHandle::type(receiver()));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1423 Handle mtype(THREAD, m->method_handle_type());
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1424 if (rtype() != mtype()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1425 assert(java_lang_invoke_MethodType::form(rtype()) ==
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1426 java_lang_invoke_MethodType::form(mtype()),
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1427 "must be the same shape");
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1428 // customize m to the exact required rtype
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1429 bool has_non_bcp_klass = check_non_bcp_klasses(rtype(), CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1430 TempNewSymbol sig2 = java_lang_invoke_MethodType::as_signature(rtype(), true, CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1431 methodHandle m2;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1432 if (!has_non_bcp_klass) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1433 methodOop m2_oop = SystemDictionary::find_method_handle_invoke(m->name(), sig2,
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1434 KlassHandle(), CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1435 m2 = methodHandle(THREAD, m2_oop);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1436 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1437 if (m2.is_null()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1438 // just build it fresh
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1439 m2 = methodOopDesc::make_invoke_method(klass, m->name(), sig2, rtype, CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1440 if (m2.is_null())
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1441 lose(err_msg("no customized invoker %s", sig2->as_utf8()), CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1442 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1443 m = m2;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1444 signature = m->signature();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1445 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1446 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1447
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1448 if (m->intrinsic_id() == vmIntrinsics::_selectAlternative &&
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1449 fetch_counts(argv[1], argv[2])) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1450 assert(argc == 3, "three arguments");
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1451 assert(tailcall, "only");
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1452
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1453 // do inline bytecodes so we can drop profile data into it,
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1454 // 0: iload_0
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1455 emit_load(argv[0]);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1456 // 1: ifeq 8
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1457 _selectAlternative_bci = _bytecode.length();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1458 emit_bc(Bytecodes::_ifeq, 0); // emit placeholder offset
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1459 // 4: aload_1
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1460 emit_load(argv[1]);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1461 // 5: areturn;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1462 emit_bc(Bytecodes::_areturn);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1463 // 8: aload_2
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1464 update_branch_dest(_selectAlternative_bci, cur_bci());
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1465 emit_load(argv[2]);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1466 // 9: areturn
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1467 emit_bc(Bytecodes::_areturn);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1468 return ArgToken(); // Dummy return value.
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1469 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1470
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1471 check_non_bcp_klass(klass, CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1472 if (m->is_method_handle_invoke()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1473 check_non_bcp_klasses(m->method_handle_type(), CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1474 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1475
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1476 // Count the number of arguments, not the size
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1477 ArgumentCount asc(signature);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1478 assert(argc == asc.size() + ((op == Bytecodes::_invokestatic \|\| op == Bytecodes::_invokedynamic) ? 0 : 1),
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1479 "argc mismatch");
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1480
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1481 for (int i = 0; i < argc; i++) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1482 ArgToken arg = argv[i];
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1483 TokenType tt = arg.token_type();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1484 BasicType bt = arg.basic_type();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1485
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1486 switch (tt) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1487 case tt_parameter:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1488 case tt_temporary:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1489 emit_load(bt, arg.index());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1490 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1491 case tt_constant:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1492 emit_load_constant(arg);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1493 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1494 case tt_illegal:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1495 // Sentinel.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1496 assert(i == (argc - 1), "sentinel must be last entry");
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1497 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1498 case tt_void:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1499 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1500 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1501 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1502 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1503
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1504 // Populate constant pool.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1505 int name_index = cpool_symbol_put(name);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1506 int signature_index = cpool_symbol_put(signature);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1507 int name_and_type_index = cpool_name_and_type_put(name_index, signature_index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1508 int klass_index = cpool_klass_put(klass);
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1509 int methodref_index = cpool_methodref_put(op, klass_index, name_and_type_index, m);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1510
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1511 // Generate invoke.
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1512 switch (op) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1513 case Bytecodes::_invokestatic:
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1514 case Bytecodes::_invokespecial:
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1515 case Bytecodes::_invokevirtual:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1516 emit_bc(op, methodref_index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1517 break;
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1518
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1519 case Bytecodes::_invokeinterface: {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1520 ArgumentSizeComputer asc(signature);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1521 emit_bc(op, methodref_index, asc.size() + 1);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1522 break;
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1523 }
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1524
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1525 default:
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1526 ShouldNotReachHere();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1527 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1528
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1529 // If tailcall, we have walked all the way to a direct method handle.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1530 // Otherwise, make a recursive call to some helper routine.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1531 BasicType rbt = m->result_type();
1152 cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters twisti parents: 1142 diff changeset	1532 if (rbt == T_ARRAY) rbt = T_OBJECT;
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1533 stack_push(rbt); // The return value is already pushed onto the stack.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1534 ArgToken ret;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1535 if (tailcall) {
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1536 if (return_conv() == zero_return_conv()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1537 rbt = T_VOID; // discard value
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1538 } else if (return_conv() != vmIntrinsics::_none) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1539 // return value conversion
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1540 int index = new_local_index(rbt);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1541 emit_store(rbt, index);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1542 ArgToken arglist[2];
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1543 arglist[0] = ArgToken(tt_temporary, rbt, index);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1544 arglist[1] = ArgToken(); // sentinel
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1545 ret = make_invoke(methodHandle(), return_conv(), Bytecodes::_invokestatic, false, 1, &arglist[0], CHECK_(zero));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1546 set_return_conv(vmIntrinsics::_none);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1547 rbt = ret.basic_type();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1548 emit_load(rbt, ret.index());
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1549 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1550 if (rbt != _rtype) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1551 if (rbt == T_VOID) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1552 // push a zero of the right sort
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1553 if (_rtype == T_OBJECT) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1554 zero = make_oop_constant(NULL, CHECK_(zero));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1555 } else {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1556 zero = make_prim_constant(_rtype, &zero_jvalue, CHECK_(zero));
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1557 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1558 emit_load_constant(zero);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1559 } else if (_rtype == T_VOID) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1560 // We'll emit a _return with something on the stack.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1561 // It's OK to ignore what's on the stack.
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1562 } else if (rbt == T_INT && is_subword_type(_rtype)) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1563 // Convert value to match return type.
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1564 switch (_rtype) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1565 case T_BOOLEAN: {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1566 // boolean is treated as a one-bit unsigned integer.
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1567 // Cf. API documentation: java/lang/invoke/MethodHandles.html#explicitCastArguments
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1568 ArgToken one = make_prim_constant(T_INT, &one_jvalue, CHECK_(zero));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1569 emit_load_constant(one);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1570 emit_bc(Bytecodes::_iand);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1571 break;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1572 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1573 case T_BYTE: emit_bc(Bytecodes::_i2b); break;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1574 case T_CHAR: emit_bc(Bytecodes::_i2c); break;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1575 case T_SHORT: emit_bc(Bytecodes::_i2s); break;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1576 default: ShouldNotReachHere();
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1577 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1578 } else if (is_subword_type(rbt) && (is_subword_type(_rtype) \|\| (_rtype == T_INT))) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1579 // The subword type was returned as an int and will be passed
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1580 // on as an int.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1581 } else {
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1582 lose("unknown conversion", CHECK_(zero));
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1583 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1584 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1585 switch (_rtype) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1586 case T_BOOLEAN: case T_BYTE: case T_CHAR: case T_SHORT:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1587 case T_INT: emit_bc(Bytecodes::_ireturn); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1588 case T_LONG: emit_bc(Bytecodes::_lreturn); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1589 case T_FLOAT: emit_bc(Bytecodes::_freturn); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1590 case T_DOUBLE: emit_bc(Bytecodes::_dreturn); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1591 case T_VOID: emit_bc(Bytecodes::_return); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1592 case T_OBJECT:
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	1593 if (_rklass.not_null() && _rklass() != SystemDictionary::Object_klass() && !Klass::cast(_rklass())->is_interface()) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1594 emit_bc(Bytecodes::_checkcast, cpool_klass_put(_rklass()));
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1595 check_non_bcp_klass(_rklass(), CHECK_(zero));
3757 f8c9417e3571 7052219: JSR 292: Crash in ~BufferBlob::MethodHandles adapters never parents: 3753 diff changeset	1596 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1597 emit_bc(Bytecodes::_areturn);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1598 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1599 default: ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1600 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1601 ret = ArgToken(); // Dummy return value.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1602 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1603 else {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1604 int index = new_local_index(rbt);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1605 switch (rbt) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1606 case T_BOOLEAN: case T_BYTE: case T_CHAR: case T_SHORT:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1607 case T_INT: case T_LONG: case T_FLOAT: case T_DOUBLE:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1608 case T_OBJECT:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1609 emit_store(rbt, index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1610 ret = ArgToken(tt_temporary, rbt, index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1611 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1612 case T_VOID:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1613 ret = ArgToken(tt_void);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1614 break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1615 default:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1616 ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1617 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1618 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1619
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1620 return ret;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1621 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1622
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1623 MethodHandleWalker::ArgToken
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1624 MethodHandleCompiler::make_fetch(BasicType type, klassOop tk, Bytecodes::Code op,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1625 const MethodHandleWalker::ArgToken& base,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1626 const MethodHandleWalker::ArgToken& offset,
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1627 TRAPS) {
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1628 switch (base.token_type()) {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1629 case tt_parameter:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1630 case tt_temporary:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1631 emit_load(base.basic_type(), base.index());
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1632 break;
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1633 case tt_constant:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1634 emit_load_constant(base);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1635 break;
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1636 default:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1637 ShouldNotReachHere();
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1638 }
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1639 switch (offset.token_type()) {
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1640 case tt_parameter:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1641 case tt_temporary:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1642 emit_load(offset.basic_type(), offset.index());
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1643 break;
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1644 case tt_constant:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1645 emit_load_constant(offset);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1646 break;
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1647 default:
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1648 ShouldNotReachHere();
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1649 }
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1650 emit_bc(op);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1651 int index = new_local_index(type);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1652 emit_store(type, index);
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1653 return ArgToken(tt_temporary, type, index);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1654 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1655
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1656
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1657 int MethodHandleCompiler::cpool_primitive_put(BasicType bt, jvalue* con) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1658 jvalue con_copy;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1659 assert(bt < T_OBJECT, "");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1660 if (type2aelembytes(bt) < jintSize) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1661 // widen to int
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1662 con_copy = (*con);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1663 con = &con_copy;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1664 switch (bt) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1665 case T_BOOLEAN: con->i = (con->z ? 1 : 0); break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1666 case T_BYTE: con->i = con->b; break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1667 case T_CHAR: con->i = con->c; break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1668 case T_SHORT: con->i = con->s; break;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1669 default: ShouldNotReachHere();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1670 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1671 bt = T_INT;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1672 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1673
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1674 // for (int i = 1, imax = _constants.length(); i < imax; i++) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1675 // ConstantValue* con = _constants.at(i);
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1676 // if (con != NULL && con->is_primitive() && con.basic_type() == bt) {
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1677 // bool match = false;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1678 // switch (type2size[bt]) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1679 // case 1: if (pcon->_value.i == con->i) match = true; break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1680 // case 2: if (pcon->_value.j == con->j) match = true; break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1681 // }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1682 // if (match)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1683 // return i;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1684 // }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1685 // }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1686 ConstantValue* cv = new ConstantValue(bt, *con);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1687 int index = _constants.append(cv);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1688
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1689 // long and double entries take 2 slots, we add another empty entry.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1690 if (type2size[bt] == 2)
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1691 (void) _constants.append(NULL);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1692
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1693 return index;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1694 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1695
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1696 bool MethodHandleCompiler::check_non_bcp_klasses(Handle method_type, TRAPS) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1697 bool res = false;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1698 for (int i = -1, len = java_lang_invoke_MethodType::ptype_count(method_type()); i < len; i++) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1699 oop ptype = (i == -1
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1700 ? java_lang_invoke_MethodType::rtype(method_type())
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1701 : java_lang_invoke_MethodType::ptype(method_type(), i));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1702 res \|= check_non_bcp_klass(java_lang_Class::as_klassOop(ptype), CHECK_(false));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1703 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1704 return res;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1705 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1706
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1707 bool MethodHandleCompiler::check_non_bcp_klass(klassOop klass, TRAPS) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1708 klass = methodOopDesc::check_non_bcp_klass(klass);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1709 if (klass != NULL) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1710 Symbol* name = Klass::cast(klass)->name();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1711 for (int i = _non_bcp_klasses.length() - 1; i >= 0; i--) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1712 klassOop k2 = _non_bcp_klasses.at(i)();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1713 if (Klass::cast(k2)->name() == name) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1714 if (k2 != klass) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1715 lose(err_msg("unsupported klass name alias %s", name->as_utf8()), THREAD);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1716 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1717 return true;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1718 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1719 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1720 _non_bcp_klasses.append(KlassHandle(THREAD, klass));
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1721 return true;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1722 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1723 return false;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1724 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1725
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1726 void MethodHandleCompiler::record_non_bcp_klasses() {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1727 // Append extra klasses to constant pool, to guide klass lookup.
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1728 for (int k = 0; k < _non_bcp_klasses.length(); k++) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1729 klassOop non_bcp_klass = _non_bcp_klasses.at(k)();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1730 bool add_to_cp = true;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1731 for (int j = 1; j < _constants.length(); j++) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1732 ConstantValue* cv = _constants.at(j);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1733 if (cv != NULL && cv->tag() == JVM_CONSTANT_Class
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1734 && cv->klass_oop() == non_bcp_klass) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1735 add_to_cp = false;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1736 break;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1737 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1738 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1739 if (add_to_cp) cpool_klass_put(non_bcp_klass);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1740 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1741 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1742
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1743 constantPoolHandle MethodHandleCompiler::get_constant_pool(TRAPS) const {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1744 constantPoolHandle nullHandle;
2226 c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	1745 constantPoolOop cpool_oop = oopFactory::new_constantPool(_constants.length(),
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	1746 oopDesc::IsSafeConc,
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	1747 CHECK_(nullHandle));
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1748 constantPoolHandle cpool(THREAD, cpool_oop);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1749
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1750 // Fill the real constant pool skipping the zero element.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1751 for (int i = 1; i < _constants.length(); i++) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1752 ConstantValue* cv = _constants.at(i);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1753 switch (cv->tag()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2117 diff changeset	1754 case JVM_CONSTANT_Utf8: cpool->symbol_at_put( i, cv->symbol() ); break;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1755 case JVM_CONSTANT_Integer: cpool->int_at_put( i, cv->get_jint() ); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1756 case JVM_CONSTANT_Float: cpool->float_at_put( i, cv->get_jfloat() ); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1757 case JVM_CONSTANT_Long: cpool->long_at_put( i, cv->get_jlong() ); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1758 case JVM_CONSTANT_Double: cpool->double_at_put( i, cv->get_jdouble() ); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1759 case JVM_CONSTANT_Class: cpool->klass_at_put( i, cv->klass_oop() ); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1760 case JVM_CONSTANT_Methodref: cpool->method_at_put( i, cv->first_index(), cv->second_index()); break;
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1761 case JVM_CONSTANT_InterfaceMethodref:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1762 cpool->interface_method_at_put(i, cv->first_index(), cv->second_index()); break;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1763 case JVM_CONSTANT_NameAndType: cpool->name_and_type_at_put(i, cv->first_index(), cv->second_index()); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1764 case JVM_CONSTANT_Object: cpool->object_at_put( i, cv->object_oop() ); break;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1765 default: ShouldNotReachHere();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1766 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1767
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1768 switch (cv->tag()) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1769 case JVM_CONSTANT_Long:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1770 case JVM_CONSTANT_Double:
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1771 i++; // Skip empty entry.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1772 assert(_constants.at(i) == NULL, "empty entry");
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1773 break;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1774 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1775 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1776
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1777 cpool->set_preresolution();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1778
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1779 // Set the constant pool holder to the target method's class.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1780 cpool->set_pool_holder(_target_klass());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1781
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1782 return cpool;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1783 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1784
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1785
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1786 methodHandle MethodHandleCompiler::get_method_oop(TRAPS) {
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1787 methodHandle empty;
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1788 // Create a method that holds the generated bytecode. invokedynamic
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1789 // has no receiver, normal MH calls do.
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1790 int flags_bits;
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1791 if (for_invokedynamic())
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1152 diff changeset	1792 flags_bits = (/JVM_MH_INVOKE_BITS \|/ JVM_ACC_PUBLIC \| JVM_ACC_FINAL \| JVM_ACC_SYNTHETIC \| JVM_ACC_STATIC);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1793 else
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1152 diff changeset	1794 flags_bits = (/JVM_MH_INVOKE_BITS \|/ JVM_ACC_PUBLIC \| JVM_ACC_FINAL \| JVM_ACC_SYNTHETIC);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1795
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1796 // Create a new method
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1797 methodHandle m;
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1798 {
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1799 methodOop m_oop = oopFactory::new_method(bytecode_length(),
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1800 accessFlags_from(flags_bits),
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1801 0, 0, 0, oopDesc::IsSafeConc, CHECK_(empty));
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1802 m = methodHandle(THREAD, m_oop);
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1803 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1804
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1805 constantPoolHandle cpool = get_constant_pool(CHECK_(empty));
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1806 m->set_constants(cpool());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1807
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1808 m->set_name_index(_name_index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1809 m->set_signature_index(_signature_index);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1810
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1811 m->set_code((address) bytecode());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1812
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1813 m->set_max_stack(_max_stack);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1814 m->set_max_locals(max_locals());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1815 m->set_size_of_parameters(_num_params);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1816
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1817 typeArrayHandle exception_handlers(THREAD, Universe::the_empty_int_array());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1818 m->set_exception_table(exception_handlers());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1819
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1820 // Rewrite the method and set up the constant pool cache.
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1821 objArrayOop m_array = oopFactory::new_system_objArray(1, CHECK_(empty));
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1822 objArrayHandle methods(THREAD, m_array);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1823 methods->obj_at_put(0, m());
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1824 Rewriter::rewrite(_target_klass(), cpool, methods, CHECK_(empty)); // Use fake class.
3748 d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 3388 diff changeset	1825 Rewriter::relocate_and_link(_target_klass(), methods, CHECK_(empty)); // Use fake class.
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1826
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1827 // Pre-resolve selected CP cache entries, to avoid problems with class loader scoping.
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1828 constantPoolCacheHandle cpc(THREAD, cpool->cache());
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1829 for (int i = 0; i < cpc->length(); i++) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1830 ConstantPoolCacheEntry* e = cpc->entry_at(i);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1831 assert(!e->is_secondary_entry(), "no indy instructions in here, yet");
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1832 int constant_pool_index = e->constant_pool_index();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1833 ConstantValue* cv = _constants.at(constant_pool_index);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1834 if (!cv->has_linkage()) continue;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1835 methodHandle m = cv->linkage();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1836 int index;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1837 switch (cv->tag()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1838 case JVM_CONSTANT_Methodref:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1839 index = m->vtable_index();
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1840 if (m->is_static()) {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1841 e->set_method(Bytecodes::_invokestatic, m, index);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1842 } else {
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1843 e->set_method(Bytecodes::_invokespecial, m, index);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1844 e->set_method(Bytecodes::_invokevirtual, m, index);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1845 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1846 break;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1847 case JVM_CONSTANT_InterfaceMethodref:
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1848 index = klassItable::compute_itable_index(m());
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1849 e->set_interface_call(m, index);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1850 break;
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1851 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1852 }
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1853
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1854 // Set the invocation counter's count to the invoke count of the
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1855 // original call site.
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1856 InvocationCounter* ic = m->invocation_counter();
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1857 ic->set(InvocationCounter::wait_for_compile, _invoke_count);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1858
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1859 // Create a new MDO
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1860 {
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1861 methodDataOop mdo = oopFactory::new_methodData(m, CHECK_(empty));
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1862 assert(m->method_data() == NULL, "there should not be an MDO yet");
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1863 m->set_method_data(mdo);
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1864
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1865 bool found_selectAlternative = false;
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1866 // Iterate over all profile data and set the count of the counter
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1867 // data entries to the original call site counter.
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1868 for (ProfileData* profile_data = mdo->first_data();
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1869 mdo->is_valid(profile_data);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1870 profile_data = mdo->next_data(profile_data)) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1871 if (profile_data->is_CounterData()) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1872 CounterData* counter_data = profile_data->as_CounterData();
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1873 counter_data->set_count(_invoke_count);
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1874 }
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1875 if (profile_data->is_BranchData() &&
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1876 profile_data->bci() == _selectAlternative_bci) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1877 BranchData* bd = profile_data->as_BranchData();
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1878 bd->set_taken(_taken_count);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1879 bd->set_not_taken(_not_taken_count);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1880 found_selectAlternative = true;
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1881 }
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1882 }
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3785 diff changeset	1883 assert(_selectAlternative_bci == -1 \|\| found_selectAlternative, "must have found profile entry");
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3363 diff changeset	1884 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1885
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1886 #ifndef PRODUCT
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1887 if (TraceMethodHandles) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1888 m->print();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1889 m->print_codes();
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1890 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1891 #endif //PRODUCT
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1892
1507 cd5dbf694d45 6939134: JSR 292 adjustments to method handle invocation jrose parents: 1152 diff changeset	1893 assert(m->is_method_handle_adapter(), "must be recognized as an adapter");
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1133 diff changeset	1894 return m;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1895 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1896
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1897
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1898 #ifndef PRODUCT
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1899
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1900 // MH printer for debugging.
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1901
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1902 class MethodHandlePrinter : public MethodHandleWalker {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1903 private:
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1904 outputStream* _out;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1905 bool _verbose;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1906 int _temp_num;
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1907 int _param_state;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1908 stringStream _strbuf;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1909 const char* strbuf() {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1910 const char* s = _strbuf.as_string();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1911 _strbuf.reset();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1912 return s;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1913 }
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1914 ArgToken token(const char* str, BasicType type) {
5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1915 return ArgToken(str, type);
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1916 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1917 const char* string(ArgToken token) {
3388 a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp never parents: 3385 diff changeset	1918 return token.str();
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1919 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1920 void start_params() {
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1921 _param_state <<= 1;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1922 _out->print("(");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1923 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1924 void end_params() {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1925 if (_verbose) _out->print("\n");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1926 _out->print(") => {");
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1927 _param_state >>= 1;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1928 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1929 void put_type_name(BasicType type, klassOop tk, outputStream* s) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1930 const char* kname = NULL;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1931 if (tk != NULL)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1932 kname = Klass::cast(tk)->external_name();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1933 s->print("%s", (kname != NULL) ? kname : type2name(type));
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1934 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1935 ArgToken maybe_make_temp(const char* statement_op, BasicType type, const char* temp_name) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1936 const char* value = strbuf();
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1937 if (!_verbose) return token(value, type);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1938 // make an explicit binding for each separate value
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1939 _strbuf.print("%s%d", temp_name, ++_temp_num);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1940 const char* temp = strbuf();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1941 _out->print("\n %s %s %s = %s;", statement_op, type2name(type), temp, value);
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1942 return token(temp, type);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1943 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1944
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1945 public:
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1946 MethodHandlePrinter(Handle root, bool verbose, outputStream* out, TRAPS)
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1947 : MethodHandleWalker(root, false, THREAD),
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1948 _out(out),
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1949 _verbose(verbose),
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1950 _param_state(0),
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1951 _temp_num(0)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1952 {
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1953 out->print("MethodHandle:");
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1954 java_lang_invoke_MethodType::print_signature(java_lang_invoke_MethodHandle::type(root()), out);
ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	1955 out->print(" : #");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1956 start_params();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1957 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1958 virtual ArgToken make_parameter(BasicType type, klassOop tk, int argnum, TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1959 if (argnum < 0) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1960 end_params();
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1961 return token("return", type);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1962 }
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1963 if ((_param_state & 1) == 0) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1964 _param_state \|= 1;
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1965 _out->print(_verbose ? "\n " : "");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1966 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1967 _out->print(_verbose ? ",\n " : ", ");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1968 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1969 if (argnum >= _temp_num)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1970 _temp_num = argnum;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1971 // generate an argument name
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1972 _strbuf.print("a%d", argnum);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1973 const char* arg = strbuf();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1974 put_type_name(type, tk, _out);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1975 _out->print(" %s", arg);
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	1976 return token(arg, type);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1977 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1978 virtual ArgToken make_oop_constant(oop con, TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1979 if (con == NULL)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1980 _strbuf.print("null");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1981 else
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1982 con->print_value_on(&_strbuf);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1983 if (_strbuf.size() == 0) { // yuck
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1984 _strbuf.print("(a ");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1985 put_type_name(T_OBJECT, con->klass(), &_strbuf);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1986 _strbuf.print(")");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1987 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1988 return maybe_make_temp("constant", T_OBJECT, "k");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1989 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1990 virtual ArgToken make_prim_constant(BasicType type, jvalue* con, TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1991 java_lang_boxing_object::print(type, con, &_strbuf);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1992 return maybe_make_temp("constant", type, "k");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	1993 }
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1994 void print_bytecode_name(Bytecodes::Code op) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1995 if (Bytecodes::is_defined(op))
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1996 _strbuf.print("%s", Bytecodes::name(op));
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1997 else
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1998 _strbuf.print("bytecode_%d", (int) op);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	1999 }
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2000 virtual ArgToken make_conversion(BasicType type, klassOop tk, Bytecodes::Code op, const ArgToken& src, TRAPS) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2001 print_bytecode_name(op);
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2002 _strbuf.print("(%s", string(src));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2003 if (tk != NULL) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2004 _strbuf.print(", ");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2005 put_type_name(type, tk, &_strbuf);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2006 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2007 _strbuf.print(")");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2008 return maybe_make_temp("convert", type, "v");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2009 }
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2010 virtual ArgToken make_fetch(BasicType type, klassOop tk, Bytecodes::Code op, const ArgToken& base, const ArgToken& offset, TRAPS) {
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2011 _strbuf.print("%s(%s, %s", Bytecodes::name(op), string(base), string(offset));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2012 if (tk != NULL) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2013 _strbuf.print(", ");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2014 put_type_name(type, tk, &_strbuf);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2015 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2016 _strbuf.print(")");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2017 return maybe_make_temp("fetch", type, "x");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2018 }
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	2019 virtual ArgToken make_invoke(methodHandle m, vmIntrinsics::ID iid,
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2020 Bytecodes::Code op, bool tailcall,
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2021 int argc, ArgToken* argv, TRAPS) {
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2022 Symbol* name;
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2023 Symbol* sig;
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 3759 diff changeset	2024 if (m.not_null()) {
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2025 name = m->name();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2026 sig = m->signature();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2027 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2028 name = vmSymbols::symbol_at(vmIntrinsics::name_for(iid));
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2029 sig = vmSymbols::symbol_at(vmIntrinsics::signature_for(iid));
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2030 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2031 _strbuf.print("%s %s%s(", Bytecodes::name(op), name->as_C_string(), sig->as_C_string());
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2032 for (int i = 0; i < argc; i++) {
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2033 _strbuf.print("%s%s", (i > 0 ? ", " : ""), string(argv[i]));
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2034 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2035 _strbuf.print(")");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2036 if (!tailcall) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2037 BasicType rt = char2type(sig->byte_at(sig->utf8_length()-1));
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2038 if (rt == T_ILLEGAL) rt = T_OBJECT; // ';' at the end of '(...)L...;'
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2039 return maybe_make_temp("invoke", rt, "x");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2040 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2041 const char* ret = strbuf();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2042 _out->print(_verbose ? "\n return " : " ");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2043 _out->print("%s", ret);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2044 _out->print(_verbose ? "\n}\n" : " }");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2045 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2046 return ArgToken();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2047 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2048
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2049 virtual void set_method_handle(oop mh) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2050 if (WizardMode && Verbose) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2051 tty->print("\n--- next target: ");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2052 mh->print();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2053 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2054 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2055
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2056 static void print(Handle root, bool verbose, outputStream* out, TRAPS) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2057 ResourceMark rm;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2058 MethodHandlePrinter printer(root, verbose, out, CHECK);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2059 printer.walk(CHECK);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2060 out->print("\n");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2061 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2062 static void print(Handle root, bool verbose = Verbose, outputStream* out = tty) {
3740 5ac411b3b8fc 7047961: JSR 292 MethodHandleWalk swap args doesn't handle T_LONG and T_DOUBLE properly never parents: 3388 diff changeset	2063 Thread* THREAD = Thread::current();
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2064 ResourceMark rm;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2065 MethodHandlePrinter printer(root, verbose, out, THREAD);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2066 if (!HAS_PENDING_EXCEPTION)
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2067 printer.walk(THREAD);
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2068 if (HAS_PENDING_EXCEPTION) {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2069 oop ex = PENDING_EXCEPTION;
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2070 CLEAR_PENDING_EXCEPTION;
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2071 out->print(" *** ");
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2072 if (printer.lose_message() != NULL) out->print("%s ", printer.lose_message());
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2073 out->print("}");
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2074 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2075 out->print("\n");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2076 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2077 };
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2078
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2079 extern "C"
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2080 void print_method_handle(oop mh) {
1793 d257356e35f0 6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions jrose parents: 1783 diff changeset	2081 if (!mh->is_oop()) {
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2082 tty->print_cr("*** not a method handle: "PTR_FORMAT, (intptr_t)mh);
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	2083 } else if (java_lang_invoke_MethodHandle::is_instance(mh)) {
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 3366 diff changeset	2084 MethodHandlePrinter::print(mh);
1133 aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2085 } else {
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2086 tty->print("*** not a method handle: ");
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2087 mh->print();
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2088 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2089 }
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2090
aa62b9388fce 6894206: JVM needs a way to traverse method handle structures twisti parents: diff changeset	2091 #endif // PRODUCT

Mercurial > hg > graal-compiler

annotate src/share/vm/prims/methodHandleWalk.cpp @ 3992:d1bdeef3e3e2