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