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 46327 91576389a517
parent 43957 9ae31c0b2148
parent 46289 1904e7ec236e
child 46329 53ccc37bda19
equal deleted inserted replaced
44203:d2d435372329 46327:91576389a517 
     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.
 
    79 
    79 
    80 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
 
    80 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
 
    81   if (klass() != NULL) {
 
    81   if (klass() != NULL) {
 
    82     JavaValue result(T_OBJECT);
 
    82     JavaValue result(T_OBJECT);
 
    83     JavaCallArguments args;
 
    83     JavaCallArguments args;
 
    84     args.push_oop(klass->java_mirror());
 
    84     args.push_oop(Handle(THREAD, klass->java_mirror()));
 
    85     JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);
 
    85     JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);
 
    86 
    86 
    87     return (oop)result.get_jobject();
 
    87     return (oop)result.get_jobject();
 
    88   }
 
    88   }
 
    89   return NULL;
 
    89   return NULL;
 
   218 
   218 
   219 #undef SET_TRIGFUNC
 
   219 #undef SET_TRIGFUNC
 
   220 }
 
   220 }
 
   221 
   221 
   222 objArrayHandle CompilerToVM::initialize_intrinsics(TRAPS) {
 
   222 objArrayHandle CompilerToVM::initialize_intrinsics(TRAPS) {
 
   223   objArrayHandle vmIntrinsics = oopFactory::new_objArray(VMIntrinsicMethod::klass(), (vmIntrinsics::ID_LIMIT - 1), CHECK_(objArrayHandle()));
 
   223   objArrayHandle vmIntrinsics = oopFactory::new_objArray_handle(VMIntrinsicMethod::klass(), (vmIntrinsics::ID_LIMIT - 1), CHECK_(objArrayHandle()));
 
   224   int index = 0;
 
   224   int index = 0;
 
   225   // The intrinsics for a class are usually adjacent to each other.
 
   225   // The intrinsics for a class are usually adjacent to each other.
 
   226   // When they are, the string for the class name can be reused.
 
   226   // When they are, the string for the class name can be reused.
 
   227   vmSymbols::SID kls_sid = vmSymbols::NO_SID;
 
   227   vmSymbols::SID kls_sid = vmSymbols::NO_SID;
 
   228   Handle kls_str;
 
   228   Handle kls_str;
 
   323   oop name; \
 
   323   oop name; \
 
   324   do { \
 
   324   do { \
 
   325     jvalue p; p.j = (jlong) (value); \
 
   325     jvalue p; p.j = (jlong) (value); \
 
   326     Handle* e = longs.get(p.j); \
 
   326     Handle* e = longs.get(p.j); \
 
   327     if (e == NULL) { \
 
   327     if (e == NULL) { \
 
   328       Handle h = java_lang_boxing_object::create(T_LONG, &p, CHECK_NULL); \
 
   328       oop o = java_lang_boxing_object::create(T_LONG, &p, CHECK_NULL); \
 
       
   329       Handle h(THREAD, o); \
 
   329       longs.put(p.j, h); \
 
   330       longs.put(p.j, h); \
 
   330       name = h(); \
 
   331       name = h(); \
 
   331     } else { \
 
   332     } else { \
 
   332       name = (*e)(); \
 
   333       name = (*e)(); \
 
   333     } \
 
   334     } \
 
   339     if (value != NULL) { \
 
   340     if (value != NULL) { \
 
   340       Handle* e = strings.get(value); \
 
   341       Handle* e = strings.get(value); \
 
   341       if (e == NULL) { \
 
   342       if (e == NULL) { \
 
   342         Handle h = java_lang_String::create_from_str(value, CHECK_NULL); \
 
   343         Handle h = java_lang_String::create_from_str(value, CHECK_NULL); \
 
   343         strings.put(value, h); \
 
   344         strings.put(value, h); \
 
   344         name = h(); \
 
   345         name = h; \
 
   345       } else { \
 
   346       } else { \
 
   346         name = (*e)(); \
 
   347         name = (*e); \
 
   347       } \
 
   348       } \
 
   348     } \
 
   349     } \
 
   349   } while (0)
 
   350   } while (0)
 
   350 
   351 
   351 C2V_VMENTRY(jobjectArray, readConfiguration, (JNIEnv *env))
 
   352 C2V_VMENTRY(jobjectArray, readConfiguration, (JNIEnv *env))
 
   355   // Used to canonicalize Long and String values.
 
   356   // Used to canonicalize Long and String values.
 
   356   ResourceHashtable<jlong, Handle> longs;
 
   357   ResourceHashtable<jlong, Handle> longs;
 
   357   ResourceHashtable<const char*, Handle, &CompilerToVM::cstring_hash, &CompilerToVM::cstring_equals> strings;
 
   358   ResourceHashtable<const char*, Handle, &CompilerToVM::cstring_hash, &CompilerToVM::cstring_equals> strings;
 
   358 
   359 
   359   jvalue prim;
 
   360   jvalue prim;
 
   360   prim.z = true;  Handle boxedTrue =  java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL);
 
   361   prim.z = true;  oop boxedTrueOop =  java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL);
 
   361   prim.z = false; Handle boxedFalse = java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL);
 
   362   Handle boxedTrue(THREAD, boxedTrueOop);
 
       
   363   prim.z = false; oop boxedFalseOop = java_lang_boxing_object::create(T_BOOLEAN, &prim, CHECK_NULL);
 
       
   364   Handle boxedFalse(THREAD, boxedFalseOop);
 
   362 
   365 
   363   CompilerToVM::Data::initialize(CHECK_NULL);
 
   366   CompilerToVM::Data::initialize(CHECK_NULL);
 
   364 
   367 
   365   VMField::klass()->initialize(CHECK_NULL);
 
   368   VMField::klass()->initialize(CHECK_NULL);
 
   366   VMFlag::klass()->initialize(CHECK_NULL);
 
   369   VMFlag::klass()->initialize(CHECK_NULL);
 
   367   VMIntrinsicMethod::klass()->initialize(CHECK_NULL);
 
   370   VMIntrinsicMethod::klass()->initialize(CHECK_NULL);
 
   368 
   371 
   369   int len = JVMCIVMStructs::localHotSpotVMStructs_count();
 
   372   int len = JVMCIVMStructs::localHotSpotVMStructs_count();
 
   370   objArrayHandle vmFields = oopFactory::new_objArray(VMField::klass(), len, CHECK_NULL);
 
   373   objArrayHandle vmFields = oopFactory::new_objArray_handle(VMField::klass(), len, CHECK_NULL);
 
   371   for (int i = 0; i < len ; i++) {
 
   374   for (int i = 0; i < len ; i++) {
 
   372     VMStructEntry vmField = JVMCIVMStructs::localHotSpotVMStructs[i];
 
   375     VMStructEntry vmField = JVMCIVMStructs::localHotSpotVMStructs[i];
 
   373     instanceHandle vmFieldObj = InstanceKlass::cast(VMField::klass())->allocate_instance_handle(CHECK_NULL);
 
   376     instanceHandle vmFieldObj = InstanceKlass::cast(VMField::klass())->allocate_instance_handle(CHECK_NULL);
 
   374     size_t name_buf_len = strlen(vmField.typeName) + strlen(vmField.fieldName) + 2 /* "::" */;
 
   377     size_t name_buf_len = strlen(vmField.typeName) + strlen(vmField.fieldName) + 2 /* "::" */;
 
   375     char* name_buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, name_buf_len + 1);
 
   378     char* name_buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, name_buf_len + 1);
 
   407   }
 
   410   }
 
   408 
   411 
   409   int ints_len = JVMCIVMStructs::localHotSpotVMIntConstants_count();
 
   412   int ints_len = JVMCIVMStructs::localHotSpotVMIntConstants_count();
 
   410   int longs_len = JVMCIVMStructs::localHotSpotVMLongConstants_count();
 
   413   int longs_len = JVMCIVMStructs::localHotSpotVMLongConstants_count();
 
   411   len = ints_len + longs_len;
 
   414   len = ints_len + longs_len;
 
   412   objArrayHandle vmConstants = oopFactory::new_objArray(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   415   objArrayHandle vmConstants = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   413   int insert = 0;
 
   416   int insert = 0;
 
   414   for (int i = 0; i < ints_len ; i++) {
 
   417   for (int i = 0; i < ints_len ; i++) {
 
   415     VMIntConstantEntry c = JVMCIVMStructs::localHotSpotVMIntConstants[i];
 
   418     VMIntConstantEntry c = JVMCIVMStructs::localHotSpotVMIntConstants[i];
 
   416     CSTRING_TO_JSTRING(name, c.name);
 
   419     CSTRING_TO_JSTRING(name, c.name);
 
   417     BOXED_LONG(value, c.value);
 
   420     BOXED_LONG(value, c.value);
 
   426     vmConstants->obj_at_put(insert++, value);
 
   429     vmConstants->obj_at_put(insert++, value);
 
   427   }
 
   430   }
 
   428   assert(insert == len * 2, "must be");
 
   431   assert(insert == len * 2, "must be");
 
   429 
   432 
   430   len = JVMCIVMStructs::localHotSpotVMAddresses_count();
 
   433   len = JVMCIVMStructs::localHotSpotVMAddresses_count();
 
   431   objArrayHandle vmAddresses = oopFactory::new_objArray(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   434   objArrayHandle vmAddresses = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), len * 2, CHECK_NULL);
 
   432   for (int i = 0; i < len ; i++) {
 
   435   for (int i = 0; i < len ; i++) {
 
   433     VMAddressEntry a = JVMCIVMStructs::localHotSpotVMAddresses[i];
 
   436     VMAddressEntry a = JVMCIVMStructs::localHotSpotVMAddresses[i];
 
   434     CSTRING_TO_JSTRING(name, a.name);
 
   437     CSTRING_TO_JSTRING(name, a.name);
 
   435     BOXED_LONG(value, a.value);
 
   438     BOXED_LONG(value, a.value);
 
   436     vmAddresses->obj_at_put(i * 2, name());
 
   439     vmAddresses->obj_at_put(i * 2, name());
 
   462 #define ADD_BOOL_FLAG(name)  ADD_FLAG(bool, name, BOXED_BOOLEAN)
 
   465 #define ADD_BOOL_FLAG(name)  ADD_FLAG(bool, name, BOXED_BOOLEAN)
 
   463 #define ADD_INTX_FLAG(name)  ADD_FLAG(intx, name, BOXED_LONG)
 
   466 #define ADD_INTX_FLAG(name)  ADD_FLAG(intx, name, BOXED_LONG)
 
   464 #define ADD_UINTX_FLAG(name) ADD_FLAG(uintx, name, BOXED_LONG)
 
   467 #define ADD_UINTX_FLAG(name) ADD_FLAG(uintx, name, BOXED_LONG)
 
   465 
   468 
   466   len = 0 + PREDEFINED_CONFIG_FLAGS(COUNT_FLAG, COUNT_FLAG, COUNT_FLAG);
 
   469   len = 0 + PREDEFINED_CONFIG_FLAGS(COUNT_FLAG, COUNT_FLAG, COUNT_FLAG);
 
   467   objArrayHandle vmFlags = oopFactory::new_objArray(VMFlag::klass(), len, CHECK_NULL);
 
   470   objArrayHandle vmFlags = oopFactory::new_objArray_handle(VMFlag::klass(), len, CHECK_NULL);
 
   468   int i = 0;
 
   471   int i = 0;
 
   469   PREDEFINED_CONFIG_FLAGS(ADD_BOOL_FLAG, ADD_INTX_FLAG, ADD_UINTX_FLAG)
 
   472   PREDEFINED_CONFIG_FLAGS(ADD_BOOL_FLAG, ADD_INTX_FLAG, ADD_UINTX_FLAG)
 
   470 
   473 
   471   objArrayHandle vmIntrinsics = CompilerToVM::initialize_intrinsics(CHECK_NULL);
 
   474   objArrayHandle vmIntrinsics = CompilerToVM::initialize_intrinsics(CHECK_NULL);
 
   472 
   475 
   487 C2V_END
 
   490 C2V_END
 
   488 
   491 
   489 C2V_VMENTRY(jobject, getFlagValue, (JNIEnv *, jobject c2vm, jobject name_handle))
 
   492 C2V_VMENTRY(jobject, getFlagValue, (JNIEnv *, jobject c2vm, jobject name_handle))
 
   490 #define RETURN_BOXED_LONG(value) oop box; jvalue p; p.j = (jlong) (value); box = java_lang_boxing_object::create(T_LONG, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box);
 
   493 #define RETURN_BOXED_LONG(value) oop box; jvalue p; p.j = (jlong) (value); box = java_lang_boxing_object::create(T_LONG, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box);
 
   491 #define RETURN_BOXED_DOUBLE(value) oop box; jvalue p; p.d = (jdouble) (value); box = java_lang_boxing_object::create(T_DOUBLE, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box);
 
   494 #define RETURN_BOXED_DOUBLE(value) oop box; jvalue p; p.d = (jdouble) (value); box = java_lang_boxing_object::create(T_DOUBLE, &p, CHECK_NULL); return JNIHandles::make_local(THREAD, box);
 
   492   Handle name = JNIHandles::resolve(name_handle);
 
   495   Handle name(THREAD, JNIHandles::resolve(name_handle));
 
   493   if (name.is_null()) {
 
   496   if (name.is_null()) {
 
   494     THROW_0(vmSymbols::java_lang_NullPointerException());
 
   497     THROW_0(vmSymbols::java_lang_NullPointerException());
 
   495   }
 
   498   }
 
   496   ResourceMark rm;
 
   499   ResourceMark rm;
 
   497   const char* cstring = java_lang_String::as_utf8_string(name());
 
   500   const char* cstring = java_lang_String::as_utf8_string(name());
 
   748   return CompilerOracle::should_inline(method) || method->force_inline();
 
   751   return CompilerOracle::should_inline(method) || method->force_inline();
 
   749 C2V_END
 
   752 C2V_END
 
   750 
   753 
   751 C2V_VMENTRY(jobject, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve))
 
   754 C2V_VMENTRY(jobject, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve))
 
   752   ResourceMark rm;
 
   755   ResourceMark rm;
 
   753   Handle name = JNIHandles::resolve(jname);
 
   756   Handle name(THREAD, JNIHandles::resolve(jname));
 
   754   Symbol* class_name = java_lang_String::as_symbol(name, CHECK_0);
 
   757   Symbol* class_name = java_lang_String::as_symbol(name(), CHECK_0);
 
   755   if (java_lang_String::length(name()) <= 1) {
 
   758   if (java_lang_String::length(name()) <= 1) {
 
   756     THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string()));
 
   759     THROW_MSG_0(vmSymbols::java_lang_InternalError(), err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string()));
 
   757   }
 
   760   }
 
   758 
   761 
   759   Klass* resolved_klass = NULL;
 
   762   Klass* resolved_klass = NULL;
 
   760   Handle class_loader;
 
       
   761   Handle protection_domain;
 
       
   762   if (JNIHandles::resolve(accessing_class) == NULL) {
 
   763   if (JNIHandles::resolve(accessing_class) == NULL) {
 
   763     THROW_0(vmSymbols::java_lang_NullPointerException());
 
   764     THROW_0(vmSymbols::java_lang_NullPointerException());
 
   764   }
 
   765   }
 
   765   Klass* accessing_klass = java_lang_Class::as_Klass(JNIHandles::resolve(accessing_class));
 
   766   Klass* accessing_klass = java_lang_Class::as_Klass(JNIHandles::resolve(accessing_class));
 
   766   class_loader = accessing_klass->class_loader();
 
   767   Handle class_loader(THREAD, accessing_klass->class_loader());
 
   767   protection_domain = accessing_klass->protection_domain();
 
   768   Handle protection_domain(THREAD, accessing_klass->protection_domain());
 
   768 
   769 
   769   if (resolve) {
 
   770   if (resolve) {
 
   770     resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0);
 
   771     resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0);
 
   771   } else {
 
   772   } else {
 
   772     if (class_name->byte_at(0) == 'L' &&
 
   773     if (class_name->byte_at(0) == 'L' &&
 
   798         resolved_klass = Universe::typeArrayKlassObj(t);
 
   799         resolved_klass = Universe::typeArrayKlassObj(t);
 
   799         resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0);
 
   800         resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0);
 
   800       }
 
   801       }
 
   801     }
 
   802     }
 
   802   }
 
   803   }
 
   803   Handle result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   804   oop result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   804   return JNIHandles::make_local(THREAD, result());
 
   805   return JNIHandles::make_local(THREAD, result);
 
   805 C2V_END
 
   806 C2V_END
 
   806 
   807 
   807 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   808 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   808   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   809   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   809   oop result = cp->resolve_constant_at(index, CHECK_NULL);
 
   810   oop result = cp->resolve_constant_at(index, CHECK_NULL);
 
   839 C2V_END
 
   840 C2V_END
 
   840 
   841 
   841 C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   842 C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   842   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   843   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   843   Klass* resolved_klass = cp->klass_at(index, CHECK_NULL);
 
   844   Klass* resolved_klass = cp->klass_at(index, CHECK_NULL);
 
   844   Handle klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   845   oop klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
 
   845   return JNIHandles::make_local(THREAD, klass());
 
   846   return JNIHandles::make_local(THREAD, klass);
 
   846 C2V_END
 
   847 C2V_END
 
   847 
   848 
   848 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
 
   849 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
 
   849   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   850   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   850   KlassHandle loading_klass(cp->pool_holder());
 
   851   KlassHandle loading_klass(cp->pool_holder());
 
   852   KlassHandle klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass);
 
   853   KlassHandle klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass);
 
   853   Symbol* symbol = NULL;
 
   854   Symbol* symbol = NULL;
 
   854   if (klass.is_null()) {
 
   855   if (klass.is_null()) {
 
   855     symbol = cp->klass_name_at(index);
 
   856     symbol = cp->klass_name_at(index);
 
   856   }
 
   857   }
 
   857   Handle result;
 
   858   oop result_oop;
 
   858   if (!klass.is_null()) {
 
   859   if (!klass.is_null()) {
 
   859     result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);
 
   860     result_oop = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);
 
   860   } else {
 
   861   } else {
 
   861     result = java_lang_String::create_from_symbol(symbol, CHECK_NULL);
 
   862     Handle result = java_lang_String::create_from_symbol(symbol, CHECK_NULL);
 
   862   }
 
   863     result_oop = result();
 
   863   return JNIHandles::make_local(THREAD, result());
 
   864   }
 
       
   865   return JNIHandles::make_local(THREAD, result_oop);
 
   864 C2V_END
 
   866 C2V_END
 
   865 
   867 
   866 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   868 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
 
   867   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   869   constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
 
   868   oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
 
   870   oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
 
   983 C2V_END
 
   985 C2V_END
 
   984 
   986 
   985 C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject installed_code, jobject speculation_log))
 
   987 C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject installed_code, jobject speculation_log))
 
   986   ResourceMark rm;
 
   988   ResourceMark rm;
 
   987   HandleMark hm;
 
   989   HandleMark hm;
 
   988   Handle target_handle = JNIHandles::resolve(target);
 
   990   Handle target_handle(THREAD, JNIHandles::resolve(target));
 
   989   Handle compiled_code_handle = JNIHandles::resolve(compiled_code);
 
   991   Handle compiled_code_handle(THREAD, JNIHandles::resolve(compiled_code));
 
   990   CodeBlob* cb = NULL;
 
   992   CodeBlob* cb = NULL;
 
   991   Handle installed_code_handle = JNIHandles::resolve(installed_code);
 
   993   Handle installed_code_handle(THREAD, JNIHandles::resolve(installed_code));
 
   992   Handle speculation_log_handle = JNIHandles::resolve(speculation_log);
 
   994   Handle speculation_log_handle(THREAD, JNIHandles::resolve(speculation_log));
 
   993 
   995 
   994   JVMCICompiler* compiler = JVMCICompiler::instance(CHECK_JNI_ERR);
 
   996   JVMCICompiler* compiler = JVMCICompiler::instance(CHECK_JNI_ERR);
 
   995 
   997 
   996   TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
 
   998   TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
 
   997   bool is_immutable_PIC = HotSpotCompiledCode::isImmutablePIC(compiled_code_handle) > 0;
 
   999   bool is_immutable_PIC = HotSpotCompiledCode::isImmutablePIC(compiled_code_handle) > 0;
 
  1045 
  1047 
  1046 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata))
 
  1048 C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject compiled_code, jobject metadata))
 
  1047   ResourceMark rm;
 
  1049   ResourceMark rm;
 
  1048   HandleMark hm;
 
  1050   HandleMark hm;
 
  1049 
  1051 
  1050   Handle target_handle = JNIHandles::resolve(target);
 
  1052   Handle target_handle(THREAD, JNIHandles::resolve(target));
 
  1051   Handle compiled_code_handle = JNIHandles::resolve(compiled_code);
 
  1053   Handle compiled_code_handle(THREAD, JNIHandles::resolve(compiled_code));
 
  1052   Handle metadata_handle = JNIHandles::resolve(metadata);
 
  1054   Handle metadata_handle(THREAD, JNIHandles::resolve(metadata));
 
  1053 
  1055 
  1054   CodeMetadata code_metadata;
 
  1056   CodeMetadata code_metadata;
 
  1055   CodeBlob *cb = NULL;
 
  1057   CodeBlob *cb = NULL;
 
  1056   CodeInstaller installer(true /* immutable PIC compilation */);
 
  1058   CodeInstaller installer(true /* immutable PIC compilation */);
 
  1057 
  1059 
  1059   if (result != JVMCIEnv::ok) {
 
  1061   if (result != JVMCIEnv::ok) {
 
  1060     return result;
 
  1062     return result;
 
  1061   }
 
  1063   }
 
  1062 
  1064 
  1063   if (code_metadata.get_nr_pc_desc() > 0) {
 
  1065   if (code_metadata.get_nr_pc_desc() > 0) {
 
  1064     typeArrayHandle pcArrayOop = oopFactory::new_byteArray(sizeof(PcDesc) * code_metadata.get_nr_pc_desc(), CHECK_(JVMCIEnv::cache_full));
 
  1066     typeArrayHandle pcArrayOop = oopFactory::new_byteArray_handle(sizeof(PcDesc) * code_metadata.get_nr_pc_desc(), CHECK_(JVMCIEnv::cache_full));
 
  1065     memcpy(pcArrayOop->byte_at_addr(0), code_metadata.get_pc_desc(), sizeof(PcDesc) * code_metadata.get_nr_pc_desc());
 
  1067     memcpy(pcArrayOop->byte_at_addr(0), code_metadata.get_pc_desc(), sizeof(PcDesc) * code_metadata.get_nr_pc_desc());
 
  1066     HotSpotMetaData::set_pcDescBytes(metadata_handle, pcArrayOop());
 
  1068     HotSpotMetaData::set_pcDescBytes(metadata_handle, pcArrayOop());
 
  1067   }
 
  1069   }
 
  1068 
  1070 
  1069   if (code_metadata.get_scopes_size() > 0) {
 
  1071   if (code_metadata.get_scopes_size() > 0) {
 
  1070     typeArrayHandle scopesArrayOop = oopFactory::new_byteArray(code_metadata.get_scopes_size(), CHECK_(JVMCIEnv::cache_full));
 
  1072     typeArrayHandle scopesArrayOop = oopFactory::new_byteArray_handle(code_metadata.get_scopes_size(), CHECK_(JVMCIEnv::cache_full));
 
  1071     memcpy(scopesArrayOop->byte_at_addr(0), code_metadata.get_scopes_desc(), code_metadata.get_scopes_size());
 
  1073     memcpy(scopesArrayOop->byte_at_addr(0), code_metadata.get_scopes_desc(), code_metadata.get_scopes_size());
 
  1072     HotSpotMetaData::set_scopesDescBytes(metadata_handle, scopesArrayOop());
 
  1074     HotSpotMetaData::set_scopesDescBytes(metadata_handle, scopesArrayOop());
 
  1073   }
 
  1075   }
 
  1074 
  1076 
  1075   RelocBuffer* reloc_buffer = code_metadata.get_reloc_buffer();
 
  1077   RelocBuffer* reloc_buffer = code_metadata.get_reloc_buffer();
 
  1076   typeArrayHandle relocArrayOop = oopFactory::new_byteArray((int) reloc_buffer->size(), CHECK_(JVMCIEnv::cache_full));
 
  1078   typeArrayHandle relocArrayOop = oopFactory::new_byteArray_handle((int) reloc_buffer->size(), CHECK_(JVMCIEnv::cache_full));
 
  1077   if (reloc_buffer->size() > 0) {
 
  1079   if (reloc_buffer->size() > 0) {
 
  1078     memcpy(relocArrayOop->byte_at_addr(0), reloc_buffer->begin(), reloc_buffer->size());
 
  1080     memcpy(relocArrayOop->byte_at_addr(0), reloc_buffer->begin(), reloc_buffer->size());
 
  1079   }
 
  1081   }
 
  1080   HotSpotMetaData::set_relocBytes(metadata_handle, relocArrayOop());
 
  1082   HotSpotMetaData::set_relocBytes(metadata_handle, relocArrayOop());
 
  1081 
  1083 
  1082   const OopMapSet* oopMapSet = installer.oopMapSet();
 
  1084   const OopMapSet* oopMapSet = installer.oopMapSet();
 
  1083   {
 
  1085   {
 
  1084     ResourceMark mark;
 
  1086     ResourceMark mark;
 
  1085     ImmutableOopMapBuilder builder(oopMapSet);
 
  1087     ImmutableOopMapBuilder builder(oopMapSet);
 
  1086     int oopmap_size = builder.heap_size();
 
  1088     int oopmap_size = builder.heap_size();
 
  1087     typeArrayHandle oopMapArrayHandle = oopFactory::new_byteArray(oopmap_size, CHECK_(JVMCIEnv::cache_full));
 
  1089     typeArrayHandle oopMapArrayHandle = oopFactory::new_byteArray_handle(oopmap_size, CHECK_(JVMCIEnv::cache_full));
 
  1088     builder.generate_into((address) oopMapArrayHandle->byte_at_addr(0));
 
  1090     builder.generate_into((address) oopMapArrayHandle->byte_at_addr(0));
 
  1089     HotSpotMetaData::set_oopMaps(metadata_handle, oopMapArrayHandle());
 
  1091     HotSpotMetaData::set_oopMaps(metadata_handle, oopMapArrayHandle());
 
  1090   }
 
  1092   }
 
  1091 
  1093 
  1092   AOTOopRecorder* recorder = code_metadata.get_oop_recorder();
 
  1094   AOTOopRecorder* recorder = code_metadata.get_oop_recorder();
 
  1093 
  1095 
  1094   int nr_meta_strings = recorder->nr_meta_strings();
 
  1096   int nr_meta_strings = recorder->nr_meta_strings();
 
  1095   objArrayHandle metadataArrayHandle = oopFactory::new_objectArray(nr_meta_strings, CHECK_(JVMCIEnv::cache_full));
 
  1097   objArrayOop metadataArray = oopFactory::new_objectArray(nr_meta_strings, CHECK_(JVMCIEnv::cache_full));
 
       
  1098   objArrayHandle metadataArrayHandle(THREAD, metadataArray);
 
  1096   for (int i = 0; i < nr_meta_strings; ++i) {
 
  1099   for (int i = 0; i < nr_meta_strings; ++i) {
 
  1097     const char* element = recorder->meta_element(i);
 
  1100     const char* element = recorder->meta_element(i);
 
  1098     Handle java_string = java_lang_String::create_from_str(element, CHECK_(JVMCIEnv::cache_full));
 
  1101     Handle java_string = java_lang_String::create_from_str(element, CHECK_(JVMCIEnv::cache_full));
 
  1099     metadataArrayHandle->obj_at_put(i, java_string());
 
  1102     metadataArrayHandle->obj_at_put(i, java_string());
 
  1100   }
 
  1103   }
 
  1101   HotSpotMetaData::set_metadata(metadata_handle, metadataArrayHandle());
 
  1104   HotSpotMetaData::set_metadata(metadata_handle, metadataArrayHandle());
 
  1102 
  1105 
  1103   ExceptionHandlerTable* handler = code_metadata.get_exception_table();
 
  1106   ExceptionHandlerTable* handler = code_metadata.get_exception_table();
 
  1104   int table_size = handler->size_in_bytes();
 
  1107   int table_size = handler->size_in_bytes();
 
  1105   typeArrayHandle exceptionArrayOop = oopFactory::new_byteArray(table_size, CHECK_(JVMCIEnv::cache_full));
 
  1108   typeArrayHandle exceptionArrayOop = oopFactory::new_byteArray_handle(table_size, CHECK_(JVMCIEnv::cache_full));
 
  1106 
  1109 
  1107   if (table_size > 0) {
 
  1110   if (table_size > 0) {
 
  1108     handler->copy_bytes_to((address) exceptionArrayOop->byte_at_addr(0));
 
  1111     handler->copy_bytes_to((address) exceptionArrayOop->byte_at_addr(0));
 
  1109   }
 
  1112   }
 
  1110   HotSpotMetaData::set_exceptionBytes(metadata_handle, exceptionArrayOop());
 
  1113   HotSpotMetaData::set_exceptionBytes(metadata_handle, exceptionArrayOop());
 
  1279   }
 
  1282   }
 
  1280 C2V_END
 
  1283 C2V_END
 
  1281 
  1284 
  1282 
  1285 
  1283 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code))
 
  1286 C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code))
 
  1284   Handle installed_code_handle = JNIHandles::resolve(installed_code);
 
  1287   Handle installed_code_handle(THREAD, JNIHandles::resolve(installed_code));
 
  1285   nmethod::invalidate_installed_code(installed_code_handle, CHECK);
 
  1288   nmethod::invalidate_installed_code(installed_code_handle, CHECK);
 
  1286 C2V_END
 
  1289 C2V_END
 
  1287 
  1290 
  1288 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject))
 
  1291 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv*, jobject))
 
  1289   typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL);
 
  1292   typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL);
 
  1334 
  1337 
  1335 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip))
 
  1338 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip))
 
  1336   ResourceMark rm;
 
  1339   ResourceMark rm;
 
  1337 
  1340 
  1338   if (!thread->has_last_Java_frame()) return NULL;
 
  1341   if (!thread->has_last_Java_frame()) return NULL;
 
  1339   Handle result = HotSpotStackFrameReference::klass()->allocate_instance(thread);
 
  1342   Handle result = HotSpotStackFrameReference::klass()->allocate_instance_handle(thread);
 
  1340   HotSpotStackFrameReference::klass()->initialize(thread);
 
  1343   HotSpotStackFrameReference::klass()->initialize(thread);
 
  1341 
  1344 
  1342   StackFrameStream fst(thread);
 
  1345   StackFrameStream fst(thread);
 
  1343   if (hs_frame != NULL) {
 
  1346   if (hs_frame != NULL) {
 
  1344     // look for the correct stack frame if one is given
 
  1347     // look for the correct stack frame if one is given
 
  1393             if (scope != NULL && scope->objects() != NULL) {
 
  1396             if (scope != NULL && scope->objects() != NULL) {
 
  1394               bool realloc_failures = Deoptimization::realloc_objects(thread, fst.current(), scope->objects(), THREAD);
 
  1397               bool realloc_failures = Deoptimization::realloc_objects(thread, fst.current(), scope->objects(), THREAD);
 
  1395               Deoptimization::reassign_fields(fst.current(), fst.register_map(), scope->objects(), realloc_failures, false);
 
  1398               Deoptimization::reassign_fields(fst.current(), fst.register_map(), scope->objects(), realloc_failures, false);
 
  1396 
  1399 
  1397               GrowableArray<ScopeValue*>* local_values = scope->locals();
 
  1400               GrowableArray<ScopeValue*>* local_values = scope->locals();
 
  1398               typeArrayHandle array = oopFactory::new_boolArray(local_values->length(), thread);
 
  1401               typeArrayOop array_oop = oopFactory::new_boolArray(local_values->length(), thread);
 
       
  1402               typeArrayHandle array(THREAD, array_oop);
 
  1399               for (int i = 0; i < local_values->length(); i++) {
 
  1403               for (int i = 0; i < local_values->length(); i++) {
 
  1400                 ScopeValue* value = local_values->at(i);
 
  1404                 ScopeValue* value = local_values->at(i);
 
  1401                 if (value->is_object()) {
 
  1405                 if (value->is_object()) {
 
  1402                   array->bool_at_put(i, true);
 
  1406                   array->bool_at_put(i, true);
 
  1403                 }
 
  1407                 }
 
  1434         HotSpotStackFrameReference::set_compilerToVM(result, JNIHandles::resolve(compilerToVM));
 
  1438         HotSpotStackFrameReference::set_compilerToVM(result, JNIHandles::resolve(compilerToVM));
 
  1435         HotSpotStackFrameReference::set_stackPointer(result, (jlong) fst.current()->sp());
 
  1439         HotSpotStackFrameReference::set_stackPointer(result, (jlong) fst.current()->sp());
 
  1436         HotSpotStackFrameReference::set_frameNumber(result, frame_number);
 
  1440         HotSpotStackFrameReference::set_frameNumber(result, frame_number);
 
  1437 
  1441 
  1438         // initialize the locals array
 
  1442         // initialize the locals array
 
  1439         objArrayHandle array = oopFactory::new_objectArray(locals->size(), thread);
 
  1443         objArrayOop array_oop = oopFactory::new_objectArray(locals->size(), CHECK_NULL);
 
       
  1444         objArrayHandle array(THREAD, array_oop);
 
  1440         for (int i = 0; i < locals->size(); i++) {
 
  1445         for (int i = 0; i < locals->size(); i++) {
 
  1441           StackValue* var = locals->at(i);
 
  1446           StackValue* var = locals->at(i);
 
  1442           if (var->type() == T_OBJECT) {
 
  1447           if (var->type() == T_OBJECT) {
 
  1443             array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1448             array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1444           }
 
  1449           }
 
  1486     cp_cache_entry->set_method_handle(cp, callInfo);
 
  1491     cp_cache_entry->set_method_handle(cp, callInfo);
 
  1487   }
 
  1492   }
 
  1488 C2V_END
 
  1493 C2V_END
 
  1489 
  1494 
  1490 C2V_VMENTRY(jobject, getSignaturePolymorphicHolders, (JNIEnv*, jobject))
 
  1495 C2V_VMENTRY(jobject, getSignaturePolymorphicHolders, (JNIEnv*, jobject))
 
  1491   objArrayHandle holders = oopFactory::new_objArray(SystemDictionary::String_klass(), 2, CHECK_NULL);
 
  1496   objArrayHandle holders = oopFactory::new_objArray_handle(SystemDictionary::String_klass(), 2, CHECK_NULL);
 
  1492   Handle mh = java_lang_String::create_from_str("Ljava/lang/invoke/MethodHandle;", CHECK_NULL);
 
  1497   Handle mh = java_lang_String::create_from_str("Ljava/lang/invoke/MethodHandle;", CHECK_NULL);
 
  1493   Handle vh = java_lang_String::create_from_str("Ljava/lang/invoke/VarHandle;", CHECK_NULL);
 
  1498   Handle vh = java_lang_String::create_from_str("Ljava/lang/invoke/VarHandle;", CHECK_NULL);
 
  1494   holders->obj_at_put(0, mh());
 
  1499   holders->obj_at_put(0, mh());
 
  1495   holders->obj_at_put(1, vh());
 
  1500   holders->obj_at_put(1, vh());
 
  1496   return JNIHandles::make_local(THREAD, holders());
 
  1501   return JNIHandles::make_local(THREAD, holders());
 
  1593 
  1598 
  1594   // all locals are materialized by now
 
  1599   // all locals are materialized by now
 
  1595   HotSpotStackFrameReference::set_localIsVirtual(hs_frame, NULL);
 
  1600   HotSpotStackFrameReference::set_localIsVirtual(hs_frame, NULL);
 
  1596 
  1601 
  1597   // update the locals array
 
  1602   // update the locals array
 
  1598   objArrayHandle array = HotSpotStackFrameReference::locals(hs_frame);
 
  1603   objArrayHandle array(THREAD, HotSpotStackFrameReference::locals(hs_frame));
 
  1599   StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals();
 
  1604   StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals();
 
  1600   for (int i = 0; i < locals->size(); i++) {
 
  1605   for (int i = 0; i < locals->size(); i++) {
 
  1601     StackValue* var = locals->at(i);
 
  1606     StackValue* var = locals->at(i);
 
  1602     if (var->type() == T_OBJECT) {
 
  1607     if (var->type() == T_OBJECT) {
 
  1603       array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1608       array->obj_at_put(i, locals->at(i)->get_obj()());
 
  1694   }
 
  1699   }
 
  1695   return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord;
 
  1700   return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord;
 
  1696 C2V_END
 
  1701 C2V_END
 
  1697 
  1702 
  1698 C2V_VMENTRY(void, compileToBytecode, (JNIEnv*, jobject, jobject lambda_form_handle))
 
  1703 C2V_VMENTRY(void, compileToBytecode, (JNIEnv*, jobject, jobject lambda_form_handle))
 
  1699   Handle lambda_form = JNIHandles::resolve_non_null(lambda_form_handle);
 
  1704   Handle lambda_form(THREAD, JNIHandles::resolve_non_null(lambda_form_handle));
 
  1700   if (lambda_form->is_a(SystemDictionary::LambdaForm_klass())) {
 
  1705   if (lambda_form->is_a(SystemDictionary::LambdaForm_klass())) {
 
  1701     TempNewSymbol compileToBytecode = SymbolTable::new_symbol("compileToBytecode", CHECK);
 
  1706     TempNewSymbol compileToBytecode = SymbolTable::new_symbol("compileToBytecode", CHECK);
 
  1702     JavaValue result(T_VOID);
 
  1707     JavaValue result(T_VOID);
 
  1703     JavaCalls::call_special(&result, lambda_form, SystemDictionary::LambdaForm_klass(), compileToBytecode, vmSymbols::void_method_signature(), CHECK);
 
  1708     JavaCalls::call_special(&result, lambda_form, SystemDictionary::LambdaForm_klass(), compileToBytecode, vmSymbols::void_method_signature(), CHECK);
 
  1704   } else {
 
  1709   } else {
jdk-sandbox