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