libjava/include/jvm.h

   1 // jvm.h - Header file for private implementation information. -*- c++ -*-
   2
   3 /* Copyright (C) 1998, 1999, 2000  Red Hat, Inc.
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 #ifndef __JAVA_JVM_H__
  12 #define __JAVA_JVM_H__
  13
  14 #include <gcj/javaprims.h>
  15
  16 #include <java-assert.h>
  17 #include <java-threads.h>
  18 // Must include java-gc.h before Object.h for the implementation.
  19 #include <java-gc.h>
  20
  21 #include <java/lang/Object.h>
  22
  23 // Include cni.h before field.h to enable all definitions.  FIXME.
  24 #include <gcj/cni.h>
  25 #include <gcj/field.h>
  26
  27 /* Structure of the virtual table.  */
  28 struct _Jv_VTable
  29 {
  30   jclass clas;
  31   void *method[1];
  32 };
  33
  34 /* Extract a character from a Java-style Utf8 string.
  35  * PTR points to the current character.
  36  * LIMIT points to the end of the Utf8 string.
  37  * PTR is incremented to point after the character thta gets returns.
  38  * On an error, -1 is returned. */
  39 #define UTF8_GET(PTR, LIMIT) \
  40   ((PTR) >= (LIMIT) ? -1 \
  41    : *(PTR) < 128 ? *(PTR)++ \
  42    : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
  43    ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
  44    : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
  45    && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
  46    ? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
  47    : ((PTR)++, -1))
  48
  49 extern int _Jv_strLengthUtf8(char* str, int len);
  50
  51 typedef struct _Jv_Utf8Const Utf8Const;
  52 _Jv_Utf8Const *_Jv_makeUtf8Const (char *s, int len);
  53 _Jv_Utf8Const *_Jv_makeUtf8Const (jstring string);
  54 extern jboolean _Jv_equalUtf8Consts (_Jv_Utf8Const *, _Jv_Utf8Const *);
  55 extern jboolean _Jv_equal (_Jv_Utf8Const *, jstring, jint);
  56 extern jboolean _Jv_equaln (_Jv_Utf8Const *, jstring, jint);
  57
  58 #define StringClass _CL_Q34java4lang6String
  59 extern java::lang::Class StringClass;
  60
  61 /* Type of pointer used as finalizer.  */
  62 typedef void _Jv_FinalizerFunc (jobject);
  63
  64 /* Allocate space for a new Java object.  */
  65 void *_Jv_AllocObj (jsize size) __attribute__((__malloc__));
  66 /* Allocate space for an array of Java objects.  */
  67 void *_Jv_AllocArray (jsize size) __attribute__((__malloc__));
  68 /* Allocate space that is known to be pointer-free.  */
  69 void *_Jv_AllocBytes (jsize size) __attribute__((__malloc__));
  70 /* Initialize the GC.  */
  71 void _Jv_InitGC (void);
  72 /* Register a finalizer.  */
  73 void _Jv_RegisterFinalizer (void *object, _Jv_FinalizerFunc *method);
  74
  75 /* Run finalizers for objects ready to be finalized..  */
  76 void _Jv_RunFinalizers (void);
  77 /* Run all finalizers.  Should be called only before exit.  */
  78 void _Jv_RunAllFinalizers (void);
  79 /* Perform a GC.  */
  80 void _Jv_RunGC (void);
  81
  82 /* Return approximation of total size of heap.  */
  83 long _Jv_GCTotalMemory (void);
  84 /* Return approximation of total free memory.  */
  85 long _Jv_GCFreeMemory (void);
  86
  87 /* Set initial heap size.  If SIZE==0, ignore.  Should be run before
  88    _Jv_InitGC.  Not required to have any actual effect.  */
  89 void _Jv_GCSetInitialHeapSize (size_t size);
  90
  91 /* Set maximum heap size.  If SIZE==0, unbounded.  Should be run
  92    before _Jv_InitGC.  Not required to have any actual effect.  */
  93 void _Jv_GCSetMaximumHeapSize (size_t size);
  94
  95 /* External interface to setting the heap size.  Parses ARG (a number
  96    which can optionally have "k" or "m" appended and calls
  97    _Jv_GCSetInitialHeapSize.  */
  98 void _Jv_SetInitialHeapSize (const char *arg);
  99
 100 /* External interface to setting the maximum heap size.  Parses ARG (a
 101    number which can optionally have "k" or "m" appended and calls
 102    _Jv_GCSetMaximumHeapSize.  */
 103 void _Jv_SetMaximumHeapSize (const char *arg);
 104
 105 /* Allocate some unscanned bytes.  Throw exception if out of memory.  */
 106 void *_Jv_AllocBytesChecked (jsize size) __attribute__((__malloc__));
 107
 108 extern "C" void JvRunMain (jclass klass, int argc, const char **argv);
 109 void _Jv_RunMain (const char* name, int argc, const char **argv);
 110
 111 // This function is used to determine the hash code of an object.
 112 inline jint
 113 _Jv_HashCode (jobject obj)
 114 {
 115   return (jint) obj;
 116 }
 117
 118 // Return a raw pointer to the elements of an array given the array
 119 // and its element type.  You might think we could just pick a single
 120 // array type and use elements() on it, but we can't because we must
 121 // account for alignment of the element type.
 122 inline char *
 123 _Jv_GetArrayElementFromElementType (jobject array,
 124                                     jclass element_type)
 125 {
 126   char *elts;
 127   if (element_type == JvPrimClass (byte))
 128     elts = (char *) elements ((jbyteArray) array);
 129   else if (element_type == JvPrimClass (short))
 130     elts = (char *) elements ((jshortArray) array);
 131   else if (element_type == JvPrimClass (int))
 132     elts = (char *) elements ((jintArray) array);
 133   else if (element_type == JvPrimClass (long))
 134     elts = (char *) elements ((jlongArray) array);
 135   else if (element_type == JvPrimClass (boolean))
 136     elts = (char *) elements ((jbooleanArray) array);
 137   else if (element_type == JvPrimClass (char))
 138     elts = (char *) elements ((jcharArray) array);
 139   else if (element_type == JvPrimClass (float))
 140     elts = (char *) elements ((jfloatArray) array);
 141   else if (element_type == JvPrimClass (double))
 142     elts = (char *) elements ((jdoubleArray) array);
 143   else
 144     elts = (char *) elements ((jobjectArray) array);
 145   return elts;
 146 }
 147
 148 extern "C" void _Jv_ThrowBadArrayIndex (jint bad_index);
 149 extern "C" jobject _Jv_NewArray (jint type, jint size)
 150   __attribute__((__malloc__));
 151 extern "C" jobject _Jv_NewMultiArray (jclass klass, jint dims, ...)
 152   __attribute__((__malloc__));
 153 extern "C" void *_Jv_CheckCast (jclass klass, jobject obj);
 154 extern "C" void *_Jv_LookupInterfaceMethod (jclass klass, Utf8Const *name,
 155                                             Utf8Const *signature);
 156 extern "C" void _Jv_CheckArrayStore (jobject array, jobject obj);
 157 extern "C" void _Jv_RegisterClass (jclass klass);
 158 extern "C" void _Jv_RegisterClasses (jclass *classes);
 159 extern void _Jv_UnregisterClass (_Jv_Utf8Const*, java::lang::ClassLoader*);
 160
 161 extern jclass _Jv_FindClass (_Jv_Utf8Const *name,
 162                              java::lang::ClassLoader *loader);
 163 extern jclass _Jv_FindClassFromSignature (char *,
 164                                           java::lang::ClassLoader *loader);
 165 extern void _Jv_GetTypesFromSignature (jmethodID method,
 166                                        jclass declaringClass,
 167                                        JArray<jclass> **arg_types_out,
 168                                        jclass *return_type_out);
 169
 170 extern jobject _Jv_CallAnyMethodA (jobject obj, jclass return_type,
 171                                    jmethodID meth, jboolean is_constructor,
 172                                    JArray<jclass> *parameter_types,
 173                                    jobjectArray args);
 174
 175 union jvalue;
 176 extern jthrowable _Jv_CallAnyMethodA (jobject obj,
 177                                       jclass return_type,
 178                                       jmethodID meth,
 179                                       jboolean is_constructor,
 180                                       JArray<jclass> *parameter_types,
 181                                       jvalue *args,
 182                                       jvalue *result);
 183
 184 extern jobject _Jv_NewMultiArray (jclass, jint ndims, jint* dims)
 185   __attribute__((__malloc__));
 186
 187 /* Checked divide subroutines. */
 188 extern "C"
 189 {
 190   jint _Jv_divI (jint, jint);
 191   jint _Jv_remI (jint, jint);
 192   jlong _Jv_divJ (jlong, jlong);
 193   jlong _Jv_remJ (jlong, jlong);
 194 }
 195
 196 /* get/set the name of the running executable. */
 197 extern char *_Jv_ThisExecutable (void);
 198 extern void _Jv_ThisExecutable (const char *);
 199
 200 #endif /* __JAVA_JVM_H__ */