CoCalc -- j9vm31.h

GitHub Repository: PojavLauncherTeam/openj9
Path: blob/master/runtime/j9vm31/j9vm31.h
⁵⁹⁸⁵ views
1
/*******************************************************************************
2
 * Copyright (c) 2021, 2021 IBM Corp. and others
3
 *
4
 * This program and the accompanying materials are made available under
5
 * the terms of the Eclipse Public License 2.0 which accompanies this
6
 * distribution and is available at https://www.eclipse.org/legal/epl-2.0/
7
 * or the Apache License, Version 2.0 which accompanies this distribution and
8
 * is available at https://www.apache.org/licenses/LICENSE-2.0.
9
 *
10
 * This Source Code may also be made available under the following
11
 * Secondary Licenses when the conditions for such availability set
12
 * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU
13
 * General Public License, version 2 with the GNU Classpath
14
 * Exception [1] and GNU General Public License, version 2 with the
15
 * OpenJDK Assembly Exception [2].
16
 *
17
 * [1] https://www.gnu.org/software/classpath/license.html
18
 * [2] http://openjdk.java.net/legal/assembly-exception.html
19
 *
20
 * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
21
 *******************************************************************************/
22

23
#ifndef j9vm31_h
24
#define j9vm31_h
25

26
#include <stdint.h>
27
#include <stddef.h>
28
#include <stdlib.h>
29

30
#include "j9cel4ro64.h"
31
#include "jni.h"
32
#include "j9cfg.h"
33

34
/* High tag bits to signify 31-bit function handles that are passed to 64-bit. */
35
#define HANDLE31_HIGHTAG 0x31000000
36

37
/* Macro to look up 64-bit function descriptors from JNINativeInterface_. */
38
#define FUNCTION_DESCRIPTOR_FROM_JNIENV31(jniEnv, functionX) \
39
		jlong functionDescriptor = ((JNIEnv31 *)jniEnv)->functions64[offsetof(struct JNINativeInterface_, functionX) / sizeof(intptr_t)]; \
40
		j9vm31TrcJNIMethodEntry(jniEnv, #functionX);
41

42
/* Utility macros to extract corresponding 64-bit handle. */
43
#define JNIENV64_FROM_JNIENV31(jniEnv) ((JNIEnv31 *)jniEnv)->jniEnv64
44
#define JAVAVM64_FROM_JAVAVM31(javaVM) ((JavaVM31 *)javaVM)->javaVM64
45

46
/* We need to do DLL query on libjvm.so (sidecar redirector), which will load the appropriate VM module. */
47
#define LIBJVM_NAME "libjvm.so"
48
#define LIBJ9VM29_NAME "libj9vm29.so"
49

50
#ifdef __cplusplus
51
extern "C" {
52
#endif
53

54
/* A 31-bit JavaVM struct, instances of which are used by 31-bit native code.
55
 * Each instance should always have a matching 64-bit JavaVM * isntance from the JVM.
56
 */
57
typedef struct JavaVM31 {
58
	struct JNIInvokeInterface_ *functions;
59
	void *reserved0;
60
	void *reserved1;
61
	void *reserved2;
62
	JavaVM31 *next;             /**< Next JavaVM31 instance in global list. */
63
	jlong javaVM64;             /**< Handle to corresponding 64-bit JavaVM* instance from JVM. */
64
	const jlong *functions64;   /**< Reference to 64-bit JNIInvokeInterface_ function descriptors to invoke. */
65
} JavaVM31;
66

67
/* A 31-bit JNIEnv struct, instances of which are used by 31-bit native code.
68
 * Each instance should always have a matching 64-bit JNIEnv * isntance from the JVM.
69
 */
70
typedef struct JNIEnv31 {
71
	struct JNINativeInterface_ *functions;
72
	void *reserved0;
73
	void *reserved1[6];
74
	JavaVM31 *javaVM31;         /**< A handle to the matching JavaVM31 instance. */
75
	JNIEnv31 *next;             /**< Next JNIEnv31 instance in global list. */
76
	jlong jniEnv64;             /**< Handle to corresponding 64-bit JNIEnv* instance from JVM. */
77
	const jlong *functions64;   /**< Reference to 64-bit JNINativeInterface_ function descriptors to invoke. */
78
} JNIEnv31;
79

80
/**
81
 * Typedefs to wrap the arguments of a va_list to the 64-bit representation.
82
 * The actual parameter data itself is still in 31-bit, and those are interpreted on
83
 * the 64-bit side with recognition that they are being invoked by 31-bit caller, as
84
 * the parameters interpretation require understanding of the specifiers from the
85
 * method signature.
86
 */
87
typedef char  *___valist64[4];    // 64-bit uses char *[2].
88
typedef ___valist64  va_list_64;
89

90
/**
91
 * A helper function that can be also invoked by 64-bit JVM to return the respective 31-bit
92
 * JavaVM instance for the given 64-bit JavaVM reference. When invoked by the JVM, this
93
 * allows 64-bit JVM to directly invoke 31-bit target functions passing a valid 31-bit JavaVM*
94
 * parameter.
95
 *
96
 * @param[in] JavaVM64Ptr The 64-bit JavaVM reference.
97
 *
98
 * @return The 31-bit corresponding JavaVM instance.
99
 */
100
JavaVM31 *
101
JNICALL getJavaVM31(uint64_t JavaVM64Ptr);
102

103
/**
104
 * A helper function that can be also invoked by 64-bit JVM to return the respective 31-bit
105
 * JNIEnv instance for the given 64-bit JNIEnv reference. When invoked by the JVM, this
106
 * allows 64-bit JVM to directly invoke 31-bit target functions passing a valid 31-bit JNIEnv*
107
 * parameter.
108
 *
109
 * @param[in] JNIEnv64Ptr The 64-bit JNIEnv reference.
110
 *
111
 * @return The 31-bit corresponding JNIEnv instance.
112
 */
113
JNIEnv31 *
114
JNICALL getJNIEnv31(uint64_t JNIEnv64Ptr);
115

116
/**
117
 * A debugging routine that outputs method entry statements to stderr. While there
118
 * are trace points in 64-bit JVM for most of the JNI methods, this routine
119
 * supports diagnostics on 31-bit side.
120
 * @Todo: Should consider how to improve this RAS support.
121
 *
122
 * @param[in] JNIEnv The 31-bit JNIEnv instance.
123
 * @param[in] functionName The JNI function to invoke.
124
 */
125
void
126
j9vm31TrcJNIMethodEntry(JNIEnv* env, const char *functionName);
127

128
/* The Java Invocation API functions that the shim library will implement. */
129
jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *);
130
jint JNICALL JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *vm_args);
131
jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
132
jint JNICALL DestroyJavaVM(JavaVM *vm);
133
jint JNICALL AttachCurrentThread(JavaVM *vm, void **penv, void *args);
134
jint JNICALL DetachCurrentThread(JavaVM *vm);
135
jint JNICALL GetEnv(JavaVM *vm, void **penv, jint version);
136
jint JNICALL AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *args);
137

138
/* The Java Native Interface API functions that the shim library will implement. */
139
jint JNICALL GetVersion(JNIEnv *env);
140
jclass JNICALL DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize bufLen);
141
jclass JNICALL FindClass(JNIEnv *env, const char *name);
142
jmethodID JNICALL FromReflectedMethod(JNIEnv *env, jobject method);
143
jfieldID JNICALL FromReflectedField(JNIEnv *env, jobject field);
144
jobject JNICALL ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
145
jclass JNICALL GetSuperclass(JNIEnv *env, jclass clazz);
146
jboolean JNICALL IsAssignableFrom(JNIEnv *env, jclass clazz1, jclass clazz2);
147
jobject JNICALL ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
148
jint JNICALL Throw(JNIEnv *env, jthrowable obj);
149
jint JNICALL ThrowNew(JNIEnv *env, jclass clazz, const char *message);
150
jthrowable JNICALL ExceptionOccurred(JNIEnv *env);
151
void JNICALL ExceptionDescribe(JNIEnv *env);
152
void JNICALL ExceptionClear(JNIEnv *env);
153
void JNICALL FatalError(JNIEnv *env, const char *msg);
154
jint JNICALL PushLocalFrame(JNIEnv *env, jint capacity);
155
jobject JNICALL PopLocalFrame(JNIEnv *env, jobject result);
156
jobject JNICALL NewGlobalRef(JNIEnv *env, jobject obj);
157
void JNICALL DeleteGlobalRef(JNIEnv *env, jobject gref);
158
void JNICALL DeleteLocalRef(JNIEnv *env, jobject localRef);
159
jboolean JNICALL IsSameObject(JNIEnv *env, jobject ref1, jobject ref2);
160
jobject JNICALL NewLocalRef(JNIEnv *env, jobject ref);
161
jint JNICALL EnsureLocalCapacity(JNIEnv *env, jint capacity);
162
jobject JNICALL AllocObject(JNIEnv *env, jclass clazz);
163
jobject JNICALL NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
164
jobject JNICALL NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
165
jobject JNICALL NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
166
jclass JNICALL GetObjectClass(JNIEnv *env, jobject obj);
167
jboolean JNICALL IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz);
168
jmethodID JNICALL GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
169
jobject JNICALL CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
170
jobject JNICALL CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
171
jobject JNICALL CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
172
jboolean JNICALL CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
173
jboolean JNICALL CallBooleanMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
174
jboolean JNICALL CallBooleanMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
175
jbyte JNICALL CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
176
jbyte JNICALL CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
177
jbyte JNICALL CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
178
jchar JNICALL CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
179
jchar JNICALL CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
180
jchar JNICALL CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
181
jshort JNICALL CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
182
jshort JNICALL CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
183
jshort JNICALL CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
184
jint JNICALL CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
185
jint JNICALL CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
186
jint JNICALL CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
187
jlong JNICALL CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
188
jlong JNICALL CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
189
jlong JNICALL CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
190
jfloat JNICALL CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
191
jfloat JNICALL CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
192
jfloat JNICALL CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
193
jdouble JNICALL CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
194
jdouble JNICALL CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
195
jdouble JNICALL CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
196
void JNICALL CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...);
197
void JNICALL CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
198
void JNICALL CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
199
jobject JNICALL CallNonvirtualObjectMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
200
jobject JNICALL CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
201
jobject JNICALL CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
202
jboolean JNICALL CallNonvirtualBooleanMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
203
jboolean JNICALL CallNonvirtualBooleanMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
204
jboolean JNICALL CallNonvirtualBooleanMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
205
jbyte JNICALL CallNonvirtualByteMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
206
jbyte JNICALL CallNonvirtualByteMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
207
jbyte JNICALL CallNonvirtualByteMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
208
jchar JNICALL CallNonvirtualCharMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
209
jchar JNICALL CallNonvirtualCharMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
210
jchar JNICALL CallNonvirtualCharMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
211
jshort JNICALL CallNonvirtualShortMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
212
jshort JNICALL CallNonvirtualShortMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
213
jshort JNICALL CallNonvirtualShortMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
214
jint JNICALL CallNonvirtualIntMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
215
jint JNICALL CallNonvirtualIntMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
216
jint JNICALL CallNonvirtualIntMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
217
jlong JNICALL CallNonvirtualLongMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
218
jlong JNICALL CallNonvirtualLongMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
219
jlong JNICALL CallNonvirtualLongMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
220
jfloat JNICALL CallNonvirtualFloatMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
221
jfloat JNICALL CallNonvirtualFloatMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
222
jfloat JNICALL CallNonvirtualFloatMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
223
jdouble JNICALL CallNonvirtualDoubleMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
224
jdouble JNICALL CallNonvirtualDoubleMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
225
jdouble JNICALL CallNonvirtualDoubleMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
226
void JNICALL CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
227
void JNICALL CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
228
void JNICALL CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
229
jfieldID JNICALL GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
230
jobject JNICALL GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID);
231
jboolean JNICALL GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID);
232
jbyte JNICALL GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID);
233
jchar JNICALL GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID);
234
jshort JNICALL GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID);
235
jint JNICALL GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID);
236
jlong JNICALL GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID);
237
jfloat JNICALL GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID);
238
jdouble JNICALL GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID);
239
void JNICALL SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value);
240
void JNICALL SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value);
241
void JNICALL SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value);
242
void JNICALL SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value);
243
void JNICALL SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value);
244
void JNICALL SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value);
245
void JNICALL SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value);
246
void JNICALL SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value);
247
void JNICALL SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value);
248
jmethodID JNICALL GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
249
jobject JNICALL CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
250
jobject JNICALL CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
251
jobject JNICALL CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
252
jboolean JNICALL CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
253
jboolean JNICALL CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
254
jboolean JNICALL CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
255
jbyte JNICALL CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
256
jbyte JNICALL CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
257
jbyte JNICALL CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
258
jchar JNICALL CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
259
jchar JNICALL CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
260
jchar JNICALL CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
261
jshort JNICALL CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
262
jshort JNICALL CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
263
jshort JNICALL CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
264
jint JNICALL CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
265
jint JNICALL CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
266
jint JNICALL CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
267
jlong JNICALL CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
268
jlong JNICALL CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
269
jlong JNICALL CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
270
jfloat JNICALL CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
271
jfloat JNICALL CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
272
jfloat JNICALL CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
273
jdouble JNICALL CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
274
jdouble JNICALL CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
275
jdouble JNICALL CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
276
void JNICALL CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
277
void JNICALL CallStaticVoidMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
278
void JNICALL CallStaticVoidMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args);
279
jfieldID JNICALL GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
280
jobject JNICALL GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID);
281
jboolean JNICALL GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID);
282
jbyte JNICALL GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID);
283
jchar JNICALL GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID);
284
jshort JNICALL GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID);
285
jint JNICALL GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID);
286
jlong JNICALL GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID);
287
jfloat JNICALL GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID);
288
jdouble JNICALL GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID);
289
void JNICALL SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
290
void JNICALL SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
291
void JNICALL SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
292
void JNICALL SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
293
void JNICALL SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
294
void JNICALL SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
295
void JNICALL SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
296
void JNICALL SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
297
void JNICALL SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
298
jstring JNICALL NewString(JNIEnv *env, const jchar *unicodeChars, jsize len);
299
jsize JNICALL GetStringLength(JNIEnv *env, jstring string);
300
const jchar *JNICALL GetStringChars(JNIEnv *env, jstring string, jboolean *isCopy);
301
void JNICALL ReleaseStringChars(JNIEnv *env, jstring string, const jchar *utf);
302
jstring JNICALL NewStringUTF(JNIEnv *env, const char *bytes);
303
jsize JNICALL GetStringUTFLength(JNIEnv *env, jstring string);
304
const char* JNICALL GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy);
305
void JNICALL ReleaseStringUTFChars(JNIEnv *env, jstring string, const char* utf);
306
jsize JNICALL GetArrayLength(JNIEnv *env, jarray array);
307
jobjectArray JNICALL NewObjectArray(JNIEnv *env, jsize length, jclass clazz, jobject initialElement);
308
jobject JNICALL GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index);
309
void JNICALL SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value);
310
jbooleanArray JNICALL NewBooleanArray(JNIEnv *env, jsize length);
311
jbyteArray JNICALL NewByteArray(JNIEnv *env, jsize length);
312
jcharArray JNICALL NewCharArray(JNIEnv *env, jsize length);
313
jshortArray JNICALL NewShortArray(JNIEnv *env, jsize length);
314
jintArray JNICALL NewIntArray(JNIEnv *env, jsize length);
315
jlongArray JNICALL NewLongArray(JNIEnv *env, jsize length);
316
jfloatArray JNICALL NewFloatArray(JNIEnv *env, jsize length);
317
jdoubleArray JNICALL NewDoubleArray(JNIEnv *env, jsize length);
318
void * JNICALL getArrayElements(JNIEnv *env, jdoubleArray array, jboolean *isCopy);
319
void JNICALL releaseArrayElements(JNIEnv *env, jarray array, void *elems, jint mode);
320
void JNICALL getArrayRegion(JNIEnv *env, jarray array, jsize start, jsize len, void *buf);
321
void JNICALL setArrayRegion(JNIEnv *env, jarray array, jsize start, jsize len, void *buf);
322
jint JNICALL RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods);
323
jint JNICALL UnregisterNatives(JNIEnv *env, jclass clazz);
324
jint JNICALL MonitorEnter(JNIEnv *env, jobject obj);
325
jint JNICALL MonitorExit(JNIEnv *env, jobject obj);
326
jint JNICALL GetJavaVM(JNIEnv *env, JavaVM **vm);
327
void JNICALL GetStringRegion(JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
328
void JNICALL GetStringUTFRegion(JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
329
jweak JNICALL NewWeakGlobalRef(JNIEnv *env, jobject obj);
330
void JNICALL DeleteWeakGlobalRef(JNIEnv *env, jweak obj);
331
jboolean JNICALL ExceptionCheck(JNIEnv *env);
332
jobject JNICALL NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity);
333
void * JNICALL GetDirectBufferAddress(JNIEnv *env, jobject buf);
334
jlong JNICALL GetDirectBufferCapacity(JNIEnv *env, jobject buf);
335
jobjectRefType JNICALL GetObjectRefType(JNIEnv* env, jobject obj);
336
#if JAVA_SPEC_VERSION >= 9
337
jobject JNICALL GetModule(JNIEnv *env, jclass clazz);
338
#endif /* JAVA_SPEC_VERSION >= 9 */
339

340
/* The JNI convert functions that the shim library will implement. */
341
jint JNICALL GetStringPlatform(JNIEnv* env, jstring instr, char* outstr, jint outlen, const char* encoding);
342
jint JNICALL GetStringPlatformLength(JNIEnv* env, jstring instr, jint* outlen, const char* encoding);
343
jint JNICALL NewStringPlatform(JNIEnv* env, const char* instr, jstring* outstr, const char* encoding);
344

345
#ifdef __cplusplus
346
}
347
#endif
348

349
#endif /* j9vm31_h */
350

351
Product

Resources

Company
