Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/src/cpu/sparc/vm/assembler_sparc.cpp	Fri Mar 11 22:33:47 2011 -0800
     1.2 +++ b/src/cpu/sparc/vm/assembler_sparc.cpp	Fri Mar 11 22:34:57 2011 -0800
     1.3 @@ -3179,7 +3179,7 @@
     1.4                                                Label& wrong_method_type) {
     1.5    assert_different_registers(mtype_reg, mh_reg, temp_reg);
     1.6    // compare method type against that of the receiver
     1.7 -  RegisterOrConstant mhtype_offset = delayed_value(java_dyn_MethodHandle::type_offset_in_bytes, temp_reg);
     1.8 +  RegisterOrConstant mhtype_offset = delayed_value(java_lang_invoke_MethodHandle::type_offset_in_bytes, temp_reg);
     1.9    load_heap_oop(mh_reg, mhtype_offset, temp_reg);
    1.10    cmp(temp_reg, mtype_reg);
    1.11    br(Assembler::notEqual, false, Assembler::pn, wrong_method_type);
    1.12 @@ -3195,14 +3195,14 @@
    1.13                                                  Register temp_reg) {
    1.14    assert_different_registers(vmslots_reg, mh_reg, temp_reg);
    1.15    // load mh.type.form.vmslots
    1.16 -  if (java_dyn_MethodHandle::vmslots_offset_in_bytes() != 0) {
    1.17 +  if (java_lang_invoke_MethodHandle::vmslots_offset_in_bytes() != 0) {
    1.18      // hoist vmslots into every mh to avoid dependent load chain
    1.19 -    ld(           Address(mh_reg,    delayed_value(java_dyn_MethodHandle::vmslots_offset_in_bytes, temp_reg)),   vmslots_reg);
    1.20 +    ld(           Address(mh_reg,    delayed_value(java_lang_invoke_MethodHandle::vmslots_offset_in_bytes, temp_reg)),   vmslots_reg);
    1.21    } else {
    1.22      Register temp2_reg = vmslots_reg;
    1.23 -    load_heap_oop(Address(mh_reg,    delayed_value(java_dyn_MethodHandle::type_offset_in_bytes, temp_reg)),      temp2_reg);
    1.24 -    load_heap_oop(Address(temp2_reg, delayed_value(java_dyn_MethodType::form_offset_in_bytes, temp_reg)),        temp2_reg);
    1.25 -    ld(           Address(temp2_reg, delayed_value(java_dyn_MethodTypeForm::vmslots_offset_in_bytes, temp_reg)), vmslots_reg);
    1.26 +    load_heap_oop(Address(mh_reg,    delayed_value(java_lang_invoke_MethodHandle::type_offset_in_bytes, temp_reg)),      temp2_reg);
    1.27 +    load_heap_oop(Address(temp2_reg, delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes, temp_reg)),        temp2_reg);
    1.28 +    ld(           Address(temp2_reg, delayed_value(java_lang_invoke_MethodTypeForm::vmslots_offset_in_bytes, temp_reg)), vmslots_reg);
    1.29    }
    1.30  }
    1.31  
    1.32 @@ -3213,7 +3213,7 @@
    1.33  
    1.34    // pick out the interpreted side of the handler
    1.35    // NOTE: vmentry is not an oop!
    1.36 -  ld_ptr(mh_reg, delayed_value(java_dyn_MethodHandle::vmentry_offset_in_bytes, temp_reg), temp_reg);
    1.37 +  ld_ptr(mh_reg, delayed_value(java_lang_invoke_MethodHandle::vmentry_offset_in_bytes, temp_reg), temp_reg);
    1.38  
    1.39    // off we go...
    1.40    ld_ptr(temp_reg, MethodHandleEntry::from_interpreted_entry_offset_in_bytes(), temp_reg);

     2.1 --- a/src/cpu/sparc/vm/cppInterpreter_sparc.cpp	Fri Mar 11 22:33:47 2011 -0800
     2.2 +++ b/src/cpu/sparc/vm/cppInterpreter_sparc.cpp	Fri Mar 11 22:34:57 2011 -0800
     2.3 @@ -1,5 +1,5 @@
     2.4  /*
     2.5 - * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
     2.6 + * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
     2.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     2.8   *
     2.9   * This code is free software; you can redistribute it and/or modify it
    2.10 @@ -1188,7 +1188,7 @@
    2.11    __ st_ptr(O2, XXX_STATE(_stack));                // PREPUSH
    2.12  
    2.13    __ lduh(max_stack, O3);                      // Full size expression stack
    2.14 -  guarantee(!EnableMethodHandles, "no support yet for java.dyn.MethodHandle"); //6815692
    2.15 +  guarantee(!EnableMethodHandles, "no support yet for java.lang.invoke.MethodHandle"); //6815692
    2.16    //6815692//if (EnableMethodHandles)
    2.17    //6815692//  __ inc(O3, methodOopDesc::extra_stack_entries());
    2.18    __ sll(O3, LogBytesPerWord, O3);

     3.1 --- a/src/cpu/sparc/vm/interpreter_sparc.cpp	Fri Mar 11 22:33:47 2011 -0800
     3.2 +++ b/src/cpu/sparc/vm/interpreter_sparc.cpp	Fri Mar 11 22:34:57 2011 -0800
     3.3 @@ -1,5 +1,5 @@
     3.4  /*
     3.5 - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
     3.6 + * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
     3.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3.8   *
     3.9   * This code is free software; you can redistribute it and/or modify it
    3.10 @@ -260,7 +260,7 @@
    3.11  
    3.12  
    3.13  // Method handle invoker
    3.14 -// Dispatch a method of the form java.dyn.MethodHandles::invoke(...)
    3.15 +// Dispatch a method of the form java.lang.invoke.MethodHandles::invoke(...)
    3.16  address InterpreterGenerator::generate_method_handle_entry(void) {
    3.17    if (!EnableMethodHandles) {
    3.18      return generate_abstract_entry();

     4.1 --- a/src/cpu/sparc/vm/methodHandles_sparc.cpp	Fri Mar 11 22:33:47 2011 -0800
     4.2 +++ b/src/cpu/sparc/vm/methodHandles_sparc.cpp	Fri Mar 11 22:34:57 2011 -0800
     4.3 @@ -112,8 +112,8 @@
     4.4    }
     4.5  
     4.6    // given the MethodType, find out where the MH argument is buried
     4.7 -  __ load_heap_oop(Address(O0_mtype,   __ delayed_value(java_dyn_MethodType::form_offset_in_bytes,        O1_scratch)), O4_argslot);
     4.8 -  __ ldsw(         Address(O4_argslot, __ delayed_value(java_dyn_MethodTypeForm::vmslots_offset_in_bytes, O1_scratch)), O4_argslot);
     4.9 +  __ load_heap_oop(Address(O0_mtype,   __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes,        O1_scratch)), O4_argslot);
    4.10 +  __ ldsw(         Address(O4_argslot, __ delayed_value(java_lang_invoke_MethodTypeForm::vmslots_offset_in_bytes, O1_scratch)), O4_argslot);
    4.11    __ add(Gargs, __ argument_offset(O4_argslot, 1), O4_argbase);
    4.12    // Note: argument_address uses its input as a scratch register!
    4.13    __ ld_ptr(Address(O4_argbase, -Interpreter::stackElementSize), G3_method_handle);
    4.14 @@ -141,10 +141,10 @@
    4.15    // load up an adapter from the calling type (Java weaves this)
    4.16    Register O2_form    = O2_scratch;
    4.17    Register O3_adapter = O3_scratch;
    4.18 -  __ load_heap_oop(Address(O0_mtype, __ delayed_value(java_dyn_MethodType::form_offset_in_bytes,               O1_scratch)), O2_form);
    4.19 -  // load_heap_oop(Address(O2_form,  __ delayed_value(java_dyn_MethodTypeForm::genericInvoker_offset_in_bytes, O1_scratch)), O3_adapter);
    4.20 +  __ load_heap_oop(Address(O0_mtype, __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes,               O1_scratch)), O2_form);
    4.21 +  // load_heap_oop(Address(O2_form,  __ delayed_value(java_lang_invoke_MethodTypeForm::genericInvoker_offset_in_bytes, O1_scratch)), O3_adapter);
    4.22    // deal with old JDK versions:
    4.23 -  __ add(          Address(O2_form,  __ delayed_value(java_dyn_MethodTypeForm::genericInvoker_offset_in_bytes, O1_scratch)), O3_adapter);
    4.24 +  __ add(          Address(O2_form,  __ delayed_value(java_lang_invoke_MethodTypeForm::genericInvoker_offset_in_bytes, O1_scratch)), O3_adapter);
    4.25    __ cmp(O3_adapter, O2_form);
    4.26    Label sorry_no_invoke_generic;
    4.27    __ brx(Assembler::lessUnsigned, false, Assembler::pn, sorry_no_invoke_generic);
    4.28 @@ -376,16 +376,16 @@
    4.29  
    4.30  // which conversion op types are implemented here?
    4.31  int MethodHandles::adapter_conversion_ops_supported_mask() {
    4.32 -  return ((1<<sun_dyn_AdapterMethodHandle::OP_RETYPE_ONLY)
    4.33 -         |(1<<sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW)
    4.34 -         |(1<<sun_dyn_AdapterMethodHandle::OP_CHECK_CAST)
    4.35 -         |(1<<sun_dyn_AdapterMethodHandle::OP_PRIM_TO_PRIM)
    4.36 -         |(1<<sun_dyn_AdapterMethodHandle::OP_REF_TO_PRIM)
    4.37 -         |(1<<sun_dyn_AdapterMethodHandle::OP_SWAP_ARGS)
    4.38 -         |(1<<sun_dyn_AdapterMethodHandle::OP_ROT_ARGS)
    4.39 -         |(1<<sun_dyn_AdapterMethodHandle::OP_DUP_ARGS)
    4.40 -         |(1<<sun_dyn_AdapterMethodHandle::OP_DROP_ARGS)
    4.41 -         //|(1<<sun_dyn_AdapterMethodHandle::OP_SPREAD_ARGS) //BUG!
    4.42 +  return ((1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY)
    4.43 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW)
    4.44 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST)
    4.45 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM)
    4.46 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM)
    4.47 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS)
    4.48 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS)
    4.49 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS)
    4.50 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS)
    4.51 +         //|(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) //BUG!
    4.52           );
    4.53    // FIXME: MethodHandlesTest gets a crash if we enable OP_SPREAD_ARGS.
    4.54  }
    4.55 @@ -413,22 +413,22 @@
    4.56    const Register O1_actual   = O1;
    4.57    const Register O2_required = O2;
    4.58  
    4.59 -  guarantee(java_dyn_MethodHandle::vmentry_offset_in_bytes() != 0, "must have offsets");
    4.60 +  guarantee(java_lang_invoke_MethodHandle::vmentry_offset_in_bytes() != 0, "must have offsets");
    4.61  
    4.62    // Some handy addresses:
    4.63    Address G5_method_fie(    G5_method,        in_bytes(methodOopDesc::from_interpreted_offset()));
    4.64    Address G5_method_fce(    G5_method,        in_bytes(methodOopDesc::from_compiled_offset()));
    4.65  
    4.66 -  Address G3_mh_vmtarget(   G3_method_handle, java_dyn_MethodHandle::vmtarget_offset_in_bytes());
    4.67 +  Address G3_mh_vmtarget(   G3_method_handle, java_lang_invoke_MethodHandle::vmtarget_offset_in_bytes());
    4.68  
    4.69 -  Address G3_dmh_vmindex(   G3_method_handle, sun_dyn_DirectMethodHandle::vmindex_offset_in_bytes());
    4.70 +  Address G3_dmh_vmindex(   G3_method_handle, java_lang_invoke_DirectMethodHandle::vmindex_offset_in_bytes());
    4.71  
    4.72 -  Address G3_bmh_vmargslot( G3_method_handle, sun_dyn_BoundMethodHandle::vmargslot_offset_in_bytes());
    4.73 -  Address G3_bmh_argument(  G3_method_handle, sun_dyn_BoundMethodHandle::argument_offset_in_bytes());
    4.74 +  Address G3_bmh_vmargslot( G3_method_handle, java_lang_invoke_BoundMethodHandle::vmargslot_offset_in_bytes());
    4.75 +  Address G3_bmh_argument(  G3_method_handle, java_lang_invoke_BoundMethodHandle::argument_offset_in_bytes());
    4.76  
    4.77 -  Address G3_amh_vmargslot( G3_method_handle, sun_dyn_AdapterMethodHandle::vmargslot_offset_in_bytes());
    4.78 -  Address G3_amh_argument ( G3_method_handle, sun_dyn_AdapterMethodHandle::argument_offset_in_bytes());
    4.79 -  Address G3_amh_conversion(G3_method_handle, sun_dyn_AdapterMethodHandle::conversion_offset_in_bytes());
    4.80 +  Address G3_amh_vmargslot( G3_method_handle, java_lang_invoke_AdapterMethodHandle::vmargslot_offset_in_bytes());
    4.81 +  Address G3_amh_argument ( G3_method_handle, java_lang_invoke_AdapterMethodHandle::argument_offset_in_bytes());
    4.82 +  Address G3_amh_conversion(G3_method_handle, java_lang_invoke_AdapterMethodHandle::conversion_offset_in_bytes());
    4.83  
    4.84    const int java_mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();
    4.85  
    4.86 @@ -453,7 +453,7 @@
    4.87        __ mov(O5_savedSP, SP);  // Cut the stack back to where the caller started.
    4.88  
    4.89        Label L_no_method;
    4.90 -      // FIXME: fill in _raise_exception_method with a suitable sun.dyn method
    4.91 +      // FIXME: fill in _raise_exception_method with a suitable java.lang.invoke method
    4.92        __ set(AddressLiteral((address) &_raise_exception_method), G5_method);
    4.93        __ ld_ptr(Address(G5_method, 0), G5_method);
    4.94        __ tst(G5_method);

     5.1 --- a/src/cpu/sparc/vm/templateTable_sparc.cpp	Fri Mar 11 22:33:47 2011 -0800
     5.2 +++ b/src/cpu/sparc/vm/templateTable_sparc.cpp	Fri Mar 11 22:34:57 2011 -0800
     5.3 @@ -3303,7 +3303,7 @@
     5.4    __ sll(Rret, LogBytesPerWord, Rret);
     5.5    __ ld_ptr(Rtemp, Rret, Rret);  // get return address
     5.6  
     5.7 -  __ load_heap_oop(G5_callsite, __ delayed_value(java_dyn_CallSite::target_offset_in_bytes, Rscratch), G3_method_handle);
     5.8 +  __ load_heap_oop(G5_callsite, __ delayed_value(java_lang_invoke_CallSite::target_offset_in_bytes, Rscratch), G3_method_handle);
     5.9    __ null_check(G3_method_handle);
    5.10  
    5.11    // Adjust Rret first so Llast_SP can be same as Rret

     6.1 --- a/src/cpu/x86/vm/assembler_x86.cpp	Fri Mar 11 22:33:47 2011 -0800
     6.2 +++ b/src/cpu/x86/vm/assembler_x86.cpp	Fri Mar 11 22:34:57 2011 -0800
     6.3 @@ -7831,7 +7831,7 @@
     6.4  void MacroAssembler::check_method_handle_type(Register mtype_reg, Register mh_reg,
     6.5                                                Register temp_reg,
     6.6                                                Label& wrong_method_type) {
     6.7 -  Address type_addr(mh_reg, delayed_value(java_dyn_MethodHandle::type_offset_in_bytes, temp_reg));
     6.8 +  Address type_addr(mh_reg, delayed_value(java_lang_invoke_MethodHandle::type_offset_in_bytes, temp_reg));
     6.9    // compare method type against that of the receiver
    6.10    if (UseCompressedOops) {
    6.11      load_heap_oop(temp_reg, type_addr);
    6.12 @@ -7851,14 +7851,14 @@
    6.13                                                  Register temp_reg) {
    6.14    assert_different_registers(vmslots_reg, mh_reg, temp_reg);
    6.15    // load mh.type.form.vmslots
    6.16 -  if (java_dyn_MethodHandle::vmslots_offset_in_bytes() != 0) {
    6.17 +  if (java_lang_invoke_MethodHandle::vmslots_offset_in_bytes() != 0) {
    6.18      // hoist vmslots into every mh to avoid dependent load chain
    6.19 -    movl(vmslots_reg, Address(mh_reg, delayed_value(java_dyn_MethodHandle::vmslots_offset_in_bytes, temp_reg)));
    6.20 +    movl(vmslots_reg, Address(mh_reg, delayed_value(java_lang_invoke_MethodHandle::vmslots_offset_in_bytes, temp_reg)));
    6.21    } else {
    6.22      Register temp2_reg = vmslots_reg;
    6.23 -    load_heap_oop(temp2_reg, Address(mh_reg,    delayed_value(java_dyn_MethodHandle::type_offset_in_bytes, temp_reg)));
    6.24 -    load_heap_oop(temp2_reg, Address(temp2_reg, delayed_value(java_dyn_MethodType::form_offset_in_bytes, temp_reg)));
    6.25 -    movl(vmslots_reg, Address(temp2_reg, delayed_value(java_dyn_MethodTypeForm::vmslots_offset_in_bytes, temp_reg)));
    6.26 +    load_heap_oop(temp2_reg, Address(mh_reg,    delayed_value(java_lang_invoke_MethodHandle::type_offset_in_bytes, temp_reg)));
    6.27 +    load_heap_oop(temp2_reg, Address(temp2_reg, delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes, temp_reg)));
    6.28 +    movl(vmslots_reg, Address(temp2_reg, delayed_value(java_lang_invoke_MethodTypeForm::vmslots_offset_in_bytes, temp_reg)));
    6.29    }
    6.30  }
    6.31  
    6.32 @@ -7873,7 +7873,7 @@
    6.33  
    6.34    // pick out the interpreted side of the handler
    6.35    // NOTE: vmentry is not an oop!
    6.36 -  movptr(temp_reg, Address(mh_reg, delayed_value(java_dyn_MethodHandle::vmentry_offset_in_bytes, temp_reg)));
    6.37 +  movptr(temp_reg, Address(mh_reg, delayed_value(java_lang_invoke_MethodHandle::vmentry_offset_in_bytes, temp_reg)));
    6.38  
    6.39    // off we go...
    6.40    jmp(Address(temp_reg, MethodHandleEntry::from_interpreted_entry_offset_in_bytes()));

     7.1 --- a/src/cpu/x86/vm/interpreter_x86_32.cpp	Fri Mar 11 22:33:47 2011 -0800
     7.2 +++ b/src/cpu/x86/vm/interpreter_x86_32.cpp	Fri Mar 11 22:34:57 2011 -0800
     7.3 @@ -231,7 +231,7 @@
     7.4  
     7.5  
     7.6  // Method handle invoker
     7.7 -// Dispatch a method of the form java.dyn.MethodHandles::invoke(...)
     7.8 +// Dispatch a method of the form java.lang.invoke.MethodHandles::invoke(...)
     7.9  address InterpreterGenerator::generate_method_handle_entry(void) {
    7.10    if (!EnableMethodHandles) {
    7.11      return generate_abstract_entry();

     8.1 --- a/src/cpu/x86/vm/interpreter_x86_64.cpp	Fri Mar 11 22:33:47 2011 -0800
     8.2 +++ b/src/cpu/x86/vm/interpreter_x86_64.cpp	Fri Mar 11 22:34:57 2011 -0800
     8.3 @@ -1,5 +1,5 @@
     8.4  /*
     8.5 - * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
     8.6 + * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
     8.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.8   *
     8.9   * This code is free software; you can redistribute it and/or modify it
    8.10 @@ -318,7 +318,7 @@
    8.11  
    8.12  
    8.13  // Method handle invoker
    8.14 -// Dispatch a method of the form java.dyn.MethodHandles::invoke(...)
    8.15 +// Dispatch a method of the form java.lang.invoke.MethodHandles::invoke(...)
    8.16  address InterpreterGenerator::generate_method_handle_entry(void) {
    8.17    if (!EnableMethodHandles) {
    8.18      return generate_abstract_entry();

     9.1 --- a/src/cpu/x86/vm/methodHandles_x86.cpp	Fri Mar 11 22:33:47 2011 -0800
     9.2 +++ b/src/cpu/x86/vm/methodHandles_x86.cpp	Fri Mar 11 22:34:57 2011 -0800
     9.3 @@ -125,9 +125,9 @@
     9.4    }
     9.5  
     9.6    // given the MethodType, find out where the MH argument is buried
     9.7 -  __ load_heap_oop(rdx_temp, Address(rax_mtype, __ delayed_value(java_dyn_MethodType::form_offset_in_bytes, rdi_temp)));
     9.8 +  __ load_heap_oop(rdx_temp, Address(rax_mtype, __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes, rdi_temp)));
     9.9    Register rdx_vmslots = rdx_temp;
    9.10 -  __ movl(rdx_vmslots, Address(rdx_temp, __ delayed_value(java_dyn_MethodTypeForm::vmslots_offset_in_bytes, rdi_temp)));
    9.11 +  __ movl(rdx_vmslots, Address(rdx_temp, __ delayed_value(java_lang_invoke_MethodTypeForm::vmslots_offset_in_bytes, rdi_temp)));
    9.12    __ movptr(rcx_recv, __ argument_address(rdx_vmslots));
    9.13  
    9.14    trace_method_handle(_masm, "invokeExact");
    9.15 @@ -154,11 +154,11 @@
    9.16                     rcx_argslot, rbx_temp, rdx_temp);
    9.17  
    9.18    // load up an adapter from the calling type (Java weaves this)
    9.19 -  __ load_heap_oop(rdx_temp, Address(rax_mtype, __ delayed_value(java_dyn_MethodType::form_offset_in_bytes, rdi_temp)));
    9.20 +  __ load_heap_oop(rdx_temp, Address(rax_mtype, __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes, rdi_temp)));
    9.21    Register rdx_adapter = rdx_temp;
    9.22 -  // __ load_heap_oop(rdx_adapter, Address(rdx_temp, java_dyn_MethodTypeForm::genericInvoker_offset_in_bytes()));
    9.23 +  // __ load_heap_oop(rdx_adapter, Address(rdx_temp, java_lang_invoke_MethodTypeForm::genericInvoker_offset_in_bytes()));
    9.24    // deal with old JDK versions:
    9.25 -  __ lea(rdi_temp, Address(rdx_temp, __ delayed_value(java_dyn_MethodTypeForm::genericInvoker_offset_in_bytes, rdi_temp)));
    9.26 +  __ lea(rdi_temp, Address(rdx_temp, __ delayed_value(java_lang_invoke_MethodTypeForm::genericInvoker_offset_in_bytes, rdi_temp)));
    9.27    __ cmpptr(rdi_temp, rdx_temp);
    9.28    Label sorry_no_invoke_generic;
    9.29    __ jcc(Assembler::below, sorry_no_invoke_generic);
    9.30 @@ -371,16 +371,16 @@
    9.31  
    9.32  // which conversion op types are implemented here?
    9.33  int MethodHandles::adapter_conversion_ops_supported_mask() {
    9.34 -  return ((1<<sun_dyn_AdapterMethodHandle::OP_RETYPE_ONLY)
    9.35 -         |(1<<sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW)
    9.36 -         |(1<<sun_dyn_AdapterMethodHandle::OP_CHECK_CAST)
    9.37 -         |(1<<sun_dyn_AdapterMethodHandle::OP_PRIM_TO_PRIM)
    9.38 -         |(1<<sun_dyn_AdapterMethodHandle::OP_REF_TO_PRIM)
    9.39 -         |(1<<sun_dyn_AdapterMethodHandle::OP_SWAP_ARGS)
    9.40 -         |(1<<sun_dyn_AdapterMethodHandle::OP_ROT_ARGS)
    9.41 -         |(1<<sun_dyn_AdapterMethodHandle::OP_DUP_ARGS)
    9.42 -         |(1<<sun_dyn_AdapterMethodHandle::OP_DROP_ARGS)
    9.43 -         //|(1<<sun_dyn_AdapterMethodHandle::OP_SPREAD_ARGS) //BUG!
    9.44 +  return ((1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY)
    9.45 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW)
    9.46 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST)
    9.47 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM)
    9.48 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM)
    9.49 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS)
    9.50 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS)
    9.51 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS)
    9.52 +         |(1<<java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS)
    9.53 +         //|(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) //BUG!
    9.54           );
    9.55    // FIXME: MethodHandlesTest gets a crash if we enable OP_SPREAD_ARGS.
    9.56  }
    9.57 @@ -415,21 +415,21 @@
    9.58    const Register rarg2_required = LP64_ONLY(j_rarg2) NOT_LP64(rdi);
    9.59    assert_different_registers(rarg0_code, rarg1_actual, rarg2_required, saved_last_sp);
    9.60  
    9.61 -  guarantee(java_dyn_MethodHandle::vmentry_offset_in_bytes() != 0, "must have offsets");
    9.62 +  guarantee(java_lang_invoke_MethodHandle::vmentry_offset_in_bytes() != 0, "must have offsets");
    9.63  
    9.64    // some handy addresses
    9.65    Address rbx_method_fie(     rbx,      methodOopDesc::from_interpreted_offset() );
    9.66    Address rbx_method_fce(     rbx,      methodOopDesc::from_compiled_offset() );
    9.67  
    9.68 -  Address rcx_mh_vmtarget(    rcx_recv, java_dyn_MethodHandle::vmtarget_offset_in_bytes() );
    9.69 -  Address rcx_dmh_vmindex(    rcx_recv, sun_dyn_DirectMethodHandle::vmindex_offset_in_bytes() );
    9.70 +  Address rcx_mh_vmtarget(    rcx_recv, java_lang_invoke_MethodHandle::vmtarget_offset_in_bytes() );
    9.71 +  Address rcx_dmh_vmindex(    rcx_recv, java_lang_invoke_DirectMethodHandle::vmindex_offset_in_bytes() );
    9.72  
    9.73 -  Address rcx_bmh_vmargslot(  rcx_recv, sun_dyn_BoundMethodHandle::vmargslot_offset_in_bytes() );
    9.74 -  Address rcx_bmh_argument(   rcx_recv, sun_dyn_BoundMethodHandle::argument_offset_in_bytes() );
    9.75 +  Address rcx_bmh_vmargslot(  rcx_recv, java_lang_invoke_BoundMethodHandle::vmargslot_offset_in_bytes() );
    9.76 +  Address rcx_bmh_argument(   rcx_recv, java_lang_invoke_BoundMethodHandle::argument_offset_in_bytes() );
    9.77  
    9.78 -  Address rcx_amh_vmargslot(  rcx_recv, sun_dyn_AdapterMethodHandle::vmargslot_offset_in_bytes() );
    9.79 -  Address rcx_amh_argument(   rcx_recv, sun_dyn_AdapterMethodHandle::argument_offset_in_bytes() );
    9.80 -  Address rcx_amh_conversion( rcx_recv, sun_dyn_AdapterMethodHandle::conversion_offset_in_bytes() );
    9.81 +  Address rcx_amh_vmargslot(  rcx_recv, java_lang_invoke_AdapterMethodHandle::vmargslot_offset_in_bytes() );
    9.82 +  Address rcx_amh_argument(   rcx_recv, java_lang_invoke_AdapterMethodHandle::argument_offset_in_bytes() );
    9.83 +  Address rcx_amh_conversion( rcx_recv, java_lang_invoke_AdapterMethodHandle::conversion_offset_in_bytes() );
    9.84    Address vmarg;                // __ argument_address(vmargslot)
    9.85  
    9.86    const int java_mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();
    9.87 @@ -460,7 +460,7 @@
    9.88  
    9.89        Register rbx_method = rbx_temp;
    9.90        Label L_no_method;
    9.91 -      // FIXME: fill in _raise_exception_method with a suitable sun.dyn method
    9.92 +      // FIXME: fill in _raise_exception_method with a suitable java.lang.invoke method
    9.93        __ movptr(rbx_method, ExternalAddress((address) &_raise_exception_method));
    9.94        __ testptr(rbx_method, rbx_method);
    9.95        __ jccb(Assembler::zero, L_no_method);

    10.1 --- a/src/cpu/x86/vm/templateTable_x86_32.cpp	Fri Mar 11 22:33:47 2011 -0800
    10.2 +++ b/src/cpu/x86/vm/templateTable_x86_32.cpp	Fri Mar 11 22:34:57 2011 -0800
    10.3 @@ -3110,7 +3110,7 @@
    10.4      __ profile_call(rsi);
    10.5    }
    10.6  
    10.7 -  __ movptr(rcx_method_handle, Address(rax_callsite, __ delayed_value(java_dyn_CallSite::target_offset_in_bytes, rcx)));
    10.8 +  __ movptr(rcx_method_handle, Address(rax_callsite, __ delayed_value(java_lang_invoke_CallSite::target_offset_in_bytes, rcx)));
    10.9    __ null_check(rcx_method_handle);
   10.10    __ prepare_to_jump_from_interpreted();
   10.11    __ jump_to_method_handle_entry(rcx_method_handle, rdx);

    11.1 --- a/src/cpu/x86/vm/templateTable_x86_64.cpp	Fri Mar 11 22:33:47 2011 -0800
    11.2 +++ b/src/cpu/x86/vm/templateTable_x86_64.cpp	Fri Mar 11 22:34:57 2011 -0800
    11.3 @@ -3145,7 +3145,7 @@
    11.4      __ profile_call(r13);
    11.5    }
    11.6  
    11.7 -  __ load_heap_oop(rcx_method_handle, Address(rax_callsite, __ delayed_value(java_dyn_CallSite::target_offset_in_bytes, rcx)));
    11.8 +  __ load_heap_oop(rcx_method_handle, Address(rax_callsite, __ delayed_value(java_lang_invoke_CallSite::target_offset_in_bytes, rcx)));
    11.9    __ null_check(rcx_method_handle);
   11.10    __ prepare_to_jump_from_interpreted();
   11.11    __ jump_to_method_handle_entry(rcx_method_handle, rdx);

    12.1 --- a/src/share/vm/c1/c1_LIR.hpp	Fri Mar 11 22:33:47 2011 -0800
    12.2 +++ b/src/share/vm/c1/c1_LIR.hpp	Fri Mar 11 22:34:57 2011 -0800
    12.3 @@ -1,5 +1,5 @@
    12.4  /*
    12.5 - * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
    12.6 + * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
    12.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    12.8   *
    12.9   * This code is free software; you can redistribute it and/or modify it
   12.10 @@ -1156,7 +1156,7 @@
   12.11      return
   12.12        is_invokedynamic()  // An invokedynamic is always a MethodHandle call site.
   12.13        ||
   12.14 -      (method()->holder()->name() == ciSymbol::java_dyn_MethodHandle() &&
   12.15 +      (method()->holder()->name() == ciSymbol::java_lang_invoke_MethodHandle() &&
   12.16         methodOopDesc::is_method_handle_invoke_name(method()->name()->sid()));
   12.17    }
   12.18  

    13.1 --- a/src/share/vm/c1/c1_LIRGenerator.cpp	Fri Mar 11 22:33:47 2011 -0800
    13.2 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp	Fri Mar 11 22:34:57 2011 -0800
    13.3 @@ -2512,7 +2512,7 @@
    13.4        __ load(new LIR_Address(tmp, call_site_offset, T_OBJECT), tmp);
    13.5  
    13.6        // Load target MethodHandle from CallSite object.
    13.7 -      __ load(new LIR_Address(tmp, java_dyn_CallSite::target_offset_in_bytes(), T_OBJECT), receiver);
    13.8 +      __ load(new LIR_Address(tmp, java_lang_invoke_CallSite::target_offset_in_bytes(), T_OBJECT), receiver);
    13.9  
   13.10        __ call_dynamic(target, receiver, result_register,
   13.11                        SharedRuntime::get_resolve_opt_virtual_call_stub(),

    14.1 --- a/src/share/vm/ci/ciCallSite.cpp	Fri Mar 11 22:33:47 2011 -0800
    14.2 +++ b/src/share/vm/ci/ciCallSite.cpp	Fri Mar 11 22:34:57 2011 -0800
    14.3 @@ -1,5 +1,5 @@
    14.4  /*
    14.5 - * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
    14.6 + * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
    14.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    14.8   *
    14.9   * This code is free software; you can redistribute it and/or modify it
   14.10 @@ -34,7 +34,7 @@
   14.11  // Return the target MethodHandle of this CallSite.
   14.12  ciMethodHandle* ciCallSite::get_target() const {
   14.13    VM_ENTRY_MARK;
   14.14 -  oop method_handle_oop = java_dyn_CallSite::target(get_oop());
   14.15 +  oop method_handle_oop = java_lang_invoke_CallSite::target(get_oop());
   14.16    return CURRENT_ENV->get_object(method_handle_oop)->as_method_handle();
   14.17  }
   14.18  

    15.1 --- a/src/share/vm/ci/ciCallSite.hpp	Fri Mar 11 22:33:47 2011 -0800
    15.2 +++ b/src/share/vm/ci/ciCallSite.hpp	Fri Mar 11 22:34:57 2011 -0800
    15.3 @@ -1,5 +1,5 @@
    15.4  /*
    15.5 - * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
    15.6 + * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
    15.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    15.8   *
    15.9   * This code is free software; you can redistribute it and/or modify it
   15.10 @@ -29,7 +29,7 @@
   15.11  
   15.12  // ciCallSite
   15.13  //
   15.14 -// The class represents a java.dyn.CallSite object.
   15.15 +// The class represents a java.lang.invoke.CallSite object.
   15.16  class ciCallSite : public ciInstance {
   15.17  public:
   15.18    ciCallSite(instanceHandle h_i) : ciInstance(h_i) {}

    16.1 --- a/src/share/vm/ci/ciField.cpp	Fri Mar 11 22:33:47 2011 -0800
    16.2 +++ b/src/share/vm/ci/ciField.cpp	Fri Mar 11 22:34:57 2011 -0800
    16.3 @@ -177,7 +177,7 @@
    16.4      // Never trust strangely unstable finals:  System.out, etc.
    16.5      return false;
    16.6    // Even if general trusting is disabled, trust system-built closures in these packages.
    16.7 -  if (holder->is_in_package("java/dyn") || holder->is_in_package("sun/dyn"))
    16.8 +  if (holder->is_in_package("java/lang/invoke") || holder->is_in_package("sun/invoke"))
    16.9      return true;
   16.10    return TrustFinalNonStaticFields;
   16.11  }
   16.12 @@ -191,8 +191,9 @@
   16.13    // Check to see if the field is constant.
   16.14    if (_holder->is_initialized() && this->is_final()) {
   16.15      if (!this->is_static()) {
   16.16 -      // A field can be constant if it's a final static field or if it's
   16.17 -      // a final non-static field of a trusted class ({java,sun}.dyn).
   16.18 +      // A field can be constant if it's a final static field or if
   16.19 +      // it's a final non-static field of a trusted class (classes in
   16.20 +      // java.lang.invoke and sun.invoke packages and subpackages).
   16.21        if (trust_final_non_static_fields(_holder)) {
   16.22          _is_constant = true;
   16.23          return;

    17.1 --- a/src/share/vm/ci/ciMethod.cpp	Fri Mar 11 22:33:47 2011 -0800
    17.2 +++ b/src/share/vm/ci/ciMethod.cpp	Fri Mar 11 22:34:57 2011 -0800
    17.3 @@ -1,5 +1,5 @@
    17.4  /*
    17.5 - * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
    17.6 + * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
    17.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    17.8   *
    17.9   * This code is free software; you can redistribute it and/or modify it
   17.10 @@ -769,7 +769,7 @@
   17.11  // signature-polymorphic MethodHandle methods, invokeExact or invokeGeneric.
   17.12  bool ciMethod::is_method_handle_invoke() const {
   17.13    if (!is_loaded()) {
   17.14 -    bool flag = (holder()->name() == ciSymbol::java_dyn_MethodHandle() &&
   17.15 +    bool flag = (holder()->name() == ciSymbol::java_lang_invoke_MethodHandle() &&
   17.16                   methodOopDesc::is_method_handle_invoke_name(name()->sid()));
   17.17      return flag;
   17.18    }

    18.1 --- a/src/share/vm/ci/ciMethodHandle.hpp	Fri Mar 11 22:33:47 2011 -0800
    18.2 +++ b/src/share/vm/ci/ciMethodHandle.hpp	Fri Mar 11 22:34:57 2011 -0800
    18.3 @@ -1,5 +1,5 @@
    18.4  /*
    18.5 - * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
    18.6 + * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
    18.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    18.8   *
    18.9   * This code is free software; you can redistribute it and/or modify it
   18.10 @@ -30,7 +30,7 @@
   18.11  
   18.12  // ciMethodHandle
   18.13  //
   18.14 -// The class represents a java.dyn.MethodHandle object.
   18.15 +// The class represents a java.lang.invoke.MethodHandle object.
   18.16  class ciMethodHandle : public ciInstance {
   18.17  private:
   18.18    ciMethod* _callee;

    19.1 --- a/src/share/vm/ci/ciObjectFactory.cpp	Fri Mar 11 22:33:47 2011 -0800
    19.2 +++ b/src/share/vm/ci/ciObjectFactory.cpp	Fri Mar 11 22:34:57 2011 -0800
    19.3 @@ -1,5 +1,5 @@
    19.4  /*
    19.5 - * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
    19.6 + * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
    19.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    19.8   *
    19.9   * This code is free software; you can redistribute it and/or modify it
   19.10 @@ -342,9 +342,9 @@
   19.11      return new (arena()) ciMethodData(h_md);
   19.12    } else if (o->is_instance()) {
   19.13      instanceHandle h_i(THREAD, (instanceOop)o);
   19.14 -    if (java_dyn_CallSite::is_instance(o))
   19.15 +    if (java_lang_invoke_CallSite::is_instance(o))
   19.16        return new (arena()) ciCallSite(h_i);
   19.17 -    else if (java_dyn_MethodHandle::is_instance(o))
   19.18 +    else if (java_lang_invoke_MethodHandle::is_instance(o))
   19.19        return new (arena()) ciMethodHandle(h_i);
   19.20      else
   19.21        return new (arena()) ciInstance(h_i);

    20.1 --- a/src/share/vm/ci/ciStreams.cpp	Fri Mar 11 22:33:47 2011 -0800
    20.2 +++ b/src/share/vm/ci/ciStreams.cpp	Fri Mar 11 22:34:57 2011 -0800
    20.3 @@ -1,5 +1,5 @@
    20.4  /*
    20.5 - * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
    20.6 + * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
    20.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    20.8   *
    20.9   * This code is free software; you can redistribute it and/or modify it
   20.10 @@ -380,7 +380,7 @@
   20.11    bool ignore;
   20.12    // report as InvokeDynamic for invokedynamic, which is syntactically classless
   20.13    if (cur_bc() == Bytecodes::_invokedynamic)
   20.14 -    return CURRENT_ENV->get_klass_by_name(_holder, ciSymbol::java_dyn_InvokeDynamic(), false);
   20.15 +    return CURRENT_ENV->get_klass_by_name(_holder, ciSymbol::java_lang_invoke_InvokeDynamic(), false);
   20.16    return CURRENT_ENV->get_klass_by_index(cpool, get_method_holder_index(), ignore, _holder);
   20.17  }
   20.18  

    21.1 --- a/src/share/vm/classfile/classFileParser.cpp	Fri Mar 11 22:33:47 2011 -0800
    21.2 +++ b/src/share/vm/classfile/classFileParser.cpp	Fri Mar 11 22:34:57 2011 -0800
    21.3 @@ -2806,11 +2806,11 @@
    21.4  
    21.5  // Force MethodHandle.vmentry to be an unmanaged pointer.
    21.6  // There is no way for a classfile to express this, so we must help it.
    21.7 -void ClassFileParser::java_dyn_MethodHandle_fix_pre(constantPoolHandle cp,
    21.8 +void ClassFileParser::java_lang_invoke_MethodHandle_fix_pre(constantPoolHandle cp,
    21.9                                                      typeArrayHandle fields,
   21.10                                                      FieldAllocationCount *fac_ptr,
   21.11                                                      TRAPS) {
   21.12 -  // Add fake fields for java.dyn.MethodHandle instances
   21.13 +  // Add fake fields for java.lang.invoke.MethodHandle instances
   21.14    //
   21.15    // This is not particularly nice, but since there is no way to express
   21.16    // a native wordSize field in Java, we must do it at this level.
   21.17 @@ -2830,7 +2830,7 @@
   21.18    if (AllowTransitionalJSR292 && word_sig_index == 0)  return;
   21.19    if (word_sig_index == 0)
   21.20      THROW_MSG(vmSymbols::java_lang_VirtualMachineError(),
   21.21 -              "missing I or J signature (for vmentry) in java.dyn.MethodHandle");
   21.22 +              "missing I or J signature (for vmentry) in java.lang.invoke.MethodHandle");
   21.23  
   21.24    // Find vmentry field and change the signature.
   21.25    bool found_vmentry = false;
   21.26 @@ -2870,7 +2870,7 @@
   21.27    if (AllowTransitionalJSR292 && !found_vmentry)  return;
   21.28    if (!found_vmentry)
   21.29      THROW_MSG(vmSymbols::java_lang_VirtualMachineError(),
   21.30 -              "missing vmentry byte field in java.dyn.MethodHandle");
   21.31 +              "missing vmentry byte field in java.lang.invoke.MethodHandle");
   21.32  }
   21.33  
   21.34  
   21.35 @@ -3235,14 +3235,18 @@
   21.36        java_lang_Class_fix_pre(&methods, &fac, CHECK_(nullHandle));
   21.37      }
   21.38  
   21.39 -    // adjust the vmentry field declaration in java.dyn.MethodHandle
   21.40 -    if (EnableMethodHandles && class_name == vmSymbols::java_dyn_MethodHandle() && class_loader.is_null()) {
   21.41 -      java_dyn_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
   21.42 +    // adjust the vmentry field declaration in java.lang.invoke.MethodHandle
   21.43 +    if (EnableMethodHandles && class_name == vmSymbols::java_lang_invoke_MethodHandle() && class_loader.is_null()) {
   21.44 +      java_lang_invoke_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
   21.45 +    }
   21.46 +    if (AllowTransitionalJSR292 &&
   21.47 +        EnableMethodHandles && class_name == vmSymbols::java_dyn_MethodHandle() && class_loader.is_null()) {
   21.48 +      java_lang_invoke_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
   21.49      }
   21.50      if (AllowTransitionalJSR292 &&
   21.51          EnableMethodHandles && class_name == vmSymbols::sun_dyn_MethodHandleImpl() && class_loader.is_null()) {
   21.52        // allow vmentry field in MethodHandleImpl also
   21.53 -      java_dyn_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
   21.54 +      java_lang_invoke_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
   21.55      }
   21.56  
   21.57      // Add a fake "discovered" field if it is not present

    22.1 --- a/src/share/vm/classfile/classFileParser.hpp	Fri Mar 11 22:33:47 2011 -0800
    22.2 +++ b/src/share/vm/classfile/classFileParser.hpp	Fri Mar 11 22:34:57 2011 -0800
    22.3 @@ -1,5 +1,5 @@
    22.4  /*
    22.5 - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
    22.6 + * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
    22.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    22.8   *
    22.9   * This code is free software; you can redistribute it and/or modify it
   22.10 @@ -162,9 +162,9 @@
   22.11    // Adjust the next_nonstatic_oop_offset to place the fake fields
   22.12    // before any Java fields.
   22.13    void java_lang_Class_fix_post(int* next_nonstatic_oop_offset);
   22.14 -  // Adjust the field allocation counts for java.dyn.MethodHandle to add
   22.15 +  // Adjust the field allocation counts for java.lang.invoke.MethodHandle to add
   22.16    // a fake address (void*) field.
   22.17 -  void java_dyn_MethodHandle_fix_pre(constantPoolHandle cp,
   22.18 +  void java_lang_invoke_MethodHandle_fix_pre(constantPoolHandle cp,
   22.19                                       typeArrayHandle fields,
   22.20                                       FieldAllocationCount *fac_ptr, TRAPS);
   22.21  

    23.1 --- a/src/share/vm/classfile/javaClasses.cpp	Fri Mar 11 22:33:47 2011 -0800
    23.2 +++ b/src/share/vm/classfile/javaClasses.cpp	Fri Mar 11 22:34:57 2011 -0800
    23.3 @@ -2198,35 +2198,35 @@
    23.4  }
    23.5  
    23.6  
    23.7 -// Support for java_dyn_MethodHandle
    23.8 -
    23.9 -int java_dyn_MethodHandle::_type_offset;
   23.10 -int java_dyn_MethodHandle::_vmtarget_offset;
   23.11 -int java_dyn_MethodHandle::_vmentry_offset;
   23.12 -int java_dyn_MethodHandle::_vmslots_offset;
   23.13 -
   23.14 -int sun_dyn_MemberName::_clazz_offset;
   23.15 -int sun_dyn_MemberName::_name_offset;
   23.16 -int sun_dyn_MemberName::_type_offset;
   23.17 -int sun_dyn_MemberName::_flags_offset;
   23.18 -int sun_dyn_MemberName::_vmtarget_offset;
   23.19 -int sun_dyn_MemberName::_vmindex_offset;
   23.20 -
   23.21 -int sun_dyn_DirectMethodHandle::_vmindex_offset;
   23.22 -
   23.23 -int sun_dyn_BoundMethodHandle::_argument_offset;
   23.24 -int sun_dyn_BoundMethodHandle::_vmargslot_offset;
   23.25 -
   23.26 -int sun_dyn_AdapterMethodHandle::_conversion_offset;
   23.27 -
   23.28 -void java_dyn_MethodHandle::compute_offsets() {
   23.29 +// Support for java_lang_invoke_MethodHandle
   23.30 +
   23.31 +int java_lang_invoke_MethodHandle::_type_offset;
   23.32 +int java_lang_invoke_MethodHandle::_vmtarget_offset;
   23.33 +int java_lang_invoke_MethodHandle::_vmentry_offset;
   23.34 +int java_lang_invoke_MethodHandle::_vmslots_offset;
   23.35 +
   23.36 +int java_lang_invoke_MemberName::_clazz_offset;
   23.37 +int java_lang_invoke_MemberName::_name_offset;
   23.38 +int java_lang_invoke_MemberName::_type_offset;
   23.39 +int java_lang_invoke_MemberName::_flags_offset;
   23.40 +int java_lang_invoke_MemberName::_vmtarget_offset;
   23.41 +int java_lang_invoke_MemberName::_vmindex_offset;
   23.42 +
   23.43 +int java_lang_invoke_DirectMethodHandle::_vmindex_offset;
   23.44 +
   23.45 +int java_lang_invoke_BoundMethodHandle::_argument_offset;
   23.46 +int java_lang_invoke_BoundMethodHandle::_vmargslot_offset;
   23.47 +
   23.48 +int java_lang_invoke_AdapterMethodHandle::_conversion_offset;
   23.49 +
   23.50 +void java_lang_invoke_MethodHandle::compute_offsets() {
   23.51    klassOop k = SystemDictionary::MethodHandle_klass();
   23.52    if (k != NULL && EnableMethodHandles) {
   23.53      bool allow_super = false;
   23.54 -    if (AllowTransitionalJSR292)  allow_super = true;  // temporary, to access sun.dyn.MethodHandleImpl
   23.55 -    compute_offset(_type_offset,      k, vmSymbols::type_name(),      vmSymbols::java_dyn_MethodType_signature(), allow_super);
   23.56 -    compute_offset(_vmtarget_offset,  k, vmSymbols::vmtarget_name(),  vmSymbols::object_signature(), allow_super);
   23.57 -    compute_offset(_vmentry_offset,   k, vmSymbols::vmentry_name(),   vmSymbols::machine_word_signature(), allow_super);
   23.58 +    if (AllowTransitionalJSR292)  allow_super = true;  // temporary, to access java.dyn.MethodHandleImpl
   23.59 +    compute_offset(_type_offset,      k, vmSymbols::type_name(),      vmSymbols::java_lang_invoke_MethodType_signature(), allow_super);
   23.60 +    compute_offset(_vmtarget_offset,  k, vmSymbols::vmtarget_name(),  vmSymbols::object_signature(),                      allow_super);
   23.61 +    compute_offset(_vmentry_offset,   k, vmSymbols::vmentry_name(),   vmSymbols::machine_word_signature(),                allow_super);
   23.62  
   23.63      // Note:  MH.vmslots (if it is present) is a hoisted copy of MH.type.form.vmslots.
   23.64      // It is optional pending experiments to keep or toss.
   23.65 @@ -2234,7 +2234,7 @@
   23.66    }
   23.67  }
   23.68  
   23.69 -void sun_dyn_MemberName::compute_offsets() {
   23.70 +void java_lang_invoke_MemberName::compute_offsets() {
   23.71    klassOop k = SystemDictionary::MemberName_klass();
   23.72    if (k != NULL && EnableMethodHandles) {
   23.73      compute_offset(_clazz_offset,     k, vmSymbols::clazz_name(),     vmSymbols::class_signature());
   23.74 @@ -2246,14 +2246,14 @@
   23.75    }
   23.76  }
   23.77  
   23.78 -void sun_dyn_DirectMethodHandle::compute_offsets() {
   23.79 +void java_lang_invoke_DirectMethodHandle::compute_offsets() {
   23.80    klassOop k = SystemDictionary::DirectMethodHandle_klass();
   23.81    if (k != NULL && EnableMethodHandles) {
   23.82      compute_offset(_vmindex_offset,   k, vmSymbols::vmindex_name(),   vmSymbols::int_signature(),    true);
   23.83    }
   23.84  }
   23.85  
   23.86 -void sun_dyn_BoundMethodHandle::compute_offsets() {
   23.87 +void java_lang_invoke_BoundMethodHandle::compute_offsets() {
   23.88    klassOop k = SystemDictionary::BoundMethodHandle_klass();
   23.89    if (k != NULL && EnableMethodHandles) {
   23.90      compute_offset(_vmargslot_offset, k, vmSymbols::vmargslot_name(), vmSymbols::int_signature(),    true);
   23.91 @@ -2261,22 +2261,22 @@
   23.92    }
   23.93  }
   23.94  
   23.95 -void sun_dyn_AdapterMethodHandle::compute_offsets() {
   23.96 +void java_lang_invoke_AdapterMethodHandle::compute_offsets() {
   23.97    klassOop k = SystemDictionary::AdapterMethodHandle_klass();
   23.98    if (k != NULL && EnableMethodHandles) {
   23.99      compute_offset(_conversion_offset, k, vmSymbols::conversion_name(), vmSymbols::int_signature(), true);
  23.100    }
  23.101  }
  23.102  
  23.103 -oop java_dyn_MethodHandle::type(oop mh) {
  23.104 +oop java_lang_invoke_MethodHandle::type(oop mh) {
  23.105    return mh->obj_field(_type_offset);
  23.106  }
  23.107  
  23.108 -void java_dyn_MethodHandle::set_type(oop mh, oop mtype) {
  23.109 +void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
  23.110    mh->obj_field_put(_type_offset, mtype);
  23.111  }
  23.112  
  23.113 -int java_dyn_MethodHandle::vmslots(oop mh) {
  23.114 +int java_lang_invoke_MethodHandle::vmslots(oop mh) {
  23.115    int vmslots_offset = _vmslots_offset;
  23.116    if (vmslots_offset != 0) {
  23.117  #ifdef ASSERT
  23.118 @@ -2291,7 +2291,7 @@
  23.119  }
  23.120  
  23.121  // if MH.vmslots exists, hoist into it the value of type.form.vmslots
  23.122 -void java_dyn_MethodHandle::init_vmslots(oop mh) {
  23.123 +void java_lang_invoke_MethodHandle::init_vmslots(oop mh) {
  23.124    int vmslots_offset = _vmslots_offset;
  23.125    if (vmslots_offset != 0) {
  23.126      mh->int_field_put(vmslots_offset, compute_vmslots(mh));
  23.127 @@ -2300,20 +2300,20 @@
  23.128  
  23.129  // fetch type.form.vmslots, which is the number of JVM stack slots
  23.130  // required to carry the arguments of this MH
  23.131 -int java_dyn_MethodHandle::compute_vmslots(oop mh) {
  23.132 +int java_lang_invoke_MethodHandle::compute_vmslots(oop mh) {
  23.133    oop mtype = type(mh);
  23.134    if (mtype == NULL)  return 0;  // Java code would get NPE
  23.135 -  oop form = java_dyn_MethodType::form(mtype);
  23.136 +  oop form = java_lang_invoke_MethodType::form(mtype);
  23.137    if (form == NULL)   return 0;  // Java code would get NPE
  23.138 -  return java_dyn_MethodTypeForm::vmslots(form);
  23.139 +  return java_lang_invoke_MethodTypeForm::vmslots(form);
  23.140  }
  23.141  
  23.142  // fetch the low-level entry point for this mh
  23.143 -MethodHandleEntry* java_dyn_MethodHandle::vmentry(oop mh) {
  23.144 +MethodHandleEntry* java_lang_invoke_MethodHandle::vmentry(oop mh) {
  23.145    return (MethodHandleEntry*) mh->address_field(_vmentry_offset);
  23.146  }
  23.147  
  23.148 -void java_dyn_MethodHandle::set_vmentry(oop mh, MethodHandleEntry* me) {
  23.149 +void java_lang_invoke_MethodHandle::set_vmentry(oop mh, MethodHandleEntry* me) {
  23.150    assert(_vmentry_offset != 0, "must be present");
  23.151  
  23.152    // This is always the final step that initializes a valid method handle:
  23.153 @@ -2327,123 +2327,123 @@
  23.154  
  23.155  /// MemberName accessors
  23.156  
  23.157 -oop sun_dyn_MemberName::clazz(oop mname) {
  23.158 +oop java_lang_invoke_MemberName::clazz(oop mname) {
  23.159    assert(is_instance(mname), "wrong type");
  23.160    return mname->obj_field(_clazz_offset);
  23.161  }
  23.162  
  23.163 -void sun_dyn_MemberName::set_clazz(oop mname, oop clazz) {
  23.164 +void java_lang_invoke_MemberName::set_clazz(oop mname, oop clazz) {
  23.165    assert(is_instance(mname), "wrong type");
  23.166    mname->obj_field_put(_clazz_offset, clazz);
  23.167  }
  23.168  
  23.169 -oop sun_dyn_MemberName::name(oop mname) {
  23.170 +oop java_lang_invoke_MemberName::name(oop mname) {
  23.171    assert(is_instance(mname), "wrong type");
  23.172    return mname->obj_field(_name_offset);
  23.173  }
  23.174  
  23.175 -void sun_dyn_MemberName::set_name(oop mname, oop name) {
  23.176 +void java_lang_invoke_MemberName::set_name(oop mname, oop name) {
  23.177    assert(is_instance(mname), "wrong type");
  23.178    mname->obj_field_put(_name_offset, name);
  23.179  }
  23.180  
  23.181 -oop sun_dyn_MemberName::type(oop mname) {
  23.182 +oop java_lang_invoke_MemberName::type(oop mname) {
  23.183    assert(is_instance(mname), "wrong type");
  23.184    return mname->obj_field(_type_offset);
  23.185  }
  23.186  
  23.187 -void sun_dyn_MemberName::set_type(oop mname, oop type) {
  23.188 +void java_lang_invoke_MemberName::set_type(oop mname, oop type) {
  23.189    assert(is_instance(mname), "wrong type");
  23.190    mname->obj_field_put(_type_offset, type);
  23.191  }
  23.192  
  23.193 -int sun_dyn_MemberName::flags(oop mname) {
  23.194 +int java_lang_invoke_MemberName::flags(oop mname) {
  23.195    assert(is_instance(mname), "wrong type");
  23.196    return mname->int_field(_flags_offset);
  23.197  }
  23.198  
  23.199 -void sun_dyn_MemberName::set_flags(oop mname, int flags) {
  23.200 +void java_lang_invoke_MemberName::set_flags(oop mname, int flags) {
  23.201    assert(is_instance(mname), "wrong type");
  23.202    mname->int_field_put(_flags_offset, flags);
  23.203  }
  23.204  
  23.205 -oop sun_dyn_MemberName::vmtarget(oop mname) {
  23.206 +oop java_lang_invoke_MemberName::vmtarget(oop mname) {
  23.207    assert(is_instance(mname), "wrong type");
  23.208    return mname->obj_field(_vmtarget_offset);
  23.209  }
  23.210  
  23.211 -void sun_dyn_MemberName::set_vmtarget(oop mname, oop ref) {
  23.212 +void java_lang_invoke_MemberName::set_vmtarget(oop mname, oop ref) {
  23.213    assert(is_instance(mname), "wrong type");
  23.214    mname->obj_field_put(_vmtarget_offset, ref);
  23.215  }
  23.216  
  23.217 -int sun_dyn_MemberName::vmindex(oop mname) {
  23.218 +int java_lang_invoke_MemberName::vmindex(oop mname) {
  23.219    assert(is_instance(mname), "wrong type");
  23.220    return mname->int_field(_vmindex_offset);
  23.221  }
  23.222  
  23.223 -void sun_dyn_MemberName::set_vmindex(oop mname, int index) {
  23.224 +void java_lang_invoke_MemberName::set_vmindex(oop mname, int index) {
  23.225    assert(is_instance(mname), "wrong type");
  23.226    mname->int_field_put(_vmindex_offset, index);
  23.227  }
  23.228  
  23.229 -oop java_dyn_MethodHandle::vmtarget(oop mh) {
  23.230 +oop java_lang_invoke_MethodHandle::vmtarget(oop mh) {
  23.231    assert(is_instance(mh), "MH only");
  23.232    return mh->obj_field(_vmtarget_offset);
  23.233  }
  23.234  
  23.235 -void java_dyn_MethodHandle::set_vmtarget(oop mh, oop ref) {
  23.236 +void java_lang_invoke_MethodHandle::set_vmtarget(oop mh, oop ref) {
  23.237    assert(is_instance(mh), "MH only");
  23.238    mh->obj_field_put(_vmtarget_offset, ref);
  23.239  }
  23.240  
  23.241 -int sun_dyn_DirectMethodHandle::vmindex(oop mh) {
  23.242 +int java_lang_invoke_DirectMethodHandle::vmindex(oop mh) {
  23.243    assert(is_instance(mh), "DMH only");
  23.244    return mh->int_field(_vmindex_offset);
  23.245  }
  23.246  
  23.247 -void sun_dyn_DirectMethodHandle::set_vmindex(oop mh, int index) {
  23.248 +void java_lang_invoke_DirectMethodHandle::set_vmindex(oop mh, int index) {
  23.249    assert(is_instance(mh), "DMH only");
  23.250    mh->int_field_put(_vmindex_offset, index);
  23.251  }
  23.252  
  23.253 -int sun_dyn_BoundMethodHandle::vmargslot(oop mh) {
  23.254 +int java_lang_invoke_BoundMethodHandle::vmargslot(oop mh) {
  23.255    assert(is_instance(mh), "BMH only");
  23.256    return mh->int_field(_vmargslot_offset);
  23.257  }
  23.258  
  23.259 -oop sun_dyn_BoundMethodHandle::argument(oop mh) {
  23.260 +oop java_lang_invoke_BoundMethodHandle::argument(oop mh) {
  23.261    assert(is_instance(mh), "BMH only");
  23.262    return mh->obj_field(_argument_offset);
  23.263  }
  23.264  
  23.265 -int sun_dyn_AdapterMethodHandle::conversion(oop mh) {
  23.266 +int java_lang_invoke_AdapterMethodHandle::conversion(oop mh) {
  23.267    assert(is_instance(mh), "AMH only");
  23.268    return mh->int_field(_conversion_offset);
  23.269  }
  23.270  
  23.271 -void sun_dyn_AdapterMethodHandle::set_conversion(oop mh, int conv) {
  23.272 +void java_lang_invoke_AdapterMethodHandle::set_conversion(oop mh, int conv) {
  23.273    assert(is_instance(mh), "AMH only");
  23.274    mh->int_field_put(_conversion_offset, conv);
  23.275  }
  23.276  
  23.277  
  23.278 -// Support for java_dyn_MethodType
  23.279 -
  23.280 -int java_dyn_MethodType::_rtype_offset;
  23.281 -int java_dyn_MethodType::_ptypes_offset;
  23.282 -int java_dyn_MethodType::_form_offset;
  23.283 -
  23.284 -void java_dyn_MethodType::compute_offsets() {
  23.285 +// Support for java_lang_invoke_MethodType
  23.286 +
  23.287 +int java_lang_invoke_MethodType::_rtype_offset;
  23.288 +int java_lang_invoke_MethodType::_ptypes_offset;
  23.289 +int java_lang_invoke_MethodType::_form_offset;
  23.290 +
  23.291 +void java_lang_invoke_MethodType::compute_offsets() {
  23.292    klassOop k = SystemDictionary::MethodType_klass();
  23.293    if (k != NULL) {
  23.294      compute_offset(_rtype_offset,  k, vmSymbols::rtype_name(),  vmSymbols::class_signature());
  23.295      compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature());
  23.296 -    compute_offset(_form_offset,   k, vmSymbols::form_name(),   vmSymbols::java_dyn_MethodTypeForm_signature());
  23.297 +    compute_offset(_form_offset,   k, vmSymbols::form_name(),   vmSymbols::java_lang_invoke_MethodTypeForm_signature());
  23.298    }
  23.299  }
  23.300  
  23.301 -void java_dyn_MethodType::print_signature(oop mt, outputStream* st) {
  23.302 +void java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) {
  23.303    st->print("(");
  23.304    objArrayOop pts = ptypes(mt);
  23.305    for (int i = 0, limit = pts->length(); i < limit; i++) {
  23.306 @@ -2453,7 +2453,7 @@
  23.307    java_lang_Class::print_signature(rtype(mt), st);
  23.308  }
  23.309  
  23.310 -Symbol* java_dyn_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) {
  23.311 +Symbol* java_lang_invoke_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) {
  23.312    ResourceMark rm;
  23.313    stringStream buffer(128);
  23.314    print_signature(mt, &buffer);
  23.315 @@ -2468,80 +2468,80 @@
  23.316    return name;
  23.317  }
  23.318  
  23.319 -oop java_dyn_MethodType::rtype(oop mt) {
  23.320 +oop java_lang_invoke_MethodType::rtype(oop mt) {
  23.321    assert(is_instance(mt), "must be a MethodType");
  23.322    return mt->obj_field(_rtype_offset);
  23.323  }
  23.324  
  23.325 -objArrayOop java_dyn_MethodType::ptypes(oop mt) {
  23.326 +objArrayOop java_lang_invoke_MethodType::ptypes(oop mt) {
  23.327    assert(is_instance(mt), "must be a MethodType");
  23.328    return (objArrayOop) mt->obj_field(_ptypes_offset);
  23.329  }
  23.330  
  23.331 -oop java_dyn_MethodType::form(oop mt) {
  23.332 +oop java_lang_invoke_MethodType::form(oop mt) {
  23.333    assert(is_instance(mt), "must be a MethodType");
  23.334    return mt->obj_field(_form_offset);
  23.335  }
  23.336  
  23.337 -oop java_dyn_MethodType::ptype(oop mt, int idx) {
  23.338 +oop java_lang_invoke_MethodType::ptype(oop mt, int idx) {
  23.339    return ptypes(mt)->obj_at(idx);
  23.340  }
  23.341  
  23.342 -int java_dyn_MethodType::ptype_count(oop mt) {
  23.343 +int java_lang_invoke_MethodType::ptype_count(oop mt) {
  23.344    return ptypes(mt)->length();
  23.345  }
  23.346  
  23.347  
  23.348  
  23.349 -// Support for java_dyn_MethodTypeForm
  23.350 -
  23.351 -int java_dyn_MethodTypeForm::_vmslots_offset;
  23.352 -int java_dyn_MethodTypeForm::_erasedType_offset;
  23.353 -int java_dyn_MethodTypeForm::_genericInvoker_offset;
  23.354 -
  23.355 -void java_dyn_MethodTypeForm::compute_offsets() {
  23.356 +// Support for java_lang_invoke_MethodTypeForm
  23.357 +
  23.358 +int java_lang_invoke_MethodTypeForm::_vmslots_offset;
  23.359 +int java_lang_invoke_MethodTypeForm::_erasedType_offset;
  23.360 +int java_lang_invoke_MethodTypeForm::_genericInvoker_offset;
  23.361 +
  23.362 +void java_lang_invoke_MethodTypeForm::compute_offsets() {
  23.363    klassOop k = SystemDictionary::MethodTypeForm_klass();
  23.364    if (k != NULL) {
  23.365      compute_optional_offset(_vmslots_offset,    k, vmSymbols::vmslots_name(),    vmSymbols::int_signature(), true);
  23.366 -    compute_optional_offset(_erasedType_offset, k, vmSymbols::erasedType_name(), vmSymbols::java_dyn_MethodType_signature(), true);
  23.367 -    compute_optional_offset(_genericInvoker_offset, k, vmSymbols::genericInvoker_name(), vmSymbols::java_dyn_MethodHandle_signature(), true);
  23.368 +    compute_optional_offset(_erasedType_offset, k, vmSymbols::erasedType_name(), vmSymbols::java_lang_invoke_MethodType_signature(), true);
  23.369 +    compute_optional_offset(_genericInvoker_offset, k, vmSymbols::genericInvoker_name(), vmSymbols::java_lang_invoke_MethodHandle_signature(), true);
  23.370      if (_genericInvoker_offset == 0)  _genericInvoker_offset = -1;  // set to explicit "empty" value
  23.371    }
  23.372  }
  23.373  
  23.374 -int java_dyn_MethodTypeForm::vmslots(oop mtform) {
  23.375 +int java_lang_invoke_MethodTypeForm::vmslots(oop mtform) {
  23.376    assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
  23.377    return mtform->int_field(_vmslots_offset);
  23.378  }
  23.379  
  23.380 -oop java_dyn_MethodTypeForm::erasedType(oop mtform) {
  23.381 +oop java_lang_invoke_MethodTypeForm::erasedType(oop mtform) {
  23.382    assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
  23.383    return mtform->obj_field(_erasedType_offset);
  23.384  }
  23.385  
  23.386 -oop java_dyn_MethodTypeForm::genericInvoker(oop mtform) {
  23.387 +oop java_lang_invoke_MethodTypeForm::genericInvoker(oop mtform) {
  23.388    assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
  23.389    return mtform->obj_field(_genericInvoker_offset);
  23.390  }
  23.391  
  23.392  
  23.393 -// Support for java_dyn_CallSite
  23.394 -
  23.395 -int java_dyn_CallSite::_target_offset;
  23.396 -
  23.397 -void java_dyn_CallSite::compute_offsets() {
  23.398 +// Support for java_lang_invoke_CallSite
  23.399 +
  23.400 +int java_lang_invoke_CallSite::_target_offset;
  23.401 +
  23.402 +void java_lang_invoke_CallSite::compute_offsets() {
  23.403    if (!EnableInvokeDynamic)  return;
  23.404    klassOop k = SystemDictionary::CallSite_klass();
  23.405    if (k != NULL) {
  23.406 -    compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_dyn_MethodHandle_signature());
  23.407 +    compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature());
  23.408    }
  23.409  }
  23.410  
  23.411 -oop java_dyn_CallSite::target(oop site) {
  23.412 +oop java_lang_invoke_CallSite::target(oop site) {
  23.413    return site->obj_field(_target_offset);
  23.414  }
  23.415  
  23.416 -void java_dyn_CallSite::set_target(oop site, oop target) {
  23.417 +void java_lang_invoke_CallSite::set_target(oop site, oop target) {
  23.418    site->obj_field_put(_target_offset, target);
  23.419  }
  23.420  
  23.421 @@ -2881,16 +2881,16 @@
  23.422    java_lang_Thread::compute_offsets();
  23.423    java_lang_ThreadGroup::compute_offsets();
  23.424    if (EnableMethodHandles) {
  23.425 -    java_dyn_MethodHandle::compute_offsets();
  23.426 -    sun_dyn_MemberName::compute_offsets();
  23.427 -    sun_dyn_DirectMethodHandle::compute_offsets();
  23.428 -    sun_dyn_BoundMethodHandle::compute_offsets();
  23.429 -    sun_dyn_AdapterMethodHandle::compute_offsets();
  23.430 -    java_dyn_MethodType::compute_offsets();
  23.431 -    java_dyn_MethodTypeForm::compute_offsets();
  23.432 +    java_lang_invoke_MethodHandle::compute_offsets();
  23.433 +    java_lang_invoke_MemberName::compute_offsets();
  23.434 +    java_lang_invoke_DirectMethodHandle::compute_offsets();
  23.435 +    java_lang_invoke_BoundMethodHandle::compute_offsets();
  23.436 +    java_lang_invoke_AdapterMethodHandle::compute_offsets();
  23.437 +    java_lang_invoke_MethodType::compute_offsets();
  23.438 +    java_lang_invoke_MethodTypeForm::compute_offsets();
  23.439    }
  23.440    if (EnableInvokeDynamic) {
  23.441 -    java_dyn_CallSite::compute_offsets();
  23.442 +    java_lang_invoke_CallSite::compute_offsets();
  23.443    }
  23.444    java_security_AccessControlContext::compute_offsets();
  23.445    // Initialize reflection classes. The layouts of these classes

    24.1 --- a/src/share/vm/classfile/javaClasses.hpp	Fri Mar 11 22:33:47 2011 -0800
    24.2 +++ b/src/share/vm/classfile/javaClasses.hpp	Fri Mar 11 22:34:57 2011 -0800
    24.3 @@ -1,5 +1,5 @@
    24.4  /*
    24.5 - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
    24.6 + * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
    24.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    24.8   *
    24.9   * This code is free software; you can redistribute it and/or modify it
   24.10 @@ -794,11 +794,11 @@
   24.11  };
   24.12  
   24.13  
   24.14 -// Interface to java.dyn.MethodHandle objects
   24.15 +// Interface to java.lang.invoke.MethodHandle objects
   24.16  
   24.17  class MethodHandleEntry;
   24.18  
   24.19 -class java_dyn_MethodHandle: AllStatic {
   24.20 +class java_lang_invoke_MethodHandle: AllStatic {
   24.21    friend class JavaClasses;
   24.22  
   24.23   private:
   24.24 @@ -839,7 +839,7 @@
   24.25    static int vmslots_offset_in_bytes()          { return _vmslots_offset; }
   24.26  };
   24.27  
   24.28 -class sun_dyn_DirectMethodHandle: public java_dyn_MethodHandle {
   24.29 +class java_lang_invoke_DirectMethodHandle: public java_lang_invoke_MethodHandle {
   24.30    friend class JavaClasses;
   24.31  
   24.32   private:
   24.33 @@ -864,7 +864,7 @@
   24.34    static int vmindex_offset_in_bytes()          { return _vmindex_offset; }
   24.35  };
   24.36  
   24.37 -class sun_dyn_BoundMethodHandle: public java_dyn_MethodHandle {
   24.38 +class java_lang_invoke_BoundMethodHandle: public java_lang_invoke_MethodHandle {
   24.39    friend class JavaClasses;
   24.40  
   24.41   private:
   24.42 @@ -891,7 +891,7 @@
   24.43    static int vmargslot_offset_in_bytes()        { return _vmargslot_offset; }
   24.44  };
   24.45  
   24.46 -class sun_dyn_AdapterMethodHandle: public sun_dyn_BoundMethodHandle {
   24.47 +class java_lang_invoke_AdapterMethodHandle: public java_lang_invoke_BoundMethodHandle {
   24.48    friend class JavaClasses;
   24.49  
   24.50   private:
   24.51 @@ -942,14 +942,14 @@
   24.52  };
   24.53  
   24.54  
   24.55 -// Interface to sun.dyn.MemberName objects
   24.56 +// Interface to java.lang.invoke.MemberName objects
   24.57  // (These are a private interface for Java code to query the class hierarchy.)
   24.58  
   24.59 -class sun_dyn_MemberName: AllStatic {
   24.60 +class java_lang_invoke_MemberName: AllStatic {
   24.61    friend class JavaClasses;
   24.62  
   24.63   private:
   24.64 -  // From java.dyn.MemberName:
   24.65 +  // From java.lang.invoke.MemberName:
   24.66    //    private Class<?>   clazz;       // class in which the method is defined
   24.67    //    private String     name;        // may be null if not yet materialized
   24.68    //    private Object     type;        // may be null if not yet materialized
   24.69 @@ -1018,9 +1018,9 @@
   24.70  };
   24.71  
   24.72  
   24.73 -// Interface to java.dyn.MethodType objects
   24.74 +// Interface to java.lang.invoke.MethodType objects
   24.75  
   24.76 -class java_dyn_MethodType: AllStatic {
   24.77 +class java_lang_invoke_MethodType: AllStatic {
   24.78    friend class JavaClasses;
   24.79  
   24.80   private:
   24.81 @@ -1052,7 +1052,7 @@
   24.82    static int form_offset_in_bytes()             { return _form_offset; }
   24.83  };
   24.84  
   24.85 -class java_dyn_MethodTypeForm: AllStatic {
   24.86 +class java_lang_invoke_MethodTypeForm: AllStatic {
   24.87    friend class JavaClasses;
   24.88  
   24.89   private:
   24.90 @@ -1075,9 +1075,9 @@
   24.91  };
   24.92  
   24.93  
   24.94 -// Interface to java.dyn.CallSite objects
   24.95 +// Interface to java.lang.invoke.CallSite objects
   24.96  
   24.97 -class java_dyn_CallSite: AllStatic {
   24.98 +class java_lang_invoke_CallSite: AllStatic {
   24.99    friend class JavaClasses;
  24.100  
  24.101  private:

    25.1 --- a/src/share/vm/classfile/systemDictionary.cpp	Fri Mar 11 22:33:47 2011 -0800
    25.2 +++ b/src/share/vm/classfile/systemDictionary.cpp	Fri Mar 11 22:34:57 2011 -0800
    25.3 @@ -2450,7 +2450,7 @@
    25.4    }
    25.5  }
    25.6  
    25.7 -// Ask Java code to find or construct a java.dyn.MethodType for the given
    25.8 +// Ask Java code to find or construct a java.lang.invoke.MethodType for the given
    25.9  // signature, as interpreted relative to the given class loader.
   25.10  // Because of class loader constraints, all method handle usage must be
   25.11  // consistent with this loader.
   25.12 @@ -2504,25 +2504,33 @@
   25.13    }
   25.14    assert(arg == npts, "");
   25.15  
   25.16 -  // call sun.dyn.MethodHandleNatives::findMethodType(Class rt, Class[] pts) -> MethodType
   25.17 +  // call java.lang.invoke.MethodHandleNatives::findMethodType(Class rt, Class[] pts) -> MethodType
   25.18    JavaCallArguments args(Handle(THREAD, rt()));
   25.19    args.push_oop(pts());
   25.20    JavaValue result(T_OBJECT);
   25.21 +  Symbol* findMethodHandleType_signature = vmSymbols::findMethodHandleType_signature();
   25.22 +  if (AllowTransitionalJSR292 && SystemDictionaryHandles::MethodType_klass()->name() == vmSymbols::java_dyn_MethodType()) {
   25.23 +    findMethodHandleType_signature = vmSymbols::findMethodHandleType_TRANS_signature();
   25.24 +  }
   25.25    JavaCalls::call_static(&result,
   25.26                           SystemDictionary::MethodHandleNatives_klass(),
   25.27                           vmSymbols::findMethodHandleType_name(),
   25.28 -                         vmSymbols::findMethodHandleType_signature(),
   25.29 +                         findMethodHandleType_signature,
   25.30                           &args, CHECK_(empty));
   25.31    Handle method_type(THREAD, (oop) result.get_jobject());
   25.32  
   25.33    if (for_invokeGeneric) {
   25.34 -    // call sun.dyn.MethodHandleNatives::notifyGenericMethodType(MethodType) -> void
   25.35 +    // call java.lang.invoke.MethodHandleNatives::notifyGenericMethodType(MethodType) -> void
   25.36      JavaCallArguments args(Handle(THREAD, method_type()));
   25.37      JavaValue no_result(T_VOID);
   25.38 +    Symbol* notifyGenericMethodType_signature = vmSymbols::notifyGenericMethodType_signature();
   25.39 +    if (AllowTransitionalJSR292 && SystemDictionaryHandles::MethodType_klass()->name() == vmSymbols::java_dyn_MethodType()) {
   25.40 +      notifyGenericMethodType_signature = vmSymbols::notifyGenericMethodType_TRANS_signature();
   25.41 +    }
   25.42      JavaCalls::call_static(&no_result,
   25.43                             SystemDictionary::MethodHandleNatives_klass(),
   25.44                             vmSymbols::notifyGenericMethodType_name(),
   25.45 -                           vmSymbols::notifyGenericMethodType_signature(),
   25.46 +                           notifyGenericMethodType_signature,
   25.47                             &args, THREAD);
   25.48      if (HAS_PENDING_EXCEPTION) {
   25.49        // If the notification fails, just kill it.
   25.50 @@ -2563,7 +2571,7 @@
   25.51      THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad signature", empty);
   25.52    }
   25.53  
   25.54 -  // call sun.dyn.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle
   25.55 +  // call java.lang.invoke.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle
   25.56    JavaCallArguments args;
   25.57    args.push_oop(caller->java_mirror());  // the referring class
   25.58    args.push_int(ref_kind);
   25.59 @@ -2571,15 +2579,19 @@
   25.60    args.push_oop(name());
   25.61    args.push_oop(type());
   25.62    JavaValue result(T_OBJECT);
   25.63 +  Symbol* linkMethodHandleConstant_signature = vmSymbols::linkMethodHandleConstant_signature();
   25.64 +  if (AllowTransitionalJSR292 && SystemDictionaryHandles::MethodHandle_klass()->name() == vmSymbols::java_dyn_MethodHandle()) {
   25.65 +    linkMethodHandleConstant_signature = vmSymbols::linkMethodHandleConstant_TRANS_signature();
   25.66 +  }
   25.67    JavaCalls::call_static(&result,
   25.68                           SystemDictionary::MethodHandleNatives_klass(),
   25.69                           vmSymbols::linkMethodHandleConstant_name(),
   25.70 -                         vmSymbols::linkMethodHandleConstant_signature(),
   25.71 +                         linkMethodHandleConstant_signature,
   25.72                           &args, CHECK_(empty));
   25.73    return Handle(THREAD, (oop) result.get_jobject());
   25.74  }
   25.75  
   25.76 -// Ask Java code to find or construct a java.dyn.CallSite for the given
   25.77 +// Ask Java code to find or construct a java.lang.invoke.CallSite for the given
   25.78  // name and signature, as interpreted relative to the given class loader.
   25.79  Handle SystemDictionary::make_dynamic_call_site(Handle bootstrap_method,
   25.80                                                  Symbol* name,
   25.81 @@ -2590,13 +2602,13 @@
   25.82                                                  TRAPS) {
   25.83    Handle empty;
   25.84    guarantee(bootstrap_method.not_null() &&
   25.85 -            java_dyn_MethodHandle::is_instance(bootstrap_method()),
   25.86 +            java_lang_invoke_MethodHandle::is_instance(bootstrap_method()),
   25.87              "caller must supply a valid BSM");
   25.88  
   25.89    Handle caller_mname = MethodHandles::new_MemberName(CHECK_(empty));
   25.90    MethodHandles::init_MemberName(caller_mname(), caller_method());
   25.91  
   25.92 -  // call sun.dyn.MethodHandleNatives::makeDynamicCallSite(bootm, name, mtype, info, caller_mname, caller_pos)
   25.93 +  // call java.lang.invoke.MethodHandleNatives::makeDynamicCallSite(bootm, name, mtype, info, caller_mname, caller_pos)
   25.94    oop name_str_oop = StringTable::intern(name, CHECK_(empty)); // not a handle!
   25.95    JavaCallArguments args(Handle(THREAD, bootstrap_method()));
   25.96    args.push_oop(name_str_oop);
   25.97 @@ -2609,6 +2621,9 @@
   25.98    if (AllowTransitionalJSR292 && SystemDictionaryHandles::MethodHandleNatives_klass()->name() == vmSymbols::sun_dyn_MethodHandleNatives()) {
   25.99      makeDynamicCallSite_signature = vmSymbols::makeDynamicCallSite_TRANS_signature();
  25.100    }
  25.101 +  if (AllowTransitionalJSR292 && SystemDictionaryHandles::MethodHandleNatives_klass()->name() == vmSymbols::java_dyn_MethodHandleNatives()) {
  25.102 +    makeDynamicCallSite_signature = vmSymbols::makeDynamicCallSite_TRANS2_signature();
  25.103 +  }
  25.104    JavaCalls::call_static(&result,
  25.105                           SystemDictionary::MethodHandleNatives_klass(),
  25.106                           vmSymbols::makeDynamicCallSite_name(),
  25.107 @@ -2616,7 +2631,7 @@
  25.108                           &args, CHECK_(empty));
  25.109    oop call_site_oop = (oop) result.get_jobject();
  25.110    assert(call_site_oop->is_oop()
  25.111 -         /*&& java_dyn_CallSite::is_instance(call_site_oop)*/, "must be sane");
  25.112 +         /*&& java_lang_invoke_CallSite::is_instance(call_site_oop)*/, "must be sane");
  25.113    if (TraceMethodHandles) {
  25.114  #ifndef PRODUCT
  25.115      tty->print_cr("Linked invokedynamic bci=%d site="INTPTR_FORMAT":", caller_bci, call_site_oop);

    26.1 --- a/src/share/vm/classfile/systemDictionary.hpp	Fri Mar 11 22:33:47 2011 -0800
    26.2 +++ b/src/share/vm/classfile/systemDictionary.hpp	Fri Mar 11 22:34:57 2011 -0800
    26.3 @@ -144,18 +144,18 @@
    26.4    template(reflect_UnsafeStaticFieldAccessorImpl_klass, sun_reflect_UnsafeStaticFieldAccessorImpl, Opt_Only_JDK15) \
    26.5                                                                                \
    26.6    /* support for dynamic typing; it's OK if these are NULL in earlier JDKs */ \
    26.7 -  template(MethodHandle_klass,           java_dyn_MethodHandle,          Pre_JSR292) \
    26.8 -  template(MemberName_klass,             java_dyn_MemberName,            Pre_JSR292) \
    26.9 -  template(MethodHandleImpl_klass,       java_dyn_MethodHandleImpl,      Pre_JSR292) /* AllowTransitionalJSR292 ONLY */ \
   26.10 -  template(MethodHandleNatives_klass,    java_dyn_MethodHandleNatives,   Pre_JSR292) \
   26.11 -  template(AdapterMethodHandle_klass,    java_dyn_AdapterMethodHandle,   Pre_JSR292) \
   26.12 -  template(BoundMethodHandle_klass,      java_dyn_BoundMethodHandle,     Pre_JSR292) \
   26.13 -  template(DirectMethodHandle_klass,     java_dyn_DirectMethodHandle,    Pre_JSR292) \
   26.14 -  template(MethodType_klass,             java_dyn_MethodType,            Pre_JSR292) \
   26.15 -  template(MethodTypeForm_klass,         java_dyn_MethodTypeForm,        Pre_JSR292) \
   26.16 -  template(WrongMethodTypeException_klass, java_dyn_WrongMethodTypeException, Pre_JSR292) \
   26.17 -  template(Linkage_klass,                java_dyn_Linkage,               Pre_JSR292) \
   26.18 -  template(CallSite_klass,               java_dyn_CallSite,              Pre_JSR292) \
   26.19 +  template(MethodHandle_klass,           java_lang_invoke_MethodHandle,     Pre_JSR292) \
   26.20 +  template(MemberName_klass,             java_lang_invoke_MemberName,       Pre_JSR292) \
   26.21 +  template(MethodHandleImpl_klass,       sun_dyn_MethodHandleImpl,          Opt) /* AllowTransitionalJSR292 ONLY */ \
   26.22 +  template(MethodHandleNatives_klass,    java_lang_invoke_MethodHandleNatives, Pre_JSR292) \
   26.23 +  template(AdapterMethodHandle_klass,    java_lang_invoke_AdapterMethodHandle, Pre_JSR292) \
   26.24 +  template(BoundMethodHandle_klass,      java_lang_invoke_BoundMethodHandle, Pre_JSR292) \
   26.25 +  template(DirectMethodHandle_klass,     java_lang_invoke_DirectMethodHandle, Pre_JSR292) \
   26.26 +  template(MethodType_klass,             java_lang_invoke_MethodType,       Pre_JSR292) \
   26.27 +  template(MethodTypeForm_klass,         java_lang_invoke_MethodTypeForm,   Pre_JSR292) \
   26.28 +  template(WrongMethodTypeException_klass, java_lang_invoke_WrongMethodTypeException, Pre_JSR292) \
   26.29 +  template(Linkage_klass,                java_lang_invoke_Linkage,          Opt) /* AllowTransitionalJSR292 ONLY */ \
   26.30 +  template(CallSite_klass,               java_lang_invoke_CallSite,         Pre_JSR292) \
   26.31    /* Note: MethodHandle must be first, and CallSite last in group */          \
   26.32                                                                                \
   26.33    template(StringBuffer_klass,           java_lang_StringBuffer,         Pre) \
   26.34 @@ -482,18 +482,18 @@
   26.35                                         Handle loader2, bool is_method, TRAPS);
   26.36  
   26.37    // JSR 292
   26.38 -  // find the java.dyn.MethodHandles::invoke method for a given signature
   26.39 +  // find the java.lang.invoke.MethodHandles::invoke method for a given signature
   26.40    static methodOop find_method_handle_invoke(Symbol* name,
   26.41                                               Symbol* signature,
   26.42                                               KlassHandle accessing_klass,
   26.43                                               TRAPS);
   26.44 -  // ask Java to compute a java.dyn.MethodType object for a given signature
   26.45 +  // ask Java to compute a java.lang.invoke.MethodType object for a given signature
   26.46    static Handle    find_method_handle_type(Symbol* signature,
   26.47                                             KlassHandle accessing_klass,
   26.48                                             bool for_invokeGeneric,
   26.49                                             bool& return_bcp_flag,
   26.50                                             TRAPS);
   26.51 -  // ask Java to compute a java.dyn.MethodHandle object for a given CP entry
   26.52 +  // ask Java to compute a java.lang.invoke.MethodHandle object for a given CP entry
   26.53    static Handle    link_method_handle_constant(KlassHandle caller,
   26.54                                                 int ref_kind, //e.g., JVM_REF_invokeVirtual
   26.55                                                 KlassHandle callee,

    27.1 --- a/src/share/vm/classfile/verifier.cpp	Fri Mar 11 22:33:47 2011 -0800
    27.2 +++ b/src/share/vm/classfile/verifier.cpp	Fri Mar 11 22:34:57 2011 -0800
    27.3 @@ -1,5 +1,5 @@
    27.4  /*
    27.5 - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
    27.6 + * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
    27.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    27.8   *
    27.9   * This code is free software; you can redistribute it and/or modify it
   27.10 @@ -1671,13 +1671,19 @@
   27.11        VerificationType::long_type(),
   27.12        VerificationType::long2_type(), CHECK_VERIFY(this));
   27.13    } else if (tag.is_method_handle()) {
   27.14 +    Symbol* methodHandle_name = vmSymbols::java_lang_invoke_MethodHandle();
   27.15 +    if (AllowTransitionalJSR292 && !Universe::is_bootstrapping())
   27.16 +      methodHandle_name = SystemDictionaryHandles::MethodHandle_klass()->name();
   27.17      current_frame->push_stack(
   27.18        VerificationType::reference_type(
   27.19 -        vmSymbols::java_dyn_MethodHandle()), CHECK_VERIFY(this));
   27.20 +        methodHandle_name), CHECK_VERIFY(this));
   27.21    } else if (tag.is_method_type()) {
   27.22 +    Symbol* methodType_name = vmSymbols::java_lang_invoke_MethodType();
   27.23 +    if (AllowTransitionalJSR292 && !Universe::is_bootstrapping())
   27.24 +      methodType_name = SystemDictionaryHandles::MethodType_klass()->name();
   27.25      current_frame->push_stack(
   27.26        VerificationType::reference_type(
   27.27 -        vmSymbols::java_dyn_MethodType()), CHECK_VERIFY(this));
   27.28 +        methodType_name), CHECK_VERIFY(this));
   27.29    } else {
   27.30      verify_error(bci, "Invalid index in ldc");
   27.31      return;

    28.1 --- a/src/share/vm/classfile/vmSymbols.hpp	Fri Mar 11 22:33:47 2011 -0800
    28.2 +++ b/src/share/vm/classfile/vmSymbols.hpp	Fri Mar 11 22:34:57 2011 -0800
    28.3 @@ -229,39 +229,60 @@
    28.4    template(base_name,                                 "base")                                     \
    28.5                                                                                                    \
    28.6    /* Support for JSR 292 & invokedynamic (JDK 1.7 and above) */                                   \
    28.7 -  template(java_dyn_InvokeDynamic,                    "java/dyn/InvokeDynamic")                   \
    28.8 -  template(java_dyn_Linkage,                          "java/dyn/Linkage")                         \
    28.9 -  template(java_dyn_CallSite,                         "java/dyn/CallSite")                        \
   28.10 -  template(java_dyn_MethodHandle,                     "java/dyn/MethodHandle")                    \
   28.11 -  template(java_dyn_MethodType,                       "java/dyn/MethodType")                      \
   28.12 -  template(java_dyn_WrongMethodTypeException,         "java/dyn/WrongMethodTypeException")        \
   28.13 -  template(java_dyn_MethodType_signature,             "Ljava/dyn/MethodType;")                    \
   28.14 -  template(java_dyn_MethodHandle_signature,           "Ljava/dyn/MethodHandle;")                  \
   28.15 +  template(java_lang_invoke_InvokeDynamic,            "java/lang/invoke/InvokeDynamic")           \
   28.16 +  template(java_lang_invoke_Linkage,                  "java/lang/invoke/Linkage")                 \
   28.17 +  template(java_lang_invoke_CallSite,                 "java/lang/invoke/CallSite")                \
   28.18 +  template(java_lang_invoke_MethodHandle,             "java/lang/invoke/MethodHandle")            \
   28.19 +  template(java_lang_invoke_MethodType,               "java/lang/invoke/MethodType")              \
   28.20 +  template(java_lang_invoke_WrongMethodTypeException, "java/lang/invoke/WrongMethodTypeException") \
   28.21 +  template(java_lang_invoke_MethodType_signature,     "Ljava/lang/invoke/MethodType;")            \
   28.22 +  template(java_lang_invoke_MethodHandle_signature,   "Ljava/lang/invoke/MethodHandle;")          \
   28.23    /* internal classes known only to the JVM: */                                                   \
   28.24 -  template(java_dyn_MethodTypeForm,                   "java/dyn/MethodTypeForm")                  \
   28.25 -  template(java_dyn_MethodTypeForm_signature,         "Ljava/dyn/MethodTypeForm;")                \
   28.26 -  template(java_dyn_MemberName,                       "java/dyn/MemberName")                      \
   28.27 -  template(java_dyn_MethodHandleImpl,                 "java/dyn/MethodHandleImpl")                \
   28.28 -  template(java_dyn_MethodHandleNatives,              "java/dyn/MethodHandleNatives")             \
   28.29 -  template(java_dyn_AdapterMethodHandle,              "java/dyn/AdapterMethodHandle")             \
   28.30 -  template(java_dyn_BoundMethodHandle,                "java/dyn/BoundMethodHandle")               \
   28.31 -  template(java_dyn_DirectMethodHandle,               "java/dyn/DirectMethodHandle")              \
   28.32 +  template(java_lang_invoke_MethodTypeForm,           "java/lang/invoke/MethodTypeForm")          \
   28.33 +  template(java_lang_invoke_MethodTypeForm_signature, "Ljava/lang/invoke/MethodTypeForm;")        \
   28.34 +  template(java_lang_invoke_MemberName,               "java/lang/invoke/MemberName")              \
   28.35 +  template(java_lang_invoke_MethodHandleNatives,      "java/lang/invoke/MethodHandleNatives")     \
   28.36 +  template(java_lang_invoke_AdapterMethodHandle,      "java/lang/invoke/AdapterMethodHandle")     \
   28.37 +  template(java_lang_invoke_BoundMethodHandle,        "java/lang/invoke/BoundMethodHandle")       \
   28.38 +  template(java_lang_invoke_DirectMethodHandle,       "java/lang/invoke/DirectMethodHandle")      \
   28.39 +  /* temporary transitional public names from 6839872: */                                         \
   28.40 +  template(java_dyn_InvokeDynamic,                    "java/dyn/InvokeDynamic")         /* AllowTransitionalJSR292 ONLY */ \
   28.41 +  template(java_dyn_Linkage,                          "java/dyn/Linkage")               /* AllowTransitionalJSR292 ONLY */ \
   28.42 +  template(java_dyn_CallSite,                         "java/dyn/CallSite")              /* AllowTransitionalJSR292 ONLY */ \
   28.43 +  template(java_dyn_MethodHandle,                     "java/dyn/MethodHandle")          /* AllowTransitionalJSR292 ONLY */ \
   28.44 +  template(java_dyn_MethodType,                       "java/dyn/MethodType")            /* AllowTransitionalJSR292 ONLY */ \
   28.45 +  template(java_dyn_WrongMethodTypeException,         "java/dyn/WrongMethodTypeException") /* AllowTransitionalJSR292 ONLY */ \
   28.46 +  template(java_dyn_MethodType_signature,             "Ljava/dyn/MethodType;")          /* AllowTransitionalJSR292 ONLY */ \
   28.47 +  template(java_dyn_MethodHandle_signature,           "Ljava/dyn/MethodHandle;")        /* AllowTransitionalJSR292 ONLY */ \
   28.48 +  /* temporary transitional internal names from 6839872: */                                       \
   28.49 +  template(java_dyn_MethodTypeForm,                   "java/dyn/MethodTypeForm")        /* AllowTransitionalJSR292 ONLY */ \
   28.50 +  template(java_dyn_MethodTypeForm_signature,         "Ljava/dyn/MethodTypeForm;")      /* AllowTransitionalJSR292 ONLY */ \
   28.51 +  template(java_dyn_MemberName,                       "java/dyn/MemberName")            /* AllowTransitionalJSR292 ONLY */ \
   28.52 +  template(java_dyn_MethodHandleNatives,              "java/dyn/MethodHandleNatives")   /* AllowTransitionalJSR292 ONLY */ \
   28.53 +  template(java_dyn_AdapterMethodHandle,              "java/dyn/AdapterMethodHandle")   /* AllowTransitionalJSR292 ONLY */ \
   28.54 +  template(java_dyn_BoundMethodHandle,                "java/dyn/BoundMethodHandle")     /* AllowTransitionalJSR292 ONLY */ \
   28.55 +  template(java_dyn_DirectMethodHandle,               "java/dyn/DirectMethodHandle")    /* AllowTransitionalJSR292 ONLY */ \
   28.56 +  /* temporary transitional internal names from EDR: */                                           \
   28.57    template(sun_dyn_MemberName,                        "sun/dyn/MemberName")             /* AllowTransitionalJSR292 ONLY */ \
   28.58    template(sun_dyn_MethodHandleImpl,                  "sun/dyn/MethodHandleImpl")       /* AllowTransitionalJSR292 ONLY */ \
   28.59    template(sun_dyn_MethodHandleNatives,               "sun/dyn/MethodHandleNatives")    /* AllowTransitionalJSR292 ONLY */ \
   28.60    template(sun_dyn_AdapterMethodHandle,               "sun/dyn/AdapterMethodHandle")    /* AllowTransitionalJSR292 ONLY */ \
   28.61    template(sun_dyn_BoundMethodHandle,                 "sun/dyn/BoundMethodHandle")      /* AllowTransitionalJSR292 ONLY */ \
   28.62    template(sun_dyn_DirectMethodHandle,                "sun/dyn/DirectMethodHandle")     /* AllowTransitionalJSR292 ONLY */ \
   28.63 -  /* internal up-calls made only by the JVM, via class sun.dyn.MethodHandleNatives: */            \
   28.64 +  /* internal up-calls made only by the JVM, via class sun.invoke.MethodHandleNatives: */         \
   28.65    template(findMethodHandleType_name,                 "findMethodHandleType")                     \
   28.66 -  template(findMethodHandleType_signature, "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/dyn/MethodType;") \
   28.67 +  template(findMethodHandleType_signature,       "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/invoke/MethodType;") \
   28.68 +  template(findMethodHandleType_TRANS_signature, "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/dyn/MethodType;") /* AllowTransitionalJSR292 ONLY */ \
   28.69    template(notifyGenericMethodType_name,              "notifyGenericMethodType")                  \
   28.70 -  template(notifyGenericMethodType_signature,         "(Ljava/dyn/MethodType;)V")                 \
   28.71 +  template(notifyGenericMethodType_signature,         "(Ljava/lang/invoke/MethodType;)V")         \
   28.72 +  template(notifyGenericMethodType_TRANS_signature,   "(Ljava/dyn/MethodType;)V")       /* AllowTransitionalJSR292 ONLY */ \
   28.73    template(linkMethodHandleConstant_name,             "linkMethodHandleConstant")                 \
   28.74 -  template(linkMethodHandleConstant_signature, "(Ljava/lang/Class;ILjava/lang/Class;Ljava/lang/String;Ljava/lang/Object;)Ljava/dyn/MethodHandle;") \
   28.75 +  template(linkMethodHandleConstant_signature, "(Ljava/lang/Class;ILjava/lang/Class;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/invoke/MethodHandle;") \
   28.76 +  template(linkMethodHandleConstant_TRANS_signature, "(Ljava/lang/Class;ILjava/lang/Class;Ljava/lang/String;Ljava/lang/Object;)Ljava/dyn/MethodHandle;") /* AllowTransitionalJSR292 ONLY */ \
   28.77    template(makeDynamicCallSite_name,                  "makeDynamicCallSite")                      \
   28.78 -  template(makeDynamicCallSite_signature, "(Ljava/dyn/MethodHandle;Ljava/lang/String;Ljava/dyn/MethodType;Ljava/lang/Object;Ljava/dyn/MemberName;I)Ljava/dyn/CallSite;") \
   28.79 +  template(makeDynamicCallSite_signature, "(Ljava/lang/invoke/MethodHandle;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/Object;Ljava/lang/invoke/MemberName;I)Ljava/lang/invoke/CallSite;") \
   28.80    template(makeDynamicCallSite_TRANS_signature, "(Ljava/dyn/MethodHandle;Ljava/lang/String;Ljava/dyn/MethodType;Ljava/lang/Object;Lsun/dyn/MemberName;I)Ljava/dyn/CallSite;") /* AllowTransitionalJSR292 ONLY */ \
   28.81 +  template(makeDynamicCallSite_TRANS2_signature, "(Ljava/dyn/MethodHandle;Ljava/lang/String;Ljava/dyn/MethodType;Ljava/lang/Object;Ljava/dyn/MemberName;I)Ljava/dyn/CallSite;") /* AllowTransitionalJSR292 ONLY */ \
   28.82    NOT_LP64(  do_alias(machine_word_signature,         int_signature)  )                           \
   28.83    LP64_ONLY( do_alias(machine_word_signature,         long_signature) )                           \
   28.84                                                                                                    \
   28.85 @@ -888,14 +909,15 @@
   28.86                                                                                                                            \
   28.87    do_intrinsic(_invoke,                   java_lang_reflect_Method, invoke_name, object_object_array_object_signature, F_R) \
   28.88    /*   (symbols invoke_name and invoke_signature defined above) */                                                      \
   28.89 -  do_intrinsic(_checkSpreadArgument,      java_dyn_MethodHandleNatives, checkSpreadArgument_name, checkSpreadArgument_signature, F_S) \
   28.90 -  do_intrinsic(_checkSpreadArgument_TRANS, sun_dyn_MethodHandleImpl,    checkSpreadArgument_name, checkSpreadArgument_signature, F_S) /* AllowTransitionalJSR292 ONLY */ \
   28.91 +  do_intrinsic(_checkSpreadArgument,      java_lang_invoke_MethodHandleNatives, checkSpreadArgument_name, checkSpreadArgument_signature, F_S) \
   28.92 +  do_intrinsic(_checkSpreadArgument_TRANS,sun_dyn_MethodHandleImpl, checkSpreadArgument_name, checkSpreadArgument_signature, F_S) /* AllowTransitionalJSR292 ONLY */ \
   28.93 +  do_intrinsic(_checkSpreadArgument_TRANS2,java_dyn_MethodHandleNatives, checkSpreadArgument_name, checkSpreadArgument_signature, F_S) /* AllowTransitionalJSR292 ONLY */ \
   28.94     do_name(    checkSpreadArgument_name,       "checkSpreadArgument")                                                   \
   28.95     do_name(    checkSpreadArgument_signature,  "(Ljava/lang/Object;I)V")                                                \
   28.96 -  do_intrinsic(_invokeExact,              java_dyn_MethodHandle, invokeExact_name,   object_array_object_signature, F_RN) \
   28.97 -  do_intrinsic(_invokeGeneric,            java_dyn_MethodHandle, invokeGeneric_name, object_array_object_signature, F_RN) \
   28.98 -  do_intrinsic(_invokeVarargs,            java_dyn_MethodHandle, invokeVarargs_name, object_array_object_signature, F_R)  \
   28.99 -  do_intrinsic(_invokeDynamic,            java_dyn_InvokeDynamic, star_name,         object_array_object_signature, F_SN) \
  28.100 +  do_intrinsic(_invokeExact,              java_lang_invoke_MethodHandle, invokeExact_name,   object_array_object_signature, F_RN) \
  28.101 +  do_intrinsic(_invokeGeneric,            java_lang_invoke_MethodHandle, invokeGeneric_name, object_array_object_signature, F_RN) \
  28.102 +  do_intrinsic(_invokeVarargs,            java_lang_invoke_MethodHandle, invokeVarargs_name, object_array_object_signature, F_R)  \
  28.103 +  do_intrinsic(_invokeDynamic,            java_lang_invoke_InvokeDynamic, star_name,         object_array_object_signature, F_SN) \
  28.104                                                                                                                          \
  28.105    /* unboxing methods: */                                                                                               \
  28.106    do_intrinsic(_booleanValue,             java_lang_Boolean,      booleanValue_name, void_boolean_signature, F_R)       \

    29.1 --- a/src/share/vm/interpreter/abstractInterpreter.hpp	Fri Mar 11 22:33:47 2011 -0800
    29.2 +++ b/src/share/vm/interpreter/abstractInterpreter.hpp	Fri Mar 11 22:34:57 2011 -0800
    29.3 @@ -1,5 +1,5 @@
    29.4  /*
    29.5 - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
    29.6 + * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
    29.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    29.8   *
    29.9   * This code is free software; you can redistribute it and/or modify it
   29.10 @@ -96,7 +96,7 @@
   29.11      empty,                                                      // empty method (code: _return)
   29.12      accessor,                                                   // accessor method (code: _aload_0, _getfield, _(a|i)return)
   29.13      abstract,                                                   // abstract method (throws an AbstractMethodException)
   29.14 -    method_handle,                                              // java.dyn.MethodHandles::invoke
   29.15 +    method_handle,                                              // java.lang.invoke.MethodHandles::invoke
   29.16      java_lang_math_sin,                                         // implementation of java.lang.Math.sin   (x)
   29.17      java_lang_math_cos,                                         // implementation of java.lang.Math.cos   (x)
   29.18      java_lang_math_tan,                                         // implementation of java.lang.Math.tan   (x)

    30.1 --- a/src/share/vm/interpreter/interpreterRuntime.cpp	Fri Mar 11 22:33:47 2011 -0800
    30.2 +++ b/src/share/vm/interpreter/interpreterRuntime.cpp	Fri Mar 11 22:34:57 2011 -0800
    30.3 @@ -369,7 +369,10 @@
    30.4    }
    30.5  
    30.6    // create exception
    30.7 -  THROW_MSG(vmSymbols::java_dyn_WrongMethodTypeException(), message);
    30.8 +  Symbol* java_lang_invoke_WrongMethodTypeException = vmSymbols::java_lang_invoke_WrongMethodTypeException();
    30.9 +  if (AllowTransitionalJSR292)
   30.10 +    java_lang_invoke_WrongMethodTypeException = SystemDictionaryHandles::WrongMethodTypeException_klass()->name();
   30.11 +  THROW_MSG(java_lang_invoke_WrongMethodTypeException, message);
   30.12  }
   30.13  IRT_END
   30.14  
   30.15 @@ -794,7 +797,7 @@
   30.16    Handle info;  // optional argument(s) in JVM_CONSTANT_InvokeDynamic
   30.17    Handle bootm = SystemDictionary::find_bootstrap_method(caller_method, caller_bci,
   30.18                                                           main_index, info, CHECK);
   30.19 -  if (!java_dyn_MethodHandle::is_instance(bootm())) {
   30.20 +  if (!java_lang_invoke_MethodHandle::is_instance(bootm())) {
   30.21      THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
   30.22                "no bootstrap method found for invokedynamic");
   30.23    }

    31.1 --- a/src/share/vm/interpreter/linkResolver.cpp	Fri Mar 11 22:33:47 2011 -0800
    31.2 +++ b/src/share/vm/interpreter/linkResolver.cpp	Fri Mar 11 22:34:57 2011 -0800
    31.3 @@ -221,7 +221,7 @@
    31.4        // Make sure the Java part of the runtime has been booted up.
    31.5        klassOop natives = SystemDictionary::MethodHandleNatives_klass();
    31.6        if (natives == NULL || instanceKlass::cast(natives)->is_not_initialized()) {
    31.7 -        Symbol* natives_name = vmSymbols::java_dyn_MethodHandleNatives();
    31.8 +        Symbol* natives_name = vmSymbols::java_lang_invoke_MethodHandleNatives();
    31.9          if (natives != NULL && AllowTransitionalJSR292)  natives_name = Klass::cast(natives)->name();
   31.10          SystemDictionary::resolve_or_fail(natives_name,
   31.11                                            Handle(),
   31.12 @@ -300,7 +300,7 @@
   31.13  }
   31.14  
   31.15  void LinkResolver::resolve_dynamic_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) {
   31.16 -  // The class is java.dyn.MethodHandle
   31.17 +  // The class is java.lang.invoke.MethodHandle
   31.18    resolved_klass = SystemDictionaryHandles::MethodHandle_klass();
   31.19  
   31.20    Symbol* method_name = vmSymbols::invokeExact_name();

    32.1 --- a/src/share/vm/oops/cpCacheOop.hpp	Fri Mar 11 22:33:47 2011 -0800
    32.2 +++ b/src/share/vm/oops/cpCacheOop.hpp	Fri Mar 11 22:34:57 2011 -0800
    32.3 @@ -190,7 +190,7 @@
    32.4    );
    32.5  
    32.6    void set_dynamic_call(
    32.7 -    Handle call_site,                            // Resolved java.dyn.CallSite (f1)
    32.8 +    Handle call_site,                            // Resolved java.lang.invoke.CallSite (f1)
    32.9      methodHandle signature_invoker               // determines signature information
   32.10    );
   32.11  

    33.1 --- a/src/share/vm/oops/instanceKlass.cpp	Fri Mar 11 22:33:47 2011 -0800
    33.2 +++ b/src/share/vm/oops/instanceKlass.cpp	Fri Mar 11 22:34:57 2011 -0800
    33.3 @@ -2420,7 +2420,7 @@
    33.4      st->cr();
    33.5    } else if (as_klassOop() == SystemDictionary::MethodType_klass()) {
    33.6      st->print(BULLET"signature: ");
    33.7 -    java_dyn_MethodType::print_signature(obj, st);
    33.8 +    java_lang_invoke_MethodType::print_signature(obj, st);
    33.9      st->cr();
   33.10    }
   33.11  }
   33.12 @@ -2451,7 +2451,7 @@
   33.13      }
   33.14    } else if (as_klassOop() == SystemDictionary::MethodType_klass()) {
   33.15      st->print(" = ");
   33.16 -    java_dyn_MethodType::print_signature(obj, st);
   33.17 +    java_lang_invoke_MethodType::print_signature(obj, st);
   33.18    } else if (java_lang_boxing_object::is_instance(obj)) {
   33.19      st->print(" = ");
   33.20      java_lang_boxing_object::print(obj, st);

    34.1 --- a/src/share/vm/oops/instanceKlass.hpp	Fri Mar 11 22:33:47 2011 -0800
    34.2 +++ b/src/share/vm/oops/instanceKlass.hpp	Fri Mar 11 22:34:57 2011 -0800
    34.3 @@ -193,7 +193,7 @@
    34.4    typeArrayOop    _inner_classes;
    34.5    // Implementors of this interface (not valid if it overflows)
    34.6    klassOop        _implementors[implementors_limit];
    34.7 -  // invokedynamic bootstrap method (a java.dyn.MethodHandle)
    34.8 +  // invokedynamic bootstrap method (a java.lang.invoke.MethodHandle)
    34.9    oop             _bootstrap_method;  // AllowTransitionalJSR292 ONLY
   34.10    // Annotations for this class, or null if none.
   34.11    typeArrayOop    _class_annotations;

    35.1 --- a/src/share/vm/oops/methodOop.cpp	Fri Mar 11 22:33:47 2011 -0800
    35.2 +++ b/src/share/vm/oops/methodOop.cpp	Fri Mar 11 22:34:57 2011 -0800
    35.3 @@ -865,7 +865,7 @@
    35.4  enum {
    35.5    _imcp_invoke_name = 1,        // utf8: 'invokeExact' or 'invokeGeneric'
    35.6    _imcp_invoke_signature,       // utf8: (variable Symbol*)
    35.7 -  _imcp_method_type_value,      // string: (variable java/dyn/MethodType, sic)
    35.8 +  _imcp_method_type_value,      // string: (variable java/lang/invoke/MethodType, sic)
    35.9    _imcp_limit
   35.10  };
   35.11  
   35.12 @@ -1091,7 +1091,8 @@
   35.13    vmSymbols::SID  name_id = vmSymbols::find_sid(name());
   35.14    if (name_id == vmSymbols::NO_SID)  return;
   35.15    vmSymbols::SID   sig_id = vmSymbols::find_sid(signature());
   35.16 -  if (klass_id != vmSymbols::VM_SYMBOL_ENUM_NAME(java_dyn_MethodHandle)
   35.17 +  if (klass_id != vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle)
   35.18 +      && !(klass_id == vmSymbols::VM_SYMBOL_ENUM_NAME(java_dyn_MethodHandle) && AllowTransitionalJSR292)
   35.19        && sig_id == vmSymbols::NO_SID)  return;
   35.20    jshort flags = access_flags().as_short();
   35.21  
   35.22 @@ -1117,7 +1118,8 @@
   35.23      break;
   35.24  
   35.25    // Signature-polymorphic methods: MethodHandle.invoke*, InvokeDynamic.*.
   35.26 -  case vmSymbols::VM_SYMBOL_ENUM_NAME(java_dyn_MethodHandle):
   35.27 +  case vmSymbols::VM_SYMBOL_ENUM_NAME(java_dyn_MethodHandle):  // AllowTransitionalJSR292 ONLY
   35.28 +  case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle):
   35.29      if (is_static() || !is_native())  break;
   35.30      switch (name_id) {
   35.31      case vmSymbols::VM_SYMBOL_ENUM_NAME(invokeGeneric_name):
   35.32 @@ -1132,7 +1134,7 @@
   35.33        break;
   35.34      }
   35.35      break;
   35.36 -  case vmSymbols::VM_SYMBOL_ENUM_NAME(java_dyn_InvokeDynamic):
   35.37 +  case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_InvokeDynamic):
   35.38      if (!is_static() || !is_native())  break;
   35.39      id = vmIntrinsics::_invokeDynamic;
   35.40      break;

    36.1 --- a/src/share/vm/opto/bytecodeInfo.cpp	Fri Mar 11 22:33:47 2011 -0800
    36.2 +++ b/src/share/vm/opto/bytecodeInfo.cpp	Fri Mar 11 22:34:57 2011 -0800
    36.3 @@ -1,5 +1,5 @@
    36.4  /*
    36.5 - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
    36.6 + * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
    36.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    36.8   *
    36.9   * This code is free software; you can redistribute it and/or modify it
   36.10 @@ -487,7 +487,7 @@
   36.11      if (caller_jvms->method()->is_method_handle_adapter())
   36.12        new_depth_adjust -= 1;  // don't count actions in MH or indy adapter frames
   36.13      else if (callee_method->is_method_handle_invoke()) {
   36.14 -      new_depth_adjust -= 1;  // don't count method handle calls from java.dyn implem
   36.15 +      new_depth_adjust -= 1;  // don't count method handle calls from java.lang.invoke implem
   36.16      }
   36.17      if (new_depth_adjust != 0 && PrintInlining) {
   36.18        stringStream nm1; caller_jvms->method()->print_name(&nm1);

    37.1 --- a/src/share/vm/opto/callGenerator.cpp	Fri Mar 11 22:33:47 2011 -0800
    37.2 +++ b/src/share/vm/opto/callGenerator.cpp	Fri Mar 11 22:34:57 2011 -0800
    37.3 @@ -1,5 +1,5 @@
    37.4  /*
    37.5 - * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
    37.6 + * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
    37.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    37.8   *
    37.9   * This code is free software; you can redistribute it and/or modify it
   37.10 @@ -199,7 +199,7 @@
   37.11    Node* call_site = kit.make_load(kit.control(), call_site_adr, TypeInstPtr::BOTTOM, T_OBJECT, Compile::AliasIdxRaw);
   37.12  
   37.13    // Load the target MethodHandle from the CallSite object.
   37.14 -  Node* target_mh_adr = kit.basic_plus_adr(call_site, call_site, java_dyn_CallSite::target_offset_in_bytes());
   37.15 +  Node* target_mh_adr = kit.basic_plus_adr(call_site, call_site, java_lang_invoke_CallSite::target_offset_in_bytes());
   37.16    Node* target_mh = kit.make_load(kit.control(), target_mh_adr, TypeInstPtr::BOTTOM, T_OBJECT);
   37.17  
   37.18    address resolve_stub = SharedRuntime::get_resolve_opt_virtual_call_stub();
   37.19 @@ -725,7 +725,7 @@
   37.20    Node* call_site     = kit.make_load(kit.control(), call_site_adr, TypeInstPtr::BOTTOM, T_OBJECT, Compile::AliasIdxRaw);
   37.21  
   37.22    // Load the target MethodHandle from the CallSite object.
   37.23 -  Node* target_adr = kit.basic_plus_adr(call_site, call_site, java_dyn_CallSite::target_offset_in_bytes());
   37.24 +  Node* target_adr = kit.basic_plus_adr(call_site, call_site, java_lang_invoke_CallSite::target_offset_in_bytes());
   37.25    Node* target_mh  = kit.make_load(kit.control(), target_adr, TypeInstPtr::BOTTOM, T_OBJECT);
   37.26  
   37.27    // Check if the MethodHandle is still the same.

    38.1 --- a/src/share/vm/opto/parse3.cpp	Fri Mar 11 22:33:47 2011 -0800
    38.2 +++ b/src/share/vm/opto/parse3.cpp	Fri Mar 11 22:34:57 2011 -0800
    38.3 @@ -1,5 +1,5 @@
    38.4  /*
    38.5 - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
    38.6 + * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
    38.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    38.8   *
    38.9   * This code is free software; you can redistribute it and/or modify it
   38.10 @@ -143,8 +143,8 @@
   38.11          return;
   38.12      }
   38.13      else {
   38.14 -      // final non-static field of a trusted class ({java,sun}.dyn
   38.15 -      // classes).
   38.16 +      // final non-static field of a trusted class (classes in
   38.17 +      // java.lang.invoke and sun.invoke packages and subpackages).
   38.18        if (obj->is_Con()) {
   38.19          const TypeOopPtr* oop_ptr = obj->bottom_type()->isa_oopptr();
   38.20          ciObject* constant_oop = oop_ptr->const_oop();

    39.1 --- a/src/share/vm/prims/methodHandleWalk.cpp	Fri Mar 11 22:33:47 2011 -0800
    39.2 +++ b/src/share/vm/prims/methodHandleWalk.cpp	Fri Mar 11 22:34:57 2011 -0800
    39.3 @@ -36,7 +36,7 @@
    39.4  // MethodHandleChain
    39.5  
    39.6  void MethodHandleChain::set_method_handle(Handle mh, TRAPS) {
    39.7 -  if (!java_dyn_MethodHandle::is_instance(mh()))  lose("bad method handle", CHECK);
    39.8 +  if (!java_lang_invoke_MethodHandle::is_instance(mh()))  lose("bad method handle", CHECK);
    39.9  
   39.10    // set current method handle and unpack partially
   39.11    _method_handle = mh;
   39.12 @@ -47,21 +47,21 @@
   39.13    _conversion    = -1;
   39.14    _last_invoke   = Bytecodes::_nop;  //arbitrary non-garbage
   39.15  
   39.16 -  if (sun_dyn_DirectMethodHandle::is_instance(mh())) {
   39.17 +  if (java_lang_invoke_DirectMethodHandle::is_instance(mh())) {
   39.18      set_last_method(mh(), THREAD);
   39.19      return;
   39.20    }
   39.21 -  if (sun_dyn_AdapterMethodHandle::is_instance(mh())) {
   39.22 +  if (java_lang_invoke_AdapterMethodHandle::is_instance(mh())) {
   39.23      _conversion = AdapterMethodHandle_conversion();
   39.24      assert(_conversion != -1, "bad conv value");
   39.25 -    assert(sun_dyn_BoundMethodHandle::is_instance(mh()), "also BMH");
   39.26 +    assert(java_lang_invoke_BoundMethodHandle::is_instance(mh()), "also BMH");
   39.27    }
   39.28 -  if (sun_dyn_BoundMethodHandle::is_instance(mh())) {
   39.29 +  if (java_lang_invoke_BoundMethodHandle::is_instance(mh())) {
   39.30      if (!is_adapter())          // keep AMH and BMH separate in this model
   39.31        _is_bound = true;
   39.32      _arg_slot = BoundMethodHandle_vmargslot();
   39.33      oop target = MethodHandle_vmtarget_oop();
   39.34 -    if (!is_bound() || java_dyn_MethodHandle::is_instance(target)) {
   39.35 +    if (!is_bound() || java_lang_invoke_MethodHandle::is_instance(target)) {
   39.36        _arg_type = compute_bound_arg_type(target, NULL, _arg_slot, CHECK);
   39.37      } else if (target != NULL && target->is_method()) {
   39.38        methodOop m = (methodOop) target;
   39.39 @@ -102,10 +102,10 @@
   39.40    // It is implied by the _vmentry code, and by the MethodType of the target.
   39.41    BasicType arg_type = T_VOID;
   39.42    if (target != NULL) {
   39.43 -    oop mtype = java_dyn_MethodHandle::type(target);
   39.44 +    oop mtype = java_lang_invoke_MethodHandle::type(target);
   39.45      int arg_num = MethodHandles::argument_slot_to_argnum(mtype, arg_slot);
   39.46      if (arg_num >= 0) {
   39.47 -      oop ptype = java_dyn_MethodType::ptype(mtype, arg_num);
   39.48 +      oop ptype = java_lang_invoke_MethodType::ptype(mtype, arg_num);
   39.49        arg_type = java_lang_Class::as_BasicType(ptype);
   39.50      }
   39.51    } else if (m != NULL) {
   39.52 @@ -204,28 +204,28 @@
   39.53        int arg_slot = chain().adapter_arg_slot();
   39.54        SlotState* arg_state = slot_state(arg_slot);
   39.55        if (arg_state == NULL
   39.56 -          && conv_op > sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW) {
   39.57 +          && conv_op > java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW) {
   39.58          lose("bad argument index", CHECK_(empty));
   39.59        }
   39.60  
   39.61        // perform the adapter action
   39.62        switch (chain().adapter_conversion_op()) {
   39.63 -      case sun_dyn_AdapterMethodHandle::OP_RETYPE_ONLY:
   39.64 +      case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY:
   39.65          // No changes to arguments; pass the bits through.
   39.66          break;
   39.67  
   39.68 -      case sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW: {
   39.69 +      case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW: {
   39.70          // To keep the verifier happy, emit bitwise ("raw") conversions as needed.
   39.71          // See MethodHandles::same_basic_type_for_arguments for allowed conversions.
   39.72          Handle incoming_mtype(THREAD, chain().method_type_oop());
   39.73          oop outgoing_mh_oop = chain().vmtarget_oop();
   39.74 -        if (!java_dyn_MethodHandle::is_instance(outgoing_mh_oop))
   39.75 +        if (!java_lang_invoke_MethodHandle::is_instance(outgoing_mh_oop))
   39.76            lose("outgoing target not a MethodHandle", CHECK_(empty));
   39.77 -        Handle outgoing_mtype(THREAD, java_dyn_MethodHandle::type(outgoing_mh_oop));
   39.78 +        Handle outgoing_mtype(THREAD, java_lang_invoke_MethodHandle::type(outgoing_mh_oop));
   39.79          outgoing_mh_oop = NULL;  // GC safety
   39.80  
   39.81 -        int nptypes = java_dyn_MethodType::ptype_count(outgoing_mtype());
   39.82 -        if (nptypes != java_dyn_MethodType::ptype_count(incoming_mtype()))
   39.83 +        int nptypes = java_lang_invoke_MethodType::ptype_count(outgoing_mtype());
   39.84 +        if (nptypes != java_lang_invoke_MethodType::ptype_count(incoming_mtype()))
   39.85            lose("incoming and outgoing parameter count do not agree", CHECK_(empty));
   39.86  
   39.87          for (int i = 0, slot = _outgoing.length() - 1; slot >= 0; slot--) {
   39.88 @@ -235,8 +235,8 @@
   39.89  
   39.90            klassOop  in_klass  = NULL;
   39.91            klassOop  out_klass = NULL;
   39.92 -          BasicType inpbt  = java_lang_Class::as_BasicType(java_dyn_MethodType::ptype(incoming_mtype(), i), &in_klass);
   39.93 -          BasicType outpbt = java_lang_Class::as_BasicType(java_dyn_MethodType::ptype(outgoing_mtype(), i), &out_klass);
   39.94 +          BasicType inpbt  = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(incoming_mtype(), i), &in_klass);
   39.95 +          BasicType outpbt = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(outgoing_mtype(), i), &out_klass);
   39.96            assert(inpbt == arg.basic_type(), "sanity");
   39.97  
   39.98            if (inpbt != outpbt) {
   39.99 @@ -254,8 +254,8 @@
  39.100            i++;  // We need to skip void slots at the top of the loop.
  39.101          }
  39.102  
  39.103 -        BasicType inrbt  = java_lang_Class::as_BasicType(java_dyn_MethodType::rtype(incoming_mtype()));
  39.104 -        BasicType outrbt = java_lang_Class::as_BasicType(java_dyn_MethodType::rtype(outgoing_mtype()));
  39.105 +        BasicType inrbt  = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(incoming_mtype()));
  39.106 +        BasicType outrbt = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(outgoing_mtype()));
  39.107          if (inrbt != outrbt) {
  39.108            if (inrbt == T_INT && outrbt == T_VOID) {
  39.109              // See comments in MethodHandles::same_basic_type_for_arguments.
  39.110 @@ -267,7 +267,7 @@
  39.111          break;
  39.112        }
  39.113  
  39.114 -      case sun_dyn_AdapterMethodHandle::OP_CHECK_CAST: {
  39.115 +      case java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST: {
  39.116          // checkcast the Nth outgoing argument in place
  39.117          klassOop dest_klass = NULL;
  39.118          BasicType dest = java_lang_Class::as_BasicType(chain().adapter_arg_oop(), &dest_klass);
  39.119 @@ -280,7 +280,7 @@
  39.120          break;
  39.121        }
  39.122  
  39.123 -      case sun_dyn_AdapterMethodHandle::OP_PRIM_TO_PRIM: {
  39.124 +      case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM: {
  39.125          // i2l, etc., on the Nth outgoing argument in place
  39.126          BasicType src = chain().adapter_conversion_src_type(),
  39.127                    dest = chain().adapter_conversion_dest_type();
  39.128 @@ -305,7 +305,7 @@
  39.129          break;
  39.130        }
  39.131  
  39.132 -      case sun_dyn_AdapterMethodHandle::OP_REF_TO_PRIM: {
  39.133 +      case java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM: {
  39.134          // checkcast to wrapper type & call intValue, etc.
  39.135          BasicType dest = chain().adapter_conversion_dest_type();
  39.136          ArgToken arg = arg_state->_arg;
  39.137 @@ -323,7 +323,7 @@
  39.138          break;
  39.139        }
  39.140  
  39.141 -      case sun_dyn_AdapterMethodHandle::OP_PRIM_TO_REF: {
  39.142 +      case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF: {
  39.143          // call wrapper type.valueOf
  39.144          BasicType src = chain().adapter_conversion_src_type();
  39.145          ArgToken arg = arg_state->_arg;
  39.146 @@ -339,7 +339,7 @@
  39.147          break;
  39.148        }
  39.149  
  39.150 -      case sun_dyn_AdapterMethodHandle::OP_SWAP_ARGS: {
  39.151 +      case java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS: {
  39.152          int dest_arg_slot = chain().adapter_conversion_vminfo();
  39.153          if (!slot_has_argument(dest_arg_slot)) {
  39.154            lose("bad swap index", CHECK_(empty));
  39.155 @@ -352,7 +352,7 @@
  39.156          break;
  39.157        }
  39.158  
  39.159 -      case sun_dyn_AdapterMethodHandle::OP_ROT_ARGS: {
  39.160 +      case java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS: {
  39.161          int dest_arg_slot = chain().adapter_conversion_vminfo();
  39.162          if (!slot_has_argument(dest_arg_slot) || arg_slot == dest_arg_slot) {
  39.163            lose("bad rotate index", CHECK_(empty));
  39.164 @@ -378,7 +378,7 @@
  39.165          break;
  39.166        }
  39.167  
  39.168 -      case sun_dyn_AdapterMethodHandle::OP_DUP_ARGS: {
  39.169 +      case java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS: {
  39.170          int dup_slots = chain().adapter_conversion_stack_pushes();
  39.171          if (dup_slots <= 0) {
  39.172            lose("bad dup count", CHECK_(empty));
  39.173 @@ -392,7 +392,7 @@
  39.174          break;
  39.175        }
  39.176  
  39.177 -      case sun_dyn_AdapterMethodHandle::OP_DROP_ARGS: {
  39.178 +      case java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS: {
  39.179          int drop_slots = -chain().adapter_conversion_stack_pushes();
  39.180          if (drop_slots <= 0) {
  39.181            lose("bad drop count", CHECK_(empty));
  39.182 @@ -406,12 +406,12 @@
  39.183          break;
  39.184        }
  39.185  
  39.186 -      case sun_dyn_AdapterMethodHandle::OP_COLLECT_ARGS: { //NYI, may GC
  39.187 +      case java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS: { //NYI, may GC
  39.188          lose("unimplemented", CHECK_(empty));
  39.189          break;
  39.190        }
  39.191  
  39.192 -      case sun_dyn_AdapterMethodHandle::OP_SPREAD_ARGS: {
  39.193 +      case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {
  39.194          klassOop array_klass_oop = NULL;
  39.195          BasicType array_type = java_lang_Class::as_BasicType(chain().adapter_arg_oop(),
  39.196                                                               &array_klass_oop);
  39.197 @@ -469,8 +469,8 @@
  39.198          break;
  39.199        }
  39.200  
  39.201 -      case sun_dyn_AdapterMethodHandle::OP_FLYBY: //NYI, runs Java code
  39.202 -      case sun_dyn_AdapterMethodHandle::OP_RICOCHET: //NYI, runs Java code
  39.203 +      case java_lang_invoke_AdapterMethodHandle::OP_FLYBY: //NYI, runs Java code
  39.204 +      case java_lang_invoke_AdapterMethodHandle::OP_RICOCHET: //NYI, runs Java code
  39.205          lose("unimplemented", CHECK_(empty));
  39.206          break;
  39.207  
  39.208 @@ -532,7 +532,7 @@
  39.209  //
  39.210  void MethodHandleWalker::walk_incoming_state(TRAPS) {
  39.211    Handle mtype(THREAD, chain().method_type_oop());
  39.212 -  int nptypes = java_dyn_MethodType::ptype_count(mtype());
  39.213 +  int nptypes = java_lang_invoke_MethodType::ptype_count(mtype());
  39.214    _outgoing_argc = nptypes;
  39.215    int argp = nptypes - 1;
  39.216    if (argp >= 0) {
  39.217 @@ -541,7 +541,7 @@
  39.218    for (int i = 0; i < nptypes; i++) {
  39.219      klassOop  arg_type_klass = NULL;
  39.220      BasicType arg_type = java_lang_Class::as_BasicType(
  39.221 -                java_dyn_MethodType::ptype(mtype(), i), &arg_type_klass);
  39.222 +                java_lang_invoke_MethodType::ptype(mtype(), i), &arg_type_klass);
  39.223      int index = new_local_index(arg_type);
  39.224      ArgToken arg = make_parameter(arg_type, arg_type_klass, index, CHECK);
  39.225      debug_only(arg_type_klass = (klassOop) NULL);
  39.226 @@ -555,7 +555,7 @@
  39.227    // call make_parameter at the end of the list for the return type
  39.228    klassOop  ret_type_klass = NULL;
  39.229    BasicType ret_type = java_lang_Class::as_BasicType(
  39.230 -              java_dyn_MethodType::rtype(mtype()), &ret_type_klass);
  39.231 +              java_lang_invoke_MethodType::rtype(mtype()), &ret_type_klass);
  39.232    ArgToken  ret = make_parameter(ret_type, ret_type_klass, -1, CHECK);
  39.233    // ignore ret; client can catch it if needed
  39.234  }
  39.235 @@ -630,7 +630,7 @@
  39.236    // Get return type klass.
  39.237    Handle first_mtype(THREAD, chain().method_type_oop());
  39.238    // _rklass is NULL for primitives.
  39.239 -  _rtype = java_lang_Class::as_BasicType(java_dyn_MethodType::rtype(first_mtype()), &_rklass);
  39.240 +  _rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(first_mtype()), &_rklass);
  39.241    if (_rtype == T_ARRAY)  _rtype = T_OBJECT;
  39.242  
  39.243    int params = _callee->size_of_parameters();  // Incoming arguments plus receiver.
  39.244 @@ -961,6 +961,9 @@
  39.245      m = vmIntrinsics::method_for(iid);
  39.246      if (m == NULL && iid == vmIntrinsics::_checkSpreadArgument && AllowTransitionalJSR292) {
  39.247        m = vmIntrinsics::method_for(vmIntrinsics::_checkSpreadArgument_TRANS);
  39.248 +      if (m == NULL)
  39.249 +        // sun.dyn.MethodHandleImpl not found, look for java.dyn.MethodHandleNatives:
  39.250 +        m = vmIntrinsics::method_for(vmIntrinsics::_checkSpreadArgument_TRANS2);
  39.251      }
  39.252      if (m == NULL) {
  39.253        ArgToken zero;
  39.254 @@ -1402,7 +1405,7 @@
  39.255  void print_method_handle(oop mh) {
  39.256    if (!mh->is_oop()) {
  39.257      tty->print_cr("*** not a method handle: "INTPTR_FORMAT, (intptr_t)mh);
  39.258 -  } else if (java_dyn_MethodHandle::is_instance(mh)) {
  39.259 +  } else if (java_lang_invoke_MethodHandle::is_instance(mh)) {
  39.260      //MethodHandlePrinter::print(mh);
  39.261    } else {
  39.262      tty->print("*** not a method handle: ");

    40.1 --- a/src/share/vm/prims/methodHandleWalk.hpp	Fri Mar 11 22:33:47 2011 -0800
    40.2 +++ b/src/share/vm/prims/methodHandleWalk.hpp	Fri Mar 11 22:34:57 2011 -0800
    40.3 @@ -1,5 +1,5 @@
    40.4  /*
    40.5 - * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
    40.6 + * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
    40.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    40.8   *
    40.9   * This code is free software; you can redistribute it and/or modify it
   40.10 @@ -48,13 +48,13 @@
   40.11    void set_last_method(oop target, TRAPS);
   40.12    static BasicType compute_bound_arg_type(oop target, methodOop m, int arg_slot, TRAPS);
   40.13  
   40.14 -  oop MethodHandle_type_oop()     { return java_dyn_MethodHandle::type(method_handle_oop()); }
   40.15 -  oop MethodHandle_vmtarget_oop() { return java_dyn_MethodHandle::vmtarget(method_handle_oop()); }
   40.16 -  int MethodHandle_vmslots()      { return java_dyn_MethodHandle::vmslots(method_handle_oop()); }
   40.17 -  int DirectMethodHandle_vmindex()     { return sun_dyn_DirectMethodHandle::vmindex(method_handle_oop()); }
   40.18 -  oop BoundMethodHandle_argument_oop() { return sun_dyn_BoundMethodHandle::argument(method_handle_oop()); }
   40.19 -  int BoundMethodHandle_vmargslot()    { return sun_dyn_BoundMethodHandle::vmargslot(method_handle_oop()); }
   40.20 -  int AdapterMethodHandle_conversion() { return sun_dyn_AdapterMethodHandle::conversion(method_handle_oop()); }
   40.21 +  oop MethodHandle_type_oop()          { return java_lang_invoke_MethodHandle::type(method_handle_oop()); }
   40.22 +  oop MethodHandle_vmtarget_oop()      { return java_lang_invoke_MethodHandle::vmtarget(method_handle_oop()); }
   40.23 +  int MethodHandle_vmslots()           { return java_lang_invoke_MethodHandle::vmslots(method_handle_oop()); }
   40.24 +  int DirectMethodHandle_vmindex()     { return java_lang_invoke_DirectMethodHandle::vmindex(method_handle_oop()); }
   40.25 +  oop BoundMethodHandle_argument_oop() { return java_lang_invoke_BoundMethodHandle::argument(method_handle_oop()); }
   40.26 +  int BoundMethodHandle_vmargslot()    { return java_lang_invoke_BoundMethodHandle::vmargslot(method_handle_oop()); }
   40.27 +  int AdapterMethodHandle_conversion() { return java_lang_invoke_AdapterMethodHandle::conversion(method_handle_oop()); }
   40.28  
   40.29  public:
   40.30    MethodHandleChain(Handle root, TRAPS)

    41.1 --- a/src/share/vm/prims/methodHandles.cpp	Fri Mar 11 22:33:47 2011 -0800
    41.2 +++ b/src/share/vm/prims/methodHandles.cpp	Fri Mar 11 22:34:57 2011 -0800
    41.3 @@ -163,9 +163,9 @@
    41.4      // or it may use the klass/index form; both forms mean the same thing.
    41.5      methodOop m = decode_methodOop(methodOop(vmtarget), decode_flags_result);
    41.6      if ((decode_flags_result & _dmf_has_receiver) != 0
    41.7 -        && java_dyn_MethodType::is_instance(mtype)) {
    41.8 +        && java_lang_invoke_MethodType::is_instance(mtype)) {
    41.9        // Extract receiver type restriction from mtype.ptypes[0].
   41.10 -      objArrayOop ptypes = java_dyn_MethodType::ptypes(mtype);
   41.11 +      objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(mtype);
   41.12        oop ptype0 = (ptypes == NULL || ptypes->length() < 1) ? oop(NULL) : ptypes->obj_at(0);
   41.13        if (java_lang_Class::is_instance(ptype0))
   41.14          receiver_limit_result = java_lang_Class::as_klassOop(ptype0);
   41.15 @@ -199,18 +199,18 @@
   41.16  // (MemberName is the non-operational name used for queries and setup.)
   41.17  
   41.18  methodOop MethodHandles::decode_DirectMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
   41.19 -  oop vmtarget = sun_dyn_DirectMethodHandle::vmtarget(mh);
   41.20 -  int vmindex  = sun_dyn_DirectMethodHandle::vmindex(mh);
   41.21 -  oop mtype    = sun_dyn_DirectMethodHandle::type(mh);
   41.22 +  oop vmtarget = java_lang_invoke_DirectMethodHandle::vmtarget(mh);
   41.23 +  int vmindex  = java_lang_invoke_DirectMethodHandle::vmindex(mh);
   41.24 +  oop mtype    = java_lang_invoke_DirectMethodHandle::type(mh);
   41.25    return decode_vmtarget(vmtarget, vmindex, mtype, receiver_limit_result, decode_flags_result);
   41.26  }
   41.27  
   41.28  methodOop MethodHandles::decode_BoundMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
   41.29 -  assert(sun_dyn_BoundMethodHandle::is_instance(mh), "");
   41.30 +  assert(java_lang_invoke_BoundMethodHandle::is_instance(mh), "");
   41.31    assert(mh->klass() != SystemDictionary::AdapterMethodHandle_klass(), "");
   41.32    for (oop bmh = mh;;) {
   41.33      // Bound MHs can be stacked to bind several arguments.
   41.34 -    oop target = java_dyn_MethodHandle::vmtarget(bmh);
   41.35 +    oop target = java_lang_invoke_MethodHandle::vmtarget(bmh);
   41.36      if (target == NULL)  return NULL;
   41.37      decode_flags_result |= MethodHandles::_dmf_binds_argument;
   41.38      klassOop tk = target->klass();
   41.39 @@ -218,7 +218,7 @@
   41.40        bmh = target;
   41.41        continue;
   41.42      } else {
   41.43 -      if (java_dyn_MethodHandle::is_subclass(tk)) {
   41.44 +      if (java_lang_invoke_MethodHandle::is_subclass(tk)) {
   41.45          //assert(tk == SystemDictionary::DirectMethodHandle_klass(), "end of BMH chain must be DMH");
   41.46          return decode_MethodHandle(target, receiver_limit_result, decode_flags_result);
   41.47        } else {
   41.48 @@ -240,9 +240,9 @@
   41.49    assert(mh->klass() == SystemDictionary::AdapterMethodHandle_klass(), "");
   41.50    for (oop amh = mh;;) {
   41.51      // Adapter MHs can be stacked to convert several arguments.
   41.52 -    int conv_op = adapter_conversion_op(sun_dyn_AdapterMethodHandle::conversion(amh));
   41.53 +    int conv_op = adapter_conversion_op(java_lang_invoke_AdapterMethodHandle::conversion(amh));
   41.54      decode_flags_result |= (_dmf_adapter_lsb << conv_op) & _DMF_ADAPTER_MASK;
   41.55 -    oop target = java_dyn_MethodHandle::vmtarget(amh);
   41.56 +    oop target = java_lang_invoke_MethodHandle::vmtarget(amh);
   41.57      if (target == NULL)  return NULL;
   41.58      klassOop tk = target->klass();
   41.59      if (tk == SystemDictionary::AdapterMethodHandle_klass()) {
   41.60 @@ -258,14 +258,14 @@
   41.61  methodOop MethodHandles::decode_MethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
   41.62    if (mh == NULL)  return NULL;
   41.63    klassOop mhk = mh->klass();
   41.64 -  assert(java_dyn_MethodHandle::is_subclass(mhk), "must be a MethodHandle");
   41.65 +  assert(java_lang_invoke_MethodHandle::is_subclass(mhk), "must be a MethodHandle");
   41.66    if (mhk == SystemDictionary::DirectMethodHandle_klass()) {
   41.67      return decode_DirectMethodHandle(mh, receiver_limit_result, decode_flags_result);
   41.68    } else if (mhk == SystemDictionary::BoundMethodHandle_klass()) {
   41.69      return decode_BoundMethodHandle(mh, receiver_limit_result, decode_flags_result);
   41.70    } else if (mhk == SystemDictionary::AdapterMethodHandle_klass()) {
   41.71      return decode_AdapterMethodHandle(mh, receiver_limit_result, decode_flags_result);
   41.72 -  } else if (sun_dyn_BoundMethodHandle::is_subclass(mhk)) {
   41.73 +  } else if (java_lang_invoke_BoundMethodHandle::is_subclass(mhk)) {
   41.74      // could be a JavaMethodHandle (but not an adapter MH)
   41.75      return decode_BoundMethodHandle(mh, receiver_limit_result, decode_flags_result);
   41.76    } else {
   41.77 @@ -308,7 +308,7 @@
   41.78    } else if (xk == SystemDictionary::MemberName_klass()) {
   41.79      // Note: This only works if the MemberName has already been resolved.
   41.80      return decode_MemberName(x, receiver_limit_result, decode_flags_result);
   41.81 -  } else if (java_dyn_MethodHandle::is_subclass(xk)) {
   41.82 +  } else if (java_lang_invoke_MethodHandle::is_subclass(xk)) {
   41.83      return decode_MethodHandle(x, receiver_limit_result, decode_flags_result);
   41.84    } else if (xk == SystemDictionary::reflect_Method_klass()) {
   41.85      oop clazz  = java_lang_reflect_Method::clazz(x);
   41.86 @@ -327,7 +327,7 @@
   41.87    } else {
   41.88      // unrecognized object
   41.89      assert(!x->is_method(), "already checked");
   41.90 -    assert(!sun_dyn_MemberName::is_instance(x), "already checked");
   41.91 +    assert(!java_lang_invoke_MemberName::is_instance(x), "already checked");
   41.92    }
   41.93    return NULL;
   41.94  }
   41.95 @@ -336,15 +336,15 @@
   41.96  int MethodHandles::decode_MethodHandle_stack_pushes(oop mh) {
   41.97    if (mh->klass() == SystemDictionary::DirectMethodHandle_klass())
   41.98      return 0;                   // no push/pop
   41.99 -  int this_vmslots = java_dyn_MethodHandle::vmslots(mh);
  41.100 +  int this_vmslots = java_lang_invoke_MethodHandle::vmslots(mh);
  41.101    int last_vmslots = 0;
  41.102    oop last_mh = mh;
  41.103    for (;;) {
  41.104 -    oop target = java_dyn_MethodHandle::vmtarget(last_mh);
  41.105 +    oop target = java_lang_invoke_MethodHandle::vmtarget(last_mh);
  41.106      if (target->klass() == SystemDictionary::DirectMethodHandle_klass()) {
  41.107 -      last_vmslots = java_dyn_MethodHandle::vmslots(target);
  41.108 +      last_vmslots = java_lang_invoke_MethodHandle::vmslots(target);
  41.109        break;
  41.110 -    } else if (!java_dyn_MethodHandle::is_instance(target)) {
  41.111 +    } else if (!java_lang_invoke_MethodHandle::is_instance(target)) {
  41.112        // might be klass or method
  41.113        assert(target->is_method(), "must get here with a direct ref to method");
  41.114        last_vmslots = methodOop(target)->size_of_parameters();
  41.115 @@ -361,16 +361,16 @@
  41.116  
  41.117  // MemberName support
  41.118  
  41.119 -// import sun_dyn_MemberName.*
  41.120 +// import java_lang_invoke_MemberName.*
  41.121  enum {
  41.122 -  IS_METHOD      = sun_dyn_MemberName::MN_IS_METHOD,
  41.123 -  IS_CONSTRUCTOR = sun_dyn_MemberName::MN_IS_CONSTRUCTOR,
  41.124 -  IS_FIELD       = sun_dyn_MemberName::MN_IS_FIELD,
  41.125 -  IS_TYPE        = sun_dyn_MemberName::MN_IS_TYPE,
  41.126 -  SEARCH_SUPERCLASSES = sun_dyn_MemberName::MN_SEARCH_SUPERCLASSES,
  41.127 -  SEARCH_INTERFACES   = sun_dyn_MemberName::MN_SEARCH_INTERFACES,
  41.128 +  IS_METHOD      = java_lang_invoke_MemberName::MN_IS_METHOD,
  41.129 +  IS_CONSTRUCTOR = java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR,
  41.130 +  IS_FIELD       = java_lang_invoke_MemberName::MN_IS_FIELD,
  41.131 +  IS_TYPE        = java_lang_invoke_MemberName::MN_IS_TYPE,
  41.132 +  SEARCH_SUPERCLASSES = java_lang_invoke_MemberName::MN_SEARCH_SUPERCLASSES,
  41.133 +  SEARCH_INTERFACES   = java_lang_invoke_MemberName::MN_SEARCH_INTERFACES,
  41.134    ALL_KINDS      = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE,
  41.135 -  VM_INDEX_UNINITIALIZED = sun_dyn_MemberName::VM_INDEX_UNINITIALIZED
  41.136 +  VM_INDEX_UNINITIALIZED = java_lang_invoke_MemberName::VM_INDEX_UNINITIALIZED
  41.137  };
  41.138  
  41.139  Handle MethodHandles::new_MemberName(TRAPS) {
  41.140 @@ -405,10 +405,10 @@
  41.141    if (!do_dispatch || (flags & IS_CONSTRUCTOR) || m->can_be_statically_bound())
  41.142      vmindex = methodOopDesc::nonvirtual_vtable_index; // implies never any dispatch
  41.143    assert(vmindex != VM_INDEX_UNINITIALIZED, "Java sentinel value");
  41.144 -  sun_dyn_MemberName::set_vmtarget(mname_oop, vmtarget);
  41.145 -  sun_dyn_MemberName::set_vmindex(mname_oop,  vmindex);
  41.146 -  sun_dyn_MemberName::set_flags(mname_oop,    flags);
  41.147 -  sun_dyn_MemberName::set_clazz(mname_oop,    Klass::cast(m->method_holder())->java_mirror());
  41.148 +  java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);
  41.149 +  java_lang_invoke_MemberName::set_vmindex(mname_oop,  vmindex);
  41.150 +  java_lang_invoke_MemberName::set_flags(mname_oop,    flags);
  41.151 +  java_lang_invoke_MemberName::set_clazz(mname_oop,    Klass::cast(m->method_holder())->java_mirror());
  41.152  }
  41.153  
  41.154  void MethodHandles::init_MemberName(oop mname_oop, klassOop field_holder, AccessFlags mods, int offset) {
  41.155 @@ -416,21 +416,21 @@
  41.156    oop vmtarget = field_holder;
  41.157    int vmindex  = offset;  // determines the field uniquely when combined with static bit
  41.158    assert(vmindex != VM_INDEX_UNINITIALIZED, "bad alias on vmindex");
  41.159 -  sun_dyn_MemberName::set_vmtarget(mname_oop, vmtarget);
  41.160 -  sun_dyn_MemberName::set_vmindex(mname_oop,  vmindex);
  41.161 -  sun_dyn_MemberName::set_flags(mname_oop,    flags);
  41.162 -  sun_dyn_MemberName::set_clazz(mname_oop,    Klass::cast(field_holder)->java_mirror());
  41.163 +  java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);
  41.164 +  java_lang_invoke_MemberName::set_vmindex(mname_oop,  vmindex);
  41.165 +  java_lang_invoke_MemberName::set_flags(mname_oop,    flags);
  41.166 +  java_lang_invoke_MemberName::set_clazz(mname_oop,    Klass::cast(field_holder)->java_mirror());
  41.167  }
  41.168  
  41.169  
  41.170  methodOop MethodHandles::decode_MemberName(oop mname, klassOop& receiver_limit_result, int& decode_flags_result) {
  41.171 -  int flags  = sun_dyn_MemberName::flags(mname);
  41.172 +  int flags  = java_lang_invoke_MemberName::flags(mname);
  41.173    if ((flags & (IS_METHOD | IS_CONSTRUCTOR)) == 0)  return NULL;  // not invocable
  41.174 -  oop vmtarget = sun_dyn_MemberName::vmtarget(mname);
  41.175 -  int vmindex  = sun_dyn_MemberName::vmindex(mname);
  41.176 +  oop vmtarget = java_lang_invoke_MemberName::vmtarget(mname);
  41.177 +  int vmindex  = java_lang_invoke_MemberName::vmindex(mname);
  41.178    if (vmindex == VM_INDEX_UNINITIALIZED)  return NULL; // not resolved
  41.179    methodOop m = decode_vmtarget(vmtarget, vmindex, NULL, receiver_limit_result, decode_flags_result);
  41.180 -  oop clazz = sun_dyn_MemberName::clazz(mname);
  41.181 +  oop clazz = java_lang_invoke_MemberName::clazz(mname);
  41.182    if (clazz != NULL && java_lang_Class::is_instance(clazz)) {
  41.183      klassOop klass = java_lang_Class::as_klassOop(clazz);
  41.184      if (klass != NULL)  receiver_limit_result = klass;
  41.185 @@ -442,8 +442,8 @@
  41.186  Symbol* MethodHandles::convert_to_signature(oop type_str,
  41.187                                              bool polymorphic,
  41.188                                              TRAPS) {
  41.189 -  if (java_dyn_MethodType::is_instance(type_str)) {
  41.190 -    return java_dyn_MethodType::as_signature(type_str, polymorphic, CHECK_NULL);
  41.191 +  if (java_lang_invoke_MethodType::is_instance(type_str)) {
  41.192 +    return java_lang_invoke_MethodType::as_signature(type_str, polymorphic, CHECK_NULL);
  41.193    } else if (java_lang_Class::is_instance(type_str)) {
  41.194      return java_lang_Class::as_signature(type_str, false, CHECK_NULL);
  41.195    } else if (java_lang_String::is_instance(type_str)) {
  41.196 @@ -461,7 +461,7 @@
  41.197  // Resolving it plants a vmtarget/vmindex in it,
  41.198  // which refers dirctly to JVM internals.
  41.199  void MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
  41.200 -  assert(sun_dyn_MemberName::is_instance(mname()), "");
  41.201 +  assert(java_lang_invoke_MemberName::is_instance(mname()), "");
  41.202  #ifdef ASSERT
  41.203    // If this assert throws, renegotiate the sentinel value used by the Java code,
  41.204    // so that it is distinct from any valid vtable index value, and any special
  41.205 @@ -472,12 +472,12 @@
  41.206    const int sentinel_limit = methodOopDesc::highest_unused_vtable_index_value - sentinel_slop;
  41.207    assert(VM_INDEX_UNINITIALIZED < sentinel_limit, "Java sentinel != JVM sentinels");
  41.208  #endif
  41.209 -  if (sun_dyn_MemberName::vmindex(mname()) != VM_INDEX_UNINITIALIZED)
  41.210 +  if (java_lang_invoke_MemberName::vmindex(mname()) != VM_INDEX_UNINITIALIZED)
  41.211      return;  // already resolved
  41.212 -  oop defc_oop = sun_dyn_MemberName::clazz(mname());
  41.213 -  oop name_str = sun_dyn_MemberName::name(mname());
  41.214 -  oop type_str = sun_dyn_MemberName::type(mname());
  41.215 -  int flags    = sun_dyn_MemberName::flags(mname());
  41.216 +  oop defc_oop = java_lang_invoke_MemberName::clazz(mname());
  41.217 +  oop name_str = java_lang_invoke_MemberName::name(mname());
  41.218 +  oop type_str = java_lang_invoke_MemberName::type(mname());
  41.219 +  int flags    = java_lang_invoke_MemberName::flags(mname());
  41.220  
  41.221    if (defc_oop == NULL || name_str == NULL || type_str == NULL) {
  41.222      THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve");
  41.223 @@ -510,7 +510,7 @@
  41.224  
  41.225    // convert the external string or reflective type to an internal signature
  41.226    TempNewSymbol type = convert_to_signature(type_str, polymorphic_signature, CHECK);
  41.227 -  if (java_dyn_MethodType::is_instance(type_str) && polymorphic_signature) {
  41.228 +  if (java_lang_invoke_MethodType::is_instance(type_str) && polymorphic_signature) {
  41.229      polymorphic_method_type = Handle(THREAD, type_str);  //preserve exactly
  41.230    }
  41.231  
  41.232 @@ -557,9 +557,9 @@
  41.233          vmtarget = result.resolved_klass()->as_klassOop();
  41.234        }
  41.235        int mods = (m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS);
  41.236 -      sun_dyn_MemberName::set_vmtarget(mname(), vmtarget);
  41.237 -      sun_dyn_MemberName::set_vmindex(mname(),  vmindex);
  41.238 -      sun_dyn_MemberName::set_modifiers(mname(), mods);
  41.239 +      java_lang_invoke_MemberName::set_vmtarget(mname(), vmtarget);
  41.240 +      java_lang_invoke_MemberName::set_vmindex(mname(),  vmindex);
  41.241 +      java_lang_invoke_MemberName::set_modifiers(mname(), mods);
  41.242        DEBUG_ONLY(int junk; klassOop junk2);
  41.243        assert(decode_MemberName(mname(), junk2, junk) == result.resolved_method()(),
  41.244               "properly stored for later decoding");
  41.245 @@ -586,9 +586,9 @@
  41.246        oop vmtarget = m();
  41.247        int vmindex  = methodOopDesc::nonvirtual_vtable_index;
  41.248        int mods     = (m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS);
  41.249 -      sun_dyn_MemberName::set_vmtarget(mname(), vmtarget);
  41.250 -      sun_dyn_MemberName::set_vmindex(mname(),  vmindex);
  41.251 -      sun_dyn_MemberName::set_modifiers(mname(), mods);
  41.252 +      java_lang_invoke_MemberName::set_vmtarget(mname(), vmtarget);
  41.253 +      java_lang_invoke_MemberName::set_vmindex(mname(),  vmindex);
  41.254 +      java_lang_invoke_MemberName::set_modifiers(mname(), mods);
  41.255        DEBUG_ONLY(int junk; klassOop junk2);
  41.256        assert(decode_MemberName(mname(), junk2, junk) == result.resolved_method()(),
  41.257               "properly stored for later decoding");
  41.258 @@ -605,9 +605,9 @@
  41.259        int vmindex  = fd.offset();
  41.260        int mods     = (fd.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS);
  41.261        if (vmindex == VM_INDEX_UNINITIALIZED)  break;  // should not happen
  41.262 -      sun_dyn_MemberName::set_vmtarget(mname(),  vmtarget);
  41.263 -      sun_dyn_MemberName::set_vmindex(mname(),   vmindex);
  41.264 -      sun_dyn_MemberName::set_modifiers(mname(), mods);
  41.265 +      java_lang_invoke_MemberName::set_vmtarget(mname(),  vmtarget);
  41.266 +      java_lang_invoke_MemberName::set_vmindex(mname(),   vmindex);
  41.267 +      java_lang_invoke_MemberName::set_modifiers(mname(), mods);
  41.268        return;
  41.269      }
  41.270    default:
  41.271 @@ -618,11 +618,11 @@
  41.272    if (polymorphic_method_type.not_null()) {
  41.273      // Look on a non-null class loader.
  41.274      Handle cur_class_loader;
  41.275 -    const int nptypes = java_dyn_MethodType::ptype_count(polymorphic_method_type());
  41.276 +    const int nptypes = java_lang_invoke_MethodType::ptype_count(polymorphic_method_type());
  41.277      for (int i = 0; i <= nptypes; i++) {
  41.278        oop type_mirror;
  41.279 -      if (i < nptypes)  type_mirror = java_dyn_MethodType::ptype(polymorphic_method_type(), i);
  41.280 -      else              type_mirror = java_dyn_MethodType::rtype(polymorphic_method_type());
  41.281 +      if (i < nptypes)  type_mirror = java_lang_invoke_MethodType::ptype(polymorphic_method_type(), i);
  41.282 +      else              type_mirror = java_lang_invoke_MethodType::rtype(polymorphic_method_type());
  41.283        klassOop example_type = java_lang_Class::as_klassOop(type_mirror);
  41.284        if (example_type == NULL)  continue;
  41.285        oop class_loader = Klass::cast(example_type)->class_loader();
  41.286 @@ -639,9 +639,9 @@
  41.287        }
  41.288        if (m != NULL) {
  41.289          int mods = (m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS);
  41.290 -        sun_dyn_MemberName::set_vmtarget(mname(),  m);
  41.291 -        sun_dyn_MemberName::set_vmindex(mname(),   m->vtable_index());
  41.292 -        sun_dyn_MemberName::set_modifiers(mname(), mods);
  41.293 +        java_lang_invoke_MemberName::set_vmtarget(mname(),  m);
  41.294 +        java_lang_invoke_MemberName::set_vmindex(mname(),   m->vtable_index());
  41.295 +        java_lang_invoke_MemberName::set_modifiers(mname(), mods);
  41.296          return;
  41.297        }
  41.298      }
  41.299 @@ -653,17 +653,17 @@
  41.300  // Resolving it plants a vmtarget/vmindex in it,
  41.301  // which refers directly to JVM internals.
  41.302  void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
  41.303 -  assert(sun_dyn_MemberName::is_instance(mname()), "");
  41.304 -  oop vmtarget = sun_dyn_MemberName::vmtarget(mname());
  41.305 -  int vmindex  = sun_dyn_MemberName::vmindex(mname());
  41.306 +  assert(java_lang_invoke_MemberName::is_instance(mname()), "");
  41.307 +  oop vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
  41.308 +  int vmindex  = java_lang_invoke_MemberName::vmindex(mname());
  41.309    if (vmtarget == NULL || vmindex == VM_INDEX_UNINITIALIZED) {
  41.310      THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand");
  41.311    }
  41.312  
  41.313 -  bool have_defc = (sun_dyn_MemberName::clazz(mname()) != NULL);
  41.314 -  bool have_name = (sun_dyn_MemberName::name(mname()) != NULL);
  41.315 -  bool have_type = (sun_dyn_MemberName::type(mname()) != NULL);
  41.316 -  int flags      = sun_dyn_MemberName::flags(mname());
  41.317 +  bool have_defc = (java_lang_invoke_MemberName::clazz(mname()) != NULL);
  41.318 +  bool have_name = (java_lang_invoke_MemberName::name(mname()) != NULL);
  41.319 +  bool have_type = (java_lang_invoke_MemberName::type(mname()) != NULL);
  41.320 +  int flags      = java_lang_invoke_MemberName::flags(mname());
  41.321  
  41.322    if (suppress != 0) {
  41.323      if (suppress & _suppress_defc)  have_defc = true;
  41.324 @@ -687,16 +687,16 @@
  41.325          if (receiver_limit != NULL && receiver_limit != defc
  41.326              && Klass::cast(receiver_limit)->is_subtype_of(defc))
  41.327            defc = receiver_limit;
  41.328 -        sun_dyn_MemberName::set_clazz(mname(), Klass::cast(defc)->java_mirror());
  41.329 +        java_lang_invoke_MemberName::set_clazz(mname(), Klass::cast(defc)->java_mirror());
  41.330        }
  41.331        if (!have_name) {
  41.332          //not java_lang_String::create_from_symbol; let's intern member names
  41.333          Handle name = StringTable::intern(m->name(), CHECK);
  41.334 -        sun_dyn_MemberName::set_name(mname(), name());
  41.335 +        java_lang_invoke_MemberName::set_name(mname(), name());
  41.336        }
  41.337        if (!have_type) {
  41.338          Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
  41.339 -        sun_dyn_MemberName::set_type(mname(), type());
  41.340 +        java_lang_invoke_MemberName::set_type(mname(), type());
  41.341        }
  41.342        return;
  41.343      }
  41.344 @@ -711,16 +711,16 @@
  41.345        if (!defc->find_field_from_offset(vmindex, is_static, &fd))
  41.346          break;                  // cannot expand
  41.347        if (!have_defc) {
  41.348 -        sun_dyn_MemberName::set_clazz(mname(), defc->java_mirror());
  41.349 +        java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
  41.350        }
  41.351        if (!have_name) {
  41.352          //not java_lang_String::create_from_symbol; let's intern member names
  41.353          Handle name = StringTable::intern(fd.name(), CHECK);
  41.354 -        sun_dyn_MemberName::set_name(mname(), name());
  41.355 +        java_lang_invoke_MemberName::set_name(mname(), name());
  41.356        }
  41.357        if (!have_type) {
  41.358          Handle type = java_lang_String::create_from_symbol(fd.signature(), CHECK);
  41.359 -        sun_dyn_MemberName::set_type(mname(), type());
  41.360 +        java_lang_invoke_MemberName::set_type(mname(), type());
  41.361        }
  41.362        return;
  41.363      }
  41.364 @@ -775,7 +775,7 @@
  41.365          --rskip;
  41.366        } else if (rfill < rlimit) {
  41.367          oop result = results->obj_at(rfill++);
  41.368 -        if (!sun_dyn_MemberName::is_instance(result))
  41.369 +        if (!java_lang_invoke_MemberName::is_instance(result))
  41.370            return -99;  // caller bug!
  41.371          MethodHandles::init_MemberName(result, st.klass()->as_klassOop(), st.access_flags(), st.offset());
  41.372        } else if (++overflow >= overflow_limit) {
  41.373 @@ -823,7 +823,7 @@
  41.374          --rskip;
  41.375        } else if (rfill < rlimit) {
  41.376          oop result = results->obj_at(rfill++);
  41.377 -        if (!sun_dyn_MemberName::is_instance(result))
  41.378 +        if (!java_lang_invoke_MemberName::is_instance(result))
  41.379            return -99;  // caller bug!
  41.380          MethodHandles::init_MemberName(result, m, true);
  41.381        } else if (++overflow >= overflow_limit) {
  41.382 @@ -857,9 +857,9 @@
  41.383  // Sanitize out methodOops, klassOops, and any other non-Java data.
  41.384  // This is for debugging and reflection.
  41.385  oop MethodHandles::encode_target(Handle mh, int format, TRAPS) {
  41.386 -  assert(java_dyn_MethodHandle::is_instance(mh()), "must be a MH");
  41.387 +  assert(java_lang_invoke_MethodHandle::is_instance(mh()), "must be a MH");
  41.388    if (format == ETF_HANDLE_OR_METHOD_NAME) {
  41.389 -    oop target = java_dyn_MethodHandle::vmtarget(mh());
  41.390 +    oop target = java_lang_invoke_MethodHandle::vmtarget(mh());
  41.391      if (target == NULL) {
  41.392        return NULL;                // unformed MH
  41.393      }
  41.394 @@ -874,10 +874,10 @@
  41.395        if (target->klass() == SystemDictionary::DirectMethodHandle_klass()) {
  41.396          return target;
  41.397        }
  41.398 -      if (!java_dyn_MethodHandle::is_instance(target)){
  41.399 +      if (!java_lang_invoke_MethodHandle::is_instance(target)){
  41.400          return NULL;                // unformed MH
  41.401        }
  41.402 -      target = java_dyn_MethodHandle::vmtarget(target);
  41.403 +      target = java_lang_invoke_MethodHandle::vmtarget(target);
  41.404      }
  41.405    }
  41.406    // cases of metadata in MH.vmtarget:
  41.407 @@ -904,7 +904,7 @@
  41.408        instanceKlassHandle mname_klass(THREAD, SystemDictionary::MemberName_klass());
  41.409        mname_klass->initialize(CHECK_NULL);
  41.410        Handle mname = mname_klass->allocate_instance_handle(CHECK_NULL);
  41.411 -      sun_dyn_MemberName::set_vmindex(mname(), VM_INDEX_UNINITIALIZED);
  41.412 +      java_lang_invoke_MemberName::set_vmindex(mname(), VM_INDEX_UNINITIALIZED);
  41.413        bool do_dispatch = ((decode_flags & MethodHandles::_dmf_does_dispatch) != 0);
  41.414        init_MemberName(mname(), m, do_dispatch);
  41.415        expand_MemberName(mname, 0, CHECK_NULL);
  41.416 @@ -923,6 +923,7 @@
  41.417    "java/lang/Null",
  41.418    //"java/lang/Nothing",
  41.419    "sun/dyn/empty/Empty",
  41.420 +  "sun/invoke/empty/Empty",
  41.421    NULL
  41.422  };
  41.423  
  41.424 @@ -1025,7 +1026,7 @@
  41.425                                              int first_ptype_pos,
  41.426                                              KlassHandle insert_ptype,
  41.427                                              TRAPS) {
  41.428 -  objArrayHandle ptypes(THREAD, java_dyn_MethodType::ptypes(mtype()));
  41.429 +  objArrayHandle ptypes(THREAD, java_lang_invoke_MethodType::ptypes(mtype()));
  41.430    int pnum = first_ptype_pos;
  41.431    int pmax = ptypes->length();
  41.432    int mnum = 0;                 // method argument
  41.433 @@ -1036,7 +1037,7 @@
  41.434      if (ss.at_return_type()) {
  41.435        if (pnum != pmax)
  41.436          { err = "too many arguments"; break; }
  41.437 -      ptype_oop = java_dyn_MethodType::rtype(mtype());
  41.438 +      ptype_oop = java_lang_invoke_MethodType::rtype(mtype());
  41.439      } else {
  41.440        if (pnum >= pmax)
  41.441          { err = "not enough arguments"; break; }
  41.442 @@ -1111,7 +1112,7 @@
  41.443    }
  41.444  
  41.445    if (m_needs_receiver && err == NULL) {
  41.446 -    objArrayOop ptypes = java_dyn_MethodType::ptypes(mtype());
  41.447 +    objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(mtype());
  41.448      if (ptypes->length() < first_ptype_pos)
  41.449        { err = "receiver argument is missing"; goto die; }
  41.450      if (has_bound_recv)
  41.451 @@ -1131,15 +1132,15 @@
  41.452  
  41.453  void MethodHandles::verify_vmslots(Handle mh, TRAPS) {
  41.454    // Verify vmslots.
  41.455 -  int check_slots = argument_slot_count(java_dyn_MethodHandle::type(mh()));
  41.456 -  if (java_dyn_MethodHandle::vmslots(mh()) != check_slots) {
  41.457 +  int check_slots = argument_slot_count(java_lang_invoke_MethodHandle::type(mh()));
  41.458 +  if (java_lang_invoke_MethodHandle::vmslots(mh()) != check_slots) {
  41.459      THROW_MSG(vmSymbols::java_lang_InternalError(), "bad vmslots in BMH");
  41.460    }
  41.461  }
  41.462  
  41.463  void MethodHandles::verify_vmargslot(Handle mh, int argnum, int argslot, TRAPS) {
  41.464    // Verify that argslot points at the given argnum.
  41.465 -  int check_slot = argument_slot(java_dyn_MethodHandle::type(mh()), argnum);
  41.466 +  int check_slot = argument_slot(java_lang_invoke_MethodHandle::type(mh()), argnum);
  41.467    if (argslot != check_slot || argslot < 0) {
  41.468      const char* fmt = "for argnum of %d, vmargslot is %d, should be %d";
  41.469      size_t msglen = strlen(fmt) + 3*11 + 1;
  41.470 @@ -1160,8 +1161,8 @@
  41.471                                                      int delete_argnum,
  41.472                                                      oop dst_mtype, int dst_beg, int dst_end,
  41.473                                                      bool raw) {
  41.474 -  objArrayOop src_ptypes = java_dyn_MethodType::ptypes(src_mtype);
  41.475 -  objArrayOop dst_ptypes = java_dyn_MethodType::ptypes(dst_mtype);
  41.476 +  objArrayOop src_ptypes = java_lang_invoke_MethodType::ptypes(src_mtype);
  41.477 +  objArrayOop dst_ptypes = java_lang_invoke_MethodType::ptypes(dst_mtype);
  41.478  
  41.479    int src_max = src_ptypes->length();
  41.480    int dst_max = dst_ptypes->length();
  41.481 @@ -1224,8 +1225,8 @@
  41.482    }
  41.483  
  41.484    // Now compare return types also.
  41.485 -  oop src_rtype = java_dyn_MethodType::rtype(src_mtype);
  41.486 -  oop dst_rtype = java_dyn_MethodType::rtype(dst_mtype);
  41.487 +  oop src_rtype = java_lang_invoke_MethodType::rtype(src_mtype);
  41.488 +  oop dst_rtype = java_lang_invoke_MethodType::rtype(dst_mtype);
  41.489    if (src_rtype != dst_rtype) {
  41.490      err = check_return_type_change(dst_rtype, src_rtype, raw); // note reversal!
  41.491      if (err != NULL)  return err;
  41.492 @@ -1314,7 +1315,7 @@
  41.493  // then return a negative number.  Otherwise, the result
  41.494  // is in the range [0..vmslots] inclusive.
  41.495  int MethodHandles::argument_slot(oop method_type, int arg) {
  41.496 -  objArrayOop ptypes = java_dyn_MethodType::ptypes(method_type);
  41.497 +  objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(method_type);
  41.498    int argslot = 0;
  41.499    int len = ptypes->length();
  41.500    if (arg < -1 || arg >= len)  return -99;
  41.501 @@ -1328,7 +1329,7 @@
  41.502  
  41.503  // Given a slot number, return the argument number.
  41.504  int MethodHandles::argument_slot_to_argnum(oop method_type, int query_argslot) {
  41.505 -  objArrayOop ptypes = java_dyn_MethodType::ptypes(method_type);
  41.506 +  objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(method_type);
  41.507    int argslot = 0;
  41.508    int len = ptypes->length();
  41.509    for (int i = len-1; i >= 0; i--) {
  41.510 @@ -1394,11 +1395,11 @@
  41.511  
  41.512  void MethodHandles::verify_DirectMethodHandle(Handle mh, methodHandle m, TRAPS) {
  41.513    // Verify type.
  41.514 -  Handle mtype(THREAD, java_dyn_MethodHandle::type(mh()));
  41.515 +  Handle mtype(THREAD, java_lang_invoke_MethodHandle::type(mh()));
  41.516    verify_method_type(m, mtype, false, KlassHandle(), CHECK);
  41.517  
  41.518    // Verify vmslots.
  41.519 -  if (java_dyn_MethodHandle::vmslots(mh()) != m->size_of_parameters()) {
  41.520 +  if (java_lang_invoke_MethodHandle::vmslots(mh()) != m->size_of_parameters()) {
  41.521      THROW_MSG(vmSymbols::java_lang_InternalError(), "bad vmslots in DMH");
  41.522    }
  41.523  }
  41.524 @@ -1410,7 +1411,7 @@
  41.525      THROW(vmSymbols::java_lang_InternalError());
  41.526    }
  41.527  
  41.528 -  java_dyn_MethodHandle::init_vmslots(mh());
  41.529 +  java_lang_invoke_MethodHandle::init_vmslots(mh());
  41.530  
  41.531    if (VerifyMethodHandles) {
  41.532      // The privileged code which invokes this routine should not make
  41.533 @@ -1470,8 +1471,8 @@
  41.534  
  41.535    if (me == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
  41.536  
  41.537 -  sun_dyn_DirectMethodHandle::set_vmtarget(mh(), vmtarget);
  41.538 -  sun_dyn_DirectMethodHandle::set_vmindex(mh(),  vmindex);
  41.539 +  java_lang_invoke_DirectMethodHandle::set_vmtarget(mh(), vmtarget);
  41.540 +  java_lang_invoke_DirectMethodHandle::set_vmindex(mh(),  vmindex);
  41.541    DEBUG_ONLY(int flags; klassOop rlimit);
  41.542    assert(MethodHandles::decode_method(mh(), rlimit, flags) == m(),
  41.543           "properly stored for later decoding");
  41.544 @@ -1482,15 +1483,15 @@
  41.545    assert(decode_MethodHandle_stack_pushes(mh()) == 0, "DMH does not move stack");
  41.546  
  41.547    // Done!
  41.548 -  java_dyn_MethodHandle::set_vmentry(mh(), me);
  41.549 +  java_lang_invoke_MethodHandle::set_vmentry(mh(), me);
  41.550  }
  41.551  
  41.552  void MethodHandles::verify_BoundMethodHandle_with_receiver(Handle mh,
  41.553                                                             methodHandle m,
  41.554                                                             TRAPS) {
  41.555    // Verify type.
  41.556 -  oop receiver = sun_dyn_BoundMethodHandle::argument(mh());
  41.557 -  Handle mtype(THREAD, java_dyn_MethodHandle::type(mh()));
  41.558 +  oop receiver = java_lang_invoke_BoundMethodHandle::argument(mh());
  41.559 +  Handle mtype(THREAD, java_lang_invoke_MethodHandle::type(mh()));
  41.560    KlassHandle bound_recv_type;
  41.561    if (receiver != NULL)  bound_recv_type = KlassHandle(THREAD, receiver->klass());
  41.562    verify_method_type(m, mtype, true, bound_recv_type, CHECK);
  41.563 @@ -1498,11 +1499,11 @@
  41.564    int receiver_pos = m->size_of_parameters() - 1;
  41.565  
  41.566    // Verify MH.vmargslot, which should point at the bound receiver.
  41.567 -  verify_vmargslot(mh, -1, sun_dyn_BoundMethodHandle::vmargslot(mh()), CHECK);
  41.568 +  verify_vmargslot(mh, -1, java_lang_invoke_BoundMethodHandle::vmargslot(mh()), CHECK);
  41.569    //verify_vmslots(mh, CHECK);
  41.570  
  41.571    // Verify vmslots.
  41.572 -  if (java_dyn_MethodHandle::vmslots(mh()) != receiver_pos) {
  41.573 +  if (java_lang_invoke_MethodHandle::vmslots(mh()) != receiver_pos) {
  41.574      THROW_MSG(vmSymbols::java_lang_InternalError(), "bad vmslots in BMH (receiver)");
  41.575    }
  41.576  }
  41.577 @@ -1520,7 +1521,7 @@
  41.578  
  41.579    KlassHandle receiver_klass;
  41.580    {
  41.581 -    oop receiver_oop = sun_dyn_BoundMethodHandle::argument(mh());
  41.582 +    oop receiver_oop = java_lang_invoke_BoundMethodHandle::argument(mh());
  41.583      if (receiver_oop != NULL)
  41.584        receiver_klass = KlassHandle(THREAD, receiver_oop->klass());
  41.585    }
  41.586 @@ -1531,31 +1532,31 @@
  41.587    if (m.is_null())      { THROW(vmSymbols::java_lang_InternalError()); }
  41.588    if (m->is_abstract()) { THROW(vmSymbols::java_lang_AbstractMethodError()); }
  41.589  
  41.590 -  java_dyn_MethodHandle::init_vmslots(mh());
  41.591 +  java_lang_invoke_MethodHandle::init_vmslots(mh());
  41.592  
  41.593    if (VerifyMethodHandles) {
  41.594      verify_BoundMethodHandle_with_receiver(mh, m, CHECK);
  41.595    }
  41.596  
  41.597 -  sun_dyn_BoundMethodHandle::set_vmtarget(mh(), m());
  41.598 +  java_lang_invoke_BoundMethodHandle::set_vmtarget(mh(), m());
  41.599  
  41.600    DEBUG_ONLY(int junk; klassOop junk2);
  41.601    assert(MethodHandles::decode_method(mh(), junk2, junk) == m(), "properly stored for later decoding");
  41.602    assert(decode_MethodHandle_stack_pushes(mh()) == 1, "BMH pushes one stack slot");
  41.603  
  41.604    // Done!
  41.605 -  java_dyn_MethodHandle::set_vmentry(mh(), MethodHandles::entry(MethodHandles::_bound_ref_direct_mh));
  41.606 +  java_lang_invoke_MethodHandle::set_vmentry(mh(), MethodHandles::entry(MethodHandles::_bound_ref_direct_mh));
  41.607  }
  41.608  
  41.609  void MethodHandles::verify_BoundMethodHandle(Handle mh, Handle target, int argnum,
  41.610                                               bool direct_to_method, TRAPS) {
  41.611    Handle ptype_handle(THREAD,
  41.612 -                           java_dyn_MethodType::ptype(java_dyn_MethodHandle::type(target()), argnum));
  41.613 +                           java_lang_invoke_MethodType::ptype(java_lang_invoke_MethodHandle::type(target()), argnum));
  41.614    KlassHandle ptype_klass;
  41.615    BasicType ptype = java_lang_Class::as_BasicType(ptype_handle(), &ptype_klass);
  41.616    int slots_pushed = type2size[ptype];
  41.617  
  41.618 -  oop argument = sun_dyn_BoundMethodHandle::argument(mh());
  41.619 +  oop argument = java_lang_invoke_BoundMethodHandle::argument(mh());
  41.620  
  41.621    const char* err = NULL;
  41.622  
  41.623 @@ -1623,9 +1624,9 @@
  41.624  
  41.625    if (err == NULL) {
  41.626      // Verify the rest of the method type.
  41.627 -    err = check_method_type_insertion(java_dyn_MethodHandle::type(mh()),
  41.628 +    err = check_method_type_insertion(java_lang_invoke_MethodHandle::type(mh()),
  41.629                                        argnum, ptype_handle(),
  41.630 -                                      java_dyn_MethodHandle::type(target()));
  41.631 +                                      java_lang_invoke_MethodHandle::type(target()));
  41.632    }
  41.633  
  41.634    if (err != NULL) {
  41.635 @@ -1635,20 +1636,20 @@
  41.636  
  41.637  void MethodHandles::init_BoundMethodHandle(Handle mh, Handle target, int argnum, TRAPS) {
  41.638    // Check arguments.
  41.639 -  if (mh.is_null() || target.is_null() || !java_dyn_MethodHandle::is_instance(target())) {
  41.640 +  if (mh.is_null() || target.is_null() || !java_lang_invoke_MethodHandle::is_instance(target())) {
  41.641      THROW(vmSymbols::java_lang_InternalError());
  41.642    }
  41.643  
  41.644 -  java_dyn_MethodHandle::init_vmslots(mh());
  41.645 +  java_lang_invoke_MethodHandle::init_vmslots(mh());
  41.646  
  41.647    if (VerifyMethodHandles) {
  41.648      int insert_after = argnum - 1;
  41.649 -    verify_vmargslot(mh, insert_after, sun_dyn_BoundMethodHandle::vmargslot(mh()), CHECK);
  41.650 +    verify_vmargslot(mh, insert_after, java_lang_invoke_BoundMethodHandle::vmargslot(mh()), CHECK);
  41.651      verify_vmslots(mh, CHECK);
  41.652    }
  41.653  
  41.654    // Get bound type and required slots.
  41.655 -  oop ptype_oop = java_dyn_MethodType::ptype(java_dyn_MethodHandle::type(target()), argnum);
  41.656 +  oop ptype_oop = java_lang_invoke_MethodType::ptype(java_lang_invoke_MethodHandle::type(target()), argnum);
  41.657    BasicType ptype = java_lang_Class::as_BasicType(ptype_oop);
  41.658    int slots_pushed = type2size[ptype];
  41.659  
  41.660 @@ -1659,12 +1660,12 @@
  41.661    bool direct_to_method = false;
  41.662    if (OptimizeMethodHandles &&
  41.663        target->klass() == SystemDictionary::DirectMethodHandle_klass() &&
  41.664 -      (argnum == 0 || sun_dyn_DirectMethodHandle::vmindex(target()) < 0)) {
  41.665 +      (argnum == 0 || java_lang_invoke_DirectMethodHandle::vmindex(target()) < 0)) {
  41.666      int decode_flags = 0; klassOop receiver_limit_oop = NULL;
  41.667      methodHandle m(THREAD, decode_method(target(), receiver_limit_oop, decode_flags));
  41.668      if (m.is_null()) { THROW_MSG(vmSymbols::java_lang_InternalError(), "DMH failed to decode"); }
  41.669      DEBUG_ONLY(int m_vmslots = m->size_of_parameters() - slots_pushed); // pos. of 1st arg.
  41.670 -    assert(sun_dyn_BoundMethodHandle::vmslots(mh()) == m_vmslots, "type w/ m sig");
  41.671 +    assert(java_lang_invoke_BoundMethodHandle::vmslots(mh()) == m_vmslots, "type w/ m sig");
  41.672      if (argnum == 0 && (decode_flags & _dmf_has_receiver) != 0) {
  41.673        KlassHandle receiver_limit(THREAD, receiver_limit_oop);
  41.674        init_BoundMethodHandle_with_receiver(mh, m,
  41.675 @@ -1677,11 +1678,11 @@
  41.676      // to bind another argument and still invoke the methodOop directly.
  41.677      if (!(decode_flags & _dmf_does_dispatch)) {
  41.678        direct_to_method = true;
  41.679 -      sun_dyn_BoundMethodHandle::set_vmtarget(mh(), m());
  41.680 +      java_lang_invoke_BoundMethodHandle::set_vmtarget(mh(), m());
  41.681      }
  41.682    }
  41.683    if (!direct_to_method)
  41.684 -    sun_dyn_BoundMethodHandle::set_vmtarget(mh(), target());
  41.685 +    java_lang_invoke_BoundMethodHandle::set_vmtarget(mh(), target());
  41.686  
  41.687    if (VerifyMethodHandles) {
  41.688      verify_BoundMethodHandle(mh, target, argnum, direct_to_method, CHECK);
  41.689 @@ -1703,7 +1704,7 @@
  41.690    }
  41.691  
  41.692    // Done!
  41.693 -  java_dyn_MethodHandle::set_vmentry(mh(), me);
  41.694 +  java_lang_invoke_MethodHandle::set_vmentry(mh(), me);
  41.695  }
  41.696  
  41.697  static void throw_InternalError_for_bad_conversion(int conversion, const char* err, TRAPS) {
  41.698 @@ -1713,8 +1714,8 @@
  41.699  }
  41.700  
  41.701  void MethodHandles::verify_AdapterMethodHandle(Handle mh, int argnum, TRAPS) {
  41.702 -  jint conversion = sun_dyn_AdapterMethodHandle::conversion(mh());
  41.703 -  int  argslot    = sun_dyn_AdapterMethodHandle::vmargslot(mh());
  41.704 +  jint conversion = java_lang_invoke_AdapterMethodHandle::conversion(mh());
  41.705 +  int  argslot    = java_lang_invoke_AdapterMethodHandle::vmargslot(mh());
  41.706  
  41.707    verify_vmargslot(mh, argnum, argslot, CHECK);
  41.708    verify_vmslots(mh, CHECK);
  41.709 @@ -1731,10 +1732,10 @@
  41.710    BasicType dest = adapter_conversion_dest_type(conversion);
  41.711    int vminfo     = adapter_conversion_vminfo(conversion); // should be zero
  41.712  
  41.713 -  Handle argument(THREAD,  sun_dyn_AdapterMethodHandle::argument(mh()));
  41.714 -  Handle target(THREAD,    sun_dyn_AdapterMethodHandle::vmtarget(mh()));
  41.715 -  Handle src_mtype(THREAD, java_dyn_MethodHandle::type(mh()));
  41.716 -  Handle dst_mtype(THREAD, java_dyn_MethodHandle::type(target()));
  41.717 +  Handle argument(THREAD,  java_lang_invoke_AdapterMethodHandle::argument(mh()));
  41.718 +  Handle target(THREAD,    java_lang_invoke_AdapterMethodHandle::vmtarget(mh()));
  41.719 +  Handle src_mtype(THREAD, java_lang_invoke_MethodHandle::type(mh()));
  41.720 +  Handle dst_mtype(THREAD, java_lang_invoke_MethodHandle::type(target()));
  41.721  
  41.722    const char* err = NULL;
  41.723  
  41.724 @@ -1760,7 +1761,7 @@
  41.725        break;
  41.726      case _adapter_flyby:
  41.727      case _adapter_ricochet:
  41.728 -      if (!java_dyn_MethodHandle::is_instance(argument()))
  41.729 +      if (!java_lang_invoke_MethodHandle::is_instance(argument()))
  41.730          { err = "MethodHandle adapter argument required"; break; }
  41.731        break;
  41.732      default:
  41.733 @@ -1806,9 +1807,9 @@
  41.734            err = "adapter requires src/dest conversion subfields for swap"; break;
  41.735          }
  41.736          int swap_size = type2size[src];
  41.737 -        oop src_mtype  = sun_dyn_AdapterMethodHandle::type(mh());
  41.738 -        oop dest_mtype = sun_dyn_AdapterMethodHandle::type(target());
  41.739 -        int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(target());
  41.740 +        oop src_mtype  = java_lang_invoke_AdapterMethodHandle::type(mh());
  41.741 +        oop dest_mtype = java_lang_invoke_AdapterMethodHandle::type(target());
  41.742 +        int slot_limit = java_lang_invoke_AdapterMethodHandle::vmslots(target());
  41.743          int src_slot   = argslot;
  41.744          int dest_slot  = vminfo;
  41.745          bool rotate_up = (src_slot > dest_slot); // upward rotation
  41.746 @@ -1821,8 +1822,8 @@
  41.747          } else if (ek == _adapter_swap_args && !(src_slot > dest_slot)) {
  41.748            err = "source of swap must be deeper in stack";
  41.749          } else if (ek == _adapter_swap_args) {
  41.750 -          err = check_argument_type_change(java_dyn_MethodType::ptype(src_mtype, dest_arg),
  41.751 -                                           java_dyn_MethodType::ptype(dest_mtype, src_arg),
  41.752 +          err = check_argument_type_change(java_lang_invoke_MethodType::ptype(src_mtype, dest_arg),
  41.753 +                                           java_lang_invoke_MethodType::ptype(dest_mtype, src_arg),
  41.754                                             dest_arg);
  41.755          } else if (ek == _adapter_rot_args) {
  41.756            if (rotate_up) {
  41.757 @@ -1830,8 +1831,8 @@
  41.758              // rotate up: [dest_slot..src_slot-ss] --> [dest_slot+ss..src_slot]
  41.759              // that is:   [src_arg+1..dest_arg] --> [src_arg..dest_arg-1]
  41.760              for (int i = src_arg+1; i <= dest_arg && err == NULL; i++) {
  41.761 -              err = check_argument_type_change(java_dyn_MethodType::ptype(src_mtype, i),
  41.762 -                                               java_dyn_MethodType::ptype(dest_mtype, i-1),
  41.763 +              err = check_argument_type_change(java_lang_invoke_MethodType::ptype(src_mtype, i),
  41.764 +                                               java_lang_invoke_MethodType::ptype(dest_mtype, i-1),
  41.765                                                 i);
  41.766              }
  41.767            } else { // rotate down
  41.768 @@ -1839,15 +1840,15 @@
  41.769              // rotate down: [src_slot+ss..dest_slot] --> [src_slot..dest_slot-ss]
  41.770              // that is:     [dest_arg..src_arg-1] --> [dst_arg+1..src_arg]
  41.771              for (int i = dest_arg; i <= src_arg-1 && err == NULL; i++) {
  41.772 -              err = check_argument_type_change(java_dyn_MethodType::ptype(src_mtype, i),
  41.773 -                                               java_dyn_MethodType::ptype(dest_mtype, i+1),
  41.774 +              err = check_argument_type_change(java_lang_invoke_MethodType::ptype(src_mtype, i),
  41.775 +                                               java_lang_invoke_MethodType::ptype(dest_mtype, i+1),
  41.776                                                 i);
  41.777              }
  41.778            }
  41.779          }
  41.780          if (err == NULL)
  41.781 -          err = check_argument_type_change(java_dyn_MethodType::ptype(src_mtype, src_arg),
  41.782 -                                           java_dyn_MethodType::ptype(dest_mtype, dest_arg),
  41.783 +          err = check_argument_type_change(java_lang_invoke_MethodType::ptype(src_mtype, src_arg),
  41.784 +                                           java_lang_invoke_MethodType::ptype(dest_mtype, dest_arg),
  41.785                                             src_arg);
  41.786        }
  41.787        break;
  41.788 @@ -1918,8 +1919,8 @@
  41.789    if (err == NULL) {
  41.790      // Make sure this adapter does not push too deeply.
  41.791      int slots_pushed = stack_move / stack_move_unit();
  41.792 -    int this_vmslots = java_dyn_MethodHandle::vmslots(mh());
  41.793 -    int target_vmslots = java_dyn_MethodHandle::vmslots(target());
  41.794 +    int this_vmslots = java_lang_invoke_MethodHandle::vmslots(mh());
  41.795 +    int target_vmslots = java_lang_invoke_MethodHandle::vmslots(target());
  41.796      if (slots_pushed != (target_vmslots - this_vmslots)) {
  41.797        err = "stack_move inconsistent with previous and current MethodType vmslots";
  41.798      } else if (slots_pushed > 0)  {
  41.799 @@ -1961,7 +1962,7 @@
  41.800      case _adapter_check_cast:
  41.801        {
  41.802          // The actual value being checked must be a reference:
  41.803 -        err = check_argument_type_change(java_dyn_MethodType::ptype(src_mtype(), argnum),
  41.804 +        err = check_argument_type_change(java_lang_invoke_MethodType::ptype(src_mtype(), argnum),
  41.805                                           object_java_mirror(), argnum);
  41.806          if (err != NULL)  break;
  41.807  
  41.808 @@ -1985,9 +1986,9 @@
  41.809  }
  41.810  
  41.811  void MethodHandles::init_AdapterMethodHandle(Handle mh, Handle target, int argnum, TRAPS) {
  41.812 -  oop  argument   = sun_dyn_AdapterMethodHandle::argument(mh());
  41.813 -  int  argslot    = sun_dyn_AdapterMethodHandle::vmargslot(mh());
  41.814 -  jint conversion = sun_dyn_AdapterMethodHandle::conversion(mh());
  41.815 +  oop  argument   = java_lang_invoke_AdapterMethodHandle::argument(mh());
  41.816 +  int  argslot    = java_lang_invoke_AdapterMethodHandle::vmargslot(mh());
  41.817 +  jint conversion = java_lang_invoke_AdapterMethodHandle::conversion(mh());
  41.818    jint conv_op    = adapter_conversion_op(conversion);
  41.819  
  41.820    // adjust the adapter code to the internal EntryKind enumeration:
  41.821 @@ -1995,11 +1996,11 @@
  41.822    EntryKind ek_opt  = ek_orig;  // may be optimized
  41.823  
  41.824    // Finalize the vmtarget field (Java initialized it to null).
  41.825 -  if (!java_dyn_MethodHandle::is_instance(target())) {
  41.826 +  if (!java_lang_invoke_MethodHandle::is_instance(target())) {
  41.827      throw_InternalError_for_bad_conversion(conversion, "bad target", THREAD);
  41.828      return;
  41.829    }
  41.830 -  sun_dyn_AdapterMethodHandle::set_vmtarget(mh(), target());
  41.831 +  java_lang_invoke_AdapterMethodHandle::set_vmtarget(mh(), target());
  41.832  
  41.833    if (VerifyMethodHandles) {
  41.834      verify_AdapterMethodHandle(mh, argnum, CHECK);
  41.835 @@ -2083,7 +2084,7 @@
  41.836    case _adapter_rot_args:
  41.837      {
  41.838        int swap_slots = type2size[src];
  41.839 -      int slot_limit = sun_dyn_AdapterMethodHandle::vmslots(mh());
  41.840 +      int slot_limit = java_lang_invoke_AdapterMethodHandle::vmslots(mh());
  41.841        int src_slot   = argslot;
  41.842        int dest_slot  = vminfo;
  41.843        int rotate     = (ek_orig == _adapter_swap_args) ? 0 : (src_slot > dest_slot) ? 1 : -1;
  41.844 @@ -2147,10 +2148,10 @@
  41.845    jint new_conversion = adapter_conversion(conv_op, src, dest, stack_move, vminfo);
  41.846  
  41.847    // Finalize the conversion field.  (Note that it is final to Java code.)
  41.848 -  sun_dyn_AdapterMethodHandle::set_conversion(mh(), new_conversion);
  41.849 +  java_lang_invoke_AdapterMethodHandle::set_conversion(mh(), new_conversion);
  41.850  
  41.851    // Done!
  41.852 -  java_dyn_MethodHandle::set_vmentry(mh(), entry(ek_opt));
  41.853 +  java_lang_invoke_MethodHandle::set_vmentry(mh(), entry(ek_opt));
  41.854  
  41.855    // There should be enough memory barriers on exit from native methods
  41.856    // to ensure that the MH is fully initialized to all threads before
  41.857 @@ -2158,7 +2159,7 @@
  41.858  }
  41.859  
  41.860  //
  41.861 -// Here are the native methods on sun.dyn.MethodHandleImpl.
  41.862 +// Here are the native methods on sun.invoke.MethodHandleImpl.
  41.863  // They are the private interface between this JVM and the HotSpot-specific
  41.864  // Java code that implements JSR 292 method handles.
  41.865  //
  41.866 @@ -2168,7 +2169,7 @@
  41.867  
  41.868  // direct method handles for invokestatic or invokespecial
  41.869  // void init(DirectMethodHandle self, MemberName ref, boolean doDispatch, Class<?> caller);
  41.870 -JVM_ENTRY(void, MHI_init_DMH(JNIEnv *env, jobject igcls, jobject mh_jh,
  41.871 +JVM_ENTRY(void, MHN_init_DMH(JNIEnv *env, jobject igcls, jobject mh_jh,
  41.872                               jobject target_jh, jboolean do_dispatch, jobject caller_jh)) {
  41.873    ResourceMark rm;              // for error messages
  41.874  
  41.875 @@ -2177,13 +2178,13 @@
  41.876    Handle mh(THREAD, JNIHandles::resolve_non_null(mh_jh));
  41.877  
  41.878    // Early returns out of this method leave the DMH in an unfinished state.
  41.879 -  assert(java_dyn_MethodHandle::vmentry(mh()) == NULL, "must be safely null");
  41.880 +  assert(java_lang_invoke_MethodHandle::vmentry(mh()) == NULL, "must be safely null");
  41.881  
  41.882    // which method are we really talking about?
  41.883    if (target_jh == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
  41.884    oop target_oop = JNIHandles::resolve_non_null(target_jh);
  41.885 -  if (sun_dyn_MemberName::is_instance(target_oop) &&
  41.886 -      sun_dyn_MemberName::vmindex(target_oop) == VM_INDEX_UNINITIALIZED) {
  41.887 +  if (java_lang_invoke_MemberName::is_instance(target_oop) &&
  41.888 +      java_lang_invoke_MemberName::vmindex(target_oop) == VM_INDEX_UNINITIALIZED) {
  41.889      Handle mname(THREAD, target_oop);
  41.890      MethodHandles::resolve_MemberName(mname, CHECK);
  41.891      target_oop = mname(); // in case of GC
  41.892 @@ -2232,7 +2233,7 @@
  41.893  JVM_END
  41.894  
  41.895  // bound method handles
  41.896 -JVM_ENTRY(void, MHI_init_BMH(JNIEnv *env, jobject igcls, jobject mh_jh,
  41.897 +JVM_ENTRY(void, MHN_init_BMH(JNIEnv *env, jobject igcls, jobject mh_jh,
  41.898                               jobject target_jh, int argnum)) {
  41.899    ResourceMark rm;              // for error messages
  41.900  
  41.901 @@ -2241,12 +2242,12 @@
  41.902    Handle mh(THREAD, JNIHandles::resolve_non_null(mh_jh));
  41.903  
  41.904    // Early returns out of this method leave the BMH in an unfinished state.
  41.905 -  assert(java_dyn_MethodHandle::vmentry(mh()) == NULL, "must be safely null");
  41.906 +  assert(java_lang_invoke_MethodHandle::vmentry(mh()) == NULL, "must be safely null");
  41.907  
  41.908    if (target_jh == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
  41.909    Handle target(THREAD, JNIHandles::resolve_non_null(target_jh));
  41.910  
  41.911 -  if (!java_dyn_MethodHandle::is_instance(target())) {
  41.912 +  if (!java_lang_invoke_MethodHandle::is_instance(target())) {
  41.913      // Target object is a reflective method.  (%%% Do we need this alternate path?)
  41.914      Untested("init_BMH of non-MH");
  41.915      if (argnum != 0) { THROW(vmSymbols::java_lang_InternalError()); }
  41.916 @@ -2269,7 +2270,7 @@
  41.917  JVM_END
  41.918  
  41.919  // adapter method handles
  41.920 -JVM_ENTRY(void, MHI_init_AMH(JNIEnv *env, jobject igcls, jobject mh_jh,
  41.921 +JVM_ENTRY(void, MHN_init_AMH(JNIEnv *env, jobject igcls, jobject mh_jh,
  41.922                               jobject target_jh, int argnum)) {
  41.923    // This is the guy we are initializing:
  41.924    if (mh_jh == NULL || target_jh == NULL) {
  41.925 @@ -2279,14 +2280,14 @@
  41.926    Handle target(THREAD, JNIHandles::resolve_non_null(target_jh));
  41.927  
  41.928    // Early returns out of this method leave the AMH in an unfinished state.
  41.929 -  assert(java_dyn_MethodHandle::vmentry(mh()) == NULL, "must be safely null");
  41.930 +  assert(java_lang_invoke_MethodHandle::vmentry(mh()) == NULL, "must be safely null");
  41.931  
  41.932    MethodHandles::init_AdapterMethodHandle(mh, target, argnum, CHECK);
  41.933  }
  41.934  JVM_END
  41.935  
  41.936  // method type forms
  41.937 -JVM_ENTRY(void, MHI_init_MT(JNIEnv *env, jobject igcls, jobject erased_jh)) {
  41.938 +JVM_ENTRY(void, MHN_init_MT(JNIEnv *env, jobject igcls, jobject erased_jh)) {
  41.939    if (erased_jh == NULL)  return;
  41.940    if (TraceMethodHandles) {
  41.941      tty->print("creating MethodType form ");
  41.942 @@ -2307,9 +2308,9 @@
  41.943  JVM_END
  41.944  
  41.945  // debugging and reflection
  41.946 -JVM_ENTRY(jobject, MHI_getTarget(JNIEnv *env, jobject igcls, jobject mh_jh, jint format)) {
  41.947 +JVM_ENTRY(jobject, MHN_getTarget(JNIEnv *env, jobject igcls, jobject mh_jh, jint format)) {
  41.948    Handle mh(THREAD, JNIHandles::resolve(mh_jh));
  41.949 -  if (!java_dyn_MethodHandle::is_instance(mh())) {
  41.950 +  if (!java_lang_invoke_MethodHandle::is_instance(mh())) {
  41.951      THROW_NULL(vmSymbols::java_lang_IllegalArgumentException());
  41.952    }
  41.953    oop target = MethodHandles::encode_target(mh, format, CHECK_NULL);
  41.954 @@ -2317,7 +2318,7 @@
  41.955  }
  41.956  JVM_END
  41.957  
  41.958 -JVM_ENTRY(jint, MHI_getConstant(JNIEnv *env, jobject igcls, jint which)) {
  41.959 +JVM_ENTRY(jint, MHN_getConstant(JNIEnv *env, jobject igcls, jint which)) {
  41.960    switch (which) {
  41.961    case MethodHandles::GC_JVM_PUSH_LIMIT:
  41.962      guarantee(MethodHandlePushLimit >= 2 && MethodHandlePushLimit <= 0xFF,
  41.963 @@ -2341,36 +2342,36 @@
  41.964      template(MethodHandles,ETF_DIRECT_HANDLE) \
  41.965      template(MethodHandles,ETF_METHOD_NAME) \
  41.966      template(MethodHandles,ETF_REFLECT_METHOD) \
  41.967 -    template(sun_dyn_MemberName,MN_IS_METHOD) \
  41.968 -    template(sun_dyn_MemberName,MN_IS_CONSTRUCTOR) \
  41.969 -    template(sun_dyn_MemberName,MN_IS_FIELD) \
  41.970 -    template(sun_dyn_MemberName,MN_IS_TYPE) \
  41.971 -    template(sun_dyn_MemberName,MN_SEARCH_SUPERCLASSES) \
  41.972 -    template(sun_dyn_MemberName,MN_SEARCH_INTERFACES) \
  41.973 -    template(sun_dyn_MemberName,VM_INDEX_UNINITIALIZED) \
  41.974 -    template(sun_dyn_AdapterMethodHandle,OP_RETYPE_ONLY) \
  41.975 -    template(sun_dyn_AdapterMethodHandle,OP_RETYPE_RAW) \
  41.976 -    template(sun_dyn_AdapterMethodHandle,OP_CHECK_CAST) \
  41.977 -    template(sun_dyn_AdapterMethodHandle,OP_PRIM_TO_PRIM) \
  41.978 -    template(sun_dyn_AdapterMethodHandle,OP_REF_TO_PRIM) \
  41.979 -    template(sun_dyn_AdapterMethodHandle,OP_PRIM_TO_REF) \
  41.980 -    template(sun_dyn_AdapterMethodHandle,OP_SWAP_ARGS) \
  41.981 -    template(sun_dyn_AdapterMethodHandle,OP_ROT_ARGS) \
  41.982 -    template(sun_dyn_AdapterMethodHandle,OP_DUP_ARGS) \
  41.983 -    template(sun_dyn_AdapterMethodHandle,OP_DROP_ARGS) \
  41.984 -    template(sun_dyn_AdapterMethodHandle,OP_COLLECT_ARGS) \
  41.985 -    template(sun_dyn_AdapterMethodHandle,OP_SPREAD_ARGS) \
  41.986 -    template(sun_dyn_AdapterMethodHandle,OP_FLYBY) \
  41.987 -    template(sun_dyn_AdapterMethodHandle,OP_RICOCHET) \
  41.988 -    template(sun_dyn_AdapterMethodHandle,CONV_OP_LIMIT) \
  41.989 -    template(sun_dyn_AdapterMethodHandle,CONV_OP_MASK) \
  41.990 -    template(sun_dyn_AdapterMethodHandle,CONV_VMINFO_MASK) \
  41.991 -    template(sun_dyn_AdapterMethodHandle,CONV_VMINFO_SHIFT) \
  41.992 -    template(sun_dyn_AdapterMethodHandle,CONV_OP_SHIFT) \
  41.993 -    template(sun_dyn_AdapterMethodHandle,CONV_DEST_TYPE_SHIFT) \
  41.994 -    template(sun_dyn_AdapterMethodHandle,CONV_SRC_TYPE_SHIFT) \
  41.995 -    template(sun_dyn_AdapterMethodHandle,CONV_STACK_MOVE_SHIFT) \
  41.996 -    template(sun_dyn_AdapterMethodHandle,CONV_STACK_MOVE_MASK) \
  41.997 +    template(java_lang_invoke_MemberName,MN_IS_METHOD) \
  41.998 +    template(java_lang_invoke_MemberName,MN_IS_CONSTRUCTOR) \
  41.999 +    template(java_lang_invoke_MemberName,MN_IS_FIELD) \
 41.1000 +    template(java_lang_invoke_MemberName,MN_IS_TYPE) \
 41.1001 +    template(java_lang_invoke_MemberName,MN_SEARCH_SUPERCLASSES) \
 41.1002 +    template(java_lang_invoke_MemberName,MN_SEARCH_INTERFACES) \
 41.1003 +    template(java_lang_invoke_MemberName,VM_INDEX_UNINITIALIZED) \
 41.1004 +    template(java_lang_invoke_AdapterMethodHandle,OP_RETYPE_ONLY) \
 41.1005 +    template(java_lang_invoke_AdapterMethodHandle,OP_RETYPE_RAW) \
 41.1006 +    template(java_lang_invoke_AdapterMethodHandle,OP_CHECK_CAST) \
 41.1007 +    template(java_lang_invoke_AdapterMethodHandle,OP_PRIM_TO_PRIM) \
 41.1008 +    template(java_lang_invoke_AdapterMethodHandle,OP_REF_TO_PRIM) \
 41.1009 +    template(java_lang_invoke_AdapterMethodHandle,OP_PRIM_TO_REF) \
 41.1010 +    template(java_lang_invoke_AdapterMethodHandle,OP_SWAP_ARGS) \
 41.1011 +    template(java_lang_invoke_AdapterMethodHandle,OP_ROT_ARGS) \
 41.1012 +    template(java_lang_invoke_AdapterMethodHandle,OP_DUP_ARGS) \
 41.1013 +    template(java_lang_invoke_AdapterMethodHandle,OP_DROP_ARGS) \
 41.1014 +    template(java_lang_invoke_AdapterMethodHandle,OP_COLLECT_ARGS) \
 41.1015 +    template(java_lang_invoke_AdapterMethodHandle,OP_SPREAD_ARGS) \
 41.1016 +    template(java_lang_invoke_AdapterMethodHandle,OP_FLYBY) \
 41.1017 +    template(java_lang_invoke_AdapterMethodHandle,OP_RICOCHET) \
 41.1018 +    template(java_lang_invoke_AdapterMethodHandle,CONV_OP_LIMIT) \
 41.1019 +    template(java_lang_invoke_AdapterMethodHandle,CONV_OP_MASK) \
 41.1020 +    template(java_lang_invoke_AdapterMethodHandle,CONV_VMINFO_MASK) \
 41.1021 +    template(java_lang_invoke_AdapterMethodHandle,CONV_VMINFO_SHIFT) \
 41.1022 +    template(java_lang_invoke_AdapterMethodHandle,CONV_OP_SHIFT) \
 41.1023 +    template(java_lang_invoke_AdapterMethodHandle,CONV_DEST_TYPE_SHIFT) \
 41.1024 +    template(java_lang_invoke_AdapterMethodHandle,CONV_SRC_TYPE_SHIFT) \
 41.1025 +    template(java_lang_invoke_AdapterMethodHandle,CONV_STACK_MOVE_SHIFT) \
 41.1026 +    template(java_lang_invoke_AdapterMethodHandle,CONV_STACK_MOVE_MASK) \
 41.1027      /*end*/
 41.1028  
 41.1029  #define ONE_PLUS(scope,value) 1+
 41.1030 @@ -2386,7 +2387,7 @@
 41.1031  #undef EACH_NAMED_CON
 41.1032  #endif
 41.1033  
 41.1034 -JVM_ENTRY(jint, MHI_getNamedCon(JNIEnv *env, jobject igcls, jint which, jobjectArray box_jh)) {
 41.1035 +JVM_ENTRY(jint, MHN_getNamedCon(JNIEnv *env, jobject igcls, jint which, jobjectArray box_jh)) {
 41.1036  #ifndef PRODUCT
 41.1037    if (which >= 0 && which < con_value_count) {
 41.1038      int con = con_values[which];
 41.1039 @@ -2406,7 +2407,7 @@
 41.1040  JVM_END
 41.1041  
 41.1042  // void init(MemberName self, AccessibleObject ref)
 41.1043 -JVM_ENTRY(void, MHI_init_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jobject target_jh)) {
 41.1044 +JVM_ENTRY(void, MHN_init_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jobject target_jh)) {
 41.1045    if (mname_jh == NULL || target_jh == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
 41.1046    Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
 41.1047    oop target_oop = JNIHandles::resolve_non_null(target_jh);
 41.1048 @@ -2415,7 +2416,7 @@
 41.1049  JVM_END
 41.1050  
 41.1051  // void expand(MemberName self)
 41.1052 -JVM_ENTRY(void, MHI_expand_Mem(JNIEnv *env, jobject igcls, jobject mname_jh)) {
 41.1053 +JVM_ENTRY(void, MHN_expand_Mem(JNIEnv *env, jobject igcls, jobject mname_jh)) {
 41.1054    if (mname_jh == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
 41.1055    Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
 41.1056    MethodHandles::expand_MemberName(mname, 0, CHECK);
 41.1057 @@ -2423,14 +2424,14 @@
 41.1058  JVM_END
 41.1059  
 41.1060  // void resolve(MemberName self, Class<?> caller)
 41.1061 -JVM_ENTRY(void, MHI_resolve_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jclass caller_jh)) {
 41.1062 +JVM_ENTRY(void, MHN_resolve_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jclass caller_jh)) {
 41.1063    if (mname_jh == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
 41.1064    Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
 41.1065  
 41.1066    // The trusted Java code that calls this method should already have performed
 41.1067    // access checks on behalf of the given caller.  But, we can verify this.
 41.1068    if (VerifyMethodHandles && caller_jh != NULL) {
 41.1069 -    klassOop reference_klass = java_lang_Class::as_klassOop(sun_dyn_MemberName::clazz(mname()));
 41.1070 +    klassOop reference_klass = java_lang_Class::as_klassOop(java_lang_invoke_MemberName::clazz(mname()));
 41.1071      if (reference_klass != NULL) {
 41.1072        // Emulate LinkResolver::check_klass_accessability.
 41.1073        klassOop caller = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(caller_jh));
 41.1074 @@ -2448,7 +2449,7 @@
 41.1075  
 41.1076  //  static native int getMembers(Class<?> defc, String matchName, String matchSig,
 41.1077  //          int matchFlags, Class<?> caller, int skip, MemberName[] results);
 41.1078 -JVM_ENTRY(jint, MHI_getMembers(JNIEnv *env, jobject igcls,
 41.1079 +JVM_ENTRY(jint, MHN_getMembers(JNIEnv *env, jobject igcls,
 41.1080                                 jclass clazz_jh, jstring name_jh, jstring sig_jh,
 41.1081                                 int mflags, jclass caller_jh, jint skip, jobjectArray results_jh)) {
 41.1082    if (clazz_jh == NULL || results_jh == NULL)  return -1;
 41.1083 @@ -2487,14 +2488,14 @@
 41.1084  }
 41.1085  JVM_END
 41.1086  
 41.1087 -JVM_ENTRY(void, MHI_registerBootstrap(JNIEnv *env, jobject igcls, jclass caller_jh, jobject bsm_jh)) {
 41.1088 +JVM_ENTRY(void, MHN_registerBootstrap(JNIEnv *env, jobject igcls, jclass caller_jh, jobject bsm_jh)) {
 41.1089    instanceKlassHandle ik = MethodHandles::resolve_instance_klass(caller_jh, THREAD);
 41.1090    if (!AllowTransitionalJSR292) {
 41.1091      THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 41.1092                "registerBootstrapMethod is only supported in JSR 292 EDR");
 41.1093    }
 41.1094    ik->link_class(CHECK);
 41.1095 -  if (!java_dyn_MethodHandle::is_instance(JNIHandles::resolve(bsm_jh))) {
 41.1096 +  if (!java_lang_invoke_MethodHandle::is_instance(JNIHandles::resolve(bsm_jh))) {
 41.1097      THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "method handle");
 41.1098    }
 41.1099    const char* err = NULL;
 41.1100 @@ -2522,7 +2523,7 @@
 41.1101  }
 41.1102  JVM_END
 41.1103  
 41.1104 -JVM_ENTRY(jobject, MHI_getBootstrap(JNIEnv *env, jobject igcls, jclass caller_jh)) {
 41.1105 +JVM_ENTRY(jobject, MHN_getBootstrap(JNIEnv *env, jobject igcls, jclass caller_jh)) {
 41.1106    if (!AllowTransitionalJSR292)
 41.1107      THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "getBootstrap: transitional only");
 41.1108    instanceKlassHandle ik = MethodHandles::resolve_instance_klass(caller_jh, THREAD);
 41.1109 @@ -2530,7 +2531,7 @@
 41.1110  }
 41.1111  JVM_END
 41.1112  
 41.1113 -JVM_ENTRY(void, MHI_setCallSiteTarget(JNIEnv *env, jobject igcls, jobject site_jh, jobject target_jh)) {
 41.1114 +JVM_ENTRY(void, MHN_setCallSiteTarget(JNIEnv *env, jobject igcls, jobject site_jh, jobject target_jh)) {
 41.1115    if (!AllowTransitionalJSR292)
 41.1116      THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "setCallSite: transitional only");
 41.1117  }
 41.1118 @@ -2539,8 +2540,6 @@
 41.1119  
 41.1120  /// JVM_RegisterMethodHandleMethods
 41.1121  
 41.1122 -#define ADR "J"
 41.1123 -
 41.1124  #define LANG "Ljava/lang/"
 41.1125  #define JLINV "Ljava/lang/invoke/" /* standard package */
 41.1126  #define JDYN "Ljava/dyn/" /* alternative package to JLINV if AllowTransitionalJSR292 */
 41.1127 @@ -2561,31 +2560,31 @@
 41.1128  #define CC (char*)  /*cast a literal from (const char*)*/
 41.1129  #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
 41.1130  
 41.1131 -// These are the native methods on sun.dyn.MethodHandleNatives.
 41.1132 +// These are the native methods on sun.invoke.MethodHandleNatives.
 41.1133  static JNINativeMethod methods[] = {
 41.1134    // void init(MemberName self, AccessibleObject ref)
 41.1135 -  {CC"init",                    CC"("AMH""MH"I)V",              FN_PTR(MHI_init_AMH)},
 41.1136 -  {CC"init",                    CC"("BMH""OBJ"I)V",             FN_PTR(MHI_init_BMH)},
 41.1137 -  {CC"init",                    CC"("DMH""OBJ"Z"CLS")V",        FN_PTR(MHI_init_DMH)},
 41.1138 -  {CC"init",                    CC"("MT")V",                    FN_PTR(MHI_init_MT)},
 41.1139 -  {CC"init",                    CC"("MEM""OBJ")V",              FN_PTR(MHI_init_Mem)},
 41.1140 -  {CC"expand",                  CC"("MEM")V",                   FN_PTR(MHI_expand_Mem)},
 41.1141 -  {CC"resolve",                 CC"("MEM""CLS")V",              FN_PTR(MHI_resolve_Mem)},
 41.1142 -  {CC"getTarget",               CC"("MH"I)"OBJ,                 FN_PTR(MHI_getTarget)},
 41.1143 -  {CC"getConstant",             CC"(I)I",                       FN_PTR(MHI_getConstant)},
 41.1144 +  {CC"init",                    CC"("AMH""MH"I)V",              FN_PTR(MHN_init_AMH)},
 41.1145 +  {CC"init",                    CC"("BMH""OBJ"I)V",             FN_PTR(MHN_init_BMH)},
 41.1146 +  {CC"init",                    CC"("DMH""OBJ"Z"CLS")V",        FN_PTR(MHN_init_DMH)},
 41.1147 +  {CC"init",                    CC"("MT")V",                    FN_PTR(MHN_init_MT)},
 41.1148 +  {CC"init",                    CC"("MEM""OBJ")V",              FN_PTR(MHN_init_Mem)},
 41.1149 +  {CC"expand",                  CC"("MEM")V",                   FN_PTR(MHN_expand_Mem)},
 41.1150 +  {CC"resolve",                 CC"("MEM""CLS")V",              FN_PTR(MHN_resolve_Mem)},
 41.1151 +  {CC"getTarget",               CC"("MH"I)"OBJ,                 FN_PTR(MHN_getTarget)},
 41.1152 +  {CC"getConstant",             CC"(I)I",                       FN_PTR(MHN_getConstant)},
 41.1153    //  static native int getNamedCon(int which, Object[] name)
 41.1154 -  {CC"getNamedCon",             CC"(I["OBJ")I",                 FN_PTR(MHI_getNamedCon)},
 41.1155 +  {CC"getNamedCon",             CC"(I["OBJ")I",                 FN_PTR(MHN_getNamedCon)},
 41.1156    //  static native int getMembers(Class<?> defc, String matchName, String matchSig,
 41.1157    //          int matchFlags, Class<?> caller, int skip, MemberName[] results);
 41.1158 -  {CC"getMembers",              CC"("CLS""STRG""STRG"I"CLS"I["MEM")I",  FN_PTR(MHI_getMembers)}
 41.1159 +  {CC"getMembers",              CC"("CLS""STRG""STRG"I"CLS"I["MEM")I",  FN_PTR(MHN_getMembers)}
 41.1160  };
 41.1161  
 41.1162  // More entry points specifically for EnableInvokeDynamic.
 41.1163  // FIXME: Remove methods2 after AllowTransitionalJSR292 is removed.
 41.1164  static JNINativeMethod methods2[] = {
 41.1165 -  {CC"registerBootstrap",       CC"("CLS MH")V",                FN_PTR(MHI_registerBootstrap)},
 41.1166 -  {CC"getBootstrap",            CC"("CLS")"MH,                  FN_PTR(MHI_getBootstrap)},
 41.1167 -  {CC"setCallSiteTarget",       CC"("CST MH")V",                FN_PTR(MHI_setCallSiteTarget)}
 41.1168 +  {CC"registerBootstrap",       CC"("CLS MH")V",                FN_PTR(MHN_registerBootstrap)},
 41.1169 +  {CC"getBootstrap",            CC"("CLS")"MH,                  FN_PTR(MHN_getBootstrap)},
 41.1170 +  {CC"setCallSiteTarget",       CC"("CST MH")V",                FN_PTR(MHN_setCallSiteTarget)}
 41.1171  };
 41.1172  
 41.1173  static void hack_signatures(JNINativeMethod* methods, jint num_methods, const char* from_sig, const char* to_sig) {
 41.1174 @@ -2692,9 +2691,11 @@
 41.1175        // We need to link the MethodHandleImpl klass before we generate
 41.1176        // the method handle adapters as the _raise_exception adapter uses
 41.1177        // one of its methods (and its c2i-adapter).
 41.1178 -      KlassHandle    k  = SystemDictionaryHandles::MethodHandleImpl_klass();
 41.1179 -      instanceKlass* ik = instanceKlass::cast(k());
 41.1180 -      ik->link_class(CHECK);
 41.1181 +      klassOop k = SystemDictionary::MethodHandleImpl_klass();
 41.1182 +      if (k != NULL) {
 41.1183 +        instanceKlass* ik = instanceKlass::cast(k);
 41.1184 +        ik->link_class(CHECK);
 41.1185 +      }
 41.1186      }
 41.1187  
 41.1188      MethodHandles::generate_adapters();
 41.1189 @@ -2711,8 +2712,8 @@
 41.1190  
 41.1191      int status = env->RegisterNatives(MHN_class, methods2, sizeof(methods2)/sizeof(JNINativeMethod));
 41.1192      if (env->ExceptionOccurred()) {
 41.1193 -      MethodHandles::set_enabled(false);
 41.1194 -      warning("JSR 292 method handle code is mismatched to this JVM.  Disabling support.");
 41.1195 +      // Don't do this, since it's too late:
 41.1196 +      //   MethodHandles::set_enabled(false)
 41.1197        env->ExceptionClear();
 41.1198      }
 41.1199    }

    42.1 --- a/src/share/vm/prims/methodHandles.hpp	Fri Mar 11 22:33:47 2011 -0800
    42.2 +++ b/src/share/vm/prims/methodHandles.hpp	Fri Mar 11 22:34:57 2011 -0800
    42.3 @@ -37,8 +37,8 @@
    42.4  
    42.5  class MethodHandles: AllStatic {
    42.6    // JVM support for MethodHandle, MethodType, and related types
    42.7 -  // in java.dyn and java.dyn.hotspot.
    42.8 -  // See also  javaClasses for layouts java_dyn_Method{Handle,Type,Type::Form}.
    42.9 +  // in java.lang.invoke and sun.invoke.
   42.10 +  // See also  javaClasses for layouts java_lang_invoke_Method{Handle,Type,Type::Form}.
   42.11   public:
   42.12    enum EntryKind {
   42.13      _raise_exception,           // stub for error generation from other stubs
   42.14 @@ -54,21 +54,21 @@
   42.15      _bound_long_direct_mh,
   42.16  
   42.17      _adapter_mh_first,     // adapter sequence goes here...
   42.18 -    _adapter_retype_only   = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_RETYPE_ONLY,
   42.19 -    _adapter_retype_raw    = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW,
   42.20 -    _adapter_check_cast    = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_CHECK_CAST,
   42.21 -    _adapter_prim_to_prim  = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_PRIM_TO_PRIM,
   42.22 -    _adapter_ref_to_prim   = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_REF_TO_PRIM,
   42.23 -    _adapter_prim_to_ref   = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_PRIM_TO_REF,
   42.24 -    _adapter_swap_args     = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_SWAP_ARGS,
   42.25 -    _adapter_rot_args      = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_ROT_ARGS,
   42.26 -    _adapter_dup_args      = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_DUP_ARGS,
   42.27 -    _adapter_drop_args     = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_DROP_ARGS,
   42.28 -    _adapter_collect_args  = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_COLLECT_ARGS,
   42.29 -    _adapter_spread_args   = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_SPREAD_ARGS,
   42.30 -    _adapter_flyby         = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_FLYBY,
   42.31 -    _adapter_ricochet      = _adapter_mh_first + sun_dyn_AdapterMethodHandle::OP_RICOCHET,
   42.32 -    _adapter_mh_last       = _adapter_mh_first + sun_dyn_AdapterMethodHandle::CONV_OP_LIMIT - 1,
   42.33 +    _adapter_retype_only   = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY,
   42.34 +    _adapter_retype_raw    = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW,
   42.35 +    _adapter_check_cast    = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST,
   42.36 +    _adapter_prim_to_prim  = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM,
   42.37 +    _adapter_ref_to_prim   = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM,
   42.38 +    _adapter_prim_to_ref   = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF,
   42.39 +    _adapter_swap_args     = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS,
   42.40 +    _adapter_rot_args      = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS,
   42.41 +    _adapter_dup_args      = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS,
   42.42 +    _adapter_drop_args     = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS,
   42.43 +    _adapter_collect_args  = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS,
   42.44 +    _adapter_spread_args   = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS,
   42.45 +    _adapter_flyby         = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_FLYBY,
   42.46 +    _adapter_ricochet      = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::OP_RICOCHET,
   42.47 +    _adapter_mh_last       = _adapter_mh_first + java_lang_invoke_AdapterMethodHandle::CONV_OP_LIMIT - 1,
   42.48  
   42.49      // Optimized adapter types
   42.50  
   42.51 @@ -107,16 +107,16 @@
   42.52    static void set_enabled(bool z);
   42.53  
   42.54   private:
   42.55 -  enum {  // import sun_dyn_AdapterMethodHandle::CONV_OP_*
   42.56 -    CONV_OP_LIMIT         = sun_dyn_AdapterMethodHandle::CONV_OP_LIMIT,
   42.57 -    CONV_OP_MASK          = sun_dyn_AdapterMethodHandle::CONV_OP_MASK,
   42.58 -    CONV_VMINFO_MASK      = sun_dyn_AdapterMethodHandle::CONV_VMINFO_MASK,
   42.59 -    CONV_VMINFO_SHIFT     = sun_dyn_AdapterMethodHandle::CONV_VMINFO_SHIFT,
   42.60 -    CONV_OP_SHIFT         = sun_dyn_AdapterMethodHandle::CONV_OP_SHIFT,
   42.61 -    CONV_DEST_TYPE_SHIFT  = sun_dyn_AdapterMethodHandle::CONV_DEST_TYPE_SHIFT,
   42.62 -    CONV_SRC_TYPE_SHIFT   = sun_dyn_AdapterMethodHandle::CONV_SRC_TYPE_SHIFT,
   42.63 -    CONV_STACK_MOVE_SHIFT = sun_dyn_AdapterMethodHandle::CONV_STACK_MOVE_SHIFT,
   42.64 -    CONV_STACK_MOVE_MASK  = sun_dyn_AdapterMethodHandle::CONV_STACK_MOVE_MASK
   42.65 +  enum {  // import java_lang_invoke_AdapterMethodHandle::CONV_OP_*
   42.66 +    CONV_OP_LIMIT         = java_lang_invoke_AdapterMethodHandle::CONV_OP_LIMIT,
   42.67 +    CONV_OP_MASK          = java_lang_invoke_AdapterMethodHandle::CONV_OP_MASK,
   42.68 +    CONV_VMINFO_MASK      = java_lang_invoke_AdapterMethodHandle::CONV_VMINFO_MASK,
   42.69 +    CONV_VMINFO_SHIFT     = java_lang_invoke_AdapterMethodHandle::CONV_VMINFO_SHIFT,
   42.70 +    CONV_OP_SHIFT         = java_lang_invoke_AdapterMethodHandle::CONV_OP_SHIFT,
   42.71 +    CONV_DEST_TYPE_SHIFT  = java_lang_invoke_AdapterMethodHandle::CONV_DEST_TYPE_SHIFT,
   42.72 +    CONV_SRC_TYPE_SHIFT   = java_lang_invoke_AdapterMethodHandle::CONV_SRC_TYPE_SHIFT,
   42.73 +    CONV_STACK_MOVE_SHIFT = java_lang_invoke_AdapterMethodHandle::CONV_STACK_MOVE_SHIFT,
   42.74 +    CONV_STACK_MOVE_MASK  = java_lang_invoke_AdapterMethodHandle::CONV_STACK_MOVE_MASK
   42.75    };
   42.76  
   42.77    static bool _enabled;
   42.78 @@ -471,7 +471,7 @@
   42.79  };
   42.80  
   42.81  
   42.82 -// Access methods for the "entry" field of a java.dyn.MethodHandle.
   42.83 +// Access methods for the "entry" field of a java.lang.invoke.MethodHandle.
   42.84  // The field is primarily a jump target for compiled calls.
   42.85  // However, we squirrel away some nice pointers for other uses,
   42.86  // just before the jump target.

    43.1 --- a/src/share/vm/prims/nativeLookup.cpp	Fri Mar 11 22:33:47 2011 -0800
    43.2 +++ b/src/share/vm/prims/nativeLookup.cpp	Fri Mar 11 22:34:57 2011 -0800
    43.3 @@ -116,6 +116,7 @@
    43.4    { CC"Java_java_io_ObjectInputStream_setPrimitiveFieldValues",    NULL, FN_PTR(JVM_SetPrimitiveFieldValues)     },  // intercept ObjectInputStream setPrimitiveFieldValues for faster serialization
    43.5  
    43.6    { CC"Java_sun_misc_Unsafe_registerNatives",                      NULL, FN_PTR(JVM_RegisterUnsafeMethods)       },
    43.7 +  { CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },
    43.8    { CC"Java_sun_dyn_MethodHandleNatives_registerNatives",          NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },  // AllowTransitionalJSR292
    43.9    { CC"Java_java_dyn_MethodHandleNatives_registerNatives",         NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },  // AllowTransitionalJSR292
   43.10    { CC"Java_sun_misc_Perf_registerNatives",                        NULL, FN_PTR(JVM_RegisterPerfMethods)         }