truffle: src/share/vm/c1/c1_GraphBuilder.cpp comparison

comparison src/share/vm/c1/c1_GraphBuilder.cpp @ 1783:d5d065957597

6953144: Tiered compilation Summary: Infrastructure for tiered compilation support (interpreter + c1 + c2) for 32 and 64 bit. Simple tiered policy implementation. Reviewed-by: kvn, never, phh, twisti

author	iveresov
date	Fri, 03 Sep 2010 17:51:07 -0700
parents	136b78722a08
children	3a294e483abc

comparison

equal deleted inserted replaced

-:f353275af40e
+:d5d065957597
 store_local(intType, index);
 }
 void GraphBuilder::_goto(int from_bci, int to_bci) {
-profile_bci(from_bci);
+Goto *x = new Goto(block_at(to_bci), to_bci <= from_bci);
-append(new Goto(block_at(to_bci), to_bci <= from_bci));
+if (is_profiling()) {
+compilation()->set_would_profile(true);
+}
+if (profile_branches()) {
+x->set_profiled_method(method());
+x->set_profiled_bci(bci());
+x->set_should_profile(true);
+}
+append(x);
 }
 void GraphBuilder::if_node(Value x, If::Condition cond, Value y, ValueStack* state_before) {
 BlockBegin* tsux = block_at(stream()->get_dest());
 BlockBegin* fsux = block_at(stream()->next_bci());
 bool is_bb = tsux->bci() < stream()->cur_bci() || fsux->bci() < stream()->cur_bci();
-If* if_node = append(new If(x, cond, false, y, tsux, fsux, is_bb ? state_before : NULL, is_bb))->as_If();
+Instruction *i = append(new If(x, cond, false, y, tsux, fsux, is_bb ? state_before : NULL, is_bb));
-if (profile_branches() && (if_node != NULL)) {
-if_node->set_profiled_method(method());
+if (is_profiling()) {
-if_node->set_profiled_bci(bci());
+If* if_node = i->as_If();
-if_node->set_should_profile(true);
+if (if_node != NULL) {
+// Note that we'd collect profile data in this method if we wanted it.
+compilation()->set_would_profile(true);
+// At level 2 we need the proper bci to count backedges
+if_node->set_profiled_bci(bci());
+if (profile_branches()) {
+// Successors can be rotated by the canonicalizer, check for this case.
+if_node->set_profiled_method(method());
+if_node->set_should_profile(true);
+if (if_node->tsux() == fsux) {
+if_node->set_swapped(true);
+}
+}
+return;
+}
+// Check if this If was reduced to Goto.
+Goto *goto_node = i->as_Goto();
+if (goto_node != NULL) {
+compilation()->set_would_profile(true);
+if (profile_branches()) {
+goto_node->set_profiled_method(method());
+goto_node->set_profiled_bci(bci());
+goto_node->set_should_profile(true);
+// Find out which successor is used.
+if (goto_node->default_sux() == tsux) {
+goto_node->set_direction(Goto::taken);
+} else if (goto_node->default_sux() == fsux) {
+goto_node->set_direction(Goto::not_taken);
+} else {
+ShouldNotReachHere();
+}
+}
+return;
+}
 }
 }
 void GraphBuilder::if_zero(ValueType* type, If::Condition cond) {
 }
 #endif
 if (recv != NULL &&
 (code == Bytecodes::_invokespecial ||
-!is_loaded || target->is_final() ||
+!is_loaded || target->is_final())) {
-profile_calls())) {
 // invokespecial always needs a NULL check.  invokevirtual where
 // the target is final or where it's not known that whether the
 // target is final requires a NULL check.  Otherwise normal
 // invokevirtual will perform the null check during the lookup
 // logic or the unverified entry point.  Profiling of calls
 // requires that the null check is performed in all cases.
 null_check(recv);
 }
-if (profile_calls()) {
+if (is_profiling()) {
-assert(cha_monomorphic_target == NULL || exact_target == NULL, "both can not be set");
+if (recv != NULL && profile_calls()) {
-ciKlass* target_klass = NULL;
+null_check(recv);
-if (cha_monomorphic_target != NULL) {
+}
-target_klass = cha_monomorphic_target->holder();
+// Note that we'd collect profile data in this method if we wanted it.
-} else if (exact_target != NULL) {
+compilation()->set_would_profile(true);
-target_klass = exact_target->holder();
-}
+if (profile_calls()) {
-profile_call(recv, target_klass);
+assert(cha_monomorphic_target == NULL || exact_target == NULL, "both can not be set");
+ciKlass* target_klass = NULL;
+if (cha_monomorphic_target != NULL) {
+target_klass = cha_monomorphic_target->holder();
+} else if (exact_target != NULL) {
+target_klass = exact_target->holder();
+}
+profile_call(recv, target_klass);
+}
 }
 Invoke* result = new Invoke(code, result_type, recv, args, vtable_index, target, state_before);
 // push result
 append_split(result);
 ciKlass* klass = stream()->get_klass(will_link);
 ValueStack* state_before = !klass->is_loaded() || PatchALot ? state()->copy() : NULL;
 CheckCast* c = new CheckCast(klass, apop(), state_before);
 apush(append_split(c));
 c->set_direct_compare(direct_compare(klass));
-if (profile_checkcasts()) {
-c->set_profiled_method(method());
+if (is_profiling()) {
-c->set_profiled_bci(bci());
+// Note that we'd collect profile data in this method if we wanted it.
-c->set_should_profile(true);
+compilation()->set_would_profile(true);
+if (profile_checkcasts()) {
+c->set_profiled_method(method());
+c->set_profiled_bci(bci());
+c->set_should_profile(true);
+}
 }
 }
 void GraphBuilder::instance_of(int klass_index) {
 return fp_value;
 }
 Instruction* GraphBuilder::append_with_bci(Instruction* instr, int bci) {
-Canonicalizer canon(instr, bci);
+Canonicalizer canon(compilation(), instr, bci);
 Instruction* i1 = canon.canonical();
 if (i1->bci() != -99) {
 // Canonicalizer returned an instruction which was already
 // appended so simply return it.
 return i1;
 // create header block
 BlockBegin* h = new BlockBegin(entry->bci());
 h->set_depth_first_number(0);
 Value l = h;
-if (profile_branches()) {
-// Increment the invocation count on entry to the method.  We
-// can't use profile_invocation here because append isn't setup to
-// work properly at this point.  The instruction have to be
-// appended to the instruction stream by hand.
-Value m = new Constant(new ObjectConstant(compilation()->method()));
-h->set_next(m, 0);
-Value p = new ProfileCounter(m, methodOopDesc::interpreter_invocation_counter_offset_in_bytes(), 1);
-m->set_next(p, 0);
-l = p;
-}
 BlockEnd* g = new Goto(entry, false);
 l->set_next(g, entry->bci());
 h->set_end(g);
 h->set(f);
 // setup header block end state
 // necesary if std_entry is also a backward branch target because
 // then phi functions may be necessary in the header block.  It's
 // also necessary when profiling so that there's a single block that
 // can increment the interpreter_invocation_count.
 BlockBegin* new_header_block;
-if (std_entry->number_of_preds() == 0 && !profile_branches()) {
+if (std_entry->number_of_preds() > 0 || count_invocations() || count_backedges()) {
+new_header_block = header_block(std_entry, BlockBegin::std_entry_flag, state);
+} else {
 new_header_block = std_entry;
-} else {
-new_header_block = header_block(std_entry, BlockBegin::std_entry_flag, state);
 }
 // setup start block (root for the IR graph)
 Base* base =
 new Base(
 const bool has_receiver = !callee->is_static();
 ValueType* result_type = as_ValueType(callee->return_type());
 Values* args = state()->pop_arguments(callee->arg_size());
 ValueStack* locks = lock_stack();
-if (profile_calls()) {
+if (is_profiling()) {
 // Don't profile in the special case where the root method
 // is the intrinsic
 if (callee != method()) {
-Value recv = NULL;
+// Note that we'd collect profile data in this method if we wanted it.
-if (has_receiver) {
+compilation()->set_would_profile(true);
-recv = args->at(0);
+if (profile_calls()) {
-null_check(recv);
+Value recv = NULL;
-}
+if (has_receiver) {
-profile_call(recv, NULL);
+recv = args->at(0);
+null_check(recv);
+}
+profile_call(recv, NULL);
+}
 }
 }
 Intrinsic* result = new Intrinsic(result_type, id, args, has_receiver, lock_stack(),
 preserves_state, cantrap);
 }
 bool GraphBuilder::try_inline_full(ciMethod* callee, bool holder_known) {
 assert(!callee->is_native(), "callee must not be native");
+if (count_backedges() && callee->has_loops()) {
+INLINE_BAILOUT("too complex for tiered");
+}
 // first perform tests of things it's not possible to inline
 if (callee->has_exception_handlers() &&
 !InlineMethodsWithExceptionHandlers) INLINE_BAILOUT("callee has exception handlers");
 if (callee->is_synchronized() &&
 !InlineSynchronizedMethods         ) INLINE_BAILOUT("callee is synchronized");
 assert(callee->arg_size() > 0, "must have at least a receiver");
 recv = state()->stack_at(args_base);
 null_check(recv);
 }
-if (profile_inlined_calls()) {
+if (is_profiling()) {
-profile_call(recv, holder_known ? callee->holder() : NULL);
+// Note that we'd collect profile data in this method if we wanted it.
-}
+// this may be redundant here...
+compilation()->set_would_profile(true);
-profile_invocation(callee);
+if (profile_calls()) {
+profile_call(recv, holder_known ? callee->holder() : NULL);
+}
+if (profile_inlined_calls()) {
+profile_invocation(callee, state(), 0);
+}
+}
 // Introduce a new callee continuation point - if the callee has
 // more than one return instruction or the return does not allow
 // fall-through of control flow, all return instructions of the
 // callee will need to be replaced by Goto's pointing to this
 void GraphBuilder::print_stats() {
 vmap()->print();
 }
 #endif // PRODUCT
 void GraphBuilder::profile_call(Value recv, ciKlass* known_holder) {
 append(new ProfileCall(method(), bci(), recv, known_holder));
 }
+void GraphBuilder::profile_invocation(ciMethod* callee, ValueStack* state, int bci) {
-void GraphBuilder::profile_invocation(ciMethod* callee) {
+append(new ProfileInvoke(callee, state, bci));
-if (profile_calls()) {
+}
-// increment the interpreter_invocation_count for the inlinee
-Value m = append(new Constant(new ObjectConstant(callee)));
-append(new ProfileCounter(m, methodOopDesc::interpreter_invocation_counter_offset_in_bytes(), 1));
-}
-}
-void GraphBuilder::profile_bci(int bci) {
-if (profile_branches()) {
-ciMethodData* md = method()->method_data();
-if (md == NULL) {
-BAILOUT("out of memory building methodDataOop");
-}
-ciProfileData* data = md->bci_to_data(bci);
-assert(data != NULL && data->is_JumpData(), "need JumpData for goto");
-Value mdo = append(new Constant(new ObjectConstant(md)));
-append(new ProfileCounter(mdo, md->byte_offset_of_slot(data, JumpData::taken_offset()), 1));
-}
-}

Mercurial > hg > truffle

comparison src/share/vm/c1/c1_GraphBuilder.cpp @ 1783:d5d065957597