< prev index next >

src/hotspot/share/code/nmethod.cpp

Print this page

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






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

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



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

2997         default:
2998           break;
2999     }
3000   }
3001   return have_one ? "other" : nullptr;
3002 }
3003 
3004 // Return the last scope in (begin..end]
3005 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
3006   PcDesc* p = pc_desc_near(begin+1);
3007   if (p != nullptr && p->real_pc(this) <= end) {
3008     return new ScopeDesc(this, p);
3009   }
3010   return nullptr;
3011 }
3012 
3013 const char* nmethod::nmethod_section_label(address pos) const {
3014   const char* label = nullptr;
3015   if (pos == code_begin())                                              label = "[Instructions begin]";
3016   if (pos == entry_point())                                             label = "[Entry Point]";

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


3018   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
3019   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
3020   // Check stub_code before checking exception_handler or deopt_handler.
3021   if (pos == this->stub_begin())                                        label = "[Stub Code]";
3022   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
3023   if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
3024   return label;
3025 }
3026 










3027 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
3028   if (print_section_labels) {
3029     const char* label = nmethod_section_label(block_begin);
3030     if (label != nullptr) {
3031       stream->bol();
3032       stream->print_cr("%s", label);
3033     }
3034   }
3035 
3036   if (block_begin == entry_point()) {
3037     Method* m = method();
3038     if (m != nullptr) {
3039       stream->print("  # ");
3040       m->print_value_on(stream);
3041       stream->cr();
3042     }
3043     if (m != nullptr && !is_osr_method()) {
3044       ResourceMark rm;
3045       int sizeargs = m->size_of_parameters();
3046       BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
3047       VMRegPair* regs   = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
3048       {
3049         int sig_index = 0;
3050         if (!m->is_static())
3051           sig_bt[sig_index++] = T_OBJECT; // 'this'
3052         for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) {
3053           BasicType t = ss.type();
3054           sig_bt[sig_index++] = t;
3055           if (type2size[t] == 2) {
3056             sig_bt[sig_index++] = T_VOID;
3057           } else {
3058             assert(type2size[t] == 1, "size is 1 or 2");
3059           }
3060         }
3061         assert(sig_index == sizeargs, "");
3062       }
3063       const char* spname = "sp"; // make arch-specific?
3064       intptr_t out_preserve = SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs);
3065       int stack_slot_offset = this->frame_size() * wordSize;
3066       int tab1 = 14, tab2 = 24;
3067       int sig_index = 0;
3068       int arg_index = (m->is_static() ? 0 : -1);
3069       bool did_old_sp = false;
3070       for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) {
3071         bool at_this = (arg_index == -1);
3072         bool at_old_sp = false;
3073         BasicType t = (at_this ? T_OBJECT : ss.type());
3074         assert(t == sig_bt[sig_index], "sigs in sync");
3075         if (at_this)
3076           stream->print("  # this: ");
3077         else
3078           stream->print("  # parm%d: ", arg_index);
3079         stream->move_to(tab1);
3080         VMReg fst = regs[sig_index].first();
3081         VMReg snd = regs[sig_index].second();
3082         if (fst->is_reg()) {
3083           stream->print("%s", fst->name());
3084           if (snd->is_valid())  {
3085             stream->print(":%s", snd->name());
3086           }
3087         } else if (fst->is_stack()) {
3088           int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3089           if (offset == stack_slot_offset)  at_old_sp = true;
3090           stream->print("[%s+0x%x]", spname, offset);
3091         } else {
3092           stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3093         }
3094         stream->print(" ");
3095         stream->move_to(tab2);
3096         stream->print("= ");
3097         if (at_this) {
3098           m->method_holder()->print_value_on(stream);
3099         } else {
3100           bool did_name = false;
3101           if (!at_this && ss.is_reference()) {
3102             Symbol* name = ss.as_symbol();
3103             name->print_value_on(stream);
3104             did_name = true;
3105           }
3106           if (!did_name)
3107             stream->print("%s", type2name(t));
3108         }
3109         if (at_old_sp) {
3110           stream->print("  (%s of caller)", spname);
3111           did_old_sp = true;
3112         }
3113         stream->cr();
3114         sig_index += type2size[t];
3115         arg_index += 1;
3116         if (!at_this)  ss.next();









3117       }
3118       if (!did_old_sp) {
3119         stream->print("  # ");
3120         stream->move_to(tab1);
3121         stream->print("[%s+0x%x]", spname, stack_slot_offset);
3122         stream->print("  (%s of caller)", spname);
3123         stream->cr();












3124       }


3125     }














3126   }
3127 }
3128 
3129 // Returns whether this nmethod has code comments.
3130 bool nmethod::has_code_comment(address begin, address end) {
3131   // scopes?
3132   ScopeDesc* sd  = scope_desc_in(begin, end);
3133   if (sd != nullptr) return true;
3134 
3135   // relocations?
3136   const char* str = reloc_string_for(begin, end);
3137   if (str != nullptr) return true;
3138 
3139   // implicit exceptions?
3140   int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3141   if (cont_offset != 0) return true;
3142 
3143   return false;
3144 }
3145 

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

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

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

3006         default:
3007           break;
3008     }
3009   }
3010   return have_one ? "other" : nullptr;
3011 }
3012 
3013 // Return the last scope in (begin..end]
3014 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
3015   PcDesc* p = pc_desc_near(begin+1);
3016   if (p != nullptr && p->real_pc(this) <= end) {
3017     return new ScopeDesc(this, p);
3018   }
3019   return nullptr;
3020 }
3021 
3022 const char* nmethod::nmethod_section_label(address pos) const {
3023   const char* label = nullptr;
3024   if (pos == code_begin())                                              label = "[Instructions begin]";
3025   if (pos == entry_point())                                             label = "[Entry Point]";
3026   if (pos == inline_entry_point())                                      label = "[Inline Entry Point]";
3027   if (pos == verified_entry_point())                                    label = "[Verified Entry Point]";
3028   if (pos == verified_inline_entry_point())                             label = "[Verified Inline Entry Point]";
3029   if (pos == verified_inline_ro_entry_point())                          label = "[Verified Inline Entry Point (RO)]";
3030   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
3031   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
3032   // Check stub_code before checking exception_handler or deopt_handler.
3033   if (pos == this->stub_begin())                                        label = "[Stub Code]";
3034   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
3035   if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
3036   return label;
3037 }
3038 
3039 static int maybe_print_entry_label(outputStream* stream, address pos, address entry, const char* label) {
3040   if (pos == entry) {
3041     stream->bol();
3042     stream->print_cr("%s", label);
3043     return 1;
3044   } else {
3045     return 0;
3046   }
3047 }
3048 
3049 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
3050   if (print_section_labels) {
3051     int n = 0;
3052     // Multiple entry points may be at the same position. Print them all.
3053     n += maybe_print_entry_label(stream, block_begin, entry_point(),                    "[Entry Point]");
3054     n += maybe_print_entry_label(stream, block_begin, inline_entry_point(),             "[Inline Entry Point]");
3055     n += maybe_print_entry_label(stream, block_begin, verified_entry_point(),           "[Verified Entry Point]");
3056     n += maybe_print_entry_label(stream, block_begin, verified_inline_entry_point(),    "[Verified Inline Entry Point]");
3057     n += maybe_print_entry_label(stream, block_begin, verified_inline_ro_entry_point(), "[Verified Inline Entry Point (RO)]");
3058     if (n == 0) {
3059       const char* label = nmethod_section_label(block_begin);
3060       if (label != nullptr) {
3061         stream->bol();
3062         stream->print_cr("%s", label);





















3063       }
3064     }
3065   }
3066 
3067   Method* m = method();
3068   if (m == nullptr || is_osr_method()) {
3069     return;
3070   }
3071 
3072   // Print the name of the method (only once)
3073   address low = MIN4(entry_point(), verified_entry_point(), verified_inline_entry_point(), verified_inline_ro_entry_point());
3074   low = MIN2(low, inline_entry_point());
3075   assert(low != 0, "sanity");
3076   if (block_begin == low) {
3077     stream->print("  # ");
3078     m->print_value_on(stream);
3079     stream->cr();
3080   }
3081 
3082   // Print the arguments for the 3 types of verified entry points
3083   CompiledEntrySignature ces(m);
3084   ces.compute_calling_conventions(false);
3085   const GrowableArray<SigEntry>* sig_cc;
3086   const VMRegPair* regs;
3087   if (block_begin == verified_entry_point()) {
3088     sig_cc = ces.sig_cc();
3089     regs = ces.regs_cc();
3090   } else if (block_begin == verified_inline_entry_point()) {
3091     sig_cc = ces.sig();
3092     regs = ces.regs();
3093   } else if (block_begin == verified_inline_ro_entry_point()) {
3094     sig_cc = ces.sig_cc_ro();
3095     regs = ces.regs_cc_ro();
3096   } else {
3097     return;
3098   }
3099 
3100   bool has_this = !m->is_static();
3101   if (ces.has_inline_recv() && block_begin == verified_entry_point()) {
3102     // <this> argument is scalarized for verified_entry_point()
3103     has_this = false;
3104   }
3105   const char* spname = "sp"; // make arch-specific?
3106   int stack_slot_offset = this->frame_size() * wordSize;
3107   int tab1 = 14, tab2 = 24;
3108   int sig_index = 0;
3109   int arg_index = has_this ? -1 : 0;
3110   bool did_old_sp = false;
3111   for (ExtendedSignature sig = ExtendedSignature(sig_cc, SigEntryFilter()); !sig.at_end(); ++sig) {
3112     bool at_this = (arg_index == -1);
3113     bool at_old_sp = false;
3114     BasicType t = (*sig)._bt;
3115     if (at_this) {
3116       stream->print("  # this: ");
3117     } else {
3118       stream->print("  # parm%d: ", arg_index);
3119     }
3120     stream->move_to(tab1);
3121     VMReg fst = regs[sig_index].first();
3122     VMReg snd = regs[sig_index].second();
3123     if (fst->is_reg()) {
3124       stream->print("%s", fst->name());
3125       if (snd->is_valid())  {
3126         stream->print(":%s", snd->name());
3127       }
3128     } else if (fst->is_stack()) {
3129       int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3130       if (offset == stack_slot_offset)  at_old_sp = true;
3131       stream->print("[%s+0x%x]", spname, offset);
3132     } else {
3133       stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3134     }
3135     stream->print(" ");
3136     stream->move_to(tab2);
3137     stream->print("= ");
3138     if (at_this) {
3139       m->method_holder()->print_value_on(stream);
3140     } else {
3141       bool did_name = false;
3142       if (is_reference_type(t)) {
3143         Symbol* name = (*sig)._symbol;
3144         name->print_value_on(stream);
3145         did_name = true;
3146       }
3147       if (!did_name)
3148         stream->print("%s", type2name(t));
3149     }
3150     if (at_old_sp) {
3151       stream->print("  (%s of caller)", spname);
3152       did_old_sp = true;
3153     }
3154     stream->cr();
3155     sig_index += type2size[t];
3156     arg_index += 1;
3157   }
3158   if (!did_old_sp) {
3159     stream->print("  # ");
3160     stream->move_to(tab1);
3161     stream->print("[%s+0x%x]", spname, stack_slot_offset);
3162     stream->print("  (%s of caller)", spname);
3163     stream->cr();
3164   }
3165 }
3166 
3167 // Returns whether this nmethod has code comments.
3168 bool nmethod::has_code_comment(address begin, address end) {
3169   // scopes?
3170   ScopeDesc* sd  = scope_desc_in(begin, end);
3171   if (sd != nullptr) return true;
3172 
3173   // relocations?
3174   const char* str = reloc_string_for(begin, end);
3175   if (str != nullptr) return true;
3176 
3177   // implicit exceptions?
3178   int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3179   if (cont_offset != 0) return true;
3180 
3181   return false;
3182 }
3183 

3267             else
3268               st->print("<UNKNOWN>");
3269             break;
3270           }
3271         case Bytecodes::_getfield:
3272         case Bytecodes::_putfield:
3273         case Bytecodes::_getstatic:
3274         case Bytecodes::_putstatic:
3275           {
3276             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3277             st->print(" ");
3278             if (field.name() != nullptr)
3279               field.name()->print_symbol_on(st);
3280             else
3281               st->print("<UNKNOWN>");
3282           }
3283         default:
3284           break;
3285         }
3286       }
3287       st->print(" {reexecute=%d rethrow=%d return_oop=%d return_scalarized=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop(), sd->return_scalarized());
3288     }
3289 
3290     // Print all scopes
3291     for (;sd != nullptr; sd = sd->sender()) {
3292       st->move_to(column, 6, 0);
3293       st->print("; -");
3294       if (sd->should_reexecute()) {
3295         st->print(" (reexecute)");
3296       }
3297       if (sd->method() == nullptr) {
3298         st->print("method is nullptr");
3299       } else {
3300         sd->method()->print_short_name(st);
3301       }
3302       int lineno = sd->method()->line_number_from_bci(sd->bci());
3303       if (lineno != -1) {
3304         st->print("@%d (line %d)", sd->bci(), lineno);
3305       } else {
3306         st->print("@%d", sd->bci());
3307       }
< prev index next >