interpreter.h

《移动Agent技术》一书的所有章节源代码。

#include "jcov.h"
#endif /* JCOV */

/* from classloader.c */
void FreeClass(ClassClass *cb);
void AddBinClass(ClassClass * cb);
void DelBinClass(ClassClass * cb);
ClassClass *LoadClassLocally(char *name);
bool_t createInternalClass(unsigned char *bytes, unsigned char *limit,
                           ClassClass *cb, struct Hjava_lang_ClassLoader *,
                            char *utfname, char **detail);
ClassClass *createFakeArrayClass(char *name, int base_type, int depth,
                                 ClassClass *inner_cb,
                                 struct Hjava_lang_ClassLoader *);
ClassClass *createPrimitiveClass(char *name, char sig, unsigned char typecode,
    unsigned char slotsize, unsigned char elementsize);
unsigned Signature2ArgsSize(char *method_signature);

typedef struct {
    unsigned char *class_data;
    int            class_data_len;
    unsigned char *new_class_data;
    int            new_class_data_len;
    void *       (*malloc_f)(int);
} classload_event;

typedef void (*classload_hook)(classload_event *);

/* from classresolver.c */
char *LinkClass(ClassClass *cb, char **detail);
char *InitializeClass(ClassClass * cb, char **detail);
char *ResolveClass(ClassClass * cb, char **detail);
ClassClass *FindClass(struct execenv *ee, char *name, bool_t resolve);
ClassClass *FindClassFromClass(struct execenv *ee, char *name,
                               bool_t resolve, ClassClass *from);
ClassClass *ClassLoaderFindClass(ExecEnv *ee,
                                 struct Hjava_lang_ClassLoader *loader,
                                 char *name, bool_t resolve);

int  makeslottable(ClassClass * clb);
void lock_classes(void);
void unlock_classes(void);

extern ClassClass *class_void;
extern ClassClass *class_boolean;
extern ClassClass *class_byte;
extern ClassClass *class_char;
extern ClassClass *class_short;
extern ClassClass *class_int;
extern ClassClass *class_long;
extern ClassClass *class_float;
extern ClassClass *class_double;

extern ClassClass *FindPrimitiveClass(char *);

/* from path_md.c */
char **CLASSPATH(void);

/* from threadruntime.c */
struct Hjava_lang_Thread *InitializeClassThread(ExecEnv *ee, char **errmsg);
void InitializeMainThread(void);
long *getclassvariable(ClassClass *cb, char *fname);
struct Hjava_lang_Thread;
char *thread_name(struct Hjava_lang_Thread *tid);

void setThreadName(struct Hjava_lang_Thread *ht, HArrayOfChar *newName);
HArrayOfChar *getThreadName(void);

/* from exception.c */
struct Hjava_lang_Throwable;
void fillInStackTrace(struct Hjava_lang_Throwable *handle, ExecEnv *ee);

/* from CompSupport.c */
long CallInterpreted(register struct methodblock * mb, void *obj,...);

/* used to indicate of an object or remote or local */
extern struct methodtable *remote_methodtable;

void unicode2str(unicode *, char *, long);
unicode *str2unicode(char *, unicode *, long);

enum {
    MangleMethodName_JDK_1,
    MangleMethodName_JNI_SHORT,
    MangleMethodName_JNI_LONG
};
void mangleMethodName(struct methodblock *mb, char *buffer, int buflen,
                      int mangleType);

enum {
    MangleUTF_Class,
    MangleUTF_Field,
    MangleUTF_FieldStub,
    MangleUTF_Signature,
    MangleUTF_JNI
};
int mangleUTFString(char *name, char *buffer, int buflen, int mangleType);

/* string hash support */
struct StrIDhash;
unsigned short Str2ID(struct StrIDhash **, char *, void ***, int);
char *ID2Str(struct StrIDhash *, unsigned short, void ***);
void Str2IDFree(struct StrIDhash **);
#ifdef JMS_TRL
void Str2IDCallback(struct StrIDhash **hash_ptr, void (*)(char *, void**));
#else
void Str2IDCallback(struct StrIDhash **hash_ptr, void (*)(char *, void *));
#endif
ExecEnv *EE(void);

/* Miscellaneous functions in util.c */
char *unicode2rd(unicode *s, long len);
void out_of_memory(void);
void prints(char *s);
void printus(unicode *str, long len);
int jio_snprintf(char *str, size_t count, const char *fmt, ...);
int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);

int jio_printf(const char *fmt, ...);
int jio_fprintf(FILE *, const char *fmt, ...);
int jio_vfprintf(FILE *, const char *fmt, va_list args);


/* allows you to override panic & oom "functionality" */
typedef void (*PanicHook)(const char* panicString);
typedef void (*OutOfMemoryHook) ();

extern PanicHook panic_hook;
extern OutOfMemoryHook out_of_memory_hook;

/* Stuff from compiler.c */

void InitializeForCompiler(ClassClass *cb);
void CompilerFreeClass(ClassClass *cb);
void CompilerCompileClass(ClassClass *cb);
void ReadInCompiledCode(void *context, struct methodblock *mb,
                        int attribute_length,
                        unsigned long (*get1byte)(),
                        unsigned long (*get2bytes)(),
                        unsigned long (*get4bytes)(),
                        void (*getNbytes)());

bool_t PCinCompiledCode(unsigned char *pc, struct methodblock *mb);
unsigned char *CompiledCodePC(JavaFrame *frame, struct methodblock *mb);
JavaFrame *CompiledFramePrev(JavaFrame *frame, JavaFrame *buf);

#ifdef JIT_TRL
/*
 * execution mode
 */
typedef enum {
   EXECMODE_BYTECODE,
   EXECMODE_COMPILEDCODE,
   EXECMODE_JITCOMPILE
} ExecMode;

/*
 * Frame traverser
 *
 * The size of a frame traverser varies depending on implementations.
 * However, for the efficiency reason, the user of a traverser interface
 * has the resopnsibility to allocate the traverser's memory. We
 * (believe and) assume that the following macro constant is
 * sufficiently large for any traverser implementation.
 */

typedef struct {
#if defined(IBM_MIXED_MODE) && defined(IBM_WIN32)                   /*ibm.6205*/
/*
 * Win32 format FrameTraverser structure breakdown
 */
   int       exec_mode;
   jvmframe *frame;
   char     *end_of_jitf;
   char      padding[20];
#else  /* !IBM_MIXED_MODE */                                        /*ibm.6205*/
#define MAX_FRAME_TRAVERSER_SIZE 32
   char buf[MAX_FRAME_TRAVERSER_SIZE];
#endif /* !IBM_MIXED_MODE */                                        /*ibm.6205*/
} FrameTraverser;

/*
 * Frame Interface (Facade)
 */
typedef struct {
    /* FrameTraverser
     */
    void (*init)(ExecEnv*, FrameTraverser*);
    void (*clone)(FrameTraverser*src, FrameTraverser*dest);

    void   (*prev)(FrameTraverser*);
    bool_t (*more)(FrameTraverser*);

    struct methodblock* (*method)(FrameTraverser*);
    unsigned char*      (*lastpc)(FrameTraverser*);
    JHandle*            (*target)(FrameTraverser*);
    /* only for dumping thread info */
    stack_item          (*args)(FrameTraverser*, int);

    /* Quick access to the attributes of the "current frame",
     * done without creating a FrameTraverser.
     */
    bool_t              (*current_frame_exists)(ExecEnv*);
    struct methodblock* (*current_frame_method)(ExecEnv*);
    unsigned char*      (*current_frame_lastpc)(ExecEnv*);
    int                 (*current_frame_address)(ExecEnv*);

    /* execution mode
     */
    ExecMode (*set_mode)(ExecEnv*, ExecMode);
    ExecMode (*get_mode)(ExecEnv*);

    /* for java.lang.Thread.stop0(o) */
    void (*jitcThreadPostException)(ExecEnv*, void*);
} FrameInterface;

extern FrameInterface  FrameIntf;

#define being_interpreted(ee)     (FrameIntf.get_mode(ee)==EXECMODE_BYTECODE)
#define being_jitcompiled(ee)     (FrameIntf.get_mode(ee)==EXECMODE_JITCOMPILE)

#endif /* JIT_TRL */

/* Stuff from simplify.c */
bool_t MethodCallInline(unsigned char *pc, struct methodblock *sourceMethod,
                        struct methodblock *mb, unsigned char *result);

#define KEEP_POINTER_ALIVE(p) if ((p) == 0) EE()



#if defined(IBM_JVMPI)                                              /*ibm.6402*/
JavaFrame *CompiledFrameUpdate(JavaFrame *frame);
bool_t CompilerRegisterNatives(ClassClass *cb);
bool_t CompilerUnRegisterNatives(ClassClass *cb);
// bool_t CompiledCodeSignalHandler( int sig, void *info, void *uc);

/*
 * These macros are used for walking the stack and determining if
 * a frame is JITed or not.  JITed frames are special in that multiple
 * JIT frames may be represented by a single JavaFrame.  The frame_buf
 * argument is normally a pointer to a JavaFrame structure on the stack.
 * The JIT will fill this frame in for the cases were multiple JIT frames
 * are being represented by a single JavaFrame.
 */

#define IS_JIT_FRAME(frame) \
    ((frame)->current_method && \
    (frame)->current_method->fb.access & ACC_MACHINE_COMPILED && \
    (frame)->constant_pool == NULL)

#define FRAME_PREV(frame, frame_buf) \
    IS_JIT_FRAME(frame) ? \
    CompiledFramePrev(frame, frame_buf) : frame->prev;
#endif /* +IBM_JVMPI */                                             /*ibm.6402*/




/*
 * BEGIN JNI STUFF:
 * Only the stuff used by the JNI implementation, but not by JNI
 * programmers. jni.h contains the types and function prototypes
 * used by JNI programmers
 */

int InitializeJNI();

void InitializeJNIRootFrame(ExecEnv *ee);
void DeleteJNIRootFrame(ExecEnv *ee);

/*
 * Reference tables
 */

#define JNI_REF_COUNT_MASK 0x1fffffff

#define JNI_REF_TAG_MASK 0x60000000

#define JNI_REF_HANDLE_TAG 0x00000000

#define JNI_REF_FB_TAG 0x20000000

#define JNI_REF_MB_TAG 0x40000000

typedef struct JNIRefCell {
    uint32_t refCount;
    void *content;
} JNIRefCell;

typedef struct JNIRefTable {
    JNIRefCell *elements;
    int base;
    int top;
    int size;
} JNIRefTable;

extern jref jni_AddRefCell(JNIRefTable *table, void *entry, int kind);
extern JNIRefTable globalRefTable;

/*
 * JNIEnv <-> ExecEnv conversion
 */

#define JNIEnv2EE(env) \
    ((ExecEnv*)((char*)(env) - offsetof(ExecEnv, nativeInterface)))

#define EE2JNIEnv(ee) ((JNIEnv *)(&(ee)->nativeInterface))

/*
 * References
 * The local reference table is stored in field reserved1.
 */

#define JNIEnvGetLocalRefs(env) \
    ((JNIRefTable *)(((struct JNIEnv_ *)(env))->reserved1))

#define MkRefLocal(env, jobj, tag) \
    ((jref)(jni_AddRefCell(JNIEnvGetLocalRefs(env), (void *)(jobj), tag)))

#define DeRef(env, ref) \
    ((int)(ref) > 0 ? \
         JNIEnvGetLocalRefs(env)->elements[(int)(ref) - 1].content \
       : ((ref) ? \
              globalRefTable.elements[-((int)(ref)) - 1].content \
            : 0))

/*
 * JavaVM <-> main EE conversion
 * The main EE is stored in field reserved0.
 */
#define JavaVMGetEE(vm) ((ExecEnv *)(((struct JavaVM_ *)vm)->reserved0))

/* used in java_main */
struct methodblock *
JNI_FindMainMethod(ClassClass *cb, char **error_message_p);
/*
 * END JNI STUFF
 */

#endif /* ! _INTERPRETER_H_ */