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 

       31 #include "jni.h"

       32 #include "jvm_md.h"

       33 

       34 #ifdef __cplusplus

       35 extern "C" {

       36 #endif

       37 

       38 /*

       39  * This file contains additional functions exported from the VM.

       40  * These functions are complementary to the standard JNI support.

       41  * There are three parts to this file:

       42  *

       43  * First, this file contains the VM-related functions needed by native

       44  * libraries in the standard Java API. For example, the java.lang.Object

       45  * class needs VM-level functions that wait for and notify monitors.

       46  *

       47  * Second, this file contains the functions and constant definitions

       48  * needed by the byte code verifier and class file format checker.

       49  * These functions allow the verifier and format checker to be written

       50  * in a VM-independent way.

       51  *

       52  * Third, this file contains various I/O and nerwork operations needed

       53  * by the standard Java I/O and network APIs.

       54  */

       55 

       56 /*

       57  * Bump the version number when either of the following happens:

       58  *

       59  * 1. There is a change in JVM_* functions.

       60  *

       61  * 2. There is a change in the contract between VM and Java classes.

       62  *    For example, if the VM relies on a new private field in Thread

       63  *    class.

       64  */

       65 

       66 #define JVM_INTERFACE_VERSION 4

       67 

       68 JNIEXPORT jint JNICALL

       69 JVM_GetInterfaceVersion(void);

       70 

       71 /*************************************************************************

       72  PART 1: Functions for Native Libraries

       73  ************************************************************************/

       74 /*

       75  * java.lang.Object

       76  */

       77 JNIEXPORT jint JNICALL

       78 JVM_IHashCode(JNIEnv *env, jobject obj);

       79 

       80 JNIEXPORT void JNICALL

       81 JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms);

       82 

       83 JNIEXPORT void JNICALL

       84 JVM_MonitorNotify(JNIEnv *env, jobject obj);

       85 

       86 JNIEXPORT void JNICALL

       87 JVM_MonitorNotifyAll(JNIEnv *env, jobject obj);

       88 

       89 JNIEXPORT jobject JNICALL

       90 JVM_Clone(JNIEnv *env, jobject obj);

       91 

       92 /*

       93  * java.lang.String

       94  */

       95 JNIEXPORT jstring JNICALL

       96 JVM_InternString(JNIEnv *env, jstring str);

       97 

       98 /*

       99  * java.lang.System

      100  */

      101 JNIEXPORT jlong JNICALL

      102 JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored);

      103 

      104 JNIEXPORT jlong JNICALL

      105 JVM_NanoTime(JNIEnv *env, jclass ignored);

      106 

      107 JNIEXPORT void JNICALL

      108 JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,

      109               jobject dst, jint dst_pos, jint length);

      110 

      111 JNIEXPORT jobject JNICALL

      112 JVM_InitProperties(JNIEnv *env, jobject p);

      113 

      114 /*

      115  * java.io.File

      116  */

      117 JNIEXPORT void JNICALL

      118 JVM_OnExit(void (*func)(void));

      119 

      120 /*

      121  * java.lang.Runtime

      122  */

      123 JNIEXPORT void JNICALL

      124 JVM_Exit(jint code);

      125 

      126 JNIEXPORT void JNICALL

      127 JVM_Halt(jint code);

      128 

      129 JNIEXPORT void JNICALL

      130 JVM_GC(void);

      131 

      132 /* Returns the number of real-time milliseconds that have elapsed since the

      133  * least-recently-inspected heap object was last inspected by the garbage

      134  * collector.

      135  *

      136  * For simple stop-the-world collectors this value is just the time

      137  * since the most recent collection.  For generational collectors it is the

      138  * time since the oldest generation was most recently collected.  Other

      139  * collectors are free to return a pessimistic estimate of the elapsed time, or

      140  * simply the time since the last full collection was performed.

      141  *

      142  * Note that in the presence of reference objects, a given object that is no

      143  * longer strongly reachable may have to be inspected multiple times before it

      144  * can be reclaimed.

      145  */

      146 JNIEXPORT jlong JNICALL

      147 JVM_MaxObjectInspectionAge(void);

      148 

      149 JNIEXPORT void JNICALL

      150 JVM_TraceInstructions(jboolean on);

      151 

      152 JNIEXPORT void JNICALL

      153 JVM_TraceMethodCalls(jboolean on);

      154 

      155 JNIEXPORT jlong JNICALL

      156 JVM_TotalMemory(void);

      157 

      158 JNIEXPORT jlong JNICALL

      159 JVM_FreeMemory(void);

      160 

      161 JNIEXPORT jlong JNICALL

      162 JVM_MaxMemory(void);

      163 

      164 JNIEXPORT jint JNICALL

      165 JVM_ActiveProcessorCount(void);

      166 

      167 JNIEXPORT void * JNICALL

      168 JVM_LoadLibrary(const char *name);

      169 

      170 JNIEXPORT void JNICALL

      171 JVM_UnloadLibrary(void * handle);

      172 

      173 JNIEXPORT void * JNICALL

      174 JVM_FindLibraryEntry(void *handle, const char *name);

      175 

      176 JNIEXPORT jboolean JNICALL

      177 JVM_IsSupportedJNIVersion(jint version);

      178 

      179 /*

      180  * java.lang.Float and java.lang.Double

      181  */

      182 JNIEXPORT jboolean JNICALL

      183 JVM_IsNaN(jdouble d);

      184 

      185 /*

      186  * java.lang.Throwable

      187  */

      188 JNIEXPORT void JNICALL

      189 JVM_FillInStackTrace(JNIEnv *env, jobject throwable);

      190 

      191 JNIEXPORT void JNICALL

      192 JVM_PrintStackTrace(JNIEnv *env, jobject throwable, jobject printable);

      193 

      194 JNIEXPORT jint JNICALL

      195 JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable);

      196 

      197 JNIEXPORT jobject JNICALL

      198 JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index);

      199 

      200 /*

      201  * java.lang.Compiler

      202  */

      203 JNIEXPORT void JNICALL

      204 JVM_InitializeCompiler (JNIEnv *env, jclass compCls);

      205 

      206 JNIEXPORT jboolean JNICALL

      207 JVM_IsSilentCompiler(JNIEnv *env, jclass compCls);

      208 

      209 JNIEXPORT jboolean JNICALL

      210 JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls);

      211 

      212 JNIEXPORT jboolean JNICALL

      213 JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname);

      214 

      215 JNIEXPORT jobject JNICALL

      216 JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg);

      217 

      218 JNIEXPORT void JNICALL

      219 JVM_EnableCompiler(JNIEnv *env, jclass compCls);

      220 

      221 JNIEXPORT void JNICALL

      222 JVM_DisableCompiler(JNIEnv *env, jclass compCls);

      223 

      224 /*

      225  * java.lang.Thread

      226  */

      227 JNIEXPORT void JNICALL

      228 JVM_StartThread(JNIEnv *env, jobject thread);

      229 

      230 JNIEXPORT void JNICALL

      231 JVM_StopThread(JNIEnv *env, jobject thread, jobject exception);

      232 

      233 JNIEXPORT jboolean JNICALL

      234 JVM_IsThreadAlive(JNIEnv *env, jobject thread);

      235 

      236 JNIEXPORT void JNICALL

      237 JVM_SuspendThread(JNIEnv *env, jobject thread);

      238 

      239 JNIEXPORT void JNICALL

      240 JVM_ResumeThread(JNIEnv *env, jobject thread);

      241 

      242 JNIEXPORT void JNICALL

      243 JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio);

      244 

      245 JNIEXPORT void JNICALL

      246 JVM_Yield(JNIEnv *env, jclass threadClass);

      247 

      248 JNIEXPORT void JNICALL

      249 JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis);

      250 

      251 JNIEXPORT jobject JNICALL

      252 JVM_CurrentThread(JNIEnv *env, jclass threadClass);

      253 

      254 JNIEXPORT jint JNICALL

      255 JVM_CountStackFrames(JNIEnv *env, jobject thread);

      256 

      257 JNIEXPORT void JNICALL

      258 JVM_Interrupt(JNIEnv *env, jobject thread);

      259 

      260 JNIEXPORT jboolean JNICALL

      261 JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted);

      262 

      263 JNIEXPORT jboolean JNICALL

      264 JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj);

      265 

      266 JNIEXPORT void JNICALL

      267 JVM_DumpAllStacks(JNIEnv *env, jclass unused);

      268 

      269 JNIEXPORT jobjectArray JNICALL

      270 JVM_GetAllThreads(JNIEnv *env, jclass dummy);

      271 

      272 /* getStackTrace() and getAllStackTraces() method */

      273 JNIEXPORT jobjectArray JNICALL

      274 JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);

      275 

      276 /*

      277  * java.lang.SecurityManager

      278  */

      279 JNIEXPORT jclass JNICALL

      280 JVM_CurrentLoadedClass(JNIEnv *env);

      281 

      282 JNIEXPORT jobject JNICALL

      283 JVM_CurrentClassLoader(JNIEnv *env);

      284 

      285 JNIEXPORT jobjectArray JNICALL

      286 JVM_GetClassContext(JNIEnv *env);

      287 

      288 JNIEXPORT jint JNICALL

      289 JVM_ClassDepth(JNIEnv *env, jstring name);

      290 

      291 JNIEXPORT jint JNICALL

      292 JVM_ClassLoaderDepth(JNIEnv *env);

      293 

      294 /*

      295  * java.lang.Package

      296  */

      297 JNIEXPORT jstring JNICALL

      298 JVM_GetSystemPackage(JNIEnv *env, jstring name);

      299 

      300 JNIEXPORT jobjectArray JNICALL

      301 JVM_GetSystemPackages(JNIEnv *env);

      302 

      303 /*

      304  * java.io.ObjectInputStream

      305  */

      306 JNIEXPORT jobject JNICALL

      307 JVM_AllocateNewObject(JNIEnv *env, jobject obj, jclass currClass,

      308                       jclass initClass);

      309 

      310 JNIEXPORT jobject JNICALL

      311 JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass,

      312                      jint length);

      313 

      314 JNIEXPORT jobject JNICALL

      315 JVM_LatestUserDefinedLoader(JNIEnv *env);

      316 

      317 /*

      318  * This function has been deprecated and should not be considered

      319  * part of the specified JVM interface.

      320  */

      321 JNIEXPORT jclass JNICALL

      322 JVM_LoadClass0(JNIEnv *env, jobject obj, jclass currClass,

      323                jstring currClassName);

      324 

      325 /*

      326  * java.lang.reflect.Array

      327  */

      328 JNIEXPORT jint JNICALL

      329 JVM_GetArrayLength(JNIEnv *env, jobject arr);

      330 

      331 JNIEXPORT jobject JNICALL

      332 JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index);

      333 

      334 JNIEXPORT jvalue JNICALL

      335 JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode);

      336 

      337 JNIEXPORT void JNICALL

      338 JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val);

      339 

      340 JNIEXPORT void JNICALL

      341 JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v,

      342                              unsigned char vCode);

      343 

      344 JNIEXPORT jobject JNICALL

      345 JVM_NewArray(JNIEnv *env, jclass eltClass, jint length);

      346 

      347 JNIEXPORT jobject JNICALL

      348 JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim);

      349 

      350 /*

      351  * java.lang.Class and java.lang.ClassLoader

      352  */

      353 /*

      354  * Returns the class in which the code invoking the native method

      355  * belongs.

      356  *

      357  * Note that in JDK 1.1, native methods did not create a frame.

      358  * In 1.2, they do. Therefore native methods like Class.forName

      359  * can no longer look at the current frame for the caller class.

      360  */

      361 JNIEXPORT jclass JNICALL

      362 JVM_GetCallerClass(JNIEnv *env, int n);

      363 

      364 /*

      365  * Find primitive classes

      366  * utf: class name

      367  */

      368 JNIEXPORT jclass JNICALL

      369 JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);

      370 

      371 /*

      372  * Link the class

      373  */

      374 JNIEXPORT void JNICALL

      375 JVM_ResolveClass(JNIEnv *env, jclass cls);

      376 

      377 /*

      378  * Find a class from a boot class loader. Returns NULL if class not found.

      379  */

      380 JNIEXPORT jclass JNICALL

      381 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name);

      382 

      383 /*

      384  * Find a class from a given class loader. Throw ClassNotFoundException

      385  * or NoClassDefFoundError depending on the value of the last

      386  * argument.

      387  */

      388 JNIEXPORT jclass JNICALL

      389 JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,

      390                              jobject loader, jboolean throwError);

      391 

      392 /*

      393  * Find a class from a given class.

      394  */

      395 JNIEXPORT jclass JNICALL

      396 JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,

      397                              jclass from);

      398 

      399 /* Find a loaded class cached by the VM */

      400 JNIEXPORT jclass JNICALL

      401 JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);

      402 

      403 /* Define a class */

      404 JNIEXPORT jclass JNICALL

      405 JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,

      406                 jsize len, jobject pd);

      407 

      408 /* Define a class with a source (added in JDK1.5) */

      409 JNIEXPORT jclass JNICALL

      410 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,

      411                           const jbyte *buf, jsize len, jobject pd,

      412                           const char *source);

      413 

      414 /*

      415  * Reflection support functions

      416  */

      417 

      418 JNIEXPORT jstring JNICALL

      419 JVM_GetClassName(JNIEnv *env, jclass cls);

      420 

      421 JNIEXPORT jobjectArray JNICALL

      422 JVM_GetClassInterfaces(JNIEnv *env, jclass cls);

      423 

      424 JNIEXPORT jobject JNICALL

      425 JVM_GetClassLoader(JNIEnv *env, jclass cls);

      426 

      427 JNIEXPORT jboolean JNICALL

      428 JVM_IsInterface(JNIEnv *env, jclass cls);

      429 

      430 JNIEXPORT jobjectArray JNICALL

      431 JVM_GetClassSigners(JNIEnv *env, jclass cls);

      432 

      433 JNIEXPORT void JNICALL

      434 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);

      435 

      436 JNIEXPORT jobject JNICALL

      437 JVM_GetProtectionDomain(JNIEnv *env, jclass cls);

      438 

      439 JNIEXPORT void JNICALL

      440 JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain);

      441 

      442 JNIEXPORT jboolean JNICALL

      443 JVM_IsArrayClass(JNIEnv *env, jclass cls);

      444 

      445 JNIEXPORT jboolean JNICALL

      446 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);

      447 

      448 JNIEXPORT jclass JNICALL

      449 JVM_GetComponentType(JNIEnv *env, jclass cls);

      450 

      451 JNIEXPORT jint JNICALL

      452 JVM_GetClassModifiers(JNIEnv *env, jclass cls);

      453 

      454 JNIEXPORT jobjectArray JNICALL

      455 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);

      456 

      457 JNIEXPORT jclass JNICALL

      458 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);

      459 

      460 /* Generics support (JDK 1.5) */

      461 JNIEXPORT jstring JNICALL

      462 JVM_GetClassSignature(JNIEnv *env, jclass cls);

      463 

      464 /* Annotations support (JDK 1.5) */

      465 JNIEXPORT jbyteArray JNICALL

      466 JVM_GetClassAnnotations(JNIEnv *env, jclass cls);

      467 

      468 /*

      469  * New (JDK 1.4) reflection implementation

      470  */

      471 

      472 JNIEXPORT jobjectArray JNICALL

      473 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);

      474 

      475 JNIEXPORT jobjectArray JNICALL

      476 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);

      477 

      478 JNIEXPORT jobjectArray JNICALL

      479 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);

      480 

      481 /* Differs from JVM_GetClassModifiers in treatment of inner classes.

      482    This returns the access flags for the class as specified in the

      483    class file rather than searching the InnerClasses attribute (if

      484    present) to find the source-level access flags. Only the values of

      485    the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be

      486    valid. */

      487 JNIEXPORT jint JNICALL

      488 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);

      489 

      490 /* The following two reflection routines are still needed due to startup time issues */

      491 /*

      492  * java.lang.reflect.Method

      493  */

      494 JNIEXPORT jobject JNICALL

      495 JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0);

      496 

      497 /*

      498  * java.lang.reflect.Constructor

      499  */

      500 JNIEXPORT jobject JNICALL

      501 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);

      502 

      503 /*

      504  * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)

      505  */

      506 

      507 JNIEXPORT jobject JNICALL

      508 JVM_GetClassConstantPool(JNIEnv *env, jclass cls);

      509 

      510 JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize

      511 (JNIEnv *env, jobject unused, jobject jcpool);

      512 

      513 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt

      514 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      515 

      516 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded

      517 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      518 

      519 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt

      520 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      521 

      522 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded

      523 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      524 

      525 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt

      526 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      527 

      528 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded

      529 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      530 

      531 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt

      532 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      533 

      534 JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt

      535 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      536 

      537 JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt

      538 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      539 

      540 JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt

      541 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      542 

      543 JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt

      544 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      545 

      546 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt

      547 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      548 

      549 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At

      550 (JNIEnv *env, jobject unused, jobject jcpool, jint index);

      551 

      552 /*

      553  * java.security.*

      554  */

      555 

      556 JNIEXPORT jobject JNICALL

      557 JVM_DoPrivileged(JNIEnv *env, jclass cls,

      558                  jobject action, jobject context, jboolean wrapException);

      559 

      560 JNIEXPORT jobject JNICALL

      561 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);

      562 

      563 JNIEXPORT jobject JNICALL

      564 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);

      565 

      566 /*

      567  * Signal support, used to implement the shutdown sequence.  Every VM must

      568  * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts

      569  * (^C) and the latter for external termination (kill, system shutdown, etc.).

      570  * Other platform-dependent signal values may also be supported.

      571  */

      572 

      573 JNIEXPORT void * JNICALL

      574 JVM_RegisterSignal(jint sig, void *handler);

      575 

      576 JNIEXPORT jboolean JNICALL

      577 JVM_RaiseSignal(jint sig);

      578 

      579 JNIEXPORT jint JNICALL

      580 JVM_FindSignal(const char *name);

      581 

      582 /*

      583  * Retrieve the assertion directives for the specified class.

      584  */

      585 JNIEXPORT jboolean JNICALL

      586 JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls);

      587 

      588 /*

      589  * Retrieve the assertion directives from the VM.

      590  */

      591 JNIEXPORT jobject JNICALL

      592 JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);

      593 

      594 /*

      595  * java.util.concurrent.AtomicLong

      596  */

      597 JNIEXPORT jboolean JNICALL

      598 JVM_SupportsCX8(void);

      599 

      600 /*

      601  * com.sun.dtrace.jsdt support

      602  */

      603 

      604 #define JVM_TRACING_DTRACE_VERSION 1

      605 

      606 /*

      607  * Structure to pass one probe description to JVM

      608  */

      609 typedef struct {

      610     jmethodID method;

      611     jstring   function;

      612     jstring   name;

      613     void*            reserved[4];     // for future use

      614 } JVM_DTraceProbe;

      615 

      616 /**

      617  * Encapsulates the stability ratings for a DTrace provider field

      618  */

      619 typedef struct {

      620     jint nameStability;

      621     jint dataStability;

      622     jint dependencyClass;

      623 } JVM_DTraceInterfaceAttributes;

      624 

      625 /*

      626  * Structure to pass one provider description to JVM

      627  */

      628 typedef struct {

      629     jstring                       name;

      630     JVM_DTraceProbe*              probes;

      631     jint                          probe_count;

      632     JVM_DTraceInterfaceAttributes providerAttributes;

      633     JVM_DTraceInterfaceAttributes moduleAttributes;

      634     JVM_DTraceInterfaceAttributes functionAttributes;

      635     JVM_DTraceInterfaceAttributes nameAttributes;

      636     JVM_DTraceInterfaceAttributes argsAttributes;

      637     void*                         reserved[4]; // for future use

      638 } JVM_DTraceProvider;

      639 

      640 /*

      641  * Get the version number the JVM was built with

      642  */

      643 JNIEXPORT jint JNICALL

      644 JVM_DTraceGetVersion(JNIEnv* env);

      645 

      646 /*

      647  * Register new probe with given signature, return global handle

      648  *

      649  * The version passed in is the version that the library code was

      650  * built with.

      651  */

      652 JNIEXPORT jlong JNICALL

      653 JVM_DTraceActivate(JNIEnv* env, jint version, jstring module_name,

      654   jint providers_count, JVM_DTraceProvider* providers);

      655 

      656 /*

      657  * Check JSDT probe

      658  */

      659 JNIEXPORT jboolean JNICALL

      660 JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method);

      661 

      662 /*

      663  * Destroy custom DOF

      664  */

      665 JNIEXPORT void JNICALL

      666 JVM_DTraceDispose(JNIEnv* env, jlong activation_handle);

      667 

      668 /*

      669  * Check to see if DTrace is supported by OS

      670  */

      671 JNIEXPORT jboolean JNICALL

      672 JVM_DTraceIsSupported(JNIEnv* env);

      673 

      674 /*************************************************************************

      675  PART 2: Support for the Verifier and Class File Format Checker

      676  ************************************************************************/

      677 /*

      678  * Return the class name in UTF format. The result is valid

      679  * until JVM_ReleaseUTf is called.

      680  *

      681  * The caller must treat the string as a constant and not modify it

      682  * in any way.

      683  */

      684 JNIEXPORT const char * JNICALL

      685 JVM_GetClassNameUTF(JNIEnv *env, jclass cb);

      686 

      687 /*

      688  * Returns the constant pool types in the buffer provided by "types."

      689  */

      690 JNIEXPORT void JNICALL

      691 JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types);

      692 

      693 /*

      694  * Returns the number of Constant Pool entries.

      695  */

      696 JNIEXPORT jint JNICALL

      697 JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);

      698 

      699 /*

      700  * Returns the number of *declared* fields or methods.

      701  */

      702 JNIEXPORT jint JNICALL

      703 JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);

      704 

      705 JNIEXPORT jint JNICALL

      706 JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);

      707 

      708 /*

      709  * Returns the CP indexes of exceptions raised by a given method.

      710  * Places the result in the given buffer.

      711  *

      712  * The method is identified by method_index.

      713  */

      714 JNIEXPORT void JNICALL

      715 JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,

      716                                 unsigned short *exceptions);

      717 /*

      718  * Returns the number of exceptions raised by a given method.

      719  * The method is identified by method_index.

      720  */

      721 JNIEXPORT jint JNICALL

      722 JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index);

      723 

      724 /*

      725  * Returns the byte code sequence of a given method.

      726  * Places the result in the given buffer.

      727  *

      728  * The method is identified by method_index.

      729  */

      730 JNIEXPORT void JNICALL

      731 JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,

      732                         unsigned char *code);

      733 

      734 /*

      735  * Returns the length of the byte code sequence of a given method.

      736  * The method is identified by method_index.

      737  */

      738 JNIEXPORT jint JNICALL

      739 JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index);

      740 

      741 /*

      742  * A structure used to a capture exception table entry in a Java method.

      743  */

      744 typedef struct {

      745     jint start_pc;

      746     jint end_pc;

      747     jint handler_pc;

      748     jint catchType;

      749 } JVM_ExceptionTableEntryType;

      750 

      751 /*

      752  * Returns the exception table entry at entry_index of a given method.

      753  * Places the result in the given buffer.

      754  *

      755  * The method is identified by method_index.

      756  */

      757 JNIEXPORT void JNICALL

      758 JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index,

      759                                    jint entry_index,

      760                                    JVM_ExceptionTableEntryType *entry);

      761 

      762 /*

      763  * Returns the length of the exception table of a given method.

      764  * The method is identified by method_index.

      765  */

      766 JNIEXPORT jint JNICALL

      767 JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index);

      768 

      769 /*

      770  * Returns the modifiers of a given field.

      771  * The field is identified by field_index.

      772  */

      773 JNIEXPORT jint JNICALL

      774 JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index);

      775 

      776 /*

      777  * Returns the modifiers of a given method.

      778  * The method is identified by method_index.

      779  */

      780 JNIEXPORT jint JNICALL

      781 JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index);

      782 

      783 /*

      784  * Returns the number of local variables of a given method.

      785  * The method is identified by method_index.

      786  */

      787 JNIEXPORT jint JNICALL

      788 JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index);

      789 

      790 /*

      791  * Returns the number of arguments (including this pointer) of a given method.

      792  * The method is identified by method_index.

      793  */

      794 JNIEXPORT jint JNICALL

      795 JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index);

      796 

      797 /*

      798  * Returns the maximum amount of stack (in words) used by a given method.

      799  * The method is identified by method_index.

      800  */

      801 JNIEXPORT jint JNICALL

      802 JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index);

      803 

      804 /*

      805  * Is a given method a constructor.

      806  * The method is identified by method_index.

      807  */

      808 JNIEXPORT jboolean JNICALL

      809 JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index);

      810 

      811 /*

      812  * Returns the name of a given method in UTF format.

      813  * The result remains valid until JVM_ReleaseUTF is called.

      814  *

      815  * The caller must treat the string as a constant and not modify it

      816  * in any way.

      817  */

      818 JNIEXPORT const char * JNICALL

      819 JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index);

      820 

      821 /*

      822  * Returns the signature of a given method in UTF format.

      823  * The result remains valid until JVM_ReleaseUTF is called.

      824  *

      825  * The caller must treat the string as a constant and not modify it

      826  * in any way.

      827  */

      828 JNIEXPORT const char * JNICALL

      829 JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index);

      830 

      831 /*

      832  * Returns the name of the field refered to at a given constant pool

      833  * index.

      834  *

      835  * The result is in UTF format and remains valid until JVM_ReleaseUTF

      836  * is called.

      837  *

      838  * The caller must treat the string as a constant and not modify it

      839  * in any way.

      840  */

      841 JNIEXPORT const char * JNICALL

      842 JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);

      843 

      844 /*

      845  * Returns the name of the method refered to at a given constant pool

      846  * index.

      847  *

      848  * The result is in UTF format and remains valid until JVM_ReleaseUTF

      849  * is called.

      850  *

      851  * The caller must treat the string as a constant and not modify it

      852  * in any way.

      853  */

      854 JNIEXPORT const char * JNICALL

      855 JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);

      856 

      857 /*

      858  * Returns the signature of the method refered to at a given constant pool

      859  * index.

      860  *

      861  * The result is in UTF format and remains valid until JVM_ReleaseUTF

      862  * is called.

      863  *

      864  * The caller must treat the string as a constant and not modify it

      865  * in any way.

      866  */

      867 JNIEXPORT const char * JNICALL

      868 JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);

      869 

      870 /*

      871  * Returns the signature of the field refered to at a given constant pool

      872  * index.

      873  *

      874  * The result is in UTF format and remains valid until JVM_ReleaseUTF

      875  * is called.

      876  *

      877  * The caller must treat the string as a constant and not modify it

      878  * in any way.

      879  */

      880 JNIEXPORT const char * JNICALL

      881 JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);

      882 

      883 /*

      884  * Returns the class name refered to at a given constant pool index.

      885  *

      886  * The result is in UTF format and remains valid until JVM_ReleaseUTF

      887  * is called.

      888  *

      889  * The caller must treat the string as a constant and not modify it

      890  * in any way.

      891  */

      892 JNIEXPORT const char * JNICALL

      893 JVM_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index);

      894 

      895 /*

      896  * Returns the class name refered to at a given constant pool index.

      897  *

      898  * The constant pool entry must refer to a CONSTANT_Fieldref.

      899  *

      900  * The result is in UTF format and remains valid until JVM_ReleaseUTF

      901  * is called.

      902  *

      903  * The caller must treat the string as a constant and not modify it

      904  * in any way.

      905  */

      906 JNIEXPORT const char * JNICALL

      907 JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index);

      908 

      909 /*

      910  * Returns the class name refered to at a given constant pool index.

      911  *

      912  * The constant pool entry must refer to CONSTANT_Methodref or

      913  * CONSTANT_InterfaceMethodref.

      914  *

      915  * The result is in UTF format and remains valid until JVM_ReleaseUTF

      916  * is called.

      917  *

      918  * The caller must treat the string as a constant and not modify it

      919  * in any way.

      920  */

      921 JNIEXPORT const char * JNICALL

      922 JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index);

      923 

      924 /*

      925  * Returns the modifiers of a field in calledClass. The field is

      926  * referred to in class cb at constant pool entry index.

      927  *

      928  * The caller must treat the string as a constant and not modify it

      929  * in any way.

      930  *

      931  * Returns -1 if the field does not exist in calledClass.

      932  */

      933 JNIEXPORT jint JNICALL

      934 JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);

      935 

      936 /*

      937  * Returns the modifiers of a method in calledClass. The method is

      938  * referred to in class cb at constant pool entry index.

      939  *

      940  * Returns -1 if the method does not exist in calledClass.

      941  */

      942 JNIEXPORT jint JNICALL

      943 JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);

      944 

      945 /*

      946  * Releases the UTF string obtained from the VM.

      947  */

      948 JNIEXPORT void JNICALL

      949 JVM_ReleaseUTF(const char *utf);

      950 

      951 /*

      952  * Compare if two classes are in the same package.

      953  */

      954 JNIEXPORT jboolean JNICALL

      955 JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2);

      956 

      957 /* Get classfile constants */

      958 #include "classfile_constants.h"

      959 

      960 /*

      961  * A function defined by the byte-code verifier and called by the VM.

      962  * This is not a function implemented in the VM.

      963  *

      964  * Returns JNI_FALSE if verification fails. A detailed error message

      965  * will be places in msg_buf, whose length is specified by buf_len.

      966  */

      967 typedef jboolean (*verifier_fn_t)(JNIEnv *env,

      968                                   jclass cb,

      969                                   char * msg_buf,

      970                                   jint buf_len);

      971 

      972 

      973 /*

      974  * Support for a VM-independent class format checker.

      975  */

      976 typedef struct {

      977     unsigned long code;    /* byte code */

      978     unsigned long excs;    /* exceptions */

      979     unsigned long etab;    /* catch table */

      980     unsigned long lnum;    /* line number */

      981     unsigned long lvar;    /* local vars */

      982 } method_size_info;

      983 

      984 typedef struct {

      985     unsigned int constants;    /* constant pool */

      986     unsigned int fields;

      987     unsigned int methods;

      988     unsigned int interfaces;

      989     unsigned int fields2;      /* number of static 2-word fields */

      990     unsigned int innerclasses; /* # of records in InnerClasses attr */

      991 

      992     method_size_info clinit;   /* memory used in clinit */

      993     method_size_info main;     /* used everywhere else */

      994 } class_size_info;

      995 

      996 /*

      997  * Functions defined in libjava.so to perform string conversions.

      998  *

      999  */

     1000 

     1001 typedef jstring (*to_java_string_fn_t)(JNIEnv *env, char *str);

     1002 

     1003 typedef char *(*to_c_string_fn_t)(JNIEnv *env, jstring s, jboolean *b);

     1004 

     1005 /* This is the function defined in libjava.so that performs class

     1006  * format checks. This functions fills in size information about

     1007  * the class file and returns:

     1008  *

     1009  *   0: good

     1010  *  -1: out of memory

     1011  *  -2: bad format

     1012  *  -3: unsupported version

     1013  *  -4: bad class name

     1014  */

     1015 

     1016 typedef jint (*check_format_fn_t)(char *class_name,

     1017                                   unsigned char *data,

     1018                                   unsigned int data_size,

     1019                                   class_size_info *class_size,

     1020                                   char *message_buffer,

     1021                                   jint buffer_length,

     1022                                   jboolean measure_only,

     1023                                   jboolean check_relaxed);

     1024 

     1025 #define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \

     1026                                         JVM_ACC_FINAL | \

     1027                                         JVM_ACC_SUPER | \

     1028                                         JVM_ACC_INTERFACE | \

     1029                                         JVM_ACC_ABSTRACT | \

     1030                                         JVM_ACC_ANNOTATION | \

     1031                                         JVM_ACC_ENUM | \

     1032                                         JVM_ACC_SYNTHETIC)

     1033 

     1034 #define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \

     1035                                         JVM_ACC_PRIVATE | \

     1036                                         JVM_ACC_PROTECTED | \

     1037                                         JVM_ACC_STATIC | \

     1038                                         JVM_ACC_FINAL | \

     1039                                         JVM_ACC_VOLATILE | \

     1040                                         JVM_ACC_TRANSIENT | \

     1041                                         JVM_ACC_ENUM | \

     1042                                         JVM_ACC_SYNTHETIC)

     1043 

     1044 #define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \

     1045                                          JVM_ACC_PRIVATE | \

     1046                                          JVM_ACC_PROTECTED | \

     1047                                          JVM_ACC_STATIC | \

     1048                                          JVM_ACC_FINAL | \

     1049                                          JVM_ACC_SYNCHRONIZED | \

     1050                                          JVM_ACC_BRIDGE | \

     1051                                          JVM_ACC_VARARGS | \

     1052                                          JVM_ACC_NATIVE | \

     1053                                          JVM_ACC_ABSTRACT | \

     1054                                          JVM_ACC_STRICT | \

     1055                                          JVM_ACC_SYNTHETIC)

     1056 

     1057 /*

     1058  * This is the function defined in libjava.so to perform path

     1059  * canonicalization. VM call this function before opening jar files

     1060  * to load system classes.

     1061  *

     1062  */

     1063 

     1064 typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len);

     1065 

     1066 /*************************************************************************

     1067  PART 3: I/O and Network Support

     1068  ************************************************************************/

     1069 

     1070 /* Note that the JVM IO functions are expected to return JVM_IO_ERR

     1071  * when there is any kind of error. The caller can then use the

     1072  * platform specific support (e.g., errno) to get the detailed

     1073  * error info.  The JVM_GetLastErrorString procedure may also be used

     1074  * to obtain a descriptive error string.

     1075  */

     1076 #define JVM_IO_ERR  (-1)

     1077 

     1078 /* For interruptible IO. Returning JVM_IO_INTR indicates that an IO

     1079  * operation has been disrupted by Thread.interrupt. There are a

     1080  * number of technical difficulties related to interruptible IO that

     1081  * need to be solved. For example, most existing programs do not handle

     1082  * InterruptedIOExceptions specially, they simply treat those as any

     1083  * IOExceptions, which typically indicate fatal errors.

     1084  *

     1085  * There are also two modes of operation for interruptible IO. In the

     1086  * resumption mode, an interrupted IO operation is guaranteed not to

     1087  * have any side-effects, and can be restarted. In the termination mode,

     1088  * an interrupted IO operation corrupts the underlying IO stream, so

     1089  * that the only reasonable operation on an interrupted stream is to

     1090  * close that stream. The resumption mode seems to be impossible to

     1091  * implement on Win32 and Solaris. Implementing the termination mode is

     1092  * easier, but it's not clear that's the right semantics.

     1093  *

     1094  * Interruptible IO is not supported on Win32.It can be enabled/disabled

     1095  * using a compile-time flag on Solaris. Third-party JVM ports do not

     1096  * need to implement interruptible IO.

     1097  */

     1098 #define JVM_IO_INTR (-2)

     1099 

     1100 /* Write a string into the given buffer, in the platform's local encoding,

     1101  * that describes the most recent system-level error to occur in this thread.

     1102  * Return the length of the string or zero if no error occurred.

     1103  */

     1104 JNIEXPORT jint JNICALL

     1105 JVM_GetLastErrorString(char *buf, int len);

     1106 

     1107 /*

     1108  * Convert a pathname into native format.  This function does syntactic

     1109  * cleanup, such as removing redundant separator characters.  It modifies

     1110  * the given pathname string in place.

     1111  */

     1112 JNIEXPORT char * JNICALL

     1113 JVM_NativePath(char *);

     1114 

     1115 /*

     1116  * JVM I/O error codes

     1117  */

     1118 #define JVM_EEXIST       -100

     1119 

     1120 /*

     1121  * Open a file descriptor. This function returns a negative error code

     1122  * on error, and a non-negative integer that is the file descriptor on

     1123  * success.

     1124  */

     1125 JNIEXPORT jint JNICALL

     1126 JVM_Open(const char *fname, jint flags, jint mode);

     1127 

     1128 /*

     1129  * Close a file descriptor. This function returns -1 on error, and 0

     1130  * on success.

     1131  *

     1132  * fd        the file descriptor to close.

     1133  */

     1134 JNIEXPORT jint JNICALL

     1135 JVM_Close(jint fd);

     1136 

     1137 /*

     1138  * Read data from a file decriptor into a char array.

     1139  *

     1140  * fd        the file descriptor to read from.

     1141  * buf       the buffer where to put the read data.

     1142  * nbytes    the number of bytes to read.

     1143  *

     1144  * This function returns -1 on error, and 0 on success.

     1145  */

     1146 JNIEXPORT jint JNICALL

     1147 JVM_Read(jint fd, char *buf, jint nbytes);

     1148 

     1149 /*

     1150  * Write data from a char array to a file decriptor.

     1151  *

     1152  * fd        the file descriptor to read from.

     1153  * buf       the buffer from which to fetch the data.

     1154  * nbytes    the number of bytes to write.

     1155  *

     1156  * This function returns -1 on error, and 0 on success.

     1157  */

     1158 JNIEXPORT jint JNICALL

     1159 JVM_Write(jint fd, char *buf, jint nbytes);

     1160 

     1161 /*

     1162  * Returns the number of bytes available for reading from a given file

     1163  * descriptor

     1164  */

     1165 JNIEXPORT jint JNICALL

     1166 JVM_Available(jint fd, jlong *pbytes);

     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_ */