truffle: src/share/vm/opto/escape.cpp annotate

annotate src/share/vm/opto/escape.cpp @ 2459:55973726c600

6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice Summary: Swap checks: check for regular memory slice first and keep input phi. Reviewed-by: never

author	kvn
date	Wed, 06 Apr 2011 17:32:09 -0700
parents	3763ca6579b7
children	66b0e2371912

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	2 * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1539 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1539 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1539 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	26 #include "ci/bcEscapeAnalyzer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	27 #include "libadt/vectset.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	28 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	29 #include "opto/c2compiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	30 #include "opto/callnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	31 #include "opto/cfgnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	32 #include "opto/compile.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	33 #include "opto/escape.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	34 #include "opto/phaseX.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1921 diff changeset	35 #include "opto/rootnode.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 void PointsToNode::add_edge(uint targIdx, PointsToNode::EdgeType et) {
a61af66fc99e Initial load duke parents: diff changeset	38 uint v = (targIdx << EdgeShift) + ((uint) et);
a61af66fc99e Initial load duke parents: diff changeset	39 if (_edges == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	40 Arena *a = Compile::current()->comp_arena();
a61af66fc99e Initial load duke parents: diff changeset	41 _edges = new(a) GrowableArray<uint>(a, INITIAL_EDGE_COUNT, 0, 0);
a61af66fc99e Initial load duke parents: diff changeset	42 }
a61af66fc99e Initial load duke parents: diff changeset	43 _edges->append_if_missing(v);
a61af66fc99e Initial load duke parents: diff changeset	44 }
a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 void PointsToNode::remove_edge(uint targIdx, PointsToNode::EdgeType et) {
a61af66fc99e Initial load duke parents: diff changeset	47 uint v = (targIdx << EdgeShift) + ((uint) et);
a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49 _edges->remove(v);
a61af66fc99e Initial load duke parents: diff changeset	50 }
a61af66fc99e Initial load duke parents: diff changeset	51
a61af66fc99e Initial load duke parents: diff changeset	52 #ifndef PRODUCT
77 36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	53 static const char *node_type_names[] = {
0 a61af66fc99e Initial load duke parents: diff changeset	54 "UnknownType",
a61af66fc99e Initial load duke parents: diff changeset	55 "JavaObject",
a61af66fc99e Initial load duke parents: diff changeset	56 "LocalVar",
a61af66fc99e Initial load duke parents: diff changeset	57 "Field"
a61af66fc99e Initial load duke parents: diff changeset	58 };
a61af66fc99e Initial load duke parents: diff changeset	59
77 36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	60 static const char *esc_names[] = {
0 a61af66fc99e Initial load duke parents: diff changeset	61 "UnknownEscape",
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	62 "NoEscape",
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	63 "ArgEscape",
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	64 "GlobalEscape"
0 a61af66fc99e Initial load duke parents: diff changeset	65 };
a61af66fc99e Initial load duke parents: diff changeset	66
77 36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	67 static const char *edge_type_suffix[] = {
0 a61af66fc99e Initial load duke parents: diff changeset	68 "?", // UnknownEdge
a61af66fc99e Initial load duke parents: diff changeset	69 "P", // PointsToEdge
a61af66fc99e Initial load duke parents: diff changeset	70 "D", // DeferredEdge
a61af66fc99e Initial load duke parents: diff changeset	71 "F" // FieldEdge
a61af66fc99e Initial load duke parents: diff changeset	72 };
a61af66fc99e Initial load duke parents: diff changeset	73
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	74 void PointsToNode::dump(bool print_state) const {
0 a61af66fc99e Initial load duke parents: diff changeset	75 NodeType nt = node_type();
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	76 tty->print("%s ", node_type_names[(int) nt]);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	77 if (print_state) {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	78 EscapeState es = escape_state();
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	79 tty->print("%s %s ", esc_names[(int) es], _scalar_replaceable ? "":"NSR");
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	80 }
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	81 tty->print("[[");
0 a61af66fc99e Initial load duke parents: diff changeset	82 for (uint i = 0; i < edge_count(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	83 tty->print(" %d%s", edge_target(i), edge_type_suffix[(int) edge_type(i)]);
a61af66fc99e Initial load duke parents: diff changeset	84 }
a61af66fc99e Initial load duke parents: diff changeset	85 tty->print("]] ");
a61af66fc99e Initial load duke parents: diff changeset	86 if (_node == NULL)
a61af66fc99e Initial load duke parents: diff changeset	87 tty->print_cr("<null>");
a61af66fc99e Initial load duke parents: diff changeset	88 else
a61af66fc99e Initial load duke parents: diff changeset	89 _node->dump();
a61af66fc99e Initial load duke parents: diff changeset	90 }
a61af66fc99e Initial load duke parents: diff changeset	91 #endif
a61af66fc99e Initial load duke parents: diff changeset	92
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	93 ConnectionGraph::ConnectionGraph(Compile * C, PhaseIterGVN *igvn) :
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	94 _nodes(C->comp_arena(), C->unique(), C->unique(), PointsToNode()),
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	95 _processed(C->comp_arena()),
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	96 pt_ptset(C->comp_arena()),
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	97 pt_visited(C->comp_arena()),
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	98 pt_worklist(C->comp_arena(), 4, 0, 0),
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	99 _collecting(true),
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	100 _progress(false),
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	101 _compile(C),
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	102 _igvn(igvn),
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	103 _node_map(C->comp_arena()) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	104
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	105 _phantom_object = C->top()->_idx,
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	106 add_node(C->top(), PointsToNode::JavaObject, PointsToNode::GlobalEscape,true);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	107
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	108 // Add ConP(#NULL) and ConN(#NULL) nodes.
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	109 Node* oop_null = igvn->zerocon(T_OBJECT);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	110 _oop_null = oop_null->_idx;
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	111 assert(_oop_null < C->unique(), "should be created already");
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	112 add_node(oop_null, PointsToNode::JavaObject, PointsToNode::NoEscape, true);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	113
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	114 if (UseCompressedOops) {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	115 Node* noop_null = igvn->zerocon(T_NARROWOOP);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	116 _noop_null = noop_null->_idx;
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	117 assert(_noop_null < C->unique(), "should be created already");
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	118 add_node(noop_null, PointsToNode::JavaObject, PointsToNode::NoEscape, true);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	119 }
0 a61af66fc99e Initial load duke parents: diff changeset	120 }
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 void ConnectionGraph::add_pointsto_edge(uint from_i, uint to_i) {
a61af66fc99e Initial load duke parents: diff changeset	123 PointsToNode *f = ptnode_adr(from_i);
a61af66fc99e Initial load duke parents: diff changeset	124 PointsToNode *t = ptnode_adr(to_i);
a61af66fc99e Initial load duke parents: diff changeset	125
a61af66fc99e Initial load duke parents: diff changeset	126 assert(f->node_type() != PointsToNode::UnknownType && t->node_type() != PointsToNode::UnknownType, "node types must be set");
a61af66fc99e Initial load duke parents: diff changeset	127 assert(f->node_type() == PointsToNode::LocalVar \|\| f->node_type() == PointsToNode::Field, "invalid source of PointsTo edge");
a61af66fc99e Initial load duke parents: diff changeset	128 assert(t->node_type() == PointsToNode::JavaObject, "invalid destination of PointsTo edge");
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	129 add_edge(f, to_i, PointsToNode::PointsToEdge);
0 a61af66fc99e Initial load duke parents: diff changeset	130 }
a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 void ConnectionGraph::add_deferred_edge(uint from_i, uint to_i) {
a61af66fc99e Initial load duke parents: diff changeset	133 PointsToNode *f = ptnode_adr(from_i);
a61af66fc99e Initial load duke parents: diff changeset	134 PointsToNode *t = ptnode_adr(to_i);
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 assert(f->node_type() != PointsToNode::UnknownType && t->node_type() != PointsToNode::UnknownType, "node types must be set");
a61af66fc99e Initial load duke parents: diff changeset	137 assert(f->node_type() == PointsToNode::LocalVar \|\| f->node_type() == PointsToNode::Field, "invalid source of Deferred edge");
a61af66fc99e Initial load duke parents: diff changeset	138 assert(t->node_type() == PointsToNode::LocalVar \|\| t->node_type() == PointsToNode::Field, "invalid destination of Deferred edge");
a61af66fc99e Initial load duke parents: diff changeset	139 // don't add a self-referential edge, this can occur during removal of
a61af66fc99e Initial load duke parents: diff changeset	140 // deferred edges
a61af66fc99e Initial load duke parents: diff changeset	141 if (from_i != to_i)
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	142 add_edge(f, to_i, PointsToNode::DeferredEdge);
0 a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	145 int ConnectionGraph::address_offset(Node* adr, PhaseTransform *phase) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	146 const Type *adr_type = phase->type(adr);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	147 if (adr->is_AddP() && adr_type->isa_oopptr() == NULL &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	148 adr->in(AddPNode::Address)->is_Proj() &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	149 adr->in(AddPNode::Address)->in(0)->is_Allocate()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	150 // We are computing a raw address for a store captured by an Initialize
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	151 // compute an appropriate address type. AddP cases #3 and #5 (see below).
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	152 int offs = (int)phase->find_intptr_t_con(adr->in(AddPNode::Offset), Type::OffsetBot);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	153 assert(offs != Type::OffsetBot \|\|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	154 adr->in(AddPNode::Address)->in(0)->is_AllocateArray(),
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	155 "offset must be a constant or it is initialization of array");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	156 return offs;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	157 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	158 const TypePtr *t_ptr = adr_type->isa_ptr();
0 a61af66fc99e Initial load duke parents: diff changeset	159 assert(t_ptr != NULL, "must be a pointer type");
a61af66fc99e Initial load duke parents: diff changeset	160 return t_ptr->offset();
a61af66fc99e Initial load duke parents: diff changeset	161 }
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 void ConnectionGraph::add_field_edge(uint from_i, uint to_i, int offset) {
a61af66fc99e Initial load duke parents: diff changeset	164 PointsToNode *f = ptnode_adr(from_i);
a61af66fc99e Initial load duke parents: diff changeset	165 PointsToNode *t = ptnode_adr(to_i);
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 assert(f->node_type() != PointsToNode::UnknownType && t->node_type() != PointsToNode::UnknownType, "node types must be set");
a61af66fc99e Initial load duke parents: diff changeset	168 assert(f->node_type() == PointsToNode::JavaObject, "invalid destination of Field edge");
a61af66fc99e Initial load duke parents: diff changeset	169 assert(t->node_type() == PointsToNode::Field, "invalid destination of Field edge");
a61af66fc99e Initial load duke parents: diff changeset	170 assert (t->offset() == -1 \|\| t->offset() == offset, "conflicting field offsets");
a61af66fc99e Initial load duke parents: diff changeset	171 t->set_offset(offset);
a61af66fc99e Initial load duke parents: diff changeset	172
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	173 add_edge(f, to_i, PointsToNode::FieldEdge);
0 a61af66fc99e Initial load duke parents: diff changeset	174 }
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 void ConnectionGraph::set_escape_state(uint ni, PointsToNode::EscapeState es) {
a61af66fc99e Initial load duke parents: diff changeset	177 PointsToNode *npt = ptnode_adr(ni);
a61af66fc99e Initial load duke parents: diff changeset	178 PointsToNode::EscapeState old_es = npt->escape_state();
a61af66fc99e Initial load duke parents: diff changeset	179 if (es > old_es)
a61af66fc99e Initial load duke parents: diff changeset	180 npt->set_escape_state(es);
a61af66fc99e Initial load duke parents: diff changeset	181 }
a61af66fc99e Initial load duke parents: diff changeset	182
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	183 void ConnectionGraph::add_node(Node *n, PointsToNode::NodeType nt,
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	184 PointsToNode::EscapeState es, bool done) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	185 PointsToNode* ptadr = ptnode_adr(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	186 ptadr->_node = n;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	187 ptadr->set_node_type(nt);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	188
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	189 // inline set_escape_state(idx, es);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	190 PointsToNode::EscapeState old_es = ptadr->escape_state();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	191 if (es > old_es)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	192 ptadr->set_escape_state(es);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	193
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	194 if (done)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	195 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	196 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	197
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	198 PointsToNode::EscapeState ConnectionGraph::escape_state(Node *n) {
0 a61af66fc99e Initial load duke parents: diff changeset	199 uint idx = n->_idx;
a61af66fc99e Initial load duke parents: diff changeset	200 PointsToNode::EscapeState es;
a61af66fc99e Initial load duke parents: diff changeset	201
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	202 // If we are still collecting or there were no non-escaping allocations
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	203 // we don't know the answer yet
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	204 if (_collecting)
0 a61af66fc99e Initial load duke parents: diff changeset	205 return PointsToNode::UnknownEscape;
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 // if the node was created after the escape computation, return
a61af66fc99e Initial load duke parents: diff changeset	208 // UnknownEscape
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	209 if (idx >= nodes_size())
0 a61af66fc99e Initial load duke parents: diff changeset	210 return PointsToNode::UnknownEscape;
a61af66fc99e Initial load duke parents: diff changeset	211
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	212 es = ptnode_adr(idx)->escape_state();
0 a61af66fc99e Initial load duke parents: diff changeset	213
a61af66fc99e Initial load duke parents: diff changeset	214 // if we have already computed a value, return it
460 424f9bfe6b96 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now") kvn parents: 307 diff changeset	215 if (es != PointsToNode::UnknownEscape &&
424f9bfe6b96 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now") kvn parents: 307 diff changeset	216 ptnode_adr(idx)->node_type() == PointsToNode::JavaObject)
0 a61af66fc99e Initial load duke parents: diff changeset	217 return es;
a61af66fc99e Initial load duke parents: diff changeset	218
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	219 // PointsTo() calls n->uncast() which can return a new ideal node.
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	220 if (n->uncast()->_idx >= nodes_size())
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	221 return PointsToNode::UnknownEscape;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	222
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	223 PointsToNode::EscapeState orig_es = es;
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	224
0 a61af66fc99e Initial load duke parents: diff changeset	225 // compute max escape state of anything this node could point to
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	226 for(VectorSetI i(PointsTo(n)); i.test() && es != PointsToNode::GlobalEscape; ++i) {
0 a61af66fc99e Initial load duke parents: diff changeset	227 uint pt = i.elem;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	228 PointsToNode::EscapeState pes = ptnode_adr(pt)->escape_state();
0 a61af66fc99e Initial load duke parents: diff changeset	229 if (pes > es)
a61af66fc99e Initial load duke parents: diff changeset	230 es = pes;
a61af66fc99e Initial load duke parents: diff changeset	231 }
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	232 if (orig_es != es) {
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	233 // cache the computed escape state
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	234 assert(es != PointsToNode::UnknownEscape, "should have computed an escape state");
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	235 ptnode_adr(idx)->set_escape_state(es);
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	236 } // orig_es could be PointsToNode::UnknownEscape
0 a61af66fc99e Initial load duke parents: diff changeset	237 return es;
a61af66fc99e Initial load duke parents: diff changeset	238 }
a61af66fc99e Initial load duke parents: diff changeset	239
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	240 VectorSet* ConnectionGraph::PointsTo(Node * n) {
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	241 pt_ptset.Reset();
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	242 pt_visited.Reset();
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	243 pt_worklist.clear();
0 a61af66fc99e Initial load duke parents: diff changeset	244
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	245 #ifdef ASSERT
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	246 Node *orig_n = n;
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	247 #endif
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	248
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	249 n = n->uncast();
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	250 PointsToNode* npt = ptnode_adr(n->_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252 // If we have a JavaObject, return just that object
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	253 if (npt->node_type() == PointsToNode::JavaObject) {
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	254 pt_ptset.set(n->_idx);
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	255 return &pt_ptset;
0 a61af66fc99e Initial load duke parents: diff changeset	256 }
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	257 #ifdef ASSERT
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	258 if (npt->_node == NULL) {
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	259 if (orig_n != n)
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	260 orig_n->dump();
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	261 n->dump();
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	262 assert(npt->_node != NULL, "unregistered node");
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	263 }
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	264 #endif
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	265 pt_worklist.push(n->_idx);
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	266 while(pt_worklist.length() > 0) {
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	267 int ni = pt_worklist.pop();
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	268 if (pt_visited.test_set(ni))
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	269 continue;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	270
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	271 PointsToNode* pn = ptnode_adr(ni);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	272 // ensure that all inputs of a Phi have been processed
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	273 assert(!_collecting \|\| !pn->_node->is_Phi() \|\| _processed.test(ni),"");
0 a61af66fc99e Initial load duke parents: diff changeset	274
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	275 int edges_processed = 0;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	276 uint e_cnt = pn->edge_count();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	277 for (uint e = 0; e < e_cnt; e++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	278 uint etgt = pn->edge_target(e);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	279 PointsToNode::EdgeType et = pn->edge_type(e);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	280 if (et == PointsToNode::PointsToEdge) {
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	281 pt_ptset.set(etgt);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	282 edges_processed++;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	283 } else if (et == PointsToNode::DeferredEdge) {
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	284 pt_worklist.push(etgt);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	285 edges_processed++;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	286 } else {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	287 assert(false,"neither PointsToEdge or DeferredEdge");
0 a61af66fc99e Initial load duke parents: diff changeset	288 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	289 }
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	290 if (edges_processed == 0) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	291 // no deferred or pointsto edges found. Assume the value was set
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	292 // outside this method. Add the phantom object to the pointsto set.
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	293 pt_ptset.set(_phantom_object);
0 a61af66fc99e Initial load duke parents: diff changeset	294 }
a61af66fc99e Initial load duke parents: diff changeset	295 }
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	296 return &pt_ptset;
0 a61af66fc99e Initial load duke parents: diff changeset	297 }
a61af66fc99e Initial load duke parents: diff changeset	298
101 a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	299 void ConnectionGraph::remove_deferred(uint ni, GrowableArray<uint>* deferred_edges, VectorSet* visited) {
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	300 // This method is most expensive during ConnectionGraph construction.
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	301 // Reuse vectorSet and an additional growable array for deferred edges.
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	302 deferred_edges->clear();
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	303 visited->Reset();
0 a61af66fc99e Initial load duke parents: diff changeset	304
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	305 visited->set(ni);
0 a61af66fc99e Initial load duke parents: diff changeset	306 PointsToNode *ptn = ptnode_adr(ni);
a61af66fc99e Initial load duke parents: diff changeset	307
101 a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	308 // Mark current edges as visited and move deferred edges to separate array.
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	309 for (uint i = 0; i < ptn->edge_count(); ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	310 uint t = ptn->edge_target(i);
101 a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	311 #ifdef ASSERT
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	312 assert(!visited->test_set(t), "expecting no duplications");
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	313 #else
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	314 visited->set(t);
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	315 #endif
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	316 if (ptn->edge_type(i) == PointsToNode::DeferredEdge) {
0 a61af66fc99e Initial load duke parents: diff changeset	317 ptn->remove_edge(t, PointsToNode::DeferredEdge);
101 a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	318 deferred_edges->append(t);
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	319 } else {
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	320 i++;
101 a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	321 }
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	322 }
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	323 for (int next = 0; next < deferred_edges->length(); ++next) {
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	324 uint t = deferred_edges->at(next);
a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	325 PointsToNode *ptt = ptnode_adr(t);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	326 uint e_cnt = ptt->edge_count();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	327 for (uint e = 0; e < e_cnt; e++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	328 uint etgt = ptt->edge_target(e);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	329 if (visited->test_set(etgt))
101 a6cb86dd209b 6681577: PIT: some VM tests fails with -XX:+AggressiveOpts in 6u5p b01 kvn parents: 65 diff changeset	330 continue;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	331
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	332 PointsToNode::EdgeType et = ptt->edge_type(e);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	333 if (et == PointsToNode::PointsToEdge) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	334 add_pointsto_edge(ni, etgt);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	335 if(etgt == _phantom_object) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	336 // Special case - field set outside (globally escaping).
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	337 ptn->set_escape_state(PointsToNode::GlobalEscape);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	338 }
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	339 } else if (et == PointsToNode::DeferredEdge) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	340 deferred_edges->append(etgt);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	341 } else {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	342 assert(false,"invalid connection graph");
0 a61af66fc99e Initial load duke parents: diff changeset	343 }
a61af66fc99e Initial load duke parents: diff changeset	344 }
a61af66fc99e Initial load duke parents: diff changeset	345 }
a61af66fc99e Initial load duke parents: diff changeset	346 }
a61af66fc99e Initial load duke parents: diff changeset	347
a61af66fc99e Initial load duke parents: diff changeset	348
a61af66fc99e Initial load duke parents: diff changeset	349 // Add an edge to node given by "to_i" from any field of adr_i whose offset
a61af66fc99e Initial load duke parents: diff changeset	350 // matches "offset" A deferred edge is added if to_i is a LocalVar, and
a61af66fc99e Initial load duke parents: diff changeset	351 // a pointsto edge is added if it is a JavaObject
a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 void ConnectionGraph::add_edge_from_fields(uint adr_i, uint to_i, int offs) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	354 PointsToNode* an = ptnode_adr(adr_i);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	355 PointsToNode* to = ptnode_adr(to_i);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	356 bool deferred = (to->node_type() == PointsToNode::LocalVar);
0 a61af66fc99e Initial load duke parents: diff changeset	357
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	358 for (uint fe = 0; fe < an->edge_count(); fe++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	359 assert(an->edge_type(fe) == PointsToNode::FieldEdge, "expecting a field edge");
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	360 int fi = an->edge_target(fe);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	361 PointsToNode* pf = ptnode_adr(fi);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	362 int po = pf->offset();
0 a61af66fc99e Initial load duke parents: diff changeset	363 if (po == offs \|\| po == Type::OffsetBot \|\| offs == Type::OffsetBot) {
a61af66fc99e Initial load duke parents: diff changeset	364 if (deferred)
a61af66fc99e Initial load duke parents: diff changeset	365 add_deferred_edge(fi, to_i);
a61af66fc99e Initial load duke parents: diff changeset	366 else
a61af66fc99e Initial load duke parents: diff changeset	367 add_pointsto_edge(fi, to_i);
a61af66fc99e Initial load duke parents: diff changeset	368 }
a61af66fc99e Initial load duke parents: diff changeset	369 }
a61af66fc99e Initial load duke parents: diff changeset	370 }
a61af66fc99e Initial load duke parents: diff changeset	371
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	372 // Add a deferred edge from node given by "from_i" to any field of adr_i
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	373 // whose offset matches "offset".
0 a61af66fc99e Initial load duke parents: diff changeset	374 void ConnectionGraph::add_deferred_edge_to_fields(uint from_i, uint adr_i, int offs) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	375 PointsToNode* an = ptnode_adr(adr_i);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	376 for (uint fe = 0; fe < an->edge_count(); fe++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	377 assert(an->edge_type(fe) == PointsToNode::FieldEdge, "expecting a field edge");
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	378 int fi = an->edge_target(fe);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	379 PointsToNode* pf = ptnode_adr(fi);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	380 int po = pf->offset();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	381 if (pf->edge_count() == 0) {
0 a61af66fc99e Initial load duke parents: diff changeset	382 // we have not seen any stores to this field, assume it was set outside this method
a61af66fc99e Initial load duke parents: diff changeset	383 add_pointsto_edge(fi, _phantom_object);
a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385 if (po == offs \|\| po == Type::OffsetBot \|\| offs == Type::OffsetBot) {
a61af66fc99e Initial load duke parents: diff changeset	386 add_deferred_edge(from_i, fi);
a61af66fc99e Initial load duke parents: diff changeset	387 }
a61af66fc99e Initial load duke parents: diff changeset	388 }
a61af66fc99e Initial load duke parents: diff changeset	389 }
a61af66fc99e Initial load duke parents: diff changeset	390
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	391 // Helper functions
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	392
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	393 static Node* get_addp_base(Node *addp) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	394 assert(addp->is_AddP(), "must be AddP");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	395 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	396 // AddP cases for Base and Address inputs:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	397 // case #1. Direct object's field reference:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	398 // Allocate
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	399 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	400 // Proj #5 ( oop result )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	401 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	402 // CheckCastPP (cast to instance type)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	403 // \| \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	404 // AddP ( base == address )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	405 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	406 // case #2. Indirect object's field reference:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	407 // Phi
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	408 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	409 // CastPP (cast to instance type)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	410 // \| \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	411 // AddP ( base == address )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	412 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	413 // case #3. Raw object's field reference for Initialize node:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	414 // Allocate
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	415 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	416 // Proj #5 ( oop result )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	417 // top \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	418 // \ \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	419 // AddP ( base == top )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	420 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	421 // case #4. Array's element reference:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	422 // {CheckCastPP \| CastPP}
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	423 // \| \| \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	424 // \| AddP ( array's element offset )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	425 // \| \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	426 // AddP ( array's offset )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	427 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	428 // case #5. Raw object's field reference for arraycopy stub call:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	429 // The inline_native_clone() case when the arraycopy stub is called
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	430 // after the allocation before Initialize and CheckCastPP nodes.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	431 // Allocate
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	432 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	433 // Proj #5 ( oop result )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	434 // \| \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	435 // AddP ( base == address )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	436 //
77 36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	437 // case #6. Constant Pool, ThreadLocal, CastX2P or
36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	438 // Raw object's field reference:
36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	439 // {ConP, ThreadLocal, CastX2P, raw Load}
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	440 // top \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	441 // \ \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	442 // AddP ( base == top )
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	443 //
77 36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	444 // case #7. Klass's field reference.
36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	445 // LoadKlass
36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	446 // \| \|
36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	447 // AddP ( base == address )
36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	448 //
164 c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	449 // case #8. narrow Klass's field reference.
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	450 // LoadNKlass
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	451 // \|
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	452 // DecodeN
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	453 // \| \|
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	454 // AddP ( base == address )
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	455 //
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	456 Node *base = addp->in(AddPNode::Base)->uncast();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	457 if (base->is_top()) { // The AddP case #3 and #6.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	458 base = addp->in(AddPNode::Address)->uncast();
957 159d56b94894 6880574: C2 assert in escape.cpp:445 on linux-amd64 kvn parents: 866 diff changeset	459 while (base->is_AddP()) {
159d56b94894 6880574: C2 assert in escape.cpp:445 on linux-amd64 kvn parents: 866 diff changeset	460 // Case #6 (unsafe access) may have several chained AddP nodes.
159d56b94894 6880574: C2 assert in escape.cpp:445 on linux-amd64 kvn parents: 866 diff changeset	461 assert(base->in(AddPNode::Base)->is_top(), "expected unsafe access address only");
159d56b94894 6880574: C2 assert in escape.cpp:445 on linux-amd64 kvn parents: 866 diff changeset	462 base = base->in(AddPNode::Address)->uncast();
159d56b94894 6880574: C2 assert in escape.cpp:445 on linux-amd64 kvn parents: 866 diff changeset	463 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	464 assert(base->Opcode() == Op_ConP \|\| base->Opcode() == Op_ThreadLocal \|\|
168 7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops kvn parents: 164 diff changeset	465 base->Opcode() == Op_CastX2P \|\| base->is_DecodeN() \|\|
77 36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	466 (base->is_Mem() && base->bottom_type() == TypeRawPtr::NOTNULL) \|\|
36cd3cc4d27b 6679854: assert in escape.cpp:397 kvn parents: 65 diff changeset	467 (base->is_Proj() && base->in(0)->is_Allocate()), "sanity");
0 a61af66fc99e Initial load duke parents: diff changeset	468 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	469 return base;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	470 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	471
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	472 static Node* find_second_addp(Node* addp, Node* n) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	473 assert(addp->is_AddP() && addp->outcnt() > 0, "Don't process dead nodes");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	474
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	475 Node* addp2 = addp->raw_out(0);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	476 if (addp->outcnt() == 1 && addp2->is_AddP() &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	477 addp2->in(AddPNode::Base) == n &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	478 addp2->in(AddPNode::Address) == addp) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	479
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	480 assert(addp->in(AddPNode::Base) == n, "expecting the same base");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	481 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	482 // Find array's offset to push it on worklist first and
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	483 // as result process an array's element offset first (pushed second)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	484 // to avoid CastPP for the array's offset.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	485 // Otherwise the inserted CastPP (LocalVar) will point to what
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	486 // the AddP (Field) points to. Which would be wrong since
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	487 // the algorithm expects the CastPP has the same point as
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	488 // as AddP's base CheckCastPP (LocalVar).
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	489 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	490 // ArrayAllocation
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	491 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	492 // CheckCastPP
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	493 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	494 // memProj (from ArrayAllocation CheckCastPP)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	495 // \| \|\|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	496 // \| \|\| Int (element index)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	497 // \| \|\| \| ConI (log(element size))
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	498 // \| \|\| \| /
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	499 // \| \|\| LShift
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	500 // \| \|\| /
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	501 // \| AddP (array's element offset)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	502 // \| \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	503 // \| \| ConI (array's offset: #12(32-bits) or #24(64-bits))
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	504 // \| / /
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	505 // AddP (array's offset)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	506 // \|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	507 // Load/Store (memory operation on array's element)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	508 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	509 return addp2;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	510 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	511 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	512 }
a61af66fc99e Initial load duke parents: diff changeset	513
a61af66fc99e Initial load duke parents: diff changeset	514 //
a61af66fc99e Initial load duke parents: diff changeset	515 // Adjust the type and inputs of an AddP which computes the
a61af66fc99e Initial load duke parents: diff changeset	516 // address of a field of an instance
a61af66fc99e Initial load duke parents: diff changeset	517 //
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	518 bool ConnectionGraph::split_AddP(Node addp, Node base, PhaseGVN *igvn) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	519 const TypeOopPtr *base_t = igvn->type(base)->isa_oopptr();
223 1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	520 assert(base_t != NULL && base_t->is_known_instance(), "expecting instance oopptr");
0 a61af66fc99e Initial load duke parents: diff changeset	521 const TypeOopPtr *t = igvn->type(addp)->isa_oopptr();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	522 if (t == NULL) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	523 // We are computing a raw address for a store captured by an Initialize
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	524 // compute an appropriate address type (cases #3 and #5).
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	525 assert(igvn->type(addp) == TypeRawPtr::NOTNULL, "must be raw pointer");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	526 assert(addp->in(AddPNode::Address)->is_Proj(), "base of raw address must be result projection from allocation");
306 af945ba2e739 6741738: TypePtr::add_offset() set incorrect offset when the add overflows kvn parents: 293 diff changeset	527 intptr_t offs = (int)igvn->find_intptr_t_con(addp->in(AddPNode::Offset), Type::OffsetBot);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	528 assert(offs != Type::OffsetBot, "offset must be a constant");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	529 t = base_t->add_offset(offs)->is_oopptr();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	530 }
223 1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	531 int inst_id = base_t->instance_id();
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	532 assert(!t->is_known_instance() \|\| t->instance_id() == inst_id,
0 a61af66fc99e Initial load duke parents: diff changeset	533 "old type must be non-instance or match new type");
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	534
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	535 // The type 't' could be subclass of 'base_t'.
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	536 // As result t->offset() could be large then base_t's size and it will
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	537 // cause the failure in add_offset() with narrow oops since TypeOopPtr()
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	538 // constructor verifies correctness of the offset.
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	539 //
605 98cb887364d3 6810672: Comment typos twisti parents: 584 diff changeset	540 // It could happened on subclass's branch (from the type profiling
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	541 // inlining) which was not eliminated during parsing since the exactness
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	542 // of the allocation type was not propagated to the subclass type check.
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	543 //
988 7e309ecb83ce 6879362: assert(!klass_is_exact(),"only non-exact klass") kvn parents: 957 diff changeset	544 // Or the type 't' could be not related to 'base_t' at all.
7e309ecb83ce 6879362: assert(!klass_is_exact(),"only non-exact klass") kvn parents: 957 diff changeset	545 // It could happened when CHA type is different from MDO type on a dead path
7e309ecb83ce 6879362: assert(!klass_is_exact(),"only non-exact klass") kvn parents: 957 diff changeset	546 // (for example, from instanceof check) which is not collapsed during parsing.
7e309ecb83ce 6879362: assert(!klass_is_exact(),"only non-exact klass") kvn parents: 957 diff changeset	547 //
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	548 // Do nothing for such AddP node and don't process its users since
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	549 // this code branch will go away.
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	550 //
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	551 if (!t->is_known_instance() &&
988 7e309ecb83ce 6879362: assert(!klass_is_exact(),"only non-exact klass") kvn parents: 957 diff changeset	552 !base_t->klass()->is_subtype_of(t->klass())) {
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	553 return false; // bail out
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	554 }
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	555
0 a61af66fc99e Initial load duke parents: diff changeset	556 const TypeOopPtr *tinst = base_t->add_offset(t->offset())->is_oopptr();
1062 dcdcc8c16e20 6896352: CTW fails hotspot/src/share/vm/opto/escape.cpp:1155 kvn parents: 988 diff changeset	557 // Do NOT remove the next line: ensure a new alias index is allocated
dcdcc8c16e20 6896352: CTW fails hotspot/src/share/vm/opto/escape.cpp:1155 kvn parents: 988 diff changeset	558 // for the instance type. Note: C++ will not remove it since the call
dcdcc8c16e20 6896352: CTW fails hotspot/src/share/vm/opto/escape.cpp:1155 kvn parents: 988 diff changeset	559 // has side effect.
0 a61af66fc99e Initial load duke parents: diff changeset	560 int alias_idx = _compile->get_alias_index(tinst);
a61af66fc99e Initial load duke parents: diff changeset	561 igvn->set_type(addp, tinst);
a61af66fc99e Initial load duke parents: diff changeset	562 // record the allocation in the node map
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	563 assert(ptnode_adr(addp->_idx)->_node != NULL, "should be registered");
0 a61af66fc99e Initial load duke parents: diff changeset	564 set_map(addp->_idx, get_map(base->_idx));
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	565
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	566 // Set addp's Base and Address to 'base'.
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	567 Node *abase = addp->in(AddPNode::Base);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	568 Node *adr = addp->in(AddPNode::Address);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	569 if (adr->is_Proj() && adr->in(0)->is_Allocate() &&
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	570 adr->in(0)->_idx == (uint)inst_id) {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	571 // Skip AddP cases #3 and #5.
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	572 } else {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	573 assert(!abase->is_top(), "sanity"); // AddP case #3
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	574 if (abase != base) {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	575 igvn->hash_delete(addp);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	576 addp->set_req(AddPNode::Base, base);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	577 if (abase == adr) {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	578 addp->set_req(AddPNode::Address, base);
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	579 } else {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	580 // AddP case #4 (adr is array's element offset AddP node)
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	581 #ifdef ASSERT
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	582 const TypeOopPtr *atype = igvn->type(adr)->isa_oopptr();
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	583 assert(adr->is_AddP() && atype != NULL &&
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	584 atype->instance_id() == inst_id, "array's element offset should be processed first");
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	585 #endif
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	586 }
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	587 igvn->hash_insert(addp);
0 a61af66fc99e Initial load duke parents: diff changeset	588 }
a61af66fc99e Initial load duke parents: diff changeset	589 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	590 // Put on IGVN worklist since at least addp's type was changed above.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	591 record_for_optimizer(addp);
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	592 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	593 }
a61af66fc99e Initial load duke parents: diff changeset	594
a61af66fc99e Initial load duke parents: diff changeset	595 //
a61af66fc99e Initial load duke parents: diff changeset	596 // Create a new version of orig_phi if necessary. Returns either the newly
2459 55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	597 // created phi or an existing phi. Sets create_new to indicate whether a new
0 a61af66fc99e Initial load duke parents: diff changeset	598 // phi was created. Cache the last newly created phi in the node map.
a61af66fc99e Initial load duke parents: diff changeset	599 //
a61af66fc99e Initial load duke parents: diff changeset	600 PhiNode ConnectionGraph::create_split_phi(PhiNode orig_phi, int alias_idx, GrowableArray<PhiNode > &orig_phi_worklist, PhaseGVN igvn, bool &new_created) {
a61af66fc99e Initial load duke parents: diff changeset	601 Compile *C = _compile;
a61af66fc99e Initial load duke parents: diff changeset	602 new_created = false;
a61af66fc99e Initial load duke parents: diff changeset	603 int phi_alias_idx = C->get_alias_index(orig_phi->adr_type());
a61af66fc99e Initial load duke parents: diff changeset	604 // nothing to do if orig_phi is bottom memory or matches alias_idx
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	605 if (phi_alias_idx == alias_idx) {
0 a61af66fc99e Initial load duke parents: diff changeset	606 return orig_phi;
a61af66fc99e Initial load duke parents: diff changeset	607 }
851 fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	608 // Have we recently created a Phi for this alias index?
0 a61af66fc99e Initial load duke parents: diff changeset	609 PhiNode *result = get_map_phi(orig_phi->_idx);
a61af66fc99e Initial load duke parents: diff changeset	610 if (result != NULL && C->get_alias_index(result->adr_type()) == alias_idx) {
a61af66fc99e Initial load duke parents: diff changeset	611 return result;
a61af66fc99e Initial load duke parents: diff changeset	612 }
851 fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	613 // Previous check may fail when the same wide memory Phi was split into Phis
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	614 // for different memory slices. Search all Phis for this region.
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	615 if (result != NULL) {
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	616 Node* region = orig_phi->in(0);
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	617 for (DUIterator_Fast imax, i = region->fast_outs(imax); i < imax; i++) {
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	618 Node* phi = region->fast_out(i);
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	619 if (phi->is_Phi() &&
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	620 C->get_alias_index(phi->as_Phi()->adr_type()) == alias_idx) {
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	621 assert(phi->_idx >= nodes_size(), "only new Phi per instance memory slice");
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	622 return phi->as_Phi();
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	623 }
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	624 }
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	625 }
38 b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	626 if ((int)C->unique() + 2*NodeLimitFudgeFactor > MaxNodeLimit) {
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	627 if (C->do_escape_analysis() == true && !C->failing()) {
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	628 // Retry compilation without escape analysis.
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	629 // If this is the first failure, the sentinel string will "stick"
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	630 // to the Compile object, and the C2Compiler will see it and retry.
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	631 C->record_failure(C2Compiler::retry_no_escape_analysis());
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	632 }
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	633 return NULL;
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	634 }
0 a61af66fc99e Initial load duke parents: diff changeset	635 orig_phi_worklist.append_if_missing(orig_phi);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	636 const TypePtr *atype = C->get_adr_type(alias_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	637 result = PhiNode::make(orig_phi->in(0), NULL, Type::MEMORY, atype);
851 fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC kvn parents: 784 diff changeset	638 C->copy_node_notes_to(result, orig_phi);
0 a61af66fc99e Initial load duke parents: diff changeset	639 igvn->set_type(result, result->bottom_type());
a61af66fc99e Initial load duke parents: diff changeset	640 record_for_optimizer(result);
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	641
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	642 debug_only(Node* pn = ptnode_adr(orig_phi->_idx)->_node;)
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	643 assert(pn == NULL \|\| pn == orig_phi, "wrong node");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	644 set_map(orig_phi->_idx, result);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	645 ptnode_adr(orig_phi->_idx)->_node = orig_phi;
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	646
0 a61af66fc99e Initial load duke parents: diff changeset	647 new_created = true;
a61af66fc99e Initial load duke parents: diff changeset	648 return result;
a61af66fc99e Initial load duke parents: diff changeset	649 }
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 //
2459 55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	652 // Return a new version of Memory Phi "orig_phi" with the inputs having the
0 a61af66fc99e Initial load duke parents: diff changeset	653 // specified alias index.
a61af66fc99e Initial load duke parents: diff changeset	654 //
a61af66fc99e Initial load duke parents: diff changeset	655 PhiNode ConnectionGraph::split_memory_phi(PhiNode orig_phi, int alias_idx, GrowableArray<PhiNode > &orig_phi_worklist, PhaseGVN igvn) {
a61af66fc99e Initial load duke parents: diff changeset	656
a61af66fc99e Initial load duke parents: diff changeset	657 assert(alias_idx != Compile::AliasIdxBot, "can't split out bottom memory");
a61af66fc99e Initial load duke parents: diff changeset	658 Compile *C = _compile;
a61af66fc99e Initial load duke parents: diff changeset	659 bool new_phi_created;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	660 PhiNode *result = create_split_phi(orig_phi, alias_idx, orig_phi_worklist, igvn, new_phi_created);
0 a61af66fc99e Initial load duke parents: diff changeset	661 if (!new_phi_created) {
a61af66fc99e Initial load duke parents: diff changeset	662 return result;
a61af66fc99e Initial load duke parents: diff changeset	663 }
a61af66fc99e Initial load duke parents: diff changeset	664
a61af66fc99e Initial load duke parents: diff changeset	665 GrowableArray<PhiNode *> phi_list;
a61af66fc99e Initial load duke parents: diff changeset	666 GrowableArray<uint> cur_input;
a61af66fc99e Initial load duke parents: diff changeset	667
a61af66fc99e Initial load duke parents: diff changeset	668 PhiNode *phi = orig_phi;
a61af66fc99e Initial load duke parents: diff changeset	669 uint idx = 1;
a61af66fc99e Initial load duke parents: diff changeset	670 bool finished = false;
a61af66fc99e Initial load duke parents: diff changeset	671 while(!finished) {
a61af66fc99e Initial load duke parents: diff changeset	672 while (idx < phi->req()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	673 Node *mem = find_inst_mem(phi->in(idx), alias_idx, orig_phi_worklist, igvn);
0 a61af66fc99e Initial load duke parents: diff changeset	674 if (mem != NULL && mem->is_Phi()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	675 PhiNode *newphi = create_split_phi(mem->as_Phi(), alias_idx, orig_phi_worklist, igvn, new_phi_created);
0 a61af66fc99e Initial load duke parents: diff changeset	676 if (new_phi_created) {
a61af66fc99e Initial load duke parents: diff changeset	677 // found an phi for which we created a new split, push current one on worklist and begin
a61af66fc99e Initial load duke parents: diff changeset	678 // processing new one
a61af66fc99e Initial load duke parents: diff changeset	679 phi_list.push(phi);
a61af66fc99e Initial load duke parents: diff changeset	680 cur_input.push(idx);
a61af66fc99e Initial load duke parents: diff changeset	681 phi = mem->as_Phi();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	682 result = newphi;
0 a61af66fc99e Initial load duke parents: diff changeset	683 idx = 1;
a61af66fc99e Initial load duke parents: diff changeset	684 continue;
a61af66fc99e Initial load duke parents: diff changeset	685 } else {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	686 mem = newphi;
0 a61af66fc99e Initial load duke parents: diff changeset	687 }
a61af66fc99e Initial load duke parents: diff changeset	688 }
38 b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	689 if (C->failing()) {
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	690 return NULL;
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	691 }
0 a61af66fc99e Initial load duke parents: diff changeset	692 result->set_req(idx++, mem);
a61af66fc99e Initial load duke parents: diff changeset	693 }
a61af66fc99e Initial load duke parents: diff changeset	694 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	695 // verify that the new Phi has an input for each input of the original
a61af66fc99e Initial load duke parents: diff changeset	696 assert( phi->req() == result->req(), "must have same number of inputs.");
a61af66fc99e Initial load duke parents: diff changeset	697 assert( result->in(0) != NULL && result->in(0) == phi->in(0), "regions must match");
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	698 #endif
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	699 // Check if all new phi's inputs have specified alias index.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	700 // Otherwise use old phi.
0 a61af66fc99e Initial load duke parents: diff changeset	701 for (uint i = 1; i < phi->req(); i++) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	702 Node* in = result->in(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	703 assert((phi->in(i) == NULL) == (in == NULL), "inputs must correspond.");
0 a61af66fc99e Initial load duke parents: diff changeset	704 }
a61af66fc99e Initial load duke parents: diff changeset	705 // we have finished processing a Phi, see if there are any more to do
a61af66fc99e Initial load duke parents: diff changeset	706 finished = (phi_list.length() == 0 );
a61af66fc99e Initial load duke parents: diff changeset	707 if (!finished) {
a61af66fc99e Initial load duke parents: diff changeset	708 phi = phi_list.pop();
a61af66fc99e Initial load duke parents: diff changeset	709 idx = cur_input.pop();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	710 PhiNode *prev_result = get_map_phi(phi->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	711 prev_result->set_req(idx++, result);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	712 result = prev_result;
0 a61af66fc99e Initial load duke parents: diff changeset	713 }
a61af66fc99e Initial load duke parents: diff changeset	714 }
a61af66fc99e Initial load duke parents: diff changeset	715 return result;
a61af66fc99e Initial load duke parents: diff changeset	716 }
a61af66fc99e Initial load duke parents: diff changeset	717
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	718
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	719 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	720 // The next methods are derived from methods in MemNode.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	721 //
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	722 static Node step_through_mergemem(MergeMemNode mmem, int alias_idx, const TypeOopPtr *toop) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	723 Node *mem = mmem;
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	724 // TypeOopPtr::NOTNULL+any is an OOP with unknown offset - generally
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	725 // means an array I have not precisely typed yet. Do not do any
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	726 // alias stuff with it any time soon.
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	727 if( toop->base() != Type::AnyPtr &&
5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	728 !(toop->klass() != NULL &&
5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	729 toop->klass()->is_java_lang_Object() &&
5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	730 toop->offset() == Type::OffsetBot) ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	731 mem = mmem->memory_at(alias_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	732 // Update input if it is progress over what we have now
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	733 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	734 return mem;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	735 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	736
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	737 //
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	738 // Move memory users to their memory slices.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	739 //
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	740 void ConnectionGraph::move_inst_mem(Node* n, GrowableArray<PhiNode > &orig_phis, PhaseGVN igvn) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	741 Compile* C = _compile;
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	742
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	743 const TypePtr* tp = igvn->type(n->in(MemNode::Address))->isa_ptr();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	744 assert(tp != NULL, "ptr type");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	745 int alias_idx = C->get_alias_index(tp);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	746 int general_idx = C->get_general_index(alias_idx);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	747
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	748 // Move users first
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	749 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	750 Node* use = n->fast_out(i);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	751 if (use->is_MergeMem()) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	752 MergeMemNode* mmem = use->as_MergeMem();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	753 assert(n == mmem->memory_at(alias_idx), "should be on instance memory slice");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	754 if (n != mmem->memory_at(general_idx) \|\| alias_idx == general_idx) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	755 continue; // Nothing to do
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	756 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	757 // Replace previous general reference to mem node.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	758 uint orig_uniq = C->unique();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	759 Node* m = find_inst_mem(n, general_idx, orig_phis, igvn);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	760 assert(orig_uniq == C->unique(), "no new nodes");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	761 mmem->set_memory_at(general_idx, m);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	762 --imax;
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	763 --i;
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	764 } else if (use->is_MemBar()) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	765 assert(!use->is_Initialize(), "initializing stores should not be moved");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	766 if (use->req() > MemBarNode::Precedent &&
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	767 use->in(MemBarNode::Precedent) == n) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	768 // Don't move related membars.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	769 record_for_optimizer(use);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	770 continue;
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	771 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	772 tp = use->as_MemBar()->adr_type()->isa_ptr();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	773 if (tp != NULL && C->get_alias_index(tp) == alias_idx \|\|
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	774 alias_idx == general_idx) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	775 continue; // Nothing to do
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	776 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	777 // Move to general memory slice.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	778 uint orig_uniq = C->unique();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	779 Node* m = find_inst_mem(n, general_idx, orig_phis, igvn);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	780 assert(orig_uniq == C->unique(), "no new nodes");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	781 igvn->hash_delete(use);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	782 imax -= use->replace_edge(n, m);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	783 igvn->hash_insert(use);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	784 record_for_optimizer(use);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	785 --i;
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	786 #ifdef ASSERT
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	787 } else if (use->is_Mem()) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	788 if (use->Opcode() == Op_StoreCM && use->in(MemNode::OopStore) == n) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	789 // Don't move related cardmark.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	790 continue;
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	791 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	792 // Memory nodes should have new memory input.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	793 tp = igvn->type(use->in(MemNode::Address))->isa_ptr();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	794 assert(tp != NULL, "ptr type");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	795 int idx = C->get_alias_index(tp);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	796 assert(get_map(use->_idx) != NULL \|\| idx == alias_idx,
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	797 "Following memory nodes should have new memory input or be on the same memory slice");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	798 } else if (use->is_Phi()) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	799 // Phi nodes should be split and moved already.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	800 tp = use->as_Phi()->adr_type()->isa_ptr();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	801 assert(tp != NULL, "ptr type");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	802 int idx = C->get_alias_index(tp);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	803 assert(idx == alias_idx, "Following Phi nodes should be on the same memory slice");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	804 } else {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	805 use->dump();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	806 assert(false, "should not be here");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	807 #endif
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	808 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	809 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	810 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	811
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	812 //
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	813 // Search memory chain of "mem" to find a MemNode whose address
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	814 // is the specified alias index.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	815 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	816 Node* ConnectionGraph::find_inst_mem(Node orig_mem, int alias_idx, GrowableArray<PhiNode > &orig_phis, PhaseGVN *phase) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	817 if (orig_mem == NULL)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	818 return orig_mem;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	819 Compile* C = phase->C;
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	820 const TypeOopPtr *toop = C->get_adr_type(alias_idx)->isa_oopptr();
5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	821 bool is_instance = (toop != NULL) && toop->is_known_instance();
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	822 Node *start_mem = C->start()->proj_out(TypeFunc::Memory);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	823 Node *prev = NULL;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	824 Node *result = orig_mem;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	825 while (prev != result) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	826 prev = result;
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	827 if (result == start_mem)
605 98cb887364d3 6810672: Comment typos twisti parents: 584 diff changeset	828 break; // hit one of our sentinels
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	829 if (result->is_Mem()) {
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	830 const Type *at = phase->type(result->in(MemNode::Address));
2459 55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	831 if (at == Type::TOP)
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	832 break; // Dead
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	833 assert (at->isa_ptr() != NULL, "pointer type required.");
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	834 int idx = C->get_alias_index(at->is_ptr());
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	835 if (idx == alias_idx)
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	836 break; // Found
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	837 if (!is_instance && (at->isa_oopptr() == NULL \|\|
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	838 !at->is_oopptr()->is_known_instance())) {
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	839 break; // Do not skip store to general memory slice.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	840 }
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	841 result = result->in(MemNode::Memory);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	842 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	843 if (!is_instance)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	844 continue; // don't search further for non-instance types
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	845 // skip over a call which does not affect this memory slice
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	846 if (result->is_Proj() && result->as_Proj()->_con == TypeFunc::Memory) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	847 Node *proj_in = result->in(0);
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	848 if (proj_in->is_Allocate() && proj_in->_idx == (uint)toop->instance_id()) {
605 98cb887364d3 6810672: Comment typos twisti parents: 584 diff changeset	849 break; // hit one of our sentinels
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	850 } else if (proj_in->is_Call()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	851 CallNode *call = proj_in->as_Call();
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	852 if (!call->may_modify(toop, phase)) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	853 result = call->in(TypeFunc::Memory);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	854 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	855 } else if (proj_in->is_Initialize()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	856 AllocateNode* alloc = proj_in->as_Initialize()->allocation();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	857 // Stop if this is the initialization for the object instance which
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	858 // which contains this memory slice, otherwise skip over it.
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	859 if (alloc == NULL \|\| alloc->_idx != (uint)toop->instance_id()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	860 result = proj_in->in(TypeFunc::Memory);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	861 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	862 } else if (proj_in->is_MemBar()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	863 result = proj_in->in(TypeFunc::Memory);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	864 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	865 } else if (result->is_MergeMem()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	866 MergeMemNode *mmem = result->as_MergeMem();
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	867 result = step_through_mergemem(mmem, alias_idx, toop);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	868 if (result == mmem->base_memory()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	869 // Didn't find instance memory, search through general slice recursively.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	870 result = mmem->memory_at(C->get_general_index(alias_idx));
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	871 result = find_inst_mem(result, alias_idx, orig_phis, phase);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	872 if (C->failing()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	873 return NULL;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	874 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	875 mmem->set_memory_at(alias_idx, result);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	876 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	877 } else if (result->is_Phi() &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	878 C->get_alias_index(result->as_Phi()->adr_type()) != alias_idx) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	879 Node *un = result->as_Phi()->unique_input(phase);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	880 if (un != NULL) {
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	881 orig_phis.append_if_missing(result->as_Phi());
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	882 result = un;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	883 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	884 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	885 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	886 } else if (result->is_ClearArray()) {
1815 5867d89c129b 6982537: Crash in Nodestep_through_mergemem never* parents: 1634 diff changeset	887 if (!ClearArrayNode::step_through(&result, (uint)toop->instance_id(), phase)) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	888 // Can not bypass initialization of the instance
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	889 // we are looking for.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	890 break;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	891 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	892 // Otherwise skip it (the call updated 'result' value).
584 49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	893 } else if (result->Opcode() == Op_SCMemProj) {
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	894 assert(result->in(0)->is_LoadStore(), "sanity");
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	895 const Type *at = phase->type(result->in(0)->in(MemNode::Address));
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	896 if (at != Type::TOP) {
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	897 assert (at->isa_ptr() != NULL, "pointer type required.");
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	898 int idx = C->get_alias_index(at->is_ptr());
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	899 assert(idx != alias_idx, "Object is not scalar replaceable if a LoadStore node access its field");
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	900 break;
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	901 }
49a36a80b0c7 6802499: EA: assert(false,"unknown node on this path") kvn parents: 460 diff changeset	902 result = result->in(0)->in(MemNode::Memory);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	903 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	904 }
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	905 if (result->is_Phi()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	906 PhiNode *mphi = result->as_Phi();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	907 assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	908 const TypePtr *t = mphi->adr_type();
2459 55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	909 if (!is_instance) {
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	910 // Push all non-instance Phis on the orig_phis worklist to update inputs
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	911 // during Phase 4 if needed.
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	912 orig_phis.append_if_missing(mphi);
2459 55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	913 } else if (C->get_alias_index(t) != alias_idx) {
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	914 // Create a new Phi with the specified alias index type.
55973726c600 6992789: assert(phi->_idx >= nodes_size()) failed: only new Phi per instance memory slice kvn parents: 2249 diff changeset	915 result = split_memory_phi(mphi, alias_idx, orig_phis, phase);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	916 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	917 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	918 // the result is either MemNode, PhiNode, InitializeNode.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	919 return result;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	920 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	921
0 a61af66fc99e Initial load duke parents: diff changeset	922 //
a61af66fc99e Initial load duke parents: diff changeset	923 // Convert the types of unescaped object to instance types where possible,
a61af66fc99e Initial load duke parents: diff changeset	924 // propagate the new type information through the graph, and update memory
a61af66fc99e Initial load duke parents: diff changeset	925 // edges and MergeMem inputs to reflect the new type.
a61af66fc99e Initial load duke parents: diff changeset	926 //
a61af66fc99e Initial load duke parents: diff changeset	927 // We start with allocations (and calls which may be allocations) on alloc_worklist.
a61af66fc99e Initial load duke parents: diff changeset	928 // The processing is done in 4 phases:
a61af66fc99e Initial load duke parents: diff changeset	929 //
a61af66fc99e Initial load duke parents: diff changeset	930 // Phase 1: Process possible allocations from alloc_worklist. Create instance
a61af66fc99e Initial load duke parents: diff changeset	931 // types for the CheckCastPP for allocations where possible.
a61af66fc99e Initial load duke parents: diff changeset	932 // Propagate the the new types through users as follows:
a61af66fc99e Initial load duke parents: diff changeset	933 // casts and Phi: push users on alloc_worklist
a61af66fc99e Initial load duke parents: diff changeset	934 // AddP: cast Base and Address inputs to the instance type
a61af66fc99e Initial load duke parents: diff changeset	935 // push any AddP users on alloc_worklist and push any memnode
a61af66fc99e Initial load duke parents: diff changeset	936 // users onto memnode_worklist.
a61af66fc99e Initial load duke parents: diff changeset	937 // Phase 2: Process MemNode's from memnode_worklist. compute new address type and
a61af66fc99e Initial load duke parents: diff changeset	938 // search the Memory chain for a store with the appropriate type
a61af66fc99e Initial load duke parents: diff changeset	939 // address type. If a Phi is found, create a new version with
605 98cb887364d3 6810672: Comment typos twisti parents: 584 diff changeset	940 // the appropriate memory slices from each of the Phi inputs.
0 a61af66fc99e Initial load duke parents: diff changeset	941 // For stores, process the users as follows:
a61af66fc99e Initial load duke parents: diff changeset	942 // MemNode: push on memnode_worklist
a61af66fc99e Initial load duke parents: diff changeset	943 // MergeMem: push on mergemem_worklist
a61af66fc99e Initial load duke parents: diff changeset	944 // Phase 3: Process MergeMem nodes from mergemem_worklist. Walk each memory slice
a61af66fc99e Initial load duke parents: diff changeset	945 // moving the first node encountered of each instance type to the
a61af66fc99e Initial load duke parents: diff changeset	946 // the input corresponding to its alias index.
a61af66fc99e Initial load duke parents: diff changeset	947 // appropriate memory slice.
a61af66fc99e Initial load duke parents: diff changeset	948 // Phase 4: Update the inputs of non-instance memory Phis and the Memory input of memnodes.
a61af66fc99e Initial load duke parents: diff changeset	949 //
a61af66fc99e Initial load duke parents: diff changeset	950 // In the following example, the CheckCastPP nodes are the cast of allocation
a61af66fc99e Initial load duke parents: diff changeset	951 // results and the allocation of node 29 is unescaped and eligible to be an
a61af66fc99e Initial load duke parents: diff changeset	952 // instance type.
a61af66fc99e Initial load duke parents: diff changeset	953 //
a61af66fc99e Initial load duke parents: diff changeset	954 // We start with:
a61af66fc99e Initial load duke parents: diff changeset	955 //
a61af66fc99e Initial load duke parents: diff changeset	956 // 7 Parm #memory
a61af66fc99e Initial load duke parents: diff changeset	957 // 10 ConI "12"
a61af66fc99e Initial load duke parents: diff changeset	958 // 19 CheckCastPP "Foo"
a61af66fc99e Initial load duke parents: diff changeset	959 // 20 AddP _ 19 19 10 Foo+12 alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	960 // 29 CheckCastPP "Foo"
a61af66fc99e Initial load duke parents: diff changeset	961 // 30 AddP _ 29 29 10 Foo+12 alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	962 //
a61af66fc99e Initial load duke parents: diff changeset	963 // 40 StoreP 25 7 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	964 // 50 StoreP 35 40 30 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	965 // 60 StoreP 45 50 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	966 // 70 LoadP _ 60 30 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	967 // 80 Phi 75 50 60 Memory alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	968 // 90 LoadP _ 80 30 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	969 // 100 LoadP _ 80 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	970 //
a61af66fc99e Initial load duke parents: diff changeset	971 //
a61af66fc99e Initial load duke parents: diff changeset	972 // Phase 1 creates an instance type for node 29 assigning it an instance id of 24
a61af66fc99e Initial load duke parents: diff changeset	973 // and creating a new alias index for node 30. This gives:
a61af66fc99e Initial load duke parents: diff changeset	974 //
a61af66fc99e Initial load duke parents: diff changeset	975 // 7 Parm #memory
a61af66fc99e Initial load duke parents: diff changeset	976 // 10 ConI "12"
a61af66fc99e Initial load duke parents: diff changeset	977 // 19 CheckCastPP "Foo"
a61af66fc99e Initial load duke parents: diff changeset	978 // 20 AddP _ 19 19 10 Foo+12 alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	979 // 29 CheckCastPP "Foo" iid=24
a61af66fc99e Initial load duke parents: diff changeset	980 // 30 AddP _ 29 29 10 Foo+12 alias_index=6 iid=24
a61af66fc99e Initial load duke parents: diff changeset	981 //
a61af66fc99e Initial load duke parents: diff changeset	982 // 40 StoreP 25 7 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	983 // 50 StoreP 35 40 30 ... alias_index=6
a61af66fc99e Initial load duke parents: diff changeset	984 // 60 StoreP 45 50 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	985 // 70 LoadP _ 60 30 ... alias_index=6
a61af66fc99e Initial load duke parents: diff changeset	986 // 80 Phi 75 50 60 Memory alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	987 // 90 LoadP _ 80 30 ... alias_index=6
a61af66fc99e Initial load duke parents: diff changeset	988 // 100 LoadP _ 80 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	989 //
a61af66fc99e Initial load duke parents: diff changeset	990 // In phase 2, new memory inputs are computed for the loads and stores,
a61af66fc99e Initial load duke parents: diff changeset	991 // And a new version of the phi is created. In phase 4, the inputs to
a61af66fc99e Initial load duke parents: diff changeset	992 // node 80 are updated and then the memory nodes are updated with the
a61af66fc99e Initial load duke parents: diff changeset	993 // values computed in phase 2. This results in:
a61af66fc99e Initial load duke parents: diff changeset	994 //
a61af66fc99e Initial load duke parents: diff changeset	995 // 7 Parm #memory
a61af66fc99e Initial load duke parents: diff changeset	996 // 10 ConI "12"
a61af66fc99e Initial load duke parents: diff changeset	997 // 19 CheckCastPP "Foo"
a61af66fc99e Initial load duke parents: diff changeset	998 // 20 AddP _ 19 19 10 Foo+12 alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	999 // 29 CheckCastPP "Foo" iid=24
a61af66fc99e Initial load duke parents: diff changeset	1000 // 30 AddP _ 29 29 10 Foo+12 alias_index=6 iid=24
a61af66fc99e Initial load duke parents: diff changeset	1001 //
a61af66fc99e Initial load duke parents: diff changeset	1002 // 40 StoreP 25 7 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	1003 // 50 StoreP 35 7 30 ... alias_index=6
a61af66fc99e Initial load duke parents: diff changeset	1004 // 60 StoreP 45 40 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	1005 // 70 LoadP _ 50 30 ... alias_index=6
a61af66fc99e Initial load duke parents: diff changeset	1006 // 80 Phi 75 40 60 Memory alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	1007 // 120 Phi 75 50 50 Memory alias_index=6
a61af66fc99e Initial load duke parents: diff changeset	1008 // 90 LoadP _ 120 30 ... alias_index=6
a61af66fc99e Initial load duke parents: diff changeset	1009 // 100 LoadP _ 80 20 ... alias_index=4
a61af66fc99e Initial load duke parents: diff changeset	1010 //
a61af66fc99e Initial load duke parents: diff changeset	1011 void ConnectionGraph::split_unique_types(GrowableArray<Node *> &alloc_worklist) {
a61af66fc99e Initial load duke parents: diff changeset	1012 GrowableArray<Node *> memnode_worklist;
a61af66fc99e Initial load duke parents: diff changeset	1013 GrowableArray<PhiNode *> orig_phis;
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1014
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1015 PhaseIterGVN *igvn = _igvn;
0 a61af66fc99e Initial load duke parents: diff changeset	1016 uint new_index_start = (uint) _compile->num_alias_types();
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1017 Arena* arena = Thread::current()->resource_area();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1018 VectorSet visited(arena);
0 a61af66fc99e Initial load duke parents: diff changeset	1019
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1020
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1021 // Phase 1: Process possible allocations from alloc_worklist.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1022 // Create instance types for the CheckCastPP for allocations where possible.
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1023 //
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1024 // (Note: don't forget to change the order of the second AddP node on
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1025 // the alloc_worklist if the order of the worklist processing is changed,
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1026 // see the comment in find_second_addp().)
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1027 //
0 a61af66fc99e Initial load duke parents: diff changeset	1028 while (alloc_worklist.length() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	1029 Node *n = alloc_worklist.pop();
a61af66fc99e Initial load duke parents: diff changeset	1030 uint ni = n->_idx;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1031 const TypeOopPtr* tinst = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1032 if (n->is_Call()) {
a61af66fc99e Initial load duke parents: diff changeset	1033 CallNode *alloc = n->as_Call();
a61af66fc99e Initial load duke parents: diff changeset	1034 // copy escape information to call node
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1035 PointsToNode* ptn = ptnode_adr(alloc->_idx);
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1036 PointsToNode::EscapeState es = escape_state(alloc);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1037 // We have an allocation or call which returns a Java object,
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1038 // see if it is unescaped.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1039 if (es != PointsToNode::NoEscape \|\| !ptn->_scalar_replaceable)
0 a61af66fc99e Initial load duke parents: diff changeset	1040 continue;
784 b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1041
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1042 // Find CheckCastPP for the allocate or for the return value of a call
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1043 n = alloc->result_cast();
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1044 if (n == NULL) { // No uses except Initialize node
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1045 if (alloc->is_Allocate()) {
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1046 // Set the scalar_replaceable flag for allocation
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1047 // so it could be eliminated if it has no uses.
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1048 alloc->as_Allocate()->_is_scalar_replaceable = true;
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1049 }
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1050 continue;
39 76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 38 diff changeset	1051 }
784 b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1052 if (!n->is_CheckCastPP()) { // not unique CheckCastPP.
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1053 assert(!alloc->is_Allocate(), "allocation should have unique type");
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1054 continue;
784 b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1055 }
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1056
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1057 // The inline code for Object.clone() casts the allocation result to
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1058 // java.lang.Object and then to the actual type of the allocated
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1059 // object. Detect this case and use the second cast.
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1060 // Also detect j.l.reflect.Array.newInstance(jobject, jint) case when
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1061 // the allocation result is cast to java.lang.Object and then
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1062 // to the actual Array type.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1063 if (alloc->is_Allocate() && n->as_Type()->type() == TypeInstPtr::NOTNULL
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1064 && (alloc->is_AllocateArray() \|\|
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1065 igvn->type(alloc->in(AllocateNode::KlassNode)) != TypeKlassPtr::OBJECT)) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1066 Node *cast2 = NULL;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1067 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1068 Node *use = n->fast_out(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1069 if (use->is_CheckCastPP()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1070 cast2 = use;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1071 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1072 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1073 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1074 if (cast2 != NULL) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1075 n = cast2;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1076 } else {
784 b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1077 // Non-scalar replaceable if the allocation type is unknown statically
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1078 // (reflection allocation), the object can't be restored during
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1079 // deoptimization without precise type.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1080 continue;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1081 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1082 }
784 b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1083 if (alloc->is_Allocate()) {
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1084 // Set the scalar_replaceable flag for allocation
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1085 // so it could be eliminated.
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1086 alloc->as_Allocate()->_is_scalar_replaceable = true;
b2934faac289 6836054: java/util/Arrays/CopyMethods.java fails on solaris-sparc with IllegalArgumentException kvn parents: 605 diff changeset	1087 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1088 set_escape_state(n->_idx, es);
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1089 // in order for an object to be scalar-replaceable, it must be:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1090 // - a direct allocation (not a call returning an object)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1091 // - non-escaping
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1092 // - eligible to be a unique type
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1093 // - not determined to be ineligible by escape analysis
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1094 assert(ptnode_adr(alloc->_idx)->_node != NULL &&
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1095 ptnode_adr(n->_idx)->_node != NULL, "should be registered");
0 a61af66fc99e Initial load duke parents: diff changeset	1096 set_map(alloc->_idx, n);
a61af66fc99e Initial load duke parents: diff changeset	1097 set_map(n->_idx, alloc);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1098 const TypeOopPtr *t = igvn->type(n)->isa_oopptr();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1099 if (t == NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	1100 continue; // not a TypeInstPtr
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1101 tinst = t->cast_to_exactness(true)->is_oopptr()->cast_to_instance_id(ni);
0 a61af66fc99e Initial load duke parents: diff changeset	1102 igvn->hash_delete(n);
a61af66fc99e Initial load duke parents: diff changeset	1103 igvn->set_type(n, tinst);
a61af66fc99e Initial load duke parents: diff changeset	1104 n->raise_bottom_type(tinst);
a61af66fc99e Initial load duke parents: diff changeset	1105 igvn->hash_insert(n);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1106 record_for_optimizer(n);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1107 if (alloc->is_Allocate() && ptn->_scalar_replaceable &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1108 (t->isa_instptr() \|\| t->isa_aryptr())) {
163 885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1109
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1110 // First, put on the worklist all Field edges from Connection Graph
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1111 // which is more accurate then putting immediate users from Ideal Graph.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1112 for (uint e = 0; e < ptn->edge_count(); e++) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1113 Node *use = ptnode_adr(ptn->edge_target(e))->_node;
163 885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1114 assert(ptn->edge_type(e) == PointsToNode::FieldEdge && use->is_AddP(),
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1115 "only AddP nodes are Field edges in CG");
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1116 if (use->outcnt() > 0) { // Don't process dead nodes
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1117 Node* addp2 = find_second_addp(use, use->in(AddPNode::Base));
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1118 if (addp2 != NULL) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1119 assert(alloc->is_AllocateArray(),"array allocation was expected");
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1120 alloc_worklist.append_if_missing(addp2);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1121 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1122 alloc_worklist.append_if_missing(use);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1123 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1124 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1125
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1126 // An allocation may have an Initialize which has raw stores. Scan
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1127 // the users of the raw allocation result and push AddP users
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1128 // on alloc_worklist.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1129 Node *raw_result = alloc->proj_out(TypeFunc::Parms);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1130 assert (raw_result != NULL, "must have an allocation result");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1131 for (DUIterator_Fast imax, i = raw_result->fast_outs(imax); i < imax; i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1132 Node *use = raw_result->fast_out(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1133 if (use->is_AddP() && use->outcnt() > 0) { // Don't process dead nodes
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1134 Node* addp2 = find_second_addp(use, raw_result);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1135 if (addp2 != NULL) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1136 assert(alloc->is_AllocateArray(),"array allocation was expected");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1137 alloc_worklist.append_if_missing(addp2);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1138 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1139 alloc_worklist.append_if_missing(use);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1140 } else if (use->is_MemBar()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1141 memnode_worklist.append_if_missing(use);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1142 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1143 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1144 }
0 a61af66fc99e Initial load duke parents: diff changeset	1145 } else if (n->is_AddP()) {
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1146 VectorSet* ptset = PointsTo(get_addp_base(n));
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1147 assert(ptset->Size() == 1, "AddP address is unique");
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1148 uint elem = ptset->getelem(); // Allocation node's index
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1149 if (elem == _phantom_object) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1150 assert(false, "escaped allocation");
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1151 continue; // Assume the value was set outside this method.
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1152 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1153 Node *base = get_map(elem); // CheckCastPP node
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1154 if (!split_AddP(n, base, igvn)) continue; // wrong type from dead path
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1155 tinst = igvn->type(base)->isa_oopptr();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1156 } else if (n->is_Phi() \|\|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1157 n->is_CheckCastPP() \|\|
168 7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops kvn parents: 164 diff changeset	1158 n->is_EncodeP() \|\|
7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops kvn parents: 164 diff changeset	1159 n->is_DecodeN() \|\|
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1160 (n->is_ConstraintCast() && n->Opcode() == Op_CastPP)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1161 if (visited.test_set(n->_idx)) {
a61af66fc99e Initial load duke parents: diff changeset	1162 assert(n->is_Phi(), "loops only through Phi's");
a61af66fc99e Initial load duke parents: diff changeset	1163 continue; // already processed
a61af66fc99e Initial load duke parents: diff changeset	1164 }
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1165 VectorSet* ptset = PointsTo(n);
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1166 if (ptset->Size() == 1) {
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1167 uint elem = ptset->getelem(); // Allocation node's index
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1168 if (elem == _phantom_object) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1169 assert(false, "escaped allocation");
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1170 continue; // Assume the value was set outside this method.
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1171 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1172 Node *val = get_map(elem); // CheckCastPP node
0 a61af66fc99e Initial load duke parents: diff changeset	1173 TypeNode *tn = n->as_Type();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1174 tinst = igvn->type(val)->isa_oopptr();
223 1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1175 assert(tinst != NULL && tinst->is_known_instance() &&
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1176 (uint)tinst->instance_id() == elem , "instance type expected.");
163 885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1177
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1178 const Type *tn_type = igvn->type(tn);
223 1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1179 const TypeOopPtr *tn_t;
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1180 if (tn_type->isa_narrowoop()) {
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1181 tn_t = tn_type->make_ptr()->isa_oopptr();
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1182 } else {
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1183 tn_t = tn_type->isa_oopptr();
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis kvn parents: 221 diff changeset	1184 }
0 a61af66fc99e Initial load duke parents: diff changeset	1185
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1186 if (tn_t != NULL && tinst->klass()->is_subtype_of(tn_t->klass())) {
163 885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1187 if (tn_type->isa_narrowoop()) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1188 tn_type = tinst->make_narrowoop();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1189 } else {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1190 tn_type = tinst;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1191 }
0 a61af66fc99e Initial load duke parents: diff changeset	1192 igvn->hash_delete(tn);
163 885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1193 igvn->set_type(tn, tn_type);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1194 tn->set_type(tn_type);
0 a61af66fc99e Initial load duke parents: diff changeset	1195 igvn->hash_insert(tn);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1196 record_for_optimizer(n);
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 253 diff changeset	1197 } else {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1198 assert(tn_type == TypePtr::NULL_PTR \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1199 tn_t != NULL && !tinst->klass()->is_subtype_of(tn_t->klass()),
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1200 "unexpected type");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1201 continue; // Skip dead path with different type
0 a61af66fc99e Initial load duke parents: diff changeset	1202 }
a61af66fc99e Initial load duke parents: diff changeset	1203 }
a61af66fc99e Initial load duke parents: diff changeset	1204 } else {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1205 debug_only(n->dump();)
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1206 assert(false, "EA: unexpected node");
0 a61af66fc99e Initial load duke parents: diff changeset	1207 continue;
a61af66fc99e Initial load duke parents: diff changeset	1208 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1209 // push allocation's users on appropriate worklist
0 a61af66fc99e Initial load duke parents: diff changeset	1210 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1211 Node *use = n->fast_out(i);
a61af66fc99e Initial load duke parents: diff changeset	1212 if(use->is_Mem() && use->in(MemNode::Address) == n) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1213 // Load/store to instance's field
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1214 memnode_worklist.append_if_missing(use);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1215 } else if (use->is_MemBar()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1216 memnode_worklist.append_if_missing(use);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1217 } else if (use->is_AddP() && use->outcnt() > 0) { // No dead nodes
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1218 Node* addp2 = find_second_addp(use, n);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1219 if (addp2 != NULL) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1220 alloc_worklist.append_if_missing(addp2);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1221 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1222 alloc_worklist.append_if_missing(use);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1223 } else if (use->is_Phi() \|\|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1224 use->is_CheckCastPP() \|\|
168 7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops kvn parents: 164 diff changeset	1225 use->is_EncodeP() \|\|
7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops kvn parents: 164 diff changeset	1226 use->is_DecodeN() \|\|
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1227 (use->is_ConstraintCast() && use->Opcode() == Op_CastPP)) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1228 alloc_worklist.append_if_missing(use);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1229 #ifdef ASSERT
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1230 } else if (use->is_Mem()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1231 assert(use->in(MemNode::Address) != n, "EA: missing allocation reference path");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1232 } else if (use->is_MergeMem()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1233 assert(_mergemem_worklist.contains(use->as_MergeMem()), "EA: missing MergeMem node in the worklist");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1234 } else if (use->is_SafePoint()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1235 // Look for MergeMem nodes for calls which reference unique allocation
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1236 // (through CheckCastPP nodes) even for debug info.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1237 Node* m = use->in(TypeFunc::Memory);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1238 if (m->is_MergeMem()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1239 assert(_mergemem_worklist.contains(m->as_MergeMem()), "EA: missing MergeMem node in the worklist");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1240 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1241 } else {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1242 uint op = use->Opcode();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1243 if (!(op == Op_CmpP \|\| op == Op_Conv2B \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1244 op == Op_CastP2X \|\| op == Op_StoreCM \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1245 op == Op_FastLock \|\| op == Op_AryEq \|\| op == Op_StrComp \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1246 op == Op_StrEquals \|\| op == Op_StrIndexOf)) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1247 n->dump();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1248 use->dump();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1249 assert(false, "EA: missing allocation reference path");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1250 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1251 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1252 }
a61af66fc99e Initial load duke parents: diff changeset	1253 }
a61af66fc99e Initial load duke parents: diff changeset	1254
a61af66fc99e Initial load duke parents: diff changeset	1255 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1256 // New alias types were created in split_AddP().
0 a61af66fc99e Initial load duke parents: diff changeset	1257 uint new_index_end = (uint) _compile->num_alias_types();
a61af66fc99e Initial load duke parents: diff changeset	1258
a61af66fc99e Initial load duke parents: diff changeset	1259 // Phase 2: Process MemNode's from memnode_worklist. compute new address type and
a61af66fc99e Initial load duke parents: diff changeset	1260 // compute new values for Memory inputs (the Memory inputs are not
a61af66fc99e Initial load duke parents: diff changeset	1261 // actually updated until phase 4.)
a61af66fc99e Initial load duke parents: diff changeset	1262 if (memnode_worklist.length() == 0)
a61af66fc99e Initial load duke parents: diff changeset	1263 return; // nothing to do
a61af66fc99e Initial load duke parents: diff changeset	1264
a61af66fc99e Initial load duke parents: diff changeset	1265 while (memnode_worklist.length() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	1266 Node *n = memnode_worklist.pop();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1267 if (visited.test_set(n->_idx))
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1268 continue;
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1269 if (n->is_Phi() \|\| n->is_ClearArray()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1270 // we don't need to do anything, but the users must be pushed
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1271 } else if (n->is_MemBar()) { // Initialize, MemBar nodes
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1272 // we don't need to do anything, but the users must be pushed
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1273 n = n->as_MemBar()->proj_out(TypeFunc::Memory);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1274 if (n == NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	1275 continue;
a61af66fc99e Initial load duke parents: diff changeset	1276 } else {
a61af66fc99e Initial load duke parents: diff changeset	1277 assert(n->is_Mem(), "memory node required.");
a61af66fc99e Initial load duke parents: diff changeset	1278 Node *addr = n->in(MemNode::Address);
a61af66fc99e Initial load duke parents: diff changeset	1279 const Type *addr_t = igvn->type(addr);
a61af66fc99e Initial load duke parents: diff changeset	1280 if (addr_t == Type::TOP)
a61af66fc99e Initial load duke parents: diff changeset	1281 continue;
a61af66fc99e Initial load duke parents: diff changeset	1282 assert (addr_t->isa_ptr() != NULL, "pointer type required.");
a61af66fc99e Initial load duke parents: diff changeset	1283 int alias_idx = _compile->get_alias_index(addr_t->is_ptr());
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1284 assert ((uint)alias_idx < new_index_end, "wrong alias index");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1285 Node *mem = find_inst_mem(n->in(MemNode::Memory), alias_idx, orig_phis, igvn);
38 b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	1286 if (_compile->failing()) {
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	1287 return;
b789bcaf2dd9 6667610: (Escape Analysis) retry compilation without EA if it fails kvn parents: 0 diff changeset	1288 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1289 if (mem != n->in(MemNode::Memory)) {
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1290 // We delay the memory edge update since we need old one in
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1291 // MergeMem code below when instances memory slices are separated.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1292 debug_only(Node* pn = ptnode_adr(n->_idx)->_node;)
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1293 assert(pn == NULL \|\| pn == n, "wrong node");
0 a61af66fc99e Initial load duke parents: diff changeset	1294 set_map(n->_idx, mem);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1295 ptnode_adr(n->_idx)->_node = n;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1296 }
0 a61af66fc99e Initial load duke parents: diff changeset	1297 if (n->is_Load()) {
a61af66fc99e Initial load duke parents: diff changeset	1298 continue; // don't push users
a61af66fc99e Initial load duke parents: diff changeset	1299 } else if (n->is_LoadStore()) {
a61af66fc99e Initial load duke parents: diff changeset	1300 // get the memory projection
a61af66fc99e Initial load duke parents: diff changeset	1301 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1302 Node *use = n->fast_out(i);
a61af66fc99e Initial load duke parents: diff changeset	1303 if (use->Opcode() == Op_SCMemProj) {
a61af66fc99e Initial load duke parents: diff changeset	1304 n = use;
a61af66fc99e Initial load duke parents: diff changeset	1305 break;
a61af66fc99e Initial load duke parents: diff changeset	1306 }
a61af66fc99e Initial load duke parents: diff changeset	1307 }
a61af66fc99e Initial load duke parents: diff changeset	1308 assert(n->Opcode() == Op_SCMemProj, "memory projection required");
a61af66fc99e Initial load duke parents: diff changeset	1309 }
a61af66fc99e Initial load duke parents: diff changeset	1310 }
a61af66fc99e Initial load duke parents: diff changeset	1311 // push user on appropriate worklist
a61af66fc99e Initial load duke parents: diff changeset	1312 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1313 Node *use = n->fast_out(i);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1314 if (use->is_Phi() \|\| use->is_ClearArray()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1315 memnode_worklist.append_if_missing(use);
0 a61af66fc99e Initial load duke parents: diff changeset	1316 } else if(use->is_Mem() && use->in(MemNode::Memory) == n) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1317 if (use->Opcode() == Op_StoreCM) // Ignore cardmark stores
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1318 continue;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1319 memnode_worklist.append_if_missing(use);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1320 } else if (use->is_MemBar()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1321 memnode_worklist.append_if_missing(use);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1322 #ifdef ASSERT
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1323 } else if(use->is_Mem()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1324 assert(use->in(MemNode::Memory) != n, "EA: missing memory path");
0 a61af66fc99e Initial load duke parents: diff changeset	1325 } else if (use->is_MergeMem()) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1326 assert(_mergemem_worklist.contains(use->as_MergeMem()), "EA: missing MergeMem node in the worklist");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1327 } else {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1328 uint op = use->Opcode();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1329 if (!(op == Op_StoreCM \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1330 (op == Op_CallLeaf && use->as_CallLeaf()->_name != NULL &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1331 strcmp(use->as_CallLeaf()->_name, "g1_wb_pre") == 0) \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1332 op == Op_AryEq \|\| op == Op_StrComp \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1333 op == Op_StrEquals \|\| op == Op_StrIndexOf)) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1334 n->dump();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1335 use->dump();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1336 assert(false, "EA: missing memory path");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1337 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1338 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1339 }
a61af66fc99e Initial load duke parents: diff changeset	1340 }
a61af66fc99e Initial load duke parents: diff changeset	1341 }
a61af66fc99e Initial load duke parents: diff changeset	1342
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1343 // Phase 3: Process MergeMem nodes from mergemem_worklist.
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1344 // Walk each memory slice moving the first node encountered of each
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1345 // instance type to the the input corresponding to its alias index.
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1346 uint length = _mergemem_worklist.length();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1347 for( uint next = 0; next < length; ++next ) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1348 MergeMemNode* nmm = _mergemem_worklist.at(next);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1349 assert(!visited.test_set(nmm->_idx), "should not be visited before");
0 a61af66fc99e Initial load duke parents: diff changeset	1350 // Note: we don't want to use MergeMemStream here because we only want to
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1351 // scan inputs which exist at the start, not ones we add during processing.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1352 // Note 2: MergeMem may already contains instance memory slices added
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1353 // during find_inst_mem() call when memory nodes were processed above.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1354 igvn->hash_delete(nmm);
0 a61af66fc99e Initial load duke parents: diff changeset	1355 uint nslices = nmm->req();
a61af66fc99e Initial load duke parents: diff changeset	1356 for (uint i = Compile::AliasIdxRaw+1; i < nslices; i++) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1357 Node* mem = nmm->in(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1358 Node* cur = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1359 if (mem == NULL \|\| mem->is_top())
a61af66fc99e Initial load duke parents: diff changeset	1360 continue;
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1361 // First, update mergemem by moving memory nodes to corresponding slices
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1362 // if their type became more precise since this mergemem was created.
0 a61af66fc99e Initial load duke parents: diff changeset	1363 while (mem->is_Mem()) {
a61af66fc99e Initial load duke parents: diff changeset	1364 const Type *at = igvn->type(mem->in(MemNode::Address));
a61af66fc99e Initial load duke parents: diff changeset	1365 if (at != Type::TOP) {
a61af66fc99e Initial load duke parents: diff changeset	1366 assert (at->isa_ptr() != NULL, "pointer type required.");
a61af66fc99e Initial load duke parents: diff changeset	1367 uint idx = (uint)_compile->get_alias_index(at->is_ptr());
a61af66fc99e Initial load duke parents: diff changeset	1368 if (idx == i) {
a61af66fc99e Initial load duke parents: diff changeset	1369 if (cur == NULL)
a61af66fc99e Initial load duke parents: diff changeset	1370 cur = mem;
a61af66fc99e Initial load duke parents: diff changeset	1371 } else {
a61af66fc99e Initial load duke parents: diff changeset	1372 if (idx >= nmm->req() \|\| nmm->is_empty_memory(nmm->in(idx))) {
a61af66fc99e Initial load duke parents: diff changeset	1373 nmm->set_memory_at(idx, mem);
a61af66fc99e Initial load duke parents: diff changeset	1374 }
a61af66fc99e Initial load duke parents: diff changeset	1375 }
a61af66fc99e Initial load duke parents: diff changeset	1376 }
a61af66fc99e Initial load duke parents: diff changeset	1377 mem = mem->in(MemNode::Memory);
a61af66fc99e Initial load duke parents: diff changeset	1378 }
a61af66fc99e Initial load duke parents: diff changeset	1379 nmm->set_memory_at(i, (cur != NULL) ? cur : mem);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1380 // Find any instance of the current type if we haven't encountered
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1381 // already a memory slice of the instance along the memory chain.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1382 for (uint ni = new_index_start; ni < new_index_end; ni++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1383 if((uint)_compile->get_general_index(ni) == i) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1384 Node *m = (ni >= nmm->req()) ? nmm->empty_memory() : nmm->in(ni);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1385 if (nmm->is_empty_memory(m)) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1386 Node* result = find_inst_mem(mem, ni, orig_phis, igvn);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1387 if (_compile->failing()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1388 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1389 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1390 nmm->set_memory_at(ni, result);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1391 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1392 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1393 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1394 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1395 // Find the rest of instances values
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1396 for (uint ni = new_index_start; ni < new_index_end; ni++) {
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1397 const TypeOopPtr *tinst = _compile->get_adr_type(ni)->isa_oopptr();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1398 Node* result = step_through_mergemem(nmm, ni, tinst);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1399 if (result == nmm->base_memory()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1400 // Didn't find instance memory, search through general slice recursively.
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1401 result = nmm->memory_at(_compile->get_general_index(ni));
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1402 result = find_inst_mem(result, ni, orig_phis, igvn);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1403 if (_compile->failing()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1404 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1405 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1406 nmm->set_memory_at(ni, result);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1407 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1408 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1409 igvn->hash_insert(nmm);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1410 record_for_optimizer(nmm);
0 a61af66fc99e Initial load duke parents: diff changeset	1411 }
a61af66fc99e Initial load duke parents: diff changeset	1412
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1413 // Phase 4: Update the inputs of non-instance memory Phis and
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1414 // the Memory input of memnodes
0 a61af66fc99e Initial load duke parents: diff changeset	1415 // First update the inputs of any non-instance Phi's from
a61af66fc99e Initial load duke parents: diff changeset	1416 // which we split out an instance Phi. Note we don't have
a61af66fc99e Initial load duke parents: diff changeset	1417 // to recursively process Phi's encounted on the input memory
a61af66fc99e Initial load duke parents: diff changeset	1418 // chains as is done in split_memory_phi() since they will
a61af66fc99e Initial load duke parents: diff changeset	1419 // also be processed here.
247 02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1420 for (int j = 0; j < orig_phis.length(); j++) {
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric kvn parents: 245 diff changeset	1421 PhiNode *phi = orig_phis.at(j);
0 a61af66fc99e Initial load duke parents: diff changeset	1422 int alias_idx = _compile->get_alias_index(phi->adr_type());
a61af66fc99e Initial load duke parents: diff changeset	1423 igvn->hash_delete(phi);
a61af66fc99e Initial load duke parents: diff changeset	1424 for (uint i = 1; i < phi->req(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1425 Node *mem = phi->in(i);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1426 Node *new_mem = find_inst_mem(mem, alias_idx, orig_phis, igvn);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1427 if (_compile->failing()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1428 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1429 }
0 a61af66fc99e Initial load duke parents: diff changeset	1430 if (mem != new_mem) {
a61af66fc99e Initial load duke parents: diff changeset	1431 phi->set_req(i, new_mem);
a61af66fc99e Initial load duke parents: diff changeset	1432 }
a61af66fc99e Initial load duke parents: diff changeset	1433 }
a61af66fc99e Initial load duke parents: diff changeset	1434 igvn->hash_insert(phi);
a61af66fc99e Initial load duke parents: diff changeset	1435 record_for_optimizer(phi);
a61af66fc99e Initial load duke parents: diff changeset	1436 }
a61af66fc99e Initial load duke parents: diff changeset	1437
a61af66fc99e Initial load duke parents: diff changeset	1438 // Update the memory inputs of MemNodes with the value we computed
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1439 // in Phase 2 and move stores memory users to corresponding memory slices.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1440 #ifdef ASSERT
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1441 visited.Reset();
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1442 Node_Stack old_mems(arena, _compile->unique() >> 2);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1443 #endif
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1444 for (uint i = 0; i < nodes_size(); i++) {
0 a61af66fc99e Initial load duke parents: diff changeset	1445 Node *nmem = get_map(i);
a61af66fc99e Initial load duke parents: diff changeset	1446 if (nmem != NULL) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1447 Node *n = ptnode_adr(i)->_node;
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1448 assert(n != NULL, "sanity");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1449 if (n->is_Mem()) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1450 #ifdef ASSERT
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1451 Node* old_mem = n->in(MemNode::Memory);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1452 if (!visited.test_set(old_mem->_idx)) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1453 old_mems.push(old_mem, old_mem->outcnt());
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1454 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1455 #endif
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1456 assert(n->in(MemNode::Memory) != nmem, "sanity");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1457 if (!n->is_Load()) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1458 // Move memory users of a store first.
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1459 move_inst_mem(n, orig_phis, igvn);
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1460 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1461 // Now update memory input
0 a61af66fc99e Initial load duke parents: diff changeset	1462 igvn->hash_delete(n);
a61af66fc99e Initial load duke parents: diff changeset	1463 n->set_req(MemNode::Memory, nmem);
a61af66fc99e Initial load duke parents: diff changeset	1464 igvn->hash_insert(n);
a61af66fc99e Initial load duke parents: diff changeset	1465 record_for_optimizer(n);
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1466 } else {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1467 assert(n->is_Allocate() \|\| n->is_CheckCastPP() \|\|
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1468 n->is_AddP() \|\| n->is_Phi(), "unknown node used for set_map()");
0 a61af66fc99e Initial load duke parents: diff changeset	1469 }
a61af66fc99e Initial load duke parents: diff changeset	1470 }
a61af66fc99e Initial load duke parents: diff changeset	1471 }
1101 7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1472 #ifdef ASSERT
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1473 // Verify that memory was split correctly
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1474 while (old_mems.is_nonempty()) {
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1475 Node* old_mem = old_mems.node();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1476 uint old_cnt = old_mems.index();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1477 old_mems.pop();
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1478 assert(old_cnt = old_mem->outcnt(), "old mem could be lost");
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1479 }
7fee0a6cc6d4 6896727: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys kvn parents: 1100 diff changeset	1480 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1481 }
a61af66fc99e Initial load duke parents: diff changeset	1482
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1483 bool ConnectionGraph::has_candidates(Compile *C) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1484 // EA brings benefits only when the code has allocations and/or locks which
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1485 // are represented by ideal Macro nodes.
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1486 int cnt = C->macro_count();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1487 for( int i=0; i < cnt; i++ ) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1488 Node *n = C->macro_node(i);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1489 if ( n->is_Allocate() )
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1490 return true;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1491 if( n->is_Lock() ) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1492 Node* obj = n->as_Lock()->obj_node()->uncast();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1493 if( !(obj->is_Parm() \|\| obj->is_Con()) )
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1494 return true;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1495 }
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1496 }
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1497 return false;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1498 }
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1499
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1500 void ConnectionGraph::do_analysis(Compile C, PhaseIterGVN igvn) {
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1501 // Add ConP#NULL and ConN#NULL nodes before ConnectionGraph construction
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1502 // to create space for them in ConnectionGraph::_nodes[].
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1503 Node* oop_null = igvn->zerocon(T_OBJECT);
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1504 Node* noop_null = igvn->zerocon(T_NARROWOOP);
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1505
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1506 ConnectionGraph* congraph = new(C->comp_arena()) ConnectionGraph(C, igvn);
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1507 // Perform escape analysis
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1508 if (congraph->compute_escape()) {
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1509 // There are non escaping objects.
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1510 C->set_congraph(congraph);
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1511 }
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1512
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1513 // Cleanup.
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1514 if (oop_null->outcnt() == 0)
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1515 igvn->hash_delete(oop_null);
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1516 if (noop_null->outcnt() == 0)
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1517 igvn->hash_delete(noop_null);
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1518 }
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1519
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1520 bool ConnectionGraph::compute_escape() {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1521 Compile* C = _compile;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1522
163 885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	1523 // 1. Populate Connection Graph (CG) with Ideal nodes.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1524
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1525 Unique_Node_List worklist_init;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1526 worklist_init.map(C->unique(), NULL); // preallocate space
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1527
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1528 // Initialize worklist
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1529 if (C->root() != NULL) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1530 worklist_init.push(C->root());
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1531 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1532
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1533 GrowableArray<int> cg_worklist;
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1534 PhaseGVN* igvn = _igvn;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1535 bool has_allocations = false;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1536
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1537 // Push all useful nodes onto CG list and set their type.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1538 for( uint next = 0; next < worklist_init.size(); ++next ) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1539 Node* n = worklist_init.at(next);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1540 record_for_escape_analysis(n, igvn);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1541 // Only allocations and java static calls results are checked
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1542 // for an escape status. See process_call_result() below.
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1543 if (n->is_Allocate() \|\| n->is_CallStaticJava() &&
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1544 ptnode_adr(n->_idx)->node_type() == PointsToNode::JavaObject) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1545 has_allocations = true;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1546 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1547 if(n->is_AddP()) {
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1548 // Collect address nodes. Use them during stage 3 below
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1549 // to build initial connection graph field edges.
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1550 cg_worklist.append(n->_idx);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1551 } else if (n->is_MergeMem()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1552 // Collect all MergeMem nodes to add memory slices for
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1553 // scalar replaceable objects in split_unique_types().
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1554 _mergemem_worklist.append(n->as_MergeMem());
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1555 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1556 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1557 Node* m = n->fast_out(i); // Get user
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1558 worklist_init.push(m);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1559 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1560 }
0 a61af66fc99e Initial load duke parents: diff changeset	1561
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1562 if (!has_allocations) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1563 _collecting = false;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1564 return false; // Nothing to do.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1565 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1566
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1567 // 2. First pass to create simple CG edges (doesn't require to walk CG).
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1568 uint delayed_size = _delayed_worklist.size();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1569 for( uint next = 0; next < delayed_size; ++next ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1570 Node* n = _delayed_worklist.at(next);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1571 build_connection_graph(n, igvn);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1572 }
0 a61af66fc99e Initial load duke parents: diff changeset	1573
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1574 // 3. Pass to create initial fields edges (JavaObject -F-> AddP)
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1575 // to reduce number of iterations during stage 4 below.
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1576 uint cg_length = cg_worklist.length();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1577 for( uint next = 0; next < cg_length; ++next ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1578 int ni = cg_worklist.at(next);
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1579 Node* n = ptnode_adr(ni)->_node;
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1580 Node* base = get_addp_base(n);
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1581 if (base->is_Proj())
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1582 base = base->in(0);
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1583 PointsToNode::NodeType nt = ptnode_adr(base->_idx)->node_type();
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1584 if (nt == PointsToNode::JavaObject) {
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1585 build_connection_graph(n, igvn);
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1586 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1587 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1588
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1589 cg_worklist.clear();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1590 cg_worklist.append(_phantom_object);
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1591 GrowableArray<uint> worklist;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1592
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1593 // 4. Build Connection Graph which need
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1594 // to walk the connection graph.
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1595 _progress = false;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1596 for (uint ni = 0; ni < nodes_size(); ni++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1597 PointsToNode* ptn = ptnode_adr(ni);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1598 Node *n = ptn->_node;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1599 if (n != NULL) { // Call, AddP, LoadP, StoreP
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1600 build_connection_graph(n, igvn);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1601 if (ptn->node_type() != PointsToNode::UnknownType)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1602 cg_worklist.append(n->_idx); // Collect CG nodes
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1603 if (!_processed.test(n->_idx))
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1604 worklist.append(n->_idx); // Collect C/A/L/S nodes
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1605 }
0 a61af66fc99e Initial load duke parents: diff changeset	1606 }
a61af66fc99e Initial load duke parents: diff changeset	1607
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1608 // After IGVN user nodes may have smaller _idx than
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1609 // their inputs so they will be processed first in
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1610 // previous loop. Because of that not all Graph
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1611 // edges will be created. Walk over interesting
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1612 // nodes again until no new edges are created.
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1613 //
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1614 // Normally only 1-3 passes needed to build
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1615 // Connection Graph depending on graph complexity.
2086 a21ff35351ec 7003130: assert(iterations<CG_BUILD_ITER_LIMIT) failed: infinite EA connection graph kvn parents: 1972 diff changeset	1616 // Observed 8 passes in jvm2008 compiler.compiler.
a21ff35351ec 7003130: assert(iterations<CG_BUILD_ITER_LIMIT) failed: infinite EA connection graph kvn parents: 1972 diff changeset	1617 // Set limit to 20 to catch situation when something
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1618 // did go wrong and recompile the method without EA.
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1619
2086 a21ff35351ec 7003130: assert(iterations<CG_BUILD_ITER_LIMIT) failed: infinite EA connection graph kvn parents: 1972 diff changeset	1620 #define CG_BUILD_ITER_LIMIT 20
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1621
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1622 uint length = worklist.length();
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1623 int iterations = 0;
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1624 while(_progress && (iterations++ < CG_BUILD_ITER_LIMIT)) {
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1625 _progress = false;
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1626 for( uint next = 0; next < length; ++next ) {
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1627 int ni = worklist.at(next);
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1628 PointsToNode* ptn = ptnode_adr(ni);
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1629 Node* n = ptn->_node;
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1630 assert(n != NULL, "should be known node");
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1631 build_connection_graph(n, igvn);
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1632 }
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1633 }
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1634 if (iterations >= CG_BUILD_ITER_LIMIT) {
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1635 assert(iterations < CG_BUILD_ITER_LIMIT,
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1636 err_msg("infinite EA connection graph build with %d nodes and worklist size %d",
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1637 nodes_size(), length));
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1638 // Possible infinite build_connection_graph loop,
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1639 // retry compilation without escape analysis.
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1640 C->record_failure(C2Compiler::retry_no_escape_analysis());
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1641 _collecting = false;
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1642 return false;
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1643 }
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1644 #undef CG_BUILD_ITER_LIMIT
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1645
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1646 Arena* arena = Thread::current()->resource_area();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1647 VectorSet visited(arena);
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1648 worklist.clear();
0 a61af66fc99e Initial load duke parents: diff changeset	1649
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1650 // 5. Remove deferred edges from the graph and adjust
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1651 // escape state of nonescaping objects.
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1652 cg_length = cg_worklist.length();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1653 for( uint next = 0; next < cg_length; ++next ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1654 int ni = cg_worklist.at(next);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1655 PointsToNode* ptn = ptnode_adr(ni);
0 a61af66fc99e Initial load duke parents: diff changeset	1656 PointsToNode::NodeType nt = ptn->node_type();
a61af66fc99e Initial load duke parents: diff changeset	1657 if (nt == PointsToNode::LocalVar \|\| nt == PointsToNode::Field) {
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1658 remove_deferred(ni, &worklist, &visited);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1659 Node *n = ptn->_node;
0 a61af66fc99e Initial load duke parents: diff changeset	1660 if (n->is_AddP()) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1661 // Search for objects which are not scalar replaceable
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1662 // and adjust their escape state.
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1663 adjust_escape_state(ni, igvn);
0 a61af66fc99e Initial load duke parents: diff changeset	1664 }
a61af66fc99e Initial load duke parents: diff changeset	1665 }
a61af66fc99e Initial load duke parents: diff changeset	1666 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1667
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1668 // 6. Propagate escape states.
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	1669 worklist.clear();
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1670 bool has_non_escaping_obj = false;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1671
0 a61af66fc99e Initial load duke parents: diff changeset	1672 // push all GlobalEscape nodes on the worklist
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1673 for( uint next = 0; next < cg_length; ++next ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1674 int nk = cg_worklist.at(next);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1675 if (ptnode_adr(nk)->escape_state() == PointsToNode::GlobalEscape)
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1676 worklist.push(nk);
0 a61af66fc99e Initial load duke parents: diff changeset	1677 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1678 // mark all nodes reachable from GlobalEscape nodes
0 a61af66fc99e Initial load duke parents: diff changeset	1679 while(worklist.length() > 0) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1680 PointsToNode* ptn = ptnode_adr(worklist.pop());
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1681 uint e_cnt = ptn->edge_count();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1682 for (uint ei = 0; ei < e_cnt; ei++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1683 uint npi = ptn->edge_target(ei);
0 a61af66fc99e Initial load duke parents: diff changeset	1684 PointsToNode *np = ptnode_adr(npi);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1685 if (np->escape_state() < PointsToNode::GlobalEscape) {
0 a61af66fc99e Initial load duke parents: diff changeset	1686 np->set_escape_state(PointsToNode::GlobalEscape);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1687 worklist.push(npi);
0 a61af66fc99e Initial load duke parents: diff changeset	1688 }
a61af66fc99e Initial load duke parents: diff changeset	1689 }
a61af66fc99e Initial load duke parents: diff changeset	1690 }
a61af66fc99e Initial load duke parents: diff changeset	1691
a61af66fc99e Initial load duke parents: diff changeset	1692 // push all ArgEscape nodes on the worklist
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1693 for( uint next = 0; next < cg_length; ++next ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1694 int nk = cg_worklist.at(next);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1695 if (ptnode_adr(nk)->escape_state() == PointsToNode::ArgEscape)
0 a61af66fc99e Initial load duke parents: diff changeset	1696 worklist.push(nk);
a61af66fc99e Initial load duke parents: diff changeset	1697 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1698 // mark all nodes reachable from ArgEscape nodes
0 a61af66fc99e Initial load duke parents: diff changeset	1699 while(worklist.length() > 0) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1700 PointsToNode* ptn = ptnode_adr(worklist.pop());
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1701 if (ptn->node_type() == PointsToNode::JavaObject)
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1702 has_non_escaping_obj = true; // Non GlobalEscape
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1703 uint e_cnt = ptn->edge_count();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1704 for (uint ei = 0; ei < e_cnt; ei++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1705 uint npi = ptn->edge_target(ei);
0 a61af66fc99e Initial load duke parents: diff changeset	1706 PointsToNode *np = ptnode_adr(npi);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1707 if (np->escape_state() < PointsToNode::ArgEscape) {
0 a61af66fc99e Initial load duke parents: diff changeset	1708 np->set_escape_state(PointsToNode::ArgEscape);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1709 worklist.push(npi);
0 a61af66fc99e Initial load duke parents: diff changeset	1710 }
a61af66fc99e Initial load duke parents: diff changeset	1711 }
a61af66fc99e Initial load duke parents: diff changeset	1712 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1713
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1714 GrowableArray<Node*> alloc_worklist;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1715
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1716 // push all NoEscape nodes on the worklist
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1717 for( uint next = 0; next < cg_length; ++next ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1718 int nk = cg_worklist.at(next);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1719 if (ptnode_adr(nk)->escape_state() == PointsToNode::NoEscape)
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1720 worklist.push(nk);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1721 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1722 // mark all nodes reachable from NoEscape nodes
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1723 while(worklist.length() > 0) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1724 PointsToNode* ptn = ptnode_adr(worklist.pop());
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1725 if (ptn->node_type() == PointsToNode::JavaObject)
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1726 has_non_escaping_obj = true; // Non GlobalEscape
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1727 Node* n = ptn->_node;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1728 if (n->is_Allocate() && ptn->_scalar_replaceable ) {
605 98cb887364d3 6810672: Comment typos twisti parents: 584 diff changeset	1729 // Push scalar replaceable allocations on alloc_worklist
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1730 // for processing in split_unique_types().
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1731 alloc_worklist.append(n);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1732 }
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1733 uint e_cnt = ptn->edge_count();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1734 for (uint ei = 0; ei < e_cnt; ei++) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1735 uint npi = ptn->edge_target(ei);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1736 PointsToNode *np = ptnode_adr(npi);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1737 if (np->escape_state() < PointsToNode::NoEscape) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1738 np->set_escape_state(PointsToNode::NoEscape);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1739 worklist.push(npi);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1740 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1741 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1742 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1743
0 a61af66fc99e Initial load duke parents: diff changeset	1744 _collecting = false;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1745 assert(C->unique() == nodes_size(), "there should be no new ideal nodes during ConnectionGraph build");
0 a61af66fc99e Initial load duke parents: diff changeset	1746
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1747 #ifndef PRODUCT
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1748 if (PrintEscapeAnalysis) {
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1749 dump(); // Dump ConnectionGraph
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1750 }
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1751 #endif
60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	1752
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1753 bool has_scalar_replaceable_candidates = alloc_worklist.length() > 0;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1754 if ( has_scalar_replaceable_candidates &&
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1755 C->AliasLevel() >= 3 && EliminateAllocations ) {
0 a61af66fc99e Initial load duke parents: diff changeset	1756
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1757 // Now use the escape information to create unique types for
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1758 // scalar replaceable objects.
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1759 split_unique_types(alloc_worklist);
0 a61af66fc99e Initial load duke parents: diff changeset	1760
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1761 if (C->failing()) return false;
0 a61af66fc99e Initial load duke parents: diff changeset	1762
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1763 C->print_method("After Escape Analysis", 2);
0 a61af66fc99e Initial load duke parents: diff changeset	1764
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1765 #ifdef ASSERT
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1766 } else if (Verbose && (PrintEscapeAnalysis \|\| PrintEliminateAllocations)) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1767 tty->print("=== No allocations eliminated for ");
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1768 C->method()->print_short_name();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1769 if(!EliminateAllocations) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1770 tty->print(" since EliminateAllocations is off ===");
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1771 } else if(!has_scalar_replaceable_candidates) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1772 tty->print(" since there are no scalar replaceable candidates ===");
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1773 } else if(C->AliasLevel() < 3) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1774 tty->print(" since AliasLevel < 3 ===");
0 a61af66fc99e Initial load duke parents: diff changeset	1775 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1776 tty->cr();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1777 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1778 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	1779 return has_non_escaping_obj;
0 a61af66fc99e Initial load duke parents: diff changeset	1780 }
a61af66fc99e Initial load duke parents: diff changeset	1781
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1782 // Adjust escape state after Connection Graph is built.
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1783 void ConnectionGraph::adjust_escape_state(int nidx, PhaseTransform* phase) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1784 PointsToNode* ptn = ptnode_adr(nidx);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1785 Node* n = ptn->_node;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1786 assert(n->is_AddP(), "Should be called for AddP nodes only");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1787 // Search for objects which are not scalar replaceable.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1788 // Mark their escape state as ArgEscape to propagate the state
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1789 // to referenced objects.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1790 // Note: currently there are no difference in compiler optimizations
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1791 // for ArgEscape objects and NoEscape objects which are not
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1792 // scalar replaceable.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1793
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1794 Compile* C = _compile;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1795
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1796 int offset = ptn->offset();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1797 Node* base = get_addp_base(n);
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1798 VectorSet* ptset = PointsTo(base);
3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1799 int ptset_size = ptset->Size();
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1800
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1801 // Check if a oop field's initializing value is recorded and add
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1802 // a corresponding NULL field's value if it is not recorded.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1803 // Connection Graph does not record a default initialization by NULL
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1804 // captured by Initialize node.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1805 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1806 // Note: it will disable scalar replacement in some cases:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1807 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1808 // Point p[] = new Point[1];
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1809 // p[0] = new Point(); // Will be not scalar replaced
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1810 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1811 // but it will save us from incorrect optimizations in next cases:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1812 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1813 // Point p[] = new Point[1];
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1814 // if ( x ) p[0] = new Point(); // Will be not scalar replaced
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1815 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1816 // Do a simple control flow analysis to distinguish above cases.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1817 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1818 if (offset != Type::OffsetBot && ptset_size == 1) {
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1819 uint elem = ptset->getelem(); // Allocation node's index
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1820 // It does not matter if it is not Allocation node since
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1821 // only non-escaping allocations are scalar replaced.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1822 if (ptnode_adr(elem)->_node->is_Allocate() &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1823 ptnode_adr(elem)->escape_state() == PointsToNode::NoEscape) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1824 AllocateNode* alloc = ptnode_adr(elem)->_node->as_Allocate();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1825 InitializeNode* ini = alloc->initialization();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1826
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1827 // Check only oop fields.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1828 const Type* adr_type = n->as_AddP()->bottom_type();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1829 BasicType basic_field_type = T_INT;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1830 if (adr_type->isa_instptr()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1831 ciField* field = C->alias_type(adr_type->isa_instptr())->field();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1832 if (field != NULL) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1833 basic_field_type = field->layout_type();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1834 } else {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1835 // Ignore non field load (for example, klass load)
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1836 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1837 } else if (adr_type->isa_aryptr()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1838 const Type* elemtype = adr_type->isa_aryptr()->elem();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1839 basic_field_type = elemtype->array_element_basic_type();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1840 } else {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1841 // Raw pointers are used for initializing stores so skip it.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1842 assert(adr_type->isa_rawptr() && base->is_Proj() &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1843 (base->in(0) == alloc),"unexpected pointer type");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1844 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1845 if (basic_field_type == T_OBJECT \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1846 basic_field_type == T_NARROWOOP \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1847 basic_field_type == T_ARRAY) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1848 Node* value = NULL;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1849 if (ini != NULL) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1850 BasicType ft = UseCompressedOops ? T_NARROWOOP : T_OBJECT;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1851 Node* store = ini->find_captured_store(offset, type2aelembytes(ft), phase);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1852 if (store != NULL && store->is_Store()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1853 value = store->in(MemNode::ValueIn);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1854 } else if (ptn->edge_count() > 0) { // Are there oop stores?
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1855 // Check for a store which follows allocation without branches.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1856 // For example, a volatile field store is not collected
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1857 // by Initialize node. TODO: it would be nice to use idom() here.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1858 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1859 store = n->fast_out(i);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1860 if (store->is_Store() && store->in(0) != NULL) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1861 Node* ctrl = store->in(0);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1862 while(!(ctrl == ini \|\| ctrl == alloc \|\| ctrl == NULL \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1863 ctrl == C->root() \|\| ctrl == C->top() \|\| ctrl->is_Region() \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1864 ctrl->is_IfTrue() \|\| ctrl->is_IfFalse())) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1865 ctrl = ctrl->in(0);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1866 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1867 if (ctrl == ini \|\| ctrl == alloc) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1868 value = store->in(MemNode::ValueIn);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1869 break;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1870 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1871 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1872 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1873 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1874 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1875 if (value == NULL \|\| value != ptnode_adr(value->_idx)->_node) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1876 // A field's initializing value was not recorded. Add NULL.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1877 uint null_idx = UseCompressedOops ? _noop_null : _oop_null;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1878 add_pointsto_edge(nidx, null_idx);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1879 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1880 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1881 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1882 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1883
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1884 // An object is not scalar replaceable if the field which may point
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1885 // to it has unknown offset (unknown element of an array of objects).
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1886 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1887 if (offset == Type::OffsetBot) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1888 uint e_cnt = ptn->edge_count();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1889 for (uint ei = 0; ei < e_cnt; ei++) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1890 uint npi = ptn->edge_target(ei);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1891 set_escape_state(npi, PointsToNode::ArgEscape);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1892 ptnode_adr(npi)->_scalar_replaceable = false;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1893 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1894 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1895
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1896 // Currently an object is not scalar replaceable if a LoadStore node
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1897 // access its field since the field value is unknown after it.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1898 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1899 bool has_LoadStore = false;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1900 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1901 Node *use = n->fast_out(i);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1902 if (use->is_LoadStore()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1903 has_LoadStore = true;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1904 break;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1905 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1906 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1907 // An object is not scalar replaceable if the address points
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1908 // to unknown field (unknown element for arrays, offset is OffsetBot).
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1909 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1910 // Or the address may point to more then one object. This may produce
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1911 // the false positive result (set scalar_replaceable to false)
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1912 // since the flow-insensitive escape analysis can't separate
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1913 // the case when stores overwrite the field's value from the case
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1914 // when stores happened on different control branches.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1915 //
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1916 if (ptset_size > 1 \|\| ptset_size != 0 &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1917 (has_LoadStore \|\| offset == Type::OffsetBot)) {
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1918 for( VectorSetI j(ptset); j.test(); ++j ) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1919 set_escape_state(j.elem, PointsToNode::ArgEscape);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1920 ptnode_adr(j.elem)->_scalar_replaceable = false;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1921 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1922 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1923 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1924
0 a61af66fc99e Initial load duke parents: diff changeset	1925 void ConnectionGraph::process_call_arguments(CallNode call, PhaseTransform phase) {
a61af66fc99e Initial load duke parents: diff changeset	1926
a61af66fc99e Initial load duke parents: diff changeset	1927 switch (call->Opcode()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1928 #ifdef ASSERT
0 a61af66fc99e Initial load duke parents: diff changeset	1929 case Op_Allocate:
a61af66fc99e Initial load duke parents: diff changeset	1930 case Op_AllocateArray:
a61af66fc99e Initial load duke parents: diff changeset	1931 case Op_Lock:
a61af66fc99e Initial load duke parents: diff changeset	1932 case Op_Unlock:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1933 assert(false, "should be done already");
0 a61af66fc99e Initial load duke parents: diff changeset	1934 break;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1935 #endif
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1936 case Op_CallLeaf:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1937 case Op_CallLeafNoFP:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1938 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1939 // Stub calls, objects do not escape but they are not scale replaceable.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1940 // Adjust escape state for outgoing arguments.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1941 const TypeTuple * d = call->tf()->domain();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1942 for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1943 const Type* at = d->field_at(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1944 Node *arg = call->in(i)->uncast();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1945 const Type *aat = phase->type(arg);
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1946 if (!arg->is_top() && at->isa_ptr() && aat->isa_ptr() &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1947 ptnode_adr(arg->_idx)->escape_state() < PointsToNode::ArgEscape) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1948
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1949 assert(aat == Type::TOP \|\| aat == TypePtr::NULL_PTR \|\|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1950 aat->isa_ptr() != NULL, "expecting an Ptr");
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1951 #ifdef ASSERT
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1952 if (!(call->Opcode() == Op_CallLeafNoFP &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1953 call->as_CallLeaf()->_name != NULL &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1954 (strstr(call->as_CallLeaf()->_name, "arraycopy") != 0) \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1955 call->as_CallLeaf()->_name != NULL &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1956 (strcmp(call->as_CallLeaf()->_name, "g1_wb_pre") == 0 \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1957 strcmp(call->as_CallLeaf()->_name, "g1_wb_post") == 0 ))
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1958 ) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1959 call->dump();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1960 assert(false, "EA: unexpected CallLeaf");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1961 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1962 #endif
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1963 set_escape_state(arg->_idx, PointsToNode::ArgEscape);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1964 if (arg->is_AddP()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1965 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1966 // The inline_native_clone() case when the arraycopy stub is called
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1967 // after the allocation before Initialize and CheckCastPP nodes.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1968 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1969 // Set AddP's base (Allocate) as not scalar replaceable since
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1970 // pointer to the base (with offset) is passed as argument.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1971 //
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1972 arg = get_addp_base(arg);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1973 }
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	1974 for( VectorSetI j(PointsTo(arg)); j.test(); ++j ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1975 uint pt = j.elem;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1976 set_escape_state(pt, PointsToNode::ArgEscape);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1977 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1978 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1979 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1980 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1981 }
0 a61af66fc99e Initial load duke parents: diff changeset	1982
a61af66fc99e Initial load duke parents: diff changeset	1983 case Op_CallStaticJava:
a61af66fc99e Initial load duke parents: diff changeset	1984 // For a static call, we know exactly what method is being called.
a61af66fc99e Initial load duke parents: diff changeset	1985 // Use bytecode estimator to record the call's escape affects
a61af66fc99e Initial load duke parents: diff changeset	1986 {
a61af66fc99e Initial load duke parents: diff changeset	1987 ciMethod *meth = call->as_CallJava()->method();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1988 BCEscapeAnalyzer *call_analyzer = (meth !=NULL) ? meth->get_bcea() : NULL;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1989 // fall-through if not a Java method or no analyzer information
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1990 if (call_analyzer != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1991 const TypeTuple * d = call->tf()->domain();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	1992 bool copy_dependencies = false;
0 a61af66fc99e Initial load duke parents: diff changeset	1993 for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1994 const Type* at = d->field_at(i);
a61af66fc99e Initial load duke parents: diff changeset	1995 int k = i - TypeFunc::Parms;
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1996 Node *arg = call->in(i)->uncast();
0 a61af66fc99e Initial load duke parents: diff changeset	1997
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	1998 if (at->isa_oopptr() != NULL &&
1136 4b84186a8248 6913075: EA identifies escape state incorrectly after 6895383 fix kvn parents: 1101 diff changeset	1999 ptnode_adr(arg->_idx)->escape_state() < PointsToNode::GlobalEscape) {
0 a61af66fc99e Initial load duke parents: diff changeset	2000
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2001 bool global_escapes = false;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2002 bool fields_escapes = false;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2003 if (!call_analyzer->is_arg_stack(k)) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2004 // The argument global escapes, mark everything it could point to
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2005 set_escape_state(arg->_idx, PointsToNode::GlobalEscape);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2006 global_escapes = true;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2007 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2008 if (!call_analyzer->is_arg_local(k)) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2009 // The argument itself doesn't escape, but any fields might
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2010 fields_escapes = true;
0 a61af66fc99e Initial load duke parents: diff changeset	2011 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2012 set_escape_state(arg->_idx, PointsToNode::ArgEscape);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2013 copy_dependencies = true;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2014 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2015
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	2016 for( VectorSetI j(PointsTo(arg)); j.test(); ++j ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2017 uint pt = j.elem;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2018 if (global_escapes) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2019 //The argument global escapes, mark everything it could point to
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2020 set_escape_state(pt, PointsToNode::GlobalEscape);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2021 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2022 if (fields_escapes) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2023 // The argument itself doesn't escape, but any fields might
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2024 add_edge_from_fields(pt, _phantom_object, Type::OffsetBot);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2025 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2026 set_escape_state(pt, PointsToNode::ArgEscape);
0 a61af66fc99e Initial load duke parents: diff changeset	2027 }
a61af66fc99e Initial load duke parents: diff changeset	2028 }
a61af66fc99e Initial load duke parents: diff changeset	2029 }
a61af66fc99e Initial load duke parents: diff changeset	2030 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2031 if (copy_dependencies)
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2032 call_analyzer->copy_dependencies(_compile->dependencies());
0 a61af66fc99e Initial load duke parents: diff changeset	2033 break;
a61af66fc99e Initial load duke parents: diff changeset	2034 }
a61af66fc99e Initial load duke parents: diff changeset	2035 }
a61af66fc99e Initial load duke parents: diff changeset	2036
a61af66fc99e Initial load duke parents: diff changeset	2037 default:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2038 // Fall-through here if not a Java method or no analyzer information
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2039 // or some other type of call, assume the worst case: all arguments
0 a61af66fc99e Initial load duke parents: diff changeset	2040 // globally escape.
a61af66fc99e Initial load duke parents: diff changeset	2041 {
a61af66fc99e Initial load duke parents: diff changeset	2042 // adjust escape state for outgoing arguments
a61af66fc99e Initial load duke parents: diff changeset	2043 const TypeTuple * d = call->tf()->domain();
a61af66fc99e Initial load duke parents: diff changeset	2044 for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	2045 const Type* at = d->field_at(i);
a61af66fc99e Initial load duke parents: diff changeset	2046 if (at->isa_oopptr() != NULL) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2047 Node *arg = call->in(i)->uncast();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2048 set_escape_state(arg->_idx, PointsToNode::GlobalEscape);
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	2049 for( VectorSetI j(PointsTo(arg)); j.test(); ++j ) {
0 a61af66fc99e Initial load duke parents: diff changeset	2050 uint pt = j.elem;
a61af66fc99e Initial load duke parents: diff changeset	2051 set_escape_state(pt, PointsToNode::GlobalEscape);
a61af66fc99e Initial load duke parents: diff changeset	2052 }
a61af66fc99e Initial load duke parents: diff changeset	2053 }
a61af66fc99e Initial load duke parents: diff changeset	2054 }
a61af66fc99e Initial load duke parents: diff changeset	2055 }
a61af66fc99e Initial load duke parents: diff changeset	2056 }
a61af66fc99e Initial load duke parents: diff changeset	2057 }
a61af66fc99e Initial load duke parents: diff changeset	2058 void ConnectionGraph::process_call_result(ProjNode resproj, PhaseTransform phase) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2059 CallNode *call = resproj->in(0)->as_Call();
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2060 uint call_idx = call->_idx;
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2061 uint resproj_idx = resproj->_idx;
0 a61af66fc99e Initial load duke parents: diff changeset	2062
a61af66fc99e Initial load duke parents: diff changeset	2063 switch (call->Opcode()) {
a61af66fc99e Initial load duke parents: diff changeset	2064 case Op_Allocate:
a61af66fc99e Initial load duke parents: diff changeset	2065 {
a61af66fc99e Initial load duke parents: diff changeset	2066 Node *k = call->in(AllocateNode::KlassNode);
1539 c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2067 const TypeKlassPtr *kt = k->bottom_type()->isa_klassptr();
0 a61af66fc99e Initial load duke parents: diff changeset	2068 assert(kt != NULL, "TypeKlassPtr required.");
a61af66fc99e Initial load duke parents: diff changeset	2069 ciKlass* cik = kt->klass();
a61af66fc99e Initial load duke parents: diff changeset	2070
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2071 PointsToNode::EscapeState es;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2072 uint edge_to;
1539 c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2073 if (cik->is_subclass_of(_compile->env()->Thread_klass()) \|\|
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2074 !cik->is_instance_klass() \|\| // StressReflectiveCode
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2075 cik->as_instance_klass()->has_finalizer()) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2076 es = PointsToNode::GlobalEscape;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2077 edge_to = _phantom_object; // Could not be worse
0 a61af66fc99e Initial load duke parents: diff changeset	2078 } else {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2079 es = PointsToNode::NoEscape;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2080 edge_to = call_idx;
0 a61af66fc99e Initial load duke parents: diff changeset	2081 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2082 set_escape_state(call_idx, es);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2083 add_pointsto_edge(resproj_idx, edge_to);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2084 _processed.set(resproj_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2085 break;
a61af66fc99e Initial load duke parents: diff changeset	2086 }
a61af66fc99e Initial load duke parents: diff changeset	2087
a61af66fc99e Initial load duke parents: diff changeset	2088 case Op_AllocateArray:
a61af66fc99e Initial load duke parents: diff changeset	2089 {
1539 c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2090
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2091 Node *k = call->in(AllocateNode::KlassNode);
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2092 const TypeKlassPtr *kt = k->bottom_type()->isa_klassptr();
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2093 assert(kt != NULL, "TypeKlassPtr required.");
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2094 ciKlass* cik = kt->klass();
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2095
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2096 PointsToNode::EscapeState es;
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2097 uint edge_to;
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2098 if (!cik->is_array_klass()) { // StressReflectiveCode
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2099 es = PointsToNode::GlobalEscape;
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2100 edge_to = _phantom_object;
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2101 } else {
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2102 es = PointsToNode::NoEscape;
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2103 edge_to = call_idx;
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2104 int length = call->in(AllocateNode::ALength)->find_int_con(-1);
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2105 if (length < 0 \|\| length > EliminateAllocationArraySizeLimit) {
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2106 // Not scalar replaceable if the length is not constant or too big.
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2107 ptnode_adr(call_idx)->_scalar_replaceable = false;
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2108 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2109 }
1539 c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2110 set_escape_state(call_idx, es);
c52275c698d1 6953267: assert in EA code with -XX:+StressReflectiveCode kvn parents: 1136 diff changeset	2111 add_pointsto_edge(resproj_idx, edge_to);
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2112 _processed.set(resproj_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2113 break;
a61af66fc99e Initial load duke parents: diff changeset	2114 }
a61af66fc99e Initial load duke parents: diff changeset	2115
a61af66fc99e Initial load duke parents: diff changeset	2116 case Op_CallStaticJava:
a61af66fc99e Initial load duke parents: diff changeset	2117 // For a static call, we know exactly what method is being called.
a61af66fc99e Initial load duke parents: diff changeset	2118 // Use bytecode estimator to record whether the call's return value escapes
a61af66fc99e Initial load duke parents: diff changeset	2119 {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2120 bool done = true;
0 a61af66fc99e Initial load duke parents: diff changeset	2121 const TypeTuple *r = call->tf()->range();
a61af66fc99e Initial load duke parents: diff changeset	2122 const Type* ret_type = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2123
a61af66fc99e Initial load duke parents: diff changeset	2124 if (r->cnt() > TypeFunc::Parms)
a61af66fc99e Initial load duke parents: diff changeset	2125 ret_type = r->field_at(TypeFunc::Parms);
a61af66fc99e Initial load duke parents: diff changeset	2126
a61af66fc99e Initial load duke parents: diff changeset	2127 // Note: we use isa_ptr() instead of isa_oopptr() here because the
a61af66fc99e Initial load duke parents: diff changeset	2128 // _multianewarray functions return a TypeRawPtr.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2129 if (ret_type == NULL \|\| ret_type->isa_ptr() == NULL) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2130 _processed.set(resproj_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2131 break; // doesn't return a pointer type
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2132 }
0 a61af66fc99e Initial load duke parents: diff changeset	2133 ciMethod *meth = call->as_CallJava()->method();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2134 const TypeTuple * d = call->tf()->domain();
0 a61af66fc99e Initial load duke parents: diff changeset	2135 if (meth == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2136 // not a Java method, assume global escape
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2137 set_escape_state(call_idx, PointsToNode::GlobalEscape);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2138 add_pointsto_edge(resproj_idx, _phantom_object);
0 a61af66fc99e Initial load duke parents: diff changeset	2139 } else {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2140 BCEscapeAnalyzer *call_analyzer = meth->get_bcea();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2141 bool copy_dependencies = false;
0 a61af66fc99e Initial load duke parents: diff changeset	2142
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2143 if (call_analyzer->is_return_allocated()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2144 // Returns a newly allocated unescaped object, simply
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2145 // update dependency information.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2146 // Mark it as NoEscape so that objects referenced by
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2147 // it's fields will be marked as NoEscape at least.
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2148 set_escape_state(call_idx, PointsToNode::NoEscape);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2149 add_pointsto_edge(resproj_idx, call_idx);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2150 copy_dependencies = true;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2151 } else if (call_analyzer->is_return_local()) {
0 a61af66fc99e Initial load duke parents: diff changeset	2152 // determine whether any arguments are returned
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2153 set_escape_state(call_idx, PointsToNode::NoEscape);
307 892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2154 bool ret_arg = false;
0 a61af66fc99e Initial load duke parents: diff changeset	2155 for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	2156 const Type* at = d->field_at(i);
a61af66fc99e Initial load duke parents: diff changeset	2157
a61af66fc99e Initial load duke parents: diff changeset	2158 if (at->isa_oopptr() != NULL) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2159 Node *arg = call->in(i)->uncast();
0 a61af66fc99e Initial load duke parents: diff changeset	2160
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2161 if (call_analyzer->is_arg_returned(i - TypeFunc::Parms)) {
307 892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2162 ret_arg = true;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2163 PointsToNode *arg_esp = ptnode_adr(arg->_idx);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2164 if (arg_esp->node_type() == PointsToNode::UnknownType)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2165 done = false;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2166 else if (arg_esp->node_type() == PointsToNode::JavaObject)
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2167 add_pointsto_edge(resproj_idx, arg->_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2168 else
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2169 add_deferred_edge(resproj_idx, arg->_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2170 arg_esp->_hidden_alias = true;
a61af66fc99e Initial load duke parents: diff changeset	2171 }
a61af66fc99e Initial load duke parents: diff changeset	2172 }
a61af66fc99e Initial load duke parents: diff changeset	2173 }
307 892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2174 if (done && !ret_arg) {
892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2175 // Returns unknown object.
892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2176 set_escape_state(call_idx, PointsToNode::GlobalEscape);
892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2177 add_pointsto_edge(resproj_idx, _phantom_object);
892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2178 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2179 copy_dependencies = true;
0 a61af66fc99e Initial load duke parents: diff changeset	2180 } else {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2181 set_escape_state(call_idx, PointsToNode::GlobalEscape);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2182 add_pointsto_edge(resproj_idx, _phantom_object);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2183 for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2184 const Type* at = d->field_at(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2185 if (at->isa_oopptr() != NULL) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2186 Node *arg = call->in(i)->uncast();
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2187 PointsToNode *arg_esp = ptnode_adr(arg->_idx);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2188 arg_esp->_hidden_alias = true;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2189 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2190 }
0 a61af66fc99e Initial load duke parents: diff changeset	2191 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2192 if (copy_dependencies)
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2193 call_analyzer->copy_dependencies(_compile->dependencies());
0 a61af66fc99e Initial load duke parents: diff changeset	2194 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2195 if (done)
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2196 _processed.set(resproj_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2197 break;
a61af66fc99e Initial load duke parents: diff changeset	2198 }
a61af66fc99e Initial load duke parents: diff changeset	2199
a61af66fc99e Initial load duke parents: diff changeset	2200 default:
a61af66fc99e Initial load duke parents: diff changeset	2201 // Some other type of call, assume the worst case that the
a61af66fc99e Initial load duke parents: diff changeset	2202 // returned value, if any, globally escapes.
a61af66fc99e Initial load duke parents: diff changeset	2203 {
a61af66fc99e Initial load duke parents: diff changeset	2204 const TypeTuple *r = call->tf()->range();
a61af66fc99e Initial load duke parents: diff changeset	2205 if (r->cnt() > TypeFunc::Parms) {
a61af66fc99e Initial load duke parents: diff changeset	2206 const Type* ret_type = r->field_at(TypeFunc::Parms);
a61af66fc99e Initial load duke parents: diff changeset	2207
a61af66fc99e Initial load duke parents: diff changeset	2208 // Note: we use isa_ptr() instead of isa_oopptr() here because the
a61af66fc99e Initial load duke parents: diff changeset	2209 // _multianewarray functions return a TypeRawPtr.
a61af66fc99e Initial load duke parents: diff changeset	2210 if (ret_type->isa_ptr() != NULL) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2211 set_escape_state(call_idx, PointsToNode::GlobalEscape);
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2212 add_pointsto_edge(resproj_idx, _phantom_object);
0 a61af66fc99e Initial load duke parents: diff changeset	2213 }
a61af66fc99e Initial load duke parents: diff changeset	2214 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2215 _processed.set(resproj_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2216 }
a61af66fc99e Initial load duke parents: diff changeset	2217 }
a61af66fc99e Initial load duke parents: diff changeset	2218 }
a61af66fc99e Initial load duke parents: diff changeset	2219
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2220 // Populate Connection Graph with Ideal nodes and create simple
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2221 // connection graph edges (do not need to check the node_type of inputs
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2222 // or to call PointsTo() to walk the connection graph).
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2223 void ConnectionGraph::record_for_escape_analysis(Node n, PhaseTransform phase) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2224 if (_processed.test(n->_idx))
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2225 return; // No need to redefine node's state.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2226
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2227 if (n->is_Call()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2228 // Arguments to allocation and locking don't escape.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2229 if (n->is_Allocate()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2230 add_node(n, PointsToNode::JavaObject, PointsToNode::UnknownEscape, true);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2231 record_for_optimizer(n);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2232 } else if (n->is_Lock() \|\| n->is_Unlock()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2233 // Put Lock and Unlock nodes on IGVN worklist to process them during
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2234 // the first IGVN optimization when escape information is still available.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2235 record_for_optimizer(n);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2236 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2237 } else {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2238 // Don't mark as processed since call's arguments have to be processed.
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2239 PointsToNode::NodeType nt = PointsToNode::UnknownType;
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2240 PointsToNode::EscapeState es = PointsToNode::UnknownEscape;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2241
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2242 // Check if a call returns an object.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2243 const TypeTuple *r = n->as_Call()->tf()->range();
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2244 if (r->cnt() > TypeFunc::Parms &&
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2245 r->field_at(TypeFunc::Parms)->isa_ptr() &&
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2246 n->as_Call()->proj_out(TypeFunc::Parms) != NULL) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2247 nt = PointsToNode::JavaObject;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2248 if (!n->is_CallStaticJava()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2249 // Since the called mathod is statically unknown assume
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2250 // the worst case that the returned value globally escapes.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2251 es = PointsToNode::GlobalEscape;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2252 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2253 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2254 add_node(n, nt, es, false);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2255 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2256 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2257 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2258
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2259 // Using isa_ptr() instead of isa_oopptr() for LoadP and Phi because
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2260 // ThreadLocal has RawPrt type.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2261 switch (n->Opcode()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2262 case Op_AddP:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2263 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2264 add_node(n, PointsToNode::Field, PointsToNode::UnknownEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2265 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2266 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2267 case Op_CastX2P:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2268 { // "Unsafe" memory access.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2269 add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, true);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2270 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2271 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2272 case Op_CastPP:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2273 case Op_CheckCastPP:
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2274 case Op_EncodeP:
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2275 case Op_DecodeN:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2276 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2277 add_node(n, PointsToNode::LocalVar, PointsToNode::UnknownEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2278 int ti = n->in(1)->_idx;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2279 PointsToNode::NodeType nt = ptnode_adr(ti)->node_type();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2280 if (nt == PointsToNode::UnknownType) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2281 _delayed_worklist.push(n); // Process it later.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2282 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2283 } else if (nt == PointsToNode::JavaObject) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2284 add_pointsto_edge(n->_idx, ti);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2285 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2286 add_deferred_edge(n->_idx, ti);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2287 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2288 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2289 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2290 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2291 case Op_ConP:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2292 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2293 // assume all pointer constants globally escape except for null
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2294 PointsToNode::EscapeState es;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2295 if (phase->type(n) == TypePtr::NULL_PTR)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2296 es = PointsToNode::NoEscape;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2297 else
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2298 es = PointsToNode::GlobalEscape;
0 a61af66fc99e Initial load duke parents: diff changeset	2299
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2300 add_node(n, PointsToNode::JavaObject, es, true);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2301 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2302 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2303 case Op_ConN:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2304 {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2305 // assume all narrow oop constants globally escape except for null
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2306 PointsToNode::EscapeState es;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2307 if (phase->type(n) == TypeNarrowOop::NULL_PTR)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2308 es = PointsToNode::NoEscape;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2309 else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2310 es = PointsToNode::GlobalEscape;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2311
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2312 add_node(n, PointsToNode::JavaObject, es, true);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2313 break;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2314 }
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2315 case Op_CreateEx:
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2316 {
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2317 // assume that all exception objects globally escape
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2318 add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, true);
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2319 break;
b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2320 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2321 case Op_LoadKlass:
164 c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	2322 case Op_LoadNKlass:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2323 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2324 add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, true);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2325 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2326 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2327 case Op_LoadP:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2328 case Op_LoadN:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2329 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2330 const Type *t = phase->type(n);
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2331 if (t->make_ptr() == NULL) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2332 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2333 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2334 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2335 add_node(n, PointsToNode::LocalVar, PointsToNode::UnknownEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2336 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2337 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2338 case Op_Parm:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2339 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2340 _processed.set(n->_idx); // No need to redefine it state.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2341 uint con = n->as_Proj()->_con;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2342 if (con < TypeFunc::Parms)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2343 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2344 const Type *t = n->in(0)->as_Start()->_domain->field_at(con);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2345 if (t->isa_ptr() == NULL)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2346 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2347 // We have to assume all input parameters globally escape
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2348 // (Note: passing 'false' since _processed is already set).
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2349 add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2350 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2351 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2352 case Op_Phi:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2353 {
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2354 const Type *t = n->as_Phi()->type();
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2355 if (t->make_ptr() == NULL) {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2356 // nothing to do if not an oop or narrow oop
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2357 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2358 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2359 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2360 add_node(n, PointsToNode::LocalVar, PointsToNode::UnknownEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2361 uint i;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2362 for (i = 1; i < n->req() ; i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2363 Node* in = n->in(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2364 if (in == NULL)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2365 continue; // ignore NULL
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2366 in = in->uncast();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2367 if (in->is_top() \|\| in == n)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2368 continue; // ignore top or inputs which go back this node
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2369 int ti = in->_idx;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2370 PointsToNode::NodeType nt = ptnode_adr(ti)->node_type();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2371 if (nt == PointsToNode::UnknownType) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2372 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2373 } else if (nt == PointsToNode::JavaObject) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2374 add_pointsto_edge(n->_idx, ti);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2375 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2376 add_deferred_edge(n->_idx, ti);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2377 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2378 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2379 if (i >= n->req())
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2380 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2381 else
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2382 _delayed_worklist.push(n);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2383 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2384 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2385 case Op_Proj:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2386 {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2387 // we are only interested in the oop result projection from a call
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2388 if (n->as_Proj()->_con == TypeFunc::Parms && n->in(0)->is_Call() ) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2389 const TypeTuple *r = n->in(0)->as_Call()->tf()->range();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2390 assert(r->cnt() > TypeFunc::Parms, "sanity");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2391 if (r->field_at(TypeFunc::Parms)->isa_ptr() != NULL) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2392 add_node(n, PointsToNode::LocalVar, PointsToNode::UnknownEscape, false);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2393 int ti = n->in(0)->_idx;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2394 // The call may not be registered yet (since not all its inputs are registered)
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2395 // if this is the projection from backbranch edge of Phi.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2396 if (ptnode_adr(ti)->node_type() != PointsToNode::UnknownType) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2397 process_call_result(n->as_Proj(), phase);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2398 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2399 if (!_processed.test(n->_idx)) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2400 // The call's result may need to be processed later if the call
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2401 // returns it's argument and the argument is not processed yet.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2402 _delayed_worklist.push(n);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2403 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2404 break;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2405 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2406 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2407 _processed.set(n->_idx);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2408 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2409 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2410 case Op_Return:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2411 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2412 if( n->req() > TypeFunc::Parms &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2413 phase->type(n->in(TypeFunc::Parms))->isa_oopptr() ) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2414 // Treat Return value as LocalVar with GlobalEscape escape state.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2415 add_node(n, PointsToNode::LocalVar, PointsToNode::GlobalEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2416 int ti = n->in(TypeFunc::Parms)->_idx;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2417 PointsToNode::NodeType nt = ptnode_adr(ti)->node_type();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2418 if (nt == PointsToNode::UnknownType) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2419 _delayed_worklist.push(n); // Process it later.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2420 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2421 } else if (nt == PointsToNode::JavaObject) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2422 add_pointsto_edge(n->_idx, ti);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2423 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2424 add_deferred_edge(n->_idx, ti);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2425 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2426 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2427 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2428 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2429 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2430 case Op_StoreP:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2431 case Op_StoreN:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2432 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2433 const Type *adr_type = phase->type(n->in(MemNode::Address));
221 1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode kvn parents: 168 diff changeset	2434 adr_type = adr_type->make_ptr();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2435 if (adr_type->isa_oopptr()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2436 add_node(n, PointsToNode::UnknownType, PointsToNode::UnknownEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2437 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2438 Node* adr = n->in(MemNode::Address);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2439 if (adr->is_AddP() && phase->type(adr) == TypeRawPtr::NOTNULL &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2440 adr->in(AddPNode::Address)->is_Proj() &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2441 adr->in(AddPNode::Address)->in(0)->is_Allocate()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2442 add_node(n, PointsToNode::UnknownType, PointsToNode::UnknownEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2443 // We are computing a raw address for a store captured
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2444 // by an Initialize compute an appropriate address type.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2445 int offs = (int)phase->find_intptr_t_con(adr->in(AddPNode::Offset), Type::OffsetBot);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2446 assert(offs != Type::OffsetBot, "offset must be a constant");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2447 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2448 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2449 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2450 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2451 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2452 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2453 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2454 case Op_StorePConditional:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2455 case Op_CompareAndSwapP:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2456 case Op_CompareAndSwapN:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2457 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2458 const Type *adr_type = phase->type(n->in(MemNode::Address));
221 1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode kvn parents: 168 diff changeset	2459 adr_type = adr_type->make_ptr();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2460 if (adr_type->isa_oopptr()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2461 add_node(n, PointsToNode::UnknownType, PointsToNode::UnknownEscape, false);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2462 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2463 _processed.set(n->_idx);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2464 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2465 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2466 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2467 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2468 case Op_AryEq:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2469 case Op_StrComp:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2470 case Op_StrEquals:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2471 case Op_StrIndexOf:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2472 {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2473 // char[] arrays passed to string intrinsics are not scalar replaceable.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2474 add_node(n, PointsToNode::UnknownType, PointsToNode::UnknownEscape, false);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2475 break;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2476 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2477 case Op_ThreadLocal:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2478 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2479 add_node(n, PointsToNode::JavaObject, PointsToNode::ArgEscape, true);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2480 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2481 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2482 default:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2483 ;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2484 // nothing to do
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2485 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2486 return;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2487 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2488
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2489 void ConnectionGraph::build_connection_graph(Node n, PhaseTransform phase) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2490 uint n_idx = n->_idx;
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2491 assert(ptnode_adr(n_idx)->_node != NULL, "node should be registered");
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2492
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2493 // Don't set processed bit for AddP, LoadP, StoreP since
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2494 // they may need more then one pass to process.
1921 e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	2495 // Also don't mark as processed Call nodes since their
e4fcbeb5a698 6991188: C2 Crashes while compiling method kvn parents: 1815 diff changeset	2496 // arguments may need more then one pass to process.
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2497 if (_processed.test(n_idx))
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2498 return; // No need to redefine node's state.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2499
0 a61af66fc99e Initial load duke parents: diff changeset	2500 if (n->is_Call()) {
a61af66fc99e Initial load duke parents: diff changeset	2501 CallNode *call = n->as_Call();
a61af66fc99e Initial load duke parents: diff changeset	2502 process_call_arguments(call, phase);
a61af66fc99e Initial load duke parents: diff changeset	2503 return;
a61af66fc99e Initial load duke parents: diff changeset	2504 }
a61af66fc99e Initial load duke parents: diff changeset	2505
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2506 switch (n->Opcode()) {
0 a61af66fc99e Initial load duke parents: diff changeset	2507 case Op_AddP:
a61af66fc99e Initial load duke parents: diff changeset	2508 {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2509 Node *base = get_addp_base(n);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2510 // Create a field edge to this node from everything base could point to.
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	2511 for( VectorSetI i(PointsTo(base)); i.test(); ++i ) {
0 a61af66fc99e Initial load duke parents: diff changeset	2512 uint pt = i.elem;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2513 add_field_edge(pt, n_idx, address_offset(n, phase));
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2514 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2515 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2516 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2517 case Op_CastX2P:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2518 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2519 assert(false, "Op_CastX2P");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2520 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2521 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2522 case Op_CastPP:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2523 case Op_CheckCastPP:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2524 case Op_EncodeP:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 102 diff changeset	2525 case Op_DecodeN:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2526 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2527 int ti = n->in(1)->_idx;
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2528 assert(ptnode_adr(ti)->node_type() != PointsToNode::UnknownType, "all nodes should be registered");
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2529 if (ptnode_adr(ti)->node_type() == PointsToNode::JavaObject) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2530 add_pointsto_edge(n_idx, ti);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2531 } else {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2532 add_deferred_edge(n_idx, ti);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2533 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2534 _processed.set(n_idx);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2535 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2536 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2537 case Op_ConP:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2538 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2539 assert(false, "Op_ConP");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2540 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2541 }
163 885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	2542 case Op_ConN:
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	2543 {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	2544 assert(false, "Op_ConN");
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	2545 break;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null kvn parents: 124 diff changeset	2546 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2547 case Op_CreateEx:
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2548 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2549 assert(false, "Op_CreateEx");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2550 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2551 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2552 case Op_LoadKlass:
164 c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions kvn parents: 163 diff changeset	2553 case Op_LoadNKlass:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2554 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2555 assert(false, "Op_LoadKlass");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2556 break;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2557 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2558 case Op_LoadP:
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2559 case Op_LoadN:
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2560 {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2561 const Type *t = phase->type(n);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2562 #ifdef ASSERT
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2563 if (t->make_ptr() == NULL)
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2564 assert(false, "Op_LoadP");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2565 #endif
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2566
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2567 Node* adr = n->in(MemNode::Address)->uncast();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2568 Node* adr_base;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2569 if (adr->is_AddP()) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2570 adr_base = get_addp_base(adr);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2571 } else {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2572 adr_base = adr;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2573 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2574
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2575 // For everything "adr_base" could point to, create a deferred edge from
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2576 // this node to each field with the same offset.
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2577 int offset = address_offset(adr, phase);
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	2578 for( VectorSetI i(PointsTo(adr_base)); i.test(); ++i ) {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2579 uint pt = i.elem;
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2580 add_deferred_edge_to_fields(n_idx, pt, offset);
0 a61af66fc99e Initial load duke parents: diff changeset	2581 }
a61af66fc99e Initial load duke parents: diff changeset	2582 break;
a61af66fc99e Initial load duke parents: diff changeset	2583 }
a61af66fc99e Initial load duke parents: diff changeset	2584 case Op_Parm:
a61af66fc99e Initial load duke parents: diff changeset	2585 {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2586 assert(false, "Op_Parm");
0 a61af66fc99e Initial load duke parents: diff changeset	2587 break;
a61af66fc99e Initial load duke parents: diff changeset	2588 }
a61af66fc99e Initial load duke parents: diff changeset	2589 case Op_Phi:
a61af66fc99e Initial load duke parents: diff changeset	2590 {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2591 #ifdef ASSERT
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2592 const Type *t = n->as_Phi()->type();
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2593 if (t->make_ptr() == NULL)
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2594 assert(false, "Op_Phi");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2595 #endif
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2596 for (uint i = 1; i < n->req() ; i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2597 Node* in = n->in(i);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2598 if (in == NULL)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2599 continue; // ignore NULL
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2600 in = in->uncast();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2601 if (in->is_top() \|\| in == n)
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2602 continue; // ignore top or inputs which go back this node
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2603 int ti = in->_idx;
307 892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2604 PointsToNode::NodeType nt = ptnode_adr(ti)->node_type();
892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2605 assert(nt != PointsToNode::UnknownType, "all nodes should be known");
892493c3d862 6732732: CTW with EA: assert(n != 0L,"Bad immediate dominator info.") kvn parents: 306 diff changeset	2606 if (nt == PointsToNode::JavaObject) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2607 add_pointsto_edge(n_idx, ti);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2608 } else {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2609 add_deferred_edge(n_idx, ti);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2610 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2611 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2612 _processed.set(n_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2613 break;
a61af66fc99e Initial load duke parents: diff changeset	2614 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2615 case Op_Proj:
0 a61af66fc99e Initial load duke parents: diff changeset	2616 {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2617 // we are only interested in the oop result projection from a call
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2618 if (n->as_Proj()->_con == TypeFunc::Parms && n->in(0)->is_Call() ) {
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2619 assert(ptnode_adr(n->in(0)->_idx)->node_type() != PointsToNode::UnknownType,
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2620 "all nodes should be registered");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2621 const TypeTuple *r = n->in(0)->as_Call()->tf()->range();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2622 assert(r->cnt() > TypeFunc::Parms, "sanity");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2623 if (r->field_at(TypeFunc::Parms)->isa_ptr() != NULL) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2624 process_call_result(n->as_Proj(), phase);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2625 assert(_processed.test(n_idx), "all call results should be processed");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2626 break;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2627 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2628 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2629 assert(false, "Op_Proj");
0 a61af66fc99e Initial load duke parents: diff changeset	2630 break;
a61af66fc99e Initial load duke parents: diff changeset	2631 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2632 case Op_Return:
0 a61af66fc99e Initial load duke parents: diff changeset	2633 {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2634 #ifdef ASSERT
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2635 if( n->req() <= TypeFunc::Parms \|\|
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2636 !phase->type(n->in(TypeFunc::Parms))->isa_oopptr() ) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2637 assert(false, "Op_Return");
0 a61af66fc99e Initial load duke parents: diff changeset	2638 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2639 #endif
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2640 int ti = n->in(TypeFunc::Parms)->_idx;
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2641 assert(ptnode_adr(ti)->node_type() != PointsToNode::UnknownType, "node should be registered");
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2642 if (ptnode_adr(ti)->node_type() == PointsToNode::JavaObject) {
524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2643 add_pointsto_edge(n_idx, ti);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2644 } else {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2645 add_deferred_edge(n_idx, ti);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2646 }
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2647 _processed.set(n_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	2648 break;
a61af66fc99e Initial load duke parents: diff changeset	2649 }
a61af66fc99e Initial load duke parents: diff changeset	2650 case Op_StoreP:
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2651 case Op_StoreN:
0 a61af66fc99e Initial load duke parents: diff changeset	2652 case Op_StorePConditional:
a61af66fc99e Initial load duke parents: diff changeset	2653 case Op_CompareAndSwapP:
124 b130b98db9cf 6689060: Escape Analysis does not work with Compressed Oops kvn parents: 113 diff changeset	2654 case Op_CompareAndSwapN:
0 a61af66fc99e Initial load duke parents: diff changeset	2655 {
a61af66fc99e Initial load duke parents: diff changeset	2656 Node *adr = n->in(MemNode::Address);
221 1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode kvn parents: 168 diff changeset	2657 const Type *adr_type = phase->type(adr)->make_ptr();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2658 #ifdef ASSERT
0 a61af66fc99e Initial load duke parents: diff changeset	2659 if (!adr_type->isa_oopptr())
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2660 assert(phase->type(adr) == TypeRawPtr::NOTNULL, "Op_StoreP");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2661 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	2662
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2663 assert(adr->is_AddP(), "expecting an AddP");
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2664 Node *adr_base = get_addp_base(adr);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2665 Node *val = n->in(MemNode::ValueIn)->uncast();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2666 // For everything "adr_base" could point to, create a deferred edge
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2667 // to "val" from each field with the same offset.
2249 3763ca6579b7 7013538: Java memory leak with escape analysis kvn parents: 2086 diff changeset	2668 for( VectorSetI i(PointsTo(adr_base)); i.test(); ++i ) {
0 a61af66fc99e Initial load duke parents: diff changeset	2669 uint pt = i.elem;
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2670 add_edge_from_fields(pt, val->_idx, address_offset(adr, phase));
0 a61af66fc99e Initial load duke parents: diff changeset	2671 }
a61af66fc99e Initial load duke parents: diff changeset	2672 break;
a61af66fc99e Initial load duke parents: diff changeset	2673 }
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2674 case Op_AryEq:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2675 case Op_StrComp:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2676 case Op_StrEquals:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2677 case Op_StrIndexOf:
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2678 {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2679 // char[] arrays passed to string intrinsic do not escape but
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2680 // they are not scalar replaceable. Adjust escape state for them.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2681 // Start from in(2) edge since in(1) is memory edge.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2682 for (uint i = 2; i < n->req(); i++) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2683 Node* adr = n->in(i)->uncast();
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2684 const Type *at = phase->type(adr);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2685 if (!adr->is_top() && at->isa_ptr()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2686 assert(at == Type::TOP \|\| at == TypePtr::NULL_PTR \|\|
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2687 at->isa_ptr() != NULL, "expecting an Ptr");
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2688 if (adr->is_AddP()) {
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2689 adr = get_addp_base(adr);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2690 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2691 // Mark as ArgEscape everything "adr" could point to.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2692 set_escape_state(adr->_idx, PointsToNode::ArgEscape);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2693 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2694 }
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2695 _processed.set(n_idx);
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2696 break;
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2697 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2698 case Op_ThreadLocal:
0 a61af66fc99e Initial load duke parents: diff changeset	2699 {
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2700 assert(false, "Op_ThreadLocal");
0 a61af66fc99e Initial load duke parents: diff changeset	2701 break;
a61af66fc99e Initial load duke parents: diff changeset	2702 }
a61af66fc99e Initial load duke parents: diff changeset	2703 default:
1100 f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2704 // This method should be called only for EA specific nodes.
f96a1a986f7b 6895383: JCK test throws NPE for method compiled with Escape Analysis kvn parents: 1072 diff changeset	2705 ShouldNotReachHere();
0 a61af66fc99e Initial load duke parents: diff changeset	2706 }
a61af66fc99e Initial load duke parents: diff changeset	2707 }
a61af66fc99e Initial load duke parents: diff changeset	2708
a61af66fc99e Initial load duke parents: diff changeset	2709 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2710 void ConnectionGraph::dump() {
a61af66fc99e Initial load duke parents: diff changeset	2711 bool first = true;
a61af66fc99e Initial load duke parents: diff changeset	2712
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2713 uint size = nodes_size();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2714 for (uint ni = 0; ni < size; ni++) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2715 PointsToNode *ptn = ptnode_adr(ni);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2716 PointsToNode::NodeType ptn_type = ptn->node_type();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2717
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2718 if (ptn_type != PointsToNode::JavaObject \|\| ptn->_node == NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	2719 continue;
1634 60a14ad85270 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP kvn parents: 1552 diff changeset	2720 PointsToNode::EscapeState es = escape_state(ptn->_node);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2721 if (ptn->_node->is_Allocate() && (es == PointsToNode::NoEscape \|\| Verbose)) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2722 if (first) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2723 tty->cr();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2724 tty->print("======== Connection graph for ");
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2725 _compile->method()->print_short_name();
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2726 tty->cr();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2727 first = false;
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2728 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2729 tty->print("%6d ", ni);
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2730 ptn->dump();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2731 // Print all locals which reference this allocation
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2732 for (uint li = ni; li < size; li++) {
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 223 diff changeset	2733 PointsToNode *ptn_loc = ptnode_adr(li);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2734 PointsToNode::NodeType ptn_loc_type = ptn_loc->node_type();
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2735 if ( ptn_loc_type == PointsToNode::LocalVar && ptn_loc->_node != NULL &&
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2736 ptn_loc->edge_count() == 1 && ptn_loc->edge_target(0) == ni ) {
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2737 ptnode_adr(li)->dump(false);
0 a61af66fc99e Initial load duke parents: diff changeset	2738 }
a61af66fc99e Initial load duke parents: diff changeset	2739 }
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2740 if (Verbose) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2741 // Print all fields which reference this allocation
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2742 for (uint i = 0; i < ptn->edge_count(); i++) {
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2743 uint ei = ptn->edge_target(i);
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 247 diff changeset	2744 ptnode_adr(ei)->dump(false);
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2745 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2746 }
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 39 diff changeset	2747 tty->cr();
0 a61af66fc99e Initial load duke parents: diff changeset	2748 }
a61af66fc99e Initial load duke parents: diff changeset	2749 }
a61af66fc99e Initial load duke parents: diff changeset	2750 }
a61af66fc99e Initial load duke parents: diff changeset	2751 #endif

Mercurial > hg > truffle

annotate src/share/vm/opto/escape.cpp @ 2459:55973726c600