< prev index next >

src/hotspot/share/code/nmethod.cpp

Print this page

 670 
 671     _consts_offset           = content_offset()      + code_buffer->total_offset_of(code_buffer->consts());
 672     _stub_offset             = content_offset()      + code_buffer->total_offset_of(code_buffer->stubs());
 673     _oops_offset             = data_offset();
 674     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 675     scopes_data_offset       = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 676     _scopes_pcs_offset       = scopes_data_offset;
 677     _dependencies_offset     = _scopes_pcs_offset;
 678     _handler_table_offset    = _dependencies_offset;
 679     _nul_chk_table_offset    = _handler_table_offset;
 680 #if INCLUDE_JVMCI
 681     _speculations_offset     = _nul_chk_table_offset;
 682     _jvmci_data_offset       = _speculations_offset;
 683     _nmethod_end_offset      = _jvmci_data_offset;
 684 #else
 685     _nmethod_end_offset      = _nul_chk_table_offset;
 686 #endif
 687     _compile_id              = compile_id;
 688     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 689     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);






 690     _osr_entry_point         = NULL;
 691     _exception_cache         = NULL;
 692     _pc_desc_container.reset_to(NULL);
 693 
 694     _exception_offset        = code_offset()         + offsets->value(CodeOffsets::Exceptions);
 695 
 696     _scopes_data_begin = (address) this + scopes_data_offset;
 697     _deopt_handler_begin = (address) this + deoptimize_offset;
 698     _deopt_mh_handler_begin = (address) this + deoptimize_mh_offset;
 699 
 700     code_buffer->copy_code_and_locs_to(this);
 701     code_buffer->copy_values_to(this);
 702 
 703     clear_unloading_state();
 704 
 705     Universe::heap()->register_nmethod(this);
 706     debug_only(Universe::heap()->verify_nmethod(this));
 707 
 708     CodeCache::commit(this);
 709 

 853       _unwind_handler_offset = -1;
 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     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 868 #else
 869     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 870 #endif
 871     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 872     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);



 873     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 874     _exception_cache         = NULL;
 875     _scopes_data_begin       = (address) this + scopes_data_offset;
 876 
 877     _pc_desc_container.reset_to(scopes_pcs_begin());
 878 
 879     code_buffer->copy_code_and_locs_to(this);
 880     // Copy contents of ScopeDescRecorder to nmethod
 881     code_buffer->copy_values_to(this);
 882     debug_info->copy_to(this);
 883     dependencies->copy_to(this);
 884     clear_unloading_state();
 885 
 886     Universe::heap()->register_nmethod(this);
 887     debug_only(Universe::heap()->verify_nmethod(this));
 888 
 889     CodeCache::commit(this);
 890 
 891     finalize_relocations();
 892 

2981         default:
2982           break;
2983     }
2984   }
2985   return have_one ? "other" : NULL;
2986 }
2987 
2988 // Return the last scope in (begin..end]
2989 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
2990   PcDesc* p = pc_desc_near(begin+1);
2991   if (p != NULL && p->real_pc(this) <= end) {
2992     return new ScopeDesc(this, p);
2993   }
2994   return NULL;
2995 }
2996 
2997 const char* nmethod::nmethod_section_label(address pos) const {
2998   const char* label = NULL;
2999   if (pos == code_begin())                                              label = "[Instructions begin]";
3000   if (pos == entry_point())                                             label = "[Entry Point]";

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


3002   if (has_method_handle_invokes() && (pos == deopt_mh_handler_begin())) label = "[Deopt MH Handler Code]";
3003   if (pos == consts_begin() && pos != insts_begin())                    label = "[Constants]";
3004   // Check stub_code before checking exception_handler or deopt_handler.
3005   if (pos == this->stub_begin())                                        label = "[Stub Code]";
3006   if (JVMCI_ONLY(_exception_offset >= 0 &&) pos == exception_begin())           label = "[Exception Handler]";
3007   if (JVMCI_ONLY(_deopt_handler_begin != NULL &&) pos == deopt_handler_begin()) label = "[Deopt Handler Code]";
3008   return label;
3009 }
3010 










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









3101       }
3102       if (!did_old_sp) {
3103         stream->print("  # ");
3104         stream->move_to(tab1);
3105         stream->print("[%s+0x%x]", spname, stack_slot_offset);
3106         stream->print("  (%s of caller)", spname);
3107         stream->cr();












3108       }


3109     }














3110   }
3111 }
3112 
3113 // Returns whether this nmethod has code comments.
3114 bool nmethod::has_code_comment(address begin, address end) {
3115   // scopes?
3116   ScopeDesc* sd  = scope_desc_in(begin, end);
3117   if (sd != NULL) return true;
3118 
3119   // relocations?
3120   const char* str = reloc_string_for(begin, end);
3121   if (str != NULL) return true;
3122 
3123   // implicit exceptions?
3124   int cont_offset = ImplicitExceptionTable(this).continuation_offset(begin - code_begin());
3125   if (cont_offset != 0) return true;
3126 
3127   return false;
3128 }
3129 

3213             else
3214               st->print("<UNKNOWN>");
3215             break;
3216           }
3217         case Bytecodes::_getfield:
3218         case Bytecodes::_putfield:
3219         case Bytecodes::_getstatic:
3220         case Bytecodes::_putstatic:
3221           {
3222             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3223             st->print(" ");
3224             if (field.name() != NULL)
3225               field.name()->print_symbol_on(st);
3226             else
3227               st->print("<UNKNOWN>");
3228           }
3229         default:
3230           break;
3231         }
3232       }
3233       st->print(" {reexecute=%d rethrow=%d return_oop=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop());
3234     }
3235 
3236     // Print all scopes
3237     for (;sd != NULL; sd = sd->sender()) {
3238       st->move_to(column, 6, 0);
3239       st->print("; -");
3240       if (sd->should_reexecute()) {
3241         st->print(" (reexecute)");
3242       }
3243       if (sd->method() == NULL) {
3244         st->print("method is NULL");
3245       } else {
3246         sd->method()->print_short_name(st);
3247       }
3248       int lineno = sd->method()->line_number_from_bci(sd->bci());
3249       if (lineno != -1) {
3250         st->print("@%d (line %d)", sd->bci(), lineno);
3251       } else {
3252         st->print("@%d", sd->bci());
3253       }

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

 859       _unwind_handler_offset = -1;
 860     }
 861 
 862     _oops_offset             = data_offset();
 863     _metadata_offset         = _oops_offset          + align_up(code_buffer->total_oop_size(), oopSize);
 864     int scopes_data_offset   = _metadata_offset      + align_up(code_buffer->total_metadata_size(), wordSize);
 865 
 866     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
 867     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
 868     _handler_table_offset    = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
 869     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 870 #if INCLUDE_JVMCI
 871     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 872     _jvmci_data_offset       = _speculations_offset  + align_up(speculations_len, oopSize);
 873     _nmethod_end_offset      = _jvmci_data_offset    + align_up(jvmci_data_size, oopSize);
 874 #else
 875     _nmethod_end_offset      = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
 876 #endif
 877     _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 878     _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 879     _inline_entry_point       = code_begin()         + offsets->value(CodeOffsets::Inline_Entry);
 880     _verified_inline_entry_point = code_begin()      + offsets->value(CodeOffsets::Verified_Inline_Entry);
 881     _verified_inline_ro_entry_point = code_begin()   + offsets->value(CodeOffsets::Verified_Inline_Entry_RO);
 882     _osr_entry_point         = code_begin()          + offsets->value(CodeOffsets::OSR_Entry);
 883     _exception_cache         = NULL;
 884     _scopes_data_begin       = (address) this + scopes_data_offset;
 885 
 886     _pc_desc_container.reset_to(scopes_pcs_begin());
 887 
 888     code_buffer->copy_code_and_locs_to(this);
 889     // Copy contents of ScopeDescRecorder to nmethod
 890     code_buffer->copy_values_to(this);
 891     debug_info->copy_to(this);
 892     dependencies->copy_to(this);
 893     clear_unloading_state();
 894 
 895     Universe::heap()->register_nmethod(this);
 896     debug_only(Universe::heap()->verify_nmethod(this));
 897 
 898     CodeCache::commit(this);
 899 
 900     finalize_relocations();
 901 

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





















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

3251             else
3252               st->print("<UNKNOWN>");
3253             break;
3254           }
3255         case Bytecodes::_getfield:
3256         case Bytecodes::_putfield:
3257         case Bytecodes::_getstatic:
3258         case Bytecodes::_putstatic:
3259           {
3260             Bytecode_field field(methodHandle(thread, sd->method()), sd->bci());
3261             st->print(" ");
3262             if (field.name() != NULL)
3263               field.name()->print_symbol_on(st);
3264             else
3265               st->print("<UNKNOWN>");
3266           }
3267         default:
3268           break;
3269         }
3270       }
3271       st->print(" {reexecute=%d rethrow=%d return_oop=%d return_scalarized=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop(), sd->return_scalarized());
3272     }
3273 
3274     // Print all scopes
3275     for (;sd != NULL; sd = sd->sender()) {
3276       st->move_to(column, 6, 0);
3277       st->print("; -");
3278       if (sd->should_reexecute()) {
3279         st->print(" (reexecute)");
3280       }
3281       if (sd->method() == NULL) {
3282         st->print("method is NULL");
3283       } else {
3284         sd->method()->print_short_name(st);
3285       }
3286       int lineno = sd->method()->line_number_from_bci(sd->bci());
3287       if (lineno != -1) {
3288         st->print("@%d (line %d)", sd->bci(), lineno);
3289       } else {
3290         st->print("@%d", sd->bci());
3291       }
< prev index next >