< prev index next >

src/hotspot/share/code/nmethod.cpp

Print this page

 629 
 630     _consts_offset           = data_offset();
 631     _stub_offset             = content_offset()      + code_buffer->total_offset_of(code_buffer->stubs());
 632     _oops_offset             = data_offset();
 633     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 634     scopes_data_offset       = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 635     _scopes_pcs_offset       = scopes_data_offset;
 636     _dependencies_offset     = _scopes_pcs_offset;
 637     _handler_table_offset    = _dependencies_offset;
 638     _nul_chk_table_offset    = _handler_table_offset;
 639 #if INCLUDE_JVMCI
 640     _speculations_offset     = _nul_chk_table_offset;
 641     _jvmci_data_offset       = _speculations_offset;
 642     _nmethod_end_offset      = _jvmci_data_offset;
 643 #else
 644     _nmethod_end_offset      = _nul_chk_table_offset;
 645 #endif
 646     _compile_id              = compile_id;
 647     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 648     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);






 649     _osr_entry_point         = NULL;
 650     _exception_cache         = NULL;
 651     _pc_desc_container.reset_to(NULL);
 652 
 653     _exception_offset        = code_offset()         + offsets->value(CodeOffsets::Exceptions);
 654 
 655     _scopes_data_begin = (address) this + scopes_data_offset;
 656     _deopt_handler_begin = (address) this + deoptimize_offset;
 657     _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
 658 
 659     code_buffer->copy_code_and_locs_to(this);
 660     code_buffer->copy_values_to(this);
 661 
 662     clear_unloading_state();
 663 
 664     Universe::heap()->register_nmethod(this);
 665     debug_only(Universe::heap()->verify_nmethod(this));
 666 
 667     CodeCache::commit(this);
 668 

 804       _unwind_handler_offset = -1;
 805     }
 806 
 807     _oops_offset             = data_offset();
 808     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 809     int scopes_data_offset   = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 810 
 811     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
 812     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
 813     _handler_table_offset    = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
 814     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 815 #if INCLUDE_JVMCI
 816     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 817     _jvmci_data_offset       = _speculations_offset  + align_up(speculations_len, oopSize);
 818     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 819 #else
 820     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 821 #endif
 822     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 823     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);



 824     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 825     _exception_cache         = NULL;
 826     _scopes_data_begin       = (address) this + scopes_data_offset;
 827 
 828     _pc_desc_container.reset_to(scopes_pcs_begin());
 829 
 830     code_buffer->copy_code_and_locs_to(this);
 831     // Copy contents of ScopeDescRecorder to nmethod
 832     code_buffer->copy_values_to(this);
 833     debug_info->copy_to(this);
 834     dependencies->copy_to(this);
 835     clear_unloading_state();
 836 
 837     Universe::heap()->register_nmethod(this);
 838     debug_only(Universe::heap()->verify_nmethod(this));
 839 
 840     CodeCache::commit(this);
 841 
 842     finalize_relocations();
 843 

2921         default:
2922           break;
2923     }
2924   }
2925   return have_one ? "other" : NULL;
2926 }
2927 
2928 // Return the last scope in (begin..end]
2929 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2930   PcDesc* p = pc_desc_near(begin+1);
2931   if (p != NULL && p->real_pc(this) <= end) {
2932     return new ScopeDesc(this, p);
2933   }
2934   return NULL;
2935 }
2936 
2937 const char* nmethod::nmethod_section_label(address pos) const {
2938   const char* label = NULL;
2939   if (pos == code_begin())                                              label = "[Instructions begin]";
2940   if (pos == entry_point())                                             label = "[Entry Point]";

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


2942   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
2943   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
2944   // Check stub_code before checking exception_handler or deopt_handler.
2945   if (pos == this->stub_begin())                                        label = "[Stub Code]";
2946   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
2947   if (JVMCI_ONLY(_deopt_handler_begin != NULL &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
2948   return label;
2949 }
2950 










2951 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
2952   if (print_section_labels) {
2953     const char* label = nmethod_section_label(block_begin);
2954     if (label != NULL) {
2955       stream->bol();
2956       stream->print_cr("%s", label);
2957     }
2958   }
2959 
2960   if (block_begin == entry_point()) {
2961     Method* m = method();
2962     if (m != NULL) {
2963       stream->print("  # ");
2964       m->print_value_on(stream);
2965       stream->cr();
2966     }
2967     if (m != NULL && !is_osr_method()) {
2968       ResourceMark rm;
2969       int sizeargs = m->size_of_parameters();
2970       BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
2971       VMRegPair* regs   = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
2972       {
2973         int sig_index = 0;
2974         if (!m->is_static())
2975           sig_bt[sig_index++] = T_OBJECT; // 'this'
2976         for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) {
2977           BasicType t = ss.type();
2978           sig_bt[sig_index++] = t;
2979           if (type2size[t] == 2) {
2980             sig_bt[sig_index++] = T_VOID;
2981           } else {
2982             assert(type2size[t] == 1, "size is 1 or 2");
2983           }
2984         }
2985         assert(sig_index == sizeargs, "");
2986       }
2987       const char* spname = "sp"; // make arch-specific?
2988       intptr_t out_preserve = SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs);
2989       int stack_slot_offset = this->frame_size() * wordSize;
2990       int tab1 = 14, tab2 = 24;
2991       int sig_index = 0;
2992       int arg_index = (m->is_static() ? 0 : -1);
2993       bool did_old_sp = false;
2994       for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) {
2995         bool at_this = (arg_index == -1);
2996         bool at_old_sp = false;
2997         BasicType t = (at_this ? T_OBJECT : ss.type());
2998         assert(t == sig_bt[sig_index], "sigs in sync");
2999         if (at_this)
3000           stream->print("  # this: ");
3001         else
3002           stream->print("  # parm%d: ", arg_index);
3003         stream->move_to(tab1);
3004         VMReg fst = regs[sig_index].first();
3005         VMReg snd = regs[sig_index].second();
3006         if (fst->is_reg()) {
3007           stream->print("%s", fst->name());
3008           if (snd->is_valid())  {
3009             stream->print(":%s", snd->name());
3010           }
3011         } else if (fst->is_stack()) {
3012           int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3013           if (offset == stack_slot_offset)  at_old_sp = true;
3014           stream->print("[%s+0x%x]", spname, offset);
3015         } else {
3016           stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3017         }
3018         stream->print(" ");
3019         stream->move_to(tab2);
3020         stream->print("= ");
3021         if (at_this) {
3022           m->method_holder()->print_value_on(stream);
3023         } else {
3024           bool did_name = false;
3025           if (!at_this && ss.is_reference()) {
3026             Symbol* name = ss.as_symbol();
3027             name->print_value_on(stream);
3028             did_name = true;
3029           }
3030           if (!did_name)
3031             stream->print("%s", type2name(t));
3032         }
3033         if (at_old_sp) {
3034           stream->print("  (%s of caller)", spname);
3035           did_old_sp = true;
3036         }
3037         stream->cr();
3038         sig_index += type2size[t];
3039         arg_index += 1;
3040         if (!at_this)  ss.next();









3041       }
3042       if (!did_old_sp) {
3043         stream->print("  # ");
3044         stream->move_to(tab1);
3045         stream->print("[%s+0x%x]", spname, stack_slot_offset);
3046         stream->print("  (%s of caller)", spname);
3047         stream->cr();












3048       }


3049     }














3050   }
3051 }
3052 
3053 // Returns whether this nmethod has code comments.
3054 bool nmethod::has_code_comment(address begin, address end) {
3055   // scopes?
3056   ScopeDesc* sd  = scope_desc_in(begin, end);
3057   if (sd != NULL) return true;
3058 
3059   // relocations?
3060   const char* str = reloc_string_for(begin, end);
3061   if (str != NULL) return true;
3062 
3063   // implicit exceptions?
3064   int cont_offset = ImplicitExceptionTable(this).continuation_offset(begin - code_begin());
3065   if (cont_offset != 0) return true;
3066 
3067   return false;
3068 }
3069 

3153             else
3154               st->print("<UNKNOWN>");
3155             break;
3156           }
3157         case Bytecodes::_getfield:
3158         case Bytecodes::_putfield:
3159         case Bytecodes::_getstatic:
3160         case Bytecodes::_putstatic:
3161           {
3162             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3163             st->print(" ");
3164             if (field.name() != NULL)
3165               field.name()->print_symbol_on(st);
3166             else
3167               st->print("<UNKNOWN>");
3168           }
3169         default:
3170           break;
3171         }
3172       }
3173       st->print(" {reexecute=%d rethrow=%d return_oop=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop());
3174     }
3175 
3176     // Print all scopes
3177     for (;sd != NULL; sd = sd->sender()) {
3178       st->move_to(column, 6, 0);
3179       st->print("; -");
3180       if (sd->should_reexecute()) {
3181         st->print(" (reexecute)");
3182       }
3183       if (sd->method() == NULL) {
3184         st->print("method is NULL");
3185       } else {
3186         sd->method()->print_short_name(st);
3187       }
3188       int lineno = sd->method()->line_number_from_bci(sd->bci());
3189       if (lineno != -1) {
3190         st->print("@%d (line %d)", sd->bci(), lineno);
3191       } else {
3192         st->print("@%d", sd->bci());
3193       }

 629 
 630     _consts_offset           = data_offset();
 631     _stub_offset             = content_offset()      + code_buffer->total_offset_of(code_buffer->stubs());
 632     _oops_offset             = data_offset();
 633     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 634     scopes_data_offset       = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 635     _scopes_pcs_offset       = scopes_data_offset;
 636     _dependencies_offset     = _scopes_pcs_offset;
 637     _handler_table_offset    = _dependencies_offset;
 638     _nul_chk_table_offset    = _handler_table_offset;
 639 #if INCLUDE_JVMCI
 640     _speculations_offset     = _nul_chk_table_offset;
 641     _jvmci_data_offset       = _speculations_offset;
 642     _nmethod_end_offset      = _jvmci_data_offset;
 643 #else
 644     _nmethod_end_offset      = _nul_chk_table_offset;
 645 #endif
 646     _compile_id              = compile_id;
 647     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 648     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 649 
 650     assert(!method->has_scalarized_args(), "scalarized native wrappers not supported yet"); // for the next 3 fields
 651     _inline_entry_point       = _entry_point;
 652     _verified_inline_entry_point = _verified_entry_point;
 653     _verified_inline_ro_entry_point = _verified_entry_point;
 654 
 655     _osr_entry_point         = NULL;
 656     _exception_cache         = NULL;
 657     _pc_desc_container.reset_to(NULL);
 658 
 659     _exception_offset        = code_offset()         + offsets->value(CodeOffsets::Exceptions);
 660 
 661     _scopes_data_begin = (address) this + scopes_data_offset;
 662     _deopt_handler_begin = (address) this + deoptimize_offset;
 663     _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
 664 
 665     code_buffer->copy_code_and_locs_to(this);
 666     code_buffer->copy_values_to(this);
 667 
 668     clear_unloading_state();
 669 
 670     Universe::heap()->register_nmethod(this);
 671     debug_only(Universe::heap()->verify_nmethod(this));
 672 
 673     CodeCache::commit(this);
 674 

 810       _unwind_handler_offset = -1;
 811     }
 812 
 813     _oops_offset             = data_offset();
 814     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 815     int scopes_data_offset   = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 816 
 817     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
 818     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
 819     _handler_table_offset    = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
 820     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 821 #if INCLUDE_JVMCI
 822     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 823     _jvmci_data_offset       = _speculations_offset  + align_up(speculations_len, oopSize);
 824     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 825 #else
 826     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 827 #endif
 828     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 829     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 830     _inline_entry_point       = code_begin()         + offsets->value(CodeOffsets::Inline_Entry);
 831     _verified_inline_entry_point = code_begin()      + offsets->value(CodeOffsets::Verified_Inline_Entry);
 832     _verified_inline_ro_entry_point = code_begin()   + offsets->value(CodeOffsets::Verified_Inline_Entry_RO);
 833     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 834     _exception_cache         = NULL;
 835     _scopes_data_begin       = (address) this + scopes_data_offset;
 836 
 837     _pc_desc_container.reset_to(scopes_pcs_begin());
 838 
 839     code_buffer->copy_code_and_locs_to(this);
 840     // Copy contents of ScopeDescRecorder to nmethod
 841     code_buffer->copy_values_to(this);
 842     debug_info->copy_to(this);
 843     dependencies->copy_to(this);
 844     clear_unloading_state();
 845 
 846     Universe::heap()->register_nmethod(this);
 847     debug_only(Universe::heap()->verify_nmethod(this));
 848 
 849     CodeCache::commit(this);
 850 
 851     finalize_relocations();
 852 

2930         default:
2931           break;
2932     }
2933   }
2934   return have_one ? "other" : NULL;
2935 }
2936 
2937 // Return the last scope in (begin..end]
2938 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2939   PcDesc* p = pc_desc_near(begin+1);
2940   if (p != NULL && p->real_pc(this) <= end) {
2941     return new ScopeDesc(this, p);
2942   }
2943   return NULL;
2944 }
2945 
2946 const char* nmethod::nmethod_section_label(address pos) const {
2947   const char* label = NULL;
2948   if (pos == code_begin())                                              label = "[Instructions begin]";
2949   if (pos == entry_point())                                             label = "[Entry Point]";
2950   if (pos == inline_entry_point())                                      label = "[Inline Entry Point]";
2951   if (pos == verified_entry_point())                                    label = "[Verified Entry Point]";
2952   if (pos == verified_inline_entry_point())                             label = "[Verified Inline Entry Point]";
2953   if (pos == verified_inline_ro_entry_point())                          label = "[Verified Inline Entry Point (RO)]";
2954   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
2955   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
2956   // Check stub_code before checking exception_handler or deopt_handler.
2957   if (pos == this->stub_begin())                                        label = "[Stub Code]";
2958   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
2959   if (JVMCI_ONLY(_deopt_handler_begin != NULL &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
2960   return label;
2961 }
2962 
2963 static int maybe_print_entry_label(outputStream* stream, address pos, address entry, const char* label) {
2964   if (pos == entry) {
2965     stream->bol();
2966     stream->print_cr("%s", label);
2967     return 1;
2968   } else {
2969     return 0;
2970   }
2971 }
2972 
2973 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin, bool print_section_labels) const {
2974   if (print_section_labels) {
2975     int n = 0;
2976     // Multiple entry points may be at the same position. Print them all.
2977     n += maybe_print_entry_label(stream, block_begin, entry_point(),                    "[Entry Point]");
2978     n += maybe_print_entry_label(stream, block_begin, inline_entry_point(),             "[Inline Entry Point]");
2979     n += maybe_print_entry_label(stream, block_begin, verified_entry_point(),           "[Verified Entry Point]");
2980     n += maybe_print_entry_label(stream, block_begin, verified_inline_entry_point(),    "[Verified Inline Entry Point]");
2981     n += maybe_print_entry_label(stream, block_begin, verified_inline_ro_entry_point(), "[Verified Inline Entry Point (RO)]");
2982     if (n == 0) {
2983       const char* label = nmethod_section_label(block_begin);
2984       if (label != NULL) {
2985         stream->bol();
2986         stream->print_cr("%s", label);





















2987       }
2988     }
2989   }
2990 
2991   Method* m = method();
2992   if (m == NULL || is_osr_method()) {
2993     return;
2994   }
2995 
2996   // Print the name of the method (only once)
2997   address low = MIN4(entry_point(), verified_entry_point(), verified_inline_entry_point(), verified_inline_ro_entry_point());
2998   low = MIN2(low, inline_entry_point());
2999   assert(low != 0, "sanity");
3000   if (block_begin == low) {
3001     stream->print("  # ");
3002     m->print_value_on(stream);
3003     stream->cr();
3004   }
3005 
3006   // Print the arguments for the 3 types of verified entry points
3007   CompiledEntrySignature ces(m);
3008   ces.compute_calling_conventions();
3009   const GrowableArray<SigEntry>* sig_cc;
3010   const VMRegPair* regs;
3011   if (block_begin == verified_entry_point()) {
3012     sig_cc = &ces.sig_cc();
3013     regs = ces.regs_cc();
3014   } else if (block_begin == verified_inline_entry_point()) {
3015     sig_cc = &ces.sig();
3016     regs = ces.regs();
3017   } else if (block_begin == verified_inline_ro_entry_point()) {
3018     sig_cc = &ces.sig_cc_ro();
3019     regs = ces.regs_cc_ro();
3020   } else {
3021     return;
3022   }
3023 
3024   bool has_this = !m->is_static();
3025   if (ces.has_inline_recv() && block_begin == verified_entry_point()) {
3026     // <this> argument is scalarized for verified_entry_point()
3027     has_this = false;
3028   }
3029   const char* spname = "sp"; // make arch-specific?
3030   int stack_slot_offset = this->frame_size() * wordSize;
3031   int tab1 = 14, tab2 = 24;
3032   int sig_index = 0;
3033   int arg_index = has_this ? -1 : 0;
3034   bool did_old_sp = false;
3035   for (ExtendedSignature sig = ExtendedSignature(sig_cc, SigEntryFilter()); !sig.at_end(); ++sig) {
3036     bool at_this = (arg_index == -1);
3037     bool at_old_sp = false;
3038     BasicType t = (*sig)._bt;
3039     if (at_this) {
3040       stream->print("  # this: ");
3041     } else {
3042       stream->print("  # parm%d: ", arg_index);
3043     }
3044     stream->move_to(tab1);
3045     VMReg fst = regs[sig_index].first();
3046     VMReg snd = regs[sig_index].second();
3047     if (fst->is_reg()) {
3048       stream->print("%s", fst->name());
3049       if (snd->is_valid())  {
3050         stream->print(":%s", snd->name());
3051       }
3052     } else if (fst->is_stack()) {
3053       int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;
3054       if (offset == stack_slot_offset)  at_old_sp = true;
3055       stream->print("[%s+0x%x]", spname, offset);
3056     } else {
3057       stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);
3058     }
3059     stream->print(" ");
3060     stream->move_to(tab2);
3061     stream->print("= ");
3062     if (at_this) {
3063       m->method_holder()->print_value_on(stream);
3064     } else {
3065       bool did_name = false;
3066       if (is_reference_type(t)) {
3067         Symbol* name = (*sig)._symbol;
3068         name->print_value_on(stream);
3069         did_name = true;
3070       }
3071       if (!did_name)
3072         stream->print("%s", type2name(t));
3073     }
3074     if (at_old_sp) {
3075       stream->print("  (%s of caller)", spname);
3076       did_old_sp = true;
3077     }
3078     stream->cr();
3079     sig_index += type2size[t];
3080     arg_index += 1;
3081   }
3082   if (!did_old_sp) {
3083     stream->print("  # ");
3084     stream->move_to(tab1);
3085     stream->print("[%s+0x%x]", spname, stack_slot_offset);
3086     stream->print("  (%s of caller)", spname);
3087     stream->cr();
3088   }
3089 }
3090 
3091 // Returns whether this nmethod has code comments.
3092 bool nmethod::has_code_comment(address begin, address end) {
3093   // scopes?
3094   ScopeDesc* sd  = scope_desc_in(begin, end);
3095   if (sd != NULL) return true;
3096 
3097   // relocations?
3098   const char* str = reloc_string_for(begin, end);
3099   if (str != NULL) return true;
3100 
3101   // implicit exceptions?
3102   int cont_offset = ImplicitExceptionTable(this).continuation_offset(begin - code_begin());
3103   if (cont_offset != 0) return true;
3104 
3105   return false;
3106 }
3107 

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