natClassLoader.cc (_Jv_PrepareCompiledClass): Call _Jv_PushClass.
2002-12-03 Andrew Haley <aph@redhat.com> * java/lang/natClassLoader.cc (_Jv_PrepareCompiledClass): Call _Jv_PushClass. (_Jv_InitNewClassFields): Set protectionDomain and chain = NULL. (_Jv_PopClass): New. (_Jv_PushClass): New. * java/lang/natClass.cc (forName (jstring)): Use a StackTrace to discover the ClassLoader of our caller. (_Jv_CheckArrayStore): Don't check that a class is assignment compatible with Object. * java/lang/natVMTHrowable.cc: Delete. * gnu/gcj/runtime/StackTrace.java: New, partly copied from java.lang.VMThrowable. (StackTrace(), StackTrace(int)): New constructors. (classAt, methodAt, update, methodAtAddress): New methods. (map): New field. * java/lang/VMThrowable.java: Use StackTrace instead of natVMTHrowable. * java/lang/Class.h (getClassLoaderInternal): New. (class Class): Be friendly with _Jv_PopClass and _Jv_PushClass. Be friendly with gnu::gcj::runtime::StackTrace. (Object.chain): New field. * include/java-interp.h (class _Jv_InterpMethod): Be friendly with gnu::gcj::runtime::StackTrace. * gnu/gcj/runtime/natStackTrace.cc: New file. * gnu/gcj/runtime/MethodRef.java: New file. * prims.cc (_Jv_NewObjectArray): Use getClassLoaderInternal() instead of getClassLoader(). * verify.cc (class _Jv_BytecodeVerifier): Likewise. java::lang::VMThrowable. * Makefile.am (core_java_source_files): Add MethodRef.java, StackTrace.java. (nat_source_files): Remove natVMThrowable.cc; add natStackTrace.cc. * Makefile.in: Rebuild. From-SVN: r59771
This commit is contained in:
Andrew Haley
committed by
Andrew Haley
Andrew Haley
parent
f3f110d5d1
commit
765828d5a8
@@ -0,0 +1,25 @@
|
||||
// gnu.gcj.runtime.MethodRef -- used by StackTrace.
|
||||
|
||||
/* Copyright (C) 2002 Free Software Foundation
|
||||
|
||||
This file is part of libgcj.
|
||||
|
||||
This software is copyrighted work licensed under the terms of the
|
||||
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
||||
details. */
|
||||
|
||||
package gnu.gcj.runtime;
|
||||
|
||||
import gnu.gcj.RawData;
|
||||
|
||||
class MethodRef
|
||||
{
|
||||
MethodRef(RawData /* Actually _Jv_Method */ m, Class k)
|
||||
{
|
||||
klass = k;
|
||||
method = m;
|
||||
}
|
||||
|
||||
public RawData method; // Actually a raw pointer to _Jv_Method
|
||||
public Class klass;
|
||||
}
|
||||
@@ -0,0 +1,164 @@
|
||||
/* gnu.gcj.runtime.StackTrace -- VM support methods for walking the
|
||||
stack.
|
||||
Copyright (C) 1998, 1999, 2002 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2, or (at your option)
|
||||
any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; see the file COPYING. If not, write to the
|
||||
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA.
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
package gnu.gcj.runtime;
|
||||
|
||||
import gnu.gcj.RawData;
|
||||
import java.util.TreeMap;
|
||||
import java.util.IdentityHashMap;
|
||||
import java.util.SortedMap;
|
||||
import gnu.gcj.runtime.NameFinder;
|
||||
import java.util.NoSuchElementException;
|
||||
|
||||
/**
|
||||
* VM dependent state and support methods for walking the stack.
|
||||
* <p>
|
||||
* This is the version used by libgcj (http://gcc.gnu.org/java/).
|
||||
*
|
||||
* @author Mark Wielaard (mark@klomp.org)
|
||||
* @author Andrew Haley (aph@redhat.com)
|
||||
*/
|
||||
public final class StackTrace
|
||||
{
|
||||
/**
|
||||
* Fill in the stack trace with the top n frames on current
|
||||
* execution stack. Can return null if the VM does not support
|
||||
* capturing the VM execution state.
|
||||
*
|
||||
* @see Throwable#fillInStackTrace()
|
||||
*/
|
||||
public StackTrace(int n)
|
||||
{
|
||||
fillInStackTrace(n, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Fill in the stack trace with state of the entire execution stack,
|
||||
* starting from frame <code>offset</code>. Can return null if the
|
||||
* VM does not support capturing the VM execution state.
|
||||
*
|
||||
* This can be very expensive. If you only want part of the stack,
|
||||
* see <code>Throwable.fillInStackTrace(int)</code>
|
||||
*
|
||||
* @see Throwable#fillInStackTrace()
|
||||
*/
|
||||
public StackTrace()
|
||||
{
|
||||
int n = 64;
|
||||
|
||||
do
|
||||
{
|
||||
n *= 4;
|
||||
fillInStackTrace(n, 1);
|
||||
}
|
||||
while (len >= n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the class containing the execution point represented by
|
||||
* the Nth frame down the stack. The zeroth frame represents the
|
||||
* top of the stack, which is the method that called classAt().
|
||||
*
|
||||
* If the Nth frame down the stack was not create by a method
|
||||
* invocation, return null.
|
||||
*
|
||||
* It is not necessary to call <code>fillInStackTrace()</code> with
|
||||
* a size greater than N before calling this method; if the current
|
||||
* stack trace is insufficiently large, it will be expanded as
|
||||
* required. This requires some caution if
|
||||
* <code>fillInStackTrace()</code> is called from a different
|
||||
* invocation to the one that calls <code>classAt()</code>.
|
||||
* classAt() will not call <code>fillInStackTrace()</code> unless N
|
||||
* is greater than the current length.
|
||||
*
|
||||
*/
|
||||
public native Class classAt(int n);
|
||||
|
||||
/**
|
||||
* Return the name of the method containing the execution point
|
||||
* represented by the Nth frame down the stack. The zeroth frame
|
||||
* represents the top of the stack, which is the method that called
|
||||
* classAt().
|
||||
*
|
||||
* If the Nth frame down the stack was not create by a method
|
||||
* invocation, return null.
|
||||
*
|
||||
* It is not necessary to call <code>fillInStackTrace()</code> with
|
||||
* a size greater than N before calling this method; if the current
|
||||
* stack trace is insufficiently large, it will be expanded as
|
||||
* required. This requires some caution if
|
||||
* <code>fillInStackTrace()</code> is called from a different
|
||||
* invocation to the one that calls <code>classAt()</code>.
|
||||
* classAt() will not call <code>fillInStackTrace()</code> unless N
|
||||
* is greater than the current length.
|
||||
*
|
||||
*/
|
||||
public native String methodAt(int n);
|
||||
|
||||
/**
|
||||
* Return the length of this stack trace.
|
||||
*
|
||||
*/
|
||||
public int length ()
|
||||
{
|
||||
return len;
|
||||
}
|
||||
|
||||
private static native void update();
|
||||
private static MethodRef methodAtAddress(RawData addr)
|
||||
{
|
||||
update();
|
||||
synchronized (map)
|
||||
{
|
||||
return (MethodRef) map.get (addr);
|
||||
}
|
||||
}
|
||||
|
||||
gnu.gcj.RawData stackTraceAddrs()
|
||||
{
|
||||
return addrs;
|
||||
}
|
||||
|
||||
private native void fillInStackTrace(int n, int offset);
|
||||
|
||||
private static native MethodRef getCompiledMethodRef(RawData addr);
|
||||
private static IdentityHashMap map = new IdentityHashMap();
|
||||
|
||||
private gnu.gcj.RawData addrs;
|
||||
private int len;
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
// natStackTrace.cc - native helper methods for Throwable
|
||||
|
||||
/* Copyright (C) 2000, 2002 Free Software Foundation, Inc
|
||||
|
||||
This file is part of libgcj.
|
||||
|
||||
This software is copyrighted work licensed under the terms of the
|
||||
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
||||
details. */
|
||||
|
||||
/**
|
||||
* @author Andrew Haley <aph@cygnus.com>
|
||||
* @author Mark Wielaard <mark@klomp.org>
|
||||
*
|
||||
* Native helper methods for VM specific Throwable support.
|
||||
*/
|
||||
|
||||
#include <config.h>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <jvm.h>
|
||||
#include <gcj/cni.h>
|
||||
#include <gnu/gcj/RawData.h>
|
||||
#include <java/lang/Object.h>
|
||||
#include <java-threads.h>
|
||||
#include <gnu/gcj/runtime/MethodRef.h>
|
||||
#include <gnu/gcj/runtime/StackTrace.h>
|
||||
#include <java/lang/Thread.h>
|
||||
#include <java-interp.h>
|
||||
#include <java/util/IdentityHashMap.h>
|
||||
#include <java/lang/ArrayIndexOutOfBoundsException.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef HAVE_EXECINFO_H
|
||||
#include <execinfo.h>
|
||||
#endif
|
||||
|
||||
#include <unwind.h>
|
||||
|
||||
|
||||
// Fill in this stack trace with N elements starting at offset.
|
||||
void
|
||||
gnu::gcj::runtime::StackTrace::fillInStackTrace (jint maxlen, jint offset)
|
||||
{
|
||||
#if defined (HAVE_BACKTRACE)
|
||||
offset += 1;
|
||||
void *_p[maxlen + offset];
|
||||
len = backtrace (_p, maxlen + offset) - offset;
|
||||
void **p = _p + offset;
|
||||
#endif
|
||||
_Jv_frame_info *frame;
|
||||
if (len > 0)
|
||||
{
|
||||
#ifdef INTERPRETER
|
||||
extern void _Jv_StartOfInterpreter (void);
|
||||
extern void _Jv_EndOfInterpreter (void);
|
||||
|
||||
java::lang::Thread *thread = java::lang::Thread::currentThread();
|
||||
_Jv_MethodChain *interp_frame
|
||||
= (thread ? reinterpret_cast<_Jv_MethodChain *> (thread->interp_frame)
|
||||
: NULL);
|
||||
#endif // INTERPRETER
|
||||
|
||||
frame = (_Jv_frame_info *) _Jv_Malloc (len * sizeof (_Jv_frame_info));
|
||||
for (int n = 0; n < len; n++)
|
||||
{
|
||||
frame[n].addr = p[n];
|
||||
#ifdef INTERPRETER
|
||||
if (p[n] >= &_Jv_StartOfInterpreter && p[n] <= &_Jv_EndOfInterpreter)
|
||||
{
|
||||
frame[n].interp = (void *) interp_frame->self;
|
||||
interp_frame = interp_frame->next;
|
||||
}
|
||||
else
|
||||
frame[n].interp = 0;
|
||||
#endif // INTERPRETER
|
||||
}
|
||||
}
|
||||
else
|
||||
frame = NULL;
|
||||
|
||||
addrs = reinterpret_cast<gnu::gcj::RawData *> (frame);
|
||||
}
|
||||
|
||||
/* Obtain the next power-of-2 of some integer. */
|
||||
static inline jint
|
||||
nextpowerof2 (jint n)
|
||||
{
|
||||
n |= (n >> 1);
|
||||
n |= (n >> 2);
|
||||
n |= (n >> 4);
|
||||
n |= (n >> 8);
|
||||
n |= (n >> 16);
|
||||
return n+1;
|
||||
}
|
||||
|
||||
#define GET_FRAME(N) \
|
||||
({ \
|
||||
if ((N) >= len) \
|
||||
fillInStackTrace (nextpowerof2 (N), 1); \
|
||||
if ((N) < 0 || (N) >= len) \
|
||||
throw new ::java::lang::ArrayIndexOutOfBoundsException (); \
|
||||
\
|
||||
_Jv_frame_info *frame = (_Jv_frame_info *)addrs; \
|
||||
&frame[N]; \
|
||||
})
|
||||
|
||||
gnu::gcj::runtime::MethodRef *
|
||||
gnu::gcj::runtime::StackTrace::getCompiledMethodRef (gnu::gcj::RawData *addr)
|
||||
{
|
||||
void *p = _Unwind_FindEnclosingFunction (addr);
|
||||
return gnu::gcj::runtime::StackTrace
|
||||
::methodAtAddress ((gnu::gcj::RawData *)p);
|
||||
}
|
||||
|
||||
java::lang::Class *
|
||||
gnu::gcj::runtime::StackTrace::classAt (jint n)
|
||||
{
|
||||
_Jv_frame_info *frame = GET_FRAME (n);
|
||||
|
||||
#ifdef INTERPRETER
|
||||
if (frame->interp)
|
||||
{
|
||||
_Jv_InterpMethod *meth
|
||||
= reinterpret_cast<_Jv_InterpMethod *> (frame->interp);
|
||||
return meth->defining_class;
|
||||
}
|
||||
#endif // INTERPRETER
|
||||
|
||||
gnu::gcj::runtime::MethodRef *ref
|
||||
= getCompiledMethodRef ((gnu::gcj::RawData *)frame->addr);
|
||||
if (ref)
|
||||
return ref->klass;
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
java::lang::String*
|
||||
gnu::gcj::runtime::StackTrace::methodAt (jint n)
|
||||
{
|
||||
_Jv_frame_info *frame = GET_FRAME (n);
|
||||
_Jv_Method *meth = NULL;
|
||||
|
||||
#ifdef INTERPRETER
|
||||
if (frame->interp)
|
||||
{
|
||||
meth
|
||||
= reinterpret_cast<_Jv_InterpMethod *> (frame->interp)
|
||||
->get_method();
|
||||
}
|
||||
#endif // INTERPRETER
|
||||
|
||||
if (! meth)
|
||||
{
|
||||
gnu::gcj::runtime::MethodRef *ref
|
||||
= getCompiledMethodRef ((gnu::gcj::RawData *)frame->addr);
|
||||
if (ref)
|
||||
meth = (_Jv_Method *)ref->method;
|
||||
}
|
||||
|
||||
return meth
|
||||
? _Jv_NewStringUtf8Const (meth->name)
|
||||
: NULL ;
|
||||
}
|
||||
|
||||
void
|
||||
gnu::gcj::runtime::StackTrace::update(void)
|
||||
{
|
||||
jclass klass;
|
||||
|
||||
while ((klass = _Jv_PopClass ()))
|
||||
{
|
||||
for (int i=0; i<klass->method_count; i++)
|
||||
{
|
||||
JvSynchronize sync (map);
|
||||
_Jv_Method *meth = &(klass->methods[i]);
|
||||
if (meth->ncode) // i.e. if p is not abstract
|
||||
{
|
||||
gnu::gcj::runtime::MethodRef *ref
|
||||
= new gnu::gcj::runtime::MethodRef
|
||||
((gnu::gcj::RawData *)meth, klass);
|
||||
map->put ((java::lang::Object*)(meth->ncode), ref);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user