< prev index next >

src/hotspot/share/code/nmethod.cpp

Print this page

 627     _stub_offset             = data_offset();
 628     _oops_offset             = data_offset();
 629     _metadata_offset         = _oops_offset         + align_up(code_buffer->total_oop_size(), oopSize);
 630     scopes_data_offset       = _metadata_offset     + align_up(code_buffer->total_metadata_size(), wordSize);
 631     _scopes_pcs_offset       = scopes_data_offset;
 632     _dependencies_offset     = _scopes_pcs_offset;
 633     _native_invokers_offset     = _dependencies_offset;
 634     _handler_table_offset    = _native_invokers_offset;
 635     _nul_chk_table_offset    = _handler_table_offset;
 636 #if INCLUDE_JVMCI
 637     _speculations_offset     = _nul_chk_table_offset;
 638     _jvmci_data_offset       = _speculations_offset;
 639     _nmethod_end_offset      = _jvmci_data_offset;
 640 #else
 641     _nmethod_end_offset      = _nul_chk_table_offset;
 642 #endif
 643     _compile_id              = compile_id;
 644     _comp_level              = CompLevel_none;
 645     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 646     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);






 647     _osr_entry_point         = NULL;
 648     _exception_cache         = NULL;
 649     _pc_desc_container.reset_to(NULL);
 650     _hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
 651 
 652     _scopes_data_begin = (address) this + scopes_data_offset;
 653     _deopt_handler_begin = (address) this + deoptimize_offset;
 654     _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
 655 
 656     code_buffer->copy_code_and_locs_to(this);
 657     code_buffer->copy_values_to(this);
 658 
 659     clear_unloading_state();
 660 
 661     Universe::heap()->register_nmethod(this);
 662     debug_only(Universe::heap()->verify_nmethod(this));
 663 
 664     CodeCache::commit(this);
 665   }
 666 

 800     }
 801 
 802     _oops_offset             = data_offset();
 803     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 804     int scopes_data_offset   = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 805 
 806     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
 807     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
 808     _native_invokers_offset  = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
 809     _handler_table_offset    = _native_invokers_offset + align_up(checked_cast<int>(native_invokers.data_size_in_bytes()), oopSize);
 810     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 811 #if INCLUDE_JVMCI
 812     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 813     _jvmci_data_offset       = _speculations_offset  + align_up(speculations_len, oopSize);
 814     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 815 #else
 816     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 817 #endif
 818     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 819     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);



 820     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 821     _exception_cache         = NULL;
 822     _scopes_data_begin       = (address) this + scopes_data_offset;
 823 
 824     _pc_desc_container.reset_to(scopes_pcs_begin());
 825 
 826     code_buffer->copy_code_and_locs_to(this);
 827     // Copy contents of ScopeDescRecorder to nmethod
 828     code_buffer->copy_values_to(this);
 829     debug_info->copy_to(this);
 830     dependencies->copy_to(this);
 831     if (native_invokers.is_nonempty()) { // can not get address of zero-length array
 832       // Copy native stubs
 833       memcpy(native_invokers_begin(), native_invokers.adr_at(0), native_invokers.data_size_in_bytes());
 834     }
 835     clear_unloading_state();
 836 
 837     Universe::heap()->register_nmethod(this);
 838     debug_only(Universe::heap()->verify_nmethod(this));
 839 

3126         default:
3127           break;
3128     }
3129   }
3130   return have_one ? "other" : NULL;
3131 }
3132 
3133 // Return a the last scope in (begin..end]
3134 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
3135   PcDesc* p = pc_desc_near(begin+1);
3136   if (p != NULL && p->real_pc(this) <= end) {
3137     return new ScopeDesc(this, p);
3138   }
3139   return NULL;
3140 }
3141 
3142 const char* nmethod::nmethod_section_label(address pos) const {
3143   const char* label = NULL;
3144   if (pos == code_begin())                                              label = "[Instructions begin]";
3145   if (pos == entry_point())                                             label = "[Entry Point]";

3146   if (pos == verified_entry_point())                                    label = "[Verified Entry Point]";


3147   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
3148   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
3149   // Check stub_code before checking exception_handler or deopt_handler.
3150   if (pos == this->stub_begin())                                        label = "[Stub Code]";
3151   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
3152   if (JVMCI_ONLY(_deopt_handler_begin != NULL &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
3153   return label;
3154 }
3155 










3156 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
3157   if (print_section_labels) {
3158     const char* label = nmethod_section_label(block_begin);
3159     if (label != NULL) {
3160       stream->bol();
3161       stream->print_cr("%s", label);
3162     }
3163   }
3164 
3165   if (block_begin == entry_point()) {
3166     Method* m = method();
3167     if (m != NULL) {
3168       stream->print("  # ");
3169       m->print_value_on(stream);
3170       stream->cr();
3171     }
3172     if (m != NULL && !is_osr_method()) {
3173       ResourceMark rm;
3174       int sizeargs = m->size_of_parameters();
3175       BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
3176       VMRegPair* regs   = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
3177       {
3178         int sig_index = 0;
3179         if (!m->is_static())
3180           sig_bt[sig_index++] = T_OBJECT; // 'this'
3181         for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) {
3182           BasicType t = ss.type();
3183           sig_bt[sig_index++] = t;
3184           if (type2size[t] == 2) {
3185             sig_bt[sig_index++] = T_VOID;
3186           } else {
3187             assert(type2size[t] == 1, "size is 1 or 2");
3188           }
3189         }
3190         assert(sig_index == sizeargs, "");
3191       }
3192       const char* spname = "sp"; // make arch-specific?
3193       intptr_t out_preserve = SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs);
3194       int stack_slot_offset = this->frame_size() * wordSize;
3195       int tab1 = 14, tab2 = 24;
3196       int sig_index = 0;
3197       int arg_index = (m->is_static() ? 0 : -1);
3198       bool did_old_sp = false;
3199       for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) {
3200         bool at_this = (arg_index == -1);
3201         bool at_old_sp = false;
3202         BasicType t = (at_this ? T_OBJECT : ss.type());
3203         assert(t == sig_bt[sig_index], "sigs in sync");
3204         if (at_this)
3205           stream->print("  # this: ");
3206         else
3207           stream->print("  # parm%d: ", arg_index);
3208         stream->move_to(tab1);
3209         VMReg fst = regs[sig_index].first();
3210         VMReg snd = regs[sig_index].second();
3211         if (fst->is_reg()) {
3212           stream->print("%s", fst->name());
3213           if (snd->is_valid())  {
3214             stream->print(":%s", snd->name());
3215           }
3216         } else if (fst->is_stack()) {
3217           int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3218           if (offset == stack_slot_offset)  at_old_sp = true;
3219           stream->print("[%s+0x%x]", spname, offset);
3220         } else {
3221           stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3222         }
3223         stream->print(" ");
3224         stream->move_to(tab2);
3225         stream->print("= ");
3226         if (at_this) {
3227           m->method_holder()->print_value_on(stream);
3228         } else {
3229           bool did_name = false;
3230           if (!at_this && ss.is_reference()) {
3231             Symbol* name = ss.as_symbol();
3232             name->print_value_on(stream);
3233             did_name = true;
3234           }
3235           if (!did_name)
3236             stream->print("%s", type2name(t));
3237         }
3238         if (at_old_sp) {
3239           stream->print("  (%s of caller)", spname);
3240           did_old_sp = true;
3241         }
3242         stream->cr();
3243         sig_index += type2size[t];
3244         arg_index += 1;
3245         if (!at_this)  ss.next();









3246       }
3247       if (!did_old_sp) {
3248         stream->print("  # ");
3249         stream->move_to(tab1);
3250         stream->print("[%s+0x%x]", spname, stack_slot_offset);
3251         stream->print("  (%s of caller)", spname);
3252         stream->cr();












3253       }


3254     }














3255   }
3256 }
3257 
3258 // Returns whether this nmethod has code comments.
3259 bool nmethod::has_code_comment(address begin, address end) {
3260   // scopes?
3261   ScopeDesc* sd  = scope_desc_in(begin, end);
3262   if (sd != NULL) return true;
3263 
3264   // relocations?
3265   const char* str = reloc_string_for(begin, end);
3266   if (str != NULL) return true;
3267 
3268   // implicit exceptions?
3269   int cont_offset = ImplicitExceptionTable(this).continuation_offset(begin - code_begin());
3270   if (cont_offset != 0) return true;
3271 
3272   return false;
3273 }
3274 

3358             else
3359               st->print("<UNKNOWN>");
3360             break;
3361           }
3362         case Bytecodes::_getfield:
3363         case Bytecodes::_putfield:
3364         case Bytecodes::_getstatic:
3365         case Bytecodes::_putstatic:
3366           {
3367             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3368             st->print(" ");
3369             if (field.name() != NULL)
3370               field.name()->print_symbol_on(st);
3371             else
3372               st->print("<UNKNOWN>");
3373           }
3374         default:
3375           break;
3376         }
3377       }
3378       st->print(" {reexecute=%d rethrow=%d return_oop=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop());
3379     }
3380 
3381     // Print all scopes
3382     for (;sd != NULL; sd = sd->sender()) {
3383       st->move_to(column, 6, 0);
3384       st->print("; -");
3385       if (sd->should_reexecute()) {
3386         st->print(" (reexecute)");
3387       }
3388       if (sd->method() == NULL) {
3389         st->print("method is NULL");
3390       } else {
3391         sd->method()->print_short_name(st);
3392       }
3393       int lineno = sd->method()->line_number_from_bci(sd->bci());
3394       if (lineno != -1) {
3395         st->print("@%d (line %d)", sd->bci(), lineno);
3396       } else {
3397         st->print("@%d", sd->bci());
3398       }

 627     _stub_offset             = data_offset();
 628     _oops_offset             = data_offset();
 629     _metadata_offset         = _oops_offset         + align_up(code_buffer->total_oop_size(), oopSize);
 630     scopes_data_offset       = _metadata_offset     + align_up(code_buffer->total_metadata_size(), wordSize);
 631     _scopes_pcs_offset       = scopes_data_offset;
 632     _dependencies_offset     = _scopes_pcs_offset;
 633     _native_invokers_offset     = _dependencies_offset;
 634     _handler_table_offset    = _native_invokers_offset;
 635     _nul_chk_table_offset    = _handler_table_offset;
 636 #if INCLUDE_JVMCI
 637     _speculations_offset     = _nul_chk_table_offset;
 638     _jvmci_data_offset       = _speculations_offset;
 639     _nmethod_end_offset      = _jvmci_data_offset;
 640 #else
 641     _nmethod_end_offset      = _nul_chk_table_offset;
 642 #endif
 643     _compile_id              = compile_id;
 644     _comp_level              = CompLevel_none;
 645     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 646     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 647 
 648     assert(!method->has_scalarized_args(), "scalarized native wrappers not supported yet"); // for the next 3 fields
 649     _inline_entry_point       = _entry_point;
 650     _verified_inline_entry_point = _verified_entry_point;
 651     _verified_inline_ro_entry_point = _verified_entry_point;
 652 
 653     _osr_entry_point         = NULL;
 654     _exception_cache         = NULL;
 655     _pc_desc_container.reset_to(NULL);
 656     _hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
 657 
 658     _scopes_data_begin = (address) this + scopes_data_offset;
 659     _deopt_handler_begin = (address) this + deoptimize_offset;
 660     _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
 661 
 662     code_buffer->copy_code_and_locs_to(this);
 663     code_buffer->copy_values_to(this);
 664 
 665     clear_unloading_state();
 666 
 667     Universe::heap()->register_nmethod(this);
 668     debug_only(Universe::heap()->verify_nmethod(this));
 669 
 670     CodeCache::commit(this);
 671   }
 672 

 806     }
 807 
 808     _oops_offset             = data_offset();
 809     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 810     int scopes_data_offset   = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 811 
 812     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
 813     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
 814     _native_invokers_offset  = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
 815     _handler_table_offset    = _native_invokers_offset + align_up(checked_cast<int>(native_invokers.data_size_in_bytes()), oopSize);
 816     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 817 #if INCLUDE_JVMCI
 818     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 819     _jvmci_data_offset       = _speculations_offset  + align_up(speculations_len, oopSize);
 820     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 821 #else
 822     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 823 #endif
 824     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 825     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 826     _inline_entry_point       = code_begin()         + offsets->value(CodeOffsets::Inline_Entry);
 827     _verified_inline_entry_point = code_begin()      + offsets->value(CodeOffsets::Verified_Inline_Entry);
 828     _verified_inline_ro_entry_point = code_begin()   + offsets->value(CodeOffsets::Verified_Inline_Entry_RO);
 829     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 830     _exception_cache         = NULL;
 831     _scopes_data_begin       = (address) this + scopes_data_offset;
 832 
 833     _pc_desc_container.reset_to(scopes_pcs_begin());
 834 
 835     code_buffer->copy_code_and_locs_to(this);
 836     // Copy contents of ScopeDescRecorder to nmethod
 837     code_buffer->copy_values_to(this);
 838     debug_info->copy_to(this);
 839     dependencies->copy_to(this);
 840     if (native_invokers.is_nonempty()) { // can not get address of zero-length array
 841       // Copy native stubs
 842       memcpy(native_invokers_begin(), native_invokers.adr_at(0), native_invokers.data_size_in_bytes());
 843     }
 844     clear_unloading_state();
 845 
 846     Universe::heap()->register_nmethod(this);
 847     debug_only(Universe::heap()->verify_nmethod(this));
 848 

3135         default:
3136           break;
3137     }
3138   }
3139   return have_one ? "other" : NULL;
3140 }
3141 
3142 // Return a the last scope in (begin..end]
3143 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
3144   PcDesc* p = pc_desc_near(begin+1);
3145   if (p != NULL && p->real_pc(this) <= end) {
3146     return new ScopeDesc(this, p);
3147   }
3148   return NULL;
3149 }
3150 
3151 const char* nmethod::nmethod_section_label(address pos) const {
3152   const char* label = NULL;
3153   if (pos == code_begin())                                              label = "[Instructions begin]";
3154   if (pos == entry_point())                                             label = "[Entry Point]";
3155   if (pos == inline_entry_point())                                      label = "[Inline Entry Point]";
3156   if (pos == verified_entry_point())                                    label = "[Verified Entry Point]";
3157   if (pos == verified_inline_entry_point())                             label = "[Verified Inline Entry Point]";
3158   if (pos == verified_inline_ro_entry_point())                          label = "[Verified Inline Entry Point (RO)]";
3159   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
3160   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
3161   // Check stub_code before checking exception_handler or deopt_handler.
3162   if (pos == this->stub_begin())                                        label = "[Stub Code]";
3163   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
3164   if (JVMCI_ONLY(_deopt_handler_begin != NULL &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
3165   return label;
3166 }
3167 
3168 static int maybe_print_entry_label(outputStream* stream, address pos, address entry, const char* label) {
3169   if (pos == entry) {
3170     stream->bol();
3171     stream->print_cr("%s", label);
3172     return 1;
3173   } else {
3174     return 0;
3175   }
3176 }
3177 
3178 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
3179   if (print_section_labels) {
3180     int n = 0;
3181     // Multiple entry points may be at the same position. Print them all.
3182     n += maybe_print_entry_label(stream, block_begin, entry_point(),                    "[Entry Point]");
3183     n += maybe_print_entry_label(stream, block_begin, inline_entry_point(),             "[Inline Entry Point]");
3184     n += maybe_print_entry_label(stream, block_begin, verified_entry_point(),           "[Verified Entry Point]");
3185     n += maybe_print_entry_label(stream, block_begin, verified_inline_entry_point(),    "[Verified Inline Entry Point]");
3186     n += maybe_print_entry_label(stream, block_begin, verified_inline_ro_entry_point(), "[Verified Inline Entry Point (RO)]");
3187     if (n == 0) {
3188       const char* label = nmethod_section_label(block_begin);
3189       if (label != NULL) {
3190         stream->bol();
3191         stream->print_cr("%s", label);





















3192       }
3193     }
3194   }
3195 
3196   Method* m = method();
3197   if (m == NULL || is_osr_method()) {
3198     return;
3199   }
3200 
3201   // Print the name of the method (only once)
3202   address low = MIN4(entry_point(), verified_entry_point(), verified_inline_entry_point(), verified_inline_ro_entry_point());
3203   low = MIN2(low, inline_entry_point());
3204   assert(low != 0, "sanity");
3205   if (block_begin == low) {
3206     stream->print("  # ");
3207     m->print_value_on(stream);
3208     stream->cr();
3209   }
3210 
3211   // Print the arguments for the 3 types of verified entry points
3212   CompiledEntrySignature ces(m);
3213   ces.compute_calling_conventions();
3214   const GrowableArray<SigEntry>* sig_cc;
3215   const VMRegPair* regs;
3216   if (block_begin == verified_entry_point()) {
3217     sig_cc = &ces.sig_cc();
3218     regs = ces.regs_cc();
3219   } else if (block_begin == verified_inline_entry_point()) {
3220     sig_cc = &ces.sig();
3221     regs = ces.regs();
3222   } else if (block_begin == verified_inline_ro_entry_point()) {
3223     sig_cc = &ces.sig_cc_ro();
3224     regs = ces.regs_cc_ro();
3225   } else {
3226     return;
3227   }
3228 
3229   bool has_this = !m->is_static();
3230   if (ces.has_inline_recv() && block_begin == verified_entry_point()) {
3231     // <this> argument is scalarized for verified_entry_point()
3232     has_this = false;
3233   }
3234   const char* spname = "sp"; // make arch-specific?
3235   int stack_slot_offset = this->frame_size() * wordSize;
3236   int tab1 = 14, tab2 = 24;
3237   int sig_index = 0;
3238   int arg_index = has_this ? -1 : 0;
3239   bool did_old_sp = false;
3240   for (ExtendedSignature sig = ExtendedSignature(sig_cc, SigEntryFilter()); !sig.at_end(); ++sig) {
3241     bool at_this = (arg_index == -1);
3242     bool at_old_sp = false;
3243     BasicType t = (*sig)._bt;
3244     if (at_this) {
3245       stream->print("  # this: ");
3246     } else {
3247       stream->print("  # parm%d: ", arg_index);
3248     }
3249     stream->move_to(tab1);
3250     VMReg fst = regs[sig_index].first();
3251     VMReg snd = regs[sig_index].second();
3252     if (fst->is_reg()) {
3253       stream->print("%s", fst->name());
3254       if (snd->is_valid())  {
3255         stream->print(":%s", snd->name());
3256       }
3257     } else if (fst->is_stack()) {
3258       int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3259       if (offset == stack_slot_offset)  at_old_sp = true;
3260       stream->print("[%s+0x%x]", spname, offset);
3261     } else {
3262       stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3263     }
3264     stream->print(" ");
3265     stream->move_to(tab2);
3266     stream->print("= ");
3267     if (at_this) {
3268       m->method_holder()->print_value_on(stream);
3269     } else {
3270       bool did_name = false;
3271       if (is_reference_type(t)) {
3272         Symbol* name = (*sig)._symbol;
3273         name->print_value_on(stream);
3274         did_name = true;
3275       }
3276       if (!did_name)
3277         stream->print("%s", type2name(t));
3278     }
3279     if (at_old_sp) {
3280       stream->print("  (%s of caller)", spname);
3281       did_old_sp = true;
3282     }
3283     stream->cr();
3284     sig_index += type2size[t];
3285     arg_index += 1;
3286   }
3287   if (!did_old_sp) {
3288     stream->print("  # ");
3289     stream->move_to(tab1);
3290     stream->print("[%s+0x%x]", spname, stack_slot_offset);
3291     stream->print("  (%s of caller)", spname);
3292     stream->cr();
3293   }
3294 }
3295 
3296 // Returns whether this nmethod has code comments.
3297 bool nmethod::has_code_comment(address begin, address end) {
3298   // scopes?
3299   ScopeDesc* sd  = scope_desc_in(begin, end);
3300   if (sd != NULL) return true;
3301 
3302   // relocations?
3303   const char* str = reloc_string_for(begin, end);
3304   if (str != NULL) return true;
3305 
3306   // implicit exceptions?
3307   int cont_offset = ImplicitExceptionTable(this).continuation_offset(begin - code_begin());
3308   if (cont_offset != 0) return true;
3309 
3310   return false;
3311 }
3312 

3396             else
3397               st->print("<UNKNOWN>");
3398             break;
3399           }
3400         case Bytecodes::_getfield:
3401         case Bytecodes::_putfield:
3402         case Bytecodes::_getstatic:
3403         case Bytecodes::_putstatic:
3404           {
3405             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3406             st->print(" ");
3407             if (field.name() != NULL)
3408               field.name()->print_symbol_on(st);
3409             else
3410               st->print("<UNKNOWN>");
3411           }
3412         default:
3413           break;
3414         }
3415       }
3416       st->print(" {reexecute=%d rethrow=%d return_oop=%d return_scalarized=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop(), sd->return_scalarized());
3417     }
3418 
3419     // Print all scopes
3420     for (;sd != NULL; sd = sd->sender()) {
3421       st->move_to(column, 6, 0);
3422       st->print("; -");
3423       if (sd->should_reexecute()) {
3424         st->print(" (reexecute)");
3425       }
3426       if (sd->method() == NULL) {
3427         st->print("method is NULL");
3428       } else {
3429         sd->method()->print_short_name(st);
3430       }
3431       int lineno = sd->method()->line_number_from_bci(sd->bci());
3432       if (lineno != -1) {
3433         st->print("@%d (line %d)", sd->bci(), lineno);
3434       } else {
3435         st->print("@%d", sd->bci());
3436       }
< prev index next >