From 58eb6e7cef1cea515f8da18d24341a4aa53ccb70 Mon Sep 17 00:00:00 2001 From: Anthony Green Date: Sun, 8 Aug 1999 14:06:23 +0000 Subject: [multiple changes] 1999-08-09 Anthony Green * 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 * 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 * 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 --- libjava/include/java-cpool.h | 173 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 libjava/include/java-cpool.h (limited to 'libjava/include/java-cpool.h') diff --git a/libjava/include/java-cpool.h b/libjava/include/java-cpool.h new file mode 100644 index 0000000..f4d7ef99 --- /dev/null +++ b/libjava/include/java-cpool.h @@ -0,0 +1,173 @@ +// java-cpool.h - Constant pool parsing header. -*- c++ -*- + +/* Copyright (C) 1999 Cygnus Solutions + + 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_CPOOL_H__ +#define __JAVA_CPOOL_H__ + +#include + +// we rename these, to avoid polluting the name space +#define JV_CONSTANT_Undefined (0L) +#define JV_CONSTANT_Utf8 (1L) +#define JV_CONSTANT_Unicode (2L) +#define JV_CONSTANT_Integer (3L) +#define JV_CONSTANT_Float (4L) +#define JV_CONSTANT_Long (5L) +#define JV_CONSTANT_Double (6L) +#define JV_CONSTANT_Class (7L) +#define JV_CONSTANT_String (8L) +#define JV_CONSTANT_Fieldref (9L) +#define JV_CONSTANT_Methodref (10L) +#define JV_CONSTANT_InterfaceMethodref (11L) +#define JV_CONSTANT_NameAndType (12L) +#define JV_CONSTANT_ResolvedFlag (16L) +#define JV_CONSTANT_ResolvedString (16L | 8L) +#define JV_CONSTANT_ResolvedClass (16L | 7L) + +/* We use the following two operations uniformly for all put/get operations + * in the runtime system (constant pool & stack), to assure that we keep + * everything in the same format. The idea is, that these should be inlined + * away, into just a simple store (for small data types, and a pair of stores + * if double or long has alignment greater than void *. On an 64-bit + * architecture, all operations should be simple stores; on a 32-bit + * architecture it depends on the alignment requirement for the specific + * type. */ + +template +static inline void _Jv_put (void *dst, T value) +{ +#if 0 + if (sizeof (T) == 8 && __alignof__ (T) > __alignof__ (void*)) + { + jint *v_dst = (jint*)(dst); + jint *v_src = (jint*)&value; + + v_dst[0] = v_src[0]; + v_dst[1] = v_src[1]; + } + else +#endif + { + *((T*) (dst)) = value; + } +} + +template +static inline T _Jv_get (void *src) +{ +#if 0 + if (sizeof (T) == 8 && __alignof__ (T) > __alignof__ (void*)) + { + T value; + jint *v_dst = (jint*)&value; + jint *v_src = (jint*)src; + + v_dst[0] = v_src[0]; + v_dst[1] = v_src[1]; + + return value; + } + else +#endif + { + return *((T*) (src)); + } +} + +/** needed to keep the CONSTANT_XXXRef & CONSTANT_NameAndType entries */ +extern inline void +_Jv_storeIndexes (void **data, + _Jv_ushort index0, + _Jv_ushort index1) +{ + // accomodate 64bit machines... + if (sizeof (void*) == (2 * sizeof (jint))) + { + ((jint*)data)[0] = index0; + ((jint*)data)[1] = index0; + } + else + { + _Jv_put(data, ((jint)index0 << 16) | (jint)index1); + } +} + +extern inline void +_Jv_loadIndexes (const void **data, + _Jv_ushort& index0, + _Jv_ushort& index1) +{ + if (sizeof (void*) == (2*sizeof (jint))) + { + index0 = ((jint*)data)[0]; + index0 = ((jint*)data)[1]; + } + else + { + jint udata = _Jv_get(data); + + _Jv_uint uindex0 = ((udata >> 16) & 0xffff); + _Jv_uint uindex1 = udata & 0xffff; + + index0 = uindex0; + index1 = uindex1; + } +} + +extern inline void +_Jv_storeFloat (void **data, jfloat f) +{ + _Jv_put(data, f); +} + +extern inline jfloat +_Jv_loadFloat (void **data) +{ + return _Jv_get(data); +} + +extern inline void +_Jv_storeInt (void **data, jint i) +{ + _Jv_put(data, i); +} + +extern inline jint +_Jv_loadInt (void **data) +{ + return _Jv_get(data); +} + +extern inline void +_Jv_storeLong (void **data, jlong l) +{ + return _Jv_put(data, l); +} + +extern inline jlong +_Jv_loadLong (void **data) +{ + return _Jv_get(data); +} + +extern inline void +_Jv_storeDouble (void **data, jdouble d) +{ + _Jv_put(data, d); +} + +extern inline jdouble +_Jv_loadDouble (void **data) +{ + return _Jv_get (data); +} + + +#endif /* __JAVA_CPOOL_H__ */ -- cgit v1.1