1 /*
   2  * Copyright (c) 1997, 2015, 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 5
  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 jlong JNICALL
 108 JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs);
 109 
 110 JNIEXPORT void JNICALL
 111 JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
 112               jobject dst, jint dst_pos, jint length);
 113 
 114 JNIEXPORT jobject JNICALL
 115 JVM_InitProperties(JNIEnv *env, jobject p);
 116 
 117 
 118 /*
 119  * java.lang.Runtime
 120  */
 121 JNIEXPORT void JNICALL
 122 JVM_Halt(jint code);
 123 
 124 JNIEXPORT void JNICALL
 125 JVM_GC(void);
 126 
 127 /* Returns the number of real-time milliseconds that have elapsed since the
 128  * least-recently-inspected heap object was last inspected by the garbage
 129  * collector.
 130  *
 131  * For simple stop-the-world collectors this value is just the time
 132  * since the most recent collection.  For generational collectors it is the
 133  * time since the oldest generation was most recently collected.  Other
 134  * collectors are free to return a pessimistic estimate of the elapsed time, or
 135  * simply the time since the last full collection was performed.
 136  *
 137  * Note that in the presence of reference objects, a given object that is no
 138  * longer strongly reachable may have to be inspected multiple times before it
 139  * can be reclaimed.
 140  */
 141 JNIEXPORT jlong JNICALL
 142 JVM_MaxObjectInspectionAge(void);
 143 
 144 JNIEXPORT jlong JNICALL
 145 JVM_TotalMemory(void);
 146 
 147 JNIEXPORT jlong JNICALL
 148 JVM_FreeMemory(void);
 149 
 150 JNIEXPORT jlong JNICALL
 151 JVM_MaxMemory(void);
 152 
 153 JNIEXPORT jint JNICALL
 154 JVM_ActiveProcessorCount(void);
 155 
 156 JNIEXPORT void * JNICALL
 157 JVM_LoadLibrary(const char *name);
 158 
 159 JNIEXPORT void JNICALL
 160 JVM_UnloadLibrary(void * handle);
 161 
 162 JNIEXPORT void * JNICALL
 163 JVM_FindLibraryEntry(void *handle, const char *name);
 164 
 165 JNIEXPORT jboolean JNICALL
 166 JVM_IsSupportedJNIVersion(jint version);
 167 
 168 /*
 169  * java.lang.Throwable
 170  */
 171 JNIEXPORT void JNICALL
 172 JVM_FillInStackTrace(JNIEnv *env, jobject throwable);
 173 
 174 JNIEXPORT jint JNICALL
 175 JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable);
 176 
 177 JNIEXPORT jobject JNICALL
 178 JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index);
 179 
 180 /*
 181  * java.lang.Thread
 182  */
 183 JNIEXPORT void JNICALL
 184 JVM_StartThread(JNIEnv *env, jobject thread);
 185 
 186 JNIEXPORT void JNICALL
 187 JVM_StopThread(JNIEnv *env, jobject thread, jobject exception);
 188 
 189 JNIEXPORT jboolean JNICALL
 190 JVM_IsThreadAlive(JNIEnv *env, jobject thread);
 191 
 192 JNIEXPORT void JNICALL
 193 JVM_SuspendThread(JNIEnv *env, jobject thread);
 194 
 195 JNIEXPORT void JNICALL
 196 JVM_ResumeThread(JNIEnv *env, jobject thread);
 197 
 198 JNIEXPORT void JNICALL
 199 JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio);
 200 
 201 JNIEXPORT void JNICALL
 202 JVM_Yield(JNIEnv *env, jclass threadClass);
 203 
 204 JNIEXPORT void JNICALL
 205 JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis);
 206 
 207 JNIEXPORT jobject JNICALL
 208 JVM_CurrentThread(JNIEnv *env, jclass threadClass);
 209 
 210 JNIEXPORT jint JNICALL
 211 JVM_CountStackFrames(JNIEnv *env, jobject thread);
 212 
 213 JNIEXPORT void JNICALL
 214 JVM_Interrupt(JNIEnv *env, jobject thread);
 215 
 216 JNIEXPORT jboolean JNICALL
 217 JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted);
 218 
 219 JNIEXPORT jboolean JNICALL
 220 JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj);
 221 
 222 JNIEXPORT void JNICALL
 223 JVM_DumpAllStacks(JNIEnv *env, jclass unused);
 224 
 225 JNIEXPORT jobjectArray JNICALL
 226 JVM_GetAllThreads(JNIEnv *env, jclass dummy);
 227 
 228 JNIEXPORT void JNICALL
 229 JVM_SetNativeThreadName(JNIEnv *env, jobject jthread, jstring name);
 230 
 231 /* getStackTrace() and getAllStackTraces() method */
 232 JNIEXPORT jobjectArray JNICALL
 233 JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);
 234 
 235 /*
 236  * java.lang.SecurityManager
 237  */
 238 JNIEXPORT jclass JNICALL
 239 JVM_CurrentLoadedClass(JNIEnv *env);
 240 
 241 JNIEXPORT jobject JNICALL
 242 JVM_CurrentClassLoader(JNIEnv *env);
 243 
 244 JNIEXPORT jobjectArray JNICALL
 245 JVM_GetClassContext(JNIEnv *env);
 246 
 247 JNIEXPORT jint JNICALL
 248 JVM_ClassDepth(JNIEnv *env, jstring name);
 249 
 250 JNIEXPORT jint JNICALL
 251 JVM_ClassLoaderDepth(JNIEnv *env);
 252 
 253 /*
 254  * java.lang.Package
 255  */
 256 JNIEXPORT jstring JNICALL
 257 JVM_GetSystemPackage(JNIEnv *env, jstring name);
 258 
 259 JNIEXPORT jobjectArray JNICALL
 260 JVM_GetSystemPackages(JNIEnv *env);
 261 
 262 /*
 263  * java.io.ObjectInputStream
 264  */
 265 JNIEXPORT jobject JNICALL
 266 JVM_LatestUserDefinedLoader(JNIEnv *env);
 267 
 268 /*
 269  * java.lang.reflect.Array
 270  */
 271 JNIEXPORT jint JNICALL
 272 JVM_GetArrayLength(JNIEnv *env, jobject arr);
 273 
 274 JNIEXPORT jobject JNICALL
 275 JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index);
 276 
 277 JNIEXPORT jvalue JNICALL
 278 JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode);
 279 
 280 JNIEXPORT void JNICALL
 281 JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val);
 282 
 283 JNIEXPORT void JNICALL
 284 JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v,
 285                              unsigned char vCode);
 286 
 287 JNIEXPORT jobject JNICALL
 288 JVM_NewArray(JNIEnv *env, jclass eltClass, jint length);
 289 
 290 JNIEXPORT jobject JNICALL
 291 JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim);
 292 
 293 /*
 294  * java.lang.Class and java.lang.ClassLoader
 295  */
 296 
 297 #define JVM_CALLER_DEPTH -1
 298 
 299 /*
 300  * Returns the immediate caller class of the native method invoking
 301  * JVM_GetCallerClass.  The Method.invoke and other frames due to
 302  * reflection machinery are skipped.
 303  *
 304  * The depth parameter must be -1 (JVM_DEPTH). The caller is expected
 305  * to be marked with sun.reflect.CallerSensitive.  The JVM will throw
 306  * an error if it is not marked propertly.
 307  */
 308 JNIEXPORT jclass JNICALL
 309 JVM_GetCallerClass(JNIEnv *env, int depth);
 310 
 311 
 312 /*
 313  * Find primitive classes
 314  * utf: class name
 315  */
 316 JNIEXPORT jclass JNICALL
 317 JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);
 318 
 319 
 320 /*
 321  * Find a class from a boot class loader. Returns NULL if class not found.
 322  */
 323 JNIEXPORT jclass JNICALL
 324 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name);
 325 
 326 /*
 327  * Find a class from a given class loader.  Throws ClassNotFoundException.
 328  *  name:   name of class
 329  *  init:   whether initialization is done
 330  *  loader: class loader to look up the class. This may not be the same as the caller's
 331  *          class loader.
 332  *  caller: initiating class. The initiating class may be null when a security
 333  *          manager is not installed.
 334  */
 335 JNIEXPORT jclass JNICALL
 336 JVM_FindClassFromCaller(JNIEnv *env, const char *name, jboolean init,
 337                         jobject loader, jclass caller);
 338 
 339 /*
 340  * Find a class from a given class.
 341  */
 342 JNIEXPORT jclass JNICALL
 343 JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,
 344                              jclass from);
 345 
 346 /* Find a loaded class cached by the VM */
 347 JNIEXPORT jclass JNICALL
 348 JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);
 349 
 350 /* Define a class */
 351 JNIEXPORT jclass JNICALL
 352 JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
 353                 jsize len, jobject pd);
 354 
 355 /* Define a class with a source (added in JDK1.5) */
 356 JNIEXPORT jclass JNICALL
 357 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
 358                           const jbyte *buf, jsize len, jobject pd,
 359                           const char *source);
 360 
 361 /*
 362  * Reflection support functions
 363  */
 364 
 365 JNIEXPORT jstring JNICALL
 366 JVM_GetClassName(JNIEnv *env, jclass cls);
 367 
 368 JNIEXPORT jobjectArray JNICALL
 369 JVM_GetClassInterfaces(JNIEnv *env, jclass cls);
 370 
 371 JNIEXPORT jboolean JNICALL
 372 JVM_IsInterface(JNIEnv *env, jclass cls);
 373 
 374 JNIEXPORT jobjectArray JNICALL
 375 JVM_GetClassSigners(JNIEnv *env, jclass cls);
 376 
 377 JNIEXPORT void JNICALL
 378 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);
 379 
 380 JNIEXPORT jobject JNICALL
 381 JVM_GetProtectionDomain(JNIEnv *env, jclass cls);
 382 
 383 JNIEXPORT jboolean JNICALL
 384 JVM_IsArrayClass(JNIEnv *env, jclass cls);
 385 
 386 JNIEXPORT jboolean JNICALL
 387 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);
 388 
 389 JNIEXPORT jint JNICALL
 390 JVM_GetClassModifiers(JNIEnv *env, jclass cls);
 391 
 392 JNIEXPORT jobjectArray JNICALL
 393 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);
 394 
 395 JNIEXPORT jclass JNICALL
 396 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);
 397 
 398 JNIEXPORT jstring JNICALL
 399 JVM_GetSimpleBinaryName(JNIEnv *env, jclass ofClass);
 400 
 401 /* Generics support (JDK 1.5) */
 402 JNIEXPORT jstring JNICALL
 403 JVM_GetClassSignature(JNIEnv *env, jclass cls);
 404 
 405 /* Annotations support (JDK 1.5) */
 406 JNIEXPORT jbyteArray JNICALL
 407 JVM_GetClassAnnotations(JNIEnv *env, jclass cls);
 408 
 409 /* Type use annotations support (JDK 1.8) */
 410 
 411 JNIEXPORT jbyteArray JNICALL
 412 JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls);
 413 
 414 JNIEXPORT jbyteArray JNICALL
 415 JVM_GetFieldTypeAnnotations(JNIEnv *env, jobject field);
 416 
 417 JNIEXPORT jbyteArray JNICALL
 418 JVM_GetMethodTypeAnnotations(JNIEnv *env, jobject method);
 419 
 420 /*
 421  * New (JDK 1.4) reflection implementation
 422  */
 423 
 424 JNIEXPORT jobjectArray JNICALL
 425 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 426 
 427 JNIEXPORT jobjectArray JNICALL
 428 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 429 
 430 JNIEXPORT jobjectArray JNICALL
 431 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 432 
 433 /* Differs from JVM_GetClassModifiers in treatment of inner classes.
 434    This returns the access flags for the class as specified in the
 435    class file rather than searching the InnerClasses attribute (if
 436    present) to find the source-level access flags. Only the values of
 437    the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
 438    valid. */
 439 JNIEXPORT jint JNICALL
 440 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);
 441 
 442 /* The following two reflection routines are still needed due to startup time issues */
 443 /*
 444  * java.lang.reflect.Method
 445  */
 446 JNIEXPORT jobject JNICALL
 447 JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0);
 448 
 449 /*
 450  * java.lang.reflect.Constructor
 451  */
 452 JNIEXPORT jobject JNICALL
 453 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);
 454 
 455 /*
 456  * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)
 457  */
 458 
 459 JNIEXPORT jobject JNICALL
 460 JVM_GetClassConstantPool(JNIEnv *env, jclass cls);
 461 
 462 JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize
 463 (JNIEnv *env, jobject unused, jobject jcpool);
 464 
 465 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt
 466 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 467 
 468 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded
 469 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 470 
 471 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt
 472 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 473 
 474 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded
 475 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 476 
 477 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt
 478 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 479 
 480 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded
 481 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 482 
 483 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt
 484 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 485 
 486 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetNameAndTypeRefInfoAt
 487 (JNIEnv *env, jobject obj, jobject unused, jint index);
 488 
 489 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetInvokedynamicRefInfoAt
 490 (JNIEnv *env, jobject obj, jobject unused, jint index);
 491 
 492 JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt
 493 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 494 
 495 JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt
 496 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 497 
 498 JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt
 499 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 500 
 501 JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt
 502 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 503 
 504 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt
 505 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 506 
 507 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
 508 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 509 
 510 JNIEXPORT jbyte JNICALL JVM_ConstantPoolGetTagAt
 511 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 512 
 513 /*
 514  * Parameter reflection
 515  */
 516 
 517 JNIEXPORT jobjectArray JNICALL
 518 JVM_GetMethodParameters(JNIEnv *env, jobject method);
 519 
 520 /*
 521  * java.security.*
 522  */
 523 
 524 JNIEXPORT jobject JNICALL
 525 JVM_DoPrivileged(JNIEnv *env, jclass cls,
 526                  jobject action, jobject context, jboolean wrapException);
 527 
 528 JNIEXPORT jobject JNICALL
 529 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);
 530 
 531 JNIEXPORT jobject JNICALL
 532 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);
 533 
 534 /*
 535  * Signal support, used to implement the shutdown sequence.  Every VM must
 536  * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts
 537  * (^C) and the latter for external termination (kill, system shutdown, etc.).
 538  * Other platform-dependent signal values may also be supported.
 539  */
 540 
 541 JNIEXPORT void * JNICALL
 542 JVM_RegisterSignal(jint sig, void *handler);
 543 
 544 JNIEXPORT jboolean JNICALL
 545 JVM_RaiseSignal(jint sig);
 546 
 547 JNIEXPORT jint JNICALL
 548 JVM_FindSignal(const char *name);
 549 
 550 /*
 551  * Retrieve the assertion directives for the specified class.
 552  */
 553 JNIEXPORT jboolean JNICALL
 554 JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls);
 555 
 556 /*
 557  * Retrieve the assertion directives from the VM.
 558  */
 559 JNIEXPORT jobject JNICALL
 560 JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);
 561 
 562 /*
 563  * java.util.concurrent.atomic.AtomicLong
 564  */
 565 JNIEXPORT jboolean JNICALL
 566 JVM_SupportsCX8(void);
 567 
 568 /*
 569  * com.sun.dtrace.jsdt support
 570  */
 571 
 572 #define JVM_TRACING_DTRACE_VERSION 1
 573 
 574 /*
 575  * Structure to pass one probe description to JVM
 576  */
 577 typedef struct {
 578     jmethodID method;
 579     jstring   function;
 580     jstring   name;
 581     void*            reserved[4];     // for future use
 582 } JVM_DTraceProbe;
 583 
 584 /**
 585  * Encapsulates the stability ratings for a DTrace provider field
 586  */
 587 typedef struct {
 588     jint nameStability;
 589     jint dataStability;
 590     jint dependencyClass;
 591 } JVM_DTraceInterfaceAttributes;
 592 
 593 /*
 594  * Structure to pass one provider description to JVM
 595  */
 596 typedef struct {
 597     jstring                       name;
 598     JVM_DTraceProbe*              probes;
 599     jint                          probe_count;
 600     JVM_DTraceInterfaceAttributes providerAttributes;
 601     JVM_DTraceInterfaceAttributes moduleAttributes;
 602     JVM_DTraceInterfaceAttributes functionAttributes;
 603     JVM_DTraceInterfaceAttributes nameAttributes;
 604     JVM_DTraceInterfaceAttributes argsAttributes;
 605     void*                         reserved[4]; // for future use
 606 } JVM_DTraceProvider;
 607 
 608 /*
 609  * Get the version number the JVM was built with
 610  */
 611 JNIEXPORT jint JNICALL
 612 JVM_DTraceGetVersion(JNIEnv* env);
 613 
 614 /*
 615  * Register new probe with given signature, return global handle
 616  *
 617  * The version passed in is the version that the library code was
 618  * built with.
 619  */
 620 JNIEXPORT jlong JNICALL
 621 JVM_DTraceActivate(JNIEnv* env, jint version, jstring module_name,
 622   jint providers_count, JVM_DTraceProvider* providers);
 623 
 624 /*
 625  * Check JSDT probe
 626  */
 627 JNIEXPORT jboolean JNICALL
 628 JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method);
 629 
 630 /*
 631  * Destroy custom DOF
 632  */
 633 JNIEXPORT void JNICALL
 634 JVM_DTraceDispose(JNIEnv* env, jlong activation_handle);
 635 
 636 /*
 637  * Check to see if DTrace is supported by OS
 638  */
 639 JNIEXPORT jboolean JNICALL
 640 JVM_DTraceIsSupported(JNIEnv* env);
 641 
 642 /*************************************************************************
 643  PART 2: Support for the Verifier and Class File Format Checker
 644  ************************************************************************/
 645 /*
 646  * Return the class name in UTF format. The result is valid
 647  * until JVM_ReleaseUTf is called.
 648  *
 649  * The caller must treat the string as a constant and not modify it
 650  * in any way.
 651  */
 652 JNIEXPORT const char * JNICALL
 653 JVM_GetClassNameUTF(JNIEnv *env, jclass cb);
 654 
 655 /*
 656  * Returns the constant pool types in the buffer provided by "types."
 657  */
 658 JNIEXPORT void JNICALL
 659 JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types);
 660 
 661 /*
 662  * Returns the number of Constant Pool entries.
 663  */
 664 JNIEXPORT jint JNICALL
 665 JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);
 666 
 667 /*
 668  * Returns the number of *declared* fields or methods.
 669  */
 670 JNIEXPORT jint JNICALL
 671 JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);
 672 
 673 JNIEXPORT jint JNICALL
 674 JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);
 675 
 676 /*
 677  * Returns the CP indexes of exceptions raised by a given method.
 678  * Places the result in the given buffer.
 679  *
 680  * The method is identified by method_index.
 681  */
 682 JNIEXPORT void JNICALL
 683 JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,
 684                                 unsigned short *exceptions);
 685 /*
 686  * Returns the number of exceptions raised by a given method.
 687  * The method is identified by method_index.
 688  */
 689 JNIEXPORT jint JNICALL
 690 JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index);
 691 
 692 /*
 693  * Returns the byte code sequence of a given method.
 694  * Places the result in the given buffer.
 695  *
 696  * The method is identified by method_index.
 697  */
 698 JNIEXPORT void JNICALL
 699 JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,
 700                         unsigned char *code);
 701 
 702 /*
 703  * Returns the length of the byte code sequence of a given method.
 704  * The method is identified by method_index.
 705  */
 706 JNIEXPORT jint JNICALL
 707 JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index);
 708 
 709 /*
 710  * A structure used to a capture exception table entry in a Java method.
 711  */
 712 typedef struct {
 713     jint start_pc;
 714     jint end_pc;
 715     jint handler_pc;
 716     jint catchType;
 717 } JVM_ExceptionTableEntryType;
 718 
 719 /*
 720  * Returns the exception table entry at entry_index of a given method.
 721  * Places the result in the given buffer.
 722  *
 723  * The method is identified by method_index.
 724  */
 725 JNIEXPORT void JNICALL
 726 JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index,
 727                                    jint entry_index,
 728                                    JVM_ExceptionTableEntryType *entry);
 729 
 730 /*
 731  * Returns the length of the exception table of a given method.
 732  * The method is identified by method_index.
 733  */
 734 JNIEXPORT jint JNICALL
 735 JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index);
 736 
 737 /*
 738  * Returns the modifiers of a given field.
 739  * The field is identified by field_index.
 740  */
 741 JNIEXPORT jint JNICALL
 742 JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index);
 743 
 744 /*
 745  * Returns the modifiers of a given method.
 746  * The method is identified by method_index.
 747  */
 748 JNIEXPORT jint JNICALL
 749 JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index);
 750 
 751 /*
 752  * Returns the number of local variables of a given method.
 753  * The method is identified by method_index.
 754  */
 755 JNIEXPORT jint JNICALL
 756 JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index);
 757 
 758 /*
 759  * Returns the number of arguments (including this pointer) of a given method.
 760  * The method is identified by method_index.
 761  */
 762 JNIEXPORT jint JNICALL
 763 JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index);
 764 
 765 /*
 766  * Returns the maximum amount of stack (in words) used by a given method.
 767  * The method is identified by method_index.
 768  */
 769 JNIEXPORT jint JNICALL
 770 JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index);
 771 
 772 /*
 773  * Is a given method a constructor.
 774  * The method is identified by method_index.
 775  */
 776 JNIEXPORT jboolean JNICALL
 777 JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index);
 778 
 779 /*
 780  * Is the given method generated by the VM.
 781  * The method is identified by method_index.
 782  */
 783 JNIEXPORT jboolean JNICALL
 784 JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cb, int index);
 785 
 786 /*
 787  * Returns the name of a given method in UTF format.
 788  * The result remains valid until JVM_ReleaseUTF is called.
 789  *
 790  * The caller must treat the string as a constant and not modify it
 791  * in any way.
 792  */
 793 JNIEXPORT const char * JNICALL
 794 JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index);
 795 
 796 /*
 797  * Returns the signature of a given method in UTF format.
 798  * The result remains valid until JVM_ReleaseUTF is called.
 799  *
 800  * The caller must treat the string as a constant and not modify it
 801  * in any way.
 802  */
 803 JNIEXPORT const char * JNICALL
 804 JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index);
 805 
 806 /*
 807  * Returns the name of the field referred to at a given constant pool
 808  * index.
 809  *
 810  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 811  * is called.
 812  *
 813  * The caller must treat the string as a constant and not modify it
 814  * in any way.
 815  */
 816 JNIEXPORT const char * JNICALL
 817 JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);
 818 
 819 /*
 820  * Returns the name of the method referred to at a given constant pool
 821  * index.
 822  *
 823  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 824  * is called.
 825  *
 826  * The caller must treat the string as a constant and not modify it
 827  * in any way.
 828  */
 829 JNIEXPORT const char * JNICALL
 830 JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);
 831 
 832 /*
 833  * Returns the signature of the method referred to at a given constant pool
 834  * index.
 835  *
 836  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 837  * is called.
 838  *
 839  * The caller must treat the string as a constant and not modify it
 840  * in any way.
 841  */
 842 JNIEXPORT const char * JNICALL
 843 JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);
 844 
 845 /*
 846  * Returns the signature of the field referred to at a given constant pool
 847  * index.
 848  *
 849  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 850  * is called.
 851  *
 852  * The caller must treat the string as a constant and not modify it
 853  * in any way.
 854  */
 855 JNIEXPORT const char * JNICALL
 856 JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);
 857 
 858 /*
 859  * Returns the class name referred to at a given constant pool 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_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index);
 869 
 870 /*
 871  * Returns the class name referred to at a given constant pool index.
 872  *
 873  * The constant pool entry must refer to a CONSTANT_Fieldref.
 874  *
 875  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 876  * is called.
 877  *
 878  * The caller must treat the string as a constant and not modify it
 879  * in any way.
 880  */
 881 JNIEXPORT const char * JNICALL
 882 JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index);
 883 
 884 /*
 885  * Returns the class name referred to at a given constant pool index.
 886  *
 887  * The constant pool entry must refer to CONSTANT_Methodref or
 888  * CONSTANT_InterfaceMethodref.
 889  *
 890  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 891  * is called.
 892  *
 893  * The caller must treat the string as a constant and not modify it
 894  * in any way.
 895  */
 896 JNIEXPORT const char * JNICALL
 897 JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index);
 898 
 899 /*
 900  * Returns the modifiers of a field in calledClass. The field is
 901  * referred to in class cb at constant pool entry index.
 902  *
 903  * The caller must treat the string as a constant and not modify it
 904  * in any way.
 905  *
 906  * Returns -1 if the field does not exist in calledClass.
 907  */
 908 JNIEXPORT jint JNICALL
 909 JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
 910 
 911 /*
 912  * Returns the modifiers of a method in calledClass. The method is
 913  * referred to in class cb at constant pool entry index.
 914  *
 915  * Returns -1 if the method does not exist in calledClass.
 916  */
 917 JNIEXPORT jint JNICALL
 918 JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
 919 
 920 /*
 921  * Releases the UTF string obtained from the VM.
 922  */
 923 JNIEXPORT void JNICALL
 924 JVM_ReleaseUTF(const char *utf);
 925 
 926 /*
 927  * Compare if two classes are in the same package.
 928  */
 929 JNIEXPORT jboolean JNICALL
 930 JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2);
 931 
 932 /* Get classfile constants */
 933 #include "classfile_constants.h"
 934 
 935 /*
 936  * A function defined by the byte-code verifier and called by the VM.
 937  * This is not a function implemented in the VM.
 938  *
 939  * Returns JNI_FALSE if verification fails. A detailed error message
 940  * will be places in msg_buf, whose length is specified by buf_len.
 941  */
 942 typedef jboolean (*verifier_fn_t)(JNIEnv *env,
 943                                   jclass cb,
 944                                   char * msg_buf,
 945                                   jint buf_len);
 946 
 947 
 948 /*
 949  * Support for a VM-independent class format checker.
 950  */
 951 typedef struct {
 952     unsigned long code;    /* byte code */
 953     unsigned long excs;    /* exceptions */
 954     unsigned long etab;    /* catch table */
 955     unsigned long lnum;    /* line number */
 956     unsigned long lvar;    /* local vars */
 957 } method_size_info;
 958 
 959 typedef struct {
 960     unsigned int constants;    /* constant pool */
 961     unsigned int fields;
 962     unsigned int methods;
 963     unsigned int interfaces;
 964     unsigned int fields2;      /* number of static 2-word fields */
 965     unsigned int innerclasses; /* # of records in InnerClasses attr */
 966 
 967     method_size_info clinit;   /* memory used in clinit */
 968     method_size_info main;     /* used everywhere else */
 969 } class_size_info;
 970 
 971 /*
 972  * Functions defined in libjava.so to perform string conversions.
 973  *
 974  */
 975 
 976 typedef jstring (*to_java_string_fn_t)(JNIEnv *env, char *str);
 977 
 978 typedef char *(*to_c_string_fn_t)(JNIEnv *env, jstring s, jboolean *b);
 979 
 980 /* This is the function defined in libjava.so that performs class
 981  * format checks. This functions fills in size information about
 982  * the class file and returns:
 983  *
 984  *   0: good
 985  *  -1: out of memory
 986  *  -2: bad format
 987  *  -3: unsupported version
 988  *  -4: bad class name
 989  */
 990 
 991 typedef jint (*check_format_fn_t)(char *class_name,
 992                                   unsigned char *data,
 993                                   unsigned int data_size,
 994                                   class_size_info *class_size,
 995                                   char *message_buffer,
 996                                   jint buffer_length,
 997                                   jboolean measure_only,
 998                                   jboolean check_relaxed);
 999 
1000 #define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \
1001                                         JVM_ACC_FINAL | \
1002                                         JVM_ACC_SUPER | \
1003                                         JVM_ACC_INTERFACE | \
1004                                         JVM_ACC_ABSTRACT | \
1005                                         JVM_ACC_ANNOTATION | \
1006                                         JVM_ACC_ENUM | \
1007                                         JVM_ACC_SYNTHETIC)
1008 
1009 #define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \
1010                                         JVM_ACC_PRIVATE | \
1011                                         JVM_ACC_PROTECTED | \
1012                                         JVM_ACC_STATIC | \
1013                                         JVM_ACC_FINAL | \
1014                                         JVM_ACC_VOLATILE | \
1015                                         JVM_ACC_TRANSIENT | \
1016                                         JVM_ACC_ENUM | \
1017                                         JVM_ACC_SYNTHETIC)
1018 
1019 #define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \
1020                                          JVM_ACC_PRIVATE | \
1021                                          JVM_ACC_PROTECTED | \
1022                                          JVM_ACC_STATIC | \
1023                                          JVM_ACC_FINAL | \
1024                                          JVM_ACC_SYNCHRONIZED | \
1025                                          JVM_ACC_BRIDGE | \
1026                                          JVM_ACC_VARARGS | \
1027                                          JVM_ACC_NATIVE | \
1028                                          JVM_ACC_ABSTRACT | \
1029                                          JVM_ACC_STRICT | \
1030                                          JVM_ACC_SYNTHETIC)
1031 
1032 /*
1033  * This is the function defined in libjava.so to perform path
1034  * canonicalization. VM call this function before opening jar files
1035  * to load system classes.
1036  *
1037  */
1038 
1039 typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len);
1040 
1041 /*************************************************************************
1042  PART 3: I/O and Network Support
1043  ************************************************************************/
1044 
1045 /*
1046  * Convert a pathname into native format.  This function does syntactic
1047  * cleanup, such as removing redundant separator characters.  It modifies
1048  * the given pathname string in place.
1049  */
1050 JNIEXPORT char * JNICALL
1051 JVM_NativePath(char *);
1052 
1053 /*
1054  * The standard printing functions supported by the Java VM. (Should they
1055  * be renamed to JVM_* in the future?
1056  */
1057 
1058 /*
1059  * BE CAREFUL! The following functions do not implement the
1060  * full feature set of standard C printf formats.
1061  */
1062 int
1063 jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
1064 
1065 int
1066 jio_snprintf(char *str, size_t count, const char *fmt, ...);
1067 
1068 int
1069 jio_fprintf(FILE *, const char *fmt, ...);
1070 
1071 int
1072 jio_vfprintf(FILE *, const char *fmt, va_list args);
1073 
1074 
1075 JNIEXPORT void * JNICALL
1076 JVM_RawMonitorCreate(void);
1077 
1078 JNIEXPORT void JNICALL
1079 JVM_RawMonitorDestroy(void *mon);
1080 
1081 JNIEXPORT jint JNICALL
1082 JVM_RawMonitorEnter(void *mon);
1083 
1084 JNIEXPORT void JNICALL
1085 JVM_RawMonitorExit(void *mon);
1086 
1087 /*
1088  * java.lang.management support
1089  */
1090 JNIEXPORT void* JNICALL
1091 JVM_GetManagement(jint version);
1092 
1093 /*
1094  * com.sun.tools.attach.VirtualMachine support
1095  *
1096  * Initialize the agent properties with the properties maintained in the VM.
1097  */
1098 JNIEXPORT jobject JNICALL
1099 JVM_InitAgentProperties(JNIEnv *env, jobject agent_props);
1100 
1101 JNIEXPORT jstring JNICALL
1102 JVM_GetTemporaryDirectory(JNIEnv *env);
1103 
1104 /* Generics reflection support.
1105  *
1106  * Returns information about the given class's EnclosingMethod
1107  * attribute, if present, or null if the class had no enclosing
1108  * method.
1109  *
1110  * If non-null, the returned array contains three elements. Element 0
1111  * is the java.lang.Class of which the enclosing method is a member,
1112  * and elements 1 and 2 are the java.lang.Strings for the enclosing
1113  * method's name and descriptor, respectively.
1114  */
1115 JNIEXPORT jobjectArray JNICALL
1116 JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);
1117 
1118 /* =========================================================================
1119  * The following defines a private JVM interface that the JDK can query
1120  * for the JVM version and capabilities.  sun.misc.Version defines
1121  * the methods for getting the VM version and its capabilities.
1122  *
1123  * When a new bit is added, the following should be updated to provide
1124  * access to the new capability:
1125  *    HS:   JVM_GetVersionInfo and Abstract_VM_Version class
1126  *    SDK:  Version class
1127  *
1128  * Similary, a private JDK interface JDK_GetVersionInfo0 is defined for
1129  * JVM to query for the JDK version and capabilities.
1130  *
1131  * When a new bit is added, the following should be updated to provide
1132  * access to the new capability:
1133  *    HS:   JDK_Version class
1134  *    SDK:  JDK_GetVersionInfo0
1135  *
1136  * ==========================================================================
1137  */
1138 typedef struct {
1139     /* Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx */
1140     unsigned int jvm_version;   /* Consists of major, minor, micro (n.n.n) */
1141                                 /* and build number (xx) */
1142     unsigned int update_version : 8;         /* Update release version (uu) */
1143     unsigned int special_update_version : 8; /* Special update release version (c)*/
1144     unsigned int reserved1 : 16;
1145     unsigned int reserved2;
1146 
1147     /* The following bits represents JVM supports that JDK has dependency on.
1148      * JDK can use these bits to determine which JVM version
1149      * and support it has to maintain runtime compatibility.
1150      *
1151      * When a new bit is added in a minor or update release, make sure
1152      * the new bit is also added in the main/baseline.
1153      */
1154     unsigned int is_attach_supported : 1;
1155     unsigned int : 31;
1156     unsigned int : 32;
1157     unsigned int : 32;
1158 } jvm_version_info;
1159 
1160 #define JVM_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
1161 #define JVM_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
1162 #define JVM_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
1163 
1164 /* Build number is available only for RE builds.
1165  * It will be zero for internal builds.
1166  */
1167 #define JVM_VERSION_BUILD(version) ((version & 0x000000FF))
1168 
1169 JNIEXPORT void JNICALL
1170 JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size);
1171 
1172 typedef struct {
1173     // Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx
1174     unsigned int jdk_version;   /* Consists of major, minor, micro (n.n.n) */
1175                                 /* and build number (xx) */
1176     unsigned int update_version : 8;         /* Update release version (uu) */
1177     unsigned int special_update_version : 8; /* Special update release version (c)*/
1178     unsigned int reserved1 : 16;
1179     unsigned int reserved2;
1180 
1181     /* The following bits represents new JDK supports that VM has dependency on.
1182      * VM implementation can use these bits to determine which JDK version
1183      * and support it has to maintain runtime compatibility.
1184      *
1185      * When a new bit is added in a minor or update release, make sure
1186      * the new bit is also added in the main/baseline.
1187      */
1188     unsigned int thread_park_blocker : 1;
1189     unsigned int post_vm_init_hook_enabled : 1;
1190     unsigned int pending_list_uses_discovered_field : 1;
1191     unsigned int : 29;
1192     unsigned int : 32;
1193     unsigned int : 32;
1194 } jdk_version_info;
1195 
1196 #define JDK_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
1197 #define JDK_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
1198 #define JDK_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
1199 
1200 /* Build number is available only for RE build (i.e. JDK_BUILD_NUMBER is set to bNN)
1201  * It will be zero for internal builds.
1202  */
1203 #define JDK_VERSION_BUILD(version) ((version & 0x000000FF))
1204 
1205 /*
1206  * This is the function JDK_GetVersionInfo0 defined in libjava.so
1207  * that is dynamically looked up by JVM.
1208  */
1209 typedef void (*jdk_version_info_fn_t)(jdk_version_info* info, size_t info_size);
1210 
1211 /*
1212  * This structure is used by the launcher to get the default thread
1213  * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a
1214  * version of 1.1.  As it is not supported otherwise, it has been removed
1215  * from jni.h
1216  */
1217 typedef struct JDK1_1InitArgs {
1218     jint version;
1219 
1220     char **properties;
1221     jint checkSource;
1222     jint nativeStackSize;
1223     jint javaStackSize;
1224     jint minHeapSize;
1225     jint maxHeapSize;
1226     jint verifyMode;
1227     char *classpath;
1228 
1229     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
1230     void (JNICALL *exit)(jint code);
1231     void (JNICALL *abort)(void);
1232 
1233     jint enableClassGC;
1234     jint enableVerboseGC;
1235     jint disableAsyncGC;
1236     jint verbose;
1237     jboolean debugging;
1238     jint debugPort;
1239 } JDK1_1InitArgs;
1240 
1241 
1242 #ifdef __cplusplus
1243 } /* extern "C" */
1244 
1245 #endif /* __cplusplus */
1246 
1247 #endif /* !_JAVASOFT_JVM_H_ */