drlvm/modules/vm/src/main/native/interpreter/shared/interp_stack_trace.cpp - harmony - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 #include "interpreter.h"

 #include "open/vm_method_access.h"
 #include "interp_native.h"
 #include "interp_defs.h"
 #include "stack_trace.h"
 #include "exceptions.h"
 #include "jvmti_support.h"
 #include "vtable.h"
 #include "jit_import_rt.h"

 typedef struct StackFrame StackIterator_interp;

 static inline StackIterator_interp*
 interp_si_create_from_native() {
     return getLastStackFrame();
 }

 static inline StackIterator_interp*
 interp_si_create_from_native(VM_thread *thread) {
     return getLastStackFrame(thread);
 }

 static inline bool
 interp_si_is_past_end(StackIterator_interp* si) {
     return si == 0;
 }

 static inline Method_Handle
 interp_si_get_method(StackIterator_interp* si) {
     return (Method_Handle) si->method;
 }

 static inline NativeCodePtr
 interp_si_get_ip(StackIterator_interp* si) {
     return si->ip;
 }

 static inline Boolean
 interp_si_method_is_native(Method_Handle m) {
     assert(m);
     Method *meth = (Method *)m;
     return meth->is_native();
 }

 static inline Class_Handle
 interp_si_method_get_class(Method_Handle m) {
     assert(m);
     return ((Method *)m)->get_class();
 }

 static inline void
 interp_si_free(StackIterator_interp* UNREF si) {
     // nothing to be done!
 }

 /** Note: Tricky construction, to preserve visual compatibility */
 static inline void
 interp_si_goto_previous(StackIterator_interp* &si) {
     si = si->prev;
 }


 /*extern*/ bool
 interpreter_st_get_frame(unsigned target_depth, StackTraceFrame* stf) {
     // st_get_frame

     StackIterator_interp* si = interp_si_create_from_native();
     unsigned depth = 0;
     while (!interp_si_is_past_end(si)) {
         stf->method = interp_si_get_method(si);
         if (stf->method) {
             if (depth==target_depth) {
                 stf->ip = interp_si_get_ip(si);
                 interp_si_free(si);
                 return true;
             }
             depth++;
         }
         interp_si_goto_previous(si);
     }
     interp_si_free(si);
     return false;
 }

 static inline unsigned
 interp_st_get_depth(VM_thread *p_thread) {
     StackIterator_interp* si = interp_si_create_from_native(p_thread);
     unsigned depth = 0;
     while (!interp_si_is_past_end(si)) {
         if (interp_si_get_method(si))
             depth++;
         interp_si_goto_previous(si);
     }
     interp_si_free(si);
     return depth;
 }

 unsigned
 interpreter_st_get_interrupted_method_native_bit(VM_thread *thread) {
     StackIterator_interp* si = interp_si_create_from_native(thread);
     if (interp_si_is_past_end(si)) {
         return 0;
     }
     Method * method = (Method *)interp_si_get_method(si);
     return method -> is_native();
  }

 void
 interpreter_st_get_trace(VM_thread *p_vmthread, unsigned* res_depth, StackTraceFrame** stfs) {
     unsigned depth = interp_st_get_depth(p_vmthread);
     StackTraceFrame* stf = st_alloc_frames(depth);
     assert(stf);
     *res_depth = depth;
     *stfs = stf;
     StackIterator_interp* si = interp_si_create_from_native(p_vmthread);
     depth = 0;
     while (!interp_si_is_past_end(si)) {
         Method_Handle method = interp_si_get_method(si);
         if (method) {
             stf->method = method;
             stf->ip = interp_si_get_ip(si);
             stf->depth = -1;
             stf->outdated_this = si->This;
             assert(stf->outdated_this || method->is_static());
             stf++;
             depth++;
         }
         interp_si_goto_previous(si);
     }
     assert(depth==*res_depth);
     interp_si_free(si);
 }


 #if defined(REF32) // Compressed references; cref is COMPRESSED_REFERENCE
 #define vm_enumerate(cref,f) vm_enumerate_compressed_root_reference(cref,f)
 #else // Uncompressed or runtime switchable; ref us uncompressed
 static inline void** m2v(REF* obj) {
     return (void**)obj;
 }
 #define vm_enumerate(ref,f) vm_enumerate_root_reference(m2v(ref),f)
 #endif

 void
 interp_enumerate_root_set_single_thread_on_stack(VM_thread *thread) {
     TRACE2("enumeration", "interp_enumerate_root_set_single_thread_on_stack()");
     StackIterator_interp* si;
     si = interp_si_create_from_native(thread);

     int i;
     DEBUG_GC("\n\nGC enumeration in interpreter stack:\n");
     while(!interp_si_is_past_end(si)) {
         Method* method = (Method*)interp_si_get_method(si);
         method = method;

         if (si->This) {
             vm_enumerate_root_reference((void**)&si->This, FALSE);
             DEBUG_GC("  [THIS]: " << si->This);
         }

         if (si->exc) {
             vm_enumerate_root_reference((void**)&si->exc, FALSE);
             DEBUG_GC("  [EXCEPTION]: " << si->exc);
         }

         if (method->is_native()) {
             DEBUG_GC("[METHOD <native>]: " << method);
             interp_si_goto_previous(si);
             continue;
         }

         DEBUG_GC("[METHOD "<< si->stack.size << " " << (int)si->locals.varNum << "]: "
                 << method);

         if (si->stack.size)
             for(i = 0; i <= si->stack.index; i++) {
                 if (si->stack.refs[i] == FLAG_OBJECT) {
                     DEBUG_GC("  Stack[" << i << "] ");
                     REF* ref = &si->stack.data[i].ref;
                     ManagedObject *obj = UNCOMPRESS_INTERP(*ref);
                     if (obj == 0) {
                         DEBUG_GC("NULL");
                     } else {
                         DEBUG_GC(obj);
                         vm_enumerate(ref, FALSE); // CHECK!!! can we enumerate uncompressed ref in compressed mode
                     }
                 }
             }

                 unsigned j;
         if (si->locals.varNum)
             for(j = 0; j < si->locals.varNum; j++) {
                 if (si->locals.refs[j] == FLAG_OBJECT) {
                     DEBUG_GC("  Locals[" << j << "] ");
                     REF* ref = &si->locals.vars[j].ref;
                     ManagedObject *obj = UNCOMPRESS_INTERP(*ref);
                     if (obj == 0) {
                         DEBUG_GC("NULL\n");
                     } else {
                         DEBUG_GC(obj);
                         vm_enumerate(ref, FALSE); // CHECK!!! can we enumerate uncompressed ref in compressed mode
                     }
                 }
             }
         MonitorList *ml = si->locked_monitors;
         while(ml) {
             vm_enumerate_root_reference((void**)&ml->monitor, FALSE);
             ml = ml->next;
         }
         interp_si_goto_previous(si);
     }

     // enumerate m2n frames
     M2nFrame *m2n = m2n_get_last_frame(thread);
     while(m2n) {
         oh_enumerate_handles(m2n_get_local_handles(m2n));
         m2n = m2n_get_previous_frame(m2n);
     }
 }

 /* extern*/void
 interpreter_enumerate_thread(VM_thread *thread)
 {
     interp_enumerate_root_set_single_thread_on_stack(thread);

     // Enumerate references associated with a thread that are not stored on the thread's stack.
     vm_enumerate_root_set_single_thread_not_on_stack(thread);
 } //vm_enumerate_thread

 void
 interp_ti_enumerate_root_set_single_thread_on_stack(jvmtiEnv* ti_env, VM_thread *thread) {
     TRACE2("enumeration", "interp_enumerate_root_set_single_thread_on_stack()");
     StackIterator_interp* si;
     si = interp_si_create_from_native(thread);

     int i;
     int depth;
     DEBUG_GC("\n\nGC enumeration in interpreter stack:\n");
     for (depth = 0; !interp_si_is_past_end(si); depth++) {
         Method* method = (Method*)interp_si_get_method(si);
         jmethodID method_id = (jmethodID)method;
         int slot = 0;

         if (si->This) {
             vm_ti_enumerate_stack_root(ti_env,
                     (void**)&si->This, si->This,
                     JVMTI_HEAP_ROOT_STACK_LOCAL,
                     depth, method_id, slot++);
             DEBUG_GC("  [THIS]: " << si->This);
         }

         if (si->exc) {
             vm_ti_enumerate_stack_root(ti_env,
                 (void**)&si->exc, si->exc,
                 JVMTI_HEAP_ROOT_STACK_LOCAL,
                 depth, method_id, slot++);
             DEBUG_GC("  [EXCEPTION]: " << si->exc);
         }

         if (method->is_native()) {
             DEBUG_GC("[METHOD <native>]: " << method);
             interp_si_goto_previous(si);
             continue;
         }

         DEBUG_GC("[METHOD "<< si->stack.size << " " << (int)si->locals.varNum << "]: "
                 << method);

         if (si->stack.size)
             for(i = 0; i <= si->stack.index; i++) {
                 if (si->stack.refs[i] == FLAG_OBJECT) {
                     DEBUG_GC("  Stack[" << i << "] ");
                     REF* ref = &si->stack.data[i].ref;
                     ManagedObject *obj = UNCOMPRESS_INTERP(*ref);
                     if (obj == 0) {
                         DEBUG_GC("NULL");
                     } else {
                         DEBUG_GC(obj);
                         vm_ti_enumerate_stack_root(ti_env,
                             ref, (Managed_Object_Handle)obj,
                             JVMTI_HEAP_ROOT_STACK_LOCAL,
                             depth, method_id, slot++);
                     }
                 }
             }

                 unsigned j;
         if (si->locals.varNum)
             for(j = 0; j < si->locals.varNum; j++) {
                 if (si->locals.refs[j] == FLAG_OBJECT) {
                     DEBUG_GC("  Locals[" << j << "] ");
                     REF* ref = &si->locals.vars[j].ref;
                     ManagedObject *obj = UNCOMPRESS_INTERP(*ref);
                     if (obj == 0) {
                         DEBUG_GC("NULL\n");
                     } else {
                         DEBUG_GC(obj);
                         vm_ti_enumerate_stack_root(ti_env,
                             ref, (Managed_Object_Handle)obj,
                             JVMTI_HEAP_ROOT_STACK_LOCAL,
                             depth, method_id, slot++);
                     }
                 }
             }
         MonitorList *ml = si->locked_monitors;
         while(ml) {
             vm_ti_enumerate_stack_root(ti_env,
                     &ml->monitor, ml->monitor,
                     JVMTI_HEAP_ROOT_MONITOR,
                     depth, method_id, slot++);
             ml = ml->next;
         }
         interp_si_goto_previous(si);
     }

     // enumerate m2n frames
     M2nFrame *m2n = m2n_get_last_frame(thread);
     while(m2n) {
         oh_enumerate_handles(m2n_get_local_handles(m2n));
         m2n = m2n_get_previous_frame(m2n);
     }
 }

 void interpreter_ti_enumerate_thread(jvmtiEnv *ti_env, VM_thread *thread)
 {
     interp_ti_enumerate_root_set_single_thread_on_stack(ti_env, thread);

     // Enumerate references associated with a thread that are not stored on the thread's stack.
     vm_enumerate_root_set_single_thread_not_on_stack(thread);
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#include "interpreter.h"

	#include "open/vm_method_access.h"
	#include "interp_native.h"
	#include "interp_defs.h"
	#include "stack_trace.h"
	#include "exceptions.h"
	#include "jvmti_support.h"
	#include "vtable.h"
	#include "jit_import_rt.h"

	typedef struct StackFrame StackIterator_interp;

	static inline StackIterator_interp*
	interp_si_create_from_native() {
	return getLastStackFrame();
	}

	static inline StackIterator_interp*
	interp_si_create_from_native(VM_thread *thread) {
	return getLastStackFrame(thread);
	}

	static inline bool
	interp_si_is_past_end(StackIterator_interp* si) {
	return si == 0;
	}

	static inline Method_Handle
	interp_si_get_method(StackIterator_interp* si) {
	return (Method_Handle) si->method;
	}

	static inline NativeCodePtr
	interp_si_get_ip(StackIterator_interp* si) {
	return si->ip;
	}

	static inline Boolean
	interp_si_method_is_native(Method_Handle m) {
	assert(m);
	Method meth = (Method )m;
	return meth->is_native();
	}

	static inline Class_Handle
	interp_si_method_get_class(Method_Handle m) {
	assert(m);
	return ((Method *)m)->get_class();
	}

	static inline void
	interp_si_free(StackIterator_interp* UNREF si) {
	// nothing to be done!
	}

	/** Note: Tricky construction, to preserve visual compatibility */
	static inline void
	interp_si_goto_previous(StackIterator_interp* &si) {
	si = si->prev;
	}


	/extern/ bool
	interpreter_st_get_frame(unsigned target_depth, StackTraceFrame* stf) {
	// st_get_frame

	StackIterator_interp* si = interp_si_create_from_native();
	unsigned depth = 0;
	while (!interp_si_is_past_end(si)) {
	stf->method = interp_si_get_method(si);
	if (stf->method) {
	if (depth==target_depth) {
	stf->ip = interp_si_get_ip(si);
	interp_si_free(si);
	return true;
	}
	depth++;
	}
	interp_si_goto_previous(si);
	}
	interp_si_free(si);
	return false;
	}

	static inline unsigned
	interp_st_get_depth(VM_thread *p_thread) {
	StackIterator_interp* si = interp_si_create_from_native(p_thread);
	unsigned depth = 0;
	while (!interp_si_is_past_end(si)) {
	if (interp_si_get_method(si))
	depth++;
	interp_si_goto_previous(si);
	}
	interp_si_free(si);
	return depth;
	}

	unsigned
	interpreter_st_get_interrupted_method_native_bit(VM_thread *thread) {
	StackIterator_interp* si = interp_si_create_from_native(thread);
	if (interp_si_is_past_end(si)) {
	return 0;
	}
	Method * method = (Method *)interp_si_get_method(si);
	return method -> is_native();
	}

	void
	interpreter_st_get_trace(VM_thread p_vmthread, unsigned res_depth, StackTraceFrame** stfs) {
	unsigned depth = interp_st_get_depth(p_vmthread);
	StackTraceFrame* stf = st_alloc_frames(depth);
	assert(stf);
	*res_depth = depth;
	*stfs = stf;
	StackIterator_interp* si = interp_si_create_from_native(p_vmthread);
	depth = 0;
	while (!interp_si_is_past_end(si)) {
	Method_Handle method = interp_si_get_method(si);
	if (method) {
	stf->method = method;
	stf->ip = interp_si_get_ip(si);
	stf->depth = -1;
	stf->outdated_this = si->This;
	assert(stf->outdated_this \|\| method->is_static());
	stf++;
	depth++;
	}
	interp_si_goto_previous(si);
	}
	assert(depth==*res_depth);
	interp_si_free(si);
	}


	#if defined(REF32) // Compressed references; cref is COMPRESSED_REFERENCE
	#define vm_enumerate(cref,f) vm_enumerate_compressed_root_reference(cref,f)
	#else // Uncompressed or runtime switchable; ref us uncompressed
	static inline void** m2v(REF* obj) {
	return (void**)obj;
	}
	#define vm_enumerate(ref,f) vm_enumerate_root_reference(m2v(ref),f)
	#endif

	void
	interp_enumerate_root_set_single_thread_on_stack(VM_thread *thread) {
	TRACE2("enumeration", "interp_enumerate_root_set_single_thread_on_stack()");
	StackIterator_interp* si;
	si = interp_si_create_from_native(thread);

	int i;
	DEBUG_GC("\n\nGC enumeration in interpreter stack:\n");
	while(!interp_si_is_past_end(si)) {
	Method* method = (Method*)interp_si_get_method(si);
	method = method;

	if (si->This) {
	vm_enumerate_root_reference((void**)&si->This, FALSE);
	DEBUG_GC(" [THIS]: " << si->This);
	}

	if (si->exc) {
	vm_enumerate_root_reference((void**)&si->exc, FALSE);
	DEBUG_GC(" [EXCEPTION]: " << si->exc);
	}

	if (method->is_native()) {
	DEBUG_GC("[METHOD <native>]: " << method);
	interp_si_goto_previous(si);
	continue;
	}

	DEBUG_GC("[METHOD "<< si->stack.size << " " << (int)si->locals.varNum << "]: "
	<< method);

	if (si->stack.size)
	for(i = 0; i <= si->stack.index; i++) {
	if (si->stack.refs[i] == FLAG_OBJECT) {
	DEBUG_GC(" Stack[" << i << "] ");
	REF* ref = &si->stack.data[i].ref;
	ManagedObject obj = UNCOMPRESS_INTERP(ref);
	if (obj == 0) {
	DEBUG_GC("NULL");
	} else {
	DEBUG_GC(obj);
	vm_enumerate(ref, FALSE); // CHECK!!! can we enumerate uncompressed ref in compressed mode
	}
	}
	}

	unsigned j;
	if (si->locals.varNum)
	for(j = 0; j < si->locals.varNum; j++) {
	if (si->locals.refs[j] == FLAG_OBJECT) {
	DEBUG_GC(" Locals[" << j << "] ");
	REF* ref = &si->locals.vars[j].ref;
	ManagedObject obj = UNCOMPRESS_INTERP(ref);
	if (obj == 0) {
	DEBUG_GC("NULL\n");
	} else {
	DEBUG_GC(obj);
	vm_enumerate(ref, FALSE); // CHECK!!! can we enumerate uncompressed ref in compressed mode
	}
	}
	}
	MonitorList *ml = si->locked_monitors;
	while(ml) {
	vm_enumerate_root_reference((void**)&ml->monitor, FALSE);
	ml = ml->next;
	}
	interp_si_goto_previous(si);
	}

	// enumerate m2n frames
	M2nFrame *m2n = m2n_get_last_frame(thread);
	while(m2n) {
	oh_enumerate_handles(m2n_get_local_handles(m2n));
	m2n = m2n_get_previous_frame(m2n);
	}
	}

	/* extern*/void
	interpreter_enumerate_thread(VM_thread *thread)
	{
	interp_enumerate_root_set_single_thread_on_stack(thread);

	// Enumerate references associated with a thread that are not stored on the thread's stack.
	vm_enumerate_root_set_single_thread_not_on_stack(thread);
	} //vm_enumerate_thread

	void
	interp_ti_enumerate_root_set_single_thread_on_stack(jvmtiEnv* ti_env, VM_thread *thread) {
	TRACE2("enumeration", "interp_enumerate_root_set_single_thread_on_stack()");
	StackIterator_interp* si;
	si = interp_si_create_from_native(thread);

	int i;
	int depth;
	DEBUG_GC("\n\nGC enumeration in interpreter stack:\n");
	for (depth = 0; !interp_si_is_past_end(si); depth++) {
	Method* method = (Method*)interp_si_get_method(si);
	jmethodID method_id = (jmethodID)method;
	int slot = 0;

	if (si->This) {
	vm_ti_enumerate_stack_root(ti_env,
	(void**)&si->This, si->This,
	JVMTI_HEAP_ROOT_STACK_LOCAL,
	depth, method_id, slot++);
	DEBUG_GC(" [THIS]: " << si->This);
	}

	if (si->exc) {
	vm_ti_enumerate_stack_root(ti_env,
	(void**)&si->exc, si->exc,
	JVMTI_HEAP_ROOT_STACK_LOCAL,
	depth, method_id, slot++);
	DEBUG_GC(" [EXCEPTION]: " << si->exc);
	}

	if (method->is_native()) {
	DEBUG_GC("[METHOD <native>]: " << method);
	interp_si_goto_previous(si);
	continue;
	}

	DEBUG_GC("[METHOD "<< si->stack.size << " " << (int)si->locals.varNum << "]: "
	<< method);

	if (si->stack.size)
	for(i = 0; i <= si->stack.index; i++) {
	if (si->stack.refs[i] == FLAG_OBJECT) {
	DEBUG_GC(" Stack[" << i << "] ");
	REF* ref = &si->stack.data[i].ref;
	ManagedObject obj = UNCOMPRESS_INTERP(ref);
	if (obj == 0) {
	DEBUG_GC("NULL");
	} else {
	DEBUG_GC(obj);
	vm_ti_enumerate_stack_root(ti_env,
	ref, (Managed_Object_Handle)obj,
	JVMTI_HEAP_ROOT_STACK_LOCAL,
	depth, method_id, slot++);
	}
	}
	}

	unsigned j;
	if (si->locals.varNum)
	for(j = 0; j < si->locals.varNum; j++) {
	if (si->locals.refs[j] == FLAG_OBJECT) {
	DEBUG_GC(" Locals[" << j << "] ");
	REF* ref = &si->locals.vars[j].ref;
	ManagedObject obj = UNCOMPRESS_INTERP(ref);
	if (obj == 0) {
	DEBUG_GC("NULL\n");
	} else {
	DEBUG_GC(obj);
	vm_ti_enumerate_stack_root(ti_env,
	ref, (Managed_Object_Handle)obj,
	JVMTI_HEAP_ROOT_STACK_LOCAL,
	depth, method_id, slot++);
	}
	}
	}
	MonitorList *ml = si->locked_monitors;
	while(ml) {
	vm_ti_enumerate_stack_root(ti_env,
	&ml->monitor, ml->monitor,
	JVMTI_HEAP_ROOT_MONITOR,
	depth, method_id, slot++);
	ml = ml->next;
	}
	interp_si_goto_previous(si);
	}

	// enumerate m2n frames
	M2nFrame *m2n = m2n_get_last_frame(thread);
	while(m2n) {
	oh_enumerate_handles(m2n_get_local_handles(m2n));
	m2n = m2n_get_previous_frame(m2n);
	}
	}

	void interpreter_ti_enumerate_thread(jvmtiEnv ti_env, VM_thread thread)
	{
	interp_ti_enumerate_root_set_single_thread_on_stack(ti_env, thread);

	// Enumerate references associated with a thread that are not stored on the thread's stack.
	vm_enumerate_root_set_single_thread_not_on_stack(thread);
	}