Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/share/vm/jvmci/jvmciCompilerToVM.cpp
changeset 46271 979ebd346ecf
parent 42650 1f304d0c888b
child 46289 1904e7ec236e
equal deleted inserted replaced
46270:2e7898927798 46271:979ebd346ecf 
     1 /*
 
     1 /*
 
     2  * Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
 
     2  * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     4  *
 
     4  *
 
     5  * This code is free software; you can redistribute it and/or modify it
 
     5  * This code is free software; you can redistribute it and/or modify it
 
     6  * under the terms of the GNU General Public License version 2 only, as
 
     6  * under the terms of the GNU General Public License version 2 only, as
 
     7  * published by the Free Software Foundation.
 
     7  * published by the Free Software Foundation.
 
    78 
    78 
    79 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
 
    79 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
 
    80   if (klass() != NULL) {
 
    80   if (klass() != NULL) {
 
    81     JavaValue result(T_OBJECT);
 
    81     JavaValue result(T_OBJECT);
 
    82     JavaCallArguments args;
 
    82     JavaCallArguments args;
 
    83     args.push_oop(klass->java_mirror());
 
    83     args.push_oop(Handle(THREAD, klass->java_mirror()));
 
    84     JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);
 
    84     JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);
 
    85 
    85 
    86     return (oop)result.get_jobject();
 
    86     return (oop)result.get_jobject();
 
    87   }
 
    87   }
 
    88   return NULL;
 
    88   return NULL;
 
   202 
   202 
   203 #undef SET_TRIGFUNC
 
   203 #undef SET_TRIGFUNC
 
   204 }
 
   204 }
 
   205 
   205 
   206 objArrayHandle CompilerToVM::initialize_intrinsics(TRAPS) {
 
   206 objArrayHandle CompilerToVM::initialize_intrinsics(TRAPS) {
 
   207   objArrayHandle vmIntrinsics = oopFactory::new_objArray(VMIntrinsicMethod::klass(), (vmIntrinsics::ID_LIMIT - 1), CHECK_(objArrayHandle()));
 
   207   objArrayHandle vmIntrinsics = oopFactory::new_objArray_handle(VMIntrinsicMethod::klass(), (vmIntrinsics::ID_LIMIT - 1), CHECK_(objArrayHandle()));
 
   208   int index = 0;
 
   208   int index = 0;
 
   209   // The intrinsics for a class are usually adjacent to each other.
 
   209   // The intrinsics for a class are usually adjacent to each other.
 
   210   // When they are, the string for the class name can be reused.
 
   210   // When they are, the string for the class name can be reused.
 
   211   vmSymbols::SID kls_sid = vmSymbols::NO_SID;
 
   211   vmSymbols::SID kls_sid = vmSymbols::NO_SID;
 
   212   Handle kls_str;
 
   212   Handle kls_str;
 
   248   VMField::klass()->initialize(CHECK_NULL);
 
   248   VMField::klass()->initialize(CHECK_NULL);
 
   249   VMFlag::klass()->initialize(CHECK_NULL);
 
   249   VMFlag::klass()->initialize(CHECK_NULL);
 
   250   VMIntrinsicMethod::klass()->initialize(CHECK_NULL);
 
   250   VMIntrinsicMethod::klass()->initialize(CHECK_NULL);
 
   251 
   251 
   252   int len = JVMCIVMStructs::localHotSpotVMStructs_count();
 
   252   int len = JVMCIVMStructs::localHotSpotVMStructs_count();
 
   253   objArrayHandle vmFields = oopFactory::new_objArray(VMField::klass(), len, CHECK_NULL);
 
   253   objArrayHandle vmFields = oopFactory::new_objArray_handle(VMField::klass(), len, CHECK_NULL);
 
   254   for (int i = 0; i < len ; i++) {
 
   254   for (int i = 0; i < len ; i++) {
 
       
   255     HandleMark hm(THREAD);
 
   255     VMStructEntry vmField = JVMCIVMStructs::localHotSpotVMStructs[i];
 
   256     VMStructEntry vmField = JVMCIVMStructs::localHotSpotVMStructs[i];
 
   256     instanceHandle vmFieldObj = InstanceKlass::cast(VMField::klass())->allocate_instance_handle(CHECK_NULL);
 
   257     instanceHandle vmFieldObj = InstanceKlass::cast(VMField::klass())->allocate_instance_handle(CHECK_NULL);
 
   257     size_t name_buf_len = strlen(vmField.typeName) + strlen(vmField.fieldName) + 2 /* "::" */;
 
   258     size_t name_buf_len = strlen(vmField.typeName) + strlen(vmField.fieldName) + 2 /* "::" */;
 
   258     char* name_buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, name_buf_len + 1);
 
   259     char* name_buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, name_buf_len + 1);
 
   259     sprintf(name_buf, "%s::%s", vmField.typeName, vmField.fieldName);
 
   260     sprintf(name_buf, "%s::%s", vmField.typeName, vmField.fieldName);
 
   288     }
 
   289     }
 
   289     vmFields->obj_at_put(i, vmFieldObj());
 
   290     vmFields->obj_at_put(i, vmFieldObj());
 
   290   }
 
   291   }
 
   291 
   292 
   292   len = JVMCIVMStructs::localHotSpotVMTypes_count();
 
   293   len = JVMCIVMStructs::localHotSpotVMTypes_count();
 
   293   objArrayHandle vmTypes = oopFactory::new_objArray(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   294   objArrayHandle vmTypes = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   294   for (int i = 0; i < len ; i++) {
 
   295   for (int i = 0; i < len ; i++) {
 
       
   296     HandleMark hm(THREAD);
 
   295     VMTypeEntry vmType = JVMCIVMStructs::localHotSpotVMTypes[i];
 
   297     VMTypeEntry vmType = JVMCIVMStructs::localHotSpotVMTypes[i];
 
   296     Handle name = java_lang_String::create_from_str(vmType.typeName, CHECK_NULL);
 
   298     Handle name = java_lang_String::create_from_str(vmType.typeName, CHECK_NULL);
 
   297     BOXED_LONG(size, vmType.size);
 
   299     BOXED_LONG(size, vmType.size);
 
   298     vmTypes->obj_at_put(i * 2, name());
 
   300     vmTypes->obj_at_put(i * 2, name());
 
   299     vmTypes->obj_at_put(i * 2 + 1, size);
 
   301     vmTypes->obj_at_put(i * 2 + 1, size);
 
   300   }
 
   302   }
 
   301 
   303 
   302   int ints_len = JVMCIVMStructs::localHotSpotVMIntConstants_count();
 
   304   int ints_len = JVMCIVMStructs::localHotSpotVMIntConstants_count();
 
   303   int longs_len = JVMCIVMStructs::localHotSpotVMLongConstants_count();
 
   305   int longs_len = JVMCIVMStructs::localHotSpotVMLongConstants_count();
 
   304   len = ints_len + longs_len;
 
   306   len = ints_len + longs_len;
 
   305   objArrayHandle vmConstants = oopFactory::new_objArray(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   307   objArrayHandle vmConstants = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   306   int insert = 0;
 
   308   int insert = 0;
 
   307   for (int i = 0; i < ints_len ; i++) {
 
   309   for (int i = 0; i < ints_len ; i++) {
 
       
   310     HandleMark hm(THREAD);
 
   308     VMIntConstantEntry c = JVMCIVMStructs::localHotSpotVMIntConstants[i];
 
   311     VMIntConstantEntry c = JVMCIVMStructs::localHotSpotVMIntConstants[i];
 
   309     Handle name = java_lang_String::create_from_str(c.name, CHECK_NULL);
 
   312     Handle name = java_lang_String::create_from_str(c.name, CHECK_NULL);
 
   310     BOXED_LONG(value, c.value);
 
   313     BOXED_LONG(value, c.value);
 
   311     vmConstants->obj_at_put(insert++, name());
 
   314     vmConstants->obj_at_put(insert++, name());
 
   312     vmConstants->obj_at_put(insert++, value);
 
   315     vmConstants->obj_at_put(insert++, value);
 
   313   }
 
   316   }
 
   314   for (int i = 0; i < longs_len ; i++) {
 
   317   for (int i = 0; i < longs_len ; i++) {
 
       
   318     HandleMark hm(THREAD);
 
   315     VMLongConstantEntry c = JVMCIVMStructs::localHotSpotVMLongConstants[i];
 
   319     VMLongConstantEntry c = JVMCIVMStructs::localHotSpotVMLongConstants[i];
 
   316     Handle name = java_lang_String::create_from_str(c.name, CHECK_NULL);
 
   320     Handle name = java_lang_String::create_from_str(c.name, CHECK_NULL);
 
   317     BOXED_LONG(value, c.value);
 
   321     BOXED_LONG(value, c.value);
 
   318     vmConstants->obj_at_put(insert++, name());
 
   322     vmConstants->obj_at_put(insert++, name());
 
   319     vmConstants->obj_at_put(insert++, value);
 
   323     vmConstants->obj_at_put(insert++, value);
 
   320   }
 
   324   }
 
   321   assert(insert == len * 2, "must be");
 
   325   assert(insert == len * 2, "must be");
 
   322 
   326 
   323   len = JVMCIVMStructs::localHotSpotVMAddresses_count();
 
   327   len = JVMCIVMStructs::localHotSpotVMAddresses_count();
 
   324   objArrayHandle vmAddresses = oopFactory::new_objArray(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   328   objArrayHandle vmAddresses = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   325   for (int i = 0; i < len ; i++) {
 
   329   for (int i = 0; i < len ; i++) {
 
       
   330     HandleMark hm(THREAD);
 
   326     VMAddressEntry a = JVMCIVMStructs::localHotSpotVMAddresses[i];
 
   331     VMAddressEntry a = JVMCIVMStructs::localHotSpotVMAddresses[i];
 
   327     Handle name = java_lang_String::create_from_str(a.name, CHECK_NULL);
 
   332     Handle name = java_lang_String::create_from_str(a.name, CHECK_NULL);
 
   328     BOXED_LONG(value, a.value);
 
   333     BOXED_LONG(value, a.value);
 
   329     vmAddresses->obj_at_put(i * 2, name());
 
   334     vmAddresses->obj_at_put(i * 2, name());
 
   330     vmAddresses->obj_at_put(i * 2 + 1, value);
 
   335     vmAddresses->obj_at_put(i * 2 + 1, value);
 
   331   }
 
   336   }
 
   332 
   337 
   333   // The last entry is the null entry.
 
   338   // The last entry is the null entry.
 
   334   len = (int) Flag::numFlags - 1;
 
   339   len = (int) Flag::numFlags - 1;
 
   335   objArrayHandle vmFlags = oopFactory::new_objArray(VMFlag::klass(), len, CHECK_NULL);
 
   340   objArrayHandle vmFlags = oopFactory::new_objArray_handle(VMFlag::klass(), len, CHECK_NULL);
 
   336   for (int i = 0; i < len; i++) {
 
   341   for (int i = 0; i < len; i++) {
 
       
   342     HandleMark hm(THREAD);
 
   337     Flag* flag = &Flag::flags[i];
 
   343     Flag* flag = &Flag::flags[i];
 
   338     instanceHandle vmFlagObj = InstanceKlass::cast(VMFlag::klass())->allocate_instance_handle(CHECK_NULL);
 
   344     instanceHandle vmFlagObj = InstanceKlass::cast(VMFlag::klass())->allocate_instance_handle(CHECK_NULL);
 
   339     Handle name = java_lang_String::create_from_str(flag->_name, CHECK_NULL);
 
   345     Handle name = java_lang_String::create_from_str(flag->_name, CHECK_NULL);
 
   340     Handle type = java_lang_String::create_from_str(flag->_type, CHECK_NULL);
 
   346     Handle type = java_lang_String::create_from_str(flag->_type, CHECK_NULL);
 
   341     VMFlag::set_name(vmFlagObj, name());
 
   347     VMFlag::set_name(vmFlagObj, name());
 
   604   return CompilerOracle::should_inline(method) || method->force_inline();
 
   610   return CompilerOracle::should_inline(method) || method->force_inline();
 
   605 C2V_END
 
   611 C2V_END
 
   606 
   612 
   607 C2V_VMENTRY(jobject, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve))
 
   613 C2V_VMENTRY(jobject, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve))
 
   608   ResourceMark rm;
 
   614   ResourceMark rm;
 
   609   Handle name = JNIHandles::resolve(jname);
 
   615   Handle name(THREAD, JNIHandles::resolve(jname));
 
   610   Symbol* class_name = java_lang_String::as_symbol(name, CHECK_0);
 
   616   Symbol* class_name = java_lang_String::as_symbol(name(), CHECK_0);
 
   611   if (java_lang_String::length(name()) <= 1) {
 
   617   if (java_lang_String::length(name()) <= 1) {
 
   612     THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string()));
 
   618     THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string()));
 
   613   }
 
   619   }
 
   614 
   620 
   615   Klass* resolved_klass = NULL;
 
   621   Klass* resolved_klass = NULL;
 
   616   Handle class_loader;
 
       
   617   Handle protection_domain;
 
       
   618   if (JNIHandles::resolve(accessing_class) == NULL) {
 
   622   if (JNIHandles::resolve(accessing_class) == NULL) {
 
   619     THROW_0(vmSymbols::java_lang_NullPointerException());
 
   623     THROW_0(vmSymbols::java_lang_NullPointerException());
 
   620   }
 
   624   }
 
   621   Klass* accessing_klass = java_lang_Class::as_Klass(JNIHandles::resolve(accessing_class));
 
   625   Klass* accessing_klass = java_lang_Class::as_Klass(JNIHandles::resolve(accessing_class));
 
   622   class_loader = accessing_klass->class_loader();
 
   626   Handle class_loader(THREAD, accessing_klass->class_loader());
 
   623   protection_domain = accessing_klass->protection_domain();
 
   627   Handle protection_domain(THREAD, accessing_klass->protection_domain());
 
   624 
   628 
   625   if (resolve) {
 
   629   if (resolve) {
 
   626     resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0);
 
   630     resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0);
 
   627   } else {
 
   631   } else {
 
   628     if (class_name->byte_at(0) == 'L' &&
 
   632     if (class_name->byte_at(0) == 'L' &&
 
   654         resolved_klass = Universe::typeArrayKlassObj(t);
 
   658         resolved_klass = Universe::typeArrayKlassObj(t);
 
   655         resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0);
 
   659         resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0);
 
   656       }
 
   660       }
 
   657     }
 
   661     }
 
   658   }
 
   662   }
 
   659   Handle result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   663   oop result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   660   return JNIHandles::make_local(THREAD, result());
 
   664   return JNIHandles::make_local(THREAD, result);
 
   661 C2V_END
 
   665 C2V_END
 
   662 
   666 
   663 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   667 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   664   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   668   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   665   oop result = cp->resolve_constant_at(index, CHECK_NULL);
 
   669   oop result = cp->resolve_constant_at(index, CHECK_NULL);
 
   695 C2V_END
 
   699 C2V_END
 
   696 
   700 
   697 C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   701 C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   698   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   702   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   699   Klass* resolved_klass = cp->klass_at(index, CHECK_NULL);
 
   703   Klass* resolved_klass = cp->klass_at(index, CHECK_NULL);
 
   700   Handle klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   704   oop klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   701   return JNIHandles::make_local(THREAD, klass());
 
   705   return JNIHandles::make_local(THREAD, klass);
 
   702 C2V_END
 
   706 C2V_END
 
   703 
   707 
   704 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
 
   708 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
 
   705   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   709   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   706   KlassHandle loading_klass(cp->pool_holder());
 
   710   KlassHandle loading_klass(cp->pool_holder());
 
   708   KlassHandle klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass);
 
   712   KlassHandle klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass);
 
   709   Symbol* symbol = NULL;
 
   713   Symbol* symbol = NULL;
 
   710   if (klass.is_null()) {
 
   714   if (klass.is_null()) {
 
   711     symbol = cp->klass_name_at(index);
 
   715     symbol = cp->klass_name_at(index);
 
   712   }
 
   716   }
 
   713   Handle result;
 
   717   oop result_oop;
 
   714   if (!klass.is_null()) {
 
   718   if (!klass.is_null()) {
 
   715     result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);
 
   719     result_oop = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);
 
   716   } else {
 
   720   } else {
 
   717     result = java_lang_String::create_from_symbol(symbol, CHECK_NULL);
 
   721     Handle result = java_lang_String::create_from_symbol(symbol, CHECK_NULL);
 
   718   }
 
   722     result_oop = result();
 
   719   return JNIHandles::make_local(THREAD, result());
 
   723   }
 
       
   724   return JNIHandles::make_local(THREAD, result_oop);
 
   720 C2V_END
 
   725 C2V_END
 
   721 
   726 
   722 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   727 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   723   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   728   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   724   oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
 
   729   oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
 
   836 C2V_END
 
   841 C2V_END
 
   837 
   842 
   838 C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject installed_code, jobject speculation_log))
 
   843 C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject installed_code, jobject speculation_log))
 
   839   ResourceMark rm;
 
   844   ResourceMark rm;
 
   840   HandleMark hm;
 
   845   HandleMark hm;
 
   841   Handle target_handle = JNIHandles::resolve(target);
 
   846   Handle target_handle(THREAD, JNIHandles::resolve(target));
 
   842   Handle compiled_code_handle = JNIHandles::resolve(compiled_code);
 
   847   Handle compiled_code_handle(THREAD, JNIHandles::resolve(compiled_code));
 
   843   CodeBlob* cb = NULL;
 
   848   CodeBlob* cb = NULL;
 
   844   Handle installed_code_handle = JNIHandles::resolve(installed_code);
 
   849   Handle installed_code_handle(THREAD, JNIHandles::resolve(installed_code));
 
   845   Handle speculation_log_handle = JNIHandles::resolve(speculation_log);
 
   850   Handle speculation_log_handle(THREAD, JNIHandles::resolve(speculation_log));
 
   846 
   851 
   847   JVMCICompiler* compiler = JVMCICompiler::instance(CHECK_JNI_ERR);
 
   852   JVMCICompiler* compiler = JVMCICompiler::instance(CHECK_JNI_ERR);
 
   848 
   853 
   849   TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
 
   854   TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
 
   850   bool is_immutable_PIC = HotSpotCompiledCode::isImmutablePIC(compiled_code_handle) > 0;
 
   855   bool is_immutable_PIC = HotSpotCompiledCode::isImmutablePIC(compiled_code_handle) > 0;
 
   898 
   903 
   899 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata))
 
   904 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata))
 
   900   ResourceMark rm;
 
   905   ResourceMark rm;
 
   901   HandleMark hm;
 
   906   HandleMark hm;
 
   902 
   907 
   903   Handle target_handle = JNIHandles::resolve(target);
 
   908   Handle target_handle(THREAD, JNIHandles::resolve(target));
 
   904   Handle compiled_code_handle = JNIHandles::resolve(compiled_code);
 
   909   Handle compiled_code_handle(THREAD, JNIHandles::resolve(compiled_code));
 
   905   Handle metadata_handle = JNIHandles::resolve(metadata);
 
   910   Handle metadata_handle(THREAD, JNIHandles::resolve(metadata));
 
   906 
   911 
   907   CodeMetadata code_metadata;
 
   912   CodeMetadata code_metadata;
 
   908   CodeBlob *cb = NULL;
 
   913   CodeBlob *cb = NULL;
 
   909   CodeInstaller installer(true /* immutable PIC compilation */);
 
   914   CodeInstaller installer(true /* immutable PIC compilation */);
 
   910 
   915 
   912   if (result != JVMCIEnv::ok) {
 
   917   if (result != JVMCIEnv::ok) {
 
   913     return result;
 
   918     return result;
 
   914   }
 
   919   }
 
   915 
   920 
   916   if (code_metadata.get_nr_pc_desc() > 0) {
 
   921   if (code_metadata.get_nr_pc_desc() > 0) {
 
   917     typeArrayHandle pcArrayOop = oopFactory::new_byteArray(sizeof(PcDesc) * code_metadata.get_nr_pc_desc(), CHECK_(JVMCIEnv::cache_full));
 
   922     typeArrayHandle pcArrayOop = oopFactory::new_byteArray_handle(sizeof(PcDesc) * code_metadata.get_nr_pc_desc(), CHECK_(JVMCIEnv::cache_full));
 
   918     memcpy(pcArrayOop->byte_at_addr(0), code_metadata.get_pc_desc(), sizeof(PcDesc) * code_metadata.get_nr_pc_desc());
 
   923     memcpy(pcArrayOop->byte_at_addr(0), code_metadata.get_pc_desc(), sizeof(PcDesc) * code_metadata.get_nr_pc_desc());
 
   919     HotSpotMetaData::set_pcDescBytes(metadata_handle, pcArrayOop());
 
   924     HotSpotMetaData::set_pcDescBytes(metadata_handle, pcArrayOop());
 
   920   }
 
   925   }
 
   921 
   926 
   922   if (code_metadata.get_scopes_size() > 0) {
 
   927   if (code_metadata.get_scopes_size() > 0) {
 
   923     typeArrayHandle scopesArrayOop = oopFactory::new_byteArray(code_metadata.get_scopes_size(), CHECK_(JVMCIEnv::cache_full));
 
   928     typeArrayHandle scopesArrayOop = oopFactory::new_byteArray_handle(code_metadata.get_scopes_size(), CHECK_(JVMCIEnv::cache_full));
 
   924     memcpy(scopesArrayOop->byte_at_addr(0), code_metadata.get_scopes_desc(), code_metadata.get_scopes_size());
 
   929     memcpy(scopesArrayOop->byte_at_addr(0), code_metadata.get_scopes_desc(), code_metadata.get_scopes_size());
 
   925     HotSpotMetaData::set_scopesDescBytes(metadata_handle, scopesArrayOop());
 
   930     HotSpotMetaData::set_scopesDescBytes(metadata_handle, scopesArrayOop());
 
   926   }
 
   931   }
 
   927 
   932 
   928   RelocBuffer* reloc_buffer = code_metadata.get_reloc_buffer();
 
   933   RelocBuffer* reloc_buffer = code_metadata.get_reloc_buffer();
 
   929   typeArrayHandle relocArrayOop = oopFactory::new_byteArray((int) reloc_buffer->size(), CHECK_(JVMCIEnv::cache_full));
 
   934   typeArrayHandle relocArrayOop = oopFactory::new_byteArray_handle((int) reloc_buffer->size(), CHECK_(JVMCIEnv::cache_full));
 
   930   if (reloc_buffer->size() > 0) {
 
   935   if (reloc_buffer->size() > 0) {
 
   931     memcpy(relocArrayOop->byte_at_addr(0), reloc_buffer->begin(), reloc_buffer->size());
 
   936     memcpy(relocArrayOop->byte_at_addr(0), reloc_buffer->begin(), reloc_buffer->size());
 
   932   }
 
   937   }
 
   933   HotSpotMetaData::set_relocBytes(metadata_handle, relocArrayOop());
 
   938   HotSpotMetaData::set_relocBytes(metadata_handle, relocArrayOop());
 
   934 
   939 
   935   const OopMapSet* oopMapSet = installer.oopMapSet();
 
   940   const OopMapSet* oopMapSet = installer.oopMapSet();
 
   936   {
 
   941   {
 
   937     ResourceMark mark;
 
   942     ResourceMark mark;
 
   938     ImmutableOopMapBuilder builder(oopMapSet);
 
   943     ImmutableOopMapBuilder builder(oopMapSet);
 
   939     int oopmap_size = builder.heap_size();
 
   944     int oopmap_size = builder.heap_size();
 
   940     typeArrayHandle oopMapArrayHandle = oopFactory::new_byteArray(oopmap_size, CHECK_(JVMCIEnv::cache_full));
 
   945     typeArrayHandle oopMapArrayHandle = oopFactory::new_byteArray_handle(oopmap_size, CHECK_(JVMCIEnv::cache_full));
 
   941     builder.generate_into((address) oopMapArrayHandle->byte_at_addr(0));
 
   946     builder.generate_into((address) oopMapArrayHandle->byte_at_addr(0));
 
   942     HotSpotMetaData::set_oopMaps(metadata_handle, oopMapArrayHandle());
 
   947     HotSpotMetaData::set_oopMaps(metadata_handle, oopMapArrayHandle());
 
   943   }
 
   948   }
 
   944 
   949 
   945   AOTOopRecorder* recorder = code_metadata.get_oop_recorder();
 
   950   AOTOopRecorder* recorder = code_metadata.get_oop_recorder();
 
   946 
   951 
   947   int nr_meta_strings = recorder->nr_meta_strings();
 
   952   int nr_meta_strings = recorder->nr_meta_strings();
 
   948   objArrayHandle metadataArrayHandle = oopFactory::new_objectArray(nr_meta_strings, CHECK_(JVMCIEnv::cache_full));
 
   953   objArrayOop metadataArray = oopFactory::new_objectArray(nr_meta_strings, CHECK_(JVMCIEnv::cache_full));
 
       
   954   objArrayHandle metadataArrayHandle(THREAD, metadataArray);
 
   949   for (int i = 0; i < nr_meta_strings; ++i) {
 
   955   for (int i = 0; i < nr_meta_strings; ++i) {
 
   950     const char* element = recorder->meta_element(i);
 
   956     const char* element = recorder->meta_element(i);
 
   951     Handle java_string = java_lang_String::create_from_str(element, CHECK_(JVMCIEnv::cache_full));
 
   957     Handle java_string = java_lang_String::create_from_str(element, CHECK_(JVMCIEnv::cache_full));
 
   952     metadataArrayHandle->obj_at_put(i, java_string());
 
   958     metadataArrayHandle->obj_at_put(i, java_string());
 
   953   }
 
   959   }
 
   954   HotSpotMetaData::set_metadata(metadata_handle, metadataArrayHandle());
 
   960   HotSpotMetaData::set_metadata(metadata_handle, metadataArrayHandle());
 
   955 
   961 
   956   ExceptionHandlerTable* handler = code_metadata.get_exception_table();
 
   962   ExceptionHandlerTable* handler = code_metadata.get_exception_table();
 
   957   int table_size = handler->size_in_bytes();
 
   963   int table_size = handler->size_in_bytes();
 
   958   typeArrayHandle exceptionArrayOop = oopFactory::new_byteArray(table_size, CHECK_(JVMCIEnv::cache_full));
 
   964   typeArrayHandle exceptionArrayOop = oopFactory::new_byteArray_handle(table_size, CHECK_(JVMCIEnv::cache_full));
 
   959 
   965 
   960   if (table_size > 0) {
 
   966   if (table_size > 0) {
 
   961     handler->copy_bytes_to((address) exceptionArrayOop->byte_at_addr(0));
 
   967     handler->copy_bytes_to((address) exceptionArrayOop->byte_at_addr(0));
 
   962   }
 
   968   }
 
   963   HotSpotMetaData::set_exceptionBytes(metadata_handle, exceptionArrayOop());
 
   969   HotSpotMetaData::set_exceptionBytes(metadata_handle, exceptionArrayOop());
 
  1132   }
 
  1138   }
 
  1133 C2V_END
 
  1139 C2V_END
 
  1134 
  1140 
  1135 
  1141 
  1136 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code))
 
  1142 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code))
 
  1137   Handle installed_code_handle = JNIHandles::resolve(installed_code);
 
  1143   Handle installed_code_handle(THREAD, JNIHandles::resolve(installed_code));
 
  1138   nmethod::invalidate_installed_code(installed_code_handle, CHECK);
 
  1144   nmethod::invalidate_installed_code(installed_code_handle, CHECK);
 
  1139 C2V_END
 
  1145 C2V_END
 
  1140 
  1146 
  1141 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject))
 
  1147 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject))
 
  1142   typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL);
 
  1148   typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL);
 
  1187 
  1193 
  1188 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip))
 
  1194 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip))
 
  1189   ResourceMark rm;
 
  1195   ResourceMark rm;
 
  1190 
  1196 
  1191   if (!thread->has_last_Java_frame()) return NULL;
 
  1197   if (!thread->has_last_Java_frame()) return NULL;
 
  1192   Handle result = HotSpotStackFrameReference::klass()->allocate_instance(thread);
 
  1198   Handle result = HotSpotStackFrameReference::klass()->allocate_instance_handle(thread);
 
  1193   HotSpotStackFrameReference::klass()->initialize(thread);
 
  1199   HotSpotStackFrameReference::klass()->initialize(thread);
 
  1194 
  1200 
  1195   StackFrameStream fst(thread);
 
  1201   StackFrameStream fst(thread);
 
  1196   if (hs_frame != NULL) {
 
  1202   if (hs_frame != NULL) {
 
  1197     // look for the correct stack frame if one is given
 
  1203     // look for the correct stack frame if one is given
 
  1246             if (scope != NULL && scope->objects() != NULL) {
 
  1252             if (scope != NULL && scope->objects() != NULL) {
 
  1247               bool realloc_failures = Deoptimization::realloc_objects(thread, fst.current(), scope->objects(), THREAD);
 
  1253               bool realloc_failures = Deoptimization::realloc_objects(thread, fst.current(), scope->objects(), THREAD);
 
  1248               Deoptimization::reassign_fields(fst.current(), fst.register_map(), scope->objects(), realloc_failures, false);
 
  1254               Deoptimization::reassign_fields(fst.current(), fst.register_map(), scope->objects(), realloc_failures, false);
 
  1249 
  1255 
  1250               GrowableArray<ScopeValue*>* local_values = scope->locals();
 
  1256               GrowableArray<ScopeValue*>* local_values = scope->locals();
 
  1251               typeArrayHandle array = oopFactory::new_boolArray(local_values->length(), thread);
 
  1257               typeArrayOop array_oop = oopFactory::new_boolArray(local_values->length(), thread);
 
       
  1258               typeArrayHandle array(THREAD, array_oop);
 
  1252               for (int i = 0; i < local_values->length(); i++) {
 
  1259               for (int i = 0; i < local_values->length(); i++) {
 
  1253                 ScopeValue* value = local_values->at(i);
 
  1260                 ScopeValue* value = local_values->at(i);
 
  1254                 if (value->is_object()) {
 
  1261                 if (value->is_object()) {
 
  1255                   array->bool_at_put(i, true);
 
  1262                   array->bool_at_put(i, true);
 
  1256                 }
 
  1263                 }
 
  1287         HotSpotStackFrameReference::set_compilerToVM(result, JNIHandles::resolve(compilerToVM));
 
  1294         HotSpotStackFrameReference::set_compilerToVM(result, JNIHandles::resolve(compilerToVM));
 
  1288         HotSpotStackFrameReference::set_stackPointer(result, (jlong) fst.current()->sp());
 
  1295         HotSpotStackFrameReference::set_stackPointer(result, (jlong) fst.current()->sp());
 
  1289         HotSpotStackFrameReference::set_frameNumber(result, frame_number);
 
  1296         HotSpotStackFrameReference::set_frameNumber(result, frame_number);
 
  1290 
  1297 
  1291         // initialize the locals array
 
  1298         // initialize the locals array
 
  1292         objArrayHandle array = oopFactory::new_objectArray(locals->size(), thread);
 
  1299         objArrayOop array_oop = oopFactory::new_objectArray(locals->size(), CHECK_NULL);
 
       
  1300         objArrayHandle array(THREAD, array_oop);
 
  1293         for (int i = 0; i < locals->size(); i++) {
 
  1301         for (int i = 0; i < locals->size(); i++) {
 
  1294           StackValue* var = locals->at(i);
 
  1302           StackValue* var = locals->at(i);
 
  1295           if (var->type() == T_OBJECT) {
 
  1303           if (var->type() == T_OBJECT) {
 
  1296             array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1304             array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1297           }
 
  1305           }
 
  1339     cp_cache_entry->set_method_handle(cp, callInfo);
 
  1347     cp_cache_entry->set_method_handle(cp, callInfo);
 
  1340   }
 
  1348   }
 
  1341 C2V_END
 
  1349 C2V_END
 
  1342 
  1350 
  1343 C2V_VMENTRY(jobject, getSignaturePolymorphicHolders, (JNIEnv*, jobject))
 
  1351 C2V_VMENTRY(jobject, getSignaturePolymorphicHolders, (JNIEnv*, jobject))
 
  1344   objArrayHandle holders = oopFactory::new_objArray(SystemDictionary::String_klass(), 2, CHECK_NULL);
 
  1352   objArrayHandle holders = oopFactory::new_objArray_handle(SystemDictionary::String_klass(), 2, CHECK_NULL);
 
  1345   Handle mh = java_lang_String::create_from_str("Ljava/lang/invoke/MethodHandle;", CHECK_NULL);
 
  1353   Handle mh = java_lang_String::create_from_str("Ljava/lang/invoke/MethodHandle;", CHECK_NULL);
 
  1346   Handle vh = java_lang_String::create_from_str("Ljava/lang/invoke/VarHandle;", CHECK_NULL);
 
  1354   Handle vh = java_lang_String::create_from_str("Ljava/lang/invoke/VarHandle;", CHECK_NULL);
 
  1347   holders->obj_at_put(0, mh());
 
  1355   holders->obj_at_put(0, mh());
 
  1348   holders->obj_at_put(1, vh());
 
  1356   holders->obj_at_put(1, vh());
 
  1349   return JNIHandles::make_local(THREAD, holders());
 
  1357   return JNIHandles::make_local(THREAD, holders());
 
  1446 
  1454 
  1447   // all locals are materialized by now
 
  1455   // all locals are materialized by now
 
  1448   HotSpotStackFrameReference::set_localIsVirtual(hs_frame, NULL);
 
  1456   HotSpotStackFrameReference::set_localIsVirtual(hs_frame, NULL);
 
  1449 
  1457 
  1450   // update the locals array
 
  1458   // update the locals array
 
  1451   objArrayHandle array = HotSpotStackFrameReference::locals(hs_frame);
 
  1459   objArrayHandle array(THREAD, HotSpotStackFrameReference::locals(hs_frame));
 
  1452   StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals();
 
  1460   StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals();
 
  1453   for (int i = 0; i < locals->size(); i++) {
 
  1461   for (int i = 0; i < locals->size(); i++) {
 
  1454     StackValue* var = locals->at(i);
 
  1462     StackValue* var = locals->at(i);
 
  1455     if (var->type() == T_OBJECT) {
 
  1463     if (var->type() == T_OBJECT) {
 
  1456       array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1464       array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1547   }
 
  1555   }
 
  1548   return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord;
 
  1556   return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord;
 
  1549 C2V_END
 
  1557 C2V_END
 
  1550 
  1558 
  1551 C2V_VMENTRY(void, compileToBytecode, (JNIEnv*, jobject, jobject lambda_form_handle))
 
  1559 C2V_VMENTRY(void, compileToBytecode, (JNIEnv*, jobject, jobject lambda_form_handle))
 
  1552   Handle lambda_form = JNIHandles::resolve_non_null(lambda_form_handle);
 
  1560   Handle lambda_form(THREAD, JNIHandles::resolve_non_null(lambda_form_handle));
 
  1553   if (lambda_form->is_a(SystemDictionary::LambdaForm_klass())) {
 
  1561   if (lambda_form->is_a(SystemDictionary::LambdaForm_klass())) {
 
  1554     TempNewSymbol compileToBytecode = SymbolTable::new_symbol("compileToBytecode", CHECK);
 
  1562     TempNewSymbol compileToBytecode = SymbolTable::new_symbol("compileToBytecode", CHECK);
 
  1555     JavaValue result(T_VOID);
 
  1563     JavaValue result(T_VOID);
 
  1556     JavaCalls::call_special(&result, lambda_form, SystemDictionary::LambdaForm_klass(), compileToBytecode, vmSymbols::void_method_signature(), CHECK);
 
  1564     JavaCalls::call_special(&result, lambda_form, SystemDictionary::LambdaForm_klass(), compileToBytecode, vmSymbols::void_method_signature(), CHECK);
 
  1557   } else {
 
  1565   } else {
jdk-sandbox