--- a/hotspot/src/share/vm/opto/compile.cpp Tue Apr 08 09:51:25 2014 +0200
+++ b/hotspot/src/share/vm/opto/compile.cpp Wed Apr 09 09:17:43 2014 +0200
@@ -662,6 +662,7 @@
_inlining_progress(false),
_inlining_incrementally(false),
_print_inlining_list(NULL),
+ _print_inlining_stream(NULL),
_print_inlining_idx(0),
_preserve_jvm_state(0) {
C = this;
@@ -723,9 +724,7 @@
PhaseGVN gvn(node_arena(), estimated_size);
set_initial_gvn(&gvn);
- if (print_inlining() || print_intrinsics()) {
- _print_inlining_list = new (comp_arena())GrowableArray<PrintInliningBuffer>(comp_arena(), 1, 1, PrintInliningBuffer());
- }
+ print_inlining_init();
{ // Scope for timing the parser
TracePhase t3("parse", &_t_parser, true);
@@ -967,6 +966,7 @@
_inlining_progress(false),
_inlining_incrementally(false),
_print_inlining_list(NULL),
+ _print_inlining_stream(NULL),
_print_inlining_idx(0),
_preserve_jvm_state(0),
_allowed_reasons(0) {
@@ -2023,6 +2023,8 @@
ResourceMark rm;
int loop_opts_cnt;
+ print_inlining_reinit();
+
NOT_PRODUCT( verify_graph_edges(); )
print_method(PHASE_AFTER_PARSING);
@@ -3755,30 +3757,114 @@
}
}
-void Compile::dump_inlining() {
+// The message about the current inlining is accumulated in
+// _print_inlining_stream and transfered into the _print_inlining_list
+// once we know whether inlining succeeds or not. For regular
+// inlining, messages are appended to the buffer pointed by
+// _print_inlining_idx in the _print_inlining_list. For late inlining,
+// a new buffer is added after _print_inlining_idx in the list. This
+// way we can update the inlining message for late inlining call site
+// when the inlining is attempted again.
+void Compile::print_inlining_init() {
+ if (print_inlining() || print_intrinsics()) {
+ _print_inlining_stream = new stringStream();
+ _print_inlining_list = new (comp_arena())GrowableArray<PrintInliningBuffer>(comp_arena(), 1, 1, PrintInliningBuffer());
+ }
+}
+
+void Compile::print_inlining_reinit() {
+ if (print_inlining() || print_intrinsics()) {
+ // Re allocate buffer when we change ResourceMark
+ _print_inlining_stream = new stringStream();
+ }
+}
+
+void Compile::print_inlining_reset() {
+ _print_inlining_stream->reset();
+}
+
+void Compile::print_inlining_commit() {
+ assert(print_inlining() || print_intrinsics(), "PrintInlining off?");
+ // Transfer the message from _print_inlining_stream to the current
+ // _print_inlining_list buffer and clear _print_inlining_stream.
+ _print_inlining_list->at(_print_inlining_idx).ss()->write(_print_inlining_stream->as_string(), _print_inlining_stream->size());
+ print_inlining_reset();
+}
+
+void Compile::print_inlining_push() {
+ // Add new buffer to the _print_inlining_list at current position
+ _print_inlining_idx++;
+ _print_inlining_list->insert_before(_print_inlining_idx, PrintInliningBuffer());
+}
+
+Compile::PrintInliningBuffer& Compile::print_inlining_current() {
+ return _print_inlining_list->at(_print_inlining_idx);
+}
+
+void Compile::print_inlining_update(CallGenerator* cg) {
if (print_inlining() || print_intrinsics()) {
+ if (!cg->is_late_inline()) {
+ if (print_inlining_current().cg() != NULL) {
+ print_inlining_push();
+ }
+ print_inlining_commit();
+ } else {
+ if (print_inlining_current().cg() != cg &&
+ (print_inlining_current().cg() != NULL ||
+ print_inlining_current().ss()->size() != 0)) {
+ print_inlining_push();
+ }
+ print_inlining_commit();
+ print_inlining_current().set_cg(cg);
+ }
+ }
+}
+
+void Compile::print_inlining_move_to(CallGenerator* cg) {
+ // We resume inlining at a late inlining call site. Locate the
+ // corresponding inlining buffer so that we can update it.
+ if (print_inlining()) {
+ for (int i = 0; i < _print_inlining_list->length(); i++) {
+ if (_print_inlining_list->adr_at(i)->cg() == cg) {
+ _print_inlining_idx = i;
+ return;
+ }
+ }
+ ShouldNotReachHere();
+ }
+}
+
+void Compile::print_inlining_update_delayed(CallGenerator* cg) {
+ if (print_inlining()) {
+ assert(_print_inlining_stream->size() > 0, "missing inlining msg");
+ assert(print_inlining_current().cg() == cg, "wrong entry");
+ // replace message with new message
+ _print_inlining_list->at_put(_print_inlining_idx, PrintInliningBuffer());
+ print_inlining_commit();
+ print_inlining_current().set_cg(cg);
+ }
+}
+
+void Compile::print_inlining_assert_ready() {
+ assert(!_print_inlining || _print_inlining_stream->size() == 0, "loosing data");
+}
+
+void Compile::dump_inlining() {
+ bool do_print_inlining = print_inlining() || print_intrinsics();
+ if (do_print_inlining) {
// Print inlining message for candidates that we couldn't inline
- // for lack of space or non constant receiver
+ // for lack of space
for (int i = 0; i < _late_inlines.length(); i++) {
CallGenerator* cg = _late_inlines.at(i);
- cg->print_inlining_late("live nodes > LiveNodeCountInliningCutoff");
- }
- Unique_Node_List useful;
- useful.push(root());
- for (uint next = 0; next < useful.size(); ++next) {
- Node* n = useful.at(next);
- if (n->is_Call() && n->as_Call()->generator() != NULL && n->as_Call()->generator()->call_node() == n) {
- CallNode* call = n->as_Call();
- CallGenerator* cg = call->generator();
- cg->print_inlining_late("receiver not constant");
- }
- uint max = n->len();
- for ( uint i = 0; i < max; ++i ) {
- Node *m = n->in(i);
- if ( m == NULL ) continue;
- useful.push(m);
+ if (!cg->is_mh_late_inline()) {
+ const char* msg = "live nodes > LiveNodeCountInliningCutoff";
+ if (do_print_inlining) {
+ cg->print_inlining_late(msg);
+ }
}
}
+ }
+ if (do_print_inlining) {
for (int i = 0; i < _print_inlining_list->length(); i++) {
tty->print(_print_inlining_list->adr_at(i)->ss()->as_string());
}