[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

1 files changed, 172 insertions, 0 deletions

diff --git a/libjava/include/java-interp.h b/libjava/include/java-interp.h
new file mode 100644
index 0000000..70feec1
--- /dev/null
+++ b/libjava/include/java-interp.h
@@ -0,0 +1,172 @@
+// java-interp.h - Header file for the bytecode interpreter.  -*- 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_INTERP_H__
+#define __JAVA_INTERP_H__
+
+#include <config.h>
+
+#include <jvm.h>
+#include <java-cpool.h>
+
+#ifdef INTERPRETER
+
+#pragma interface
+
+#include <java/lang/Class.h>
+#include <java/lang/ClassLoader.h>
+#include <gnu/gcj/runtime/MethodInvocation.h>
+
+extern "C" {
+#include <ffi.h>
+}
+
+extern inline jboolean
+_Jv_IsInterpretedClass (jclass c)
+{
+  return (c->loader != 0);
+}
+
+struct _Jv_ResolvedMethod;
+
+void _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig);
+void _Jv_VerifyMethodSignature (_Jv_Utf8Const*sig);
+void _Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length);
+void _Jv_VerifyClassName (_Jv_Utf8Const *name);
+void _Jv_VerifyIdentifier (_Jv_Utf8Const *);
+bool _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2);
+void _Jv_DefineClass (jclass, jbyteArray, jint, jint);
+void _Jv_ResolveField (_Jv_Field *, java::lang::ClassLoader*);
+
+void _Jv_InitField (jobject, jclass, int);
+void * _Jv_AllocMethodInvocation (jsize size);
+
+/* FIXME: this should really be defined in some more generic place */
+#define ROUND(V, A) (((((unsigned) (V))-1) | ((A)-1))+1)
+
+/* the interpreter is written in C++, primarily because it makes it easy for
+ * the entire thing to be "friend" with class Class. */
+
+class _Jv_InterpClass;
+class _Jv_InterpMethod;
+class _Jv_InterpMethodInvocation;
+
+class _Jv_InterpException {
+  int  start_pc;
+  int  end_pc;
+  int  handler_pc;
+  int  handler_type;
+
+  friend class _Jv_ClassReader;
+  friend class _Jv_InterpMethod;
+};
+
+class _Jv_InterpMethod {
+
+  _Jv_ushort       max_stack;
+  _Jv_ushort       max_locals;
+  int              code_length;
+
+  _Jv_ushort       exc_count;
+  _Jv_ushort       args_raw_size;
+
+  _Jv_InterpClass *defining_class;
+  _Jv_Method      *self;
+
+  unsigned char* bytecode () 
+  {
+    return 
+      ((unsigned char*)this) 
+      + ROUND((sizeof (_Jv_InterpMethod)
+	       + exc_count*sizeof (_Jv_InterpException)), 4);
+  }
+    
+  _Jv_InterpException * exceptions ()
+  {
+    return (_Jv_InterpException*) (this+1);
+  }
+
+  static size_t size (int exc_count, int code_length)
+  {
+    return 
+      ROUND ((sizeof (_Jv_InterpMethod) 
+	      + (exc_count * sizeof (_Jv_InterpException))), 4)
+      + code_length;
+  }
+
+  // return the method's invocation pointer (a stub).
+  void *ncode ();
+  void continue1 (_Jv_InterpMethodInvocation *inv);
+
+  static void run_normal (ffi_cif*, void*, void**, void*);
+  static void run_synch_object (ffi_cif*, void*, void**, void*);
+  static void run_synch_class (ffi_cif*, void*, void**, void*);
+
+  inline jobject run (ffi_cif*, void*, void**, 
+		      _Jv_InterpMethodInvocation*);
+
+  bool find_exception (jobject ex,
+		       _Jv_InterpMethodInvocation *inv);
+
+ public:
+  static void dump_object(jobject o);
+
+  friend class _Jv_ClassReader;
+  friend class _Jv_InterpMethodInvocation;
+  friend class gnu::gcj::runtime::MethodInvocation;
+
+  friend void _Jv_PrepareClass(jclass);
+
+  friend void _Jv_callInterpretedMethod (ffi_cif*,
+					 void*,
+					 void **,
+					 void*);
+};
+
+class _Jv_InterpMethodInvocation {
+  _Jv_InterpMethod *running;
+  void            **sp;
+  unsigned char    *pc;
+  void*             state[0];
+
+  void**            stack_base () { return &state[0]; }
+  void**            local_base () { return &state[running->max_stack]; }
+
+  friend class _Jv_InterpMethod;
+};
+  
+class _Jv_InterpClass : public java::lang::Class
+{
+  _Jv_InterpMethod **interpreted_methods;
+  _Jv_ushort        *field_initializers;
+
+  friend class _Jv_ClassReader;
+  friend class _Jv_InterpMethod;
+  friend void  _Jv_PrepareClass(jclass);
+  friend void  _Jv_InitField (jobject, jclass, int);
+  friend void* _Jv_MarkObj (void *, void *, void *, void *);
+};
+
+struct _Jv_ResolvedMethod {
+  jint            stack_item_count;	
+  jint            vtable_index;	
+  jclass          klass;
+  _Jv_Method*     method;
+
+  // a resolved method holds the cif in-line, so that _Jv_MarkObj just needs
+  // to mark the resolved method to hold on to the cif.  Some memory could be
+  // saved by keeping a cache of cif's, since many will be the same.
+  ffi_cif         cif;
+  ffi_type *      arg_types[0];
+};
+
+#endif /* INTERPRETER */
+
+#endif /* __JAVA_INTERP_H__ */