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