jdk-sandbox: comparison hotspot/src/share/vm/prims/methodHandleWalk.cpp

equal deleted inserted replaced

-:a9aea2b8010f
+:b3d5b50e2289
 BasicType dest = java_lang_Class::as_BasicType(chain().adapter_arg_oop(), &dest_klass);
 assert(dest == T_OBJECT, "");
 assert(dest == arg_state->_type, "");
 ArgToken arg = arg_state->_arg;
 ArgToken new_arg = make_conversion(T_OBJECT, dest_klass, Bytecodes::_checkcast, arg, CHECK_(empty));
-assert(arg.token_type() >= tt_symbolic || arg.index() == new_arg.index(), "should be the same index");
+assert(!arg.has_index() || arg.index() == new_arg.index(), "should be the same index");
 debug_only(dest_klass = (klassOop)badOop);
 break;
 }
 case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM: {
 !Klass::cast(rklass)->is_interface()) {
 // preserve type safety
 ret = make_conversion(T_OBJECT, rklass, Bytecodes::_checkcast, ret, CHECK_(empty));
 }
 }
-int ret_slot = arg_slot + (retain_original_args ? coll_slots : 0);
+if (rtype != T_VOID) {
-change_argument(T_VOID, ret_slot, rtype, ret);
+int ret_slot = arg_slot + (retain_original_args ? coll_slots : 0);
+change_argument(T_VOID, ret_slot, rtype, ret);
+}
 break;
 }
 case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {
 klassOop array_klass_oop = NULL;
 // -----------------------------------------------------------------------------
 // MethodHandleCompiler
-MethodHandleCompiler::MethodHandleCompiler(Handle root, methodHandle callee, int invoke_count, bool is_invokedynamic, TRAPS)
+MethodHandleCompiler::MethodHandleCompiler(Handle root, Symbol* name, Symbol* signature, int invoke_count, bool is_invokedynamic, TRAPS)
 : MethodHandleWalker(root, is_invokedynamic, THREAD),
-_callee(callee),
 _invoke_count(invoke_count),
 _thread(THREAD),
 _bytecode(THREAD, 50),
 _constants(THREAD, 10),
 _cur_stack(0),
 // Element zero is always the null constant.
 (void) _constants.append(NULL);
 // Set name and signature index.
-_name_index      = cpool_symbol_put(_callee->name());
+_name_index      = cpool_symbol_put(name);
-_signature_index = cpool_symbol_put(_callee->signature());
+_signature_index = cpool_symbol_put(signature);
 // Get return type klass.
 Handle first_mtype(THREAD, chain().method_type_oop());
 // _rklass is NULL for primitives.
 _rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(first_mtype()), &_rklass);
 if (_rtype == T_ARRAY)  _rtype = T_OBJECT;
-int params = _callee->size_of_parameters();  // Incoming arguments plus receiver.
+ArgumentSizeComputer args(signature);
+int params = args.size() + 1;  // Incoming arguments plus receiver.
 _num_params = for_invokedynamic() ? params - 1 : params;  // XXX Check if callee is static?
 }
 // -----------------------------------------------------------------------------
 (void) walk(CHECK_(nullHandle));
 return get_method_oop(CHECK_(nullHandle));
 }
-void MethodHandleCompiler::emit_bc(Bytecodes::Code op, int index) {
+void MethodHandleCompiler::emit_bc(Bytecodes::Code op, int index, int args_size) {
 Bytecodes::check(op);  // Are we legal?
 switch (op) {
 // b
 case Bytecodes::_aconst_null:
 case Bytecodes::_f2l:
 case Bytecodes::_f2d:
 case Bytecodes::_d2i:
 case Bytecodes::_d2l:
 case Bytecodes::_d2f:
+case Bytecodes::_iaload:
+case Bytecodes::_laload:
+case Bytecodes::_faload:
+case Bytecodes::_daload:
+case Bytecodes::_aaload:
+case Bytecodes::_baload:
+case Bytecodes::_caload:
+case Bytecodes::_saload:
 case Bytecodes::_ireturn:
 case Bytecodes::_lreturn:
 case Bytecodes::_freturn:
 case Bytecodes::_dreturn:
 case Bytecodes::_areturn:
 break;
 // bi
 case Bytecodes::_ldc:
 assert(Bytecodes::format_bits(op, false) == (Bytecodes::_fmt_b|Bytecodes::_fmt_has_k), "wrong bytecode format");
-assert((char) index == index, "index does not fit in 8-bit");
+if (index == (index & 0xff)) {
 _bytecode.push(op);
 _bytecode.push(index);
+} else {
+_bytecode.push(Bytecodes::_ldc_w);
+_bytecode.push(index >> 8);
+_bytecode.push(index);
+}
 break;
 case Bytecodes::_iload:
 case Bytecodes::_lload:
 case Bytecodes::_fload:
 case Bytecodes::_lstore:
 case Bytecodes::_fstore:
 case Bytecodes::_dstore:
 case Bytecodes::_astore:
 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bi, "wrong bytecode format");
-assert((char) index == index, "index does not fit in 8-bit");
+if (index == (index & 0xff)) {
 _bytecode.push(op);
 _bytecode.push(index);
+} else {
+// doesn't fit in a u2
+_bytecode.push(Bytecodes::_wide);
+_bytecode.push(op);
+_bytecode.push(index >> 8);
+_bytecode.push(index);
+}
 break;
 // bkk
 case Bytecodes::_ldc_w:
 case Bytecodes::_ldc2_w:
 case Bytecodes::_checkcast:
 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bkk, "wrong bytecode format");
-assert((short) index == index, "index does not fit in 16-bit");
+assert((unsigned short) index == index, "index does not fit in 16-bit");
 _bytecode.push(op);
 _bytecode.push(index >> 8);
 _bytecode.push(index);
 break;
 // bJJ
 case Bytecodes::_invokestatic:
 case Bytecodes::_invokespecial:
 case Bytecodes::_invokevirtual:
 assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bJJ, "wrong bytecode format");
-assert((short) index == index, "index does not fit in 16-bit");
+assert((unsigned short) index == index, "index does not fit in 16-bit");
 _bytecode.push(op);
 _bytecode.push(index >> 8);
 _bytecode.push(index);
+break;
+case Bytecodes::_invokeinterface:
+assert(Bytecodes::format_bits(op, false) == Bytecodes::_fmt_bJJ, "wrong bytecode format");
+assert((unsigned short) index == index, "index does not fit in 16-bit");
+assert(args_size > 0, "valid args_size");
+_bytecode.push(op);
+_bytecode.push(index >> 8);
+_bytecode.push(index);
+_bytecode.push(args_size);
+_bytecode.push(0);
 break;
 default:
 ShouldNotReachHere();
 }
 MethodHandleWalker::ArgToken
 MethodHandleCompiler::make_conversion(BasicType type, klassOop tk, Bytecodes::Code op,
 const ArgToken& src, TRAPS) {
 BasicType srctype = src.basic_type();
-int index = src.index();
+TokenType tt = src.token_type();
+int index = -1;
 switch (op) {
 case Bytecodes::_i2l:
 case Bytecodes::_i2f:
 case Bytecodes::_i2d:
 case Bytecodes::_f2d:
 case Bytecodes::_d2i:
 case Bytecodes::_d2l:
 case Bytecodes::_d2f:
-emit_load(srctype, index);
+if (tt == tt_constant) {
+emit_load_constant(src);
+} else {
+emit_load(srctype, src.index());
+}
 stack_pop(srctype);  // pop the src type
 emit_bc(op);
 stack_push(type);    // push the dest value
-if (srctype != type)
+if (tt != tt_constant)
+index = src.index();
+if (srctype != type || index == -1)
 index = new_local_index(type);
 emit_store(type, index);
 break;
 case Bytecodes::_checkcast:
-emit_load(srctype, index);
+if (tt == tt_constant) {
+emit_load_constant(src);
+} else {
+emit_load(srctype, src.index());
+index = src.index();
+}
 emit_bc(op, cpool_klass_put(tk));
+if (index == -1)
+index = new_local_index(type);
 emit_store(srctype, index);
 break;
 default:
 if (op == Bytecodes::_illegal)
 }
 klassOop klass     = m->method_holder();
 Symbol*  name      = m->name();
 Symbol*  signature = m->signature();
+// Count the number of arguments, not the size
+ArgumentCount asc(signature);
+assert(argc == asc.size() + ((op == Bytecodes::_invokestatic || op == Bytecodes::_invokedynamic) ? 0 : 1),
+"argc mismatch");
 if (tailcall) {
 // Actually, in order to make these methods more recognizable,
 // let's put them in holder class MethodHandle.  That way stack
 // walkers and compiler heuristics can recognize them.
 case Bytecodes::_invokestatic:
 case Bytecodes::_invokespecial:
 case Bytecodes::_invokevirtual:
 emit_bc(op, methodref_index);
 break;
-case Bytecodes::_invokeinterface:
-Unimplemented();
+case Bytecodes::_invokeinterface: {
+ArgumentSizeComputer asc(signature);
+emit_bc(op, methodref_index, asc.size() + 1);
 break;
+}
 default:
 ShouldNotReachHere();
 }
 // If tailcall, we have walked all the way to a direct method handle.
 // Otherwise, make a recursive call to some helper routine.
 BasicType rbt = m->result_type();
 if (rbt == T_ARRAY)  rbt = T_OBJECT;
+stack_push(rbt);  // The return value is already pushed onto the stack.
 ArgToken ret;
 if (tailcall) {
 if (rbt != _rtype) {
 if (rbt == T_VOID) {
 // push a zero of the right sort
 default: ShouldNotReachHere();
 }
 ret = ArgToken();  // Dummy return value.
 }
 else {
-stack_push(rbt);  // The return value is already pushed onto the stack.
 int index = new_local_index(rbt);
 switch (rbt) {
 case T_BOOLEAN: case T_BYTE: case T_CHAR:  case T_SHORT:
 case T_INT:     case T_LONG: case T_FLOAT: case T_DOUBLE:
 case T_OBJECT:
 MethodHandleWalker::ArgToken
 MethodHandleCompiler::make_fetch(BasicType type, klassOop tk, Bytecodes::Code op,
 const MethodHandleWalker::ArgToken& base,
 const MethodHandleWalker::ArgToken& offset,
 TRAPS) {
-Unimplemented();
+switch (base.token_type()) {
-return ArgToken();
+case tt_parameter:
+case tt_temporary:
+emit_load(base.basic_type(), base.index());
+break;
+case tt_constant:
+emit_load_constant(base);
+break;
+default:
+ShouldNotReachHere();
+}
+switch (offset.token_type()) {
+case tt_parameter:
+case tt_temporary:
+emit_load(offset.basic_type(), offset.index());
+break;
+case tt_constant:
+emit_load_constant(offset);
+break;
+default:
+ShouldNotReachHere();
+}
+emit_bc(op);
+int index = new_local_index(type);
+emit_store(type, index);
+return ArgToken(tt_temporary, type, index);
 }
 int MethodHandleCompiler::cpool_primitive_put(BasicType bt, jvalue* con) {
 jvalue con_copy;
 const char* s = _strbuf.as_string();
 _strbuf.reset();
 return s;
 }
 ArgToken token(const char* str) {
-jvalue string_con;
+return ArgToken(str);
-string_con.j = (intptr_t) str;
-return ArgToken(tt_symbolic, T_LONG, string_con);
 }
 const char* string(ArgToken token) {
-return (const char*) (intptr_t) token.get_jlong();
+return token.str();
 }
 void start_params() {
 _param_state <<= 1;
 _out->print("(");
 }

changeset 9946	b3d5b50e2289
parent 9943	a9aea2b8010f
child 9971	d496ecd7b9de
child 9963	4a783069663c