graal-jvmci-8: src/cpu/x86/vm/frame

comparison src/cpu/x86/vm/frame_x86.cpp @ 1204:18a389214829

6921352: JSR 292 needs its own deopt handler Summary: We need to introduce a new MH deopt handler so we can easily determine if the deopt happened at a MH call site or not. Reviewed-by: never, jrose

author	twisti
date	Mon, 01 Feb 2010 19:29:46 +0100
parents	24128c2ffa87
children	615a9d95d265 2338d41fbd81

comparison

equal deleted inserted replaced

-:844a9d73ec22
+:18a389214829
 /*
-* Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 1997-2010 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 tty->print_cr("patch_pc at address" INTPTR_FORMAT " [" INTPTR_FORMAT " -> " INTPTR_FORMAT "] ",
 &((address *)sp())[-1], ((address *)sp())[-1], pc);
 }
 ((address *)sp())[-1] = pc;
 _cb = CodeCache::find_blob(pc);
-if (_cb != NULL && _cb->is_nmethod() && ((nmethod*)_cb)->is_deopt_pc(_pc)) {
+address original_pc = nmethod::get_deopt_original_pc(this);
-address orig = (((nmethod*)_cb)->get_original_pc(this));
+if (original_pc != NULL) {
-assert(orig == _pc, "expected original to be stored before patching");
+assert(original_pc == _pc, "expected original PC to be stored before patching");
 _deopt_state = is_deoptimized;
 // leave _pc as is
 } else {
 _deopt_state = not_deoptimized;
 _pc = pc;
 }
 frame fr(jfa->last_Java_sp(), jfa->last_Java_fp());
 return fr;
 }
+//------------------------------------------------------------------------------
+// frame::verify_deopt_original_pc
+//
+// Verifies the calculated original PC of a deoptimization PC for the
+// given unextended SP.  The unextended SP might also be the saved SP
+// for MethodHandle call sites.
+#if ASSERT
+void frame::verify_deopt_original_pc(nmethod* nm, intptr_t* unextended_sp, bool is_method_handle_return) {
+frame fr;
+// This is ugly but it's better than to change {get,set}_original_pc
+// to take an SP value as argument.  And it's only a debugging
+// method anyway.
+fr._unextended_sp = unextended_sp;
+address original_pc = nm->get_original_pc(&fr);
+assert(nm->code_contains(original_pc), "original PC must be in nmethod");
+assert(nm->is_method_handle_return(original_pc) == is_method_handle_return, "must be");
+}
+#endif
+//------------------------------------------------------------------------------
+// frame::sender_for_interpreter_frame
 frame frame::sender_for_interpreter_frame(RegisterMap* map) const {
-// sp is the raw sp from the sender after adapter or interpreter extension
+// SP is the raw SP from the sender after adapter or interpreter
-intptr_t* sp = (intptr_t*) addr_at(sender_sp_offset);
+// extension.
+intptr_t* sender_sp = this->sender_sp();
 // This is the sp before any possible extension (adapter/locals).
 intptr_t* unextended_sp = interpreter_frame_sender_sp();
+// Stored FP.
+intptr_t* saved_fp = link();
 address sender_pc = this->sender_pc();
 CodeBlob* sender_cb = CodeCache::find_blob_unsafe(sender_pc);
 assert(sender_cb, "sanity");
 nmethod* sender_nm = sender_cb->as_nmethod_or_null();
-if (sender_nm != NULL && sender_nm->is_method_handle_return(sender_pc)) {
-unextended_sp = (intptr_t*) at(link_offset);
+if (sender_nm != NULL) {
+// If the sender PC is a deoptimization point, get the original
+// PC.  For MethodHandle call site the unextended_sp is stored in
+// saved_fp.
+if (sender_nm->is_deopt_mh_entry(sender_pc)) {
+DEBUG_ONLY(verify_deopt_mh_original_pc(sender_nm, saved_fp));
+unextended_sp = saved_fp;
+}
+else if (sender_nm->is_deopt_entry(sender_pc)) {
+DEBUG_ONLY(verify_deopt_original_pc(sender_nm, unextended_sp));
+}
+else if (sender_nm->is_method_handle_return(sender_pc)) {
+unextended_sp = saved_fp;
+}
 }
 // The interpreter and compiler(s) always save EBP/RBP in a known
 // location on entry. We must record where that location is
 // so this if EBP/RBP was live on callout from c2 we can find
 if (true) {
 map->set_location(rbp->as_VMReg()->next(), (address)addr_at(link_offset));
 }
 #endif // AMD64
 }
-#endif /* COMPILER2 */
+#endif // COMPILER2
-return frame(sp, unextended_sp, link(), sender_pc);
-}
+return frame(sender_sp, unextended_sp, saved_fp, sender_pc);
+}
-//------------------------------sender_for_compiled_frame-----------------------
+//------------------------------------------------------------------------------
+// frame::sender_for_compiled_frame
 frame frame::sender_for_compiled_frame(RegisterMap* map) const {
 assert(map != NULL, "map must be set");
-const bool c1_compiled = _cb->is_compiled_by_c1();
 // frame owned by optimizing compiler
-intptr_t* sender_sp = NULL;
 assert(_cb->frame_size() >= 0, "must have non-zero frame size");
-sender_sp = unextended_sp() + _cb->frame_size();
+intptr_t* sender_sp = unextended_sp() + _cb->frame_size();
+intptr_t* unextended_sp = sender_sp;
 // On Intel the return_address is always the word on the stack
 address sender_pc = (address) *(sender_sp-1);
-// This is the saved value of ebp which may or may not really be an fp.
+// This is the saved value of EBP which may or may not really be an FP.
-// it is only an fp if the sender is an interpreter frame (or c1?)
+// It is only an FP if the sender is an interpreter frame (or C1?).
+intptr_t* saved_fp = (intptr_t*) *(sender_sp - frame::sender_sp_offset);
-intptr_t *saved_fp = (intptr_t*)*(sender_sp - frame::sender_sp_offset);
+// If we are returning to a compiled MethodHandle call site, the
-intptr_t* unextended_sp = sender_sp;
+// saved_fp will in fact be a saved value of the unextended SP.  The
-// If we are returning to a compiled method handle call site,
+// simplest way to tell whether we are returning to such a call site
-// the saved_fp will in fact be a saved value of the unextended SP.
+// is as follows:
-// The simplest way to tell whether we are returning to such a call
-// site is as follows:
 CodeBlob* sender_cb = CodeCache::find_blob_unsafe(sender_pc);
 assert(sender_cb, "sanity");
 nmethod* sender_nm = sender_cb->as_nmethod_or_null();
-if (sender_nm != NULL && sender_nm->is_method_handle_return(sender_pc)) {
-unextended_sp = saved_fp;
+if (sender_nm != NULL) {
+// If the sender PC is a deoptimization point, get the original
+// PC.  For MethodHandle call site the unextended_sp is stored in
+// saved_fp.
+if (sender_nm->is_deopt_mh_entry(sender_pc)) {
+DEBUG_ONLY(verify_deopt_mh_original_pc(sender_nm, saved_fp));
+unextended_sp = saved_fp;
+}
+else if (sender_nm->is_deopt_entry(sender_pc)) {
+DEBUG_ONLY(verify_deopt_original_pc(sender_nm, unextended_sp));
+}
+else if (sender_nm->is_method_handle_return(sender_pc)) {
+unextended_sp = saved_fp;
+}
 }
 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);
 }
-// Since the prolog does the save and restore of epb there is no oopmap
+// Since the prolog does the save and restore of EBP there is no oopmap
 // for it so we must fill in its location as if there was an oopmap entry
 // since if our caller was compiled code there could be live jvm state in it.
 map->set_location(rbp->as_VMReg(), (address) (sender_sp - frame::sender_sp_offset));
 #ifdef AMD64
 // this is weird "H" ought to be at a higher address however the
 assert(sender_sp != sp(), "must have changed");
 return frame(sender_sp, unextended_sp, saved_fp, sender_pc);
 }
+//------------------------------------------------------------------------------
+// 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);

Mercurial > hg > graal-jvmci-8

comparison src/cpu/x86/vm/frame_x86.cpp @ 1204:18a389214829