1 /*
   2  * Copyright (c) 1997, 2016, 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.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_PRIMS_JVM_H
  26 #define SHARE_VM_PRIMS_JVM_H
  27 
  28 #include "prims/jni.h"
  29 #ifdef TARGET_OS_FAMILY_linux
  30 # include "jvm_linux.h"
  31 #endif
  32 #ifdef TARGET_OS_FAMILY_solaris
  33 # include "jvm_solaris.h"
  34 #endif
  35 #ifdef TARGET_OS_FAMILY_windows
  36 # include "jvm_windows.h"
  37 #endif
  38 #ifdef TARGET_OS_FAMILY_aix
  39 # include "jvm_aix.h"
  40 #endif
  41 #ifdef TARGET_OS_FAMILY_bsd
  42 # include "jvm_bsd.h"
  43 #endif
  44 
  45 #ifndef _JAVASOFT_JVM_H_
  46 #define _JAVASOFT_JVM_H_
  47 
  48 // HotSpot integration note:
  49 //
  50 // This file and jvm.h used with the JDK are identical,
  51 // except for the three includes removed below
  52 
  53 // #include <sys/stat.h>
  54 // #include "jni.h"
  55 // #include "jvm_md.h"
  56 
  57 
  58 #ifdef __cplusplus
  59 extern "C" {
  60 #endif
  61 
  62 /*
  63  * This file contains additional functions exported from the VM.
  64  * These functions are complementary to the standard JNI support.
  65  * There are three parts to this file:
  66  *
  67  * First, this file contains the VM-related functions needed by native
  68  * libraries in the standard Java API. For example, the java.lang.Object
  69  * class needs VM-level functions that wait for and notify monitors.
  70  *
  71  * Second, this file contains the functions and constant definitions
  72  * needed by the byte code verifier and class file format checker.
  73  * These functions allow the verifier and format checker to be written
  74  * in a VM-independent way.
  75  *
  76  * Third, this file contains various I/O and nerwork operations needed
  77  * by the standard Java I/O and network APIs.
  78  */
  79 
  80 /*
  81  * Bump the version number when either of the following happens:
  82  *
  83  * 1. There is a change in JVM_* functions.
  84  *
  85  * 2. There is a change in the contract between VM and Java classes.
  86  *    For example, if the VM relies on a new private field in Thread
  87  *    class.
  88  */
  89 
  90 #define JVM_INTERFACE_VERSION 5
  91 
  92 JNIEXPORT jobjectArray JNICALL
  93 JVM_GetMethodParameters(JNIEnv *env, jobject method);
  94 
  95 JNIEXPORT jint JNICALL
  96 JVM_GetInterfaceVersion(void);
  97 
  98 /*************************************************************************
  99  PART 1: Functions for Native Libraries
 100  ************************************************************************/
 101 /*
 102  * java.lang.Object
 103  */
 104 JNIEXPORT jint JNICALL
 105 JVM_IHashCode(JNIEnv *env, jobject obj);
 106 
 107 JNIEXPORT void JNICALL
 108 JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms);
 109 
 110 JNIEXPORT void JNICALL
 111 JVM_MonitorNotify(JNIEnv *env, jobject obj);
 112 
 113 JNIEXPORT void JNICALL
 114 JVM_MonitorNotifyAll(JNIEnv *env, jobject obj);
 115 
 116 JNIEXPORT jobject JNICALL
 117 JVM_Clone(JNIEnv *env, jobject obj);
 118 
 119 /*
 120  * java.lang.String
 121  */
 122 JNIEXPORT jstring JNICALL
 123 JVM_InternString(JNIEnv *env, jstring str);
 124 
 125 /*
 126  * java.lang.System
 127  */
 128 JNIEXPORT jlong JNICALL
 129 JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored);
 130 
 131 JNIEXPORT jlong JNICALL
 132 JVM_NanoTime(JNIEnv *env, jclass ignored);
 133 
 134 JNIEXPORT jlong JNICALL
 135 JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs);
 136 
 137 JNIEXPORT void JNICALL
 138 JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
 139               jobject dst, jint dst_pos, jint length);
 140 
 141 JNIEXPORT jobject JNICALL
 142 JVM_InitProperties(JNIEnv *env, jobject p);
 143 
 144 /*
 145  * java.lang.Runtime
 146  */
 147 
 148 JNIEXPORT void JNICALL
 149 JVM_Halt(jint code);
 150 
 151 JNIEXPORT void JNICALL
 152 JVM_GC(void);
 153 
 154 /* Returns the number of real-time milliseconds that have elapsed since the
 155  * least-recently-inspected heap object was last inspected by the garbage
 156  * collector.
 157  *
 158  * For simple stop-the-world collectors this value is just the time
 159  * since the most recent collection.  For generational collectors it is the
 160  * time since the oldest generation was most recently collected.  Other
 161  * collectors are free to return a pessimistic estimate of the elapsed time, or
 162  * simply the time since the last full collection was performed.
 163  *
 164  * Note that in the presence of reference objects, a given object that is no
 165  * longer strongly reachable may have to be inspected multiple times before it
 166  * can be reclaimed.
 167  */
 168 JNIEXPORT jlong JNICALL
 169 JVM_MaxObjectInspectionAge(void);
 170 
 171 JNIEXPORT jlong JNICALL
 172 JVM_TotalMemory(void);
 173 
 174 JNIEXPORT jlong JNICALL
 175 JVM_FreeMemory(void);
 176 
 177 JNIEXPORT jlong JNICALL
 178 JVM_MaxMemory(void);
 179 
 180 JNIEXPORT jint JNICALL
 181 JVM_ActiveProcessorCount(void);
 182 
 183 JNIEXPORT void * JNICALL
 184 JVM_LoadLibrary(const char *name);
 185 
 186 JNIEXPORT void JNICALL
 187 JVM_UnloadLibrary(void * handle);
 188 
 189 JNIEXPORT void * JNICALL
 190 JVM_FindLibraryEntry(void *handle, const char *name);
 191 
 192 JNIEXPORT jboolean JNICALL
 193 JVM_IsSupportedJNIVersion(jint version);
 194 
 195 JNIEXPORT jobjectArray JNICALL
 196 JVM_GetVmArguments(JNIEnv *env);
 197 
 198 /*
 199  * java.lang.Throwable
 200  */
 201 JNIEXPORT void JNICALL
 202 JVM_FillInStackTrace(JNIEnv *env, jobject throwable);
 203 
 204 JNIEXPORT void JNICALL
 205 JVM_GetStackTraceElements(JNIEnv *env, jobject throwable, jobjectArray elements);
 206 
 207 /*
 208  * java.lang.StackWalker
 209  */
 210 enum {
 211   JVM_STACKWALK_FILL_CLASS_REFS_ONLY       = 0x2,
 212   JVM_STACKWALK_SHOW_HIDDEN_FRAMES         = 0x20,
 213   JVM_STACKWALK_FILL_LIVE_STACK_FRAMES     = 0x100
 214 };
 215 
 216 JNIEXPORT jobject JNICALL
 217 JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jlong mode,
 218                   jint skip_frames, jint frame_count, jint start_index,
 219                   jobjectArray frames);
 220 
 221 JNIEXPORT jint JNICALL
 222 JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jlong mode, jlong anchor,
 223                   jint frame_count, jint start_index,
 224                   jobjectArray frames);
 225 
 226 JNIEXPORT void JNICALL
 227 JVM_ToStackTraceElement(JNIEnv* env, jobject frame, jobject stackElement);
 228 
 229 /*
 230  * java.lang.Thread
 231  */
 232 JNIEXPORT void JNICALL
 233 JVM_StartThread(JNIEnv *env, jobject thread);
 234 
 235 JNIEXPORT void JNICALL
 236 JVM_StopThread(JNIEnv *env, jobject thread, jobject exception);
 237 
 238 JNIEXPORT jboolean JNICALL
 239 JVM_IsThreadAlive(JNIEnv *env, jobject thread);
 240 
 241 JNIEXPORT void JNICALL
 242 JVM_SuspendThread(JNIEnv *env, jobject thread);
 243 
 244 JNIEXPORT void JNICALL
 245 JVM_ResumeThread(JNIEnv *env, jobject thread);
 246 
 247 JNIEXPORT void JNICALL
 248 JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio);
 249 
 250 JNIEXPORT void JNICALL
 251 JVM_Yield(JNIEnv *env, jclass threadClass);
 252 
 253 JNIEXPORT void JNICALL
 254 JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis);
 255 
 256 JNIEXPORT jobject JNICALL
 257 JVM_CurrentThread(JNIEnv *env, jclass threadClass);
 258 
 259 JNIEXPORT jint JNICALL
 260 JVM_CountStackFrames(JNIEnv *env, jobject thread);
 261 
 262 JNIEXPORT void JNICALL
 263 JVM_Interrupt(JNIEnv *env, jobject thread);
 264 
 265 JNIEXPORT jboolean JNICALL
 266 JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted);
 267 
 268 JNIEXPORT jboolean JNICALL
 269 JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj);
 270 
 271 JNIEXPORT void JNICALL
 272 JVM_DumpAllStacks(JNIEnv *env, jclass unused);
 273 
 274 JNIEXPORT jobjectArray JNICALL
 275 JVM_GetAllThreads(JNIEnv *env, jclass dummy);
 276 
 277 JNIEXPORT void JNICALL
 278 JVM_SetNativeThreadName(JNIEnv *env, jobject jthread, jstring name, jboolean allowAttachedThread);
 279 
 280 /* getStackTrace() and getAllStackTraces() method */
 281 JNIEXPORT jobjectArray JNICALL
 282 JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);
 283 
 284 /*
 285  * java.lang.SecurityManager
 286  */
 287 JNIEXPORT jclass JNICALL
 288 JVM_CurrentLoadedClass(JNIEnv *env);
 289 
 290 JNIEXPORT jobject JNICALL
 291 JVM_CurrentClassLoader(JNIEnv *env);
 292 
 293 JNIEXPORT jobjectArray JNICALL
 294 JVM_GetClassContext(JNIEnv *env);
 295 
 296 JNIEXPORT jint JNICALL
 297 JVM_ClassDepth(JNIEnv *env, jstring name);
 298 
 299 JNIEXPORT jint JNICALL
 300 JVM_ClassLoaderDepth(JNIEnv *env);
 301 
 302 /*
 303  * java.lang.Package
 304  */
 305 JNIEXPORT jstring JNICALL
 306 JVM_GetSystemPackage(JNIEnv *env, jstring name);
 307 
 308 JNIEXPORT jobjectArray JNICALL
 309 JVM_GetSystemPackages(JNIEnv *env);
 310 
 311 /*
 312  * java.io.ObjectInputStream
 313  */
 314 JNIEXPORT jobject JNICALL
 315 JVM_LatestUserDefinedLoader(JNIEnv *env);
 316 
 317 /*
 318  * java.lang.reflect.Array
 319  */
 320 JNIEXPORT jint JNICALL
 321 JVM_GetArrayLength(JNIEnv *env, jobject arr);
 322 
 323 JNIEXPORT jobject JNICALL
 324 JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index);
 325 
 326 JNIEXPORT jvalue JNICALL
 327 JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode);
 328 
 329 JNIEXPORT void JNICALL
 330 JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val);
 331 
 332 JNIEXPORT void JNICALL
 333 JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v,
 334                              unsigned char vCode);
 335 
 336 JNIEXPORT jobject JNICALL
 337 JVM_NewArray(JNIEnv *env, jclass eltClass, jint length);
 338 
 339 JNIEXPORT jobject JNICALL
 340 JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim);
 341 
 342 /*
 343  * java.lang.Class and java.lang.ClassLoader
 344  */
 345 
 346 #define JVM_CALLER_DEPTH -1
 347 
 348 /*
 349  * Returns the class in which the code invoking the native method
 350  * belongs.
 351  *
 352  * Note that in JDK 1.1, native methods did not create a frame.
 353  * In 1.2, they do. Therefore native methods like Class.forName
 354  * can no longer look at the current frame for the caller class.
 355  */
 356 JNIEXPORT jclass JNICALL
 357 JVM_GetCallerClass(JNIEnv *env, int n);
 358 
 359 /*
 360  * Find primitive classes
 361  * utf: class name
 362  */
 363 JNIEXPORT jclass JNICALL
 364 JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);
 365 
 366 /*
 367  * Find a class from a boot class loader. Returns NULL if class not found.
 368  */
 369 JNIEXPORT jclass JNICALL
 370 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name);
 371 
 372 /*
 373  * Find a class from a given class loader.  Throws ClassNotFoundException.
 374  *  name:   name of class
 375  *  init:   whether initialization is done
 376  *  loader: class loader to look up the class. This may not be the same as the caller's
 377  *          class loader.
 378  *  caller: initiating class. The initiating class may be null when a security
 379  *          manager is not installed.
 380  */
 381 JNIEXPORT jclass JNICALL
 382 JVM_FindClassFromCaller(JNIEnv *env, const char *name, jboolean init,
 383                         jobject loader, jclass caller);
 384 
 385 /*
 386  * Find a class from a given class.
 387  */
 388 JNIEXPORT jclass JNICALL
 389 JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,
 390                              jclass from);
 391 
 392 /* Find a loaded class cached by the VM */
 393 JNIEXPORT jclass JNICALL
 394 JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);
 395 
 396 /* Define a class */
 397 JNIEXPORT jclass JNICALL
 398 JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
 399                 jsize len, jobject pd);
 400 
 401 /* Define a class with a source (added in JDK1.5) */
 402 JNIEXPORT jclass JNICALL
 403 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
 404                           const jbyte *buf, jsize len, jobject pd,
 405                           const char *source);
 406 
 407 /*
 408  * Module support funcions
 409  */
 410 
 411 JNIEXPORT void JNICALL
 412 JVM_DefineModule(JNIEnv *env, jobject module, jstring version, jstring location,
 413                  jobjectArray packages);
 414 
 415 JNIEXPORT void JNICALL
 416 JVM_SetBootLoaderUnnamedModule(JNIEnv *env, jobject module);
 417 
 418 JNIEXPORT void JNICALL
 419 JVM_AddModuleExports(JNIEnv *env, jobject from_module, jstring package, jobject to_module);
 420 
 421 JNIEXPORT void JNICALL
 422 JVM_AddModuleExportsToAllUnnamed(JNIEnv *env, jobject from_module, jstring package);
 423 
 424 JNIEXPORT void JNICALL
 425 JVM_AddModuleExportsToAll(JNIEnv *env, jobject from_module, jstring package);
 426 
 427 JNIEXPORT void JNICALL
 428 JVM_AddReadsModule(JNIEnv *env, jobject from_module, jobject source_module);
 429 
 430 JNIEXPORT jboolean JNICALL
 431 JVM_CanReadModule(JNIEnv *env, jobject asking_module, jobject source_module);
 432 
 433 JNIEXPORT jboolean JNICALL
 434 JVM_IsExportedToModule(JNIEnv *env, jobject from_module, jstring package, jobject to_module);
 435 
 436 JNIEXPORT void JNICALL
 437 JVM_AddModulePackage(JNIEnv* env,  jobject module, jstring package);
 438 
 439 JNIEXPORT jobject JNICALL
 440 JVM_GetModuleByPackageName(JNIEnv* env, jobject loader, jstring package);
 441 
 442 /*
 443  * Reflection support functions
 444  */
 445 
 446 JNIEXPORT jstring JNICALL
 447 JVM_GetClassName(JNIEnv *env, jclass cls);
 448 
 449 JNIEXPORT jobjectArray JNICALL
 450 JVM_GetClassInterfaces(JNIEnv *env, jclass cls);
 451 
 452 JNIEXPORT jboolean JNICALL
 453 JVM_IsInterface(JNIEnv *env, jclass cls);
 454 
 455 JNIEXPORT jobjectArray JNICALL
 456 JVM_GetClassSigners(JNIEnv *env, jclass cls);
 457 
 458 JNIEXPORT void JNICALL
 459 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);
 460 
 461 JNIEXPORT jobject JNICALL
 462 JVM_GetProtectionDomain(JNIEnv *env, jclass cls);
 463 
 464 JNIEXPORT jboolean JNICALL
 465 JVM_IsArrayClass(JNIEnv *env, jclass cls);
 466 
 467 JNIEXPORT jboolean JNICALL
 468 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);
 469 
 470 JNIEXPORT jint JNICALL
 471 JVM_GetClassModifiers(JNIEnv *env, jclass cls);
 472 
 473 JNIEXPORT jobjectArray JNICALL
 474 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);
 475 
 476 JNIEXPORT jclass JNICALL
 477 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);
 478 
 479 JNIEXPORT jstring JNICALL
 480 JVM_GetSimpleBinaryName(JNIEnv *env, jclass ofClass);
 481 
 482 /* Generics support (JDK 1.5) */
 483 JNIEXPORT jstring JNICALL
 484 JVM_GetClassSignature(JNIEnv *env, jclass cls);
 485 
 486 /* Annotations support (JDK 1.5) */
 487 JNIEXPORT jbyteArray JNICALL
 488 JVM_GetClassAnnotations(JNIEnv *env, jclass cls);
 489 
 490 /* Annotations support (JDK 1.6) */
 491 
 492 /* Type use annotations support (JDK 1.8) */
 493 
 494 JNIEXPORT jbyteArray JNICALL
 495 JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls);
 496 
 497 // field is a handle to a java.lang.reflect.Field object
 498 JNIEXPORT jbyteArray JNICALL
 499 JVM_GetFieldTypeAnnotations(JNIEnv *env, jobject field);
 500 
 501 // method is a handle to a java.lang.reflect.Method object
 502 JNIEXPORT jbyteArray JNICALL
 503 JVM_GetMethodTypeAnnotations(JNIEnv *env, jobject method);
 504 
 505 /*
 506  * New (JDK 1.4) reflection implementation
 507  */
 508 
 509 JNIEXPORT jobjectArray JNICALL
 510 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 511 
 512 JNIEXPORT jobjectArray JNICALL
 513 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 514 
 515 JNIEXPORT jobjectArray JNICALL
 516 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 517 
 518 /* Differs from JVM_GetClassModifiers in treatment of inner classes.
 519    This returns the access flags for the class as specified in the
 520    class file rather than searching the InnerClasses attribute (if
 521    present) to find the source-level access flags. Only the values of
 522    the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
 523    valid. */
 524 JNIEXPORT jint JNICALL
 525 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);
 526 
 527 /*
 528  * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)
 529  */
 530 
 531 JNIEXPORT jobject JNICALL
 532 JVM_GetClassConstantPool(JNIEnv *env, jclass cls);
 533 
 534 JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize
 535 (JNIEnv *env, jobject obj, jobject unused);
 536 
 537 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt
 538 (JNIEnv *env, jobject obj, jobject unused, jint index);
 539 
 540 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded
 541 (JNIEnv *env, jobject obj, jobject unused, jint index);
 542 
 543 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt
 544 (JNIEnv *env, jobject obj, jobject unused, jint index);
 545 
 546 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded
 547 (JNIEnv *env, jobject obj, jobject unused, jint index);
 548 
 549 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt
 550 (JNIEnv *env, jobject obj, jobject unused, jint index);
 551 
 552 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded
 553 (JNIEnv *env, jobject obj, jobject unused, jint index);
 554 
 555 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt
 556 (JNIEnv *env, jobject obj, jobject unused, jint index);
 557 
 558 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetNameAndTypeRefInfoAt
 559 (JNIEnv *env, jobject obj, jobject unused, jint index);
 560 
 561 JNIEXPORT jint JNICALL JVM_ConstantPoolGetNameAndTypeRefIndexAt
 562 (JNIEnv *env, jobject obj, jobject unused, jint index);
 563 
 564 JNIEXPORT jint JNICALL JVM_ConstantPoolGetClassRefIndexAt
 565 (JNIEnv *env, jobject obj, jobject unused, jint index);
 566 
 567 JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt
 568 (JNIEnv *env, jobject obj, jobject unused, jint index);
 569 
 570 JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt
 571 (JNIEnv *env, jobject obj, jobject unused, jint index);
 572 
 573 JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt
 574 (JNIEnv *env, jobject obj, jobject unused, jint index);
 575 
 576 JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt
 577 (JNIEnv *env, jobject obj, jobject unused, jint index);
 578 
 579 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt
 580 (JNIEnv *env, jobject obj, jobject unused, jint index);
 581 
 582 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
 583 (JNIEnv *env, jobject obj, jobject unused, jint index);
 584 
 585 JNIEXPORT jbyte JNICALL JVM_ConstantPoolGetTagAt
 586 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 587 
 588 /*
 589  * java.security.*
 590  */
 591 
 592 JNIEXPORT jobject JNICALL
 593 JVM_DoPrivileged(JNIEnv *env, jclass cls,
 594                  jobject action, jobject context, jboolean wrapException);
 595 
 596 JNIEXPORT jobject JNICALL
 597 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);
 598 
 599 JNIEXPORT jobject JNICALL
 600 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);
 601 
 602 /*
 603  * Signal support, used to implement the shutdown sequence.  Every VM must
 604  * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts
 605  * (^C) and the latter for external termination (kill, system shutdown, etc.).
 606  * Other platform-dependent signal values may also be supported.
 607  */
 608 
 609 JNIEXPORT void * JNICALL
 610 JVM_RegisterSignal(jint sig, void *handler);
 611 
 612 JNIEXPORT jboolean JNICALL
 613 JVM_RaiseSignal(jint sig);
 614 
 615 JNIEXPORT jint JNICALL
 616 JVM_FindSignal(const char *name);
 617 
 618 /*
 619  * Retrieve the assertion directives for the specified class.
 620  */
 621 JNIEXPORT jboolean JNICALL
 622 JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls);
 623 
 624 /*
 625  * Retrieve the assertion directives from the VM.
 626  */
 627 JNIEXPORT jobject JNICALL
 628 JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);
 629 
 630 /*
 631  * java.util.concurrent.atomic.AtomicLong
 632  */
 633 JNIEXPORT jboolean JNICALL
 634 JVM_SupportsCX8(void);
 635 
 636 /*************************************************************************
 637  PART 2: Support for the Verifier and Class File Format Checker
 638  ************************************************************************/
 639 /*
 640  * Return the class name in UTF format. The result is valid
 641  * until JVM_ReleaseUTf is called.
 642  *
 643  * The caller must treat the string as a constant and not modify it
 644  * in any way.
 645  */
 646 JNIEXPORT const char * JNICALL
 647 JVM_GetClassNameUTF(JNIEnv *env, jclass cb);
 648 
 649 /*
 650  * Returns the constant pool types in the buffer provided by "types."
 651  */
 652 JNIEXPORT void JNICALL
 653 JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types);
 654 
 655 /*
 656  * Returns the number of Constant Pool entries.
 657  */
 658 JNIEXPORT jint JNICALL
 659 JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);
 660 
 661 /*
 662  * Returns the number of *declared* fields or methods.
 663  */
 664 JNIEXPORT jint JNICALL
 665 JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);
 666 
 667 JNIEXPORT jint JNICALL
 668 JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);
 669 
 670 /*
 671  * Returns the CP indexes of exceptions raised by a given method.
 672  * Places the result in the given buffer.
 673  *
 674  * The method is identified by method_index.
 675  */
 676 JNIEXPORT void JNICALL
 677 JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,
 678                                 unsigned short *exceptions);
 679 /*
 680  * Returns the number of exceptions raised by a given method.
 681  * The method is identified by method_index.
 682  */
 683 JNIEXPORT jint JNICALL
 684 JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index);
 685 
 686 /*
 687  * Returns the byte code sequence of a given method.
 688  * Places the result in the given buffer.
 689  *
 690  * The method is identified by method_index.
 691  */
 692 JNIEXPORT void JNICALL
 693 JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,
 694                         unsigned char *code);
 695 
 696 /*
 697  * Returns the length of the byte code sequence of a given method.
 698  * The method is identified by method_index.
 699  */
 700 JNIEXPORT jint JNICALL
 701 JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index);
 702 
 703 /*
 704  * A structure used to a capture exception table entry in a Java method.
 705  */
 706 typedef struct {
 707     jint start_pc;
 708     jint end_pc;
 709     jint handler_pc;
 710     jint catchType;
 711 } JVM_ExceptionTableEntryType;
 712 
 713 /*
 714  * Returns the exception table entry at entry_index of a given method.
 715  * Places the result in the given buffer.
 716  *
 717  * The method is identified by method_index.
 718  */
 719 JNIEXPORT void JNICALL
 720 JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index,
 721                                    jint entry_index,
 722                                    JVM_ExceptionTableEntryType *entry);
 723 
 724 /*
 725  * Returns the length of the exception table of a given method.
 726  * The method is identified by method_index.
 727  */
 728 JNIEXPORT jint JNICALL
 729 JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index);
 730 
 731 /*
 732  * Returns the modifiers of a given field.
 733  * The field is identified by field_index.
 734  */
 735 JNIEXPORT jint JNICALL
 736 JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index);
 737 
 738 /*
 739  * Returns the modifiers of a given method.
 740  * The method is identified by method_index.
 741  */
 742 JNIEXPORT jint JNICALL
 743 JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index);
 744 
 745 /*
 746  * Returns the number of local variables of a given method.
 747  * The method is identified by method_index.
 748  */
 749 JNIEXPORT jint JNICALL
 750 JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index);
 751 
 752 /*
 753  * Returns the number of arguments (including this pointer) of a given method.
 754  * The method is identified by method_index.
 755  */
 756 JNIEXPORT jint JNICALL
 757 JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index);
 758 
 759 /*
 760  * Returns the maximum amount of stack (in words) used by a given method.
 761  * The method is identified by method_index.
 762  */
 763 JNIEXPORT jint JNICALL
 764 JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index);
 765 
 766 /*
 767  * Is a given method a constructor.
 768  * The method is identified by method_index.
 769  */
 770 JNIEXPORT jboolean JNICALL
 771 JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index);
 772 
 773 /*
 774  * Is the given method generated by the VM.
 775  * The method is identified by method_index.
 776  */
 777 JNIEXPORT jboolean JNICALL
 778 JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cb, int index);
 779 
 780 /*
 781  * Returns the name of a given method in UTF format.
 782  * The result remains valid until JVM_ReleaseUTF is called.
 783  *
 784  * The caller must treat the string as a constant and not modify it
 785  * in any way.
 786  */
 787 JNIEXPORT const char * JNICALL
 788 JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index);
 789 
 790 /*
 791  * Returns the signature of a given method in UTF format.
 792  * The result remains valid until JVM_ReleaseUTF is called.
 793  *
 794  * The caller must treat the string as a constant and not modify it
 795  * in any way.
 796  */
 797 JNIEXPORT const char * JNICALL
 798 JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index);
 799 
 800 /*
 801  * Returns the name of the field refered to at a given constant pool
 802  * index.
 803  *
 804  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 805  * is called.
 806  *
 807  * The caller must treat the string as a constant and not modify it
 808  * in any way.
 809  */
 810 JNIEXPORT const char * JNICALL
 811 JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);
 812 
 813 /*
 814  * Returns the name of the method refered to at a given constant pool
 815  * index.
 816  *
 817  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 818  * is called.
 819  *
 820  * The caller must treat the string as a constant and not modify it
 821  * in any way.
 822  */
 823 JNIEXPORT const char * JNICALL
 824 JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);
 825 
 826 /*
 827  * Returns the signature of the method refered to at a given constant pool
 828  * index.
 829  *
 830  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 831  * is called.
 832  *
 833  * The caller must treat the string as a constant and not modify it
 834  * in any way.
 835  */
 836 JNIEXPORT const char * JNICALL
 837 JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);
 838 
 839 /*
 840  * Returns the signature of the field refered to at a given constant pool
 841  * index.
 842  *
 843  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 844  * is called.
 845  *
 846  * The caller must treat the string as a constant and not modify it
 847  * in any way.
 848  */
 849 JNIEXPORT const char * JNICALL
 850 JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);
 851 
 852 /*
 853  * Returns the class name refered to at a given constant pool 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_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index);
 863 
 864 /*
 865  * Returns the class name refered to at a given constant pool index.
 866  *
 867  * The constant pool entry must refer to a CONSTANT_Fieldref.
 868  *
 869  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 870  * is called.
 871  *
 872  * The caller must treat the string as a constant and not modify it
 873  * in any way.
 874  */
 875 JNIEXPORT const char * JNICALL
 876 JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index);
 877 
 878 /*
 879  * Returns the class name refered to at a given constant pool index.
 880  *
 881  * The constant pool entry must refer to CONSTANT_Methodref or
 882  * CONSTANT_InterfaceMethodref.
 883  *
 884  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 885  * is called.
 886  *
 887  * The caller must treat the string as a constant and not modify it
 888  * in any way.
 889  */
 890 JNIEXPORT const char * JNICALL
 891 JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index);
 892 
 893 /*
 894  * Returns the modifiers of a field in calledClass. The field is
 895  * referred to in class cb at constant pool entry index.
 896  *
 897  * The caller must treat the string as a constant and not modify it
 898  * in any way.
 899  *
 900  * Returns -1 if the field does not exist in calledClass.
 901  */
 902 JNIEXPORT jint JNICALL
 903 JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
 904 
 905 /*
 906  * Returns the modifiers of a method in calledClass. The method is
 907  * referred to in class cb at constant pool entry index.
 908  *
 909  * Returns -1 if the method does not exist in calledClass.
 910  */
 911 JNIEXPORT jint JNICALL
 912 JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
 913 
 914 /*
 915  * Releases the UTF string obtained from the VM.
 916  */
 917 JNIEXPORT void JNICALL
 918 JVM_ReleaseUTF(const char *utf);
 919 
 920 /*
 921  * Compare if two classes are in the same package.
 922  */
 923 JNIEXPORT jboolean JNICALL
 924 JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2);
 925 
 926 /* Constants in class files */
 927 
 928 #define JVM_ACC_PUBLIC        0x0001  /* visible to everyone */
 929 #define JVM_ACC_PRIVATE       0x0002  /* visible only to the defining class */
 930 #define JVM_ACC_PROTECTED     0x0004  /* visible to subclasses */
 931 #define JVM_ACC_STATIC        0x0008  /* instance variable is static */
 932 #define JVM_ACC_FINAL         0x0010  /* no further subclassing, overriding */
 933 #define JVM_ACC_SYNCHRONIZED  0x0020  /* wrap method call in monitor lock */
 934 #define JVM_ACC_SUPER         0x0020  /* funky handling of invokespecial */
 935 #define JVM_ACC_VOLATILE      0x0040  /* can not cache in registers */
 936 #define JVM_ACC_BRIDGE        0x0040  /* bridge method generated by compiler */
 937 #define JVM_ACC_TRANSIENT     0x0080  /* not persistent */
 938 #define JVM_ACC_VARARGS       0x0080  /* method declared with variable number of args */
 939 #define JVM_ACC_NATIVE        0x0100  /* implemented in C */
 940 #define JVM_ACC_INTERFACE     0x0200  /* class is an interface */
 941 #define JVM_ACC_ABSTRACT      0x0400  /* no definition provided */
 942 #define JVM_ACC_STRICT        0x0800  /* strict floating point */
 943 #define JVM_ACC_SYNTHETIC     0x1000  /* compiler-generated class, method or field */
 944 #define JVM_ACC_ANNOTATION    0x2000  /* annotation type */
 945 #define JVM_ACC_ENUM          0x4000  /* field is declared as element of enum */
 946 #define JVM_ACC_MODULE        0x8000  /* module-info class file */
 947 
 948 #define JVM_ACC_PUBLIC_BIT        0
 949 #define JVM_ACC_PRIVATE_BIT       1
 950 #define JVM_ACC_PROTECTED_BIT     2
 951 #define JVM_ACC_STATIC_BIT        3
 952 #define JVM_ACC_FINAL_BIT         4
 953 #define JVM_ACC_SYNCHRONIZED_BIT  5
 954 #define JVM_ACC_SUPER_BIT         5
 955 #define JVM_ACC_VOLATILE_BIT      6
 956 #define JVM_ACC_BRIDGE_BIT        6
 957 #define JVM_ACC_TRANSIENT_BIT     7
 958 #define JVM_ACC_VARARGS_BIT       7
 959 #define JVM_ACC_NATIVE_BIT        8
 960 #define JVM_ACC_INTERFACE_BIT     9
 961 #define JVM_ACC_ABSTRACT_BIT      10
 962 #define JVM_ACC_STRICT_BIT        11
 963 #define JVM_ACC_SYNTHETIC_BIT     12
 964 #define JVM_ACC_ANNOTATION_BIT    13
 965 #define JVM_ACC_ENUM_BIT          14
 966 
 967 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/utilities/ConstantTag.java
 968 enum {
 969     JVM_CONSTANT_Utf8 = 1,
 970     JVM_CONSTANT_Unicode,               /* unused */
 971     JVM_CONSTANT_Integer,
 972     JVM_CONSTANT_Float,
 973     JVM_CONSTANT_Long,
 974     JVM_CONSTANT_Double,
 975     JVM_CONSTANT_Class,
 976     JVM_CONSTANT_String,
 977     JVM_CONSTANT_Fieldref,
 978     JVM_CONSTANT_Methodref,
 979     JVM_CONSTANT_InterfaceMethodref,
 980     JVM_CONSTANT_NameAndType,
 981     JVM_CONSTANT_MethodHandle           = 15,  // JSR 292
 982     JVM_CONSTANT_MethodType             = 16,  // JSR 292
 983     //JVM_CONSTANT_(unused)             = 17,  // JSR 292 early drafts only
 984     JVM_CONSTANT_InvokeDynamic          = 18,  // JSR 292
 985     JVM_CONSTANT_ExternalMax            = 18   // Last tag found in classfiles
 986 };
 987 
 988 /* JVM_CONSTANT_MethodHandle subtypes */
 989 enum {
 990     JVM_REF_getField                = 1,
 991     JVM_REF_getStatic               = 2,
 992     JVM_REF_putField                = 3,
 993     JVM_REF_putStatic               = 4,
 994     JVM_REF_invokeVirtual           = 5,
 995     JVM_REF_invokeStatic            = 6,
 996     JVM_REF_invokeSpecial           = 7,
 997     JVM_REF_newInvokeSpecial        = 8,
 998     JVM_REF_invokeInterface         = 9
 999 };
1000 
1001 /* Used in the newarray instruction. */
1002 
1003 #define JVM_T_BOOLEAN 4
1004 #define JVM_T_CHAR    5
1005 #define JVM_T_FLOAT   6
1006 #define JVM_T_DOUBLE  7
1007 #define JVM_T_BYTE    8
1008 #define JVM_T_SHORT   9
1009 #define JVM_T_INT    10
1010 #define JVM_T_LONG   11
1011 
1012 /* JVM method signatures */
1013 
1014 #define JVM_SIGNATURE_ARRAY             '['
1015 #define JVM_SIGNATURE_BYTE              'B'
1016 #define JVM_SIGNATURE_CHAR              'C'
1017 #define JVM_SIGNATURE_CLASS             'L'
1018 #define JVM_SIGNATURE_ENDCLASS          ';'
1019 #define JVM_SIGNATURE_ENUM              'E'
1020 #define JVM_SIGNATURE_FLOAT             'F'
1021 #define JVM_SIGNATURE_DOUBLE            'D'
1022 #define JVM_SIGNATURE_FUNC              '('
1023 #define JVM_SIGNATURE_ENDFUNC           ')'
1024 #define JVM_SIGNATURE_INT               'I'
1025 #define JVM_SIGNATURE_LONG              'J'
1026 #define JVM_SIGNATURE_SHORT             'S'
1027 #define JVM_SIGNATURE_VOID              'V'
1028 #define JVM_SIGNATURE_BOOLEAN           'Z'
1029 
1030 /*
1031  * A function defined by the byte-code verifier and called by the VM.
1032  * This is not a function implemented in the VM.
1033  *
1034  * Returns JNI_FALSE if verification fails. A detailed error message
1035  * will be places in msg_buf, whose length is specified by buf_len.
1036  */
1037 typedef jboolean (*verifier_fn_t)(JNIEnv *env,
1038                                   jclass cb,
1039                                   char * msg_buf,
1040                                   jint buf_len);
1041 
1042 
1043 /*
1044  * Support for a VM-independent class format checker.
1045  */
1046 typedef struct {
1047     unsigned long code;    /* byte code */
1048     unsigned long excs;    /* exceptions */
1049     unsigned long etab;    /* catch table */
1050     unsigned long lnum;    /* line number */
1051     unsigned long lvar;    /* local vars */
1052 } method_size_info;
1053 
1054 typedef struct {
1055     unsigned int constants;    /* constant pool */
1056     unsigned int fields;
1057     unsigned int methods;
1058     unsigned int interfaces;
1059     unsigned int fields2;      /* number of static 2-word fields */
1060     unsigned int innerclasses; /* # of records in InnerClasses attr */
1061 
1062     method_size_info clinit;   /* memory used in clinit */
1063     method_size_info main;     /* used everywhere else */
1064 } class_size_info;
1065 
1066 /*
1067  * Functions defined in libjava.so to perform string conversions.
1068  *
1069  */
1070 
1071 typedef jstring (*to_java_string_fn_t)(JNIEnv *env, char *str);
1072 
1073 typedef char *(*to_c_string_fn_t)(JNIEnv *env, jstring s, jboolean *b);
1074 
1075 /* This is the function defined in libjava.so that performs class
1076  * format checks. This functions fills in size information about
1077  * the class file and returns:
1078  *
1079  *   0: good
1080  *  -1: out of memory
1081  *  -2: bad format
1082  *  -3: unsupported version
1083  *  -4: bad class name
1084  */
1085 
1086 typedef jint (*check_format_fn_t)(char *class_name,
1087                                   unsigned char *data,
1088                                   unsigned int data_size,
1089                                   class_size_info *class_size,
1090                                   char *message_buffer,
1091                                   jint buffer_length,
1092                                   jboolean measure_only,
1093                                   jboolean check_relaxed);
1094 
1095 #define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \
1096                                         JVM_ACC_FINAL | \
1097                                         JVM_ACC_SUPER | \
1098                                         JVM_ACC_INTERFACE | \
1099                                         JVM_ACC_ABSTRACT | \
1100                                         JVM_ACC_ANNOTATION | \
1101                                         JVM_ACC_ENUM | \
1102                                         JVM_ACC_SYNTHETIC)
1103 
1104 #define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \
1105                                         JVM_ACC_PRIVATE | \
1106                                         JVM_ACC_PROTECTED | \
1107                                         JVM_ACC_STATIC | \
1108                                         JVM_ACC_FINAL | \
1109                                         JVM_ACC_VOLATILE | \
1110                                         JVM_ACC_TRANSIENT | \
1111                                         JVM_ACC_ENUM | \
1112                                         JVM_ACC_SYNTHETIC)
1113 
1114 #define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \
1115                                          JVM_ACC_PRIVATE | \
1116                                          JVM_ACC_PROTECTED | \
1117                                          JVM_ACC_STATIC | \
1118                                          JVM_ACC_FINAL | \
1119                                          JVM_ACC_SYNCHRONIZED | \
1120                                          JVM_ACC_BRIDGE | \
1121                                          JVM_ACC_VARARGS | \
1122                                          JVM_ACC_NATIVE | \
1123                                          JVM_ACC_ABSTRACT | \
1124                                          JVM_ACC_STRICT | \
1125                                          JVM_ACC_SYNTHETIC)
1126 
1127 /*
1128  * This is the function defined in libjava.so to perform path
1129  * canonicalization. VM call this function before opening jar files
1130  * to load system classes.
1131  *
1132  */
1133 
1134 typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len);
1135 
1136 /*************************************************************************
1137  PART 3: I/O and Network Support
1138  ************************************************************************/
1139 
1140 /*
1141  * Convert a pathname into native format.  This function does syntactic
1142  * cleanup, such as removing redundant separator characters.  It modifies
1143  * the given pathname string in place.
1144  */
1145 JNIEXPORT char * JNICALL
1146 JVM_NativePath(char *);
1147 
1148 /*
1149  * The standard printing functions supported by the Java VM. (Should they
1150  * be renamed to JVM_* in the future?
1151  */
1152 
1153 /* jio_snprintf() and jio_vsnprintf() behave like snprintf(3) and vsnprintf(3),
1154  *  respectively, with the following differences:
1155  * - The string written to str is always zero-terminated, also in case of
1156  *   truncation (count is too small to hold the result string), unless count
1157  *   is 0. In case of truncation count-1 characters are written and '\0'
1158  *   appendend.
1159  * - If count is too small to hold the whole string, -1 is returned across
1160  *   all platforms. */
1161 JNIEXPORT int
1162 jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
1163 
1164 JNIEXPORT int
1165 jio_snprintf(char *str, size_t count, const char *fmt, ...);
1166 
1167 JNIEXPORT int
1168 jio_fprintf(FILE *, const char *fmt, ...);
1169 
1170 JNIEXPORT int
1171 jio_vfprintf(FILE *, const char *fmt, va_list args);
1172 
1173 
1174 JNIEXPORT void * JNICALL
1175 JVM_RawMonitorCreate(void);
1176 
1177 JNIEXPORT void JNICALL
1178 JVM_RawMonitorDestroy(void *mon);
1179 
1180 JNIEXPORT jint JNICALL
1181 JVM_RawMonitorEnter(void *mon);
1182 
1183 JNIEXPORT void JNICALL
1184 JVM_RawMonitorExit(void *mon);
1185 
1186 /*
1187  * java.lang.reflect.Method
1188  */
1189 JNIEXPORT jobject JNICALL
1190 JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0);
1191 
1192 /*
1193  * java.lang.reflect.Constructor
1194  */
1195 JNIEXPORT jobject JNICALL
1196 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);
1197 
1198 /*
1199  * java.lang.management support
1200  */
1201 JNIEXPORT void* JNICALL
1202 JVM_GetManagement(jint version);
1203 
1204 /*
1205  * com.sun.tools.attach.VirtualMachine support
1206  *
1207  * Initialize the agent properties with the properties maintained in the VM.
1208  */
1209 JNIEXPORT jobject JNICALL
1210 JVM_InitAgentProperties(JNIEnv *env, jobject agent_props);
1211 
1212 JNIEXPORT jstring JNICALL
1213 JVM_GetTemporaryDirectory(JNIEnv *env);
1214 
1215 /* Generics reflection support.
1216  *
1217  * Returns information about the given class's EnclosingMethod
1218  * attribute, if present, or null if the class had no enclosing
1219  * method.
1220  *
1221  * If non-null, the returned array contains three elements. Element 0
1222  * is the java.lang.Class of which the enclosing method is a member,
1223  * and elements 1 and 2 are the java.lang.Strings for the enclosing
1224  * method's name and descriptor, respectively.
1225  */
1226 JNIEXPORT jobjectArray JNICALL
1227 JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);
1228 
1229 /* =========================================================================
1230  * The following defines a private JVM interface that the JDK can query
1231  * for the JVM version and capabilities.  sun.misc.Version defines
1232  * the methods for getting the VM version and its capabilities.
1233  *
1234  * When a new bit is added, the following should be updated to provide
1235  * access to the new capability:
1236  *    HS:   JVM_GetVersionInfo and Abstract_VM_Version class
1237  *    SDK:  Version class
1238  *
1239  * Similary, a private JDK interface JDK_GetVersionInfo0 is defined for
1240  * JVM to query for the JDK version and capabilities.
1241  *
1242  * When a new bit is added, the following should be updated to provide
1243  * access to the new capability:
1244  *    HS:   JDK_Version class
1245  *    SDK:  JDK_GetVersionInfo0
1246  *
1247  * ==========================================================================
1248  */
1249 typedef struct {
1250     unsigned int jvm_version; /* Encoded $VNUM as defined by JEP-223 */
1251     unsigned int patch_version : 8; /* JEP-223 patch version */
1252     unsigned int reserved3 : 8;
1253     unsigned int reserved1 : 16;
1254     unsigned int reserved2;
1255 
1256     /* The following bits represents JVM supports that JDK has dependency on.
1257      * JDK can use these bits to determine which JVM version
1258      * and support it has to maintain runtime compatibility.
1259      *
1260      * When a new bit is added in a minor or update release, make sure
1261      * the new bit is also added in the main/baseline.
1262      */
1263     unsigned int is_attachable : 1;
1264     unsigned int : 31;
1265     unsigned int : 32;
1266     unsigned int : 32;
1267 } jvm_version_info;
1268 
1269 #define JVM_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
1270 #define JVM_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
1271 #define JVM_VERSION_SECURITY(version) ((version & 0x0000FF00) >> 8)
1272 #define JVM_VERSION_BUILD(version) ((version & 0x000000FF))
1273 
1274 JNIEXPORT void JNICALL
1275 JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size);
1276 
1277 typedef struct {
1278     unsigned int jdk_version; /* Encoded $VNUM as defined by JEP-223 */
1279     unsigned int patch_version : 8; /* JEP-223 patch version */
1280     unsigned int reserved3 : 8;
1281     unsigned int reserved1 : 16;
1282     unsigned int reserved2;
1283 
1284     /* The following bits represents new JDK supports that VM has dependency on.
1285      * VM implementation can use these bits to determine which JDK version
1286      * and support it has to maintain runtime compatibility.
1287      *
1288      * When a new bit is added in a minor or update release, make sure
1289      * the new bit is also added in the main/baseline.
1290      */
1291     unsigned int thread_park_blocker : 1;
1292     unsigned int post_vm_init_hook_enabled : 1;
1293     unsigned int pending_list_uses_discovered_field : 1;
1294     unsigned int : 29;
1295     unsigned int : 32;
1296     unsigned int : 32;
1297 } jdk_version_info;
1298 
1299 #define JDK_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
1300 #define JDK_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
1301 #define JDK_VERSION_SECURITY(version) ((version & 0x0000FF00) >> 8)
1302 #define JDK_VERSION_BUILD(version) ((version & 0x000000FF))
1303 
1304 /*
1305  * This is the function JDK_GetVersionInfo0 defined in libjava.so
1306  * that is dynamically looked up by JVM.
1307  */
1308 typedef void (*jdk_version_info_fn_t)(jdk_version_info* info, size_t info_size);
1309 
1310 /*
1311  * This structure is used by the launcher to get the default thread
1312  * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a
1313  * version of 1.1.  As it is not supported otherwise, it has been removed
1314  * from jni.h
1315  */
1316 typedef struct JDK1_1InitArgs {
1317     jint version;
1318 
1319     char **properties;
1320     jint checkSource;
1321     jint nativeStackSize;
1322     jint javaStackSize;
1323     jint minHeapSize;
1324     jint maxHeapSize;
1325     jint verifyMode;
1326     char *classpath;
1327 
1328     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
1329     void (JNICALL *exit)(jint code);
1330     void (JNICALL *abort)(void);
1331 
1332     jint enableClassGC;
1333     jint enableVerboseGC;
1334     jint disableAsyncGC;
1335     jint verbose;
1336     jboolean debugging;
1337     jint debugPort;
1338 } JDK1_1InitArgs;
1339 
1340 #ifdef __cplusplus
1341 } /* extern "C" */
1342 #endif /* __cplusplus */
1343 
1344 #endif /* !_JAVASOFT_JVM_H_ */
1345 
1346 #endif // SHARE_VM_PRIMS_JVM_H
--- EOF ---