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

comparison src/share/vm/opto/callGenerator.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	6c5b7a6becc8
children	7a302948f5a4

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 /*
-* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "precompiled.hpp"
 #include "ci/bcEscapeAnalyzer.hpp"
 #include "ci/ciCallSite.hpp"
 #include "ci/ciCPCache.hpp"
+#include "ci/ciMemberName.hpp"
 #include "ci/ciMethodHandle.hpp"
 #include "classfile/javaClasses.hpp"
 #include "compiler/compileLog.hpp"
 #include "opto/addnode.hpp"
 #include "opto/callGenerator.hpp"
 #include "opto/parse.hpp"
 #include "opto/rootnode.hpp"
 #include "opto/runtime.hpp"
 #include "opto/subnode.hpp"
-CallGenerator::CallGenerator(ciMethod* method) {
-_method = method;
-}
 // Utility function.
 const TypeFunc* CallGenerator::tf() const {
 return TypeFunc::make(method());
 }
 if (kit.C->log() != NULL) {
 kit.C->log()->elem("direct_call bci='%d'", jvms->bci());
 }
 CallStaticJavaNode *call = new (kit.C, tf()->domain()->cnt()) CallStaticJavaNode(tf(), target, method(), kit.bci());
+_call_node = call;  // Save the call node in case we need it later
 if (!is_static) {
 // Make an explicit receiver null_check as part of this call.
 // Since we share a map with the caller, his JVMS gets adjusted.
 kit.null_check_receiver(method());
 if (kit.stopped()) {
 // And dump it back to the caller, decorated with any exceptions:
 return kit.transfer_exceptions_into_jvms();
 }
 // Mark the call node as virtual, sort of:
 call->set_optimized_virtual(true);
-if (method()->is_method_handle_invoke()) {
+if (method()->is_method_handle_intrinsic() ||
+method()->is_compiled_lambda_form()) {
 call->set_method_handle_invoke(true);
 }
 }
 kit.set_arguments_for_java_call(call);
 kit.set_edges_for_java_call(call, false, _separate_io_proj);
 Node* ret = kit.set_results_for_java_call(call, _separate_io_proj);
 kit.push_node(method()->return_type()->basic_type(), ret);
-_call_node = call;  // Save the call node in case we need it later
 return kit.transfer_exceptions_into_jvms();
 }
 //---------------------------DynamicCallGenerator-----------------------------
 // Internal class which handles all out-of-line invokedynamic calls.
 virtual JVMState* generate(JVMState* jvms);
 };
 JVMState* DynamicCallGenerator::generate(JVMState* jvms) {
 GraphKit kit(jvms);
+Compile* C = kit.C;
-if (kit.C->log() != NULL) {
+PhaseGVN& gvn = kit.gvn();
-kit.C->log()->elem("dynamic_call bci='%d'", jvms->bci());
+if (C->log() != NULL) {
+C->log()->elem("dynamic_call bci='%d'", jvms->bci());
 }
 // Get the constant pool cache from the caller class.
 ciMethod* caller_method = jvms->method();
 ciBytecodeStream str(caller_method);
 // pointer.
 int index = str.get_method_index();
 size_t call_site_offset = cpcache->get_f1_offset(index);
 // Load the CallSite object from the constant pool cache.
-const TypeOopPtr* cpcache_ptr = TypeOopPtr::make_from_constant(cpcache);
+const TypeOopPtr* cpcache_type   = TypeOopPtr::make_from_constant(cpcache);  // returns TypeAryPtr of type T_OBJECT
-Node* cpcache_adr = kit.makecon(cpcache_ptr);
+const TypeOopPtr* call_site_type = TypeOopPtr::make_from_klass(C->env()->CallSite_klass());
-Node* call_site_adr = kit.basic_plus_adr(cpcache_adr, cpcache_adr, call_site_offset);
+Node* cpcache_adr   = kit.makecon(cpcache_type);
-Node* call_site = kit.make_load(kit.control(), call_site_adr, TypeInstPtr::BOTTOM, T_OBJECT, Compile::AliasIdxRaw);
+Node* call_site_adr = kit.basic_plus_adr(cpcache_adr, call_site_offset);
+// The oops in the constant pool cache are not compressed; load then as raw pointers.
+Node* call_site     = kit.make_load(kit.control(), call_site_adr, call_site_type, T_ADDRESS, Compile::AliasIdxRaw);
 // Load the target MethodHandle from the CallSite object.
-Node* target_mh_adr = kit.basic_plus_adr(call_site, call_site, java_lang_invoke_CallSite::target_offset_in_bytes());
+const TypeOopPtr* target_type = TypeOopPtr::make_from_klass(C->env()->MethodHandle_klass());
-Node* target_mh = kit.make_load(kit.control(), target_mh_adr, TypeInstPtr::BOTTOM, T_OBJECT);
+Node* target_mh_adr = kit.basic_plus_adr(call_site, java_lang_invoke_CallSite::target_offset_in_bytes());
+Node* target_mh     = kit.make_load(kit.control(), target_mh_adr, target_type, T_OBJECT);
 address resolve_stub = SharedRuntime::get_resolve_opt_virtual_call_stub();
-CallStaticJavaNode *call = new (kit.C, tf()->domain()->cnt()) CallStaticJavaNode(tf(), resolve_stub, method(), kit.bci());
+CallStaticJavaNode* call = new (C, tf()->domain()->cnt()) CallStaticJavaNode(tf(), resolve_stub, method(), kit.bci());
 // invokedynamic is treated as an optimized invokevirtual.
 call->set_optimized_virtual(true);
 // Take extra care (in the presence of argument motion) not to trash the SP:
 call->set_method_handle_invoke(true);
 return new DirectCallGenerator(m, separate_io_proj);
 }
 CallGenerator* CallGenerator::for_virtual_call(ciMethod* m, int vtable_index) {
 assert(!m->is_static(), "for_virtual_call mismatch");
-assert(!m->is_method_handle_invoke(), "should be a direct call");
+assert(!m->is_method_handle_intrinsic(), "should be a direct call");
 return new VirtualCallGenerator(m, vtable_index);
 }
 CallGenerator* CallGenerator::for_dynamic_call(ciMethod* m) {
-assert(m->is_method_handle_invoke() || m->is_method_handle_adapter(), "for_dynamic_call mismatch");
+assert(m->is_compiled_lambda_form(), "for_dynamic_call mismatch");
+//@@ FIXME: this should be done via a direct call
 return new DynamicCallGenerator(m);
 }
 // Allow inlining decisions to be delayed
 class LateInlineCallGenerator : public DirectCallGenerator {
 }
 return kit.transfer_exceptions_into_jvms();
 }
-//------------------------PredictedDynamicCallGenerator-----------------------
+CallGenerator* CallGenerator::for_method_handle_call(JVMState* jvms, ciMethod* caller, ciMethod* callee) {
-// Internal class which handles all out-of-line calls checking receiver type.
+assert(callee->is_method_handle_intrinsic() ||
-class PredictedDynamicCallGenerator : public CallGenerator {
+callee->is_compiled_lambda_form(), "for_method_handle_call mismatch");
-ciMethodHandle* _predicted_method_handle;
+CallGenerator* cg = CallGenerator::for_method_handle_inline(jvms, caller, callee);
-CallGenerator*  _if_missed;
-CallGenerator*  _if_hit;
-float           _hit_prob;
-public:
-PredictedDynamicCallGenerator(ciMethodHandle* predicted_method_handle,
-CallGenerator* if_missed,
-CallGenerator* if_hit,
-float hit_prob)
-: CallGenerator(if_missed->method()),
-_predicted_method_handle(predicted_method_handle),
-_if_missed(if_missed),
-_if_hit(if_hit),
-_hit_prob(hit_prob)
-{}
-virtual bool is_inline()   const { return _if_hit->is_inline(); }
-virtual bool is_deferred() const { return _if_hit->is_deferred(); }
-virtual JVMState* generate(JVMState* jvms);
-};
-CallGenerator* CallGenerator::for_predicted_dynamic_call(ciMethodHandle* predicted_method_handle,
-CallGenerator* if_missed,
-CallGenerator* if_hit,
-float hit_prob) {
-return new PredictedDynamicCallGenerator(predicted_method_handle, if_missed, if_hit, hit_prob);
-}
-CallGenerator* CallGenerator::for_method_handle_call(Node* method_handle, JVMState* jvms,
-ciMethod* caller, ciMethod* callee, ciCallProfile profile) {
-assert(callee->is_method_handle_invoke() || callee->is_method_handle_adapter(), "for_method_handle_call mismatch");
-CallGenerator* cg = CallGenerator::for_method_handle_inline(method_handle, jvms, caller, callee, profile);
 if (cg != NULL)
 return cg;
 return CallGenerator::for_direct_call(callee);
 }
-CallGenerator* CallGenerator::for_method_handle_inline(Node* method_handle, JVMState* jvms,
+CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee) {
-ciMethod* caller, ciMethod* callee, ciCallProfile profile) {
-if (method_handle->Opcode() == Op_ConP) {
-const TypeOopPtr* oop_ptr = method_handle->bottom_type()->is_oopptr();
-ciObject* const_oop = oop_ptr->const_oop();
-ciMethodHandle* method_handle = const_oop->as_method_handle();
-// Set the callee to have access to the class and signature in
-// the MethodHandleCompiler.
-method_handle->set_callee(callee);
-method_handle->set_caller(caller);
-method_handle->set_call_profile(profile);
-// Get an adapter for the MethodHandle.
-ciMethod* target_method = method_handle->get_method_handle_adapter();
-if (target_method != NULL) {
-CallGenerator* cg = Compile::current()->call_generator(target_method, -1, false, jvms, true, PROB_ALWAYS);
-if (cg != NULL && cg->is_inline())
-return cg;
-}
-} else if (method_handle->Opcode() == Op_Phi && method_handle->req() == 3 &&
-method_handle->in(1)->Opcode() == Op_ConP && method_handle->in(2)->Opcode() == Op_ConP) {
-float prob = PROB_FAIR;
-Node* meth_region = method_handle->in(0);
-if (meth_region->is_Region() &&
-meth_region->in(1)->is_Proj() && meth_region->in(2)->is_Proj() &&
-meth_region->in(1)->in(0) == meth_region->in(2)->in(0) &&
-meth_region->in(1)->in(0)->is_If()) {
-// If diamond, so grab the probability of the test to drive the inlining below
-prob = meth_region->in(1)->in(0)->as_If()->_prob;
-if (meth_region->in(1)->is_IfTrue()) {
-prob = 1 - prob;
-}
-}
-// selectAlternative idiom merging two constant MethodHandles.
-// Generate a guard so that each can be inlined.  We might want to
-// do more inputs at later point but this gets the most common
-// case.
-CallGenerator* cg1 = for_method_handle_call(method_handle->in(1), jvms, caller, callee, profile.rescale(1.0 - prob));
-CallGenerator* cg2 = for_method_handle_call(method_handle->in(2), jvms, caller, callee, profile.rescale(prob));
-if (cg1 != NULL && cg2 != NULL) {
-const TypeOopPtr* oop_ptr = method_handle->in(1)->bottom_type()->is_oopptr();
-ciObject* const_oop = oop_ptr->const_oop();
-ciMethodHandle* mh = const_oop->as_method_handle();
-return new PredictedDynamicCallGenerator(mh, cg2, cg1, prob);
-}
-}
-return NULL;
-}
-CallGenerator* CallGenerator::for_invokedynamic_call(JVMState* jvms, ciMethod* caller, ciMethod* callee, ciCallProfile profile) {
-assert(callee->is_method_handle_invoke() || callee->is_method_handle_adapter(), "for_invokedynamic_call mismatch");
-// Get the CallSite object.
-ciBytecodeStream str(caller);
-str.force_bci(jvms->bci());  // Set the stream to the invokedynamic bci.
-ciCallSite* call_site = str.get_call_site();
-CallGenerator* cg = CallGenerator::for_invokedynamic_inline(call_site, jvms, caller, callee, profile);
-if (cg != NULL)
-return cg;
-return CallGenerator::for_dynamic_call(callee);
-}
-CallGenerator* CallGenerator::for_invokedynamic_inline(ciCallSite* call_site, JVMState* jvms,
-ciMethod* caller, ciMethod* callee, ciCallProfile profile) {
-ciMethodHandle* method_handle = call_site->get_target();
-// Set the callee to have access to the class and signature in the
-// MethodHandleCompiler.
-method_handle->set_callee(callee);
-method_handle->set_caller(caller);
-method_handle->set_call_profile(profile);
-// Get an adapter for the MethodHandle.
-ciMethod* target_method = method_handle->get_invokedynamic_adapter();
-if (target_method != NULL) {
-Compile *C = Compile::current();
-CallGenerator* cg = C->call_generator(target_method, -1, false, jvms, true, PROB_ALWAYS);
-if (cg != NULL && cg->is_inline()) {
-// Add a dependence for invalidation of the optimization.
-if (!call_site->is_constant_call_site()) {
-C->dependencies()->assert_call_site_target_value(call_site, method_handle);
-}
-return cg;
-}
-}
-return NULL;
-}
-JVMState* PredictedDynamicCallGenerator::generate(JVMState* jvms) {
 GraphKit kit(jvms);
 PhaseGVN& gvn = kit.gvn();
+Compile* C = kit.C;
-CompileLog* log = kit.C->log();
+vmIntrinsics::ID iid = callee->intrinsic_id();
-if (log != NULL) {
+switch (iid) {
-log->elem("predicted_dynamic_call bci='%d'", jvms->bci());
+case vmIntrinsics::_invokeBasic:
-}
+{
+// get MethodHandle receiver
-const TypeOopPtr* predicted_mh_ptr = TypeOopPtr::make_from_constant(_predicted_method_handle, true);
+Node* receiver = kit.argument(0);
-Node* predicted_mh = kit.makecon(predicted_mh_ptr);
+if (receiver->Opcode() == Op_ConP) {
+const TypeOopPtr* oop_ptr = receiver->bottom_type()->is_oopptr();
-Node* bol = NULL;
+ciMethod* target = oop_ptr->const_oop()->as_method_handle()->get_vmtarget();
-int bc = jvms->method()->java_code_at_bci(jvms->bci());
+guarantee(!target->is_method_handle_intrinsic(), "should not happen");  // XXX remove
-if (bc != Bytecodes::_invokedynamic) {
+const int vtable_index = methodOopDesc::invalid_vtable_index;
-// This is the selectAlternative idiom for guardWithTest or
+CallGenerator* cg = C->call_generator(target, vtable_index, false, jvms, true, PROB_ALWAYS);
-// similar idioms.
+if (cg != NULL && cg->is_inline())
-Node* receiver = kit.argument(0);
+return cg;
+} else {
-// Check if the MethodHandle is the expected one
+if (PrintInlining)  CompileTask::print_inlining(callee, jvms->depth() - 1, jvms->bci(), "receiver not constant");
-Node* cmp = gvn.transform(new(kit.C, 3) CmpPNode(receiver, predicted_mh));
+}
-bol = gvn.transform(new(kit.C, 2) BoolNode(cmp, BoolTest::eq) );
+}
-} else {
+break;
-// Get the constant pool cache from the caller class.
-ciMethod* caller_method = jvms->method();
+case vmIntrinsics::_linkToVirtual:
-ciBytecodeStream str(caller_method);
+case vmIntrinsics::_linkToStatic:
-str.force_bci(jvms->bci());  // Set the stream to the invokedynamic bci.
+case vmIntrinsics::_linkToSpecial:
-ciCPCache* cpcache = str.get_cpcache();
+case vmIntrinsics::_linkToInterface:
+{
-// Get the offset of the CallSite from the constant pool cache
+// pop MemberName argument
-// pointer.
+Node* member_name = kit.argument(callee->arg_size() - 1);
-int index = str.get_method_index();
+if (member_name->Opcode() == Op_ConP) {
-size_t call_site_offset = cpcache->get_f1_offset(index);
+const TypeOopPtr* oop_ptr = member_name->bottom_type()->is_oopptr();
+ciMethod* target = oop_ptr->const_oop()->as_member_name()->get_vmtarget();
-// Load the CallSite object from the constant pool cache.
-const TypeOopPtr* cpcache_ptr = TypeOopPtr::make_from_constant(cpcache);
+// In lamda forms we erase signature types to avoid resolving issues
-Node* cpcache_adr   = kit.makecon(cpcache_ptr);
+// involving class loaders.  When we optimize a method handle invoke
-Node* call_site_adr = kit.basic_plus_adr(cpcache_adr, cpcache_adr, call_site_offset);
+// to a direct call we must cast the receiver and arguments to its
-Node* call_site     = kit.make_load(kit.control(), call_site_adr, TypeInstPtr::BOTTOM, T_OBJECT, Compile::AliasIdxRaw);
+// actual types.
+ciSignature* signature = target->signature();
-// Load the target MethodHandle from the CallSite object.
+const int receiver_skip = target->is_static() ? 0 : 1;
-Node* target_adr = kit.basic_plus_adr(call_site, call_site, java_lang_invoke_CallSite::target_offset_in_bytes());
+// Cast receiver to its type.
-Node* target_mh  = kit.make_load(kit.control(), target_adr, TypeInstPtr::BOTTOM, T_OBJECT);
+if (!target->is_static()) {
+Node* arg = kit.argument(0);
-// Check if the MethodHandle is still the same.
+const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
-Node* cmp = gvn.transform(new(kit.C, 3) CmpPNode(target_mh, predicted_mh));
+const Type*       sig_type = TypeOopPtr::make_from_klass(signature->accessing_klass());
-bol = gvn.transform(new(kit.C, 2) BoolNode(cmp, BoolTest::eq) );
+if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
-}
+Node* cast_obj = gvn.transform(new (C, 2) CheckCastPPNode(kit.control(), arg, sig_type));
-IfNode* iff = kit.create_and_xform_if(kit.control(), bol, _hit_prob, COUNT_UNKNOWN);
+kit.set_argument(0, cast_obj);
-kit.set_control( gvn.transform(new(kit.C, 1) IfTrueNode (iff)));
+}
-Node* slow_ctl = gvn.transform(new(kit.C, 1) IfFalseNode(iff));
+}
+// Cast reference arguments to its type.
-SafePointNode* slow_map = NULL;
+for (int i = 0; i < signature->count(); i++) {
-JVMState* slow_jvms;
+ciType* t = signature->type_at(i);
-{ PreserveJVMState pjvms(&kit);
+if (t->is_klass()) {
-kit.set_control(slow_ctl);
+Node* arg = kit.argument(receiver_skip + i);
-if (!kit.stopped()) {
+const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
-slow_jvms = _if_missed->generate(kit.sync_jvms());
+const Type*       sig_type = TypeOopPtr::make_from_klass(t->as_klass());
-if (kit.failing())
+if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
-return NULL;  // might happen because of NodeCountInliningCutoff
+Node* cast_obj = gvn.transform(new (C, 2) CheckCastPPNode(kit.control(), arg, sig_type));
-assert(slow_jvms != NULL, "must be");
+kit.set_argument(receiver_skip + i, cast_obj);
-kit.add_exception_states_from(slow_jvms);
+}
-kit.set_map(slow_jvms->map());
+}
-if (!kit.stopped())
+}
-slow_map = kit.stop();
+const int vtable_index = methodOopDesc::invalid_vtable_index;
-}
+const bool call_is_virtual = target->is_abstract();  // FIXME workaround
-}
+CallGenerator* cg = C->call_generator(target, vtable_index, call_is_virtual, jvms, true, PROB_ALWAYS);
+if (cg != NULL && cg->is_inline())
-if (kit.stopped()) {
+return cg;
-// Instance exactly does not matches the desired type.
+}
-kit.set_jvms(slow_jvms);
+}
-return kit.transfer_exceptions_into_jvms();
+break;
-}
+default:
-// Make the hot call:
+fatal(err_msg_res("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)));
-JVMState* new_jvms = _if_hit->generate(kit.sync_jvms());
+break;
-if (new_jvms == NULL) {
+}
-// Inline failed, so make a direct call.
+return NULL;
-assert(_if_hit->is_inline(), "must have been a failed inline");
-CallGenerator* cg = CallGenerator::for_direct_call(_if_hit->method());
-new_jvms = cg->generate(kit.sync_jvms());
-}
-kit.add_exception_states_from(new_jvms);
-kit.set_jvms(new_jvms);
-// Need to merge slow and fast?
-if (slow_map == NULL) {
-// The fast path is the only path remaining.
-return kit.transfer_exceptions_into_jvms();
-}
-if (kit.stopped()) {
-// Inlined method threw an exception, so it's just the slow path after all.
-kit.set_jvms(slow_jvms);
-return kit.transfer_exceptions_into_jvms();
-}
-// Finish the diamond.
-kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
-RegionNode* region = new (kit.C, 3) RegionNode(3);
-region->init_req(1, kit.control());
-region->init_req(2, slow_map->control());
-kit.set_control(gvn.transform(region));
-Node* iophi = PhiNode::make(region, kit.i_o(), Type::ABIO);
-iophi->set_req(2, slow_map->i_o());
-kit.set_i_o(gvn.transform(iophi));
-kit.merge_memory(slow_map->merged_memory(), region, 2);
-uint tos = kit.jvms()->stkoff() + kit.sp();
-uint limit = slow_map->req();
-for (uint i = TypeFunc::Parms; i < limit; i++) {
-// Skip unused stack slots; fast forward to monoff();
-if (i == tos) {
-i = kit.jvms()->monoff();
-if( i >= limit ) break;
-}
-Node* m = kit.map()->in(i);
-Node* n = slow_map->in(i);
-if (m != n) {
-const Type* t = gvn.type(m)->meet(gvn.type(n));
-Node* phi = PhiNode::make(region, m, t);
-phi->set_req(2, n);
-kit.map()->set_req(i, gvn.transform(phi));
-}
-}
-return kit.transfer_exceptions_into_jvms();
 }
 //-------------------------UncommonTrapCallGenerator-----------------------------
 // Internal class which handles all out-of-line calls checking receiver type.

Mercurial > hg > truffle

comparison src/share/vm/opto/callGenerator.cpp @ 6275:957c266d8bc5