1 /*
2 * Copyright (c) 1999, 2019, 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_JVMCI_JVMCIENV_HPP
26 #define SHARE_JVMCI_JVMCIENV_HPP
27
28 #include "classfile/javaClasses.hpp"
29 #include "jvmci/jvmciJavaClasses.hpp"
30 #include "runtime/thread.hpp"
31
32 class CompileTask;
33 class JVMCIObject;
34 class JVMCIObjectArray;
35 class JVMCIPrimitiveArray;
36 class JVMCICompiler;
37 class JVMCIRuntime;
38
39 // Bring the JVMCI compiler thread into the VM state.
40 #define JVMCI_VM_ENTRY_MARK \
41 JavaThread* thread = JavaThread::current(); \
42 ThreadInVMfromNative __tiv(thread); \
43 ResetNoHandleMark rnhm; \
44 HandleMarkCleaner __hm(thread); \
45 Thread* THREAD = thread; \
46 debug_only(VMNativeEntryWrapper __vew;)
47
48 #define JVMCI_EXCEPTION_CONTEXT \
49 JavaThread* thread=JavaThread::current(); \
50 Thread* THREAD = thread;
51
52 // Helper to log more context on a JNI exception
53 #define JVMCI_EXCEPTION_CHECK(env, ...) \
54 do { \
55 if (env->ExceptionCheck()) { \
56 if (env != JavaThread::current()->jni_environment() && JVMCIEnv::get_shared_library_path() != NULL) { \
57 tty->print_cr("In JVMCI shared library (%s):", JVMCIEnv::get_shared_library_path()); \
58 } \
59 tty->print_cr(__VA_ARGS__); \
60 return; \
61 } \
62 } while(0)
63
64 // Helper class to ensure that references to Klass* are kept alive for G1
65 class JVMCIKlassHandle : public StackObj {
66 private:
67 Klass* _klass;
68 Handle _holder;
69 Thread* _thread;
70
71 Klass* klass() const { return _klass; }
72 Klass* non_null_klass() const { assert(_klass != NULL, "resolving NULL _klass"); return _klass; }
73
74 public:
75 /* Constructors */
76 JVMCIKlassHandle (Thread* thread) : _klass(NULL), _thread(thread) {}
77 JVMCIKlassHandle (Thread* thread, Klass* klass);
78
79 JVMCIKlassHandle (const JVMCIKlassHandle &h): _klass(h._klass), _holder(h._holder), _thread(h._thread) {}
80 JVMCIKlassHandle& operator=(const JVMCIKlassHandle &s);
81 JVMCIKlassHandle& operator=(Klass* klass);
82
83 /* Operators for ease of use */
84 Klass* operator () () const { return klass(); }
85 Klass* operator -> () const { return non_null_klass(); }
86
87 bool operator == (Klass* o) const { return klass() == o; }
88 bool operator == (const JVMCIKlassHandle& h) const { return klass() == h.klass(); }
89
90 /* Null checks */
91 bool is_null() const { return _klass == NULL; }
92 bool not_null() const { return _klass != NULL; }
93 };
94
95 // A class that maintains the state needed for compilations requested
96 // by the CompileBroker. It is created in the broker and passed through
97 // into the code installation step.
98 class JVMCICompileState : public ResourceObj {
99 friend class VMStructs;
100 private:
101 CompileTask* _task;
102 int _system_dictionary_modification_counter;
103
104 // Cache JVMTI state. Defined as bytes so that reading them from Java
105 // via Unsafe is well defined (the C++ type for bool is implementation
106 // defined and may not be the same as a Java boolean).
107 jbyte _jvmti_can_hotswap_or_post_breakpoint;
108 jbyte _jvmti_can_access_local_variables;
109 jbyte _jvmti_can_post_on_exceptions;
110 jbyte _jvmti_can_pop_frame;
111
112 // Compilation result values.
113 bool _retryable;
114 const char* _failure_reason;
115
116 // Specifies if _failure_reason is on the C heap. If so, it is allocated
117 // with the mtJVMCI NMT flag.
118 bool _failure_reason_on_C_heap;
119
120 public:
121 JVMCICompileState(CompileTask* task, int system_dictionary_modification_counter);
122
123 CompileTask* task() { return _task; }
124
125 int system_dictionary_modification_counter() { return _system_dictionary_modification_counter; }
126 bool jvmti_state_changed() const;
127 bool jvmti_can_hotswap_or_post_breakpoint() const { return _jvmti_can_hotswap_or_post_breakpoint != 0; }
128 bool jvmti_can_access_local_variables() const { return _jvmti_can_access_local_variables != 0; }
129 bool jvmti_can_post_on_exceptions() const { return _jvmti_can_post_on_exceptions != 0; }
130 bool jvmti_can_pop_frame() const { return _jvmti_can_pop_frame != 0; }
131
132 const char* failure_reason() { return _failure_reason; }
133 bool failure_reason_on_C_heap() { return _failure_reason_on_C_heap; }
134 bool retryable() { return _retryable; }
135
136 void set_failure(bool retryable, const char* reason, bool reason_on_C_heap = false) {
137 _failure_reason = reason;
138 _failure_reason_on_C_heap = reason_on_C_heap;
139 _retryable = retryable;
140 }
141 };
142
143
144 // This class is a top level wrapper around interactions between HotSpot
145 // and the JVMCI Java code. It supports both a HotSpot heap based
146 // runtime with HotSpot oop based accessors as well as a shared library
147 // based runtime that is accessed through JNI. It abstracts away all
148 // interactions with JVMCI objects so that a single version of the
149 // HotSpot C++ code can can work with either runtime.
150 class JVMCIEnv : public ResourceObj {
151 friend class JNIAccessMark;
152
153 static char* _shared_library_path; // argument to os:dll_load
154 static void* _shared_library_handle; // result of os::dll_load
155 static JavaVM* _shared_library_javavm; // result of calling JNI_CreateJavaVM in shared library
156
157 // Attaches the current thread to the JavaVM in the shared library,
158 // initializing the shared library VM first if necessary.
159 // Returns the JNI interface pointer of the current thread.
160 // The _shared_library_* fields are initialized by the first
161 // call to this method.
162 static JNIEnv* attach_shared_library();
163
164 // Initializes the _env, _mode and _runtime fields.
165 void init_env_mode_runtime(JNIEnv* parent_env);
166
167 void init(bool is_hotspot, const char* file, int line);
168
169 JNIEnv* _env; // JNI env for calling into shared library
170 JVMCIRuntime* _runtime; // Access to a HotSpotJVMCIRuntime
171 bool _is_hotspot; // Which heap is the HotSpotJVMCIRuntime in
172 bool _throw_to_caller; // Propagate an exception raised in this env to the caller?
173 const char* _file; // The file and ...
174 int _line; // ... line where this JNIEnv was created
175
176 // Translates an exception on the HotSpot heap to an exception on
177 // the shared library heap. The translation includes the stack and
178 // causes of `throwable`. The translated exception is pending in the
179 // shared library thread upon returning.
180 void translate_hotspot_exception_to_jni_exception(JavaThread* THREAD, const Handle& throwable);
181
182 public:
183 // Opens a JVMCIEnv scope for a Java to VM call (e.g., via CompilerToVM).
184 // An exception occurring within the scope is left pending when the
185 // scope closes so that it will be propagated back to Java.
186 // The JVMCIEnv destructor translates the exception object for the
187 // Java runtime if necessary.
188 JVMCIEnv(JNIEnv* env, const char* file, int line);
189
190 // Opens a JVMCIEnv scope for a compilation scheduled by the CompileBroker.
191 // An exception occurring within the scope must not be propagated back to
192 // the CompileBroker.
193 JVMCIEnv(JVMCICompileState* compile_state, const char* file, int line);
194
195 // Opens a JNIEnv scope for a call from within the VM. An exception occurring
196 // within the scope must not be propagated back to the caller.
197 JVMCIEnv(JavaThread* env, const char* file, int line);
198
199 // Opens a JNIEnv scope for accessing `for_object`. An exception occurring
200 // within the scope must not be propagated back to the caller.
201 JVMCIEnv(JVMCIObject for_object, const char* file, int line) {
202 // A JNI call to access an object in the shared library heap
203 // can block or take a long time so do not allow such access
204 // on the VM thread.
205 assert(for_object.is_hotspot() || !Thread::current()->is_VM_thread(),
206 "cannot open JVMCIEnv scope when in the VM thread for accessing a shared library heap object");
207 init(for_object.is_hotspot(), file, line);
208 }
209
210 // Opens a JNIEnv scope for the HotSpot runtime if `is_hotspot` is true
211 // otherwise for the shared library runtime. An exception occurring
212 // within the scope must not be propagated back to the caller.
213 JVMCIEnv(bool is_hotspot, const char* file, int line) {
214 init(is_hotspot, file, line);
215 }
216
217 ~JVMCIEnv();
218
219 JVMCIRuntime* runtime() {
220 return _runtime;
221 }
222
223 // Initializes Services.savedProperties in the shared library by copying
224 // the values from the same field in the HotSpot heap.
225 void copy_saved_properties();
226
227 jboolean has_pending_exception();
228 void clear_pending_exception();
229
230 // Prints an exception and stack trace of a pending exception.
231 void describe_pending_exception(bool clear);
232
233 int get_length(JVMCIArray array);
234
235 JVMCIObject get_object_at(JVMCIObjectArray array, int index);
236 void put_object_at(JVMCIObjectArray array, int index, JVMCIObject value);
237
238 jboolean get_bool_at(JVMCIPrimitiveArray array, int index);
239 void put_bool_at(JVMCIPrimitiveArray array, int index, jboolean value);
240
241 jbyte get_byte_at(JVMCIPrimitiveArray array, int index);
242 void put_byte_at(JVMCIPrimitiveArray array, int index, jbyte value);
243
244 jint get_int_at(JVMCIPrimitiveArray array, int index);
245 void put_int_at(JVMCIPrimitiveArray array, int index, jint value);
246
247 long get_long_at(JVMCIPrimitiveArray array, int index);
248 void put_long_at(JVMCIPrimitiveArray array, int index, jlong value);
249
250 void copy_bytes_to(JVMCIPrimitiveArray src, jbyte* dest, int offset, int size_in_bytes);
251 void copy_bytes_from(jbyte* src, JVMCIPrimitiveArray dest, int offset, int size_in_bytes);
252
253 JVMCIObjectArray initialize_intrinsics(JVMCI_TRAPS);
254
255 jboolean is_boxing_object(BasicType type, JVMCIObject object);
256
257 // Get the primitive value from a Java boxing object. It's hard error to
258 // pass a non-primitive BasicType.
259 jvalue get_boxed_value(BasicType type, JVMCIObject object);
260
261 // Return the BasicType of the object if it's a boxing object, otherwise return T_ILLEGAL.
262 BasicType get_box_type(JVMCIObject object);
263
264 // Create a boxing object of the appropriate primitive type.
265 JVMCIObject create_box(BasicType type, jvalue* value, JVMCI_TRAPS);
266
267 const char* as_utf8_string(JVMCIObject str);
268 char* as_utf8_string(JVMCIObject str, char* buf, int buflen);
269
270 JVMCIObject create_string(Symbol* str, JVMCI_TRAPS) {
271 return create_string(str->as_C_string(), JVMCI_CHECK_(JVMCIObject()));
272 }
273
274 JVMCIObject create_string(const char* str, JVMCI_TRAPS);
275
276 bool equals(JVMCIObject a, JVMCIObject b);
277
278 // Convert into a JNI handle for the appropriate runtime
279 jobject get_jobject(JVMCIObject object) { assert(object.as_jobject() == NULL || is_hotspot() == object.is_hotspot(), "mismatch"); return object.as_jobject(); }
280 jarray get_jarray(JVMCIArray array) { assert(array.as_jobject() == NULL || is_hotspot() == array.is_hotspot(), "mismatch"); return array.as_jobject(); }
281 jobjectArray get_jobjectArray(JVMCIObjectArray objectArray) { assert(objectArray.as_jobject() == NULL || is_hotspot() == objectArray.is_hotspot(), "mismatch"); return objectArray.as_jobject(); }
282 jbyteArray get_jbyteArray(JVMCIPrimitiveArray primitiveArray) { assert(primitiveArray.as_jobject() == NULL || is_hotspot() == primitiveArray.is_hotspot(), "mismatch"); return primitiveArray.as_jbyteArray(); }
283
284 JVMCIObject wrap(jobject obj);
285 JVMCIObjectArray wrap(jobjectArray obj) { return (JVMCIObjectArray) wrap((jobject) obj); }
286 JVMCIPrimitiveArray wrap(jintArray obj) { return (JVMCIPrimitiveArray) wrap((jobject) obj); }
287 JVMCIPrimitiveArray wrap(jbooleanArray obj) { return (JVMCIPrimitiveArray) wrap((jobject) obj); }
288 JVMCIPrimitiveArray wrap(jbyteArray obj) { return (JVMCIPrimitiveArray) wrap((jobject) obj); }
289 JVMCIPrimitiveArray wrap(jlongArray obj) { return (JVMCIPrimitiveArray) wrap((jobject) obj); }
290
291 private:
292 JVMCIObject wrap(oop obj) { assert(is_hotspot(), "must be"); return wrap(JNIHandles::make_local(obj)); }
293 JVMCIObjectArray wrap(objArrayOop obj) { assert(is_hotspot(), "must be"); return (JVMCIObjectArray) wrap(JNIHandles::make_local(obj)); }
294 JVMCIPrimitiveArray wrap(typeArrayOop obj) { assert(is_hotspot(), "must be"); return (JVMCIPrimitiveArray) wrap(JNIHandles::make_local(obj)); }
295
296 public:
297 // Compiles a method with the JVMIC compiler.
298 // Caller must handle pending exception.
299 JVMCIObject call_HotSpotJVMCIRuntime_compileMethod(JVMCIObject runtime, JVMCIObject method, int entry_bci,
300 jlong compile_state, int id);
301
302 void call_HotSpotJVMCIRuntime_bootstrapFinished(JVMCIObject runtime, JVMCI_TRAPS);
303 void call_HotSpotJVMCIRuntime_shutdown(JVMCIObject runtime);
304 JVMCIObject call_HotSpotJVMCIRuntime_runtime(JVMCI_TRAPS);
305 JVMCIObject call_JVMCI_getRuntime(JVMCI_TRAPS);
306 JVMCIObject call_HotSpotJVMCIRuntime_getCompiler(JVMCIObject runtime, JVMCI_TRAPS);
307
308 JVMCIObject call_HotSpotJVMCIRuntime_callToString(JVMCIObject object, JVMCI_TRAPS);
309
310 JVMCIObject call_PrimitiveConstant_forTypeChar(jchar kind, jlong value, JVMCI_TRAPS);
311 JVMCIObject call_JavaConstant_forFloat(float value, JVMCI_TRAPS);
312 JVMCIObject call_JavaConstant_forDouble(double value, JVMCI_TRAPS);
313
314 BasicType kindToBasicType(JVMCIObject kind, JVMCI_TRAPS);
315
316 #define DO_THROW(name) \
317 void throw_##name(const char* msg = NULL);
318
319 DO_THROW(InternalError)
320 DO_THROW(ArrayIndexOutOfBoundsException)
321 DO_THROW(IllegalStateException)
322 DO_THROW(NullPointerException)
323 DO_THROW(IllegalArgumentException)
324 DO_THROW(InvalidInstalledCodeException)
325 DO_THROW(UnsatisfiedLinkError)
326
327 #undef DO_THROW
328
329 void fthrow_error(const char* file, int line, const char* format, ...) ATTRIBUTE_PRINTF(4, 5);
330
331 // Given an instance of HotSpotInstalledCode return the corresponding CodeBlob*
332 CodeBlob* asCodeBlob(JVMCIObject code);
333
334 nmethod* asNmethod(JVMCIObject code) {
335 CodeBlob* cb = asCodeBlob(code);
336 if (cb == NULL) {
337 return NULL;
338 }
339 nmethod* nm = cb->as_nmethod_or_null();
340 guarantee(nm != NULL, "not an nmethod");
341 return nm;
342 }
343
344 MethodData* asMethodData(jlong metaspaceMethodData) {
345 return (MethodData*) (address) metaspaceMethodData;
346 }
347
348 const char* klass_name(JVMCIObject object);
349
350 // Unpack an instance of HotSpotResolvedJavaMethodImpl into the original Method*
351 Method* asMethod(JVMCIObject jvmci_method);
352 Method* asMethod(jobject jvmci_method) { return asMethod(wrap(jvmci_method)); }
353
354 // Unpack an instance of HotSpotResolvedObjectTypeImpl into the original Klass*
355 Klass* asKlass(JVMCIObject jvmci_type);
356 Klass* asKlass(jobject jvmci_type) { return asKlass(wrap(jvmci_type)); }
357
358 JVMCIObject get_jvmci_method(const methodHandle& method, JVMCI_TRAPS);
359
360 JVMCIObject get_jvmci_type(const JVMCIKlassHandle& klass, JVMCI_TRAPS);
361
362 // Unpack an instance of HotSpotConstantPool into the original ConstantPool*
363 ConstantPool* asConstantPool(JVMCIObject constant_pool);
364 ConstantPool* asConstantPool(jobject constant_pool) { return asConstantPool(wrap(constant_pool)); }
365
366 JVMCIObject get_jvmci_constant_pool(const constantPoolHandle& cp, JVMCI_TRAPS);
367 JVMCIObject get_jvmci_primitive_type(BasicType type);
368
369 Handle asConstant(JVMCIObject object, JVMCI_TRAPS);
370 JVMCIObject get_object_constant(oop objOop, bool compressed = false, bool dont_register = false);
371
372 JVMCIPrimitiveArray new_booleanArray(int length, JVMCI_TRAPS);
373 JVMCIPrimitiveArray new_byteArray(int length, JVMCI_TRAPS);
374 JVMCIPrimitiveArray new_intArray(int length, JVMCI_TRAPS);
375 JVMCIPrimitiveArray new_longArray(int length, JVMCI_TRAPS);
376
377 JVMCIObjectArray new_byte_array_array(int length, JVMCI_TRAPS);
378
379 JVMCIObject new_StackTraceElement(const methodHandle& method, int bci, JVMCI_TRAPS);
380 JVMCIObject new_HotSpotNmethod(const methodHandle& method, const char* name, jboolean isDefault, jlong compileId, JVMCI_TRAPS);
381 JVMCIObject new_VMField(JVMCIObject name, JVMCIObject type, jlong offset, jlong address, JVMCIObject value, JVMCI_TRAPS);
382 JVMCIObject new_VMFlag(JVMCIObject name, JVMCIObject type, JVMCIObject value, JVMCI_TRAPS);
383 JVMCIObject new_VMIntrinsicMethod(JVMCIObject declaringClass, JVMCIObject name, JVMCIObject descriptor, int id, JVMCI_TRAPS);
384 JVMCIObject new_HotSpotStackFrameReference(JVMCI_TRAPS);
385 JVMCIObject new_JVMCIError(JVMCI_TRAPS);
386
387 jlong make_handle(const Handle& obj);
388 oop resolve_handle(jlong objectHandle);
389
390 // These are analagous to the JNI routines
391 JVMCIObject make_local(JVMCIObject object);
392 JVMCIObject make_global(JVMCIObject object);
393 JVMCIObject make_weak(JVMCIObject object);
394 void destroy_local(JVMCIObject object);
395 void destroy_global(JVMCIObject object);
396 void destroy_weak(JVMCIObject object);
397
398 // Deoptimizes the nmethod (if any) in the HotSpotNmethod.address
399 // field of mirror. The field is subsequently zeroed.
400 void invalidate_nmethod_mirror(JVMCIObject mirror, JVMCI_TRAPS);
401
402 void initialize_installed_code(JVMCIObject installed_code, CodeBlob* cb, JVMCI_TRAPS);
403
404 private:
405 JVMCICompileState* _compile_state;
406
407 public:
408 static JavaVM* get_shared_library_javavm() { return _shared_library_javavm; }
409 static void* get_shared_library_handle() { return _shared_library_handle; }
410 static char* get_shared_library_path() { return _shared_library_path; }
411
412 // Determines if this is for the JVMCI runtime in the HotSpot
413 // heap (true) or the shared library heap (false).
414 bool is_hotspot() { return _is_hotspot; }
415
416 JVMCICompileState* compile_state() { return _compile_state; }
417 void set_compile_state(JVMCICompileState* compile_state) {
418 assert(_compile_state == NULL, "set only once");
419 _compile_state = compile_state;
420 }
421 // Generate declarations for the initialize, new, isa, get and set methods for all the types and
422 // fields declared in the JVMCI_CLASSES_DO macro.
423
424 #define START_CLASS(className, fullClassName) \
425 void className##_initialize(JVMCI_TRAPS); \
426 JVMCIObjectArray new_##className##_array(int length, JVMCI_TRAPS); \
427 bool isa_##className(JVMCIObject object);
428
429 #define END_CLASS
430
431 #define FIELD(className, name, type, accessor) \
432 type get_ ## className ## _ ## name(JVMCIObject obj); \
433 void set_ ## className ## _ ## name(JVMCIObject obj, type x);
434
435 #define OOPISH_FIELD(className, name, type, hstype, accessor) \
436 FIELD(className, name, type, accessor)
437
438 #define STATIC_FIELD(className, name, type) \
439 type get_ ## className ## _ ## name(); \
440 void set_ ## className ## _ ## name(type x);
441
442 #define STATIC_OOPISH_FIELD(className, name, type, hstype) \
443 STATIC_FIELD(className, name, type)
444
445 #define EMPTY_CAST
446 #define CHAR_FIELD(className, name) FIELD(className, name, jchar, char_field)
447 #define INT_FIELD(className, name) FIELD(className, name, jint, int_field)
448 #define BOOLEAN_FIELD(className, name) FIELD(className, name, jboolean, bool_field)
449 #define LONG_FIELD(className, name) FIELD(className, name, jlong, long_field)
450 #define FLOAT_FIELD(className, name) FIELD(className, name, jfloat, float_field)
451 #define OBJECT_FIELD(className, name, signature) OOPISH_FIELD(className, name, JVMCIObject, oop, obj_field)
452 #define OBJECTARRAY_FIELD(className, name, signature) OOPISH_FIELD(className, name, JVMCIObjectArray, objArrayOop, obj_field)
453 #define PRIMARRAY_FIELD(className, name, signature) OOPISH_FIELD(className, name, JVMCIPrimitiveArray, typeArrayOop, obj_field)
454
455 #define STATIC_INT_FIELD(className, name) STATIC_FIELD(className, name, jint)
456 #define STATIC_BOOLEAN_FIELD(className, name) STATIC_FIELD(className, name, jboolean)
457 #define STATIC_OBJECT_FIELD(className, name, signature) STATIC_OOPISH_FIELD(className, name, JVMCIObject, oop)
458 #define STATIC_OBJECTARRAY_FIELD(className, name, signature) STATIC_OOPISH_FIELD(className, name, JVMCIObjectArray, objArrayOop)
459 #define METHOD(jniCallType, jniGetMethod, hsCallType, returnType, className, methodName, signatureSymbolName, args)
460 #define CONSTRUCTOR(className, signature)
461
462 JVMCI_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, LONG_FIELD, FLOAT_FIELD, OBJECT_FIELD, PRIMARRAY_FIELD, OBJECTARRAY_FIELD, STATIC_OBJECT_FIELD, STATIC_OBJECTARRAY_FIELD, STATIC_INT_FIELD, STATIC_BOOLEAN_FIELD, METHOD, CONSTRUCTOR)
463
464 #undef JNI_START_CLASS
465 #undef START_CLASS
466 #undef END_CLASS
467 #undef METHOD
468 #undef CONSTRUCTOR
469 #undef FIELD
470 #undef CHAR_FIELD
471 #undef INT_FIELD
472 #undef BOOLEAN_FIELD
473 #undef LONG_FIELD
474 #undef FLOAT_FIELD
475 #undef OBJECT_FIELD
476 #undef PRIMARRAY_FIELD
477 #undef OBJECTARRAY_FIELD
478 #undef FIELD
479 #undef OOPISH_FIELD
480 #undef STATIC_FIELD
481 #undef STATIC_OOPISH_FIELD
482 #undef STATIC_FIELD
483 #undef STATIC_OBJECT_FIELD
484 #undef STATIC_OBJECTARRAY_FIELD
485 #undef STATIC_INT_FIELD
486 #undef STATIC_BOOLEAN_FIELD
487 #undef EMPTY_CAST
488
489 // End of JVMCIEnv
490 };
491
492 #endif // SHARE_JVMCI_JVMCIENV_HPP