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-interp.h | 172 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 172 insertions(+) create mode 100644 libjava/include/java-interp.h (limited to 'libjava/include/java-interp.h') 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 + +#include +#include + +#ifdef INTERPRETER + +#pragma interface + +#include +#include +#include + +extern "C" { +#include +} + +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__ */ -- cgit v1.1