graal-jvmci-8: src/share/vm/c1/c1_GraphBuilder.cpp comparison

comparison src/share/vm/c1/c1_GraphBuilder.cpp @ 13086:096c224171c4

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

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 20 Nov 2013 00:10:38 +0100
parents	cefad50507d8 144b23411b51
children	0097301f34fa

comparison

equal deleted inserted replaced

-:92b7ec34ddfa
+:096c224171c4
 }
 // State at end of inlined method is the state of the caller
 // without the method parameters on stack, including the
 // return value, if any, of the inlined method on operand stack.
+int invoke_bci = state()->caller_state()->bci();
 set_state(state()->caller_state()->copy_for_parsing());
 if (x != NULL) {
 state()->push(x->type(), x);
+if (profile_return() && x->type()->is_object_kind()) {
+ciMethod* caller = state()->scope()->method();
+ciMethodData* md = caller->method_data_or_null();
+ciProfileData* data = md->bci_to_data(invoke_bci);
+if (data->is_CallTypeData() || data->is_VirtualCallTypeData()) {
+bool has_return = data->is_CallTypeData() ? ((ciCallTypeData*)data)->has_return() : ((ciVirtualCallTypeData*)data)->has_return();
+// May not be true in case of an inlined call through a method handle intrinsic.
+if (has_return) {
+profile_return_type(x, method(), caller, invoke_bci);
+}
+}
+}
 }
 Goto* goto_callee = new Goto(continuation(), false);
 // See whether this is the first return; if so, store off some
 // of the state for later examination
 Dependencies* GraphBuilder::dependency_recorder() const {
 assert(DeoptC1, "need debug information");
 return compilation()->dependency_recorder();
 }
+// How many arguments do we want to profile?
+Values* GraphBuilder::args_list_for_profiling(ciMethod* target, int& start, bool may_have_receiver) {
+int n = 0;
+bool has_receiver = may_have_receiver && Bytecodes::has_receiver(method()->java_code_at_bci(bci()));
+start = has_receiver ? 1 : 0;
+if (profile_arguments()) {
+ciProfileData* data = method()->method_data()->bci_to_data(bci());
+if (data->is_CallTypeData() || data->is_VirtualCallTypeData()) {
+n = data->is_CallTypeData() ? data->as_CallTypeData()->number_of_arguments() : data->as_VirtualCallTypeData()->number_of_arguments();
+}
+}
+// If we are inlining then we need to collect arguments to profile parameters for the target
+if (profile_parameters() && target != NULL) {
+if (target->method_data() != NULL && target->method_data()->parameters_type_data() != NULL) {
+// The receiver is profiled on method entry so it's included in
+// the number of parameters but here we're only interested in
+// actual arguments.
+n = MAX2(n, target->method_data()->parameters_type_data()->number_of_parameters() - start);
+}
+}
+if (n > 0) {
+return new Values(n);
+}
+return NULL;
+}
+// Collect arguments that we want to profile in a list
+Values* GraphBuilder::collect_args_for_profiling(Values* args, ciMethod* target, bool may_have_receiver) {
+int start = 0;
+Values* obj_args = args_list_for_profiling(target, start, may_have_receiver);
+if (obj_args == NULL) {
+return NULL;
+}
+int s = obj_args->size();
+for (int i = start, j = 0; j < s; i++) {
+if (args->at(i)->type()->is_object_kind()) {
+obj_args->push(args->at(i));
+j++;
+}
+}
+assert(s == obj_args->length(), "missed on arg?");
+return obj_args;
+}
 void GraphBuilder::invoke(Bytecodes::Code code) {
 bool will_link;
 ciSignature* declared_signature = NULL;
 ciMethod*             target = stream()->get_method(will_link, &declared_signature);
 // equal to the number of implementors for target->holder() so
 // if number of implementors of target->holder() == 1 then
 // number of implementors for decl_interface is 0 or 1. If
 // it's 0 then no class implements decl_interface and there's
 // no point in inlining.
-if (!holder->is_loaded() || decl_interface->nof_implementors() != 1) {
+if (!holder->is_loaded() || decl_interface->nof_implementors() != 1 || decl_interface->has_default_methods()) {
 singleton = NULL;
 }
 }
 if (singleton) {
 cha_monomorphic_target = target->find_monomorphic_target(calling_klass, target->holder(), singleton);
 if (cha_monomorphic_target != NULL) {
 target_klass = cha_monomorphic_target->holder();
 } else if (exact_target != NULL) {
 target_klass = exact_target->holder();
 }
-profile_call(target, recv, target_klass);
+profile_call(target, recv, target_klass, collect_args_for_profiling(args, NULL, false), false);
 }
 }
 Invoke* result = new Invoke(code, result_type, recv, args, vtable_index, target, state_before);
 // push result
 if (method()->is_strict()) {
 push(result_type, round_fp(result));
 } else {
 push(result_type, result);
 }
+}
+if (profile_return() && result_type->is_object_kind()) {
+profile_return_type(result, target);
 }
 }
 void GraphBuilder::new_instance(int klass_index) {
 Value recv = NULL;
 if (has_receiver) {
 recv = args->at(0);
 null_check(recv);
 }
-profile_call(callee, recv, NULL);
+profile_call(callee, recv, NULL, collect_args_for_profiling(args, callee, true), true);
 }
 }
 }
 Intrinsic* result = new Intrinsic(result_type, id, args, has_receiver, state_before,
 preserves_state, cantrap);
 // append instruction & push result
 Value value = append_split(result);
 if (result_type != voidType) push(result_type, value);
+if (callee != method() && profile_return() && result_type->is_object_kind()) {
+profile_return_type(result, callee);
+}
 // done
 return true;
 }
 INLINE_BAILOUT("mdo allocation failed");
 }
 // now perform tests that are based on flag settings
 if (callee->force_inline()) {
+if (inline_level() > MaxForceInlineLevel) INLINE_BAILOUT("MaxForceInlineLevel");
 print_inlining(callee, "force inline by annotation");
 } else if (callee->should_inline()) {
 print_inlining(callee, "force inline by CompileOracle");
 } else {
 // use heuristic controls on inlining
 // Note that we'd collect profile data in this method if we wanted it.
 // this may be redundant here...
 compilation()->set_would_profile(true);
 if (profile_calls()) {
-profile_call(callee, recv, holder_known ? callee->holder() : NULL);
+int start = 0;
+Values* obj_args = args_list_for_profiling(callee, start, has_receiver);
+if (obj_args != NULL) {
+int s = obj_args->size();
+// if called through method handle invoke, some arguments may have been popped
+for (int i = args_base+start, j = 0; j < obj_args->size() && i < state()->stack_size(); ) {
+Value v = state()->stack_at_inc(i);
+if (v->type()->is_object_kind()) {
+obj_args->push(v);
+j++;
+}
+}
+#ifdef ASSERT
+{
+bool ignored_will_link;
+ciSignature* declared_signature = NULL;
+ciMethod* real_target = method()->get_method_at_bci(bci(), ignored_will_link, &declared_signature);
+assert(s == obj_args->length() || real_target->is_method_handle_intrinsic(), "missed on arg?");
+}
+#endif
+}
+profile_call(callee, recv, holder_known ? callee->holder() : NULL, obj_args, true);
 }
 }
 // Introduce a new callee continuation point - if the callee has
 // more than one return instruction or the return does not allow
 void GraphBuilder::print_stats() {
 vmap()->print();
 }
 #endif // PRODUCT
-void GraphBuilder::profile_call(ciMethod* callee, Value recv, ciKlass* known_holder) {
+void GraphBuilder::profile_call(ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined) {
-append(new ProfileCall(method(), bci(), callee, recv, known_holder));
+// A default method's holder is an interface
+if (known_holder != NULL && known_holder->is_interface()) {
+assert(known_holder->is_instance_klass() && ((ciInstanceKlass*)known_holder)->has_default_methods(), "should be default method");
+known_holder = NULL;
+}
+append(new ProfileCall(method(), bci(), callee, recv, known_holder, obj_args, inlined));
+}
+void GraphBuilder::profile_return_type(Value ret, ciMethod* callee, ciMethod* m, int invoke_bci) {
+assert((m == NULL) == (invoke_bci < 0), "invalid method and invalid bci together");
+if (m == NULL) {
+m = method();
+}
+if (invoke_bci < 0) {
+invoke_bci = bci();
+}
+ciMethodData* md = m->method_data_or_null();
+ciProfileData* data = md->bci_to_data(invoke_bci);
+if (data->is_CallTypeData() || data->is_VirtualCallTypeData()) {
+append(new ProfileReturnType(m , invoke_bci, callee, ret));
+}
 }
 void GraphBuilder::profile_invocation(ciMethod* callee, ValueStack* state) {
 append(new ProfileInvoke(callee, state));
 }

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/c1/c1_GraphBuilder.cpp @ 13086:096c224171c4