Home | History | Annotate | Download | only in native
      1 /*
      2  * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
      3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
      4  *
      5  * This code is free software; you can redistribute it and/or modify it
      6  * under the terms of the GNU General Public License version 2 only, as
      7  * published by the Free Software Foundation.  Oracle designates this
      8  * particular file as subject to the "Classpath" exception as provided
      9  * by Oracle in the LICENSE file that accompanied this code.
     10  *
     11  * This code is distributed in the hope that it will be useful, but WITHOUT
     12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
     14  * version 2 for more details (a copy is included in the LICENSE file that
     15  * accompanied this code).
     16  *
     17  * You should have received a copy of the GNU General Public License version
     18  * 2 along with this work; if not, write to the Free Software Foundation,
     19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
     20  *
     21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
     22  * or visit www.oracle.com if you need additional information or have any
     23  * questions.
     24  */
     25 
     26 #ifndef _JAVASOFT_JVM_H_
     27 #define _JAVASOFT_JVM_H_
     28 
     29 #include <sys/stat.h>
     30 #include <stdio.h>
     31 
     32 #include "jni.h"
     33 #include "jvm_md.h"
     34 
     35 #ifdef __cplusplus
     36 extern "C" {
     37 #endif
     38 
     39 /*
     40  * This file contains additional functions exported from the VM.
     41  * These functions are complementary to the standard JNI support.
     42  * There are three parts to this file:
     43  *
     44  * First, this file contains the VM-related functions needed by native
     45  * libraries in the standard Java API. For example, the java.lang.Object
     46  * class needs VM-level functions that wait for and notify monitors.
     47  *
     48  * Second, this file contains the functions and constant definitions
     49  * needed by the byte code verifier and class file format checker.
     50  * These functions allow the verifier and format checker to be written
     51  * in a VM-independent way.
     52  *
     53  * Third, this file contains various I/O and nerwork operations needed
     54  * by the standard Java I/O and network APIs.
     55  */
     56 
     57 /*
     58  * Bump the version number when either of the following happens:
     59  *
     60  * 1. There is a change in JVM_* functions.
     61  *
     62  * 2. There is a change in the contract between VM and Java classes.
     63  *    For example, if the VM relies on a new private field in Thread
     64  *    class.
     65  */
     66 
     67 #define JVM_INTERFACE_VERSION 4
     68 
     69 JNIEXPORT jint JNICALL
     70 JVM_GetInterfaceVersion(void);
     71 
     72 /*************************************************************************
     73  PART 1: Functions for Native Libraries
     74  ************************************************************************/
     75 /*
     76  * java.lang.Object
     77  */
     78 JNIEXPORT jint JNICALL
     79 JVM_IHashCode(JNIEnv *env, jobject obj);
     80 
     81 JNIEXPORT void JNICALL
     82 JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms);
     83 
     84 JNIEXPORT void JNICALL
     85 JVM_MonitorNotify(JNIEnv *env, jobject obj);
     86 
     87 JNIEXPORT void JNICALL
     88 JVM_MonitorNotifyAll(JNIEnv *env, jobject obj);
     89 
     90 JNIEXPORT jobject JNICALL
     91 JVM_Clone(JNIEnv *env, jobject obj);
     92 
     93 /*
     94  * java.lang.String
     95  */
     96 JNIEXPORT jstring JNICALL
     97 JVM_InternString(JNIEnv *env, jstring str);
     98 
     99 /*
    100  * java.lang.System
    101  */
    102 JNIEXPORT jlong JNICALL
    103 JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored);
    104 
    105 JNIEXPORT jlong JNICALL
    106 JVM_NanoTime(JNIEnv *env, jclass ignored);
    107 
    108 JNIEXPORT void JNICALL
    109 JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
    110               jobject dst, jint dst_pos, jint length);
    111 
    112 JNIEXPORT jobject JNICALL
    113 JVM_InitProperties(JNIEnv *env, jobject p);
    114 
    115 /*
    116  * java.io.File
    117  */
    118 JNIEXPORT void JNICALL
    119 JVM_OnExit(void (*func)(void));
    120 
    121 /*
    122  * java.lang.Runtime
    123  */
    124 JNIEXPORT void JNICALL
    125 JVM_Exit(jint code);
    126 
    127 JNIEXPORT void JNICALL
    128 JVM_Halt(jint code);
    129 
    130 JNIEXPORT void JNICALL
    131 JVM_GC(void);
    132 
    133 /* Returns the number of real-time milliseconds that have elapsed since the
    134  * least-recently-inspected heap object was last inspected by the garbage
    135  * collector.
    136  *
    137  * For simple stop-the-world collectors this value is just the time
    138  * since the most recent collection.  For generational collectors it is the
    139  * time since the oldest generation was most recently collected.  Other
    140  * collectors are free to return a pessimistic estimate of the elapsed time, or
    141  * simply the time since the last full collection was performed.
    142  *
    143  * Note that in the presence of reference objects, a given object that is no
    144  * longer strongly reachable may have to be inspected multiple times before it
    145  * can be reclaimed.
    146  */
    147 JNIEXPORT jlong JNICALL
    148 JVM_MaxObjectInspectionAge(void);
    149 
    150 JNIEXPORT void JNICALL
    151 JVM_TraceInstructions(jboolean on);
    152 
    153 JNIEXPORT void JNICALL
    154 JVM_TraceMethodCalls(jboolean on);
    155 
    156 JNIEXPORT jlong JNICALL
    157 JVM_TotalMemory(void);
    158 
    159 JNIEXPORT jlong JNICALL
    160 JVM_FreeMemory(void);
    161 
    162 JNIEXPORT jlong JNICALL
    163 JVM_MaxMemory(void);
    164 
    165 JNIEXPORT jint JNICALL
    166 JVM_ActiveProcessorCount(void);
    167 
    168 JNIEXPORT jstring JVM_NativeLoad(JNIEnv* env, jstring javaFilename,
    169                                  jobject javaLoader, jstring javaLibrarySearchPath);
    170 
    171 JNIEXPORT void * JNICALL
    172 JVM_LoadLibrary(const char *name);
    173 
    174 JNIEXPORT void JNICALL
    175 JVM_UnloadLibrary(void * handle);
    176 
    177 JNIEXPORT void * JNICALL
    178 JVM_FindLibraryEntry(void *handle, const char *name);
    179 
    180 JNIEXPORT jboolean JNICALL
    181 JVM_IsSupportedJNIVersion(jint version);
    182 
    183 /*
    184  * java.lang.Float and java.lang.Double
    185  */
    186 JNIEXPORT jboolean JNICALL
    187 JVM_IsNaN(jdouble d);
    188 
    189 /*
    190  * java.lang.Throwable
    191  */
    192 JNIEXPORT void JNICALL
    193 JVM_FillInStackTrace(JNIEnv *env, jobject throwable);
    194 
    195 JNIEXPORT void JNICALL
    196 JVM_PrintStackTrace(JNIEnv *env, jobject throwable, jobject printable);
    197 
    198 JNIEXPORT jint JNICALL
    199 JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable);
    200 
    201 JNIEXPORT jobject JNICALL
    202 JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index);
    203 
    204 /*
    205  * java.lang.Compiler
    206  */
    207 JNIEXPORT void JNICALL
    208 JVM_InitializeCompiler (JNIEnv *env, jclass compCls);
    209 
    210 JNIEXPORT jboolean JNICALL
    211 JVM_IsSilentCompiler(JNIEnv *env, jclass compCls);
    212 
    213 JNIEXPORT jboolean JNICALL
    214 JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls);
    215 
    216 JNIEXPORT jboolean JNICALL
    217 JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname);
    218 
    219 JNIEXPORT jobject JNICALL
    220 JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg);
    221 
    222 JNIEXPORT void JNICALL
    223 JVM_EnableCompiler(JNIEnv *env, jclass compCls);
    224 
    225 JNIEXPORT void JNICALL
    226 JVM_DisableCompiler(JNIEnv *env, jclass compCls);
    227 
    228 /*
    229  * java.lang.Thread
    230  */
    231 JNIEXPORT void JNICALL
    232 JVM_StartThread(JNIEnv *env, jobject thread, jlong stack_size, jboolean daemon);
    233 
    234 JNIEXPORT void JNICALL
    235 JVM_StopThread(JNIEnv *env, jobject thread, jobject exception);
    236 
    237 JNIEXPORT jboolean JNICALL
    238 JVM_IsThreadAlive(JNIEnv *env, jobject thread);
    239 
    240 JNIEXPORT void JNICALL
    241 JVM_SuspendThread(JNIEnv *env, jobject thread);
    242 
    243 JNIEXPORT void JNICALL
    244 JVM_ResumeThread(JNIEnv *env, jobject thread);
    245 
    246 JNIEXPORT void JNICALL
    247 JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio);
    248 
    249 JNIEXPORT void JNICALL
    250 JVM_Yield(JNIEnv *env, jclass threadClass);
    251 
    252 JNIEXPORT void JNICALL
    253 JVM_Sleep(JNIEnv *env, jclass threadClass, jobject java_object, jlong millis);
    254 
    255 JNIEXPORT jobject JNICALL
    256 JVM_CurrentThread(JNIEnv *env, jclass threadClass);
    257 
    258 JNIEXPORT jint JNICALL
    259 JVM_CountStackFrames(JNIEnv *env, jobject thread);
    260 
    261 JNIEXPORT void JNICALL
    262 JVM_Interrupt(JNIEnv *env, jobject thread);
    263 
    264 JNIEXPORT jboolean JNICALL
    265 JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted);
    266 
    267 JNIEXPORT jboolean JNICALL
    268 JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj);
    269 
    270 JNIEXPORT void JNICALL
    271 JVM_DumpAllStacks(JNIEnv *env, jclass unused);
    272 
    273 JNIEXPORT jobjectArray JNICALL
    274 JVM_GetAllThreads(JNIEnv *env, jclass dummy);
    275 
    276 JNIEXPORT void JNICALL
    277 JVM_SetNativeThreadName(JNIEnv *env, jobject jthread, jstring name);
    278 
    279 /* getStackTrace() and getAllStackTraces() method */
    280 JNIEXPORT jobjectArray JNICALL
    281 JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);
    282 
    283 /*
    284  * java.lang.SecurityManager
    285  */
    286 JNIEXPORT jclass JNICALL
    287 JVM_CurrentLoadedClass(JNIEnv *env);
    288 
    289 JNIEXPORT jobject JNICALL
    290 JVM_CurrentClassLoader(JNIEnv *env);
    291 
    292 JNIEXPORT jobjectArray JNICALL
    293 JVM_GetClassContext(JNIEnv *env);
    294 
    295 JNIEXPORT jint JNICALL
    296 JVM_ClassDepth(JNIEnv *env, jstring name);
    297 
    298 JNIEXPORT jint JNICALL
    299 JVM_ClassLoaderDepth(JNIEnv *env);
    300 
    301 /*
    302  * java.lang.Package
    303  */
    304 JNIEXPORT jstring JNICALL
    305 JVM_GetSystemPackage(JNIEnv *env, jstring name);
    306 
    307 JNIEXPORT jobjectArray JNICALL
    308 JVM_GetSystemPackages(JNIEnv *env);
    309 
    310 /*
    311  * java.io.ObjectInputStream
    312  */
    313 JNIEXPORT jobject JNICALL
    314 JVM_AllocateNewObject(JNIEnv *env, jobject obj, jclass currClass,
    315                       jclass initClass);
    316 
    317 JNIEXPORT jobject JNICALL
    318 JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass,
    319                      jint length);
    320 
    321 JNIEXPORT jobject JNICALL
    322 JVM_LatestUserDefinedLoader(JNIEnv *env);
    323 
    324 /*
    325  * This function has been deprecated and should not be considered
    326  * part of the specified JVM interface.
    327  */
    328 JNIEXPORT jclass JNICALL
    329 JVM_LoadClass0(JNIEnv *env, jobject obj, jclass currClass,
    330                jstring currClassName);
    331 
    332 /*
    333  * java.lang.reflect.Array
    334  */
    335 JNIEXPORT jint JNICALL
    336 JVM_GetArrayLength(JNIEnv *env, jobject arr);
    337 
    338 JNIEXPORT jobject JNICALL
    339 JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index);
    340 
    341 JNIEXPORT jvalue JNICALL
    342 JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode);
    343 
    344 JNIEXPORT void JNICALL
    345 JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val);
    346 
    347 JNIEXPORT void JNICALL
    348 JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v,
    349                              unsigned char vCode);
    350 
    351 JNIEXPORT jobject JNICALL
    352 JVM_NewArray(JNIEnv *env, jclass eltClass, jint length);
    353 
    354 JNIEXPORT jobject JNICALL
    355 JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim);
    356 
    357 /*
    358  * java.lang.Class and java.lang.ClassLoader
    359  */
    360 /*
    361  * Returns the class in which the code invoking the native method
    362  * belongs.
    363  *
    364  * Note that in JDK 1.1, native methods did not create a frame.
    365  * In 1.2, they do. Therefore native methods like Class.forName
    366  * can no longer look at the current frame for the caller class.
    367  */
    368 JNIEXPORT jclass JNICALL
    369 JVM_GetCallerClass(JNIEnv *env, int n);
    370 
    371 /*
    372  * Find primitive classes
    373  * utf: class name
    374  */
    375 JNIEXPORT jclass JNICALL
    376 JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);
    377 
    378 /*
    379  * Link the class
    380  */
    381 JNIEXPORT void JNICALL
    382 JVM_ResolveClass(JNIEnv *env, jclass cls);
    383 
    384 /*
    385  * Find a class from a boot class loader. Returns NULL if class not found.
    386  */
    387 JNIEXPORT jclass JNICALL
    388 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name);
    389 
    390 /*
    391  * Find a class from a given class loader. Throw ClassNotFoundException
    392  * or NoClassDefFoundError depending on the value of the last
    393  * argument.
    394  */
    395 JNIEXPORT jclass JNICALL
    396 JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,
    397                              jobject loader, jboolean throwError);
    398 
    399 /*
    400  * Find a class from a given class.
    401  */
    402 JNIEXPORT jclass JNICALL
    403 JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,
    404                              jclass from);
    405 
    406 /* Find a loaded class cached by the VM */
    407 JNIEXPORT jclass JNICALL
    408 JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);
    409 
    410 /* Define a class */
    411 JNIEXPORT jclass JNICALL
    412 JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
    413                 jsize len, jobject pd);
    414 
    415 /* Define a class with a source (added in JDK1.5) */
    416 JNIEXPORT jclass JNICALL
    417 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
    418                           const jbyte *buf, jsize len, jobject pd,
    419                           const char *source);
    420 
    421 /*
    422  * Reflection support functions
    423  */
    424 
    425 JNIEXPORT jstring JNICALL
    426 JVM_GetClassName(JNIEnv *env, jclass cls);
    427 
    428 JNIEXPORT jobjectArray JNICALL
    429 JVM_GetClassInterfaces(JNIEnv *env, jclass cls);
    430 
    431 JNIEXPORT jobject JNICALL
    432 JVM_GetClassLoader(JNIEnv *env, jclass cls);
    433 
    434 JNIEXPORT jboolean JNICALL
    435 JVM_IsInterface(JNIEnv *env, jclass cls);
    436 
    437 JNIEXPORT jobjectArray JNICALL
    438 JVM_GetClassSigners(JNIEnv *env, jclass cls);
    439 
    440 JNIEXPORT void JNICALL
    441 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);
    442 
    443 JNIEXPORT jobject JNICALL
    444 JVM_GetProtectionDomain(JNIEnv *env, jclass cls);
    445 
    446 JNIEXPORT void JNICALL
    447 JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain);
    448 
    449 JNIEXPORT jboolean JNICALL
    450 JVM_IsArrayClass(JNIEnv *env, jclass cls);
    451 
    452 JNIEXPORT jboolean JNICALL
    453 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);
    454 
    455 JNIEXPORT jclass JNICALL
    456 JVM_GetComponentType(JNIEnv *env, jclass cls);
    457 
    458 JNIEXPORT jint JNICALL
    459 JVM_GetClassModifiers(JNIEnv *env, jclass cls);
    460 
    461 JNIEXPORT jobjectArray JNICALL
    462 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);
    463 
    464 JNIEXPORT jclass JNICALL
    465 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);
    466 
    467 /* Generics support (JDK 1.5) */
    468 JNIEXPORT jstring JNICALL
    469 JVM_GetClassSignature(JNIEnv *env, jclass cls);
    470 
    471 /* Annotations support (JDK 1.5) */
    472 JNIEXPORT jbyteArray JNICALL
    473 JVM_GetClassAnnotations(JNIEnv *env, jclass cls);
    474 
    475 /*
    476  * New (JDK 1.4) reflection implementation
    477  */
    478 
    479 JNIEXPORT jobjectArray JNICALL
    480 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);
    481 
    482 JNIEXPORT jobjectArray JNICALL
    483 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);
    484 
    485 JNIEXPORT jobjectArray JNICALL
    486 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);
    487 
    488 /* Differs from JVM_GetClassModifiers in treatment of inner classes.
    489    This returns the access flags for the class as specified in the
    490    class file rather than searching the InnerClasses attribute (if
    491    present) to find the source-level access flags. Only the values of
    492    the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
    493    valid. */
    494 JNIEXPORT jint JNICALL
    495 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);
    496 
    497 /* The following two reflection routines are still needed due to startup time issues */
    498 /*
    499  * java.lang.reflect.Method
    500  */
    501 JNIEXPORT jobject JNICALL
    502 JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0);
    503 
    504 /*
    505  * java.lang.reflect.Constructor
    506  */
    507 JNIEXPORT jobject JNICALL
    508 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);
    509 
    510 /*
    511  * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)
    512  */
    513 
    514 JNIEXPORT jobject JNICALL
    515 JVM_GetClassConstantPool(JNIEnv *env, jclass cls);
    516 
    517 JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize
    518 (JNIEnv *env, jobject unused, jobject jcpool);
    519 
    520 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt
    521 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    522 
    523 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded
    524 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    525 
    526 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt
    527 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    528 
    529 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded
    530 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    531 
    532 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt
    533 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    534 
    535 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded
    536 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    537 
    538 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt
    539 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    540 
    541 JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt
    542 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    543 
    544 JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt
    545 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    546 
    547 JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt
    548 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    549 
    550 JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt
    551 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    552 
    553 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt
    554 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    555 
    556 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
    557 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
    558 
    559 /*
    560  * java.security.*
    561  */
    562 
    563 JNIEXPORT jobject JNICALL
    564 JVM_DoPrivileged(JNIEnv *env, jclass cls,
    565                  jobject action, jobject context, jboolean wrapException);
    566 
    567 JNIEXPORT jobject JNICALL
    568 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);
    569 
    570 JNIEXPORT jobject JNICALL
    571 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);
    572 
    573 /*
    574  * Signal support, used to implement the shutdown sequence.  Every VM must
    575  * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts
    576  * (^C) and the latter for external termination (kill, system shutdown, etc.).
    577  * Other platform-dependent signal values may also be supported.
    578  */
    579 
    580 JNIEXPORT void * JNICALL
    581 JVM_RegisterSignal(jint sig, void *handler);
    582 
    583 JNIEXPORT jboolean JNICALL
    584 JVM_RaiseSignal(jint sig);
    585 
    586 JNIEXPORT jint JNICALL
    587 JVM_FindSignal(const char *name);
    588 
    589 /*
    590  * Retrieve the assertion directives for the specified class.
    591  */
    592 JNIEXPORT jboolean JNICALL
    593 JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls);
    594 
    595 /*
    596  * Retrieve the assertion directives from the VM.
    597  */
    598 JNIEXPORT jobject JNICALL
    599 JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);
    600 
    601 /*
    602  * java.util.concurrent.AtomicLong
    603  */
    604 JNIEXPORT jboolean JNICALL
    605 JVM_SupportsCX8(void);
    606 
    607 /*
    608  * com.sun.dtrace.jsdt support
    609  */
    610 
    611 #define JVM_TRACING_DTRACE_VERSION 1
    612 
    613 /*
    614  * Structure to pass one probe description to JVM
    615  */
    616 typedef struct {
    617     jmethodID method;
    618     jstring   function;
    619     jstring   name;
    620     void*            reserved[4];     // for future use
    621 } JVM_DTraceProbe;
    622 
    623 /**
    624  * Encapsulates the stability ratings for a DTrace provider field
    625  */
    626 typedef struct {
    627     jint nameStability;
    628     jint dataStability;
    629     jint dependencyClass;
    630 } JVM_DTraceInterfaceAttributes;
    631 
    632 /*
    633  * Structure to pass one provider description to JVM
    634  */
    635 typedef struct {
    636     jstring                       name;
    637     JVM_DTraceProbe*              probes;
    638     jint                          probe_count;
    639     JVM_DTraceInterfaceAttributes providerAttributes;
    640     JVM_DTraceInterfaceAttributes moduleAttributes;
    641     JVM_DTraceInterfaceAttributes functionAttributes;
    642     JVM_DTraceInterfaceAttributes nameAttributes;
    643     JVM_DTraceInterfaceAttributes argsAttributes;
    644     void*                         reserved[4]; // for future use
    645 } JVM_DTraceProvider;
    646 
    647 /*
    648  * Get the version number the JVM was built with
    649  */
    650 JNIEXPORT jint JNICALL
    651 JVM_DTraceGetVersion(JNIEnv* env);
    652 
    653 /*
    654  * Register new probe with given signature, return global handle
    655  *
    656  * The version passed in is the version that the library code was
    657  * built with.
    658  */
    659 JNIEXPORT jlong JNICALL
    660 JVM_DTraceActivate(JNIEnv* env, jint version, jstring module_name,
    661   jint providers_count, JVM_DTraceProvider* providers);
    662 
    663 /*
    664  * Check JSDT probe
    665  */
    666 JNIEXPORT jboolean JNICALL
    667 JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method);
    668 
    669 /*
    670  * Destroy custom DOF
    671  */
    672 JNIEXPORT void JNICALL
    673 JVM_DTraceDispose(JNIEnv* env, jlong activation_handle);
    674 
    675 /*
    676  * Check to see if DTrace is supported by OS
    677  */
    678 JNIEXPORT jboolean JNICALL
    679 JVM_DTraceIsSupported(JNIEnv* env);
    680 
    681 /*************************************************************************
    682  PART 2: Support for the Verifier and Class File Format Checker
    683  ************************************************************************/
    684 /*
    685  * Return the class name in UTF format. The result is valid
    686  * until JVM_ReleaseUTf is called.
    687  *
    688  * The caller must treat the string as a constant and not modify it
    689  * in any way.
    690  */
    691 JNIEXPORT const char * JNICALL
    692 JVM_GetClassNameUTF(JNIEnv *env, jclass cb);
    693 
    694 /*
    695  * Returns the constant pool types in the buffer provided by "types."
    696  */
    697 JNIEXPORT void JNICALL
    698 JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types);
    699 
    700 /*
    701  * Returns the number of Constant Pool entries.
    702  */
    703 JNIEXPORT jint JNICALL
    704 JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);
    705 
    706 /*
    707  * Returns the number of *declared* fields or methods.
    708  */
    709 JNIEXPORT jint JNICALL
    710 JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);
    711 
    712 JNIEXPORT jint JNICALL
    713 JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);
    714 
    715 /*
    716  * Returns the CP indexes of exceptions raised by a given method.
    717  * Places the result in the given buffer.
    718  *
    719  * The method is identified by method_index.
    720  */
    721 JNIEXPORT void JNICALL
    722 JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,
    723                                 unsigned short *exceptions);
    724 /*
    725  * Returns the number of exceptions raised by a given method.
    726  * The method is identified by method_index.
    727  */
    728 JNIEXPORT jint JNICALL
    729 JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index);
    730 
    731 /*
    732  * Returns the byte code sequence of a given method.
    733  * Places the result in the given buffer.
    734  *
    735  * The method is identified by method_index.
    736  */
    737 JNIEXPORT void JNICALL
    738 JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,
    739                         unsigned char *code);
    740 
    741 /*
    742  * Returns the length of the byte code sequence of a given method.
    743  * The method is identified by method_index.
    744  */
    745 JNIEXPORT jint JNICALL
    746 JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index);
    747 
    748 /*
    749  * A structure used to a capture exception table entry in a Java method.
    750  */
    751 typedef struct {
    752     jint start_pc;
    753     jint end_pc;
    754     jint handler_pc;
    755     jint catchType;
    756 } JVM_ExceptionTableEntryType;
    757 
    758 /*
    759  * Returns the exception table entry at entry_index of a given method.
    760  * Places the result in the given buffer.
    761  *
    762  * The method is identified by method_index.
    763  */
    764 JNIEXPORT void JNICALL
    765 JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index,
    766                                    jint entry_index,
    767                                    JVM_ExceptionTableEntryType *entry);
    768 
    769 /*
    770  * Returns the length of the exception table of a given method.
    771  * The method is identified by method_index.
    772  */
    773 JNIEXPORT jint JNICALL
    774 JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index);
    775 
    776 /*
    777  * Returns the modifiers of a given field.
    778  * The field is identified by field_index.
    779  */
    780 JNIEXPORT jint JNICALL
    781 JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index);
    782 
    783 /*
    784  * Returns the modifiers of a given method.
    785  * The method is identified by method_index.
    786  */
    787 JNIEXPORT jint JNICALL
    788 JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index);
    789 
    790 /*
    791  * Returns the number of local variables of a given method.
    792  * The method is identified by method_index.
    793  */
    794 JNIEXPORT jint JNICALL
    795 JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index);
    796 
    797 /*
    798  * Returns the number of arguments (including this pointer) of a given method.
    799  * The method is identified by method_index.
    800  */
    801 JNIEXPORT jint JNICALL
    802 JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index);
    803 
    804 /*
    805  * Returns the maximum amount of stack (in words) used by a given method.
    806  * The method is identified by method_index.
    807  */
    808 JNIEXPORT jint JNICALL
    809 JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index);
    810 
    811 /*
    812  * Is a given method a constructor.
    813  * The method is identified by method_index.
    814  */
    815 JNIEXPORT jboolean JNICALL
    816 JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index);
    817 
    818 /*
    819  * Returns the name of a given method in UTF format.
    820  * The result remains valid until JVM_ReleaseUTF is called.
    821  *
    822  * The caller must treat the string as a constant and not modify it
    823  * in any way.
    824  */
    825 JNIEXPORT const char * JNICALL
    826 JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index);
    827 
    828 /*
    829  * Returns the signature of a given method in UTF format.
    830  * The result remains valid until JVM_ReleaseUTF is called.
    831  *
    832  * The caller must treat the string as a constant and not modify it
    833  * in any way.
    834  */
    835 JNIEXPORT const char * JNICALL
    836 JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index);
    837 
    838 /*
    839  * Returns the name of the field refered to at a given constant pool
    840  * index.
    841  *
    842  * The result is in UTF format and remains valid until JVM_ReleaseUTF
    843  * is called.
    844  *
    845  * The caller must treat the string as a constant and not modify it
    846  * in any way.
    847  */
    848 JNIEXPORT const char * JNICALL
    849 JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);
    850 
    851 /*
    852  * Returns the name of the method refered to at a given constant pool
    853  * index.
    854  *
    855  * The result is in UTF format and remains valid until JVM_ReleaseUTF
    856  * is called.
    857  *
    858  * The caller must treat the string as a constant and not modify it
    859  * in any way.
    860  */
    861 JNIEXPORT const char * JNICALL
    862 JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);
    863 
    864 /*
    865  * Returns the signature of the method refered to at a given constant pool
    866  * index.
    867  *
    868  * The result is in UTF format and remains valid until JVM_ReleaseUTF
    869  * is called.
    870  *
    871  * The caller must treat the string as a constant and not modify it
    872  * in any way.
    873  */
    874 JNIEXPORT const char * JNICALL
    875 JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);
    876 
    877 /*
    878  * Returns the signature of the field refered to at a given constant pool
    879  * index.
    880  *
    881  * The result is in UTF format and remains valid until JVM_ReleaseUTF
    882  * is called.
    883  *
    884  * The caller must treat the string as a constant and not modify it
    885  * in any way.
    886  */
    887 JNIEXPORT const char * JNICALL
    888 JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);
    889 
    890 /*
    891  * Returns the class name refered to at a given constant pool index.
    892  *
    893  * The result is in UTF format and remains valid until JVM_ReleaseUTF
    894  * is called.
    895  *
    896  * The caller must treat the string as a constant and not modify it
    897  * in any way.
    898  */
    899 JNIEXPORT const char * JNICALL
    900 JVM_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index);
    901 
    902 /*
    903  * Returns the class name refered to at a given constant pool index.
    904  *
    905  * The constant pool entry must refer to a CONSTANT_Fieldref.
    906  *
    907  * The result is in UTF format and remains valid until JVM_ReleaseUTF
    908  * is called.
    909  *
    910  * The caller must treat the string as a constant and not modify it
    911  * in any way.
    912  */
    913 JNIEXPORT const char * JNICALL
    914 JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index);
    915 
    916 /*
    917  * Returns the class name refered to at a given constant pool index.
    918  *
    919  * The constant pool entry must refer to CONSTANT_Methodref or
    920  * CONSTANT_InterfaceMethodref.
    921  *
    922  * The result is in UTF format and remains valid until JVM_ReleaseUTF
    923  * is called.
    924  *
    925  * The caller must treat the string as a constant and not modify it
    926  * in any way.
    927  */
    928 JNIEXPORT const char * JNICALL
    929 JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index);
    930 
    931 /*
    932  * Returns the modifiers of a field in calledClass. The field is
    933  * referred to in class cb at constant pool entry index.
    934  *
    935  * The caller must treat the string as a constant and not modify it
    936  * in any way.
    937  *
    938  * Returns -1 if the field does not exist in calledClass.
    939  */
    940 JNIEXPORT jint JNICALL
    941 JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
    942 
    943 /*
    944  * Returns the modifiers of a method in calledClass. The method is
    945  * referred to in class cb at constant pool entry index.
    946  *
    947  * Returns -1 if the method does not exist in calledClass.
    948  */
    949 JNIEXPORT jint JNICALL
    950 JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
    951 
    952 /*
    953  * Releases the UTF string obtained from the VM.
    954  */
    955 JNIEXPORT void JNICALL
    956 JVM_ReleaseUTF(const char *utf);
    957 
    958 /*
    959  * Compare if two classes are in the same package.
    960  */
    961 JNIEXPORT jboolean JNICALL
    962 JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2);
    963 
    964 /* Get classfile constants */
    965 #include "classfile_constants.h"
    966 
    967 /*
    968  * A function defined by the byte-code verifier and called by the VM.
    969  * This is not a function implemented in the VM.
    970  *
    971  * Returns JNI_FALSE if verification fails. A detailed error message
    972  * will be places in msg_buf, whose length is specified by buf_len.
    973  */
    974 typedef jboolean (*verifier_fn_t)(JNIEnv *env,
    975                                   jclass cb,
    976                                   char * msg_buf,
    977                                   jint buf_len);
    978 
    979 
    980 /*
    981  * Support for a VM-independent class format checker.
    982  */
    983 typedef struct {
    984     unsigned long code;    /* byte code */
    985     unsigned long excs;    /* exceptions */
    986     unsigned long etab;    /* catch table */
    987     unsigned long lnum;    /* line number */
    988     unsigned long lvar;    /* local vars */
    989 } method_size_info;
    990 
    991 typedef struct {
    992     unsigned int constants;    /* constant pool */
    993     unsigned int fields;
    994     unsigned int methods;
    995     unsigned int interfaces;
    996     unsigned int fields2;      /* number of static 2-word fields */
    997     unsigned int innerclasses; /* # of records in InnerClasses attr */
    998 
    999     method_size_info clinit;   /* memory used in clinit */
   1000     method_size_info main;     /* used everywhere else */
   1001 } class_size_info;
   1002 
   1003 /*
   1004  * Functions defined in libjava.so to perform string conversions.
   1005  *
   1006  */
   1007 
   1008 typedef jstring (*to_java_string_fn_t)(JNIEnv *env, char *str);
   1009 
   1010 typedef char *(*to_c_string_fn_t)(JNIEnv *env, jstring s, jboolean *b);
   1011 
   1012 /* This is the function defined in libjava.so that performs class
   1013  * format checks. This functions fills in size information about
   1014  * the class file and returns:
   1015  *
   1016  *   0: good
   1017  *  -1: out of memory
   1018  *  -2: bad format
   1019  *  -3: unsupported version
   1020  *  -4: bad class name
   1021  */
   1022 
   1023 typedef jint (*check_format_fn_t)(char *class_name,
   1024                                   unsigned char *data,
   1025                                   unsigned int data_size,
   1026                                   class_size_info *class_size,
   1027                                   char *message_buffer,
   1028                                   jint buffer_length,
   1029                                   jboolean measure_only,
   1030                                   jboolean check_relaxed);
   1031 
   1032 #define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \
   1033                                         JVM_ACC_FINAL | \
   1034                                         JVM_ACC_SUPER | \
   1035                                         JVM_ACC_INTERFACE | \
   1036                                         JVM_ACC_ABSTRACT | \
   1037                                         JVM_ACC_ANNOTATION | \
   1038                                         JVM_ACC_ENUM | \
   1039                                         JVM_ACC_SYNTHETIC)
   1040 
   1041 #define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \
   1042                                         JVM_ACC_PRIVATE | \
   1043                                         JVM_ACC_PROTECTED | \
   1044                                         JVM_ACC_STATIC | \
   1045                                         JVM_ACC_FINAL | \
   1046                                         JVM_ACC_VOLATILE | \
   1047                                         JVM_ACC_TRANSIENT | \
   1048                                         JVM_ACC_ENUM | \
   1049                                         JVM_ACC_SYNTHETIC)
   1050 
   1051 #define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \
   1052                                          JVM_ACC_PRIVATE | \
   1053                                          JVM_ACC_PROTECTED | \
   1054                                          JVM_ACC_STATIC | \
   1055                                          JVM_ACC_FINAL | \
   1056                                          JVM_ACC_SYNCHRONIZED | \
   1057                                          JVM_ACC_BRIDGE | \
   1058                                          JVM_ACC_VARARGS | \
   1059                                          JVM_ACC_NATIVE | \
   1060                                          JVM_ACC_ABSTRACT | \
   1061                                          JVM_ACC_STRICT | \
   1062                                          JVM_ACC_SYNTHETIC)
   1063 
   1064 /*
   1065  * This is the function defined in libjava.so to perform path
   1066  * canonicalization. VM call this function before opening jar files
   1067  * to load system classes.
   1068  *
   1069  */
   1070 
   1071 typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len);
   1072 
   1073 /*************************************************************************
   1074  PART 3: I/O and Network Support
   1075  ************************************************************************/
   1076 
   1077 /* Note that the JVM IO functions are expected to return JVM_IO_ERR
   1078  * when there is any kind of error. The caller can then use the
   1079  * platform specific support (e.g., errno) to get the detailed
   1080  * error info.  The JVM_GetLastErrorString procedure may also be used
   1081  * to obtain a descriptive error string.
   1082  */
   1083 #define JVM_IO_ERR  (-1)
   1084 
   1085 /* For interruptible IO. Returning JVM_IO_INTR indicates that an IO
   1086  * operation has been disrupted by Thread.interrupt. There are a
   1087  * number of technical difficulties related to interruptible IO that
   1088  * need to be solved. For example, most existing programs do not handle
   1089  * InterruptedIOExceptions specially, they simply treat those as any
   1090  * IOExceptions, which typically indicate fatal errors.
   1091  *
   1092  * There are also two modes of operation for interruptible IO. In the
   1093  * resumption mode, an interrupted IO operation is guaranteed not to
   1094  * have any side-effects, and can be restarted. In the termination mode,
   1095  * an interrupted IO operation corrupts the underlying IO stream, so
   1096  * that the only reasonable operation on an interrupted stream is to
   1097  * close that stream. The resumption mode seems to be impossible to
   1098  * implement on Win32 and Solaris. Implementing the termination mode is
   1099  * easier, but it's not clear that's the right semantics.
   1100  *
   1101  * Interruptible IO is not supported on Win32.It can be enabled/disabled
   1102  * using a compile-time flag on Solaris. Third-party JVM ports do not
   1103  * need to implement interruptible IO.
   1104  */
   1105 #define JVM_IO_INTR (-2)
   1106 
   1107 /* Write a string into the given buffer, in the platform's local encoding,
   1108  * that describes the most recent system-level error to occur in this thread.
   1109  * Return the length of the string or zero if no error occurred.
   1110  */
   1111 JNIEXPORT jint JNICALL
   1112 JVM_GetLastErrorString(char *buf, int len);
   1113 
   1114 /*
   1115  * Convert a pathname into native format.  This function does syntactic
   1116  * cleanup, such as removing redundant separator characters.  It modifies
   1117  * the given pathname string in place.
   1118  */
   1119 JNIEXPORT char * JNICALL
   1120 JVM_NativePath(char *);
   1121 
   1122 /*
   1123  * JVM I/O error codes
   1124  */
   1125 #define JVM_EEXIST       -100
   1126 
   1127 /*
   1128  * Open a file descriptor. This function returns a negative error code
   1129  * on error, and a non-negative integer that is the file descriptor on
   1130  * success.
   1131  */
   1132 JNIEXPORT jint JNICALL
   1133 JVM_Open(const char *fname, jint flags, jint mode);
   1134 
   1135 /*
   1136  * Close a file descriptor. This function returns -1 on error, and 0
   1137  * on success.
   1138  *
   1139  * fd        the file descriptor to close.
   1140  */
   1141 JNIEXPORT jint JNICALL
   1142 JVM_Close(jint fd);
   1143 
   1144 /*
   1145  * Read data from a file decriptor into a char array.
   1146  *
   1147  * fd        the file descriptor to read from.
   1148  * buf       the buffer where to put the read data.
   1149  * nbytes    the number of bytes to read.
   1150  *
   1151  * This function returns -1 on error, and 0 on success.
   1152  */
   1153 JNIEXPORT jint JNICALL
   1154 JVM_Read(jint fd, char *buf, jint nbytes);
   1155 
   1156 /*
   1157  * Write data from a char array to a file decriptor.
   1158  *
   1159  * fd        the file descriptor to read from.
   1160  * buf       the buffer from which to fetch the data.
   1161  * nbytes    the number of bytes to write.
   1162  *
   1163  * This function returns -1 on error, and 0 on success.
   1164  */
   1165 JNIEXPORT jint JNICALL
   1166 JVM_Write(jint fd, char *buf, jint nbytes);
   1167 
   1168 /*
   1169  * Move the file descriptor pointer from whence by offset.
   1170  *
   1171  * fd        the file descriptor to move.
   1172  * offset    the number of bytes to move it by.
   1173  * whence    the start from where to move it.
   1174  *
   1175  * This function returns the resulting pointer location.
   1176  */
   1177 JNIEXPORT jlong JNICALL
   1178 JVM_Lseek(jint fd, jlong offset, jint whence);
   1179 
   1180 /*
   1181  * Set the length of the file associated with the given descriptor to the given
   1182  * length.  If the new length is longer than the current length then the file
   1183  * is extended; the contents of the extended portion are not defined.  The
   1184  * value of the file pointer is undefined after this procedure returns.
   1185  */
   1186 JNIEXPORT jint JNICALL
   1187 JVM_SetLength(jint fd, jlong length);
   1188 
   1189 /*
   1190  * Synchronize the file descriptor's in memory state with that of the
   1191  * physical device.  Return of -1 is an error, 0 is OK.
   1192  */
   1193 JNIEXPORT jint JNICALL
   1194 JVM_Sync(jint fd);
   1195 
   1196 /*
   1197  * Networking library support
   1198  */
   1199 
   1200 JNIEXPORT jint JNICALL
   1201 JVM_InitializeSocketLibrary(void);
   1202 
   1203 struct sockaddr;
   1204 
   1205 JNIEXPORT jint JNICALL
   1206 JVM_Socket(jint domain, jint type, jint protocol);
   1207 
   1208 JNIEXPORT jint JNICALL
   1209 JVM_SocketClose(jint fd);
   1210 
   1211 JNIEXPORT jint JNICALL
   1212 JVM_SocketShutdown(jint fd, jint howto);
   1213 
   1214 JNIEXPORT jint JNICALL
   1215 JVM_Recv(jint fd, char *buf, jint nBytes, jint flags);
   1216 
   1217 JNIEXPORT jint JNICALL
   1218 JVM_Send(jint fd, char *buf, jint nBytes, jint flags);
   1219 
   1220 JNIEXPORT jint JNICALL
   1221 JVM_Timeout(int fd, long timeout);
   1222 
   1223 JNIEXPORT jint JNICALL
   1224 JVM_Listen(jint fd, jint count);
   1225 
   1226 JNIEXPORT jint JNICALL
   1227 JVM_Connect(jint fd, struct sockaddr *him, jint len);
   1228 
   1229 JNIEXPORT jint JNICALL
   1230 JVM_Bind(jint fd, struct sockaddr *him, jint len);
   1231 
   1232 JNIEXPORT jint JNICALL
   1233 JVM_Accept(jint fd, struct sockaddr *him, jint *len);
   1234 
   1235 JNIEXPORT jint JNICALL
   1236 JVM_RecvFrom(jint fd, char *buf, int nBytes,
   1237                   int flags, struct sockaddr *from, int *fromlen);
   1238 
   1239 JNIEXPORT jint JNICALL
   1240 JVM_SendTo(jint fd, char *buf, int len,
   1241                 int flags, struct sockaddr *to, int tolen);
   1242 
   1243 JNIEXPORT jint JNICALL
   1244 JVM_SocketAvailable(jint fd, jint *result);
   1245 
   1246 
   1247 JNIEXPORT jint JNICALL
   1248 JVM_GetSockName(jint fd, struct sockaddr *him, int *len);
   1249 
   1250 JNIEXPORT jint JNICALL
   1251 JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen);
   1252 
   1253 JNIEXPORT jint JNICALL
   1254 JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen);
   1255 
   1256 JNIEXPORT int JNICALL
   1257 JVM_GetHostName(char* name, int namelen);
   1258 
   1259 /*
   1260  * The standard printing functions supported by the Java VM. (Should they
   1261  * be renamed to JVM_* in the future?
   1262  */
   1263 
   1264 /*
   1265  * BE CAREFUL! The following functions do not implement the
   1266  * full feature set of standard C printf formats.
   1267  */
   1268 int
   1269 jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
   1270 
   1271 int
   1272 jio_snprintf(char *str, size_t count, const char *fmt, ...);
   1273 
   1274 int
   1275 jio_fprintf(FILE *, const char *fmt, ...);
   1276 
   1277 int
   1278 jio_vfprintf(FILE *, const char *fmt, va_list args);
   1279 
   1280 
   1281 JNIEXPORT void * JNICALL
   1282 JVM_RawMonitorCreate(void);
   1283 
   1284 JNIEXPORT void JNICALL
   1285 JVM_RawMonitorDestroy(void *mon);
   1286 
   1287 JNIEXPORT jint JNICALL
   1288 JVM_RawMonitorEnter(void *mon);
   1289 
   1290 JNIEXPORT void JNICALL
   1291 JVM_RawMonitorExit(void *mon);
   1292 
   1293 /*
   1294  * java.lang.management support
   1295  */
   1296 JNIEXPORT void* JNICALL
   1297 JVM_GetManagement(jint version);
   1298 
   1299 /*
   1300  * com.sun.tools.attach.VirtualMachine support
   1301  *
   1302  * Initialize the agent properties with the properties maintained in the VM.
   1303  */
   1304 JNIEXPORT jobject JNICALL
   1305 JVM_InitAgentProperties(JNIEnv *env, jobject agent_props);
   1306 
   1307 /* Generics reflection support.
   1308  *
   1309  * Returns information about the given class's EnclosingMethod
   1310  * attribute, if present, or null if the class had no enclosing
   1311  * method.
   1312  *
   1313  * If non-null, the returned array contains three elements. Element 0
   1314  * is the java.lang.Class of which the enclosing method is a member,
   1315  * and elements 1 and 2 are the java.lang.Strings for the enclosing
   1316  * method's name and descriptor, respectively.
   1317  */
   1318 JNIEXPORT jobjectArray JNICALL
   1319 JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);
   1320 
   1321 /*
   1322  * Java thread state support
   1323  */
   1324 enum {
   1325     JAVA_THREAD_STATE_NEW           = 0,
   1326     JAVA_THREAD_STATE_RUNNABLE      = 1,
   1327     JAVA_THREAD_STATE_BLOCKED       = 2,
   1328     JAVA_THREAD_STATE_WAITING       = 3,
   1329     JAVA_THREAD_STATE_TIMED_WAITING = 4,
   1330     JAVA_THREAD_STATE_TERMINATED    = 5,
   1331     JAVA_THREAD_STATE_COUNT         = 6
   1332 };
   1333 
   1334 /*
   1335  * Returns an array of the threadStatus values representing the
   1336  * given Java thread state.  Returns NULL if the VM version is
   1337  * incompatible with the JDK or doesn't support the given
   1338  * Java thread state.
   1339  */
   1340 JNIEXPORT jintArray JNICALL
   1341 JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState);
   1342 
   1343 /*
   1344  * Returns an array of the substate names representing the
   1345  * given Java thread state.  Returns NULL if the VM version is
   1346  * incompatible with the JDK or the VM doesn't support
   1347  * the given Java thread state.
   1348  * values must be the jintArray returned from JVM_GetThreadStateValues
   1349  * and javaThreadState.
   1350  */
   1351 JNIEXPORT jobjectArray JNICALL
   1352 JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values);
   1353 
   1354 /* =========================================================================
   1355  * The following defines a private JVM interface that the JDK can query
   1356  * for the JVM version and capabilities.  sun.misc.Version defines
   1357  * the methods for getting the VM version and its capabilities.
   1358  *
   1359  * When a new bit is added, the following should be updated to provide
   1360  * access to the new capability:
   1361  *    HS:   JVM_GetVersionInfo and Abstract_VM_Version class
   1362  *    SDK:  Version class
   1363  *
   1364  * Similary, a private JDK interface JDK_GetVersionInfo0 is defined for
   1365  * JVM to query for the JDK version and capabilities.
   1366  *
   1367  * When a new bit is added, the following should be updated to provide
   1368  * access to the new capability:
   1369  *    HS:   JDK_Version class
   1370  *    SDK:  JDK_GetVersionInfo0
   1371  *
   1372  * ==========================================================================
   1373  */
   1374 typedef struct {
   1375     /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */
   1376     unsigned int jvm_version;   /* Consists of major, minor, micro (n.n.n) */
   1377                                 /* and build number (xx) */
   1378     unsigned int update_version : 8;         /* Update release version (uu) */
   1379     unsigned int special_update_version : 8; /* Special update release version (c)*/
   1380     unsigned int reserved1 : 16;
   1381     unsigned int reserved2;
   1382 
   1383     /* The following bits represents JVM supports that JDK has dependency on.
   1384      * JDK can use these bits to determine which JVM version
   1385      * and support it has to maintain runtime compatibility.
   1386      *
   1387      * When a new bit is added in a minor or update release, make sure
   1388      * the new bit is also added in the main/baseline.
   1389      */
   1390     unsigned int is_attach_supported : 1;
   1391     unsigned int is_kernel_jvm : 1;
   1392     unsigned int : 30;
   1393     unsigned int : 32;
   1394     unsigned int : 32;
   1395 } jvm_version_info;
   1396 
   1397 #define JVM_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
   1398 #define JVM_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
   1399 #define JVM_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
   1400 
   1401 /* Build number is available only for RE builds.
   1402  * It will be zero for internal builds.
   1403  */
   1404 #define JVM_VERSION_BUILD(version) ((version & 0x000000FF))
   1405 
   1406 JNIEXPORT void JNICALL
   1407 JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size);
   1408 
   1409 typedef struct {
   1410     // Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx
   1411     unsigned int jdk_version;   /* Consists of major, minor, micro (n.n.n) */
   1412                                 /* and build number (xx) */
   1413     unsigned int update_version : 8;         /* Update release version (uu) */
   1414     unsigned int special_update_version : 8; /* Special update release version (c)*/
   1415     unsigned int reserved1 : 16;
   1416     unsigned int reserved2;
   1417 
   1418     /* The following bits represents new JDK supports that VM has dependency on.
   1419      * VM implementation can use these bits to determine which JDK version
   1420      * and support it has to maintain runtime compatibility.
   1421      *
   1422      * When a new bit is added in a minor or update release, make sure
   1423      * the new bit is also added in the main/baseline.
   1424      */
   1425     unsigned int thread_park_blocker : 1;
   1426     unsigned int post_vm_init_hook_enabled : 1;
   1427     unsigned int : 30;
   1428     unsigned int : 32;
   1429     unsigned int : 32;
   1430 } jdk_version_info;
   1431 
   1432 #define JDK_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
   1433 #define JDK_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
   1434 #define JDK_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
   1435 
   1436 /* Build number is available only for RE build (i.e. JDK_BUILD_NUMBER is set to bNN)
   1437  * It will be zero for internal builds.
   1438  */
   1439 #define JDK_VERSION_BUILD(version) ((version & 0x000000FF))
   1440 
   1441 /*
   1442  * This is the function JDK_GetVersionInfo0 defined in libjava.so
   1443  * that is dynamically looked up by JVM.
   1444  */
   1445 typedef void (*jdk_version_info_fn_t)(jdk_version_info* info, size_t info_size);
   1446 
   1447 /*
   1448  * This structure is used by the launcher to get the default thread
   1449  * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a
   1450  * version of 1.1.  As it is not supported otherwise, it has been removed
   1451  * from jni.h
   1452  */
   1453 typedef struct JDK1_1InitArgs {
   1454     jint version;
   1455 
   1456     char **properties;
   1457     jint checkSource;
   1458     jint nativeStackSize;
   1459     jint javaStackSize;
   1460     jint minHeapSize;
   1461     jint maxHeapSize;
   1462     jint verifyMode;
   1463     char *classpath;
   1464 
   1465     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
   1466     void (JNICALL *exit)(jint code);
   1467     void (JNICALL *abort)(void);
   1468 
   1469     jint enableClassGC;
   1470     jint enableVerboseGC;
   1471     jint disableAsyncGC;
   1472     jint verbose;
   1473     jboolean debugging;
   1474     jint debugPort;
   1475 } JDK1_1InitArgs;
   1476 
   1477 
   1478 #ifdef __cplusplus
   1479 } /* extern "C" */
   1480 
   1481 #endif /* __cplusplus */
   1482 
   1483 #endif /* !_JAVASOFT_JVM_H_ */
   1484