1 /*

        2  * Copyright 1997-2006 Sun Microsystems, Inc.  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.  Sun designates this

        8  * particular file as subject to the "Classpath" exception as provided

        9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

       22  * CA 95054 USA or visit www.sun.com if you need additional information or

       23  * have any 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 given class loader. Throw ClassNotFoundException

      379  * or NoClassDefFoundError depending on the value of the last

      380  * argument.

      381  */

      382 JNIEXPORT jclass JNICALL

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

      384                              jobject loader, jboolean throwError);

      385 

      386 /*

      387  * Find a class from a given class.

      388  */

      389 JNIEXPORT jclass JNICALL

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

      391                              jclass from);

      392 

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

      394 JNIEXPORT jclass JNICALL

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

      396 

      397 /* Define a class */

      398 JNIEXPORT jclass JNICALL

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

      400                 jsize len, jobject pd);

      401 

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

      403 JNIEXPORT jclass JNICALL

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

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

      406                           const char *source);

      407 

      408 /*

      409  * Reflection support functions

      410  */

      411 

      412 JNIEXPORT jstring JNICALL

      413 JVM_GetClassName(JNIEnv *env, jclass cls);

      414 

      415 JNIEXPORT jobjectArray JNICALL

      416 JVM_GetClassInterfaces(JNIEnv *env, jclass cls);

      417 

      418 JNIEXPORT jobject JNICALL

      419 JVM_GetClassLoader(JNIEnv *env, jclass cls);

      420 

      421 JNIEXPORT jboolean JNICALL

      422 JVM_IsInterface(JNIEnv *env, jclass cls);

      423 

      424 JNIEXPORT jobjectArray JNICALL

      425 JVM_GetClassSigners(JNIEnv *env, jclass cls);

      426 

      427 JNIEXPORT void JNICALL

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

      429 

      430 JNIEXPORT jobject JNICALL

      431 JVM_GetProtectionDomain(JNIEnv *env, jclass cls);

      432 

      433 JNIEXPORT void JNICALL

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

      435 

      436 JNIEXPORT jboolean JNICALL

      437 JVM_IsArrayClass(JNIEnv *env, jclass cls);

      438 

      439 JNIEXPORT jboolean JNICALL

      440 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);

      441 

      442 JNIEXPORT jclass JNICALL

      443 JVM_GetComponentType(JNIEnv *env, jclass cls);

      444 

      445 JNIEXPORT jint JNICALL

      446 JVM_GetClassModifiers(JNIEnv *env, jclass cls);

      447 

      448 JNIEXPORT jobjectArray JNICALL

      449 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);

      450 

      451 JNIEXPORT jclass JNICALL

      452 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);

      453 

      454 /* Generics support (JDK 1.5) */

      455 JNIEXPORT jstring JNICALL

      456 JVM_GetClassSignature(JNIEnv *env, jclass cls);

      457 

      458 /* Annotations support (JDK 1.5) */

      459 JNIEXPORT jbyteArray JNICALL

      460 JVM_GetClassAnnotations(JNIEnv *env, jclass cls);

      461 

      462 /*

      463  * New (JDK 1.4) reflection implementation

      464  */

      465 

      466 JNIEXPORT jobjectArray JNICALL

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

      468 

      469 JNIEXPORT jobjectArray JNICALL

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

      471 

      472 JNIEXPORT jobjectArray JNICALL

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

      474 

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

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

      477    class file rather than searching the InnerClasses attribute (if

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

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

      480    valid. */

      481 JNIEXPORT jint JNICALL

      482 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);

      483 

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

      485 /*

      486  * java.lang.reflect.Method

      487  */

      488 JNIEXPORT jobject JNICALL

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

      490 

      491 /*

      492  * java.lang.reflect.Constructor

      493  */

      494 JNIEXPORT jobject JNICALL

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

      496 

      497 /*

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

      499  */

      500 

      501 JNIEXPORT jobject JNICALL

      502 JVM_GetClassConstantPool(JNIEnv *env, jclass cls);

      503 

      504 JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize

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

      506 

      507 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt

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

      509 

      510 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded

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

      512 

      513 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt

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

      515 

      516 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded

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

      518 

      519 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt

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

      521 

      522 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded

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

      524 

      525 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt

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

      527 

      528 JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt

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

      530 

      531 JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt

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

      533 

      534 JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt

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

      536 

      537 JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt

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

      539 

      540 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt

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

      542 

      543 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At

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

      545 

      546 /*

      547  * java.security.*

      548  */

      549 

      550 JNIEXPORT jobject JNICALL

      551 JVM_DoPrivileged(JNIEnv *env, jclass cls,

      552                  jobject action, jobject context, jboolean wrapException);

      553 

      554 JNIEXPORT jobject JNICALL

      555 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);

      556 

      557 JNIEXPORT jobject JNICALL

      558 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);

      559 

      560 /*

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

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

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

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

      565  */

      566 

      567 JNIEXPORT void * JNICALL

      568 JVM_RegisterSignal(jint sig, void *handler);

      569 

      570 JNIEXPORT jboolean JNICALL

      571 JVM_RaiseSignal(jint sig);

      572 

      573 JNIEXPORT jint JNICALL

      574 JVM_FindSignal(const char *name);

      575 

      576 /*

      577  * Retrieve the assertion directives for the specified class.

      578  */

      579 JNIEXPORT jboolean JNICALL

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

      581 

      582 /*

      583  * Retrieve the assertion directives from the VM.

      584  */

      585 JNIEXPORT jobject JNICALL

      586 JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);

      587 

      588 /*

      589  * java.util.concurrent.AtomicLong

      590  */

      591 JNIEXPORT jboolean JNICALL

      592 JVM_SupportsCX8(void);

      593 

      594 /*

      595  * com.sun.dtrace.jsdt support

      596  */

      597 

      598 #define JVM_TRACING_DTRACE_VERSION 1

      599 

      600 /*

      601  * Structure to pass one probe description to JVM

      602  */

      603 typedef struct {

      604     jmethodID method;

      605     jstring   function;

      606     jstring   name;

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

      608 } JVM_DTraceProbe;

      609 

      610 /**

      611  * Encapsulates the stability ratings for a DTrace provider field

      612  */

      613 typedef struct {

      614     jint nameStability;

      615     jint dataStability;

      616     jint dependencyClass;

      617 } JVM_DTraceInterfaceAttributes;

      618 

      619 /*

      620  * Structure to pass one provider description to JVM

      621  */

      622 typedef struct {

      623     jstring                       name;

      624     JVM_DTraceProbe*              probes;

      625     jint                          probe_count;

      626     JVM_DTraceInterfaceAttributes providerAttributes;

      627     JVM_DTraceInterfaceAttributes moduleAttributes;

      628     JVM_DTraceInterfaceAttributes functionAttributes;

      629     JVM_DTraceInterfaceAttributes nameAttributes;

      630     JVM_DTraceInterfaceAttributes argsAttributes;

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

      632 } JVM_DTraceProvider;

      633 

      634 /*

      635  * Get the version number the JVM was built with

      636  */

      637 JNIEXPORT jint JNICALL

      638 JVM_DTraceGetVersion(JNIEnv* env);

      639 

      640 /*

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

      642  *

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

      644  * built with.

      645  */

      646 JNIEXPORT jlong JNICALL

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

      648   jint providers_count, JVM_DTraceProvider* providers);

      649 

      650 /*

      651  * Check JSDT probe

      652  */

      653 JNIEXPORT jboolean JNICALL

      654 JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method);

      655 

      656 /*

      657  * Destroy custom DOF

      658  */

      659 JNIEXPORT void JNICALL

      660 JVM_DTraceDispose(JNIEnv* env, jlong activation_handle);

      661 

      662 /*

      663  * Check to see if DTrace is supported by OS

      664  */

      665 JNIEXPORT jboolean JNICALL

      666 JVM_DTraceIsSupported(JNIEnv* env);

      667 

      668 /*************************************************************************

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

      670  ************************************************************************/

      671 /*

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

      673  * until JVM_ReleaseUTf is called.

      674  *

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

      676  * in any way.

      677  */

      678 JNIEXPORT const char * JNICALL

      679 JVM_GetClassNameUTF(JNIEnv *env, jclass cb);

      680 

      681 /*

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

      683  */

      684 JNIEXPORT void JNICALL

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

      686 

      687 /*

      688  * Returns the number of Constant Pool entries.

      689  */

      690 JNIEXPORT jint JNICALL

      691 JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);

      692 

      693 /*

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

      695  */

      696 JNIEXPORT jint JNICALL

      697 JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);

      698 

      699 JNIEXPORT jint JNICALL

      700 JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);

      701 

      702 /*

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

      704  * Places the result in the given buffer.

      705  *

      706  * The method is identified by method_index.

      707  */

      708 JNIEXPORT void JNICALL

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

      710                                 unsigned short *exceptions);

      711 /*

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

      713  * The method is identified by method_index.

      714  */

      715 JNIEXPORT jint JNICALL

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

      717 

      718 /*

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

      720  * Places the result in the given buffer.

      721  *

      722  * The method is identified by method_index.

      723  */

      724 JNIEXPORT void JNICALL

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

      726                         unsigned char *code);

      727 

      728 /*

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

      730  * The method is identified by method_index.

      731  */

      732 JNIEXPORT jint JNICALL

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

      734 

      735 /*

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

      737  */

      738 typedef struct {

      739     jint start_pc;

      740     jint end_pc;

      741     jint handler_pc;

      742     jint catchType;

      743 } JVM_ExceptionTableEntryType;

      744 

      745 /*

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

      747  * Places the result in the given buffer.

      748  *

      749  * The method is identified by method_index.

      750  */

      751 JNIEXPORT void JNICALL

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

      753                                    jint entry_index,

      754                                    JVM_ExceptionTableEntryType *entry);

      755 

      756 /*

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

      758  * The method is identified by method_index.

      759  */

      760 JNIEXPORT jint JNICALL

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

      762 

      763 /*

      764  * Returns the modifiers of a given field.

      765  * The field is identified by field_index.

      766  */

      767 JNIEXPORT jint JNICALL

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

      769 

      770 /*

      771  * Returns the modifiers of a given method.

      772  * The method is identified by method_index.

      773  */

      774 JNIEXPORT jint JNICALL

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

      776 

      777 /*

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

      779  * The method is identified by method_index.

      780  */

      781 JNIEXPORT jint JNICALL

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

      783 

      784 /*

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

      786  * The method is identified by method_index.

      787  */

      788 JNIEXPORT jint JNICALL

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

      790 

      791 /*

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

      793  * The method is identified by method_index.

      794  */

      795 JNIEXPORT jint JNICALL

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

      797 

      798 /*

      799  * Is a given method a constructor.

      800  * The method is identified by method_index.

      801  */

      802 JNIEXPORT jboolean JNICALL

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

      804 

      805 /*

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

      807  * The result remains valid until JVM_ReleaseUTF is called.

      808  *

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

      810  * in any way.

      811  */

      812 JNIEXPORT const char * JNICALL

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

      814 

      815 /*

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

      817  * The result remains valid until JVM_ReleaseUTF is called.

      818  *

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

      820  * in any way.

      821  */

      822 JNIEXPORT const char * JNICALL

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

      824 

      825 /*

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

      827  * index.

      828  *

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

      830  * 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_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);

      837 

      838 /*

      839  * Returns the name of the method 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_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);

      850 

      851 /*

      852  * Returns the signature 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_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);

      863 

      864 /*

      865  * Returns the signature of the field 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_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);

      876 

      877 /*

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

      879  *

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

      881  * is called.

      882  *

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

      884  * in any way.

      885  */

      886 JNIEXPORT const char * JNICALL

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

      888 

      889 /*

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

      891  *

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

      893  *

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

      895  * is called.

      896  *

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

      898  * in any way.

      899  */

      900 JNIEXPORT const char * JNICALL

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

      902 

      903 /*

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

      905  *

      906  * The constant pool entry must refer to CONSTANT_Methodref or

      907  * CONSTANT_InterfaceMethodref.

      908  *

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

      910  * is called.

      911  *

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

      913  * in any way.

      914  */

      915 JNIEXPORT const char * JNICALL

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

      917 

      918 /*

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

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

      921  *

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

      923  * in any way.

      924  *

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

      926  */

      927 JNIEXPORT jint JNICALL

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

      929 

      930 /*

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

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

      933  *

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

      935  */

      936 JNIEXPORT jint JNICALL

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

      938 

      939 /*

      940  * Releases the UTF string obtained from the VM.

      941  */

      942 JNIEXPORT void JNICALL

      943 JVM_ReleaseUTF(const char *utf);

      944 

      945 /*

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

      947  */

      948 JNIEXPORT jboolean JNICALL

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

      950 

      951 /* Constants in class files */

      952 

      953 #define JVM_ACC_PUBLIC        0x0001  /* visible to everyone */

      954 #define JVM_ACC_PRIVATE       0x0002  /* visible only to the defining class */

      955 #define JVM_ACC_PROTECTED     0x0004  /* visible to subclasses */

      956 #define JVM_ACC_STATIC        0x0008  /* instance variable is static */

      957 #define JVM_ACC_FINAL         0x0010  /* no further subclassing, overriding */

      958 #define JVM_ACC_SYNCHRONIZED  0x0020  /* wrap method call in monitor lock */

      959 #define JVM_ACC_SUPER         0x0020  /* funky handling of invokespecial */

      960 #define JVM_ACC_VOLATILE      0x0040  /* can not cache in registers */

      961 #define JVM_ACC_BRIDGE        0x0040  /* bridge method generated by compiler */

      962 #define JVM_ACC_TRANSIENT     0x0080  /* not persistant */

      963 #define JVM_ACC_VARARGS       0x0080  /* method declared with variable number of args */

      964 #define JVM_ACC_NATIVE        0x0100  /* implemented in C */

      965 #define JVM_ACC_INTERFACE     0x0200  /* class is an interface */

      966 #define JVM_ACC_ABSTRACT      0x0400  /* no definition provided */

      967 #define JVM_ACC_STRICT        0x0800  /* strict floating point */

      968 #define JVM_ACC_SYNTHETIC     0x1000  /* compiler-generated class, method or field */

      969 

      970 #define JVM_ACC_ANNOTATION    0x2000  /* annotation type */

      971 #define JVM_ACC_ENUM          0x4000  /* field is declared as element of enum */

      972 

      973 #define JVM_ACC_PUBLIC_BIT        0

      974 #define JVM_ACC_PRIVATE_BIT       1

      975 #define JVM_ACC_PROTECTED_BIT     2

      976 #define JVM_ACC_STATIC_BIT        3

      977 #define JVM_ACC_FINAL_BIT         4

      978 #define JVM_ACC_SYNCHRONIZED_BIT  5

      979 #define JVM_ACC_SUPER_BIT         5

      980 #define JVM_ACC_VOLATILE_BIT      6

      981 #define JVM_ACC_BRIDGE_BIT        6

      982 #define JVM_ACC_TRANSIENT_BIT     7

      983 #define JVM_ACC_VARARGS_BIT       7

      984 #define JVM_ACC_NATIVE_BIT        8

      985 #define JVM_ACC_INTERFACE_BIT     9

      986 #define JVM_ACC_ABSTRACT_BIT      10

      987 #define JVM_ACC_STRICT_BIT        11

      988 #define JVM_ACC_SYNTHETIC_BIT     12

      989 #define JVM_ACC_ANNOTATION_BIT    13

      990 #define JVM_ACC_ENUM_BIT          14

      991 

      992 enum {

      993     JVM_CONSTANT_Utf8 = 1,

      994     JVM_CONSTANT_Unicode,               /* unused */

      995     JVM_CONSTANT_Integer,

      996     JVM_CONSTANT_Float,

      997     JVM_CONSTANT_Long,

      998     JVM_CONSTANT_Double,

      999     JVM_CONSTANT_Class,

     1000     JVM_CONSTANT_String,

     1001     JVM_CONSTANT_Fieldref,

     1002     JVM_CONSTANT_Methodref,

     1003     JVM_CONSTANT_InterfaceMethodref,

     1004     JVM_CONSTANT_NameAndType

     1005 };

     1006 

     1007 /* Used in the newarray instruction. */

     1008 

     1009 #define JVM_T_BOOLEAN 4

     1010 #define JVM_T_CHAR    5

     1011 #define JVM_T_FLOAT   6

     1012 #define JVM_T_DOUBLE  7

     1013 #define JVM_T_BYTE    8

     1014 #define JVM_T_SHORT   9

     1015 #define JVM_T_INT    10

     1016 #define JVM_T_LONG   11

     1017 

     1018 /* JVM method signatures */

     1019 

     1020 #define JVM_SIGNATURE_ARRAY             '['

     1021 #define JVM_SIGNATURE_BYTE              'B'

     1022 #define JVM_SIGNATURE_CHAR              'C'

     1023 #define JVM_SIGNATURE_CLASS             'L'

     1024 #define JVM_SIGNATURE_ENDCLASS          ';'

     1025 #define JVM_SIGNATURE_ENUM              'E'

     1026 #define JVM_SIGNATURE_FLOAT             'F'

     1027 #define JVM_SIGNATURE_DOUBLE            'D'

     1028 #define JVM_SIGNATURE_FUNC              '('

     1029 #define JVM_SIGNATURE_ENDFUNC           ')'

     1030 #define JVM_SIGNATURE_INT               'I'

     1031 #define JVM_SIGNATURE_LONG              'J'

     1032 #define JVM_SIGNATURE_SHORT             'S'

     1033 #define JVM_SIGNATURE_VOID              'V'

     1034 #define JVM_SIGNATURE_BOOLEAN           'Z'

     1035 

     1036 /*

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

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

     1039  *

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

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

     1042  */

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

     1044                                   jclass cb,

     1045                                   char * msg_buf,

     1046                                   jint buf_len);

     1047 

     1048 

     1049 /*

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

     1051  */

     1052 typedef struct {

     1053     unsigned long code;    /* byte code */

     1054     unsigned long excs;    /* exceptions */

     1055     unsigned long etab;    /* catch table */

     1056     unsigned long lnum;    /* line number */

     1057     unsigned long lvar;    /* local vars */

     1058 } method_size_info;

     1059 

     1060 typedef struct {

     1061     unsigned int constants;    /* constant pool */

     1062     unsigned int fields;

     1063     unsigned int methods;

     1064     unsigned int interfaces;

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

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

     1067 

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

     1069     method_size_info main;     /* used everywhere else */

     1070 } class_size_info;

     1071 

     1072 /*

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

     1074  *

     1075  */

     1076 

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

     1078 

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

     1080 

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

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

     1083  * the class file and returns:

     1084  *

     1085  *   0: good

     1086  *  -1: out of memory

     1087  *  -2: bad format

     1088  *  -3: unsupported version

     1089  *  -4: bad class name

     1090  */

     1091 

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

     1093                                   unsigned char *data,

     1094                                   unsigned int data_size,

     1095                                   class_size_info *class_size,

     1096                                   char *message_buffer,

     1097                                   jint buffer_length,

     1098                                   jboolean measure_only,

     1099                                   jboolean check_relaxed);

     1100 

     1101 #define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \

     1102                                         JVM_ACC_FINAL | \

     1103                                         JVM_ACC_SUPER | \

     1104                                         JVM_ACC_INTERFACE | \

     1105                                         JVM_ACC_ABSTRACT | \

     1106                                         JVM_ACC_ANNOTATION | \

     1107                                         JVM_ACC_ENUM | \

     1108                                         JVM_ACC_SYNTHETIC)

     1109 

     1110 #define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \

     1111                                         JVM_ACC_PRIVATE | \

     1112                                         JVM_ACC_PROTECTED | \

     1113                                         JVM_ACC_STATIC | \

     1114                                         JVM_ACC_FINAL | \

     1115                                         JVM_ACC_VOLATILE | \

     1116                                         JVM_ACC_TRANSIENT | \

     1117                                         JVM_ACC_ENUM | \

     1118                                         JVM_ACC_SYNTHETIC)

     1119 

     1120 #define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \

     1121                                          JVM_ACC_PRIVATE | \

     1122                                          JVM_ACC_PROTECTED | \

     1123                                          JVM_ACC_STATIC | \

     1124                                          JVM_ACC_FINAL | \

     1125                                          JVM_ACC_SYNCHRONIZED | \

     1126                                          JVM_ACC_BRIDGE | \

     1127                                          JVM_ACC_VARARGS | \

     1128                                          JVM_ACC_NATIVE | \

     1129                                          JVM_ACC_ABSTRACT | \

     1130                                          JVM_ACC_STRICT | \

     1131                                          JVM_ACC_SYNTHETIC)

     1132 

     1133 /*

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

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

     1136  * to load system classes.

     1137  *

     1138  */

     1139 

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

     1141 

     1142 /*************************************************************************

     1143  PART 3: I/O and Network Support

     1144  ************************************************************************/

     1145 

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

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

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

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

     1150  * to obtain a descriptive error string.

     1151  */

     1152 #define JVM_IO_ERR  (-1)

     1153 

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

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

     1156  * number of technical difficulties related to interruptible IO that

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

     1158  * InterruptedIOExceptions specially, they simply treat those as any

     1159  * IOExceptions, which typically indicate fatal errors.

     1160  *

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

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

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

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

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

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

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

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

     1169  *

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

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

     1172  * need to implement interruptible IO.

     1173  */

     1174 #define JVM_IO_INTR (-2)

     1175 

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

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

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

     1179  */

     1180 JNIEXPORT jint JNICALL

     1181 JVM_GetLastErrorString(char *buf, int len);

     1182 

     1183 /*

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

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

     1186  * the given pathname string in place.

     1187  */

     1188 JNIEXPORT char * JNICALL

     1189 JVM_NativePath(char *);

     1190 

     1191 /*

     1192  * JVM I/O error codes

     1193  */

     1194 #define JVM_EEXIST       -100

     1195 

     1196 /*

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

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

     1199  * success.

     1200  */

     1201 JNIEXPORT jint JNICALL

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

     1203 

     1204 /*

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

     1206  * on success.

     1207  *

     1208  * fd        the file descriptor to close.

     1209  */

     1210 JNIEXPORT jint JNICALL

     1211 JVM_Close(jint fd);

     1212 

     1213 /*

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

     1215  *

     1216  * fd        the file descriptor to read from.

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

     1218  * nbytes    the number of bytes to read.

     1219  *

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

     1221  */

     1222 JNIEXPORT jint JNICALL

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

     1224 

     1225 /*

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

     1227  *

     1228  * fd        the file descriptor to read from.

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

     1230  * nbytes    the number of bytes to write.

     1231  *

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

     1233  */

     1234 JNIEXPORT jint JNICALL

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

     1236 

     1237 /*

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

     1239  * descriptor

     1240  */

     1241 JNIEXPORT jint JNICALL

     1242 JVM_Available(jint fd, jlong *pbytes);

     1243 

     1244 /*

     1245  * Move the file descriptor pointer from whence by offset.

     1246  *

     1247  * fd        the file descriptor to move.

     1248  * offset    the number of bytes to move it by.

     1249  * whence    the start from where to move it.

     1250  *

     1251  * This function returns the resulting pointer location.

     1252  */

     1253 JNIEXPORT jlong JNICALL

     1254 JVM_Lseek(jint fd, jlong offset, jint whence);

     1255 

     1256 /*

     1257  * Set the length of the file associated with the given descriptor to the given

     1258  * length.  If the new length is longer than the current length then the file

     1259  * is extended; the contents of the extended portion are not defined.  The

     1260  * value of the file pointer is undefined after this procedure returns.

     1261  */

     1262 JNIEXPORT jint JNICALL

     1263 JVM_SetLength(jint fd, jlong length);

     1264 

     1265 /*

     1266  * Synchronize the file descriptor's in memory state with that of the

     1267  * physical device.  Return of -1 is an error, 0 is OK.

     1268  */

     1269 JNIEXPORT jint JNICALL

     1270 JVM_Sync(jint fd);

     1271 

     1272 /*

     1273  * Networking library support

     1274  */

     1275 

     1276 JNIEXPORT jint JNICALL

     1277 JVM_InitializeSocketLibrary(void);

     1278 

     1279 struct sockaddr;

     1280 

     1281 JNIEXPORT jint JNICALL

     1282 JVM_Socket(jint domain, jint type, jint protocol);

     1283 

     1284 JNIEXPORT jint JNICALL

     1285 JVM_SocketClose(jint fd);

     1286 

     1287 JNIEXPORT jint JNICALL

     1288 JVM_SocketShutdown(jint fd, jint howto);

     1289 

     1290 JNIEXPORT jint JNICALL

     1291 JVM_Recv(jint fd, char *buf, jint nBytes, jint flags);

     1292 

     1293 JNIEXPORT jint JNICALL

     1294 JVM_Send(jint fd, char *buf, jint nBytes, jint flags);

     1295 

     1296 JNIEXPORT jint JNICALL

     1297 JVM_Timeout(int fd, long timeout);

     1298 

     1299 JNIEXPORT jint JNICALL

     1300 JVM_Listen(jint fd, jint count);

     1301 

     1302 JNIEXPORT jint JNICALL

     1303 JVM_Connect(jint fd, struct sockaddr *him, jint len);

     1304 

     1305 JNIEXPORT jint JNICALL

     1306 JVM_Bind(jint fd, struct sockaddr *him, jint len);

     1307 

     1308 JNIEXPORT jint JNICALL

     1309 JVM_Accept(jint fd, struct sockaddr *him, jint *len);

     1310 

     1311 JNIEXPORT jint JNICALL

     1312 JVM_RecvFrom(jint fd, char *buf, int nBytes,

     1313                   int flags, struct sockaddr *from, int *fromlen);

     1314 

     1315 JNIEXPORT jint JNICALL

     1316 JVM_SendTo(jint fd, char *buf, int len,

     1317                 int flags, struct sockaddr *to, int tolen);

     1318 

     1319 JNIEXPORT jint JNICALL

     1320 JVM_SocketAvailable(jint fd, jint *result);

     1321 

     1322 

     1323 JNIEXPORT jint JNICALL

     1324 JVM_GetSockName(jint fd, struct sockaddr *him, int *len);

     1325 

     1326 JNIEXPORT jint JNICALL

     1327 JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen);

     1328 

     1329 JNIEXPORT jint JNICALL

     1330 JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen);

     1331 

     1332 /*

     1333  * These routines are only reentrant on Windows

     1334  */

     1335 

     1336 #ifdef WIN32

     1337 

     1338 JNIEXPORT struct protoent * JNICALL

     1339 JVM_GetProtoByName(char* name);

     1340 

     1341 JNIEXPORT struct hostent* JNICALL

     1342 JVM_GetHostByAddr(const char* name, int len, int type);

     1343 

     1344 JNIEXPORT struct hostent* JNICALL

     1345 JVM_GetHostByName(char* name);

     1346 

     1347 #endif /* _WINDOWS */

     1348 

     1349 JNIEXPORT int JNICALL

     1350 JVM_GetHostName(char* name, int namelen);

     1351 

     1352 /*

     1353  * The standard printing functions supported by the Java VM. (Should they

     1354  * be renamed to JVM_* in the future?

     1355  */

     1356 

     1357 /*

     1358  * BE CAREFUL! The following functions do not implement the

     1359  * full feature set of standard C printf formats.

     1360  */

     1361 int

     1362 jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);

     1363 

     1364 int

     1365 jio_snprintf(char *str, size_t count, const char *fmt, ...);

     1366 

     1367 int

     1368 jio_fprintf(FILE *, const char *fmt, ...);

     1369 

     1370 int

     1371 jio_vfprintf(FILE *, const char *fmt, va_list args);

     1372 

     1373 

     1374 JNIEXPORT void * JNICALL

     1375 JVM_RawMonitorCreate(void);

     1376 

     1377 JNIEXPORT void JNICALL

     1378 JVM_RawMonitorDestroy(void *mon);

     1379 

     1380 JNIEXPORT jint JNICALL

     1381 JVM_RawMonitorEnter(void *mon);

     1382 

     1383 JNIEXPORT void JNICALL

     1384 JVM_RawMonitorExit(void *mon);

     1385 

     1386 /*

     1387  * java.lang.management support

     1388  */

     1389 JNIEXPORT void* JNICALL

     1390 JVM_GetManagement(jint version);

     1391 

     1392 /*

     1393  * com.sun.tools.attach.VirtualMachine support

     1394  *

     1395  * Initialize the agent properties with the properties maintained in the VM.

     1396  */

     1397 JNIEXPORT jobject JNICALL

     1398 JVM_InitAgentProperties(JNIEnv *env, jobject agent_props);

     1399 

     1400 /* Generics reflection support.

     1401  *

     1402  * Returns information about the given class's EnclosingMethod

     1403  * attribute, if present, or null if the class had no enclosing

     1404  * method.

     1405  *

     1406  * If non-null, the returned array contains three elements. Element 0

     1407  * is the java.lang.Class of which the enclosing method is a member,

     1408  * and elements 1 and 2 are the java.lang.Strings for the enclosing

     1409  * method's name and descriptor, respectively.

     1410  */

     1411 JNIEXPORT jobjectArray JNICALL

     1412 JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);

     1413 

     1414 /*

     1415  * Java thread state support

     1416  */

     1417 enum {

     1418     JAVA_THREAD_STATE_NEW           = 0,

     1419     JAVA_THREAD_STATE_RUNNABLE      = 1,

     1420     JAVA_THREAD_STATE_BLOCKED       = 2,

     1421     JAVA_THREAD_STATE_WAITING       = 3,

     1422     JAVA_THREAD_STATE_TIMED_WAITING = 4,

     1423     JAVA_THREAD_STATE_TERMINATED    = 5,

     1424     JAVA_THREAD_STATE_COUNT         = 6

     1425 };

     1426 

     1427 /*

     1428  * Returns an array of the threadStatus values representing the

     1429  * given Java thread state.  Returns NULL if the VM version is

     1430  * incompatible with the JDK or doesn't support the given

     1431  * Java thread state.

     1432  */

     1433 JNIEXPORT jintArray JNICALL

     1434 JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState);

     1435 

     1436 /*

     1437  * Returns an array of the substate names representing the

     1438  * given Java thread state.  Returns NULL if the VM version is

     1439  * incompatible with the JDK or the VM doesn't support

     1440  * the given Java thread state.

     1441  * values must be the jintArray returned from JVM_GetThreadStateValues

     1442  * and javaThreadState.

     1443  */

     1444 JNIEXPORT jobjectArray JNICALL

     1445 JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values);

     1446 

     1447 /* =========================================================================

     1448  * The following defines a private JVM interface that the JDK can query

     1449  * for the JVM version and capabilities.  sun.misc.Version defines

     1450  * the methods for getting the VM version and its capabilities.

     1451  *

     1452  * When a new bit is added, the following should be updated to provide

     1453  * access to the new capability:

     1454  *    HS:   JVM_GetVersionInfo and Abstract_VM_Version class

     1455  *    SDK:  Version class

     1456  *

     1457  * Similary, a private JDK interface JDK_GetVersionInfo0 is defined for

     1458  * JVM to query for the JDK version and capabilities.

     1459  *

     1460  * When a new bit is added, the following should be updated to provide

     1461  * access to the new capability:

     1462  *    HS:   JDK_Version class

     1463  *    SDK:  JDK_GetVersionInfo0

     1464  *

     1465  * ==========================================================================

     1466  */

     1467 typedef struct {

     1468     /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */

     1469     unsigned int jvm_version;   /* Consists of major, minor, micro (n.n.n) */

     1470                                 /* and build number (xx) */

     1471     unsigned int update_version : 8;         /* Update release version (uu) */

     1472     unsigned int special_update_version : 8; /* Special update release version (c)*/

     1473     unsigned int reserved1 : 16;

     1474     unsigned int reserved2;

     1475 

     1476     /* The following bits represents JVM supports that JDK has dependency on.

     1477      * JDK can use these bits to determine which JVM version

     1478      * and support it has to maintain runtime compatibility.

     1479      *

     1480      * When a new bit is added in a minor or update release, make sure

     1481      * the new bit is also added in the main/baseline.

     1482      */

     1483     unsigned int is_attach_supported : 1;

     1484     unsigned int is_kernel_jvm : 1;

     1485     unsigned int : 30;

     1486     unsigned int : 32;

     1487     unsigned int : 32;

     1488 } jvm_version_info;

     1489 

     1490 #define JVM_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)

     1491 #define JVM_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)

     1492 #define JVM_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)

     1493 

     1494 /* Build number is available only for RE builds.

     1495  * It will be zero for internal builds.

     1496  */

     1497 #define JVM_VERSION_BUILD(version) ((version & 0x000000FF))

     1498 

     1499 JNIEXPORT void JNICALL

     1500 JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size);

     1501 

     1502 typedef struct {

     1503     // Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx

     1504     unsigned int jdk_version;   /* Consists of major, minor, micro (n.n.n) */

     1505                                 /* and build number (xx) */

     1506     unsigned int update_version : 8;         /* Update release version (uu) */

     1507     unsigned int special_update_version : 8; /* Special update release version (c)*/

     1508     unsigned int reserved1 : 16;

     1509     unsigned int reserved2;

     1510 

     1511     /* The following bits represents new JDK supports that VM has dependency on.

     1512      * VM implementation can use these bits to determine which JDK version

     1513      * and support it has to maintain runtime compatibility.

     1514      *

     1515      * When a new bit is added in a minor or update release, make sure

     1516      * the new bit is also added in the main/baseline.

     1517      */

     1518     unsigned int thread_park_blocker : 1;

     1519     unsigned int : 31;

     1520     unsigned int : 32;

     1521     unsigned int : 32;

     1522 } jdk_version_info;

     1523 

     1524 #define JDK_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)

     1525 #define JDK_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)

     1526 #define JDK_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)

     1527 

     1528 /* Build number is available only for RE build (i.e. JDK_BUILD_NUMBER is set to bNN)

     1529  * It will be zero for internal builds.

     1530  */

     1531 #define JDK_VERSION_BUILD(version) ((version & 0x000000FF))

     1532 

     1533 /*

     1534  * This is the function JDK_GetVersionInfo0 defined in libjava.so

     1535  * that is dynamically looked up by JVM.

     1536  */

     1537 typedef void (*jdk_version_info_fn_t)(jdk_version_info* info, size_t info_size);

     1538 

     1539 /*

     1540  * This structure is used by the launcher to get the default thread

     1541  * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a

     1542  * version of 1.1.  As it is not supported otherwise, it has been removed

     1543  * from jni.h

     1544  */

     1545 typedef struct JDK1_1InitArgs {

     1546     jint version;

     1547 

     1548     char **properties;

     1549     jint checkSource;

     1550     jint nativeStackSize;

     1551     jint javaStackSize;

     1552     jint minHeapSize;

     1553     jint maxHeapSize;

     1554     jint verifyMode;

     1555     char *classpath;

     1556 

     1557     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);

     1558     void (JNICALL *exit)(jint code);

     1559     void (JNICALL *abort)(void);

     1560 

     1561     jint enableClassGC;

     1562     jint enableVerboseGC;

     1563     jint disableAsyncGC;

     1564     jint verbose;

     1565     jboolean debugging;

     1566     jint debugPort;

     1567 } JDK1_1InitArgs;

     1568 

     1569 

     1570 #ifdef __cplusplus

     1571 } /* extern "C" */

     1572 

     1573 #endif /* __cplusplus */

     1574 

     1575 #endif /* !_JAVASOFT_JVM_H_ */