560 #ifndef PRODUCT
561 assert(is_interpreted_frame(), "Not an interpreted frame");
562 jint i;
563 for (i = 0; i < interpreter_frame_method()->max_locals(); i++ ) {
564 intptr_t x = *interpreter_frame_local_at(i);
565 st->print(" - local [" INTPTR_FORMAT "]", x);
566 st->fill_to(23);
567 st->print_cr("; #%d", i);
568 }
569 for (i = interpreter_frame_expression_stack_size() - 1; i >= 0; --i ) {
570 intptr_t x = *interpreter_frame_expression_stack_at(i);
571 st->print(" - stack [" INTPTR_FORMAT "]", x);
572 st->fill_to(23);
573 st->print_cr("; #%d", i);
574 }
575 // locks for synchronization
576 for (BasicObjectLock* current = interpreter_frame_monitor_end();
577 current < interpreter_frame_monitor_begin();
578 current = next_monitor_in_interpreter_frame(current)) {
579 st->print(" - obj [%s", current->obj() == nullptr ? "null" : "");
580 if (current->obj() != nullptr) current->obj()->print_value_on(st);
581 st->print_cr("]");
582 st->print(" - lock [");
583 current->lock()->print_on(st, current->obj());
584 st->print_cr("]");
585 }
586 // monitor
587 st->print_cr(" - monitor[" INTPTR_FORMAT "]", p2i(interpreter_frame_monitor_begin()));
588 // bcp
589 st->print(" - bcp [" INTPTR_FORMAT "]", p2i(interpreter_frame_bcp()));
590 st->fill_to(23);
591 st->print_cr("; @%d", interpreter_frame_bci());
592 // locals
593 st->print_cr(" - locals [" INTPTR_FORMAT "]", p2i(interpreter_frame_local_at(0)));
594 // method
595 st->print(" - method [" INTPTR_FORMAT "]", p2i(interpreter_frame_method()));
596 st->fill_to(23);
597 st->print("; ");
598 interpreter_frame_method()->print_name(st);
599 st->cr();
600 #endif
601 }
602
603 // Print whether the frame is in the VM or OS indicating a HotSpot problem.
1067 // check local reg_map for it being a callee-save register or argument
1068 // register, both of which are saved in the local frame. If not found
1069 // there, it must be an in-stack argument of the caller.
1070 // Note: caller.sp() points to callee-arguments
1071 oop frame::retrieve_receiver(RegisterMap* reg_map) {
1072 frame caller = *this;
1073
1074 // First consult the ADLC on where it puts parameter 0 for this signature.
1075 VMReg reg = SharedRuntime::name_for_receiver();
1076 oop* oop_adr = caller.oopmapreg_to_oop_location(reg, reg_map);
1077 if (oop_adr == nullptr) {
1078 guarantee(oop_adr != nullptr, "bad register save location");
1079 return nullptr;
1080 }
1081 oop r = *oop_adr;
1082 assert(Universe::heap()->is_in_or_null(r), "bad receiver: " INTPTR_FORMAT " (" INTX_FORMAT ")", p2i(r), p2i(r));
1083 return r;
1084 }
1085
1086
1087 BasicLock* frame::get_native_monitor() {
1088 nmethod* nm = (nmethod*)_cb;
1089 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1090 "Should not call this unless it's a native nmethod");
1091 int byte_offset = in_bytes(nm->native_basic_lock_sp_offset());
1092 assert(byte_offset >= 0, "should not see invalid offset");
1093 return (BasicLock*) &sp()[byte_offset / wordSize];
1094 }
1095
1096 oop frame::get_native_receiver() {
1097 nmethod* nm = (nmethod*)_cb;
1098 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1099 "Should not call this unless it's a native nmethod");
1100 int byte_offset = in_bytes(nm->native_receiver_sp_offset());
1101 assert(byte_offset >= 0, "should not see invalid offset");
1102 oop owner = ((oop*) sp())[byte_offset / wordSize];
1103 assert( Universe::heap()->is_in(owner), "bad receiver" );
1104 return owner;
1105 }
1106
1107 void frame::oops_entry_do(OopClosure* f, const RegisterMap* map) const {
1108 assert(map != nullptr, "map must be set");
1109 if (map->include_argument_oops()) {
1110 // must collect argument oops, as nobody else is doing it
1111 Thread *thread = Thread::current();
1112 methodHandle m (thread, entry_frame_call_wrapper()->callee_method());
1113 EntryFrameOopFinder finder(this, m->signature(), m->is_static());
1114 finder.arguments_do(f);
1115 }
1116 // Traverse the Handle Block saved in the entry frame
1256 _oops = new (mtThread) GrowableArray<oop*>(100, mtThread);
1257 _narrow_oops = new (mtThread) GrowableArray<narrowOop*>(100, mtThread);
1258 _base = new (mtThread) GrowableArray<derived_base*>(100, mtThread);
1259 _derived = new (mtThread) GrowableArray<derived_pointer*>(100, mtThread);
1260 }
1261 ~FrameValuesOopClosure() {
1262 delete _oops;
1263 delete _narrow_oops;
1264 delete _base;
1265 delete _derived;
1266 }
1267
1268 virtual void do_oop(oop* p) override { _oops->push(p); }
1269 virtual void do_oop(narrowOop* p) override { _narrow_oops->push(p); }
1270 virtual void do_derived_oop(derived_base* base_loc, derived_pointer* derived_loc) override {
1271 _base->push(base_loc);
1272 _derived->push(derived_loc);
1273 }
1274
1275 bool is_good(oop* p) {
1276 return *p == nullptr || (dbg_is_safe(*p, -1) && dbg_is_safe((*p)->klass(), -1) && oopDesc::is_oop_or_null(*p));
1277 }
1278 void describe(FrameValues& values, int frame_no) {
1279 for (int i = 0; i < _oops->length(); i++) {
1280 oop* p = _oops->at(i);
1281 values.describe(frame_no, (intptr_t*)p, err_msg("oop%s for #%d", is_good(p) ? "" : " (BAD)", frame_no));
1282 }
1283 for (int i = 0; i < _narrow_oops->length(); i++) {
1284 narrowOop* p = _narrow_oops->at(i);
1285 // we can't check for bad compressed oops, as decoding them might crash
1286 values.describe(frame_no, (intptr_t*)p, err_msg("narrow oop for #%d", frame_no));
1287 }
1288 assert(_base->length() == _derived->length(), "should be the same");
1289 for (int i = 0; i < _base->length(); i++) {
1290 derived_base* base = _base->at(i);
1291 derived_pointer* derived = _derived->at(i);
1292 values.describe(frame_no, (intptr_t*)derived, err_msg("derived pointer (base: " INTPTR_FORMAT ") for #%d", p2i(base), frame_no));
1293 }
1294 }
1295 };
1296
1309 intptr_t* p = (intptr_t*)_fr->oopmapreg_to_location(reg, _reg_map);
1310 if (p != nullptr && (((intptr_t)p & WordAlignmentMask) == 0)) {
1311 const char* type_name = nullptr;
1312 switch(type) {
1313 case OopMapValue::oop_value: type_name = "oop"; break;
1314 case OopMapValue::narrowoop_value: type_name = "narrow oop"; break;
1315 case OopMapValue::callee_saved_value: type_name = "callee-saved"; break;
1316 case OopMapValue::derived_oop_value: type_name = "derived"; break;
1317 // case OopMapValue::live_value: type_name = "live"; break;
1318 default: break;
1319 }
1320 if (type_name != nullptr) {
1321 _values.describe(_frame_no, p, err_msg("%s for #%d", type_name, _frame_no));
1322 }
1323 }
1324 }
1325 };
1326
1327 // callers need a ResourceMark because of name_and_sig_as_C_string() usage,
1328 // RA allocated string is returned to the caller
1329 void frame::describe(FrameValues& values, int frame_no, const RegisterMap* reg_map) {
1330 // boundaries: sp and the 'real' frame pointer
1331 values.describe(-1, sp(), err_msg("sp for #%d", frame_no), 0);
1332 intptr_t* frame_pointer = real_fp(); // Note: may differ from fp()
1333
1334 // print frame info at the highest boundary
1335 intptr_t* info_address = MAX2(sp(), frame_pointer);
1336
1337 if (info_address != frame_pointer) {
1338 // print frame_pointer explicitly if not marked by the frame info
1339 values.describe(-1, frame_pointer, err_msg("frame pointer for #%d", frame_no), 1);
1340 }
1341
1342 if (is_entry_frame() || is_compiled_frame() || is_interpreted_frame() || is_native_frame()) {
1343 // Label values common to most frames
1344 values.describe(-1, unextended_sp(), err_msg("unextended_sp for #%d", frame_no), 0);
1345 }
1346
1347 if (is_interpreted_frame()) {
1348 Method* m = interpreter_frame_method();
1349 int bci = interpreter_frame_bci();
1350 InterpreterCodelet* desc = Interpreter::codelet_containing(pc());
1351
1383 OopMapCache::compute_one_oop_map(methodHandle(Thread::current(), m), bci, &mask);
1384 intptr_t* tos = nullptr;
1385 // Report each stack element and mark as owned by this frame
1386 for (int e = 0; e < mask.expression_stack_size(); e++) {
1387 tos = MAX2(tos, interpreter_frame_expression_stack_at(e));
1388 values.describe(frame_no, interpreter_frame_expression_stack_at(e),
1389 err_msg("stack %d", e), 1);
1390 }
1391 if (tos != nullptr) {
1392 values.describe(-1, tos, err_msg("expression stack for #%d", frame_no), 2);
1393 }
1394
1395 if (reg_map != nullptr) {
1396 FrameValuesOopClosure oopsFn;
1397 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1398 oopsFn.describe(values, frame_no);
1399 }
1400 } else if (is_entry_frame()) {
1401 // For now just label the frame
1402 values.describe(-1, info_address, err_msg("#%d entry frame", frame_no), 2);
1403 } else if (cb()->is_nmethod()) {
1404 // For now just label the frame
1405 nmethod* nm = cb()->as_nmethod();
1406 values.describe(-1, info_address,
1407 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for method J %s%s", frame_no,
1408 p2i(nm),
1409 nm->method()->name_and_sig_as_C_string(),
1410 (_deopt_state == is_deoptimized) ?
1411 " (deoptimized)" :
1412 ((_deopt_state == unknown) ? " (state unknown)" : "")),
1413 3);
1414
1415 { // mark arguments (see nmethod::print_nmethod_labels)
1416 Method* m = nm->method();
1417
1418 int stack_slot_offset = nm->frame_size() * wordSize; // offset, in bytes, to caller sp
1419 int sizeargs = m->size_of_parameters();
1420
1421 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
1422 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
1423 {
|
560 #ifndef PRODUCT
561 assert(is_interpreted_frame(), "Not an interpreted frame");
562 jint i;
563 for (i = 0; i < interpreter_frame_method()->max_locals(); i++ ) {
564 intptr_t x = *interpreter_frame_local_at(i);
565 st->print(" - local [" INTPTR_FORMAT "]", x);
566 st->fill_to(23);
567 st->print_cr("; #%d", i);
568 }
569 for (i = interpreter_frame_expression_stack_size() - 1; i >= 0; --i ) {
570 intptr_t x = *interpreter_frame_expression_stack_at(i);
571 st->print(" - stack [" INTPTR_FORMAT "]", x);
572 st->fill_to(23);
573 st->print_cr("; #%d", i);
574 }
575 // locks for synchronization
576 for (BasicObjectLock* current = interpreter_frame_monitor_end();
577 current < interpreter_frame_monitor_begin();
578 current = next_monitor_in_interpreter_frame(current)) {
579 st->print(" - obj [%s", current->obj() == nullptr ? "null" : "");
580 oop obj = current->obj();
581 if (obj != nullptr) {
582 if (!is_heap_frame()) {
583 obj->print_value_on(st);
584 } else {
585 // Might be an invalid oop. We don't have the
586 // stackChunk to correct it so just print address.
587 st->print(INTPTR_FORMAT, p2i(obj));
588 }
589 }
590 st->print_cr("]");
591 st->print(" - lock [");
592 if (!is_heap_frame()) {
593 current->lock()->print_on(st, obj);
594 }
595 st->print_cr("]");
596 }
597 // monitor
598 st->print_cr(" - monitor[" INTPTR_FORMAT "]", p2i(interpreter_frame_monitor_begin()));
599 // bcp
600 st->print(" - bcp [" INTPTR_FORMAT "]", p2i(interpreter_frame_bcp()));
601 st->fill_to(23);
602 st->print_cr("; @%d", interpreter_frame_bci());
603 // locals
604 st->print_cr(" - locals [" INTPTR_FORMAT "]", p2i(interpreter_frame_local_at(0)));
605 // method
606 st->print(" - method [" INTPTR_FORMAT "]", p2i(interpreter_frame_method()));
607 st->fill_to(23);
608 st->print("; ");
609 interpreter_frame_method()->print_name(st);
610 st->cr();
611 #endif
612 }
613
614 // Print whether the frame is in the VM or OS indicating a HotSpot problem.
1078 // check local reg_map for it being a callee-save register or argument
1079 // register, both of which are saved in the local frame. If not found
1080 // there, it must be an in-stack argument of the caller.
1081 // Note: caller.sp() points to callee-arguments
1082 oop frame::retrieve_receiver(RegisterMap* reg_map) {
1083 frame caller = *this;
1084
1085 // First consult the ADLC on where it puts parameter 0 for this signature.
1086 VMReg reg = SharedRuntime::name_for_receiver();
1087 oop* oop_adr = caller.oopmapreg_to_oop_location(reg, reg_map);
1088 if (oop_adr == nullptr) {
1089 guarantee(oop_adr != nullptr, "bad register save location");
1090 return nullptr;
1091 }
1092 oop r = *oop_adr;
1093 assert(Universe::heap()->is_in_or_null(r), "bad receiver: " INTPTR_FORMAT " (" INTX_FORMAT ")", p2i(r), p2i(r));
1094 return r;
1095 }
1096
1097
1098 BasicLock* frame::get_native_monitor() const {
1099 nmethod* nm = (nmethod*)_cb;
1100 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1101 "Should not call this unless it's a native nmethod");
1102 int byte_offset = in_bytes(nm->native_basic_lock_sp_offset());
1103 assert(byte_offset >= 0, "should not see invalid offset");
1104 return (BasicLock*) &sp()[byte_offset / wordSize];
1105 }
1106
1107 oop frame::get_native_receiver() const {
1108 nmethod* nm = (nmethod*)_cb;
1109 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1110 "Should not call this unless it's a native nmethod");
1111 int byte_offset = in_bytes(nm->native_receiver_sp_offset());
1112 assert(byte_offset >= 0, "should not see invalid offset");
1113 oop owner = ((oop*) sp())[byte_offset / wordSize];
1114 assert( Universe::heap()->is_in(owner), "bad receiver" );
1115 return owner;
1116 }
1117
1118 void frame::oops_entry_do(OopClosure* f, const RegisterMap* map) const {
1119 assert(map != nullptr, "map must be set");
1120 if (map->include_argument_oops()) {
1121 // must collect argument oops, as nobody else is doing it
1122 Thread *thread = Thread::current();
1123 methodHandle m (thread, entry_frame_call_wrapper()->callee_method());
1124 EntryFrameOopFinder finder(this, m->signature(), m->is_static());
1125 finder.arguments_do(f);
1126 }
1127 // Traverse the Handle Block saved in the entry frame
1267 _oops = new (mtThread) GrowableArray<oop*>(100, mtThread);
1268 _narrow_oops = new (mtThread) GrowableArray<narrowOop*>(100, mtThread);
1269 _base = new (mtThread) GrowableArray<derived_base*>(100, mtThread);
1270 _derived = new (mtThread) GrowableArray<derived_pointer*>(100, mtThread);
1271 }
1272 ~FrameValuesOopClosure() {
1273 delete _oops;
1274 delete _narrow_oops;
1275 delete _base;
1276 delete _derived;
1277 }
1278
1279 virtual void do_oop(oop* p) override { _oops->push(p); }
1280 virtual void do_oop(narrowOop* p) override { _narrow_oops->push(p); }
1281 virtual void do_derived_oop(derived_base* base_loc, derived_pointer* derived_loc) override {
1282 _base->push(base_loc);
1283 _derived->push(derived_loc);
1284 }
1285
1286 bool is_good(oop* p) {
1287 return *p == nullptr || (dbg_is_safe(*p, -1) && oopDesc::is_oop_or_null(*p));
1288 }
1289 void describe(FrameValues& values, int frame_no) {
1290 for (int i = 0; i < _oops->length(); i++) {
1291 oop* p = _oops->at(i);
1292 values.describe(frame_no, (intptr_t*)p, err_msg("oop%s for #%d", is_good(p) ? "" : " (BAD)", frame_no));
1293 }
1294 for (int i = 0; i < _narrow_oops->length(); i++) {
1295 narrowOop* p = _narrow_oops->at(i);
1296 // we can't check for bad compressed oops, as decoding them might crash
1297 values.describe(frame_no, (intptr_t*)p, err_msg("narrow oop for #%d", frame_no));
1298 }
1299 assert(_base->length() == _derived->length(), "should be the same");
1300 for (int i = 0; i < _base->length(); i++) {
1301 derived_base* base = _base->at(i);
1302 derived_pointer* derived = _derived->at(i);
1303 values.describe(frame_no, (intptr_t*)derived, err_msg("derived pointer (base: " INTPTR_FORMAT ") for #%d", p2i(base), frame_no));
1304 }
1305 }
1306 };
1307
1320 intptr_t* p = (intptr_t*)_fr->oopmapreg_to_location(reg, _reg_map);
1321 if (p != nullptr && (((intptr_t)p & WordAlignmentMask) == 0)) {
1322 const char* type_name = nullptr;
1323 switch(type) {
1324 case OopMapValue::oop_value: type_name = "oop"; break;
1325 case OopMapValue::narrowoop_value: type_name = "narrow oop"; break;
1326 case OopMapValue::callee_saved_value: type_name = "callee-saved"; break;
1327 case OopMapValue::derived_oop_value: type_name = "derived"; break;
1328 // case OopMapValue::live_value: type_name = "live"; break;
1329 default: break;
1330 }
1331 if (type_name != nullptr) {
1332 _values.describe(_frame_no, p, err_msg("%s for #%d", type_name, _frame_no));
1333 }
1334 }
1335 }
1336 };
1337
1338 // callers need a ResourceMark because of name_and_sig_as_C_string() usage,
1339 // RA allocated string is returned to the caller
1340 void frame::describe(FrameValues& values, int frame_no, const RegisterMap* reg_map, bool top) {
1341 // boundaries: sp and the 'real' frame pointer
1342 values.describe(-1, sp(), err_msg("sp for #%d", frame_no), 0);
1343 if (top) {
1344 values.describe(-1, sp() - 1, err_msg("sp[-1] for #%d", frame_no), 0);
1345 values.describe(-1, sp() - 2, err_msg("sp[-2] for #%d", frame_no), 0);
1346 }
1347
1348 intptr_t* frame_pointer = real_fp(); // Note: may differ from fp()
1349
1350 // print frame info at the highest boundary
1351 intptr_t* info_address = MAX2(sp(), frame_pointer);
1352
1353 if (info_address != frame_pointer) {
1354 // print frame_pointer explicitly if not marked by the frame info
1355 values.describe(-1, frame_pointer, err_msg("frame pointer for #%d", frame_no), 1);
1356 }
1357
1358 if (is_entry_frame() || is_compiled_frame() || is_interpreted_frame() || is_native_frame()) {
1359 // Label values common to most frames
1360 values.describe(-1, unextended_sp(), err_msg("unextended_sp for #%d", frame_no), 0);
1361 }
1362
1363 if (is_interpreted_frame()) {
1364 Method* m = interpreter_frame_method();
1365 int bci = interpreter_frame_bci();
1366 InterpreterCodelet* desc = Interpreter::codelet_containing(pc());
1367
1399 OopMapCache::compute_one_oop_map(methodHandle(Thread::current(), m), bci, &mask);
1400 intptr_t* tos = nullptr;
1401 // Report each stack element and mark as owned by this frame
1402 for (int e = 0; e < mask.expression_stack_size(); e++) {
1403 tos = MAX2(tos, interpreter_frame_expression_stack_at(e));
1404 values.describe(frame_no, interpreter_frame_expression_stack_at(e),
1405 err_msg("stack %d", e), 1);
1406 }
1407 if (tos != nullptr) {
1408 values.describe(-1, tos, err_msg("expression stack for #%d", frame_no), 2);
1409 }
1410
1411 if (reg_map != nullptr) {
1412 FrameValuesOopClosure oopsFn;
1413 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1414 oopsFn.describe(values, frame_no);
1415 }
1416 } else if (is_entry_frame()) {
1417 // For now just label the frame
1418 values.describe(-1, info_address, err_msg("#%d entry frame", frame_no), 2);
1419 } else if (cb() && cb()->is_nmethod()) {
1420 // For now just label the frame
1421 nmethod* nm = cb()->as_nmethod();
1422 values.describe(-1, info_address,
1423 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for method J %s%s", frame_no,
1424 p2i(nm),
1425 nm->method()->name_and_sig_as_C_string(),
1426 (_deopt_state == is_deoptimized) ?
1427 " (deoptimized)" :
1428 ((_deopt_state == unknown) ? " (state unknown)" : "")),
1429 3);
1430
1431 { // mark arguments (see nmethod::print_nmethod_labels)
1432 Method* m = nm->method();
1433
1434 int stack_slot_offset = nm->frame_size() * wordSize; // offset, in bytes, to caller sp
1435 int sizeargs = m->size_of_parameters();
1436
1437 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
1438 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
1439 {
|