OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [java/] [lang/] [natRuntime.cc] - Blame information for rev 758

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 758 jeremybenn
// natRuntime.cc - Implementation of native side of Runtime class.
2
 
3
/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007  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
#include <config.h>
12
#include <platform.h>
13
 
14
#include <stdlib.h>
15
 
16
#include <gcj/cni.h>
17
#include <jvm.h>
18
#include <java-props.h>
19
#include <java-stack.h>
20
#include <java/lang/Long.h>
21
#include <java/lang/Runtime.h>
22
#include <java/lang/UnknownError.h>
23
#include <java/lang/UnsatisfiedLinkError.h>
24
#include <gnu/gcj/runtime/FinalizerThread.h>
25
#include <java/io/File.h>
26
#include <java/util/TimeZone.h>
27
#include <java/lang/StringBuffer.h>
28
#include <java/lang/Process.h>
29
#include <java/lang/ClassLoader.h>
30
 
31
// It is convenient and safe to simply include all of these.
32
#include <java/lang/Win32Process.h>
33
#include <java/lang/EcosProcess.h>
34
#include <java/lang/PosixProcess.h>
35
 
36
#include <jni.h>
37
 
38
#ifdef HAVE_PWD_H
39
#include <pwd.h>
40
#endif
41
#include <errno.h>
42
 
43
#ifdef HAVE_LOCALE_H
44
#include <locale.h>
45
#endif
46
 
47
#ifdef HAVE_LANGINFO_H
48
#include <langinfo.h>
49
#endif
50
 
51
 
52
 
53
#ifdef USE_LTDL
54
#include <ltdl.h>
55
 
56
/* FIXME: we don't always need this.  The next libtool will let us use
57
   AC_LTDL_PREOPEN to see if we do.  */
58
extern const lt_dlsymlist lt_preloaded_symbols[1] = { { 0, 0 } };
59
 
60
struct lookup_data
61
{
62
  const char *symname;
63
  void *result;
64
};
65
 
66
static int
67
find_symbol (lt_dlhandle handle, lt_ptr data)
68
{
69
  lookup_data *ld = (lookup_data *) data;
70
  ld->result = lt_dlsym (handle, ld->symname);
71
  return ld->result != NULL;
72
}
73
 
74
void *
75
_Jv_FindSymbolInExecutable (const char *symname)
76
{
77
  lookup_data data;
78
  data.symname = symname;
79
  data.result = NULL;
80
  lt_dlforeach (find_symbol, (lt_ptr) &data);
81
  return data.result;
82
}
83
 
84
#else
85
 
86
void *
87
_Jv_FindSymbolInExecutable (const char *)
88
{
89
  return NULL;
90
}
91
 
92
#endif /* USE_LTDL */
93
 
94
 
95
 
96
void
97
java::lang::Runtime::runFinalizationForExit ()
98
{
99
  if (finalizeOnExit)
100
    _Jv_RunAllFinalizers ();
101
}
102
 
103
void
104
java::lang::Runtime::exitInternal (jint status)
105
{
106
  // Make status right for Unix.  This is perhaps strange.
107
  if (status < 0 || status > 255)
108
    status = 255;
109
 
110
  ::exit (status);
111
}
112
 
113
jlong
114
java::lang::Runtime::freeMemory (void)
115
{
116
  return _Jv_GCFreeMemory ();
117
}
118
 
119
void
120
java::lang::Runtime::gc (void)
121
{
122
  _Jv_RunGC ();
123
}
124
 
125
#ifdef USE_LTDL
126
// List of names for JNI_OnLoad.
127
static const char *onload_names[] = _Jv_platform_onload_names;
128
#endif
129
 
130
void
131
java::lang::Runtime::_load (jstring path, jboolean do_search)
132
{
133
  JvSynchronize sync (this);
134
  using namespace java::lang;
135
#ifdef USE_LTDL
136
  jint len = _Jv_GetStringUTFLength (path);
137
  char buf[len + 1 + strlen (_Jv_platform_solib_prefix)
138
           + strlen (_Jv_platform_solib_suffix)];
139
  int offset = 0;
140
  if (do_search)
141
    {
142
      strcpy (buf, _Jv_platform_solib_prefix);
143
      offset = strlen (_Jv_platform_solib_prefix);
144
    }
145
  jsize total = JvGetStringUTFRegion (path, 0, path->length(), &buf[offset]);
146
  buf[offset + total] = '\0';
147
 
148
  char *lib_name = buf;
149
 
150
  if (do_search)
151
    {
152
      ClassLoader *look = _Jv_StackTrace::GetFirstNonSystemClassLoader ();
153
 
154
      if (look != NULL)
155
        {
156
          // Don't include solib prefix in string passed to
157
          // findLibrary.
158
          jstring name = look->findLibrary(JvNewStringUTF(&buf[offset]));
159
          if (name != NULL)
160
            {
161
              len = _Jv_GetStringUTFLength (name);
162
              lib_name = (char *) _Jv_AllocBytes(len + 1);
163
              total = JvGetStringUTFRegion (name, 0,
164
                                            name->length(), lib_name);
165
              lib_name[total] = '\0';
166
              // Don't append suffixes any more; we have the full file
167
              // name.
168
              do_search = false;
169
            }
170
        }
171
    }
172
 
173
  lt_dlhandle h;
174
  // FIXME: make sure path is absolute.
175
  {
176
    // Synchronize on java.lang.Class. This is to protect the class chain from
177
    // concurrent modification by class registration calls which may be run
178
    // during the dlopen().
179
    JvSynchronize sync (&java::lang::Class::class$);
180
    h = do_search ? lt_dlopenext (lib_name) : lt_dlopen (lib_name);
181
  }
182
  if (h == NULL)
183
    {
184
      const char *msg = lt_dlerror ();
185
      jstring str = JvNewStringLatin1 (lib_name);
186
      str = str->concat (JvNewStringLatin1 (": "));
187
      str = str->concat (JvNewStringLatin1 (msg));
188
      throw new UnsatisfiedLinkError (str);
189
    }
190
 
191
  // Search for JNI_OnLoad function.
192
  void *onload = NULL;
193
  const char **name = onload_names;
194
  while (*name != NULL)
195
    {
196
      onload = lt_dlsym (h, *name);
197
      if (onload != NULL)
198
        break;
199
      ++name;
200
    }
201
 
202
  if (onload != NULL)
203
    {
204
      JavaVM *vm = _Jv_GetJavaVM ();
205
      if (vm == NULL)
206
        {
207
          // FIXME: what?
208
          return;
209
        }
210
 
211
      // Push a new frame so that JNI_OnLoad will get the right class
212
      // loader if it calls FindClass.
213
      ::java::lang::ClassLoader *loader
214
          = _Jv_StackTrace::GetFirstNonSystemClassLoader();
215
      JNIEnv *env = _Jv_GetJNIEnvNewFrameWithLoader (loader);
216
      jint vers = ((jint (JNICALL *) (JavaVM *, void *)) onload) (vm, NULL);
217
      _Jv_JNI_PopSystemFrame (env);
218
      if (vers != JNI_VERSION_1_1 && vers != JNI_VERSION_1_2
219
          && vers != JNI_VERSION_1_4)
220
        {
221
          // FIXME: unload the library.
222
          throw new UnsatisfiedLinkError (JvNewStringLatin1 ("unrecognized version from JNI_OnLoad"));
223
        }
224
    }
225
#else
226
  throw new UnknownError
227
    (JvNewStringLatin1 (do_search
228
                        ? "Runtime.loadLibrary not implemented"
229
                        : "Runtime.load not implemented"));
230
#endif /* USE_LTDL */
231
}
232
 
233
jboolean
234
java::lang::Runtime::loadLibraryInternal (jstring lib)
235
{
236
  JvSynchronize sync (this);
237
  using namespace java::lang;
238
#ifdef USE_LTDL
239
  jint len = _Jv_GetStringUTFLength (lib);
240
  char buf[len + 1];
241
  jsize total = JvGetStringUTFRegion (lib, 0, lib->length(), buf);
242
  buf[total] = '\0';
243
  // FIXME: make sure path is absolute.
244
  lt_dlhandle h = lt_dlopenext (buf);
245
  return h != NULL;
246
#else
247
  return false;
248
#endif /* USE_LTDL */
249
}
250
 
251
void
252
java::lang::Runtime::init (void)
253
{
254
#ifdef USE_LTDL
255
  lt_dlinit ();
256
  // Set module load path.
257
  lt_dlsetsearchpath (_Jv_Module_Load_Path);
258
  // Make sure self is opened.
259
  lt_dlopen (NULL);
260
#endif
261
}
262
 
263
void
264
java::lang::Runtime::runFinalization (void)
265
{
266
  gnu::gcj::runtime::FinalizerThread::finalizerReady ();
267
}
268
 
269
jlong
270
java::lang::Runtime::totalMemory (void)
271
{
272
  return _Jv_GCTotalMemory ();
273
}
274
 
275
jlong
276
java::lang::Runtime::maxMemory (void)
277
{
278
  // We don't have a maximum.  FIXME: we might if we ask the GC for
279
  // one.
280
  return Long::MAX_VALUE;
281
}
282
 
283
void
284
java::lang::Runtime::traceInstructions (jboolean)
285
{
286
  // Do nothing.
287
}
288
 
289
void
290
java::lang::Runtime::traceMethodCalls (jboolean)
291
{
292
  // Do nothing.
293
}
294
 
295
java::lang::Process *
296
java::lang::Runtime::execInternal (jstringArray cmd,
297
                                   jstringArray env,
298
                                   java::io::File *dir)
299
{
300
  return new _Jv_platform_process (cmd, env, dir, false);
301
}
302
 
303
jint
304
java::lang::Runtime::availableProcessors (void)
305
{
306
  // FIXME: find the real value.
307
  return 1;
308
}
309
 
310
jstring
311
java::lang::Runtime::nativeGetLibname (jstring pathname, jstring libname)
312
{
313
  java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
314
  sb->append(pathname);
315
  if (pathname->length() > 0)
316
    sb->append (_Jv_platform_file_separator);
317
 
318
  sb->append (JvNewStringLatin1 (_Jv_platform_solib_prefix));
319
  sb->append(libname);
320
  sb->append (JvNewStringLatin1 (_Jv_platform_solib_suffix));
321
 
322
  return sb->toString();
323
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.