1999-04-07 16:42:40 +02:00
|
|
|
// jvm.h - Header file for private implementation information. -*- c++ -*-
|
|
|
|
|
2002-04-11 17:57:56 +02:00
|
|
|
/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
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. */
|
|
|
|
|
|
|
|
#ifndef __JAVA_JVM_H__
|
|
|
|
#define __JAVA_JVM_H__
|
|
|
|
|
2001-12-16 23:33:02 +01:00
|
|
|
// Define this before including jni.h.
|
|
|
|
// jni.h is included by jvmpi.h, which might be included. We define
|
|
|
|
// this unconditionally because it is convenient and it lets other
|
|
|
|
// files include jni.h without difficulty.
|
|
|
|
#define __GCJ_JNI_IMPL__
|
|
|
|
|
1999-09-11 00:03:10 +02:00
|
|
|
#include <gcj/javaprims.h>
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
#include <java-assert.h>
|
1999-09-11 00:03:10 +02:00
|
|
|
#include <java-threads.h>
|
|
|
|
// Must include java-gc.h before Object.h for the implementation.
|
|
|
|
#include <java-gc.h>
|
|
|
|
|
|
|
|
#include <java/lang/Object.h>
|
|
|
|
|
|
|
|
// Include cni.h before field.h to enable all definitions. FIXME.
|
|
|
|
#include <gcj/cni.h>
|
|
|
|
#include <gcj/field.h>
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
/* Structure of the virtual table. */
|
|
|
|
struct _Jv_VTable
|
|
|
|
{
|
2001-09-21 18:59:12 +02:00
|
|
|
#ifdef __ia64__
|
|
|
|
typedef struct { void *pc, *gp; } vtable_elt;
|
|
|
|
#else
|
|
|
|
typedef void *vtable_elt;
|
|
|
|
#endif
|
2001-12-14 19:43:55 +01:00
|
|
|
jclass clas;
|
|
|
|
void *gc_descr;
|
2001-09-21 18:59:12 +02:00
|
|
|
|
|
|
|
// This must be last, as derived classes "extend" this by
|
|
|
|
// adding new data members.
|
|
|
|
vtable_elt method[1];
|
|
|
|
|
|
|
|
#ifdef __ia64__
|
|
|
|
void *get_method(int i) { return &method[i]; }
|
|
|
|
void set_method(int i, void *fptr) { method[i] = *(vtable_elt *)fptr; }
|
2001-12-14 19:43:55 +01:00
|
|
|
void *get_finalizer()
|
|
|
|
{
|
|
|
|
// We know that get_finalizer is only used for checking whether
|
|
|
|
// this object needs to have a finalizer registered. So it is
|
|
|
|
// safe to simply return just the PC component of the vtable
|
|
|
|
// slot.
|
|
|
|
return ((vtable_elt *)(get_method(0)))->pc;
|
|
|
|
}
|
2001-09-21 18:59:12 +02:00
|
|
|
#else
|
|
|
|
void *get_method(int i) { return method[i]; }
|
|
|
|
void set_method(int i, void *fptr) { method[i] = fptr; }
|
2001-12-14 19:43:55 +01:00
|
|
|
void *get_finalizer() { return get_method(0); }
|
2001-09-21 18:59:12 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
static size_t vtable_elt_size() { return sizeof(vtable_elt); }
|
java-tree.h (otable_methods, [...]): New field/global tree definitions.
gcc/java:
* java-tree.h (otable_methods, otable_decl, otable_syms_decl,
otable_type, otable_ptr_type, method_symbol_type,
method_symbols_array_type, method_symbols_array_ptr_type): New
field/global tree definitions.
(flag_indirect_dispatch): New flag.
* decl.c (java_init_decl_processing): Initialize new otable and
otable_syms type nodes and decls. Add new field "index" to
method_type_node.
* class.c (build_method_symbols_entry): New function.
(make_method_value): Set "index" to to method's vtable index for
virtual methods when indirect-dispatch is not used.
(make_class_data): For indirect-dispatch, dont emit the dtable_decl,
and set vtable_method_count to -1. Set otable and otable_syms field
if indirect-dispatch is used and there was something to put in them.
(build_method_symbols_entry): New function.
(emit_offset_symbol_table): New function.
* expr.c (get_offset_table_index): New function.
(build_invokevirtual): Build array reference to otable at the index
returned by get_offset_table_index, and use the result as the vtable
offset.
(build_invokeinterface): Similar.
* jcf-parse.c (yyparse): If indirect-dispatch, call
emit_offset_symbol_table at the end of compilation, after all classes
have been generated.
* jvspec.c: Don't pass findirect-dispatch to jvgenmain.
* lang.c (flag_indirect_dispatch): Define.
(lang_f_options): Add indirect-dispatch flag.
libjava:
* include/jvm.h (_Jv_VTable::idx_to_offset): New method.
* java/lang/natClassLoader.cc (_Jv_PrepareCompiledClass): Call
_Jv_MakeVTable and _Jv_LinkOffsetTable if needed.
* java/lang/Class.h (_Jv_Method): Add "index" field.
(_Jv_MethodSymbol): New struct type.
(_Jv_LinkOffsetTable, _Jv_LayoutVTableMethods, _Jv_SetVTableEntries,
_Jv_MakeVTable): Friends.
(otable, otable_syms): New Class fields.
* java/lang/natClass.cc (_Jv_LinkOffsetTable): New function.
(isVirtualMethod): New static function.
(_Jv_LayoutVTableMethods): New function.
(_Jv_SetVTableEntries): New function.
(_Jv_MakeVTable): New function.
From-SVN: r48038
2001-12-15 09:31:49 +01:00
|
|
|
|
|
|
|
// Given a method index, return byte offset from the vtable pointer.
|
|
|
|
static jint idx_to_offset (int index)
|
|
|
|
{
|
|
|
|
return (2 * sizeof (void *)) + (index * vtable_elt_size ());
|
|
|
|
}
|
2001-09-21 18:59:12 +02:00
|
|
|
static _Jv_VTable *new_vtable (int count);
|
1999-04-07 16:42:40 +02:00
|
|
|
};
|
|
|
|
|
2000-06-01 01:50:37 +02:00
|
|
|
// Number of virtual methods on object. FIXME: it sucks that we have
|
|
|
|
// to keep this up to date by hand.
|
|
|
|
#define NUM_OBJECT_METHODS 5
|
|
|
|
|
|
|
|
// This structure is the type of an array's vtable.
|
2001-09-21 18:59:12 +02:00
|
|
|
struct _Jv_ArrayVTable : public _Jv_VTable
|
2000-06-01 01:50:37 +02:00
|
|
|
{
|
2001-09-21 18:59:12 +02:00
|
|
|
vtable_elt extra_method[NUM_OBJECT_METHODS - 1];
|
2000-06-01 01:50:37 +02:00
|
|
|
};
|
|
|
|
|
2000-04-21 00:24:33 +02:00
|
|
|
union _Jv_word
|
|
|
|
{
|
|
|
|
jobject o;
|
|
|
|
jint i; // Also stores smaller integral types.
|
|
|
|
jfloat f;
|
|
|
|
jint ia[1]; // Half of _Jv_word2.
|
|
|
|
void* p;
|
|
|
|
|
|
|
|
#if SIZEOF_VOID_P == 8
|
|
|
|
// We can safely put a long or a double in here without increasing
|
|
|
|
// the size of _Jv_Word; we take advantage of this in the interpreter.
|
|
|
|
jlong l;
|
|
|
|
jdouble d;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
jclass clazz;
|
|
|
|
jstring string;
|
|
|
|
struct _Jv_Field *field;
|
|
|
|
struct _Jv_Utf8Const *utf8;
|
|
|
|
struct _Jv_ResolvedMethod *rmethod;
|
|
|
|
};
|
|
|
|
|
|
|
|
union _Jv_word2
|
|
|
|
{
|
|
|
|
jint ia[2];
|
|
|
|
jlong l;
|
|
|
|
jdouble d;
|
|
|
|
};
|
|
|
|
|
2002-08-29 19:53:28 +02:00
|
|
|
// An instance of this type is used to represent a single frame in a
|
|
|
|
// backtrace. If the interpreter has been built, we also include
|
|
|
|
// information about the interpreted method.
|
|
|
|
struct _Jv_frame_info
|
|
|
|
{
|
|
|
|
// PC value.
|
|
|
|
void *addr;
|
|
|
|
#ifdef INTERPRETER
|
|
|
|
// Actually a _Jv_InterpMethod, but we don't want to include
|
|
|
|
// java-interp.h everywhere.
|
|
|
|
void *interp;
|
|
|
|
#endif // INTERPRETER
|
|
|
|
};
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
/* Extract a character from a Java-style Utf8 string.
|
|
|
|
* PTR points to the current character.
|
|
|
|
* LIMIT points to the end of the Utf8 string.
|
|
|
|
* PTR is incremented to point after the character thta gets returns.
|
|
|
|
* On an error, -1 is returned. */
|
|
|
|
#define UTF8_GET(PTR, LIMIT) \
|
|
|
|
((PTR) >= (LIMIT) ? -1 \
|
|
|
|
: *(PTR) < 128 ? *(PTR)++ \
|
|
|
|
: (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
|
|
|
|
? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
|
|
|
|
: (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
|
|
|
|
&& ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
|
|
|
|
? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
|
|
|
|
: ((PTR)++, -1))
|
|
|
|
|
|
|
|
extern int _Jv_strLengthUtf8(char* str, int len);
|
|
|
|
|
|
|
|
typedef struct _Jv_Utf8Const Utf8Const;
|
|
|
|
_Jv_Utf8Const *_Jv_makeUtf8Const (char *s, int len);
|
[multiple changes]
1999-08-09 Anthony Green <green@cygnus.com>
* gij.cc: New file.
* include/config.h.in: Rebuilt.
* acconfig.h: Add INTERPRETER.
* configure: Rebuilt.
* Makefile.in: Rebuilt.
* Makefile.am (libffi_files): Identify the libffi object files for
inclusion in libgcj.
(LIBFFIINCS): Define.
* interpret.cc (gnu::gcj::runtime::MethodInvocation::continue1):
Dummy definition for configurations without an interpreter.
* java/net/natPlainSocketImpl.cc (getOption): Disamiguate call to
java::lang::Boolean constructor.
* include/java-interp.h: Always include java-cpool.h.
* java/lang/natClassLoader.cc (getVMClassLoader0): Always return 0
when INTERPRETER not defined.
* java/lang/Class.h (finalize): Define.
* gnu/gcj/util/path/DirectoryPathEntry.java (getURL): Catch
IOException from File.getCanonicalPath.
(getStream): Likewise.
* NEWS: More news.
* THANKS: More thanks.
1999-08-09 Kresten Krab Thorup <krab@gnu.org>
* resolve.cc (get_ffi_type_from_signature): Generate uint16 for
jchar type.
(_Jv_PrepareClass): Allow non-abstract classes to
have abstract subclasses.
(_Jv_ResolvePoolEntry): Revert subclass check for protected
fields and methods.
* interpret.cc (continue1/perform_invoke): Don't sign extend
uint16 return val.
(continue1/lshl,lshr): Push long, not int.
(continue1/ulshr): Use UINT64, not long long.
* defineclass.cc (handleFieldsEnd): Handle case when all fields
are static.
* java/lang/natClass.cc (forName): Add call to _Jv_InitClass.
* java/lang/FirstThread.java (run): Add top-level exception
handler.
(run0): Renamed from run.
1999-08-08 Kresten Krab Thorup <krab@gnu.org>
* configure.in (--with-interpreter): Added.
* include/config.h.in (INTERPRETER): Added.
* java/lang/ClassLoader.java: File replaced.
* java/lang/VMClassLoader.java: New file.
* java/lang/natClassLoader.cc: New file.
* gnu/gcj/runtime/MethodInvocation.java: New file.
* gnu/gcj/util/path/SearchPath.java: New file.
* gnu/gcj/util/path/PathEntry.java: New file.
* gnu/gcj/util/path/DirectoryPathEntry.java: New file.
* gnu/gcj/util/path/ZipPathEntry.java: New file.
* gnu/gcj/util/path/URLPathEntry.java: New file.
* gnu/gcj/util/path/CacheEntry.java: New file.
* include/java-interp.h: New file.
* include/java-cpool.h: New file.
* include/java-insns.h: New file.
* defineclass.cc: New file.
* interpret.cc: New file.
* resolve.cc: New file.
* java/lang/natClass.cc (loaded_classes, _Jv_RegisterClass,
_Jv_RegisterClasses, _Jv_FindClassInCache, _Jv_FindClass,
_Jv_NewClass, _Jv_FindArrayClass): Moved to natClassLoader.cc.
(finalize): New.
(STATE_NOTHING, STATE_RESOLVED, STATE_IN_PROGRESS, STATE_DONE,
STATE_ERROR): Moved to java/lang/Class.h and renamed with JV_
prefix.
(initializeClass): Use new JV_ prefixed names. Also, call
ClassLoader::resolveClass instead of _Jv_ResolveClass.
* java/lang/Class.h (JV_STATE_PRELOADING, JV_STATE_LOADING,
JV_STATE_LOADED, JV_STATE_COMPILED, JV_STATE_PREPARED,
JV_STATE_LINKED): New.
(_Jv_WaitForState, _Jv_RegisterInitiatingLoader,
_Jv_UnregisterClass, _Jv_InternClassStrings): New friends.
(_Jv_IsInterpretedClass, _Jv_InitField, _Jv_LookupDeclaredMethod,
_Jv_DetermineVTableIndex, _Jv_ResolvePoolEntry, _Jv_PrepareClass,
_Jv_ClassReader, _Jv_InterpClass, _Jv_InterpMethod,
_Jv_InterpMethodInvocation): New friends for interpreter.
(finalize): New.
(CONSTANT_Class, CONSTANT_String, etc.): Moved to
include/java-cpool.h and renamed with JV_ prefix.
* include/jvm.h (_Jv_makeUtf8Const, _Jv_makeUtf8TypeConst): New
decls.
(_Jv_UnregisterClass): New decl.
* java/lang/natClassLoader.cc (_Jv_FindArrayClass): Added
class loader argument.
(_Jv_FindClass): Use class loader.
* prims.cc (_Jv_makeUtf8Const): New function.
(_Jv_NewObjectArray): Change use of _Jv_FindArrayClass.
(_Jv_NewPrimArray): Ditto.
(_Jv_FindClassFromSignature): Ditto.
* java/lang/reflect/natArray.cc (newInstance): Ditto.
* java/lang/reflect/natMethod.cc (getType): Ditto.
* include/java-field.h (_Jv_Field::isRef): Make robust for
non-resolved contexts.
* boehm.cc (_Jv_MarkObj): Mark interpreter-related fields.
Also, don't mark class->next field.
* java/lang/VirtualMachineError.java: Added FIXME note.
* configure.in (INTERPSPEC): New spec.
* libgcj.spec.in: Added INTERPSPEC.
* Makefile.am: Added gcjh friends for java/lang/VMClassLoader and
gnu/gcj/runtime/MethodInvocation.
(libgcj_la_SOURCES): Added resolve.cc defineclass.cc interpret.cc.
(ordinary_java_source_files): Added above mentioned java classes.
* configure: Rebuilt.
* Makefile.in: Rebuilt.
From-SVN: r28597
1999-08-08 16:06:23 +02:00
|
|
|
_Jv_Utf8Const *_Jv_makeUtf8Const (jstring string);
|
1999-04-07 16:42:40 +02:00
|
|
|
extern jboolean _Jv_equalUtf8Consts (_Jv_Utf8Const *, _Jv_Utf8Const *);
|
|
|
|
extern jboolean _Jv_equal (_Jv_Utf8Const *, jstring, jint);
|
2000-01-04 09:46:52 +01:00
|
|
|
extern jboolean _Jv_equaln (_Jv_Utf8Const *, jstring, jint);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
natField.cc (BooleanClass): Don't define.
* java/lang/reflect/natField.cc (BooleanClass): Don't define.
* java/lang/reflect/natArray.cc (BooleanClass): Don't define.
* java/lang/Class.h (Object): Added `class$' field.
* java/lang/Object.h (Object): Added `class$' field.
* defineclass.cc (ClassClass): Use `class$' form.
(ClassObject): Likewise.
* resolve.cc (ClassObject): Use `class$' form.
(ObjectClass): Likewise.
* interpret.cc (ClassError): Removed.
* java/net/natPlainDatagramSocketImpl.cc (BooleanClass): Use
`class$' form.
(IntegerClass): Likewise.
* java/net/natPlainSocketImpl.cc (BooleanClass): Use `class$'
form.
* java/lang/natClassLoader.cc (CloneableClass): Use `class$' form.
(ObjectClass, ClassClass, VMClassLoaderClass, ClassLoaderClass,
SerializableClass): Likewise.
Include Serializable.h, Cloneable.h.
* java/lang/natSystem.cc (SystemClass): Removed.
(init_properties): Use `class$' form.
* java/lang/natObject.cc (CloneableClass): Removed.
(clone): Use `class$' form.
* java/lang/natClass.cc (CloneableClass): Use `class$' form.
(ObjectClass, ErrorClass, ClassClass, MethodClass, FieldClass,
ConstructorClass): Likewise.
* java/lang/reflect/natMethod.cc (ObjectClass): Use `class$' form.
(ClassClass, VoidClass, ByteClass, ShortClass, CharacterClass,
IntegerClass, LongClass, FloatClass, DoubleClass): Likewise.
* java/io/natObjectInputStream.cc (ObjectClass): Use `class$'
form.
(ClassClass): Likewise.
* include/jvm.h (StringClass): Use `class$' form.
* prims.cc (ObjectClass): Removed.
(_Jv_RunMain): Use `class$' form.
(_Jv_AllocObject): Likewise.
* jni.cc (ClassClass): Use `class$' form.
(ThrowableClass): Likewise.
(ObjectClass): Likewise.
(MethodClass): Likewise.
(ThreadGroupClass): Likewise.
(NativeThreadClass): Likewise.
* boehm.cc (ObjectClass): Removed.
(ClassClass): Removed.
(_Jv_MarkObj): Use `class$' form.
* gcj/field.h (JvFieldIsRef): Use `class$' form.
Include RawData.h.
From-SVN: r36740
2000-10-06 03:49:32 +02:00
|
|
|
// FIXME: remove this define.
|
|
|
|
#define StringClass java::lang::String::class$
|
1999-04-07 16:42:40 +02:00
|
|
|
|
2001-10-16 10:35:17 +02:00
|
|
|
namespace gcj
|
|
|
|
{
|
|
|
|
/* Some constants used during lookup of special class methods. */
|
|
|
|
extern _Jv_Utf8Const *void_signature; /* "()V" */
|
|
|
|
extern _Jv_Utf8Const *clinit_name; /* "<clinit>" */
|
|
|
|
extern _Jv_Utf8Const *init_name; /* "<init>" */
|
|
|
|
extern _Jv_Utf8Const *finit_name; /* "finit$", */
|
2001-10-23 07:42:03 +02:00
|
|
|
|
|
|
|
/* Set to true by _Jv_CreateJavaVM. */
|
|
|
|
extern bool runtimeInitialized;
|
2001-10-16 10:35:17 +02:00
|
|
|
};
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
/* Type of pointer used as finalizer. */
|
|
|
|
typedef void _Jv_FinalizerFunc (jobject);
|
|
|
|
|
|
|
|
/* Allocate space for a new Java object. */
|
2000-09-30 11:56:58 +02:00
|
|
|
void *_Jv_AllocObj (jsize size, jclass cl) __attribute__((__malloc__));
|
2001-05-24 07:40:37 +02:00
|
|
|
/* Allocate space for a potentially uninitialized pointer-free object.
|
|
|
|
Interesting only with JV_HASH_SYNCHRONIZATION. */
|
|
|
|
void *_Jv_AllocPtrFreeObj (jsize size, jclass cl) __attribute__((__malloc__));
|
1999-04-07 16:42:40 +02:00
|
|
|
/* Allocate space for an array of Java objects. */
|
2000-09-30 11:56:58 +02:00
|
|
|
void *_Jv_AllocArray (jsize size, jclass cl) __attribute__((__malloc__));
|
1999-04-07 16:42:40 +02:00
|
|
|
/* Allocate space that is known to be pointer-free. */
|
1999-12-06 07:33:56 +01:00
|
|
|
void *_Jv_AllocBytes (jsize size) __attribute__((__malloc__));
|
2001-09-10 03:21:08 +02:00
|
|
|
/* Allocate space for a new non-Java object, which does not have the usual
|
|
|
|
Java object header but may contain pointers to other GC'ed objects. */
|
|
|
|
void *_Jv_AllocRawObj (jsize size) __attribute__((__malloc__));
|
2001-05-24 07:40:37 +02:00
|
|
|
/* Explicitly throw an out-of-memory exception. */
|
2001-05-30 00:18:41 +02:00
|
|
|
void _Jv_ThrowNoMemory() __attribute__((__noreturn__));
|
2001-05-24 07:40:37 +02:00
|
|
|
/* Allocate an object with a single pointer. The first word is reserved
|
|
|
|
for the GC, and the second word is the traced pointer. */
|
|
|
|
void *_Jv_AllocTraceOne (jsize size /* incl. reserved slot */);
|
2001-10-16 00:42:42 +02:00
|
|
|
/* Ditto, but for two traced pointers. */
|
|
|
|
void *_Jv_AllocTraceTwo (jsize size /* incl. reserved slot */);
|
1999-04-07 16:42:40 +02:00
|
|
|
/* Initialize the GC. */
|
|
|
|
void _Jv_InitGC (void);
|
|
|
|
/* Register a finalizer. */
|
|
|
|
void _Jv_RegisterFinalizer (void *object, _Jv_FinalizerFunc *method);
|
2000-09-30 11:56:58 +02:00
|
|
|
/* Compute the GC descriptor for a class */
|
|
|
|
void * _Jv_BuildGCDescr(jclass);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
2000-02-01 07:14:26 +01:00
|
|
|
/* Allocate some unscanned, unmoveable memory. Return NULL if out of
|
|
|
|
memory. */
|
|
|
|
void *_Jv_MallocUnchecked (jsize size) __attribute__((__malloc__));
|
|
|
|
|
2001-10-11 00:25:43 +02:00
|
|
|
/* Initialize finalizers. The argument is a function to be called
|
|
|
|
when a finalizer is ready to be run. */
|
|
|
|
void _Jv_GCInitializeFinalizers (void (*notifier) (void));
|
1999-04-07 16:42:40 +02:00
|
|
|
/* Run finalizers for objects ready to be finalized.. */
|
|
|
|
void _Jv_RunFinalizers (void);
|
|
|
|
/* Run all finalizers. Should be called only before exit. */
|
|
|
|
void _Jv_RunAllFinalizers (void);
|
|
|
|
/* Perform a GC. */
|
|
|
|
void _Jv_RunGC (void);
|
2000-04-02 17:34:17 +02:00
|
|
|
/* Disable and enable GC. */
|
|
|
|
void _Jv_DisableGC (void);
|
|
|
|
void _Jv_EnableGC (void);
|
2001-10-02 16:31:47 +02:00
|
|
|
/* Register a disappearing link. This is a field F which should be
|
|
|
|
cleared when *F is found to be inaccessible. This is used in the
|
|
|
|
implementation of java.lang.ref.Reference. */
|
|
|
|
void _Jv_GCRegisterDisappearingLink (jobject *objp);
|
|
|
|
/* Return true if OBJECT should be reclaimed. This is used to
|
|
|
|
implement soft references. */
|
|
|
|
jboolean _Jv_GCCanReclaimSoftReference (jobject obj);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
/* Return approximation of total size of heap. */
|
|
|
|
long _Jv_GCTotalMemory (void);
|
|
|
|
/* Return approximation of total free memory. */
|
|
|
|
long _Jv_GCFreeMemory (void);
|
|
|
|
|
1999-10-22 21:43:41 +02:00
|
|
|
/* Set initial heap size. If SIZE==0, ignore. Should be run before
|
|
|
|
_Jv_InitGC. Not required to have any actual effect. */
|
|
|
|
void _Jv_GCSetInitialHeapSize (size_t size);
|
|
|
|
|
|
|
|
/* Set maximum heap size. If SIZE==0, unbounded. Should be run
|
|
|
|
before _Jv_InitGC. Not required to have any actual effect. */
|
|
|
|
void _Jv_GCSetMaximumHeapSize (size_t size);
|
|
|
|
|
|
|
|
/* External interface to setting the heap size. Parses ARG (a number
|
|
|
|
which can optionally have "k" or "m" appended and calls
|
|
|
|
_Jv_GCSetInitialHeapSize. */
|
|
|
|
void _Jv_SetInitialHeapSize (const char *arg);
|
|
|
|
|
|
|
|
/* External interface to setting the maximum heap size. Parses ARG (a
|
|
|
|
number which can optionally have "k" or "m" appended and calls
|
|
|
|
_Jv_GCSetMaximumHeapSize. */
|
|
|
|
void _Jv_SetMaximumHeapSize (const char *arg);
|
|
|
|
|
|
|
|
extern "C" void JvRunMain (jclass klass, int argc, const char **argv);
|
2001-08-26 13:30:09 +02:00
|
|
|
void _Jv_RunMain (jclass klass, const char *name, int argc, const char **argv,
|
|
|
|
bool is_jar);
|
1999-10-22 21:43:41 +02:00
|
|
|
|
2001-09-21 18:59:12 +02:00
|
|
|
// Delayed until after _Jv_AllocBytes is declared.
|
|
|
|
//
|
|
|
|
// Note that we allocate this as unscanned memory -- the vtables
|
|
|
|
// are handled specially by the GC.
|
|
|
|
|
|
|
|
inline _Jv_VTable *
|
|
|
|
_Jv_VTable::new_vtable (int count)
|
|
|
|
{
|
|
|
|
size_t size = sizeof(_Jv_VTable) + (count - 1) * vtable_elt_size ();
|
|
|
|
return (_Jv_VTable *) _Jv_AllocBytes (size);
|
|
|
|
}
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
// This function is used to determine the hash code of an object.
|
|
|
|
inline jint
|
|
|
|
_Jv_HashCode (jobject obj)
|
|
|
|
{
|
2000-08-16 17:30:02 +02:00
|
|
|
// This was chosen to yield relatively well distributed results on
|
2000-09-07 00:25:56 +02:00
|
|
|
// both 32- and 64-bit architectures. Note 0x7fffffff is prime.
|
|
|
|
// FIXME: we assume sizeof(long) == sizeof(void *).
|
|
|
|
return (jint) ((unsigned long) obj % 0x7fffffff);
|
1999-04-07 16:42:40 +02:00
|
|
|
}
|
|
|
|
|
1999-11-25 01:36:51 +01:00
|
|
|
// Return a raw pointer to the elements of an array given the array
|
|
|
|
// and its element type. You might think we could just pick a single
|
|
|
|
// array type and use elements() on it, but we can't because we must
|
2000-04-04 01:36:49 +02:00
|
|
|
// account for alignment of the element type. When ARRAY is null, we
|
|
|
|
// obtain the number of bytes taken by the base part of the array.
|
1999-11-25 01:36:51 +01:00
|
|
|
inline char *
|
|
|
|
_Jv_GetArrayElementFromElementType (jobject array,
|
|
|
|
jclass element_type)
|
|
|
|
{
|
|
|
|
char *elts;
|
|
|
|
if (element_type == JvPrimClass (byte))
|
|
|
|
elts = (char *) elements ((jbyteArray) array);
|
|
|
|
else if (element_type == JvPrimClass (short))
|
|
|
|
elts = (char *) elements ((jshortArray) array);
|
|
|
|
else if (element_type == JvPrimClass (int))
|
|
|
|
elts = (char *) elements ((jintArray) array);
|
|
|
|
else if (element_type == JvPrimClass (long))
|
|
|
|
elts = (char *) elements ((jlongArray) array);
|
|
|
|
else if (element_type == JvPrimClass (boolean))
|
|
|
|
elts = (char *) elements ((jbooleanArray) array);
|
|
|
|
else if (element_type == JvPrimClass (char))
|
|
|
|
elts = (char *) elements ((jcharArray) array);
|
|
|
|
else if (element_type == JvPrimClass (float))
|
|
|
|
elts = (char *) elements ((jfloatArray) array);
|
|
|
|
else if (element_type == JvPrimClass (double))
|
|
|
|
elts = (char *) elements ((jdoubleArray) array);
|
|
|
|
else
|
|
|
|
elts = (char *) elements ((jobjectArray) array);
|
|
|
|
return elts;
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:57:56 +02:00
|
|
|
extern "C" void _Jv_ThrowBadArrayIndex (jint bad_index)
|
|
|
|
__attribute__((noreturn));
|
|
|
|
extern "C" void _Jv_ThrowNullPointerException (void)
|
|
|
|
__attribute__((noreturn));
|
1999-12-06 07:33:56 +01:00
|
|
|
extern "C" jobject _Jv_NewArray (jint type, jint size)
|
|
|
|
__attribute__((__malloc__));
|
|
|
|
extern "C" jobject _Jv_NewMultiArray (jclass klass, jint dims, ...)
|
|
|
|
__attribute__((__malloc__));
|
1999-04-07 16:42:40 +02:00
|
|
|
extern "C" void *_Jv_CheckCast (jclass klass, jobject obj);
|
|
|
|
extern "C" void *_Jv_LookupInterfaceMethod (jclass klass, Utf8Const *name,
|
resolve.cc (_Jv_SearchMethodInClass): New function.
2000-03-07 Bryce McKinlay <bryce@albatross.co.nz>
* resolve.cc (_Jv_SearchMethodInClass): New function.
(_Jv_ResolvePoolEntry): Search superinterfaces for interface
methods.
* java/lang/Class.h (_Jv_SearchMethodInClass): New prototype.
2000-03-07 Bryce McKinlay <bryce@albatross.co.nz>
* java/lang/Class.h (union _Jv_IDispatchTable): New declaration.
(struct _Jv_ifaces): New declaration.
JV_CLASS: New macro definition.
(getComponentType): Relocate below isArray() for inlining.
(getModifiers): Declare `inline'.
(getSuperclass): Ditto.
(isArray): Ditto.
(isPrimitive): Ditto.
(_Jv_IsAssignableFrom): New prototype.
(_Jv_LookupInterfaceMethodIdx): New prototype. Predeclare with "C"
linkage.
(_Jv_InitClass): Move from natClass.cc. Declare `inline'.
Check for JV_STATE_DONE before invoking initializeClass().
(_Jv_PrepareConstantTimeTables): New prototype.
(_Jv_GetInterfaces): Ditto.
(_Jv_GenerateITable): Ditto.
(_Jv_GetMethodString): Ditto.
(_Jv_AppendPartialITable): Ditto.
(_Jv_FindIIndex): Ditto.
depth, ancestors, idt: New class fields.
* java/lang/natClass.cc (isAssignableFrom): Move functionality to
inline function `_Jv_IsAssignableFrom'. Use that function.
(isInstance): Declare `inline'.
(initializeClass): Get lock on class before checking `state'. Unlock
before calling resolveClass0. Call _Jv_PrepareConstantTimeTables
with the lock held.
(_Jv_LookupInterfaceMethod): Use _Jv_GetMessageString.
(_Jv_IsAssignableFrom): New inline function. Test assignability
using class->depth and ancestor table.
(_Jv_IsInstanceOf): Use _Jv_IsAssignableFrom.
(_Jv_CheckCast): Move from prims.cc. Use JV_CLASS and
_Jv_IsAssignableFrom.
(_Jv_CheckArrayStore): Ditto.
(_Jv_LookupInterfaceMethodIdx): New function.
INITIAL_IOFFSETS_LEN, INITIAL_IFACES_LEN: New #defines.
(_Jv_PrepareConstantTimeTables): New function.
(_Jv_IndexOf): Ditto.
(_Jv_GetInterfaces): Ditto.
(_Jv_GenerateITable): Ditto.
(_Jv_GetMethodString): Ditto.
(_Jv_AppendPartialITable): Ditto.
iindex_mutex, iindex_mutex_initialized: New static fields.
(_Jv_FindIIndex): New function.
* java/lang/natClassLoader.cc (_Jv_NewClass): Set new jclass fields.
* prims.cc (_Jv_CheckCast): Moved to natClass.cc.
(_Jv_CheckArrayStore): Ditto.
(JvNewCharArray, JvNewBooleanArray, JvNewByteArray, JvNewShortArray,
JvNewIntArray, JvNewLongArray, JvNewFloatArray, JvNewDoubleArray):
Moved to gcj/array.h.
(_Jv_Realloc): New function.
* gcj/cni.h: Move _Jv_PrimClass definitions to gcj/array.h.
* gcj/array.h: _Jv_PrimClass definitions moved from gcj/cni.h.
(JvNewCharArray, JvNewBooleanArray, JvNewByteArray,
JvNewShortArray, JvNewIntArray, JvNewLongArray, JvNewFloatArray,
JvNewDoubleArray): Implementations moved from prims.cc and
declared `inline'.
* gcj/javaprims.h (_Jv_Realloc): Prototype.
* include/jvm.h (_Jv_LookupInterfaceMethodIdx): Prototype.
From-SVN: r32382
2000-03-07 10:52:56 +01:00
|
|
|
Utf8Const *signature);
|
|
|
|
extern "C" void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface,
|
|
|
|
int meth_idx);
|
1999-04-07 16:42:40 +02:00
|
|
|
extern "C" void _Jv_CheckArrayStore (jobject array, jobject obj);
|
|
|
|
extern "C" void _Jv_RegisterClass (jclass klass);
|
|
|
|
extern "C" void _Jv_RegisterClasses (jclass *classes);
|
2001-09-07 00:32:54 +02:00
|
|
|
extern "C" void _Jv_RegisterResource (void *vptr);
|
[multiple changes]
1999-08-09 Anthony Green <green@cygnus.com>
* gij.cc: New file.
* include/config.h.in: Rebuilt.
* acconfig.h: Add INTERPRETER.
* configure: Rebuilt.
* Makefile.in: Rebuilt.
* Makefile.am (libffi_files): Identify the libffi object files for
inclusion in libgcj.
(LIBFFIINCS): Define.
* interpret.cc (gnu::gcj::runtime::MethodInvocation::continue1):
Dummy definition for configurations without an interpreter.
* java/net/natPlainSocketImpl.cc (getOption): Disamiguate call to
java::lang::Boolean constructor.
* include/java-interp.h: Always include java-cpool.h.
* java/lang/natClassLoader.cc (getVMClassLoader0): Always return 0
when INTERPRETER not defined.
* java/lang/Class.h (finalize): Define.
* gnu/gcj/util/path/DirectoryPathEntry.java (getURL): Catch
IOException from File.getCanonicalPath.
(getStream): Likewise.
* NEWS: More news.
* THANKS: More thanks.
1999-08-09 Kresten Krab Thorup <krab@gnu.org>
* resolve.cc (get_ffi_type_from_signature): Generate uint16 for
jchar type.
(_Jv_PrepareClass): Allow non-abstract classes to
have abstract subclasses.
(_Jv_ResolvePoolEntry): Revert subclass check for protected
fields and methods.
* interpret.cc (continue1/perform_invoke): Don't sign extend
uint16 return val.
(continue1/lshl,lshr): Push long, not int.
(continue1/ulshr): Use UINT64, not long long.
* defineclass.cc (handleFieldsEnd): Handle case when all fields
are static.
* java/lang/natClass.cc (forName): Add call to _Jv_InitClass.
* java/lang/FirstThread.java (run): Add top-level exception
handler.
(run0): Renamed from run.
1999-08-08 Kresten Krab Thorup <krab@gnu.org>
* configure.in (--with-interpreter): Added.
* include/config.h.in (INTERPRETER): Added.
* java/lang/ClassLoader.java: File replaced.
* java/lang/VMClassLoader.java: New file.
* java/lang/natClassLoader.cc: New file.
* gnu/gcj/runtime/MethodInvocation.java: New file.
* gnu/gcj/util/path/SearchPath.java: New file.
* gnu/gcj/util/path/PathEntry.java: New file.
* gnu/gcj/util/path/DirectoryPathEntry.java: New file.
* gnu/gcj/util/path/ZipPathEntry.java: New file.
* gnu/gcj/util/path/URLPathEntry.java: New file.
* gnu/gcj/util/path/CacheEntry.java: New file.
* include/java-interp.h: New file.
* include/java-cpool.h: New file.
* include/java-insns.h: New file.
* defineclass.cc: New file.
* interpret.cc: New file.
* resolve.cc: New file.
* java/lang/natClass.cc (loaded_classes, _Jv_RegisterClass,
_Jv_RegisterClasses, _Jv_FindClassInCache, _Jv_FindClass,
_Jv_NewClass, _Jv_FindArrayClass): Moved to natClassLoader.cc.
(finalize): New.
(STATE_NOTHING, STATE_RESOLVED, STATE_IN_PROGRESS, STATE_DONE,
STATE_ERROR): Moved to java/lang/Class.h and renamed with JV_
prefix.
(initializeClass): Use new JV_ prefixed names. Also, call
ClassLoader::resolveClass instead of _Jv_ResolveClass.
* java/lang/Class.h (JV_STATE_PRELOADING, JV_STATE_LOADING,
JV_STATE_LOADED, JV_STATE_COMPILED, JV_STATE_PREPARED,
JV_STATE_LINKED): New.
(_Jv_WaitForState, _Jv_RegisterInitiatingLoader,
_Jv_UnregisterClass, _Jv_InternClassStrings): New friends.
(_Jv_IsInterpretedClass, _Jv_InitField, _Jv_LookupDeclaredMethod,
_Jv_DetermineVTableIndex, _Jv_ResolvePoolEntry, _Jv_PrepareClass,
_Jv_ClassReader, _Jv_InterpClass, _Jv_InterpMethod,
_Jv_InterpMethodInvocation): New friends for interpreter.
(finalize): New.
(CONSTANT_Class, CONSTANT_String, etc.): Moved to
include/java-cpool.h and renamed with JV_ prefix.
* include/jvm.h (_Jv_makeUtf8Const, _Jv_makeUtf8TypeConst): New
decls.
(_Jv_UnregisterClass): New decl.
* java/lang/natClassLoader.cc (_Jv_FindArrayClass): Added
class loader argument.
(_Jv_FindClass): Use class loader.
* prims.cc (_Jv_makeUtf8Const): New function.
(_Jv_NewObjectArray): Change use of _Jv_FindArrayClass.
(_Jv_NewPrimArray): Ditto.
(_Jv_FindClassFromSignature): Ditto.
* java/lang/reflect/natArray.cc (newInstance): Ditto.
* java/lang/reflect/natMethod.cc (getType): Ditto.
* include/java-field.h (_Jv_Field::isRef): Make robust for
non-resolved contexts.
* boehm.cc (_Jv_MarkObj): Mark interpreter-related fields.
Also, don't mark class->next field.
* java/lang/VirtualMachineError.java: Added FIXME note.
* configure.in (INTERPSPEC): New spec.
* libgcj.spec.in: Added INTERPSPEC.
* Makefile.am: Added gcjh friends for java/lang/VMClassLoader and
gnu/gcj/runtime/MethodInvocation.
(libgcj_la_SOURCES): Added resolve.cc defineclass.cc interpret.cc.
(ordinary_java_source_files): Added above mentioned java classes.
* configure: Rebuilt.
* Makefile.in: Rebuilt.
From-SVN: r28597
1999-08-08 16:06:23 +02:00
|
|
|
extern void _Jv_UnregisterClass (_Jv_Utf8Const*, java::lang::ClassLoader*);
|
2001-03-23 20:15:44 +01:00
|
|
|
extern void _Jv_ResolveField (_Jv_Field *, java::lang::ClassLoader*);
|
[multiple changes]
1999-08-09 Anthony Green <green@cygnus.com>
* gij.cc: New file.
* include/config.h.in: Rebuilt.
* acconfig.h: Add INTERPRETER.
* configure: Rebuilt.
* Makefile.in: Rebuilt.
* Makefile.am (libffi_files): Identify the libffi object files for
inclusion in libgcj.
(LIBFFIINCS): Define.
* interpret.cc (gnu::gcj::runtime::MethodInvocation::continue1):
Dummy definition for configurations without an interpreter.
* java/net/natPlainSocketImpl.cc (getOption): Disamiguate call to
java::lang::Boolean constructor.
* include/java-interp.h: Always include java-cpool.h.
* java/lang/natClassLoader.cc (getVMClassLoader0): Always return 0
when INTERPRETER not defined.
* java/lang/Class.h (finalize): Define.
* gnu/gcj/util/path/DirectoryPathEntry.java (getURL): Catch
IOException from File.getCanonicalPath.
(getStream): Likewise.
* NEWS: More news.
* THANKS: More thanks.
1999-08-09 Kresten Krab Thorup <krab@gnu.org>
* resolve.cc (get_ffi_type_from_signature): Generate uint16 for
jchar type.
(_Jv_PrepareClass): Allow non-abstract classes to
have abstract subclasses.
(_Jv_ResolvePoolEntry): Revert subclass check for protected
fields and methods.
* interpret.cc (continue1/perform_invoke): Don't sign extend
uint16 return val.
(continue1/lshl,lshr): Push long, not int.
(continue1/ulshr): Use UINT64, not long long.
* defineclass.cc (handleFieldsEnd): Handle case when all fields
are static.
* java/lang/natClass.cc (forName): Add call to _Jv_InitClass.
* java/lang/FirstThread.java (run): Add top-level exception
handler.
(run0): Renamed from run.
1999-08-08 Kresten Krab Thorup <krab@gnu.org>
* configure.in (--with-interpreter): Added.
* include/config.h.in (INTERPRETER): Added.
* java/lang/ClassLoader.java: File replaced.
* java/lang/VMClassLoader.java: New file.
* java/lang/natClassLoader.cc: New file.
* gnu/gcj/runtime/MethodInvocation.java: New file.
* gnu/gcj/util/path/SearchPath.java: New file.
* gnu/gcj/util/path/PathEntry.java: New file.
* gnu/gcj/util/path/DirectoryPathEntry.java: New file.
* gnu/gcj/util/path/ZipPathEntry.java: New file.
* gnu/gcj/util/path/URLPathEntry.java: New file.
* gnu/gcj/util/path/CacheEntry.java: New file.
* include/java-interp.h: New file.
* include/java-cpool.h: New file.
* include/java-insns.h: New file.
* defineclass.cc: New file.
* interpret.cc: New file.
* resolve.cc: New file.
* java/lang/natClass.cc (loaded_classes, _Jv_RegisterClass,
_Jv_RegisterClasses, _Jv_FindClassInCache, _Jv_FindClass,
_Jv_NewClass, _Jv_FindArrayClass): Moved to natClassLoader.cc.
(finalize): New.
(STATE_NOTHING, STATE_RESOLVED, STATE_IN_PROGRESS, STATE_DONE,
STATE_ERROR): Moved to java/lang/Class.h and renamed with JV_
prefix.
(initializeClass): Use new JV_ prefixed names. Also, call
ClassLoader::resolveClass instead of _Jv_ResolveClass.
* java/lang/Class.h (JV_STATE_PRELOADING, JV_STATE_LOADING,
JV_STATE_LOADED, JV_STATE_COMPILED, JV_STATE_PREPARED,
JV_STATE_LINKED): New.
(_Jv_WaitForState, _Jv_RegisterInitiatingLoader,
_Jv_UnregisterClass, _Jv_InternClassStrings): New friends.
(_Jv_IsInterpretedClass, _Jv_InitField, _Jv_LookupDeclaredMethod,
_Jv_DetermineVTableIndex, _Jv_ResolvePoolEntry, _Jv_PrepareClass,
_Jv_ClassReader, _Jv_InterpClass, _Jv_InterpMethod,
_Jv_InterpMethodInvocation): New friends for interpreter.
(finalize): New.
(CONSTANT_Class, CONSTANT_String, etc.): Moved to
include/java-cpool.h and renamed with JV_ prefix.
* include/jvm.h (_Jv_makeUtf8Const, _Jv_makeUtf8TypeConst): New
decls.
(_Jv_UnregisterClass): New decl.
* java/lang/natClassLoader.cc (_Jv_FindArrayClass): Added
class loader argument.
(_Jv_FindClass): Use class loader.
* prims.cc (_Jv_makeUtf8Const): New function.
(_Jv_NewObjectArray): Change use of _Jv_FindArrayClass.
(_Jv_NewPrimArray): Ditto.
(_Jv_FindClassFromSignature): Ditto.
* java/lang/reflect/natArray.cc (newInstance): Ditto.
* java/lang/reflect/natMethod.cc (getType): Ditto.
* include/java-field.h (_Jv_Field::isRef): Make robust for
non-resolved contexts.
* boehm.cc (_Jv_MarkObj): Mark interpreter-related fields.
Also, don't mark class->next field.
* java/lang/VirtualMachineError.java: Added FIXME note.
* configure.in (INTERPSPEC): New spec.
* libgcj.spec.in: Added INTERPSPEC.
* Makefile.am: Added gcjh friends for java/lang/VMClassLoader and
gnu/gcj/runtime/MethodInvocation.
(libgcj_la_SOURCES): Added resolve.cc defineclass.cc interpret.cc.
(ordinary_java_source_files): Added above mentioned java classes.
* configure: Rebuilt.
* Makefile.in: Rebuilt.
From-SVN: r28597
1999-08-08 16:06:23 +02:00
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
extern jclass _Jv_FindClass (_Jv_Utf8Const *name,
|
|
|
|
java::lang::ClassLoader *loader);
|
|
|
|
extern jclass _Jv_FindClassFromSignature (char *,
|
|
|
|
java::lang::ClassLoader *loader);
|
2000-01-04 09:46:52 +01:00
|
|
|
extern void _Jv_GetTypesFromSignature (jmethodID method,
|
|
|
|
jclass declaringClass,
|
|
|
|
JArray<jclass> **arg_types_out,
|
|
|
|
jclass *return_type_out);
|
natConstructor.cc (newInstance): Use _Jv_CallAnyMethodA.
* java/lang/reflect/natConstructor.cc (newInstance): Use
_Jv_CallAnyMethodA.
* include/jvm.h: Declare _Jv_CallAnyMethodA.
* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Renamed
from _Jv_CallNonvirtualMethodA. Changed interface; overloaded.
Include <jni.h>.
(COPY): Removed.
(invoke): Use _Jv_CallAnyMethodA.
(VAL): Redefined.
* java/lang/Class.h (Class): Declare JvGetFirstStaticField,
JvNumStaticFields, JvNumMethods, and JvGetFirstMethod as friend
functions.
(struct _Jv_Method): Added getNextMethod method.
(JvNumMethods): New function.
(JvGetFirstMethod): Likewise.
* gcj/field.h (JvGetFirstStaticField): New function.
(JvNumStaticFields): Likewise.
(getNextField): Renamed from getNextInstanceField.
(struct _Jv_Field): New method getClass.
* jni.cc: Wrote many new functions.
* include/jni.h (JNI_TRUE): Define.
(JNI_FALSE): Likewise.
(jobject, jclass, jstring, jarray, jthrowable, jobjectArray,
jbyteArray, jshortArray, jintArray, jlongArray, jbooleanArray,
jcharArray, jfloatArray, jdoubleArray): New typedefs.
(jfieldID, jmethodID): Likewise.
(JNI_COMMIT, JNI_ABORT): New defines.
(JNINativeMethod): New struct.
(struct JNINativeInterface): Correctly declared more entries.
(class _Jv_JNIEnv): Added `ex' member.
(JNI_VERSION_1_1): New define.
(JNI_VERSION_1_2): Likewise.
* boehm.cc (_Jv_MarkObj): Use getNextField, not
getNextInstanceField.
From-SVN: r31553
2000-01-22 00:50:31 +01:00
|
|
|
|
|
|
|
extern jobject _Jv_CallAnyMethodA (jobject obj, jclass return_type,
|
|
|
|
jmethodID meth, jboolean is_constructor,
|
|
|
|
JArray<jclass> *parameter_types,
|
|
|
|
jobjectArray args);
|
|
|
|
|
|
|
|
union jvalue;
|
|
|
|
extern jthrowable _Jv_CallAnyMethodA (jobject obj,
|
|
|
|
jclass return_type,
|
|
|
|
jmethodID meth,
|
|
|
|
jboolean is_constructor,
|
|
|
|
JArray<jclass> *parameter_types,
|
|
|
|
jvalue *args,
|
|
|
|
jvalue *result);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
1999-12-06 07:33:56 +01:00
|
|
|
extern jobject _Jv_NewMultiArray (jclass, jint ndims, jint* dims)
|
|
|
|
__attribute__((__malloc__));
|
1999-04-07 16:42:40 +02:00
|
|
|
|
1999-07-21 17:11:56 +02:00
|
|
|
/* Checked divide subroutines. */
|
|
|
|
extern "C"
|
|
|
|
{
|
|
|
|
jint _Jv_divI (jint, jint);
|
|
|
|
jint _Jv_remI (jint, jint);
|
|
|
|
jlong _Jv_divJ (jlong, jlong);
|
|
|
|
jlong _Jv_remJ (jlong, jlong);
|
|
|
|
}
|
|
|
|
|
2000-01-17 16:45:24 +01:00
|
|
|
/* get/set the name of the running executable. */
|
|
|
|
extern char *_Jv_ThisExecutable (void);
|
|
|
|
extern void _Jv_ThisExecutable (const char *);
|
|
|
|
|
2000-02-04 21:49:27 +01:00
|
|
|
/* Return a pointer to a symbol in executable or loaded library. */
|
|
|
|
void *_Jv_FindSymbolInExecutable (const char *);
|
|
|
|
|
2000-02-01 07:14:26 +01:00
|
|
|
/* Initialize JNI. */
|
|
|
|
extern void _Jv_JNI_Init (void);
|
|
|
|
|
2000-02-10 21:31:48 +01:00
|
|
|
/* Get or set the per-thread JNIEnv used by the invocation API. */
|
|
|
|
_Jv_JNIEnv *_Jv_GetCurrentJNIEnv ();
|
|
|
|
void _Jv_SetCurrentJNIEnv (_Jv_JNIEnv *);
|
|
|
|
|
2000-02-18 22:22:06 +01:00
|
|
|
struct _Jv_JavaVM;
|
2001-08-26 13:30:09 +02:00
|
|
|
_Jv_JavaVM *_Jv_GetJavaVM ();
|
2000-02-18 22:22:06 +01:00
|
|
|
|
2001-11-26 07:40:06 +01:00
|
|
|
// Some verification functions from defineclass.cc.
|
|
|
|
bool _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig);
|
|
|
|
bool _Jv_VerifyMethodSignature (_Jv_Utf8Const*sig);
|
|
|
|
bool _Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length);
|
|
|
|
bool _Jv_VerifyClassName (_Jv_Utf8Const *name);
|
|
|
|
bool _Jv_VerifyIdentifier (_Jv_Utf8Const *);
|
|
|
|
bool _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2);
|
|
|
|
|
2000-04-02 17:34:17 +02:00
|
|
|
#ifdef ENABLE_JVMPI
|
2001-12-16 23:33:02 +01:00
|
|
|
|
2000-04-02 17:34:17 +02:00
|
|
|
#include "jvmpi.h"
|
|
|
|
|
|
|
|
extern void (*_Jv_JVMPI_Notify_OBJECT_ALLOC) (JVMPI_Event *event);
|
|
|
|
extern void (*_Jv_JVMPI_Notify_THREAD_START) (JVMPI_Event *event);
|
|
|
|
extern void (*_Jv_JVMPI_Notify_THREAD_END) (JVMPI_Event *event);
|
|
|
|
#endif
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
#endif /* __JAVA_JVM_H__ */
|