home *** CD-ROM | disk | FTP | other *** search
/ PC User 2001 August / APC_Aug2001_CD2.iso / features / j2sdk / files / linux / j2sdklin.bin / jdk1.3.1 / include-old / interpreter.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-06  |  25.6 KB  |  807 lines
  1. /*
  2.  * @(#)interpreter.h    1.219 00/04/06
  3.  *
  4.  * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the proprietary information of Sun Microsystems, Inc.  
  7.  * Use is subject to license terms.
  8.  * 
  9.  */
  10.  
  11. /*
  12.  * Definitions for the interperter    6/27/91
  13.  */
  14.  
  15. #ifndef _JAVASOFT_INTERPRETER_H_
  16. #define _JAVASOFT_INTERPRETER_H_
  17.  
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <string.h>
  21.  
  22. #include "util.h"
  23. #include "bool.h"
  24. #include "jni.h"
  25. #include "jvm.h"
  26. #include "alloc_cache.h"
  27. #include "sysmacros_md.h"  /* for sysAssert */
  28. #include "dll.h"
  29.  
  30. #include "miscdefs_md.h"
  31.  
  32. /* Global variables */
  33. extern bool_t debugging;
  34. extern bool_t instruction_tracing;
  35. extern bool_t verbose;
  36. extern bool_t verbosegc;
  37. extern bool_t verboseclassdep;
  38. extern bool_t classgc;
  39. extern char *init_sysclasspath;
  40. extern char *java_home_dir;
  41. extern char *java_dll_dir;
  42.  
  43. extern bool_t tried_loading_jit;
  44.  
  45. extern bool_t reduce_signal_usage;
  46. extern bool_t verbose_jni;
  47. extern bool_t compilerInitialized;
  48.  
  49. extern int min_javastack_chunk_size;
  50.  
  51. extern jint (JNICALL *vfprintf_hook)(FILE *fp, const char *fmt, va_list args);
  52. extern void (JNICALL *exit_hook)(jint code);
  53. extern void (JNICALL *abort_hook)(void);
  54.  
  55. extern ClassClass *classJavaLangClass;       /* class java/lang/Class */
  56. extern ClassClass *classJavaLangObject;       /* class java/lang/Object */
  57. extern ClassClass *classJavaLangString;       /* class java/lang/String */
  58. extern ClassClass *classJavaLangThread;       /* class java/lang/String */
  59.  
  60. extern ClassClass *classJavaLangClassLoader;
  61. extern ClassClass *classJavaLangThrowable;
  62. extern ClassClass *classJavaLangException;
  63. extern ClassClass *classJavaLangError;
  64. extern ClassClass *classJavaLangRuntimeException;
  65. extern ClassClass *classJavaLangThreadDeath;
  66.  
  67. extern ClassClass *interfaceJavaLangCloneable; /* class java/lang/Cloneable */
  68. extern ClassClass *interfaceJavaIoSerializable; /* class java/io/Serializable */
  69.  
  70. extern struct methodblock *reflect_invoke_mb; /* Used in getCallerFrame. */
  71.  
  72. #define STK_BUF_LEN 256   /* size of temp buffer allocated on stack */
  73. #define MSG_BUF_LEN 256   /* size of stack-allocated temp buffer used to hold
  74.                  messages */
  75. #define MAXDIM 255        /* maximum Java array dimension allowed in class
  76.                  files */
  77.  
  78. /* Byte to Short macro*/
  79. #ifndef PC2SIGNEDSHORT
  80. #define PC2SIGNEDSHORT(pc)  ((short)(((signed char *)(pc))[1] << 8) | \
  81.                              (short)pc[2])
  82. #endif /* PC2SIGNEDSHORT */
  83.  
  84. /* Byte to Long macro */
  85. #ifndef PC2SIGNEDLONG
  86. #define PC2SIGNEDLONG(pc)  ((long)(((signed char *)(pc))[1] << 24) |  \
  87.                            (long)(pc[2] << 16) | (long)(pc[3] << 8) | \
  88.                            (long)(pc[4]))
  89. #endif /* PC2SIGNEDLONG */
  90.  
  91. enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
  92.  
  93. extern int verifyclasses;
  94.  
  95. #define FINALIZER_METHOD_NAME "finalize"
  96. #define FINALIZER_METHOD_SIGNATURE "()V"
  97.  
  98. #ifdef TRACING
  99.   extern int trace;
  100.   extern int tracem;
  101.   extern void trace_method(struct execenv*, struct methodblock*, int, int);
  102.   enum { TRACE_METHOD_ENTER, TRACE_METHOD_RETURN, TRACE_METHOD_NATIVE_RETURN };
  103. # define TRACE_METHOD(ee, mb, args_size, type) \
  104.       if (tracem) trace_method(ee, mb, args_size, type); else ((void) 0)
  105.  
  106. #else
  107. # define TRACE_METHOD(ee, mb, args_size, type) 
  108. #endif
  109.  
  110. extern char * const opnames[];
  111.  
  112. /* Get a constant pool index, from a pc */
  113. #define GET_INDEX(ptr) (((int)((ptr)[0]) << 8) | (ptr)[1])
  114.  
  115. extern char *Object2CString(JHandle *);
  116.  
  117. /* These need to be defined differently for some machines (Unisys) */
  118.  
  119. #ifndef METHOD_FLAG_BITS
  120. #define METHOD_FLAG_BITS 5
  121. #endif
  122. #ifndef FLAG_MASK
  123. #define FLAG_MASK       ((1<<METHOD_FLAG_BITS)-1)  /* valid flag bits */
  124. #endif
  125. #ifndef METHOD_MASK
  126. #define METHOD_MASK     (~FLAG_MASK)  /* valid mtable ptr bits */
  127. #endif
  128. #ifndef LENGTH_MASK
  129. #define LENGTH_MASK     METHOD_MASK
  130. #endif
  131. #ifndef METHODALIGNMENT
  132. #define METHODALIGNMENT (FLAG_MASK+1)
  133. #endif /* METHODALIGNMENT */
  134.  
  135. #define obj_flags(o) \
  136.     (((uintptr_t) (o)->methods) & FLAG_MASK)
  137. #define obj_length(o)   \
  138.     (((size_t) (o)->methods) >> METHOD_FLAG_BITS)
  139.  
  140. #define mkatype(t,l) ((struct methodtable *) (((l) << METHOD_FLAG_BITS)|(t)))
  141. #define atype(m) ((m) & FLAG_MASK)
  142.  
  143.  
  144. #define obj_methodtable(obj) ((obj)->methods)
  145. #define obj_classblock(obj) ((obj)->methods->classdescriptor)
  146.  
  147. #define obj_array_methodtable(obj) \
  148.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? obj_methodtable((obj))      \
  149.                                            : cbMethodTable(classJavaLangObject))
  150. #define obj_array_classblock(obj) \
  151.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? (obj)->methods->classdescriptor \
  152.                                            : classJavaLangObject)
  153.  
  154. #define mt_slot(methodtable, slot) (methodtable)->methods[slot]
  155.  
  156. #define uobj_getslot(o, slot) (o)[slot]
  157. #define uobj_setslot(o, slot, v) (uobj_getslot(o, slot) = (v))
  158.  
  159. #define obj_getslot(o, slot) uobj_getslot(unhand(o), slot)
  160. #define obj_setslot(o, slot, v) (obj_getslot(o, slot) = (v))
  161.  
  162. #define obj_monitor(handlep) ((uintptr_t) handlep)
  163.  
  164. int PrepareToExit(void);
  165. void Exit(int status);
  166. int AtExit(void (*func)(void));
  167. void Abort(void);
  168.  
  169. typedef struct {
  170.     char *sysclasspath;
  171.     char *library_path;
  172.     char *dll_dir;
  173.     char *java_home;
  174.     char *ext_dirs;
  175. } props_md_t;
  176.  
  177. props_md_t *GetPropertiesMD(void);
  178.  
  179. typedef union stack_item {
  180.     /* Non pointer items */
  181.     int            i;
  182.     float          f;
  183.     OBJECT         o;
  184.     /* Pointer items */
  185.     JHandle       *h;
  186.     void          *p;
  187.     unsigned char *addr;
  188. } stack_item;
  189.  
  190. typedef struct privileged_item {
  191.     void *frame_id;               /* frame id of doPrivileged frame */
  192.     ClassClass *clazz;            /* class this item refers to */
  193.     jobject context;              /* for doPrivileged(context) */
  194.     struct privileged_item *next; /* linked list of privileged item's */
  195. } privileged_item;
  196.  
  197. /*
  198.  * Set up thread-local storage for second order monitor cache.  The
  199.  * number of words of thread-local storage must be a power of 2!
  200.  */
  201. #define TLS_MONCACHE 8 /* must be power of 2 */
  202. #define currentCacheKey(ee) (ee->cacheKey)
  203. #define localMonCache(ee, hash) (ee->monitorCache[hash])
  204.  
  205. struct execenv {
  206.     /* Stuff for the JNI: */
  207.     struct JNIEnv_    nativeInterface;
  208.  
  209.     struct javastack  *initial_stack;
  210.     struct javaframe  *current_frame; 
  211.     JHandle           *thread;        /* vague type to avoid include files */
  212.     char              exceptionKind;
  213.     union {
  214.     JHandle          *exc;        /* holds exception object */
  215.     unsigned char *addr;        /* holds pc for stack overflow */
  216.     } exception;
  217.  
  218.     /* Detecting class circularities */
  219.     struct seenclass {
  220.     ClassClass    *cb;
  221.     struct seenclass *next;
  222.     } *seenclasses;
  223.  
  224.     /* Per-thread allocation cache */
  225.     struct alloc_cache alloc_cache;
  226.  
  227.     /* starting point of native stack GC scans */
  228.     void *stack_base;
  229.  
  230.     /* Per-thread list of privileged blocks, points to most recent block */
  231.     privileged_item *privileged;
  232.  
  233.     /* Keep track of the number of times JNI GetPrimitiveArrayCritical
  234.      * functions are called.
  235.      */
  236.     int critical_count:        16;
  237.     int interrupt_pending:      1;
  238.     int async_disable_count:   15;
  239.  
  240.     JHandle *pending_async_exc;
  241.  
  242.     void *RESERVED1;
  243.     void *RESERVED2;
  244.  
  245.     /* Thread-local monitor cache */
  246. #ifndef FAST_MONITOR
  247.     volatile uintptr_t cacheKey;
  248. #else
  249.     void*  spareMonitor;
  250. #endif
  251.     void * volatile monitorCache[TLS_MONCACHE];
  252.  
  253.     /* per thread profile information */
  254.     struct profile_table * profileData; 
  255.   
  256.     /* Low address on stacks that grow downwards.  If $esp >= (stack_top +
  257.      * redzone), then there is potential C stack overflow, so a JIT doing
  258.      * explicit stack overflow checks must now raise the exception.
  259.      */
  260.     void* stack_top;
  261.  
  262.     /* Platform-dependent thread block. See threads_md.c for details.
  263.      * This field must be placed at the end of execenv.
  264.      * Use double to make sure sys_thr is 8-byte aligned. */
  265.     double sys_thr[1];
  266. };
  267.  
  268. typedef struct execenv ExecEnv;
  269.  
  270. #define SysThread2EE(tid) \
  271.     ((ExecEnv *)((char *)(tid) - offsetof(ExecEnv, sys_thr)))
  272.  
  273. #define EE2SysThread(ee) \
  274.     ((sys_thread_t *)((char *)(ee) + offsetof(ExecEnv, sys_thr)))
  275.  
  276. #define PRIVILEGED_EE ((ExecEnv*)-1)
  277.  
  278. struct javastack {
  279.     struct execenv  *execenv;        /* execenv we belong to */
  280.     struct javastack *prev;          /* previous stack of this execenv */
  281.     struct javastack *next;          /* next stack of this execenv */
  282.     stack_item      *end_data;      /* address of end of data */
  283.     unsigned int     stack_so_far;  /* total space used by this chunk and
  284.                      * all previous chunks. */
  285.     stack_item       data[1];    /* actual data */
  286. };
  287.  
  288. typedef struct javastack JavaStack;
  289.  
  290. #define JAVASTACK_CHUNK_SIZE(stack) (stack->end_data - stack->data)
  291.  
  292. #define IN_JAVASTACK(ptr,stack) \
  293.     (((ptr) >= (stack)->data) && ((ptr) < (stack)->end_data))
  294.  
  295. struct javaframe {
  296.     cp_item_type       *constant_pool; /* constant_pool of this method */
  297.     unsigned char      *returnpc;      /* pc of next instruction */
  298.     stack_item         *optop;           /* current top of stack */
  299.     stack_item         *vars;           /* pointer to this frame's vars */
  300.     struct javaframe   *prev;          /* previous java frame. */
  301.     struct javastack   *javastack;                      
  302.     unsigned char      *lastpc;           /* pc of last executed instruction */
  303.     struct methodblock *current_method;/* method currently executing */
  304.     struct sys_mon     *monitor;       /* monitor locked by this method */
  305.     long               profiler_info;  /* if profiling, time this method began;
  306.                     * if instruction profiling, the weight
  307.                     * of bytecodes executed. */
  308.     stack_item ostack[1];           /* start of this frame's stack */
  309. };
  310.  
  311. typedef struct javaframe JavaFrame; 
  312.  
  313. int ExpandJavaStackForJNI(ExecEnv *ee,
  314.               JavaStack **stackP, 
  315.               JavaFrame **frameP,
  316.               int capacity);
  317.  
  318. int ExpandJavaStack(ExecEnv *ee,
  319.             JavaStack **stackP, 
  320.             JavaFrame **frameP, 
  321.             stack_item **optopP,
  322.             int args_size,
  323.             int nlocals, 
  324.             int maxstack);
  325.  
  326. /*
  327.  * These macros are used for walking the stack and determining if
  328.  * a frame is JITed or not.  JITed frames are special in that multiple
  329.  * JIT frames may be represented by a single JavaFrame.  The frame_buf
  330.  * argument is normally a pointer to a JavaFrame structure on the stack.
  331.  * The JIT will fill this frame in for the cases were multiple JIT frames
  332.  * are being represented by a single JavaFrame.
  333.  */
  334.  
  335. #define IS_JIT_FRAME(frame) \
  336.     ((frame)->current_method && \
  337.      (frame)->current_method->fb.access & ACC_MACHINE_COMPILED && \
  338.      (frame)->constant_pool == NULL)
  339.  
  340. #define FRAME_PREV(frame, frame_buf) \
  341.     (CompilerHandlesFrame() || IS_JIT_FRAME(frame)) ? \
  342.         CompiledFramePrev(frame, frame_buf) : frame->prev;
  343.  
  344.  
  345. /*
  346.  * Javaframe.exceptionKind is used to signal why the interpreter
  347.  * loop was exited.
  348.  */
  349. #define EXCKIND_NONE            0               /* return */
  350. #define EXCKIND_THROW        1        /* throw */
  351.  
  352. /*
  353.  * Be sure to use these macros to access the exception structure.  Do
  354.  * not access the fields directly.
  355.  */
  356. #define exceptionClear(ee)            \
  357.     ((ee)->exceptionKind = EXCKIND_NONE);
  358.  
  359. #define exceptionOccurred(ee)            \
  360.     ((ee)->exceptionKind != EXCKIND_NONE)
  361.  
  362. #define exceptionThrow(ee, obj)            \
  363.     if (1) { \
  364.         (ee)->exceptionKind = EXCKIND_THROW;    \
  365.         (ee)->exception.exc = (obj); \
  366.     } else (void)0
  367.  
  368. extern int nbinclasses, sizebinclasses;
  369. extern ClassClass **binclasses;
  370.  
  371. /* stuff for dealing with handles */
  372. #define unhand(o) ((o)->obj)
  373.  
  374. /* Get class of the caller, skip n real (non-pseudo) frames */
  375. ClassClass * getCallerClass(ExecEnv * ee, int n);
  376. /*
  377.  * Get frame of the caller, skiping n real (non-pseudo) frames.  frame_buf
  378.  * is a pointer to a temporary frame which may be in the presence of
  379.  * a JIT (see CompiledFramePrev).  The return value may be equal to
  380.  * frame_buf.
  381.  */
  382. JavaFrame * getCallerFrame(JavaFrame * frame, int n, JavaFrame * frame_buf);
  383.  
  384. long ThreadCPUTimeMillis(void); /* millisecond timer */
  385.  
  386. /* signals_md.c */
  387.  
  388. extern void InitializeSignals(void);
  389.  
  390. /* jvm.c */
  391.  
  392. void InitializeObjectHash(void);
  393. bool_t InitializeSystemClassLoader(void);
  394. bool_t IsTrustedClassLoader(struct Hjava_lang_ClassLoader *loader);
  395.  
  396. #define NEED_VERIFY(cond) \
  397.     ((verifyclasses == VERIFY_ALL) || \
  398.      ((verifyclasses == VERIFY_REMOTE) && (cond)))
  399.  
  400. /* globals.c */
  401.  
  402. ClassClass** get_binclasses(void);
  403. int get_nbinclasses(void);
  404.  
  405. /* gc.c */
  406.  
  407. HObject *cacheAlloc(ExecEnv *ee, struct methodtable *mptr, long size);
  408. JHandle *allocArray(ExecEnv *, int, int);
  409. JHandle *allocObject(ExecEnv *, ClassClass *);
  410. ClassClass *allocClass(ExecEnv *);
  411.  
  412. bool_t InitializeAlloc(long max, long min);
  413. extern int64_t TotalObjectMemory(void);
  414. extern int64_t FreeObjectMemory(void);
  415. extern int64_t TotalHandleMemory(void);
  416. extern int64_t FreeHandleMemory(void);
  417. extern int tracegc;
  418.  
  419. extern void gc(unsigned int spaceRequested);
  420.  
  421. JHandle **newJNIWeakRef(ExecEnv *ee, JHandle *obj);
  422. bool_t deleteJNIWeakRef(ExecEnv *ee, JHandle **handleP);
  423.  
  424. extern void RunFinalizersOnExit(void);
  425.  
  426. extern void InitializeRefs(void);    /* Reference objects */
  427.  
  428. extern void InitializeZip(void);    /* Zip file support */
  429.  
  430. void EnableGC(ExecEnv *ee);
  431. void DisableGC(ExecEnv *ee);
  432. bool_t GCEnabled(ExecEnv *ee);
  433. void heap_lock(ExecEnv *ee);
  434. void heap_unlock(ExecEnv *ee);
  435.  
  436. /* interpreter.c */
  437.  
  438. /* SignalError() -- Instantiate an object of the specified class. 
  439.  * Indicate that that error occurred.
  440.  */
  441. void SignalError(struct execenv *, char *, char *);
  442.  
  443. extern bool_t UseLosslessQuickOpcodes;
  444.  
  445. void lock_code(ExecEnv * ee);
  446. void unlock_code(ExecEnv * ee);
  447.  
  448. JavaStack *
  449. CreateNewJavaStack(ExecEnv *ee, JavaStack *previous_stack, size_t size);
  450.  
  451. ExecEnv *NewExecEnv(void);
  452. bool_t InitializeExecEnv(ExecEnv *ee, JHandle *thread, void *stack_base);
  453. void DeleteExecEnv(ExecEnv *ee);
  454. struct sys_thread;
  455. void FreeThreadBlock(struct sys_thread *tid);
  456.  
  457. HObject *execute_java_constructor(ExecEnv *,
  458.                  char *classname,
  459.                  ClassClass *cb,
  460.                  char *signature, ...);
  461. long execute_java_static_method(ExecEnv *, ClassClass *cb,
  462.                    char *method_name, char *signature, ...);
  463. long execute_java_dynamic_method(ExecEnv *, HObject *obj,
  464.                 char *method_name, char *signature, ...);
  465.      
  466. long do_execute_java_method(ExecEnv *ee, void *obj, 
  467.                char *method_name, char *signature, 
  468.                struct methodblock *mb,
  469.                bool_t isStaticCall, ...);
  470.  
  471. long do_execute_java_method_vararg(ExecEnv *ee, void *obj, 
  472.                    char *method_name, char *signature, 
  473.                    struct methodblock *mb,
  474.                    bool_t isStaticCall, va_list args, 
  475.                    long *highBits, bool_t shortFloats);
  476.  
  477. bool_t isSpecialSuperCall(ClassClass *current_class, struct methodblock *mb);
  478.  
  479. bool_t InitializeInterpreter(void);
  480. bool_t is_instance_of(JHandle * h, ClassClass *dcb, ExecEnv *ee);
  481. bool_t is_subclass_of(ClassClass *cb, ClassClass *dcb, ExecEnv *ee);
  482. bool_t array_is_instance_of_array_type(JHandle * h, ClassClass *cb, 
  483.                        ExecEnv *ee);
  484. bool_t array_type_assignable_to_array_type(ClassClass *from_elt_class,
  485.                        int from_elt_type,
  486.                        ClassClass *to_class, ExecEnv *ee);
  487. bool_t ImplementsInterface(ClassClass *cb, ClassClass *icb, ExecEnv *ee);
  488. HObject *MultiArrayAlloc(int dimensions, ClassClass *, stack_item *sizes);
  489.  
  490. bool_t ExecuteJava(unsigned char  *, ExecEnv *ee);
  491. bool_t ExecuteJava_C(unsigned char  *, ExecEnv *ee);
  492. extern bool_t (*pExecuteJava)(unsigned char  *, ExecEnv *ee);
  493.  
  494. /*
  495.  * Called from ExecuteJava.
  496.  *    -1:   rewrite signalled an error
  497.  *     0:   rewrite went okay
  498.  *    +1:   opcode changed underneath us.  Redo
  499.  */
  500.  
  501. int quickFieldAccess( int opcode, unsigned char * pc, struct fieldblock *fb,
  502.             ExecEnv *ee );
  503. int quickStaticAccess( int opcode, unsigned char * pc, struct fieldblock *fb,
  504.             ExecEnv *ee );
  505. int quickInvocation( int opcode, unsigned char * pc, struct methodblock *mb,
  506.             ExecEnv *ee );
  507. void FixupQuickInvocation(ExecEnv * pc, JavaFrame * frame);
  508. struct methodblock * quickSelectSuperMethod(JavaFrame * frame,
  509.                         struct methodblock * mb);
  510.  
  511. bool_t
  512. invokeInterfaceError(ExecEnv *ee, unsigned char *pc, 
  513.              ClassClass *cb, ClassClass *intf);
  514.  
  515. unsigned char *
  516. ProcedureFindThrowTag(ExecEnv *ee, 
  517.               JavaFrame *frame, JHandle *object, unsigned char *pc);
  518.  
  519. void *
  520. ResolveClassConstantFromPC(unsigned char *pc, unsigned char opcode, 
  521.                    cp_item_type *, struct execenv *ee, unsigned mask);
  522.  
  523. unsigned char *classLoaderLink(struct Hjava_lang_ClassLoader *, char *, int);
  524. void *dynoLink(struct methodblock *, uint32_t *info);
  525.  
  526. bool_t DisableAsyncEvents(ExecEnv *ee);
  527. bool_t EnableAsyncEvents(ExecEnv *ee);
  528.  
  529. /* classruntime.c */
  530. HArrayOfChar *MakeString(char *, long);
  531.  
  532. ClassClass *FindClass(struct execenv *, char *, bool_t resolve);
  533. ClassClass *FindStickySystemClass(struct execenv *, char *, bool_t resolve);
  534. ClassClass *FindClassFromClass(struct execenv *, char *, bool_t resolve, 
  535.                    ClassClass *from);
  536. ClassClass *FindClassFromClassLoader(struct execenv *ee, char *name, 
  537.                      bool_t resolve,
  538.                      struct Hjava_lang_ClassLoader *loader,
  539.                      bool_t throwError);
  540. ClassClass *FindClassFromClassLoader2(struct execenv *ee, char *name, 
  541.                      bool_t resolve,
  542.                      struct Hjava_lang_ClassLoader *loader,
  543.                      bool_t throwError, HObject *pd);
  544.  
  545. void InitClass(ClassClass * cb);
  546. void PrepareInvoker(struct methodblock *mb);
  547. Invoker getCustomInvoker(char * sig);
  548. bool_t invokeJavaMethod(JHandle *o, struct methodblock *mb,
  549.             int args_size, ExecEnv *ee);
  550. bool_t invokeSynchronizedJavaMethod(JHandle *o, struct methodblock *mb, 
  551.                     int args_size, ExecEnv *ee);
  552. bool_t invokeNativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  553.               ExecEnv *ee);
  554. bool_t invokeSynchronizedNativeMethod(JHandle *o, struct methodblock *mb, 
  555.                       int args_size, ExecEnv *ee);
  556. bool_t invokeJNINativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  557.                  ExecEnv *ee);
  558. bool_t invokeJNISynchronizedNativeMethod(JHandle *o, struct methodblock *mb, 
  559.                      int args_size, ExecEnv *ee);
  560. bool_t invokeLazyNativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  561.                   ExecEnv *ee);
  562. bool_t invokeAbstractMethod(JHandle *o, struct methodblock *mb, int args_size, 
  563.                 ExecEnv *ee);
  564. bool_t invokeCompiledMethod(JHandle *o, struct methodblock *mb, int args_size, 
  565.                 ExecEnv *ee);
  566.  
  567. #ifdef DEBUG
  568. /*
  569.  * This is a debugging utility that can be used just before a call to
  570.  * validate that all the Object arguments being passed into a method are
  571.  * really valid objects.  This can be useful for debugging in the presence
  572.  * of a JIT.  All the invokers call this by default in the DEBUG VM.
  573.  */
  574. void invokerValidateArgs(stack_item * optop, struct methodblock * mb);
  575. #endif /* DEBUG */
  576.  
  577. void * FindBuiltinEntry(const char *name); /* A symbol in libjava.so.  */
  578. void * FindVerifyEntry(const char *name);  /* A symbol in libverify.so */
  579. bool_t LoadJavaLibrary(void);
  580. bool_t RunOnLoadHook(void *h);
  581.  
  582. /* classinitialize.c */
  583. bool_t ResolveClassConstant(cp_item_type *, unsigned index, struct execenv *ee,
  584.                 unsigned mask);
  585. bool_t ResolveClassConstantFromClass(ClassClass *, unsigned index, 
  586.                      struct execenv *ee, unsigned mask);
  587. bool_t ResolveClassConstant2(cp_item_type *, unsigned index, 
  588.                  struct execenv *ee, unsigned mask, 
  589.                  bool_t resolve);
  590. bool_t ResolveClassConstantFromClass2(ClassClass *, unsigned index, 
  591.                       struct execenv *ee, unsigned mask,
  592.                       bool_t resolve);
  593.  
  594. bool_t VerifyClassAccess(ClassClass *, ClassClass *, bool_t);
  595. bool_t VerifyFieldAccess(ClassClass *, ClassClass *, int, bool_t);
  596. bool_t VerifyFieldAccess2(ClassClass *, ClassClass *, int, bool_t, bool_t);
  597. bool_t IsSameClassPackage(ClassClass *class1, ClassClass *class2); 
  598.  
  599. char *GetClassConstantClassName(cp_item_type *constant_pool, int index);
  600.  
  601.  
  602. char *pc2string(unsigned char *pc, JavaFrame * frame,
  603.         char *buf, char *limit);
  604. int pc2lineno(struct methodblock *, unsigned short);
  605.  
  606. int sizearray(int, int);
  607. void printStackTrace(struct execenv *ee, int limit, void (*f)(char *, ...));
  608.  
  609. /* From check_class.c */
  610. void VerifyClass(ClassClass *cb);
  611.  
  612. /* from classload.c */
  613. void FreeClass(ClassClass *cb);
  614. ClassClass *LoadClassLocally(char *name);
  615. ClassClass *createInternalClass(unsigned char *bytes, 
  616.                 unsigned char *limit,
  617.                 struct Hjava_lang_ClassLoader *,
  618.                 char *utfname, 
  619.                 char *filename);
  620. ClassClass *createFakeArrayClass(char *name, int base_type, int depth, 
  621.                  ClassClass *inner_cb, 
  622.                  struct Hjava_lang_ClassLoader *);
  623. ClassClass *createPrimitiveClass(char *name, char sig, unsigned char typecode,
  624.     unsigned char slotsize, unsigned char elementsize);
  625. unsigned Signature2ArgsSize(char *method_signature);
  626. bool_t LoadZipLibrary(void);
  627.  
  628. /* from classresolver.c */
  629. void LoadSuperclasses(ClassClass * cb);
  630. void LinkClass(ClassClass *cb);
  631. ClassClass *FindClass(struct execenv *ee, char *name, bool_t resolve);
  632. ClassClass *FindClassFromClass(struct execenv *ee, char *name, 
  633.                    bool_t resolve, ClassClass *from);
  634. void DeleteClassFromLoaderConstraints(ClassClass *cb);
  635. bool_t CheckSignatureLoaders(char *signature, 
  636.                  struct Hjava_lang_ClassLoader *loader1,
  637.                  struct Hjava_lang_ClassLoader *loader2);
  638. char * UpdateLoaderCache(ClassClass *cb,
  639.              struct Hjava_lang_ClassLoader *loader,
  640.              char *details,
  641.              int len);
  642. int EnumerateOverLoaderCache(
  643.              int (*func)(ClassClass *, 
  644.                          struct Hjava_lang_ClassLoader *initiatingLoader, 
  645.                          void *),
  646.              void *arg);
  647.  
  648. extern ClassClass *class_void;
  649. extern ClassClass *class_boolean;
  650. extern ClassClass *class_byte;
  651. extern ClassClass *class_char;
  652. extern ClassClass *class_short;
  653. extern ClassClass *class_int;
  654. extern ClassClass *class_long;
  655. extern ClassClass *class_float;
  656. extern ClassClass *class_double;
  657.  
  658. extern ClassClass *FindPrimitiveClass(char *);
  659.  
  660. /* from threads.c */
  661. struct Hjava_lang_Thread *InitializeClassThread(ExecEnv *ee);
  662. HArrayOfChar *getThreadName(void);
  663.  
  664. /* from exception.c */
  665. struct Hjava_lang_Throwable;
  666. void fillInStackTrace(struct Hjava_lang_Throwable *handle, ExecEnv *ee);
  667.  
  668. void unicode2str(unicode *, char *, long);
  669. unicode *str2unicode(char *, unicode *, long);
  670.  
  671. enum {
  672.     MangleMethodName_JDK_1,
  673.     MangleMethodName_JNI_SHORT,
  674.     MangleMethodName_JNI_LONG
  675. };
  676. void mangleMethodName(struct methodblock *mb, char *buffer, int buflen,
  677.               int mangleType);
  678. int maxMangledMethodNameLength(struct methodblock *mb);
  679.  
  680. enum { 
  681.     MangleUTF_Class, 
  682.     MangleUTF_Field, 
  683.     MangleUTF_FieldStub, 
  684.     MangleUTF_Signature,
  685.     MangleUTF_JNI
  686. };
  687. int mangleUTFString(char *name, char *buffer, int buflen, int mangleType);
  688. int mangleUTFString2(char *name, char *buffer, int buflen, int mangleType,
  689.              char endChar);
  690.  
  691. ExecEnv *EE(void);
  692.  
  693. void panic (const char *, ...);
  694.  
  695. /* Stuff from compiler.c */
  696. void InitializeForCompiler(ClassClass *cb);
  697. void CompilerFreeClass(ClassClass *cb);
  698. void CompilerLinkClass(ClassClass *cb);
  699. void CompilerLoadClass(ClassClass *cb, unsigned char *data, int len);
  700. void CompilerCompileClass(ClassClass *cb);
  701. void ReadInCompiledCode(void *context, struct methodblock *mb, 
  702.             int attribute_length, 
  703.             unsigned long (*get1byte)(void * context),
  704.             unsigned long (*get2bytes)(void * context), 
  705.             unsigned long (*get4bytes)(void * context), 
  706.             void (*getNbytes)(void *, size_t, char *));
  707. extern char * CompiledCodeAttribute;
  708.  
  709. bool_t PCinCompiledCode(unsigned char *pc, struct methodblock *mb);
  710. unsigned char *CompiledCodePC(JavaFrame *frame, struct methodblock *mb);
  711. JavaFrame *CompiledFramePrev(JavaFrame *frame, JavaFrame *buf);
  712. void *CompiledFrameID(JavaFrame *frame);
  713. JavaFrame *CompiledFrameUpdate(JavaFrame *frame);
  714. bool_t CompilerRegisterNatives(ClassClass *cb);
  715. bool_t CompilerUnregisterNatives(ClassClass *cb);
  716. bool_t CompiledCodeSignalHandler(int sig, void *info, void *uc);
  717. int CompiledCodePCtoLineNo(unsigned char *pc);
  718. int CompilerHandlesFrame(void);
  719.  
  720. /*
  721.  * returns 0 if inline succeeded, -1 if can't be inlined, 1 if call needs
  722.  * to happen before inlining can be determined.
  723.  */
  724. int MethodCallInline(unsigned char *pc, struct methodblock *sourceMethod,
  725.              struct methodblock *mb, unsigned char *result);
  726.  
  727. #define KEEP_POINTER_ALIVE(p) if ((p) == 0) EE()
  728.  
  729. /* javai.c:
  730.  */
  731. extern GetInterfaceFunc GetHPI;
  732. extern jboolean oldjava;
  733. int InitializeJavaVM(void *args);
  734. int GetDefaultJavaVMInitArgs(JDK1_1InitArgs *args);
  735. void * InitializeHPI(void *);
  736.  
  737. /* 
  738.  * BEGIN JNI STUFF: 
  739.  * Only the stuff used by the JNI implementation, but not by JNI 
  740.  * programmers. jni.h contains the types and function prototypes
  741.  * used by JNI programmers
  742.  */
  743.  
  744. extern const struct JNINativeInterface_ unchecked_jni_NativeInterface;
  745. extern const struct JNINativeInterface_ checked_jni_NativeInterface;
  746. extern const struct JNINativeInterface_ *jni_NativeInterfacePtr;
  747.  
  748. bool_t isValidHandle(JHandle *h);
  749. bool_t isObject(void * ptr);
  750. bool_t isHandle(void * ptr);
  751.  
  752. int InitializeJNI(void);
  753.  
  754. void InitializeJNIRootFrame(ExecEnv *ee);
  755. void DeleteJNIRootFrame(ExecEnv *ee);
  756.  
  757. #define JNI_DEFAULT_LOCAL_CAPACITY 16
  758.  
  759. /* The first three slots in a JNI frame store the pointer to the list
  760.  * of freed local refs, the number of live local refs, and the ensured 
  761.  * capacity of the frame.
  762.  */
  763.  
  764. #define JNI_REF_INFO_SIZE 3
  765.  
  766. #define JNI_REFS_FREELIST(frame) (frame->ostack[0].p)
  767. #define JNI_N_REFS_IN_USE(frame) (frame->ostack[1].i)
  768. #define JNI_REFS_CAPACITY(frame) (frame->ostack[2].i)
  769.  
  770. extern JavaFrame *globalRefFrame;
  771.  
  772. /*
  773.  * JNIEnv <-> ExecEnv conversion
  774.  */
  775.  
  776. #define JNIEnv2EE(env) \
  777.     ((ExecEnv*)((char*)(env) - offsetof(ExecEnv, nativeInterface)))
  778.  
  779. #define EE2JNIEnv(ee) ((JNIEnv *)(&(ee)->nativeInterface))
  780.     
  781. /* Create
  782.  * a local reference
  783.  */
  784. #define MkRefLocal(env, jobj) \
  785.     ((jobject)(jni_mkRefLocal(JNIEnv2EE(env), (JHandle *)(jobj))))
  786.  
  787. /* A function version for the JIT interface */
  788. jobject jni_mkRefLocal(ExecEnv *ee, JHandle *jobj);
  789.  
  790. /* Deref local and global reference */
  791. #define DeRef(env, ref) ((ref) ? *(JHandle **)(ref) : 0)
  792.  
  793. void bad_critical_count_on_return(void);
  794.  
  795. #define CHECK_CRITICAL_COUNT_ON_RETURN(ee) \
  796.     if (ee->critical_count) \
  797.         bad_critical_count_on_return()
  798.  
  799. ClassClass *
  800. AddToLoadedClasses(ExecEnv *ee, ClassClass *cb);
  801.  
  802. /*
  803.  * END JNI STUFF
  804.  */
  805.  
  806. #endif /* !_JAVASOFT_INTERPRETER_H_ */
  807.