frame frame::sender(RegisterMap* map) const {
// Default is not to follow arguments; the various
// sender_for_xxx methods update this accordingly.
map->set_include_argument_oops(false);
if (is_entry_frame())
return sender_for_entry_frame(map);
else
return sender_for_nonentry_frame(map);
}
frame frame::sender(RegisterMap* map) const {
assert(map != NULL, "map must be set");
assert(CodeCache::find_blob_unsafe(_pc) == _cb, "inconsistent");
// Default is not to follow arguments; update it accordingly below
map->set_include_argument_oops(false);
if (is_entry_frame()) return sender_for_entry_frame(map);
intptr_t* younger_sp = sp();
intptr_t* sp = sender_sp();
// Note: The version of this operation on any platform with callee-save
// registers must update the register map (if not null).
// In order to do this correctly, the various subtypes of
// of frame (interpreted, compiled, glue, native),
// must be distinguished. There is no need on SPARC for
// such distinctions, because all callee-save registers are
// preserved for all frames via SPARC-specific mechanisms.
//
// *** HOWEVER, *** if and when we make any floating-point
// registers callee-saved, then we will have to copy over
// the RegisterMap update logic from the Intel code.
// The constructor of the sender must know whether this frame is interpreted so it can set the
// sender's _sp_adjustment_by_callee field. An osr adapter frame was originally
// interpreted but its pc is in the code cache (for c1 -> osr_frame_return_id stub), so it must be
// explicitly recognized.
if (is_ricochet_frame()) return sender_for_ricochet_frame(map);
bool frame_is_interpreted = is_interpreted_frame();
if (frame_is_interpreted) {
map->make_integer_regs_unsaved();
map->shift_window(sp, younger_sp);
} else if (_cb != NULL) {
// Update the locations of implicitly saved registers to be their
// addresses in the register save area.
// For %o registers, the addresses of %i registers in the next younger
// frame are used.
map->shift_window(sp, younger_sp);
if (map->update_map()) {
// Tell GC to use argument oopmaps for some runtime stubs that need it.
// For C1, the runtime stub might not have oop maps, so set this flag
// outside of update_register_map.
map->set_include_argument_oops(_cb->caller_must_gc_arguments(map->thread()));
if (_cb->oop_maps() != NULL) {
OopMapSet::update_register_map(this, map);
}
}
}
return frame(sp, younger_sp, frame_is_interpreted);
}
//------------------------------------------------------------------------------
// frame::sender
frame frame::sender(RegisterMap* map) const {
// Default is we done have to follow them. The sender_for_xxx will
// update it accordingly
map->set_include_argument_oops(false);
if (is_entry_frame()) return sender_for_entry_frame(map);
if (is_interpreted_frame()) return sender_for_interpreter_frame(map);
assert(_cb == CodeCache::find_blob(pc()),"Must be the same");
if (_cb != NULL) {
return sender_for_compiled_frame(map);
}
// Must be native-compiled frame, i.e. the marshaling code for native
// methods that exists in the core system.
return frame(sender_sp(), link(), sender_pc());
}
