Mercurial > hg > truffle
annotate src/share/vm/opto/parse1.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | 9dc311b8473e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1377
diff
changeset
|
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1377
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1377
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1377
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "compiler/compileLog.hpp" | |
| 27 #include "interpreter/linkResolver.hpp" | |
| 28 #include "oops/methodOop.hpp" | |
| 29 #include "opto/addnode.hpp" | |
| 30 #include "opto/idealGraphPrinter.hpp" | |
| 31 #include "opto/locknode.hpp" | |
| 32 #include "opto/memnode.hpp" | |
| 33 #include "opto/parse.hpp" | |
| 34 #include "opto/rootnode.hpp" | |
| 35 #include "opto/runtime.hpp" | |
| 36 #include "runtime/arguments.hpp" | |
| 37 #include "runtime/handles.inline.hpp" | |
| 38 #include "runtime/sharedRuntime.hpp" | |
| 39 #include "utilities/copy.hpp" | |
| 0 | 40 |
| 41 // Static array so we can figure out which bytecodes stop us from compiling | |
| 42 // the most. Some of the non-static variables are needed in bytecodeInfo.cpp | |
| 43 // and eventually should be encapsulated in a proper class (gri 8/18/98). | |
| 44 | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
45 int nodes_created = 0; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
46 int methods_parsed = 0; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
47 int methods_seen = 0; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
48 int blocks_parsed = 0; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
49 int blocks_seen = 0; |
| 0 | 50 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
51 int explicit_null_checks_inserted = 0; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
52 int explicit_null_checks_elided = 0; |
| 0 | 53 int all_null_checks_found = 0, implicit_null_checks = 0; |
| 54 int implicit_null_throws = 0; | |
| 55 | |
| 56 int reclaim_idx = 0; | |
| 57 int reclaim_in = 0; | |
| 58 int reclaim_node = 0; | |
| 59 | |
| 60 #ifndef PRODUCT | |
| 61 bool Parse::BytecodeParseHistogram::_initialized = false; | |
| 62 uint Parse::BytecodeParseHistogram::_bytecodes_parsed [Bytecodes::number_of_codes]; | |
| 63 uint Parse::BytecodeParseHistogram::_nodes_constructed[Bytecodes::number_of_codes]; | |
| 64 uint Parse::BytecodeParseHistogram::_nodes_transformed[Bytecodes::number_of_codes]; | |
| 65 uint Parse::BytecodeParseHistogram::_new_values [Bytecodes::number_of_codes]; | |
| 66 #endif | |
| 67 | |
| 68 //------------------------------print_statistics------------------------------- | |
| 69 #ifndef PRODUCT | |
| 70 void Parse::print_statistics() { | |
| 71 tty->print_cr("--- Compiler Statistics ---"); | |
| 72 tty->print("Methods seen: %d Methods parsed: %d", methods_seen, methods_parsed); | |
| 73 tty->print(" Nodes created: %d", nodes_created); | |
| 74 tty->cr(); | |
| 75 if (methods_seen != methods_parsed) | |
| 76 tty->print_cr("Reasons for parse failures (NOT cumulative):"); | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
77 tty->print_cr("Blocks parsed: %d Blocks seen: %d", blocks_parsed, blocks_seen); |
| 0 | 78 |
| 79 if( explicit_null_checks_inserted ) | |
| 80 tty->print_cr("%d original NULL checks - %d elided (%2d%%); optimizer leaves %d,", explicit_null_checks_inserted, explicit_null_checks_elided, (100*explicit_null_checks_elided)/explicit_null_checks_inserted, all_null_checks_found); | |
| 81 if( all_null_checks_found ) | |
| 82 tty->print_cr("%d made implicit (%2d%%)", implicit_null_checks, | |
| 83 (100*implicit_null_checks)/all_null_checks_found); | |
| 84 if( implicit_null_throws ) | |
| 85 tty->print_cr("%d implicit null exceptions at runtime", | |
| 86 implicit_null_throws); | |
| 87 | |
| 88 if( PrintParseStatistics && BytecodeParseHistogram::initialized() ) { | |
| 89 BytecodeParseHistogram::print(); | |
| 90 } | |
| 91 } | |
| 92 #endif | |
| 93 | |
| 94 //------------------------------ON STACK REPLACEMENT--------------------------- | |
| 95 | |
| 96 // Construct a node which can be used to get incoming state for | |
| 97 // on stack replacement. | |
| 98 Node *Parse::fetch_interpreter_state(int index, | |
| 99 BasicType bt, | |
| 100 Node *local_addrs, | |
| 101 Node *local_addrs_base) { | |
| 102 Node *mem = memory(Compile::AliasIdxRaw); | |
| 103 Node *adr = basic_plus_adr( local_addrs_base, local_addrs, -index*wordSize ); | |
| 1609 | 104 Node *ctl = control(); |
| 0 | 105 |
| 106 // Very similar to LoadNode::make, except we handle un-aligned longs and | |
| 107 // doubles on Sparc. Intel can handle them just fine directly. | |
| 108 Node *l; | |
| 109 switch( bt ) { // Signature is flattened | |
| 1609 | 110 case T_INT: l = new (C, 3) LoadINode( ctl, mem, adr, TypeRawPtr::BOTTOM ); break; |
| 111 case T_FLOAT: l = new (C, 3) LoadFNode( ctl, mem, adr, TypeRawPtr::BOTTOM ); break; | |
| 112 case T_ADDRESS: l = new (C, 3) LoadPNode( ctl, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM ); break; | |
| 113 case T_OBJECT: l = new (C, 3) LoadPNode( ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInstPtr::BOTTOM ); break; | |
| 0 | 114 case T_LONG: |
| 115 case T_DOUBLE: { | |
| 116 // Since arguments are in reverse order, the argument address 'adr' | |
| 117 // refers to the back half of the long/double. Recompute adr. | |
| 118 adr = basic_plus_adr( local_addrs_base, local_addrs, -(index+1)*wordSize ); | |
| 119 if( Matcher::misaligned_doubles_ok ) { | |
| 120 l = (bt == T_DOUBLE) | |
| 1609 | 121 ? (Node*)new (C, 3) LoadDNode( ctl, mem, adr, TypeRawPtr::BOTTOM ) |
| 122 : (Node*)new (C, 3) LoadLNode( ctl, mem, adr, TypeRawPtr::BOTTOM ); | |
| 0 | 123 } else { |
| 124 l = (bt == T_DOUBLE) | |
| 1609 | 125 ? (Node*)new (C, 3) LoadD_unalignedNode( ctl, mem, adr, TypeRawPtr::BOTTOM ) |
| 126 : (Node*)new (C, 3) LoadL_unalignedNode( ctl, mem, adr, TypeRawPtr::BOTTOM ); | |
| 0 | 127 } |
| 128 break; | |
| 129 } | |
| 130 default: ShouldNotReachHere(); | |
| 131 } | |
| 132 return _gvn.transform(l); | |
| 133 } | |
| 134 | |
| 135 // Helper routine to prevent the interpreter from handing | |
| 136 // unexpected typestate to an OSR method. | |
| 137 // The Node l is a value newly dug out of the interpreter frame. | |
| 138 // The type is the type predicted by ciTypeFlow. Note that it is | |
| 139 // not a general type, but can only come from Type::get_typeflow_type. | |
| 140 // The safepoint is a map which will feed an uncommon trap. | |
| 141 Node* Parse::check_interpreter_type(Node* l, const Type* type, | |
| 142 SafePointNode* &bad_type_exit) { | |
| 143 | |
| 144 const TypeOopPtr* tp = type->isa_oopptr(); | |
| 145 | |
| 146 // TypeFlow may assert null-ness if a type appears unloaded. | |
| 147 if (type == TypePtr::NULL_PTR || | |
| 148 (tp != NULL && !tp->klass()->is_loaded())) { | |
| 149 // Value must be null, not a real oop. | |
| 150 Node* chk = _gvn.transform( new (C, 3) CmpPNode(l, null()) ); | |
| 151 Node* tst = _gvn.transform( new (C, 2) BoolNode(chk, BoolTest::eq) ); | |
| 152 IfNode* iff = create_and_map_if(control(), tst, PROB_MAX, COUNT_UNKNOWN); | |
| 153 set_control(_gvn.transform( new (C, 1) IfTrueNode(iff) )); | |
| 154 Node* bad_type = _gvn.transform( new (C, 1) IfFalseNode(iff) ); | |
| 155 bad_type_exit->control()->add_req(bad_type); | |
| 156 l = null(); | |
| 157 } | |
| 158 | |
| 159 // Typeflow can also cut off paths from the CFG, based on | |
| 160 // types which appear unloaded, or call sites which appear unlinked. | |
| 161 // When paths are cut off, values at later merge points can rise | |
| 162 // toward more specific classes. Make sure these specific classes | |
| 163 // are still in effect. | |
| 164 if (tp != NULL && tp->klass() != C->env()->Object_klass()) { | |
| 165 // TypeFlow asserted a specific object type. Value must have that type. | |
| 166 Node* bad_type_ctrl = NULL; | |
| 167 l = gen_checkcast(l, makecon(TypeKlassPtr::make(tp->klass())), &bad_type_ctrl); | |
| 168 bad_type_exit->control()->add_req(bad_type_ctrl); | |
| 169 } | |
| 170 | |
| 171 BasicType bt_l = _gvn.type(l)->basic_type(); | |
| 172 BasicType bt_t = type->basic_type(); | |
| 173 assert(_gvn.type(l)->higher_equal(type), "must constrain OSR typestate"); | |
| 174 return l; | |
| 175 } | |
| 176 | |
| 177 // Helper routine which sets up elements of the initial parser map when | |
| 178 // performing a parse for on stack replacement. Add values into map. | |
| 179 // The only parameter contains the address of a interpreter arguments. | |
| 180 void Parse::load_interpreter_state(Node* osr_buf) { | |
| 181 int index; | |
| 182 int max_locals = jvms()->loc_size(); | |
| 183 int max_stack = jvms()->stk_size(); | |
| 184 | |
| 185 | |
| 186 // Mismatch between method and jvms can occur since map briefly held | |
| 187 // an OSR entry state (which takes up one RawPtr word). | |
| 188 assert(max_locals == method()->max_locals(), "sanity"); | |
| 189 assert(max_stack >= method()->max_stack(), "sanity"); | |
| 190 assert((int)jvms()->endoff() == TypeFunc::Parms + max_locals + max_stack, "sanity"); | |
| 191 assert((int)jvms()->endoff() == (int)map()->req(), "sanity"); | |
| 192 | |
| 193 // Find the start block. | |
| 194 Block* osr_block = start_block(); | |
| 195 assert(osr_block->start() == osr_bci(), "sanity"); | |
| 196 | |
| 197 // Set initial BCI. | |
| 198 set_parse_bci(osr_block->start()); | |
| 199 | |
| 200 // Set initial stack depth. | |
| 201 set_sp(osr_block->start_sp()); | |
| 202 | |
| 203 // Check bailouts. We currently do not perform on stack replacement | |
| 204 // of loops in catch blocks or loops which branch with a non-empty stack. | |
| 205 if (sp() != 0) { | |
| 206 C->record_method_not_compilable("OSR starts with non-empty stack"); | |
| 207 return; | |
| 208 } | |
| 209 // Do not OSR inside finally clauses: | |
| 210 if (osr_block->has_trap_at(osr_block->start())) { | |
| 211 C->record_method_not_compilable("OSR starts with an immediate trap"); | |
| 212 return; | |
| 213 } | |
| 214 | |
| 215 // Commute monitors from interpreter frame to compiler frame. | |
| 216 assert(jvms()->monitor_depth() == 0, "should be no active locks at beginning of osr"); | |
| 217 int mcnt = osr_block->flow()->monitor_count(); | |
| 218 Node *monitors_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals+mcnt*2-1)*wordSize); | |
| 219 for (index = 0; index < mcnt; index++) { | |
| 220 // Make a BoxLockNode for the monitor. | |
| 221 Node *box = _gvn.transform(new (C, 1) BoxLockNode(next_monitor())); | |
| 222 | |
| 223 | |
| 224 // Displaced headers and locked objects are interleaved in the | |
| 225 // temp OSR buffer. We only copy the locked objects out here. | |
| 226 // Fetch the locked object from the OSR temp buffer and copy to our fastlock node. | |
| 227 Node *lock_object = fetch_interpreter_state(index*2, T_OBJECT, monitors_addr, osr_buf); | |
| 228 // Try and copy the displaced header to the BoxNode | |
| 229 Node *displaced_hdr = fetch_interpreter_state((index*2) + 1, T_ADDRESS, monitors_addr, osr_buf); | |
| 230 | |
| 231 | |
| 232 store_to_memory(control(), box, displaced_hdr, T_ADDRESS, Compile::AliasIdxRaw); | |
| 233 | |
| 234 // Build a bogus FastLockNode (no code will be generated) and push the | |
| 235 // monitor into our debug info. | |
| 236 const FastLockNode *flock = _gvn.transform(new (C, 3) FastLockNode( 0, lock_object, box ))->as_FastLock(); | |
| 237 map()->push_monitor(flock); | |
| 238 | |
| 239 // If the lock is our method synchronization lock, tuck it away in | |
| 240 // _sync_lock for return and rethrow exit paths. | |
| 241 if (index == 0 && method()->is_synchronized()) { | |
| 242 _synch_lock = flock; | |
| 243 } | |
| 244 } | |
| 245 | |
| 991 | 246 // Use the raw liveness computation to make sure that unexpected |
| 247 // values don't propagate into the OSR frame. | |
|
1070
87b2fdd4bf98
6892079: live value must not be garbage failure after fix for 6854812
never
parents:
991
diff
changeset
|
248 MethodLivenessResult live_locals = method()->liveness_at_bci(osr_bci()); |
| 0 | 249 if (!live_locals.is_valid()) { |
| 250 // Degenerate or breakpointed method. | |
| 251 C->record_method_not_compilable("OSR in empty or breakpointed method"); | |
| 252 return; | |
| 253 } | |
| 254 | |
| 255 // Extract the needed locals from the interpreter frame. | |
| 256 Node *locals_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals-1)*wordSize); | |
| 257 | |
| 258 // find all the locals that the interpreter thinks contain live oops | |
| 259 const BitMap live_oops = method()->live_local_oops_at_bci(osr_bci()); | |
| 260 for (index = 0; index < max_locals; index++) { | |
| 261 | |
| 262 if (!live_locals.at(index)) { | |
| 263 continue; | |
| 264 } | |
| 265 | |
| 266 const Type *type = osr_block->local_type_at(index); | |
| 267 | |
| 268 if (type->isa_oopptr() != NULL) { | |
| 269 | |
| 270 // 6403625: Verify that the interpreter oopMap thinks that the oop is live | |
| 271 // else we might load a stale oop if the MethodLiveness disagrees with the | |
| 272 // result of the interpreter. If the interpreter says it is dead we agree | |
| 273 // by making the value go to top. | |
| 274 // | |
| 275 | |
| 276 if (!live_oops.at(index)) { | |
| 277 if (C->log() != NULL) { | |
| 278 C->log()->elem("OSR_mismatch local_index='%d'",index); | |
| 279 } | |
| 280 set_local(index, null()); | |
| 281 // and ignore it for the loads | |
| 282 continue; | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 // Filter out TOP, HALF, and BOTTOM. (Cf. ensure_phi.) | |
| 287 if (type == Type::TOP || type == Type::HALF) { | |
| 288 continue; | |
| 289 } | |
| 290 // If the type falls to bottom, then this must be a local that | |
| 291 // is mixing ints and oops or some such. Forcing it to top | |
| 292 // makes it go dead. | |
| 293 if (type == Type::BOTTOM) { | |
| 294 continue; | |
| 295 } | |
| 296 // Construct code to access the appropriate local. | |
|
1377
ef74d6d1ac1e
6938026: C2 compiler fails in Node::rematerialize()const
never
parents:
1344
diff
changeset
|
297 BasicType bt = type->basic_type(); |
|
ef74d6d1ac1e
6938026: C2 compiler fails in Node::rematerialize()const
never
parents:
1344
diff
changeset
|
298 if (type == TypePtr::NULL_PTR) { |
|
ef74d6d1ac1e
6938026: C2 compiler fails in Node::rematerialize()const
never
parents:
1344
diff
changeset
|
299 // Ptr types are mixed together with T_ADDRESS but NULL is |
|
ef74d6d1ac1e
6938026: C2 compiler fails in Node::rematerialize()const
never
parents:
1344
diff
changeset
|
300 // really for T_OBJECT types so correct it. |
|
ef74d6d1ac1e
6938026: C2 compiler fails in Node::rematerialize()const
never
parents:
1344
diff
changeset
|
301 bt = T_OBJECT; |
|
ef74d6d1ac1e
6938026: C2 compiler fails in Node::rematerialize()const
never
parents:
1344
diff
changeset
|
302 } |
|
ef74d6d1ac1e
6938026: C2 compiler fails in Node::rematerialize()const
never
parents:
1344
diff
changeset
|
303 Node *value = fetch_interpreter_state(index, bt, locals_addr, osr_buf); |
| 0 | 304 set_local(index, value); |
| 305 } | |
| 306 | |
| 307 // Extract the needed stack entries from the interpreter frame. | |
| 308 for (index = 0; index < sp(); index++) { | |
| 309 const Type *type = osr_block->stack_type_at(index); | |
| 310 if (type != Type::TOP) { | |
| 311 // Currently the compiler bails out when attempting to on stack replace | |
| 312 // at a bci with a non-empty stack. We should not reach here. | |
| 313 ShouldNotReachHere(); | |
| 314 } | |
| 315 } | |
| 316 | |
| 317 // End the OSR migration | |
| 318 make_runtime_call(RC_LEAF, OptoRuntime::osr_end_Type(), | |
| 319 CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_end), | |
| 320 "OSR_migration_end", TypeRawPtr::BOTTOM, | |
| 321 osr_buf); | |
| 322 | |
| 323 // Now that the interpreter state is loaded, make sure it will match | |
| 324 // at execution time what the compiler is expecting now: | |
| 325 SafePointNode* bad_type_exit = clone_map(); | |
| 326 bad_type_exit->set_control(new (C, 1) RegionNode(1)); | |
| 327 | |
|
1278
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
328 assert(osr_block->flow()->jsrs()->size() == 0, "should be no jsrs live at osr point"); |
| 0 | 329 for (index = 0; index < max_locals; index++) { |
| 330 if (stopped()) break; | |
| 331 Node* l = local(index); | |
| 332 if (l->is_top()) continue; // nothing here | |
| 333 const Type *type = osr_block->local_type_at(index); | |
| 334 if (type->isa_oopptr() != NULL) { | |
| 335 if (!live_oops.at(index)) { | |
| 336 // skip type check for dead oops | |
| 337 continue; | |
| 338 } | |
| 339 } | |
|
1281
7d236a9688c5
6930398: fix for return address locals in OSR entries uses wrong test
never
parents:
1278
diff
changeset
|
340 if (osr_block->flow()->local_type_at(index)->is_return_address()) { |
|
1278
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
341 // In our current system it's illegal for jsr addresses to be |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
342 // live into an OSR entry point because the compiler performs |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
343 // inlining of jsrs. ciTypeFlow has a bailout that detect this |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
344 // case and aborts the compile if addresses are live into an OSR |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
345 // entry point. Because of that we can assume that any address |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
346 // locals at the OSR entry point are dead. Method liveness |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
347 // isn't precise enought to figure out that they are dead in all |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
348 // cases so simply skip checking address locals all |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
349 // together. Any type check is guaranteed to fail since the |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
350 // interpreter type is the result of a load which might have any |
|
da9559b49b84
6915557: assert(_gvn.type(l)->higher_equal(type),"must constrain OSR typestate") with debug build
never
parents:
1264
diff
changeset
|
351 // value and the expected type is a constant. |
|
1070
87b2fdd4bf98
6892079: live value must not be garbage failure after fix for 6854812
never
parents:
991
diff
changeset
|
352 continue; |
|
87b2fdd4bf98
6892079: live value must not be garbage failure after fix for 6854812
never
parents:
991
diff
changeset
|
353 } |
| 0 | 354 set_local(index, check_interpreter_type(l, type, bad_type_exit)); |
| 355 } | |
| 356 | |
| 357 for (index = 0; index < sp(); index++) { | |
| 358 if (stopped()) break; | |
| 359 Node* l = stack(index); | |
| 360 if (l->is_top()) continue; // nothing here | |
| 361 const Type *type = osr_block->stack_type_at(index); | |
| 362 set_stack(index, check_interpreter_type(l, type, bad_type_exit)); | |
| 363 } | |
| 364 | |
| 365 if (bad_type_exit->control()->req() > 1) { | |
| 366 // Build an uncommon trap here, if any inputs can be unexpected. | |
| 367 bad_type_exit->set_control(_gvn.transform( bad_type_exit->control() )); | |
| 368 record_for_igvn(bad_type_exit->control()); | |
| 369 SafePointNode* types_are_good = map(); | |
| 370 set_map(bad_type_exit); | |
| 371 // The unexpected type happens because a new edge is active | |
| 372 // in the CFG, which typeflow had previously ignored. | |
| 373 // E.g., Object x = coldAtFirst() && notReached()? "str": new Integer(123). | |
| 374 // This x will be typed as Integer if notReached is not yet linked. | |
| 375 uncommon_trap(Deoptimization::Reason_unreached, | |
| 376 Deoptimization::Action_reinterpret); | |
| 377 set_map(types_are_good); | |
| 378 } | |
| 379 } | |
| 380 | |
| 381 //------------------------------Parse------------------------------------------ | |
| 382 // Main parser constructor. | |
| 383 Parse::Parse(JVMState* caller, ciMethod* parse_method, float expected_uses) | |
| 384 : _exits(caller) | |
| 385 { | |
| 386 // Init some variables | |
| 387 _caller = caller; | |
| 388 _method = parse_method; | |
| 389 _expected_uses = expected_uses; | |
| 390 _depth = 1 + (caller->has_method() ? caller->depth() : 0); | |
| 391 _wrote_final = false; | |
| 392 _entry_bci = InvocationEntryBci; | |
| 393 _tf = NULL; | |
| 394 _block = NULL; | |
| 395 debug_only(_block_count = -1); | |
| 396 debug_only(_blocks = (Block*)-1); | |
| 397 #ifndef PRODUCT | |
| 398 if (PrintCompilation || PrintOpto) { | |
| 399 // Make sure I have an inline tree, so I can print messages about it. | |
| 400 JVMState* ilt_caller = is_osr_parse() ? caller->caller() : caller; | |
| 401 InlineTree::find_subtree_from_root(C->ilt(), ilt_caller, parse_method, true); | |
| 402 } | |
| 403 _max_switch_depth = 0; | |
| 404 _est_switch_depth = 0; | |
| 405 #endif | |
| 406 | |
| 407 _tf = TypeFunc::make(method()); | |
| 408 _iter.reset_to_method(method()); | |
| 409 _flow = method()->get_flow_analysis(); | |
| 410 if (_flow->failing()) { | |
| 411 C->record_method_not_compilable_all_tiers(_flow->failure_reason()); | |
| 412 } | |
| 413 | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
414 #ifndef PRODUCT |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
415 if (_flow->has_irreducible_entry()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
416 C->set_parsed_irreducible_loop(true); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
417 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
418 #endif |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
419 |
| 0 | 420 if (_expected_uses <= 0) { |
| 421 _prof_factor = 1; | |
| 422 } else { | |
| 423 float prof_total = parse_method->interpreter_invocation_count(); | |
| 424 if (prof_total <= _expected_uses) { | |
| 425 _prof_factor = 1; | |
| 426 } else { | |
| 427 _prof_factor = _expected_uses / prof_total; | |
| 428 } | |
| 429 } | |
| 430 | |
| 431 CompileLog* log = C->log(); | |
| 432 if (log != NULL) { | |
| 433 log->begin_head("parse method='%d' uses='%g'", | |
| 434 log->identify(parse_method), expected_uses); | |
| 435 if (depth() == 1 && C->is_osr_compilation()) { | |
| 436 log->print(" osr_bci='%d'", C->entry_bci()); | |
| 437 } | |
| 438 log->stamp(); | |
| 439 log->end_head(); | |
| 440 } | |
| 441 | |
| 442 // Accumulate deoptimization counts. | |
| 443 // (The range_check and store_check counts are checked elsewhere.) | |
| 444 ciMethodData* md = method()->method_data(); | |
| 445 for (uint reason = 0; reason < md->trap_reason_limit(); reason++) { | |
| 446 uint md_count = md->trap_count(reason); | |
| 447 if (md_count != 0) { | |
| 448 if (md_count == md->trap_count_limit()) | |
| 449 md_count += md->overflow_trap_count(); | |
| 450 uint total_count = C->trap_count(reason); | |
| 451 uint old_count = total_count; | |
| 452 total_count += md_count; | |
| 453 // Saturate the add if it overflows. | |
| 454 if (total_count < old_count || total_count < md_count) | |
| 455 total_count = (uint)-1; | |
| 456 C->set_trap_count(reason, total_count); | |
| 457 if (log != NULL) | |
| 458 log->elem("observe trap='%s' count='%d' total='%d'", | |
| 459 Deoptimization::trap_reason_name(reason), | |
| 460 md_count, total_count); | |
| 461 } | |
| 462 } | |
| 463 // Accumulate total sum of decompilations, also. | |
| 464 C->set_decompile_count(C->decompile_count() + md->decompile_count()); | |
| 465 | |
| 466 _count_invocations = C->do_count_invocations(); | |
| 467 _method_data_update = C->do_method_data_update(); | |
| 468 | |
| 469 if (log != NULL && method()->has_exception_handlers()) { | |
| 470 log->elem("observe that='has_exception_handlers'"); | |
| 471 } | |
| 472 | |
| 473 assert(method()->can_be_compiled(), "Can not parse this method, cutout earlier"); | |
| 474 assert(method()->has_balanced_monitors(), "Can not parse unbalanced monitors, cutout earlier"); | |
| 475 | |
| 476 // Always register dependence if JVMTI is enabled, because | |
| 477 // either breakpoint setting or hotswapping of methods may | |
| 478 // cause deoptimization. | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
479 if (C->env()->jvmti_can_hotswap_or_post_breakpoint()) { |
| 0 | 480 C->dependencies()->assert_evol_method(method()); |
| 481 } | |
| 482 | |
| 483 methods_seen++; | |
| 484 | |
| 485 // Do some special top-level things. | |
| 486 if (depth() == 1 && C->is_osr_compilation()) { | |
| 487 _entry_bci = C->entry_bci(); | |
| 488 _flow = method()->get_osr_flow_analysis(osr_bci()); | |
| 489 if (_flow->failing()) { | |
| 490 C->record_method_not_compilable(_flow->failure_reason()); | |
| 491 #ifndef PRODUCT | |
| 492 if (PrintOpto && (Verbose || WizardMode)) { | |
| 493 tty->print_cr("OSR @%d type flow bailout: %s", _entry_bci, _flow->failure_reason()); | |
| 494 if (Verbose) { | |
| 495 method()->print_oop(); | |
| 496 method()->print_codes(); | |
| 497 _flow->print(); | |
| 498 } | |
| 499 } | |
| 500 #endif | |
| 501 } | |
| 502 _tf = C->tf(); // the OSR entry type is different | |
| 503 } | |
| 504 | |
| 505 #ifdef ASSERT | |
| 506 if (depth() == 1) { | |
| 507 assert(C->is_osr_compilation() == this->is_osr_parse(), "OSR in sync"); | |
| 508 if (C->tf() != tf()) { | |
| 509 MutexLockerEx ml(Compile_lock, Mutex::_no_safepoint_check_flag); | |
| 510 assert(C->env()->system_dictionary_modification_counter_changed(), | |
| 511 "Must invalidate if TypeFuncs differ"); | |
| 512 } | |
| 513 } else { | |
| 514 assert(!this->is_osr_parse(), "no recursive OSR"); | |
| 515 } | |
| 516 #endif | |
| 517 | |
| 518 methods_parsed++; | |
| 519 #ifndef PRODUCT | |
| 520 // add method size here to guarantee that inlined methods are added too | |
| 521 if (TimeCompiler) | |
| 522 _total_bytes_compiled += method()->code_size(); | |
| 523 | |
| 524 show_parse_info(); | |
| 525 #endif | |
| 526 | |
| 527 if (failing()) { | |
| 528 if (log) log->done("parse"); | |
| 529 return; | |
| 530 } | |
| 531 | |
| 532 gvn().set_type(root(), root()->bottom_type()); | |
| 533 gvn().transform(top()); | |
| 534 | |
| 535 // Import the results of the ciTypeFlow. | |
| 536 init_blocks(); | |
| 537 | |
| 538 // Merge point for all normal exits | |
| 539 build_exits(); | |
| 540 | |
| 541 // Setup the initial JVM state map. | |
| 542 SafePointNode* entry_map = create_entry_map(); | |
| 543 | |
| 544 // Check for bailouts during map initialization | |
| 545 if (failing() || entry_map == NULL) { | |
| 546 if (log) log->done("parse"); | |
| 547 return; | |
| 548 } | |
| 549 | |
| 550 Node_Notes* caller_nn = C->default_node_notes(); | |
| 551 // Collect debug info for inlined calls unless -XX:-DebugInlinedCalls. | |
| 552 if (DebugInlinedCalls || depth() == 1) { | |
| 553 C->set_default_node_notes(make_node_notes(caller_nn)); | |
| 554 } | |
| 555 | |
| 556 if (is_osr_parse()) { | |
| 557 Node* osr_buf = entry_map->in(TypeFunc::Parms+0); | |
| 558 entry_map->set_req(TypeFunc::Parms+0, top()); | |
| 559 set_map(entry_map); | |
| 560 load_interpreter_state(osr_buf); | |
| 561 } else { | |
| 562 set_map(entry_map); | |
| 563 do_method_entry(); | |
| 564 } | |
| 565 | |
| 566 // Check for bailouts during method entry. | |
| 567 if (failing()) { | |
| 568 if (log) log->done("parse"); | |
| 569 C->set_default_node_notes(caller_nn); | |
| 570 return; | |
| 571 } | |
| 572 | |
| 573 entry_map = map(); // capture any changes performed by method setup code | |
| 574 assert(jvms()->endoff() == map()->req(), "map matches JVMS layout"); | |
| 575 | |
| 576 // We begin parsing as if we have just encountered a jump to the | |
| 577 // method entry. | |
| 578 Block* entry_block = start_block(); | |
| 579 assert(entry_block->start() == (is_osr_parse() ? osr_bci() : 0), ""); | |
| 580 set_map_clone(entry_map); | |
| 581 merge_common(entry_block, entry_block->next_path_num()); | |
| 582 | |
| 583 #ifndef PRODUCT | |
| 584 BytecodeParseHistogram *parse_histogram_obj = new (C->env()->arena()) BytecodeParseHistogram(this, C); | |
| 585 set_parse_histogram( parse_histogram_obj ); | |
| 586 #endif | |
| 587 | |
| 588 // Parse all the basic blocks. | |
| 589 do_all_blocks(); | |
| 590 | |
| 591 C->set_default_node_notes(caller_nn); | |
| 592 | |
| 593 // Check for bailouts during conversion to graph | |
| 594 if (failing()) { | |
| 595 if (log) log->done("parse"); | |
| 596 return; | |
| 597 } | |
| 598 | |
| 599 // Fix up all exiting control flow. | |
| 600 set_map(entry_map); | |
| 601 do_exits(); | |
| 602 | |
| 603 if (log) log->done("parse nodes='%d' memory='%d'", | |
| 604 C->unique(), C->node_arena()->used()); | |
| 605 } | |
| 606 | |
| 607 //---------------------------do_all_blocks------------------------------------- | |
| 608 void Parse::do_all_blocks() { | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
609 bool has_irreducible = flow()->has_irreducible_entry(); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
610 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
611 // Walk over all blocks in Reverse Post-Order. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
612 while (true) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
613 bool progress = false; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
614 for (int rpo = 0; rpo < block_count(); rpo++) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
615 Block* block = rpo_at(rpo); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
616 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
617 if (block->is_parsed()) continue; |
| 0 | 618 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
619 if (!block->is_merged()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
620 // Dead block, no state reaches this block |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
621 continue; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
622 } |
| 0 | 623 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
624 // Prepare to parse this block. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
625 load_state_from(block); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
626 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
627 if (stopped()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
628 // Block is dead. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
629 continue; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
630 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
631 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
632 blocks_parsed++; |
| 0 | 633 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
634 progress = true; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
635 if (block->is_loop_head() || block->is_handler() || has_irreducible && !block->is_ready()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
636 // Not all preds have been parsed. We must build phis everywhere. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
637 // (Note that dead locals do not get phis built, ever.) |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
638 ensure_phis_everywhere(); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
639 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
640 // Leave behind an undisturbed copy of the map, for future merges. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
641 set_map(clone_map()); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
642 } |
| 0 | 643 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
644 if (control()->is_Region() && !block->is_loop_head() && !has_irreducible && !block->is_handler()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
645 // In the absence of irreducible loops, the Region and Phis |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
646 // associated with a merge that doesn't involve a backedge can |
| 605 | 647 // be simplified now since the RPO parsing order guarantees |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
648 // that any path which was supposed to reach here has already |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
649 // been parsed or must be dead. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
650 Node* c = control(); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
651 Node* result = _gvn.transform_no_reclaim(control()); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
652 if (c != result && TraceOptoParse) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
653 tty->print_cr("Block #%d replace %d with %d", block->rpo(), c->_idx, result->_idx); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
654 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
655 if (result != top()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
656 record_for_igvn(result); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
657 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
658 } |
| 0 | 659 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
660 // Parse the block. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
661 do_one_block(); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
662 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
663 // Check for bailouts. |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
664 if (failing()) return; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
665 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
666 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
667 // with irreducible loops multiple passes might be necessary to parse everything |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
668 if (!has_irreducible || !progress) { |
| 0 | 669 break; |
| 670 } | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
671 } |
| 0 | 672 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
673 blocks_seen += block_count(); |
| 0 | 674 |
| 675 #ifndef PRODUCT | |
| 676 // Make sure there are no half-processed blocks remaining. | |
| 677 // Every remaining unprocessed block is dead and may be ignored now. | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
678 for (int rpo = 0; rpo < block_count(); rpo++) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
679 Block* block = rpo_at(rpo); |
| 0 | 680 if (!block->is_parsed()) { |
| 681 if (TraceOptoParse) { | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
682 tty->print_cr("Skipped dead block %d at bci:%d", rpo, block->start()); |
| 0 | 683 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
684 assert(!block->is_merged(), "no half-processed blocks"); |
| 0 | 685 } |
| 686 } | |
| 687 #endif | |
| 688 } | |
| 689 | |
| 690 //-------------------------------build_exits---------------------------------- | |
| 691 // Build normal and exceptional exit merge points. | |
| 692 void Parse::build_exits() { | |
| 693 // make a clone of caller to prevent sharing of side-effects | |
| 694 _exits.set_map(_exits.clone_map()); | |
| 695 _exits.clean_stack(_exits.sp()); | |
| 696 _exits.sync_jvms(); | |
| 697 | |
| 698 RegionNode* region = new (C, 1) RegionNode(1); | |
| 699 record_for_igvn(region); | |
| 700 gvn().set_type_bottom(region); | |
| 701 _exits.set_control(region); | |
| 702 | |
| 703 // Note: iophi and memphi are not transformed until do_exits. | |
| 704 Node* iophi = new (C, region->req()) PhiNode(region, Type::ABIO); | |
| 705 Node* memphi = new (C, region->req()) PhiNode(region, Type::MEMORY, TypePtr::BOTTOM); | |
| 706 _exits.set_i_o(iophi); | |
| 707 _exits.set_all_memory(memphi); | |
| 708 | |
| 709 // Add a return value to the exit state. (Do not push it yet.) | |
| 710 if (tf()->range()->cnt() > TypeFunc::Parms) { | |
| 711 const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms); | |
| 712 // Don't "bind" an unloaded return klass to the ret_phi. If the klass | |
| 713 // becomes loaded during the subsequent parsing, the loaded and unloaded | |
| 714 // types will not join when we transform and push in do_exits(). | |
| 715 const TypeOopPtr* ret_oop_type = ret_type->isa_oopptr(); | |
| 716 if (ret_oop_type && !ret_oop_type->klass()->is_loaded()) { | |
| 717 ret_type = TypeOopPtr::BOTTOM; | |
| 718 } | |
| 719 int ret_size = type2size[ret_type->basic_type()]; | |
| 720 Node* ret_phi = new (C, region->req()) PhiNode(region, ret_type); | |
| 721 _exits.ensure_stack(ret_size); | |
| 722 assert((int)(tf()->range()->cnt() - TypeFunc::Parms) == ret_size, "good tf range"); | |
| 723 assert(method()->return_type()->size() == ret_size, "tf agrees w/ method"); | |
| 724 _exits.set_argument(0, ret_phi); // here is where the parser finds it | |
| 725 // Note: ret_phi is not yet pushed, until do_exits. | |
| 726 } | |
| 727 } | |
| 728 | |
| 729 | |
| 730 //----------------------------build_start_state------------------------------- | |
| 731 // Construct a state which contains only the incoming arguments from an | |
| 732 // unknown caller. The method & bci will be NULL & InvocationEntryBci. | |
| 733 JVMState* Compile::build_start_state(StartNode* start, const TypeFunc* tf) { | |
| 734 int arg_size = tf->domain()->cnt(); | |
| 735 int max_size = MAX2(arg_size, (int)tf->range()->cnt()); | |
| 736 JVMState* jvms = new (this) JVMState(max_size - TypeFunc::Parms); | |
| 737 SafePointNode* map = new (this, max_size) SafePointNode(max_size, NULL); | |
| 738 record_for_igvn(map); | |
| 739 assert(arg_size == TypeFunc::Parms + (is_osr_compilation() ? 1 : method()->arg_size()), "correct arg_size"); | |
| 740 Node_Notes* old_nn = default_node_notes(); | |
| 741 if (old_nn != NULL && has_method()) { | |
| 742 Node_Notes* entry_nn = old_nn->clone(this); | |
| 743 JVMState* entry_jvms = new(this) JVMState(method(), old_nn->jvms()); | |
| 744 entry_jvms->set_offsets(0); | |
| 745 entry_jvms->set_bci(entry_bci()); | |
| 746 entry_nn->set_jvms(entry_jvms); | |
| 747 set_default_node_notes(entry_nn); | |
| 748 } | |
| 749 uint i; | |
| 750 for (i = 0; i < (uint)arg_size; i++) { | |
| 751 Node* parm = initial_gvn()->transform(new (this, 1) ParmNode(start, i)); | |
| 752 map->init_req(i, parm); | |
| 753 // Record all these guys for later GVN. | |
| 754 record_for_igvn(parm); | |
| 755 } | |
| 756 for (; i < map->req(); i++) { | |
| 757 map->init_req(i, top()); | |
| 758 } | |
| 759 assert(jvms->argoff() == TypeFunc::Parms, "parser gets arguments here"); | |
| 760 set_default_node_notes(old_nn); | |
| 761 map->set_jvms(jvms); | |
| 762 jvms->set_map(map); | |
| 763 return jvms; | |
| 764 } | |
| 765 | |
| 766 //-----------------------------make_node_notes--------------------------------- | |
| 767 Node_Notes* Parse::make_node_notes(Node_Notes* caller_nn) { | |
| 768 if (caller_nn == NULL) return NULL; | |
| 769 Node_Notes* nn = caller_nn->clone(C); | |
| 770 JVMState* caller_jvms = nn->jvms(); | |
| 771 JVMState* jvms = new (C) JVMState(method(), caller_jvms); | |
| 772 jvms->set_offsets(0); | |
| 773 jvms->set_bci(_entry_bci); | |
| 774 nn->set_jvms(jvms); | |
| 775 return nn; | |
| 776 } | |
| 777 | |
| 778 | |
| 779 //--------------------------return_values-------------------------------------- | |
| 780 void Compile::return_values(JVMState* jvms) { | |
| 781 GraphKit kit(jvms); | |
| 782 Node* ret = new (this, TypeFunc::Parms) ReturnNode(TypeFunc::Parms, | |
| 783 kit.control(), | |
| 784 kit.i_o(), | |
| 785 kit.reset_memory(), | |
| 786 kit.frameptr(), | |
| 787 kit.returnadr()); | |
| 788 // Add zero or 1 return values | |
| 789 int ret_size = tf()->range()->cnt() - TypeFunc::Parms; | |
| 790 if (ret_size > 0) { | |
| 791 kit.inc_sp(-ret_size); // pop the return value(s) | |
| 792 kit.sync_jvms(); | |
| 793 ret->add_req(kit.argument(0)); | |
| 794 // Note: The second dummy edge is not needed by a ReturnNode. | |
| 795 } | |
| 796 // bind it to root | |
| 797 root()->add_req(ret); | |
| 798 record_for_igvn(ret); | |
| 799 initial_gvn()->transform_no_reclaim(ret); | |
| 800 } | |
| 801 | |
| 802 //------------------------rethrow_exceptions----------------------------------- | |
| 803 // Bind all exception states in the list into a single RethrowNode. | |
| 804 void Compile::rethrow_exceptions(JVMState* jvms) { | |
| 805 GraphKit kit(jvms); | |
| 806 if (!kit.has_exceptions()) return; // nothing to generate | |
| 807 // Load my combined exception state into the kit, with all phis transformed: | |
| 808 SafePointNode* ex_map = kit.combine_and_pop_all_exception_states(); | |
| 809 Node* ex_oop = kit.use_exception_state(ex_map); | |
| 810 RethrowNode* exit = new (this, TypeFunc::Parms + 1) RethrowNode(kit.control(), | |
| 811 kit.i_o(), kit.reset_memory(), | |
| 812 kit.frameptr(), kit.returnadr(), | |
| 813 // like a return but with exception input | |
| 814 ex_oop); | |
| 815 // bind to root | |
| 816 root()->add_req(exit); | |
| 817 record_for_igvn(exit); | |
| 818 initial_gvn()->transform_no_reclaim(exit); | |
| 819 } | |
| 820 | |
| 821 //---------------------------do_exceptions------------------------------------- | |
| 822 // Process exceptions arising from the current bytecode. | |
| 823 // Send caught exceptions to the proper handler within this method. | |
| 824 // Unhandled exceptions feed into _exit. | |
| 825 void Parse::do_exceptions() { | |
| 826 if (!has_exceptions()) return; | |
| 827 | |
| 828 if (failing()) { | |
| 829 // Pop them all off and throw them away. | |
| 830 while (pop_exception_state() != NULL) ; | |
| 831 return; | |
| 832 } | |
| 833 | |
| 834 PreserveJVMState pjvms(this, false); | |
| 835 | |
| 836 SafePointNode* ex_map; | |
| 837 while ((ex_map = pop_exception_state()) != NULL) { | |
| 838 if (!method()->has_exception_handlers()) { | |
| 839 // Common case: Transfer control outward. | |
| 840 // Doing it this early allows the exceptions to common up | |
| 841 // even between adjacent method calls. | |
| 842 throw_to_exit(ex_map); | |
| 843 } else { | |
| 844 // Have to look at the exception first. | |
| 845 assert(stopped(), "catch_inline_exceptions trashes the map"); | |
| 846 catch_inline_exceptions(ex_map); | |
| 847 stop_and_kill_map(); // we used up this exception state; kill it | |
| 848 } | |
| 849 } | |
| 850 | |
| 851 // We now return to our regularly scheduled program: | |
| 852 } | |
| 853 | |
| 854 //---------------------------throw_to_exit------------------------------------- | |
| 855 // Merge the given map into an exception exit from this method. | |
| 856 // The exception exit will handle any unlocking of receiver. | |
| 857 // The ex_oop must be saved within the ex_map, unlike merge_exception. | |
| 858 void Parse::throw_to_exit(SafePointNode* ex_map) { | |
| 859 // Pop the JVMS to (a copy of) the caller. | |
| 860 GraphKit caller; | |
| 861 caller.set_map_clone(_caller->map()); | |
| 862 caller.set_bci(_caller->bci()); | |
| 863 caller.set_sp(_caller->sp()); | |
| 864 // Copy out the standard machine state: | |
| 865 for (uint i = 0; i < TypeFunc::Parms; i++) { | |
| 866 caller.map()->set_req(i, ex_map->in(i)); | |
| 867 } | |
| 868 // ...and the exception: | |
| 869 Node* ex_oop = saved_ex_oop(ex_map); | |
| 870 SafePointNode* caller_ex_map = caller.make_exception_state(ex_oop); | |
| 871 // Finally, collect the new exception state in my exits: | |
| 872 _exits.add_exception_state(caller_ex_map); | |
| 873 } | |
| 874 | |
| 875 //------------------------------do_exits--------------------------------------- | |
| 876 void Parse::do_exits() { | |
| 877 set_parse_bci(InvocationEntryBci); | |
| 878 | |
| 879 // Now peephole on the return bits | |
| 880 Node* region = _exits.control(); | |
| 881 _exits.set_control(gvn().transform(region)); | |
| 882 | |
| 883 Node* iophi = _exits.i_o(); | |
| 884 _exits.set_i_o(gvn().transform(iophi)); | |
| 885 | |
| 886 if (wrote_final()) { | |
| 887 // This method (which must be a constructor by the rules of Java) | |
| 888 // wrote a final. The effects of all initializations must be | |
| 889 // committed to memory before any code after the constructor | |
| 890 // publishes the reference to the newly constructor object. | |
| 891 // Rather than wait for the publication, we simply block the | |
| 892 // writes here. Rather than put a barrier on only those writes | |
| 893 // which are required to complete, we force all writes to complete. | |
| 894 // | |
| 895 // "All bets are off" unless the first publication occurs after a | |
| 896 // normal return from the constructor. We do not attempt to detect | |
| 897 // such unusual early publications. But no barrier is needed on | |
| 898 // exceptional returns, since they cannot publish normally. | |
| 899 // | |
| 900 _exits.insert_mem_bar(Op_MemBarRelease); | |
| 901 #ifndef PRODUCT | |
| 902 if (PrintOpto && (Verbose || WizardMode)) { | |
| 903 method()->print_name(); | |
| 904 tty->print_cr(" writes finals and needs a memory barrier"); | |
| 905 } | |
| 906 #endif | |
| 907 } | |
| 908 | |
| 909 for (MergeMemStream mms(_exits.merged_memory()); mms.next_non_empty(); ) { | |
| 910 // transform each slice of the original memphi: | |
| 911 mms.set_memory(_gvn.transform(mms.memory())); | |
| 912 } | |
| 913 | |
| 914 if (tf()->range()->cnt() > TypeFunc::Parms) { | |
| 915 const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms); | |
| 916 Node* ret_phi = _gvn.transform( _exits.argument(0) ); | |
| 917 assert(_exits.control()->is_top() || !_gvn.type(ret_phi)->empty(), "return value must be well defined"); | |
| 918 _exits.push_node(ret_type->basic_type(), ret_phi); | |
| 919 } | |
| 920 | |
| 921 // Note: Logic for creating and optimizing the ReturnNode is in Compile. | |
| 922 | |
| 923 // Unlock along the exceptional paths. | |
| 924 // This is done late so that we can common up equivalent exceptions | |
| 925 // (e.g., null checks) arising from multiple points within this method. | |
| 926 // See GraphKit::add_exception_state, which performs the commoning. | |
| 927 bool do_synch = method()->is_synchronized() && GenerateSynchronizationCode; | |
| 928 | |
| 929 // record exit from a method if compiled while Dtrace is turned on. | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
930 if (do_synch || C->env()->dtrace_method_probes()) { |
| 0 | 931 // First move the exception list out of _exits: |
| 932 GraphKit kit(_exits.transfer_exceptions_into_jvms()); | |
| 933 SafePointNode* normal_map = kit.map(); // keep this guy safe | |
| 934 // Now re-collect the exceptions into _exits: | |
| 935 SafePointNode* ex_map; | |
| 936 while ((ex_map = kit.pop_exception_state()) != NULL) { | |
| 937 Node* ex_oop = kit.use_exception_state(ex_map); | |
| 938 // Force the exiting JVM state to have this method at InvocationEntryBci. | |
| 939 // The exiting JVM state is otherwise a copy of the calling JVMS. | |
| 940 JVMState* caller = kit.jvms(); | |
| 941 JVMState* ex_jvms = caller->clone_shallow(C); | |
| 942 ex_jvms->set_map(kit.clone_map()); | |
| 943 ex_jvms->map()->set_jvms(ex_jvms); | |
| 944 ex_jvms->set_bci( InvocationEntryBci); | |
| 945 kit.set_jvms(ex_jvms); | |
| 946 if (do_synch) { | |
| 947 // Add on the synchronized-method box/object combo | |
| 948 kit.map()->push_monitor(_synch_lock); | |
| 949 // Unlock! | |
| 950 kit.shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node()); | |
| 951 } | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
952 if (C->env()->dtrace_method_probes()) { |
| 0 | 953 kit.make_dtrace_method_exit(method()); |
| 954 } | |
| 955 // Done with exception-path processing. | |
| 956 ex_map = kit.make_exception_state(ex_oop); | |
| 957 assert(ex_jvms->same_calls_as(ex_map->jvms()), "sanity"); | |
| 958 // Pop the last vestige of this method: | |
| 959 ex_map->set_jvms(caller->clone_shallow(C)); | |
| 960 ex_map->jvms()->set_map(ex_map); | |
| 961 _exits.push_exception_state(ex_map); | |
| 962 } | |
| 963 assert(_exits.map() == normal_map, "keep the same return state"); | |
| 964 } | |
| 965 | |
| 966 { | |
| 967 // Capture very early exceptions (receiver null checks) from caller JVMS | |
| 968 GraphKit caller(_caller); | |
| 969 SafePointNode* ex_map; | |
| 970 while ((ex_map = caller.pop_exception_state()) != NULL) { | |
| 971 _exits.add_exception_state(ex_map); | |
| 972 } | |
| 973 } | |
| 974 } | |
| 975 | |
| 976 //-----------------------------create_entry_map------------------------------- | |
| 977 // Initialize our parser map to contain the types at method entry. | |
| 978 // For OSR, the map contains a single RawPtr parameter. | |
| 979 // Initial monitor locking for sync. methods is performed by do_method_entry. | |
| 980 SafePointNode* Parse::create_entry_map() { | |
| 981 // Check for really stupid bail-out cases. | |
| 982 uint len = TypeFunc::Parms + method()->max_locals() + method()->max_stack(); | |
| 983 if (len >= 32760) { | |
| 984 C->record_method_not_compilable_all_tiers("too many local variables"); | |
| 985 return NULL; | |
| 986 } | |
| 987 | |
| 988 // If this is an inlined method, we may have to do a receiver null check. | |
| 989 if (_caller->has_method() && is_normal_parse() && !method()->is_static()) { | |
| 990 GraphKit kit(_caller); | |
| 991 kit.null_check_receiver(method()); | |
| 992 _caller = kit.transfer_exceptions_into_jvms(); | |
| 993 if (kit.stopped()) { | |
| 994 _exits.add_exception_states_from(_caller); | |
| 995 _exits.set_jvms(_caller); | |
| 996 return NULL; | |
| 997 } | |
| 998 } | |
| 999 | |
| 1000 assert(method() != NULL, "parser must have a method"); | |
| 1001 | |
| 1002 // Create an initial safepoint to hold JVM state during parsing | |
| 1003 JVMState* jvms = new (C) JVMState(method(), _caller->has_method() ? _caller : NULL); | |
| 1004 set_map(new (C, len) SafePointNode(len, jvms)); | |
| 1005 jvms->set_map(map()); | |
| 1006 record_for_igvn(map()); | |
| 1007 assert(jvms->endoff() == len, "correct jvms sizing"); | |
| 1008 | |
| 1009 SafePointNode* inmap = _caller->map(); | |
| 1010 assert(inmap != NULL, "must have inmap"); | |
| 1011 | |
| 1012 uint i; | |
| 1013 | |
| 1014 // Pass thru the predefined input parameters. | |
| 1015 for (i = 0; i < TypeFunc::Parms; i++) { | |
| 1016 map()->init_req(i, inmap->in(i)); | |
| 1017 } | |
| 1018 | |
| 1019 if (depth() == 1) { | |
| 1020 assert(map()->memory()->Opcode() == Op_Parm, ""); | |
| 1021 // Insert the memory aliasing node | |
| 1022 set_all_memory(reset_memory()); | |
| 1023 } | |
| 1024 assert(merged_memory(), ""); | |
| 1025 | |
| 1026 // Now add the locals which are initially bound to arguments: | |
| 1027 uint arg_size = tf()->domain()->cnt(); | |
| 1028 ensure_stack(arg_size - TypeFunc::Parms); // OSR methods have funny args | |
| 1029 for (i = TypeFunc::Parms; i < arg_size; i++) { | |
| 1030 map()->init_req(i, inmap->argument(_caller, i - TypeFunc::Parms)); | |
| 1031 } | |
| 1032 | |
| 1033 // Clear out the rest of the map (locals and stack) | |
| 1034 for (i = arg_size; i < len; i++) { | |
| 1035 map()->init_req(i, top()); | |
| 1036 } | |
| 1037 | |
| 1038 SafePointNode* entry_map = stop(); | |
| 1039 return entry_map; | |
| 1040 } | |
| 1041 | |
| 1042 //-----------------------------do_method_entry-------------------------------- | |
| 1043 // Emit any code needed in the pseudo-block before BCI zero. | |
| 1044 // The main thing to do is lock the receiver of a synchronized method. | |
| 1045 void Parse::do_method_entry() { | |
| 1046 set_parse_bci(InvocationEntryBci); // Pseudo-BCP | |
| 1047 set_sp(0); // Java Stack Pointer | |
| 1048 | |
| 1049 NOT_PRODUCT( count_compiled_calls(true/*at_method_entry*/, false/*is_inline*/); ) | |
| 1050 | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
1051 if (C->env()->dtrace_method_probes()) { |
| 0 | 1052 make_dtrace_method_entry(method()); |
| 1053 } | |
| 1054 | |
| 1055 // If the method is synchronized, we need to construct a lock node, attach | |
| 1056 // it to the Start node, and pin it there. | |
| 1057 if (method()->is_synchronized()) { | |
| 1058 // Insert a FastLockNode right after the Start which takes as arguments | |
| 1059 // the current thread pointer, the "this" pointer & the address of the | |
| 1060 // stack slot pair used for the lock. The "this" pointer is a projection | |
| 1061 // off the start node, but the locking spot has to be constructed by | |
| 1062 // creating a ConLNode of 0, and boxing it with a BoxLockNode. The BoxLockNode | |
| 1063 // becomes the second argument to the FastLockNode call. The | |
| 1064 // FastLockNode becomes the new control parent to pin it to the start. | |
| 1065 | |
| 1066 // Setup Object Pointer | |
| 1067 Node *lock_obj = NULL; | |
| 1068 if(method()->is_static()) { | |
| 1069 ciInstance* mirror = _method->holder()->java_mirror(); | |
| 1070 const TypeInstPtr *t_lock = TypeInstPtr::make(mirror); | |
| 1071 lock_obj = makecon(t_lock); | |
| 1072 } else { // Else pass the "this" pointer, | |
| 1073 lock_obj = local(0); // which is Parm0 from StartNode | |
| 1074 } | |
| 1075 // Clear out dead values from the debug info. | |
| 1076 kill_dead_locals(); | |
| 1077 // Build the FastLockNode | |
| 1078 _synch_lock = shared_lock(lock_obj); | |
| 1079 } | |
| 1080 | |
| 1081 if (depth() == 1) { | |
| 1082 increment_and_test_invocation_counter(Tier2CompileThreshold); | |
| 1083 } | |
| 1084 } | |
| 1085 | |
| 1086 //------------------------------init_blocks------------------------------------ | |
| 1087 // Initialize our parser map to contain the types/monitors at method entry. | |
| 1088 void Parse::init_blocks() { | |
| 1089 // Create the blocks. | |
| 1090 _block_count = flow()->block_count(); | |
| 1091 _blocks = NEW_RESOURCE_ARRAY(Block, _block_count); | |
| 1092 Copy::zero_to_bytes(_blocks, sizeof(Block)*_block_count); | |
| 1093 | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1094 int rpo; |
| 0 | 1095 |
| 1096 // Initialize the structs. | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1097 for (rpo = 0; rpo < block_count(); rpo++) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1098 Block* block = rpo_at(rpo); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1099 block->init_node(this, rpo); |
| 0 | 1100 } |
| 1101 | |
| 1102 // Collect predecessor and successor information. | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1103 for (rpo = 0; rpo < block_count(); rpo++) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1104 Block* block = rpo_at(rpo); |
| 0 | 1105 block->init_graph(this); |
| 1106 } | |
| 1107 } | |
| 1108 | |
| 1109 //-------------------------------init_node------------------------------------- | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1110 void Parse::Block::init_node(Parse* outer, int rpo) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1111 _flow = outer->flow()->rpo_at(rpo); |
| 0 | 1112 _pred_count = 0; |
| 1113 _preds_parsed = 0; | |
| 1114 _count = 0; | |
| 1115 assert(pred_count() == 0 && preds_parsed() == 0, "sanity"); | |
| 1116 assert(!(is_merged() || is_parsed() || is_handler()), "sanity"); | |
| 1117 assert(_live_locals.size() == 0, "sanity"); | |
| 1118 | |
| 1119 // entry point has additional predecessor | |
| 1120 if (flow()->is_start()) _pred_count++; | |
| 1121 assert(flow()->is_start() == (this == outer->start_block()), ""); | |
| 1122 } | |
| 1123 | |
| 1124 //-------------------------------init_graph------------------------------------ | |
| 1125 void Parse::Block::init_graph(Parse* outer) { | |
| 1126 // Create the successor list for this parser block. | |
| 1127 GrowableArray<ciTypeFlow::Block*>* tfs = flow()->successors(); | |
| 1128 GrowableArray<ciTypeFlow::Block*>* tfe = flow()->exceptions(); | |
| 1129 int ns = tfs->length(); | |
| 1130 int ne = tfe->length(); | |
| 1131 _num_successors = ns; | |
| 1132 _all_successors = ns+ne; | |
| 1133 _successors = (ns+ne == 0) ? NULL : NEW_RESOURCE_ARRAY(Block*, ns+ne); | |
| 1134 int p = 0; | |
| 1135 for (int i = 0; i < ns+ne; i++) { | |
| 1136 ciTypeFlow::Block* tf2 = (i < ns) ? tfs->at(i) : tfe->at(i-ns); | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1137 Block* block2 = outer->rpo_at(tf2->rpo()); |
| 0 | 1138 _successors[i] = block2; |
| 1139 | |
| 1140 // Accumulate pred info for the other block, too. | |
| 1141 if (i < ns) { | |
| 1142 block2->_pred_count++; | |
| 1143 } else { | |
| 1144 block2->_is_handler = true; | |
| 1145 } | |
| 1146 | |
| 1147 #ifdef ASSERT | |
| 1148 // A block's successors must be distinguishable by BCI. | |
| 1149 // That is, no bytecode is allowed to branch to two different | |
| 1150 // clones of the same code location. | |
| 1151 for (int j = 0; j < i; j++) { | |
| 1152 Block* block1 = _successors[j]; | |
| 1153 if (block1 == block2) continue; // duplicates are OK | |
| 1154 assert(block1->start() != block2->start(), "successors have unique bcis"); | |
| 1155 } | |
| 1156 #endif | |
| 1157 } | |
| 1158 | |
| 1159 // Note: We never call next_path_num along exception paths, so they | |
| 1160 // never get processed as "ready". Also, the input phis of exception | |
| 1161 // handlers get specially processed, so that | |
| 1162 } | |
| 1163 | |
| 1164 //---------------------------successor_for_bci--------------------------------- | |
| 1165 Parse::Block* Parse::Block::successor_for_bci(int bci) { | |
| 1166 for (int i = 0; i < all_successors(); i++) { | |
| 1167 Block* block2 = successor_at(i); | |
| 1168 if (block2->start() == bci) return block2; | |
| 1169 } | |
| 1170 // We can actually reach here if ciTypeFlow traps out a block | |
| 1171 // due to an unloaded class, and concurrently with compilation the | |
| 1172 // class is then loaded, so that a later phase of the parser is | |
| 1173 // able to see more of the bytecode CFG. Or, the flow pass and | |
| 1174 // the parser can have a minor difference of opinion about executability | |
| 1175 // of bytecodes. For example, "obj.field = null" is executable even | |
| 1176 // if the field's type is an unloaded class; the flow pass used to | |
| 1177 // make a trap for such code. | |
| 1178 return NULL; | |
| 1179 } | |
| 1180 | |
| 1181 | |
| 1182 //-----------------------------stack_type_at----------------------------------- | |
| 1183 const Type* Parse::Block::stack_type_at(int i) const { | |
| 1184 return get_type(flow()->stack_type_at(i)); | |
| 1185 } | |
| 1186 | |
| 1187 | |
| 1188 //-----------------------------local_type_at----------------------------------- | |
| 1189 const Type* Parse::Block::local_type_at(int i) const { | |
| 1190 // Make dead locals fall to bottom. | |
| 1191 if (_live_locals.size() == 0) { | |
| 1192 MethodLivenessResult live_locals = flow()->outer()->method()->liveness_at_bci(start()); | |
| 1193 // This bitmap can be zero length if we saw a breakpoint. | |
| 1194 // In such cases, pretend they are all live. | |
| 1195 ((Block*)this)->_live_locals = live_locals; | |
| 1196 } | |
| 1197 if (_live_locals.size() > 0 && !_live_locals.at(i)) | |
| 1198 return Type::BOTTOM; | |
| 1199 | |
| 1200 return get_type(flow()->local_type_at(i)); | |
| 1201 } | |
| 1202 | |
| 1203 | |
| 1204 #ifndef PRODUCT | |
| 1205 | |
| 1206 //----------------------------name_for_bc-------------------------------------- | |
| 1207 // helper method for BytecodeParseHistogram | |
| 1208 static const char* name_for_bc(int i) { | |
| 1209 return Bytecodes::is_defined(i) ? Bytecodes::name(Bytecodes::cast(i)) : "xxxunusedxxx"; | |
| 1210 } | |
| 1211 | |
| 1212 //----------------------------BytecodeParseHistogram------------------------------------ | |
| 1213 Parse::BytecodeParseHistogram::BytecodeParseHistogram(Parse *p, Compile *c) { | |
| 1214 _parser = p; | |
| 1215 _compiler = c; | |
| 1216 if( ! _initialized ) { _initialized = true; reset(); } | |
| 1217 } | |
| 1218 | |
| 1219 //----------------------------current_count------------------------------------ | |
| 1220 int Parse::BytecodeParseHistogram::current_count(BPHType bph_type) { | |
| 1221 switch( bph_type ) { | |
| 1222 case BPH_transforms: { return _parser->gvn().made_progress(); } | |
| 1223 case BPH_values: { return _parser->gvn().made_new_values(); } | |
| 1224 default: { ShouldNotReachHere(); return 0; } | |
| 1225 } | |
| 1226 } | |
| 1227 | |
| 1228 //----------------------------initialized-------------------------------------- | |
| 1229 bool Parse::BytecodeParseHistogram::initialized() { return _initialized; } | |
| 1230 | |
| 1231 //----------------------------reset-------------------------------------------- | |
| 1232 void Parse::BytecodeParseHistogram::reset() { | |
| 1233 int i = Bytecodes::number_of_codes; | |
| 1234 while (i-- > 0) { _bytecodes_parsed[i] = 0; _nodes_constructed[i] = 0; _nodes_transformed[i] = 0; _new_values[i] = 0; } | |
| 1235 } | |
| 1236 | |
| 1237 //----------------------------set_initial_state-------------------------------- | |
| 1238 // Record info when starting to parse one bytecode | |
| 1239 void Parse::BytecodeParseHistogram::set_initial_state( Bytecodes::Code bc ) { | |
| 1240 if( PrintParseStatistics && !_parser->is_osr_parse() ) { | |
| 1241 _initial_bytecode = bc; | |
| 1242 _initial_node_count = _compiler->unique(); | |
| 1243 _initial_transforms = current_count(BPH_transforms); | |
| 1244 _initial_values = current_count(BPH_values); | |
| 1245 } | |
| 1246 } | |
| 1247 | |
| 1248 //----------------------------record_change-------------------------------- | |
| 1249 // Record results of parsing one bytecode | |
| 1250 void Parse::BytecodeParseHistogram::record_change() { | |
| 1251 if( PrintParseStatistics && !_parser->is_osr_parse() ) { | |
| 1252 ++_bytecodes_parsed[_initial_bytecode]; | |
| 1253 _nodes_constructed [_initial_bytecode] += (_compiler->unique() - _initial_node_count); | |
| 1254 _nodes_transformed [_initial_bytecode] += (current_count(BPH_transforms) - _initial_transforms); | |
| 1255 _new_values [_initial_bytecode] += (current_count(BPH_values) - _initial_values); | |
| 1256 } | |
| 1257 } | |
| 1258 | |
| 1259 | |
| 1260 //----------------------------print-------------------------------------------- | |
| 1261 void Parse::BytecodeParseHistogram::print(float cutoff) { | |
| 1262 ResourceMark rm; | |
| 1263 // print profile | |
| 1264 int total = 0; | |
| 1265 int i = 0; | |
| 1266 for( i = 0; i < Bytecodes::number_of_codes; ++i ) { total += _bytecodes_parsed[i]; } | |
| 1267 int abs_sum = 0; | |
| 1268 tty->cr(); //0123456789012345678901234567890123456789012345678901234567890123456789 | |
| 1269 tty->print_cr("Histogram of %d parsed bytecodes:", total); | |
| 1270 if( total == 0 ) { return; } | |
| 1271 tty->cr(); | |
| 1272 tty->print_cr("absolute: count of compiled bytecodes of this type"); | |
| 1273 tty->print_cr("relative: percentage contribution to compiled nodes"); | |
| 1274 tty->print_cr("nodes : Average number of nodes constructed per bytecode"); | |
| 1275 tty->print_cr("rnodes : Significance towards total nodes constructed, (nodes*relative)"); | |
| 1276 tty->print_cr("transforms: Average amount of tranform progress per bytecode compiled"); | |
| 1277 tty->print_cr("values : Average number of node values improved per bytecode"); | |
| 1278 tty->print_cr("name : Bytecode name"); | |
| 1279 tty->cr(); | |
| 1280 tty->print_cr(" absolute relative nodes rnodes transforms values name"); | |
| 1281 tty->print_cr("----------------------------------------------------------------------"); | |
| 1282 while (--i > 0) { | |
| 1283 int abs = _bytecodes_parsed[i]; | |
| 1284 float rel = abs * 100.0F / total; | |
| 1285 float nodes = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_constructed[i])/_bytecodes_parsed[i]; | |
| 1286 float rnodes = _bytecodes_parsed[i] == 0 ? 0 : rel * nodes; | |
| 1287 float xforms = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_transformed[i])/_bytecodes_parsed[i]; | |
| 1288 float values = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _new_values [i])/_bytecodes_parsed[i]; | |
| 1289 if (cutoff <= rel) { | |
| 1290 tty->print_cr("%10d %7.2f%% %6.1f %6.2f %6.1f %6.1f %s", abs, rel, nodes, rnodes, xforms, values, name_for_bc(i)); | |
| 1291 abs_sum += abs; | |
| 1292 } | |
| 1293 } | |
| 1294 tty->print_cr("----------------------------------------------------------------------"); | |
| 1295 float rel_sum = abs_sum * 100.0F / total; | |
| 1296 tty->print_cr("%10d %7.2f%% (cutoff = %.2f%%)", abs_sum, rel_sum, cutoff); | |
| 1297 tty->print_cr("----------------------------------------------------------------------"); | |
| 1298 tty->cr(); | |
| 1299 } | |
| 1300 #endif | |
| 1301 | |
| 1302 //----------------------------load_state_from---------------------------------- | |
| 1303 // Load block/map/sp. But not do not touch iter/bci. | |
| 1304 void Parse::load_state_from(Block* block) { | |
| 1305 set_block(block); | |
| 1306 // load the block's JVM state: | |
| 1307 set_map(block->start_map()); | |
| 1308 set_sp( block->start_sp()); | |
| 1309 } | |
| 1310 | |
| 1311 | |
| 1312 //-----------------------------record_state------------------------------------ | |
| 1313 void Parse::Block::record_state(Parse* p) { | |
| 1314 assert(!is_merged(), "can only record state once, on 1st inflow"); | |
| 1315 assert(start_sp() == p->sp(), "stack pointer must agree with ciTypeFlow"); | |
| 1316 set_start_map(p->stop()); | |
| 1317 } | |
| 1318 | |
| 1319 | |
| 1320 //------------------------------do_one_block----------------------------------- | |
| 1321 void Parse::do_one_block() { | |
| 1322 if (TraceOptoParse) { | |
| 1323 Block *b = block(); | |
| 1324 int ns = b->num_successors(); | |
| 1325 int nt = b->all_successors(); | |
| 1326 | |
| 1327 tty->print("Parsing block #%d at bci [%d,%d), successors: ", | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1328 block()->rpo(), block()->start(), block()->limit()); |
| 0 | 1329 for (int i = 0; i < nt; i++) { |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1330 tty->print((( i < ns) ? " %d" : " %d(e)"), b->successor_at(i)->rpo()); |
| 0 | 1331 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1332 if (b->is_loop_head()) tty->print(" lphd"); |
| 0 | 1333 tty->print_cr(""); |
| 1334 } | |
| 1335 | |
| 1336 assert(block()->is_merged(), "must be merged before being parsed"); | |
| 1337 block()->mark_parsed(); | |
| 1338 ++_blocks_parsed; | |
| 1339 | |
| 1340 // Set iterator to start of block. | |
| 1341 iter().reset_to_bci(block()->start()); | |
| 1342 | |
| 1343 CompileLog* log = C->log(); | |
| 1344 | |
| 1345 // Parse bytecodes | |
| 1346 while (!stopped() && !failing()) { | |
| 1347 iter().next(); | |
| 1348 | |
| 1349 // Learn the current bci from the iterator: | |
| 1350 set_parse_bci(iter().cur_bci()); | |
| 1351 | |
| 1352 if (bci() == block()->limit()) { | |
| 1172 | 1353 // insert a predicate if it falls through to a loop head block |
| 1354 if (should_add_predicate(bci())){ | |
| 1355 add_predicate(); | |
| 1356 } | |
| 0 | 1357 // Do not walk into the next block until directed by do_all_blocks. |
| 1358 merge(bci()); | |
| 1359 break; | |
| 1360 } | |
| 1361 assert(bci() < block()->limit(), "bci still in block"); | |
| 1362 | |
| 1363 if (log != NULL) { | |
| 1364 // Output an optional context marker, to help place actions | |
| 1365 // that occur during parsing of this BC. If there is no log | |
| 1366 // output until the next context string, this context string | |
| 1367 // will be silently ignored. | |
| 1368 log->context()->reset(); | |
| 1369 log->context()->print_cr("<bc code='%d' bci='%d'/>", (int)bc(), bci()); | |
| 1370 } | |
| 1371 | |
| 1372 if (block()->has_trap_at(bci())) { | |
| 1373 // We must respect the flow pass's traps, because it will refuse | |
| 1374 // to produce successors for trapping blocks. | |
| 1375 int trap_index = block()->flow()->trap_index(); | |
| 1376 assert(trap_index != 0, "trap index must be valid"); | |
| 1377 uncommon_trap(trap_index); | |
| 1378 break; | |
| 1379 } | |
| 1380 | |
| 1381 NOT_PRODUCT( parse_histogram()->set_initial_state(bc()); ); | |
| 1382 | |
| 1383 #ifdef ASSERT | |
| 1384 int pre_bc_sp = sp(); | |
| 1385 int inputs, depth; | |
| 1386 bool have_se = !stopped() && compute_stack_effects(inputs, depth); | |
| 1387 assert(!have_se || pre_bc_sp >= inputs, "have enough stack to execute this BC"); | |
| 1388 #endif //ASSERT | |
| 1389 | |
| 1390 do_one_bytecode(); | |
| 1391 | |
| 1392 assert(!have_se || stopped() || failing() || (sp() - pre_bc_sp) == depth, "correct depth prediction"); | |
| 1393 | |
| 1394 do_exceptions(); | |
| 1395 | |
| 1396 NOT_PRODUCT( parse_histogram()->record_change(); ); | |
| 1397 | |
| 1398 if (log != NULL) log->context()->reset(); // done w/ this one | |
| 1399 | |
| 1400 // Fall into next bytecode. Each bytecode normally has 1 sequential | |
| 1401 // successor which is typically made ready by visiting this bytecode. | |
| 1402 // If the successor has several predecessors, then it is a merge | |
| 1403 // point, starts a new basic block, and is handled like other basic blocks. | |
| 1404 } | |
| 1405 } | |
| 1406 | |
| 1407 | |
| 1408 //------------------------------merge------------------------------------------ | |
| 1409 void Parse::set_parse_bci(int bci) { | |
| 1410 set_bci(bci); | |
| 1411 Node_Notes* nn = C->default_node_notes(); | |
| 1412 if (nn == NULL) return; | |
| 1413 | |
| 1414 // Collect debug info for inlined calls unless -XX:-DebugInlinedCalls. | |
| 1415 if (!DebugInlinedCalls && depth() > 1) { | |
| 1416 return; | |
| 1417 } | |
| 1418 | |
| 1419 // Update the JVMS annotation, if present. | |
| 1420 JVMState* jvms = nn->jvms(); | |
| 1421 if (jvms != NULL && jvms->bci() != bci) { | |
| 1422 // Update the JVMS. | |
| 1423 jvms = jvms->clone_shallow(C); | |
| 1424 jvms->set_bci(bci); | |
| 1425 nn->set_jvms(jvms); | |
| 1426 } | |
| 1427 } | |
| 1428 | |
| 1429 //------------------------------merge------------------------------------------ | |
| 1430 // Merge the current mapping into the basic block starting at bci | |
| 1431 void Parse::merge(int target_bci) { | |
| 1432 Block* target = successor_for_bci(target_bci); | |
| 1433 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1434 assert(!target->is_ready(), "our arrival must be expected"); | |
| 1435 int pnum = target->next_path_num(); | |
| 1436 merge_common(target, pnum); | |
| 1437 } | |
| 1438 | |
| 1439 //-------------------------merge_new_path-------------------------------------- | |
| 1440 // Merge the current mapping into the basic block, using a new path | |
| 1441 void Parse::merge_new_path(int target_bci) { | |
| 1442 Block* target = successor_for_bci(target_bci); | |
| 1443 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1444 assert(!target->is_ready(), "new path into frozen graph"); | |
| 1445 int pnum = target->add_new_path(); | |
| 1446 merge_common(target, pnum); | |
| 1447 } | |
| 1448 | |
| 1449 //-------------------------merge_exception------------------------------------- | |
| 1450 // Merge the current mapping into the basic block starting at bci | |
| 1451 // The ex_oop must be pushed on the stack, unlike throw_to_exit. | |
| 1452 void Parse::merge_exception(int target_bci) { | |
| 1453 assert(sp() == 1, "must have only the throw exception on the stack"); | |
| 1454 Block* target = successor_for_bci(target_bci); | |
| 1455 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1456 assert(target->is_handler(), "exceptions are handled by special blocks"); | |
| 1457 int pnum = target->add_new_path(); | |
| 1458 merge_common(target, pnum); | |
| 1459 } | |
| 1460 | |
| 1461 //--------------------handle_missing_successor--------------------------------- | |
| 1462 void Parse::handle_missing_successor(int target_bci) { | |
| 1463 #ifndef PRODUCT | |
| 1464 Block* b = block(); | |
| 1465 int trap_bci = b->flow()->has_trap()? b->flow()->trap_bci(): -1; | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1466 tty->print_cr("### Missing successor at bci:%d for block #%d (trap_bci:%d)", target_bci, b->rpo(), trap_bci); |
| 0 | 1467 #endif |
| 1468 ShouldNotReachHere(); | |
| 1469 } | |
| 1470 | |
| 1471 //--------------------------merge_common--------------------------------------- | |
| 1472 void Parse::merge_common(Parse::Block* target, int pnum) { | |
| 1473 if (TraceOptoParse) { | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1474 tty->print("Merging state at block #%d bci:%d", target->rpo(), target->start()); |
| 0 | 1475 } |
| 1476 | |
| 1477 // Zap extra stack slots to top | |
| 1478 assert(sp() == target->start_sp(), ""); | |
| 1479 clean_stack(sp()); | |
| 1480 | |
| 1481 if (!target->is_merged()) { // No prior mapping at this bci | |
| 1482 if (TraceOptoParse) { tty->print(" with empty state"); } | |
| 1483 | |
| 1484 // If this path is dead, do not bother capturing it as a merge. | |
| 1485 // It is "as if" we had 1 fewer predecessors from the beginning. | |
| 1486 if (stopped()) { | |
| 1487 if (TraceOptoParse) tty->print_cr(", but path is dead and doesn't count"); | |
| 1488 return; | |
| 1489 } | |
| 1490 | |
| 1491 // Record that a new block has been merged. | |
| 1492 ++_blocks_merged; | |
| 1493 | |
| 1494 // Make a region if we know there are multiple or unpredictable inputs. | |
| 1495 // (Also, if this is a plain fall-through, we might see another region, | |
| 1496 // which must not be allowed into this block's map.) | |
| 1497 if (pnum > PhiNode::Input // Known multiple inputs. | |
| 1498 || target->is_handler() // These have unpredictable inputs. | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1499 || target->is_loop_head() // Known multiple inputs |
| 0 | 1500 || control()->is_Region()) { // We must hide this guy. |
| 1501 // Add a Region to start the new basic block. Phis will be added | |
| 1502 // later lazily. | |
| 1503 int edges = target->pred_count(); | |
| 1504 if (edges < pnum) edges = pnum; // might be a new path! | |
| 1505 Node *r = new (C, edges+1) RegionNode(edges+1); | |
| 1506 gvn().set_type(r, Type::CONTROL); | |
| 1507 record_for_igvn(r); | |
| 1508 // zap all inputs to NULL for debugging (done in Node(uint) constructor) | |
| 1509 // for (int j = 1; j < edges+1; j++) { r->init_req(j, NULL); } | |
| 1510 r->init_req(pnum, control()); | |
| 1511 set_control(r); | |
| 1512 } | |
| 1513 | |
| 1514 // Convert the existing Parser mapping into a mapping at this bci. | |
| 1515 store_state_to(target); | |
| 1516 assert(target->is_merged(), "do not come here twice"); | |
| 1517 | |
| 1518 } else { // Prior mapping at this bci | |
| 1519 if (TraceOptoParse) { tty->print(" with previous state"); } | |
| 1520 | |
| 1521 // We must not manufacture more phis if the target is already parsed. | |
| 1522 bool nophi = target->is_parsed(); | |
| 1523 | |
| 1524 SafePointNode* newin = map();// Hang on to incoming mapping | |
| 1525 Block* save_block = block(); // Hang on to incoming block; | |
| 1526 load_state_from(target); // Get prior mapping | |
| 1527 | |
| 1528 assert(newin->jvms()->locoff() == jvms()->locoff(), "JVMS layouts agree"); | |
| 1529 assert(newin->jvms()->stkoff() == jvms()->stkoff(), "JVMS layouts agree"); | |
| 1530 assert(newin->jvms()->monoff() == jvms()->monoff(), "JVMS layouts agree"); | |
| 1531 assert(newin->jvms()->endoff() == jvms()->endoff(), "JVMS layouts agree"); | |
| 1532 | |
| 1533 // Iterate over my current mapping and the old mapping. | |
| 1534 // Where different, insert Phi functions. | |
| 1535 // Use any existing Phi functions. | |
| 1536 assert(control()->is_Region(), "must be merging to a region"); | |
| 1537 RegionNode* r = control()->as_Region(); | |
| 1538 | |
| 1539 // Compute where to merge into | |
| 1540 // Merge incoming control path | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1541 r->init_req(pnum, newin->control()); |
| 0 | 1542 |
| 1543 if (pnum == 1) { // Last merge for this Region? | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1544 if (!block()->flow()->is_irreducible_entry()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1545 Node* result = _gvn.transform_no_reclaim(r); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1546 if (r != result && TraceOptoParse) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1547 tty->print_cr("Block #%d replace %d with %d", block()->rpo(), r->_idx, result->_idx); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1548 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1549 } |
| 0 | 1550 record_for_igvn(r); |
| 1551 } | |
| 1552 | |
| 1553 // Update all the non-control inputs to map: | |
| 1554 assert(TypeFunc::Parms == newin->jvms()->locoff(), "parser map should contain only youngest jvms"); | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1555 bool check_elide_phi = target->is_SEL_backedge(save_block); |
| 0 | 1556 for (uint j = 1; j < newin->req(); j++) { |
| 1557 Node* m = map()->in(j); // Current state of target. | |
| 1558 Node* n = newin->in(j); // Incoming change to target state. | |
| 1559 PhiNode* phi; | |
| 1560 if (m->is_Phi() && m->as_Phi()->region() == r) | |
| 1561 phi = m->as_Phi(); | |
| 1562 else | |
| 1563 phi = NULL; | |
| 1564 if (m != n) { // Different; must merge | |
| 1565 switch (j) { | |
| 1566 // Frame pointer and Return Address never changes | |
| 1567 case TypeFunc::FramePtr:// Drop m, use the original value | |
| 1568 case TypeFunc::ReturnAdr: | |
| 1569 break; | |
| 1570 case TypeFunc::Memory: // Merge inputs to the MergeMem node | |
| 1571 assert(phi == NULL, "the merge contains phis, not vice versa"); | |
| 1572 merge_memory_edges(n->as_MergeMem(), pnum, nophi); | |
| 1573 continue; | |
| 1574 default: // All normal stuff | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1575 if (phi == NULL) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1576 if (!check_elide_phi || !target->can_elide_SEL_phi(j)) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1577 phi = ensure_phi(j, nophi); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1578 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1579 } |
| 0 | 1580 break; |
| 1581 } | |
| 1582 } | |
| 1583 // At this point, n might be top if: | |
| 1584 // - there is no phi (because TypeFlow detected a conflict), or | |
| 1585 // - the corresponding control edges is top (a dead incoming path) | |
| 1586 // It is a bug if we create a phi which sees a garbage value on a live path. | |
| 1587 | |
| 1588 if (phi != NULL) { | |
| 1589 assert(n != top() || r->in(pnum) == top(), "live value must not be garbage"); | |
| 1590 assert(phi->region() == r, ""); | |
| 1591 phi->set_req(pnum, n); // Then add 'n' to the merge | |
| 1592 if (pnum == PhiNode::Input) { | |
| 1593 // Last merge for this Phi. | |
| 1594 // So far, Phis have had a reasonable type from ciTypeFlow. | |
| 1595 // Now _gvn will join that with the meet of current inputs. | |
| 1596 // BOTTOM is never permissible here, 'cause pessimistically | |
| 1597 // Phis of pointers cannot lose the basic pointer type. | |
| 1598 debug_only(const Type* bt1 = phi->bottom_type()); | |
| 1599 assert(bt1 != Type::BOTTOM, "should not be building conflict phis"); | |
| 1600 map()->set_req(j, _gvn.transform_no_reclaim(phi)); | |
| 1601 debug_only(const Type* bt2 = phi->bottom_type()); | |
| 1602 assert(bt2->higher_equal(bt1), "must be consistent with type-flow"); | |
| 1603 record_for_igvn(phi); | |
| 1604 } | |
| 1605 } | |
| 1606 } // End of for all values to be merged | |
| 1607 | |
| 1608 if (pnum == PhiNode::Input && | |
| 1609 !r->in(0)) { // The occasional useless Region | |
| 1610 assert(control() == r, ""); | |
| 1611 set_control(r->nonnull_req()); | |
| 1612 } | |
| 1613 | |
| 1614 // newin has been subsumed into the lazy merge, and is now dead. | |
| 1615 set_block(save_block); | |
| 1616 | |
| 1617 stop(); // done with this guy, for now | |
| 1618 } | |
| 1619 | |
| 1620 if (TraceOptoParse) { | |
| 1621 tty->print_cr(" on path %d", pnum); | |
| 1622 } | |
| 1623 | |
| 1624 // Done with this parser state. | |
| 1625 assert(stopped(), ""); | |
| 1626 } | |
| 1627 | |
| 1628 | |
| 1629 //--------------------------merge_memory_edges--------------------------------- | |
| 1630 void Parse::merge_memory_edges(MergeMemNode* n, int pnum, bool nophi) { | |
| 1631 // (nophi means we must not create phis, because we already parsed here) | |
| 1632 assert(n != NULL, ""); | |
| 1633 // Merge the inputs to the MergeMems | |
| 1634 MergeMemNode* m = merged_memory(); | |
| 1635 | |
| 1636 assert(control()->is_Region(), "must be merging to a region"); | |
| 1637 RegionNode* r = control()->as_Region(); | |
| 1638 | |
| 1639 PhiNode* base = NULL; | |
| 1640 MergeMemNode* remerge = NULL; | |
| 1641 for (MergeMemStream mms(m, n); mms.next_non_empty2(); ) { | |
| 1642 Node *p = mms.force_memory(); | |
| 1643 Node *q = mms.memory2(); | |
| 1644 if (mms.is_empty() && nophi) { | |
| 1645 // Trouble: No new splits allowed after a loop body is parsed. | |
| 1646 // Instead, wire the new split into a MergeMem on the backedge. | |
| 1647 // The optimizer will sort it out, slicing the phi. | |
| 1648 if (remerge == NULL) { | |
| 1649 assert(base != NULL, ""); | |
| 1650 assert(base->in(0) != NULL, "should not be xformed away"); | |
| 1651 remerge = MergeMemNode::make(C, base->in(pnum)); | |
| 1652 gvn().set_type(remerge, Type::MEMORY); | |
| 1653 base->set_req(pnum, remerge); | |
| 1654 } | |
| 1655 remerge->set_memory_at(mms.alias_idx(), q); | |
| 1656 continue; | |
| 1657 } | |
| 1658 assert(!q->is_MergeMem(), ""); | |
| 1659 PhiNode* phi; | |
| 1660 if (p != q) { | |
| 1661 phi = ensure_memory_phi(mms.alias_idx(), nophi); | |
| 1662 } else { | |
| 1663 if (p->is_Phi() && p->as_Phi()->region() == r) | |
| 1664 phi = p->as_Phi(); | |
| 1665 else | |
| 1666 phi = NULL; | |
| 1667 } | |
| 1668 // Insert q into local phi | |
| 1669 if (phi != NULL) { | |
| 1670 assert(phi->region() == r, ""); | |
| 1671 p = phi; | |
| 1672 phi->set_req(pnum, q); | |
| 1673 if (mms.at_base_memory()) { | |
| 1674 base = phi; // delay transforming it | |
| 1675 } else if (pnum == 1) { | |
| 1676 record_for_igvn(phi); | |
| 1677 p = _gvn.transform_no_reclaim(phi); | |
| 1678 } | |
| 1679 mms.set_memory(p);// store back through the iterator | |
| 1680 } | |
| 1681 } | |
| 1682 // Transform base last, in case we must fiddle with remerging. | |
| 1683 if (base != NULL && pnum == 1) { | |
| 1684 record_for_igvn(base); | |
| 1685 m->set_base_memory( _gvn.transform_no_reclaim(base) ); | |
| 1686 } | |
| 1687 } | |
| 1688 | |
| 1689 | |
| 1690 //------------------------ensure_phis_everywhere------------------------------- | |
| 1691 void Parse::ensure_phis_everywhere() { | |
| 1692 ensure_phi(TypeFunc::I_O); | |
| 1693 | |
| 1694 // Ensure a phi on all currently known memories. | |
| 1695 for (MergeMemStream mms(merged_memory()); mms.next_non_empty(); ) { | |
| 1696 ensure_memory_phi(mms.alias_idx()); | |
| 1697 debug_only(mms.set_memory()); // keep the iterator happy | |
| 1698 } | |
| 1699 | |
| 1700 // Note: This is our only chance to create phis for memory slices. | |
| 1701 // If we miss a slice that crops up later, it will have to be | |
| 1702 // merged into the base-memory phi that we are building here. | |
| 1703 // Later, the optimizer will comb out the knot, and build separate | |
| 1704 // phi-loops for each memory slice that matters. | |
| 1705 | |
| 1706 // Monitors must nest nicely and not get confused amongst themselves. | |
| 1707 // Phi-ify everything up to the monitors, though. | |
| 1708 uint monoff = map()->jvms()->monoff(); | |
| 1709 uint nof_monitors = map()->jvms()->nof_monitors(); | |
| 1710 | |
| 1711 assert(TypeFunc::Parms == map()->jvms()->locoff(), "parser map should contain only youngest jvms"); | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1712 bool check_elide_phi = block()->is_SEL_head(); |
| 0 | 1713 for (uint i = TypeFunc::Parms; i < monoff; i++) { |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1714 if (!check_elide_phi || !block()->can_elide_SEL_phi(i)) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1715 ensure_phi(i); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1716 } |
| 0 | 1717 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1718 |
| 0 | 1719 // Even monitors need Phis, though they are well-structured. |
| 1720 // This is true for OSR methods, and also for the rare cases where | |
| 1721 // a monitor object is the subject of a replace_in_map operation. | |
| 1722 // See bugs 4426707 and 5043395. | |
| 1723 for (uint m = 0; m < nof_monitors; m++) { | |
| 1724 ensure_phi(map()->jvms()->monitor_obj_offset(m)); | |
| 1725 } | |
| 1726 } | |
| 1727 | |
| 1728 | |
| 1729 //-----------------------------add_new_path------------------------------------ | |
| 1730 // Add a previously unaccounted predecessor to this block. | |
| 1731 int Parse::Block::add_new_path() { | |
| 1732 // If there is no map, return the lowest unused path number. | |
| 1733 if (!is_merged()) return pred_count()+1; // there will be a map shortly | |
| 1734 | |
| 1735 SafePointNode* map = start_map(); | |
| 1736 if (!map->control()->is_Region()) | |
| 1737 return pred_count()+1; // there may be a region some day | |
| 1738 RegionNode* r = map->control()->as_Region(); | |
| 1739 | |
| 1740 // Add new path to the region. | |
| 1741 uint pnum = r->req(); | |
| 1742 r->add_req(NULL); | |
| 1743 | |
| 1744 for (uint i = 1; i < map->req(); i++) { | |
| 1745 Node* n = map->in(i); | |
| 1746 if (i == TypeFunc::Memory) { | |
| 1747 // Ensure a phi on all currently known memories. | |
| 1748 for (MergeMemStream mms(n->as_MergeMem()); mms.next_non_empty(); ) { | |
| 1749 Node* phi = mms.memory(); | |
| 1750 if (phi->is_Phi() && phi->as_Phi()->region() == r) { | |
| 1751 assert(phi->req() == pnum, "must be same size as region"); | |
| 1752 phi->add_req(NULL); | |
| 1753 } | |
| 1754 } | |
| 1755 } else { | |
| 1756 if (n->is_Phi() && n->as_Phi()->region() == r) { | |
| 1757 assert(n->req() == pnum, "must be same size as region"); | |
| 1758 n->add_req(NULL); | |
| 1759 } | |
| 1760 } | |
| 1761 } | |
| 1762 | |
| 1763 return pnum; | |
| 1764 } | |
| 1765 | |
| 1766 //------------------------------ensure_phi------------------------------------- | |
| 1767 // Turn the idx'th entry of the current map into a Phi | |
| 1768 PhiNode *Parse::ensure_phi(int idx, bool nocreate) { | |
| 1769 SafePointNode* map = this->map(); | |
| 1770 Node* region = map->control(); | |
| 1771 assert(region->is_Region(), ""); | |
| 1772 | |
| 1773 Node* o = map->in(idx); | |
| 1774 assert(o != NULL, ""); | |
| 1775 | |
| 1776 if (o == top()) return NULL; // TOP always merges into TOP | |
| 1777 | |
| 1778 if (o->is_Phi() && o->as_Phi()->region() == region) { | |
| 1779 return o->as_Phi(); | |
| 1780 } | |
| 1781 | |
| 1782 // Now use a Phi here for merging | |
| 1783 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1784 const JVMState* jvms = map->jvms(); | |
| 1785 const Type* t; | |
| 1786 if (jvms->is_loc(idx)) { | |
| 1787 t = block()->local_type_at(idx - jvms->locoff()); | |
| 1788 } else if (jvms->is_stk(idx)) { | |
| 1789 t = block()->stack_type_at(idx - jvms->stkoff()); | |
| 1790 } else if (jvms->is_mon(idx)) { | |
| 1791 assert(!jvms->is_monitor_box(idx), "no phis for boxes"); | |
| 1792 t = TypeInstPtr::BOTTOM; // this is sufficient for a lock object | |
| 1793 } else if ((uint)idx < TypeFunc::Parms) { | |
| 1794 t = o->bottom_type(); // Type::RETURN_ADDRESS or such-like. | |
| 1795 } else { | |
| 1796 assert(false, "no type information for this phi"); | |
| 1797 } | |
| 1798 | |
| 1799 // If the type falls to bottom, then this must be a local that | |
| 1800 // is mixing ints and oops or some such. Forcing it to top | |
| 1801 // makes it go dead. | |
| 1802 if (t == Type::BOTTOM) { | |
| 1803 map->set_req(idx, top()); | |
| 1804 return NULL; | |
| 1805 } | |
| 1806 | |
| 1807 // Do not create phis for top either. | |
| 1808 // A top on a non-null control flow must be an unused even after the.phi. | |
| 1809 if (t == Type::TOP || t == Type::HALF) { | |
| 1810 map->set_req(idx, top()); | |
| 1811 return NULL; | |
| 1812 } | |
| 1813 | |
| 1814 PhiNode* phi = PhiNode::make(region, o, t); | |
| 1815 gvn().set_type(phi, t); | |
|
38
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
1816 if (C->do_escape_analysis()) record_for_igvn(phi); |
| 0 | 1817 map->set_req(idx, phi); |
| 1818 return phi; | |
| 1819 } | |
| 1820 | |
| 1821 //--------------------------ensure_memory_phi---------------------------------- | |
| 1822 // Turn the idx'th slice of the current memory into a Phi | |
| 1823 PhiNode *Parse::ensure_memory_phi(int idx, bool nocreate) { | |
| 1824 MergeMemNode* mem = merged_memory(); | |
| 1825 Node* region = control(); | |
| 1826 assert(region->is_Region(), ""); | |
| 1827 | |
| 1828 Node *o = (idx == Compile::AliasIdxBot)? mem->base_memory(): mem->memory_at(idx); | |
| 1829 assert(o != NULL && o != top(), ""); | |
| 1830 | |
| 1831 PhiNode* phi; | |
| 1832 if (o->is_Phi() && o->as_Phi()->region() == region) { | |
| 1833 phi = o->as_Phi(); | |
| 1834 if (phi == mem->base_memory() && idx >= Compile::AliasIdxRaw) { | |
| 1835 // clone the shared base memory phi to make a new memory split | |
| 1836 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1837 const Type* t = phi->bottom_type(); | |
| 1838 const TypePtr* adr_type = C->get_adr_type(idx); | |
| 1839 phi = phi->slice_memory(adr_type); | |
| 1840 gvn().set_type(phi, t); | |
| 1841 } | |
| 1842 return phi; | |
| 1843 } | |
| 1844 | |
| 1845 // Now use a Phi here for merging | |
| 1846 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1847 const Type* t = o->bottom_type(); | |
| 1848 const TypePtr* adr_type = C->get_adr_type(idx); | |
| 1849 phi = PhiNode::make(region, o, t, adr_type); | |
| 1850 gvn().set_type(phi, t); | |
| 1851 if (idx == Compile::AliasIdxBot) | |
| 1852 mem->set_base_memory(phi); | |
| 1853 else | |
| 1854 mem->set_memory_at(idx, phi); | |
| 1855 return phi; | |
| 1856 } | |
| 1857 | |
| 1858 //------------------------------call_register_finalizer----------------------- | |
| 1859 // Check the klass of the receiver and call register_finalizer if the | |
| 1860 // class need finalization. | |
| 1861 void Parse::call_register_finalizer() { | |
| 1862 Node* receiver = local(0); | |
| 1863 assert(receiver != NULL && receiver->bottom_type()->isa_instptr() != NULL, | |
| 1864 "must have non-null instance type"); | |
| 1865 | |
| 1866 const TypeInstPtr *tinst = receiver->bottom_type()->isa_instptr(); | |
| 1867 if (tinst != NULL && tinst->klass()->is_loaded() && !tinst->klass_is_exact()) { | |
| 1868 // The type isn't known exactly so see if CHA tells us anything. | |
| 1869 ciInstanceKlass* ik = tinst->klass()->as_instance_klass(); | |
| 1870 if (!Dependencies::has_finalizable_subclass(ik)) { | |
| 1871 // No finalizable subclasses so skip the dynamic check. | |
| 1872 C->dependencies()->assert_has_no_finalizable_subclasses(ik); | |
| 1873 return; | |
| 1874 } | |
| 1875 } | |
| 1876 | |
| 1877 // Insert a dynamic test for whether the instance needs | |
| 1878 // finalization. In general this will fold up since the concrete | |
| 1879 // class is often visible so the access flags are constant. | |
| 1880 Node* klass_addr = basic_plus_adr( receiver, receiver, oopDesc::klass_offset_in_bytes() ); | |
|
164
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
38
diff
changeset
|
1881 Node* klass = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), klass_addr, TypeInstPtr::KLASS) ); |
| 0 | 1882 |
| 1883 Node* access_flags_addr = basic_plus_adr(klass, klass, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc)); | |
| 1884 Node* access_flags = make_load(NULL, access_flags_addr, TypeInt::INT, T_INT); | |
| 1885 | |
| 1886 Node* mask = _gvn.transform(new (C, 3) AndINode(access_flags, intcon(JVM_ACC_HAS_FINALIZER))); | |
| 1887 Node* check = _gvn.transform(new (C, 3) CmpINode(mask, intcon(0))); | |
| 1888 Node* test = _gvn.transform(new (C, 2) BoolNode(check, BoolTest::ne)); | |
| 1889 | |
| 1890 IfNode* iff = create_and_map_if(control(), test, PROB_MAX, COUNT_UNKNOWN); | |
| 1891 | |
| 1892 RegionNode* result_rgn = new (C, 3) RegionNode(3); | |
| 1893 record_for_igvn(result_rgn); | |
| 1894 | |
| 1895 Node *skip_register = _gvn.transform(new (C, 1) IfFalseNode(iff)); | |
| 1896 result_rgn->init_req(1, skip_register); | |
| 1897 | |
| 1898 Node *needs_register = _gvn.transform(new (C, 1) IfTrueNode(iff)); | |
| 1899 set_control(needs_register); | |
| 1900 if (stopped()) { | |
| 1901 // There is no slow path. | |
| 1902 result_rgn->init_req(2, top()); | |
| 1903 } else { | |
| 1904 Node *call = make_runtime_call(RC_NO_LEAF, | |
| 1905 OptoRuntime::register_finalizer_Type(), | |
| 1906 OptoRuntime::register_finalizer_Java(), | |
| 1907 NULL, TypePtr::BOTTOM, | |
| 1908 receiver); | |
| 1909 make_slow_call_ex(call, env()->Throwable_klass(), true); | |
| 1910 | |
| 1911 Node* fast_io = call->in(TypeFunc::I_O); | |
| 1912 Node* fast_mem = call->in(TypeFunc::Memory); | |
| 1913 // These two phis are pre-filled with copies of of the fast IO and Memory | |
| 1914 Node* io_phi = PhiNode::make(result_rgn, fast_io, Type::ABIO); | |
| 1915 Node* mem_phi = PhiNode::make(result_rgn, fast_mem, Type::MEMORY, TypePtr::BOTTOM); | |
| 1916 | |
| 1917 result_rgn->init_req(2, control()); | |
| 1918 io_phi ->init_req(2, i_o()); | |
| 1919 mem_phi ->init_req(2, reset_memory()); | |
| 1920 | |
| 1921 set_all_memory( _gvn.transform(mem_phi) ); | |
| 1922 set_i_o( _gvn.transform(io_phi) ); | |
| 1923 } | |
| 1924 | |
| 1925 set_control( _gvn.transform(result_rgn) ); | |
| 1926 } | |
| 1927 | |
| 1928 //------------------------------return_current--------------------------------- | |
| 1929 // Append current _map to _exit_return | |
| 1930 void Parse::return_current(Node* value) { | |
| 1931 if (RegisterFinalizersAtInit && | |
| 1932 method()->intrinsic_id() == vmIntrinsics::_Object_init) { | |
| 1933 call_register_finalizer(); | |
| 1934 } | |
| 1935 | |
| 1936 // Do not set_parse_bci, so that return goo is credited to the return insn. | |
| 1937 set_bci(InvocationEntryBci); | |
| 1938 if (method()->is_synchronized() && GenerateSynchronizationCode) { | |
| 1939 shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node()); | |
| 1940 } | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
1941 if (C->env()->dtrace_method_probes()) { |
| 0 | 1942 make_dtrace_method_exit(method()); |
| 1943 } | |
| 1944 SafePointNode* exit_return = _exits.map(); | |
| 1945 exit_return->in( TypeFunc::Control )->add_req( control() ); | |
| 1946 exit_return->in( TypeFunc::I_O )->add_req( i_o () ); | |
| 1947 Node *mem = exit_return->in( TypeFunc::Memory ); | |
| 1948 for (MergeMemStream mms(mem->as_MergeMem(), merged_memory()); mms.next_non_empty2(); ) { | |
| 1949 if (mms.is_empty()) { | |
| 1950 // get a copy of the base memory, and patch just this one input | |
| 1951 const TypePtr* adr_type = mms.adr_type(C); | |
| 1952 Node* phi = mms.force_memory()->as_Phi()->slice_memory(adr_type); | |
| 1953 assert(phi->as_Phi()->region() == mms.base_memory()->in(0), ""); | |
| 1954 gvn().set_type_bottom(phi); | |
| 1955 phi->del_req(phi->req()-1); // prepare to re-patch | |
| 1956 mms.set_memory(phi); | |
| 1957 } | |
| 1958 mms.memory()->add_req(mms.memory2()); | |
| 1959 } | |
| 1960 | |
| 1961 // frame pointer is always same, already captured | |
| 1962 if (value != NULL) { | |
| 1963 // If returning oops to an interface-return, there is a silent free | |
| 1964 // cast from oop to interface allowed by the Verifier. Make it explicit | |
| 1965 // here. | |
| 1966 Node* phi = _exits.argument(0); | |
| 1967 const TypeInstPtr *tr = phi->bottom_type()->isa_instptr(); | |
| 1968 if( tr && tr->klass()->is_loaded() && | |
| 1969 tr->klass()->is_interface() ) { | |
| 1970 const TypeInstPtr *tp = value->bottom_type()->isa_instptr(); | |
| 1971 if (tp && tp->klass()->is_loaded() && | |
| 1972 !tp->klass()->is_interface()) { | |
| 1973 // sharpen the type eagerly; this eases certain assert checking | |
| 1974 if (tp->higher_equal(TypeInstPtr::NOTNULL)) | |
| 1975 tr = tr->join(TypeInstPtr::NOTNULL)->is_instptr(); | |
| 1976 value = _gvn.transform(new (C, 2) CheckCastPPNode(0,value,tr)); | |
| 1977 } | |
| 1978 } | |
| 1979 phi->add_req(value); | |
| 1980 } | |
| 1981 | |
| 1982 stop_and_kill_map(); // This CFG path dies here | |
| 1983 } | |
| 1984 | |
| 1985 | |
| 1986 //------------------------------add_safepoint---------------------------------- | |
| 1987 void Parse::add_safepoint() { | |
| 1988 // See if we can avoid this safepoint. No need for a SafePoint immediately | |
| 1989 // after a Call (except Leaf Call) or another SafePoint. | |
| 1990 Node *proj = control(); | |
| 1991 bool add_poll_param = SafePointNode::needs_polling_address_input(); | |
| 1992 uint parms = add_poll_param ? TypeFunc::Parms+1 : TypeFunc::Parms; | |
| 1993 if( proj->is_Proj() ) { | |
| 1994 Node *n0 = proj->in(0); | |
| 1995 if( n0->is_Catch() ) { | |
| 1996 n0 = n0->in(0)->in(0); | |
| 1997 assert( n0->is_Call(), "expect a call here" ); | |
| 1998 } | |
| 1999 if( n0->is_Call() ) { | |
| 2000 if( n0->as_Call()->guaranteed_safepoint() ) | |
| 2001 return; | |
| 2002 } else if( n0->is_SafePoint() && n0->req() >= parms ) { | |
| 2003 return; | |
| 2004 } | |
| 2005 } | |
| 2006 | |
| 2007 // Clear out dead values from the debug info. | |
| 2008 kill_dead_locals(); | |
| 2009 | |
| 2010 // Clone the JVM State | |
| 2011 SafePointNode *sfpnt = new (C, parms) SafePointNode(parms, NULL); | |
| 2012 | |
| 2013 // Capture memory state BEFORE a SafePoint. Since we can block at a | |
| 2014 // SafePoint we need our GC state to be safe; i.e. we need all our current | |
| 2015 // write barriers (card marks) to not float down after the SafePoint so we | |
| 2016 // must read raw memory. Likewise we need all oop stores to match the card | |
| 2017 // marks. If deopt can happen, we need ALL stores (we need the correct JVM | |
| 2018 // state on a deopt). | |
| 2019 | |
| 2020 // We do not need to WRITE the memory state after a SafePoint. The control | |
| 2021 // edge will keep card-marks and oop-stores from floating up from below a | |
| 2022 // SafePoint and our true dependency added here will keep them from floating | |
| 2023 // down below a SafePoint. | |
| 2024 | |
| 2025 // Clone the current memory state | |
| 2026 Node* mem = MergeMemNode::make(C, map()->memory()); | |
| 2027 | |
| 2028 mem = _gvn.transform(mem); | |
| 2029 | |
| 2030 // Pass control through the safepoint | |
| 2031 sfpnt->init_req(TypeFunc::Control , control()); | |
| 2032 // Fix edges normally used by a call | |
| 2033 sfpnt->init_req(TypeFunc::I_O , top() ); | |
| 2034 sfpnt->init_req(TypeFunc::Memory , mem ); | |
| 2035 sfpnt->init_req(TypeFunc::ReturnAdr, top() ); | |
| 2036 sfpnt->init_req(TypeFunc::FramePtr , top() ); | |
| 2037 | |
| 2038 // Create a node for the polling address | |
| 2039 if( add_poll_param ) { | |
| 2040 Node *polladr = ConPNode::make(C, (address)os::get_polling_page()); | |
| 2041 sfpnt->init_req(TypeFunc::Parms+0, _gvn.transform(polladr)); | |
| 2042 } | |
| 2043 | |
| 2044 // Fix up the JVM State edges | |
| 2045 add_safepoint_edges(sfpnt); | |
| 2046 Node *transformed_sfpnt = _gvn.transform(sfpnt); | |
| 2047 set_control(transformed_sfpnt); | |
| 2048 | |
| 2049 // Provide an edge from root to safepoint. This makes the safepoint | |
| 2050 // appear useful until the parse has completed. | |
| 2051 if( OptoRemoveUseless && transformed_sfpnt->is_SafePoint() ) { | |
| 2052 assert(C->root() != NULL, "Expect parse is still valid"); | |
| 2053 C->root()->add_prec(transformed_sfpnt); | |
| 2054 } | |
| 2055 } | |
| 2056 | |
| 1172 | 2057 //------------------------------should_add_predicate-------------------------- |
| 2058 bool Parse::should_add_predicate(int target_bci) { | |
| 2059 if (!UseLoopPredicate) return false; | |
| 2060 Block* target = successor_for_bci(target_bci); | |
| 2061 if (target != NULL && | |
| 2062 target->is_loop_head() && | |
| 2063 block()->rpo() < target->rpo()) { | |
| 2064 return true; | |
| 2065 } | |
| 2066 return false; | |
| 2067 } | |
| 2068 | |
| 2069 //------------------------------add_predicate--------------------------------- | |
| 2070 void Parse::add_predicate() { | |
| 2071 assert(UseLoopPredicate,"use only for loop predicate"); | |
| 2072 Node *cont = _gvn.intcon(1); | |
| 2073 Node* opq = _gvn.transform(new (C, 2) Opaque1Node(C, cont)); | |
| 2074 Node *bol = _gvn.transform(new (C, 2) Conv2BNode(opq)); | |
| 2075 IfNode* iff = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN); | |
| 2076 Node* iffalse = _gvn.transform(new (C, 1) IfFalseNode(iff)); | |
| 2077 C->add_predicate_opaq(opq); | |
| 2078 { | |
| 2079 PreserveJVMState pjvms(this); | |
| 2080 set_control(iffalse); | |
| 2081 uncommon_trap(Deoptimization::Reason_predicate, | |
| 2082 Deoptimization::Action_maybe_recompile); | |
| 2083 } | |
| 2084 Node* iftrue = _gvn.transform(new (C, 1) IfTrueNode(iff)); | |
| 2085 set_control(iftrue); | |
| 2086 } | |
| 2087 | |
| 0 | 2088 #ifndef PRODUCT |
| 2089 //------------------------show_parse_info-------------------------------------- | |
| 2090 void Parse::show_parse_info() { | |
| 2091 InlineTree* ilt = NULL; | |
| 2092 if (C->ilt() != NULL) { | |
| 2093 JVMState* caller_jvms = is_osr_parse() ? caller()->caller() : caller(); | |
| 2094 ilt = InlineTree::find_subtree_from_root(C->ilt(), caller_jvms, method()); | |
| 2095 } | |
| 2096 if (PrintCompilation && Verbose) { | |
| 2097 if (depth() == 1) { | |
| 2098 if( ilt->count_inlines() ) { | |
| 2099 tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(), | |
| 2100 ilt->count_inline_bcs()); | |
| 2101 tty->cr(); | |
| 2102 } | |
| 2103 } else { | |
| 2104 if (method()->is_synchronized()) tty->print("s"); | |
| 2105 if (method()->has_exception_handlers()) tty->print("!"); | |
| 2106 // Check this is not the final compiled version | |
| 2107 if (C->trap_can_recompile()) { | |
| 2108 tty->print("-"); | |
| 2109 } else { | |
| 2110 tty->print(" "); | |
| 2111 } | |
| 2112 method()->print_short_name(); | |
| 2113 if (is_osr_parse()) { | |
| 2114 tty->print(" @ %d", osr_bci()); | |
| 2115 } | |
| 2116 tty->print(" (%d bytes)",method()->code_size()); | |
| 2117 if (ilt->count_inlines()) { | |
| 2118 tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(), | |
| 2119 ilt->count_inline_bcs()); | |
| 2120 } | |
| 2121 tty->cr(); | |
| 2122 } | |
| 2123 } | |
| 2124 if (PrintOpto && (depth() == 1 || PrintOptoInlining)) { | |
| 2125 // Print that we succeeded; suppress this message on the first osr parse. | |
| 2126 | |
| 2127 if (method()->is_synchronized()) tty->print("s"); | |
| 2128 if (method()->has_exception_handlers()) tty->print("!"); | |
| 2129 // Check this is not the final compiled version | |
| 2130 if (C->trap_can_recompile() && depth() == 1) { | |
| 2131 tty->print("-"); | |
| 2132 } else { | |
| 2133 tty->print(" "); | |
| 2134 } | |
| 2135 if( depth() != 1 ) { tty->print(" "); } // missing compile count | |
| 2136 for (int i = 1; i < depth(); ++i) { tty->print(" "); } | |
| 2137 method()->print_short_name(); | |
| 2138 if (is_osr_parse()) { | |
| 2139 tty->print(" @ %d", osr_bci()); | |
| 2140 } | |
| 2141 if (ilt->caller_bci() != -1) { | |
| 2142 tty->print(" @ %d", ilt->caller_bci()); | |
| 2143 } | |
| 2144 tty->print(" (%d bytes)",method()->code_size()); | |
| 2145 if (ilt->count_inlines()) { | |
| 2146 tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(), | |
| 2147 ilt->count_inline_bcs()); | |
| 2148 } | |
| 2149 tty->cr(); | |
| 2150 } | |
| 2151 } | |
| 2152 | |
| 2153 | |
| 2154 //------------------------------dump------------------------------------------- | |
| 2155 // Dump information associated with the bytecodes of current _method | |
| 2156 void Parse::dump() { | |
| 2157 if( method() != NULL ) { | |
| 2158 // Iterate over bytecodes | |
| 2159 ciBytecodeStream iter(method()); | |
| 2160 for( Bytecodes::Code bc = iter.next(); bc != ciBytecodeStream::EOBC() ; bc = iter.next() ) { | |
| 2161 dump_bci( iter.cur_bci() ); | |
| 2162 tty->cr(); | |
| 2163 } | |
| 2164 } | |
| 2165 } | |
| 2166 | |
| 2167 // Dump information associated with a byte code index, 'bci' | |
| 2168 void Parse::dump_bci(int bci) { | |
| 2169 // Output info on merge-points, cloning, and within _jsr..._ret | |
| 2170 // NYI | |
| 2171 tty->print(" bci:%d", bci); | |
| 2172 } | |
| 2173 | |
| 2174 #endif |