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

annotate src/share/vm/opto/escape.cpp @ 1721:413ad0331a0c

6977924: Changes for 6975078 produce build error with certain gcc versions Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error. Reviewed-by: jcoomes, ysr, phh

author	johnc
date	Wed, 18 Aug 2010 10:59:06 -0700
parents	60a14ad85270
children	5867d89c129b

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

Mercurial > hg > truffle

annotate src/share/vm/opto/escape.cpp @ 1721:413ad0331a0c