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