aboutsummaryrefslogtreecommitdiff
path: root/libjava/gnu/gcj/runtime
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/gnu/gcj/runtime')
-rw-r--r--libjava/gnu/gcj/runtime/NameFinder.java16
-rw-r--r--libjava/gnu/gcj/runtime/SharedLibHelper.java144
-rw-r--r--libjava/gnu/gcj/runtime/SharedLibLoader.java68
-rw-r--r--libjava/gnu/gcj/runtime/StackTrace.java2
-rw-r--r--libjava/gnu/gcj/runtime/VMClassLoader.java30
-rw-r--r--libjava/gnu/gcj/runtime/natSharedLibLoader.cc74
-rw-r--r--libjava/gnu/gcj/runtime/natStackTrace.cc17
-rw-r--r--libjava/gnu/gcj/runtime/natVMClassLoader.cc18
8 files changed, 300 insertions, 69 deletions
diff --git a/libjava/gnu/gcj/runtime/NameFinder.java b/libjava/gnu/gcj/runtime/NameFinder.java
index 19820c1bd6b..0c358368390 100644
--- a/libjava/gnu/gcj/runtime/NameFinder.java
+++ b/libjava/gnu/gcj/runtime/NameFinder.java
@@ -154,18 +154,10 @@ public class NameFinder
if (addr2line != null)
{
- try
- {
- addr2lineIn = new BufferedReader
- (new InputStreamReader(addr2line.getInputStream()));
- addr2lineOut = new BufferedWriter
- (new OutputStreamWriter(addr2line.getOutputStream()));
- }
- catch (IOException ioe)
- {
- addr2line.destroy();
- addr2line = null;
- }
+ addr2lineIn = new BufferedReader
+ (new InputStreamReader(addr2line.getInputStream()));
+ addr2lineOut = new BufferedWriter
+ (new OutputStreamWriter(addr2line.getOutputStream()));
}
}
}
diff --git a/libjava/gnu/gcj/runtime/SharedLibHelper.java b/libjava/gnu/gcj/runtime/SharedLibHelper.java
new file mode 100644
index 00000000000..9e170a120be
--- /dev/null
+++ b/libjava/gnu/gcj/runtime/SharedLibHelper.java
@@ -0,0 +1,144 @@
+/* Copyright (C) 2001, 2003 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 java.lang.ref.WeakReference;
+import java.net.URL;
+import java.net.MalformedURLException;
+import java.util.HashMap;
+import java.security.*;
+import gnu.gcj.Core;
+
+public class SharedLibHelper
+{
+ /** Load a shared library, and associate a ClassLoader with it.
+ * @param libname named of shared library (passed to dlopen)
+ * @param parent the parent ClassLoader
+ * @parem flags passed to dlopen
+ */
+ SharedLibHelper(String libname, ClassLoader parent, CodeSource source,
+ int flags)
+ {
+ // FIXME: ask security manager first.
+ loader = parent;
+ baseName = libname;
+ domain = new ProtectionDomain(source,
+ Policy.getPolicy().getPermissions(source));
+ this.flags = flags;
+ }
+
+ public static SharedLibHelper findHelper (String libname)
+ {
+ synchronized (map)
+ {
+ WeakReference ref = (WeakReference) map.get(libname);
+ if (ref != null)
+ return (SharedLibHelper) ref.get();
+ return null;
+ }
+ }
+
+ public static SharedLibHelper findHelper (ClassLoader loader, String libname,
+ CodeSource source)
+ {
+ synchronized (map)
+ {
+ SharedLibHelper result;
+ WeakReference ref = (WeakReference) map.get(libname);
+ if (ref != null)
+ {
+ result = (SharedLibHelper) ref.get();
+ if (result != null)
+ {
+ if (result.loader != loader)
+ // FIXME
+ throw new UnknownError();
+ return result;
+ }
+ }
+
+ result = new SharedLibHelper(libname, loader, source, 0);
+ map.put(libname, new WeakReference(result));
+ return result;
+ }
+ }
+
+ public native void finalize ();
+
+ public Class findClass(String name)
+ {
+ ensureInit();
+ return (Class) classMap.get(name);
+ }
+
+ public URL findResource (String name)
+ {
+ ensureInit();
+ if (! hasResource(name))
+ return null;
+ try
+ {
+ return new URL("gcjlib", "", -1, baseName + "!/" + name);
+ }
+ catch (MalformedURLException _)
+ {
+ }
+ return null;
+ }
+
+ public native Core findCore (String name);
+
+ void ensureInit()
+ {
+ synchronized (classMap)
+ {
+ if (initialized)
+ return;
+ init();
+ initialized = true;
+ }
+ }
+
+ native boolean hasResource(String name);
+ native void init();
+
+ /** Called during dlopen's processing of the init section. */
+ void registerClass(String name, Class cls)
+ {
+ classMap.put(name, cls);
+ }
+
+ /** The handle returned by dlopen. */
+ gnu.gcj.RawData handler;
+
+ /** Holds a _Jv_core_chain for the loader. */
+ gnu.gcj.RawData core_chain;
+
+ /** Map classnames to Classes. */
+ HashMap classMap = new HashMap(20);
+
+ /** Class loader we're helping. */
+ ClassLoader loader;
+
+ /** Name of base file. */
+ String baseName;
+
+ /** Protection domain for loaded classes. */
+ ProtectionDomain domain;
+
+ /** Flags to pass to dlopen. FIXME: platform dependent.
+ 0 is always "sensible" (defined by us). */
+ int flags;
+
+ /** True if we've been initialized. */
+ boolean initialized = false;
+
+ /** Map shared library names to a helper object. This uses weak
+ references in the values so we don't prevent collection. */
+ static HashMap map = new HashMap ();
+}
diff --git a/libjava/gnu/gcj/runtime/SharedLibLoader.java b/libjava/gnu/gcj/runtime/SharedLibLoader.java
index ac2f72d4b64..1f80bbc8289 100644
--- a/libjava/gnu/gcj/runtime/SharedLibLoader.java
+++ b/libjava/gnu/gcj/runtime/SharedLibLoader.java
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001 Free Software Foundation
+/* Copyright (C) 2001, 2003 Free Software Foundation
This file is part of libgcj.
@@ -7,7 +7,12 @@ Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package gnu.gcj.runtime;
-import java.util.Hashtable;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.security.CodeSource;
+import java.util.Enumeration;
+import java.util.Vector;
/**
* A ClassLoader backed by a gcj-compiled shared library.
@@ -16,14 +21,6 @@ import java.util.Hashtable;
public class SharedLibLoader extends ClassLoader
{
- public native void finalize ();
-
- /** Called during dlopen's processing of the init section. */
- void registerClass(String name, Class cls)
- {
- classMap.put(name, cls);
- }
-
/** Load a shared library, and associate a ClassLoader with it.
* @param libname named of shared library (passed to dlopen)
* @param parent the parent ClassLoader
@@ -32,44 +29,51 @@ public class SharedLibLoader extends ClassLoader
public SharedLibLoader(String libname, ClassLoader parent, int flags)
{
super(parent);
- init(libname, flags);
+ URL url;
+ try
+ {
+ url = new URL("file", "", libname);
+ }
+ catch (MalformedURLException _)
+ {
+ url = null;
+ }
+ helper = SharedLibHelper.findHelper(this, libname,
+ new CodeSource(url, null));
}
-
/** Load a shared library, and asociate a ClassLoader with it.
* @param libname named of shared library (passed to dlopen)
*/
public SharedLibLoader(String libname)
{
- super(getSystemClassLoader());
- init(libname, 0);
+ this(libname, getSystemClassLoader(), 0);
}
- void init(String libname, int flags)
+ public Class findClass(String name)
+ throws ClassNotFoundException
{
- init(libname.getBytes(), flags);
+ Class cls = helper.findClass(name);
+ if (cls == null)
+ throw new ClassNotFoundException(name);
+ return cls;
}
- native void init(byte[] libname, int flags);
-
- public Class loadClass(String name)
- throws ClassNotFoundException
+ public URL findResource (String name)
{
- return super.loadClass(name);
+ return helper.findResource(name);
}
- public Class findClass(String name)
- throws ClassNotFoundException
+ public Enumeration findResources (String name) throws IOException
{
- Object cls = classMap.get(name);
- if (cls == null)
- throw new ClassNotFoundException(name);
- return (Class) cls;
+ URL url = findResource(name);
+ if (url == null)
+ return null;
+ Vector v = new Vector(1);
+ v.add(url);
+ return v.elements();
}
- /** The handle returned by dlopen. */
- gnu.gcj.RawData handler;
-
- /** Map classnames to Classes. */
- Hashtable classMap = new Hashtable(20);
+ /** The helper that does the work for us. */
+ SharedLibHelper helper;
}
diff --git a/libjava/gnu/gcj/runtime/StackTrace.java b/libjava/gnu/gcj/runtime/StackTrace.java
index 5faaa1495ae..684ee4fd997 100644
--- a/libjava/gnu/gcj/runtime/StackTrace.java
+++ b/libjava/gnu/gcj/runtime/StackTrace.java
@@ -139,6 +139,8 @@ public final class StackTrace
return len;
}
+ public static native Class getClass(RawData ip);
+
private static native void update();
private static MethodRef methodAtAddress(RawData addr)
{
diff --git a/libjava/gnu/gcj/runtime/VMClassLoader.java b/libjava/gnu/gcj/runtime/VMClassLoader.java
index fd0c32c2c57..ca0f663c9cc 100644
--- a/libjava/gnu/gcj/runtime/VMClassLoader.java
+++ b/libjava/gnu/gcj/runtime/VMClassLoader.java
@@ -1,4 +1,4 @@
-/* Copyright (C) 1999, 2001, 2002 Free Software Foundation
+/* Copyright (C) 1999, 2001, 2002, 2003 Free Software Foundation
This file is part of libgcj.
@@ -12,6 +12,7 @@ package gnu.gcj.runtime;
import java.io.*;
import java.util.StringTokenizer;
+import java.util.HashSet;
import java.net.URL;
public final class VMClassLoader extends java.net.URLClassLoader
@@ -19,6 +20,20 @@ public final class VMClassLoader extends java.net.URLClassLoader
private VMClassLoader ()
{
super (init());
+ String p
+ = System.getProperty ("gnu.gcj.runtime.VMClassLoader.library_control",
+ "");
+ if ("never".equals(p))
+ lib_control = LIB_NEVER;
+ else if ("cache".equals(p))
+ lib_control = LIB_CACHE;
+ else if ("full".equals(p))
+ {
+ // In case we ever want to change the default.
+ lib_control = LIB_FULL;
+ }
+ else
+ lib_control = LIB_FULL;
}
private static URL[] init()
@@ -67,6 +82,17 @@ public final class VMClassLoader extends java.net.URLClassLoader
protected native Class findClass(String name)
throws java.lang.ClassNotFoundException;
+ // This keeps track of shared libraries we've already tried to load.
+ private HashSet tried_libraries = new HashSet();
+
+ // Holds one of the LIB_* constants; used to determine how shared
+ // library loads are done.
+ private int lib_control;
+
// The only VMClassLoader that can exist.
- public static VMClassLoader instance = new VMClassLoader ();
+ public static VMClassLoader instance = new VMClassLoader();
+
+ private static final int LIB_FULL = 0;
+ private static final int LIB_CACHE = 1;
+ private static final int LIB_NEVER = 2;
}
diff --git a/libjava/gnu/gcj/runtime/natSharedLibLoader.cc b/libjava/gnu/gcj/runtime/natSharedLibLoader.cc
index 233540917b3..46eef755a09 100644
--- a/libjava/gnu/gcj/runtime/natSharedLibLoader.cc
+++ b/libjava/gnu/gcj/runtime/natSharedLibLoader.cc
@@ -1,6 +1,6 @@
-// natSharedLibLoader.cc - Implementation of FirstThread native methods.
+// natSharedLibLoader.cc - Implementation of SharedLibHelper native methods.
-/* Copyright (C) 2001 Free Software Foundation
+/* Copyright (C) 2001, 2003 Free Software Foundation
This file is part of libgcj.
@@ -11,65 +11,113 @@ details. */
#include <config.h>
#include <gcj/cni.h>
-#include <gnu/gcj/runtime/SharedLibLoader.h>
+#include <jvm.h>
+#include <gnu/gcj/runtime/SharedLibHelper.h>
#include <java/io/IOException.h>
#include <java/lang/UnsupportedOperationException.h>
+#include <java/lang/UnknownError.h>
#ifdef HAVE_DLOPEN
#include <dlfcn.h>
/* Only used during dlopen, while having a lock on Class.class. */
-static gnu::gcj::runtime::SharedLibLoader* curLoader;
+static java::lang::ClassLoader *curLoader;
+static gnu::gcj::runtime::SharedLibHelper *curHelper;
typedef void (*ClassHookFunc) (jclass);
+typedef void (*CoreHookFunc) (_Jv_core_chain *);
+
+void
+_Jv_sharedlib_register_hook (jclass cls)
+{
+ curHelper->registerClass(cls->getName(), cls);
+ cls->protectionDomain = curHelper->domain;
+ cls->loader = curLoader;
+}
static void
-::register_hook(jclass cls)
+core_hook (_Jv_core_chain *chain)
{
- curLoader->registerClass(cls->getName(), cls);
+ chain->next = (_Jv_core_chain *) curHelper->core_chain;
+ curHelper->core_chain = (gnu::gcj::RawData *) chain;
}
struct SharedLibDummy
{
ClassHookFunc saved;
+ CoreHookFunc saved_core;
SharedLibDummy()
{
saved = _Jv_RegisterClassHook;
+ saved_core = _Jv_RegisterCoreHook;
}
~SharedLibDummy()
{
_Jv_RegisterClassHook = saved;
+ _Jv_RegisterCoreHook = saved_core;
curLoader = NULL;
}
};
#endif
void
-gnu::gcj::runtime::SharedLibLoader::init(jbyteArray libname, jint flags)
+gnu::gcj::runtime::SharedLibHelper::init(void)
{
#ifdef HAVE_DLOPEN
- char *lname = (char*) elements(libname);
+ char *lname = (char *) __builtin_alloca (JvGetStringUTFLength (baseName)
+ + 1);
+ jsize total = JvGetStringUTFRegion (baseName, 0, baseName->length(), lname);
+ lname[total] = '\0';
+
if (flags==0)
- flags = RTLD_LAZY;
+ flags = RTLD_GLOBAL | RTLD_LAZY;
JvSynchronize dummy1(&java::lang::Class::class$);
SharedLibDummy dummy2;
- curLoader = this;
- _Jv_RegisterClassHook = ::register_hook;
+ curLoader = loader;
+ curHelper = this;
+ _Jv_RegisterClassHook = _Jv_sharedlib_register_hook;
+ _Jv_RegisterCoreHook = core_hook;
void *h = dlopen(lname, flags);
if (h == NULL)
{
const char *msg = dlerror();
+ throw new java::lang::UnknownError(JvNewStringLatin1(msg));
}
handler = (gnu::gcj::RawData*) h;
#else
- const char *msg = "ShareedLibLoader is not supported on this platform";
+ const char *msg
+ = "shared library class loading is not supported on this platform";
throw new java::lang::UnsupportedOperationException(JvNewStringLatin1(msg));
#endif
}
+jboolean
+gnu::gcj::runtime::SharedLibHelper::hasResource (jstring name)
+{
+#ifdef HAVE_DLOPEN
+ _Jv_core_chain *node = _Jv_FindCore ((_Jv_core_chain *) core_chain, name);
+ return node != NULL;
+#else
+ return false;
+#endif
+}
+
+gnu::gcj::Core *
+gnu::gcj::runtime::SharedLibHelper::findCore (jstring name)
+{
+#ifdef HAVE_DLOPEN
+ extern gnu::gcj::Core *_Jv_create_core (_Jv_core_chain *node, jstring name);
+ ensureInit();
+ return _Jv_create_core ((_Jv_core_chain *) core_chain, name);
+#else
+ return NULL;
+#endif
+}
+
void
-gnu::gcj::runtime::SharedLibLoader::finalize()
+gnu::gcj::runtime::SharedLibHelper::finalize()
{
+ _Jv_FreeCoreChain ((_Jv_core_chain *) core_chain);
#ifdef HAVE_DLOPEN
dlclose (handler);
#endif
diff --git a/libjava/gnu/gcj/runtime/natStackTrace.cc b/libjava/gnu/gcj/runtime/natStackTrace.cc
index d39cd00dbab..af8889beb52 100644
--- a/libjava/gnu/gcj/runtime/natStackTrace.cc
+++ b/libjava/gnu/gcj/runtime/natStackTrace.cc
@@ -124,6 +124,16 @@ gnu::gcj::runtime::StackTrace::getCompiledMethodRef (gnu::gcj::RawData *addr)
}
java::lang::Class *
+gnu::gcj::runtime::StackTrace::getClass (gnu::gcj::RawData *p)
+{
+ gnu::gcj::runtime::MethodRef *ref = getCompiledMethodRef (p);
+ if (ref)
+ return ref->klass;
+ else
+ return NULL;
+}
+
+java::lang::Class *
gnu::gcj::runtime::StackTrace::classAt (jint n)
{
_Jv_frame_info *frame = GET_FRAME (n);
@@ -137,12 +147,7 @@ gnu::gcj::runtime::StackTrace::classAt (jint n)
}
#endif // INTERPRETER
- gnu::gcj::runtime::MethodRef *ref
- = getCompiledMethodRef ((gnu::gcj::RawData *)frame->addr);
- if (ref)
- return ref->klass;
- else
- return NULL;
+ return getClass ((gnu::gcj::RawData *)frame->addr);
}
java::lang::String*
diff --git a/libjava/gnu/gcj/runtime/natVMClassLoader.cc b/libjava/gnu/gcj/runtime/natVMClassLoader.cc
index 33b63d6759a..42ac2a02107 100644
--- a/libjava/gnu/gcj/runtime/natVMClassLoader.cc
+++ b/libjava/gnu/gcj/runtime/natVMClassLoader.cc
@@ -1,6 +1,6 @@
// Native code for VMClassLoader
-/* Copyright (C) 2002 Free Software Foundation
+/* Copyright (C) 2002, 2003 Free Software Foundation
This file is part of libgcj.
@@ -18,6 +18,7 @@ details. */
#include <java/lang/StringBuffer.h>
#include <java/net/URLClassLoader.h>
#include <java/lang/Runtime.h>
+#include <java/util/HashSet.h>
jclass
gnu::gcj::runtime::VMClassLoader::findClass (jstring name)
@@ -25,7 +26,7 @@ gnu::gcj::runtime::VMClassLoader::findClass (jstring name)
_Jv_Utf8Const *name_u = _Jv_makeUtf8Const (name);
jclass klass = _Jv_FindClassInCache (name_u, 0);
- if (! klass)
+ if (! klass && lib_control != LIB_NEVER)
{
// Turn `gnu.pkg.quux' into `lib-gnu-pkg-quux'. Then search for
// a module named (eg, on Linux) `lib-gnu-pkg-quux.so', followed
@@ -41,11 +42,20 @@ gnu::gcj::runtime::VMClassLoader::findClass (jstring name)
cn = name->substring (0, ci);
jstring so_base_name = (sb->append (cn)->toString ())->replace ('.', '-');
+ using namespace ::java::lang;
+ Runtime *rt = Runtime::getRuntime();
+
// Compare against `3' because that is the length of "lib".
while (! klass && so_base_name && so_base_name->length() > 3)
{
- using namespace ::java::lang;
- Runtime *rt = Runtime::getRuntime();
+ if (lib_control == LIB_CACHE)
+ {
+ // If we've already tried this name, we're done.
+ if (tried_libraries->contains(so_base_name))
+ break;
+ tried_libraries->add(so_base_name);
+ }
+
jboolean loaded = rt->loadLibraryInternal (so_base_name);
jint nd = so_base_name->lastIndexOf ('-');
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-24 01:12:56 +0000