Mercurial > hg > truffle
annotate src/share/vm/opto/parse1.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | 5698813d45eb |
| children | 6f3fd5150b67 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
28 #include "oops/method.hpp" |
| 1972 | 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 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
110 case T_INT: l = new (C) LoadINode( ctl, mem, adr, TypeRawPtr::BOTTOM ); break; |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
111 case T_FLOAT: l = new (C) LoadFNode( ctl, mem, adr, TypeRawPtr::BOTTOM ); break; |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
112 case T_ADDRESS: l = new (C) LoadPNode( ctl, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM ); break; |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
113 case T_OBJECT: l = new (C) 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) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
121 ? (Node*)new (C) LoadDNode( ctl, mem, adr, TypeRawPtr::BOTTOM ) |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
122 : (Node*)new (C) LoadLNode( ctl, mem, adr, TypeRawPtr::BOTTOM ); |
| 0 | 123 } else { |
| 124 l = (bt == T_DOUBLE) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
125 ? (Node*)new (C) LoadD_unalignedNode( ctl, mem, adr, TypeRawPtr::BOTTOM ) |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
126 : (Node*)new (C) 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. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
150 Node* chk = _gvn.transform( new (C) CmpPNode(l, null()) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
151 Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) ); |
| 0 | 152 IfNode* iff = create_and_map_if(control(), tst, PROB_MAX, COUNT_UNKNOWN); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
153 set_control(_gvn.transform( new (C) IfTrueNode(iff) )); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
154 Node* bad_type = _gvn.transform( new (C) IfFalseNode(iff) ); |
| 0 | 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. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
221 Node *box = _gvn.transform(new (C) BoxLockNode(next_monitor())); |
| 0 | 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. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
236 const FastLockNode *flock = _gvn.transform(new (C) FastLockNode( 0, lock_object, box ))->as_FastLock(); |
| 0 | 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(); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
326 bad_type_exit->set_control(new (C) RegionNode(1)); |
| 0 | 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. | |
|
6824
f13867c41f73
7199742: A lot of C2 OSR compilations of the same method's bci
kvn
parents:
6804
diff
changeset
|
375 // It could also happen due to a problem in ciTypeFlow analysis. |
|
f13867c41f73
7199742: A lot of C2 OSR compilations of the same method's bci
kvn
parents:
6804
diff
changeset
|
376 uncommon_trap(Deoptimization::Reason_constraint, |
| 0 | 377 Deoptimization::Action_reinterpret); |
| 378 set_map(types_are_good); | |
| 379 } | |
| 380 } | |
| 381 | |
| 382 //------------------------------Parse------------------------------------------ | |
| 383 // Main parser constructor. | |
| 384 Parse::Parse(JVMState* caller, ciMethod* parse_method, float expected_uses) | |
| 385 : _exits(caller) | |
| 386 { | |
| 387 // Init some variables | |
| 388 _caller = caller; | |
| 389 _method = parse_method; | |
| 390 _expected_uses = expected_uses; | |
| 391 _depth = 1 + (caller->has_method() ? caller->depth() : 0); | |
| 392 _wrote_final = false; | |
| 393 _entry_bci = InvocationEntryBci; | |
| 394 _tf = NULL; | |
| 395 _block = NULL; | |
| 396 debug_only(_block_count = -1); | |
| 397 debug_only(_blocks = (Block*)-1); | |
| 398 #ifndef PRODUCT | |
| 399 if (PrintCompilation || PrintOpto) { | |
| 400 // Make sure I have an inline tree, so I can print messages about it. | |
| 401 JVMState* ilt_caller = is_osr_parse() ? caller->caller() : caller; | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
4790
diff
changeset
|
402 InlineTree::find_subtree_from_root(C->ilt(), ilt_caller, parse_method); |
| 0 | 403 } |
| 404 _max_switch_depth = 0; | |
| 405 _est_switch_depth = 0; | |
| 406 #endif | |
| 407 | |
| 408 _tf = TypeFunc::make(method()); | |
| 409 _iter.reset_to_method(method()); | |
| 410 _flow = method()->get_flow_analysis(); | |
| 411 if (_flow->failing()) { | |
| 412 C->record_method_not_compilable_all_tiers(_flow->failure_reason()); | |
| 413 } | |
| 414 | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
415 #ifndef PRODUCT |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
416 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
|
417 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
|
418 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
419 #endif |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
420 |
| 0 | 421 if (_expected_uses <= 0) { |
| 422 _prof_factor = 1; | |
| 423 } else { | |
| 424 float prof_total = parse_method->interpreter_invocation_count(); | |
| 425 if (prof_total <= _expected_uses) { | |
| 426 _prof_factor = 1; | |
| 427 } else { | |
| 428 _prof_factor = _expected_uses / prof_total; | |
| 429 } | |
| 430 } | |
| 431 | |
| 432 CompileLog* log = C->log(); | |
| 433 if (log != NULL) { | |
| 434 log->begin_head("parse method='%d' uses='%g'", | |
| 435 log->identify(parse_method), expected_uses); | |
| 436 if (depth() == 1 && C->is_osr_compilation()) { | |
| 437 log->print(" osr_bci='%d'", C->entry_bci()); | |
| 438 } | |
| 439 log->stamp(); | |
| 440 log->end_head(); | |
| 441 } | |
| 442 | |
| 443 // Accumulate deoptimization counts. | |
| 444 // (The range_check and store_check counts are checked elsewhere.) | |
| 445 ciMethodData* md = method()->method_data(); | |
| 446 for (uint reason = 0; reason < md->trap_reason_limit(); reason++) { | |
| 447 uint md_count = md->trap_count(reason); | |
| 448 if (md_count != 0) { | |
| 449 if (md_count == md->trap_count_limit()) | |
| 450 md_count += md->overflow_trap_count(); | |
| 451 uint total_count = C->trap_count(reason); | |
| 452 uint old_count = total_count; | |
| 453 total_count += md_count; | |
| 454 // Saturate the add if it overflows. | |
| 455 if (total_count < old_count || total_count < md_count) | |
| 456 total_count = (uint)-1; | |
| 457 C->set_trap_count(reason, total_count); | |
| 458 if (log != NULL) | |
| 459 log->elem("observe trap='%s' count='%d' total='%d'", | |
| 460 Deoptimization::trap_reason_name(reason), | |
| 461 md_count, total_count); | |
| 462 } | |
| 463 } | |
| 464 // Accumulate total sum of decompilations, also. | |
| 465 C->set_decompile_count(C->decompile_count() + md->decompile_count()); | |
| 466 | |
| 467 _count_invocations = C->do_count_invocations(); | |
| 468 _method_data_update = C->do_method_data_update(); | |
| 469 | |
| 470 if (log != NULL && method()->has_exception_handlers()) { | |
| 471 log->elem("observe that='has_exception_handlers'"); | |
| 472 } | |
| 473 | |
| 474 assert(method()->can_be_compiled(), "Can not parse this method, cutout earlier"); | |
| 475 assert(method()->has_balanced_monitors(), "Can not parse unbalanced monitors, cutout earlier"); | |
| 476 | |
| 477 // Always register dependence if JVMTI is enabled, because | |
| 478 // either breakpoint setting or hotswapping of methods may | |
| 479 // 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
|
480 if (C->env()->jvmti_can_hotswap_or_post_breakpoint()) { |
| 0 | 481 C->dependencies()->assert_evol_method(method()); |
| 482 } | |
| 483 | |
| 484 methods_seen++; | |
| 485 | |
| 486 // Do some special top-level things. | |
| 487 if (depth() == 1 && C->is_osr_compilation()) { | |
| 488 _entry_bci = C->entry_bci(); | |
| 489 _flow = method()->get_osr_flow_analysis(osr_bci()); | |
| 490 if (_flow->failing()) { | |
| 491 C->record_method_not_compilable(_flow->failure_reason()); | |
| 492 #ifndef PRODUCT | |
| 493 if (PrintOpto && (Verbose || WizardMode)) { | |
| 494 tty->print_cr("OSR @%d type flow bailout: %s", _entry_bci, _flow->failure_reason()); | |
| 495 if (Verbose) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6268
diff
changeset
|
496 method()->print(); |
| 0 | 497 method()->print_codes(); |
| 498 _flow->print(); | |
| 499 } | |
| 500 } | |
| 501 #endif | |
| 502 } | |
| 503 _tf = C->tf(); // the OSR entry type is different | |
| 504 } | |
| 505 | |
| 506 #ifdef ASSERT | |
| 507 if (depth() == 1) { | |
| 508 assert(C->is_osr_compilation() == this->is_osr_parse(), "OSR in sync"); | |
| 509 if (C->tf() != tf()) { | |
| 510 MutexLockerEx ml(Compile_lock, Mutex::_no_safepoint_check_flag); | |
| 511 assert(C->env()->system_dictionary_modification_counter_changed(), | |
| 512 "Must invalidate if TypeFuncs differ"); | |
| 513 } | |
| 514 } else { | |
| 515 assert(!this->is_osr_parse(), "no recursive OSR"); | |
| 516 } | |
| 517 #endif | |
| 518 | |
| 519 methods_parsed++; | |
| 520 #ifndef PRODUCT | |
| 521 // add method size here to guarantee that inlined methods are added too | |
| 522 if (TimeCompiler) | |
| 523 _total_bytes_compiled += method()->code_size(); | |
| 524 | |
| 525 show_parse_info(); | |
| 526 #endif | |
| 527 | |
| 528 if (failing()) { | |
| 529 if (log) log->done("parse"); | |
| 530 return; | |
| 531 } | |
| 532 | |
| 533 gvn().set_type(root(), root()->bottom_type()); | |
| 534 gvn().transform(top()); | |
| 535 | |
| 536 // Import the results of the ciTypeFlow. | |
| 537 init_blocks(); | |
| 538 | |
| 539 // Merge point for all normal exits | |
| 540 build_exits(); | |
| 541 | |
| 542 // Setup the initial JVM state map. | |
| 543 SafePointNode* entry_map = create_entry_map(); | |
| 544 | |
| 545 // Check for bailouts during map initialization | |
| 546 if (failing() || entry_map == NULL) { | |
| 547 if (log) log->done("parse"); | |
| 548 return; | |
| 549 } | |
| 550 | |
| 551 Node_Notes* caller_nn = C->default_node_notes(); | |
| 552 // Collect debug info for inlined calls unless -XX:-DebugInlinedCalls. | |
| 553 if (DebugInlinedCalls || depth() == 1) { | |
| 554 C->set_default_node_notes(make_node_notes(caller_nn)); | |
| 555 } | |
| 556 | |
| 557 if (is_osr_parse()) { | |
| 558 Node* osr_buf = entry_map->in(TypeFunc::Parms+0); | |
| 559 entry_map->set_req(TypeFunc::Parms+0, top()); | |
| 560 set_map(entry_map); | |
| 561 load_interpreter_state(osr_buf); | |
| 562 } else { | |
| 563 set_map(entry_map); | |
| 564 do_method_entry(); | |
| 565 } | |
| 566 | |
| 567 // Check for bailouts during method entry. | |
| 568 if (failing()) { | |
| 569 if (log) log->done("parse"); | |
| 570 C->set_default_node_notes(caller_nn); | |
| 571 return; | |
| 572 } | |
| 573 | |
| 574 entry_map = map(); // capture any changes performed by method setup code | |
| 575 assert(jvms()->endoff() == map()->req(), "map matches JVMS layout"); | |
| 576 | |
| 577 // We begin parsing as if we have just encountered a jump to the | |
| 578 // method entry. | |
| 579 Block* entry_block = start_block(); | |
| 580 assert(entry_block->start() == (is_osr_parse() ? osr_bci() : 0), ""); | |
| 581 set_map_clone(entry_map); | |
| 582 merge_common(entry_block, entry_block->next_path_num()); | |
| 583 | |
| 584 #ifndef PRODUCT | |
| 585 BytecodeParseHistogram *parse_histogram_obj = new (C->env()->arena()) BytecodeParseHistogram(this, C); | |
| 586 set_parse_histogram( parse_histogram_obj ); | |
| 587 #endif | |
| 588 | |
| 589 // Parse all the basic blocks. | |
| 590 do_all_blocks(); | |
| 591 | |
| 592 C->set_default_node_notes(caller_nn); | |
| 593 | |
| 594 // Check for bailouts during conversion to graph | |
| 595 if (failing()) { | |
| 596 if (log) log->done("parse"); | |
| 597 return; | |
| 598 } | |
| 599 | |
| 600 // Fix up all exiting control flow. | |
| 601 set_map(entry_map); | |
| 602 do_exits(); | |
| 603 | |
|
7196
2aff40cb4703
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
7194
diff
changeset
|
604 if (log) log->done("parse nodes='%d' live='%d' memory='%d'", |
|
2aff40cb4703
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
7194
diff
changeset
|
605 C->unique(), C->live_nodes(), C->node_arena()->used()); |
| 0 | 606 } |
| 607 | |
| 608 //---------------------------do_all_blocks------------------------------------- | |
| 609 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
|
610 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
|
611 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
612 // 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
|
613 while (true) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
614 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
|
615 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
|
616 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
|
617 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
618 if (block->is_parsed()) continue; |
| 0 | 619 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
620 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
|
621 // 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
|
622 continue; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
623 } |
| 0 | 624 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
625 // 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
|
626 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
|
627 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
628 if (stopped()) { |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
629 // 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
|
630 continue; |
|
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 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
633 blocks_parsed++; |
| 0 | 634 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
635 progress = true; |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
636 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
|
637 // 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
|
638 // (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
|
639 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
|
640 |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
641 if (block->is_SEL_head() && |
| 3345 | 642 (UseLoopPredicate || LoopLimitCheck)) { |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
643 // Add predicate to single entry (not irreducible) loop head. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
644 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
|
645 // Need correct bci for predicate. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
646 // 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
|
647 set_parse_bci(block->start()); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
648 add_predicate(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
649 // Add new region for back branches. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
650 int edges = block->pred_count() - block->preds_parsed() + 1; // +1 for original region |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
651 RegionNode *r = new (C) RegionNode(edges+1); |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
652 _gvn.set_type(r, Type::CONTROL); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
653 record_for_igvn(r); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
654 r->init_req(edges, control()); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
655 set_control(r); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
656 // Add new phis. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
657 ensure_phis_everywhere(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
658 } |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
659 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
660 // 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
|
661 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
|
662 } |
| 0 | 663 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
664 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
|
665 // 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
|
666 // associated with a merge that doesn't involve a backedge can |
| 605 | 667 // 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
|
668 // 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
|
669 // 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
|
670 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
|
671 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
|
672 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
|
673 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
|
674 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
675 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
|
676 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
|
677 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
678 } |
| 0 | 679 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
680 // 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
|
681 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
|
682 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
683 // 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
|
684 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
|
685 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
686 |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
687 // 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
|
688 if (!has_irreducible || !progress) { |
| 0 | 689 break; |
| 690 } | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
691 } |
| 0 | 692 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
693 blocks_seen += block_count(); |
| 0 | 694 |
| 695 #ifndef PRODUCT | |
| 696 // Make sure there are no half-processed blocks remaining. | |
| 697 // 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
|
698 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
|
699 Block* block = rpo_at(rpo); |
| 0 | 700 if (!block->is_parsed()) { |
| 701 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
|
702 tty->print_cr("Skipped dead block %d at bci:%d", rpo, block->start()); |
| 0 | 703 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
704 assert(!block->is_merged(), "no half-processed blocks"); |
| 0 | 705 } |
| 706 } | |
| 707 #endif | |
| 708 } | |
| 709 | |
| 710 //-------------------------------build_exits---------------------------------- | |
| 711 // Build normal and exceptional exit merge points. | |
| 712 void Parse::build_exits() { | |
| 713 // make a clone of caller to prevent sharing of side-effects | |
| 714 _exits.set_map(_exits.clone_map()); | |
| 715 _exits.clean_stack(_exits.sp()); | |
| 716 _exits.sync_jvms(); | |
| 717 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
718 RegionNode* region = new (C) RegionNode(1); |
| 0 | 719 record_for_igvn(region); |
| 720 gvn().set_type_bottom(region); | |
| 721 _exits.set_control(region); | |
| 722 | |
| 723 // Note: iophi and memphi are not transformed until do_exits. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
724 Node* iophi = new (C) PhiNode(region, Type::ABIO); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
725 Node* memphi = new (C) PhiNode(region, Type::MEMORY, TypePtr::BOTTOM); |
| 0 | 726 _exits.set_i_o(iophi); |
| 727 _exits.set_all_memory(memphi); | |
| 728 | |
| 729 // Add a return value to the exit state. (Do not push it yet.) | |
| 730 if (tf()->range()->cnt() > TypeFunc::Parms) { | |
| 731 const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms); | |
| 732 // Don't "bind" an unloaded return klass to the ret_phi. If the klass | |
| 733 // becomes loaded during the subsequent parsing, the loaded and unloaded | |
| 734 // types will not join when we transform and push in do_exits(). | |
| 735 const TypeOopPtr* ret_oop_type = ret_type->isa_oopptr(); | |
| 736 if (ret_oop_type && !ret_oop_type->klass()->is_loaded()) { | |
| 737 ret_type = TypeOopPtr::BOTTOM; | |
| 738 } | |
| 739 int ret_size = type2size[ret_type->basic_type()]; | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
740 Node* ret_phi = new (C) PhiNode(region, ret_type); |
| 0 | 741 _exits.ensure_stack(ret_size); |
| 742 assert((int)(tf()->range()->cnt() - TypeFunc::Parms) == ret_size, "good tf range"); | |
| 743 assert(method()->return_type()->size() == ret_size, "tf agrees w/ method"); | |
| 744 _exits.set_argument(0, ret_phi); // here is where the parser finds it | |
| 745 // Note: ret_phi is not yet pushed, until do_exits. | |
| 746 } | |
| 747 } | |
| 748 | |
| 749 | |
| 750 //----------------------------build_start_state------------------------------- | |
| 751 // Construct a state which contains only the incoming arguments from an | |
| 752 // unknown caller. The method & bci will be NULL & InvocationEntryBci. | |
| 753 JVMState* Compile::build_start_state(StartNode* start, const TypeFunc* tf) { | |
| 754 int arg_size = tf->domain()->cnt(); | |
| 755 int max_size = MAX2(arg_size, (int)tf->range()->cnt()); | |
| 756 JVMState* jvms = new (this) JVMState(max_size - TypeFunc::Parms); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
757 SafePointNode* map = new (this) SafePointNode(max_size, NULL); |
| 0 | 758 record_for_igvn(map); |
| 759 assert(arg_size == TypeFunc::Parms + (is_osr_compilation() ? 1 : method()->arg_size()), "correct arg_size"); | |
| 760 Node_Notes* old_nn = default_node_notes(); | |
| 761 if (old_nn != NULL && has_method()) { | |
| 762 Node_Notes* entry_nn = old_nn->clone(this); | |
| 763 JVMState* entry_jvms = new(this) JVMState(method(), old_nn->jvms()); | |
| 764 entry_jvms->set_offsets(0); | |
| 765 entry_jvms->set_bci(entry_bci()); | |
| 766 entry_nn->set_jvms(entry_jvms); | |
| 767 set_default_node_notes(entry_nn); | |
| 768 } | |
| 769 uint i; | |
| 770 for (i = 0; i < (uint)arg_size; i++) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
771 Node* parm = initial_gvn()->transform(new (this) ParmNode(start, i)); |
| 0 | 772 map->init_req(i, parm); |
| 773 // Record all these guys for later GVN. | |
| 774 record_for_igvn(parm); | |
| 775 } | |
| 776 for (; i < map->req(); i++) { | |
| 777 map->init_req(i, top()); | |
| 778 } | |
| 779 assert(jvms->argoff() == TypeFunc::Parms, "parser gets arguments here"); | |
| 780 set_default_node_notes(old_nn); | |
| 781 map->set_jvms(jvms); | |
| 782 jvms->set_map(map); | |
| 783 return jvms; | |
| 784 } | |
| 785 | |
| 786 //-----------------------------make_node_notes--------------------------------- | |
| 787 Node_Notes* Parse::make_node_notes(Node_Notes* caller_nn) { | |
| 788 if (caller_nn == NULL) return NULL; | |
| 789 Node_Notes* nn = caller_nn->clone(C); | |
| 790 JVMState* caller_jvms = nn->jvms(); | |
| 791 JVMState* jvms = new (C) JVMState(method(), caller_jvms); | |
| 792 jvms->set_offsets(0); | |
| 793 jvms->set_bci(_entry_bci); | |
| 794 nn->set_jvms(jvms); | |
| 795 return nn; | |
| 796 } | |
| 797 | |
| 798 | |
| 799 //--------------------------return_values-------------------------------------- | |
| 800 void Compile::return_values(JVMState* jvms) { | |
| 801 GraphKit kit(jvms); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
802 Node* ret = new (this) ReturnNode(TypeFunc::Parms, |
| 0 | 803 kit.control(), |
| 804 kit.i_o(), | |
| 805 kit.reset_memory(), | |
| 806 kit.frameptr(), | |
| 807 kit.returnadr()); | |
| 808 // Add zero or 1 return values | |
| 809 int ret_size = tf()->range()->cnt() - TypeFunc::Parms; | |
| 810 if (ret_size > 0) { | |
| 811 kit.inc_sp(-ret_size); // pop the return value(s) | |
| 812 kit.sync_jvms(); | |
| 813 ret->add_req(kit.argument(0)); | |
| 814 // Note: The second dummy edge is not needed by a ReturnNode. | |
| 815 } | |
| 816 // bind it to root | |
| 817 root()->add_req(ret); | |
| 818 record_for_igvn(ret); | |
| 819 initial_gvn()->transform_no_reclaim(ret); | |
| 820 } | |
| 821 | |
| 822 //------------------------rethrow_exceptions----------------------------------- | |
| 823 // Bind all exception states in the list into a single RethrowNode. | |
| 824 void Compile::rethrow_exceptions(JVMState* jvms) { | |
| 825 GraphKit kit(jvms); | |
| 826 if (!kit.has_exceptions()) return; // nothing to generate | |
| 827 // Load my combined exception state into the kit, with all phis transformed: | |
| 828 SafePointNode* ex_map = kit.combine_and_pop_all_exception_states(); | |
| 829 Node* ex_oop = kit.use_exception_state(ex_map); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
830 RethrowNode* exit = new (this) RethrowNode(kit.control(), |
| 0 | 831 kit.i_o(), kit.reset_memory(), |
| 832 kit.frameptr(), kit.returnadr(), | |
| 833 // like a return but with exception input | |
| 834 ex_oop); | |
| 835 // bind to root | |
| 836 root()->add_req(exit); | |
| 837 record_for_igvn(exit); | |
| 838 initial_gvn()->transform_no_reclaim(exit); | |
| 839 } | |
| 840 | |
| 841 //---------------------------do_exceptions------------------------------------- | |
| 842 // Process exceptions arising from the current bytecode. | |
| 843 // Send caught exceptions to the proper handler within this method. | |
| 844 // Unhandled exceptions feed into _exit. | |
| 845 void Parse::do_exceptions() { | |
| 846 if (!has_exceptions()) return; | |
| 847 | |
| 848 if (failing()) { | |
| 849 // Pop them all off and throw them away. | |
| 850 while (pop_exception_state() != NULL) ; | |
| 851 return; | |
| 852 } | |
| 853 | |
| 854 PreserveJVMState pjvms(this, false); | |
| 855 | |
| 856 SafePointNode* ex_map; | |
| 857 while ((ex_map = pop_exception_state()) != NULL) { | |
| 858 if (!method()->has_exception_handlers()) { | |
| 859 // Common case: Transfer control outward. | |
| 860 // Doing it this early allows the exceptions to common up | |
| 861 // even between adjacent method calls. | |
| 862 throw_to_exit(ex_map); | |
| 863 } else { | |
| 864 // Have to look at the exception first. | |
| 865 assert(stopped(), "catch_inline_exceptions trashes the map"); | |
| 866 catch_inline_exceptions(ex_map); | |
| 867 stop_and_kill_map(); // we used up this exception state; kill it | |
| 868 } | |
| 869 } | |
| 870 | |
| 871 // We now return to our regularly scheduled program: | |
| 872 } | |
| 873 | |
| 874 //---------------------------throw_to_exit------------------------------------- | |
| 875 // Merge the given map into an exception exit from this method. | |
| 876 // The exception exit will handle any unlocking of receiver. | |
| 877 // The ex_oop must be saved within the ex_map, unlike merge_exception. | |
| 878 void Parse::throw_to_exit(SafePointNode* ex_map) { | |
| 879 // Pop the JVMS to (a copy of) the caller. | |
| 880 GraphKit caller; | |
| 881 caller.set_map_clone(_caller->map()); | |
| 882 caller.set_bci(_caller->bci()); | |
| 883 caller.set_sp(_caller->sp()); | |
| 884 // Copy out the standard machine state: | |
| 885 for (uint i = 0; i < TypeFunc::Parms; i++) { | |
| 886 caller.map()->set_req(i, ex_map->in(i)); | |
| 887 } | |
| 888 // ...and the exception: | |
| 889 Node* ex_oop = saved_ex_oop(ex_map); | |
| 890 SafePointNode* caller_ex_map = caller.make_exception_state(ex_oop); | |
| 891 // Finally, collect the new exception state in my exits: | |
| 892 _exits.add_exception_state(caller_ex_map); | |
| 893 } | |
| 894 | |
| 895 //------------------------------do_exits--------------------------------------- | |
| 896 void Parse::do_exits() { | |
| 897 set_parse_bci(InvocationEntryBci); | |
| 898 | |
| 899 // Now peephole on the return bits | |
| 900 Node* region = _exits.control(); | |
| 901 _exits.set_control(gvn().transform(region)); | |
| 902 | |
| 903 Node* iophi = _exits.i_o(); | |
| 904 _exits.set_i_o(gvn().transform(iophi)); | |
| 905 | |
| 906 if (wrote_final()) { | |
| 907 // This method (which must be a constructor by the rules of Java) | |
| 908 // wrote a final. The effects of all initializations must be | |
| 909 // committed to memory before any code after the constructor | |
| 910 // publishes the reference to the newly constructor object. | |
| 911 // Rather than wait for the publication, we simply block the | |
| 912 // writes here. Rather than put a barrier on only those writes | |
| 913 // which are required to complete, we force all writes to complete. | |
| 914 // | |
| 915 // "All bets are off" unless the first publication occurs after a | |
| 916 // normal return from the constructor. We do not attempt to detect | |
| 917 // such unusual early publications. But no barrier is needed on | |
| 918 // exceptional returns, since they cannot publish normally. | |
| 919 // | |
| 920 _exits.insert_mem_bar(Op_MemBarRelease); | |
| 921 #ifndef PRODUCT | |
| 922 if (PrintOpto && (Verbose || WizardMode)) { | |
| 923 method()->print_name(); | |
| 924 tty->print_cr(" writes finals and needs a memory barrier"); | |
| 925 } | |
| 926 #endif | |
| 927 } | |
| 928 | |
| 929 for (MergeMemStream mms(_exits.merged_memory()); mms.next_non_empty(); ) { | |
| 930 // transform each slice of the original memphi: | |
| 931 mms.set_memory(_gvn.transform(mms.memory())); | |
| 932 } | |
| 933 | |
| 934 if (tf()->range()->cnt() > TypeFunc::Parms) { | |
| 935 const Type* ret_type = tf()->range()->field_at(TypeFunc::Parms); | |
| 936 Node* ret_phi = _gvn.transform( _exits.argument(0) ); | |
| 937 assert(_exits.control()->is_top() || !_gvn.type(ret_phi)->empty(), "return value must be well defined"); | |
| 938 _exits.push_node(ret_type->basic_type(), ret_phi); | |
| 939 } | |
| 940 | |
| 941 // Note: Logic for creating and optimizing the ReturnNode is in Compile. | |
| 942 | |
| 943 // Unlock along the exceptional paths. | |
| 944 // This is done late so that we can common up equivalent exceptions | |
| 945 // (e.g., null checks) arising from multiple points within this method. | |
| 946 // See GraphKit::add_exception_state, which performs the commoning. | |
| 947 bool do_synch = method()->is_synchronized() && GenerateSynchronizationCode; | |
| 948 | |
| 949 // 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
|
950 if (do_synch || C->env()->dtrace_method_probes()) { |
| 0 | 951 // First move the exception list out of _exits: |
| 952 GraphKit kit(_exits.transfer_exceptions_into_jvms()); | |
| 953 SafePointNode* normal_map = kit.map(); // keep this guy safe | |
| 954 // Now re-collect the exceptions into _exits: | |
| 955 SafePointNode* ex_map; | |
| 956 while ((ex_map = kit.pop_exception_state()) != NULL) { | |
| 957 Node* ex_oop = kit.use_exception_state(ex_map); | |
| 958 // Force the exiting JVM state to have this method at InvocationEntryBci. | |
| 959 // The exiting JVM state is otherwise a copy of the calling JVMS. | |
| 960 JVMState* caller = kit.jvms(); | |
| 961 JVMState* ex_jvms = caller->clone_shallow(C); | |
| 962 ex_jvms->set_map(kit.clone_map()); | |
| 963 ex_jvms->map()->set_jvms(ex_jvms); | |
| 964 ex_jvms->set_bci( InvocationEntryBci); | |
| 965 kit.set_jvms(ex_jvms); | |
| 966 if (do_synch) { | |
| 967 // Add on the synchronized-method box/object combo | |
| 968 kit.map()->push_monitor(_synch_lock); | |
| 969 // Unlock! | |
| 970 kit.shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node()); | |
| 971 } | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
972 if (C->env()->dtrace_method_probes()) { |
| 0 | 973 kit.make_dtrace_method_exit(method()); |
| 974 } | |
| 975 // Done with exception-path processing. | |
| 976 ex_map = kit.make_exception_state(ex_oop); | |
| 977 assert(ex_jvms->same_calls_as(ex_map->jvms()), "sanity"); | |
| 978 // Pop the last vestige of this method: | |
| 979 ex_map->set_jvms(caller->clone_shallow(C)); | |
| 980 ex_map->jvms()->set_map(ex_map); | |
| 981 _exits.push_exception_state(ex_map); | |
| 982 } | |
| 983 assert(_exits.map() == normal_map, "keep the same return state"); | |
| 984 } | |
| 985 | |
| 986 { | |
| 987 // Capture very early exceptions (receiver null checks) from caller JVMS | |
| 988 GraphKit caller(_caller); | |
| 989 SafePointNode* ex_map; | |
| 990 while ((ex_map = caller.pop_exception_state()) != NULL) { | |
| 991 _exits.add_exception_state(ex_map); | |
| 992 } | |
| 993 } | |
| 994 } | |
| 995 | |
| 996 //-----------------------------create_entry_map------------------------------- | |
| 997 // Initialize our parser map to contain the types at method entry. | |
| 998 // For OSR, the map contains a single RawPtr parameter. | |
| 999 // Initial monitor locking for sync. methods is performed by do_method_entry. | |
| 1000 SafePointNode* Parse::create_entry_map() { | |
| 1001 // Check for really stupid bail-out cases. | |
| 1002 uint len = TypeFunc::Parms + method()->max_locals() + method()->max_stack(); | |
| 1003 if (len >= 32760) { | |
| 1004 C->record_method_not_compilable_all_tiers("too many local variables"); | |
| 1005 return NULL; | |
| 1006 } | |
| 1007 | |
| 1008 // If this is an inlined method, we may have to do a receiver null check. | |
| 1009 if (_caller->has_method() && is_normal_parse() && !method()->is_static()) { | |
| 1010 GraphKit kit(_caller); | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6843
diff
changeset
|
1011 kit.null_check_receiver_before_call(method()); |
| 0 | 1012 _caller = kit.transfer_exceptions_into_jvms(); |
| 1013 if (kit.stopped()) { | |
| 1014 _exits.add_exception_states_from(_caller); | |
| 1015 _exits.set_jvms(_caller); | |
| 1016 return NULL; | |
| 1017 } | |
| 1018 } | |
| 1019 | |
| 1020 assert(method() != NULL, "parser must have a method"); | |
| 1021 | |
| 1022 // Create an initial safepoint to hold JVM state during parsing | |
| 1023 JVMState* jvms = new (C) JVMState(method(), _caller->has_method() ? _caller : NULL); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1024 set_map(new (C) SafePointNode(len, jvms)); |
| 0 | 1025 jvms->set_map(map()); |
| 1026 record_for_igvn(map()); | |
| 1027 assert(jvms->endoff() == len, "correct jvms sizing"); | |
| 1028 | |
| 1029 SafePointNode* inmap = _caller->map(); | |
| 1030 assert(inmap != NULL, "must have inmap"); | |
| 1031 | |
| 1032 uint i; | |
| 1033 | |
| 1034 // Pass thru the predefined input parameters. | |
| 1035 for (i = 0; i < TypeFunc::Parms; i++) { | |
| 1036 map()->init_req(i, inmap->in(i)); | |
| 1037 } | |
| 1038 | |
| 1039 if (depth() == 1) { | |
| 1040 assert(map()->memory()->Opcode() == Op_Parm, ""); | |
| 1041 // Insert the memory aliasing node | |
| 1042 set_all_memory(reset_memory()); | |
| 1043 } | |
| 1044 assert(merged_memory(), ""); | |
| 1045 | |
| 1046 // Now add the locals which are initially bound to arguments: | |
| 1047 uint arg_size = tf()->domain()->cnt(); | |
| 1048 ensure_stack(arg_size - TypeFunc::Parms); // OSR methods have funny args | |
| 1049 for (i = TypeFunc::Parms; i < arg_size; i++) { | |
| 1050 map()->init_req(i, inmap->argument(_caller, i - TypeFunc::Parms)); | |
| 1051 } | |
| 1052 | |
| 1053 // Clear out the rest of the map (locals and stack) | |
| 1054 for (i = arg_size; i < len; i++) { | |
| 1055 map()->init_req(i, top()); | |
| 1056 } | |
| 1057 | |
| 1058 SafePointNode* entry_map = stop(); | |
| 1059 return entry_map; | |
| 1060 } | |
| 1061 | |
| 1062 //-----------------------------do_method_entry-------------------------------- | |
| 1063 // Emit any code needed in the pseudo-block before BCI zero. | |
| 1064 // The main thing to do is lock the receiver of a synchronized method. | |
| 1065 void Parse::do_method_entry() { | |
| 1066 set_parse_bci(InvocationEntryBci); // Pseudo-BCP | |
| 1067 set_sp(0); // Java Stack Pointer | |
| 1068 | |
| 1069 NOT_PRODUCT( count_compiled_calls(true/*at_method_entry*/, false/*is_inline*/); ) | |
| 1070 | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
1071 if (C->env()->dtrace_method_probes()) { |
| 0 | 1072 make_dtrace_method_entry(method()); |
| 1073 } | |
| 1074 | |
| 1075 // If the method is synchronized, we need to construct a lock node, attach | |
| 1076 // it to the Start node, and pin it there. | |
| 1077 if (method()->is_synchronized()) { | |
| 1078 // Insert a FastLockNode right after the Start which takes as arguments | |
| 1079 // the current thread pointer, the "this" pointer & the address of the | |
| 1080 // stack slot pair used for the lock. The "this" pointer is a projection | |
| 1081 // off the start node, but the locking spot has to be constructed by | |
| 1082 // creating a ConLNode of 0, and boxing it with a BoxLockNode. The BoxLockNode | |
| 1083 // becomes the second argument to the FastLockNode call. The | |
| 1084 // FastLockNode becomes the new control parent to pin it to the start. | |
| 1085 | |
| 1086 // Setup Object Pointer | |
| 1087 Node *lock_obj = NULL; | |
| 1088 if(method()->is_static()) { | |
| 1089 ciInstance* mirror = _method->holder()->java_mirror(); | |
| 1090 const TypeInstPtr *t_lock = TypeInstPtr::make(mirror); | |
| 1091 lock_obj = makecon(t_lock); | |
| 1092 } else { // Else pass the "this" pointer, | |
| 1093 lock_obj = local(0); // which is Parm0 from StartNode | |
| 1094 } | |
| 1095 // Clear out dead values from the debug info. | |
| 1096 kill_dead_locals(); | |
| 1097 // Build the FastLockNode | |
| 1098 _synch_lock = shared_lock(lock_obj); | |
| 1099 } | |
| 1100 | |
| 1101 if (depth() == 1) { | |
| 1102 increment_and_test_invocation_counter(Tier2CompileThreshold); | |
| 1103 } | |
| 1104 } | |
| 1105 | |
| 1106 //------------------------------init_blocks------------------------------------ | |
| 1107 // Initialize our parser map to contain the types/monitors at method entry. | |
| 1108 void Parse::init_blocks() { | |
| 1109 // Create the blocks. | |
| 1110 _block_count = flow()->block_count(); | |
| 1111 _blocks = NEW_RESOURCE_ARRAY(Block, _block_count); | |
| 1112 Copy::zero_to_bytes(_blocks, sizeof(Block)*_block_count); | |
| 1113 | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1114 int rpo; |
| 0 | 1115 |
| 1116 // 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
|
1117 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
|
1118 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
|
1119 block->init_node(this, rpo); |
| 0 | 1120 } |
| 1121 | |
| 1122 // 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
|
1123 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
|
1124 Block* block = rpo_at(rpo); |
| 0 | 1125 block->init_graph(this); |
| 1126 } | |
| 1127 } | |
| 1128 | |
| 1129 //-------------------------------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
|
1130 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
|
1131 _flow = outer->flow()->rpo_at(rpo); |
| 0 | 1132 _pred_count = 0; |
| 1133 _preds_parsed = 0; | |
| 1134 _count = 0; | |
| 1135 assert(pred_count() == 0 && preds_parsed() == 0, "sanity"); | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1136 assert(!(is_merged() || is_parsed() || is_handler() || has_merged_backedge()), "sanity"); |
| 0 | 1137 assert(_live_locals.size() == 0, "sanity"); |
| 1138 | |
| 1139 // entry point has additional predecessor | |
| 1140 if (flow()->is_start()) _pred_count++; | |
| 1141 assert(flow()->is_start() == (this == outer->start_block()), ""); | |
| 1142 } | |
| 1143 | |
| 1144 //-------------------------------init_graph------------------------------------ | |
| 1145 void Parse::Block::init_graph(Parse* outer) { | |
| 1146 // Create the successor list for this parser block. | |
| 1147 GrowableArray<ciTypeFlow::Block*>* tfs = flow()->successors(); | |
| 1148 GrowableArray<ciTypeFlow::Block*>* tfe = flow()->exceptions(); | |
| 1149 int ns = tfs->length(); | |
| 1150 int ne = tfe->length(); | |
| 1151 _num_successors = ns; | |
| 1152 _all_successors = ns+ne; | |
| 1153 _successors = (ns+ne == 0) ? NULL : NEW_RESOURCE_ARRAY(Block*, ns+ne); | |
| 1154 int p = 0; | |
| 1155 for (int i = 0; i < ns+ne; i++) { | |
| 1156 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
|
1157 Block* block2 = outer->rpo_at(tf2->rpo()); |
| 0 | 1158 _successors[i] = block2; |
| 1159 | |
| 1160 // Accumulate pred info for the other block, too. | |
| 1161 if (i < ns) { | |
| 1162 block2->_pred_count++; | |
| 1163 } else { | |
| 1164 block2->_is_handler = true; | |
| 1165 } | |
| 1166 | |
| 1167 #ifdef ASSERT | |
| 1168 // A block's successors must be distinguishable by BCI. | |
| 1169 // That is, no bytecode is allowed to branch to two different | |
| 1170 // clones of the same code location. | |
| 1171 for (int j = 0; j < i; j++) { | |
| 1172 Block* block1 = _successors[j]; | |
| 1173 if (block1 == block2) continue; // duplicates are OK | |
| 1174 assert(block1->start() != block2->start(), "successors have unique bcis"); | |
| 1175 } | |
| 1176 #endif | |
| 1177 } | |
| 1178 | |
| 1179 // Note: We never call next_path_num along exception paths, so they | |
| 1180 // never get processed as "ready". Also, the input phis of exception | |
| 1181 // handlers get specially processed, so that | |
| 1182 } | |
| 1183 | |
| 1184 //---------------------------successor_for_bci--------------------------------- | |
| 1185 Parse::Block* Parse::Block::successor_for_bci(int bci) { | |
| 1186 for (int i = 0; i < all_successors(); i++) { | |
| 1187 Block* block2 = successor_at(i); | |
| 1188 if (block2->start() == bci) return block2; | |
| 1189 } | |
| 1190 // We can actually reach here if ciTypeFlow traps out a block | |
| 1191 // due to an unloaded class, and concurrently with compilation the | |
| 1192 // class is then loaded, so that a later phase of the parser is | |
| 1193 // able to see more of the bytecode CFG. Or, the flow pass and | |
| 1194 // the parser can have a minor difference of opinion about executability | |
| 1195 // of bytecodes. For example, "obj.field = null" is executable even | |
| 1196 // if the field's type is an unloaded class; the flow pass used to | |
| 1197 // make a trap for such code. | |
| 1198 return NULL; | |
| 1199 } | |
| 1200 | |
| 1201 | |
| 1202 //-----------------------------stack_type_at----------------------------------- | |
| 1203 const Type* Parse::Block::stack_type_at(int i) const { | |
| 1204 return get_type(flow()->stack_type_at(i)); | |
| 1205 } | |
| 1206 | |
| 1207 | |
| 1208 //-----------------------------local_type_at----------------------------------- | |
| 1209 const Type* Parse::Block::local_type_at(int i) const { | |
| 1210 // Make dead locals fall to bottom. | |
| 1211 if (_live_locals.size() == 0) { | |
| 1212 MethodLivenessResult live_locals = flow()->outer()->method()->liveness_at_bci(start()); | |
| 1213 // This bitmap can be zero length if we saw a breakpoint. | |
| 1214 // In such cases, pretend they are all live. | |
| 1215 ((Block*)this)->_live_locals = live_locals; | |
| 1216 } | |
| 1217 if (_live_locals.size() > 0 && !_live_locals.at(i)) | |
| 1218 return Type::BOTTOM; | |
| 1219 | |
| 1220 return get_type(flow()->local_type_at(i)); | |
| 1221 } | |
| 1222 | |
| 1223 | |
| 1224 #ifndef PRODUCT | |
| 1225 | |
| 1226 //----------------------------name_for_bc-------------------------------------- | |
| 1227 // helper method for BytecodeParseHistogram | |
| 1228 static const char* name_for_bc(int i) { | |
| 1229 return Bytecodes::is_defined(i) ? Bytecodes::name(Bytecodes::cast(i)) : "xxxunusedxxx"; | |
| 1230 } | |
| 1231 | |
| 1232 //----------------------------BytecodeParseHistogram------------------------------------ | |
| 1233 Parse::BytecodeParseHistogram::BytecodeParseHistogram(Parse *p, Compile *c) { | |
| 1234 _parser = p; | |
| 1235 _compiler = c; | |
| 1236 if( ! _initialized ) { _initialized = true; reset(); } | |
| 1237 } | |
| 1238 | |
| 1239 //----------------------------current_count------------------------------------ | |
| 1240 int Parse::BytecodeParseHistogram::current_count(BPHType bph_type) { | |
| 1241 switch( bph_type ) { | |
| 1242 case BPH_transforms: { return _parser->gvn().made_progress(); } | |
| 1243 case BPH_values: { return _parser->gvn().made_new_values(); } | |
| 1244 default: { ShouldNotReachHere(); return 0; } | |
| 1245 } | |
| 1246 } | |
| 1247 | |
| 1248 //----------------------------initialized-------------------------------------- | |
| 1249 bool Parse::BytecodeParseHistogram::initialized() { return _initialized; } | |
| 1250 | |
| 1251 //----------------------------reset-------------------------------------------- | |
| 1252 void Parse::BytecodeParseHistogram::reset() { | |
| 1253 int i = Bytecodes::number_of_codes; | |
| 1254 while (i-- > 0) { _bytecodes_parsed[i] = 0; _nodes_constructed[i] = 0; _nodes_transformed[i] = 0; _new_values[i] = 0; } | |
| 1255 } | |
| 1256 | |
| 1257 //----------------------------set_initial_state-------------------------------- | |
| 1258 // Record info when starting to parse one bytecode | |
| 1259 void Parse::BytecodeParseHistogram::set_initial_state( Bytecodes::Code bc ) { | |
| 1260 if( PrintParseStatistics && !_parser->is_osr_parse() ) { | |
| 1261 _initial_bytecode = bc; | |
| 1262 _initial_node_count = _compiler->unique(); | |
| 1263 _initial_transforms = current_count(BPH_transforms); | |
| 1264 _initial_values = current_count(BPH_values); | |
| 1265 } | |
| 1266 } | |
| 1267 | |
| 1268 //----------------------------record_change-------------------------------- | |
| 1269 // Record results of parsing one bytecode | |
| 1270 void Parse::BytecodeParseHistogram::record_change() { | |
| 1271 if( PrintParseStatistics && !_parser->is_osr_parse() ) { | |
| 1272 ++_bytecodes_parsed[_initial_bytecode]; | |
| 1273 _nodes_constructed [_initial_bytecode] += (_compiler->unique() - _initial_node_count); | |
| 1274 _nodes_transformed [_initial_bytecode] += (current_count(BPH_transforms) - _initial_transforms); | |
| 1275 _new_values [_initial_bytecode] += (current_count(BPH_values) - _initial_values); | |
| 1276 } | |
| 1277 } | |
| 1278 | |
| 1279 | |
| 1280 //----------------------------print-------------------------------------------- | |
| 1281 void Parse::BytecodeParseHistogram::print(float cutoff) { | |
| 1282 ResourceMark rm; | |
| 1283 // print profile | |
| 1284 int total = 0; | |
| 1285 int i = 0; | |
| 1286 for( i = 0; i < Bytecodes::number_of_codes; ++i ) { total += _bytecodes_parsed[i]; } | |
| 1287 int abs_sum = 0; | |
| 1288 tty->cr(); //0123456789012345678901234567890123456789012345678901234567890123456789 | |
| 1289 tty->print_cr("Histogram of %d parsed bytecodes:", total); | |
| 1290 if( total == 0 ) { return; } | |
| 1291 tty->cr(); | |
| 1292 tty->print_cr("absolute: count of compiled bytecodes of this type"); | |
| 1293 tty->print_cr("relative: percentage contribution to compiled nodes"); | |
| 1294 tty->print_cr("nodes : Average number of nodes constructed per bytecode"); | |
| 1295 tty->print_cr("rnodes : Significance towards total nodes constructed, (nodes*relative)"); | |
| 1296 tty->print_cr("transforms: Average amount of tranform progress per bytecode compiled"); | |
| 1297 tty->print_cr("values : Average number of node values improved per bytecode"); | |
| 1298 tty->print_cr("name : Bytecode name"); | |
| 1299 tty->cr(); | |
| 1300 tty->print_cr(" absolute relative nodes rnodes transforms values name"); | |
| 1301 tty->print_cr("----------------------------------------------------------------------"); | |
| 1302 while (--i > 0) { | |
| 1303 int abs = _bytecodes_parsed[i]; | |
| 1304 float rel = abs * 100.0F / total; | |
| 1305 float nodes = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_constructed[i])/_bytecodes_parsed[i]; | |
| 1306 float rnodes = _bytecodes_parsed[i] == 0 ? 0 : rel * nodes; | |
| 1307 float xforms = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _nodes_transformed[i])/_bytecodes_parsed[i]; | |
| 1308 float values = _bytecodes_parsed[i] == 0 ? 0 : (1.0F * _new_values [i])/_bytecodes_parsed[i]; | |
| 1309 if (cutoff <= rel) { | |
| 1310 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)); | |
| 1311 abs_sum += abs; | |
| 1312 } | |
| 1313 } | |
| 1314 tty->print_cr("----------------------------------------------------------------------"); | |
| 1315 float rel_sum = abs_sum * 100.0F / total; | |
| 1316 tty->print_cr("%10d %7.2f%% (cutoff = %.2f%%)", abs_sum, rel_sum, cutoff); | |
| 1317 tty->print_cr("----------------------------------------------------------------------"); | |
| 1318 tty->cr(); | |
| 1319 } | |
| 1320 #endif | |
| 1321 | |
| 1322 //----------------------------load_state_from---------------------------------- | |
| 1323 // Load block/map/sp. But not do not touch iter/bci. | |
| 1324 void Parse::load_state_from(Block* block) { | |
| 1325 set_block(block); | |
| 1326 // load the block's JVM state: | |
| 1327 set_map(block->start_map()); | |
| 1328 set_sp( block->start_sp()); | |
| 1329 } | |
| 1330 | |
| 1331 | |
| 1332 //-----------------------------record_state------------------------------------ | |
| 1333 void Parse::Block::record_state(Parse* p) { | |
| 1334 assert(!is_merged(), "can only record state once, on 1st inflow"); | |
| 1335 assert(start_sp() == p->sp(), "stack pointer must agree with ciTypeFlow"); | |
| 1336 set_start_map(p->stop()); | |
| 1337 } | |
| 1338 | |
| 1339 | |
| 1340 //------------------------------do_one_block----------------------------------- | |
| 1341 void Parse::do_one_block() { | |
| 1342 if (TraceOptoParse) { | |
| 1343 Block *b = block(); | |
| 1344 int ns = b->num_successors(); | |
| 1345 int nt = b->all_successors(); | |
| 1346 | |
| 1347 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
|
1348 block()->rpo(), block()->start(), block()->limit()); |
| 0 | 1349 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
|
1350 tty->print((( i < ns) ? " %d" : " %d(e)"), b->successor_at(i)->rpo()); |
| 0 | 1351 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1352 if (b->is_loop_head()) tty->print(" lphd"); |
| 0 | 1353 tty->print_cr(""); |
| 1354 } | |
| 1355 | |
| 1356 assert(block()->is_merged(), "must be merged before being parsed"); | |
| 1357 block()->mark_parsed(); | |
| 1358 ++_blocks_parsed; | |
| 1359 | |
| 1360 // Set iterator to start of block. | |
| 1361 iter().reset_to_bci(block()->start()); | |
| 1362 | |
| 1363 CompileLog* log = C->log(); | |
| 1364 | |
| 1365 // Parse bytecodes | |
| 1366 while (!stopped() && !failing()) { | |
| 1367 iter().next(); | |
| 1368 | |
| 1369 // Learn the current bci from the iterator: | |
| 1370 set_parse_bci(iter().cur_bci()); | |
| 1371 | |
| 1372 if (bci() == block()->limit()) { | |
| 1373 // Do not walk into the next block until directed by do_all_blocks. | |
| 1374 merge(bci()); | |
| 1375 break; | |
| 1376 } | |
| 1377 assert(bci() < block()->limit(), "bci still in block"); | |
| 1378 | |
| 1379 if (log != NULL) { | |
| 1380 // Output an optional context marker, to help place actions | |
| 1381 // that occur during parsing of this BC. If there is no log | |
| 1382 // output until the next context string, this context string | |
| 1383 // will be silently ignored. | |
| 6843 | 1384 log->set_context("bc code='%d' bci='%d'", (int)bc(), bci()); |
| 0 | 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; | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6843
diff
changeset
|
1401 bool have_se = !stopped() && compute_stack_effects(inputs, depth); |
|
6268
6c5b7a6becc8
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
6266
diff
changeset
|
1402 assert(!have_se || pre_bc_sp >= inputs, err_msg_res("have enough stack to execute this BC: pre_bc_sp=%d, inputs=%d", pre_bc_sp, inputs)); |
| 0 | 1403 #endif //ASSERT |
| 1404 | |
| 1405 do_one_bytecode(); | |
| 1406 | |
| 7478 | 1407 assert(!have_se || stopped() || failing() || (sp() - pre_bc_sp) == depth, |
| 1408 err_msg_res("incorrect depth prediction: sp=%d, pre_bc_sp=%d, depth=%d", sp(), pre_bc_sp, depth)); | |
| 0 | 1409 |
| 1410 do_exceptions(); | |
| 1411 | |
| 1412 NOT_PRODUCT( parse_histogram()->record_change(); ); | |
| 1413 | |
| 6843 | 1414 if (log != NULL) |
| 1415 log->clear_context(); // skip marker if nothing was printed | |
| 0 | 1416 |
| 1417 // Fall into next bytecode. Each bytecode normally has 1 sequential | |
| 1418 // successor which is typically made ready by visiting this bytecode. | |
| 1419 // If the successor has several predecessors, then it is a merge | |
| 1420 // point, starts a new basic block, and is handled like other basic blocks. | |
| 1421 } | |
| 1422 } | |
| 1423 | |
| 1424 | |
| 1425 //------------------------------merge------------------------------------------ | |
| 1426 void Parse::set_parse_bci(int bci) { | |
| 1427 set_bci(bci); | |
| 1428 Node_Notes* nn = C->default_node_notes(); | |
| 1429 if (nn == NULL) return; | |
| 1430 | |
| 1431 // Collect debug info for inlined calls unless -XX:-DebugInlinedCalls. | |
| 1432 if (!DebugInlinedCalls && depth() > 1) { | |
| 1433 return; | |
| 1434 } | |
| 1435 | |
| 1436 // Update the JVMS annotation, if present. | |
| 1437 JVMState* jvms = nn->jvms(); | |
| 1438 if (jvms != NULL && jvms->bci() != bci) { | |
| 1439 // Update the JVMS. | |
| 1440 jvms = jvms->clone_shallow(C); | |
| 1441 jvms->set_bci(bci); | |
| 1442 nn->set_jvms(jvms); | |
| 1443 } | |
| 1444 } | |
| 1445 | |
| 1446 //------------------------------merge------------------------------------------ | |
| 1447 // Merge the current mapping into the basic block starting at bci | |
| 1448 void Parse::merge(int target_bci) { | |
| 1449 Block* target = successor_for_bci(target_bci); | |
| 1450 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1451 assert(!target->is_ready(), "our arrival must be expected"); | |
| 1452 int pnum = target->next_path_num(); | |
| 1453 merge_common(target, pnum); | |
| 1454 } | |
| 1455 | |
| 1456 //-------------------------merge_new_path-------------------------------------- | |
| 1457 // Merge the current mapping into the basic block, using a new path | |
| 1458 void Parse::merge_new_path(int target_bci) { | |
| 1459 Block* target = successor_for_bci(target_bci); | |
| 1460 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1461 assert(!target->is_ready(), "new path into frozen graph"); | |
| 1462 int pnum = target->add_new_path(); | |
| 1463 merge_common(target, pnum); | |
| 1464 } | |
| 1465 | |
| 1466 //-------------------------merge_exception------------------------------------- | |
| 1467 // Merge the current mapping into the basic block starting at bci | |
| 1468 // The ex_oop must be pushed on the stack, unlike throw_to_exit. | |
| 1469 void Parse::merge_exception(int target_bci) { | |
| 1470 assert(sp() == 1, "must have only the throw exception on the stack"); | |
| 1471 Block* target = successor_for_bci(target_bci); | |
| 1472 if (target == NULL) { handle_missing_successor(target_bci); return; } | |
| 1473 assert(target->is_handler(), "exceptions are handled by special blocks"); | |
| 1474 int pnum = target->add_new_path(); | |
| 1475 merge_common(target, pnum); | |
| 1476 } | |
| 1477 | |
| 1478 //--------------------handle_missing_successor--------------------------------- | |
| 1479 void Parse::handle_missing_successor(int target_bci) { | |
| 1480 #ifndef PRODUCT | |
| 1481 Block* b = block(); | |
| 1482 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
|
1483 tty->print_cr("### Missing successor at bci:%d for block #%d (trap_bci:%d)", target_bci, b->rpo(), trap_bci); |
| 0 | 1484 #endif |
| 1485 ShouldNotReachHere(); | |
| 1486 } | |
| 1487 | |
| 1488 //--------------------------merge_common--------------------------------------- | |
| 1489 void Parse::merge_common(Parse::Block* target, int pnum) { | |
| 1490 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
|
1491 tty->print("Merging state at block #%d bci:%d", target->rpo(), target->start()); |
| 0 | 1492 } |
| 1493 | |
| 1494 // Zap extra stack slots to top | |
| 1495 assert(sp() == target->start_sp(), ""); | |
| 1496 clean_stack(sp()); | |
| 1497 | |
| 1498 if (!target->is_merged()) { // No prior mapping at this bci | |
| 1499 if (TraceOptoParse) { tty->print(" with empty state"); } | |
| 1500 | |
| 1501 // If this path is dead, do not bother capturing it as a merge. | |
| 1502 // It is "as if" we had 1 fewer predecessors from the beginning. | |
| 1503 if (stopped()) { | |
| 1504 if (TraceOptoParse) tty->print_cr(", but path is dead and doesn't count"); | |
| 1505 return; | |
| 1506 } | |
| 1507 | |
| 1508 // Record that a new block has been merged. | |
| 1509 ++_blocks_merged; | |
| 1510 | |
| 1511 // Make a region if we know there are multiple or unpredictable inputs. | |
| 1512 // (Also, if this is a plain fall-through, we might see another region, | |
| 1513 // which must not be allowed into this block's map.) | |
| 1514 if (pnum > PhiNode::Input // Known multiple inputs. | |
| 1515 || 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
|
1516 || target->is_loop_head() // Known multiple inputs |
| 0 | 1517 || control()->is_Region()) { // We must hide this guy. |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1518 |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1519 int current_bci = bci(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1520 set_parse_bci(target->start()); // Set target bci |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1521 if (target->is_SEL_head()) { |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1522 DEBUG_ONLY( target->mark_merged_backedge(block()); ) |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1523 if (target->start() == 0) { |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1524 // Add loop predicate for the special case when |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1525 // there are backbranches to the method entry. |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1526 add_predicate(); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1527 } |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1528 } |
| 0 | 1529 // Add a Region to start the new basic block. Phis will be added |
| 1530 // later lazily. | |
| 1531 int edges = target->pred_count(); | |
| 1532 if (edges < pnum) edges = pnum; // might be a new path! | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1533 RegionNode *r = new (C) RegionNode(edges+1); |
| 0 | 1534 gvn().set_type(r, Type::CONTROL); |
| 1535 record_for_igvn(r); | |
| 1536 // zap all inputs to NULL for debugging (done in Node(uint) constructor) | |
| 1537 // for (int j = 1; j < edges+1; j++) { r->init_req(j, NULL); } | |
| 1538 r->init_req(pnum, control()); | |
| 1539 set_control(r); | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1540 set_parse_bci(current_bci); // Restore bci |
| 0 | 1541 } |
| 1542 | |
| 1543 // Convert the existing Parser mapping into a mapping at this bci. | |
| 1544 store_state_to(target); | |
| 1545 assert(target->is_merged(), "do not come here twice"); | |
| 1546 | |
| 1547 } else { // Prior mapping at this bci | |
| 1548 if (TraceOptoParse) { tty->print(" with previous state"); } | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1549 #ifdef ASSERT |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1550 if (target->is_SEL_head()) { |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1551 target->mark_merged_backedge(block()); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1552 } |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
1553 #endif |
| 0 | 1554 // We must not manufacture more phis if the target is already parsed. |
| 1555 bool nophi = target->is_parsed(); | |
| 1556 | |
| 1557 SafePointNode* newin = map();// Hang on to incoming mapping | |
| 1558 Block* save_block = block(); // Hang on to incoming block; | |
| 1559 load_state_from(target); // Get prior mapping | |
| 1560 | |
| 1561 assert(newin->jvms()->locoff() == jvms()->locoff(), "JVMS layouts agree"); | |
| 1562 assert(newin->jvms()->stkoff() == jvms()->stkoff(), "JVMS layouts agree"); | |
| 1563 assert(newin->jvms()->monoff() == jvms()->monoff(), "JVMS layouts agree"); | |
| 1564 assert(newin->jvms()->endoff() == jvms()->endoff(), "JVMS layouts agree"); | |
| 1565 | |
| 1566 // Iterate over my current mapping and the old mapping. | |
| 1567 // Where different, insert Phi functions. | |
| 1568 // Use any existing Phi functions. | |
| 1569 assert(control()->is_Region(), "must be merging to a region"); | |
| 1570 RegionNode* r = control()->as_Region(); | |
| 1571 | |
| 1572 // Compute where to merge into | |
| 1573 // 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
|
1574 r->init_req(pnum, newin->control()); |
| 0 | 1575 |
| 1576 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
|
1577 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
|
1578 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
|
1579 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
|
1580 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
|
1581 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1582 } |
| 0 | 1583 record_for_igvn(r); |
| 1584 } | |
| 1585 | |
| 1586 // Update all the non-control inputs to map: | |
| 1587 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
|
1588 bool check_elide_phi = target->is_SEL_backedge(save_block); |
| 0 | 1589 for (uint j = 1; j < newin->req(); j++) { |
| 1590 Node* m = map()->in(j); // Current state of target. | |
| 1591 Node* n = newin->in(j); // Incoming change to target state. | |
| 1592 PhiNode* phi; | |
| 1593 if (m->is_Phi() && m->as_Phi()->region() == r) | |
| 1594 phi = m->as_Phi(); | |
| 1595 else | |
| 1596 phi = NULL; | |
| 1597 if (m != n) { // Different; must merge | |
| 1598 switch (j) { | |
| 1599 // Frame pointer and Return Address never changes | |
| 1600 case TypeFunc::FramePtr:// Drop m, use the original value | |
| 1601 case TypeFunc::ReturnAdr: | |
| 1602 break; | |
| 1603 case TypeFunc::Memory: // Merge inputs to the MergeMem node | |
| 1604 assert(phi == NULL, "the merge contains phis, not vice versa"); | |
| 1605 merge_memory_edges(n->as_MergeMem(), pnum, nophi); | |
| 1606 continue; | |
| 1607 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
|
1608 if (phi == NULL) { |
|
4790
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1609 const JVMState* jvms = map()->jvms(); |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1610 if (EliminateNestedLocks && |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1611 jvms->is_mon(j) && jvms->is_monitor_box(j)) { |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1612 // BoxLock nodes are not commoning. |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1613 // Use old BoxLock node as merged box. |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1614 assert(newin->jvms()->is_monitor_box(j), "sanity"); |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1615 // This assert also tests that nodes are BoxLock. |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1616 assert(BoxLockNode::same_slot(n, m), "sanity"); |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1617 C->gvn_replace_by(n, m); |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1618 } else if (!check_elide_phi || !target->can_elide_SEL_phi(j)) { |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1619 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
|
1620 } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1621 } |
| 0 | 1622 break; |
| 1623 } | |
| 1624 } | |
| 1625 // At this point, n might be top if: | |
| 1626 // - there is no phi (because TypeFlow detected a conflict), or | |
| 1627 // - the corresponding control edges is top (a dead incoming path) | |
| 1628 // It is a bug if we create a phi which sees a garbage value on a live path. | |
| 1629 | |
| 1630 if (phi != NULL) { | |
| 1631 assert(n != top() || r->in(pnum) == top(), "live value must not be garbage"); | |
| 1632 assert(phi->region() == r, ""); | |
| 1633 phi->set_req(pnum, n); // Then add 'n' to the merge | |
| 1634 if (pnum == PhiNode::Input) { | |
| 1635 // Last merge for this Phi. | |
| 1636 // So far, Phis have had a reasonable type from ciTypeFlow. | |
| 1637 // Now _gvn will join that with the meet of current inputs. | |
| 1638 // BOTTOM is never permissible here, 'cause pessimistically | |
| 1639 // Phis of pointers cannot lose the basic pointer type. | |
| 1640 debug_only(const Type* bt1 = phi->bottom_type()); | |
| 1641 assert(bt1 != Type::BOTTOM, "should not be building conflict phis"); | |
| 1642 map()->set_req(j, _gvn.transform_no_reclaim(phi)); | |
| 1643 debug_only(const Type* bt2 = phi->bottom_type()); | |
| 1644 assert(bt2->higher_equal(bt1), "must be consistent with type-flow"); | |
| 1645 record_for_igvn(phi); | |
| 1646 } | |
| 1647 } | |
| 1648 } // End of for all values to be merged | |
| 1649 | |
| 1650 if (pnum == PhiNode::Input && | |
| 1651 !r->in(0)) { // The occasional useless Region | |
| 1652 assert(control() == r, ""); | |
| 1653 set_control(r->nonnull_req()); | |
| 1654 } | |
| 1655 | |
| 1656 // newin has been subsumed into the lazy merge, and is now dead. | |
| 1657 set_block(save_block); | |
| 1658 | |
| 1659 stop(); // done with this guy, for now | |
| 1660 } | |
| 1661 | |
| 1662 if (TraceOptoParse) { | |
| 1663 tty->print_cr(" on path %d", pnum); | |
| 1664 } | |
| 1665 | |
| 1666 // Done with this parser state. | |
| 1667 assert(stopped(), ""); | |
| 1668 } | |
| 1669 | |
| 1670 | |
| 1671 //--------------------------merge_memory_edges--------------------------------- | |
| 1672 void Parse::merge_memory_edges(MergeMemNode* n, int pnum, bool nophi) { | |
| 1673 // (nophi means we must not create phis, because we already parsed here) | |
| 1674 assert(n != NULL, ""); | |
| 1675 // Merge the inputs to the MergeMems | |
| 1676 MergeMemNode* m = merged_memory(); | |
| 1677 | |
| 1678 assert(control()->is_Region(), "must be merging to a region"); | |
| 1679 RegionNode* r = control()->as_Region(); | |
| 1680 | |
| 1681 PhiNode* base = NULL; | |
| 1682 MergeMemNode* remerge = NULL; | |
| 1683 for (MergeMemStream mms(m, n); mms.next_non_empty2(); ) { | |
| 1684 Node *p = mms.force_memory(); | |
| 1685 Node *q = mms.memory2(); | |
| 1686 if (mms.is_empty() && nophi) { | |
| 1687 // Trouble: No new splits allowed after a loop body is parsed. | |
| 1688 // Instead, wire the new split into a MergeMem on the backedge. | |
| 1689 // The optimizer will sort it out, slicing the phi. | |
| 1690 if (remerge == NULL) { | |
| 1691 assert(base != NULL, ""); | |
| 1692 assert(base->in(0) != NULL, "should not be xformed away"); | |
| 1693 remerge = MergeMemNode::make(C, base->in(pnum)); | |
| 1694 gvn().set_type(remerge, Type::MEMORY); | |
| 1695 base->set_req(pnum, remerge); | |
| 1696 } | |
| 1697 remerge->set_memory_at(mms.alias_idx(), q); | |
| 1698 continue; | |
| 1699 } | |
| 1700 assert(!q->is_MergeMem(), ""); | |
| 1701 PhiNode* phi; | |
| 1702 if (p != q) { | |
| 1703 phi = ensure_memory_phi(mms.alias_idx(), nophi); | |
| 1704 } else { | |
| 1705 if (p->is_Phi() && p->as_Phi()->region() == r) | |
| 1706 phi = p->as_Phi(); | |
| 1707 else | |
| 1708 phi = NULL; | |
| 1709 } | |
| 1710 // Insert q into local phi | |
| 1711 if (phi != NULL) { | |
| 1712 assert(phi->region() == r, ""); | |
| 1713 p = phi; | |
| 1714 phi->set_req(pnum, q); | |
| 1715 if (mms.at_base_memory()) { | |
| 1716 base = phi; // delay transforming it | |
| 1717 } else if (pnum == 1) { | |
| 1718 record_for_igvn(phi); | |
| 1719 p = _gvn.transform_no_reclaim(phi); | |
| 1720 } | |
| 1721 mms.set_memory(p);// store back through the iterator | |
| 1722 } | |
| 1723 } | |
| 1724 // Transform base last, in case we must fiddle with remerging. | |
| 1725 if (base != NULL && pnum == 1) { | |
| 1726 record_for_igvn(base); | |
| 1727 m->set_base_memory( _gvn.transform_no_reclaim(base) ); | |
| 1728 } | |
| 1729 } | |
| 1730 | |
| 1731 | |
| 1732 //------------------------ensure_phis_everywhere------------------------------- | |
| 1733 void Parse::ensure_phis_everywhere() { | |
| 1734 ensure_phi(TypeFunc::I_O); | |
| 1735 | |
| 1736 // Ensure a phi on all currently known memories. | |
| 1737 for (MergeMemStream mms(merged_memory()); mms.next_non_empty(); ) { | |
| 1738 ensure_memory_phi(mms.alias_idx()); | |
| 1739 debug_only(mms.set_memory()); // keep the iterator happy | |
| 1740 } | |
| 1741 | |
| 1742 // Note: This is our only chance to create phis for memory slices. | |
| 1743 // If we miss a slice that crops up later, it will have to be | |
| 1744 // merged into the base-memory phi that we are building here. | |
| 1745 // Later, the optimizer will comb out the knot, and build separate | |
| 1746 // phi-loops for each memory slice that matters. | |
| 1747 | |
| 1748 // Monitors must nest nicely and not get confused amongst themselves. | |
| 1749 // Phi-ify everything up to the monitors, though. | |
| 1750 uint monoff = map()->jvms()->monoff(); | |
| 1751 uint nof_monitors = map()->jvms()->nof_monitors(); | |
| 1752 | |
| 1753 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
|
1754 bool check_elide_phi = block()->is_SEL_head(); |
| 0 | 1755 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
|
1756 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
|
1757 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
|
1758 } |
| 0 | 1759 } |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
1760 |
| 0 | 1761 // Even monitors need Phis, though they are well-structured. |
| 1762 // This is true for OSR methods, and also for the rare cases where | |
| 1763 // a monitor object is the subject of a replace_in_map operation. | |
| 1764 // See bugs 4426707 and 5043395. | |
| 1765 for (uint m = 0; m < nof_monitors; m++) { | |
| 1766 ensure_phi(map()->jvms()->monitor_obj_offset(m)); | |
| 1767 } | |
| 1768 } | |
| 1769 | |
| 1770 | |
| 1771 //-----------------------------add_new_path------------------------------------ | |
| 1772 // Add a previously unaccounted predecessor to this block. | |
| 1773 int Parse::Block::add_new_path() { | |
| 1774 // If there is no map, return the lowest unused path number. | |
| 1775 if (!is_merged()) return pred_count()+1; // there will be a map shortly | |
| 1776 | |
| 1777 SafePointNode* map = start_map(); | |
| 1778 if (!map->control()->is_Region()) | |
| 1779 return pred_count()+1; // there may be a region some day | |
| 1780 RegionNode* r = map->control()->as_Region(); | |
| 1781 | |
| 1782 // Add new path to the region. | |
| 1783 uint pnum = r->req(); | |
| 1784 r->add_req(NULL); | |
| 1785 | |
| 1786 for (uint i = 1; i < map->req(); i++) { | |
| 1787 Node* n = map->in(i); | |
| 1788 if (i == TypeFunc::Memory) { | |
| 1789 // Ensure a phi on all currently known memories. | |
| 1790 for (MergeMemStream mms(n->as_MergeMem()); mms.next_non_empty(); ) { | |
| 1791 Node* phi = mms.memory(); | |
| 1792 if (phi->is_Phi() && phi->as_Phi()->region() == r) { | |
| 1793 assert(phi->req() == pnum, "must be same size as region"); | |
| 1794 phi->add_req(NULL); | |
| 1795 } | |
| 1796 } | |
| 1797 } else { | |
| 1798 if (n->is_Phi() && n->as_Phi()->region() == r) { | |
| 1799 assert(n->req() == pnum, "must be same size as region"); | |
| 1800 n->add_req(NULL); | |
| 1801 } | |
| 1802 } | |
| 1803 } | |
| 1804 | |
| 1805 return pnum; | |
| 1806 } | |
| 1807 | |
| 1808 //------------------------------ensure_phi------------------------------------- | |
| 1809 // Turn the idx'th entry of the current map into a Phi | |
| 1810 PhiNode *Parse::ensure_phi(int idx, bool nocreate) { | |
| 1811 SafePointNode* map = this->map(); | |
| 1812 Node* region = map->control(); | |
| 1813 assert(region->is_Region(), ""); | |
| 1814 | |
| 1815 Node* o = map->in(idx); | |
| 1816 assert(o != NULL, ""); | |
| 1817 | |
| 1818 if (o == top()) return NULL; // TOP always merges into TOP | |
| 1819 | |
| 1820 if (o->is_Phi() && o->as_Phi()->region() == region) { | |
| 1821 return o->as_Phi(); | |
| 1822 } | |
| 1823 | |
| 1824 // Now use a Phi here for merging | |
| 1825 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1826 const JVMState* jvms = map->jvms(); | |
| 1827 const Type* t; | |
| 1828 if (jvms->is_loc(idx)) { | |
| 1829 t = block()->local_type_at(idx - jvms->locoff()); | |
| 1830 } else if (jvms->is_stk(idx)) { | |
| 1831 t = block()->stack_type_at(idx - jvms->stkoff()); | |
| 1832 } else if (jvms->is_mon(idx)) { | |
|
4790
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1833 assert(!jvms->is_monitor_box(idx), "no phis for boxes"); |
|
b0ff910edfc9
7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents:
4777
diff
changeset
|
1834 t = TypeInstPtr::BOTTOM; // this is sufficient for a lock object |
| 0 | 1835 } else if ((uint)idx < TypeFunc::Parms) { |
| 1836 t = o->bottom_type(); // Type::RETURN_ADDRESS or such-like. | |
| 1837 } else { | |
| 1838 assert(false, "no type information for this phi"); | |
| 1839 } | |
| 1840 | |
| 1841 // If the type falls to bottom, then this must be a local that | |
| 1842 // is mixing ints and oops or some such. Forcing it to top | |
| 1843 // makes it go dead. | |
| 1844 if (t == Type::BOTTOM) { | |
| 1845 map->set_req(idx, top()); | |
| 1846 return NULL; | |
| 1847 } | |
| 1848 | |
| 1849 // Do not create phis for top either. | |
| 1850 // A top on a non-null control flow must be an unused even after the.phi. | |
| 1851 if (t == Type::TOP || t == Type::HALF) { | |
| 1852 map->set_req(idx, top()); | |
| 1853 return NULL; | |
| 1854 } | |
| 1855 | |
| 1856 PhiNode* phi = PhiNode::make(region, o, t); | |
| 1857 gvn().set_type(phi, t); | |
|
38
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
1858 if (C->do_escape_analysis()) record_for_igvn(phi); |
| 0 | 1859 map->set_req(idx, phi); |
| 1860 return phi; | |
| 1861 } | |
| 1862 | |
| 1863 //--------------------------ensure_memory_phi---------------------------------- | |
| 1864 // Turn the idx'th slice of the current memory into a Phi | |
| 1865 PhiNode *Parse::ensure_memory_phi(int idx, bool nocreate) { | |
| 1866 MergeMemNode* mem = merged_memory(); | |
| 1867 Node* region = control(); | |
| 1868 assert(region->is_Region(), ""); | |
| 1869 | |
| 1870 Node *o = (idx == Compile::AliasIdxBot)? mem->base_memory(): mem->memory_at(idx); | |
| 1871 assert(o != NULL && o != top(), ""); | |
| 1872 | |
| 1873 PhiNode* phi; | |
| 1874 if (o->is_Phi() && o->as_Phi()->region() == region) { | |
| 1875 phi = o->as_Phi(); | |
| 1876 if (phi == mem->base_memory() && idx >= Compile::AliasIdxRaw) { | |
| 1877 // clone the shared base memory phi to make a new memory split | |
| 1878 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1879 const Type* t = phi->bottom_type(); | |
| 1880 const TypePtr* adr_type = C->get_adr_type(idx); | |
| 1881 phi = phi->slice_memory(adr_type); | |
| 1882 gvn().set_type(phi, t); | |
| 1883 } | |
| 1884 return phi; | |
| 1885 } | |
| 1886 | |
| 1887 // Now use a Phi here for merging | |
| 1888 assert(!nocreate, "Cannot build a phi for a block already parsed."); | |
| 1889 const Type* t = o->bottom_type(); | |
| 1890 const TypePtr* adr_type = C->get_adr_type(idx); | |
| 1891 phi = PhiNode::make(region, o, t, adr_type); | |
| 1892 gvn().set_type(phi, t); | |
| 1893 if (idx == Compile::AliasIdxBot) | |
| 1894 mem->set_base_memory(phi); | |
| 1895 else | |
| 1896 mem->set_memory_at(idx, phi); | |
| 1897 return phi; | |
| 1898 } | |
| 1899 | |
| 1900 //------------------------------call_register_finalizer----------------------- | |
| 1901 // Check the klass of the receiver and call register_finalizer if the | |
| 1902 // class need finalization. | |
| 1903 void Parse::call_register_finalizer() { | |
| 1904 Node* receiver = local(0); | |
| 1905 assert(receiver != NULL && receiver->bottom_type()->isa_instptr() != NULL, | |
| 1906 "must have non-null instance type"); | |
| 1907 | |
| 1908 const TypeInstPtr *tinst = receiver->bottom_type()->isa_instptr(); | |
| 1909 if (tinst != NULL && tinst->klass()->is_loaded() && !tinst->klass_is_exact()) { | |
| 1910 // The type isn't known exactly so see if CHA tells us anything. | |
| 1911 ciInstanceKlass* ik = tinst->klass()->as_instance_klass(); | |
| 1912 if (!Dependencies::has_finalizable_subclass(ik)) { | |
| 1913 // No finalizable subclasses so skip the dynamic check. | |
| 1914 C->dependencies()->assert_has_no_finalizable_subclasses(ik); | |
| 1915 return; | |
| 1916 } | |
| 1917 } | |
| 1918 | |
| 1919 // Insert a dynamic test for whether the instance needs | |
| 1920 // finalization. In general this will fold up since the concrete | |
| 1921 // class is often visible so the access flags are constant. | |
| 1922 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
|
1923 Node* klass = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), klass_addr, TypeInstPtr::KLASS) ); |
| 0 | 1924 |
|
4762
069ab3f976d3
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
3345
diff
changeset
|
1925 Node* access_flags_addr = basic_plus_adr(klass, klass, in_bytes(Klass::access_flags_offset())); |
| 0 | 1926 Node* access_flags = make_load(NULL, access_flags_addr, TypeInt::INT, T_INT); |
| 1927 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1928 Node* mask = _gvn.transform(new (C) AndINode(access_flags, intcon(JVM_ACC_HAS_FINALIZER))); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1929 Node* check = _gvn.transform(new (C) CmpINode(mask, intcon(0))); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1930 Node* test = _gvn.transform(new (C) BoolNode(check, BoolTest::ne)); |
| 0 | 1931 |
| 1932 IfNode* iff = create_and_map_if(control(), test, PROB_MAX, COUNT_UNKNOWN); | |
| 1933 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1934 RegionNode* result_rgn = new (C) RegionNode(3); |
| 0 | 1935 record_for_igvn(result_rgn); |
| 1936 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1937 Node *skip_register = _gvn.transform(new (C) IfFalseNode(iff)); |
| 0 | 1938 result_rgn->init_req(1, skip_register); |
| 1939 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
1940 Node *needs_register = _gvn.transform(new (C) IfTrueNode(iff)); |
| 0 | 1941 set_control(needs_register); |
| 1942 if (stopped()) { | |
| 1943 // There is no slow path. | |
| 1944 result_rgn->init_req(2, top()); | |
| 1945 } else { | |
| 1946 Node *call = make_runtime_call(RC_NO_LEAF, | |
| 1947 OptoRuntime::register_finalizer_Type(), | |
| 1948 OptoRuntime::register_finalizer_Java(), | |
| 1949 NULL, TypePtr::BOTTOM, | |
| 1950 receiver); | |
| 1951 make_slow_call_ex(call, env()->Throwable_klass(), true); | |
| 1952 | |
| 1953 Node* fast_io = call->in(TypeFunc::I_O); | |
| 1954 Node* fast_mem = call->in(TypeFunc::Memory); | |
| 1955 // These two phis are pre-filled with copies of of the fast IO and Memory | |
| 1956 Node* io_phi = PhiNode::make(result_rgn, fast_io, Type::ABIO); | |
| 1957 Node* mem_phi = PhiNode::make(result_rgn, fast_mem, Type::MEMORY, TypePtr::BOTTOM); | |
| 1958 | |
| 1959 result_rgn->init_req(2, control()); | |
| 1960 io_phi ->init_req(2, i_o()); | |
| 1961 mem_phi ->init_req(2, reset_memory()); | |
| 1962 | |
| 1963 set_all_memory( _gvn.transform(mem_phi) ); | |
| 1964 set_i_o( _gvn.transform(io_phi) ); | |
| 1965 } | |
| 1966 | |
| 1967 set_control( _gvn.transform(result_rgn) ); | |
| 1968 } | |
| 1969 | |
| 1970 //------------------------------return_current--------------------------------- | |
| 1971 // Append current _map to _exit_return | |
| 1972 void Parse::return_current(Node* value) { | |
| 1973 if (RegisterFinalizersAtInit && | |
| 1974 method()->intrinsic_id() == vmIntrinsics::_Object_init) { | |
| 1975 call_register_finalizer(); | |
| 1976 } | |
| 1977 | |
| 1978 // Do not set_parse_bci, so that return goo is credited to the return insn. | |
| 1979 set_bci(InvocationEntryBci); | |
| 1980 if (method()->is_synchronized() && GenerateSynchronizationCode) { | |
| 1981 shared_unlock(_synch_lock->box_node(), _synch_lock->obj_node()); | |
| 1982 } | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
1983 if (C->env()->dtrace_method_probes()) { |
| 0 | 1984 make_dtrace_method_exit(method()); |
| 1985 } | |
| 1986 SafePointNode* exit_return = _exits.map(); | |
| 1987 exit_return->in( TypeFunc::Control )->add_req( control() ); | |
| 1988 exit_return->in( TypeFunc::I_O )->add_req( i_o () ); | |
| 1989 Node *mem = exit_return->in( TypeFunc::Memory ); | |
| 1990 for (MergeMemStream mms(mem->as_MergeMem(), merged_memory()); mms.next_non_empty2(); ) { | |
| 1991 if (mms.is_empty()) { | |
| 1992 // get a copy of the base memory, and patch just this one input | |
| 1993 const TypePtr* adr_type = mms.adr_type(C); | |
| 1994 Node* phi = mms.force_memory()->as_Phi()->slice_memory(adr_type); | |
| 1995 assert(phi->as_Phi()->region() == mms.base_memory()->in(0), ""); | |
| 1996 gvn().set_type_bottom(phi); | |
| 1997 phi->del_req(phi->req()-1); // prepare to re-patch | |
| 1998 mms.set_memory(phi); | |
| 1999 } | |
| 2000 mms.memory()->add_req(mms.memory2()); | |
| 2001 } | |
| 2002 | |
| 2003 // frame pointer is always same, already captured | |
| 2004 if (value != NULL) { | |
| 2005 // If returning oops to an interface-return, there is a silent free | |
| 2006 // cast from oop to interface allowed by the Verifier. Make it explicit | |
| 2007 // here. | |
| 2008 Node* phi = _exits.argument(0); | |
| 2009 const TypeInstPtr *tr = phi->bottom_type()->isa_instptr(); | |
| 2010 if( tr && tr->klass()->is_loaded() && | |
| 2011 tr->klass()->is_interface() ) { | |
| 2012 const TypeInstPtr *tp = value->bottom_type()->isa_instptr(); | |
| 2013 if (tp && tp->klass()->is_loaded() && | |
| 2014 !tp->klass()->is_interface()) { | |
| 2015 // sharpen the type eagerly; this eases certain assert checking | |
| 2016 if (tp->higher_equal(TypeInstPtr::NOTNULL)) | |
| 2017 tr = tr->join(TypeInstPtr::NOTNULL)->is_instptr(); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
2018 value = _gvn.transform(new (C) CheckCastPPNode(0,value,tr)); |
| 0 | 2019 } |
| 2020 } | |
| 2021 phi->add_req(value); | |
| 2022 } | |
| 2023 | |
| 2024 stop_and_kill_map(); // This CFG path dies here | |
| 2025 } | |
| 2026 | |
| 2027 | |
| 2028 //------------------------------add_safepoint---------------------------------- | |
| 2029 void Parse::add_safepoint() { | |
| 2030 // See if we can avoid this safepoint. No need for a SafePoint immediately | |
| 2031 // after a Call (except Leaf Call) or another SafePoint. | |
| 2032 Node *proj = control(); | |
| 2033 bool add_poll_param = SafePointNode::needs_polling_address_input(); | |
| 2034 uint parms = add_poll_param ? TypeFunc::Parms+1 : TypeFunc::Parms; | |
| 2035 if( proj->is_Proj() ) { | |
| 2036 Node *n0 = proj->in(0); | |
| 2037 if( n0->is_Catch() ) { | |
| 2038 n0 = n0->in(0)->in(0); | |
| 2039 assert( n0->is_Call(), "expect a call here" ); | |
| 2040 } | |
| 2041 if( n0->is_Call() ) { | |
| 2042 if( n0->as_Call()->guaranteed_safepoint() ) | |
| 2043 return; | |
| 2044 } else if( n0->is_SafePoint() && n0->req() >= parms ) { | |
| 2045 return; | |
| 2046 } | |
| 2047 } | |
| 2048 | |
| 2049 // Clear out dead values from the debug info. | |
| 2050 kill_dead_locals(); | |
| 2051 | |
| 2052 // Clone the JVM State | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6725
diff
changeset
|
2053 SafePointNode *sfpnt = new (C) SafePointNode(parms, NULL); |
| 0 | 2054 |
| 2055 // Capture memory state BEFORE a SafePoint. Since we can block at a | |
| 2056 // SafePoint we need our GC state to be safe; i.e. we need all our current | |
| 2057 // write barriers (card marks) to not float down after the SafePoint so we | |
| 2058 // must read raw memory. Likewise we need all oop stores to match the card | |
| 2059 // marks. If deopt can happen, we need ALL stores (we need the correct JVM | |
| 2060 // state on a deopt). | |
| 2061 | |
| 2062 // We do not need to WRITE the memory state after a SafePoint. The control | |
| 2063 // edge will keep card-marks and oop-stores from floating up from below a | |
| 2064 // SafePoint and our true dependency added here will keep them from floating | |
| 2065 // down below a SafePoint. | |
| 2066 | |
| 2067 // Clone the current memory state | |
| 2068 Node* mem = MergeMemNode::make(C, map()->memory()); | |
| 2069 | |
| 2070 mem = _gvn.transform(mem); | |
| 2071 | |
| 2072 // Pass control through the safepoint | |
| 2073 sfpnt->init_req(TypeFunc::Control , control()); | |
| 2074 // Fix edges normally used by a call | |
| 2075 sfpnt->init_req(TypeFunc::I_O , top() ); | |
| 2076 sfpnt->init_req(TypeFunc::Memory , mem ); | |
| 2077 sfpnt->init_req(TypeFunc::ReturnAdr, top() ); | |
| 2078 sfpnt->init_req(TypeFunc::FramePtr , top() ); | |
| 2079 | |
| 2080 // Create a node for the polling address | |
| 2081 if( add_poll_param ) { | |
| 2082 Node *polladr = ConPNode::make(C, (address)os::get_polling_page()); | |
| 2083 sfpnt->init_req(TypeFunc::Parms+0, _gvn.transform(polladr)); | |
| 2084 } | |
| 2085 | |
| 2086 // Fix up the JVM State edges | |
| 2087 add_safepoint_edges(sfpnt); | |
| 2088 Node *transformed_sfpnt = _gvn.transform(sfpnt); | |
| 2089 set_control(transformed_sfpnt); | |
| 2090 | |
| 2091 // Provide an edge from root to safepoint. This makes the safepoint | |
| 2092 // appear useful until the parse has completed. | |
| 2093 if( OptoRemoveUseless && transformed_sfpnt->is_SafePoint() ) { | |
| 2094 assert(C->root() != NULL, "Expect parse is still valid"); | |
| 2095 C->root()->add_prec(transformed_sfpnt); | |
| 2096 } | |
| 2097 } | |
| 2098 | |
| 2099 #ifndef PRODUCT | |
| 2100 //------------------------show_parse_info-------------------------------------- | |
| 2101 void Parse::show_parse_info() { | |
| 2102 InlineTree* ilt = NULL; | |
| 2103 if (C->ilt() != NULL) { | |
| 2104 JVMState* caller_jvms = is_osr_parse() ? caller()->caller() : caller(); | |
| 2105 ilt = InlineTree::find_subtree_from_root(C->ilt(), caller_jvms, method()); | |
| 2106 } | |
| 2107 if (PrintCompilation && Verbose) { | |
| 2108 if (depth() == 1) { | |
| 2109 if( ilt->count_inlines() ) { | |
| 2110 tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(), | |
| 2111 ilt->count_inline_bcs()); | |
| 2112 tty->cr(); | |
| 2113 } | |
| 2114 } else { | |
| 2115 if (method()->is_synchronized()) tty->print("s"); | |
| 2116 if (method()->has_exception_handlers()) tty->print("!"); | |
| 2117 // Check this is not the final compiled version | |
| 2118 if (C->trap_can_recompile()) { | |
| 2119 tty->print("-"); | |
| 2120 } else { | |
| 2121 tty->print(" "); | |
| 2122 } | |
| 2123 method()->print_short_name(); | |
| 2124 if (is_osr_parse()) { | |
| 2125 tty->print(" @ %d", osr_bci()); | |
| 2126 } | |
| 2127 tty->print(" (%d bytes)",method()->code_size()); | |
| 2128 if (ilt->count_inlines()) { | |
| 2129 tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(), | |
| 2130 ilt->count_inline_bcs()); | |
| 2131 } | |
| 2132 tty->cr(); | |
| 2133 } | |
| 2134 } | |
| 2135 if (PrintOpto && (depth() == 1 || PrintOptoInlining)) { | |
| 2136 // Print that we succeeded; suppress this message on the first osr parse. | |
| 2137 | |
| 2138 if (method()->is_synchronized()) tty->print("s"); | |
| 2139 if (method()->has_exception_handlers()) tty->print("!"); | |
| 2140 // Check this is not the final compiled version | |
| 2141 if (C->trap_can_recompile() && depth() == 1) { | |
| 2142 tty->print("-"); | |
| 2143 } else { | |
| 2144 tty->print(" "); | |
| 2145 } | |
| 2146 if( depth() != 1 ) { tty->print(" "); } // missing compile count | |
| 2147 for (int i = 1; i < depth(); ++i) { tty->print(" "); } | |
| 2148 method()->print_short_name(); | |
| 2149 if (is_osr_parse()) { | |
| 2150 tty->print(" @ %d", osr_bci()); | |
| 2151 } | |
| 2152 if (ilt->caller_bci() != -1) { | |
| 2153 tty->print(" @ %d", ilt->caller_bci()); | |
| 2154 } | |
| 2155 tty->print(" (%d bytes)",method()->code_size()); | |
| 2156 if (ilt->count_inlines()) { | |
| 2157 tty->print(" __inlined %d (%d bytes)", ilt->count_inlines(), | |
| 2158 ilt->count_inline_bcs()); | |
| 2159 } | |
| 2160 tty->cr(); | |
| 2161 } | |
| 2162 } | |
| 2163 | |
| 2164 | |
| 2165 //------------------------------dump------------------------------------------- | |
| 2166 // Dump information associated with the bytecodes of current _method | |
| 2167 void Parse::dump() { | |
| 2168 if( method() != NULL ) { | |
| 2169 // Iterate over bytecodes | |
| 2170 ciBytecodeStream iter(method()); | |
| 2171 for( Bytecodes::Code bc = iter.next(); bc != ciBytecodeStream::EOBC() ; bc = iter.next() ) { | |
| 2172 dump_bci( iter.cur_bci() ); | |
| 2173 tty->cr(); | |
| 2174 } | |
| 2175 } | |
| 2176 } | |
| 2177 | |
| 2178 // Dump information associated with a byte code index, 'bci' | |
| 2179 void Parse::dump_bci(int bci) { | |
| 2180 // Output info on merge-points, cloning, and within _jsr..._ret | |
| 2181 // NYI | |
| 2182 tty->print(" bci:%d", bci); | |
| 2183 } | |
| 2184 | |
| 2185 #endif |