173 lines
4.3 KiB
C++
173 lines
4.3 KiB
C++
// 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__ */
|