< prev index next >

src/hotspot/share/jvmci/jvmciEnv.cpp

Print this page




  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   }


< prev index next >