Mercurial > hg > truffle
annotate src/share/vm/opto/parse1.cpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | bad7ecd0b6ed |
| children | 069ab3f976d3 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2383
diff
changeset
|
2 * Copyright (c) 1997, 2011, 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 |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
640 if (block->is_SEL_head() && |
| 3345 | 641 (UseLoopPredicate || LoopLimitCheck)) { |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
642 // Add predicate to single entry (not irreducible) loop head. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
643 assert(!block->has_merged_backedge(), "only entry paths should be merged for now"); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
644 // Need correct bci for predicate. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
645 // It is fine to set it here since do_one_block() will set it anyway. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
646 set_parse_bci(block->start()); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
647 add_predicate(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
648 // Add new region for back branches. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
649 int edges = block->pred_count() - block->preds_parsed() + 1; // +1 for original region |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
650 RegionNode *r = new (C, edges+1) RegionNode(edges+1); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
651 _gvn.set_type(r, Type::CONTROL); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
652 record_for_igvn(r); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
653 r->init_req(edges, control()); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
654 set_control(r); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
655 // Add new phis. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
656 ensure_phis_everywhere(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
657 } |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
658 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
659 // 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
|
660 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
|
661 } |
| 0 | 662 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
663 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
|
664 // 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
|
665 // associated with a merge that doesn't involve a backedge can |
| 605 | 666 // 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
|
667 // 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
|
668 // 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
|
669 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
|
670 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
|
671 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
|
672 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
|
673 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
674 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
|
675 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
|
676 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
677 } |
| 0 | 678 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
679 // 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
|
680 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
|
681 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
682 // 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
|
683 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
|
684 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
685 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
686 // 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
|
687 if (!has_irreducible || !progress) { |
| 0 | 688 break; |
| 689 } | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
690 } |
| 0 | 691 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
692 blocks_seen += block_count(); |
| 0 | 693 |
| 694 #ifndef PRODUCT | |
| 695 // Make sure there are no half-processed blocks remaining. | |
| 696 // 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
|
697 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
|
698 Block* block = rpo_at(rpo); |
| 0 | 699 if (!block->is_parsed()) { |
| 700 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
|
701 tty->print_cr("Skipped dead block %d at bci:%d", rpo, block->start()); |
| 0 | 702 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
703 assert(!block->is_merged(), "no half-processed blocks"); |
| 0 | 704 } |
| 705 } | |
| 706 #endif | |
| 707 } | |
| 708 | |
| 709 //-------------------------------build_exits---------------------------------- | |
| 710 // Build normal and exceptional exit merge points. | |
| 711 void Parse::build_exits() { | |
| 712 // make a clone of caller to prevent sharing of side-effects | |
| 713 _exits.set_map(_exits.clone_map()); | |
| 714 _exits.clean_stack(_exits.sp()); | |
| 715 _exits.sync_jvms(); | |
| 716 | |
| 717 RegionNode* region = new (C, 1) RegionNode(1); | |
| 718 record_for_igvn(region); | |
| 719 gvn().set_type_bottom(region); | |
| 720 _exits.set_control(region); | |
| 721 | |
| 722 // Note: iophi and memphi are not transformed until do_exits. | |
| 723 Node* iophi = new (C, region->req()) PhiNode(region, Type::ABIO); | |
| 724 Node* memphi = new (C, region->req()) PhiNode(region, Type::MEMORY, TypePtr::BOTTOM); | |
| 725 _exits.set_i_o(iophi); | |
| 726 _exits.set_all_memory(memphi); | |
| 727 | |
| 728 // Add a return value to the exit state. (Do not push it yet.) | |
| 729 if (tf()->range()->cnt() > TypeFunc::Parms) { | |
| 730 const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms); | |
| 731 // Don't "bind" an unloaded return klass to the ret_phi. If the klass | |
| 732 // becomes loaded during the subsequent parsing, the loaded and unloaded | |
| 733 // types will not join when we transform and push in do_exits(). | |
| 734 const TypeOopPtr* ret_oop_type = ret_type->isa_oopptr(); | |
| 735 if (ret_oop_type && !ret_oop_type->klass()->is_loaded()) { | |
| 736 ret_type = TypeOopPtr::BOTTOM; | |
| 737 } | |
| 738 int ret_size = type2size[ret_type->basic_type()]; | |
| 739 Node* ret_phi = new (C, region->req()) PhiNode(region, ret_type); | |
| 740 _exits.ensure_stack(ret_size); | |
| 741 assert((int)(tf()->range()->cnt() - TypeFunc::Parms) == ret_size, "good tf range"); | |
| 742 assert(method()->return_type()->size() == ret_size, "tf agrees w/ method"); | |
| 743 _exits.set_argument(0, ret_phi); // here is where the parser finds it | |
| 744 // Note: ret_phi is not yet pushed, until do_exits. | |
| 745 } | |
| 746 } | |
| 747 | |
| 748 | |
| 749 //----------------------------build_start_state------------------------------- | |
| 750 // Construct a state which contains only the incoming arguments from an | |
| 751 // unknown caller. The method & bci will be NULL & InvocationEntryBci. | |
| 752 JVMState* Compile::build_start_state(StartNode* start, const TypeFunc* tf) { | |
| 753 int arg_size = tf->domain()->cnt(); | |
| 754 int max_size = MAX2(arg_size, (int)tf->range()->cnt()); | |
| 755 JVMState* jvms = new (this) JVMState(max_size - TypeFunc::Parms); | |
| 756 SafePointNode* map = new (this, max_size) SafePointNode(max_size, NULL); | |
| 757 record_for_igvn(map); | |
| 758 assert(arg_size == TypeFunc::Parms + (is_osr_compilation() ? 1 : method()->arg_size()), "correct arg_size"); | |
| 759 Node_Notes* old_nn = default_node_notes(); | |
| 760 if (old_nn != NULL && has_method()) { | |
| 761 Node_Notes* entry_nn = old_nn->clone(this); | |
| 762 JVMState* entry_jvms = new(this) JVMState(method(), old_nn->jvms()); | |
| 763 entry_jvms->set_offsets(0); | |
| 764 entry_jvms->set_bci(entry_bci()); | |
| 765 entry_nn->set_jvms(entry_jvms); | |
| 766 set_default_node_notes(entry_nn); | |
| 767 } | |
| 768 uint i; | |
| 769 for (i = 0; i < (uint)arg_size; i++) { | |
| 770 Node* parm = initial_gvn()->transform(new (this, 1) ParmNode(start, i)); | |
| 771 map->init_req(i, parm); | |
| 772 // Record all these guys for later GVN. | |
| 773 record_for_igvn(parm); | |
| 774 } | |
| 775 for (; i < map->req(); i++) { | |
| 776 map->init_req(i, top()); | |
| 777 } | |
| 778 assert(jvms->argoff() == TypeFunc::Parms, "parser gets arguments here"); | |
| 779 set_default_node_notes(old_nn); | |
| 780 map->set_jvms(jvms); | |
| 781 jvms->set_map(map); | |
| 782 return jvms; | |
| 783 } | |
| 784 | |
| 785 //-----------------------------make_node_notes--------------------------------- | |
| 786 Node_Notes* Parse::make_node_notes(Node_Notes* caller_nn) { | |
| 787 if (caller_nn == NULL) return NULL; | |
| 788 Node_Notes* nn = caller_nn->clone(C); | |
| 789 JVMState* caller_jvms = nn->jvms(); | |
| 790 JVMState* jvms = new (C) JVMState(method(), caller_jvms); | |
| 791 jvms->set_offsets(0); | |
| 792 jvms->set_bci(_entry_bci); | |
| 793 nn->set_jvms(jvms); | |
| 794 return nn; | |
| 795 } | |
| 796 | |
| 797 | |
| 798 //--------------------------return_values-------------------------------------- | |
| 799 void Compile::return_values(JVMState* jvms) { | |
| 800 GraphKit kit(jvms); | |
| 801 Node* ret = new (this, TypeFunc::Parms) ReturnNode(TypeFunc::Parms, | |
| 802 kit.control(), | |
| 803 kit.i_o(), | |
| 804 kit.reset_memory(), | |
| 805 kit.frameptr(), | |
| 806 kit.returnadr()); | |
| 807 // Add zero or 1 return values | |
| 808 int ret_size = tf()->range()->cnt() - TypeFunc::Parms; | |
| 809 if (ret_size > 0) { | |
| 810 kit.inc_sp(-ret_size); // pop the return value(s) | |
| 811 kit.sync_jvms(); | |
| 812 ret->add_req(kit.argument(0)); | |
| 813 // Note: The second dummy edge is not needed by a ReturnNode. | |
| 814 } | |
| 815 // bind it to root | |
| 816 root()->add_req(ret); | |
| 817 record_for_igvn(ret); | |
| 818 initial_gvn()->transform_no_reclaim(ret); | |
| 819 } | |
| 820 | |
| 821 //------------------------rethrow_exceptions----------------------------------- | |
| 822 // Bind all exception states in the list into a single RethrowNode. | |
| 823 void Compile::rethrow_exceptions(JVMState* jvms) { | |
| 824 GraphKit kit(jvms); | |
| 825 if (!kit.has_exceptions()) return; // nothing to generate | |
| 826 // Load my combined exception state into the kit, with all phis transformed: | |
| 827 SafePointNode* ex_map = kit.combine_and_pop_all_exception_states(); | |
| 828 Node* ex_oop = kit.use_exception_state(ex_map); | |
| 829 RethrowNode* exit = new (this, TypeFunc::Parms + 1) RethrowNode(kit.control(), | |
| 830 kit.i_o(), kit.reset_memory(), | |
| 831 kit.frameptr(), kit.returnadr(), | |
| 832 // like a return but with exception input | |
| 833 ex_oop); | |
| 834 // bind to root | |
| 835 root()->add_req(exit); | |
| 836 record_for_igvn(exit); | |
| 837 initial_gvn()->transform_no_reclaim(exit); | |
| 838 } | |
| 839 | |
| 840 //---------------------------do_exceptions------------------------------------- | |
| 841 // Process exceptions arising from the current bytecode. | |
| 842 // Send caught exceptions to the proper handler within this method. | |
| 843 // Unhandled exceptions feed into _exit. | |
| 844 void Parse::do_exceptions() { | |
| 845 if (!has_exceptions()) return; | |
| 846 | |
| 847 if (failing()) { | |
| 848 // Pop them all off and throw them away. | |
| 849 while (pop_exception_state() != NULL) ; | |
| 850 return; | |
| 851 } | |
| 852 | |
| 853 PreserveJVMState pjvms(this, false); | |
| 854 | |
| 855 SafePointNode* ex_map; | |
| 856 while ((ex_map = pop_exception_state()) != NULL) { | |
| 857 if (!method()->has_exception_handlers()) { | |
| 858 // Common case: Transfer control outward. | |
| 859 // Doing it this early allows the exceptions to common up | |
| 860 // even between adjacent method calls. | |
| 861 throw_to_exit(ex_map); | |
| 862 } else { | |
| 863 // Have to look at the exception first. | |
| 864 assert(stopped(), "catch_inline_exceptions trashes the map"); | |
| 865 catch_inline_exceptions(ex_map); | |
| 866 stop_and_kill_map(); // we used up this exception state; kill it | |
| 867 } | |
| 868 } | |
| 869 | |
| 870 // We now return to our regularly scheduled program: | |
| 871 } | |
| 872 | |
| 873 //---------------------------throw_to_exit------------------------------------- | |
| 874 // Merge the given map into an exception exit from this method. | |
| 875 // The exception exit will handle any unlocking of receiver. | |
| 876 // The ex_oop must be saved within the ex_map, unlike merge_exception. | |
| 877 void Parse::throw_to_exit(SafePointNode* ex_map) { | |
| 878 // Pop the JVMS to (a copy of) the caller. | |
| 879 GraphKit caller; | |
| 880 caller.set_map_clone(_caller->map()); | |
| 881 caller.set_bci(_caller->bci()); | |
| 882 caller.set_sp(_caller->sp()); | |
| 883 // Copy out the standard machine state: | |
| 884 for (uint i = 0; i < TypeFunc::Parms; i++) { | |
| 885 caller.map()->set_req(i, ex_map->in(i)); | |
| 886 } | |
| 887 // ...and the exception: | |
| 888 Node* ex_oop = saved_ex_oop(ex_map); | |
| 889 SafePointNode* caller_ex_map = caller.make_exception_state(ex_oop); | |
| 890 // Finally, collect the new exception state in my exits: | |
| 891 _exits.add_exception_state(caller_ex_map); | |
| 892 } | |
| 893 | |
| 894 //------------------------------do_exits--------------------------------------- | |
| 895 void Parse::do_exits() { | |
| 896 set_parse_bci(InvocationEntryBci); | |
| 897 | |
| 898 // Now peephole on the return bits | |
| 899 Node* region = _exits.control(); | |
| 900 _exits.set_control(gvn().transform(region)); | |
| 901 | |
| 902 Node* iophi = _exits.i_o(); | |
| 903 _exits.set_i_o(gvn().transform(iophi)); | |
| 904 | |
| 905 if (wrote_final()) { | |
| 906 // This method (which must be a constructor by the rules of Java) | |
| 907 // wrote a final. The effects of all initializations must be | |
| 908 // committed to memory before any code after the constructor | |
| 909 // publishes the reference to the newly constructor object. | |
| 910 // Rather than wait for the publication, we simply block the | |
| 911 // writes here. Rather than put a barrier on only those writes | |
| 912 // which are required to complete, we force all writes to complete. | |
| 913 // | |
| 914 // "All bets are off" unless the first publication occurs after a | |
| 915 // normal return from the constructor. We do not attempt to detect | |
| 916 // such unusual early publications. But no barrier is needed on | |
| 917 // exceptional returns, since they cannot publish normally. | |
| 918 // | |
| 919 _exits.insert_mem_bar(Op_MemBarRelease); | |
| 920 #ifndef PRODUCT | |
| 921 if (PrintOpto && (Verbose || WizardMode)) { | |
| 922 method()->print_name(); | |
| 923 tty->print_cr(" writes finals and needs a memory barrier"); | |
| 924 } | |
| 925 #endif | |
| 926 } | |
| 927 | |
| 928 for (MergeMemStream mms(_exits.merged_memory()); mms.next_non_empty(); ) { | |
| 929 // transform each slice of the original memphi: | |
| 930 mms.set_memory(_gvn.transform(mms.memory())); | |
| 931 } | |
| 932 | |
| 933 if (tf()->range()->cnt() > TypeFunc::Parms) { | |
| 934 const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms); | |
| 935 Node* ret_phi = _gvn.transform( _exits.argument(0) ); | |
| 936 assert(_exits.control()->is_top() || !_gvn.type(ret_phi)->empty(), "return value must be well defined"); | |
| 937 _exits.push_node(ret_type->basic_type(), ret_phi); | |
| 938 } | |
| 939 | |
| 940 // Note: Logic for creating and optimizing the ReturnNode is in Compile. | |
| 941 | |
| 942 // Unlock along the exceptional paths. | |
| 943 // This is done late so that we can common up equivalent exceptions | |
| 944 // (e.g., null checks) arising from multiple points within this method. | |
| 945 // See GraphKit::add_exception_state, which performs the commoning. | |
| 946 bool do_synch = method()->is_synchronized() && GenerateSynchronizationCode; | |
| 947 | |
| 948 // 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
|
949 if (do_synch || C->env()->dtrace_method_probes()) { |
| 0 | 950 // First move the exception list out of _exits: |
| 951 GraphKit kit(_exits.transfer_exceptions_into_jvms()); | |
| 952 SafePointNode* normal_map = kit.map(); // keep this guy safe | |
| 953 // Now re-collect the exceptions into _exits: | |
| 954 SafePointNode* ex_map; | |
| 955 while ((ex_map = kit.pop_exception_state()) != NULL) { | |
| 956 Node* ex_oop = kit.use_exception_state(ex_map); | |
| 957 // Force the exiting JVM state to have this method at InvocationEntryBci. | |
| 958 // The exiting JVM state is otherwise a copy of the calling JVMS. | |
| 959 JVMState* caller = kit.jvms(); | |
| 960 JVMState* ex_jvms = caller->clone_shallow(C); | |
| 961 ex_jvms->set_map(kit.clone_map()); | |
| 962 ex_jvms->map()->set_jvms(ex_jvms); | |
| 963 ex_jvms->set_bci( InvocationEntryBci); | |
| 964 kit.set_jvms(ex_jvms); | |
| 965 if (do_synch) { | |
| 966 // Add on the synchronized-method box/object combo | |
| 967 kit.map()->push_monitor(_synch_lock); | |
| 968 // Unlock! | |
| 969 kit.shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node()); | |
| 970 } | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
971 if (C->env()->dtrace_method_probes()) { |
| 0 | 972 kit.make_dtrace_method_exit(method()); |
| 973 } | |
| 974 // Done with exception-path processing. | |
| 975 ex_map = kit.make_exception_state(ex_oop); | |
| 976 assert(ex_jvms->same_calls_as(ex_map->jvms()), "sanity"); | |
| 977 // Pop the last vestige of this method: | |
| 978 ex_map->set_jvms(caller->clone_shallow(C)); | |
| 979 ex_map->jvms()->set_map(ex_map); | |
| 980 _exits.push_exception_state(ex_map); | |
| 981 } | |
| 982 assert(_exits.map() == normal_map, "keep the same return state"); | |
| 983 } | |
| 984 | |
| 985 { | |
| 986 // Capture very early exceptions (receiver null checks) from caller JVMS | |
| 987 GraphKit caller(_caller); | |
| 988 SafePointNode* ex_map; | |
| 989 while ((ex_map = caller.pop_exception_state()) != NULL) { | |
| 990 _exits.add_exception_state(ex_map); | |
| 991 } | |
| 992 } | |
| 993 } | |
| 994 | |
| 995 //-----------------------------create_entry_map------------------------------- | |
| 996 // Initialize our parser map to contain the types at method entry. | |
| 997 // For OSR, the map contains a single RawPtr parameter. | |
| 998 // Initial monitor locking for sync. methods is performed by do_method_entry. | |
| 999 SafePointNode* Parse::create_entry_map() { | |
| 1000 // Check for really stupid bail-out cases. | |
| 1001 uint len = TypeFunc::Parms + method()->max_locals() + method()->max_stack(); | |
| 1002 if (len >= 32760) { | |
| 1003 C->record_method_not_compilable_all_tiers("too many local variables"); | |
| 1004 return NULL; | |
| 1005 } | |
| 1006 | |
| 1007 // If this is an inlined method, we may have to do a receiver null check. | |
| 1008 if (_caller->has_method() && is_normal_parse() && !method()->is_static()) { | |
| 1009 GraphKit kit(_caller); | |
| 1010 kit.null_check_receiver(method()); | |
| 1011 _caller = kit.transfer_exceptions_into_jvms(); | |
| 1012 if (kit.stopped()) { | |
| 1013 _exits.add_exception_states_from(_caller); | |
| 1014 _exits.set_jvms(_caller); | |
| 1015 return NULL; | |
| 1016 } | |
| 1017 } | |
| 1018 | |
| 1019 assert(method() != NULL, "parser must have a method"); | |
| 1020 | |
| 1021 // Create an initial safepoint to hold JVM state during parsing | |
| 1022 JVMState* jvms = new (C) JVMState(method(), _caller->has_method() ? _caller : NULL); | |
| 1023 set_map(new (C, len) SafePointNode(len, jvms)); | |
| 1024 jvms->set_map(map()); | |
| 1025 record_for_igvn(map()); | |
| 1026 assert(jvms->endoff() == len, "correct jvms sizing"); | |
| 1027 | |
| 1028 SafePointNode* inmap = _caller->map(); | |
| 1029 assert(inmap != NULL, "must have inmap"); | |
| 1030 | |
| 1031 uint i; | |
| 1032 | |
| 1033 // Pass thru the predefined input parameters. | |
| 1034 for (i = 0; i < TypeFunc::Parms; i++) { | |
| 1035 map()->init_req(i, inmap->in(i)); | |
| 1036 } | |
| 1037 | |
| 1038 if (depth() == 1) { | |
| 1039 assert(map()->memory()->Opcode() == Op_Parm, ""); | |
| 1040 // Insert the memory aliasing node | |
| 1041 set_all_memory(reset_memory()); | |
| 1042 } | |
| 1043 assert(merged_memory(), ""); | |
| 1044 | |
| 1045 // Now add the locals which are initially bound to arguments: | |
| 1046 uint arg_size = tf()->domain()->cnt(); | |
| 1047 ensure_stack(arg_size - TypeFunc::Parms); // OSR methods have funny args | |
| 1048 for (i = TypeFunc::Parms; i < arg_size; i++) { | |
| 1049 map()->init_req(i, inmap->argument(_caller, i - TypeFunc::Parms)); | |
| 1050 } | |
| 1051 | |
| 1052 // Clear out the rest of the map (locals and stack) | |
| 1053 for (i = arg_size; i < len; i++) { | |
| 1054 map()->init_req(i, top()); | |
| 1055 } | |
| 1056 | |
| 1057 SafePointNode* entry_map = stop(); | |
| 1058 return entry_map; | |
| 1059 } | |
| 1060 | |
| 1061 //-----------------------------do_method_entry-------------------------------- | |
| 1062 // Emit any code needed in the pseudo-block before BCI zero. | |
| 1063 // The main thing to do is lock the receiver of a synchronized method. | |
| 1064 void Parse::do_method_entry() { | |
| 1065 set_parse_bci(InvocationEntryBci); // Pseudo-BCP | |
| 1066 set_sp(0); // Java Stack Pointer | |
| 1067 | |
| 1068 NOT_PRODUCT( count_compiled_calls(true/*at_method_entry*/, false/*is_inline*/); ) | |
| 1069 | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
1070 if (C->env()->dtrace_method_probes()) { |
| 0 | 1071 make_dtrace_method_entry(method()); |
| 1072 } | |
| 1073 | |
| 1074 // If the method is synchronized, we need to construct a lock node, attach | |
| 1075 // it to the Start node, and pin it there. | |
| 1076 if (method()->is_synchronized()) { | |
| 1077 // Insert a FastLockNode right after the Start which takes as arguments | |
| 1078 // the current thread pointer, the "this" pointer & the address of the | |
| 1079 // stack slot pair used for the lock. The "this" pointer is a projection | |
| 1080 // off the start node, but the locking spot has to be constructed by | |
| 1081 // creating a ConLNode of 0, and boxing it with a BoxLockNode. The BoxLockNode | |
| 1082 // becomes the second argument to the FastLockNode call. The | |
| 1083 // FastLockNode becomes the new control parent to pin it to the start. | |
| 1084 | |
| 1085 // Setup Object Pointer | |
| 1086 Node *lock_obj = NULL; | |
| 1087 if(method()->is_static()) { | |
| 1088 ciInstance* mirror = _method->holder()->java_mirror(); | |
| 1089 const TypeInstPtr *t_lock = TypeInstPtr::make(mirror); | |
| 1090 lock_obj = makecon(t_lock); | |
| 1091 } else { // Else pass the "this" pointer, | |
| 1092 lock_obj = local(0); // which is Parm0 from StartNode | |
| 1093 } | |
| 1094 // Clear out dead values from the debug info. | |
| 1095 kill_dead_locals(); | |
| 1096 // Build the FastLockNode | |
| 1097 _synch_lock = shared_lock(lock_obj); | |
| 1098 } | |
| 1099 | |
| 1100 if (depth() == 1) { | |
| 1101 increment_and_test_invocation_counter(Tier2CompileThreshold); | |
| 1102 } | |
| 1103 } | |
| 1104 | |
| 1105 //------------------------------init_blocks------------------------------------ | |
| 1106 // Initialize our parser map to contain the types/monitors at method entry. | |
| 1107 void Parse::init_blocks() { | |
| 1108 // Create the blocks. | |
| 1109 _block_count = flow()->block_count(); | |
| 1110 _blocks = NEW_RESOURCE_ARRAY(Block, _block_count); | |
| 1111 Copy::zero_to_bytes(_blocks, sizeof(Block)*_block_count); | |
| 1112 | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1113 int rpo; |
| 0 | 1114 |
| 1115 // 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
|
1116 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
|
1117 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
|
1118 block->init_node(this, rpo); |
| 0 | 1119 } |
| 1120 | |
| 1121 // 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
|
1122 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
|
1123 Block* block = rpo_at(rpo); |
| 0 | 1124 block->init_graph(this); |
| 1125 } | |
| 1126 } | |
| 1127 | |
| 1128 //-------------------------------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
|
1129 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
|
1130 _flow = outer->flow()->rpo_at(rpo); |
| 0 | 1131 _pred_count = 0; |
| 1132 _preds_parsed = 0; | |
| 1133 _count = 0; | |
| 1134 assert(pred_count() == 0 && preds_parsed() == 0, "sanity"); | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1135 assert(!(is_merged() || is_parsed() || is_handler() || has_merged_backedge()), "sanity"); |
| 0 | 1136 assert(_live_locals.size() == 0, "sanity"); |
| 1137 | |
| 1138 // entry point has additional predecessor | |
| 1139 if (flow()->is_start()) _pred_count++; | |
| 1140 assert(flow()->is_start() == (this == outer->start_block()), ""); | |
| 1141 } | |
| 1142 | |
| 1143 //-------------------------------init_graph------------------------------------ | |
| 1144 void Parse::Block::init_graph(Parse* outer) { | |
| 1145 // Create the successor list for this parser block. | |
| 1146 GrowableArray<ciTypeFlow::Block*>* tfs = flow()->successors(); | |
| 1147 GrowableArray<ciTypeFlow::Block*>* tfe = flow()->exceptions(); | |
| 1148 int ns = tfs->length(); | |
| 1149 int ne = tfe->length(); | |
| 1150 _num_successors = ns; | |
| 1151 _all_successors = ns+ne; | |
| 1152 _successors = (ns+ne == 0) ? NULL : NEW_RESOURCE_ARRAY(Block*, ns+ne); | |
| 1153 int p = 0; | |
| 1154 for (int i = 0; i < ns+ne; i++) { | |
| 1155 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
|
1156 Block* block2 = outer->rpo_at(tf2->rpo()); |
| 0 | 1157 _successors[i] = block2; |
| 1158 | |
| 1159 // Accumulate pred info for the other block, too. | |
| 1160 if (i < ns) { | |
| 1161 block2->_pred_count++; | |
| 1162 } else { | |
| 1163 block2->_is_handler = true; | |
| 1164 } | |
| 1165 | |
| 1166 #ifdef ASSERT | |
| 1167 // A block's successors must be distinguishable by BCI. | |
| 1168 // That is, no bytecode is allowed to branch to two different | |
| 1169 // clones of the same code location. | |
| 1170 for (int j = 0; j < i; j++) { | |
| 1171 Block* block1 = _successors[j]; | |
| 1172 if (block1 == block2) continue; // duplicates are OK | |
| 1173 assert(block1->start() != block2->start(), "successors have unique bcis"); | |
| 1174 } | |
| 1175 #endif | |
| 1176 } | |
| 1177 | |
| 1178 // Note: We never call next_path_num along exception paths, so they | |
| 1179 // never get processed as "ready". Also, the input phis of exception | |
| 1180 // handlers get specially processed, so that | |
| 1181 } | |
| 1182 | |
| 1183 //---------------------------successor_for_bci--------------------------------- | |
| 1184 Parse::Block* Parse::Block::successor_for_bci(int bci) { | |
| 1185 for (int i = 0; i < all_successors(); i++) { | |
| 1186 Block* block2 = successor_at(i); | |
| 1187 if (block2->start() == bci) return block2; | |
| 1188 } | |
| 1189 // We can actually reach here if ciTypeFlow traps out a block | |
| 1190 // due to an unloaded class, and concurrently with compilation the | |
| 1191 // class is then loaded, so that a later phase of the parser is | |
| 1192 // able to see more of the bytecode CFG. Or, the flow pass and | |
| 1193 // the parser can have a minor difference of opinion about executability | |
| 1194 // of bytecodes. For example, "obj.field = null" is executable even | |
| 1195 // if the field's type is an unloaded class; the flow pass used to | |
| 1196 // make a trap for such code. | |
| 1197 return NULL; | |
| 1198 } | |
| 1199 | |
| 1200 | |
| 1201 //-----------------------------stack_type_at----------------------------------- | |
| 1202 const Type* Parse::Block::stack_type_at(int i) const { | |
| 1203 return get_type(flow()->stack_type_at(i)); | |
| 1204 } | |
| 1205 | |
| 1206 | |
| 1207 //-----------------------------local_type_at----------------------------------- | |
| 1208 const Type* Parse::Block::local_type_at(int i) const { | |
| 1209 // Make dead locals fall to bottom. | |
| 1210 if (_live_locals.size() == 0) { | |
| 1211 MethodLivenessResult live_locals = flow()->outer()->method()->liveness_at_bci(start()); | |
| 1212 // This bitmap can be zero length if we saw a breakpoint. | |
| 1213 // In such cases, pretend they are all live. | |
| 1214 ((Block*)this)->_live_locals = live_locals; | |
| 1215 } | |
| 1216 if (_live_locals.size() > 0 && !_live_locals.at(i)) | |
| 1217 return Type::BOTTOM; | |
| 1218 | |
| 1219 return get_type(flow()->local_type_at(i)); | |
| 1220 } | |
| 1221 | |
| 1222 | |
| 1223 #ifndef PRODUCT | |
| 1224 | |
| 1225 //----------------------------name_for_bc-------------------------------------- | |
| 1226 // helper method for BytecodeParseHistogram | |
| 1227 static const char* name_for_bc(int i) { | |
| 1228 return Bytecodes::is_defined(i) ? Bytecodes::name(Bytecodes::cast(i)) : "xxxunusedxxx"; | |
| 1229 } | |
| 1230 | |
| 1231 //----------------------------BytecodeParseHistogram------------------------------------ | |
| 1232 Parse::BytecodeParseHistogram::BytecodeParseHistogram(Parse *p, Compile *c) { | |
| 1233 _parser = p; | |
| 1234 _compiler = c; | |
| 1235 if( ! _initialized ) { _initialized = true; reset(); } | |
| 1236 } | |
| 1237 | |
| 1238 //----------------------------current_count------------------------------------ | |
| 1239 int Parse::BytecodeParseHistogram::current_count(BPHType bph_type) { | |
| 1240 switch( bph_type ) { | |
| 1241 case BPH_transforms: { return _parser->gvn().made_progress(); } | |
| 1242 case BPH_values: { return _parser->gvn().made_new_values(); } | |
| 1243 default: { ShouldNotReachHere(); return 0; } | |
| 1244 } | |
| 1245 } | |
| 1246 | |
| 1247 //----------------------------initialized-------------------------------------- | |
| 1248 bool Parse::BytecodeParseHistogram::initialized() { return _initialized; } | |
| 1249 | |
| 1250 //----------------------------reset-------------------------------------------- | |
| 1251 void Parse::BytecodeParseHistogram::reset() { | |
| 1252 int i = Bytecodes::number_of_codes; | |
| 1253 while (i-- > 0) { _bytecodes_parsed[i] = 0; _nodes_constructed[i] = 0; _nodes_transformed[i] = 0; _new_values[i] = 0; } | |
| 1254 } | |
| 1255 | |
| 1256 //----------------------------set_initial_state-------------------------------- | |
| 1257 // Record info when starting to parse one bytecode | |
| 1258 void Parse::BytecodeParseHistogram::set_initial_state( Bytecodes::Code bc ) { | |
| 1259 if( PrintParseStatistics && !_parser->is_osr_parse() ) { | |
| 1260 _initial_bytecode = bc; | |
| 1261 _initial_node_count = _compiler->unique(); | |
| 1262 _initial_transforms = current_count(BPH_transforms); | |
| 1263 _initial_values = current_count(BPH_values); | |
| 1264 } | |
| 1265 } | |
| 1266 | |
| 1267 //----------------------------record_change-------------------------------- | |
| 1268 // Record results of parsing one bytecode | |
| 1269 void Parse::BytecodeParseHistogram::record_change() { | |
| 1270 if( PrintParseStatistics && !_parser->is_osr_parse() ) { | |
| 1271 ++_bytecodes_parsed[_initial_bytecode]; | |
| 1272 _nodes_constructed [_initial_bytecode] += (_compiler->unique() - _initial_node_count); | |
| 1273 _nodes_transformed [_initial_bytecode] += (current_count(BPH_transforms) - _initial_transforms); | |
| 1274 _new_values [_initial_bytecode] += (current_count(BPH_values) - _initial_values); | |
| 1275 } | |
| 1276 } | |
| 1277 | |
| 1278 | |
| 1279 //----------------------------print-------------------------------------------- | |
| 1280 void Parse::BytecodeParseHistogram::print(float cutoff) { | |
| 1281 ResourceMark rm; | |
| 1282 // print profile | |
| 1283 int total = 0; | |
| 1284 int i = 0; | |
| 1285 for( i = 0; i < Bytecodes::number_of_codes; ++i ) { total += _bytecodes_parsed[i]; } | |
| 1286 int abs_sum = 0; | |
| 1287 tty->cr(); //0123456789012345678901234567890123456789012345678901234567890123456789 | |
| 1288 tty->print_cr("Histogram of %d parsed bytecodes:", total); | |
| 1289 if( total == 0 ) { return; } | |
| 1290 tty->cr(); | |
| 1291 tty->print_cr("absolute: count of compiled bytecodes of this type"); | |
| 1292 tty->print_cr("relative: percentage contribution to compiled nodes"); | |
| 1293 tty->print_cr("nodes : Average number of nodes constructed per bytecode"); | |
| 1294 tty->print_cr("rnodes : Significance towards total nodes constructed, (nodes*relative)"); | |
| 1295 tty->print_cr("transforms: Average amount of tranform progress per bytecode compiled"); | |
| 1296 tty->print_cr("values : Average number of node values improved per bytecode"); | |
| 1297 tty->print_cr("name : Bytecode name"); | |
| 1298 tty->cr(); | |
| 1299 tty->print_cr(" absolute relative nodes rnodes transforms values name"); | |
| 1300 tty->print_cr("----------------------------------------------------------------------"); | |
| 1301 while (--i > 0) { | |
| 1302 int abs = _bytecodes_parsed[i]; | |
| 1303 float rel = abs * 100.0F / total; | |
| 1304 float nodes = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_constructed[i])/_bytecodes_parsed[i]; | |
| 1305 float rnodes = _bytecodes_parsed[i] == 0 ? 0 : rel * nodes; | |
| 1306 float xforms = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_transformed[i])/_bytecodes_parsed[i]; | |
| 1307 float values = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _new_values [i])/_bytecodes_parsed[i]; | |
| 1308 if (cutoff <= rel) { | |
| 1309 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)); | |
| 1310 abs_sum += abs; | |
| 1311 } | |
| 1312 } | |
| 1313 tty->print_cr("----------------------------------------------------------------------"); | |
| 1314 float rel_sum = abs_sum * 100.0F / total; | |
| 1315 tty->print_cr("%10d %7.2f%% (cutoff = %.2f%%)", abs_sum, rel_sum, cutoff); | |
| 1316 tty->print_cr("----------------------------------------------------------------------"); | |
| 1317 tty->cr(); | |
| 1318 } | |
| 1319 #endif | |
| 1320 | |
| 1321 //----------------------------load_state_from---------------------------------- | |
| 1322 // Load block/map/sp. But not do not touch iter/bci. | |
| 1323 void Parse::load_state_from(Block* block) { | |
| 1324 set_block(block); | |
| 1325 // load the block's JVM state: | |
| 1326 set_map(block->start_map()); | |
| 1327 set_sp( block->start_sp()); | |
| 1328 } | |
| 1329 | |
| 1330 | |
| 1331 //-----------------------------record_state------------------------------------ | |
| 1332 void Parse::Block::record_state(Parse* p) { | |
| 1333 assert(!is_merged(), "can only record state once, on 1st inflow"); | |
| 1334 assert(start_sp() == p->sp(), "stack pointer must agree with ciTypeFlow"); | |
| 1335 set_start_map(p->stop()); | |
| 1336 } | |
| 1337 | |
| 1338 | |
| 1339 //------------------------------do_one_block----------------------------------- | |
| 1340 void Parse::do_one_block() { | |
| 1341 if (TraceOptoParse) { | |
| 1342 Block *b = block(); | |
| 1343 int ns = b->num_successors(); | |
| 1344 int nt = b->all_successors(); | |
| 1345 | |
| 1346 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
|
1347 block()->rpo(), block()->start(), block()->limit()); |
| 0 | 1348 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
|
1349 tty->print((( i < ns) ? " %d" : " %d(e)"), b->successor_at(i)->rpo()); |
| 0 | 1350 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1351 if (b->is_loop_head()) tty->print(" lphd"); |
| 0 | 1352 tty->print_cr(""); |
| 1353 } | |
| 1354 | |
| 1355 assert(block()->is_merged(), "must be merged before being parsed"); | |
| 1356 block()->mark_parsed(); | |
| 1357 ++_blocks_parsed; | |
| 1358 | |
| 1359 // Set iterator to start of block. | |
| 1360 iter().reset_to_bci(block()->start()); | |
| 1361 | |
| 1362 CompileLog* log = C->log(); | |
| 1363 | |
| 1364 // Parse bytecodes | |
| 1365 while (!stopped() && !failing()) { | |
| 1366 iter().next(); | |
| 1367 | |
| 1368 // Learn the current bci from the iterator: | |
| 1369 set_parse_bci(iter().cur_bci()); | |
| 1370 | |
| 1371 if (bci() == block()->limit()) { | |
| 1372 // Do not walk into the next block until directed by do_all_blocks. | |
| 1373 merge(bci()); | |
| 1374 break; | |
| 1375 } | |
| 1376 assert(bci() < block()->limit(), "bci still in block"); | |
| 1377 | |
| 1378 if (log != NULL) { | |
| 1379 // Output an optional context marker, to help place actions | |
| 1380 // that occur during parsing of this BC. If there is no log | |
| 1381 // output until the next context string, this context string | |
| 1382 // will be silently ignored. | |
| 1383 log->context()->reset(); | |
| 1384 log->context()->print_cr("<bc code='%d' bci='%d'/>", (int)bc(), bci()); | |
| 1385 } | |
| 1386 | |
| 1387 if (block()->has_trap_at(bci())) { | |
| 1388 // We must respect the flow pass's traps, because it will refuse | |
| 1389 // to produce successors for trapping blocks. | |
| 1390 int trap_index = block()->flow()->trap_index(); | |
| 1391 assert(trap_index != 0, "trap index must be valid"); | |
| 1392 uncommon_trap(trap_index); | |
| 1393 break; | |
| 1394 } | |
| 1395 | |
| 1396 NOT_PRODUCT( parse_histogram()->set_initial_state(bc()); ); | |
| 1397 | |
| 1398 #ifdef ASSERT | |
| 1399 int pre_bc_sp = sp(); | |
| 1400 int inputs, depth; | |
| 1401 bool have_se = !stopped() && compute_stack_effects(inputs, depth); | |
| 1402 assert(!have_se || pre_bc_sp >= inputs, "have enough stack to execute this BC"); | |
| 1403 #endif //ASSERT | |
| 1404 | |
| 1405 do_one_bytecode(); | |
| 1406 | |
| 1407 assert(!have_se || stopped() || failing() || (sp() - pre_bc_sp) == depth, "correct depth prediction"); | |
| 1408 | |
| 1409 do_exceptions(); | |
| 1410 | |
| 1411 NOT_PRODUCT( parse_histogram()->record_change(); ); | |
| 1412 | |
| 1413 if (log != NULL) log->context()->reset(); // done w/ this one | |
| 1414 | |
| 1415 // Fall into next bytecode. Each bytecode normally has 1 sequential | |
| 1416 // successor which is typically made ready by visiting this bytecode. | |
| 1417 // If the successor has several predecessors, then it is a merge | |
| 1418 // point, starts a new basic block, and is handled like other basic blocks. | |
| 1419 } | |
| 1420 } | |
| 1421 | |
| 1422 | |
| 1423 //------------------------------merge------------------------------------------ | |
| 1424 void Parse::set_parse_bci(int bci) { | |
| 1425 set_bci(bci); | |
| 1426 Node_Notes* nn = C->default_node_notes(); | |
| 1427 if (nn == NULL) return; | |
| 1428 | |
| 1429 // Collect debug info for inlined calls unless -XX:-DebugInlinedCalls. | |
| 1430 if (!DebugInlinedCalls && depth() > 1) { | |
| 1431 return; | |
| 1432 } | |
| 1433 | |
| 1434 // Update the JVMS annotation, if present. | |
| 1435 JVMState* jvms = nn->jvms(); | |
| 1436 if (jvms != NULL && jvms->bci() != bci) { | |
| 1437 // Update the JVMS. | |
| 1438 jvms = jvms->clone_shallow(C); | |
| 1439 jvms->set_bci(bci); | |
| 1440 nn->set_jvms(jvms); | |
| 1441 } | |
| 1442 } | |
| 1443 | |
| 1444 //------------------------------merge------------------------------------------ | |
| 1445 // Merge the current mapping into the basic block starting at bci | |
| 1446 void Parse::merge(int target_bci) { | |
| 1447 Block* target = successor_for_bci(target_bci); | |
| 1448 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1449 assert(!target->is_ready(), "our arrival must be expected"); | |
| 1450 int pnum = target->next_path_num(); | |
| 1451 merge_common(target, pnum); | |
| 1452 } | |
| 1453 | |
| 1454 //-------------------------merge_new_path-------------------------------------- | |
| 1455 // Merge the current mapping into the basic block, using a new path | |
| 1456 void Parse::merge_new_path(int target_bci) { | |
| 1457 Block* target = successor_for_bci(target_bci); | |
| 1458 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1459 assert(!target->is_ready(), "new path into frozen graph"); | |
| 1460 int pnum = target->add_new_path(); | |
| 1461 merge_common(target, pnum); | |
| 1462 } | |
| 1463 | |
| 1464 //-------------------------merge_exception------------------------------------- | |
| 1465 // Merge the current mapping into the basic block starting at bci | |
| 1466 // The ex_oop must be pushed on the stack, unlike throw_to_exit. | |
| 1467 void Parse::merge_exception(int target_bci) { | |
| 1468 assert(sp() == 1, "must have only the throw exception on the stack"); | |
| 1469 Block* target = successor_for_bci(target_bci); | |
| 1470 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1471 assert(target->is_handler(), "exceptions are handled by special blocks"); | |
| 1472 int pnum = target->add_new_path(); | |
| 1473 merge_common(target, pnum); | |
| 1474 } | |
| 1475 | |
| 1476 //--------------------handle_missing_successor--------------------------------- | |
| 1477 void Parse::handle_missing_successor(int target_bci) { | |
| 1478 #ifndef PRODUCT | |
| 1479 Block* b = block(); | |
| 1480 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
|
1481 tty->print_cr("### Missing successor at bci:%d for block #%d (trap_bci:%d)", target_bci, b->rpo(), trap_bci); |
| 0 | 1482 #endif |
| 1483 ShouldNotReachHere(); | |
| 1484 } | |
| 1485 | |
| 1486 //--------------------------merge_common--------------------------------------- | |
| 1487 void Parse::merge_common(Parse::Block* target, int pnum) { | |
| 1488 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
|
1489 tty->print("Merging state at block #%d bci:%d", target->rpo(), target->start()); |
| 0 | 1490 } |
| 1491 | |
| 1492 // Zap extra stack slots to top | |
| 1493 assert(sp() == target->start_sp(), ""); | |
| 1494 clean_stack(sp()); | |
| 1495 | |
| 1496 if (!target->is_merged()) { // No prior mapping at this bci | |
| 1497 if (TraceOptoParse) { tty->print(" with empty state"); } | |
| 1498 | |
| 1499 // If this path is dead, do not bother capturing it as a merge. | |
| 1500 // It is "as if" we had 1 fewer predecessors from the beginning. | |
| 1501 if (stopped()) { | |
| 1502 if (TraceOptoParse) tty->print_cr(", but path is dead and doesn't count"); | |
| 1503 return; | |
| 1504 } | |
| 1505 | |
| 1506 // Record that a new block has been merged. | |
| 1507 ++_blocks_merged; | |
| 1508 | |
| 1509 // Make a region if we know there are multiple or unpredictable inputs. | |
| 1510 // (Also, if this is a plain fall-through, we might see another region, | |
| 1511 // which must not be allowed into this block's map.) | |
| 1512 if (pnum > PhiNode::Input // Known multiple inputs. | |
| 1513 || 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
|
1514 || target->is_loop_head() // Known multiple inputs |
| 0 | 1515 || control()->is_Region()) { // We must hide this guy. |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1516 |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1517 int current_bci = bci(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1518 set_parse_bci(target->start()); // Set target bci |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1519 if (target->is_SEL_head()) { |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1520 DEBUG_ONLY( target->mark_merged_backedge(block()); ) |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1521 if (target->start() == 0) { |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1522 // Add loop predicate for the special case when |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1523 // there are backbranches to the method entry. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1524 add_predicate(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1525 } |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1526 } |
| 0 | 1527 // Add a Region to start the new basic block. Phis will be added |
| 1528 // later lazily. | |
| 1529 int edges = target->pred_count(); | |
| 1530 if (edges < pnum) edges = pnum; // might be a new path! | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1531 RegionNode *r = new (C, edges+1) RegionNode(edges+1); |
| 0 | 1532 gvn().set_type(r, Type::CONTROL); |
| 1533 record_for_igvn(r); | |
| 1534 // zap all inputs to NULL for debugging (done in Node(uint) constructor) | |
| 1535 // for (int j = 1; j < edges+1; j++) { r->init_req(j, NULL); } | |
| 1536 r->init_req(pnum, control()); | |
| 1537 set_control(r); | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1538 set_parse_bci(current_bci); // Restore bci |
| 0 | 1539 } |
| 1540 | |
| 1541 // Convert the existing Parser mapping into a mapping at this bci. | |
| 1542 store_state_to(target); | |
| 1543 assert(target->is_merged(), "do not come here twice"); | |
| 1544 | |
| 1545 } else { // Prior mapping at this bci | |
| 1546 if (TraceOptoParse) { tty->print(" with previous state"); } | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1547 #ifdef ASSERT |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1548 if (target->is_SEL_head()) { |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1549 target->mark_merged_backedge(block()); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1550 } |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1551 #endif |
| 0 | 1552 // We must not manufacture more phis if the target is already parsed. |
| 1553 bool nophi = target->is_parsed(); | |
| 1554 | |
| 1555 SafePointNode* newin = map();// Hang on to incoming mapping | |
| 1556 Block* save_block = block(); // Hang on to incoming block; | |
| 1557 load_state_from(target); // Get prior mapping | |
| 1558 | |
| 1559 assert(newin->jvms()->locoff() == jvms()->locoff(), "JVMS layouts agree"); | |
| 1560 assert(newin->jvms()->stkoff() == jvms()->stkoff(), "JVMS layouts agree"); | |
| 1561 assert(newin->jvms()->monoff() == jvms()->monoff(), "JVMS layouts agree"); | |
| 1562 assert(newin->jvms()->endoff() == jvms()->endoff(), "JVMS layouts agree"); | |
| 1563 | |
| 1564 // Iterate over my current mapping and the old mapping. | |
| 1565 // Where different, insert Phi functions. | |
| 1566 // Use any existing Phi functions. | |
| 1567 assert(control()->is_Region(), "must be merging to a region"); | |
| 1568 RegionNode* r = control()->as_Region(); | |
| 1569 | |
| 1570 // Compute where to merge into | |
| 1571 // 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
|
1572 r->init_req(pnum, newin->control()); |
| 0 | 1573 |
| 1574 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
|
1575 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
|
1576 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
|
1577 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
|
1578 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
|
1579 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1580 } |
| 0 | 1581 record_for_igvn(r); |
| 1582 } | |
| 1583 | |
| 1584 // Update all the non-control inputs to map: | |
| 1585 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
|
1586 bool check_elide_phi = target->is_SEL_backedge(save_block); |
| 0 | 1587 for (uint j = 1; j < newin->req(); j++) { |
| 1588 Node* m = map()->in(j); // Current state of target. | |
| 1589 Node* n = newin->in(j); // Incoming change to target state. | |
| 1590 PhiNode* phi; | |
| 1591 if (m->is_Phi() && m->as_Phi()->region() == r) | |
| 1592 phi = m->as_Phi(); | |
| 1593 else | |
| 1594 phi = NULL; | |
| 1595 if (m != n) { // Different; must merge | |
| 1596 switch (j) { | |
| 1597 // Frame pointer and Return Address never changes | |
| 1598 case TypeFunc::FramePtr:// Drop m, use the original value | |
| 1599 case TypeFunc::ReturnAdr: | |
| 1600 break; | |
| 1601 case TypeFunc::Memory: // Merge inputs to the MergeMem node | |
| 1602 assert(phi == NULL, "the merge contains phis, not vice versa"); | |
| 1603 merge_memory_edges(n->as_MergeMem(), pnum, nophi); | |
| 1604 continue; | |
| 1605 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
|
1606 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
|
1607 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
|
1608 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
|
1609 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1610 } |
| 0 | 1611 break; |
| 1612 } | |
| 1613 } | |
| 1614 // At this point, n might be top if: | |
| 1615 // - there is no phi (because TypeFlow detected a conflict), or | |
| 1616 // - the corresponding control edges is top (a dead incoming path) | |
| 1617 // It is a bug if we create a phi which sees a garbage value on a live path. | |
| 1618 | |
| 1619 if (phi != NULL) { | |
| 1620 assert(n != top() || r->in(pnum) == top(), "live value must not be garbage"); | |
| 1621 assert(phi->region() == r, ""); | |
| 1622 phi->set_req(pnum, n); // Then add 'n' to the merge | |
| 1623 if (pnum == PhiNode::Input) { | |
| 1624 // Last merge for this Phi. | |
| 1625 // So far, Phis have had a reasonable type from ciTypeFlow. | |
| 1626 // Now _gvn will join that with the meet of current inputs. | |
| 1627 // BOTTOM is never permissible here, 'cause pessimistically | |
| 1628 // Phis of pointers cannot lose the basic pointer type. | |
| 1629 debug_only(const Type* bt1 = phi->bottom_type()); | |
| 1630 assert(bt1 != Type::BOTTOM, "should not be building conflict phis"); | |
| 1631 map()->set_req(j, _gvn.transform_no_reclaim(phi)); | |
| 1632 debug_only(const Type* bt2 = phi->bottom_type()); | |
| 1633 assert(bt2->higher_equal(bt1), "must be consistent with type-flow"); | |
| 1634 record_for_igvn(phi); | |
| 1635 } | |
| 1636 } | |
| 1637 } // End of for all values to be merged | |
| 1638 | |
| 1639 if (pnum == PhiNode::Input && | |
| 1640 !r->in(0)) { // The occasional useless Region | |
| 1641 assert(control() == r, ""); | |
| 1642 set_control(r->nonnull_req()); | |
| 1643 } | |
| 1644 | |
| 1645 // newin has been subsumed into the lazy merge, and is now dead. | |
| 1646 set_block(save_block); | |
| 1647 | |
| 1648 stop(); // done with this guy, for now | |
| 1649 } | |
| 1650 | |
| 1651 if (TraceOptoParse) { | |
| 1652 tty->print_cr(" on path %d", pnum); | |
| 1653 } | |
| 1654 | |
| 1655 // Done with this parser state. | |
| 1656 assert(stopped(), ""); | |
| 1657 } | |
| 1658 | |
| 1659 | |
| 1660 //--------------------------merge_memory_edges--------------------------------- | |
| 1661 void Parse::merge_memory_edges(MergeMemNode* n, int pnum, bool nophi) { | |
| 1662 // (nophi means we must not create phis, because we already parsed here) | |
| 1663 assert(n != NULL, ""); | |
| 1664 // Merge the inputs to the MergeMems | |
| 1665 MergeMemNode* m = merged_memory(); | |
| 1666 | |
| 1667 assert(control()->is_Region(), "must be merging to a region"); | |
| 1668 RegionNode* r = control()->as_Region(); | |
| 1669 | |
| 1670 PhiNode* base = NULL; | |
| 1671 MergeMemNode* remerge = NULL; | |
| 1672 for (MergeMemStream mms(m, n); mms.next_non_empty2(); ) { | |
| 1673 Node *p = mms.force_memory(); | |
| 1674 Node *q = mms.memory2(); | |
| 1675 if (mms.is_empty() && nophi) { | |
| 1676 // Trouble: No new splits allowed after a loop body is parsed. | |
| 1677 // Instead, wire the new split into a MergeMem on the backedge. | |
| 1678 // The optimizer will sort it out, slicing the phi. | |
| 1679 if (remerge == NULL) { | |
| 1680 assert(base != NULL, ""); | |
| 1681 assert(base->in(0) != NULL, "should not be xformed away"); | |
| 1682 remerge = MergeMemNode::make(C, base->in(pnum)); | |
| 1683 gvn().set_type(remerge, Type::MEMORY); | |
| 1684 base->set_req(pnum, remerge); | |
| 1685 } | |
| 1686 remerge->set_memory_at(mms.alias_idx(), q); | |
| 1687 continue; | |
| 1688 } | |
| 1689 assert(!q->is_MergeMem(), ""); | |
| 1690 PhiNode* phi; | |
| 1691 if (p != q) { | |
| 1692 phi = ensure_memory_phi(mms.alias_idx(), nophi); | |
| 1693 } else { | |
| 1694 if (p->is_Phi() && p->as_Phi()->region() == r) | |
| 1695 phi = p->as_Phi(); | |
| 1696 else | |
| 1697 phi = NULL; | |
| 1698 } | |
| 1699 // Insert q into local phi | |
| 1700 if (phi != NULL) { | |
| 1701 assert(phi->region() == r, ""); | |
| 1702 p = phi; | |
| 1703 phi->set_req(pnum, q); | |
| 1704 if (mms.at_base_memory()) { | |
| 1705 base = phi; // delay transforming it | |
| 1706 } else if (pnum == 1) { | |
| 1707 record_for_igvn(phi); | |
| 1708 p = _gvn.transform_no_reclaim(phi); | |
| 1709 } | |
| 1710 mms.set_memory(p);// store back through the iterator | |
| 1711 } | |
| 1712 } | |
| 1713 // Transform base last, in case we must fiddle with remerging. | |
| 1714 if (base != NULL && pnum == 1) { | |
| 1715 record_for_igvn(base); | |
| 1716 m->set_base_memory( _gvn.transform_no_reclaim(base) ); | |
| 1717 } | |
| 1718 } | |
| 1719 | |
| 1720 | |
| 1721 //------------------------ensure_phis_everywhere------------------------------- | |
| 1722 void Parse::ensure_phis_everywhere() { | |
| 1723 ensure_phi(TypeFunc::I_O); | |
| 1724 | |
| 1725 // Ensure a phi on all currently known memories. | |
| 1726 for (MergeMemStream mms(merged_memory()); mms.next_non_empty(); ) { | |
| 1727 ensure_memory_phi(mms.alias_idx()); | |
| 1728 debug_only(mms.set_memory()); // keep the iterator happy | |
| 1729 } | |
| 1730 | |
| 1731 // Note: This is our only chance to create phis for memory slices. | |
| 1732 // If we miss a slice that crops up later, it will have to be | |
| 1733 // merged into the base-memory phi that we are building here. | |
| 1734 // Later, the optimizer will comb out the knot, and build separate | |
| 1735 // phi-loops for each memory slice that matters. | |
| 1736 | |
| 1737 // Monitors must nest nicely and not get confused amongst themselves. | |
| 1738 // Phi-ify everything up to the monitors, though. | |
| 1739 uint monoff = map()->jvms()->monoff(); | |
| 1740 uint nof_monitors = map()->jvms()->nof_monitors(); | |
| 1741 | |
| 1742 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
|
1743 bool check_elide_phi = block()->is_SEL_head(); |
| 0 | 1744 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
|
1745 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
|
1746 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
|
1747 } |
| 0 | 1748 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1749 |
| 0 | 1750 // Even monitors need Phis, though they are well-structured. |
| 1751 // This is true for OSR methods, and also for the rare cases where | |
| 1752 // a monitor object is the subject of a replace_in_map operation. | |
| 1753 // See bugs 4426707 and 5043395. | |
| 1754 for (uint m = 0; m < nof_monitors; m++) { | |
| 1755 ensure_phi(map()->jvms()->monitor_obj_offset(m)); | |
| 1756 } | |
| 1757 } | |
| 1758 | |
| 1759 | |
| 1760 //-----------------------------add_new_path------------------------------------ | |
| 1761 // Add a previously unaccounted predecessor to this block. | |
| 1762 int Parse::Block::add_new_path() { | |
| 1763 // If there is no map, return the lowest unused path number. | |
| 1764 if (!is_merged()) return pred_count()+1; // there will be a map shortly | |
| 1765 | |
| 1766 SafePointNode* map = start_map(); | |
| 1767 if (!map->control()->is_Region()) | |
| 1768 return pred_count()+1; // there may be a region some day | |
| 1769 RegionNode* r = map->control()->as_Region(); | |
| 1770 | |
| 1771 // Add new path to the region. | |
| 1772 uint pnum = r->req(); | |
| 1773 r->add_req(NULL); | |
| 1774 | |
| 1775 for (uint i = 1; i < map->req(); i++) { | |
| 1776 Node* n = map->in(i); | |
| 1777 if (i == TypeFunc::Memory) { | |
| 1778 // Ensure a phi on all currently known memories. | |
| 1779 for (MergeMemStream mms(n->as_MergeMem()); mms.next_non_empty(); ) { | |
| 1780 Node* phi = mms.memory(); | |
| 1781 if (phi->is_Phi() && phi->as_Phi()->region() == r) { | |
| 1782 assert(phi->req() == pnum, "must be same size as region"); | |
| 1783 phi->add_req(NULL); | |
| 1784 } | |
| 1785 } | |
| 1786 } else { | |
| 1787 if (n->is_Phi() && n->as_Phi()->region() == r) { | |
| 1788 assert(n->req() == pnum, "must be same size as region"); | |
| 1789 n->add_req(NULL); | |
| 1790 } | |
| 1791 } | |
| 1792 } | |
| 1793 | |
| 1794 return pnum; | |
| 1795 } | |
| 1796 | |
| 1797 //------------------------------ensure_phi------------------------------------- | |
| 1798 // Turn the idx'th entry of the current map into a Phi | |
| 1799 PhiNode *Parse::ensure_phi(int idx, bool nocreate) { | |
| 1800 SafePointNode* map = this->map(); | |
| 1801 Node* region = map->control(); | |
| 1802 assert(region->is_Region(), ""); | |
| 1803 | |
| 1804 Node* o = map->in(idx); | |
| 1805 assert(o != NULL, ""); | |
| 1806 | |
| 1807 if (o == top()) return NULL; // TOP always merges into TOP | |
| 1808 | |
| 1809 if (o->is_Phi() && o->as_Phi()->region() == region) { | |
| 1810 return o->as_Phi(); | |
| 1811 } | |
| 1812 | |
| 1813 // Now use a Phi here for merging | |
| 1814 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1815 const JVMState* jvms = map->jvms(); | |
| 1816 const Type* t; | |
| 1817 if (jvms->is_loc(idx)) { | |
| 1818 t = block()->local_type_at(idx - jvms->locoff()); | |
| 1819 } else if (jvms->is_stk(idx)) { | |
| 1820 t = block()->stack_type_at(idx - jvms->stkoff()); | |
| 1821 } else if (jvms->is_mon(idx)) { | |
| 1822 assert(!jvms->is_monitor_box(idx), "no phis for boxes"); | |
| 1823 t = TypeInstPtr::BOTTOM; // this is sufficient for a lock object | |
| 1824 } else if ((uint)idx < TypeFunc::Parms) { | |
| 1825 t = o->bottom_type(); // Type::RETURN_ADDRESS or such-like. | |
| 1826 } else { | |
| 1827 assert(false, "no type information for this phi"); | |
| 1828 } | |
| 1829 | |
| 1830 // If the type falls to bottom, then this must be a local that | |
| 1831 // is mixing ints and oops or some such. Forcing it to top | |
| 1832 // makes it go dead. | |
| 1833 if (t == Type::BOTTOM) { | |
| 1834 map->set_req(idx, top()); | |
| 1835 return NULL; | |
| 1836 } | |
| 1837 | |
| 1838 // Do not create phis for top either. | |
| 1839 // A top on a non-null control flow must be an unused even after the.phi. | |
| 1840 if (t == Type::TOP || t == Type::HALF) { | |
| 1841 map->set_req(idx, top()); | |
| 1842 return NULL; | |
| 1843 } | |
| 1844 | |
| 1845 PhiNode* phi = PhiNode::make(region, o, t); | |
| 1846 gvn().set_type(phi, t); | |
|
38
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
1847 if (C->do_escape_analysis()) record_for_igvn(phi); |
| 0 | 1848 map->set_req(idx, phi); |
| 1849 return phi; | |
| 1850 } | |
| 1851 | |
| 1852 //--------------------------ensure_memory_phi---------------------------------- | |
| 1853 // Turn the idx'th slice of the current memory into a Phi | |
| 1854 PhiNode *Parse::ensure_memory_phi(int idx, bool nocreate) { | |
| 1855 MergeMemNode* mem = merged_memory(); | |
| 1856 Node* region = control(); | |
| 1857 assert(region->is_Region(), ""); | |
| 1858 | |
| 1859 Node *o = (idx == Compile::AliasIdxBot)? mem->base_memory(): mem->memory_at(idx); | |
| 1860 assert(o != NULL && o != top(), ""); | |
| 1861 | |
| 1862 PhiNode* phi; | |
| 1863 if (o->is_Phi() && o->as_Phi()->region() == region) { | |
| 1864 phi = o->as_Phi(); | |
| 1865 if (phi == mem->base_memory() && idx >= Compile::AliasIdxRaw) { | |
| 1866 // clone the shared base memory phi to make a new memory split | |
| 1867 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1868 const Type* t = phi->bottom_type(); | |
| 1869 const TypePtr* adr_type = C->get_adr_type(idx); | |
| 1870 phi = phi->slice_memory(adr_type); | |
| 1871 gvn().set_type(phi, t); | |
| 1872 } | |
| 1873 return phi; | |
| 1874 } | |
| 1875 | |
| 1876 // Now use a Phi here for merging | |
| 1877 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1878 const Type* t = o->bottom_type(); | |
| 1879 const TypePtr* adr_type = C->get_adr_type(idx); | |
| 1880 phi = PhiNode::make(region, o, t, adr_type); | |
| 1881 gvn().set_type(phi, t); | |
| 1882 if (idx == Compile::AliasIdxBot) | |
| 1883 mem->set_base_memory(phi); | |
| 1884 else | |
| 1885 mem->set_memory_at(idx, phi); | |
| 1886 return phi; | |
| 1887 } | |
| 1888 | |
| 1889 //------------------------------call_register_finalizer----------------------- | |
| 1890 // Check the klass of the receiver and call register_finalizer if the | |
| 1891 // class need finalization. | |
| 1892 void Parse::call_register_finalizer() { | |
| 1893 Node* receiver = local(0); | |
| 1894 assert(receiver != NULL && receiver->bottom_type()->isa_instptr() != NULL, | |
| 1895 "must have non-null instance type"); | |
| 1896 | |
| 1897 const TypeInstPtr *tinst = receiver->bottom_type()->isa_instptr(); | |
| 1898 if (tinst != NULL && tinst->klass()->is_loaded() && !tinst->klass_is_exact()) { | |
| 1899 // The type isn't known exactly so see if CHA tells us anything. | |
| 1900 ciInstanceKlass* ik = tinst->klass()->as_instance_klass(); | |
| 1901 if (!Dependencies::has_finalizable_subclass(ik)) { | |
| 1902 // No finalizable subclasses so skip the dynamic check. | |
| 1903 C->dependencies()->assert_has_no_finalizable_subclasses(ik); | |
| 1904 return; | |
| 1905 } | |
| 1906 } | |
| 1907 | |
| 1908 // Insert a dynamic test for whether the instance needs | |
| 1909 // finalization. In general this will fold up since the concrete | |
| 1910 // class is often visible so the access flags are constant. | |
| 1911 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
|
1912 Node* klass = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), klass_addr, TypeInstPtr::KLASS) ); |
| 0 | 1913 |
| 1914 Node* access_flags_addr = basic_plus_adr(klass, klass, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc)); | |
| 1915 Node* access_flags = make_load(NULL, access_flags_addr, TypeInt::INT, T_INT); | |
| 1916 | |
| 1917 Node* mask = _gvn.transform(new (C, 3) AndINode(access_flags, intcon(JVM_ACC_HAS_FINALIZER))); | |
| 1918 Node* check = _gvn.transform(new (C, 3) CmpINode(mask, intcon(0))); | |
| 1919 Node* test = _gvn.transform(new (C, 2) BoolNode(check, BoolTest::ne)); | |
| 1920 | |
| 1921 IfNode* iff = create_and_map_if(control(), test, PROB_MAX, COUNT_UNKNOWN); | |
| 1922 | |
| 1923 RegionNode* result_rgn = new (C, 3) RegionNode(3); | |
| 1924 record_for_igvn(result_rgn); | |
| 1925 | |
| 1926 Node *skip_register = _gvn.transform(new (C, 1) IfFalseNode(iff)); | |
| 1927 result_rgn->init_req(1, skip_register); | |
| 1928 | |
| 1929 Node *needs_register = _gvn.transform(new (C, 1) IfTrueNode(iff)); | |
| 1930 set_control(needs_register); | |
| 1931 if (stopped()) { | |
| 1932 // There is no slow path. | |
| 1933 result_rgn->init_req(2, top()); | |
| 1934 } else { | |
| 1935 Node *call = make_runtime_call(RC_NO_LEAF, | |
| 1936 OptoRuntime::register_finalizer_Type(), | |
| 1937 OptoRuntime::register_finalizer_Java(), | |
| 1938 NULL, TypePtr::BOTTOM, | |
| 1939 receiver); | |
| 1940 make_slow_call_ex(call, env()->Throwable_klass(), true); | |
| 1941 | |
| 1942 Node* fast_io = call->in(TypeFunc::I_O); | |
| 1943 Node* fast_mem = call->in(TypeFunc::Memory); | |
| 1944 // These two phis are pre-filled with copies of of the fast IO and Memory | |
| 1945 Node* io_phi = PhiNode::make(result_rgn, fast_io, Type::ABIO); | |
| 1946 Node* mem_phi = PhiNode::make(result_rgn, fast_mem, Type::MEMORY, TypePtr::BOTTOM); | |
| 1947 | |
| 1948 result_rgn->init_req(2, control()); | |
| 1949 io_phi ->init_req(2, i_o()); | |
| 1950 mem_phi ->init_req(2, reset_memory()); | |
| 1951 | |
| 1952 set_all_memory( _gvn.transform(mem_phi) ); | |
| 1953 set_i_o( _gvn.transform(io_phi) ); | |
| 1954 } | |
| 1955 | |
| 1956 set_control( _gvn.transform(result_rgn) ); | |
| 1957 } | |
| 1958 | |
| 1959 //------------------------------return_current--------------------------------- | |
| 1960 // Append current _map to _exit_return | |
| 1961 void Parse::return_current(Node* value) { | |
| 1962 if (RegisterFinalizersAtInit && | |
| 1963 method()->intrinsic_id() == vmIntrinsics::_Object_init) { | |
| 1964 call_register_finalizer(); | |
| 1965 } | |
| 1966 | |
| 1967 // Do not set_parse_bci, so that return goo is credited to the return insn. | |
| 1968 set_bci(InvocationEntryBci); | |
| 1969 if (method()->is_synchronized() && GenerateSynchronizationCode) { | |
| 1970 shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node()); | |
| 1971 } | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
1972 if (C->env()->dtrace_method_probes()) { |
| 0 | 1973 make_dtrace_method_exit(method()); |
| 1974 } | |
| 1975 SafePointNode* exit_return = _exits.map(); | |
| 1976 exit_return->in( TypeFunc::Control )->add_req( control() ); | |
| 1977 exit_return->in( TypeFunc::I_O )->add_req( i_o () ); | |
| 1978 Node *mem = exit_return->in( TypeFunc::Memory ); | |
| 1979 for (MergeMemStream mms(mem->as_MergeMem(), merged_memory()); mms.next_non_empty2(); ) { | |
| 1980 if (mms.is_empty()) { | |
| 1981 // get a copy of the base memory, and patch just this one input | |
| 1982 const TypePtr* adr_type = mms.adr_type(C); | |
| 1983 Node* phi = mms.force_memory()->as_Phi()->slice_memory(adr_type); | |
| 1984 assert(phi->as_Phi()->region() == mms.base_memory()->in(0), ""); | |
| 1985 gvn().set_type_bottom(phi); | |
| 1986 phi->del_req(phi->req()-1); // prepare to re-patch | |
| 1987 mms.set_memory(phi); | |
| 1988 } | |
| 1989 mms.memory()->add_req(mms.memory2()); | |
| 1990 } | |
| 1991 | |
| 1992 // frame pointer is always same, already captured | |
| 1993 if (value != NULL) { | |
| 1994 // If returning oops to an interface-return, there is a silent free | |
| 1995 // cast from oop to interface allowed by the Verifier. Make it explicit | |
| 1996 // here. | |
| 1997 Node* phi = _exits.argument(0); | |
| 1998 const TypeInstPtr *tr = phi->bottom_type()->isa_instptr(); | |
| 1999 if( tr && tr->klass()->is_loaded() && | |
| 2000 tr->klass()->is_interface() ) { | |
| 2001 const TypeInstPtr *tp = value->bottom_type()->isa_instptr(); | |
| 2002 if (tp && tp->klass()->is_loaded() && | |
| 2003 !tp->klass()->is_interface()) { | |
| 2004 // sharpen the type eagerly; this eases certain assert checking | |
| 2005 if (tp->higher_equal(TypeInstPtr::NOTNULL)) | |
| 2006 tr = tr->join(TypeInstPtr::NOTNULL)->is_instptr(); | |
| 2007 value = _gvn.transform(new (C, 2) CheckCastPPNode(0,value,tr)); | |
| 2008 } | |
| 2009 } | |
| 2010 phi->add_req(value); | |
| 2011 } | |
| 2012 | |
| 2013 stop_and_kill_map(); // This CFG path dies here | |
| 2014 } | |
| 2015 | |
| 2016 | |
| 2017 //------------------------------add_safepoint---------------------------------- | |
| 2018 void Parse::add_safepoint() { | |
| 2019 // See if we can avoid this safepoint. No need for a SafePoint immediately | |
| 2020 // after a Call (except Leaf Call) or another SafePoint. | |
| 2021 Node *proj = control(); | |
| 2022 bool add_poll_param = SafePointNode::needs_polling_address_input(); | |
| 2023 uint parms = add_poll_param ? TypeFunc::Parms+1 : TypeFunc::Parms; | |
| 2024 if( proj->is_Proj() ) { | |
| 2025 Node *n0 = proj->in(0); | |
| 2026 if( n0->is_Catch() ) { | |
| 2027 n0 = n0->in(0)->in(0); | |
| 2028 assert( n0->is_Call(), "expect a call here" ); | |
| 2029 } | |
| 2030 if( n0->is_Call() ) { | |
| 2031 if( n0->as_Call()->guaranteed_safepoint() ) | |
| 2032 return; | |
| 2033 } else if( n0->is_SafePoint() && n0->req() >= parms ) { | |
| 2034 return; | |
| 2035 } | |
| 2036 } | |
| 2037 | |
| 2038 // Clear out dead values from the debug info. | |
| 2039 kill_dead_locals(); | |
| 2040 | |
| 2041 // Clone the JVM State | |
| 2042 SafePointNode *sfpnt = new (C, parms) SafePointNode(parms, NULL); | |
| 2043 | |
| 2044 // Capture memory state BEFORE a SafePoint. Since we can block at a | |
| 2045 // SafePoint we need our GC state to be safe; i.e. we need all our current | |
| 2046 // write barriers (card marks) to not float down after the SafePoint so we | |
| 2047 // must read raw memory. Likewise we need all oop stores to match the card | |
| 2048 // marks. If deopt can happen, we need ALL stores (we need the correct JVM | |
| 2049 // state on a deopt). | |
| 2050 | |
| 2051 // We do not need to WRITE the memory state after a SafePoint. The control | |
| 2052 // edge will keep card-marks and oop-stores from floating up from below a | |
| 2053 // SafePoint and our true dependency added here will keep them from floating | |
| 2054 // down below a SafePoint. | |
| 2055 | |
| 2056 // Clone the current memory state | |
| 2057 Node* mem = MergeMemNode::make(C, map()->memory()); | |
| 2058 | |
| 2059 mem = _gvn.transform(mem); | |
| 2060 | |
| 2061 // Pass control through the safepoint | |
| 2062 sfpnt->init_req(TypeFunc::Control , control()); | |
| 2063 // Fix edges normally used by a call | |
| 2064 sfpnt->init_req(TypeFunc::I_O , top() ); | |
| 2065 sfpnt->init_req(TypeFunc::Memory , mem ); | |
| 2066 sfpnt->init_req(TypeFunc::ReturnAdr, top() ); | |
| 2067 sfpnt->init_req(TypeFunc::FramePtr , top() ); | |
| 2068 | |
| 2069 // Create a node for the polling address | |
| 2070 if( add_poll_param ) { | |
| 2071 Node *polladr = ConPNode::make(C, (address)os::get_polling_page()); | |
| 2072 sfpnt->init_req(TypeFunc::Parms+0, _gvn.transform(polladr)); | |
| 2073 } | |
| 2074 | |
| 2075 // Fix up the JVM State edges | |
| 2076 add_safepoint_edges(sfpnt); | |
| 2077 Node *transformed_sfpnt = _gvn.transform(sfpnt); | |
| 2078 set_control(transformed_sfpnt); | |
| 2079 | |
| 2080 // Provide an edge from root to safepoint. This makes the safepoint | |
| 2081 // appear useful until the parse has completed. | |
| 2082 if( OptoRemoveUseless && transformed_sfpnt->is_SafePoint() ) { | |
| 2083 assert(C->root() != NULL, "Expect parse is still valid"); | |
| 2084 C->root()->add_prec(transformed_sfpnt); | |
| 2085 } | |
| 2086 } | |
| 2087 | |
| 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 |