1 /*
   2  * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #ifndef _JAVASOFT_JVM_H_
  27 #define _JAVASOFT_JVM_H_
  28 
  29 #include <sys/stat.h>
  30 
  31 #include "jni.h"
  32 #include "jvm_md.h"
  33 #include "jvm_constants.h"
  34 #include "jvm_io.h"
  35 
  36 #ifdef __cplusplus
  37 extern "C" {
  38 #endif
  39 
  40 /*
  41  * This file contains additional functions exported from the VM.
  42  * These functions are complementary to the standard JNI support.
  43  * There are three parts to this file:
  44  *
  45  * First, this file contains the VM-related functions needed by native
  46  * libraries in the standard Java API. For example, the java.lang.Object
  47  * class needs VM-level functions that wait for and notify monitors.
  48  *
  49  * Second, (included from jvm_constants.h) constant definitions
  50  * needed by the byte code verifier and class file format checker.
  51  * These definitions allow the verifier and format checker to be written
  52  * in a VM-independent way.
  53  *
  54  * Third, this file contains various I/O and network operations needed
  55  * by the standard Java I/O and network APIs. A part of these APIs,
  56  * namely the jio_xxxprintf functions, are included from jvm_io.h.
  57  */
  58 
  59 
  60 /*************************************************************************
  61  PART 1: Functions for Native Libraries
  62  ************************************************************************/
  63 /*
  64  * java.lang.Object
  65  */
  66 JNIEXPORT jint JNICALL
  67 JVM_IHashCode(JNIEnv *env, jobject obj);
  68 
  69 JNIEXPORT void JNICALL
  70 JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms);
  71 
  72 JNIEXPORT void JNICALL
  73 JVM_MonitorNotify(JNIEnv *env, jobject obj);
  74 
  75 JNIEXPORT void JNICALL
  76 JVM_MonitorNotifyAll(JNIEnv *env, jobject obj);
  77 
  78 JNIEXPORT jobject JNICALL
  79 JVM_Clone(JNIEnv *env, jobject obj);
  80 
  81 /*
  82  * java.lang.String
  83  */
  84 JNIEXPORT jstring JNICALL
  85 JVM_InternString(JNIEnv *env, jstring str);
  86 
  87 /*
  88  * java.lang.System
  89  */
  90 JNIEXPORT jlong JNICALL
  91 JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored);
  92 
  93 JNIEXPORT jlong JNICALL
  94 JVM_NanoTime(JNIEnv *env, jclass ignored);
  95 
  96 JNIEXPORT jlong JNICALL
  97 JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs);
  98 
  99 JNIEXPORT void JNICALL
 100 JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
 101               jobject dst, jint dst_pos, jint length);
 102 
 103 /*
 104  * Return an array of all properties as alternating name and value pairs.
 105  */
 106 JNIEXPORT jobjectArray JNICALL
 107 JVM_GetProperties(JNIEnv *env);
 108 
 109 /*
 110  * java.lang.Runtime
 111  */
 112 JNIEXPORT void JNICALL
 113 JVM_BeforeHalt();
 114 
 115 JNIEXPORT void JNICALL
 116 JVM_Halt(jint code);
 117 
 118 JNIEXPORT void JNICALL
 119 JVM_GC(void);
 120 
 121 /* Returns the number of real-time milliseconds that have elapsed since the
 122  * least-recently-inspected heap object was last inspected by the garbage
 123  * collector.
 124  *
 125  * For simple stop-the-world collectors this value is just the time
 126  * since the most recent collection.  For generational collectors it is the
 127  * time since the oldest generation was most recently collected.  Other
 128  * collectors are free to return a pessimistic estimate of the elapsed time, or
 129  * simply the time since the last full collection was performed.
 130  *
 131  * Note that in the presence of reference objects, a given object that is no
 132  * longer strongly reachable may have to be inspected multiple times before it
 133  * can be reclaimed.
 134  */
 135 JNIEXPORT jlong JNICALL
 136 JVM_MaxObjectInspectionAge(void);
 137 
 138 JNIEXPORT jlong JNICALL
 139 JVM_TotalMemory(void);
 140 
 141 JNIEXPORT jlong JNICALL
 142 JVM_FreeMemory(void);
 143 
 144 JNIEXPORT jlong JNICALL
 145 JVM_MaxMemory(void);
 146 
 147 JNIEXPORT jint JNICALL
 148 JVM_ActiveProcessorCount(void);
 149 
 150 JNIEXPORT jboolean JNICALL
 151 JVM_IsUseContainerSupport(void);
 152 
 153 JNIEXPORT void * JNICALL
 154 JVM_LoadZipLibrary();
 155 
 156 JNIEXPORT void * JNICALL
 157 JVM_LoadLibrary(const char *name, jboolean throwException);
 158 
 159 JNIEXPORT void JNICALL
 160 JVM_UnloadLibrary(void * handle);
 161 
 162 JNIEXPORT void * JNICALL
 163 JVM_FindLibraryEntry(void *handle, const char *name);
 164 
 165 JNIEXPORT jboolean JNICALL
 166 JVM_IsSupportedJNIVersion(jint version);
 167 
 168 JNIEXPORT jobjectArray JNICALL
 169 JVM_GetVmArguments(JNIEnv *env);
 170 
 171 JNIEXPORT jboolean JNICALL
 172 JVM_IsPreviewEnabled(void);
 173 
 174 JNIEXPORT jboolean JNICALL
 175 JVM_IsContinuationsSupported(void);
 176 
 177 JNIEXPORT jboolean JNICALL
 178 JVM_IsForeignLinkerSupported(void);
 179 
 180 JNIEXPORT void JNICALL
 181 JVM_InitializeFromArchive(JNIEnv* env, jclass cls);
 182 
 183 JNIEXPORT void JNICALL
 184 JVM_RegisterLambdaProxyClassForArchiving(JNIEnv* env, jclass caller,
 185                                          jstring interfaceMethodName,
 186                                          jobject factoryType,
 187                                          jobject interfaceMethodType,
 188                                          jobject implementationMember,
 189                                          jobject dynamicMethodType,
 190                                          jclass lambdaProxyClass);
 191 
 192 JNIEXPORT jclass JNICALL
 193 JVM_LookupLambdaProxyClassFromArchive(JNIEnv* env, jclass caller,
 194                                       jstring interfaceMethodName,
 195                                       jobject factoryType,
 196                                       jobject interfaceMethodType,
 197                                       jobject implementationMember,
 198                                       jobject dynamicMethodType);
 199 
 200 JNIEXPORT jboolean JNICALL
 201 JVM_IsCDSDumpingEnabled(JNIEnv* env);
 202 
 203 JNIEXPORT jboolean JNICALL
 204 JVM_IsSharingEnabled(JNIEnv* env);
 205 
 206 JNIEXPORT jboolean JNICALL
 207 JVM_IsDumpingClassList(JNIEnv* env);
 208 
 209 JNIEXPORT jlong JNICALL
 210 JVM_GetRandomSeedForDumping();
 211 
 212 JNIEXPORT void JNICALL
 213 JVM_LogLambdaFormInvoker(JNIEnv* env, jstring line);
 214 
 215 JNIEXPORT void JNICALL
 216 JVM_DumpClassListToFile(JNIEnv* env, jstring fileName);
 217 
 218 JNIEXPORT void JNICALL
 219 JVM_DumpDynamicArchive(JNIEnv* env, jstring archiveName);
 220 
 221 /*
 222  * java.lang.Throwable
 223  */
 224 JNIEXPORT void JNICALL
 225 JVM_FillInStackTrace(JNIEnv *env, jobject throwable);
 226 
 227 /*
 228  * java.lang.StackTraceElement
 229  */
 230 JNIEXPORT void JNICALL
 231 JVM_InitStackTraceElementArray(JNIEnv *env, jobjectArray elements, jobject backtrace, jint depth);
 232 
 233 JNIEXPORT void JNICALL
 234 JVM_InitStackTraceElement(JNIEnv* env, jobject element, jobject stackFrameInfo);
 235 
 236 /*
 237  * java.lang.NullPointerException
 238  */
 239 
 240 JNIEXPORT jstring JNICALL
 241 JVM_GetExtendedNPEMessage(JNIEnv *env, jthrowable throwable);
 242 
 243 /*
 244  * java.lang.StackWalker
 245  */
 246 enum {
 247   JVM_STACKWALK_CLASS_INFO_ONLY            = 0x2,
 248   JVM_STACKWALK_SHOW_HIDDEN_FRAMES         = 0x20,
 249   JVM_STACKWALK_FILL_LIVE_STACK_FRAMES     = 0x100
 250 };
 251 
 252 JNIEXPORT void JNICALL
 253 JVM_ExpandStackFrameInfo(JNIEnv *env, jobject obj);
 254 
 255 JNIEXPORT jobject JNICALL
 256 JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode,
 257                   jint skip_frames, jobject contScope, jobject cont,
 258                   jint buffer_size, jint start_index, jobjectArray frames);
 259 
 260 JNIEXPORT jint JNICALL
 261 JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, jlong anchor,
 262                   jint last_batch_count, jint buffer_size, jint start_index,
 263                   jobjectArray frames);
 264 
 265 JNIEXPORT void JNICALL
 266 JVM_SetStackWalkContinuation(JNIEnv *env, jobject stackStream, jlong anchor, jobjectArray frames, jobject cont);
 267 
 268 /*
 269  * java.lang.Thread
 270  */
 271 JNIEXPORT void JNICALL
 272 JVM_StartThread(JNIEnv *env, jobject thread);
 273 
 274 JNIEXPORT void JNICALL
 275 JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio);
 276 
 277 JNIEXPORT void JNICALL
 278 JVM_Yield(JNIEnv *env, jclass threadClass);
 279 
 280 JNIEXPORT void JNICALL
 281 JVM_SleepNanos(JNIEnv *env, jclass threadClass, jlong nanos);
 282 
 283 JNIEXPORT jobject JNICALL
 284 JVM_CurrentCarrierThread(JNIEnv *env, jclass threadClass);
 285 
 286 JNIEXPORT jobject JNICALL
 287 JVM_CurrentThread(JNIEnv *env, jclass threadClass);
 288 
 289 JNIEXPORT void JNICALL
 290 JVM_SetCurrentThread(JNIEnv *env, jobject thisThread, jobject theThread);
 291 
 292 JNIEXPORT void JNICALL
 293 JVM_Interrupt(JNIEnv *env, jobject thread);
 294 
 295 JNIEXPORT jboolean JNICALL
 296 JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj);
 297 
 298 JNIEXPORT jobject JNICALL
 299 JVM_GetStackTrace(JNIEnv *env, jobject thread);
 300 
 301 JNIEXPORT void JNICALL
 302 JVM_DumpAllStacks(JNIEnv *env, jclass unused);
 303 
 304 JNIEXPORT jobjectArray JNICALL
 305 JVM_GetAllThreads(JNIEnv *env, jclass dummy);
 306 
 307 JNIEXPORT void JNICALL
 308 JVM_SetNativeThreadName(JNIEnv *env, jobject jthread, jstring name);
 309 
 310 /* getStackTrace() and getAllStackTraces() method */
 311 JNIEXPORT jobjectArray JNICALL
 312 JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);
 313 
 314 JNIEXPORT jobject JNICALL
 315 JVM_ScopedValueCache(JNIEnv *env, jclass threadClass);
 316 
 317 JNIEXPORT void JNICALL
 318 JVM_SetScopedValueCache(JNIEnv *env, jclass threadClass, jobject theCache);
 319 
 320 JNIEXPORT jobject JNICALL
 321 JVM_FindScopedValueBindings(JNIEnv *env, jclass threadClass);
 322 
 323 JNIEXPORT jlong JNICALL
 324 JVM_GetNextThreadIdOffset(JNIEnv *env, jclass threadClass);
 325 
 326 /*
 327  * jdk.internal.vm.Continuation
 328  */
 329 JNIEXPORT void JNICALL
 330 JVM_RegisterContinuationMethods(JNIEnv *env, jclass cls);
 331 
 332 /*
 333  * java.lang.SecurityManager
 334  */
 335 JNIEXPORT jobjectArray JNICALL
 336 JVM_GetClassContext(JNIEnv *env);
 337 
 338 /*
 339  * java.lang.Package
 340  */
 341 JNIEXPORT jstring JNICALL
 342 JVM_GetSystemPackage(JNIEnv *env, jstring name);
 343 
 344 JNIEXPORT jobjectArray JNICALL
 345 JVM_GetSystemPackages(JNIEnv *env);
 346 
 347 /*
 348  * java.lang.ref.Reference
 349  */
 350 JNIEXPORT jobject JNICALL
 351 JVM_GetAndClearReferencePendingList(JNIEnv *env);
 352 
 353 JNIEXPORT jboolean JNICALL
 354 JVM_HasReferencePendingList(JNIEnv *env);
 355 
 356 JNIEXPORT void JNICALL
 357 JVM_WaitForReferencePendingList(JNIEnv *env);
 358 
 359 JNIEXPORT jboolean JNICALL
 360 JVM_ReferenceRefersTo(JNIEnv *env, jobject ref, jobject o);
 361 
 362 JNIEXPORT void JNICALL
 363 JVM_ReferenceClear(JNIEnv *env, jobject ref);
 364 
 365 /*
 366  * java.lang.ref.PhantomReference
 367  */
 368 JNIEXPORT jboolean JNICALL
 369 JVM_PhantomReferenceRefersTo(JNIEnv *env, jobject ref, jobject o);
 370 
 371 /*
 372  * java.io.ObjectInputStream
 373  */
 374 JNIEXPORT jobject JNICALL
 375 JVM_LatestUserDefinedLoader(JNIEnv *env);
 376 
 377 /*
 378  * java.lang.reflect.Array
 379  */
 380 JNIEXPORT jint JNICALL
 381 JVM_GetArrayLength(JNIEnv *env, jobject arr);
 382 
 383 JNIEXPORT jobject JNICALL
 384 JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index);
 385 
 386 JNIEXPORT jvalue JNICALL
 387 JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode);
 388 
 389 JNIEXPORT void JNICALL
 390 JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val);
 391 
 392 JNIEXPORT void JNICALL
 393 JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v,
 394                              unsigned char vCode);
 395 
 396 JNIEXPORT jobject JNICALL
 397 JVM_NewArray(JNIEnv *env, jclass eltClass, jint length);
 398 
 399 JNIEXPORT jobject JNICALL
 400 JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim);
 401 
 402 
 403 /*
 404  * Returns the immediate caller class of the native method invoking
 405  * JVM_GetCallerClass.  The Method.invoke and other frames due to
 406  * reflection machinery are skipped.
 407  *
 408  * The caller is expected to be marked with
 409  * jdk.internal.reflect.CallerSensitive. The JVM will throw an
 410  * error if it is not marked properly.
 411  */
 412 JNIEXPORT jclass JNICALL
 413 JVM_GetCallerClass(JNIEnv *env);
 414 
 415 
 416 /*
 417  * Find primitive classes
 418  * utf: class name
 419  */
 420 JNIEXPORT jclass JNICALL
 421 JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);
 422 
 423 
 424 /*
 425  * Find a class from a boot class loader. Returns NULL if class not found.
 426  */
 427 JNIEXPORT jclass JNICALL
 428 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name);
 429 
 430 /*
 431  * Find a class from a given class loader.  Throws ClassNotFoundException.
 432  *  name:   name of class
 433  *  init:   whether initialization is done
 434  *  loader: class loader to look up the class. This may not be the same as the caller's
 435  *          class loader.
 436  *  caller: initiating class. The initiating class may be null when a security
 437  *          manager is not installed.
 438  */
 439 JNIEXPORT jclass JNICALL
 440 JVM_FindClassFromCaller(JNIEnv *env, const char *name, jboolean init,
 441                         jobject loader, jclass caller);
 442 
 443 /*
 444  * Find a class from a given class.
 445  */
 446 JNIEXPORT jclass JNICALL
 447 JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,
 448                              jclass from);
 449 
 450 /* Find a loaded class cached by the VM */
 451 JNIEXPORT jclass JNICALL
 452 JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);
 453 
 454 /* Define a class */
 455 JNIEXPORT jclass JNICALL
 456 JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
 457                 jsize len, jobject pd);
 458 
 459 /* Define a class with a source (added in JDK1.5) */
 460 JNIEXPORT jclass JNICALL
 461 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
 462                           const jbyte *buf, jsize len, jobject pd,
 463                           const char *source);
 464 
 465 /*
 466  * Define a class with the specified lookup class.
 467  *  lookup:  Lookup class
 468  *  name:    the name of the class
 469  *  buf:     class bytes
 470  *  len:     length of class bytes
 471  *  pd:      protection domain
 472  *  init:    initialize the class
 473  *  flags:   properties of the class
 474  *  classData: private static pre-initialized field; may be null
 475  */
 476 JNIEXPORT jclass JNICALL
 477 JVM_LookupDefineClass(JNIEnv *env, jclass lookup, const char *name, const jbyte *buf,
 478                       jsize len, jobject pd, jboolean init, int flags, jobject classData);
 479 
 480 /*
 481  * Module support functions
 482  */
 483 
 484 /*
 485  * Define a module with the specified packages and bind the module to the
 486  * given class loader.
 487  *  module:       module to define
 488  *  is_open:      specifies if module is open (currently ignored)
 489  *  version:      the module version
 490  *  location:     the module location
 491  *  packages:     array of packages in the module
 492  */
 493 JNIEXPORT void JNICALL
 494 JVM_DefineModule(JNIEnv *env, jobject module, jboolean is_open, jstring version,
 495                  jstring location, jobjectArray packages);
 496 
 497 /*
 498  * Set the boot loader's unnamed module.
 499  *  module: boot loader's unnamed module
 500  */
 501 JNIEXPORT void JNICALL
 502 JVM_SetBootLoaderUnnamedModule(JNIEnv *env, jobject module);
 503 
 504 /*
 505  * Do a qualified export of a package.
 506  *  from_module: module containing the package to export
 507  *  package:     name of the package to export
 508  *  to_module:   module to export the package to
 509  */
 510 JNIEXPORT void JNICALL
 511 JVM_AddModuleExports(JNIEnv *env, jobject from_module, jstring package, jobject to_module);
 512 
 513 /*
 514  * Do an export of a package to all unnamed modules.
 515  *  from_module: module containing the package to export
 516  *  package:     name of the package to export to all unnamed modules
 517  */
 518 JNIEXPORT void JNICALL
 519 JVM_AddModuleExportsToAllUnnamed(JNIEnv *env, jobject from_module, jstring package);
 520 
 521 /*
 522  * Do an unqualified export of a package.
 523  *  from_module: module containing the package to export
 524  *  package:     name of the package to export
 525  */
 526 JNIEXPORT void JNICALL
 527 JVM_AddModuleExportsToAll(JNIEnv *env, jobject from_module, jstring package);
 528 
 529 /*
 530  * Add a module to the list of modules that a given module can read.
 531  *  from_module:   module requesting read access
 532  *  source_module: module that from_module wants to read
 533  */
 534 JNIEXPORT void JNICALL
 535 JVM_AddReadsModule(JNIEnv *env, jobject from_module, jobject source_module);
 536 
 537 /*
 538  * Define all modules that have been stored in the CDS archived heap.
 539  *  platform_loader: the built-in platform class loader
 540  *  system_loader:   the built-in system class loader
 541  */
 542 JNIEXPORT void JNICALL
 543 JVM_DefineArchivedModules(JNIEnv *env, jobject platform_loader, jobject system_loader);
 544 
 545 /*
 546  * Reflection support functions
 547  */
 548 
 549 JNIEXPORT jstring JNICALL
 550 JVM_InitClassName(JNIEnv *env, jclass cls);
 551 
 552 JNIEXPORT jobjectArray JNICALL
 553 JVM_GetClassInterfaces(JNIEnv *env, jclass cls);
 554 
 555 JNIEXPORT jboolean JNICALL
 556 JVM_IsInterface(JNIEnv *env, jclass cls);
 557 
 558 JNIEXPORT jobjectArray JNICALL
 559 JVM_GetClassSigners(JNIEnv *env, jclass cls);
 560 
 561 JNIEXPORT void JNICALL
 562 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);
 563 
 564 JNIEXPORT jobject JNICALL
 565 JVM_GetProtectionDomain(JNIEnv *env, jclass cls);
 566 
 567 JNIEXPORT jboolean JNICALL
 568 JVM_IsArrayClass(JNIEnv *env, jclass cls);
 569 
 570 JNIEXPORT jboolean JNICALL
 571 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);
 572 
 573 JNIEXPORT jboolean JNICALL
 574 JVM_IsHiddenClass(JNIEnv *env, jclass cls);
 575 
 576 JNIEXPORT jint JNICALL
 577 JVM_GetClassModifiers(JNIEnv *env, jclass cls);
 578 
 579 JNIEXPORT jobjectArray JNICALL
 580 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);
 581 
 582 JNIEXPORT jclass JNICALL
 583 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);
 584 
 585 JNIEXPORT jstring JNICALL
 586 JVM_GetSimpleBinaryName(JNIEnv *env, jclass ofClass);
 587 
 588 /* Generics support (JDK 1.5) */
 589 JNIEXPORT jstring JNICALL
 590 JVM_GetClassSignature(JNIEnv *env, jclass cls);
 591 
 592 /* Annotations support (JDK 1.5) */
 593 JNIEXPORT jbyteArray JNICALL
 594 JVM_GetClassAnnotations(JNIEnv *env, jclass cls);
 595 
 596 /* Type use annotations support (JDK 1.8) */
 597 
 598 JNIEXPORT jbyteArray JNICALL
 599 JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls);
 600 
 601 JNIEXPORT jbyteArray JNICALL
 602 JVM_GetFieldTypeAnnotations(JNIEnv *env, jobject field);
 603 
 604 JNIEXPORT jbyteArray JNICALL
 605 JVM_GetMethodTypeAnnotations(JNIEnv *env, jobject method);
 606 
 607 /*
 608  * New (JDK 1.4) reflection implementation
 609  */
 610 
 611 JNIEXPORT jobjectArray JNICALL
 612 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 613 
 614 JNIEXPORT jobjectArray JNICALL
 615 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 616 
 617 JNIEXPORT jobjectArray JNICALL
 618 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);
 619 
 620 
 621 /* Differs from JVM_GetClassModifiers in treatment of inner classes.
 622    This returns the access flags for the class as specified in the
 623    class file rather than searching the InnerClasses attribute (if
 624    present) to find the source-level access flags. Only the values of
 625    the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
 626    valid. */
 627 JNIEXPORT jint JNICALL
 628 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);
 629 
 630 /* Nestmates - since JDK 11 */
 631 
 632 JNIEXPORT jboolean JNICALL
 633 JVM_AreNestMates(JNIEnv *env, jclass current, jclass member);
 634 
 635 JNIEXPORT jclass JNICALL
 636 JVM_GetNestHost(JNIEnv *env, jclass current);
 637 
 638 JNIEXPORT jobjectArray JNICALL
 639 JVM_GetNestMembers(JNIEnv *env, jclass current);
 640 
 641 /* Records - since JDK 16 */
 642 
 643 JNIEXPORT jboolean JNICALL
 644 JVM_IsRecord(JNIEnv *env, jclass cls);
 645 
 646 JNIEXPORT jobjectArray JNICALL
 647 JVM_GetRecordComponents(JNIEnv *env, jclass ofClass);
 648 
 649 /* Sealed classes - since JDK 17 */
 650 
 651 JNIEXPORT jobjectArray JNICALL
 652 JVM_GetPermittedSubclasses(JNIEnv *env, jclass current);
 653 
 654 /* The following two reflection routines are still needed due to startup time issues */
 655 /*
 656  * java.lang.reflect.Method
 657  */
 658 JNIEXPORT jobject JNICALL
 659 JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0);
 660 
 661 /*
 662  * java.lang.reflect.Constructor
 663  */
 664 JNIEXPORT jobject JNICALL
 665 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);
 666 
 667 /*
 668  * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)
 669  */
 670 
 671 JNIEXPORT jobject JNICALL
 672 JVM_GetClassConstantPool(JNIEnv *env, jclass cls);
 673 
 674 JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize
 675 (JNIEnv *env, jobject unused, jobject jcpool);
 676 
 677 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt
 678 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 679 
 680 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded
 681 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 682 
 683 JNIEXPORT jint JNICALL JVM_ConstantPoolGetClassRefIndexAt
 684 (JNIEnv *env, jobject obj, jobject unused, jint index);
 685 
 686 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt
 687 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 688 
 689 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded
 690 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 691 
 692 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt
 693 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 694 
 695 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded
 696 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 697 
 698 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt
 699 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 700 
 701 JNIEXPORT jint JNICALL JVM_ConstantPoolGetNameAndTypeRefIndexAt
 702 (JNIEnv *env, jobject obj, jobject unused, jint index);
 703 
 704 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetNameAndTypeRefInfoAt
 705 (JNIEnv *env, jobject obj, jobject unused, jint index);
 706 
 707 JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt
 708 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 709 
 710 JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt
 711 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 712 
 713 JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt
 714 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 715 
 716 JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt
 717 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 718 
 719 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt
 720 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 721 
 722 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
 723 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 724 
 725 JNIEXPORT jbyte JNICALL JVM_ConstantPoolGetTagAt
 726 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
 727 
 728 /*
 729  * Parameter reflection
 730  */
 731 
 732 JNIEXPORT jobjectArray JNICALL
 733 JVM_GetMethodParameters(JNIEnv *env, jobject method);
 734 
 735 /*
 736  * java.security.*
 737  */
 738 
 739 JNIEXPORT jobject JNICALL
 740 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);
 741 
 742 /*
 743  * Ensure that code doing a stackwalk and using javaVFrame::locals() to
 744  * get the value will see a materialized value and not a scalar-replaced
 745  * null value.
 746  */
 747 #define JVM_EnsureMaterializedForStackWalk(env, value) \
 748     do {} while(0) // Nothing to do.  The fact that the value escaped
 749                    // through a native method is enough.
 750 JNIEXPORT void JNICALL
 751 JVM_EnsureMaterializedForStackWalk_func(JNIEnv* env, jobject vthread, jobject value);
 752 
 753 JNIEXPORT jobject JNICALL
 754 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);
 755 
 756 /*
 757  * Signal support, used to implement the shutdown sequence.  Every VM must
 758  * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts
 759  * (^C) and the latter for external termination (kill, system shutdown, etc.).
 760  * Other platform-dependent signal values may also be supported.
 761  */
 762 
 763 JNIEXPORT void * JNICALL
 764 JVM_RegisterSignal(jint sig, void *handler);
 765 
 766 JNIEXPORT jboolean JNICALL
 767 JVM_RaiseSignal(jint sig);
 768 
 769 JNIEXPORT jint JNICALL
 770 JVM_FindSignal(const char *name);
 771 
 772 /*
 773  * Retrieve the assertion directives for the specified class.
 774  */
 775 JNIEXPORT jboolean JNICALL
 776 JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls);
 777 
 778 /*
 779  * Retrieve the assertion directives from the VM.
 780  */
 781 JNIEXPORT jobject JNICALL
 782 JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);
 783 
 784 /*
 785  * java.util.concurrent.atomic.AtomicLong
 786  */
 787 JNIEXPORT jboolean JNICALL
 788 JVM_SupportsCX8(void);
 789 
 790 /*
 791  * java.lang.ref.Finalizer
 792  */
 793 JNIEXPORT void JNICALL
 794 JVM_ReportFinalizationComplete(JNIEnv *env, jobject finalizee);
 795 
 796 JNIEXPORT jboolean JNICALL
 797 JVM_IsFinalizationEnabled(JNIEnv *env);
 798 
 799 /*************************************************************************
 800  PART 2: Support for the Verifier and Class File Format Checker
 801  ************************************************************************/
 802 /*
 803  * Return the class name in UTF format. The result is valid
 804  * until JVM_ReleaseUTf is called.
 805  *
 806  * The caller must treat the string as a constant and not modify it
 807  * in any way.
 808  */
 809 JNIEXPORT const char * JNICALL
 810 JVM_GetClassNameUTF(JNIEnv *env, jclass cb);
 811 
 812 /*
 813  * Returns the constant pool types in the buffer provided by "types."
 814  */
 815 JNIEXPORT void JNICALL
 816 JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types);
 817 
 818 /*
 819  * Returns the number of Constant Pool entries.
 820  */
 821 JNIEXPORT jint JNICALL
 822 JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);
 823 
 824 /*
 825  * Returns the number of *declared* fields or methods.
 826  */
 827 JNIEXPORT jint JNICALL
 828 JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);
 829 
 830 JNIEXPORT jint JNICALL
 831 JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);
 832 
 833 /*
 834  * Returns the CP indexes of exceptions raised by a given method.
 835  * Places the result in the given buffer.
 836  *
 837  * The method is identified by method_index.
 838  */
 839 JNIEXPORT void JNICALL
 840 JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,
 841                                 unsigned short *exceptions);
 842 /*
 843  * Returns the number of exceptions raised by a given method.
 844  * The method is identified by method_index.
 845  */
 846 JNIEXPORT jint JNICALL
 847 JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index);
 848 
 849 /*
 850  * Returns the byte code sequence of a given method.
 851  * Places the result in the given buffer.
 852  *
 853  * The method is identified by method_index.
 854  */
 855 JNIEXPORT void JNICALL
 856 JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,
 857                         unsigned char *code);
 858 
 859 /*
 860  * Returns the length of the byte code sequence of a given method.
 861  * The method is identified by method_index.
 862  */
 863 JNIEXPORT jint JNICALL
 864 JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index);
 865 
 866 /*
 867  * A structure used to a capture exception table entry in a Java method.
 868  */
 869 typedef struct {
 870     jint start_pc;
 871     jint end_pc;
 872     jint handler_pc;
 873     jint catchType;
 874 } JVM_ExceptionTableEntryType;
 875 
 876 /*
 877  * Returns the exception table entry at entry_index of a given method.
 878  * Places the result in the given buffer.
 879  *
 880  * The method is identified by method_index.
 881  */
 882 JNIEXPORT void JNICALL
 883 JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index,
 884                                    jint entry_index,
 885                                    JVM_ExceptionTableEntryType *entry);
 886 
 887 /*
 888  * Returns the length of the exception table of a given method.
 889  * The method is identified by method_index.
 890  */
 891 JNIEXPORT jint JNICALL
 892 JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index);
 893 
 894 /*
 895  * Returns the modifiers of a given field.
 896  * The field is identified by field_index.
 897  */
 898 JNIEXPORT jint JNICALL
 899 JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index);
 900 
 901 /*
 902  * Returns the modifiers of a given method.
 903  * The method is identified by method_index.
 904  */
 905 JNIEXPORT jint JNICALL
 906 JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index);
 907 
 908 /*
 909  * Returns the number of local variables of a given method.
 910  * The method is identified by method_index.
 911  */
 912 JNIEXPORT jint JNICALL
 913 JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index);
 914 
 915 /*
 916  * Returns the number of arguments (including this pointer) of a given method.
 917  * The method is identified by method_index.
 918  */
 919 JNIEXPORT jint JNICALL
 920 JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index);
 921 
 922 /*
 923  * Returns the maximum amount of stack (in words) used by a given method.
 924  * The method is identified by method_index.
 925  */
 926 JNIEXPORT jint JNICALL
 927 JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index);
 928 
 929 /*
 930  * Is a given method a constructor.
 931  * The method is identified by method_index.
 932  */
 933 JNIEXPORT jboolean JNICALL
 934 JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index);
 935 
 936 /*
 937  * Is the given method generated by the VM.
 938  * The method is identified by method_index.
 939  */
 940 JNIEXPORT jboolean JNICALL
 941 JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cb, int index);
 942 
 943 /*
 944  * Returns the name of a given method in UTF format.
 945  * The result remains valid until JVM_ReleaseUTF 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_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index);
 952 
 953 /*
 954  * Returns the signature of a given method in UTF format.
 955  * The result remains valid until JVM_ReleaseUTF is called.
 956  *
 957  * The caller must treat the string as a constant and not modify it
 958  * in any way.
 959  */
 960 JNIEXPORT const char * JNICALL
 961 JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index);
 962 
 963 /*
 964  * Returns the name of the field referred to at a given constant pool
 965  * index.
 966  *
 967  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 968  * is called.
 969  *
 970  * The caller must treat the string as a constant and not modify it
 971  * in any way.
 972  */
 973 JNIEXPORT const char * JNICALL
 974 JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);
 975 
 976 /*
 977  * Returns the name of the method referred to at a given constant pool
 978  * index.
 979  *
 980  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 981  * is called.
 982  *
 983  * The caller must treat the string as a constant and not modify it
 984  * in any way.
 985  */
 986 JNIEXPORT const char * JNICALL
 987 JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);
 988 
 989 /*
 990  * Returns the signature of the method referred to at a given constant pool
 991  * index.
 992  *
 993  * The result is in UTF format and remains valid until JVM_ReleaseUTF
 994  * is called.
 995  *
 996  * The caller must treat the string as a constant and not modify it
 997  * in any way.
 998  */
 999 JNIEXPORT const char * JNICALL
1000 JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);
1001 
1002 /*
1003  * Returns the signature of the field referred to at a given constant pool
1004  * index.
1005  *
1006  * The result is in UTF format and remains valid until JVM_ReleaseUTF
1007  * is called.
1008  *
1009  * The caller must treat the string as a constant and not modify it
1010  * in any way.
1011  */
1012 JNIEXPORT const char * JNICALL
1013 JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);
1014 
1015 /*
1016  * Returns the class name referred to at a given constant pool index.
1017  *
1018  * The result is in UTF format and remains valid until JVM_ReleaseUTF
1019  * is called.
1020  *
1021  * The caller must treat the string as a constant and not modify it
1022  * in any way.
1023  */
1024 JNIEXPORT const char * JNICALL
1025 JVM_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index);
1026 
1027 /*
1028  * Returns the class name referred to at a given constant pool index.
1029  *
1030  * The constant pool entry must refer to a CONSTANT_Fieldref.
1031  *
1032  * The result is in UTF format and remains valid until JVM_ReleaseUTF
1033  * is called.
1034  *
1035  * The caller must treat the string as a constant and not modify it
1036  * in any way.
1037  */
1038 JNIEXPORT const char * JNICALL
1039 JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index);
1040 
1041 /*
1042  * Returns the class name referred to at a given constant pool index.
1043  *
1044  * The constant pool entry must refer to CONSTANT_Methodref or
1045  * CONSTANT_InterfaceMethodref.
1046  *
1047  * The result is in UTF format and remains valid until JVM_ReleaseUTF
1048  * is called.
1049  *
1050  * The caller must treat the string as a constant and not modify it
1051  * in any way.
1052  */
1053 JNIEXPORT const char * JNICALL
1054 JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index);
1055 
1056 /*
1057  * Returns the modifiers of a field in calledClass. The field is
1058  * referred to in class cb at constant pool entry index.
1059  *
1060  * The caller must treat the string as a constant and not modify it
1061  * in any way.
1062  *
1063  * Returns -1 if the field does not exist in calledClass.
1064  */
1065 JNIEXPORT jint JNICALL
1066 JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
1067 
1068 /*
1069  * Returns the modifiers of a method in calledClass. The method is
1070  * referred to in class cb at constant pool entry index.
1071  *
1072  * Returns -1 if the method does not exist in calledClass.
1073  */
1074 JNIEXPORT jint JNICALL
1075 JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
1076 
1077 /*
1078  * Releases the UTF string obtained from the VM.
1079  */
1080 JNIEXPORT void JNICALL
1081 JVM_ReleaseUTF(const char *utf);
1082 
1083 /*
1084  * Compare if two classes are in the same package.
1085  */
1086 JNIEXPORT jboolean JNICALL
1087 JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2);
1088 
1089 
1090 /*************************************************************************
1091  PART 3: I/O and Network Support
1092  ************************************************************************/
1093 
1094 /*
1095  * Convert a pathname into native format.  This function does syntactic
1096  * cleanup, such as removing redundant separator characters.  It modifies
1097  * the given pathname string in place.
1098  */
1099 JNIEXPORT char * JNICALL
1100 JVM_NativePath(char *);
1101 
1102 JNIEXPORT void * JNICALL
1103 JVM_RawMonitorCreate(void);
1104 
1105 JNIEXPORT void JNICALL
1106 JVM_RawMonitorDestroy(void *mon);
1107 
1108 JNIEXPORT jint JNICALL
1109 JVM_RawMonitorEnter(void *mon);
1110 
1111 JNIEXPORT void JNICALL
1112 JVM_RawMonitorExit(void *mon);
1113 
1114 /*
1115  * java.lang.management support
1116  */
1117 JNIEXPORT void* JNICALL
1118 JVM_GetManagement(jint version);
1119 
1120 /*
1121  * com.sun.tools.attach.VirtualMachine support
1122  *
1123  * Initialize the agent properties with the properties maintained in the VM.
1124  */
1125 JNIEXPORT jobject JNICALL
1126 JVM_InitAgentProperties(JNIEnv *env, jobject agent_props);
1127 
1128 JNIEXPORT jstring JNICALL
1129 JVM_GetTemporaryDirectory(JNIEnv *env);
1130 
1131 /* Generics reflection support.
1132  *
1133  * Returns information about the given class's EnclosingMethod
1134  * attribute, if present, or null if the class had no enclosing
1135  * method.
1136  *
1137  * If non-null, the returned array contains three elements. Element 0
1138  * is the java.lang.Class of which the enclosing method is a member,
1139  * and elements 1 and 2 are the java.lang.Strings for the enclosing
1140  * method's name and descriptor, respectively.
1141  */
1142 JNIEXPORT jobjectArray JNICALL
1143 JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);
1144 
1145 /*
1146  * Virtual thread support.
1147  */
1148 JNIEXPORT void JNICALL
1149 JVM_VirtualThreadStart(JNIEnv* env, jobject vthread);
1150 
1151 JNIEXPORT void JNICALL
1152 JVM_VirtualThreadEnd(JNIEnv* env, jobject vthread);
1153 
1154 JNIEXPORT void JNICALL
1155 JVM_VirtualThreadMount(JNIEnv* env, jobject vthread, jboolean hide);
1156 
1157 JNIEXPORT void JNICALL
1158 JVM_VirtualThreadUnmount(JNIEnv* env, jobject vthread, jboolean hide);
1159 
1160 JNIEXPORT void JNICALL
1161 JVM_VirtualThreadHideFrames(JNIEnv* env, jobject vthread, jboolean hide);
1162 
1163 /*
1164  * Core reflection support.
1165  */
1166 JNIEXPORT jint JNICALL
1167 JVM_GetClassFileVersion(JNIEnv *env, jclass current);
1168 
1169 /*
1170  * Return JNI_TRUE if warnings are printed when agents are dynamically loaded.
1171  */
1172 JNIEXPORT jboolean JNICALL
1173 JVM_PrintWarningAtDynamicAgentLoad(void);
1174 
1175 /*
1176  * This structure is used by the launcher to get the default thread
1177  * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a
1178  * version of 1.1.  As it is not supported otherwise, it has been removed
1179  * from jni.h
1180  */
1181 typedef struct JDK1_1InitArgs {
1182     jint version;
1183 
1184     char **properties;
1185     jint checkSource;
1186     jint nativeStackSize;
1187     jint javaStackSize;
1188     jint minHeapSize;
1189     jint maxHeapSize;
1190     jint verifyMode;
1191     char *classpath;
1192 
1193     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
1194     void (JNICALL *exit)(jint code);
1195     void (JNICALL *abort)(void);
1196 
1197     jint enableClassGC;
1198     jint enableVerboseGC;
1199     jint disableAsyncGC;
1200     jint verbose;
1201     jboolean debugging;
1202     jint debugPort;
1203 } JDK1_1InitArgs;
1204 
1205 
1206 #ifdef __cplusplus
1207 } /* extern "C" */
1208 
1209 #endif /* __cplusplus */
1210 
1211 #endif /* !_JAVASOFT_JVM_H_ */