// jvm.h - Header file for private implementation information. -*- c++ -*-
-/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation
This file is part of libgcj.
#include <gcj/cni.h>
#include <gcj/field.h>
+#include <java/lang/Thread.h>
+
+#include <sysdep/locks.h>
+
/* Macro for possible unused arguments. */
#define MAYBE_UNUSED __attribute__((__unused__))
typedef struct _Jv_Utf8Const Utf8Const;
_Jv_Utf8Const *_Jv_makeUtf8Const (const char *s, int len);
_Jv_Utf8Const *_Jv_makeUtf8Const (jstring string);
+static inline _Jv_Utf8Const *_Jv_makeUtf8Const (const char *s)
+{
+ return _Jv_makeUtf8Const (s, strlen (s));
+}
extern jboolean _Jv_equalUtf8Consts (const _Jv_Utf8Const *, const _Jv_Utf8Const *);
extern jboolean _Jv_equal (_Jv_Utf8Const *, jstring, jint);
extern jboolean _Jv_equaln (_Jv_Utf8Const *, jstring, jint);
/* Thread stack size specified by the -Xss runtime argument. */
extern size_t stack_size;
+
+ /* The start time */
+ extern jlong startTime;
+
+ /* The VM arguments */
+ extern JArray<jstring>* vmArgs;
+
+ // Currently loaded classes
+ extern jint loadedClasses;
+
+ // Unloaded classes
+ extern jlong unloadedClasses;
}
// This class handles all aspects of class preparation and linking.
jclass, jclass *);
static _Jv_Field *find_field(jclass, jclass, jclass *, _Jv_Utf8Const *,
_Jv_Utf8Const *);
+ static void check_loading_constraints (_Jv_Method *, jclass, jclass);
static void prepare_constant_time_tables(jclass);
static jshort get_interfaces(jclass, _Jv_ifaces *);
static void link_symbol_table(jclass);
static void link_exception_table(jclass);
static void layout_interface_methods(jclass);
- static void layout_vtable_methods(jclass);
static void set_vtable_entries(jclass, _Jv_VTable *);
static void make_vtable(jclass);
static void ensure_fields_laid_out(jclass);
static int get_alignment_from_class(jclass);
static void generate_itable(jclass, _Jv_ifaces *, jshort *);
static jshort append_partial_itable(jclass, jclass, void **, jshort);
- static _Jv_Method *search_method_in_class (jclass, jclass,
- _Jv_Utf8Const *,
- _Jv_Utf8Const *,
- bool check_perms = true);
static _Jv_Method *search_method_in_superclasses (jclass cls, jclass klass,
_Jv_Utf8Const *method_name,
_Jv_Utf8Const *method_signature,
jclass *found_class,
bool check_perms = true);
- static void *create_error_method(_Jv_Utf8Const *);
+ static void *create_error_method(_Jv_Utf8Const *, jclass);
/* The least significant bit of the signature pointer in a symbol
table is set to 1 by the compiler if the reference is "special",
s = signature;
}
+ static _Jv_Mutex_t resolve_mutex;
+ static void init (void) __attribute__((constructor));
+
public:
static bool has_field_p (jclass, _Jv_Utf8Const *);
static void print_class_loaded (jclass);
static void resolve_class_ref (jclass, jclass *);
static void wait_for_state(jclass, int);
+ static _Jv_Method *resolve_method_entry (jclass, jclass &,
+ int, int,
+ bool, bool);
static _Jv_word resolve_pool_entry (jclass, int, bool =false);
static void resolve_field (_Jv_Field *, java::lang::ClassLoader *);
static void verify_type_assertions (jclass);
+ static _Jv_Method *search_method_in_class (jclass, jclass,
+ _Jv_Utf8Const *,
+ _Jv_Utf8Const *,
+ bool check_perms = true);
+ static void layout_vtable_methods(jclass);
+
+ static jbyte read_cpool_entry (_Jv_word *data,
+ const _Jv_Constants *const pool,
+ int index)
+ {
+ _Jv_MutexLock (&resolve_mutex);
+ jbyte tags = pool->tags[index];
+ *data = pool->data[index];
+ _Jv_MutexUnlock (&resolve_mutex);
+ return tags;
+ }
+
+ static void write_cpool_entry (_Jv_word data, jbyte tags,
+ _Jv_Constants *pool,
+ int index)
+ {
+ _Jv_MutexLock (&resolve_mutex);
+ pool->data[index] = data;
+ pool->tags[index] = tags;
+ _Jv_MutexUnlock (&resolve_mutex);
+ }
};
/* Type of pointer used as finalizer. */
/* 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__));
+/* Allocate a double-indirect pointer to a _Jv_ClosureList such that
+ the _Jv_ClosureList gets automatically finalized when it is no
+ longer reachable, not even by other finalizable objects. */
+_Jv_ClosureList **_Jv_ClosureListFinalizer (void) __attribute__((__malloc__));
/* Explicitly throw an out-of-memory exception. */
void _Jv_ThrowNoMemory() __attribute__((__noreturn__));
/* Allocate an object with a single pointer. The first word is reserved
_Jv_GCSetMaximumHeapSize. */
void _Jv_SetMaximumHeapSize (const char *arg);
+/* External interface for setting the GC_free_space_divisor. Calls
+ GC_set_free_space_divisor and returns the old value. */
+int _Jv_SetGCFreeSpaceDivisor (int div);
+
/* Free the method cache, if one was allocated. This is only called
during thread deregistration. */
void _Jv_FreeMethodCache ();
void _Jv_SetStackSize (const char *arg);
extern "C" void JvRunMain (jclass klass, int argc, const char **argv);
+extern "C" void JvRunMainName (const char *name, int argc, const char **argv);
+
void _Jv_RunMain (jclass klass, const char *name, int argc, const char **argv,
bool is_jar);
jboolean is_constructor,
jboolean is_virtual_call,
JArray<jclass> *parameter_types,
- jvalue *args,
+ const jvalue *args,
jvalue *result,
jboolean is_jni_call = true,
jclass iface = NULL);
+extern void _Jv_CheckOrCreateLoadingConstraint (jclass,
+ java::lang::ClassLoader *);
+
extern jobject _Jv_NewMultiArray (jclass, jint ndims, jint* dims)
__attribute__((__malloc__));
/* Free a JNIEnv. */
void _Jv_FreeJNIEnv (_Jv_JNIEnv *);
-/* Free a JNIEnv. */
-void _Jv_FreeJNIEnv (_Jv_JNIEnv *);
+extern "C" void _Jv_JNI_PopSystemFrame (_Jv_JNIEnv *);
+_Jv_JNIEnv *_Jv_GetJNIEnvNewFrameWithLoader (::java::lang::ClassLoader *);
struct _Jv_JavaVM;
_Jv_JavaVM *_Jv_GetJavaVM ();
-/* Get the JVMTI environment */
+/* Get a JVMTI environment */
struct _Jv_JVMTIEnv;
_Jv_JVMTIEnv *_Jv_GetJVMTIEnv (void);
+/* Initialize JVMTI */
+extern void _Jv_JVMTI_Init (void);
+
// Some verification functions from defineclass.cc.
bool _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig);
bool _Jv_VerifyMethodSignature (_Jv_Utf8Const*sig);
// New style version IDs used by GCJ 4.0.1 and later.
#define GCJ_40_BC_ABI_VERSION (4 * 100000 + 0 * 1000)
-inline bool
-_Jv_CheckABIVersion (unsigned long value)
-{
- // We are compatible with GCJ 4.0.0 BC-ABI classes. This release used a
- // different format for the version ID string.
- if (value == OLD_GCJ_40_BC_ABI_VERSION)
- return true;
-
- // The 20 low-end bits are used for the version number.
- unsigned long version = value & 0xfffff;
-
- if (value & FLAG_BINARYCOMPAT_ABI)
- {
- int abi_rev = version % 100;
- int abi_ver = version - abi_rev;
- if (abi_ver == GCJ_40_BC_ABI_VERSION && abi_rev <= 0)
- return true;
- }
- else
- // C++ ABI
- return version == GCJ_CXX_ABI_VERSION;
-
- return false;
-}
+void _Jv_CheckABIVersion (unsigned long value);
+
inline bool
_Jv_ClassForBootstrapLoader (unsigned long value)
// A helper function defined in prims.cc.
char* _Jv_PrependVersionedLibdir (char* libpath);
+
+// An enum for use with JvSetThreadState. We use a C++ enum rather
+// than the Java enum to avoid problems with class initialization
+// during VM bootstrap.
+typedef enum
+{
+ JV_BLOCKED,
+ JV_NEW,
+ JV_RUNNABLE,
+ JV_TERMINATED,
+ JV_TIMED_WAITING,
+ JV_WAITING
+} JvThreadState;
+
+// Temporarily set the thread's state.
+class JvSetThreadState
+{
+private:
+ ::java::lang::Thread *thread;
+ jint saved;
+
+public:
+
+ // Note that 'cthread' could be NULL -- during VM startup there may
+ // not be a Thread available.
+ JvSetThreadState(::java::lang::Thread *cthread, JvThreadState nstate)
+ : thread (cthread),
+ saved (cthread ? cthread->state : (jint)JV_NEW)
+ {
+ if (thread)
+ thread->state = nstate;
+ }
+
+ ~JvSetThreadState()
+ {
+ if (thread)
+ thread->state = saved;
+ }
+};
+
+// This structure is used to represent all the data the native side
+// needs. An object of this type is assigned to the `data' member of
+// the Thread class.
+struct natThread
+{
+ // A thread is either alive, dead, or being sent a signal; if it is
+ // being sent a signal, it is also alive. Thus, if you want to know
+ // if a thread is alive, it is sufficient to test alive_status !=
+ // THREAD_DEAD.
+ volatile obj_addr_t alive_flag;
+
+ // These are used to interrupt sleep and join calls. We can share a
+ // condition variable here since it only ever gets notified when the thread
+ // exits.
+ _Jv_Mutex_t join_mutex;
+ _Jv_ConditionVariable_t join_cond;
+
+ // These are used by Unsafe.park() and Unsafe.unpark().
+ ParkHelper park_helper;
+
+ // This is private data for the thread system layer.
+ _Jv_Thread_t *thread;
+
+ // Each thread has its own JNI object.
+ _Jv_JNIEnv *jni_env;
+};
+
#endif /* __JAVA_JVM_H__ */
projects / gcc.git / blobdiff