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