libjava/java/lang/natVMClassLoader.cc

   1 // natVMClassLoader.cc - VMClassLoader native methods
   2
   3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 /* Author: Kresten Krab Thorup <krab@gnu.org>  */
  12
  13 #include <config.h>
  14
  15 #include <stdlib.h>
  16 #include <string.h>
  17
  18 #include <gcj/cni.h>
  19 #include <jvm.h>
  20
  21 #include <java-threads.h>
  22 #include <java-interp.h>
  23
  24 #include <java/lang/VMClassLoader.h>
  25 #include <java/lang/VMCompiler.h>
  26 #include <gnu/gcj/runtime/ExtensionClassLoader.h>
  27 #include <gnu/gcj/runtime/SystemClassLoader.h>
  28 #include <gnu/gcj/runtime/BootClassLoader.h>
  29 #include <java/lang/ClassLoader.h>
  30 #include <java/lang/Class.h>
  31 #include <java/lang/Throwable.h>
  32 #include <java/security/ProtectionDomain.h>
  33 #include <java/lang/ClassFormatError.h>
  34 #include <java/lang/StringBuffer.h>
  35 #include <java/lang/Runtime.h>
  36 #include <java/util/HashSet.h>
  37
  38 java::lang::Class *
  39 java::lang::VMClassLoader::defineClass (java::lang::ClassLoader *loader,
  40                                         jstring name,
  41                                         jbyteArray data,
  42                                         jint offset,
  43                                         jint length,
  44                                         java::security::ProtectionDomain *pd)
  45 {
  46   jclass klass = VMCompiler::compileClass(loader, name, data,
  47                                           offset, length, pd);
  48
  49 #ifdef INTERPRETER
  50   if (klass == NULL)
  51     {
  52       klass = new java::lang::Class ();
  53
  54       // Synchronize on the class, so that it is not attempted initialized
  55       // until we're done loading.
  56       JvSynchronize sync (klass);
  57
  58       // Record the defining loader.  For the bootstrap class loader,
  59       // we record NULL.
  60       if (loader != bootLoader)
  61         klass->loader = loader;
  62
  63       if (name != 0)
  64         {
  65           _Jv_Utf8Const *name2 = _Jv_makeUtf8Const (name);
  66
  67           if (! _Jv_VerifyClassName (name2))
  68             throw new java::lang::ClassFormatError
  69               (JvNewStringLatin1 ("erroneous class name"));
  70
  71           klass->name = name2;
  72         }
  73
  74       _Jv_Utf8Const *found_name = NULL;
  75       try
  76         {
  77           _Jv_DefineClass (klass, data, offset, length, pd, &found_name);
  78         }
  79       catch (java::lang::Throwable *ex)
  80         {
  81           klass->state = JV_STATE_ERROR;
  82           klass->notifyAll ();
  83
  84           if (found_name != NULL)
  85             _Jv_UnregisterInitiatingLoader (klass, klass->loader);
  86
  87           // If EX is not a ClassNotFoundException, that's ok, because we
  88           // account for the possibility in defineClass().
  89           throw ex;
  90         }
  91
  92       // if everything proceeded sucessfully, we're loaded.
  93       JvAssert (klass->state == JV_STATE_LOADED);
  94     }
  95 #endif // INTERPRETER
  96
  97   return klass;
  98 }
  99
 100 java::lang::ClassLoader *
 101 java::lang::VMClassLoader::getSystemClassLoaderInternal()
 102 {
 103   _Jv_InitClass (&gnu::gcj::runtime::ExtensionClassLoader::class$);
 104   _Jv_CopyClassesToSystemLoader (gnu::gcj::runtime::ExtensionClassLoader::system_instance);
 105   return gnu::gcj::runtime::ExtensionClassLoader::system_instance;
 106 }
 107
 108 jclass
 109 java::lang::VMClassLoader::getPrimitiveClass (jchar type)
 110 {
 111   char sig[2];
 112   sig[0] = (char) type;
 113   sig[1] = '\0';
 114   // Note: this cannot return NULL, since the input is always correct.
 115   return _Jv_FindClassFromSignature (sig, NULL);
 116 }
 117
 118 void
 119 java::lang::VMClassLoader::initBootLoader(jstring libdir)
 120 {
 121   bootLoader = new gnu::gcj::runtime::BootClassLoader(libdir);
 122 }
 123
 124 jclass
 125 java::lang::VMClassLoader::nativeFindClass (jstring name)
 126 {
 127   jclass klass = NULL;
 128
 129   if (lib_control != LIB_NEVER)
 130     {
 131       // Turn `gnu.pkg.quux' into `lib-gnu-pkg-quux'.  Then search for
 132       // a module named (eg, on Linux) `lib-gnu-pkg-quux.so', followed
 133       // by `lib-gnu-pkg.so' and `lib-gnu.so'.  If loading one of
 134       // these causes the class to appear in the cache, then use it.
 135       java::lang::StringBuffer *sb
 136         = new java::lang::StringBuffer (JvNewStringLatin1("lib-"));
 137       // Skip inner classes
 138       jstring cn;
 139       jint ci = name->indexOf('$');
 140       if (ci == -1)
 141         cn = name;
 142       else
 143         cn = name->substring (0, ci);
 144       jstring so_base_name
 145         = (sb->append (cn)->toString ())->replace ('.', '-');
 146
 147       using namespace ::java::lang;
 148       Runtime *rt = Runtime::getRuntime();
 149
 150       _Jv_Utf8Const *name_u = NULL;
 151
 152       // Compare against `3' because that is the length of "lib".
 153       while (! klass && so_base_name && so_base_name->length() > 3)
 154         {
 155           if (lib_control == LIB_CACHE)
 156             {
 157               // If we've already tried this name, we're done.
 158               if (tried_libraries->contains(so_base_name))
 159                 break;
 160               tried_libraries->add(so_base_name);
 161             }
 162
 163           jboolean loaded = rt->loadLibraryInternal (so_base_name);
 164
 165           jint nd = so_base_name->lastIndexOf ('-');
 166           if (nd == -1)
 167             so_base_name = NULL;
 168           else
 169             so_base_name = so_base_name->substring (0, nd);
 170
 171           if (loaded)
 172             {
 173               if (name_u == NULL)
 174                 name_u = _Jv_makeUtf8Const (name);
 175               klass = _Jv_FindClassInCache (name_u);
 176             }
 177         }
 178     }
 179
 180   if (klass)
 181     definePackageForNative(name);
 182
 183   return klass;
 184 }
 185
 186 jclass
 187 java::lang::VMClassLoader::loadClass(jstring name, jboolean resolve)
 188 {
 189   // We try the boot loader first, so that the endorsed directory
 190   // overrides compiled-in classes.
 191   jclass klass = NULL;
 192   if (bootLoader)
 193     klass = bootLoader->bootLoadClass(name);
 194   if (! klass)
 195     {
 196       _Jv_Utf8Const *utf = _Jv_makeUtf8Const (name);
 197       klass = _Jv_FindClassInCache (utf);
 198     }
 199   if (! klass)
 200     klass = nativeFindClass(name);
 201   if (klass)
 202     {
 203       // We never want to return a class without its supers linked.
 204       // It isn't clear from the spec, but this is what other
 205       // implementations do in practice.
 206       if (resolve)
 207         resolveClass (klass);
 208       else
 209         _Jv_Linker::wait_for_state (klass, JV_STATE_LOADING);
 210
 211       definePackageForNative(name);
 212     }
 213
 214   return klass;
 215 }