1 /*
   2  * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "ci/bcEscapeAnalyzer.hpp"
  27 #include "compiler/compileLog.hpp"
  28 #include "libadt/vectset.hpp"
  29 #include "memory/allocation.hpp"
  30 #include "opto/c2compiler.hpp"
  31 #include "opto/callnode.hpp"
  32 #include "opto/cfgnode.hpp"
  33 #include "opto/compile.hpp"
  34 #include "opto/escape.hpp"
  35 #include "opto/phaseX.hpp"
  36 #include "opto/movenode.hpp"
  37 #include "opto/rootnode.hpp"
  38 
  39 ConnectionGraph::ConnectionGraph(Compile * C, PhaseIterGVN *igvn) :
  40   _nodes(C->comp_arena(), C->unique(), C->unique(), NULL),
  41   _collecting(true),
  42   _verify(false),
  43   _compile(C),
  44   _igvn(igvn),
  45   _node_map(C->comp_arena()) {
  46   // Add unknown java object.
  47   add_java_object(C->top(), PointsToNode::GlobalEscape);
  48   phantom_obj = ptnode_adr(C->top()->_idx)->as_JavaObject();
  49   // Add ConP(#NULL) and ConN(#NULL) nodes.
  50   Node* oop_null = igvn->zerocon(T_OBJECT);
  51   assert(oop_null->_idx < nodes_size(), "should be created already");
  52   add_java_object(oop_null, PointsToNode::NoEscape);
  53   null_obj = ptnode_adr(oop_null->_idx)->as_JavaObject();
  54   if (UseCompressedOops) {
  55     Node* noop_null = igvn->zerocon(T_NARROWOOP);
  56     assert(noop_null->_idx < nodes_size(), "should be created already");
  57     map_ideal_node(noop_null, null_obj);
  58   }
  59   _pcmp_neq = NULL; // Should be initialized
  60   _pcmp_eq  = NULL;
  61 }
  62 
  63 bool ConnectionGraph::has_candidates(Compile *C) {
  64   // EA brings benefits only when the code has allocations and/or locks which
  65   // are represented by ideal Macro nodes.
  66   int cnt = C->macro_count();
  67   for (int i = 0; i < cnt; i++) {
  68     Node *n = C->macro_node(i);
  69     if (n->is_Allocate())
  70       return true;
  71     if (n->is_Lock()) {
  72       Node* obj = n->as_Lock()->obj_node()->uncast();
  73       if (!(obj->is_Parm() || obj->is_Con()))
  74         return true;
  75     }
  76     if (n->is_CallStaticJava() &&
  77         n->as_CallStaticJava()->is_boxing_method()) {
  78       return true;
  79     }
  80   }
  81   return false;
  82 }
  83 
  84 void ConnectionGraph::do_analysis(Compile *C, PhaseIterGVN *igvn) {
  85   Compile::TracePhase t2("escapeAnalysis", &Phase::_t_escapeAnalysis, true);
  86   ResourceMark rm;
  87 
  88   // Add ConP#NULL and ConN#NULL nodes before ConnectionGraph construction
  89   // to create space for them in ConnectionGraph::_nodes[].
  90   Node* oop_null = igvn->zerocon(T_OBJECT);
  91   Node* noop_null = igvn->zerocon(T_NARROWOOP);
  92   ConnectionGraph* congraph = new(C->comp_arena()) ConnectionGraph(C, igvn);
  93   // Perform escape analysis
  94   if (congraph->compute_escape()) {
  95     // There are non escaping objects.
  96     C->set_congraph(congraph);
  97   }
  98   // Cleanup.
  99   if (oop_null->outcnt() == 0)
 100     igvn->hash_delete(oop_null);
 101   if (noop_null->outcnt() == 0)
 102     igvn->hash_delete(noop_null);
 103 }
 104 
 105 bool ConnectionGraph::compute_escape() {
 106   Compile* C = _compile;
 107   PhaseGVN* igvn = _igvn;
 108 
 109   // Worklists used by EA.
 110   Unique_Node_List delayed_worklist;
 111   GrowableArray<Node*> alloc_worklist;
 112   GrowableArray<Node*> ptr_cmp_worklist;
 113   GrowableArray<Node*> storestore_worklist;
 114   GrowableArray<PointsToNode*>   ptnodes_worklist;
 115   GrowableArray<JavaObjectNode*> java_objects_worklist;
 116   GrowableArray<JavaObjectNode*> non_escaped_worklist;
 117   GrowableArray<FieldNode*>      oop_fields_worklist;
 118   DEBUG_ONLY( GrowableArray<Node*> addp_worklist; )
 119 
 120   { Compile::TracePhase t3("connectionGraph", &Phase::_t_connectionGraph, true);
 121 
 122   // 1. Populate Connection Graph (CG) with PointsTo nodes.
 123   ideal_nodes.map(C->live_nodes(), NULL);  // preallocate space
 124   // Initialize worklist
 125   if (C->root() != NULL) {
 126     ideal_nodes.push(C->root());
 127   }
 128   for( uint next = 0; next < ideal_nodes.size(); ++next ) {
 129     Node* n = ideal_nodes.at(next);
 130     // Create PointsTo nodes and add them to Connection Graph. Called
 131     // only once per ideal node since ideal_nodes is Unique_Node list.
 132     add_node_to_connection_graph(n, &delayed_worklist);
 133     PointsToNode* ptn = ptnode_adr(n->_idx);
 134     if (ptn != NULL) {
 135       ptnodes_worklist.append(ptn);
 136       if (ptn->is_JavaObject()) {
 137         java_objects_worklist.append(ptn->as_JavaObject());
 138         if ((n->is_Allocate() || n->is_CallStaticJava()) &&
 139             (ptn->escape_state() < PointsToNode::GlobalEscape)) {
 140           // Only allocations and java static calls results are interesting.
 141           non_escaped_worklist.append(ptn->as_JavaObject());
 142         }
 143       } else if (ptn->is_Field() && ptn->as_Field()->is_oop()) {
 144         oop_fields_worklist.append(ptn->as_Field());
 145       }
 146     }
 147     if (n->is_MergeMem()) {
 148       // Collect all MergeMem nodes to add memory slices for
 149       // scalar replaceable objects in split_unique_types().
 150       _mergemem_worklist.append(n->as_MergeMem());
 151     } else if (OptimizePtrCompare && n->is_Cmp() &&
 152                (n->Opcode() == Op_CmpP || n->Opcode() == Op_CmpN)) {
 153       // Collect compare pointers nodes.
 154       ptr_cmp_worklist.append(n);
 155     } else if (n->is_MemBarStoreStore()) {
 156       // Collect all MemBarStoreStore nodes so that depending on the
 157       // escape status of the associated Allocate node some of them
 158       // may be eliminated.
 159       storestore_worklist.append(n);
 160     } else if (n->is_MemBar() && (n->Opcode() == Op_MemBarRelease) &&
 161                (n->req() > MemBarNode::Precedent)) {
 162       record_for_optimizer(n);
 163 #ifdef ASSERT
 164     } else if (n->is_AddP()) {
 165       // Collect address nodes for graph verification.
 166       addp_worklist.append(n);
 167 #endif
 168     }
 169     for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
 170       Node* m = n->fast_out(i);   // Get user
 171       ideal_nodes.push(m);
 172     }
 173   }
 174   if (non_escaped_worklist.length() == 0) {
 175     _collecting = false;
 176     return false; // Nothing to do.
 177   }
 178   // Add final simple edges to graph.
 179   while(delayed_worklist.size() > 0) {
 180     Node* n = delayed_worklist.pop();
 181     add_final_edges(n);
 182   }
 183   int ptnodes_length = ptnodes_worklist.length();
 184 
 185 #ifdef ASSERT
 186   if (VerifyConnectionGraph) {
 187     // Verify that no new simple edges could be created and all
 188     // local vars has edges.
 189     _verify = true;
 190     for (int next = 0; next < ptnodes_length; ++next) {
 191       PointsToNode* ptn = ptnodes_worklist.at(next);
 192       add_final_edges(ptn->ideal_node());
 193       if (ptn->is_LocalVar() && ptn->edge_count() == 0) {
 194         ptn->dump();
 195         assert(ptn->as_LocalVar()->edge_count() > 0, "sanity");
 196       }
 197     }
 198     _verify = false;
 199   }
 200 #endif
 201 
 202   // 2. Finish Graph construction by propagating references to all
 203   //    java objects through graph.
 204   if (!complete_connection_graph(ptnodes_worklist, non_escaped_worklist,
 205                                  java_objects_worklist, oop_fields_worklist)) {
 206     // All objects escaped or hit time or iterations limits.
 207     _collecting = false;
 208     return false;
 209   }
 210 
 211   // 3. Adjust scalar_replaceable state of nonescaping objects and push
 212   //    scalar replaceable allocations on alloc_worklist for processing
 213   //    in split_unique_types().
 214   int non_escaped_length = non_escaped_worklist.length();
 215   for (int next = 0; next < non_escaped_length; next++) {
 216     JavaObjectNode* ptn = non_escaped_worklist.at(next);
 217     bool noescape = (ptn->escape_state() == PointsToNode::NoEscape);
 218     Node* n = ptn->ideal_node();
 219     if (n->is_Allocate()) {
 220       n->as_Allocate()->_is_non_escaping = noescape;
 221     }
 222     if (n->is_CallStaticJava()) {
 223       n->as_CallStaticJava()->_is_non_escaping = noescape;
 224     }
 225     if (noescape && ptn->scalar_replaceable()) {
 226       adjust_scalar_replaceable_state(ptn);
 227       if (ptn->scalar_replaceable()) {
 228         alloc_worklist.append(ptn->ideal_node());
 229       }
 230     }
 231   }
 232 
 233 #ifdef ASSERT
 234   if (VerifyConnectionGraph) {
 235     // Verify that graph is complete - no new edges could be added or needed.
 236     verify_connection_graph(ptnodes_worklist, non_escaped_worklist,
 237                             java_objects_worklist, addp_worklist);
 238   }
 239   assert(C->unique() == nodes_size(), "no new ideal nodes should be added during ConnectionGraph build");
 240   assert(null_obj->escape_state() == PointsToNode::NoEscape &&
 241          null_obj->edge_count() == 0 &&
 242          !null_obj->arraycopy_src() &&
 243          !null_obj->arraycopy_dst(), "sanity");
 244 #endif
 245 
 246   _collecting = false;
 247 
 248   } // TracePhase t3("connectionGraph")
 249 
 250   // 4. Optimize ideal graph based on EA information.
 251   bool has_non_escaping_obj = (non_escaped_worklist.length() > 0);
 252   if (has_non_escaping_obj) {
 253     optimize_ideal_graph(ptr_cmp_worklist, storestore_worklist);
 254   }
 255 
 256 #ifndef PRODUCT
 257   if (PrintEscapeAnalysis) {
 258     dump(ptnodes_worklist); // Dump ConnectionGraph
 259   }
 260 #endif
 261 
 262   bool has_scalar_replaceable_candidates = (alloc_worklist.length() > 0);
 263 #ifdef ASSERT
 264   if (VerifyConnectionGraph) {
 265     int alloc_length = alloc_worklist.length();
 266     for (int next = 0; next < alloc_length; ++next) {
 267       Node* n = alloc_worklist.at(next);
 268       PointsToNode* ptn = ptnode_adr(n->_idx);
 269       assert(ptn->escape_state() == PointsToNode::NoEscape && ptn->scalar_replaceable(), "sanity");
 270     }
 271   }
 272 #endif
 273 
 274   // 5. Separate memory graph for scalar replaceable allcations.
 275   if (has_scalar_replaceable_candidates &&
 276       C->AliasLevel() >= 3 && EliminateAllocations) {
 277     // Now use the escape information to create unique types for
 278     // scalar replaceable objects.
 279     split_unique_types(alloc_worklist);
 280     if (C->failing())  return false;
 281     C->print_method(PHASE_AFTER_EA, 2);
 282 
 283 #ifdef ASSERT
 284   } else if (Verbose && (PrintEscapeAnalysis || PrintEliminateAllocations)) {
 285     tty->print("=== No allocations eliminated for ");
 286     C->method()->print_short_name();
 287     if(!EliminateAllocations) {
 288       tty->print(" since EliminateAllocations is off ===");
 289     } else if(!has_scalar_replaceable_candidates) {
 290       tty->print(" since there are no scalar replaceable candidates ===");
 291     } else if(C->AliasLevel() < 3) {
 292       tty->print(" since AliasLevel < 3 ===");
 293     }
 294     tty->cr();
 295 #endif
 296   }
 297   return has_non_escaping_obj;
 298 }
 299 
 300 // Utility function for nodes that load an object
 301 void ConnectionGraph::add_objload_to_connection_graph(Node *n, Unique_Node_List *delayed_worklist) {
 302   // Using isa_ptr() instead of isa_oopptr() for LoadP and Phi because
 303   // ThreadLocal has RawPtr type.
 304   const Type* t = _igvn->type(n);
 305   if (t->make_ptr() != NULL) {
 306     Node* adr = n->in(MemNode::Address);
 307 #ifdef ASSERT
 308     if (!adr->is_AddP()) {
 309       assert(_igvn->type(adr)->isa_rawptr(), "sanity");
 310     } else {
 311       assert((ptnode_adr(adr->_idx) == NULL ||
 312               ptnode_adr(adr->_idx)->as_Field()->is_oop()), "sanity");
 313     }
 314 #endif
 315     add_local_var_and_edge(n, PointsToNode::NoEscape,
 316                            adr, delayed_worklist);
 317   }
 318 }
 319 
 320 // Populate Connection Graph with PointsTo nodes and create simple
 321 // connection graph edges.
 322 void ConnectionGraph::add_node_to_connection_graph(Node *n, Unique_Node_List *delayed_worklist) {
 323   assert(!_verify, "this method sould not be called for verification");
 324   PhaseGVN* igvn = _igvn;
 325   uint n_idx = n->_idx;
 326   PointsToNode* n_ptn = ptnode_adr(n_idx);
 327   if (n_ptn != NULL)
 328     return; // No need to redefine PointsTo node during first iteration.
 329 
 330   if (n->is_Call()) {
 331     // Arguments to allocation and locking don't escape.
 332     if (n->is_AbstractLock()) {
 333       // Put Lock and Unlock nodes on IGVN worklist to process them during
 334       // first IGVN optimization when escape information is still available.
 335       record_for_optimizer(n);
 336     } else if (n->is_Allocate()) {
 337       add_call_node(n->as_Call());
 338       record_for_optimizer(n);
 339     } else {
 340       if (n->is_CallStaticJava()) {
 341         const char* name = n->as_CallStaticJava()->_name;
 342         if (name != NULL && strcmp(name, "uncommon_trap") == 0)
 343           return; // Skip uncommon traps
 344       }
 345       // Don't mark as processed since call's arguments have to be processed.
 346       delayed_worklist->push(n);
 347       // Check if a call returns an object.
 348       if ((n->as_Call()->returns_pointer() &&
 349            n->as_Call()->proj_out(TypeFunc::Parms) != NULL) ||
 350           (n->is_CallStaticJava() &&
 351            n->as_CallStaticJava()->is_boxing_method())) {
 352         add_call_node(n->as_Call());
 353       }
 354     }
 355     return;
 356   }
 357   // Put this check here to process call arguments since some call nodes
 358   // point to phantom_obj.
 359   if (n_ptn == phantom_obj || n_ptn == null_obj)
 360     return; // Skip predefined nodes.
 361 
 362   int opcode = n->Opcode();
 363   switch (opcode) {
 364     case Op_AddP: {
 365       Node* base = get_addp_base(n);
 366       PointsToNode* ptn_base = ptnode_adr(base->_idx);
 367       // Field nodes are created for all field types. They are used in
 368       // adjust_scalar_replaceable_state() and split_unique_types().
 369       // Note, non-oop fields will have only base edges in Connection
 370       // Graph because such fields are not used for oop loads and stores.
 371       int offset = address_offset(n, igvn);
 372       add_field(n, PointsToNode::NoEscape, offset);
 373       if (ptn_base == NULL) {
 374         delayed_worklist->push(n); // Process it later.
 375       } else {
 376         n_ptn = ptnode_adr(n_idx);
 377         add_base(n_ptn->as_Field(), ptn_base);
 378       }
 379       break;
 380     }
 381     case Op_CastX2P: {
 382       map_ideal_node(n, phantom_obj);
 383       break;
 384     }
 385     case Op_CastPP:
 386     case Op_CheckCastPP:
 387     case Op_EncodeP:
 388     case Op_DecodeN:
 389     case Op_EncodePKlass:
 390     case Op_DecodeNKlass: {
 391       add_local_var_and_edge(n, PointsToNode::NoEscape,
 392                              n->in(1), delayed_worklist);
 393       break;
 394     }
 395     case Op_CMoveP: {
 396       add_local_var(n, PointsToNode::NoEscape);
 397       // Do not add edges during first iteration because some could be
 398       // not defined yet.
 399       delayed_worklist->push(n);
 400       break;
 401     }
 402     case Op_ConP:
 403     case Op_ConN:
 404     case Op_ConNKlass: {
 405       // assume all oop constants globally escape except for null
 406       PointsToNode::EscapeState es;
 407       const Type* t = igvn->type(n);
 408       if (t == TypePtr::NULL_PTR || t == TypeNarrowOop::NULL_PTR) {
 409         es = PointsToNode::NoEscape;
 410       } else {
 411         es = PointsToNode::GlobalEscape;
 412       }
 413       add_java_object(n, es);
 414       break;
 415     }
 416     case Op_CreateEx: {
 417       // assume that all exception objects globally escape
 418       add_java_object(n, PointsToNode::GlobalEscape);
 419       break;
 420     }
 421     case Op_LoadKlass:
 422     case Op_LoadNKlass: {
 423       // Unknown class is loaded
 424       map_ideal_node(n, phantom_obj);
 425       break;
 426     }
 427     case Op_LoadP:
 428     case Op_LoadN:
 429     case Op_LoadPLocked: {
 430       add_objload_to_connection_graph(n, delayed_worklist);
 431       break;
 432     }
 433     case Op_Parm: {
 434       map_ideal_node(n, phantom_obj);
 435       break;
 436     }
 437     case Op_PartialSubtypeCheck: {
 438       // Produces Null or notNull and is used in only in CmpP so
 439       // phantom_obj could be used.
 440       map_ideal_node(n, phantom_obj); // Result is unknown
 441       break;
 442     }
 443     case Op_Phi: {
 444       // Using isa_ptr() instead of isa_oopptr() for LoadP and Phi because
 445       // ThreadLocal has RawPtr type.
 446       const Type* t = n->as_Phi()->type();
 447       if (t->make_ptr() != NULL) {
 448         add_local_var(n, PointsToNode::NoEscape);
 449         // Do not add edges during first iteration because some could be
 450         // not defined yet.
 451         delayed_worklist->push(n);
 452       }
 453       break;
 454     }
 455     case Op_Proj: {
 456       // we are only interested in the oop result projection from a call
 457       if (n->as_Proj()->_con == TypeFunc::Parms && n->in(0)->is_Call() &&
 458           n->in(0)->as_Call()->returns_pointer()) {
 459         add_local_var_and_edge(n, PointsToNode::NoEscape,
 460                                n->in(0), delayed_worklist);
 461       }
 462       break;
 463     }
 464     case Op_Rethrow: // Exception object escapes
 465     case Op_Return: {
 466       if (n->req() > TypeFunc::Parms &&
 467           igvn->type(n->in(TypeFunc::Parms))->isa_oopptr()) {
 468         // Treat Return value as LocalVar with GlobalEscape escape state.
 469         add_local_var_and_edge(n, PointsToNode::GlobalEscape,
 470                                n->in(TypeFunc::Parms), delayed_worklist);
 471       }
 472       break;
 473     }
 474     case Op_GetAndSetP:
 475     case Op_GetAndSetN: {
 476       add_objload_to_connection_graph(n, delayed_worklist);
 477       // fallthrough
 478     }
 479     case Op_StoreP:
 480     case Op_StoreN:
 481     case Op_StoreNKlass:
 482     case Op_StorePConditional:
 483     case Op_CompareAndSwapP:
 484     case Op_CompareAndSwapN: {
 485       Node* adr = n->in(MemNode::Address);
 486       const Type *adr_type = igvn->type(adr);
 487       adr_type = adr_type->make_ptr();
 488       if (adr_type == NULL) {
 489         break; // skip dead nodes
 490       }
 491       if (adr_type->isa_oopptr() ||
 492           (opcode == Op_StoreP || opcode == Op_StoreN || opcode == Op_StoreNKlass) &&
 493                         (adr_type == TypeRawPtr::NOTNULL &&
 494                          adr->in(AddPNode::Address)->is_Proj() &&
 495                          adr->in(AddPNode::Address)->in(0)->is_Allocate())) {
 496         delayed_worklist->push(n); // Process it later.
 497 #ifdef ASSERT
 498         assert(adr->is_AddP(), "expecting an AddP");
 499         if (adr_type == TypeRawPtr::NOTNULL) {
 500           // Verify a raw address for a store captured by Initialize node.
 501           int offs = (int)igvn->find_intptr_t_con(adr->in(AddPNode::Offset), Type::OffsetBot);
 502           assert(offs != Type::OffsetBot, "offset must be a constant");
 503         }
 504 #endif
 505       } else {
 506         // Ignore copy the displaced header to the BoxNode (OSR compilation).
 507         if (adr->is_BoxLock())
 508           break;
 509         // Stored value escapes in unsafe access.
 510         if ((opcode == Op_StoreP) && (adr_type == TypeRawPtr::BOTTOM)) {
 511           // Pointer stores in G1 barriers looks like unsafe access.
 512           // Ignore such stores to be able scalar replace non-escaping
 513           // allocations.
 514           if (UseG1GC && adr->is_AddP()) {
 515             Node* base = get_addp_base(adr);
 516             if (base->Opcode() == Op_LoadP &&
 517                 base->in(MemNode::Address)->is_AddP()) {
 518               adr = base->in(MemNode::Address);
 519               Node* tls = get_addp_base(adr);
 520               if (tls->Opcode() == Op_ThreadLocal) {
 521                 int offs = (int)igvn->find_intptr_t_con(adr->in(AddPNode::Offset), Type::OffsetBot);
 522                 if (offs == in_bytes(JavaThread::satb_mark_queue_offset() +
 523                                      PtrQueue::byte_offset_of_buf())) {
 524                   break; // G1 pre barier previous oop value store.
 525                 }
 526                 if (offs == in_bytes(JavaThread::dirty_card_queue_offset() +
 527                                      PtrQueue::byte_offset_of_buf())) {
 528                   break; // G1 post barier card address store.
 529                 }
 530               }
 531             }
 532           }
 533           delayed_worklist->push(n); // Process unsafe access later.
 534           break;
 535         }
 536 #ifdef ASSERT
 537         n->dump(1);
 538         assert(false, "not unsafe or G1 barrier raw StoreP");
 539 #endif
 540       }
 541       break;
 542     }
 543     case Op_AryEq:
 544     case Op_StrComp:
 545     case Op_StrEquals:
 546     case Op_StrIndexOf:
 547     case Op_EncodeISOArray: {
 548       add_local_var(n, PointsToNode::ArgEscape);
 549       delayed_worklist->push(n); // Process it later.
 550       break;
 551     }
 552     case Op_ThreadLocal: {
 553       add_java_object(n, PointsToNode::ArgEscape);
 554       break;
 555     }
 556     default:
 557       ; // Do nothing for nodes not related to EA.
 558   }
 559   return;
 560 }
 561 
 562 #ifdef ASSERT
 563 #define ELSE_FAIL(name)                               \
 564       /* Should not be called for not pointer type. */  \
 565       n->dump(1);                                       \
 566       assert(false, name);                              \
 567       break;
 568 #else
 569 #define ELSE_FAIL(name) \
 570       break;
 571 #endif
 572 
 573 // Add final simple edges to graph.
 574 void ConnectionGraph::add_final_edges(Node *n) {
 575   PointsToNode* n_ptn = ptnode_adr(n->_idx);
 576 #ifdef ASSERT
 577   if (_verify && n_ptn->is_JavaObject())
 578     return; // This method does not change graph for JavaObject.
 579 #endif
 580 
 581   if (n->is_Call()) {
 582     process_call_arguments(n->as_Call());
 583     return;
 584   }
 585   assert(n->is_Store() || n->is_LoadStore() ||
 586          (n_ptn != NULL) && (n_ptn->ideal_node() != NULL),
 587          "node should be registered already");
 588   int opcode = n->Opcode();
 589   switch (opcode) {
 590     case Op_AddP: {
 591       Node* base = get_addp_base(n);
 592       PointsToNode* ptn_base = ptnode_adr(base->_idx);
 593       assert(ptn_base != NULL, "field's base should be registered");
 594       add_base(n_ptn->as_Field(), ptn_base);
 595       break;
 596     }
 597     case Op_CastPP:
 598     case Op_CheckCastPP:
 599     case Op_EncodeP:
 600     case Op_DecodeN:
 601     case Op_EncodePKlass:
 602     case Op_DecodeNKlass: {
 603       add_local_var_and_edge(n, PointsToNode::NoEscape,
 604                              n->in(1), NULL);
 605       break;
 606     }
 607     case Op_CMoveP: {
 608       for (uint i = CMoveNode::IfFalse; i < n->req(); i++) {
 609         Node* in = n->in(i);
 610         if (in == NULL)
 611           continue;  // ignore NULL
 612         Node* uncast_in = in->uncast();
 613         if (uncast_in->is_top() || uncast_in == n)
 614           continue;  // ignore top or inputs which go back this node
 615         PointsToNode* ptn = ptnode_adr(in->_idx);
 616         assert(ptn != NULL, "node should be registered");
 617         add_edge(n_ptn, ptn);
 618       }
 619       break;
 620     }
 621     case Op_LoadP:
 622     case Op_LoadN:
 623     case Op_LoadPLocked: {
 624       // Using isa_ptr() instead of isa_oopptr() for LoadP and Phi because
 625       // ThreadLocal has RawPtr type.
 626       const Type* t = _igvn->type(n);
 627       if (t->make_ptr() != NULL) {
 628         Node* adr = n->in(MemNode::Address);
 629         add_local_var_and_edge(n, PointsToNode::NoEscape, adr, NULL);
 630         break;
 631       }
 632       ELSE_FAIL("Op_LoadP");
 633     }
 634     case Op_Phi: {
 635       // Using isa_ptr() instead of isa_oopptr() for LoadP and Phi because
 636       // ThreadLocal has RawPtr type.
 637       const Type* t = n->as_Phi()->type();
 638       if (t->make_ptr() != NULL) {
 639         for (uint i = 1; i < n->req(); i++) {
 640           Node* in = n->in(i);
 641           if (in == NULL)
 642             continue;  // ignore NULL
 643           Node* uncast_in = in->uncast();
 644           if (uncast_in->is_top() || uncast_in == n)
 645             continue;  // ignore top or inputs which go back this node
 646           PointsToNode* ptn = ptnode_adr(in->_idx);
 647           assert(ptn != NULL, "node should be registered");
 648           add_edge(n_ptn, ptn);
 649         }
 650         break;
 651       }
 652       ELSE_FAIL("Op_Phi");
 653     }
 654     case Op_Proj: {
 655       // we are only interested in the oop result projection from a call
 656       if (n->as_Proj()->_con == TypeFunc::Parms && n->in(0)->is_Call() &&
 657           n->in(0)->as_Call()->returns_pointer()) {
 658         add_local_var_and_edge(n, PointsToNode::NoEscape, n->in(0), NULL);
 659         break;
 660       }
 661       ELSE_FAIL("Op_Proj");
 662     }
 663     case Op_Rethrow: // Exception object escapes
 664     case Op_Return: {
 665       if (n->req() > TypeFunc::Parms &&
 666           _igvn->type(n->in(TypeFunc::Parms))->isa_oopptr()) {
 667         // Treat Return value as LocalVar with GlobalEscape escape state.
 668         add_local_var_and_edge(n, PointsToNode::GlobalEscape,
 669                                n->in(TypeFunc::Parms), NULL);
 670         break;
 671       }
 672       ELSE_FAIL("Op_Return");
 673     }
 674     case Op_StoreP:
 675     case Op_StoreN:
 676     case Op_StoreNKlass:
 677     case Op_StorePConditional:
 678     case Op_CompareAndSwapP:
 679     case Op_CompareAndSwapN:
 680     case Op_GetAndSetP:
 681     case Op_GetAndSetN: {
 682       Node* adr = n->in(MemNode::Address);
 683       const Type *adr_type = _igvn->type(adr);
 684       adr_type = adr_type->make_ptr();
 685 #ifdef ASSERT
 686       if (adr_type == NULL) {
 687         n->dump(1);
 688         assert(adr_type != NULL, "dead node should not be on list");
 689         break;
 690       }
 691 #endif
 692       if (opcode == Op_GetAndSetP || opcode == Op_GetAndSetN) {
 693         add_local_var_and_edge(n, PointsToNode::NoEscape, adr, NULL);
 694       }
 695       if (adr_type->isa_oopptr() ||
 696           (opcode == Op_StoreP || opcode == Op_StoreN || opcode == Op_StoreNKlass) &&
 697                         (adr_type == TypeRawPtr::NOTNULL &&
 698                          adr->in(AddPNode::Address)->is_Proj() &&
 699                          adr->in(AddPNode::Address)->in(0)->is_Allocate())) {
 700         // Point Address to Value
 701         PointsToNode* adr_ptn = ptnode_adr(adr->_idx);
 702         assert(adr_ptn != NULL &&
 703                adr_ptn->as_Field()->is_oop(), "node should be registered");
 704         Node *val = n->in(MemNode::ValueIn);
 705         PointsToNode* ptn = ptnode_adr(val->_idx);
 706         assert(ptn != NULL, "node should be registered");
 707         add_edge(adr_ptn, ptn);
 708         break;
 709       } else if ((opcode == Op_StoreP) && (adr_type == TypeRawPtr::BOTTOM)) {
 710         // Stored value escapes in unsafe access.
 711         Node *val = n->in(MemNode::ValueIn);
 712         PointsToNode* ptn = ptnode_adr(val->_idx);
 713         assert(ptn != NULL, "node should be registered");
 714         set_escape_state(ptn, PointsToNode::GlobalEscape);
 715         // Add edge to object for unsafe access with offset.
 716         PointsToNode* adr_ptn = ptnode_adr(adr->_idx);
 717         assert(adr_ptn != NULL, "node should be registered");
 718         if (adr_ptn->is_Field()) {
 719           assert(adr_ptn->as_Field()->is_oop(), "should be oop field");
 720           add_edge(adr_ptn, ptn);
 721         }
 722         break;
 723       }
 724       ELSE_FAIL("Op_StoreP");
 725     }
 726     case Op_AryEq:
 727     case Op_StrComp:
 728     case Op_StrEquals:
 729     case Op_StrIndexOf:
 730     case Op_EncodeISOArray: {
 731       // char[] arrays passed to string intrinsic do not escape but
 732       // they are not scalar replaceable. Adjust escape state for them.
 733       // Start from in(2) edge since in(1) is memory edge.
 734       for (uint i = 2; i < n->req(); i++) {
 735         Node* adr = n->in(i);
 736         const Type* at = _igvn->type(adr);
 737         if (!adr->is_top() && at->isa_ptr()) {
 738           assert(at == Type::TOP || at == TypePtr::NULL_PTR ||
 739                  at->isa_ptr() != NULL, "expecting a pointer");
 740           if (adr->is_AddP()) {
 741             adr = get_addp_base(adr);
 742           }
 743           PointsToNode* ptn = ptnode_adr(adr->_idx);
 744           assert(ptn != NULL, "node should be registered");
 745           add_edge(n_ptn, ptn);
 746         }
 747       }
 748       break;
 749     }
 750     default: {
 751       // This method should be called only for EA specific nodes which may
 752       // miss some edges when they were created.
 753 #ifdef ASSERT
 754       n->dump(1);
 755 #endif
 756       guarantee(false, "unknown node");
 757     }
 758   }
 759   return;
 760 }
 761 
 762 void ConnectionGraph::add_call_node(CallNode* call) {
 763   assert(call->returns_pointer(), "only for call which returns pointer");
 764   uint call_idx = call->_idx;
 765   if (call->is_Allocate()) {
 766     Node* k = call->in(AllocateNode::KlassNode);
 767     const TypeKlassPtr* kt = k->bottom_type()->isa_klassptr();
 768     assert(kt != NULL, "TypeKlassPtr  required.");
 769     ciKlass* cik = kt->klass();
 770     PointsToNode::EscapeState es = PointsToNode::NoEscape;
 771     bool scalar_replaceable = true;
 772     if (call->is_AllocateArray()) {
 773       if (!cik->is_array_klass()) { // StressReflectiveCode
 774         es = PointsToNode::GlobalEscape;
 775       } else {
 776         int length = call->in(AllocateNode::ALength)->find_int_con(-1);
 777         if (length < 0 || length > EliminateAllocationArraySizeLimit) {
 778           // Not scalar replaceable if the length is not constant or too big.
 779           scalar_replaceable = false;
 780         }
 781       }
 782     } else {  // Allocate instance
 783       if (cik->is_subclass_of(_compile->env()->Thread_klass()) ||
 784           cik->is_subclass_of(_compile->env()->Reference_klass()) ||
 785          !cik->is_instance_klass() || // StressReflectiveCode
 786           cik->as_instance_klass()->has_finalizer()) {
 787         es = PointsToNode::GlobalEscape;
 788       }
 789     }
 790     add_java_object(call, es);
 791     PointsToNode* ptn = ptnode_adr(call_idx);
 792     if (!scalar_replaceable && ptn->scalar_replaceable()) {
 793       ptn->set_scalar_replaceable(false);
 794     }
 795   } else if (call->is_CallStaticJava()) {
 796     // Call nodes could be different types:
 797     //
 798     // 1. CallDynamicJavaNode (what happened during call is unknown):
 799     //
 800     //    - mapped to GlobalEscape JavaObject node if oop is returned;
 801     //
 802     //    - all oop arguments are escaping globally;
 803     //
 804     // 2. CallStaticJavaNode (execute bytecode analysis if possible):
 805     //
 806     //    - the same as CallDynamicJavaNode if can't do bytecode analysis;
 807     //
 808     //    - mapped to GlobalEscape JavaObject node if unknown oop is returned;
 809     //    - mapped to NoEscape JavaObject node if non-escaping object allocated
 810     //      during call is returned;
 811     //    - mapped to ArgEscape LocalVar node pointed to object arguments
 812     //      which are returned and does not escape during call;
 813     //
 814     //    - oop arguments escaping status is defined by bytecode analysis;
 815     //
 816     // For a static call, we know exactly what method is being called.
 817     // Use bytecode estimator to record whether the call's return value escapes.
 818     ciMethod* meth = call->as_CallJava()->method();
 819     if (meth == NULL) {
 820       const char* name = call->as_CallStaticJava()->_name;
 821       assert(strncmp(name, "_multianewarray", 15) == 0, "TODO: add failed case check");
 822       // Returns a newly allocated unescaped object.
 823       add_java_object(call, PointsToNode::NoEscape);
 824       ptnode_adr(call_idx)->set_scalar_replaceable(false);
 825     } else if (meth->is_boxing_method()) {
 826       // Returns boxing object
 827       PointsToNode::EscapeState es;
 828       vmIntrinsics::ID intr = meth->intrinsic_id();
 829       if (intr == vmIntrinsics::_floatValue || intr == vmIntrinsics::_doubleValue) {
 830         // It does not escape if object is always allocated.
 831         es = PointsToNode::NoEscape;
 832       } else {
 833         // It escapes globally if object could be loaded from cache.
 834         es = PointsToNode::GlobalEscape;
 835       }
 836       add_java_object(call, es);
 837     } else {
 838       BCEscapeAnalyzer* call_analyzer = meth->get_bcea();
 839       call_analyzer->copy_dependencies(_compile->dependencies());
 840       if (call_analyzer->is_return_allocated()) {
 841         // Returns a newly allocated unescaped object, simply
 842         // update dependency information.
 843         // Mark it as NoEscape so that objects referenced by
 844         // it's fields will be marked as NoEscape at least.
 845         add_java_object(call, PointsToNode::NoEscape);
 846         ptnode_adr(call_idx)->set_scalar_replaceable(false);
 847       } else {
 848         // Determine whether any arguments are returned.
 849         const TypeTuple* d = call->tf()->domain();
 850         bool ret_arg = false;
 851         for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
 852           if (d->field_at(i)->isa_ptr() != NULL &&
 853               call_analyzer->is_arg_returned(i - TypeFunc::Parms)) {
 854             ret_arg = true;
 855             break;
 856           }
 857         }
 858         if (ret_arg) {
 859           add_local_var(call, PointsToNode::ArgEscape);
 860         } else {
 861           // Returns unknown object.
 862           map_ideal_node(call, phantom_obj);
 863         }
 864       }
 865     }
 866   } else {
 867     // An other type of call, assume the worst case:
 868     // returned value is unknown and globally escapes.
 869     assert(call->Opcode() == Op_CallDynamicJava, "add failed case check");
 870     map_ideal_node(call, phantom_obj);
 871   }
 872 }
 873 
 874 void ConnectionGraph::process_call_arguments(CallNode *call) {
 875     bool is_arraycopy = false;
 876     switch (call->Opcode()) {
 877 #ifdef ASSERT
 878     case Op_Allocate:
 879     case Op_AllocateArray:
 880     case Op_Lock:
 881     case Op_Unlock:
 882       assert(false, "should be done already");
 883       break;
 884 #endif
 885     case Op_CallLeafNoFP:
 886       is_arraycopy = (call->as_CallLeaf()->_name != NULL &&
 887                       strstr(call->as_CallLeaf()->_name, "arraycopy") != 0);
 888       // fall through
 889     case Op_CallLeaf: {
 890       // Stub calls, objects do not escape but they are not scale replaceable.
 891       // Adjust escape state for outgoing arguments.
 892       const TypeTuple * d = call->tf()->domain();
 893       bool src_has_oops = false;
 894       for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
 895         const Type* at = d->field_at(i);
 896         Node *arg = call->in(i);
 897         const Type *aat = _igvn->type(arg);
 898         if (arg->is_top() || !at->isa_ptr() || !aat->isa_ptr())
 899           continue;
 900         if (arg->is_AddP()) {
 901           //
 902           // The inline_native_clone() case when the arraycopy stub is called
 903           // after the allocation before Initialize and CheckCastPP nodes.
 904           // Or normal arraycopy for object arrays case.
 905           //
 906           // Set AddP's base (Allocate) as not scalar replaceable since
 907           // pointer to the base (with offset) is passed as argument.
 908           //
 909           arg = get_addp_base(arg);
 910         }
 911         PointsToNode* arg_ptn = ptnode_adr(arg->_idx);
 912         assert(arg_ptn != NULL, "should be registered");
 913         PointsToNode::EscapeState arg_esc = arg_ptn->escape_state();
 914         if (is_arraycopy || arg_esc < PointsToNode::ArgEscape) {
 915           assert(aat == Type::TOP || aat == TypePtr::NULL_PTR ||
 916                  aat->isa_ptr() != NULL, "expecting an Ptr");
 917           bool arg_has_oops = aat->isa_oopptr() &&
 918                               (aat->isa_oopptr()->klass() == NULL || aat->isa_instptr() ||
 919                                (aat->isa_aryptr() && aat->isa_aryptr()->klass()->is_obj_array_klass()));
 920           if (i == TypeFunc::Parms) {
 921             src_has_oops = arg_has_oops;
 922           }
 923           //
 924           // src or dst could be j.l.Object when other is basic type array:
 925           //
 926           //   arraycopy(char[],0,Object*,0,size);
 927           //   arraycopy(Object*,0,char[],0,size);
 928           //
 929           // Don't add edges in such cases.
 930           //
 931           bool arg_is_arraycopy_dest = src_has_oops && is_arraycopy &&
 932                                        arg_has_oops && (i > TypeFunc::Parms);
 933 #ifdef ASSERT
 934           if (!(is_arraycopy ||
 935                 (call->as_CallLeaf()->_name != NULL &&
 936                  (strcmp(call->as_CallLeaf()->_name, "g1_wb_pre")  == 0 ||
 937                   strcmp(call->as_CallLeaf()->_name, "g1_wb_post") == 0 ||
 938                   strcmp(call->as_CallLeaf()->_name, "updateBytesCRC32") == 0 ||
 939                   strcmp(call->as_CallLeaf()->_name, "aescrypt_encryptBlock") == 0 ||
 940                   strcmp(call->as_CallLeaf()->_name, "aescrypt_decryptBlock") == 0 ||
 941                   strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_encryptAESCrypt") == 0 ||
 942                   strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0)
 943                   ))) {
 944             call->dump();
 945             fatal(err_msg_res("EA unexpected CallLeaf %s", call->as_CallLeaf()->_name));
 946           }
 947 #endif
 948           // Always process arraycopy's destination object since
 949           // we need to add all possible edges to references in
 950           // source object.
 951           if (arg_esc >= PointsToNode::ArgEscape &&
 952               !arg_is_arraycopy_dest) {
 953             continue;
 954           }
 955           set_escape_state(arg_ptn, PointsToNode::ArgEscape);
 956           if (arg_is_arraycopy_dest) {
 957             Node* src = call->in(TypeFunc::Parms);
 958             if (src->is_AddP()) {
 959               src = get_addp_base(src);
 960             }
 961             PointsToNode* src_ptn = ptnode_adr(src->_idx);
 962             assert(src_ptn != NULL, "should be registered");
 963             if (arg_ptn != src_ptn) {
 964               // Special arraycopy edge:
 965               // A destination object's field can't have the source object
 966               // as base since objects escape states are not related.
 967               // Only escape state of destination object's fields affects
 968               // escape state of fields in source object.
 969               add_arraycopy(call, PointsToNode::ArgEscape, src_ptn, arg_ptn);
 970             }
 971           }
 972         }
 973       }
 974       break;
 975     }
 976     case Op_CallStaticJava: {
 977       // For a static call, we know exactly what method is being called.
 978       // Use bytecode estimator to record the call's escape affects
 979 #ifdef ASSERT
 980       const char* name = call->as_CallStaticJava()->_name;
 981       assert((name == NULL || strcmp(name, "uncommon_trap") != 0), "normal calls only");
 982 #endif
 983       ciMethod* meth = call->as_CallJava()->method();
 984       if ((meth != NULL) && meth->is_boxing_method()) {
 985         break; // Boxing methods do not modify any oops.
 986       }
 987       BCEscapeAnalyzer* call_analyzer = (meth !=NULL) ? meth->get_bcea() : NULL;
 988       // fall-through if not a Java method or no analyzer information
 989       if (call_analyzer != NULL) {
 990         PointsToNode* call_ptn = ptnode_adr(call->_idx);
 991         const TypeTuple* d = call->tf()->domain();
 992         for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
 993           const Type* at = d->field_at(i);
 994           int k = i - TypeFunc::Parms;
 995           Node* arg = call->in(i);
 996           PointsToNode* arg_ptn = ptnode_adr(arg->_idx);
 997           if (at->isa_ptr() != NULL &&
 998               call_analyzer->is_arg_returned(k)) {
 999             // The call returns arguments.
1000             if (call_ptn != NULL) { // Is call's result used?
1001               assert(call_ptn->is_LocalVar(), "node should be registered");
1002               assert(arg_ptn != NULL, "node should be registered");
1003               add_edge(call_ptn, arg_ptn);
1004             }
1005           }
1006           if (at->isa_oopptr() != NULL &&
1007               arg_ptn->escape_state() < PointsToNode::GlobalEscape) {
1008             if (!call_analyzer->is_arg_stack(k)) {
1009               // The argument global escapes
1010               set_escape_state(arg_ptn, PointsToNode::GlobalEscape);
1011             } else {
1012               set_escape_state(arg_ptn, PointsToNode::ArgEscape);
1013               if (!call_analyzer->is_arg_local(k)) {
1014                 // The argument itself doesn't escape, but any fields might
1015                 set_fields_escape_state(arg_ptn, PointsToNode::GlobalEscape);
1016               }
1017             }
1018           }
1019         }
1020         if (call_ptn != NULL && call_ptn->is_LocalVar()) {
1021           // The call returns arguments.
1022           assert(call_ptn->edge_count() > 0, "sanity");
1023           if (!call_analyzer->is_return_local()) {
1024             // Returns also unknown object.
1025             add_edge(call_ptn, phantom_obj);
1026           }
1027         }
1028         break;
1029       }
1030     }
1031     default: {
1032       // Fall-through here if not a Java method or no analyzer information
1033       // or some other type of call, assume the worst case: all arguments
1034       // globally escape.
1035       const TypeTuple* d = call->tf()->domain();
1036       for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
1037         const Type* at = d->field_at(i);
1038         if (at->isa_oopptr() != NULL) {
1039           Node* arg = call->in(i);
1040           if (arg->is_AddP()) {
1041             arg = get_addp_base(arg);
1042           }
1043           assert(ptnode_adr(arg->_idx) != NULL, "should be defined already");
1044           set_escape_state(ptnode_adr(arg->_idx), PointsToNode::GlobalEscape);
1045         }
1046       }
1047     }
1048   }
1049 }
1050 
1051 
1052 // Finish Graph construction.
1053 bool ConnectionGraph::complete_connection_graph(
1054                          GrowableArray<PointsToNode*>&   ptnodes_worklist,
1055                          GrowableArray<JavaObjectNode*>& non_escaped_worklist,
1056                          GrowableArray<JavaObjectNode*>& java_objects_worklist,
1057                          GrowableArray<FieldNode*>&      oop_fields_worklist) {
1058   // Normally only 1-3 passes needed to build Connection Graph depending
1059   // on graph complexity. Observed 8 passes in jvm2008 compiler.compiler.
1060   // Set limit to 20 to catch situation when something did go wrong and
1061   // bailout Escape Analysis.
1062   // Also limit build time to 30 sec (60 in debug VM).
1063 #define CG_BUILD_ITER_LIMIT 20
1064 #ifdef ASSERT
1065 #define CG_BUILD_TIME_LIMIT 60.0
1066 #else
1067 #define CG_BUILD_TIME_LIMIT 30.0
1068 #endif
1069 
1070   // Propagate GlobalEscape and ArgEscape escape states and check that
1071   // we still have non-escaping objects. The method pushs on _worklist
1072   // Field nodes which reference phantom_object.
1073   if (!find_non_escaped_objects(ptnodes_worklist, non_escaped_worklist)) {
1074     return false; // Nothing to do.
1075   }
1076   // Now propagate references to all JavaObject nodes.
1077   int java_objects_length = java_objects_worklist.length();
1078   elapsedTimer time;
1079   int new_edges = 1;
1080   int iterations = 0;
1081   do {
1082     while ((new_edges > 0) &&
1083           (iterations++   < CG_BUILD_ITER_LIMIT) &&
1084           (time.seconds() < CG_BUILD_TIME_LIMIT)) {
1085       time.start();
1086       new_edges = 0;
1087       // Propagate references to phantom_object for nodes pushed on _worklist
1088       // by find_non_escaped_objects() and find_field_value().
1089       new_edges += add_java_object_edges(phantom_obj, false);
1090       for (int next = 0; next < java_objects_length; ++next) {
1091         JavaObjectNode* ptn = java_objects_worklist.at(next);
1092         new_edges += add_java_object_edges(ptn, true);
1093       }
1094       if (new_edges > 0) {
1095         // Update escape states on each iteration if graph was updated.
1096         if (!find_non_escaped_objects(ptnodes_worklist, non_escaped_worklist)) {
1097           return false; // Nothing to do.
1098         }
1099       }
1100       time.stop();
1101     }
1102     if ((iterations     < CG_BUILD_ITER_LIMIT) &&
1103         (time.seconds() < CG_BUILD_TIME_LIMIT)) {
1104       time.start();
1105       // Find fields which have unknown value.
1106       int fields_length = oop_fields_worklist.length();
1107       for (int next = 0; next < fields_length; next++) {
1108         FieldNode* field = oop_fields_worklist.at(next);
1109         if (field->edge_count() == 0) {
1110           new_edges += find_field_value(field);
1111           // This code may added new edges to phantom_object.
1112           // Need an other cycle to propagate references to phantom_object.
1113         }
1114       }
1115       time.stop();
1116     } else {
1117       new_edges = 0; // Bailout
1118     }
1119   } while (new_edges > 0);
1120 
1121   // Bailout if passed limits.
1122   if ((iterations     >= CG_BUILD_ITER_LIMIT) ||
1123       (time.seconds() >= CG_BUILD_TIME_LIMIT)) {
1124     Compile* C = _compile;
1125     if (C->log() != NULL) {
1126       C->log()->begin_elem("connectionGraph_bailout reason='reached ");
1127       C->log()->text("%s", (iterations >= CG_BUILD_ITER_LIMIT) ? "iterations" : "time");
1128       C->log()->end_elem(" limit'");
1129     }
1130     assert(ExitEscapeAnalysisOnTimeout, err_msg_res("infinite EA connection graph build (%f sec, %d iterations) with %d nodes and worklist size %d",
1131            time.seconds(), iterations, nodes_size(), ptnodes_worklist.length()));
1132     // Possible infinite build_connection_graph loop,
1133     // bailout (no changes to ideal graph were made).
1134     return false;
1135   }
1136 #ifdef ASSERT
1137   if (Verbose && PrintEscapeAnalysis) {
1138     tty->print_cr("EA: %d iterations to build connection graph with %d nodes and worklist size %d",
1139                   iterations, nodes_size(), ptnodes_worklist.length());
1140   }
1141 #endif
1142 
1143 #undef CG_BUILD_ITER_LIMIT
1144 #undef CG_BUILD_TIME_LIMIT
1145 
1146   // Find fields initialized by NULL for non-escaping Allocations.
1147   int non_escaped_length = non_escaped_worklist.length();
1148   for (int next = 0; next < non_escaped_length; next++) {
1149     JavaObjectNode* ptn = non_escaped_worklist.at(next);
1150     PointsToNode::EscapeState es = ptn->escape_state();
1151     assert(es <= PointsToNode::ArgEscape, "sanity");
1152     if (es == PointsToNode::NoEscape) {
1153       if (find_init_values(ptn, null_obj, _igvn) > 0) {
1154         // Adding references to NULL object does not change escape states
1155         // since it does not escape. Also no fields are added to NULL object.
1156         add_java_object_edges(null_obj, false);
1157       }
1158     }
1159     Node* n = ptn->ideal_node();
1160     if (n->is_Allocate()) {
1161       // The object allocated by this Allocate node will never be
1162       // seen by an other thread. Mark it so that when it is
1163       // expanded no MemBarStoreStore is added.
1164       InitializeNode* ini = n->as_Allocate()->initialization();
1165       if (ini != NULL)
1166         ini->set_does_not_escape();
1167     }
1168   }
1169   return true; // Finished graph construction.
1170 }
1171 
1172 // Propagate GlobalEscape and ArgEscape escape states to all nodes
1173 // and check that we still have non-escaping java objects.
1174 bool ConnectionGraph::find_non_escaped_objects(GrowableArray<PointsToNode*>& ptnodes_worklist,
1175                                                GrowableArray<JavaObjectNode*>& non_escaped_worklist) {
1176   GrowableArray<PointsToNode*> escape_worklist;
1177   // First, put all nodes with GlobalEscape and ArgEscape states on worklist.
1178   int ptnodes_length = ptnodes_worklist.length();
1179   for (int next = 0; next < ptnodes_length; ++next) {
1180     PointsToNode* ptn = ptnodes_worklist.at(next);
1181     if (ptn->escape_state() >= PointsToNode::ArgEscape ||
1182         ptn->fields_escape_state() >= PointsToNode::ArgEscape) {
1183       escape_worklist.push(ptn);
1184     }
1185   }
1186   // Set escape states to referenced nodes (edges list).
1187   while (escape_worklist.length() > 0) {
1188     PointsToNode* ptn = escape_worklist.pop();
1189     PointsToNode::EscapeState es  = ptn->escape_state();
1190     PointsToNode::EscapeState field_es = ptn->fields_escape_state();
1191     if (ptn->is_Field() && ptn->as_Field()->is_oop() &&
1192         es >= PointsToNode::ArgEscape) {
1193       // GlobalEscape or ArgEscape state of field means it has unknown value.
1194       if (add_edge(ptn, phantom_obj)) {
1195         // New edge was added
1196         add_field_uses_to_worklist(ptn->as_Field());
1197       }
1198     }
1199     for (EdgeIterator i(ptn); i.has_next(); i.next()) {
1200       PointsToNode* e = i.get();
1201       if (e->is_Arraycopy()) {
1202         assert(ptn->arraycopy_dst(), "sanity");
1203         // Propagate only fields escape state through arraycopy edge.
1204         if (e->fields_escape_state() < field_es) {
1205           set_fields_escape_state(e, field_es);
1206           escape_worklist.push(e);
1207         }
1208       } else if (es >= field_es) {
1209         // fields_escape_state is also set to 'es' if it is less than 'es'.
1210         if (e->escape_state() < es) {
1211           set_escape_state(e, es);
1212           escape_worklist.push(e);
1213         }
1214       } else {
1215         // Propagate field escape state.
1216         bool es_changed = false;
1217         if (e->fields_escape_state() < field_es) {
1218           set_fields_escape_state(e, field_es);
1219           es_changed = true;
1220         }
1221         if ((e->escape_state() < field_es) &&
1222             e->is_Field() && ptn->is_JavaObject() &&
1223             e->as_Field()->is_oop()) {
1224           // Change escape state of referenced fileds.
1225           set_escape_state(e, field_es);
1226           es_changed = true;;
1227         } else if (e->escape_state() < es) {
1228           set_escape_state(e, es);
1229           es_changed = true;;
1230         }
1231         if (es_changed) {
1232           escape_worklist.push(e);
1233         }
1234       }
1235     }
1236   }
1237   // Remove escaped objects from non_escaped list.
1238   for (int next = non_escaped_worklist.length()-1; next >= 0 ; --next) {
1239     JavaObjectNode* ptn = non_escaped_worklist.at(next);
1240     if (ptn->escape_state() >= PointsToNode::GlobalEscape) {
1241       non_escaped_worklist.delete_at(next);
1242     }
1243     if (ptn->escape_state() == PointsToNode::NoEscape) {
1244       // Find fields in non-escaped allocations which have unknown value.
1245       find_init_values(ptn, phantom_obj, NULL);
1246     }
1247   }
1248   return (non_escaped_worklist.length() > 0);
1249 }
1250 
1251 // Add all references to JavaObject node by walking over all uses.
1252 int ConnectionGraph::add_java_object_edges(JavaObjectNode* jobj, bool populate_worklist) {
1253   int new_edges = 0;
1254   if (populate_worklist) {
1255     // Populate _worklist by uses of jobj's uses.
1256     for (UseIterator i(jobj); i.has_next(); i.next()) {
1257       PointsToNode* use = i.get();
1258       if (use->is_Arraycopy())
1259         continue;
1260       add_uses_to_worklist(use);
1261       if (use->is_Field() && use->as_Field()->is_oop()) {
1262         // Put on worklist all field's uses (loads) and
1263         // related field nodes (same base and offset).
1264         add_field_uses_to_worklist(use->as_Field());
1265       }
1266     }
1267   }
1268   while(_worklist.length() > 0) {
1269     PointsToNode* use = _worklist.pop();
1270     if (PointsToNode::is_base_use(use)) {
1271       // Add reference from jobj to field and from field to jobj (field's base).
1272       use = PointsToNode::get_use_node(use)->as_Field();
1273       if (add_base(use->as_Field(), jobj)) {
1274         new_edges++;
1275       }
1276       continue;
1277     }
1278     assert(!use->is_JavaObject(), "sanity");
1279     if (use->is_Arraycopy()) {
1280       if (jobj == null_obj) // NULL object does not have field edges
1281         continue;
1282       // Added edge from Arraycopy node to arraycopy's source java object
1283       if (add_edge(use, jobj)) {
1284         jobj->set_arraycopy_src();
1285         new_edges++;
1286       }
1287       // and stop here.
1288       continue;
1289     }
1290     if (!add_edge(use, jobj))
1291       continue; // No new edge added, there was such edge already.
1292     new_edges++;
1293     if (use->is_LocalVar()) {
1294       add_uses_to_worklist(use);
1295       if (use->arraycopy_dst()) {
1296         for (EdgeIterator i(use); i.has_next(); i.next()) {
1297           PointsToNode* e = i.get();
1298           if (e->is_Arraycopy()) {
1299             if (jobj == null_obj) // NULL object does not have field edges
1300               continue;
1301             // Add edge from arraycopy's destination java object to Arraycopy node.
1302             if (add_edge(jobj, e)) {
1303               new_edges++;
1304               jobj->set_arraycopy_dst();
1305             }
1306           }
1307         }
1308       }
1309     } else {
1310       // Added new edge to stored in field values.
1311       // Put on worklist all field's uses (loads) and
1312       // related field nodes (same base and offset).
1313       add_field_uses_to_worklist(use->as_Field());
1314     }
1315   }
1316   return new_edges;
1317 }
1318 
1319 // Put on worklist all related field nodes.
1320 void ConnectionGraph::add_field_uses_to_worklist(FieldNode* field) {
1321   assert(field->is_oop(), "sanity");
1322   int offset = field->offset();
1323   add_uses_to_worklist(field);
1324   // Loop over all bases of this field and push on worklist Field nodes
1325   // with the same offset and base (since they may reference the same field).
1326   for (BaseIterator i(field); i.has_next(); i.next()) {
1327     PointsToNode* base = i.get();
1328     add_fields_to_worklist(field, base);
1329     // Check if the base was source object of arraycopy and go over arraycopy's
1330     // destination objects since values stored to a field of source object are
1331     // accessable by uses (loads) of fields of destination objects.
1332     if (base->arraycopy_src()) {
1333       for (UseIterator j(base); j.has_next(); j.next()) {
1334         PointsToNode* arycp = j.get();
1335         if (arycp->is_Arraycopy()) {
1336           for (UseIterator k(arycp); k.has_next(); k.next()) {
1337             PointsToNode* abase = k.get();
1338             if (abase->arraycopy_dst() && abase != base) {
1339               // Look for the same arracopy reference.
1340               add_fields_to_worklist(field, abase);
1341             }
1342           }
1343         }
1344       }
1345     }
1346   }
1347 }
1348 
1349 // Put on worklist all related field nodes.
1350 void ConnectionGraph::add_fields_to_worklist(FieldNode* field, PointsToNode* base) {
1351   int offset = field->offset();
1352   if (base->is_LocalVar()) {
1353     for (UseIterator j(base); j.has_next(); j.next()) {
1354       PointsToNode* f = j.get();
1355       if (PointsToNode::is_base_use(f)) { // Field
1356         f = PointsToNode::get_use_node(f);
1357         if (f == field || !f->as_Field()->is_oop())
1358           continue;
1359         int offs = f->as_Field()->offset();
1360         if (offs == offset || offset == Type::OffsetBot || offs == Type::OffsetBot) {
1361           add_to_worklist(f);
1362         }
1363       }
1364     }
1365   } else {
1366     assert(base->is_JavaObject(), "sanity");
1367     if (// Skip phantom_object since it is only used to indicate that
1368         // this field's content globally escapes.
1369         (base != phantom_obj) &&
1370         // NULL object node does not have fields.
1371         (base != null_obj)) {
1372       for (EdgeIterator i(base); i.has_next(); i.next()) {
1373         PointsToNode* f = i.get();
1374         // Skip arraycopy edge since store to destination object field
1375         // does not update value in source object field.
1376         if (f->is_Arraycopy()) {
1377           assert(base->arraycopy_dst(), "sanity");
1378           continue;
1379         }
1380         if (f == field || !f->as_Field()->is_oop())
1381           continue;
1382         int offs = f->as_Field()->offset();
1383         if (offs == offset || offset == Type::OffsetBot || offs == Type::OffsetBot) {
1384           add_to_worklist(f);
1385         }
1386       }
1387     }
1388   }
1389 }
1390 
1391 // Find fields which have unknown value.
1392 int ConnectionGraph::find_field_value(FieldNode* field) {
1393   // Escaped fields should have init value already.
1394   assert(field->escape_state() == PointsToNode::NoEscape, "sanity");
1395   int new_edges = 0;
1396   for (BaseIterator i(field); i.has_next(); i.next()) {
1397     PointsToNode* base = i.get();
1398     if (base->is_JavaObject()) {
1399       // Skip Allocate's fields which will be processed later.
1400       if (base->ideal_node()->is_Allocate())
1401         return 0;
1402       assert(base == null_obj, "only NULL ptr base expected here");
1403     }
1404   }
1405   if (add_edge(field, phantom_obj)) {
1406     // New edge was added
1407     new_edges++;
1408     add_field_uses_to_worklist(field);
1409   }
1410   return new_edges;
1411 }
1412 
1413 // Find fields initializing values for allocations.
1414 int ConnectionGraph::find_init_values(JavaObjectNode* pta, PointsToNode* init_val, PhaseTransform* phase) {
1415   assert(pta->escape_state() == PointsToNode::NoEscape, "Not escaped Allocate nodes only");
1416   int new_edges = 0;
1417   Node* alloc = pta->ideal_node();
1418   if (init_val == phantom_obj) {
1419     // Do nothing for Allocate nodes since its fields values are "known".
1420     if (alloc->is_Allocate())
1421       return 0;
1422     assert(alloc->as_CallStaticJava(), "sanity");
1423 #ifdef ASSERT
1424     if (alloc->as_CallStaticJava()->method() == NULL) {
1425       const char* name = alloc->as_CallStaticJava()->_name;
1426       assert(strncmp(name, "_multianewarray", 15) == 0, "sanity");
1427     }
1428 #endif
1429     // Non-escaped allocation returned from Java or runtime call have
1430     // unknown values in fields.
1431     for (EdgeIterator i(pta); i.has_next(); i.next()) {
1432       PointsToNode* field = i.get();
1433       if (field->is_Field() && field->as_Field()->is_oop()) {
1434         if (add_edge(field, phantom_obj)) {
1435           // New edge was added
1436           new_edges++;
1437           add_field_uses_to_worklist(field->as_Field());
1438         }
1439       }
1440     }
1441     return new_edges;
1442   }
1443   assert(init_val == null_obj, "sanity");
1444   // Do nothing for Call nodes since its fields values are unknown.
1445   if (!alloc->is_Allocate())
1446     return 0;
1447 
1448   InitializeNode* ini = alloc->as_Allocate()->initialization();
1449   Compile* C = _compile;
1450   bool visited_bottom_offset = false;
1451   GrowableArray<int> offsets_worklist;
1452 
1453   // Check if an oop field's initializing value is recorded and add
1454   // a corresponding NULL if field's value if it is not recorded.
1455   // Connection Graph does not record a default initialization by NULL
1456   // captured by Initialize node.
1457   //
1458   for (EdgeIterator i(pta); i.has_next(); i.next()) {
1459     PointsToNode* field = i.get(); // Field (AddP)
1460     if (!field->is_Field() || !field->as_Field()->is_oop())
1461       continue; // Not oop field
1462     int offset = field->as_Field()->offset();
1463     if (offset == Type::OffsetBot) {
1464       if (!visited_bottom_offset) {
1465         // OffsetBot is used to reference array's element,
1466         // always add reference to NULL to all Field nodes since we don't
1467         // known which element is referenced.
1468         if (add_edge(field, null_obj)) {
1469           // New edge was added
1470           new_edges++;
1471           add_field_uses_to_worklist(field->as_Field());
1472           visited_bottom_offset = true;
1473         }
1474       }
1475     } else {
1476       // Check only oop fields.
1477       const Type* adr_type = field->ideal_node()->as_AddP()->bottom_type();
1478       if (adr_type->isa_rawptr()) {
1479 #ifdef ASSERT
1480         // Raw pointers are used for initializing stores so skip it
1481         // since it should be recorded already
1482         Node* base = get_addp_base(field->ideal_node());
1483         assert(adr_type->isa_rawptr() && base->is_Proj() &&
1484                (base->in(0) == alloc),"unexpected pointer type");
1485 #endif
1486         continue;
1487       }
1488       if (!offsets_worklist.contains(offset)) {
1489         offsets_worklist.append(offset);
1490         Node* value = NULL;
1491         if (ini != NULL) {
1492           // StoreP::memory_type() == T_ADDRESS
1493           BasicType ft = UseCompressedOops ? T_NARROWOOP : T_ADDRESS;
1494           Node* store = ini->find_captured_store(offset, type2aelembytes(ft, true), phase);
1495           // Make sure initializing store has the same type as this AddP.
1496           // This AddP may reference non existing field because it is on a
1497           // dead branch of bimorphic call which is not eliminated yet.
1498           if (store != NULL && store->is_Store() &&
1499               store->as_Store()->memory_type() == ft) {
1500             value = store->in(MemNode::ValueIn);
1501 #ifdef ASSERT
1502             if (VerifyConnectionGraph) {
1503               // Verify that AddP already points to all objects the value points to.
1504               PointsToNode* val = ptnode_adr(value->_idx);
1505               assert((val != NULL), "should be processed already");
1506               PointsToNode* missed_obj = NULL;
1507               if (val->is_JavaObject()) {
1508                 if (!field->points_to(val->as_JavaObject())) {
1509                   missed_obj = val;
1510                 }
1511               } else {
1512                 if (!val->is_LocalVar() || (val->edge_count() == 0)) {
1513                   tty->print_cr("----------init store has invalid value -----");
1514                   store->dump();
1515                   val->dump();
1516                   assert(val->is_LocalVar() && (val->edge_count() > 0), "should be processed already");
1517                 }
1518                 for (EdgeIterator j(val); j.has_next(); j.next()) {
1519                   PointsToNode* obj = j.get();
1520                   if (obj->is_JavaObject()) {
1521                     if (!field->points_to(obj->as_JavaObject())) {
1522                       missed_obj = obj;
1523                       break;
1524                     }
1525                   }
1526                 }
1527               }
1528               if (missed_obj != NULL) {
1529                 tty->print_cr("----------field---------------------------------");
1530                 field->dump();
1531                 tty->print_cr("----------missed referernce to object-----------");
1532                 missed_obj->dump();
1533                 tty->print_cr("----------object referernced by init store -----");
1534                 store->dump();
1535                 val->dump();
1536                 assert(!field->points_to(missed_obj->as_JavaObject()), "missed JavaObject reference");
1537               }
1538             }
1539 #endif
1540           } else {
1541             // There could be initializing stores which follow allocation.
1542             // For example, a volatile field store is not collected
1543             // by Initialize node.
1544             //
1545             // Need to check for dependent loads to separate such stores from
1546             // stores which follow loads. For now, add initial value NULL so
1547             // that compare pointers optimization works correctly.
1548           }
1549         }
1550         if (value == NULL) {
1551           // A field's initializing value was not recorded. Add NULL.
1552           if (add_edge(field, null_obj)) {
1553             // New edge was added
1554             new_edges++;
1555             add_field_uses_to_worklist(field->as_Field());
1556           }
1557         }
1558       }
1559     }
1560   }
1561   return new_edges;
1562 }
1563 
1564 // Adjust scalar_replaceable state after Connection Graph is built.
1565 void ConnectionGraph::adjust_scalar_replaceable_state(JavaObjectNode* jobj) {
1566   // Search for non-escaping objects which are not scalar replaceable
1567   // and mark them to propagate the state to referenced objects.
1568 
1569   // 1. An object is not scalar replaceable if the field into which it is
1570   // stored has unknown offset (stored into unknown element of an array).
1571   //
1572   for (UseIterator i(jobj); i.has_next(); i.next()) {
1573     PointsToNode* use = i.get();
1574     assert(!use->is_Arraycopy(), "sanity");
1575     if (use->is_Field()) {
1576       FieldNode* field = use->as_Field();
1577       assert(field->is_oop() && field->scalar_replaceable() &&
1578              field->fields_escape_state() == PointsToNode::NoEscape, "sanity");
1579       if (field->offset() == Type::OffsetBot) {
1580         jobj->set_scalar_replaceable(false);
1581         return;
1582       }
1583       // 2. An object is not scalar replaceable if the field into which it is
1584       // stored has multiple bases one of which is null.
1585       if (field->base_count() > 1) {
1586         for (BaseIterator i(field); i.has_next(); i.next()) {
1587           PointsToNode* base = i.get();
1588           if (base == null_obj) {
1589             jobj->set_scalar_replaceable(false);
1590             return;
1591           }
1592         }
1593       }
1594     }
1595     assert(use->is_Field() || use->is_LocalVar(), "sanity");
1596     // 3. An object is not scalar replaceable if it is merged with other objects.
1597     for (EdgeIterator j(use); j.has_next(); j.next()) {
1598       PointsToNode* ptn = j.get();
1599       if (ptn->is_JavaObject() && ptn != jobj) {
1600         // Mark all objects.
1601         jobj->set_scalar_replaceable(false);
1602          ptn->set_scalar_replaceable(false);
1603       }
1604     }
1605     if (!jobj->scalar_replaceable()) {
1606       return;
1607     }
1608   }
1609 
1610   for (EdgeIterator j(jobj); j.has_next(); j.next()) {
1611     // Non-escaping object node should point only to field nodes.
1612     FieldNode* field = j.get()->as_Field();
1613     int offset = field->as_Field()->offset();
1614 
1615     // 4. An object is not scalar replaceable if it has a field with unknown
1616     // offset (array's element is accessed in loop).
1617     if (offset == Type::OffsetBot) {
1618       jobj->set_scalar_replaceable(false);
1619       return;
1620     }
1621     // 5. Currently an object is not scalar replaceable if a LoadStore node
1622     // access its field since the field value is unknown after it.
1623     //
1624     Node* n = field->ideal_node();
1625     for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
1626       if (n->fast_out(i)->is_LoadStore()) {
1627         jobj->set_scalar_replaceable(false);
1628         return;
1629       }
1630     }
1631 
1632     // 6. Or the address may point to more then one object. This may produce
1633     // the false positive result (set not scalar replaceable)
1634     // since the flow-insensitive escape analysis can't separate
1635     // the case when stores overwrite the field's value from the case
1636     // when stores happened on different control branches.
1637     //
1638     // Note: it will disable scalar replacement in some cases:
1639     //
1640     //    Point p[] = new Point[1];
1641     //    p[0] = new Point(); // Will be not scalar replaced
1642     //
1643     // but it will save us from incorrect optimizations in next cases:
1644     //
1645     //    Point p[] = new Point[1];
1646     //    if ( x ) p[0] = new Point(); // Will be not scalar replaced
1647     //
1648     if (field->base_count() > 1) {
1649       for (BaseIterator i(field); i.has_next(); i.next()) {
1650         PointsToNode* base = i.get();
1651         // Don't take into account LocalVar nodes which
1652         // may point to only one object which should be also
1653         // this field's base by now.
1654         if (base->is_JavaObject() && base != jobj) {
1655           // Mark all bases.
1656           jobj->set_scalar_replaceable(false);
1657           base->set_scalar_replaceable(false);
1658         }
1659       }
1660     }
1661   }
1662 }
1663 
1664 #ifdef ASSERT
1665 void ConnectionGraph::verify_connection_graph(
1666                          GrowableArray<PointsToNode*>&   ptnodes_worklist,
1667                          GrowableArray<JavaObjectNode*>& non_escaped_worklist,
1668                          GrowableArray<JavaObjectNode*>& java_objects_worklist,
1669                          GrowableArray<Node*>& addp_worklist) {
1670   // Verify that graph is complete - no new edges could be added.
1671   int java_objects_length = java_objects_worklist.length();
1672   int non_escaped_length  = non_escaped_worklist.length();
1673   int new_edges = 0;
1674   for (int next = 0; next < java_objects_length; ++next) {
1675     JavaObjectNode* ptn = java_objects_worklist.at(next);
1676     new_edges += add_java_object_edges(ptn, true);
1677   }
1678   assert(new_edges == 0, "graph was not complete");
1679   // Verify that escape state is final.
1680   int length = non_escaped_worklist.length();
1681   find_non_escaped_objects(ptnodes_worklist, non_escaped_worklist);
1682   assert((non_escaped_length == non_escaped_worklist.length()) &&
1683          (non_escaped_length == length) &&
1684          (_worklist.length() == 0), "escape state was not final");
1685 
1686   // Verify fields information.
1687   int addp_length = addp_worklist.length();
1688   for (int next = 0; next < addp_length; ++next ) {
1689     Node* n = addp_worklist.at(next);
1690     FieldNode* field = ptnode_adr(n->_idx)->as_Field();
1691     if (field->is_oop()) {
1692       // Verify that field has all bases
1693       Node* base = get_addp_base(n);
1694       PointsToNode* ptn = ptnode_adr(base->_idx);
1695       if (ptn->is_JavaObject()) {
1696         assert(field->has_base(ptn->as_JavaObject()), "sanity");
1697       } else {
1698         assert(ptn->is_LocalVar(), "sanity");
1699         for (EdgeIterator i(ptn); i.has_next(); i.next()) {
1700           PointsToNode* e = i.get();
1701           if (e->is_JavaObject()) {
1702             assert(field->has_base(e->as_JavaObject()), "sanity");
1703           }
1704         }
1705       }
1706       // Verify that all fields have initializing values.
1707       if (field->edge_count() == 0) {
1708         tty->print_cr("----------field does not have references----------");
1709         field->dump();
1710         for (BaseIterator i(field); i.has_next(); i.next()) {
1711           PointsToNode* base = i.get();
1712           tty->print_cr("----------field has next base---------------------");
1713           base->dump();
1714           if (base->is_JavaObject() && (base != phantom_obj) && (base != null_obj)) {
1715             tty->print_cr("----------base has fields-------------------------");
1716             for (EdgeIterator j(base); j.has_next(); j.next()) {
1717               j.get()->dump();
1718             }
1719             tty->print_cr("----------base has references---------------------");
1720             for (UseIterator j(base); j.has_next(); j.next()) {
1721               j.get()->dump();
1722             }
1723           }
1724         }
1725         for (UseIterator i(field); i.has_next(); i.next()) {
1726           i.get()->dump();
1727         }
1728         assert(field->edge_count() > 0, "sanity");
1729       }
1730     }
1731   }
1732 }
1733 #endif
1734 
1735 // Optimize ideal graph.
1736 void ConnectionGraph::optimize_ideal_graph(GrowableArray<Node*>& ptr_cmp_worklist,
1737                                            GrowableArray<Node*>& storestore_worklist) {
1738   Compile* C = _compile;
1739   PhaseIterGVN* igvn = _igvn;
1740   if (EliminateLocks) {
1741     // Mark locks before changing ideal graph.
1742     int cnt = C->macro_count();
1743     for( int i=0; i < cnt; i++ ) {
1744       Node *n = C->macro_node(i);
1745       if (n->is_AbstractLock()) { // Lock and Unlock nodes
1746         AbstractLockNode* alock = n->as_AbstractLock();
1747         if (!alock->is_non_esc_obj()) {
1748           if (not_global_escape(alock->obj_node())) {
1749             assert(!alock->is_eliminated() || alock->is_coarsened(), "sanity");
1750             // The lock could be marked eliminated by lock coarsening
1751             // code during first IGVN before EA. Replace coarsened flag
1752             // to eliminate all associated locks/unlocks.
1753             alock->set_non_esc_obj();
1754           }
1755         }
1756       }
1757     }
1758   }
1759 
1760   if (OptimizePtrCompare) {
1761     // Add ConI(#CC_GT) and ConI(#CC_EQ).
1762     _pcmp_neq = igvn->makecon(TypeInt::CC_GT);
1763     _pcmp_eq = igvn->makecon(TypeInt::CC_EQ);
1764     // Optimize objects compare.
1765     while (ptr_cmp_worklist.length() != 0) {
1766       Node *n = ptr_cmp_worklist.pop();
1767       Node *res = optimize_ptr_compare(n);
1768       if (res != NULL) {
1769 #ifndef PRODUCT
1770         if (PrintOptimizePtrCompare) {
1771           tty->print_cr("++++ Replaced: %d %s(%d,%d) --> %s", n->_idx, (n->Opcode() == Op_CmpP ? "CmpP" : "CmpN"), n->in(1)->_idx, n->in(2)->_idx, (res == _pcmp_eq ? "EQ" : "NotEQ"));
1772           if (Verbose) {
1773             n->dump(1);
1774           }
1775         }
1776 #endif
1777         igvn->replace_node(n, res);
1778       }
1779     }
1780     // cleanup
1781     if (_pcmp_neq->outcnt() == 0)
1782       igvn->hash_delete(_pcmp_neq);
1783     if (_pcmp_eq->outcnt()  == 0)
1784       igvn->hash_delete(_pcmp_eq);
1785   }
1786 
1787   // For MemBarStoreStore nodes added in library_call.cpp, check
1788   // escape status of associated AllocateNode and optimize out
1789   // MemBarStoreStore node if the allocated object never escapes.
1790   while (storestore_worklist.length() != 0) {
1791     Node *n = storestore_worklist.pop();
1792     MemBarStoreStoreNode *storestore = n ->as_MemBarStoreStore();
1793     Node *alloc = storestore->in(MemBarNode::Precedent)->in(0);
1794     assert (alloc->is_Allocate(), "storestore should point to AllocateNode");
1795     if (not_global_escape(alloc)) {
1796       MemBarNode* mb = MemBarNode::make(C, Op_MemBarCPUOrder, Compile::AliasIdxBot);
1797       mb->init_req(TypeFunc::Memory, storestore->in(TypeFunc::Memory));
1798       mb->init_req(TypeFunc::Control, storestore->in(TypeFunc::Control));
1799       igvn->register_new_node_with_optimizer(mb);
1800       igvn->replace_node(storestore, mb);
1801     }
1802   }
1803 }
1804 
1805 // Optimize objects compare.
1806 Node* ConnectionGraph::optimize_ptr_compare(Node* n) {
1807   assert(OptimizePtrCompare, "sanity");
1808   PointsToNode* ptn1 = ptnode_adr(n->in(1)->_idx);
1809   PointsToNode* ptn2 = ptnode_adr(n->in(2)->_idx);
1810   JavaObjectNode* jobj1 = unique_java_object(n->in(1));
1811   JavaObjectNode* jobj2 = unique_java_object(n->in(2));
1812   assert(ptn1->is_JavaObject() || ptn1->is_LocalVar(), "sanity");
1813   assert(ptn2->is_JavaObject() || ptn2->is_LocalVar(), "sanity");
1814 
1815   // Check simple cases first.
1816   if (jobj1 != NULL) {
1817     if (jobj1->escape_state() == PointsToNode::NoEscape) {
1818       if (jobj1 == jobj2) {
1819         // Comparing the same not escaping object.
1820         return _pcmp_eq;
1821       }
1822       Node* obj = jobj1->ideal_node();
1823       // Comparing not escaping allocation.
1824       if ((obj->is_Allocate() || obj->is_CallStaticJava()) &&
1825           !ptn2->points_to(jobj1)) {
1826         return _pcmp_neq; // This includes nullness check.
1827       }
1828     }
1829   }
1830   if (jobj2 != NULL) {
1831     if (jobj2->escape_state() == PointsToNode::NoEscape) {
1832       Node* obj = jobj2->ideal_node();
1833       // Comparing not escaping allocation.
1834       if ((obj->is_Allocate() || obj->is_CallStaticJava()) &&
1835           !ptn1->points_to(jobj2)) {
1836         return _pcmp_neq; // This includes nullness check.
1837       }
1838     }
1839   }
1840   if (jobj1 != NULL && jobj1 != phantom_obj &&
1841       jobj2 != NULL && jobj2 != phantom_obj &&
1842       jobj1->ideal_node()->is_Con() &&
1843       jobj2->ideal_node()->is_Con()) {
1844     // Klass or String constants compare. Need to be careful with
1845     // compressed pointers - compare types of ConN and ConP instead of nodes.
1846     const Type* t1 = jobj1->ideal_node()->get_ptr_type();
1847     const Type* t2 = jobj2->ideal_node()->get_ptr_type();
1848     if (t1->make_ptr() == t2->make_ptr()) {
1849       return _pcmp_eq;
1850     } else {
1851       return _pcmp_neq;
1852     }
1853   }
1854   if (ptn1->meet(ptn2)) {
1855     return NULL; // Sets are not disjoint
1856   }
1857 
1858   // Sets are disjoint.
1859   bool set1_has_unknown_ptr = ptn1->points_to(phantom_obj);
1860   bool set2_has_unknown_ptr = ptn2->points_to(phantom_obj);
1861   bool set1_has_null_ptr    = ptn1->points_to(null_obj);
1862   bool set2_has_null_ptr    = ptn2->points_to(null_obj);
1863   if (set1_has_unknown_ptr && set2_has_null_ptr ||
1864       set2_has_unknown_ptr && set1_has_null_ptr) {
1865     // Check nullness of unknown object.
1866     return NULL;
1867   }
1868 
1869   // Disjointness by itself is not sufficient since
1870   // alias analysis is not complete for escaped objects.
1871   // Disjoint sets are definitely unrelated only when
1872   // at least one set has only not escaping allocations.
1873   if (!set1_has_unknown_ptr && !set1_has_null_ptr) {
1874     if (ptn1->non_escaping_allocation()) {
1875       return _pcmp_neq;
1876     }
1877   }
1878   if (!set2_has_unknown_ptr && !set2_has_null_ptr) {
1879     if (ptn2->non_escaping_allocation()) {
1880       return _pcmp_neq;
1881     }
1882   }
1883   return NULL;
1884 }
1885 
1886 // Connection Graph constuction functions.
1887 
1888 void ConnectionGraph::add_local_var(Node *n, PointsToNode::EscapeState es) {
1889   PointsToNode* ptadr = _nodes.at(n->_idx);
1890   if (ptadr != NULL) {
1891     assert(ptadr->is_LocalVar() && ptadr->ideal_node() == n, "sanity");
1892     return;
1893   }
1894   Compile* C = _compile;
1895   ptadr = new (C->comp_arena()) LocalVarNode(C, n, es);
1896   _nodes.at_put(n->_idx, ptadr);
1897 }
1898 
1899 void ConnectionGraph::add_java_object(Node *n, PointsToNode::EscapeState es) {
1900   PointsToNode* ptadr = _nodes.at(n->_idx);
1901   if (ptadr != NULL) {
1902     assert(ptadr->is_JavaObject() && ptadr->ideal_node() == n, "sanity");
1903     return;
1904   }
1905   Compile* C = _compile;
1906   ptadr = new (C->comp_arena()) JavaObjectNode(C, n, es);
1907   _nodes.at_put(n->_idx, ptadr);
1908 }
1909 
1910 void ConnectionGraph::add_field(Node *n, PointsToNode::EscapeState es, int offset) {
1911   PointsToNode* ptadr = _nodes.at(n->_idx);
1912   if (ptadr != NULL) {
1913     assert(ptadr->is_Field() && ptadr->ideal_node() == n, "sanity");
1914     return;
1915   }
1916   bool unsafe = false;
1917   bool is_oop = is_oop_field(n, offset, &unsafe);
1918   if (unsafe) {
1919     es = PointsToNode::GlobalEscape;
1920   }
1921   Compile* C = _compile;
1922   FieldNode* field = new (C->comp_arena()) FieldNode(C, n, es, offset, is_oop);
1923   _nodes.at_put(n->_idx, field);
1924 }
1925 
1926 void ConnectionGraph::add_arraycopy(Node *n, PointsToNode::EscapeState es,
1927                                     PointsToNode* src, PointsToNode* dst) {
1928   assert(!src->is_Field() && !dst->is_Field(), "only for JavaObject and LocalVar");
1929   assert((src != null_obj) && (dst != null_obj), "not for ConP NULL");
1930   PointsToNode* ptadr = _nodes.at(n->_idx);
1931   if (ptadr != NULL) {
1932     assert(ptadr->is_Arraycopy() && ptadr->ideal_node() == n, "sanity");
1933     return;
1934   }
1935   Compile* C = _compile;
1936   ptadr = new (C->comp_arena()) ArraycopyNode(C, n, es);
1937   _nodes.at_put(n->_idx, ptadr);
1938   // Add edge from arraycopy node to source object.
1939   (void)add_edge(ptadr, src);
1940   src->set_arraycopy_src();
1941   // Add edge from destination object to arraycopy node.
1942   (void)add_edge(dst, ptadr);
1943   dst->set_arraycopy_dst();
1944 }
1945 
1946 bool ConnectionGraph::is_oop_field(Node* n, int offset, bool* unsafe) {
1947   const Type* adr_type = n->as_AddP()->bottom_type();
1948   BasicType bt = T_INT;
1949   if (offset == Type::OffsetBot) {
1950     // Check only oop fields.
1951     if (!adr_type->isa_aryptr() ||
1952         (adr_type->isa_aryptr()->klass() == NULL) ||
1953          adr_type->isa_aryptr()->klass()->is_obj_array_klass()) {
1954       // OffsetBot is used to reference array's element. Ignore first AddP.
1955       if (find_second_addp(n, n->in(AddPNode::Base)) == NULL) {
1956         bt = T_OBJECT;
1957       }
1958     }
1959   } else if (offset != oopDesc::klass_offset_in_bytes()) {
1960     if (adr_type->isa_instptr()) {
1961       ciField* field = _compile->alias_type(adr_type->isa_instptr())->field();
1962       if (field != NULL) {
1963         bt = field->layout_type();
1964       } else {
1965         // Check for unsafe oop field access
1966         for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
1967           int opcode = n->fast_out(i)->Opcode();
1968           if (opcode == Op_StoreP || opcode == Op_LoadP ||
1969               opcode == Op_StoreN || opcode == Op_LoadN) {
1970             bt = T_OBJECT;
1971             (*unsafe) = true;
1972             break;
1973           }
1974         }
1975       }
1976     } else if (adr_type->isa_aryptr()) {
1977       if (offset == arrayOopDesc::length_offset_in_bytes()) {
1978         // Ignore array length load.
1979       } else if (find_second_addp(n, n->in(AddPNode::Base)) != NULL) {
1980         // Ignore first AddP.
1981       } else {
1982         const Type* elemtype = adr_type->isa_aryptr()->elem();
1983         bt = elemtype->array_element_basic_type();
1984       }
1985     } else if (adr_type->isa_rawptr() || adr_type->isa_klassptr()) {
1986       // Allocation initialization, ThreadLocal field access, unsafe access
1987       for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
1988         int opcode = n->fast_out(i)->Opcode();
1989         if (opcode == Op_StoreP || opcode == Op_LoadP ||
1990             opcode == Op_StoreN || opcode == Op_LoadN) {
1991           bt = T_OBJECT;
1992           break;
1993         }
1994       }
1995     }
1996   }
1997   return (bt == T_OBJECT || bt == T_NARROWOOP || bt == T_ARRAY);
1998 }
1999 
2000 // Returns unique pointed java object or NULL.
2001 JavaObjectNode* ConnectionGraph::unique_java_object(Node *n) {
2002   assert(!_collecting, "should not call when contructed graph");
2003   // If the node was created after the escape computation we can't answer.
2004   uint idx = n->_idx;
2005   if (idx >= nodes_size()) {
2006     return NULL;
2007   }
2008   PointsToNode* ptn = ptnode_adr(idx);
2009   if (ptn->is_JavaObject()) {
2010     return ptn->as_JavaObject();
2011   }
2012   assert(ptn->is_LocalVar(), "sanity");
2013   // Check all java objects it points to.
2014   JavaObjectNode* jobj = NULL;
2015   for (EdgeIterator i(ptn); i.has_next(); i.next()) {
2016     PointsToNode* e = i.get();
2017     if (e->is_JavaObject()) {
2018       if (jobj == NULL) {
2019         jobj = e->as_JavaObject();
2020       } else if (jobj != e) {
2021         return NULL;
2022       }
2023     }
2024   }
2025   return jobj;
2026 }
2027 
2028 // Return true if this node points only to non-escaping allocations.
2029 bool PointsToNode::non_escaping_allocation() {
2030   if (is_JavaObject()) {
2031     Node* n = ideal_node();
2032     if (n->is_Allocate() || n->is_CallStaticJava()) {
2033       return (escape_state() == PointsToNode::NoEscape);
2034     } else {
2035       return false;
2036     }
2037   }
2038   assert(is_LocalVar(), "sanity");
2039   // Check all java objects it points to.
2040   for (EdgeIterator i(this); i.has_next(); i.next()) {
2041     PointsToNode* e = i.get();
2042     if (e->is_JavaObject()) {
2043       Node* n = e->ideal_node();
2044       if ((e->escape_state() != PointsToNode::NoEscape) ||
2045           !(n->is_Allocate() || n->is_CallStaticJava())) {
2046         return false;
2047       }
2048     }
2049   }
2050   return true;
2051 }
2052 
2053 // Return true if we know the node does not escape globally.
2054 bool ConnectionGraph::not_global_escape(Node *n) {
2055   assert(!_collecting, "should not call during graph construction");
2056   // If the node was created after the escape computation we can't answer.
2057   uint idx = n->_idx;
2058   if (idx >= nodes_size()) {
2059     return false;
2060   }
2061   PointsToNode* ptn = ptnode_adr(idx);
2062   PointsToNode::EscapeState es = ptn->escape_state();
2063   // If we have already computed a value, return it.
2064   if (es >= PointsToNode::GlobalEscape)
2065     return false;
2066   if (ptn->is_JavaObject()) {
2067     return true; // (es < PointsToNode::GlobalEscape);
2068   }
2069   assert(ptn->is_LocalVar(), "sanity");
2070   // Check all java objects it points to.
2071   for (EdgeIterator i(ptn); i.has_next(); i.next()) {
2072     if (i.get()->escape_state() >= PointsToNode::GlobalEscape)
2073       return false;
2074   }
2075   return true;
2076 }
2077 
2078 
2079 // Helper functions
2080 
2081 // Return true if this node points to specified node or nodes it points to.
2082 bool PointsToNode::points_to(JavaObjectNode* ptn) const {
2083   if (is_JavaObject()) {
2084     return (this == ptn);
2085   }
2086   assert(is_LocalVar() || is_Field(), "sanity");
2087   for (EdgeIterator i(this); i.has_next(); i.next()) {
2088     if (i.get() == ptn)
2089       return true;
2090   }
2091   return false;
2092 }
2093 
2094 // Return true if one node points to an other.
2095 bool PointsToNode::meet(PointsToNode* ptn) {
2096   if (this == ptn) {
2097     return true;
2098   } else if (ptn->is_JavaObject()) {
2099     return this->points_to(ptn->as_JavaObject());
2100   } else if (this->is_JavaObject()) {
2101     return ptn->points_to(this->as_JavaObject());
2102   }
2103   assert(this->is_LocalVar() && ptn->is_LocalVar(), "sanity");
2104   int ptn_count =  ptn->edge_count();
2105   for (EdgeIterator i(this); i.has_next(); i.next()) {
2106     PointsToNode* this_e = i.get();
2107     for (int j = 0; j < ptn_count; j++) {
2108       if (this_e == ptn->edge(j))
2109         return true;
2110     }
2111   }
2112   return false;
2113 }
2114 
2115 #ifdef ASSERT
2116 // Return true if bases point to this java object.
2117 bool FieldNode::has_base(JavaObjectNode* jobj) const {
2118   for (BaseIterator i(this); i.has_next(); i.next()) {
2119     if (i.get() == jobj)
2120       return true;
2121   }
2122   return false;
2123 }
2124 #endif
2125 
2126 int ConnectionGraph::address_offset(Node* adr, PhaseTransform *phase) {
2127   const Type *adr_type = phase->type(adr);
2128   if (adr->is_AddP() && adr_type->isa_oopptr() == NULL &&
2129       adr->in(AddPNode::Address)->is_Proj() &&
2130       adr->in(AddPNode::Address)->in(0)->is_Allocate()) {
2131     // We are computing a raw address for a store captured by an Initialize
2132     // compute an appropriate address type. AddP cases #3 and #5 (see below).
2133     int offs = (int)phase->find_intptr_t_con(adr->in(AddPNode::Offset), Type::OffsetBot);
2134     assert(offs != Type::OffsetBot ||
2135            adr->in(AddPNode::Address)->in(0)->is_AllocateArray(),
2136            "offset must be a constant or it is initialization of array");
2137     return offs;
2138   }
2139   const TypePtr *t_ptr = adr_type->isa_ptr();
2140   assert(t_ptr != NULL, "must be a pointer type");
2141   return t_ptr->offset();
2142 }
2143 
2144 Node* ConnectionGraph::get_addp_base(Node *addp) {
2145   assert(addp->is_AddP(), "must be AddP");
2146   //
2147   // AddP cases for Base and Address inputs:
2148   // case #1. Direct object's field reference:
2149   //     Allocate
2150   //       |
2151   //     Proj #5 ( oop result )
2152   //       |
2153   //     CheckCastPP (cast to instance type)
2154   //      | |
2155   //     AddP  ( base == address )
2156   //
2157   // case #2. Indirect object's field reference:
2158   //      Phi
2159   //       |
2160   //     CastPP (cast to instance type)
2161   //      | |
2162   //     AddP  ( base == address )
2163   //
2164   // case #3. Raw object's field reference for Initialize node:
2165   //      Allocate
2166   //        |
2167   //      Proj #5 ( oop result )
2168   //  top   |
2169   //     \  |
2170   //     AddP  ( base == top )
2171   //
2172   // case #4. Array's element reference:
2173   //   {CheckCastPP | CastPP}
2174   //     |  | |
2175   //     |  AddP ( array's element offset )
2176   //     |  |
2177   //     AddP ( array's offset )
2178   //
2179   // case #5. Raw object's field reference for arraycopy stub call:
2180   //          The inline_native_clone() case when the arraycopy stub is called
2181   //          after the allocation before Initialize and CheckCastPP nodes.
2182   //      Allocate
2183   //        |
2184   //      Proj #5 ( oop result )
2185   //       | |
2186   //       AddP  ( base == address )
2187   //
2188   // case #6. Constant Pool, ThreadLocal, CastX2P or
2189   //          Raw object's field reference:
2190   //      {ConP, ThreadLocal, CastX2P, raw Load}
2191   //  top   |
2192   //     \  |
2193   //     AddP  ( base == top )
2194   //
2195   // case #7. Klass's field reference.
2196   //      LoadKlass
2197   //       | |
2198   //       AddP  ( base == address )
2199   //
2200   // case #8. narrow Klass's field reference.
2201   //      LoadNKlass
2202   //       |
2203   //      DecodeN
2204   //       | |
2205   //       AddP  ( base == address )
2206   //
2207   Node *base = addp->in(AddPNode::Base);
2208   if (base->uncast()->is_top()) { // The AddP case #3 and #6.
2209     base = addp->in(AddPNode::Address);
2210     while (base->is_AddP()) {
2211       // Case #6 (unsafe access) may have several chained AddP nodes.
2212       assert(base->in(AddPNode::Base)->uncast()->is_top(), "expected unsafe access address only");
2213       base = base->in(AddPNode::Address);
2214     }
2215     Node* uncast_base = base->uncast();
2216     int opcode = uncast_base->Opcode();
2217     assert(opcode == Op_ConP || opcode == Op_ThreadLocal ||
2218            opcode == Op_CastX2P || uncast_base->is_DecodeNarrowPtr() ||
2219            (uncast_base->is_Mem() && (uncast_base->bottom_type()->isa_rawptr() != NULL)) ||
2220            (uncast_base->is_Proj() && uncast_base->in(0)->is_Allocate()), "sanity");
2221   }
2222   return base;
2223 }
2224 
2225 Node* ConnectionGraph::find_second_addp(Node* addp, Node* n) {
2226   assert(addp->is_AddP() && addp->outcnt() > 0, "Don't process dead nodes");
2227   Node* addp2 = addp->raw_out(0);
2228   if (addp->outcnt() == 1 && addp2->is_AddP() &&
2229       addp2->in(AddPNode::Base) == n &&
2230       addp2->in(AddPNode::Address) == addp) {
2231     assert(addp->in(AddPNode::Base) == n, "expecting the same base");
2232     //
2233     // Find array's offset to push it on worklist first and
2234     // as result process an array's element offset first (pushed second)
2235     // to avoid CastPP for the array's offset.
2236     // Otherwise the inserted CastPP (LocalVar) will point to what
2237     // the AddP (Field) points to. Which would be wrong since
2238     // the algorithm expects the CastPP has the same point as
2239     // as AddP's base CheckCastPP (LocalVar).
2240     //
2241     //    ArrayAllocation
2242     //     |
2243     //    CheckCastPP
2244     //     |
2245     //    memProj (from ArrayAllocation CheckCastPP)
2246     //     |  ||
2247     //     |  ||   Int (element index)
2248     //     |  ||    |   ConI (log(element size))
2249     //     |  ||    |   /
2250     //     |  ||   LShift
2251     //     |  ||  /
2252     //     |  AddP (array's element offset)
2253     //     |  |
2254     //     |  | ConI (array's offset: #12(32-bits) or #24(64-bits))
2255     //     | / /
2256     //     AddP (array's offset)
2257     //      |
2258     //     Load/Store (memory operation on array's element)
2259     //
2260     return addp2;
2261   }
2262   return NULL;
2263 }
2264 
2265 //
2266 // Adjust the type and inputs of an AddP which computes the
2267 // address of a field of an instance
2268 //
2269 bool ConnectionGraph::split_AddP(Node *addp, Node *base) {
2270   PhaseGVN* igvn = _igvn;
2271   const TypeOopPtr *base_t = igvn->type(base)->isa_oopptr();
2272   assert(base_t != NULL && base_t->is_known_instance(), "expecting instance oopptr");
2273   const TypeOopPtr *t = igvn->type(addp)->isa_oopptr();
2274   if (t == NULL) {
2275     // We are computing a raw address for a store captured by an Initialize
2276     // compute an appropriate address type (cases #3 and #5).
2277     assert(igvn->type(addp) == TypeRawPtr::NOTNULL, "must be raw pointer");
2278     assert(addp->in(AddPNode::Address)->is_Proj(), "base of raw address must be result projection from allocation");
2279     intptr_t offs = (int)igvn->find_intptr_t_con(addp->in(AddPNode::Offset), Type::OffsetBot);
2280     assert(offs != Type::OffsetBot, "offset must be a constant");
2281     t = base_t->add_offset(offs)->is_oopptr();
2282   }
2283   int inst_id =  base_t->instance_id();
2284   assert(!t->is_known_instance() || t->instance_id() == inst_id,
2285                              "old type must be non-instance or match new type");
2286 
2287   // The type 't' could be subclass of 'base_t'.
2288   // As result t->offset() could be large then base_t's size and it will
2289   // cause the failure in add_offset() with narrow oops since TypeOopPtr()
2290   // constructor verifies correctness of the offset.
2291   //
2292   // It could happened on subclass's branch (from the type profiling
2293   // inlining) which was not eliminated during parsing since the exactness
2294   // of the allocation type was not propagated to the subclass type check.
2295   //
2296   // Or the type 't' could be not related to 'base_t' at all.
2297   // It could happened when CHA type is different from MDO type on a dead path
2298   // (for example, from instanceof check) which is not collapsed during parsing.
2299   //
2300   // Do nothing for such AddP node and don't process its users since
2301   // this code branch will go away.
2302   //
2303   if (!t->is_known_instance() &&
2304       !base_t->klass()->is_subtype_of(t->klass())) {
2305      return false; // bail out
2306   }
2307   const TypeOopPtr *tinst = base_t->add_offset(t->offset())->is_oopptr();
2308   // Do NOT remove the next line: ensure a new alias index is allocated
2309   // for the instance type. Note: C++ will not remove it since the call
2310   // has side effect.
2311   int alias_idx = _compile->get_alias_index(tinst);
2312   igvn->set_type(addp, tinst);
2313   // record the allocation in the node map
2314   set_map(addp, get_map(base->_idx));
2315   // Set addp's Base and Address to 'base'.
2316   Node *abase = addp->in(AddPNode::Base);
2317   Node *adr   = addp->in(AddPNode::Address);
2318   if (adr->is_Proj() && adr->in(0)->is_Allocate() &&
2319       adr->in(0)->_idx == (uint)inst_id) {
2320     // Skip AddP cases #3 and #5.
2321   } else {
2322     assert(!abase->is_top(), "sanity"); // AddP case #3
2323     if (abase != base) {
2324       igvn->hash_delete(addp);
2325       addp->set_req(AddPNode::Base, base);
2326       if (abase == adr) {
2327         addp->set_req(AddPNode::Address, base);
2328       } else {
2329         // AddP case #4 (adr is array's element offset AddP node)
2330 #ifdef ASSERT
2331         const TypeOopPtr *atype = igvn->type(adr)->isa_oopptr();
2332         assert(adr->is_AddP() && atype != NULL &&
2333                atype->instance_id() == inst_id, "array's element offset should be processed first");
2334 #endif
2335       }
2336       igvn->hash_insert(addp);
2337     }
2338   }
2339   // Put on IGVN worklist since at least addp's type was changed above.
2340   record_for_optimizer(addp);
2341   return true;
2342 }
2343 
2344 //
2345 // Create a new version of orig_phi if necessary. Returns either the newly
2346 // created phi or an existing phi.  Sets create_new to indicate whether a new
2347 // phi was created.  Cache the last newly created phi in the node map.
2348 //
2349 PhiNode *ConnectionGraph::create_split_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *>  &orig_phi_worklist, bool &new_created) {
2350   Compile *C = _compile;
2351   PhaseGVN* igvn = _igvn;
2352   new_created = false;
2353   int phi_alias_idx = C->get_alias_index(orig_phi->adr_type());
2354   // nothing to do if orig_phi is bottom memory or matches alias_idx
2355   if (phi_alias_idx == alias_idx) {
2356     return orig_phi;
2357   }
2358   // Have we recently created a Phi for this alias index?
2359   PhiNode *result = get_map_phi(orig_phi->_idx);
2360   if (result != NULL && C->get_alias_index(result->adr_type()) == alias_idx) {
2361     return result;
2362   }
2363   // Previous check may fail when the same wide memory Phi was split into Phis
2364   // for different memory slices. Search all Phis for this region.
2365   if (result != NULL) {
2366     Node* region = orig_phi->in(0);
2367     for (DUIterator_Fast imax, i = region->fast_outs(imax); i < imax; i++) {
2368       Node* phi = region->fast_out(i);
2369       if (phi->is_Phi() &&
2370           C->get_alias_index(phi->as_Phi()->adr_type()) == alias_idx) {
2371         assert(phi->_idx >= nodes_size(), "only new Phi per instance memory slice");
2372         return phi->as_Phi();
2373       }
2374     }
2375   }
2376   if ((int) (C->live_nodes() + 2*NodeLimitFudgeFactor) > MaxNodeLimit) {
2377     if (C->do_escape_analysis() == true && !C->failing()) {
2378       // Retry compilation without escape analysis.
2379       // If this is the first failure, the sentinel string will "stick"
2380       // to the Compile object, and the C2Compiler will see it and retry.
2381       C->record_failure(C2Compiler::retry_no_escape_analysis());
2382     }
2383     return NULL;
2384   }
2385   orig_phi_worklist.append_if_missing(orig_phi);
2386   const TypePtr *atype = C->get_adr_type(alias_idx);
2387   result = PhiNode::make(orig_phi->in(0), NULL, Type::MEMORY, atype);
2388   C->copy_node_notes_to(result, orig_phi);
2389   igvn->set_type(result, result->bottom_type());
2390   record_for_optimizer(result);
2391   set_map(orig_phi, result);
2392   new_created = true;
2393   return result;
2394 }
2395 
2396 //
2397 // Return a new version of Memory Phi "orig_phi" with the inputs having the
2398 // specified alias index.
2399 //
2400 PhiNode *ConnectionGraph::split_memory_phi(PhiNode *orig_phi, int alias_idx, GrowableArray<PhiNode *>  &orig_phi_worklist) {
2401   assert(alias_idx != Compile::AliasIdxBot, "can't split out bottom memory");
2402   Compile *C = _compile;
2403   PhaseGVN* igvn = _igvn;
2404   bool new_phi_created;
2405   PhiNode *result = create_split_phi(orig_phi, alias_idx, orig_phi_worklist, new_phi_created);
2406   if (!new_phi_created) {
2407     return result;
2408   }
2409   GrowableArray<PhiNode *>  phi_list;
2410   GrowableArray<uint>  cur_input;
2411   PhiNode *phi = orig_phi;
2412   uint idx = 1;
2413   bool finished = false;
2414   while(!finished) {
2415     while (idx < phi->req()) {
2416       Node *mem = find_inst_mem(phi->in(idx), alias_idx, orig_phi_worklist);
2417       if (mem != NULL && mem->is_Phi()) {
2418         PhiNode *newphi = create_split_phi(mem->as_Phi(), alias_idx, orig_phi_worklist, new_phi_created);
2419         if (new_phi_created) {
2420           // found an phi for which we created a new split, push current one on worklist and begin
2421           // processing new one
2422           phi_list.push(phi);
2423           cur_input.push(idx);
2424           phi = mem->as_Phi();
2425           result = newphi;
2426           idx = 1;
2427           continue;
2428         } else {
2429           mem = newphi;
2430         }
2431       }
2432       if (C->failing()) {
2433         return NULL;
2434       }
2435       result->set_req(idx++, mem);
2436     }
2437 #ifdef ASSERT
2438     // verify that the new Phi has an input for each input of the original
2439     assert( phi->req() == result->req(), "must have same number of inputs.");
2440     assert( result->in(0) != NULL && result->in(0) == phi->in(0), "regions must match");
2441 #endif
2442     // Check if all new phi's inputs have specified alias index.
2443     // Otherwise use old phi.
2444     for (uint i = 1; i < phi->req(); i++) {
2445       Node* in = result->in(i);
2446       assert((phi->in(i) == NULL) == (in == NULL), "inputs must correspond.");
2447     }
2448     // we have finished processing a Phi, see if there are any more to do
2449     finished = (phi_list.length() == 0 );
2450     if (!finished) {
2451       phi = phi_list.pop();
2452       idx = cur_input.pop();
2453       PhiNode *prev_result = get_map_phi(phi->_idx);
2454       prev_result->set_req(idx++, result);
2455       result = prev_result;
2456     }
2457   }
2458   return result;
2459 }
2460 
2461 //
2462 // The next methods are derived from methods in MemNode.
2463 //
2464 Node* ConnectionGraph::step_through_mergemem(MergeMemNode *mmem, int alias_idx, const TypeOopPtr *toop) {
2465   Node *mem = mmem;
2466   // TypeOopPtr::NOTNULL+any is an OOP with unknown offset - generally
2467   // means an array I have not precisely typed yet.  Do not do any
2468   // alias stuff with it any time soon.
2469   if (toop->base() != Type::AnyPtr &&
2470       !(toop->klass() != NULL &&
2471         toop->klass()->is_java_lang_Object() &&
2472         toop->offset() == Type::OffsetBot)) {
2473     mem = mmem->memory_at(alias_idx);
2474     // Update input if it is progress over what we have now
2475   }
2476   return mem;
2477 }
2478 
2479 //
2480 // Move memory users to their memory slices.
2481 //
2482 void ConnectionGraph::move_inst_mem(Node* n, GrowableArray<PhiNode *>  &orig_phis) {
2483   Compile* C = _compile;
2484   PhaseGVN* igvn = _igvn;
2485   const TypePtr* tp = igvn->type(n->in(MemNode::Address))->isa_ptr();
2486   assert(tp != NULL, "ptr type");
2487   int alias_idx = C->get_alias_index(tp);
2488   int general_idx = C->get_general_index(alias_idx);
2489 
2490   // Move users first
2491   for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
2492     Node* use = n->fast_out(i);
2493     if (use->is_MergeMem()) {
2494       MergeMemNode* mmem = use->as_MergeMem();
2495       assert(n == mmem->memory_at(alias_idx), "should be on instance memory slice");
2496       if (n != mmem->memory_at(general_idx) || alias_idx == general_idx) {
2497         continue; // Nothing to do
2498       }
2499       // Replace previous general reference to mem node.
2500       uint orig_uniq = C->unique();
2501       Node* m = find_inst_mem(n, general_idx, orig_phis);
2502       assert(orig_uniq == C->unique(), "no new nodes");
2503       mmem->set_memory_at(general_idx, m);
2504       --imax;
2505       --i;
2506     } else if (use->is_MemBar()) {
2507       assert(!use->is_Initialize(), "initializing stores should not be moved");
2508       if (use->req() > MemBarNode::Precedent &&
2509           use->in(MemBarNode::Precedent) == n) {
2510         // Don't move related membars.
2511         record_for_optimizer(use);
2512         continue;
2513       }
2514       tp = use->as_MemBar()->adr_type()->isa_ptr();
2515       if (tp != NULL && C->get_alias_index(tp) == alias_idx ||
2516           alias_idx == general_idx) {
2517         continue; // Nothing to do
2518       }
2519       // Move to general memory slice.
2520       uint orig_uniq = C->unique();
2521       Node* m = find_inst_mem(n, general_idx, orig_phis);
2522       assert(orig_uniq == C->unique(), "no new nodes");
2523       igvn->hash_delete(use);
2524       imax -= use->replace_edge(n, m);
2525       igvn->hash_insert(use);
2526       record_for_optimizer(use);
2527       --i;
2528 #ifdef ASSERT
2529     } else if (use->is_Mem()) {
2530       if (use->Opcode() == Op_StoreCM && use->in(MemNode::OopStore) == n) {
2531         // Don't move related cardmark.
2532         continue;
2533       }
2534       // Memory nodes should have new memory input.
2535       tp = igvn->type(use->in(MemNode::Address))->isa_ptr();
2536       assert(tp != NULL, "ptr type");
2537       int idx = C->get_alias_index(tp);
2538       assert(get_map(use->_idx) != NULL || idx == alias_idx,
2539              "Following memory nodes should have new memory input or be on the same memory slice");
2540     } else if (use->is_Phi()) {
2541       // Phi nodes should be split and moved already.
2542       tp = use->as_Phi()->adr_type()->isa_ptr();
2543       assert(tp != NULL, "ptr type");
2544       int idx = C->get_alias_index(tp);
2545       assert(idx == alias_idx, "Following Phi nodes should be on the same memory slice");
2546     } else {
2547       use->dump();
2548       assert(false, "should not be here");
2549 #endif
2550     }
2551   }
2552 }
2553 
2554 //
2555 // Search memory chain of "mem" to find a MemNode whose address
2556 // is the specified alias index.
2557 //
2558 Node* ConnectionGraph::find_inst_mem(Node *orig_mem, int alias_idx, GrowableArray<PhiNode *>  &orig_phis) {
2559   if (orig_mem == NULL)
2560     return orig_mem;
2561   Compile* C = _compile;
2562   PhaseGVN* igvn = _igvn;
2563   const TypeOopPtr *toop = C->get_adr_type(alias_idx)->isa_oopptr();
2564   bool is_instance = (toop != NULL) && toop->is_known_instance();
2565   Node *start_mem = C->start()->proj_out(TypeFunc::Memory);
2566   Node *prev = NULL;
2567   Node *result = orig_mem;
2568   while (prev != result) {
2569     prev = result;
2570     if (result == start_mem)
2571       break;  // hit one of our sentinels
2572     if (result->is_Mem()) {
2573       const Type *at = igvn->type(result->in(MemNode::Address));
2574       if (at == Type::TOP)
2575         break; // Dead
2576       assert (at->isa_ptr() != NULL, "pointer type required.");
2577       int idx = C->get_alias_index(at->is_ptr());
2578       if (idx == alias_idx)
2579         break; // Found
2580       if (!is_instance && (at->isa_oopptr() == NULL ||
2581                            !at->is_oopptr()->is_known_instance())) {
2582         break; // Do not skip store to general memory slice.
2583       }
2584       result = result->in(MemNode::Memory);
2585     }
2586     if (!is_instance)
2587       continue;  // don't search further for non-instance types
2588     // skip over a call which does not affect this memory slice
2589     if (result->is_Proj() && result->as_Proj()->_con == TypeFunc::Memory) {
2590       Node *proj_in = result->in(0);
2591       if (proj_in->is_Allocate() && proj_in->_idx == (uint)toop->instance_id()) {
2592         break;  // hit one of our sentinels
2593       } else if (proj_in->is_Call()) {
2594         CallNode *call = proj_in->as_Call();
2595         if (!call->may_modify(toop, igvn)) {
2596           result = call->in(TypeFunc::Memory);
2597         }
2598       } else if (proj_in->is_Initialize()) {
2599         AllocateNode* alloc = proj_in->as_Initialize()->allocation();
2600         // Stop if this is the initialization for the object instance which
2601         // which contains this memory slice, otherwise skip over it.
2602         if (alloc == NULL || alloc->_idx != (uint)toop->instance_id()) {
2603           result = proj_in->in(TypeFunc::Memory);
2604         }
2605       } else if (proj_in->is_MemBar()) {
2606         result = proj_in->in(TypeFunc::Memory);
2607       }
2608     } else if (result->is_MergeMem()) {
2609       MergeMemNode *mmem = result->as_MergeMem();
2610       result = step_through_mergemem(mmem, alias_idx, toop);
2611       if (result == mmem->base_memory()) {
2612         // Didn't find instance memory, search through general slice recursively.
2613         result = mmem->memory_at(C->get_general_index(alias_idx));
2614         result = find_inst_mem(result, alias_idx, orig_phis);
2615         if (C->failing()) {
2616           return NULL;
2617         }
2618         mmem->set_memory_at(alias_idx, result);
2619       }
2620     } else if (result->is_Phi() &&
2621                C->get_alias_index(result->as_Phi()->adr_type()) != alias_idx) {
2622       Node *un = result->as_Phi()->unique_input(igvn);
2623       if (un != NULL) {
2624         orig_phis.append_if_missing(result->as_Phi());
2625         result = un;
2626       } else {
2627         break;
2628       }
2629     } else if (result->is_ClearArray()) {
2630       if (!ClearArrayNode::step_through(&result, (uint)toop->instance_id(), igvn)) {
2631         // Can not bypass initialization of the instance
2632         // we are looking for.
2633         break;
2634       }
2635       // Otherwise skip it (the call updated 'result' value).
2636     } else if (result->Opcode() == Op_SCMemProj) {
2637       Node* mem = result->in(0);
2638       Node* adr = NULL;
2639       if (mem->is_LoadStore()) {
2640         adr = mem->in(MemNode::Address);
2641       } else {
2642         assert(mem->Opcode() == Op_EncodeISOArray, "sanity");
2643         adr = mem->in(3); // Memory edge corresponds to destination array
2644       }
2645       const Type *at = igvn->type(adr);
2646       if (at != Type::TOP) {
2647         assert (at->isa_ptr() != NULL, "pointer type required.");
2648         int idx = C->get_alias_index(at->is_ptr());
2649         assert(idx != alias_idx, "Object is not scalar replaceable if a LoadStore node access its field");
2650         break;
2651       }
2652       result = mem->in(MemNode::Memory);
2653     }
2654   }
2655   if (result->is_Phi()) {
2656     PhiNode *mphi = result->as_Phi();
2657     assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");
2658     const TypePtr *t = mphi->adr_type();
2659     if (!is_instance) {
2660       // Push all non-instance Phis on the orig_phis worklist to update inputs
2661       // during Phase 4 if needed.
2662       orig_phis.append_if_missing(mphi);
2663     } else if (C->get_alias_index(t) != alias_idx) {
2664       // Create a new Phi with the specified alias index type.
2665       result = split_memory_phi(mphi, alias_idx, orig_phis);
2666     }
2667   }
2668   // the result is either MemNode, PhiNode, InitializeNode.
2669   return result;
2670 }
2671 
2672 //
2673 //  Convert the types of unescaped object to instance types where possible,
2674 //  propagate the new type information through the graph, and update memory
2675 //  edges and MergeMem inputs to reflect the new type.
2676 //
2677 //  We start with allocations (and calls which may be allocations)  on alloc_worklist.
2678 //  The processing is done in 4 phases:
2679 //
2680 //  Phase 1:  Process possible allocations from alloc_worklist.  Create instance
2681 //            types for the CheckCastPP for allocations where possible.
2682 //            Propagate the the new types through users as follows:
2683 //               casts and Phi:  push users on alloc_worklist
2684 //               AddP:  cast Base and Address inputs to the instance type
2685 //                      push any AddP users on alloc_worklist and push any memnode
2686 //                      users onto memnode_worklist.
2687 //  Phase 2:  Process MemNode's from memnode_worklist. compute new address type and
2688 //            search the Memory chain for a store with the appropriate type
2689 //            address type.  If a Phi is found, create a new version with
2690 //            the appropriate memory slices from each of the Phi inputs.
2691 //            For stores, process the users as follows:
2692 //               MemNode:  push on memnode_worklist
2693 //               MergeMem: push on mergemem_worklist
2694 //  Phase 3:  Process MergeMem nodes from mergemem_worklist.  Walk each memory slice
2695 //            moving the first node encountered of each  instance type to the
2696 //            the input corresponding to its alias index.
2697 //            appropriate memory slice.
2698 //  Phase 4:  Update the inputs of non-instance memory Phis and the Memory input of memnodes.
2699 //
2700 // In the following example, the CheckCastPP nodes are the cast of allocation
2701 // results and the allocation of node 29 is unescaped and eligible to be an
2702 // instance type.
2703 //
2704 // We start with:
2705 //
2706 //     7 Parm #memory
2707 //    10  ConI  "12"
2708 //    19  CheckCastPP   "Foo"
2709 //    20  AddP  _ 19 19 10  Foo+12  alias_index=4
2710 //    29  CheckCastPP   "Foo"
2711 //    30  AddP  _ 29 29 10  Foo+12  alias_index=4
2712 //
2713 //    40  StoreP  25   7  20   ... alias_index=4
2714 //    50  StoreP  35  40  30   ... alias_index=4
2715 //    60  StoreP  45  50  20   ... alias_index=4
2716 //    70  LoadP    _  60  30   ... alias_index=4
2717 //    80  Phi     75  50  60   Memory alias_index=4
2718 //    90  LoadP    _  80  30   ... alias_index=4
2719 //   100  LoadP    _  80  20   ... alias_index=4
2720 //
2721 //
2722 // Phase 1 creates an instance type for node 29 assigning it an instance id of 24
2723 // and creating a new alias index for node 30.  This gives:
2724 //
2725 //     7 Parm #memory
2726 //    10  ConI  "12"
2727 //    19  CheckCastPP   "Foo"
2728 //    20  AddP  _ 19 19 10  Foo+12  alias_index=4
2729 //    29  CheckCastPP   "Foo"  iid=24
2730 //    30  AddP  _ 29 29 10  Foo+12  alias_index=6  iid=24
2731 //
2732 //    40  StoreP  25   7  20   ... alias_index=4
2733 //    50  StoreP  35  40  30   ... alias_index=6
2734 //    60  StoreP  45  50  20   ... alias_index=4
2735 //    70  LoadP    _  60  30   ... alias_index=6
2736 //    80  Phi     75  50  60   Memory alias_index=4
2737 //    90  LoadP    _  80  30   ... alias_index=6
2738 //   100  LoadP    _  80  20   ... alias_index=4
2739 //
2740 // In phase 2, new memory inputs are computed for the loads and stores,
2741 // And a new version of the phi is created.  In phase 4, the inputs to
2742 // node 80 are updated and then the memory nodes are updated with the
2743 // values computed in phase 2.  This results in:
2744 //
2745 //     7 Parm #memory
2746 //    10  ConI  "12"
2747 //    19  CheckCastPP   "Foo"
2748 //    20  AddP  _ 19 19 10  Foo+12  alias_index=4
2749 //    29  CheckCastPP   "Foo"  iid=24
2750 //    30  AddP  _ 29 29 10  Foo+12  alias_index=6  iid=24
2751 //
2752 //    40  StoreP  25  7   20   ... alias_index=4
2753 //    50  StoreP  35  7   30   ... alias_index=6
2754 //    60  StoreP  45  40  20   ... alias_index=4
2755 //    70  LoadP    _  50  30   ... alias_index=6
2756 //    80  Phi     75  40  60   Memory alias_index=4
2757 //   120  Phi     75  50  50   Memory alias_index=6
2758 //    90  LoadP    _ 120  30   ... alias_index=6
2759 //   100  LoadP    _  80  20   ... alias_index=4
2760 //
2761 void ConnectionGraph::split_unique_types(GrowableArray<Node *>  &alloc_worklist) {
2762   GrowableArray<Node *>  memnode_worklist;
2763   GrowableArray<PhiNode *>  orig_phis;
2764   PhaseIterGVN  *igvn = _igvn;
2765   uint new_index_start = (uint) _compile->num_alias_types();
2766   Arena* arena = Thread::current()->resource_area();
2767   VectorSet visited(arena);
2768   ideal_nodes.clear(); // Reset for use with set_map/get_map.
2769   uint unique_old = _compile->unique();
2770 
2771   //  Phase 1:  Process possible allocations from alloc_worklist.
2772   //  Create instance types for the CheckCastPP for allocations where possible.
2773   //
2774   // (Note: don't forget to change the order of the second AddP node on
2775   //  the alloc_worklist if the order of the worklist processing is changed,
2776   //  see the comment in find_second_addp().)
2777   //
2778   while (alloc_worklist.length() != 0) {
2779     Node *n = alloc_worklist.pop();
2780     uint ni = n->_idx;
2781     if (n->is_Call()) {
2782       CallNode *alloc = n->as_Call();
2783       // copy escape information to call node
2784       PointsToNode* ptn = ptnode_adr(alloc->_idx);
2785       PointsToNode::EscapeState es = ptn->escape_state();
2786       // We have an allocation or call which returns a Java object,
2787       // see if it is unescaped.
2788       if (es != PointsToNode::NoEscape || !ptn->scalar_replaceable())
2789         continue;
2790       // Find CheckCastPP for the allocate or for the return value of a call
2791       n = alloc->result_cast();
2792       if (n == NULL) {            // No uses except Initialize node
2793         if (alloc->is_Allocate()) {
2794           // Set the scalar_replaceable flag for allocation
2795           // so it could be eliminated if it has no uses.
2796           alloc->as_Allocate()->_is_scalar_replaceable = true;
2797         }
2798         if (alloc->is_CallStaticJava()) {
2799           // Set the scalar_replaceable flag for boxing method
2800           // so it could be eliminated if it has no uses.
2801           alloc->as_CallStaticJava()->_is_scalar_replaceable = true;
2802         }
2803         continue;
2804       }
2805       if (!n->is_CheckCastPP()) { // not unique CheckCastPP.
2806         assert(!alloc->is_Allocate(), "allocation should have unique type");
2807         continue;
2808       }
2809 
2810       // The inline code for Object.clone() casts the allocation result to
2811       // java.lang.Object and then to the actual type of the allocated
2812       // object. Detect this case and use the second cast.
2813       // Also detect j.l.reflect.Array.newInstance(jobject, jint) case when
2814       // the allocation result is cast to java.lang.Object and then
2815       // to the actual Array type.
2816       if (alloc->is_Allocate() && n->as_Type()->type() == TypeInstPtr::NOTNULL
2817           && (alloc->is_AllocateArray() ||
2818               igvn->type(alloc->in(AllocateNode::KlassNode)) != TypeKlassPtr::OBJECT)) {
2819         Node *cast2 = NULL;
2820         for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
2821           Node *use = n->fast_out(i);
2822           if (use->is_CheckCastPP()) {
2823             cast2 = use;
2824             break;
2825           }
2826         }
2827         if (cast2 != NULL) {
2828           n = cast2;
2829         } else {
2830           // Non-scalar replaceable if the allocation type is unknown statically
2831           // (reflection allocation), the object can't be restored during
2832           // deoptimization without precise type.
2833           continue;
2834         }
2835       }
2836       if (alloc->is_Allocate()) {
2837         // Set the scalar_replaceable flag for allocation
2838         // so it could be eliminated.
2839         alloc->as_Allocate()->_is_scalar_replaceable = true;
2840       }
2841       if (alloc->is_CallStaticJava()) {
2842         // Set the scalar_replaceable flag for boxing method
2843         // so it could be eliminated.
2844         alloc->as_CallStaticJava()->_is_scalar_replaceable = true;
2845       }
2846       set_escape_state(ptnode_adr(n->_idx), es); // CheckCastPP escape state
2847       // in order for an object to be scalar-replaceable, it must be:
2848       //   - a direct allocation (not a call returning an object)
2849       //   - non-escaping
2850       //   - eligible to be a unique type
2851       //   - not determined to be ineligible by escape analysis
2852       set_map(alloc, n);
2853       set_map(n, alloc);
2854       const TypeOopPtr *t = igvn->type(n)->isa_oopptr();
2855       if (t == NULL)
2856         continue;  // not a TypeOopPtr
2857       const TypeOopPtr* tinst = t->cast_to_exactness(true)->is_oopptr()->cast_to_instance_id(ni);
2858       igvn->hash_delete(n);
2859       igvn->set_type(n,  tinst);
2860       n->raise_bottom_type(tinst);
2861       igvn->hash_insert(n);
2862       record_for_optimizer(n);
2863       if (alloc->is_Allocate() && (t->isa_instptr() || t->isa_aryptr())) {
2864 
2865         // First, put on the worklist all Field edges from Connection Graph
2866         // which is more accurate then putting immediate users from Ideal Graph.
2867         for (EdgeIterator e(ptn); e.has_next(); e.next()) {
2868           PointsToNode* tgt = e.get();
2869           Node* use = tgt->ideal_node();
2870           assert(tgt->is_Field() && use->is_AddP(),
2871                  "only AddP nodes are Field edges in CG");
2872           if (use->outcnt() > 0) { // Don't process dead nodes
2873             Node* addp2 = find_second_addp(use, use->in(AddPNode::Base));
2874             if (addp2 != NULL) {
2875               assert(alloc->is_AllocateArray(),"array allocation was expected");
2876               alloc_worklist.append_if_missing(addp2);
2877             }
2878             alloc_worklist.append_if_missing(use);
2879           }
2880         }
2881 
2882         // An allocation may have an Initialize which has raw stores. Scan
2883         // the users of the raw allocation result and push AddP users
2884         // on alloc_worklist.
2885         Node *raw_result = alloc->proj_out(TypeFunc::Parms);
2886         assert (raw_result != NULL, "must have an allocation result");
2887         for (DUIterator_Fast imax, i = raw_result->fast_outs(imax); i < imax; i++) {
2888           Node *use = raw_result->fast_out(i);
2889           if (use->is_AddP() && use->outcnt() > 0) { // Don't process dead nodes
2890             Node* addp2 = find_second_addp(use, raw_result);
2891             if (addp2 != NULL) {
2892               assert(alloc->is_AllocateArray(),"array allocation was expected");
2893               alloc_worklist.append_if_missing(addp2);
2894             }
2895             alloc_worklist.append_if_missing(use);
2896           } else if (use->is_MemBar()) {
2897             memnode_worklist.append_if_missing(use);
2898           }
2899         }
2900       }
2901     } else if (n->is_AddP()) {
2902       JavaObjectNode* jobj = unique_java_object(get_addp_base(n));
2903       if (jobj == NULL || jobj == phantom_obj) {
2904 #ifdef ASSERT
2905         ptnode_adr(get_addp_base(n)->_idx)->dump();
2906         ptnode_adr(n->_idx)->dump();
2907         assert(jobj != NULL && jobj != phantom_obj, "escaped allocation");
2908 #endif
2909         _compile->record_failure(C2Compiler::retry_no_escape_analysis());
2910         return;
2911       }
2912       Node *base = get_map(jobj->idx());  // CheckCastPP node
2913       if (!split_AddP(n, base)) continue; // wrong type from dead path
2914     } else if (n->is_Phi() ||
2915                n->is_CheckCastPP() ||
2916                n->is_EncodeP() ||
2917                n->is_DecodeN() ||
2918                (n->is_ConstraintCast() && n->Opcode() == Op_CastPP)) {
2919       if (visited.test_set(n->_idx)) {
2920         assert(n->is_Phi(), "loops only through Phi's");
2921         continue;  // already processed
2922       }
2923       JavaObjectNode* jobj = unique_java_object(n);
2924       if (jobj == NULL || jobj == phantom_obj) {
2925 #ifdef ASSERT
2926         ptnode_adr(n->_idx)->dump();
2927         assert(jobj != NULL && jobj != phantom_obj, "escaped allocation");
2928 #endif
2929         _compile->record_failure(C2Compiler::retry_no_escape_analysis());
2930         return;
2931       } else {
2932         Node *val = get_map(jobj->idx());   // CheckCastPP node
2933         TypeNode *tn = n->as_Type();
2934         const TypeOopPtr* tinst = igvn->type(val)->isa_oopptr();
2935         assert(tinst != NULL && tinst->is_known_instance() &&
2936                tinst->instance_id() == jobj->idx() , "instance type expected.");
2937 
2938         const Type *tn_type = igvn->type(tn);
2939         const TypeOopPtr *tn_t;
2940         if (tn_type->isa_narrowoop()) {
2941           tn_t = tn_type->make_ptr()->isa_oopptr();
2942         } else {
2943           tn_t = tn_type->isa_oopptr();
2944         }
2945         if (tn_t != NULL && tinst->klass()->is_subtype_of(tn_t->klass())) {
2946           if (tn_type->isa_narrowoop()) {
2947             tn_type = tinst->make_narrowoop();
2948           } else {
2949             tn_type = tinst;
2950           }
2951           igvn->hash_delete(tn);
2952           igvn->set_type(tn, tn_type);
2953           tn->set_type(tn_type);
2954           igvn->hash_insert(tn);
2955           record_for_optimizer(n);
2956         } else {
2957           assert(tn_type == TypePtr::NULL_PTR ||
2958                  tn_t != NULL && !tinst->klass()->is_subtype_of(tn_t->klass()),
2959                  "unexpected type");
2960           continue; // Skip dead path with different type
2961         }
2962       }
2963     } else {
2964       debug_only(n->dump();)
2965       assert(false, "EA: unexpected node");
2966       continue;
2967     }
2968     // push allocation's users on appropriate worklist
2969     for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
2970       Node *use = n->fast_out(i);
2971       if(use->is_Mem() && use->in(MemNode::Address) == n) {
2972         // Load/store to instance's field
2973         memnode_worklist.append_if_missing(use);
2974       } else if (use->is_MemBar()) {
2975         if (use->in(TypeFunc::Memory) == n) { // Ignore precedent edge
2976           memnode_worklist.append_if_missing(use);
2977         }
2978       } else if (use->is_AddP() && use->outcnt() > 0) { // No dead nodes
2979         Node* addp2 = find_second_addp(use, n);
2980         if (addp2 != NULL) {
2981           alloc_worklist.append_if_missing(addp2);
2982         }
2983         alloc_worklist.append_if_missing(use);
2984       } else if (use->is_Phi() ||
2985                  use->is_CheckCastPP() ||
2986                  use->is_EncodeNarrowPtr() ||
2987                  use->is_DecodeNarrowPtr() ||
2988                  (use->is_ConstraintCast() && use->Opcode() == Op_CastPP)) {
2989         alloc_worklist.append_if_missing(use);
2990 #ifdef ASSERT
2991       } else if (use->is_Mem()) {
2992         assert(use->in(MemNode::Address) != n, "EA: missing allocation reference path");
2993       } else if (use->is_MergeMem()) {
2994         assert(_mergemem_worklist.contains(use->as_MergeMem()), "EA: missing MergeMem node in the worklist");
2995       } else if (use->is_SafePoint()) {
2996         // Look for MergeMem nodes for calls which reference unique allocation
2997         // (through CheckCastPP nodes) even for debug info.
2998         Node* m = use->in(TypeFunc::Memory);
2999         if (m->is_MergeMem()) {
3000           assert(_mergemem_worklist.contains(m->as_MergeMem()), "EA: missing MergeMem node in the worklist");
3001         }
3002       } else if (use->Opcode() == Op_EncodeISOArray) {
3003         if (use->in(MemNode::Memory) == n || use->in(3) == n) {
3004           // EncodeISOArray overwrites destination array
3005           memnode_worklist.append_if_missing(use);
3006         }
3007       } else {
3008         uint op = use->Opcode();
3009         if (!(op == Op_CmpP || op == Op_Conv2B ||
3010               op == Op_CastP2X || op == Op_StoreCM ||
3011               op == Op_FastLock || op == Op_AryEq || op == Op_StrComp ||
3012               op == Op_StrEquals || op == Op_StrIndexOf)) {
3013           n->dump();
3014           use->dump();
3015           assert(false, "EA: missing allocation reference path");
3016         }
3017 #endif
3018       }
3019     }
3020 
3021   }
3022   // New alias types were created in split_AddP().
3023   uint new_index_end = (uint) _compile->num_alias_types();
3024   assert(unique_old == _compile->unique(), "there should be no new ideal nodes after Phase 1");
3025 
3026   //  Phase 2:  Process MemNode's from memnode_worklist. compute new address type and
3027   //            compute new values for Memory inputs  (the Memory inputs are not
3028   //            actually updated until phase 4.)
3029   if (memnode_worklist.length() == 0)
3030     return;  // nothing to do
3031   while (memnode_worklist.length() != 0) {
3032     Node *n = memnode_worklist.pop();
3033     if (visited.test_set(n->_idx))
3034       continue;
3035     if (n->is_Phi() || n->is_ClearArray()) {
3036       // we don't need to do anything, but the users must be pushed
3037     } else if (n->is_MemBar()) { // Initialize, MemBar nodes
3038       // we don't need to do anything, but the users must be pushed
3039       n = n->as_MemBar()->proj_out(TypeFunc::Memory);
3040       if (n == NULL)
3041         continue;
3042     } else if (n->Opcode() == Op_EncodeISOArray) {
3043       // get the memory projection
3044       for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
3045         Node *use = n->fast_out(i);
3046         if (use->Opcode() == Op_SCMemProj) {
3047           n = use;
3048           break;
3049         }
3050       }
3051       assert(n->Opcode() == Op_SCMemProj, "memory projection required");
3052     } else {
3053       assert(n->is_Mem(), "memory node required.");
3054       Node *addr = n->in(MemNode::Address);
3055       const Type *addr_t = igvn->type(addr);
3056       if (addr_t == Type::TOP)
3057         continue;
3058       assert (addr_t->isa_ptr() != NULL, "pointer type required.");
3059       int alias_idx = _compile->get_alias_index(addr_t->is_ptr());
3060       assert ((uint)alias_idx < new_index_end, "wrong alias index");
3061       Node *mem = find_inst_mem(n->in(MemNode::Memory), alias_idx, orig_phis);
3062       if (_compile->failing()) {
3063         return;
3064       }
3065       if (mem != n->in(MemNode::Memory)) {
3066         // We delay the memory edge update since we need old one in
3067         // MergeMem code below when instances memory slices are separated.
3068         set_map(n, mem);
3069       }
3070       if (n->is_Load()) {
3071         continue;  // don't push users
3072       } else if (n->is_LoadStore()) {
3073         // get the memory projection
3074         for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
3075           Node *use = n->fast_out(i);
3076           if (use->Opcode() == Op_SCMemProj) {
3077             n = use;
3078             break;
3079           }
3080         }
3081         assert(n->Opcode() == Op_SCMemProj, "memory projection required");
3082       }
3083     }
3084     // push user on appropriate worklist
3085     for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
3086       Node *use = n->fast_out(i);
3087       if (use->is_Phi() || use->is_ClearArray()) {
3088         memnode_worklist.append_if_missing(use);
3089       } else if (use->is_Mem() && use->in(MemNode::Memory) == n) {
3090         if (use->Opcode() == Op_StoreCM) // Ignore cardmark stores
3091           continue;
3092         memnode_worklist.append_if_missing(use);
3093       } else if (use->is_MemBar()) {
3094         if (use->in(TypeFunc::Memory) == n) { // Ignore precedent edge
3095           memnode_worklist.append_if_missing(use);
3096         }
3097 #ifdef ASSERT
3098       } else if(use->is_Mem()) {
3099         assert(use->in(MemNode::Memory) != n, "EA: missing memory path");
3100       } else if (use->is_MergeMem()) {
3101         assert(_mergemem_worklist.contains(use->as_MergeMem()), "EA: missing MergeMem node in the worklist");
3102       } else if (use->Opcode() == Op_EncodeISOArray) {
3103         if (use->in(MemNode::Memory) == n || use->in(3) == n) {
3104           // EncodeISOArray overwrites destination array
3105           memnode_worklist.append_if_missing(use);
3106         }
3107       } else {
3108         uint op = use->Opcode();
3109         if (!(op == Op_StoreCM ||
3110               (op == Op_CallLeaf && use->as_CallLeaf()->_name != NULL &&
3111                strcmp(use->as_CallLeaf()->_name, "g1_wb_pre") == 0) ||
3112               op == Op_AryEq || op == Op_StrComp ||
3113               op == Op_StrEquals || op == Op_StrIndexOf)) {
3114           n->dump();
3115           use->dump();
3116           assert(false, "EA: missing memory path");
3117         }
3118 #endif
3119       }
3120     }
3121   }
3122 
3123   //  Phase 3:  Process MergeMem nodes from mergemem_worklist.
3124   //            Walk each memory slice moving the first node encountered of each
3125   //            instance type to the the input corresponding to its alias index.
3126   uint length = _mergemem_worklist.length();
3127   for( uint next = 0; next < length; ++next ) {
3128     MergeMemNode* nmm = _mergemem_worklist.at(next);
3129     assert(!visited.test_set(nmm->_idx), "should not be visited before");
3130     // Note: we don't want to use MergeMemStream here because we only want to
3131     // scan inputs which exist at the start, not ones we add during processing.
3132     // Note 2: MergeMem may already contains instance memory slices added
3133     // during find_inst_mem() call when memory nodes were processed above.
3134     igvn->hash_delete(nmm);
3135     uint nslices = nmm->req();
3136     for (uint i = Compile::AliasIdxRaw+1; i < nslices; i++) {
3137       Node* mem = nmm->in(i);
3138       Node* cur = NULL;
3139       if (mem == NULL || mem->is_top())
3140         continue;
3141       // First, update mergemem by moving memory nodes to corresponding slices
3142       // if their type became more precise since this mergemem was created.
3143       while (mem->is_Mem()) {
3144         const Type *at = igvn->type(mem->in(MemNode::Address));
3145         if (at != Type::TOP) {
3146           assert (at->isa_ptr() != NULL, "pointer type required.");
3147           uint idx = (uint)_compile->get_alias_index(at->is_ptr());
3148           if (idx == i) {
3149             if (cur == NULL)
3150               cur = mem;
3151           } else {
3152             if (idx >= nmm->req() || nmm->is_empty_memory(nmm->in(idx))) {
3153               nmm->set_memory_at(idx, mem);
3154             }
3155           }
3156         }
3157         mem = mem->in(MemNode::Memory);
3158       }
3159       nmm->set_memory_at(i, (cur != NULL) ? cur : mem);
3160       // Find any instance of the current type if we haven't encountered
3161       // already a memory slice of the instance along the memory chain.
3162       for (uint ni = new_index_start; ni < new_index_end; ni++) {
3163         if((uint)_compile->get_general_index(ni) == i) {
3164           Node *m = (ni >= nmm->req()) ? nmm->empty_memory() : nmm->in(ni);
3165           if (nmm->is_empty_memory(m)) {
3166             Node* result = find_inst_mem(mem, ni, orig_phis);
3167             if (_compile->failing()) {
3168               return;
3169             }
3170             nmm->set_memory_at(ni, result);
3171           }
3172         }
3173       }
3174     }
3175     // Find the rest of instances values
3176     for (uint ni = new_index_start; ni < new_index_end; ni++) {
3177       const TypeOopPtr *tinst = _compile->get_adr_type(ni)->isa_oopptr();
3178       Node* result = step_through_mergemem(nmm, ni, tinst);
3179       if (result == nmm->base_memory()) {
3180         // Didn't find instance memory, search through general slice recursively.
3181         result = nmm->memory_at(_compile->get_general_index(ni));
3182         result = find_inst_mem(result, ni, orig_phis);
3183         if (_compile->failing()) {
3184           return;
3185         }
3186         nmm->set_memory_at(ni, result);
3187       }
3188     }
3189     igvn->hash_insert(nmm);
3190     record_for_optimizer(nmm);
3191   }
3192 
3193   //  Phase 4:  Update the inputs of non-instance memory Phis and
3194   //            the Memory input of memnodes
3195   // First update the inputs of any non-instance Phi's from
3196   // which we split out an instance Phi.  Note we don't have
3197   // to recursively process Phi's encounted on the input memory
3198   // chains as is done in split_memory_phi() since they  will
3199   // also be processed here.
3200   for (int j = 0; j < orig_phis.length(); j++) {
3201     PhiNode *phi = orig_phis.at(j);
3202     int alias_idx = _compile->get_alias_index(phi->adr_type());
3203     igvn->hash_delete(phi);
3204     for (uint i = 1; i < phi->req(); i++) {
3205       Node *mem = phi->in(i);
3206       Node *new_mem = find_inst_mem(mem, alias_idx, orig_phis);
3207       if (_compile->failing()) {
3208         return;
3209       }
3210       if (mem != new_mem) {
3211         phi->set_req(i, new_mem);
3212       }
3213     }
3214     igvn->hash_insert(phi);
3215     record_for_optimizer(phi);
3216   }
3217 
3218   // Update the memory inputs of MemNodes with the value we computed
3219   // in Phase 2 and move stores memory users to corresponding memory slices.
3220   // Disable memory split verification code until the fix for 6984348.
3221   // Currently it produces false negative results since it does not cover all cases.
3222 #if 0 // ifdef ASSERT
3223   visited.Reset();
3224   Node_Stack old_mems(arena, _compile->unique() >> 2);
3225 #endif
3226   for (uint i = 0; i < ideal_nodes.size(); i++) {
3227     Node*    n = ideal_nodes.at(i);
3228     Node* nmem = get_map(n->_idx);
3229     assert(nmem != NULL, "sanity");
3230     if (n->is_Mem()) {
3231 #if 0 // ifdef ASSERT
3232       Node* old_mem = n->in(MemNode::Memory);
3233       if (!visited.test_set(old_mem->_idx)) {
3234         old_mems.push(old_mem, old_mem->outcnt());
3235       }
3236 #endif
3237       assert(n->in(MemNode::Memory) != nmem, "sanity");
3238       if (!n->is_Load()) {
3239         // Move memory users of a store first.
3240         move_inst_mem(n, orig_phis);
3241       }
3242       // Now update memory input
3243       igvn->hash_delete(n);
3244       n->set_req(MemNode::Memory, nmem);
3245       igvn->hash_insert(n);
3246       record_for_optimizer(n);
3247     } else {
3248       assert(n->is_Allocate() || n->is_CheckCastPP() ||
3249              n->is_AddP() || n->is_Phi(), "unknown node used for set_map()");
3250     }
3251   }
3252 #if 0 // ifdef ASSERT
3253   // Verify that memory was split correctly
3254   while (old_mems.is_nonempty()) {
3255     Node* old_mem = old_mems.node();
3256     uint  old_cnt = old_mems.index();
3257     old_mems.pop();
3258     assert(old_cnt == old_mem->outcnt(), "old mem could be lost");
3259   }
3260 #endif
3261 }
3262 
3263 #ifndef PRODUCT
3264 static const char *node_type_names[] = {
3265   "UnknownType",
3266   "JavaObject",
3267   "LocalVar",
3268   "Field",
3269   "Arraycopy"
3270 };
3271 
3272 static const char *esc_names[] = {
3273   "UnknownEscape",
3274   "NoEscape",
3275   "ArgEscape",
3276   "GlobalEscape"
3277 };
3278 
3279 void PointsToNode::dump(bool print_state) const {
3280   NodeType nt = node_type();
3281   tty->print("%s ", node_type_names[(int) nt]);
3282   if (print_state) {
3283     EscapeState es = escape_state();
3284     EscapeState fields_es = fields_escape_state();
3285     tty->print("%s(%s) ", esc_names[(int)es], esc_names[(int)fields_es]);
3286     if (nt == PointsToNode::JavaObject && !this->scalar_replaceable())
3287       tty->print("NSR ");
3288   }
3289   if (is_Field()) {
3290     FieldNode* f = (FieldNode*)this;
3291     if (f->is_oop())
3292       tty->print("oop ");
3293     if (f->offset() > 0)
3294       tty->print("+%d ", f->offset());
3295     tty->print("(");
3296     for (BaseIterator i(f); i.has_next(); i.next()) {
3297       PointsToNode* b = i.get();
3298       tty->print(" %d%s", b->idx(),(b->is_JavaObject() ? "P" : ""));
3299     }
3300     tty->print(" )");
3301   }
3302   tty->print("[");
3303   for (EdgeIterator i(this); i.has_next(); i.next()) {
3304     PointsToNode* e = i.get();
3305     tty->print(" %d%s%s", e->idx(),(e->is_JavaObject() ? "P" : (e->is_Field() ? "F" : "")), e->is_Arraycopy() ? "cp" : "");
3306   }
3307   tty->print(" [");
3308   for (UseIterator i(this); i.has_next(); i.next()) {
3309     PointsToNode* u = i.get();
3310     bool is_base = false;
3311     if (PointsToNode::is_base_use(u)) {
3312       is_base = true;
3313       u = PointsToNode::get_use_node(u)->as_Field();
3314     }
3315     tty->print(" %d%s%s", u->idx(), is_base ? "b" : "", u->is_Arraycopy() ? "cp" : "");
3316   }
3317   tty->print(" ]]  ");
3318   if (_node == NULL)
3319     tty->print_cr("<null>");
3320   else
3321     _node->dump();
3322 }
3323 
3324 void ConnectionGraph::dump(GrowableArray<PointsToNode*>& ptnodes_worklist) {
3325   bool first = true;
3326   int ptnodes_length = ptnodes_worklist.length();
3327   for (int i = 0; i < ptnodes_length; i++) {
3328     PointsToNode *ptn = ptnodes_worklist.at(i);
3329     if (ptn == NULL || !ptn->is_JavaObject())
3330       continue;
3331     PointsToNode::EscapeState es = ptn->escape_state();
3332     if ((es != PointsToNode::NoEscape) && !Verbose) {
3333       continue;
3334     }
3335     Node* n = ptn->ideal_node();
3336     if (n->is_Allocate() || (n->is_CallStaticJava() &&
3337                              n->as_CallStaticJava()->is_boxing_method())) {
3338       if (first) {
3339         tty->cr();
3340         tty->print("======== Connection graph for ");
3341         _compile->method()->print_short_name();
3342         tty->cr();
3343         first = false;
3344       }
3345       ptn->dump();
3346       // Print all locals and fields which reference this allocation
3347       for (UseIterator j(ptn); j.has_next(); j.next()) {
3348         PointsToNode* use = j.get();
3349         if (use->is_LocalVar()) {
3350           use->dump(Verbose);
3351         } else if (Verbose) {
3352           use->dump();
3353         }
3354       }
3355       tty->cr();
3356     }
3357   }
3358 }
3359 #endif