480 const int n = i * Interpreter::stackElementWords;
481 return &(interpreter_frame_expression_stack()[n]);
482 }
483
484 jint frame::interpreter_frame_expression_stack_size() const {
485 // Number of elements on the interpreter expression stack
486 // Callers should span by stackElementWords
487 int element_size = Interpreter::stackElementWords;
488 size_t stack_size = 0;
489 if (frame::interpreter_frame_expression_stack_direction() < 0) {
490 stack_size = (interpreter_frame_expression_stack() -
491 interpreter_frame_tos_address() + 1)/element_size;
492 } else {
493 stack_size = (interpreter_frame_tos_address() -
494 interpreter_frame_expression_stack() + 1)/element_size;
495 }
496 assert(stack_size <= (size_t)max_jint, "stack size too big");
497 return (jint)stack_size;
498 }
499
500
501 // (frame::interpreter_frame_sender_sp accessor is in frame_<arch>.cpp)
502
503 const char* frame::print_name() const {
504 if (is_native_frame()) return "Native";
505 if (is_interpreted_frame()) return "Interpreted";
506 if (is_compiled_frame()) {
507 if (is_deoptimized_frame()) return "Deoptimized";
508 return "Compiled";
509 }
510 if (sp() == nullptr) return "Empty";
511 return "C";
512 }
513
514 void frame::print_value_on(outputStream* st) const {
515 NOT_PRODUCT(address begin = pc()-40;)
516 NOT_PRODUCT(address end = nullptr;)
517
518 st->print("%s frame (sp=" INTPTR_FORMAT " unextended sp=" INTPTR_FORMAT, print_name(), p2i(sp()), p2i(unextended_sp()));
519 if (sp() != nullptr)
520 st->print(", fp=" INTPTR_FORMAT ", real_fp=" INTPTR_FORMAT ", pc=" INTPTR_FORMAT,
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.
1068 // check local reg_map for it being a callee-save register or argument
1069 // register, both of which are saved in the local frame. If not found
1070 // there, it must be an in-stack argument of the caller.
1071 // Note: caller.sp() points to callee-arguments
1072 oop frame::retrieve_receiver(RegisterMap* reg_map) {
1073 frame caller = *this;
1074
1075 // First consult the ADLC on where it puts parameter 0 for this signature.
1076 VMReg reg = SharedRuntime::name_for_receiver();
1077 oop* oop_adr = caller.oopmapreg_to_oop_location(reg, reg_map);
1078 if (oop_adr == nullptr) {
1079 guarantee(oop_adr != nullptr, "bad register save location");
1080 return nullptr;
1081 }
1082 oop r = *oop_adr;
1083 assert(Universe::heap()->is_in_or_null(r), "bad receiver: " INTPTR_FORMAT " (" INTX_FORMAT ")", p2i(r), p2i(r));
1084 return r;
1085 }
1086
1087
1088 BasicLock* frame::get_native_monitor() {
1089 nmethod* nm = (nmethod*)_cb;
1090 assert(_cb != nullptr && _cb->is_nmethod() && nm->method()->is_native(),
1091 "Should not call this unless it's a native nmethod");
1092 int byte_offset = in_bytes(nm->native_basic_lock_sp_offset());
1093 assert(byte_offset >= 0, "should not see invalid offset");
1094 return (BasicLock*) &sp()[byte_offset / wordSize];
1095 }
1096
1097 oop frame::get_native_receiver() {
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_receiver_sp_offset());
1102 assert(byte_offset >= 0, "should not see invalid offset");
1103 oop owner = ((oop*) sp())[byte_offset / wordSize];
1104 assert( Universe::heap()->is_in(owner), "bad receiver" );
1105 return owner;
1106 }
1107
1108 void frame::oops_entry_do(OopClosure* f, const RegisterMap* map) const {
1109 assert(map != nullptr, "map must be set");
1110 if (map->include_argument_oops()) {
1111 // must collect argument oops, as nobody else is doing it
1112 Thread *thread = Thread::current();
1113 methodHandle m (thread, entry_frame_call_wrapper()->callee_method());
1114 EntryFrameOopFinder finder(this, m->signature(), m->is_static());
1115 finder.arguments_do(f);
1116 }
1117 // Traverse the Handle Block saved in the entry frame
1323 intptr_t* p = (intptr_t*)_fr->oopmapreg_to_location(reg, _reg_map);
1324 if (p != nullptr && (((intptr_t)p & WordAlignmentMask) == 0)) {
1325 const char* type_name = nullptr;
1326 switch(type) {
1327 case OopMapValue::oop_value: type_name = "oop"; break;
1328 case OopMapValue::narrowoop_value: type_name = "narrow oop"; break;
1329 case OopMapValue::callee_saved_value: type_name = "callee-saved"; break;
1330 case OopMapValue::derived_oop_value: type_name = "derived"; break;
1331 // case OopMapValue::live_value: type_name = "live"; break;
1332 default: break;
1333 }
1334 if (type_name != nullptr) {
1335 _values.describe(_frame_no, p, err_msg("%s for #%d", type_name, _frame_no));
1336 }
1337 }
1338 }
1339 };
1340
1341 // callers need a ResourceMark because of name_and_sig_as_C_string() usage,
1342 // RA allocated string is returned to the caller
1343 void frame::describe(FrameValues& values, int frame_no, const RegisterMap* reg_map) {
1344 // boundaries: sp and the 'real' frame pointer
1345 values.describe(-1, sp(), err_msg("sp for #%d", frame_no), 0);
1346 intptr_t* frame_pointer = real_fp(); // Note: may differ from fp()
1347
1348 // print frame info at the highest boundary
1349 intptr_t* info_address = MAX2(sp(), frame_pointer);
1350
1351 if (info_address != frame_pointer) {
1352 // print frame_pointer explicitly if not marked by the frame info
1353 values.describe(-1, frame_pointer, err_msg("frame pointer for #%d", frame_no), 1);
1354 }
1355
1356 if (is_entry_frame() || is_compiled_frame() || is_interpreted_frame() || is_native_frame()) {
1357 // Label values common to most frames
1358 values.describe(-1, unextended_sp(), err_msg("unextended_sp for #%d", frame_no), 0);
1359 }
1360
1361 if (is_interpreted_frame()) {
1362 Method* m = interpreter_frame_method();
1363 int bci = interpreter_frame_bci();
1364 InterpreterCodelet* desc = Interpreter::codelet_containing(pc());
1365
1397 OopMapCache::compute_one_oop_map(methodHandle(Thread::current(), m), bci, &mask);
1398 intptr_t* tos = nullptr;
1399 // Report each stack element and mark as owned by this frame
1400 for (int e = 0; e < mask.expression_stack_size(); e++) {
1401 tos = MAX2(tos, interpreter_frame_expression_stack_at(e));
1402 values.describe(frame_no, interpreter_frame_expression_stack_at(e),
1403 err_msg("stack %d", e), 1);
1404 }
1405 if (tos != nullptr) {
1406 values.describe(-1, tos, err_msg("expression stack for #%d", frame_no), 2);
1407 }
1408
1409 if (reg_map != nullptr) {
1410 FrameValuesOopClosure oopsFn;
1411 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1412 oopsFn.describe(values, frame_no);
1413 }
1414 } else if (is_entry_frame()) {
1415 // For now just label the frame
1416 values.describe(-1, info_address, err_msg("#%d entry frame", frame_no), 2);
1417 } else if (cb()->is_nmethod()) {
1418 // For now just label the frame
1419 nmethod* nm = cb()->as_nmethod();
1420 values.describe(-1, info_address,
1421 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for method J %s%s", frame_no,
1422 p2i(nm),
1423 nm->method()->name_and_sig_as_C_string(),
1424 (_deopt_state == is_deoptimized) ?
1425 " (deoptimized)" :
1426 ((_deopt_state == unknown) ? " (state unknown)" : "")),
1427 3);
1428
1429 { // mark arguments (see nmethod::print_nmethod_labels)
1430 Method* m = nm->method();
1431
1432 int stack_slot_offset = nm->frame_size() * wordSize; // offset, in bytes, to caller sp
1433 int sizeargs = m->size_of_parameters();
1434
1435 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
1436 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
1437 {
1500 int scvs_length = scvs != nullptr ? scvs->length() : 0;
1501 for (int i = 0; i < scvs_length; i++) {
1502 intptr_t* stack_address = (intptr_t*)StackValue::stack_value_address(this, reg_map, scvs->at(i));
1503 if (stack_address != nullptr) {
1504 values.describe(frame_no, stack_address, err_msg("stack %d for #%d (scope %d)", i, frame_no, scope_no), 1);
1505 }
1506 }
1507 }
1508 }
1509
1510 FrameValuesOopClosure oopsFn;
1511 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1512 oopsFn.describe(values, frame_no);
1513
1514 if (oop_map() != nullptr) {
1515 FrameValuesOopMapClosure valuesFn(this, reg_map, values, frame_no);
1516 // also OopMapValue::live_value ??
1517 oop_map()->all_type_do(this, OopMapValue::callee_saved_value, &valuesFn);
1518 }
1519 }
1520
1521 if (nm->method()->is_continuation_enter_intrinsic()) {
1522 ContinuationEntry* ce = Continuation::get_continuation_entry_for_entry_frame(reg_map->thread(), *this); // (ContinuationEntry*)unextended_sp();
1523 ce->describe(values, frame_no);
1524 }
1525 } else if (is_native_frame()) {
1526 // For now just label the frame
1527 nmethod* nm = cb()->as_nmethod_or_null();
1528 values.describe(-1, info_address,
1529 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for native method %s", frame_no,
1530 p2i(nm), nm->method()->name_and_sig_as_C_string()), 2);
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;
|
480 const int n = i * Interpreter::stackElementWords;
481 return &(interpreter_frame_expression_stack()[n]);
482 }
483
484 jint frame::interpreter_frame_expression_stack_size() const {
485 // Number of elements on the interpreter expression stack
486 // Callers should span by stackElementWords
487 int element_size = Interpreter::stackElementWords;
488 size_t stack_size = 0;
489 if (frame::interpreter_frame_expression_stack_direction() < 0) {
490 stack_size = (interpreter_frame_expression_stack() -
491 interpreter_frame_tos_address() + 1)/element_size;
492 } else {
493 stack_size = (interpreter_frame_tos_address() -
494 interpreter_frame_expression_stack() + 1)/element_size;
495 }
496 assert(stack_size <= (size_t)max_jint, "stack size too big");
497 return (jint)stack_size;
498 }
499
500 // (frame::interpreter_frame_sender_sp accessor is in frame_<arch>.cpp)
501
502 const char* frame::print_name() const {
503 if (is_native_frame()) return "Native";
504 if (is_interpreted_frame()) return "Interpreted";
505 if (is_compiled_frame()) {
506 if (is_deoptimized_frame()) return "Deoptimized";
507 return "Compiled";
508 }
509 if (sp() == nullptr) return "Empty";
510 return "C";
511 }
512
513 void frame::print_value_on(outputStream* st) const {
514 NOT_PRODUCT(address begin = pc()-40;)
515 NOT_PRODUCT(address end = nullptr;)
516
517 st->print("%s frame (sp=" INTPTR_FORMAT " unextended sp=" INTPTR_FORMAT, print_name(), p2i(sp()), p2i(unextended_sp()));
518 if (sp() != nullptr)
519 st->print(", fp=" INTPTR_FORMAT ", real_fp=" INTPTR_FORMAT ", pc=" INTPTR_FORMAT,
559 #ifndef PRODUCT
560 assert(is_interpreted_frame(), "Not an interpreted frame");
561 jint i;
562 for (i = 0; i < interpreter_frame_method()->max_locals(); i++ ) {
563 intptr_t x = *interpreter_frame_local_at(i);
564 st->print(" - local [" INTPTR_FORMAT "]", x);
565 st->fill_to(23);
566 st->print_cr("; #%d", i);
567 }
568 for (i = interpreter_frame_expression_stack_size() - 1; i >= 0; --i ) {
569 intptr_t x = *interpreter_frame_expression_stack_at(i);
570 st->print(" - stack [" INTPTR_FORMAT "]", x);
571 st->fill_to(23);
572 st->print_cr("; #%d", i);
573 }
574 // locks for synchronization
575 for (BasicObjectLock* current = interpreter_frame_monitor_end();
576 current < interpreter_frame_monitor_begin();
577 current = next_monitor_in_interpreter_frame(current)) {
578 st->print(" - obj [%s", current->obj() == nullptr ? "null" : "");
579 oop obj = current->obj();
580 if (obj != nullptr) {
581 if (!is_heap_frame()) {
582 obj->print_value_on(st);
583 } else {
584 // Might be an invalid oop. We don't have the
585 // stackChunk to correct it so just print address.
586 st->print(INTPTR_FORMAT, p2i(obj));
587 }
588 }
589 st->print_cr("]");
590 st->print(" - lock [");
591 if (!is_heap_frame()) {
592 current->lock()->print_on(st, obj);
593 }
594 st->print_cr("]");
595 }
596 // monitor
597 st->print_cr(" - monitor[" INTPTR_FORMAT "]", p2i(interpreter_frame_monitor_begin()));
598 // bcp
599 st->print(" - bcp [" INTPTR_FORMAT "]", p2i(interpreter_frame_bcp()));
600 st->fill_to(23);
601 st->print_cr("; @%d", interpreter_frame_bci());
602 // locals
603 st->print_cr(" - locals [" INTPTR_FORMAT "]", p2i(interpreter_frame_local_at(0)));
604 // method
605 st->print(" - method [" INTPTR_FORMAT "]", p2i(interpreter_frame_method()));
606 st->fill_to(23);
607 st->print("; ");
608 interpreter_frame_method()->print_name(st);
609 st->cr();
610 #endif
611 }
612
613 // 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
1333 intptr_t* p = (intptr_t*)_fr->oopmapreg_to_location(reg, _reg_map);
1334 if (p != nullptr && (((intptr_t)p & WordAlignmentMask) == 0)) {
1335 const char* type_name = nullptr;
1336 switch(type) {
1337 case OopMapValue::oop_value: type_name = "oop"; break;
1338 case OopMapValue::narrowoop_value: type_name = "narrow oop"; break;
1339 case OopMapValue::callee_saved_value: type_name = "callee-saved"; break;
1340 case OopMapValue::derived_oop_value: type_name = "derived"; break;
1341 // case OopMapValue::live_value: type_name = "live"; break;
1342 default: break;
1343 }
1344 if (type_name != nullptr) {
1345 _values.describe(_frame_no, p, err_msg("%s for #%d", type_name, _frame_no));
1346 }
1347 }
1348 }
1349 };
1350
1351 // callers need a ResourceMark because of name_and_sig_as_C_string() usage,
1352 // RA allocated string is returned to the caller
1353 void frame::describe(FrameValues& values, int frame_no, const RegisterMap* reg_map, bool top) {
1354 // boundaries: sp and the 'real' frame pointer
1355 values.describe(-1, sp(), err_msg("sp for #%d", frame_no), 0);
1356 if (top) {
1357 values.describe(-1, sp() - 1, err_msg("sp[-1] for #%d", frame_no), 0);
1358 values.describe(-1, sp() - 2, err_msg("sp[-2] for #%d", frame_no), 0);
1359 }
1360
1361 intptr_t* frame_pointer = real_fp(); // Note: may differ from fp()
1362
1363 // print frame info at the highest boundary
1364 intptr_t* info_address = MAX2(sp(), frame_pointer);
1365
1366 if (info_address != frame_pointer) {
1367 // print frame_pointer explicitly if not marked by the frame info
1368 values.describe(-1, frame_pointer, err_msg("frame pointer for #%d", frame_no), 1);
1369 }
1370
1371 if (is_entry_frame() || is_compiled_frame() || is_interpreted_frame() || is_native_frame()) {
1372 // Label values common to most frames
1373 values.describe(-1, unextended_sp(), err_msg("unextended_sp for #%d", frame_no), 0);
1374 }
1375
1376 if (is_interpreted_frame()) {
1377 Method* m = interpreter_frame_method();
1378 int bci = interpreter_frame_bci();
1379 InterpreterCodelet* desc = Interpreter::codelet_containing(pc());
1380
1412 OopMapCache::compute_one_oop_map(methodHandle(Thread::current(), m), bci, &mask);
1413 intptr_t* tos = nullptr;
1414 // Report each stack element and mark as owned by this frame
1415 for (int e = 0; e < mask.expression_stack_size(); e++) {
1416 tos = MAX2(tos, interpreter_frame_expression_stack_at(e));
1417 values.describe(frame_no, interpreter_frame_expression_stack_at(e),
1418 err_msg("stack %d", e), 1);
1419 }
1420 if (tos != nullptr) {
1421 values.describe(-1, tos, err_msg("expression stack for #%d", frame_no), 2);
1422 }
1423
1424 if (reg_map != nullptr) {
1425 FrameValuesOopClosure oopsFn;
1426 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1427 oopsFn.describe(values, frame_no);
1428 }
1429 } else if (is_entry_frame()) {
1430 // For now just label the frame
1431 values.describe(-1, info_address, err_msg("#%d entry frame", frame_no), 2);
1432 } else if (is_compiled_frame()) {
1433 // For now just label the frame
1434 nmethod* nm = cb()->as_nmethod();
1435 values.describe(-1, info_address,
1436 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for method J %s%s", frame_no,
1437 p2i(nm),
1438 nm->method()->name_and_sig_as_C_string(),
1439 (_deopt_state == is_deoptimized) ?
1440 " (deoptimized)" :
1441 ((_deopt_state == unknown) ? " (state unknown)" : "")),
1442 3);
1443
1444 { // mark arguments (see nmethod::print_nmethod_labels)
1445 Method* m = nm->method();
1446
1447 int stack_slot_offset = nm->frame_size() * wordSize; // offset, in bytes, to caller sp
1448 int sizeargs = m->size_of_parameters();
1449
1450 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
1451 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
1452 {
1515 int scvs_length = scvs != nullptr ? scvs->length() : 0;
1516 for (int i = 0; i < scvs_length; i++) {
1517 intptr_t* stack_address = (intptr_t*)StackValue::stack_value_address(this, reg_map, scvs->at(i));
1518 if (stack_address != nullptr) {
1519 values.describe(frame_no, stack_address, err_msg("stack %d for #%d (scope %d)", i, frame_no, scope_no), 1);
1520 }
1521 }
1522 }
1523 }
1524
1525 FrameValuesOopClosure oopsFn;
1526 oops_do(&oopsFn, nullptr, &oopsFn, reg_map);
1527 oopsFn.describe(values, frame_no);
1528
1529 if (oop_map() != nullptr) {
1530 FrameValuesOopMapClosure valuesFn(this, reg_map, values, frame_no);
1531 // also OopMapValue::live_value ??
1532 oop_map()->all_type_do(this, OopMapValue::callee_saved_value, &valuesFn);
1533 }
1534 }
1535 } else if (is_native_frame()) {
1536 // For now just label the frame
1537 nmethod* nm = cb()->as_nmethod_or_null();
1538 values.describe(-1, info_address,
1539 FormatBuffer<1024>("#%d nmethod " INTPTR_FORMAT " for native method %s", frame_no,
1540 p2i(nm), nm->method()->name_and_sig_as_C_string()), 2);
1541 if (nm->method()->is_continuation_enter_intrinsic()) {
1542 ContinuationEntry* ce = Continuation::get_continuation_entry_for_entry_frame(reg_map->thread(), *this); // (ContinuationEntry*)unextended_sp();
1543 ce->describe(values, frame_no);
1544 }
1545 } else {
1546 // provide default info if not handled before
1547 char *info = (char *) "special frame";
1548 if ((_cb != nullptr) &&
1549 (_cb->name() != nullptr)) {
1550 info = (char *)_cb->name();
1551 }
1552 values.describe(-1, info_address, err_msg("#%d <%s>", frame_no, info), 2);
1553 }
1554
1555 // platform dependent additional data
1556 describe_pd(values, frame_no);
1557 }
1558
1559 #endif
1560
1561 #ifndef PRODUCT
1562
1563 void FrameValues::describe(int owner, intptr_t* location, const char* description, int priority) {
1564 FrameValue fv;
|