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
2953 default:
2954 break;
2955 }
2956 }
2957 return have_one ? "other" : nullptr;
2958 }
2959
2960 // Return the last scope in (begin..end]
2961 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2962 PcDesc* p = pc_desc_near(begin+1);
2963 if (p != nullptr && p->real_pc(this) <= end) {
2964 return new ScopeDesc(this, p);
2965 }
2966 return nullptr;
2967 }
2968
2969 const char* nmethod::nmethod_section_label(address pos) const {
2970 const char* label = nullptr;
2971 if (pos == code_begin()) label = "[Instructions begin]";
2972 if (pos == entry_point()) label = "[Entry Point]";
2973 if (pos == verified_entry_point()) label = "[Verified Entry Point]";
2974 if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
2975 if (pos == consts_begin() && pos != insts_begin()) label = "[Constants]";
2976 // Check stub_code before checking exception_handler or deopt_handler.
2977 if (pos == this->stub_begin()) label = "[Stub Code]";
2978 if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin()) label = "[Exception Handler]";
2979 if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
2980 return label;
2981 }
2982
2983 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
2984 if (print_section_labels) {
2985 const char* label = nmethod_section_label(block_begin);
2986 if (label != nullptr) {
2987 stream->bol();
2988 stream->print_cr("%s", label);
2989 }
2990 }
2991
2992 if (block_begin == entry_point()) {
2993 Method* m = method();
2994 if (m != nullptr) {
2995 stream->print(" # ");
2996 m->print_value_on(stream);
2997 stream->cr();
2998 }
2999 if (m != nullptr && !is_osr_method()) {
3000 ResourceMark rm;
3001 int sizeargs = m->size_of_parameters();
3002 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
3003 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
3004 {
3005 int sig_index = 0;
3006 if (!m->is_static())
3007 sig_bt[sig_index++] = T_OBJECT; // 'this'
3008 for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) {
3009 BasicType t = ss.type();
3010 sig_bt[sig_index++] = t;
3011 if (type2size[t] == 2) {
3012 sig_bt[sig_index++] = T_VOID;
3013 } else {
3014 assert(type2size[t] == 1, "size is 1 or 2");
3015 }
3016 }
3017 assert(sig_index == sizeargs, "");
3018 }
3019 const char* spname = "sp"; // make arch-specific?
3020 intptr_t out_preserve = SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs);
3021 int stack_slot_offset = this->frame_size() * wordSize;
3022 int tab1 = 14, tab2 = 24;
3023 int sig_index = 0;
3024 int arg_index = (m->is_static() ? 0 : -1);
3025 bool did_old_sp = false;
3026 for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) {
3027 bool at_this = (arg_index == -1);
3028 bool at_old_sp = false;
3029 BasicType t = (at_this ? T_OBJECT : ss.type());
3030 assert(t == sig_bt[sig_index], "sigs in sync");
3031 if (at_this)
3032 stream->print(" # this: ");
3033 else
3034 stream->print(" # parm%d: ", arg_index);
3035 stream->move_to(tab1);
3036 VMReg fst = regs[sig_index].first();
3037 VMReg snd = regs[sig_index].second();
3038 if (fst->is_reg()) {
3039 stream->print("%s", fst->name());
3040 if (snd->is_valid()) {
3041 stream->print(":%s", snd->name());
3042 }
3043 } else if (fst->is_stack()) {
3044 int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3045 if (offset == stack_slot_offset) at_old_sp = true;
3046 stream->print("[%s+0x%x]", spname, offset);
3047 } else {
3048 stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3049 }
3050 stream->print(" ");
3051 stream->move_to(tab2);
3052 stream->print("= ");
3053 if (at_this) {
3054 m->method_holder()->print_value_on(stream);
3055 } else {
3056 bool did_name = false;
3057 if (!at_this && ss.is_reference()) {
3058 Symbol* name = ss.as_symbol();
3059 name->print_value_on(stream);
3060 did_name = true;
3061 }
3062 if (!did_name)
3063 stream->print("%s", type2name(t));
3064 }
3065 if (at_old_sp) {
3066 stream->print(" (%s of caller)", spname);
3067 did_old_sp = true;
3068 }
3069 stream->cr();
3070 sig_index += type2size[t];
3071 arg_index += 1;
3072 if (!at_this) ss.next();
3073 }
3074 if (!did_old_sp) {
3075 stream->print(" # ");
3076 stream->move_to(tab1);
3077 stream->print("[%s+0x%x]", spname, stack_slot_offset);
3078 stream->print(" (%s of caller)", spname);
3079 stream->cr();
3080 }
3081 }
3082 }
3083 }
3084
3085 // Returns whether this nmethod has code comments.
3086 bool nmethod::has_code_comment(address begin, address end) {
3087 // scopes?
3088 ScopeDesc* sd = scope_desc_in(begin, end);
3089 if (sd != nullptr) return true;
3090
3091 // relocations?
3092 const char* str = reloc_string_for(begin, end);
3093 if (str != nullptr) return true;
3094
3095 // implicit exceptions?
3096 int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3097 if (cont_offset != 0) return true;
3098
3099 return false;
3100 }
3101
3185 else
3186 st->print("<UNKNOWN>");
3187 break;
3188 }
3189 case Bytecodes::_getfield:
3190 case Bytecodes::_putfield:
3191 case Bytecodes::_getstatic:
3192 case Bytecodes::_putstatic:
3193 {
3194 Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3195 st->print(" ");
3196 if (field.name() != nullptr)
3197 field.name()->print_symbol_on(st);
3198 else
3199 st->print("<UNKNOWN>");
3200 }
3201 default:
3202 break;
3203 }
3204 }
3205 st->print(" {reexecute=%d rethrow=%d return_oop=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop());
3206 }
3207
3208 // Print all scopes
3209 for (;sd != nullptr; sd = sd->sender()) {
3210 st->move_to(column, 6, 0);
3211 st->print("; -");
3212 if (sd->should_reexecute()) {
3213 st->print(" (reexecute)");
3214 }
3215 if (sd->method() == nullptr) {
3216 st->print("method is nullptr");
3217 } else {
3218 sd->method()->print_short_name(st);
3219 }
3220 int lineno = sd->method()->line_number_from_bci(sd->bci());
3221 if (lineno != -1) {
3222 st->print("@%d (line %d)", sd->bci(), lineno);
3223 } else {
3224 st->print("@%d", sd->bci());
3225 }
|
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
2962 default:
2963 break;
2964 }
2965 }
2966 return have_one ? "other" : nullptr;
2967 }
2968
2969 // Return the last scope in (begin..end]
2970 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2971 PcDesc* p = pc_desc_near(begin+1);
2972 if (p != nullptr && p->real_pc(this) <= end) {
2973 return new ScopeDesc(this, p);
2974 }
2975 return nullptr;
2976 }
2977
2978 const char* nmethod::nmethod_section_label(address pos) const {
2979 const char* label = nullptr;
2980 if (pos == code_begin()) label = "[Instructions begin]";
2981 if (pos == entry_point()) label = "[Entry Point]";
2982 if (pos == inline_entry_point()) label = "[Inline Entry Point]";
2983 if (pos == verified_entry_point()) label = "[Verified Entry Point]";
2984 if (pos == verified_inline_entry_point()) label = "[Verified Inline Entry Point]";
2985 if (pos == verified_inline_ro_entry_point()) label = "[Verified Inline Entry Point (RO)]";
2986 if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
2987 if (pos == consts_begin() && pos != insts_begin()) label = "[Constants]";
2988 // Check stub_code before checking exception_handler or deopt_handler.
2989 if (pos == this->stub_begin()) label = "[Stub Code]";
2990 if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin()) label = "[Exception Handler]";
2991 if (JVMCI_ONLY(_deopt_handler_begin != nullptr &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
2992 return label;
2993 }
2994
2995 static int maybe_print_entry_label(outputStream* stream, address pos, address entry, const char* label) {
2996 if (pos == entry) {
2997 stream->bol();
2998 stream->print_cr("%s", label);
2999 return 1;
3000 } else {
3001 return 0;
3002 }
3003 }
3004
3005 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
3006 if (print_section_labels) {
3007 int n = 0;
3008 // Multiple entry points may be at the same position. Print them all.
3009 n += maybe_print_entry_label(stream, block_begin, entry_point(), "[Entry Point]");
3010 n += maybe_print_entry_label(stream, block_begin, inline_entry_point(), "[Inline Entry Point]");
3011 n += maybe_print_entry_label(stream, block_begin, verified_entry_point(), "[Verified Entry Point]");
3012 n += maybe_print_entry_label(stream, block_begin, verified_inline_entry_point(), "[Verified Inline Entry Point]");
3013 n += maybe_print_entry_label(stream, block_begin, verified_inline_ro_entry_point(), "[Verified Inline Entry Point (RO)]");
3014 if (n == 0) {
3015 const char* label = nmethod_section_label(block_begin);
3016 if (label != nullptr) {
3017 stream->bol();
3018 stream->print_cr("%s", label);
3019 }
3020 }
3021 }
3022
3023 Method* m = method();
3024 if (m == nullptr || is_osr_method()) {
3025 return;
3026 }
3027
3028 // Print the name of the method (only once)
3029 address low = MIN4(entry_point(), verified_entry_point(), verified_inline_entry_point(), verified_inline_ro_entry_point());
3030 low = MIN2(low, inline_entry_point());
3031 assert(low != 0, "sanity");
3032 if (block_begin == low) {
3033 stream->print(" # ");
3034 m->print_value_on(stream);
3035 stream->cr();
3036 }
3037
3038 // Print the arguments for the 3 types of verified entry points
3039 CompiledEntrySignature ces(m);
3040 ces.compute_calling_conventions(false);
3041 const GrowableArray<SigEntry>* sig_cc;
3042 const VMRegPair* regs;
3043 if (block_begin == verified_entry_point()) {
3044 sig_cc = ces.sig_cc();
3045 regs = ces.regs_cc();
3046 } else if (block_begin == verified_inline_entry_point()) {
3047 sig_cc = ces.sig();
3048 regs = ces.regs();
3049 } else if (block_begin == verified_inline_ro_entry_point()) {
3050 sig_cc = ces.sig_cc_ro();
3051 regs = ces.regs_cc_ro();
3052 } else {
3053 return;
3054 }
3055
3056 bool has_this = !m->is_static();
3057 if (ces.has_inline_recv() && block_begin == verified_entry_point()) {
3058 // <this> argument is scalarized for verified_entry_point()
3059 has_this = false;
3060 }
3061 const char* spname = "sp"; // make arch-specific?
3062 int stack_slot_offset = this->frame_size() * wordSize;
3063 int tab1 = 14, tab2 = 24;
3064 int sig_index = 0;
3065 int arg_index = has_this ? -1 : 0;
3066 bool did_old_sp = false;
3067 for (ExtendedSignature sig = ExtendedSignature(sig_cc, SigEntryFilter()); !sig.at_end(); ++sig) {
3068 bool at_this = (arg_index == -1);
3069 bool at_old_sp = false;
3070 BasicType t = (*sig)._bt;
3071 if (at_this) {
3072 stream->print(" # this: ");
3073 } else {
3074 stream->print(" # parm%d: ", arg_index);
3075 }
3076 stream->move_to(tab1);
3077 VMReg fst = regs[sig_index].first();
3078 VMReg snd = regs[sig_index].second();
3079 if (fst->is_reg()) {
3080 stream->print("%s", fst->name());
3081 if (snd->is_valid()) {
3082 stream->print(":%s", snd->name());
3083 }
3084 } else if (fst->is_stack()) {
3085 int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3086 if (offset == stack_slot_offset) at_old_sp = true;
3087 stream->print("[%s+0x%x]", spname, offset);
3088 } else {
3089 stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3090 }
3091 stream->print(" ");
3092 stream->move_to(tab2);
3093 stream->print("= ");
3094 if (at_this) {
3095 m->method_holder()->print_value_on(stream);
3096 } else {
3097 bool did_name = false;
3098 if (is_reference_type(t)) {
3099 Symbol* name = (*sig)._symbol;
3100 name->print_value_on(stream);
3101 did_name = true;
3102 }
3103 if (!did_name)
3104 stream->print("%s", type2name(t));
3105 }
3106 if (at_old_sp) {
3107 stream->print(" (%s of caller)", spname);
3108 did_old_sp = true;
3109 }
3110 stream->cr();
3111 sig_index += type2size[t];
3112 arg_index += 1;
3113 }
3114 if (!did_old_sp) {
3115 stream->print(" # ");
3116 stream->move_to(tab1);
3117 stream->print("[%s+0x%x]", spname, stack_slot_offset);
3118 stream->print(" (%s of caller)", spname);
3119 stream->cr();
3120 }
3121 }
3122
3123 // Returns whether this nmethod has code comments.
3124 bool nmethod::has_code_comment(address begin, address end) {
3125 // scopes?
3126 ScopeDesc* sd = scope_desc_in(begin, end);
3127 if (sd != nullptr) return true;
3128
3129 // relocations?
3130 const char* str = reloc_string_for(begin, end);
3131 if (str != nullptr) return true;
3132
3133 // implicit exceptions?
3134 int cont_offset = ImplicitExceptionTable(this).continuation_offset((uint)(begin - code_begin()));
3135 if (cont_offset != 0) return true;
3136
3137 return false;
3138 }
3139
3223 else
3224 st->print("<UNKNOWN>");
3225 break;
3226 }
3227 case Bytecodes::_getfield:
3228 case Bytecodes::_putfield:
3229 case Bytecodes::_getstatic:
3230 case Bytecodes::_putstatic:
3231 {
3232 Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3233 st->print(" ");
3234 if (field.name() != nullptr)
3235 field.name()->print_symbol_on(st);
3236 else
3237 st->print("<UNKNOWN>");
3238 }
3239 default:
3240 break;
3241 }
3242 }
3243 st->print(" {reexecute=%d rethrow=%d return_oop=%d return_scalarized=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop(), sd->return_scalarized());
3244 }
3245
3246 // Print all scopes
3247 for (;sd != nullptr; sd = sd->sender()) {
3248 st->move_to(column, 6, 0);
3249 st->print("; -");
3250 if (sd->should_reexecute()) {
3251 st->print(" (reexecute)");
3252 }
3253 if (sd->method() == nullptr) {
3254 st->print("method is nullptr");
3255 } else {
3256 sd->method()->print_short_name(st);
3257 }
3258 int lineno = sd->method()->line_number_from_bci(sd->bci());
3259 if (lineno != -1) {
3260 st->print("@%d (line %d)", sd->bci(), lineno);
3261 } else {
3262 st->print("@%d", sd->bci());
3263 }
|