jdk-sandbox: comparison hotspot/src/share/vm/runtime/frame.cpp

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 #include "interpreter/interpreter.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/markOop.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.inline2.hpp"
 #include "prims/methodHandles.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/handles.inline.hpp"
 void frame::interpreter_frame_set_locals(intptr_t* locs)  {
 assert(is_interpreted_frame(), "Not an interpreted frame");
 *interpreter_frame_locals_addr() = locs;
 }
-methodOop frame::interpreter_frame_method() const {
+Method* frame::interpreter_frame_method() const {
 assert(is_interpreted_frame(), "interpreted frame expected");
-methodOop m = *interpreter_frame_method_addr();
+Method* m = *interpreter_frame_method_addr();
-assert(m->is_perm(), "bad methodOop in interpreter frame");
+assert(m->is_metadata(), "bad Method* in interpreter frame");
-assert(m->is_method(), "not a methodOop");
+assert(m->is_method(), "not a Method*");
 return m;
 }
-void frame::interpreter_frame_set_method(methodOop method) {
+void frame::interpreter_frame_set_method(Method* method) {
 assert(is_interpreted_frame(), "interpreted frame expected");
 *interpreter_frame_method_addr() = method;
 }
 void frame::interpreter_frame_set_bcx(intptr_t bcx) {
 if (mdx != 0) {
 if (formerly_bci) {
 if (!is_now_bci) {
 // The bcx was just converted from bci to bcp.
 // Convert the mdx in parallel.
-methodDataOop mdo = interpreter_frame_method()->method_data();
+MethodData* mdo = interpreter_frame_method()->method_data();
 assert(mdo != NULL, "");
 int mdi = mdx - 1; // We distinguish valid mdi from zero by adding one.
 address mdp = mdo->di_to_dp(mdi);
 interpreter_frame_set_mdx((intptr_t)mdp);
 }
 } else {
 if (is_now_bci) {
 // The bcx was just converted from bcp to bci.
 // Convert the mdx in parallel.
-methodDataOop mdo = interpreter_frame_method()->method_data();
+MethodData* mdo = interpreter_frame_method()->method_data();
 assert(mdo != NULL, "");
 int mdi = mdo->dp_to_di((address)mdx);
 interpreter_frame_set_mdx((intptr_t)mdi + 1); // distinguish valid from 0.
 }
 }
 // suggests the problem is in user lib; everything else is likely a VM bug.
 void frame::print_on_error(outputStream* st, char* buf, int buflen, bool verbose) const {
 if (_cb != NULL) {
 if (Interpreter::contains(pc())) {
-methodOop m = this->interpreter_frame_method();
+Method* m = this->interpreter_frame_method();
 if (m != NULL) {
 m->name_and_sig_as_C_string(buf, buflen);
 st->print("j  %s", buf);
 st->print("+%d", this->interpreter_frame_bci());
 } else {
 st->print("v  ~StubRoutines::" PTR_FORMAT, pc());
 }
 } else if (_cb->is_buffer_blob()) {
 st->print("v  ~BufferBlob::%s", ((BufferBlob *)_cb)->name());
 } else if (_cb->is_nmethod()) {
-methodOop m = ((nmethod *)_cb)->method();
+Method* m = ((nmethod *)_cb)->method();
 if (m != NULL) {
 m->name_and_sig_as_C_string(buf, buflen);
 st->print("J  %s", buf);
 } else {
 st->print("J  " PTR_FORMAT, pc());
 /*
 The interpreter_frame_expression_stack_at method in the case of SPARC needs the
 max_stack value of the method in order to compute the expression stack address.
-It uses the methodOop in order to get the max_stack value but during GC this
+It uses the Method* in order to get the max_stack value but during GC this
-methodOop value saved on the frame is changed by reverse_and_push and hence cannot
+Method* value saved on the frame is changed by reverse_and_push and hence cannot
 be used. So we save the max_stack value in the FrameClosure object and pass it
 down to the interpreter_frame_expression_stack_at method
 */
 class InterpreterFrameClosure : public OffsetClosure {
 private:
 assert(map != NULL, "map must be set");
 Thread *thread = Thread::current();
 methodHandle m (thread, interpreter_frame_method());
 jint      bci = interpreter_frame_bci();
-assert(Universe::heap()->is_in(m()), "must be valid oop");
+assert(!Universe::heap()->is_in(m()),
+"must be valid oop");
 assert(m->is_method(), "checking frame value");
-assert((m->is_native() && bci == 0)  || (!m->is_native() && bci >= 0 && bci < m->code_size()), "invalid bci value");
+assert((m->is_native() && bci == 0)  ||
+(!m->is_native() && bci >= 0 && bci < m->code_size()),
+"invalid bci value");
 // Handle the monitor elements in the activation
 for (
 BasicObjectLock* current = interpreter_frame_monitor_end();
 current < interpreter_frame_monitor_begin();
 #endif
 current->oops_do(f);
 }
 // process fixed part
-f->do_oop((oop*)interpreter_frame_method_addr());
-f->do_oop((oop*)interpreter_frame_cache_addr());
-// Hmm what about the mdp?
-#ifdef CC_INTERP
-// Interpreter frame in the midst of a call have a methodOop within the
-// object.
-interpreterState istate = get_interpreterState();
-if (istate->msg() == BytecodeInterpreter::call_method) {
-f->do_oop((oop*)&istate->_result._to_call._callee);
-}
-#endif /* CC_INTERP */
 #if !defined(PPC) || defined(ZERO)
 if (m->is_native()) {
 #ifdef CC_INTERP
+interpreterState istate = get_interpreterState();
 f->do_oop((oop*)&istate->_oop_temp);
 #else
 f->do_oop((oop*)( fp() + interpreter_frame_oop_temp_offset ));
 #endif /* CC_INTERP */
 }
 cf->do_code_blob(_cb);
 }
 }
+// call f() on the interpreted Method*s in the stack.
+// Have to walk the entire code cache for the compiled frames Yuck.
+void frame::metadata_do(void f(Metadata*)) {
+if (_cb != NULL && Interpreter::contains(pc())) {
+Method* m = this->interpreter_frame_method();
+assert(m != NULL, "huh?");
+f(m);
+}
+}
 void frame::gc_prologue() {
 if (is_interpreted_frame()) {
-// set bcx to bci to become methodOop position independent during GC
+// set bcx to bci to become Method* position independent during GC
 interpreter_frame_set_bcx(interpreter_frame_bci());
 }
 }
 void frame::zap_dead_interpreted_locals(JavaThread *thread, const RegisterMap* map) {
 // get current interpreter 'pc'
 assert(is_interpreted_frame(), "Not an interpreted frame");
-methodOop m   = interpreter_frame_method();
+Method* m   = interpreter_frame_method();
 int       bci = interpreter_frame_bci();
 int max_locals = m->is_native() ? m->size_of_parameters() : m->max_locals();
 // process dynamic part
 # endif // ENABLE_ZAP_DEAD_LOCALS
 void frame::verify(const RegisterMap* map) {
 // for now make sure receiver type is correct
 if (is_interpreted_frame()) {
-methodOop method = interpreter_frame_method();
+Method* method = interpreter_frame_method();
 guarantee(method->is_method(), "method is wrong in frame::verify");
 if (!method->is_static()) {
 // fetch the receiver
 oop* p = (oop*) interpreter_frame_local_at(0);
 // make sure we have the right receiver type
 // Label values common to most frames
 values.describe(-1, unextended_sp(), err_msg("unextended_sp for #%d", frame_no));
 }
 if (is_interpreted_frame()) {
-methodOop m = interpreter_frame_method();
+Method* m = interpreter_frame_method();
 int bci = interpreter_frame_bci();
 // Label the method and current bci
 values.describe(-1, info_address,
 FormatBuffer<1024>("#%d method %s @ %d", frame_no, m->name_and_sig_as_C_string(), bci), 2);

changeset 13728	882756847a04
parent 13391	30245956af37
child 14626	0cf4eccf130f
child 14582	490bb6c0df7c