kits/interface/LayoutItem.cpp

41 #include "runtime/frame.inline.hpp"
130 // the idealized value in the frame object. This undoes the magic conversion
132 // hardware would want to see in the native frame. The only user (at this point)
135 address frame::raw_pc() const {
147 // Change the pc in a frame object. This does not change the actual pc in
148 // actual frame. To do that use patch_pc.
150 void frame::set_pc(address   newpc ) {
165 bool frame::is_ignored_frame() const {
168 bool frame::is_deoptimized_frame() const {
173 bool frame::is_native_frame() const {
179 bool frame::is_java_frame() const {
186 bool frame::is_compiled_frame() const {
196 bool frame::is_runtime_frame() const {
200 bool frame::is_safepoint_blob_frame() const {
206 bool frame::is_first_java_frame() const {
208   frame s;
214 bool frame::entry_frame_is_first() const {
218 JavaCallWrapper* frame::entry_frame_call_wrapper_if_safe(JavaThread* thread) const {
230 bool frame::is_entry_frame_valid(JavaThread* thread) const {
231   // Validate the JavaCallWrapper an entry frame must have
238   // Validate sp saved in the java frame anchor
243 bool frame::should_be_deoptimized() const {
257   // If at the return point, then the frame has already been popped, and
262 bool frame::can_be_deoptimized() const {
272 void frame::deoptimize(JavaThread* thread) {
273   // Schedule deoptimization of an nmethod activation with this frame.
282     // we could see the frame again and ask for it to be deoptimized since
317       // in native mode) and then blocks. It is only this top most frame
319       // see if this frame is one that is at risk.
321       frame at_risk =  thread->last_frame().sender(&map);
345     frame check = thread->last_frame();
354 frame frame::java_sender() const {
356   frame s;
358   guarantee(s.is_java_frame(), "tried to get caller of first java frame");
362 frame frame::real_sender(RegisterMap* map) const {
363   frame result = sender(map);
372 frame frame::profile_find_Java_sender_frame(JavaThread *thread) {
373 // If we don't recognize this frame, walk back up the stack until we do
375   frame first_java_frame = frame();
377   // Find the first Java frame on the stack starting with input frame
379     // top frame is compiled frame or deoptimized frame
382     for (frame sender_frame = sender(&map);
397 void frame::interpreter_frame_set_locals(intptr_t* locs)  {
398   assert(is_interpreted_frame(), "Not an interpreted frame");
402 Method* frame::interpreter_frame_method() const {
403   assert(is_interpreted_frame(), "interpreted frame expected");
409 void frame::interpreter_frame_set_method(Method* method) {
410   assert(is_interpreted_frame(), "interpreted frame expected");
414 void frame::interpreter_frame_set_mirror(oop mirror) {
415   assert(is_interpreted_frame(), "interpreted frame expected");
419 jint frame::interpreter_frame_bci() const {
420   assert(is_interpreted_frame(), "interpreted frame expected");
425 address frame::interpreter_frame_bcp() const {
426   assert(is_interpreted_frame(), "interpreted frame expected");
431 void frame::interpreter_frame_set_bcp(address bcp) {
432   assert(is_interpreted_frame(), "interpreted frame expected");
436 address frame::interpreter_frame_mdp() const {
438   assert(is_interpreted_frame(), "interpreted frame expected");
442 void frame::interpreter_frame_set_mdp(address mdp) {
443   assert(is_interpreted_frame(), "interpreted frame expected");
448 BasicObjectLock* frame::next_monitor_in_interpreter_frame(BasicObjectLock* current) const {
449   assert(is_interpreted_frame(), "Not an interpreted frame");
457 BasicObjectLock* frame::previous_monitor_in_interpreter_frame(BasicObjectLock* current) const {
458   assert(is_interpreted_frame(), "Not an interpreted frame");
469 intptr_t* frame::interpreter_frame_local_at(int index) const {
474 intptr_t* frame::interpreter_frame_expression_stack_at(jint offset) const {
480 jint frame::interpreter_frame_expression_stack_size() const {
485   if (frame::interpreter_frame_expression_stack_direction() < 0) {
497 // (frame::interpreter_frame_sender_sp accessor is in frame_<arch>.cpp)
499 const char* frame::print_name() const {
510 void frame::print_value_on(outputStream* st, JavaThread *thread) const {
514   st->print("%s frame (sp=" INTPTR_FORMAT " unextended sp=" INTPTR_FORMAT, print_name(), p2i(sp()), p2i(unextended_sp()));
554 void frame::print_on(outputStream* st) const {
562 void frame::interpreter_frame_print_on(outputStream* st) const {
564   assert(is_interpreted_frame(), "Not an interpreted frame");
606 // Print whether the frame is in the VM or OS indicating a HotSpot problem.
609 void frame::print_C_frame(outputStream* st, char* buf, int buflen, address pc) {
610   // C/C++ frame
643 // frame::print_on_error() is called by fatal error handler. Notice that we may
644 // crash inside this function if stack frame is corrupted. The fatal error
645 // handler can catch and handle the crash. Here we assume the frame is valid.
647 // First letter indicates type of the frame:
648 //    J: Java frame (compiled)
649 //    A: Java frame (aot compiled)
650 //    j: Java frame (interpreted)
651 //    V: VM frame (C/C++)
653 //    C: C/C++ frame
655 // We don't need detailed frame type as that in frame::print_name(). "C"
658 void frame::print_on_error(outputStream* st, char* buf, int buflen, bool verbose) const {
744   Method* value saved on the frame is changed by reverse_and_push and hence cannot
750   frame* _fr;
756   InterpreterFrameClosure(frame* fr, int max_locals, int max_stack,
768       assert((intptr_t*)addr >= _fr->sp(), "must be inside the frame");
775       if (frame::interpreter_frame_expression_stack_direction() > 0) {
787   frame* fr()       { return _fr; }
796   frame* _fr;
810   InterpretedArgumentOopFinder(Symbol* signature, bool has_receiver, frame* fr, OopClosure* f) : SignatureInfo(signature), _has_receiver(has_receiver) {
832 // Entry frame has following form (n arguments)
843 // visits and GC's all the arguments in entry frame
848   frame* _fr;
864    EntryFrameOopFinder(frame* frame, Symbol* signature, bool is_static) : SignatureInfo(signature) {
866      _fr = frame;
879 oop* frame::interpreter_callee_receiver_addr(Symbol* signature) {
886 void frame::oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache) {
887   assert(is_interpreted_frame(), "Not an interpreted frame");
895   assert(m->is_method(), "checking frame value");
916   // The method pointer in the frame might be the only path to the method's
930   // interpreted or compiled frame.
967 void frame::oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f) {
972 void frame::oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* reg_map) {
998   frame           _fr;
1017   CompiledArgumentOopFinder(Symbol* signature, bool has_receiver, bool has_appendix, OopClosure* f, frame fr,  const RegisterMap* reg_map)
1047 void frame::oops_compiled_arguments_do(Symbol* signature, bool has_receiver, bool has_appendix,
1055 // Get receiver out of callers frame, i.e. find parameter 0 in callers
1056 // frame.  Consult ADLC for where parameter 0 is to be found.  Then
1058 // register, both of which are saved in the local frame.  If not found
1061 oop frame::retrieve_receiver(RegisterMap* reg_map) {
1062   frame caller = *this;
1077 BasicLock* frame::get_native_monitor() {
1086 oop frame::get_native_receiver() {
1097 void frame::oops_entry_do(OopClosure* f, const RegisterMap* map) {
1106   // Traverse the Handle Block saved in the entry frame
1111 void frame::oops_do_internal(OopClosure* f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache) {
1134 void frame::nmethods_do(CodeBlobClosure* cf) {
1143 void frame::metadata_do(void f(Metadata*)) {
1146     assert(m != NULL, "expecting a method in this frame");
1151 void frame::verify(const RegisterMap* map) {
1155     guarantee(method->is_method(), "method is wrong in frame::verify");
1170 bool frame::verify_return_pc(address x) {
1185 void frame::interpreter_frame_verify_monitor(BasicObjectLock* value) const {
1186   assert(is_interpreted_frame(), "Not an interpreted frame");
1187   // verify that the value is in the right part of the frame
1192   const int monitor_size = frame::interpreter_frame_monitor_size();
1202 void frame::describe(FrameValues& values, int frame_no) {
1203   // boundaries: sp and the 'real' frame pointer
1207   // print frame info at the highest boundary
1211     // print frame_pointer explicitly if not marked by the frame info
1212     values.describe(-1, frame_pointer, err_msg("frame pointer for #%d", frame_no), 1);
1233       // Report each local and mark as owned by this frame
1244     // Report each stack element and mark as owned by this frame
1258     // For now just label the frame
1259     values.describe(-1, info_address, err_msg("#%d entry frame", frame_no), 2);
1261     // For now just label the frame
1273     // For now just label the frame
1280     char *info = (char *) "special frame";