< prev index next >

src/hotspot/share/code/nmethod.cpp

Print this page

 665     _consts_offset           = content_offset()      + code_buffer->total_offset_of(code_buffer->consts());
 666     _stub_offset             = content_offset()      + code_buffer->total_offset_of(code_buffer->stubs());
 667     _oops_offset             = data_offset();
 668     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 669     scopes_data_offset       = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 670     _scopes_pcs_offset       = scopes_data_offset;
 671     _dependencies_offset     = _scopes_pcs_offset;
 672     _handler_table_offset    = _dependencies_offset;
 673     _nul_chk_table_offset    = _handler_table_offset;
 674     _skipped_instructions_size = code_buffer->total_skipped_instructions_size();
 675 #if INCLUDE_JVMCI
 676     _speculations_offset     = _nul_chk_table_offset;
 677     _jvmci_data_offset       = _speculations_offset;
 678     _nmethod_end_offset      = _jvmci_data_offset;
 679 #else
 680     _nmethod_end_offset      = _nul_chk_table_offset;
 681 #endif
 682     _compile_id              = compile_id;
 683     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 684     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);






 685     _osr_entry_point         = nullptr;
 686     _exception_cache         = nullptr;
 687     _pc_desc_container.reset_to(nullptr);
 688 
 689     _exception_offset        = code_offset()         + offsets->value(CodeOffsets::Exceptions);
 690 
 691     _scopes_data_begin = (address) this + scopes_data_offset;
 692     _deopt_handler_begin = (address) this + deoptimize_offset;
 693     _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
 694 
 695     code_buffer->copy_code_and_locs_to(this);
 696     code_buffer->copy_values_to(this);
 697 
 698     clear_unloading_state();
 699 
 700     Universe::heap()->register_nmethod(this);
 701     debug_only(Universe::heap()->verify_nmethod(this));
 702 
 703     CodeCache::commit(this);
 704 

 850     }
 851 
 852     _oops_offset             = data_offset();
 853     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 854     int scopes_data_offset   = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 855 
 856     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
 857     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
 858     _handler_table_offset    = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
 859     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 860 #if INCLUDE_JVMCI
 861     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 862     _jvmci_data_offset       = _speculations_offset  + align_up(speculations_len, oopSize);
 863     int jvmci_data_size      = compiler->is_jvmci() ? jvmci_data->size() : 0;
 864     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 865 #else
 866     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 867 #endif
 868     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 869     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);



 870     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 871     _exception_cache         = nullptr;
 872     _scopes_data_begin       = (address) this + scopes_data_offset;
 873 
 874     _pc_desc_container.reset_to(scopes_pcs_begin());
 875 
 876     code_buffer->copy_code_and_locs_to(this);
 877     // Copy contents of ScopeDescRecorder to nmethod
 878     code_buffer->copy_values_to(this);
 879     debug_info->copy_to(this);
 880     dependencies->copy_to(this);
 881     clear_unloading_state();
 882 
 883 #if INCLUDE_JVMCI
 884     if (compiler->is_jvmci()) {
 885       // Initialize the JVMCINMethodData object inlined into nm
 886       jvmci_nmethod_data()->copy(jvmci_data);
 887     }
 888 #endif
 889 

2952         default:
2953           break;
2954     }
2955   }
2956   return have_one ? "other" : nullptr;
2957 }
2958 
2959 // Return the last scope in (begin..end]
2960 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2961   PcDesc* p = pc_desc_near(begin+1);
2962   if (p != nullptr && p->real_pc(this) <= end) {
2963     return new ScopeDesc(this, p);
2964   }
2965   return nullptr;
2966 }
2967 
2968 const char* nmethod::nmethod_section_label(address pos) const {
2969   const char* label = nullptr;
2970   if (pos == code_begin())                                              label = "[Instructions begin]";
2971   if (pos == entry_point())                                             label = "[Entry Point]";

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


2973   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
2974   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
2975   // Check stub_code before checking exception_handler or deopt_handler.
2976   if (pos == this->stub_begin())                                        label = "[Stub Code]";
2977   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
2978   if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
2979   return label;
2980 }
2981 










2982 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
2983   if (print_section_labels) {
2984     const char* label = nmethod_section_label(block_begin);
2985     if (label != nullptr) {
2986       stream->bol();
2987       stream->print_cr("%s", label);
2988     }
2989   }
2990 
2991   if (block_begin == entry_point()) {
2992     Method* m = method();
2993     if (m != nullptr) {
2994       stream->print("  # ");
2995       m->print_value_on(stream);
2996       stream->cr();
2997     }
2998     if (m != nullptr && !is_osr_method()) {
2999       ResourceMark rm;
3000       int sizeargs = m->size_of_parameters();
3001       BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
3002       VMRegPair* regs   = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
3003       {
3004         int sig_index = 0;
3005         if (!m->is_static())
3006           sig_bt[sig_index++] = T_OBJECT; // 'this'
3007         for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) {
3008           BasicType t = ss.type();
3009           sig_bt[sig_index++] = t;
3010           if (type2size[t] == 2) {
3011             sig_bt[sig_index++] = T_VOID;
3012           } else {
3013             assert(type2size[t] == 1, "size is 1 or 2");
3014           }
3015         }
3016         assert(sig_index == sizeargs, "");
3017       }
3018       const char* spname = "sp"; // make arch-specific?
3019       SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs);
3020       int stack_slot_offset = this->frame_size() * wordSize;
3021       int tab1 = 14, tab2 = 24;
3022       int sig_index = 0;
3023       int arg_index = (m->is_static() ? 0 : -1);
3024       bool did_old_sp = false;
3025       for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) {
3026         bool at_this = (arg_index == -1);
3027         bool at_old_sp = false;
3028         BasicType t = (at_this ? T_OBJECT : ss.type());
3029         assert(t == sig_bt[sig_index], "sigs in sync");
3030         if (at_this)
3031           stream->print("  # this: ");
3032         else
3033           stream->print("  # parm%d: ", arg_index);
3034         stream->move_to(tab1);
3035         VMReg fst = regs[sig_index].first();
3036         VMReg snd = regs[sig_index].second();
3037         if (fst->is_reg()) {
3038           stream->print("%s", fst->name());
3039           if (snd->is_valid())  {
3040             stream->print(":%s", snd->name());
3041           }
3042         } else if (fst->is_stack()) {
3043           int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3044           if (offset == stack_slot_offset)  at_old_sp = true;
3045           stream->print("[%s+0x%x]", spname, offset);
3046         } else {
3047           stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3048         }
3049         stream->print(" ");
3050         stream->move_to(tab2);
3051         stream->print("= ");
3052         if (at_this) {
3053           m->method_holder()->print_value_on(stream);
3054         } else {
3055           bool did_name = false;
3056           if (!at_this && ss.is_reference()) {
3057             Symbol* name = ss.as_symbol();
3058             name->print_value_on(stream);
3059             did_name = true;
3060           }
3061           if (!did_name)
3062             stream->print("%s", type2name(t));
3063         }
3064         if (at_old_sp) {
3065           stream->print("  (%s of caller)", spname);
3066           did_old_sp = true;
3067         }
3068         stream->cr();
3069         sig_index += type2size[t];
3070         arg_index += 1;
3071         if (!at_this)  ss.next();









3072       }
3073       if (!did_old_sp) {
3074         stream->print("  # ");
3075         stream->move_to(tab1);
3076         stream->print("[%s+0x%x]", spname, stack_slot_offset);
3077         stream->print("  (%s of caller)", spname);
3078         stream->cr();












3079       }


3080     }














3081   }
3082 }
3083 
3084 // Returns whether this nmethod has code comments.
3085 bool nmethod::has_code_comment(address begin, address end) {
3086   // scopes?
3087   ScopeDesc* sd  = scope_desc_in(begin, end);
3088   if (sd != nullptr) return true;
3089 
3090   // relocations?
3091   const char* str = reloc_string_for(begin, end);
3092   if (str != nullptr) return true;
3093 
3094   // implicit exceptions?
3095   int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3096   if (cont_offset != 0) return true;
3097 
3098   return false;
3099 }
3100 

3184             else
3185               st->print("<UNKNOWN>");
3186             break;
3187           }
3188         case Bytecodes::_getfield:
3189         case Bytecodes::_putfield:
3190         case Bytecodes::_getstatic:
3191         case Bytecodes::_putstatic:
3192           {
3193             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3194             st->print(" ");
3195             if (field.name() != nullptr)
3196               field.name()->print_symbol_on(st);
3197             else
3198               st->print("<UNKNOWN>");
3199           }
3200         default:
3201           break;
3202         }
3203       }
3204       st->print(" {reexecute=%d rethrow=%d return_oop=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop());
3205     }
3206 
3207     // Print all scopes
3208     for (;sd != nullptr; sd = sd->sender()) {
3209       st->move_to(column, 6, 0);
3210       st->print("; -");
3211       if (sd->should_reexecute()) {
3212         st->print(" (reexecute)");
3213       }
3214       if (sd->method() == nullptr) {
3215         st->print("method is nullptr");
3216       } else {
3217         sd->method()->print_short_name(st);
3218       }
3219       int lineno = sd->method()->line_number_from_bci(sd->bci());
3220       if (lineno != -1) {
3221         st->print("@%d (line %d)", sd->bci(), lineno);
3222       } else {
3223         st->print("@%d", sd->bci());
3224       }

 665     _consts_offset           = content_offset()      + code_buffer->total_offset_of(code_buffer->consts());
 666     _stub_offset             = content_offset()      + code_buffer->total_offset_of(code_buffer->stubs());
 667     _oops_offset             = data_offset();
 668     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 669     scopes_data_offset       = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 670     _scopes_pcs_offset       = scopes_data_offset;
 671     _dependencies_offset     = _scopes_pcs_offset;
 672     _handler_table_offset    = _dependencies_offset;
 673     _nul_chk_table_offset    = _handler_table_offset;
 674     _skipped_instructions_size = code_buffer->total_skipped_instructions_size();
 675 #if INCLUDE_JVMCI
 676     _speculations_offset     = _nul_chk_table_offset;
 677     _jvmci_data_offset       = _speculations_offset;
 678     _nmethod_end_offset      = _jvmci_data_offset;
 679 #else
 680     _nmethod_end_offset      = _nul_chk_table_offset;
 681 #endif
 682     _compile_id              = compile_id;
 683     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 684     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 685 
 686     assert(!method->has_scalarized_args(), "scalarized native wrappers not supported yet"); // for the next 3 fields
 687     _inline_entry_point       = _entry_point;
 688     _verified_inline_entry_point = _verified_entry_point;
 689     _verified_inline_ro_entry_point = _verified_entry_point;
 690 
 691     _osr_entry_point         = nullptr;
 692     _exception_cache         = nullptr;
 693     _pc_desc_container.reset_to(nullptr);
 694 
 695     _exception_offset        = code_offset()         + offsets->value(CodeOffsets::Exceptions);
 696 
 697     _scopes_data_begin = (address) this + scopes_data_offset;
 698     _deopt_handler_begin = (address) this + deoptimize_offset;
 699     _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
 700 
 701     code_buffer->copy_code_and_locs_to(this);
 702     code_buffer->copy_values_to(this);
 703 
 704     clear_unloading_state();
 705 
 706     Universe::heap()->register_nmethod(this);
 707     debug_only(Universe::heap()->verify_nmethod(this));
 708 
 709     CodeCache::commit(this);
 710 

 856     }
 857 
 858     _oops_offset             = data_offset();
 859     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 860     int scopes_data_offset   = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 861 
 862     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
 863     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
 864     _handler_table_offset    = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
 865     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 866 #if INCLUDE_JVMCI
 867     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 868     _jvmci_data_offset       = _speculations_offset  + align_up(speculations_len, oopSize);
 869     int jvmci_data_size      = compiler->is_jvmci() ? jvmci_data->size() : 0;
 870     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 871 #else
 872     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 873 #endif
 874     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 875     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 876     _inline_entry_point       = code_begin()         + offsets->value(CodeOffsets::Inline_Entry);
 877     _verified_inline_entry_point = code_begin()      + offsets->value(CodeOffsets::Verified_Inline_Entry);
 878     _verified_inline_ro_entry_point = code_begin()   + offsets->value(CodeOffsets::Verified_Inline_Entry_RO);
 879     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 880     _exception_cache         = nullptr;
 881     _scopes_data_begin       = (address) this + scopes_data_offset;
 882 
 883     _pc_desc_container.reset_to(scopes_pcs_begin());
 884 
 885     code_buffer->copy_code_and_locs_to(this);
 886     // Copy contents of ScopeDescRecorder to nmethod
 887     code_buffer->copy_values_to(this);
 888     debug_info->copy_to(this);
 889     dependencies->copy_to(this);
 890     clear_unloading_state();
 891 
 892 #if INCLUDE_JVMCI
 893     if (compiler->is_jvmci()) {
 894       // Initialize the JVMCINMethodData object inlined into nm
 895       jvmci_nmethod_data()->copy(jvmci_data);
 896     }
 897 #endif
 898 

2961         default:
2962           break;
2963     }
2964   }
2965   return have_one ? "other" : nullptr;
2966 }
2967 
2968 // Return the last scope in (begin..end]
2969 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2970   PcDesc* p = pc_desc_near(begin+1);
2971   if (p != nullptr && p->real_pc(this) <= end) {
2972     return new ScopeDesc(this, p);
2973   }
2974   return nullptr;
2975 }
2976 
2977 const char* nmethod::nmethod_section_label(address pos) const {
2978   const char* label = nullptr;
2979   if (pos == code_begin())                                              label = "[Instructions begin]";
2980   if (pos == entry_point())                                             label = "[Entry Point]";
2981   if (pos == inline_entry_point())                                      label = "[Inline Entry Point]";
2982   if (pos == verified_entry_point())                                    label = "[Verified Entry Point]";
2983   if (pos == verified_inline_entry_point())                             label = "[Verified Inline Entry Point]";
2984   if (pos == verified_inline_ro_entry_point())                          label = "[Verified Inline Entry Point (RO)]";
2985   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
2986   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
2987   // Check stub_code before checking exception_handler or deopt_handler.
2988   if (pos == this->stub_begin())                                        label = "[Stub Code]";
2989   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
2990   if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
2991   return label;
2992 }
2993 
2994 static int maybe_print_entry_label(outputStream* stream, address pos, address entry, const char* label) {
2995   if (pos == entry) {
2996     stream->bol();
2997     stream->print_cr("%s", label);
2998     return 1;
2999   } else {
3000     return 0;
3001   }
3002 }
3003 
3004 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
3005   if (print_section_labels) {
3006     int n = 0;
3007     // Multiple entry points may be at the same position. Print them all.
3008     n += maybe_print_entry_label(stream, block_begin, entry_point(),                    "[Entry Point]");
3009     n += maybe_print_entry_label(stream, block_begin, inline_entry_point(),             "[Inline Entry Point]");
3010     n += maybe_print_entry_label(stream, block_begin, verified_entry_point(),           "[Verified Entry Point]");
3011     n += maybe_print_entry_label(stream, block_begin, verified_inline_entry_point(),    "[Verified Inline Entry Point]");
3012     n += maybe_print_entry_label(stream, block_begin, verified_inline_ro_entry_point(), "[Verified Inline Entry Point (RO)]");
3013     if (n == 0) {
3014       const char* label = nmethod_section_label(block_begin);
3015       if (label != nullptr) {
3016         stream->bol();
3017         stream->print_cr("%s", label);





















3018       }
3019     }
3020   }
3021 
3022   Method* m = method();
3023   if (m == nullptr || is_osr_method()) {
3024     return;
3025   }
3026 
3027   // Print the name of the method (only once)
3028   address low = MIN4(entry_point(), verified_entry_point(), verified_inline_entry_point(), verified_inline_ro_entry_point());
3029   low = MIN2(low, inline_entry_point());
3030   assert(low != 0, "sanity");
3031   if (block_begin == low) {
3032     stream->print("  # ");
3033     m->print_value_on(stream);
3034     stream->cr();
3035   }
3036 
3037   // Print the arguments for the 3 types of verified entry points
3038   CompiledEntrySignature ces(m);
3039   ces.compute_calling_conventions(false);
3040   const GrowableArray<SigEntry>* sig_cc;
3041   const VMRegPair* regs;
3042   if (block_begin == verified_entry_point()) {
3043     sig_cc = ces.sig_cc();
3044     regs = ces.regs_cc();
3045   } else if (block_begin == verified_inline_entry_point()) {
3046     sig_cc = ces.sig();
3047     regs = ces.regs();
3048   } else if (block_begin == verified_inline_ro_entry_point()) {
3049     sig_cc = ces.sig_cc_ro();
3050     regs = ces.regs_cc_ro();
3051   } else {
3052     return;
3053   }
3054 
3055   bool has_this = !m->is_static();
3056   if (ces.has_inline_recv() && block_begin == verified_entry_point()) {
3057     // <this> argument is scalarized for verified_entry_point()
3058     has_this = false;
3059   }
3060   const char* spname = "sp"; // make arch-specific?
3061   int stack_slot_offset = this->frame_size() * wordSize;
3062   int tab1 = 14, tab2 = 24;
3063   int sig_index = 0;
3064   int arg_index = has_this ? -1 : 0;
3065   bool did_old_sp = false;
3066   for (ExtendedSignature sig = ExtendedSignature(sig_cc, SigEntryFilter()); !sig.at_end(); ++sig) {
3067     bool at_this = (arg_index == -1);
3068     bool at_old_sp = false;
3069     BasicType t = (*sig)._bt;
3070     if (at_this) {
3071       stream->print("  # this: ");
3072     } else {
3073       stream->print("  # parm%d: ", arg_index);
3074     }
3075     stream->move_to(tab1);
3076     VMReg fst = regs[sig_index].first();
3077     VMReg snd = regs[sig_index].second();
3078     if (fst->is_reg()) {
3079       stream->print("%s", fst->name());
3080       if (snd->is_valid())  {
3081         stream->print(":%s", snd->name());
3082       }
3083     } else if (fst->is_stack()) {
3084       int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3085       if (offset == stack_slot_offset)  at_old_sp = true;
3086       stream->print("[%s+0x%x]", spname, offset);
3087     } else {
3088       stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3089     }
3090     stream->print(" ");
3091     stream->move_to(tab2);
3092     stream->print("= ");
3093     if (at_this) {
3094       m->method_holder()->print_value_on(stream);
3095     } else {
3096       bool did_name = false;
3097       if (is_reference_type(t)) {
3098         Symbol* name = (*sig)._symbol;
3099         name->print_value_on(stream);
3100         did_name = true;
3101       }
3102       if (!did_name)
3103         stream->print("%s", type2name(t));
3104     }
3105     if (at_old_sp) {
3106       stream->print("  (%s of caller)", spname);
3107       did_old_sp = true;
3108     }
3109     stream->cr();
3110     sig_index += type2size[t];
3111     arg_index += 1;
3112   }
3113   if (!did_old_sp) {
3114     stream->print("  # ");
3115     stream->move_to(tab1);
3116     stream->print("[%s+0x%x]", spname, stack_slot_offset);
3117     stream->print("  (%s of caller)", spname);
3118     stream->cr();
3119   }
3120 }
3121 
3122 // Returns whether this nmethod has code comments.
3123 bool nmethod::has_code_comment(address begin, address end) {
3124   // scopes?
3125   ScopeDesc* sd  = scope_desc_in(begin, end);
3126   if (sd != nullptr) return true;
3127 
3128   // relocations?
3129   const char* str = reloc_string_for(begin, end);
3130   if (str != nullptr) return true;
3131 
3132   // implicit exceptions?
3133   int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3134   if (cont_offset != 0) return true;
3135 
3136   return false;
3137 }
3138 

3222             else
3223               st->print("<UNKNOWN>");
3224             break;
3225           }
3226         case Bytecodes::_getfield:
3227         case Bytecodes::_putfield:
3228         case Bytecodes::_getstatic:
3229         case Bytecodes::_putstatic:
3230           {
3231             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3232             st->print(" ");
3233             if (field.name() != nullptr)
3234               field.name()->print_symbol_on(st);
3235             else
3236               st->print("<UNKNOWN>");
3237           }
3238         default:
3239           break;
3240         }
3241       }
3242       st->print(" {reexecute=%d rethrow=%d return_oop=%d return_scalarized=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop(), sd->return_scalarized());
3243     }
3244 
3245     // Print all scopes
3246     for (;sd != nullptr; sd = sd->sender()) {
3247       st->move_to(column, 6, 0);
3248       st->print("; -");
3249       if (sd->should_reexecute()) {
3250         st->print(" (reexecute)");
3251       }
3252       if (sd->method() == nullptr) {
3253         st->print("method is nullptr");
3254       } else {
3255         sd->method()->print_short_name(st);
3256       }
3257       int lineno = sd->method()->line_number_from_bci(sd->bci());
3258       if (lineno != -1) {
3259         st->print("@%d (line %d)", sd->bci(), lineno);
3260       } else {
3261         st->print("@%d", sd->bci());
3262       }
< prev index next >