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.
1066 // check local reg_map for it being a callee-save register or argument
1067 // register, both of which are saved in the local frame. If not found
1068 // there, it must be an in-stack argument of the caller.
1069 // Note: caller.sp() points to callee-arguments
1070 oop frame::retrieve_receiver(RegisterMap* reg_map) {
1071 frame caller = *this;
1072
1073 // First consult the ADLC on where it puts parameter 0 for this signature.
1074 VMReg reg = SharedRuntime::name_for_receiver();
1075 oop* oop_adr = caller.oopmapreg_to_oop_location(reg, reg_map);
1076 if (oop_adr == nullptr) {
1077 guarantee(oop_adr != nullptr, "bad register save location");
1078 return nullptr;
1079 }
1080 oop r = *oop_adr;
1081 assert(Universe::heap()->is_in_or_null(r), "bad receiver: " INTPTR_FORMAT " (" INTX_FORMAT ")", p2i(r), p2i(r));
1082 return r;
1083 }
1084
1085
1086 BasicLock* frame::get_native_monitor() {
1087 nmethod* nm = (nmethod*)_cb;
1088 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1089 "Should not call this unless it's a native nmethod");
1090 int byte_offset = in_bytes(nm->native_basic_lock_sp_offset());
1091 assert(byte_offset >= 0, "should not see invalid offset");
1092 return (BasicLock*) &sp()[byte_offset / wordSize];
1093 }
1094
1095 oop frame::get_native_receiver() {
1096 nmethod* nm = (nmethod*)_cb;
1097 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1098 "Should not call this unless it's a native nmethod");
1099 int byte_offset = in_bytes(nm->native_receiver_sp_offset());
1100 assert(byte_offset >= 0, "should not see invalid offset");
1101 oop owner = ((oop*) sp())[byte_offset / wordSize];
1102 assert( Universe::heap()->is_in(owner), "bad receiver" );
1103 return owner;
1104 }
1105
1106 void frame::oops_entry_do(OopClosure* f, const RegisterMap* map) const {
1107 assert(map != nullptr, "map must be set");
1108 if (map->include_argument_oops()) {
1109 // must collect argument oops, as nobody else is doing it
1110 Thread *thread = Thread::current();
1111 methodHandle m (thread, entry_frame_call_wrapper()->callee_method());
1112 EntryFrameOopFinder finder(this, m->signature(), m->is_static());
1113 finder.arguments_do(f);
1114 }
1115 // Traverse the Handle Block saved in the entry frame
1255 _oops = new (mtThread) GrowableArray<oop*>(100, mtThread);
1256 _narrow_oops = new (mtThread) GrowableArray<narrowOop*>(100, mtThread);
1257 _base = new (mtThread) GrowableArray<derived_base*>(100, mtThread);
1258 _derived = new (mtThread) GrowableArray<derived_pointer*>(100, mtThread);
1259 }
1260 ~FrameValuesOopClosure() {
1261 delete _oops;
1262 delete _narrow_oops;
1263 delete _base;
1264 delete _derived;
1265 }
1266
1267 virtual void do_oop(oop* p) override { _oops->push(p); }
1268 virtual void do_oop(narrowOop* p) override { _narrow_oops->push(p); }
1269 virtual void do_derived_oop(derived_base* base_loc, derived_pointer* derived_loc) override {
1270 _base->push(base_loc);
1271 _derived->push(derived_loc);
1272 }
1273
1274 bool is_good(oop* p) {
1275 return *p == nullptr || (dbg_is_safe(*p, -1) && dbg_is_safe((*p)->klass(), -1) && oopDesc::is_oop_or_null(*p));
1276 }
1277 void describe(FrameValues& values, int frame_no) {
1278 for (int i = 0; i < _oops->length(); i++) {
1279 oop* p = _oops->at(i);
1280 values.describe(frame_no, (intptr_t*)p, err_msg("oop%s for #%d", is_good(p) ? "" : " (BAD)", frame_no));
1281 }
1282 for (int i = 0; i < _narrow_oops->length(); i++) {
1283 narrowOop* p = _narrow_oops->at(i);
1284 // we can't check for bad compressed oops, as decoding them might crash
1285 values.describe(frame_no, (intptr_t*)p, err_msg("narrow oop for #%d", frame_no));
1286 }
1287 assert(_base->length() == _derived->length(), "should be the same");
1288 for (int i = 0; i < _base->length(); i++) {
1289 derived_base* base = _base->at(i);
1290 derived_pointer* derived = _derived->at(i);
1291 values.describe(frame_no, (intptr_t*)derived, err_msg("derived pointer (base: " INTPTR_FORMAT ") for #%d", p2i(base), frame_no));
1292 }
1293 }
1294 };
1295
1308 intptr_t* p = (intptr_t*)_fr->oopmapreg_to_location(reg, _reg_map);
1309 if (p != nullptr && (((intptr_t)p & WordAlignmentMask) == 0)) {
1310 const char* type_name = nullptr;
1311 switch(type) {
1312 case OopMapValue::oop_value: type_name = "oop"; break;
1313 case OopMapValue::narrowoop_value: type_name = "narrow oop"; break;
1314 case OopMapValue::callee_saved_value: type_name = "callee-saved"; break;
1315 case OopMapValue::derived_oop_value: type_name = "derived"; break;
1316 // case OopMapValue::live_value: type_name = "live"; break;
1317 default: break;
1318 }
1319 if (type_name != nullptr) {
1320 _values.describe(_frame_no, p, err_msg("%s for #%d", type_name, _frame_no));
1321 }
1322 }
1323 }
1324 };
1325
1326 // callers need a ResourceMark because of name_and_sig_as_C_string() usage,
1327 // RA allocated string is returned to the caller
1328 void frame::describe(FrameValues& values, int frame_no, const RegisterMap* reg_map) {
1329 // boundaries: sp and the 'real' frame pointer
1330 values.describe(-1, sp(), err_msg("sp for #%d", frame_no), 0);
1331 intptr_t* frame_pointer = real_fp(); // Note: may differ from fp()
1332
1333 // print frame info at the highest boundary
1334 intptr_t* info_address = MAX2(sp(), frame_pointer);
1335
1336 if (info_address != frame_pointer) {
1337 // print frame_pointer explicitly if not marked by the frame info
1338 values.describe(-1, frame_pointer, err_msg("frame pointer for #%d", frame_no), 1);
1339 }
1340
1341 if (is_entry_frame() || is_compiled_frame() || is_interpreted_frame() || is_native_frame()) {
1342 // Label values common to most frames
1343 values.describe(-1, unextended_sp(), err_msg("unextended_sp for #%d", frame_no), 0);
1344 }
1345
1346 if (is_interpreted_frame()) {
1347 Method* m = interpreter_frame_method();
1348 int bci = interpreter_frame_bci();
1349 InterpreterCodelet* desc = Interpreter::codelet_containing(pc());
1350
1382 OopMapCache::compute_one_oop_map(methodHandle(Thread::current(), m), bci, &mask);
1383 intptr_t* tos = nullptr;
1384 // Report each stack element and mark as owned by this frame
1385 for (int e = 0; e < mask.expression_stack_size(); e++) {
1386 tos = MAX2(tos, interpreter_frame_expression_stack_at(e));
1387 values.describe(frame_no, interpreter_frame_expression_stack_at(e),
1388 err_msg("stack %d", e), 1);
1389 }
1390 if (tos != nullptr) {
1391 values.describe(-1, tos, err_msg("expression stack for #%d", frame_no), 2);
1392 }
1393
1394 if (reg_map != nullptr) {
1395 FrameValuesOopClosure oopsFn;
1396 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1397 oopsFn.describe(values, frame_no);
1398 }
1399 } else if (is_entry_frame()) {
1400 // For now just label the frame
1401 values.describe(-1, info_address, err_msg("#%d entry frame", frame_no), 2);
1402 } else if (cb()->is_nmethod()) {
1403 // For now just label the frame
1404 nmethod* nm = cb()->as_nmethod();
1405 values.describe(-1, info_address,
1406 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for method J %s%s", frame_no,
1407 p2i(nm),
1408 nm->method()->name_and_sig_as_C_string(),
1409 (_deopt_state == is_deoptimized) ?
1410 " (deoptimized)" :
1411 ((_deopt_state == unknown) ? " (state unknown)" : "")),
1412 3);
1413
1414 { // mark arguments (see nmethod::print_nmethod_labels)
1415 Method* m = nm->method();
1416
1417 int stack_slot_offset = nm->frame_size() * wordSize; // offset, in bytes, to caller sp
1418 int sizeargs = m->size_of_parameters();
1419
1420 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
1421 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
1422 {
1485 int scvs_length = scvs != nullptr ? scvs->length() : 0;
1486 for (int i = 0; i < scvs_length; i++) {
1487 intptr_t* stack_address = (intptr_t*)StackValue::stack_value_address(this, reg_map, scvs->at(i));
1488 if (stack_address != nullptr) {
1489 values.describe(frame_no, stack_address, err_msg("stack %d for #%d (scope %d)", i, frame_no, scope_no), 1);
1490 }
1491 }
1492 }
1493 }
1494
1495 FrameValuesOopClosure oopsFn;
1496 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1497 oopsFn.describe(values, frame_no);
1498
1499 if (oop_map() != nullptr) {
1500 FrameValuesOopMapClosure valuesFn(this, reg_map, values, frame_no);
1501 // also OopMapValue::live_value ??
1502 oop_map()->all_type_do(this, OopMapValue::callee_saved_value, &valuesFn);
1503 }
1504 }
1505
1506 if (nm->method()->is_continuation_enter_intrinsic()) {
1507 ContinuationEntry* ce = Continuation::get_continuation_entry_for_entry_frame(reg_map->thread(), *this); // (ContinuationEntry*)unextended_sp();
1508 ce->describe(values, frame_no);
1509 }
1510 } else if (is_native_frame()) {
1511 // For now just label the frame
1512 nmethod* nm = cb()->as_nmethod_or_null();
1513 values.describe(-1, info_address,
1514 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for native method %s", frame_no,
1515 p2i(nm), nm->method()->name_and_sig_as_C_string()), 2);
1516 } else {
1517 // provide default info if not handled before
1518 char *info = (char *) "special frame";
1519 if ((_cb != nullptr) &&
1520 (_cb->name() != nullptr)) {
1521 info = (char *)_cb->name();
1522 }
1523 values.describe(-1, info_address, err_msg("#%d <%s>", frame_no, info), 2);
1524 }
1525
1526 // platform dependent additional data
1527 describe_pd(values, frame_no);
1528 }
1529
1530 #endif
1531
1532 #ifndef PRODUCT
1533
1534 void FrameValues::describe(int owner, intptr_t* location, const char* description, int priority) {
1535 FrameValue fv;
|
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.
1077 // check local reg_map for it being a callee-save register or argument
1078 // register, both of which are saved in the local frame. If not found
1079 // there, it must be an in-stack argument of the caller.
1080 // Note: caller.sp() points to callee-arguments
1081 oop frame::retrieve_receiver(RegisterMap* reg_map) {
1082 frame caller = *this;
1083
1084 // First consult the ADLC on where it puts parameter 0 for this signature.
1085 VMReg reg = SharedRuntime::name_for_receiver();
1086 oop* oop_adr = caller.oopmapreg_to_oop_location(reg, reg_map);
1087 if (oop_adr == nullptr) {
1088 guarantee(oop_adr != nullptr, "bad register save location");
1089 return nullptr;
1090 }
1091 oop r = *oop_adr;
1092 assert(Universe::heap()->is_in_or_null(r), "bad receiver: " INTPTR_FORMAT " (" INTX_FORMAT ")", p2i(r), p2i(r));
1093 return r;
1094 }
1095
1096
1097 BasicLock* frame::get_native_monitor() const {
1098 nmethod* nm = (nmethod*)_cb;
1099 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1100 "Should not call this unless it's a native nmethod");
1101 int byte_offset = in_bytes(nm->native_basic_lock_sp_offset());
1102 assert(byte_offset >= 0, "should not see invalid offset");
1103 return (BasicLock*) &sp()[byte_offset / wordSize];
1104 }
1105
1106 oop frame::get_native_receiver() const {
1107 nmethod* nm = (nmethod*)_cb;
1108 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1109 "Should not call this unless it's a native nmethod");
1110 int byte_offset = in_bytes(nm->native_receiver_sp_offset());
1111 assert(byte_offset >= 0, "should not see invalid offset");
1112 oop owner = ((oop*) sp())[byte_offset / wordSize];
1113 assert( Universe::heap()->is_in(owner), "bad receiver" );
1114 return owner;
1115 }
1116
1117 void frame::oops_entry_do(OopClosure* f, const RegisterMap* map) const {
1118 assert(map != nullptr, "map must be set");
1119 if (map->include_argument_oops()) {
1120 // must collect argument oops, as nobody else is doing it
1121 Thread *thread = Thread::current();
1122 methodHandle m (thread, entry_frame_call_wrapper()->callee_method());
1123 EntryFrameOopFinder finder(this, m->signature(), m->is_static());
1124 finder.arguments_do(f);
1125 }
1126 // Traverse the Handle Block saved in the entry frame
1266 _oops = new (mtThread) GrowableArray<oop*>(100, mtThread);
1267 _narrow_oops = new (mtThread) GrowableArray<narrowOop*>(100, mtThread);
1268 _base = new (mtThread) GrowableArray<derived_base*>(100, mtThread);
1269 _derived = new (mtThread) GrowableArray<derived_pointer*>(100, mtThread);
1270 }
1271 ~FrameValuesOopClosure() {
1272 delete _oops;
1273 delete _narrow_oops;
1274 delete _base;
1275 delete _derived;
1276 }
1277
1278 virtual void do_oop(oop* p) override { _oops->push(p); }
1279 virtual void do_oop(narrowOop* p) override { _narrow_oops->push(p); }
1280 virtual void do_derived_oop(derived_base* base_loc, derived_pointer* derived_loc) override {
1281 _base->push(base_loc);
1282 _derived->push(derived_loc);
1283 }
1284
1285 bool is_good(oop* p) {
1286 return *p == nullptr || (dbg_is_safe(*p, -1) && oopDesc::is_oop_or_null(*p));
1287 }
1288 void describe(FrameValues& values, int frame_no) {
1289 for (int i = 0; i < _oops->length(); i++) {
1290 oop* p = _oops->at(i);
1291 values.describe(frame_no, (intptr_t*)p, err_msg("oop%s for #%d", is_good(p) ? "" : " (BAD)", frame_no));
1292 }
1293 for (int i = 0; i < _narrow_oops->length(); i++) {
1294 narrowOop* p = _narrow_oops->at(i);
1295 // we can't check for bad compressed oops, as decoding them might crash
1296 values.describe(frame_no, (intptr_t*)p, err_msg("narrow oop for #%d", frame_no));
1297 }
1298 assert(_base->length() == _derived->length(), "should be the same");
1299 for (int i = 0; i < _base->length(); i++) {
1300 derived_base* base = _base->at(i);
1301 derived_pointer* derived = _derived->at(i);
1302 values.describe(frame_no, (intptr_t*)derived, err_msg("derived pointer (base: " INTPTR_FORMAT ") for #%d", p2i(base), frame_no));
1303 }
1304 }
1305 };
1306
1319 intptr_t* p = (intptr_t*)_fr->oopmapreg_to_location(reg, _reg_map);
1320 if (p != nullptr && (((intptr_t)p & WordAlignmentMask) == 0)) {
1321 const char* type_name = nullptr;
1322 switch(type) {
1323 case OopMapValue::oop_value: type_name = "oop"; break;
1324 case OopMapValue::narrowoop_value: type_name = "narrow oop"; break;
1325 case OopMapValue::callee_saved_value: type_name = "callee-saved"; break;
1326 case OopMapValue::derived_oop_value: type_name = "derived"; break;
1327 // case OopMapValue::live_value: type_name = "live"; break;
1328 default: break;
1329 }
1330 if (type_name != nullptr) {
1331 _values.describe(_frame_no, p, err_msg("%s for #%d", type_name, _frame_no));
1332 }
1333 }
1334 }
1335 };
1336
1337 // callers need a ResourceMark because of name_and_sig_as_C_string() usage,
1338 // RA allocated string is returned to the caller
1339 void frame::describe(FrameValues& values, int frame_no, const RegisterMap* reg_map, bool top) {
1340 // boundaries: sp and the 'real' frame pointer
1341 values.describe(-1, sp(), err_msg("sp for #%d", frame_no), 0);
1342 if (top) {
1343 values.describe(-1, sp() - 1, err_msg("sp[-1] for #%d", frame_no), 0);
1344 values.describe(-1, sp() - 2, err_msg("sp[-2] for #%d", frame_no), 0);
1345 }
1346
1347 intptr_t* frame_pointer = real_fp(); // Note: may differ from fp()
1348
1349 // print frame info at the highest boundary
1350 intptr_t* info_address = MAX2(sp(), frame_pointer);
1351
1352 if (info_address != frame_pointer) {
1353 // print frame_pointer explicitly if not marked by the frame info
1354 values.describe(-1, frame_pointer, err_msg("frame pointer for #%d", frame_no), 1);
1355 }
1356
1357 if (is_entry_frame() || is_compiled_frame() || is_interpreted_frame() || is_native_frame()) {
1358 // Label values common to most frames
1359 values.describe(-1, unextended_sp(), err_msg("unextended_sp for #%d", frame_no), 0);
1360 }
1361
1362 if (is_interpreted_frame()) {
1363 Method* m = interpreter_frame_method();
1364 int bci = interpreter_frame_bci();
1365 InterpreterCodelet* desc = Interpreter::codelet_containing(pc());
1366
1398 OopMapCache::compute_one_oop_map(methodHandle(Thread::current(), m), bci, &mask);
1399 intptr_t* tos = nullptr;
1400 // Report each stack element and mark as owned by this frame
1401 for (int e = 0; e < mask.expression_stack_size(); e++) {
1402 tos = MAX2(tos, interpreter_frame_expression_stack_at(e));
1403 values.describe(frame_no, interpreter_frame_expression_stack_at(e),
1404 err_msg("stack %d", e), 1);
1405 }
1406 if (tos != nullptr) {
1407 values.describe(-1, tos, err_msg("expression stack for #%d", frame_no), 2);
1408 }
1409
1410 if (reg_map != nullptr) {
1411 FrameValuesOopClosure oopsFn;
1412 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1413 oopsFn.describe(values, frame_no);
1414 }
1415 } else if (is_entry_frame()) {
1416 // For now just label the frame
1417 values.describe(-1, info_address, err_msg("#%d entry frame", frame_no), 2);
1418 } else if (is_compiled_frame()) {
1419 // For now just label the frame
1420 nmethod* nm = cb()->as_nmethod();
1421 values.describe(-1, info_address,
1422 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for method J %s%s", frame_no,
1423 p2i(nm),
1424 nm->method()->name_and_sig_as_C_string(),
1425 (_deopt_state == is_deoptimized) ?
1426 " (deoptimized)" :
1427 ((_deopt_state == unknown) ? " (state unknown)" : "")),
1428 3);
1429
1430 { // mark arguments (see nmethod::print_nmethod_labels)
1431 Method* m = nm->method();
1432
1433 int stack_slot_offset = nm->frame_size() * wordSize; // offset, in bytes, to caller sp
1434 int sizeargs = m->size_of_parameters();
1435
1436 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
1437 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
1438 {
1501 int scvs_length = scvs != nullptr ? scvs->length() : 0;
1502 for (int i = 0; i < scvs_length; i++) {
1503 intptr_t* stack_address = (intptr_t*)StackValue::stack_value_address(this, reg_map, scvs->at(i));
1504 if (stack_address != nullptr) {
1505 values.describe(frame_no, stack_address, err_msg("stack %d for #%d (scope %d)", i, frame_no, scope_no), 1);
1506 }
1507 }
1508 }
1509 }
1510
1511 FrameValuesOopClosure oopsFn;
1512 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1513 oopsFn.describe(values, frame_no);
1514
1515 if (oop_map() != nullptr) {
1516 FrameValuesOopMapClosure valuesFn(this, reg_map, values, frame_no);
1517 // also OopMapValue::live_value ??
1518 oop_map()->all_type_do(this, OopMapValue::callee_saved_value, &valuesFn);
1519 }
1520 }
1521 } else if (is_native_frame()) {
1522 // For now just label the frame
1523 nmethod* nm = cb()->as_nmethod_or_null();
1524 values.describe(-1, info_address,
1525 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for native method %s", frame_no,
1526 p2i(nm), nm->method()->name_and_sig_as_C_string()), 2);
1527 if (nm->method()->is_continuation_enter_intrinsic()) {
1528 ContinuationEntry* ce = Continuation::get_continuation_entry_for_entry_frame(reg_map->thread(), *this); // (ContinuationEntry*)unextended_sp();
1529 ce->describe(values, frame_no);
1530 }
1531 } else {
1532 // provide default info if not handled before
1533 char *info = (char *) "special frame";
1534 if ((_cb != nullptr) &&
1535 (_cb->name() != nullptr)) {
1536 info = (char *)_cb->name();
1537 }
1538 values.describe(-1, info_address, err_msg("#%d <%s>", frame_no, info), 2);
1539 }
1540
1541 // platform dependent additional data
1542 describe_pd(values, frame_no);
1543 }
1544
1545 #endif
1546
1547 #ifndef PRODUCT
1548
1549 void FrameValues::describe(int owner, intptr_t* location, const char* description, int priority) {
1550 FrameValue fv;
|