666 _consts_offset = content_offset() + code_buffer->total_offset_of(code_buffer->consts());
667 _stub_offset = content_offset() + code_buffer->total_offset_of(code_buffer->stubs());
668 _oops_offset = data_offset();
669 _metadata_offset = _oops_offset + align_up(code_buffer->total_oop_size(), oopSize);
670 scopes_data_offset = _metadata_offset + align_up(code_buffer->total_metadata_size(), wordSize);
671 _scopes_pcs_offset = scopes_data_offset;
672 _dependencies_offset = _scopes_pcs_offset;
673 _handler_table_offset = _dependencies_offset;
674 _nul_chk_table_offset = _handler_table_offset;
675 _skipped_instructions_size = code_buffer->total_skipped_instructions_size();
676 #if INCLUDE_JVMCI
677 _speculations_offset = _nul_chk_table_offset;
678 _jvmci_data_offset = _speculations_offset;
679 _nmethod_end_offset = _jvmci_data_offset;
680 #else
681 _nmethod_end_offset = _nul_chk_table_offset;
682 #endif
683 _compile_id = compile_id;
684 _entry_point = code_begin() + offsets->value(CodeOffsets::Entry);
685 _verified_entry_point = code_begin() + offsets->value(CodeOffsets::Verified_Entry);
686 _osr_entry_point = nullptr;
687 _exception_cache = nullptr;
688 _pc_desc_container.reset_to(nullptr);
689
690 _exception_offset = code_offset() + offsets->value(CodeOffsets::Exceptions);
691
692 _scopes_data_begin = (address) this + scopes_data_offset;
693 _deopt_handler_begin = (address) this + deoptimize_offset;
694 _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
695
696 code_buffer->copy_code_and_locs_to(this);
697 code_buffer->copy_values_to(this);
698
699 clear_unloading_state();
700
701 finalize_relocations();
702
703 Universe::heap()->register_nmethod(this);
704 debug_only(Universe::heap()->verify_nmethod(this));
705
852 }
853
854 _oops_offset = data_offset();
855 _metadata_offset = _oops_offset + align_up(code_buffer->total_oop_size(), oopSize);
856 int scopes_data_offset = _metadata_offset + align_up(code_buffer->total_metadata_size(), wordSize);
857
858 _scopes_pcs_offset = scopes_data_offset + align_up(debug_info->data_size (), oopSize);
859 _dependencies_offset = _scopes_pcs_offset + adjust_pcs_size(debug_info->pcs_size());
860 _handler_table_offset = _dependencies_offset + align_up((int)dependencies->size_in_bytes(), oopSize);
861 _nul_chk_table_offset = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
862 #if INCLUDE_JVMCI
863 _speculations_offset = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
864 _jvmci_data_offset = _speculations_offset + align_up(speculations_len, oopSize);
865 int jvmci_data_size = compiler->is_jvmci() ? jvmci_data->size() : 0;
866 _nmethod_end_offset = _jvmci_data_offset + align_up(jvmci_data_size, oopSize);
867 #else
868 _nmethod_end_offset = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
869 #endif
870 _entry_point = code_begin() + offsets->value(CodeOffsets::Entry);
871 _verified_entry_point = code_begin() + offsets->value(CodeOffsets::Verified_Entry);
872 _osr_entry_point = code_begin() + offsets->value(CodeOffsets::OSR_Entry);
873 _exception_cache = nullptr;
874 _scopes_data_begin = (address) this + scopes_data_offset;
875
876 _pc_desc_container.reset_to(scopes_pcs_begin());
877
878 code_buffer->copy_code_and_locs_to(this);
879 // Copy contents of ScopeDescRecorder to nmethod
880 code_buffer->copy_values_to(this);
881 debug_info->copy_to(this);
882 dependencies->copy_to(this);
883 clear_unloading_state();
884
885 #if INCLUDE_JVMCI
886 if (compiler->is_jvmci()) {
887 // Initialize the JVMCINMethodData object inlined into nm
888 jvmci_nmethod_data()->copy(jvmci_data);
889 }
890 #endif
891
2967 default:
2968 break;
2969 }
2970 }
2971 return have_one ? "other" : nullptr;
2972 }
2973
2974 // Return the last scope in (begin..end]
2975 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2976 PcDesc* p = pc_desc_near(begin+1);
2977 if (p != nullptr && p->real_pc(this) <= end) {
2978 return new ScopeDesc(this, p);
2979 }
2980 return nullptr;
2981 }
2982
2983 const char* nmethod::nmethod_section_label(address pos) const {
2984 const char* label = nullptr;
2985 if (pos == code_begin()) label = "[Instructions begin]";
2986 if (pos == entry_point()) label = "[Entry Point]";
2987 if (pos == verified_entry_point()) label = "[Verified Entry Point]";
2988 if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
2989 if (pos == consts_begin() && pos != insts_begin()) label = "[Constants]";
2990 // Check stub_code before checking exception_handler or deopt_handler.
2991 if (pos == this->stub_begin()) label = "[Stub Code]";
2992 if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin()) label = "[Exception Handler]";
2993 if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
2994 return label;
2995 }
2996
2997 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
2998 if (print_section_labels) {
2999 const char* label = nmethod_section_label(block_begin);
3000 if (label != nullptr) {
3001 stream->bol();
3002 stream->print_cr("%s", label);
3003 }
3004 }
3005
3006 if (block_begin == entry_point()) {
3007 Method* m = method();
3008 if (m != nullptr) {
3009 stream->print(" # ");
3010 m->print_value_on(stream);
3011 stream->cr();
3012 }
3013 if (m != nullptr && !is_osr_method()) {
3014 ResourceMark rm;
3015 int sizeargs = m->size_of_parameters();
3016 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
3017 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
3018 {
3019 int sig_index = 0;
3020 if (!m->is_static())
3021 sig_bt[sig_index++] = T_OBJECT; // 'this'
3022 for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) {
3023 BasicType t = ss.type();
3024 sig_bt[sig_index++] = t;
3025 if (type2size[t] == 2) {
3026 sig_bt[sig_index++] = T_VOID;
3027 } else {
3028 assert(type2size[t] == 1, "size is 1 or 2");
3029 }
3030 }
3031 assert(sig_index == sizeargs, "");
3032 }
3033 const char* spname = "sp"; // make arch-specific?
3034 SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs);
3035 int stack_slot_offset = this->frame_size() * wordSize;
3036 int tab1 = 14, tab2 = 24;
3037 int sig_index = 0;
3038 int arg_index = (m->is_static() ? 0 : -1);
3039 bool did_old_sp = false;
3040 for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) {
3041 bool at_this = (arg_index == -1);
3042 bool at_old_sp = false;
3043 BasicType t = (at_this ? T_OBJECT : ss.type());
3044 assert(t == sig_bt[sig_index], "sigs in sync");
3045 if (at_this)
3046 stream->print(" # this: ");
3047 else
3048 stream->print(" # parm%d: ", arg_index);
3049 stream->move_to(tab1);
3050 VMReg fst = regs[sig_index].first();
3051 VMReg snd = regs[sig_index].second();
3052 if (fst->is_reg()) {
3053 stream->print("%s", fst->name());
3054 if (snd->is_valid()) {
3055 stream->print(":%s", snd->name());
3056 }
3057 } else if (fst->is_stack()) {
3058 int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3059 if (offset == stack_slot_offset) at_old_sp = true;
3060 stream->print("[%s+0x%x]", spname, offset);
3061 } else {
3062 stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3063 }
3064 stream->print(" ");
3065 stream->move_to(tab2);
3066 stream->print("= ");
3067 if (at_this) {
3068 m->method_holder()->print_value_on(stream);
3069 } else {
3070 bool did_name = false;
3071 if (!at_this && ss.is_reference()) {
3072 Symbol* name = ss.as_symbol();
3073 name->print_value_on(stream);
3074 did_name = true;
3075 }
3076 if (!did_name)
3077 stream->print("%s", type2name(t));
3078 }
3079 if (at_old_sp) {
3080 stream->print(" (%s of caller)", spname);
3081 did_old_sp = true;
3082 }
3083 stream->cr();
3084 sig_index += type2size[t];
3085 arg_index += 1;
3086 if (!at_this) ss.next();
3087 }
3088 if (!did_old_sp) {
3089 stream->print(" # ");
3090 stream->move_to(tab1);
3091 stream->print("[%s+0x%x]", spname, stack_slot_offset);
3092 stream->print(" (%s of caller)", spname);
3093 stream->cr();
3094 }
3095 }
3096 }
3097 }
3098
3099 // Returns whether this nmethod has code comments.
3100 bool nmethod::has_code_comment(address begin, address end) {
3101 // scopes?
3102 ScopeDesc* sd = scope_desc_in(begin, end);
3103 if (sd != nullptr) return true;
3104
3105 // relocations?
3106 const char* str = reloc_string_for(begin, end);
3107 if (str != nullptr) return true;
3108
3109 // implicit exceptions?
3110 int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3111 if (cont_offset != 0) return true;
3112
3113 return false;
3114 }
3115
3199 else
3200 st->print("<UNKNOWN>");
3201 break;
3202 }
3203 case Bytecodes::_getfield:
3204 case Bytecodes::_putfield:
3205 case Bytecodes::_getstatic:
3206 case Bytecodes::_putstatic:
3207 {
3208 Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3209 st->print(" ");
3210 if (field.name() != nullptr)
3211 field.name()->print_symbol_on(st);
3212 else
3213 st->print("<UNKNOWN>");
3214 }
3215 default:
3216 break;
3217 }
3218 }
3219 st->print(" {reexecute=%d rethrow=%d return_oop=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop());
3220 }
3221
3222 // Print all scopes
3223 for (;sd != nullptr; sd = sd->sender()) {
3224 st->move_to(column, 6, 0);
3225 st->print("; -");
3226 if (sd->should_reexecute()) {
3227 st->print(" (reexecute)");
3228 }
3229 if (sd->method() == nullptr) {
3230 st->print("method is nullptr");
3231 } else {
3232 sd->method()->print_short_name(st);
3233 }
3234 int lineno = sd->method()->line_number_from_bci(sd->bci());
3235 if (lineno != -1) {
3236 st->print("@%d (line %d)", sd->bci(), lineno);
3237 } else {
3238 st->print("@%d", sd->bci());
3239 }
|
666 _consts_offset = content_offset() + code_buffer->total_offset_of(code_buffer->consts());
667 _stub_offset = content_offset() + code_buffer->total_offset_of(code_buffer->stubs());
668 _oops_offset = data_offset();
669 _metadata_offset = _oops_offset + align_up(code_buffer->total_oop_size(), oopSize);
670 scopes_data_offset = _metadata_offset + align_up(code_buffer->total_metadata_size(), wordSize);
671 _scopes_pcs_offset = scopes_data_offset;
672 _dependencies_offset = _scopes_pcs_offset;
673 _handler_table_offset = _dependencies_offset;
674 _nul_chk_table_offset = _handler_table_offset;
675 _skipped_instructions_size = code_buffer->total_skipped_instructions_size();
676 #if INCLUDE_JVMCI
677 _speculations_offset = _nul_chk_table_offset;
678 _jvmci_data_offset = _speculations_offset;
679 _nmethod_end_offset = _jvmci_data_offset;
680 #else
681 _nmethod_end_offset = _nul_chk_table_offset;
682 #endif
683 _compile_id = compile_id;
684 _entry_point = code_begin() + offsets->value(CodeOffsets::Entry);
685 _verified_entry_point = code_begin() + offsets->value(CodeOffsets::Verified_Entry);
686
687 assert(!method->has_scalarized_args(), "scalarized native wrappers not supported yet"); // for the next 3 fields
688 _inline_entry_point = _entry_point;
689 _verified_inline_entry_point = _verified_entry_point;
690 _verified_inline_ro_entry_point = _verified_entry_point;
691
692 _osr_entry_point = nullptr;
693 _exception_cache = nullptr;
694 _pc_desc_container.reset_to(nullptr);
695
696 _exception_offset = code_offset() + offsets->value(CodeOffsets::Exceptions);
697
698 _scopes_data_begin = (address) this + scopes_data_offset;
699 _deopt_handler_begin = (address) this + deoptimize_offset;
700 _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
701
702 code_buffer->copy_code_and_locs_to(this);
703 code_buffer->copy_values_to(this);
704
705 clear_unloading_state();
706
707 finalize_relocations();
708
709 Universe::heap()->register_nmethod(this);
710 debug_only(Universe::heap()->verify_nmethod(this));
711
858 }
859
860 _oops_offset = data_offset();
861 _metadata_offset = _oops_offset + align_up(code_buffer->total_oop_size(), oopSize);
862 int scopes_data_offset = _metadata_offset + align_up(code_buffer->total_metadata_size(), wordSize);
863
864 _scopes_pcs_offset = scopes_data_offset + align_up(debug_info->data_size (), oopSize);
865 _dependencies_offset = _scopes_pcs_offset + adjust_pcs_size(debug_info->pcs_size());
866 _handler_table_offset = _dependencies_offset + align_up((int)dependencies->size_in_bytes(), oopSize);
867 _nul_chk_table_offset = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
868 #if INCLUDE_JVMCI
869 _speculations_offset = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
870 _jvmci_data_offset = _speculations_offset + align_up(speculations_len, oopSize);
871 int jvmci_data_size = compiler->is_jvmci() ? jvmci_data->size() : 0;
872 _nmethod_end_offset = _jvmci_data_offset + align_up(jvmci_data_size, oopSize);
873 #else
874 _nmethod_end_offset = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
875 #endif
876 _entry_point = code_begin() + offsets->value(CodeOffsets::Entry);
877 _verified_entry_point = code_begin() + offsets->value(CodeOffsets::Verified_Entry);
878 _inline_entry_point = code_begin() + offsets->value(CodeOffsets::Inline_Entry);
879 _verified_inline_entry_point = code_begin() + offsets->value(CodeOffsets::Verified_Inline_Entry);
880 _verified_inline_ro_entry_point = code_begin() + offsets->value(CodeOffsets::Verified_Inline_Entry_RO);
881 _osr_entry_point = code_begin() + offsets->value(CodeOffsets::OSR_Entry);
882 _exception_cache = nullptr;
883 _scopes_data_begin = (address) this + scopes_data_offset;
884
885 _pc_desc_container.reset_to(scopes_pcs_begin());
886
887 code_buffer->copy_code_and_locs_to(this);
888 // Copy contents of ScopeDescRecorder to nmethod
889 code_buffer->copy_values_to(this);
890 debug_info->copy_to(this);
891 dependencies->copy_to(this);
892 clear_unloading_state();
893
894 #if INCLUDE_JVMCI
895 if (compiler->is_jvmci()) {
896 // Initialize the JVMCINMethodData object inlined into nm
897 jvmci_nmethod_data()->copy(jvmci_data);
898 }
899 #endif
900
2976 default:
2977 break;
2978 }
2979 }
2980 return have_one ? "other" : nullptr;
2981 }
2982
2983 // Return the last scope in (begin..end]
2984 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2985 PcDesc* p = pc_desc_near(begin+1);
2986 if (p != nullptr && p->real_pc(this) <= end) {
2987 return new ScopeDesc(this, p);
2988 }
2989 return nullptr;
2990 }
2991
2992 const char* nmethod::nmethod_section_label(address pos) const {
2993 const char* label = nullptr;
2994 if (pos == code_begin()) label = "[Instructions begin]";
2995 if (pos == entry_point()) label = "[Entry Point]";
2996 if (pos == inline_entry_point()) label = "[Inline Entry Point]";
2997 if (pos == verified_entry_point()) label = "[Verified Entry Point]";
2998 if (pos == verified_inline_entry_point()) label = "[Verified Inline Entry Point]";
2999 if (pos == verified_inline_ro_entry_point()) label = "[Verified Inline Entry Point (RO)]";
3000 if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
3001 if (pos == consts_begin() && pos != insts_begin()) label = "[Constants]";
3002 // Check stub_code before checking exception_handler or deopt_handler.
3003 if (pos == this->stub_begin()) label = "[Stub Code]";
3004 if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin()) label = "[Exception Handler]";
3005 if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
3006 return label;
3007 }
3008
3009 static int maybe_print_entry_label(outputStream* stream, address pos, address entry, const char* label) {
3010 if (pos == entry) {
3011 stream->bol();
3012 stream->print_cr("%s", label);
3013 return 1;
3014 } else {
3015 return 0;
3016 }
3017 }
3018
3019 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
3020 if (print_section_labels) {
3021 int n = 0;
3022 // Multiple entry points may be at the same position. Print them all.
3023 n += maybe_print_entry_label(stream, block_begin, entry_point(), "[Entry Point]");
3024 n += maybe_print_entry_label(stream, block_begin, inline_entry_point(), "[Inline Entry Point]");
3025 n += maybe_print_entry_label(stream, block_begin, verified_entry_point(), "[Verified Entry Point]");
3026 n += maybe_print_entry_label(stream, block_begin, verified_inline_entry_point(), "[Verified Inline Entry Point]");
3027 n += maybe_print_entry_label(stream, block_begin, verified_inline_ro_entry_point(), "[Verified Inline Entry Point (RO)]");
3028 if (n == 0) {
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
3037 Method* m = method();
3038 if (m == nullptr || is_osr_method()) {
3039 return;
3040 }
3041
3042 // Print the name of the method (only once)
3043 address low = MIN4(entry_point(), verified_entry_point(), verified_inline_entry_point(), verified_inline_ro_entry_point());
3044 low = MIN2(low, inline_entry_point());
3045 assert(low != 0, "sanity");
3046 if (block_begin == low) {
3047 stream->print(" # ");
3048 m->print_value_on(stream);
3049 stream->cr();
3050 }
3051
3052 // Print the arguments for the 3 types of verified entry points
3053 CompiledEntrySignature ces(m);
3054 ces.compute_calling_conventions(false);
3055 const GrowableArray<SigEntry>* sig_cc;
3056 const VMRegPair* regs;
3057 if (block_begin == verified_entry_point()) {
3058 sig_cc = ces.sig_cc();
3059 regs = ces.regs_cc();
3060 } else if (block_begin == verified_inline_entry_point()) {
3061 sig_cc = ces.sig();
3062 regs = ces.regs();
3063 } else if (block_begin == verified_inline_ro_entry_point()) {
3064 sig_cc = ces.sig_cc_ro();
3065 regs = ces.regs_cc_ro();
3066 } else {
3067 return;
3068 }
3069
3070 bool has_this = !m->is_static();
3071 if (ces.has_inline_recv() && block_begin == verified_entry_point()) {
3072 // <this> argument is scalarized for verified_entry_point()
3073 has_this = false;
3074 }
3075 const char* spname = "sp"; // make arch-specific?
3076 int stack_slot_offset = this->frame_size() * wordSize;
3077 int tab1 = 14, tab2 = 24;
3078 int sig_index = 0;
3079 int arg_index = has_this ? -1 : 0;
3080 bool did_old_sp = false;
3081 for (ExtendedSignature sig = ExtendedSignature(sig_cc, SigEntryFilter()); !sig.at_end(); ++sig) {
3082 bool at_this = (arg_index == -1);
3083 bool at_old_sp = false;
3084 BasicType t = (*sig)._bt;
3085 if (at_this) {
3086 stream->print(" # this: ");
3087 } else {
3088 stream->print(" # parm%d: ", arg_index);
3089 }
3090 stream->move_to(tab1);
3091 VMReg fst = regs[sig_index].first();
3092 VMReg snd = regs[sig_index].second();
3093 if (fst->is_reg()) {
3094 stream->print("%s", fst->name());
3095 if (snd->is_valid()) {
3096 stream->print(":%s", snd->name());
3097 }
3098 } else if (fst->is_stack()) {
3099 int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3100 if (offset == stack_slot_offset) at_old_sp = true;
3101 stream->print("[%s+0x%x]", spname, offset);
3102 } else {
3103 stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3104 }
3105 stream->print(" ");
3106 stream->move_to(tab2);
3107 stream->print("= ");
3108 if (at_this) {
3109 m->method_holder()->print_value_on(stream);
3110 } else {
3111 bool did_name = false;
3112 if (is_reference_type(t)) {
3113 Symbol* name = (*sig)._symbol;
3114 name->print_value_on(stream);
3115 did_name = true;
3116 }
3117 if (!did_name)
3118 stream->print("%s", type2name(t));
3119 }
3120 if (at_old_sp) {
3121 stream->print(" (%s of caller)", spname);
3122 did_old_sp = true;
3123 }
3124 stream->cr();
3125 sig_index += type2size[t];
3126 arg_index += 1;
3127 }
3128 if (!did_old_sp) {
3129 stream->print(" # ");
3130 stream->move_to(tab1);
3131 stream->print("[%s+0x%x]", spname, stack_slot_offset);
3132 stream->print(" (%s of caller)", spname);
3133 stream->cr();
3134 }
3135 }
3136
3137 // Returns whether this nmethod has code comments.
3138 bool nmethod::has_code_comment(address begin, address end) {
3139 // scopes?
3140 ScopeDesc* sd = scope_desc_in(begin, end);
3141 if (sd != nullptr) return true;
3142
3143 // relocations?
3144 const char* str = reloc_string_for(begin, end);
3145 if (str != nullptr) return true;
3146
3147 // implicit exceptions?
3148 int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3149 if (cont_offset != 0) return true;
3150
3151 return false;
3152 }
3153
3237 else
3238 st->print("<UNKNOWN>");
3239 break;
3240 }
3241 case Bytecodes::_getfield:
3242 case Bytecodes::_putfield:
3243 case Bytecodes::_getstatic:
3244 case Bytecodes::_putstatic:
3245 {
3246 Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3247 st->print(" ");
3248 if (field.name() != nullptr)
3249 field.name()->print_symbol_on(st);
3250 else
3251 st->print("<UNKNOWN>");
3252 }
3253 default:
3254 break;
3255 }
3256 }
3257 st->print(" {reexecute=%d rethrow=%d return_oop=%d return_scalarized=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop(), sd->return_scalarized());
3258 }
3259
3260 // Print all scopes
3261 for (;sd != nullptr; sd = sd->sender()) {
3262 st->move_to(column, 6, 0);
3263 st->print("; -");
3264 if (sd->should_reexecute()) {
3265 st->print(" (reexecute)");
3266 }
3267 if (sd->method() == nullptr) {
3268 st->print("method is nullptr");
3269 } else {
3270 sd->method()->print_short_name(st);
3271 }
3272 int lineno = sd->method()->line_number_from_bci(sd->bci());
3273 if (lineno != -1) {
3274 st->print("@%d (line %d)", sd->bci(), lineno);
3275 } else {
3276 st->print("@%d", sd->bci());
3277 }
|