*** old/src/share/vm/opto/doCall.cpp	Wed Dec  2 17:37:54 2009
--- new/src/share/vm/opto/doCall.cpp	Wed Dec  2 17:37:54 2009

*** 226,235 ****
--- 226,241 ----
  
    // There was no special inlining tactic, or it bailed out.
    // Use a more generic tactic, like a simple call.
    if (call_is_virtual) {
      return CallGenerator::for_virtual_call(call_method, vtable_index);
+   } else if (call_method->is_method_handle_invoke()) {
+     if (jvms->method()->java_code_at_bci(jvms->bci()) == Bytecodes::_invokedynamic)
+       return CallGenerator::for_dynamic_call(call_method);
+     else
+       // %%% if the target MH is a compile-time constant, we should try to inline it
+       return CallGenerator::for_direct_call(call_method);
    } else {
      // Class Hierarchy Analysis or Type Profile reveals a unique target,
      // or it is a static or special call.
      return CallGenerator::for_direct_call(call_method, should_delay_inlining(call_method, jvms));
    }

*** 305,322 ****
--- 311,320 ----
      uncommon_trap(Deoptimization::Reason_uninitialized,
                    Deoptimization::Action_reinterpret,
                    holder_klass);
      return true;
    }
    if (dest_method->is_method_handle_invoke()
        && holder_klass->name() == ciSymbol::java_dyn_InvokeDynamic()) {
      // FIXME: NYI
      uncommon_trap(Deoptimization::Reason_unhandled,
                    Deoptimization::Action_none,
                    holder_klass);
      return true;
    }
  
    assert(dest_method->will_link(method()->holder(), klass, bc()), "dest_method: typeflow responsibility");
    return false;
  }
  

*** 331,349 ****
--- 329,349 ----
  
    // Set frequently used booleans
    bool is_virtual = bc() == Bytecodes::_invokevirtual;
    bool is_virtual_or_interface = is_virtual || bc() == Bytecodes::_invokeinterface;
    bool has_receiver = is_virtual_or_interface || bc() == Bytecodes::_invokespecial;
+   bool is_invokedynamic = bc() == Bytecodes::_invokedynamic;
  
    // Find target being called
    bool             will_link;
    ciMethod*        dest_method   = iter().get_method(will_link);
    ciInstanceKlass* holder_klass  = dest_method->holder();
    ciKlass* holder = iter().get_declared_method_holder();
    ciInstanceKlass* klass = ciEnv::get_instance_klass_for_declared_method_holder(holder);
  
    int nargs = dest_method->arg_size();
+   if (is_invokedynamic)  nargs -= 1;
  
    // uncommon-trap when callee is unloaded, uninitialized or will not link
    // bailout when too many arguments for register representation
    if (!will_link || can_not_compile_call_site(dest_method, klass)) {
  #ifndef PRODUCT

*** 353,363 ****
--- 353,363 ----
      }
  #endif
      return;
    }
    assert(holder_klass->is_loaded(), "");
!   assert(dest_method->is_static() == !has_receiver, "must match bc");
!   assert((dest_method->is_static() || is_invokedynamic) == !has_receiver , "must match bc");
    // Note: this takes into account invokeinterface of methods declared in java/lang/Object,
    // which should be invokevirtuals but according to the VM spec may be invokeinterfaces
    assert(holder_klass->is_interface() || holder_klass->super() == NULL || (bc() != Bytecodes::_invokeinterface), "must match bc");
    // Note:  In the absence of miranda methods, an abstract class K can perform
    // an invokevirtual directly on an interface method I.m if K implements I.