51 bool JVMCICompileState::jvmti_state_changed() const {
52 if (!jvmti_can_access_local_variables() &&
53 JvmtiExport::can_access_local_variables()) {
54 return true;
55 }
56 if (!jvmti_can_hotswap_or_post_breakpoint() &&
57 JvmtiExport::can_hotswap_or_post_breakpoint()) {
58 return true;
59 }
60 if (!jvmti_can_post_on_exceptions() &&
61 JvmtiExport::can_post_on_exceptions()) {
62 return true;
63 }
64 if (!jvmti_can_pop_frame() &&
65 JvmtiExport::can_pop_frame()) {
66 return true;
67 }
68 return false;
69 }
70
71 JavaVM* JVMCIEnv::_shared_library_javavm = NULL;
72 void* JVMCIEnv::_shared_library_handle = NULL;
73 char* JVMCIEnv::_shared_library_path = NULL;
74
75 void JVMCIEnv::copy_saved_properties() {
76 assert(!is_hotspot(), "can only copy saved properties from HotSpot to native image");
77
78 JavaThread* THREAD = JavaThread::current();
79
80 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::jdk_vm_ci_services_Services(), Handle(), Handle(), true, THREAD);
81 if (HAS_PENDING_EXCEPTION) {
82 JVMCIRuntime::exit_on_pending_exception(NULL, "Error initializing jdk.vm.ci.services.Services");
83 }
84 InstanceKlass* ik = InstanceKlass::cast(k);
85 if (ik->should_be_initialized()) {
86 ik->initialize(THREAD);
87 if (HAS_PENDING_EXCEPTION) {
88 JVMCIRuntime::exit_on_pending_exception(NULL, "Error initializing jdk.vm.ci.services.Services");
89 }
90 }
91
92 // Get the serialized saved properties from HotSpot
93 TempNewSymbol serializeSavedProperties = SymbolTable::new_symbol("serializeSavedProperties", CHECK_EXIT);
94 JavaValue result(T_OBJECT);
105
106 // Copy serialized saved properties from HotSpot object into native buffer
107 jbyte* serialized_properties = NEW_RESOURCE_ARRAY(jbyte, serialized_properties_len);
108 memcpy(serialized_properties, ba->byte_at_addr(0), serialized_properties_len);
109
110 // Copy native buffer into shared library object
111 JVMCIPrimitiveArray buf = new_byteArray(serialized_properties_len, this);
112 if (has_pending_exception()) {
113 describe_pending_exception(true);
114 fatal("Error in copy_saved_properties");
115 }
116 copy_bytes_from(serialized_properties, buf, 0, serialized_properties_len);
117 if (has_pending_exception()) {
118 describe_pending_exception(true);
119 fatal("Error in copy_saved_properties");
120 }
121
122 // Initialize saved properties in shared library
123 jclass servicesClass = JNIJVMCI::Services::clazz();
124 jmethodID initializeSavedProperties = JNIJVMCI::Services::initializeSavedProperties_method();
125 JNIAccessMark jni(this);
126 jni()->CallStaticVoidMethod(servicesClass, initializeSavedProperties, buf.as_jobject());
127 if (jni()->ExceptionCheck()) {
128 jni()->ExceptionDescribe();
129 fatal("Error calling jdk.vm.ci.services.Services.initializeSavedProperties");
130 }
131 }
132
133 JNIEnv* JVMCIEnv::init_shared_library(JavaThread* thread) {
134 if (_shared_library_javavm == NULL) {
135 MutexLocker locker(JVMCI_lock);
136 if (_shared_library_javavm == NULL) {
137 char path[JVM_MAXPATHLEN];
138 char ebuf[1024];
139 if (JVMCILibPath != NULL) {
140 if (!os::dll_locate_lib(path, sizeof(path), JVMCILibPath, JVMCI_SHARED_LIBRARY_NAME)) {
141 vm_exit_during_initialization("Unable to create JVMCI shared library path from -XX:JVMCILibPath value", JVMCILibPath);
142 }
143 } else {
144 if (!os::dll_locate_lib(path, sizeof(path), Arguments::get_dll_dir(), JVMCI_SHARED_LIBRARY_NAME)) {
145 vm_exit_during_initialization("Unable to create path to JVMCI shared library");
146 }
147 }
148
149 void* handle = os::dll_load(path, ebuf, sizeof ebuf);
150 if (handle == NULL) {
151 vm_exit_during_initialization("Unable to load JVMCI shared library", ebuf);
152 }
153 _shared_library_handle = handle;
154 _shared_library_path = strdup(path);
155 jint (*JNI_CreateJavaVM)(JavaVM **pvm, void **penv, void *args);
156 typedef jint (*JNI_CreateJavaVM_t)(JavaVM **pvm, void **penv, void *args);
157
158 JNI_CreateJavaVM = CAST_TO_FN_PTR(JNI_CreateJavaVM_t, os::dll_lookup(handle, "JNI_CreateJavaVM"));
159 JNIEnv* env;
160 if (JNI_CreateJavaVM == NULL) {
161 vm_exit_during_initialization("Unable to find JNI_CreateJavaVM", path);
162 }
163
164 ResourceMark rm;
165 JavaVMInitArgs vm_args;
166 vm_args.version = JNI_VERSION_1_2;
167 vm_args.ignoreUnrecognized = JNI_TRUE;
168 vm_args.options = NULL;
169 vm_args.nOptions = 0;
170
171 JavaVM* the_javavm = NULL;
172 int result = (*JNI_CreateJavaVM)(&the_javavm, (void**) &env, &vm_args);
173 if (result == JNI_OK) {
174 guarantee(env != NULL, "missing env");
175 _shared_library_javavm = the_javavm;
176 return env;
177 } else {
178 vm_exit_during_initialization(err_msg("JNI_CreateJavaVM failed with return value %d", result), path);
179 }
180 }
181 }
182 return NULL;
183 }
184
185 void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env) {
186 assert(thread != NULL, "npe");
187 // By default there is only one runtime which is the compiler runtime.
188 _runtime = JVMCI::compiler_runtime();
189 _env = NULL;
190 _pop_frame_on_close = false;
191 _detach_on_close = false;
192 if (!UseJVMCINativeLibrary) {
193 // In HotSpot mode, JNI isn't used at all.
194 _is_hotspot = true;
195 return;
196 }
197
198 if (parent_env != NULL) {
199 // If the parent JNI environment is non-null then figure out whether it
200 // is a HotSpot or shared library JNIEnv and set the state appropriately.
201 _is_hotspot = thread->jni_environment() == parent_env;
202 if (_is_hotspot) {
203 // Select the Java runtime
204 _runtime = JVMCI::java_runtime();
205 return;
206 }
207 _env = parent_env;
208 return;
209 }
210
211 // Running in JVMCI shared library mode so ensure the shared library
212 // is loaded and initialized and get a shared library JNIEnv
213 _is_hotspot = false;
214 _env = init_shared_library(thread);
215
216 if (_env != NULL) {
217 // Creating the JVMCI shared library VM also attaches the current thread
218 _detach_on_close = true;
219 } else {
220 _shared_library_javavm->GetEnv((void**)&parent_env, JNI_VERSION_1_2);
221 if (parent_env != NULL) {
222 // Even though there's a parent JNI env, there's no guarantee
223 // it was opened by a JVMCIEnv scope and thus may not have
224 // pushed a local JNI frame. As such, we use a new JNI local
225 // frame in this scope to ensure local JNI refs are collected
226 // in a timely manner after leaving this scope.
227 _env = parent_env;
228 } else {
229 ResourceMark rm; // Thread name is resource allocated
230 JavaVMAttachArgs attach_args;
231 attach_args.version = JNI_VERSION_1_2;
232 attach_args.name = thread->name();
233 attach_args.group = NULL;
234 if (_shared_library_javavm->AttachCurrentThread((void**)&_env, &attach_args) != JNI_OK) {
235 fatal("Error attaching current thread (%s) to JVMCI shared library JNI interface", attach_args.name);
236 }
237 _detach_on_close = true;
238 }
239 }
240
241 assert(_env != NULL, "missing env");
242 assert(_throw_to_caller == false, "must be");
243
244 JNIAccessMark jni(this);
245 jint result = _env->PushLocalFrame(32);
246 if (result != JNI_OK) {
247 char message[256];
248 jio_snprintf(message, 256, "Uncaught exception pushing local frame for JVMCIEnv scope entered at %s:%d", _file, _line);
249 JVMCIRuntime::exit_on_pending_exception(this, message);
250 }
251 _pop_frame_on_close = true;
252 }
253
254 JVMCIEnv::JVMCIEnv(JavaThread* thread, JVMCICompileState* compile_state, const char* file, int line):
255 _throw_to_caller(false), _file(file), _line(line), _compile_state(compile_state) {
256 init_env_mode_runtime(thread, NULL);
257 }
258
259 JVMCIEnv::JVMCIEnv(JavaThread* thread, const char* file, int line):
260 _throw_to_caller(false), _file(file), _line(line), _compile_state(NULL) {
261 init_env_mode_runtime(thread, NULL);
262 }
263
264 JVMCIEnv::JVMCIEnv(JavaThread* thread, JNIEnv* parent_env, const char* file, int line):
268 }
269
270 void JVMCIEnv::init(JavaThread* thread, bool is_hotspot, const char* file, int line) {
271 _compile_state = NULL;
272 _throw_to_caller = false;
273 _file = file;
274 _line = line;
275 if (is_hotspot) {
276 _env = NULL;
277 _pop_frame_on_close = false;
278 _detach_on_close = false;
279 _is_hotspot = true;
280 _runtime = JVMCI::java_runtime();
281 } else {
282 init_env_mode_runtime(thread, NULL);
283 }
284 }
285
286 // Prints a pending exception (if any) and its stack trace.
287 void JVMCIEnv::describe_pending_exception(bool clear) {
288 if (!is_hotspot()) {
289 JNIAccessMark jni(this);
290 if (jni()->ExceptionCheck()) {
291 jthrowable ex = !clear ? jni()->ExceptionOccurred() : NULL;
292 jni()->ExceptionDescribe();
293 if (ex != NULL) {
294 jni()->Throw(ex);
295 }
296 }
297 } else {
298 Thread* THREAD = Thread::current();
299 if (HAS_PENDING_EXCEPTION) {
300 JVMCIRuntime::describe_pending_hotspot_exception((JavaThread*) THREAD, clear);
301 }
302 }
303 }
304
305 void JVMCIEnv::translate_hotspot_exception_to_jni_exception(JavaThread* THREAD, const Handle& throwable) {
306 assert(!is_hotspot(), "must_be");
307 // Resolve HotSpotJVMCIRuntime class explicitly as HotSpotJVMCI::compute_offsets
308 // may not have been called.
309 Klass* runtimeKlass = SystemDictionary::resolve_or_fail(vmSymbols::jdk_vm_ci_hotspot_HotSpotJVMCIRuntime(), true, CHECK);
310 JavaCallArguments jargs;
311 jargs.push_oop(throwable);
312 JavaValue result(T_OBJECT);
313 JavaCalls::call_static(&result,
314 runtimeKlass,
315 vmSymbols::encodeThrowable_name(),
316 vmSymbols::encodeThrowable_signature(), &jargs, THREAD);
317 if (HAS_PENDING_EXCEPTION) {
318 JVMCIRuntime::exit_on_pending_exception(this, "HotSpotJVMCIRuntime.encodeThrowable should not throw an exception");
319 }
320
321 oop encoded_throwable_string = (oop) result.get_jobject();
322
323 ResourceMark rm;
324 const char* encoded_throwable_chars = java_lang_String::as_utf8_string(encoded_throwable_string);
325
326 JNIAccessMark jni(this);
327 jobject jni_encoded_throwable_string = jni()->NewStringUTF(encoded_throwable_chars);
328 jthrowable jni_throwable = (jthrowable) jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(),
329 JNIJVMCI::HotSpotJVMCIRuntime::decodeThrowable_method(),
330 jni_encoded_throwable_string);
331 jni()->Throw(jni_throwable);
332 }
333
334 JVMCIEnv::~JVMCIEnv() {
335 if (_throw_to_caller) {
336 if (is_hotspot()) {
337 // Nothing to do
338 } else {
339 if (Thread::current()->is_Java_thread()) {
340 JavaThread* THREAD = JavaThread::current();
341 if (HAS_PENDING_EXCEPTION) {
342 Handle throwable = Handle(THREAD, PENDING_EXCEPTION);
343 CLEAR_PENDING_EXCEPTION;
344 translate_hotspot_exception_to_jni_exception(THREAD, throwable);
345 }
346 }
347 }
348 } else {
349 if (_pop_frame_on_close) {
350 // Pop the JNI local frame that was pushed when entering this JVMCIEnv scope.
351 JNIAccessMark jni(this);
352 jni()->PopLocalFrame(NULL);
353 }
354
355 if (has_pending_exception()) {
356 char message[256];
357 jio_snprintf(message, 256, "Uncaught exception exiting JVMCIEnv scope entered at %s:%d", _file, _line);
358 JVMCIRuntime::exit_on_pending_exception(this, message);
359 }
360
361 if (_detach_on_close) {
362 get_shared_library_javavm()->DetachCurrentThread();
363 }
364 }
365 }
366
367 jboolean JVMCIEnv::has_pending_exception() {
368 if (is_hotspot()) {
369 Thread* THREAD = Thread::current();
370 return HAS_PENDING_EXCEPTION;
371 } else {
372 JNIAccessMark jni(this);
373 return jni()->ExceptionCheck();
374 }
375 }
376
377 void JVMCIEnv::clear_pending_exception() {
378 if (is_hotspot()) {
379 Thread* THREAD = Thread::current();
380 CLEAR_PENDING_EXCEPTION;
381 } else {
382 JNIAccessMark jni(this);
577 if (jni()->IsSameObject(clazz, JNIJVMCI::box_class(T_DOUBLE))) return T_DOUBLE;
578 return T_ILLEGAL;
579 }
580 }
581
582 // Create a boxing object of the appropriate primitive type.
583 JVMCIObject JVMCIEnv::create_box(BasicType type, jvalue* value, JVMCI_TRAPS) {
584 switch (type) {
585 case T_BOOLEAN:
586 case T_BYTE:
587 case T_CHAR:
588 case T_SHORT:
589 case T_INT:
590 case T_LONG:
591 case T_FLOAT:
592 case T_DOUBLE:
593 break;
594 default:
595 JVMCI_THROW_MSG_(IllegalArgumentException, "Only boxes for primitive values can be created", JVMCIObject());
596 }
597 if (is_hotspot()) {
598 JavaThread* THREAD = JavaThread::current();
599 oop box = java_lang_boxing_object::create(type, value, CHECK_(JVMCIObject()));
600 return HotSpotJVMCI::wrap(box);
601 } else {
602 JNIAccessMark jni(this);
603 jobject box = jni()->NewObjectA(JNIJVMCI::box_class(type), JNIJVMCI::box_constructor(type), value);
604 assert(box != NULL, "");
605 return wrap(box);
606 }
607 }
608
609 const char* JVMCIEnv::as_utf8_string(JVMCIObject str) {
610 if (is_hotspot()) {
611 return java_lang_String::as_utf8_string(HotSpotJVMCI::resolve(str));
612 } else {
613 JNIAccessMark jni(this);
614 int length = jni()->GetStringLength(str.as_jstring());
615 char* result = NEW_RESOURCE_ARRAY(char, length + 1);
616 jni()->GetStringUTFRegion(str.as_jstring(), 0, length, result);
617 return result;
618 }
619 }
620
621 char* JVMCIEnv::as_utf8_string(JVMCIObject str, char* buf, int buflen) {
622 if (is_hotspot()) {
646 DO_THROW(InternalError)
647 DO_THROW(ArrayIndexOutOfBoundsException)
648 DO_THROW(IllegalStateException)
649 DO_THROW(NullPointerException)
650 DO_THROW(IllegalArgumentException)
651 DO_THROW(InvalidInstalledCodeException)
652 DO_THROW(UnsatisfiedLinkError)
653 DO_THROW(UnsupportedOperationException)
654 DO_THROW(ClassNotFoundException)
655
656 #undef DO_THROW
657
658 void JVMCIEnv::fthrow_error(const char* file, int line, const char* format, ...) {
659 const int max_msg_size = 1024;
660 va_list ap;
661 va_start(ap, format);
662 char msg[max_msg_size];
663 vsnprintf(msg, max_msg_size, format, ap);
664 msg[max_msg_size-1] = '\0';
665 va_end(ap);
666 if (is_hotspot()) {
667 JavaThread* THREAD = JavaThread::current();
668 Handle h_loader = Handle();
669 Handle h_protection_domain = Handle();
670 Exceptions::_throw_msg(THREAD, file, line, vmSymbols::jdk_vm_ci_common_JVMCIError(), msg, h_loader, h_protection_domain);
671 } else {
672 JNIAccessMark jni(this);
673 jni()->ThrowNew(JNIJVMCI::JVMCIError::clazz(), msg);
674 }
675 }
676
677 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_compileMethod (JVMCIObject runtime, JVMCIObject method, int entry_bci,
678 jlong compile_state, int id) {
679 if (is_hotspot()) {
680 Thread* THREAD = Thread::current();
681 JavaCallArguments jargs;
682 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
683 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(method)));
684 jargs.push_int(entry_bci);
685 jargs.push_long(compile_state);
686 jargs.push_int(id);
687 JavaValue result(T_OBJECT);
688 JavaCalls::call_special(&result,
689 HotSpotJVMCI::HotSpotJVMCIRuntime::klass(),
690 vmSymbols::compileMethod_name(),
691 vmSymbols::compileMethod_signature(), &jargs, CHECK_(JVMCIObject()));
692 return wrap((oop) result.get_jobject());
709 JavaCallArguments jargs;
710 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
711 JavaValue result(T_VOID);
712 JavaCalls::call_special(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::bootstrapFinished_name(), vmSymbols::void_method_signature(), &jargs, CHECK);
713 } else {
714 JNIAccessMark jni(this);
715 jni()->CallNonvirtualVoidMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::bootstrapFinished_method());
716
717 }
718 }
719
720 void JVMCIEnv::call_HotSpotJVMCIRuntime_shutdown (JVMCIObject runtime) {
721 HandleMark hm;
722 JavaThread* THREAD = JavaThread::current();
723 if (is_hotspot()) {
724 JavaCallArguments jargs;
725 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
726 JavaValue result(T_VOID);
727 JavaCalls::call_special(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::shutdown_name(), vmSymbols::void_method_signature(), &jargs, THREAD);
728 } else {
729 JNIAccessMark jni(this);
730 jni()->CallNonvirtualVoidMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::shutdown_method());
731 }
732 if (has_pending_exception()) {
733 // This should never happen as HotSpotJVMCIRuntime.shutdown() should
734 // handle all exceptions.
735 describe_pending_exception(true);
736 }
737 }
738
739 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_runtime (JVMCIEnv* JVMCIENV) {
740 JavaThread* THREAD = JavaThread::current();
741 if (is_hotspot()) {
742 JavaCallArguments jargs;
743 JavaValue result(T_OBJECT);
744 JavaCalls::call_static(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::runtime_name(), vmSymbols::runtime_signature(), &jargs, CHECK_(JVMCIObject()));
745 return wrap((oop) result.get_jobject());
746 } else {
747 JNIAccessMark jni(this);
748 jobject result = jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::runtime_method());
749 if (jni()->ExceptionCheck()) {
750 return JVMCIObject();
751 }
752 return wrap(result);
753 }
754 }
755
756 JVMCIObject JVMCIEnv::call_JVMCI_getRuntime (JVMCIEnv* JVMCIENV) {
757 JavaThread* THREAD = JavaThread::current();
758 if (is_hotspot()) {
759 JavaCallArguments jargs;
760 JavaValue result(T_OBJECT);
761 JavaCalls::call_static(&result, HotSpotJVMCI::JVMCI::klass(), vmSymbols::getRuntime_name(), vmSymbols::getRuntime_signature(), &jargs, CHECK_(JVMCIObject()));
762 return wrap((oop) result.get_jobject());
763 } else {
764 JNIAccessMark jni(this);
765 jobject result = jni()->CallStaticObjectMethod(JNIJVMCI::JVMCI::clazz(), JNIJVMCI::JVMCI::getRuntime_method());
766 if (jni()->ExceptionCheck()) {
767 return JVMCIObject();
768 }
769 return wrap(result);
770 }
771 }
772
773 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_getCompiler (JVMCIObject runtime, JVMCIEnv* JVMCIENV) {
774 JavaThread* THREAD = JavaThread::current();
775 if (is_hotspot()) {
776 JavaCallArguments jargs;
777 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
778 JavaValue result(T_OBJECT);
779 JavaCalls::call_virtual(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::getCompiler_name(), vmSymbols::getCompiler_signature(), &jargs, CHECK_(JVMCIObject()));
780 return wrap((oop) result.get_jobject());
781 } else {
782 JNIAccessMark jni(this);
783 jobject result = jni()->CallObjectMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::getCompiler_method());
784 if (jni()->ExceptionCheck()) {
785 return JVMCIObject();
786 }
787 return wrap(result);
788 }
789 }
790
791
792 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_callToString(JVMCIObject object, JVMCIEnv* JVMCIENV) {
793 JavaThread* THREAD = JavaThread::current();
794 if (is_hotspot()) {
795 JavaCallArguments jargs;
796 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(object)));
797 JavaValue result(T_OBJECT);
798 JavaCalls::call_static(&result,
799 HotSpotJVMCI::HotSpotJVMCIRuntime::klass(),
800 vmSymbols::callToString_name(),
801 vmSymbols::callToString_signature(), &jargs, CHECK_(JVMCIObject()));
802 return wrap((oop) result.get_jobject());
803 } else {
804 JNIAccessMark jni(this);
805 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(),
806 JNIJVMCI::HotSpotJVMCIRuntime::callToString_method(),
807 object.as_jobject());
808 if (jni()->ExceptionCheck()) {
809 return JVMCIObject();
810 }
811 return wrap(result);
812 }
813 }
814
815
816 JVMCIObject JVMCIEnv::call_PrimitiveConstant_forTypeChar(jchar kind, jlong value, JVMCI_TRAPS) {
817 JavaThread* THREAD = JavaThread::current();
818 if (is_hotspot()) {
819 JavaCallArguments jargs;
820 jargs.push_int(kind);
821 jargs.push_long(value);
822 JavaValue result(T_OBJECT);
823 JavaCalls::call_static(&result,
824 HotSpotJVMCI::PrimitiveConstant::klass(),
825 vmSymbols::forTypeChar_name(),
826 vmSymbols::forTypeChar_signature(), &jargs, CHECK_(JVMCIObject()));
827 return wrap((oop) result.get_jobject());
828 } else {
829 JNIAccessMark jni(this);
830 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::PrimitiveConstant::clazz(),
831 JNIJVMCI::PrimitiveConstant::forTypeChar_method(),
832 kind, value);
833 if (jni()->ExceptionCheck()) {
834 return JVMCIObject();
835 }
836 return wrap(result);
837 }
838 }
839
840 JVMCIObject JVMCIEnv::call_JavaConstant_forFloat(float value, JVMCI_TRAPS) {
841 JavaThread* THREAD = JavaThread::current();
842 if (is_hotspot()) {
843 JavaCallArguments jargs;
844 jargs.push_float(value);
845 JavaValue result(T_OBJECT);
846 JavaCalls::call_static(&result,
847 HotSpotJVMCI::JavaConstant::klass(),
848 vmSymbols::forFloat_name(),
849 vmSymbols::forFloat_signature(), &jargs, CHECK_(JVMCIObject()));
850 return wrap((oop) result.get_jobject());
851 } else {
852 JNIAccessMark jni(this);
853 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::JavaConstant::clazz(),
854 JNIJVMCI::JavaConstant::forFloat_method(),
855 value);
856 if (jni()->ExceptionCheck()) {
857 return JVMCIObject();
858 }
859 return wrap(result);
860 }
861 }
862
863 JVMCIObject JVMCIEnv::call_JavaConstant_forDouble(double value, JVMCI_TRAPS) {
864 JavaThread* THREAD = JavaThread::current();
865 if (is_hotspot()) {
866 JavaCallArguments jargs;
867 jargs.push_double(value);
868 JavaValue result(T_OBJECT);
869 JavaCalls::call_static(&result,
870 HotSpotJVMCI::JavaConstant::klass(),
871 vmSymbols::forDouble_name(),
872 vmSymbols::forDouble_signature(), &jargs, CHECK_(JVMCIObject()));
873 return wrap((oop) result.get_jobject());
874 } else {
875 JNIAccessMark jni(this);
876 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::JavaConstant::clazz(),
877 JNIJVMCI::JavaConstant::forDouble_method(),
878 value);
879 if (jni()->ExceptionCheck()) {
880 return JVMCIObject();
881 }
882 return wrap(result);
883 }
884 }
885
886 JVMCIObject JVMCIEnv::get_jvmci_primitive_type(BasicType type) {
887 JVMCIObjectArray primitives = get_HotSpotResolvedPrimitiveType_primitives();
888 JVMCIObject result = get_object_at(primitives, type);
889 return result;
890 }
891
892 JVMCIObject JVMCIEnv::new_StackTraceElement(const methodHandle& method, int bci, JVMCI_TRAPS) {
893 JavaThread* THREAD = JavaThread::current();
894 Symbol* file_name_sym;
895 int line_number;
900 const char* declaring_class_str = holder->external_name();
901
902 if (is_hotspot()) {
903 HotSpotJVMCI::StackTraceElement::klass()->initialize(CHECK_(JVMCIObject()));
904 oop objOop = HotSpotJVMCI::StackTraceElement::klass()->allocate_instance(CHECK_(JVMCIObject()));
905 Handle obj = Handle(THREAD, objOop);
906
907 oop declaring_class = StringTable::intern((char*) declaring_class_str, CHECK_(JVMCIObject()));
908 HotSpotJVMCI::StackTraceElement::set_declaringClass(this, obj(), declaring_class);
909
910 oop method_name = StringTable::intern(method_name_sym, CHECK_(JVMCIObject()));
911 HotSpotJVMCI::StackTraceElement::set_methodName(this, obj(), method_name);
912
913 if (file_name_sym != NULL) {
914 oop file_name = StringTable::intern(file_name_sym, CHECK_(JVMCIObject()));
915 HotSpotJVMCI::StackTraceElement::set_fileName(this, obj(), file_name);
916 }
917 HotSpotJVMCI::StackTraceElement::set_lineNumber(this, obj(), line_number);
918 return wrap(obj());
919 } else {
920 JNIAccessMark jni(this);
921 jobject declaring_class = jni()->NewStringUTF(declaring_class_str);
922 if (jni()->ExceptionCheck()) {
923 return JVMCIObject();
924 }
925 jobject method_name = jni()->NewStringUTF(method_name_sym->as_C_string());
926 if (jni()->ExceptionCheck()) {
927 return JVMCIObject();
928 }
929 jobject file_name = NULL;
930 if (file_name_sym != NULL) {
931 file_name = jni()->NewStringUTF(file_name_sym->as_C_string());
932 if (jni()->ExceptionCheck()) {
933 return JVMCIObject();
934 }
935 }
936
937 jobject result = jni()->NewObject(JNIJVMCI::StackTraceElement::clazz(),
938 JNIJVMCI::StackTraceElement::constructor(),
939 declaring_class, method_name, file_name, line_number);
940 return wrap(result);
952 ik->initialize(CHECK_(JVMCIObject()));
953 }
954 oop obj = ik->allocate_instance(CHECK_(JVMCIObject()));
955 Handle obj_h(THREAD, obj);
956 Handle nameStr = java_lang_String::create_from_str(name, CHECK_(JVMCIObject()));
957
958 // Call constructor
959 JavaCallArguments jargs;
960 jargs.push_oop(obj_h);
961 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(methodObject)));
962 jargs.push_oop(nameStr);
963 jargs.push_int(isDefault);
964 jargs.push_long(compileId);
965 JavaValue result(T_VOID);
966 JavaCalls::call_special(&result, ik,
967 vmSymbols::object_initializer_name(),
968 vmSymbols::method_string_bool_long_signature(),
969 &jargs, CHECK_(JVMCIObject()));
970 return wrap(obj_h());
971 } else {
972 JNIAccessMark jni(this);
973 jobject nameStr = name == NULL ? NULL : jni()->NewStringUTF(name);
974 if (jni()->ExceptionCheck()) {
975 return JVMCIObject();
976 }
977
978 jobject result = jni()->NewObject(JNIJVMCI::HotSpotNmethod::clazz(),
979 JNIJVMCI::HotSpotNmethod::constructor(),
980 methodObject.as_jobject(), nameStr, isDefault);
981 return wrap(result);
982 }
983 }
984
985 JVMCIObject JVMCIEnv::make_local(JVMCIObject object) {
986 if (object.is_null()) {
987 return JVMCIObject();
988 }
989 if (is_hotspot()) {
990 return wrap(JNIHandles::make_local(HotSpotJVMCI::resolve(object)));
991 } else {
992 JNIAccessMark jni(this);
993 return wrap(jni()->NewLocalRef(object.as_jobject()));
994 }
995 }
996
997 JVMCIObject JVMCIEnv::make_global(JVMCIObject object) {
998 if (object.is_null()) {
999 return JVMCIObject();
1000 }
1001 if (is_hotspot()) {
1002 return wrap(JNIHandles::make_global(Handle(Thread::current(), HotSpotJVMCI::resolve(object))));
1003 } else {
1004 JNIAccessMark jni(this);
1005 return wrap(jni()->NewGlobalRef(object.as_jobject()));
1006 }
1007 }
1008
1009 JVMCIObject JVMCIEnv::make_weak(JVMCIObject object) {
1010 if (object.is_null()) {
1011 return JVMCIObject();
1012 }
1013 if (is_hotspot()) {
1014 return wrap(JNIHandles::make_weak_global(Handle(Thread::current(), HotSpotJVMCI::resolve(object))));
1015 } else {
1016 JNIAccessMark jni(this);
1017 return wrap(jni()->NewWeakGlobalRef(object.as_jobject()));
1018 }
1019 }
1020
1021 void JVMCIEnv::destroy_local(JVMCIObject object) {
1022 if (is_hotspot()) {
1023 JNIHandles::destroy_local(object.as_jobject());
1024 } else {
1025 JNIAccessMark jni(this);
1026 jni()->DeleteLocalRef(object.as_jobject());
1027 }
1028 }
1029
1030 void JVMCIEnv::destroy_global(JVMCIObject object) {
1031 if (is_hotspot()) {
1032 JNIHandles::destroy_global(object.as_jobject());
1033 } else {
1034 JNIAccessMark jni(this);
1035 jni()->DeleteGlobalRef(object.as_jobject());
1036 }
1037 }
1038
1039 void JVMCIEnv::destroy_weak(JVMCIObject object) {
1040 if (is_hotspot()) {
1041 JNIHandles::destroy_weak_global(object.as_jweak());
1042 } else {
1043 JNIAccessMark jni(this);
1044 jni()->DeleteWeakGlobalRef(object.as_jweak());
1045 }
1046 }
1047
1048 const char* JVMCIEnv::klass_name(JVMCIObject object) {
1049 if (is_hotspot()) {
1050 return HotSpotJVMCI::resolve(object)->klass()->signature_name();
1051 } else {
1052 JVMCIObject name;
1053 {
1054 JNIAccessMark jni(this);
1055 jclass jcl = jni()->GetObjectClass(object.as_jobject());
1056 jobject result = jni()->CallObjectMethod(jcl, JNIJVMCI::Class_getName_method());
1057 name = JVMCIObject::create(result, is_hotspot());
1058 }
1059 return as_utf8_string(name);
1060 }
1061 }
1062
1063 JVMCIObject JVMCIEnv::get_jvmci_method(const methodHandle& method, JVMCI_TRAPS) {
1064 JVMCIObject method_object;
1065 if (method() == NULL) {
1066 return method_object;
1067 }
1068
1069 Thread* THREAD = Thread::current();
1070 jmetadata handle = JVMCI::allocate_handle(method);
1071 jboolean exception = false;
1072 if (is_hotspot()) {
1073 JavaValue result(T_OBJECT);
1074 JavaCallArguments args;
1075 args.push_long((jlong) handle);
1076 JavaCalls::call_static(&result, HotSpotJVMCI::HotSpotResolvedJavaMethodImpl::klass(),
1077 vmSymbols::fromMetaspace_name(),
1078 vmSymbols::method_fromMetaspace_signature(), &args, THREAD);
1079 if (HAS_PENDING_EXCEPTION) {
1080 exception = true;
1081 } else {
1082 method_object = wrap((oop)result.get_jobject());
1083 }
1084 } else {
1085 JNIAccessMark jni(this);
1086 method_object = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotResolvedJavaMethodImpl::clazz(),
1087 JNIJVMCI::HotSpotResolvedJavaMethodImpl_fromMetaspace_method(),
1088 (jlong) handle));
1089 exception = jni()->ExceptionCheck();
1090 }
1091
1092 if (exception) {
1093 JVMCI::release_handle(handle);
1094 return JVMCIObject();
1095 }
1096
1097 assert(asMethod(method_object) == method(), "must be");
1098 if (get_HotSpotResolvedJavaMethodImpl_metadataHandle(method_object) != (jlong) handle) {
1099 JVMCI::release_handle(handle);
1100 }
1101 assert(!method_object.is_null(), "must be");
1102 return method_object;
1103 }
1104
1105 JVMCIObject JVMCIEnv::get_jvmci_type(const JVMCIKlassHandle& klass, JVMCI_TRAPS) {
1106 JVMCIObject type;
1107 if (klass.is_null()) {
1108 return type;
1109 }
1110
1111 jlong pointer = (jlong) klass();
1112 JavaThread* THREAD = JavaThread::current();
1113 JVMCIObject signature = create_string(klass->signature_name(), JVMCI_CHECK_(JVMCIObject()));
1114 jboolean exception = false;
1115 if (is_hotspot()) {
1116 JavaValue result(T_OBJECT);
1117 JavaCallArguments args;
1118 args.push_long(pointer);
1119 args.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(signature)));
1120 JavaCalls::call_static(&result,
1121 HotSpotJVMCI::HotSpotResolvedObjectTypeImpl::klass(),
1122 vmSymbols::fromMetaspace_name(),
1123 vmSymbols::klass_fromMetaspace_signature(), &args, THREAD);
1124
1125 if (HAS_PENDING_EXCEPTION) {
1126 exception = true;
1127 } else {
1128 type = wrap((oop)result.get_jobject());
1129 }
1130 } else {
1131 JNIAccessMark jni(this);
1132
1133 HandleMark hm(THREAD);
1134 type = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotResolvedObjectTypeImpl::clazz(),
1135 JNIJVMCI::HotSpotResolvedObjectTypeImpl_fromMetaspace_method(),
1136 pointer, signature.as_jstring()));
1137 exception = jni()->ExceptionCheck();
1138 }
1139 if (exception) {
1140 return JVMCIObject();
1141 }
1142
1143 assert(type.is_non_null(), "must have result");
1144 return type;
1145 }
1146
1147 JVMCIObject JVMCIEnv::get_jvmci_constant_pool(const constantPoolHandle& cp, JVMCI_TRAPS) {
1148 JVMCIObject cp_object;
1149 jmetadata handle = JVMCI::allocate_handle(cp);
1150 jboolean exception = false;
1151 if (is_hotspot()) {
1152 JavaThread* THREAD = JavaThread::current();
1153 JavaValue result(T_OBJECT);
1154 JavaCallArguments args;
1155 args.push_long((jlong) handle);
1156 JavaCalls::call_static(&result,
1157 HotSpotJVMCI::HotSpotConstantPool::klass(),
1158 vmSymbols::fromMetaspace_name(),
1159 vmSymbols::constantPool_fromMetaspace_signature(), &args, THREAD);
1160 if (HAS_PENDING_EXCEPTION) {
1161 exception = true;
1162 } else {
1163 cp_object = wrap((oop)result.get_jobject());
1164 }
1165 } else {
1166 JNIAccessMark jni(this);
1167 cp_object = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotConstantPool::clazz(),
1168 JNIJVMCI::HotSpotConstantPool_fromMetaspace_method(),
1169 (jlong) handle));
1170 exception = jni()->ExceptionCheck();
1171 }
1172
1173 if (exception) {
1174 JVMCI::release_handle(handle);
1175 return JVMCIObject();
1176 }
1177
1178 assert(!cp_object.is_null(), "must be");
1179 // Constant pools aren't cached so this is always a newly created object using the handle
1180 assert(get_HotSpotConstantPool_metadataHandle(cp_object) == (jlong) handle, "must use same handle");
1181 return cp_object;
1182 }
1183
1184 JVMCIPrimitiveArray JVMCIEnv::new_booleanArray(int length, JVMCI_TRAPS) {
1185 if (is_hotspot()) {
1186 JavaThread* THREAD = JavaThread::current();
1187 typeArrayOop result = oopFactory::new_boolArray(length, CHECK_(JVMCIObject()));
1188 return wrap(result);
1189 } else {
1190 JNIAccessMark jni(this);
1191 jbooleanArray result = jni()->NewBooleanArray(length);
1192 return wrap(result);
1193 }
1194 }
1195
1196 JVMCIPrimitiveArray JVMCIEnv::new_byteArray(int length, JVMCI_TRAPS) {
1197 if (is_hotspot()) {
1198 JavaThread* THREAD = JavaThread::current();
1199 typeArrayOop result = oopFactory::new_byteArray(length, CHECK_(JVMCIObject()));
1200 return wrap(result);
1201 } else {
1202 JNIAccessMark jni(this);
1203 jbyteArray result = jni()->NewByteArray(length);
1204 return wrap(result);
1205 }
1206 }
1207
1208 JVMCIObjectArray JVMCIEnv::new_byte_array_array(int length, JVMCI_TRAPS) {
1209 if (is_hotspot()) {
1210 JavaThread* THREAD = JavaThread::current();
1211 Klass* byteArrayArrayKlass = TypeArrayKlass::cast(Universe::byteArrayKlassObj ())->array_klass(CHECK_(JVMCIObject()));
1212 objArrayOop result = ObjArrayKlass::cast(byteArrayArrayKlass) ->allocate(length, CHECK_(JVMCIObject()));
1213 return wrap(result);
1214 } else {
1215 JNIAccessMark jni(this);
1216 jobjectArray result = jni()->NewObjectArray(length, JNIJVMCI::byte_array(), NULL);
1217 return wrap(result);
1218 }
1219 }
1220
1221 JVMCIPrimitiveArray JVMCIEnv::new_intArray(int length, JVMCI_TRAPS) {
1222 if (is_hotspot()) {
1223 JavaThread* THREAD = JavaThread::current();
1224 typeArrayOop result = oopFactory::new_intArray(length, CHECK_(JVMCIObject()));
1225 return wrap(result);
1226 } else {
1227 JNIAccessMark jni(this);
1228 jintArray result = jni()->NewIntArray(length);
1229 return wrap(result);
1230 }
1231 }
1232
1233 JVMCIPrimitiveArray JVMCIEnv::new_longArray(int length, JVMCI_TRAPS) {
1234 if (is_hotspot()) {
1235 JavaThread* THREAD = JavaThread::current();
1236 typeArrayOop result = oopFactory::new_longArray(length, CHECK_(JVMCIObject()));
1237 return wrap(result);
1238 } else {
1239 JNIAccessMark jni(this);
1240 jlongArray result = jni()->NewLongArray(length);
1241 return wrap(result);
1242 }
1243 }
1244
1245 JVMCIObject JVMCIEnv::new_VMField(JVMCIObject name, JVMCIObject type, jlong offset, jlong address, JVMCIObject value, JVMCI_TRAPS) {
1246 if (is_hotspot()) {
1247 JavaThread* THREAD = JavaThread::current();
1248 HotSpotJVMCI::VMField::klass()->initialize(CHECK_(JVMCIObject()));
1249 oop obj = HotSpotJVMCI::VMField::klass()->allocate_instance(CHECK_(JVMCIObject()));
1250 HotSpotJVMCI::VMField::set_name(this, obj, HotSpotJVMCI::resolve(name));
1251 HotSpotJVMCI::VMField::set_type(this, obj, HotSpotJVMCI::resolve(type));
1252 HotSpotJVMCI::VMField::set_offset(this, obj, offset);
1253 HotSpotJVMCI::VMField::set_address(this, obj, address);
1254 HotSpotJVMCI::VMField::set_value(this, obj, HotSpotJVMCI::resolve(value));
1255 return wrap(obj);
1256 } else {
1257 JNIAccessMark jni(this);
1258 jobject result = jni()->NewObject(JNIJVMCI::VMField::clazz(),
1259 JNIJVMCI::VMField::constructor(),
1260 get_jobject(name), get_jobject(type), offset, address, get_jobject(value));
1261 return wrap(result);
1262 }
1263 }
1264
1265 JVMCIObject JVMCIEnv::new_VMFlag(JVMCIObject name, JVMCIObject type, JVMCIObject value, JVMCI_TRAPS) {
1266 if (is_hotspot()) {
1267 JavaThread* THREAD = JavaThread::current();
1268 HotSpotJVMCI::VMFlag::klass()->initialize(CHECK_(JVMCIObject()));
1269 oop obj = HotSpotJVMCI::VMFlag::klass()->allocate_instance(CHECK_(JVMCIObject()));
1270 HotSpotJVMCI::VMFlag::set_name(this, obj, HotSpotJVMCI::resolve(name));
1271 HotSpotJVMCI::VMFlag::set_type(this, obj, HotSpotJVMCI::resolve(type));
1272 HotSpotJVMCI::VMFlag::set_value(this, obj, HotSpotJVMCI::resolve(value));
1273 return wrap(obj);
1274 } else {
1275 JNIAccessMark jni(this);
1276 jobject result = jni()->NewObject(JNIJVMCI::VMFlag::clazz(),
1277 JNIJVMCI::VMFlag::constructor(),
1278 get_jobject(name), get_jobject(type), get_jobject(value));
1279 return wrap(result);
1280 }
1281 }
1282
1283 JVMCIObject JVMCIEnv::new_VMIntrinsicMethod(JVMCIObject declaringClass, JVMCIObject name, JVMCIObject descriptor, int id, JVMCI_TRAPS) {
1284 if (is_hotspot()) {
1285 JavaThread* THREAD = JavaThread::current();
1286 HotSpotJVMCI::VMIntrinsicMethod::klass()->initialize(CHECK_(JVMCIObject()));
1287 oop obj = HotSpotJVMCI::VMIntrinsicMethod::klass()->allocate_instance(CHECK_(JVMCIObject()));
1288 HotSpotJVMCI::VMIntrinsicMethod::set_declaringClass(this, obj, HotSpotJVMCI::resolve(declaringClass));
1289 HotSpotJVMCI::VMIntrinsicMethod::set_name(this, obj, HotSpotJVMCI::resolve(name));
1290 HotSpotJVMCI::VMIntrinsicMethod::set_descriptor(this, obj, HotSpotJVMCI::resolve(descriptor));
1291 HotSpotJVMCI::VMIntrinsicMethod::set_id(this, obj, id);
1292 return wrap(obj);
1293 } else {
1294 JNIAccessMark jni(this);
1295 jobject result = jni()->NewObject(JNIJVMCI::VMIntrinsicMethod::clazz(),
1296 JNIJVMCI::VMIntrinsicMethod::constructor(),
1297 get_jobject(declaringClass), get_jobject(name), get_jobject(descriptor), id);
1298 return wrap(result);
1299 }
1300 }
1301
1302 JVMCIObject JVMCIEnv::new_HotSpotStackFrameReference(JVMCI_TRAPS) {
1303 if (is_hotspot()) {
1304 JavaThread* THREAD = JavaThread::current();
1305 HotSpotJVMCI::HotSpotStackFrameReference::klass()->initialize(CHECK_(JVMCIObject()));
1306 oop obj = HotSpotJVMCI::HotSpotStackFrameReference::klass()->allocate_instance(CHECK_(JVMCIObject()));
1307 return wrap(obj);
1308 } else {
1309 ShouldNotReachHere();
1310 return JVMCIObject();
1311 }
1312 }
1313 JVMCIObject JVMCIEnv::new_JVMCIError(JVMCI_TRAPS) {
1314 if (is_hotspot()) {
1320 ShouldNotReachHere();
1321 return JVMCIObject();
1322 }
1323 }
1324
1325
1326 JVMCIObject JVMCIEnv::get_object_constant(oop objOop, bool compressed, bool dont_register) {
1327 JavaThread* THREAD = JavaThread::current();
1328 Handle obj = Handle(THREAD, objOop);
1329 if (obj.is_null()) {
1330 return JVMCIObject();
1331 }
1332 if (is_hotspot()) {
1333 HotSpotJVMCI::DirectHotSpotObjectConstantImpl::klass()->initialize(CHECK_(JVMCIObject()));
1334 oop constant = HotSpotJVMCI::DirectHotSpotObjectConstantImpl::klass()->allocate_instance(CHECK_(JVMCIObject()));
1335 HotSpotJVMCI::DirectHotSpotObjectConstantImpl::set_object(this, constant, obj());
1336 HotSpotJVMCI::HotSpotObjectConstantImpl::set_compressed(this, constant, compressed);
1337 return wrap(constant);
1338 } else {
1339 jlong handle = make_handle(obj);
1340 JNIAccessMark jni(this);
1341 jobject result = jni()->NewObject(JNIJVMCI::IndirectHotSpotObjectConstantImpl::clazz(),
1342 JNIJVMCI::IndirectHotSpotObjectConstantImpl::constructor(),
1343 handle, compressed, dont_register);
1344 return wrap(result);
1345 }
1346 }
1347
1348
1349 Handle JVMCIEnv::asConstant(JVMCIObject constant, JVMCI_TRAPS) {
1350 if (constant.is_null()) {
1351 return Handle();
1352 }
1353 JavaThread* THREAD = JavaThread::current();
1354 if (is_hotspot()) {
1355 assert(HotSpotJVMCI::DirectHotSpotObjectConstantImpl::is_instance(this, constant), "wrong type");
1356 oop obj = HotSpotJVMCI::DirectHotSpotObjectConstantImpl::object(this, HotSpotJVMCI::resolve(constant));
1357 return Handle(THREAD, obj);
1358 } else if (isa_IndirectHotSpotObjectConstantImpl(constant)) {
1359 jlong object_handle = get_IndirectHotSpotObjectConstantImpl_objectHandle(constant);
1360 if (object_handle == 0L) {
1361 JVMCI_THROW_MSG_(NullPointerException, "Foreign object reference has been cleared", Handle());
1362 }
1363 oop result = resolve_handle(object_handle);
1364 if (result == NULL) {
1365 JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly NULL", Handle());
1366 }
1367 return Handle(THREAD, result);
1368 } else {
1369 JVMCI_THROW_MSG_(IllegalArgumentException, "DirectHotSpotObjectConstantImpl shouldn't reach JVMCI in SVM mode", Handle());
1370 }
1371 }
1372
1373 JVMCIObject JVMCIEnv::wrap(jobject object) {
1374 return JVMCIObject::create(object, is_hotspot());
1375 }
1376
1377 jlong JVMCIEnv::make_handle(const Handle& obj) {
1378 assert(!obj.is_null(), "should only create handle for non-NULL oops");
1379 jobject handle = JVMCI::make_global(obj);
1380 return (jlong) handle;
1381 }
1382
1383 oop JVMCIEnv::resolve_handle(jlong objectHandle) {
1384 assert(objectHandle != 0, "should be a valid handle");
1385 oop obj = *((oopDesc**)objectHandle);
1386 if (obj != NULL) {
1387 obj->verify();
1388 }
1389 return obj;
1390 }
1391
1392 JVMCIObject JVMCIEnv::create_string(const char* str, JVMCI_TRAPS) {
1393 if (is_hotspot()) {
1394 JavaThread* THREAD = JavaThread::current();
1395 Handle result = java_lang_String::create_from_str(str, CHECK_(JVMCIObject()));
1396 return HotSpotJVMCI::wrap(result());
1397 } else {
1398 jobject result;
1399 jboolean exception = false;
1400 {
1401 JNIAccessMark jni(this);
1402 result = jni()->NewStringUTF(str);
1403 exception = jni()->ExceptionCheck();
1404 }
1405 return wrap(result);
1406 }
1407 }
1408
1409 bool JVMCIEnv::equals(JVMCIObject a, JVMCIObject b) {
1410 if (is_hotspot()) {
1411 return HotSpotJVMCI::resolve(a) == HotSpotJVMCI::resolve(b);
1412 } else {
1413 JNIAccessMark jni(this);
1414 return jni()->IsSameObject(a.as_jobject(), b.as_jobject()) != 0;
1415 }
1416 }
1417
1418 BasicType JVMCIEnv::kindToBasicType(JVMCIObject kind, JVMCI_TRAPS) {
1419 if (kind.is_null()) {
1420 JVMCI_THROW_(NullPointerException, T_ILLEGAL);
1421 }
|
51 bool JVMCICompileState::jvmti_state_changed() const {
52 if (!jvmti_can_access_local_variables() &&
53 JvmtiExport::can_access_local_variables()) {
54 return true;
55 }
56 if (!jvmti_can_hotswap_or_post_breakpoint() &&
57 JvmtiExport::can_hotswap_or_post_breakpoint()) {
58 return true;
59 }
60 if (!jvmti_can_post_on_exceptions() &&
61 JvmtiExport::can_post_on_exceptions()) {
62 return true;
63 }
64 if (!jvmti_can_pop_frame() &&
65 JvmtiExport::can_pop_frame()) {
66 return true;
67 }
68 return false;
69 }
70
71 void JVMCIEnv::copy_saved_properties() {
72 assert(!is_hotspot(), "can only copy saved properties from HotSpot to native image");
73
74 JavaThread* THREAD = JavaThread::current();
75
76 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::jdk_vm_ci_services_Services(), Handle(), Handle(), true, THREAD);
77 if (HAS_PENDING_EXCEPTION) {
78 JVMCIRuntime::exit_on_pending_exception(NULL, "Error initializing jdk.vm.ci.services.Services");
79 }
80 InstanceKlass* ik = InstanceKlass::cast(k);
81 if (ik->should_be_initialized()) {
82 ik->initialize(THREAD);
83 if (HAS_PENDING_EXCEPTION) {
84 JVMCIRuntime::exit_on_pending_exception(NULL, "Error initializing jdk.vm.ci.services.Services");
85 }
86 }
87
88 // Get the serialized saved properties from HotSpot
89 TempNewSymbol serializeSavedProperties = SymbolTable::new_symbol("serializeSavedProperties", CHECK_EXIT);
90 JavaValue result(T_OBJECT);
101
102 // Copy serialized saved properties from HotSpot object into native buffer
103 jbyte* serialized_properties = NEW_RESOURCE_ARRAY(jbyte, serialized_properties_len);
104 memcpy(serialized_properties, ba->byte_at_addr(0), serialized_properties_len);
105
106 // Copy native buffer into shared library object
107 JVMCIPrimitiveArray buf = new_byteArray(serialized_properties_len, this);
108 if (has_pending_exception()) {
109 describe_pending_exception(true);
110 fatal("Error in copy_saved_properties");
111 }
112 copy_bytes_from(serialized_properties, buf, 0, serialized_properties_len);
113 if (has_pending_exception()) {
114 describe_pending_exception(true);
115 fatal("Error in copy_saved_properties");
116 }
117
118 // Initialize saved properties in shared library
119 jclass servicesClass = JNIJVMCI::Services::clazz();
120 jmethodID initializeSavedProperties = JNIJVMCI::Services::initializeSavedProperties_method();
121 JNIAccessMark jni(this, THREAD);
122 jni()->CallStaticVoidMethod(servicesClass, initializeSavedProperties, buf.as_jobject());
123 if (jni()->ExceptionCheck()) {
124 jni()->ExceptionDescribe();
125 fatal("Error calling jdk.vm.ci.services.Services.initializeSavedProperties");
126 }
127 }
128
129 void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env) {
130 assert(thread != NULL, "npe");
131 _env = NULL;
132 _pop_frame_on_close = false;
133 _detach_on_close = false;
134 if (!UseJVMCINativeLibrary) {
135 // In HotSpot mode, JNI isn't used at all.
136 _runtime = JVMCI::java_runtime();
137 _is_hotspot = true;
138 return;
139 }
140
141 if (parent_env != NULL) {
142 // If the parent JNI environment is non-null then figure out whether it
143 // is a HotSpot or shared library JNIEnv and set the state appropriately.
144 _is_hotspot = thread->jni_environment() == parent_env;
145 if (_is_hotspot) {
146 // Select the Java runtime
147 _runtime = JVMCI::java_runtime();
148 return;
149 }
150 _runtime = JVMCI::compiler_runtime();
151 assert(_runtime != NULL, "npe");
152 _env = parent_env;
153 return;
154 }
155
156 // Running in JVMCI shared library mode so ensure the shared library
157 // is loaded and initialized and get a shared library JNIEnv
158 _is_hotspot = false;
159
160 _runtime = JVMCI::compiler_runtime();
161 _env = _runtime->init_shared_library_javavm();
162
163 if (_env != NULL) {
164 // Creating the JVMCI shared library VM also attaches the current thread
165 _detach_on_close = true;
166 } else {
167 _runtime->GetEnv(thread, (void**)&parent_env, JNI_VERSION_1_2);
168 if (parent_env != NULL) {
169 // Even though there's a parent JNI env, there's no guarantee
170 // it was opened by a JVMCIEnv scope and thus may not have
171 // pushed a local JNI frame. As such, we use a new JNI local
172 // frame in this scope to ensure local JNI refs are collected
173 // in a timely manner after leaving this scope.
174 _env = parent_env;
175 } else {
176 ResourceMark rm; // Thread name is resource allocated
177 JavaVMAttachArgs attach_args;
178 attach_args.version = JNI_VERSION_1_2;
179 attach_args.name = thread->name();
180 attach_args.group = NULL;
181 if (_runtime->AttachCurrentThread(thread, (void**) &_env, &attach_args) != JNI_OK) {
182 fatal("Error attaching current thread (%s) to JVMCI shared library JNI interface", attach_args.name);
183 }
184 _detach_on_close = true;
185 }
186 }
187
188 assert(_env != NULL, "missing env");
189 assert(_throw_to_caller == false, "must be");
190
191 JNIAccessMark jni(this, thread);
192 jint result = _env->PushLocalFrame(32);
193 if (result != JNI_OK) {
194 char message[256];
195 jio_snprintf(message, 256, "Uncaught exception pushing local frame for JVMCIEnv scope entered at %s:%d", _file, _line);
196 JVMCIRuntime::exit_on_pending_exception(this, message);
197 }
198 _pop_frame_on_close = true;
199 }
200
201 JVMCIEnv::JVMCIEnv(JavaThread* thread, JVMCICompileState* compile_state, const char* file, int line):
202 _throw_to_caller(false), _file(file), _line(line), _compile_state(compile_state) {
203 init_env_mode_runtime(thread, NULL);
204 }
205
206 JVMCIEnv::JVMCIEnv(JavaThread* thread, const char* file, int line):
207 _throw_to_caller(false), _file(file), _line(line), _compile_state(NULL) {
208 init_env_mode_runtime(thread, NULL);
209 }
210
211 JVMCIEnv::JVMCIEnv(JavaThread* thread, JNIEnv* parent_env, const char* file, int line):
215 }
216
217 void JVMCIEnv::init(JavaThread* thread, bool is_hotspot, const char* file, int line) {
218 _compile_state = NULL;
219 _throw_to_caller = false;
220 _file = file;
221 _line = line;
222 if (is_hotspot) {
223 _env = NULL;
224 _pop_frame_on_close = false;
225 _detach_on_close = false;
226 _is_hotspot = true;
227 _runtime = JVMCI::java_runtime();
228 } else {
229 init_env_mode_runtime(thread, NULL);
230 }
231 }
232
233 // Prints a pending exception (if any) and its stack trace.
234 void JVMCIEnv::describe_pending_exception(bool clear) {
235 Thread* THREAD = Thread::current();
236 if (!is_hotspot()) {
237 JNIAccessMark jni(this);
238 if (jni()->ExceptionCheck()) {
239 jthrowable ex = !clear ? jni()->ExceptionOccurred() : NULL;
240 jni()->ExceptionDescribe();
241 if (ex != NULL) {
242 jni()->Throw(ex);
243 }
244 }
245 } else {
246 if (HAS_PENDING_EXCEPTION) {
247 JVMCIRuntime::describe_pending_hotspot_exception((JavaThread*) THREAD, clear);
248 }
249 }
250 }
251
252 void JVMCIEnv::translate_hotspot_exception_to_jni_exception(JavaThread* THREAD, const Handle& throwable) {
253 assert(!is_hotspot(), "must_be");
254 // Resolve HotSpotJVMCIRuntime class explicitly as HotSpotJVMCI::compute_offsets
255 // may not have been called.
256 Klass* runtimeKlass = SystemDictionary::resolve_or_fail(vmSymbols::jdk_vm_ci_hotspot_HotSpotJVMCIRuntime(), true, CHECK);
257 JavaCallArguments jargs;
258 jargs.push_oop(throwable);
259 JavaValue result(T_OBJECT);
260 JavaCalls::call_static(&result,
261 runtimeKlass,
262 vmSymbols::encodeThrowable_name(),
263 vmSymbols::encodeThrowable_signature(), &jargs, THREAD);
264 if (HAS_PENDING_EXCEPTION) {
265 JVMCIRuntime::exit_on_pending_exception(this, "HotSpotJVMCIRuntime.encodeThrowable should not throw an exception");
266 }
267
268 oop encoded_throwable_string = (oop) result.get_jobject();
269
270 ResourceMark rm;
271 const char* encoded_throwable_chars = java_lang_String::as_utf8_string(encoded_throwable_string);
272
273 JNIAccessMark jni(this, THREAD);
274 jobject jni_encoded_throwable_string = jni()->NewStringUTF(encoded_throwable_chars);
275 jthrowable jni_throwable = (jthrowable) jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(),
276 JNIJVMCI::HotSpotJVMCIRuntime::decodeThrowable_method(),
277 jni_encoded_throwable_string);
278 jni()->Throw(jni_throwable);
279 }
280
281 JVMCIEnv::~JVMCIEnv() {
282 if (_throw_to_caller) {
283 if (is_hotspot()) {
284 // Nothing to do
285 } else {
286 if (Thread::current()->is_Java_thread()) {
287 JavaThread* THREAD = JavaThread::current();
288 if (HAS_PENDING_EXCEPTION) {
289 Handle throwable = Handle(THREAD, PENDING_EXCEPTION);
290 CLEAR_PENDING_EXCEPTION;
291 translate_hotspot_exception_to_jni_exception(THREAD, throwable);
292 }
293 }
294 }
295 } else {
296 if (_pop_frame_on_close) {
297 // Pop the JNI local frame that was pushed when entering this JVMCIEnv scope.
298 JNIAccessMark jni(this);
299 jni()->PopLocalFrame(NULL);
300 }
301
302 if (has_pending_exception()) {
303 char message[256];
304 jio_snprintf(message, 256, "Uncaught exception exiting JVMCIEnv scope entered at %s:%d", _file, _line);
305 JVMCIRuntime::exit_on_pending_exception(this, message);
306 }
307
308 if (_detach_on_close) {
309 _runtime->DetachCurrentThread(JavaThread::current());
310 }
311 }
312 }
313
314 jboolean JVMCIEnv::has_pending_exception() {
315 if (is_hotspot()) {
316 Thread* THREAD = Thread::current();
317 return HAS_PENDING_EXCEPTION;
318 } else {
319 JNIAccessMark jni(this);
320 return jni()->ExceptionCheck();
321 }
322 }
323
324 void JVMCIEnv::clear_pending_exception() {
325 if (is_hotspot()) {
326 Thread* THREAD = Thread::current();
327 CLEAR_PENDING_EXCEPTION;
328 } else {
329 JNIAccessMark jni(this);
524 if (jni()->IsSameObject(clazz, JNIJVMCI::box_class(T_DOUBLE))) return T_DOUBLE;
525 return T_ILLEGAL;
526 }
527 }
528
529 // Create a boxing object of the appropriate primitive type.
530 JVMCIObject JVMCIEnv::create_box(BasicType type, jvalue* value, JVMCI_TRAPS) {
531 switch (type) {
532 case T_BOOLEAN:
533 case T_BYTE:
534 case T_CHAR:
535 case T_SHORT:
536 case T_INT:
537 case T_LONG:
538 case T_FLOAT:
539 case T_DOUBLE:
540 break;
541 default:
542 JVMCI_THROW_MSG_(IllegalArgumentException, "Only boxes for primitive values can be created", JVMCIObject());
543 }
544 JavaThread* THREAD = JavaThread::current();
545 if (is_hotspot()) {
546 oop box = java_lang_boxing_object::create(type, value, CHECK_(JVMCIObject()));
547 return HotSpotJVMCI::wrap(box);
548 } else {
549 JNIAccessMark jni(this, THREAD);
550 jobject box = jni()->NewObjectA(JNIJVMCI::box_class(type), JNIJVMCI::box_constructor(type), value);
551 assert(box != NULL, "");
552 return wrap(box);
553 }
554 }
555
556 const char* JVMCIEnv::as_utf8_string(JVMCIObject str) {
557 if (is_hotspot()) {
558 return java_lang_String::as_utf8_string(HotSpotJVMCI::resolve(str));
559 } else {
560 JNIAccessMark jni(this);
561 int length = jni()->GetStringLength(str.as_jstring());
562 char* result = NEW_RESOURCE_ARRAY(char, length + 1);
563 jni()->GetStringUTFRegion(str.as_jstring(), 0, length, result);
564 return result;
565 }
566 }
567
568 char* JVMCIEnv::as_utf8_string(JVMCIObject str, char* buf, int buflen) {
569 if (is_hotspot()) {
593 DO_THROW(InternalError)
594 DO_THROW(ArrayIndexOutOfBoundsException)
595 DO_THROW(IllegalStateException)
596 DO_THROW(NullPointerException)
597 DO_THROW(IllegalArgumentException)
598 DO_THROW(InvalidInstalledCodeException)
599 DO_THROW(UnsatisfiedLinkError)
600 DO_THROW(UnsupportedOperationException)
601 DO_THROW(ClassNotFoundException)
602
603 #undef DO_THROW
604
605 void JVMCIEnv::fthrow_error(const char* file, int line, const char* format, ...) {
606 const int max_msg_size = 1024;
607 va_list ap;
608 va_start(ap, format);
609 char msg[max_msg_size];
610 vsnprintf(msg, max_msg_size, format, ap);
611 msg[max_msg_size-1] = '\0';
612 va_end(ap);
613 JavaThread* THREAD = JavaThread::current();
614 if (is_hotspot()) {
615 Handle h_loader = Handle();
616 Handle h_protection_domain = Handle();
617 Exceptions::_throw_msg(THREAD, file, line, vmSymbols::jdk_vm_ci_common_JVMCIError(), msg, h_loader, h_protection_domain);
618 } else {
619 JNIAccessMark jni(this, THREAD);
620 jni()->ThrowNew(JNIJVMCI::JVMCIError::clazz(), msg);
621 }
622 }
623
624 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_compileMethod (JVMCIObject runtime, JVMCIObject method, int entry_bci,
625 jlong compile_state, int id) {
626 if (is_hotspot()) {
627 Thread* THREAD = Thread::current();
628 JavaCallArguments jargs;
629 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
630 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(method)));
631 jargs.push_int(entry_bci);
632 jargs.push_long(compile_state);
633 jargs.push_int(id);
634 JavaValue result(T_OBJECT);
635 JavaCalls::call_special(&result,
636 HotSpotJVMCI::HotSpotJVMCIRuntime::klass(),
637 vmSymbols::compileMethod_name(),
638 vmSymbols::compileMethod_signature(), &jargs, CHECK_(JVMCIObject()));
639 return wrap((oop) result.get_jobject());
656 JavaCallArguments jargs;
657 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
658 JavaValue result(T_VOID);
659 JavaCalls::call_special(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::bootstrapFinished_name(), vmSymbols::void_method_signature(), &jargs, CHECK);
660 } else {
661 JNIAccessMark jni(this);
662 jni()->CallNonvirtualVoidMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::bootstrapFinished_method());
663
664 }
665 }
666
667 void JVMCIEnv::call_HotSpotJVMCIRuntime_shutdown (JVMCIObject runtime) {
668 HandleMark hm;
669 JavaThread* THREAD = JavaThread::current();
670 if (is_hotspot()) {
671 JavaCallArguments jargs;
672 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
673 JavaValue result(T_VOID);
674 JavaCalls::call_special(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::shutdown_name(), vmSymbols::void_method_signature(), &jargs, THREAD);
675 } else {
676 JNIAccessMark jni(this, THREAD);
677 jni()->CallNonvirtualVoidMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::shutdown_method());
678 }
679 if (has_pending_exception()) {
680 // This should never happen as HotSpotJVMCIRuntime.shutdown() should
681 // handle all exceptions.
682 describe_pending_exception(true);
683 }
684 }
685
686 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_runtime (JVMCIEnv* JVMCIENV) {
687 JavaThread* THREAD = JavaThread::current();
688 if (is_hotspot()) {
689 JavaCallArguments jargs;
690 JavaValue result(T_OBJECT);
691 JavaCalls::call_static(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::runtime_name(), vmSymbols::runtime_signature(), &jargs, CHECK_(JVMCIObject()));
692 return wrap((oop) result.get_jobject());
693 } else {
694 JNIAccessMark jni(this, THREAD);
695 jobject result = jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::runtime_method());
696 if (jni()->ExceptionCheck()) {
697 return JVMCIObject();
698 }
699 return wrap(result);
700 }
701 }
702
703 JVMCIObject JVMCIEnv::call_JVMCI_getRuntime (JVMCIEnv* JVMCIENV) {
704 JavaThread* THREAD = JavaThread::current();
705 if (is_hotspot()) {
706 JavaCallArguments jargs;
707 JavaValue result(T_OBJECT);
708 JavaCalls::call_static(&result, HotSpotJVMCI::JVMCI::klass(), vmSymbols::getRuntime_name(), vmSymbols::getRuntime_signature(), &jargs, CHECK_(JVMCIObject()));
709 return wrap((oop) result.get_jobject());
710 } else {
711 JNIAccessMark jni(this, THREAD);
712 jobject result = jni()->CallStaticObjectMethod(JNIJVMCI::JVMCI::clazz(), JNIJVMCI::JVMCI::getRuntime_method());
713 if (jni()->ExceptionCheck()) {
714 return JVMCIObject();
715 }
716 return wrap(result);
717 }
718 }
719
720 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_getCompiler (JVMCIObject runtime, JVMCIEnv* JVMCIENV) {
721 JavaThread* THREAD = JavaThread::current();
722 if (is_hotspot()) {
723 JavaCallArguments jargs;
724 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
725 JavaValue result(T_OBJECT);
726 JavaCalls::call_virtual(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::getCompiler_name(), vmSymbols::getCompiler_signature(), &jargs, CHECK_(JVMCIObject()));
727 return wrap((oop) result.get_jobject());
728 } else {
729 JNIAccessMark jni(this, THREAD);
730 jobject result = jni()->CallObjectMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::getCompiler_method());
731 if (jni()->ExceptionCheck()) {
732 return JVMCIObject();
733 }
734 return wrap(result);
735 }
736 }
737
738
739 JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_callToString(JVMCIObject object, JVMCIEnv* JVMCIENV) {
740 JavaThread* THREAD = JavaThread::current();
741 if (is_hotspot()) {
742 JavaCallArguments jargs;
743 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(object)));
744 JavaValue result(T_OBJECT);
745 JavaCalls::call_static(&result,
746 HotSpotJVMCI::HotSpotJVMCIRuntime::klass(),
747 vmSymbols::callToString_name(),
748 vmSymbols::callToString_signature(), &jargs, CHECK_(JVMCIObject()));
749 return wrap((oop) result.get_jobject());
750 } else {
751 JNIAccessMark jni(this, THREAD);
752 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(),
753 JNIJVMCI::HotSpotJVMCIRuntime::callToString_method(),
754 object.as_jobject());
755 if (jni()->ExceptionCheck()) {
756 return JVMCIObject();
757 }
758 return wrap(result);
759 }
760 }
761
762
763 JVMCIObject JVMCIEnv::call_PrimitiveConstant_forTypeChar(jchar kind, jlong value, JVMCI_TRAPS) {
764 JavaThread* THREAD = JavaThread::current();
765 if (is_hotspot()) {
766 JavaCallArguments jargs;
767 jargs.push_int(kind);
768 jargs.push_long(value);
769 JavaValue result(T_OBJECT);
770 JavaCalls::call_static(&result,
771 HotSpotJVMCI::PrimitiveConstant::klass(),
772 vmSymbols::forTypeChar_name(),
773 vmSymbols::forTypeChar_signature(), &jargs, CHECK_(JVMCIObject()));
774 return wrap((oop) result.get_jobject());
775 } else {
776 JNIAccessMark jni(this, THREAD);
777 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::PrimitiveConstant::clazz(),
778 JNIJVMCI::PrimitiveConstant::forTypeChar_method(),
779 kind, value);
780 if (jni()->ExceptionCheck()) {
781 return JVMCIObject();
782 }
783 return wrap(result);
784 }
785 }
786
787 JVMCIObject JVMCIEnv::call_JavaConstant_forFloat(float value, JVMCI_TRAPS) {
788 JavaThread* THREAD = JavaThread::current();
789 if (is_hotspot()) {
790 JavaCallArguments jargs;
791 jargs.push_float(value);
792 JavaValue result(T_OBJECT);
793 JavaCalls::call_static(&result,
794 HotSpotJVMCI::JavaConstant::klass(),
795 vmSymbols::forFloat_name(),
796 vmSymbols::forFloat_signature(), &jargs, CHECK_(JVMCIObject()));
797 return wrap((oop) result.get_jobject());
798 } else {
799 JNIAccessMark jni(this, THREAD);
800 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::JavaConstant::clazz(),
801 JNIJVMCI::JavaConstant::forFloat_method(),
802 value);
803 if (jni()->ExceptionCheck()) {
804 return JVMCIObject();
805 }
806 return wrap(result);
807 }
808 }
809
810 JVMCIObject JVMCIEnv::call_JavaConstant_forDouble(double value, JVMCI_TRAPS) {
811 JavaThread* THREAD = JavaThread::current();
812 if (is_hotspot()) {
813 JavaCallArguments jargs;
814 jargs.push_double(value);
815 JavaValue result(T_OBJECT);
816 JavaCalls::call_static(&result,
817 HotSpotJVMCI::JavaConstant::klass(),
818 vmSymbols::forDouble_name(),
819 vmSymbols::forDouble_signature(), &jargs, CHECK_(JVMCIObject()));
820 return wrap((oop) result.get_jobject());
821 } else {
822 JNIAccessMark jni(this, THREAD);
823 jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::JavaConstant::clazz(),
824 JNIJVMCI::JavaConstant::forDouble_method(),
825 value);
826 if (jni()->ExceptionCheck()) {
827 return JVMCIObject();
828 }
829 return wrap(result);
830 }
831 }
832
833 JVMCIObject JVMCIEnv::get_jvmci_primitive_type(BasicType type) {
834 JVMCIObjectArray primitives = get_HotSpotResolvedPrimitiveType_primitives();
835 JVMCIObject result = get_object_at(primitives, type);
836 return result;
837 }
838
839 JVMCIObject JVMCIEnv::new_StackTraceElement(const methodHandle& method, int bci, JVMCI_TRAPS) {
840 JavaThread* THREAD = JavaThread::current();
841 Symbol* file_name_sym;
842 int line_number;
847 const char* declaring_class_str = holder->external_name();
848
849 if (is_hotspot()) {
850 HotSpotJVMCI::StackTraceElement::klass()->initialize(CHECK_(JVMCIObject()));
851 oop objOop = HotSpotJVMCI::StackTraceElement::klass()->allocate_instance(CHECK_(JVMCIObject()));
852 Handle obj = Handle(THREAD, objOop);
853
854 oop declaring_class = StringTable::intern((char*) declaring_class_str, CHECK_(JVMCIObject()));
855 HotSpotJVMCI::StackTraceElement::set_declaringClass(this, obj(), declaring_class);
856
857 oop method_name = StringTable::intern(method_name_sym, CHECK_(JVMCIObject()));
858 HotSpotJVMCI::StackTraceElement::set_methodName(this, obj(), method_name);
859
860 if (file_name_sym != NULL) {
861 oop file_name = StringTable::intern(file_name_sym, CHECK_(JVMCIObject()));
862 HotSpotJVMCI::StackTraceElement::set_fileName(this, obj(), file_name);
863 }
864 HotSpotJVMCI::StackTraceElement::set_lineNumber(this, obj(), line_number);
865 return wrap(obj());
866 } else {
867 JNIAccessMark jni(this, THREAD);
868 jobject declaring_class = jni()->NewStringUTF(declaring_class_str);
869 if (jni()->ExceptionCheck()) {
870 return JVMCIObject();
871 }
872 jobject method_name = jni()->NewStringUTF(method_name_sym->as_C_string());
873 if (jni()->ExceptionCheck()) {
874 return JVMCIObject();
875 }
876 jobject file_name = NULL;
877 if (file_name_sym != NULL) {
878 file_name = jni()->NewStringUTF(file_name_sym->as_C_string());
879 if (jni()->ExceptionCheck()) {
880 return JVMCIObject();
881 }
882 }
883
884 jobject result = jni()->NewObject(JNIJVMCI::StackTraceElement::clazz(),
885 JNIJVMCI::StackTraceElement::constructor(),
886 declaring_class, method_name, file_name, line_number);
887 return wrap(result);
899 ik->initialize(CHECK_(JVMCIObject()));
900 }
901 oop obj = ik->allocate_instance(CHECK_(JVMCIObject()));
902 Handle obj_h(THREAD, obj);
903 Handle nameStr = java_lang_String::create_from_str(name, CHECK_(JVMCIObject()));
904
905 // Call constructor
906 JavaCallArguments jargs;
907 jargs.push_oop(obj_h);
908 jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(methodObject)));
909 jargs.push_oop(nameStr);
910 jargs.push_int(isDefault);
911 jargs.push_long(compileId);
912 JavaValue result(T_VOID);
913 JavaCalls::call_special(&result, ik,
914 vmSymbols::object_initializer_name(),
915 vmSymbols::method_string_bool_long_signature(),
916 &jargs, CHECK_(JVMCIObject()));
917 return wrap(obj_h());
918 } else {
919 JNIAccessMark jni(this, THREAD);
920 jobject nameStr = name == NULL ? NULL : jni()->NewStringUTF(name);
921 if (jni()->ExceptionCheck()) {
922 return JVMCIObject();
923 }
924
925 jobject result = jni()->NewObject(JNIJVMCI::HotSpotNmethod::clazz(),
926 JNIJVMCI::HotSpotNmethod::constructor(),
927 methodObject.as_jobject(), nameStr, isDefault);
928 return wrap(result);
929 }
930 }
931
932 JVMCIObject JVMCIEnv::make_local(JVMCIObject object) {
933 if (object.is_null()) {
934 return JVMCIObject();
935 }
936 if (is_hotspot()) {
937 return wrap(JNIHandles::make_local(HotSpotJVMCI::resolve(object)));
938 } else {
939 JNIAccessMark jni(this);
940 return wrap(jni()->NewLocalRef(object.as_jobject()));
941 }
942 }
943
944 JVMCIObject JVMCIEnv::make_global(JVMCIObject object) {
945 if (object.is_null()) {
946 return JVMCIObject();
947 }
948 if (is_hotspot()) {
949 return wrap(JNIHandles::make_global(Handle(Thread::current(), HotSpotJVMCI::resolve(object))));
950 } else {
951 JNIAccessMark jni(this);
952 return wrap(jni()->NewGlobalRef(object.as_jobject()));
953 }
954 }
955
956 void JVMCIEnv::destroy_local(JVMCIObject object) {
957 if (is_hotspot()) {
958 JNIHandles::destroy_local(object.as_jobject());
959 } else {
960 JNIAccessMark jni(this);
961 jni()->DeleteLocalRef(object.as_jobject());
962 }
963 }
964
965 void JVMCIEnv::destroy_global(JVMCIObject object) {
966 if (is_hotspot()) {
967 JNIHandles::destroy_global(object.as_jobject());
968 } else {
969 JNIAccessMark jni(this);
970 jni()->DeleteGlobalRef(object.as_jobject());
971 }
972 }
973
974 const char* JVMCIEnv::klass_name(JVMCIObject object) {
975 if (is_hotspot()) {
976 return HotSpotJVMCI::resolve(object)->klass()->signature_name();
977 } else {
978 JVMCIObject name;
979 {
980 JNIAccessMark jni(this);
981 jclass jcl = jni()->GetObjectClass(object.as_jobject());
982 jobject result = jni()->CallObjectMethod(jcl, JNIJVMCI::Class_getName_method());
983 name = JVMCIObject::create(result, is_hotspot());
984 }
985 return as_utf8_string(name);
986 }
987 }
988
989 JVMCIObject JVMCIEnv::get_jvmci_method(const methodHandle& method, JVMCI_TRAPS) {
990 JVMCIObject method_object;
991 if (method() == NULL) {
992 return method_object;
993 }
994
995 Thread* THREAD = Thread::current();
996 jmetadata handle = _runtime->allocate_handle(method);
997 jboolean exception = false;
998 if (is_hotspot()) {
999 JavaValue result(T_OBJECT);
1000 JavaCallArguments args;
1001 args.push_long((jlong) handle);
1002 JavaCalls::call_static(&result, HotSpotJVMCI::HotSpotResolvedJavaMethodImpl::klass(),
1003 vmSymbols::fromMetaspace_name(),
1004 vmSymbols::method_fromMetaspace_signature(), &args, THREAD);
1005 if (HAS_PENDING_EXCEPTION) {
1006 exception = true;
1007 } else {
1008 method_object = wrap((oop)result.get_jobject());
1009 }
1010 } else {
1011 JNIAccessMark jni(this);
1012 method_object = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotResolvedJavaMethodImpl::clazz(),
1013 JNIJVMCI::HotSpotResolvedJavaMethodImpl_fromMetaspace_method(),
1014 (jlong) handle));
1015 exception = jni()->ExceptionCheck();
1016 }
1017
1018 if (exception) {
1019 _runtime->release_handle(handle);
1020 return JVMCIObject();
1021 }
1022
1023 assert(asMethod(method_object) == method(), "must be");
1024 if (get_HotSpotResolvedJavaMethodImpl_metadataHandle(method_object) != (jlong) handle) {
1025 _runtime->release_handle(handle);
1026 }
1027 assert(!method_object.is_null(), "must be");
1028 return method_object;
1029 }
1030
1031 JVMCIObject JVMCIEnv::get_jvmci_type(const JVMCIKlassHandle& klass, JVMCI_TRAPS) {
1032 JVMCIObject type;
1033 if (klass.is_null()) {
1034 return type;
1035 }
1036
1037 jlong pointer = (jlong) klass();
1038 JavaThread* THREAD = JavaThread::current();
1039 JVMCIObject signature = create_string(klass->signature_name(), JVMCI_CHECK_(JVMCIObject()));
1040 jboolean exception = false;
1041 if (is_hotspot()) {
1042 JavaValue result(T_OBJECT);
1043 JavaCallArguments args;
1044 args.push_long(pointer);
1045 args.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(signature)));
1046 JavaCalls::call_static(&result,
1047 HotSpotJVMCI::HotSpotResolvedObjectTypeImpl::klass(),
1048 vmSymbols::fromMetaspace_name(),
1049 vmSymbols::klass_fromMetaspace_signature(), &args, THREAD);
1050
1051 if (HAS_PENDING_EXCEPTION) {
1052 exception = true;
1053 } else {
1054 type = wrap((oop)result.get_jobject());
1055 }
1056 } else {
1057 JNIAccessMark jni(this, THREAD);
1058
1059 HandleMark hm(THREAD);
1060 type = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotResolvedObjectTypeImpl::clazz(),
1061 JNIJVMCI::HotSpotResolvedObjectTypeImpl_fromMetaspace_method(),
1062 pointer, signature.as_jstring()));
1063 exception = jni()->ExceptionCheck();
1064 }
1065 if (exception) {
1066 return JVMCIObject();
1067 }
1068
1069 assert(type.is_non_null(), "must have result");
1070 return type;
1071 }
1072
1073 JVMCIObject JVMCIEnv::get_jvmci_constant_pool(const constantPoolHandle& cp, JVMCI_TRAPS) {
1074 JVMCIObject cp_object;
1075 jmetadata handle = _runtime->allocate_handle(cp);
1076 jboolean exception = false;
1077 JavaThread* THREAD = JavaThread::current();
1078 if (is_hotspot()) {
1079 JavaValue result(T_OBJECT);
1080 JavaCallArguments args;
1081 args.push_long((jlong) handle);
1082 JavaCalls::call_static(&result,
1083 HotSpotJVMCI::HotSpotConstantPool::klass(),
1084 vmSymbols::fromMetaspace_name(),
1085 vmSymbols::constantPool_fromMetaspace_signature(), &args, THREAD);
1086 if (HAS_PENDING_EXCEPTION) {
1087 exception = true;
1088 } else {
1089 cp_object = wrap((oop)result.get_jobject());
1090 }
1091 } else {
1092 JNIAccessMark jni(this, THREAD);
1093 cp_object = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotConstantPool::clazz(),
1094 JNIJVMCI::HotSpotConstantPool_fromMetaspace_method(),
1095 (jlong) handle));
1096 exception = jni()->ExceptionCheck();
1097 }
1098
1099 if (exception) {
1100 _runtime->release_handle(handle);
1101 return JVMCIObject();
1102 }
1103
1104 assert(!cp_object.is_null(), "must be");
1105 // Constant pools aren't cached so this is always a newly created object using the handle
1106 assert(get_HotSpotConstantPool_metadataHandle(cp_object) == (jlong) handle, "must use same handle");
1107 return cp_object;
1108 }
1109
1110 JVMCIPrimitiveArray JVMCIEnv::new_booleanArray(int length, JVMCI_TRAPS) {
1111 JavaThread* THREAD = JavaThread::current();
1112 if (is_hotspot()) {
1113 typeArrayOop result = oopFactory::new_boolArray(length, CHECK_(JVMCIObject()));
1114 return wrap(result);
1115 } else {
1116 JNIAccessMark jni(this, THREAD);
1117 jbooleanArray result = jni()->NewBooleanArray(length);
1118 return wrap(result);
1119 }
1120 }
1121
1122 JVMCIPrimitiveArray JVMCIEnv::new_byteArray(int length, JVMCI_TRAPS) {
1123 JavaThread* THREAD = JavaThread::current();
1124 if (is_hotspot()) {
1125 typeArrayOop result = oopFactory::new_byteArray(length, CHECK_(JVMCIObject()));
1126 return wrap(result);
1127 } else {
1128 JNIAccessMark jni(this, THREAD);
1129 jbyteArray result = jni()->NewByteArray(length);
1130 return wrap(result);
1131 }
1132 }
1133
1134 JVMCIObjectArray JVMCIEnv::new_byte_array_array(int length, JVMCI_TRAPS) {
1135 JavaThread* THREAD = JavaThread::current();
1136 if (is_hotspot()) {
1137 Klass* byteArrayArrayKlass = TypeArrayKlass::cast(Universe::byteArrayKlassObj ())->array_klass(CHECK_(JVMCIObject()));
1138 objArrayOop result = ObjArrayKlass::cast(byteArrayArrayKlass) ->allocate(length, CHECK_(JVMCIObject()));
1139 return wrap(result);
1140 } else {
1141 JNIAccessMark jni(this, THREAD);
1142 jobjectArray result = jni()->NewObjectArray(length, JNIJVMCI::byte_array(), NULL);
1143 return wrap(result);
1144 }
1145 }
1146
1147 JVMCIPrimitiveArray JVMCIEnv::new_intArray(int length, JVMCI_TRAPS) {
1148 JavaThread* THREAD = JavaThread::current();
1149 if (is_hotspot()) {
1150 typeArrayOop result = oopFactory::new_intArray(length, CHECK_(JVMCIObject()));
1151 return wrap(result);
1152 } else {
1153 JNIAccessMark jni(this, THREAD);
1154 jintArray result = jni()->NewIntArray(length);
1155 return wrap(result);
1156 }
1157 }
1158
1159 JVMCIPrimitiveArray JVMCIEnv::new_longArray(int length, JVMCI_TRAPS) {
1160 JavaThread* THREAD = JavaThread::current();
1161 if (is_hotspot()) {
1162 typeArrayOop result = oopFactory::new_longArray(length, CHECK_(JVMCIObject()));
1163 return wrap(result);
1164 } else {
1165 JNIAccessMark jni(this, THREAD);
1166 jlongArray result = jni()->NewLongArray(length);
1167 return wrap(result);
1168 }
1169 }
1170
1171 JVMCIObject JVMCIEnv::new_VMField(JVMCIObject name, JVMCIObject type, jlong offset, jlong address, JVMCIObject value, JVMCI_TRAPS) {
1172 JavaThread* THREAD = JavaThread::current();
1173 if (is_hotspot()) {
1174 HotSpotJVMCI::VMField::klass()->initialize(CHECK_(JVMCIObject()));
1175 oop obj = HotSpotJVMCI::VMField::klass()->allocate_instance(CHECK_(JVMCIObject()));
1176 HotSpotJVMCI::VMField::set_name(this, obj, HotSpotJVMCI::resolve(name));
1177 HotSpotJVMCI::VMField::set_type(this, obj, HotSpotJVMCI::resolve(type));
1178 HotSpotJVMCI::VMField::set_offset(this, obj, offset);
1179 HotSpotJVMCI::VMField::set_address(this, obj, address);
1180 HotSpotJVMCI::VMField::set_value(this, obj, HotSpotJVMCI::resolve(value));
1181 return wrap(obj);
1182 } else {
1183 JNIAccessMark jni(this, THREAD);
1184 jobject result = jni()->NewObject(JNIJVMCI::VMField::clazz(),
1185 JNIJVMCI::VMField::constructor(),
1186 get_jobject(name), get_jobject(type), offset, address, get_jobject(value));
1187 return wrap(result);
1188 }
1189 }
1190
1191 JVMCIObject JVMCIEnv::new_VMFlag(JVMCIObject name, JVMCIObject type, JVMCIObject value, JVMCI_TRAPS) {
1192 JavaThread* THREAD = JavaThread::current();
1193 if (is_hotspot()) {
1194 HotSpotJVMCI::VMFlag::klass()->initialize(CHECK_(JVMCIObject()));
1195 oop obj = HotSpotJVMCI::VMFlag::klass()->allocate_instance(CHECK_(JVMCIObject()));
1196 HotSpotJVMCI::VMFlag::set_name(this, obj, HotSpotJVMCI::resolve(name));
1197 HotSpotJVMCI::VMFlag::set_type(this, obj, HotSpotJVMCI::resolve(type));
1198 HotSpotJVMCI::VMFlag::set_value(this, obj, HotSpotJVMCI::resolve(value));
1199 return wrap(obj);
1200 } else {
1201 JNIAccessMark jni(this, THREAD);
1202 jobject result = jni()->NewObject(JNIJVMCI::VMFlag::clazz(),
1203 JNIJVMCI::VMFlag::constructor(),
1204 get_jobject(name), get_jobject(type), get_jobject(value));
1205 return wrap(result);
1206 }
1207 }
1208
1209 JVMCIObject JVMCIEnv::new_VMIntrinsicMethod(JVMCIObject declaringClass, JVMCIObject name, JVMCIObject descriptor, int id, JVMCI_TRAPS) {
1210 JavaThread* THREAD = JavaThread::current();
1211 if (is_hotspot()) {
1212 HotSpotJVMCI::VMIntrinsicMethod::klass()->initialize(CHECK_(JVMCIObject()));
1213 oop obj = HotSpotJVMCI::VMIntrinsicMethod::klass()->allocate_instance(CHECK_(JVMCIObject()));
1214 HotSpotJVMCI::VMIntrinsicMethod::set_declaringClass(this, obj, HotSpotJVMCI::resolve(declaringClass));
1215 HotSpotJVMCI::VMIntrinsicMethod::set_name(this, obj, HotSpotJVMCI::resolve(name));
1216 HotSpotJVMCI::VMIntrinsicMethod::set_descriptor(this, obj, HotSpotJVMCI::resolve(descriptor));
1217 HotSpotJVMCI::VMIntrinsicMethod::set_id(this, obj, id);
1218 return wrap(obj);
1219 } else {
1220 JNIAccessMark jni(this, THREAD);
1221 jobject result = jni()->NewObject(JNIJVMCI::VMIntrinsicMethod::clazz(),
1222 JNIJVMCI::VMIntrinsicMethod::constructor(),
1223 get_jobject(declaringClass), get_jobject(name), get_jobject(descriptor), id);
1224 return wrap(result);
1225 }
1226 }
1227
1228 JVMCIObject JVMCIEnv::new_HotSpotStackFrameReference(JVMCI_TRAPS) {
1229 if (is_hotspot()) {
1230 JavaThread* THREAD = JavaThread::current();
1231 HotSpotJVMCI::HotSpotStackFrameReference::klass()->initialize(CHECK_(JVMCIObject()));
1232 oop obj = HotSpotJVMCI::HotSpotStackFrameReference::klass()->allocate_instance(CHECK_(JVMCIObject()));
1233 return wrap(obj);
1234 } else {
1235 ShouldNotReachHere();
1236 return JVMCIObject();
1237 }
1238 }
1239 JVMCIObject JVMCIEnv::new_JVMCIError(JVMCI_TRAPS) {
1240 if (is_hotspot()) {
1246 ShouldNotReachHere();
1247 return JVMCIObject();
1248 }
1249 }
1250
1251
1252 JVMCIObject JVMCIEnv::get_object_constant(oop objOop, bool compressed, bool dont_register) {
1253 JavaThread* THREAD = JavaThread::current();
1254 Handle obj = Handle(THREAD, objOop);
1255 if (obj.is_null()) {
1256 return JVMCIObject();
1257 }
1258 if (is_hotspot()) {
1259 HotSpotJVMCI::DirectHotSpotObjectConstantImpl::klass()->initialize(CHECK_(JVMCIObject()));
1260 oop constant = HotSpotJVMCI::DirectHotSpotObjectConstantImpl::klass()->allocate_instance(CHECK_(JVMCIObject()));
1261 HotSpotJVMCI::DirectHotSpotObjectConstantImpl::set_object(this, constant, obj());
1262 HotSpotJVMCI::HotSpotObjectConstantImpl::set_compressed(this, constant, compressed);
1263 return wrap(constant);
1264 } else {
1265 jlong handle = make_handle(obj);
1266 JNIAccessMark jni(this, THREAD);
1267 jobject result = jni()->NewObject(JNIJVMCI::IndirectHotSpotObjectConstantImpl::clazz(),
1268 JNIJVMCI::IndirectHotSpotObjectConstantImpl::constructor(),
1269 handle, compressed, dont_register);
1270 return wrap(result);
1271 }
1272 }
1273
1274
1275 Handle JVMCIEnv::asConstant(JVMCIObject constant, JVMCI_TRAPS) {
1276 if (constant.is_null()) {
1277 return Handle();
1278 }
1279 JavaThread* THREAD = JavaThread::current();
1280 if (is_hotspot()) {
1281 assert(HotSpotJVMCI::DirectHotSpotObjectConstantImpl::is_instance(this, constant), "wrong type");
1282 oop obj = HotSpotJVMCI::DirectHotSpotObjectConstantImpl::object(this, HotSpotJVMCI::resolve(constant));
1283 return Handle(THREAD, obj);
1284 } else if (isa_IndirectHotSpotObjectConstantImpl(constant)) {
1285 jlong object_handle = get_IndirectHotSpotObjectConstantImpl_objectHandle(constant);
1286 if (object_handle == 0L) {
1287 JVMCI_THROW_MSG_(NullPointerException, "Foreign object reference has been cleared", Handle());
1288 }
1289 oop result = resolve_handle(object_handle);
1290 if (result == NULL) {
1291 JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly NULL", Handle());
1292 }
1293 return Handle(THREAD, result);
1294 } else {
1295 JVMCI_THROW_MSG_(IllegalArgumentException, "DirectHotSpotObjectConstantImpl shouldn't reach JVMCI in SVM mode", Handle());
1296 }
1297 }
1298
1299 JVMCIObject JVMCIEnv::wrap(jobject object) {
1300 return JVMCIObject::create(object, is_hotspot());
1301 }
1302
1303 jlong JVMCIEnv::make_handle(const Handle& obj) {
1304 assert(!obj.is_null(), "should only create handle for non-NULL oops");
1305 jobject handle = _runtime->make_global(obj);
1306 return (jlong) handle;
1307 }
1308
1309 oop JVMCIEnv::resolve_handle(jlong objectHandle) {
1310 assert(objectHandle != 0, "should be a valid handle");
1311 oop obj = *((oopDesc**)objectHandle);
1312 if (obj != NULL) {
1313 obj->verify();
1314 }
1315 return obj;
1316 }
1317
1318 JVMCIObject JVMCIEnv::create_string(const char* str, JVMCI_TRAPS) {
1319 JavaThread* THREAD = JavaThread::current();
1320 if (is_hotspot()) {
1321 Handle result = java_lang_String::create_from_str(str, CHECK_(JVMCIObject()));
1322 return HotSpotJVMCI::wrap(result());
1323 } else {
1324 jobject result;
1325 jboolean exception = false;
1326 {
1327 JNIAccessMark jni(this, THREAD);
1328 result = jni()->NewStringUTF(str);
1329 exception = jni()->ExceptionCheck();
1330 }
1331 return wrap(result);
1332 }
1333 }
1334
1335 bool JVMCIEnv::equals(JVMCIObject a, JVMCIObject b) {
1336 if (is_hotspot()) {
1337 return HotSpotJVMCI::resolve(a) == HotSpotJVMCI::resolve(b);
1338 } else {
1339 JNIAccessMark jni(this);
1340 return jni()->IsSameObject(a.as_jobject(), b.as_jobject()) != 0;
1341 }
1342 }
1343
1344 BasicType JVMCIEnv::kindToBasicType(JVMCIObject kind, JVMCI_TRAPS) {
1345 if (kind.is_null()) {
1346 JVMCI_THROW_(NullPointerException, T_ILLEGAL);
1347 }
|