< prev index next >

src/hotspot/share/opto/parse1.cpp

Print this page

 205   set_parse_bci(osr_block->start());
 206 
 207   // Set initial stack depth.
 208   set_sp(osr_block->start_sp());
 209 
 210   // Check bailouts.  We currently do not perform on stack replacement
 211   // of loops in catch blocks or loops which branch with a non-empty stack.
 212   if (sp() != 0) {
 213     C->record_method_not_compilable("OSR starts with non-empty stack");
 214     return;
 215   }
 216   // Do not OSR inside finally clauses:
 217   if (osr_block->has_trap_at(osr_block->start())) {
 218     C->record_method_not_compilable("OSR starts with an immediate trap");
 219     return;
 220   }
 221 
 222   // Commute monitors from interpreter frame to compiler frame.
 223   assert(jvms()->monitor_depth() == 0, "should be no active locks at beginning of osr");
 224   int mcnt = osr_block->flow()->monitor_count();
 225   Node *monitors_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals+mcnt*2-1)*wordSize);
 226   for (index = 0; index < mcnt; index++) {
 227     // Make a BoxLockNode for the monitor.
 228     Node *box = _gvn.transform(new BoxLockNode(next_monitor()));
 229 
 230 
 231     // Displaced headers and locked objects are interleaved in the
 232     // temp OSR buffer.  We only copy the locked objects out here.
 233     // Fetch the locked object from the OSR temp buffer and copy to our fastlock node.
 234     Node *lock_object = fetch_interpreter_state(index*2, T_OBJECT, monitors_addr, osr_buf);
 235     // Try and copy the displaced header to the BoxNode
 236     Node *displaced_hdr = fetch_interpreter_state((index*2) + 1, T_ADDRESS, monitors_addr, osr_buf);
 237 
 238 
 239     store_to_memory(control(), box, displaced_hdr, T_ADDRESS, Compile::AliasIdxRaw, MemNode::unordered);
 240 
 241     // Build a bogus FastLockNode (no code will be generated) and push the
 242     // monitor into our debug info.
 243     const FastLockNode *flock = _gvn.transform(new FastLockNode( 0, lock_object, box ))->as_FastLock();
 244     map()->push_monitor(flock);
 245 
 246     // If the lock is our method synchronization lock, tuck it away in
 247     // _sync_lock for return and rethrow exit paths.
 248     if (index == 0 && method()->is_synchronized()) {
 249       _synch_lock = flock;
 250     }
 251   }
 252 
 253   // Use the raw liveness computation to make sure that unexpected
 254   // values don't propagate into the OSR frame.
 255   MethodLivenessResult live_locals = method()->liveness_at_bci(osr_bci());
 256   if (!live_locals.is_valid()) {
 257     // Degenerate or breakpointed method.
 258     C->record_method_not_compilable("OSR in empty or breakpointed method");
 259     return;

 205   set_parse_bci(osr_block->start());
 206 
 207   // Set initial stack depth.
 208   set_sp(osr_block->start_sp());
 209 
 210   // Check bailouts.  We currently do not perform on stack replacement
 211   // of loops in catch blocks or loops which branch with a non-empty stack.
 212   if (sp() != 0) {
 213     C->record_method_not_compilable("OSR starts with non-empty stack");
 214     return;
 215   }
 216   // Do not OSR inside finally clauses:
 217   if (osr_block->has_trap_at(osr_block->start())) {
 218     C->record_method_not_compilable("OSR starts with an immediate trap");
 219     return;
 220   }
 221 
 222   // Commute monitors from interpreter frame to compiler frame.
 223   assert(jvms()->monitor_depth() == 0, "should be no active locks at beginning of osr");
 224   int mcnt = osr_block->flow()->monitor_count();
 225   Node *monitors_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals+mcnt-1)*wordSize);
 226   for (index = 0; index < mcnt; index++) {
 227     // Make a BoxLockNode for the monitor.
 228     Node *box = _gvn.transform(new BoxLockNode(next_monitor()));
 229 
 230 
 231     // Displaced headers and locked objects are interleaved in the
 232     // temp OSR buffer.  We only copy the locked objects out here.
 233     // Fetch the locked object from the OSR temp buffer and copy to our fastlock node.
 234     Node *lock_object = fetch_interpreter_state(index, T_OBJECT, monitors_addr, osr_buf);





 235 
 236     // Build a bogus FastLockNode (no code will be generated) and push the
 237     // monitor into our debug info.
 238     const FastLockNode *flock = _gvn.transform(new FastLockNode( 0, lock_object, box ))->as_FastLock();
 239     map()->push_monitor(flock);
 240 
 241     // If the lock is our method synchronization lock, tuck it away in
 242     // _sync_lock for return and rethrow exit paths.
 243     if (index == 0 && method()->is_synchronized()) {
 244       _synch_lock = flock;
 245     }
 246   }
 247 
 248   // Use the raw liveness computation to make sure that unexpected
 249   // values don't propagate into the OSR frame.
 250   MethodLivenessResult live_locals = method()->liveness_at_bci(osr_bci());
 251   if (!live_locals.is_valid()) {
 252     // Degenerate or breakpointed method.
 253     C->record_method_not_compilable("OSR in empty or breakpointed method");
 254     return;
< prev index next >