diff options
Diffstat (limited to 'libjava/include/java-interp.h')
| -rw-r--r-- | libjava/include/java-interp.h | 172 |
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__ */ |