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.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@28597 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 173 insertions, 0 deletions

diff --git a/libjava/include/java-cpool.h b/libjava/include/java-cpool.h
new file mode 100644
index 00000000000..f4d7ef9910a
--- /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 <javaprims.h>
+
+// 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 <class T>
+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 <class T>
+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<jint>(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<jint>(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<jfloat>(data, f);
+}
+
+extern inline jfloat
+_Jv_loadFloat (void **data)
+{
+  return _Jv_get<jfloat>(data);
+}
+
+extern inline void
+_Jv_storeInt (void **data, jint i)
+{
+  _Jv_put<jint>(data, i);
+}
+
+extern inline jint
+_Jv_loadInt (void **data)
+{
+  return _Jv_get<jint>(data);
+}
+
+extern inline void
+_Jv_storeLong (void **data, jlong l)
+{
+  return _Jv_put<jlong>(data, l);
+}
+
+extern inline jlong
+_Jv_loadLong (void **data)
+{
+  return _Jv_get<jlong>(data);
+}
+
+extern inline void
+_Jv_storeDouble (void **data, jdouble d)
+{
+  _Jv_put<jdouble>(data, d);
+}
+
+extern inline jdouble
+_Jv_loadDouble (void **data)
+{
+  return _Jv_get<jdouble> (data);
+}
+
+
+#endif /* __JAVA_CPOOL_H__ */