interpreter.h

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

    int lastOpcode;
#endif /*+IBM_MIXED_MODE*/						/*ibm.8789*/

#if defined(IBM_JVMPI)                                              /*ibm.6402*/
    /* per thread profile information */
    struct profile_table * profileData;

    /* For HPROF. Always compiled in to make sure the SysThread2EE
     * macro stays the same for JITs.
     */
    unsigned int RESERVED3;

    /* Platform-dependent thread block. See threads_md.c for details.
     * This field must be placed at the end of execenv.
     * Use double to make sure sys_thr is 8-byte aligned.
     */
    double sys_thr[1];
#endif /* +IBM_JVMPI */                                             /*ibm.6402*/
};

#if defined(IBM_JVMPI)                                              /*ibm.6402*/
#define EE_FROM_SYS_THR  (sizeof(struct execenv)-sizeof(double))
#endif /* +IBM_JVMPI */                                             /*ibm.6402*/

#if defined(IBM_MIXED_MODE)                                         /*ibm.6205*/
typedef struct  syncnode
{
    struct syncnode     *next;
    JHandle             *monitor;
}   SyncNode;

/* Mixed mode interpreter frame */

typedef struct
{
    struct methodblock  *current_method;
    unsigned int        sehr_id;
    unsigned char       *returnpc;
    cp_item_type        *constant_pool;
    SyncNode            syncNode;
    unsigned int        callee_nargs;
    void                *previous_bp;
    void                *retaddr;
}   jvmframe;
#endif /* +IBM_MIXED_MODE */                                        /*ibm.6205*/

typedef struct execenv ExecEnv;

#define PRIVILEGED_EE ((ExecEnv*)-1)

#define JAVASTACK_CHUNK_SIZE 2000
struct javastack {
    struct execenv  *execenv;       /* execenv we belong to */
    struct javastack *prev;          /* previous stack of this execenv */
    struct javastack *next;          /* next stack of this execenv */
    stack_item      *end_data;      /* address of end of data */
    unsigned int     stack_so_far;  /* total space used by this chunk and
                                     * all previous chunks. */
    stack_item       data[JAVASTACK_CHUNK_SIZE];    /* actual data */

};

typedef struct javastack JavaStack;


struct javaframe {
    /* DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER
     * N. B.the first two items in structure shouldn't be needed by function
     * return or by the Garbage Collector, since they may be overwritten by
     * dreturn, lreturn, etc.
     */
    cp_item_type       *constant_pool; /* constant_pool of this method */
    unsigned char      *returnpc;      /* pc of next instruction */
    /* REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD */

    stack_item         *optop;         /* current top of stack */
    stack_item         *vars;          /* pointer to this frame's vars */
    struct javaframe   *prev;          /* previous java frame. */
    struct javastack   *javastack;
    unsigned char      *lastpc;        /* pc of last executed instruction */
    struct methodblock *current_method;/* method currently executing */
    JHandle            *monitor;       /* object locked by this method */
    int                 mon_starttime; /* time this method began */
    stack_item ostack[1];              /* start of this frame's stack */
};

typedef struct javaframe JavaFrame;


/*
 * Javaframe.exceptionKind is used to signal why the interpreter
 * loop was exited.
 */
#define EXCKIND_NONE            0               /* return */
#define EXCKIND_THROW           1               /* throw */
#define EXCKIND_STKOVRFLW       2               /* stack overflow */

/*
 * Be sure to use these macros to access the exception structure.  Do
 * not access the fields directly.
 */
#define exceptionClear(ee)                      \
    ((ee)->exceptionKind = EXCKIND_NONE);

#define exceptionOccurred(ee)                   \
    ((ee)->exceptionKind != EXCKIND_NONE)

#define exceptionThrow(ee, obj)                 \
    (ee)->exceptionKind = EXCKIND_THROW;        \
    (ee)->exception.exc = (obj);

/* Macro for handling specific kinds of exceptions */
#define exceptionThrowSpecial(ee, obj, kind)    \
    (ee)->exceptionKind = kind;                 \
    (ee)->exception.exc = (obj);


extern long nbinclasses, sizebinclasses;
extern ClassClass **binclasses;

/* stuff for dealing with handles */
#ifndef JMS_TRL  /* [TRL] Sun's original definition */
#define unhand(o) ((o)->obj)
#endif


/* globals.c */

ClassClass** get_binclasses(void);
ClassClass* get_classClass(void);
ClassClass* get_classObject(void);
long get_nbinclasses(void);

/* gc.c */
#ifdef IBM_MVS
/* ibm.7978 Kathy -- dynamic bin vectors number, start */
bool_t InitializeAlloc(long max, long min, int binVecs);
extern int binVecsNumber;
/* ibm.7978 Kathy -- dynamic bin vectors number, end */
#else /* IBM_MVS */
bool_t InitializeAlloc(long max, long min);
#endif /* IBM_MVS */
HObject *AllocHandle(struct methodtable *, ClassObject *);
extern struct arrayinfo const arrayinfo[];
extern int64_t TotalObjectMemory(void);
extern int64_t FreeObjectMemory(void);
extern int64_t TotalHandleMemory(void);
extern int64_t FreeHandleMemory(void);
extern int tracegc;

#ifdef IBM_HAIFA_GC                                             /*ibm.4860*/
#define gc(async_call,free_space_goal) StartSyncGC()

/* Variable for determining which bin vector is used  */
static volatile int binVectorIndicator = 0;
#else                                                           /*ibm.4860*/
extern void gc(int async, unsigned int spaceRequested);
#endif /* IBM_HAIFA_GC */                                       /*ibm.4860*/


/* interpreter.c */

/* SignalError() -- Instantiate an object of the specified class.
 * Indicate that that error occurred.
 */
extern bool_t UseLosslessQuickOpcodes;
void SignalError(struct execenv *, char *, char *);

JavaStack *CreateNewJavaStack(ExecEnv *ee, JavaStack *previous_stack);

void InitializeExecEnv(ExecEnv *ee, JHandle *thread);
void DeleteExecEnv(ExecEnv *ee);
extern ExecEnv *DefaultExecEnv;


HObject *execute_java_constructor(ExecEnv *,
                                 char *classname,
                                 ClassClass *cb,
                                 char *signature, ...);
long execute_java_static_method(ExecEnv *, ClassClass *cb,
                               char *method_name, char *signature, ...);
long execute_java_dynamic_method(ExecEnv *, HObject *obj,
                                char *method_name, char *signature, ...);

long do_execute_java_method(ExecEnv *ee, void *obj,
                           char *method_name, char *signature,
                           struct methodblock *mb,
                           bool_t isStaticCall, ...);

long do_execute_java_method_vararg(ExecEnv *ee, void *obj,
                                   char *method_name, char *signature,
                                   struct methodblock *mb,
                                   bool_t isStaticCall, va_list args,
                                   long *highBits, bool_t shortFloats);

long now(void);
bool_t isSpecialSuperCall(ClassClass *current_class, struct methodblock *mb);

void InitializeInterpreter(void);
bool_t is_instance_of(JHandle * h, ClassClass *dcb, ExecEnv *ee);
bool_t is_subclass_of(ClassClass *cb, ClassClass *dcb, ExecEnv *ee);
bool_t array_is_instance_of_array_type(JHandle * h, ClassClass *cb,
                                       ExecEnv *ee);
bool_t ImplementsInterface(ClassClass *cb, ClassClass *icb, ExecEnv *ee);
HObject *MultiArrayAlloc(int dimensions, ClassClass *, stack_item *sizes);
bool_t ExecuteJava(unsigned char  *, ExecEnv *ee);

/*
 * Called from ExecuteJava.
 *    -1:   rewrite signalled an error
 *     0:   rewrite went okay
 *    +1:   opcode changed underneath us.  Redo
 */

int quickFieldAccess( int opcode, unsigned char * pc, struct fieldblock *fb,
                        ExecEnv *ee );
int quickStaticAccess( int opcode, unsigned char * pc, struct fieldblock *fb,
                        ExecEnv *ee );
int quickInvocation( int opcode, unsigned char * pc, struct methodblock *mb,
                        ExecEnv *ee );
void FixupQuickInvocation(unsigned char *pc,
                          struct methodblock *currentMethod,
                          struct methodblock *targetMethod);

bool_t
invokeInterfaceError(ExecEnv *ee, unsigned char *pc,
                     ClassClass *cb, ClassClass *intf);

unsigned char *
ProcedureFindThrowTag(ExecEnv *ee,
#if defined(IBM_MIXED_MODE)                                         /*ibm.6205*/
                      jvmframe *frame, JHandle *object, unsigned char *pc);
#else  /* !IBM_MIXED_MODE */                                        /*ibm.6205*/
                      JavaFrame *frame, JHandle *object, unsigned char *pc);
#endif /* !IBM_MIXED_MODE */                                        /*ibm.6205*/

void *
ResolveClassConstantFromPC(unsigned char *pc, unsigned char opcode,
                               cp_item_type *, struct execenv *ee, unsigned mask);



struct stat;

bool_t dynoLink(struct methodblock *);
bool_t dynoLinkJNI(struct methodblock *);
char *str2rd(char *);
char *unicode2rd(unicode *, long);

/* classruntime.c */
HArrayOfChar *MakeString(char *, long);

ClassClass *FindClass(struct execenv *, char *, bool_t resolve);
ClassClass *FindStickySystemClass(struct execenv *, char *, bool_t resolve);
ClassClass *FindClassFromClass(struct execenv *, char *, bool_t resolve, ClassClass *from);
#ifdef JIT_WAY
void InstallStaticInitializer(ClassClass *cb);
void ExecuteStaticInitializers(ClassClass *cb);
void MayExecuteStaticInitializersFor_multianewarray(ClassClass*array,int dim);
#else
bool_t RunStaticInitializers(ClassClass *cb);
#endif
void InitializeInvoker(ClassClass *cb);

#if defined(IBM_MIXED_MODE)                                         /*ibm.6205*/
bool_t  invokeJavaMethodWithCatch(JHandle *o, struct methodblock *mb, int args_size, ExecEnv *ee);
bool_t  invokeSynchronizedJavaMethodWithCatch(JHandle *o, struct methodblock *mb, int args_size, ExecEnv *ee);
bool_t  invokeNativeMethod_nonstub(JHandle *o, struct methodblock *mb, int args_size, ExecEnv *ee);
bool_t  invokeSynchronizedNativeMethod_nonstub(JHandle *o, struct methodblock *mb, int args_size, ExecEnv *ee);
#endif /* +IBM_MIXED_MODE */                                        /*ibm.6205*/

bool_t
invokeJavaMethod(JHandle *o, struct methodblock *mb, int args_size, ExecEnv *ee);
bool_t invokeSynchronizedJavaMethod(JHandle *o, struct methodblock *mb,
                                    int args_size, ExecEnv *ee);
bool_t invokeNativeMethod(JHandle *o, struct methodblock *mb, int args_size,
                          ExecEnv *ee);
bool_t invokeSynchronizedNativeMethod(JHandle *o, struct methodblock *mb,
                                      int args_size, ExecEnv *ee);
bool_t invokeJNINativeMethod(JHandle *o, struct methodblock *mb, int args_size,
                             ExecEnv *ee);
bool_t invokeJNISynchronizedNativeMethod(JHandle *o, struct methodblock *mb,
                                         int args_size, ExecEnv *ee);
bool_t invokeLazyNativeMethod(JHandle *o, struct methodblock *mb, int args_size,
                              ExecEnv *ee);
bool_t invokeAbstractMethod(JHandle *o, struct methodblock *mb, int args_size,
                            ExecEnv *ee);
bool_t invokeCompiledMethod(JHandle *o, struct methodblock *mb, int args_size,
                            ExecEnv *ee);


void LoadClassConstants(ClassClass *cb);
bool_t ResolveClassStringConstant(ClassClass *, unsigned, struct execenv *);
bool_t ResolveClassConstant(cp_item_type *, unsigned index, struct execenv *ee,
                            unsigned mask);
bool_t ResolveClassConstantFromClass(ClassClass *, unsigned index,
                                     struct execenv *ee, unsigned mask);

void InitializeClassConstantResolver();

bool_t VerifyClassAccess(ClassClass *, ClassClass *, bool_t);
bool_t VerifyFieldAccess(ClassClass *, ClassClass *, int, bool_t);
bool_t IsSameClassPackage(ClassClass *class1, ClassClass *class2);

char *GetClassConstantClassName(cp_item_type *constant_pool, int index);
unsigned NameAndTypeToHash(char *name, char *type);
HObject *newobject(ClassClass *cb, unsigned char *pc, struct execenv *ee);


char *pc2string(unsigned char *pc, struct methodblock *mb, char *buf, char *limit);

#ifdef IBM_HAIFA_GC                                             /*ibm.5023*/
JHandle *ObjAlloc_ee(ClassClass *, long, ExecEnv *);
JHandle *ArrayAlloc_ee(int, int, ExecEnv *);
#define ArrayAlloc( t, l)  ArrayAlloc_ee(t, l, EE() )
#define ObjAlloc(cb, n0)   ObjAlloc_ee(cb, n0, EE() )
#else                                                           /*ibm.5023*/
JHandle *ArrayAlloc(int, int);
JHandle *ObjAlloc(ClassClass *, long);
#endif /*IBM_HAIFA_GC */                                        /*ibm.5023*/
#if defined(JMS_TRL) && defined(IBM_ALLOC_CACHE)
JHandle *FastArrayAlloc(struct execenv*, int, int);
JHandle *FastObjAlloc(struct execenv*, ClassClass *, long);
#endif
int sizearray(int, int);
extern char *remote_classname(JHandle *);
extern JHandle *remote_clone(struct execenv *);
extern long remote_cast(JHandle *, ClassClass *);
int pc2lineno(struct methodblock *, unsigned int);

/* From verify_class.c */
bool_t VerifyClass(ClassClass *cb);
bool_t IsLegalClassname(char *name, bool_t allowArrayClass);

/* From verify_code.c */
bool_t verify_class_codes(ClassClass *cb);


/* from profiler.c */
extern int java_monitor;
void javamon(int i);
void java_mon(struct methodblock *caller, struct methodblock *callee, int time);
void java_mon_dump(void);

#ifdef JCOV