truffle: src/share/vm/opto/doCall.cpp comparison

comparison src/share/vm/opto/doCall.cpp @ 1162:d749b1813f40

Merge

author	trims
date	Fri, 15 Jan 2010 14:25:44 -0800
parents	c3b315a0d58a
children	87684f1a88b5

comparison

equal deleted inserted replaced

-:1bc68593a110
+:d749b1813f40
 tty->print_cr(" (%d bytes)", prof_method->code_size());
 }
 }
 #endif
-CallGenerator* Compile::call_generator(ciMethod* call_method, int vtable_index, bool call_is_virtual, JVMState* jvms, bool allow_inline, float prof_factor) {
+CallGenerator* Compile::call_generator(ciMethod* call_method, int vtable_index, bool call_is_virtual,
+JVMState* jvms, bool allow_inline,
+float prof_factor) {
 CallGenerator* cg;
 // Dtrace currently doesn't work unless all calls are vanilla
 if (env()->dtrace_method_probes()) {
 allow_inline = false;
 } else {
 // Make a disembodied, stateless ILT.
 // TO DO:  When UseOldInlining is removed, copy the ILT code elsewhere.
 float site_invoke_ratio = prof_factor;
 // Note:  ilt is for the root of this parse, not the present call site.
-ilt = new InlineTree(this, jvms->method(), jvms->caller(), site_invoke_ratio);
+ilt = new InlineTree(this, jvms->method(), jvms->caller(), site_invoke_ratio, 0);
 }
 WarmCallInfo scratch_ci;
 if (!UseOldInlining)
 scratch_ci.init(jvms, call_method, profile, prof_factor);
 WarmCallInfo* ci = ilt->ok_to_inline(call_method, jvms, profile, &scratch_ci);
 }
 }
 }
 }
+// Do MethodHandle calls.
+if (call_method->is_method_handle_invoke()) {
+if (jvms->method()->java_code_at_bci(jvms->bci()) != Bytecodes::_invokedynamic) {
+GraphKit kit(jvms);
+Node* n = kit.argument(0);
+if (n->Opcode() == Op_ConP) {
+const TypeOopPtr* oop_ptr = n->bottom_type()->is_oopptr();
+ciObject* const_oop = oop_ptr->const_oop();
+ciMethodHandle* method_handle = const_oop->as_method_handle();
+// Set the actually called method to have access to the class
+// and signature in the MethodHandleCompiler.
+method_handle->set_callee(call_method);
+// Get an adapter for the MethodHandle.
+ciMethod* target_method = method_handle->get_method_handle_adapter();
+CallGenerator* hit_cg = this->call_generator(target_method, vtable_index, false, jvms, true, prof_factor);
+if (hit_cg != NULL && hit_cg->is_inline())
+return hit_cg;
+}
+return CallGenerator::for_direct_call(call_method);
+}
+else {
+// Get the MethodHandle from the CallSite.
+ciMethod* caller_method = jvms->method();
+ciBytecodeStream str(caller_method);
+str.force_bci(jvms->bci());  // Set the stream to the invokedynamic bci.
+ciCallSite*     call_site     = str.get_call_site();
+ciMethodHandle* method_handle = call_site->get_target();
+// Set the actually called method to have access to the class
+// and signature in the MethodHandleCompiler.
+method_handle->set_callee(call_method);
+// Get an adapter for the MethodHandle.
+ciMethod* target_method = method_handle->get_invokedynamic_adapter();
+CallGenerator* hit_cg = this->call_generator(target_method, vtable_index, false, jvms, true, prof_factor);
+if (hit_cg != NULL && hit_cg->is_inline()) {
+CallGenerator* miss_cg = CallGenerator::for_dynamic_call(call_method);
+return CallGenerator::for_predicted_dynamic_call(method_handle, miss_cg, hit_cg, prof_factor);
+}
+// If something failed, generate a normal dynamic call.
+return CallGenerator::for_dynamic_call(call_method);
+}
+}
 // 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 {
 // iter().get_method_holder_index()
 assert( dest_method->is_loaded(), "ciTypeFlow should not let us get here" );
 // Interface classes can be loaded & linked and never get around to
 // being initialized.  Uncommon-trap for not-initialized static or
 // v-calls.  Let interface calls happen.
-ciInstanceKlass* holder_klass  = dest_method->holder();
+ciInstanceKlass* holder_klass = dest_method->holder();
 if (!holder_klass->is_initialized() &&
 !holder_klass->is_interface()) {
 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_Dynamic()) {
-// 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");
 // 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();
+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
 }
 #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.

Mercurial > hg > truffle

comparison src/share/vm/opto/doCall.cpp @ 1162:d749b1813f40