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(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(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 }
|