966 Handle class_loader (THREAD, JNIHandles::resolve(loader));
967 if (UsePerfData) {
968 is_lock_held_by_thread(class_loader,
969 ClassLoader::sync_JVMDefineClassLockFreeCounter(),
970 THREAD);
971 }
972 Handle protection_domain (THREAD, JNIHandles::resolve(pd));
973 Klass* k = SystemDictionary::resolve_from_stream(class_name,
974 class_loader,
975 protection_domain,
976 &st,
977 CHECK_NULL);
978
979 if (log_is_enabled(Debug, class, resolve) && k != NULL) {
980 trace_class_resolution(k);
981 }
982
983 return (jclass) JNIHandles::make_local(env, k->java_mirror());
984 }
985
986
987 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
988 JVMWrapper("JVM_DefineClass");
989
990 return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, THREAD);
991 JVM_END
992
993
994 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
995 JVMWrapper("JVM_DefineClassWithSource");
996
997 return jvm_define_class_common(env, name, loader, buf, len, pd, source, THREAD);
998 JVM_END
999
1000 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))
1001 JVMWrapper("JVM_FindLoadedClass");
1002 ResourceMark rm(THREAD);
1003
1004 Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
1005 char* str = java_lang_String::as_utf8_string(h_name());
1006
1007 // Sanity check, don't expect null
1008 if (str == NULL) return NULL;
1009
1010 // Internalize the string, converting '.' to '/' in string.
1011 char* p = (char*)str;
1012 while (*p != '\0') {
1135 }
1136 return (jobjectArray) JNIHandles::make_local(env, result());
1137 JVM_END
1138
1139
1140 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1141 JVMWrapper("JVM_IsInterface");
1142 oop mirror = JNIHandles::resolve_non_null(cls);
1143 if (java_lang_Class::is_primitive(mirror)) {
1144 return JNI_FALSE;
1145 }
1146 Klass* k = java_lang_Class::as_Klass(mirror);
1147 jboolean result = k->is_interface();
1148 assert(!result || k->is_instance_klass(),
1149 "all interfaces are instance types");
1150 // The compiler intrinsic for isInterface tests the
1151 // Klass::_access_flags bits in the same way.
1152 return result;
1153 JVM_END
1154
1155
1156 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1157 JVMWrapper("JVM_GetClassSigners");
1158 JvmtiVMObjectAllocEventCollector oam;
1159 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1160 // There are no signers for primitive types
1161 return NULL;
1162 }
1163
1164 objArrayHandle signers(THREAD, java_lang_Class::signers(JNIHandles::resolve_non_null(cls)));
1165
1166 // If there are no signers set in the class, or if the class
1167 // is an array, return NULL.
1168 if (signers == NULL) return NULL;
1169
1170 // copy of the signers array
1171 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1172 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1173 for (int index = 0; index < signers->length(); index++) {
1174 signers_copy->obj_at_put(index, signers->obj_at(index));
1402 return (jobjectArray)JNIHandles::make_local(env, res);
1403 }
1404
1405 return (jobjectArray)JNIHandles::make_local(env, result());
1406 JVM_END
1407
1408
1409 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1410 {
1411 // ofClass is a reference to a java_lang_Class object.
1412 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1413 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) {
1414 return NULL;
1415 }
1416
1417 bool inner_is_member = false;
1418 Klass* outer_klass
1419 = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))
1420 )->compute_enclosing_class(&inner_is_member, CHECK_NULL);
1421 if (outer_klass == NULL) return NULL; // already a top-level class
1422 if (!inner_is_member) return NULL; // an anonymous class (inside a method)
1423 return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror());
1424 }
1425 JVM_END
1426
1427 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv *env, jclass cls))
1428 {
1429 oop mirror = JNIHandles::resolve_non_null(cls);
1430 if (java_lang_Class::is_primitive(mirror) ||
1431 !java_lang_Class::as_Klass(mirror)->is_instance_klass()) {
1432 return NULL;
1433 }
1434 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
1435 int ooff = 0, noff = 0;
1436 if (k->find_inner_classes_attr(&ooff, &noff, THREAD)) {
1437 if (noff != 0) {
1438 constantPoolHandle i_cp(thread, k->constants());
1439 Symbol* name = i_cp->symbol_at(noff);
1440 Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL);
1441 return (jstring) JNIHandles::make_local(env, str());
1442 }
1848 length + 1, CHECK_NULL);
1849 objArrayHandle result (THREAD, r);
1850 result->obj_at_put(0, host->java_mirror());
1851 if (length != 0) {
1852 int i;
1853 for (i = 0; i < length; i++) {
1854 int cp_index = members->at(i);
1855 Klass* k = host->constants()->klass_at(cp_index, CHECK_NULL);
1856 if (k->is_instance_klass()) {
1857 InstanceKlass* nest_host_k =
1858 InstanceKlass::cast(k)->nest_host(icce, CHECK_NULL);
1859 if (nest_host_k == host) {
1860 result->obj_at_put(i+1, k->java_mirror());
1861 }
1862 else {
1863 // k's nest host is legal but it isn't our host so
1864 // throw ICCE
1865 ResourceMark rm(THREAD);
1866 Exceptions::fthrow(THREAD_AND_LOCATION,
1867 icce,
1868 "Nest member %s in %s declares a different nest host of %s",
1869 k->external_name(),
1870 host->external_name(),
1871 nest_host_k->external_name()
1872 );
1873 return NULL;
1874 }
1875 }
1876 else {
1877 // we have a bad nest member entry - throw ICCE
1878 ResourceMark rm(THREAD);
1879 Exceptions::fthrow(THREAD_AND_LOCATION,
1880 icce,
1881 "Class %s can not be a nest member of %s",
1882 k->external_name(),
1883 host->external_name()
1884 );
1885 return NULL;
1886 }
1887 }
1888 }
1889 else {
1890 assert(host == ck, "must be singleton nest");
1891 }
1892 return (jobjectArray)JNIHandles::make_local(THREAD, result());
1893 }
1894 }
1895 JVM_END
1896
1897 // Constant pool access //////////////////////////////////////////////////////////
1898
1899 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls))
1900 {
1901 JVMWrapper("JVM_GetClassConstantPool");
1902 JvmtiVMObjectAllocEventCollector oam;
1903
1904 // Return null for primitives and arrays
1905 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1906 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1907 if (k->is_instance_klass()) {
1908 InstanceKlass* k_h = InstanceKlass::cast(k);
1909 Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
1910 reflect_ConstantPool::set_cp(jcp(), k_h->constants());
|
966 Handle class_loader (THREAD, JNIHandles::resolve(loader));
967 if (UsePerfData) {
968 is_lock_held_by_thread(class_loader,
969 ClassLoader::sync_JVMDefineClassLockFreeCounter(),
970 THREAD);
971 }
972 Handle protection_domain (THREAD, JNIHandles::resolve(pd));
973 Klass* k = SystemDictionary::resolve_from_stream(class_name,
974 class_loader,
975 protection_domain,
976 &st,
977 CHECK_NULL);
978
979 if (log_is_enabled(Debug, class, resolve) && k != NULL) {
980 trace_class_resolution(k);
981 }
982
983 return (jclass) JNIHandles::make_local(env, k->java_mirror());
984 }
985
986 enum {
987 NESTMATE = java_lang_invoke_MemberName::MN_NESTMATE_CLASS,
988 HIDDEN_CLASS = java_lang_invoke_MemberName::MN_HIDDEN_CLASS,
989 WEAK_CLASS = java_lang_invoke_MemberName::MN_WEAK_CLASS,
990 ACCESS_VM_ANNOTATIONS = java_lang_invoke_MemberName::MN_ACCESS_VM_ANNOTATIONS
991 };
992
993 /*
994 * Define a class with the specified flags that indicates if it's a nestmate,
995 * hidden, or weakly referenced from class loader.
996 */
997 static jclass jvm_lookup_define_class(JNIEnv *env, jclass lookup, const char *name,
998 jobject loader, const jbyte *buf, jsize len, jobject pd,
999 jboolean init, int flags, jobject classData, TRAPS) {
1000 assert(THREAD->is_Java_thread(), "must be a JavaThread");
1001 JavaThread* jt = (JavaThread*) THREAD;
1002 ResourceMark rm(THREAD);
1003
1004 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(lookup));
1005 // Lookup class must be a non-null instance
1006 if (k == NULL) {
1007 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null");
1008 }
1009 assert(k->is_instance_klass(), "Lookup class must be an instance klass");
1010
1011 jboolean is_nestmate = (flags & NESTMATE) == NESTMATE;
1012 jboolean is_hidden = (flags & HIDDEN_CLASS) == HIDDEN_CLASS;
1013 jboolean is_weak = (flags & WEAK_CLASS) == WEAK_CLASS;
1014 jboolean vm_annotations = (flags & ACCESS_VM_ANNOTATIONS) == ACCESS_VM_ANNOTATIONS;
1015
1016 InstanceKlass* host_class = NULL;
1017 if (is_nestmate) {
1018 host_class = InstanceKlass::cast(k)->runtime_nest_host(CHECK_NULL);
1019 }
1020
1021 if (log_is_enabled(Info, class, nestmates)) {
1022 log_info(class, nestmates)("LookupDefineClass: %s - %s%s, %s, %s, %s",
1023 name,
1024 is_nestmate ? "with dynamic nest-host " : "non-nestmate",
1025 is_nestmate ? host_class->external_name() : "",
1026 is_hidden ? "hidden" : "not hidden",
1027 is_weak ? "weak" : "strong",
1028 vm_annotations ? "with vm annotations" : "without vm annotation");
1029 }
1030
1031 if (!is_hidden) {
1032 // classData is only applicable for hidden classes
1033 if (classData != NULL) {
1034 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "classData is only applicable for hidden classes");
1035 }
1036 if (is_nestmate) {
1037 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "dynamic nestmate is only applicable for hidden classes");
1038 }
1039 if (is_weak) {
1040 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "weak class is only applicable for hidden classes");
1041 }
1042 if (vm_annotations) {
1043 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "vm annotations only allowed for hidden classes");
1044 }
1045 if (flags) {
1046 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1047 err_msg("flag 0x%x can only be set for hidden classes", flags));
1048 }
1049 }
1050
1051
1052 // Since exceptions can be thrown, class initialization can take place
1053 // if name is NULL no check for class name in .class stream has to be made.
1054 TempNewSymbol class_name = NULL;
1055 if (name != NULL) {
1056 const int str_len = (int)strlen(name);
1057 if (str_len > Symbol::max_length()) {
1058 // It's impossible to create this class; the name cannot fit
1059 // into the constant pool.
1060 Exceptions::fthrow(THREAD_AND_LOCATION,
1061 vmSymbols::java_lang_NoClassDefFoundError(),
1062 "Class name exceeds maximum length of %d: %s",
1063 Symbol::max_length(),
1064 name);
1065 return 0;
1066 }
1067 class_name = SymbolTable::new_symbol(name, str_len);
1068 }
1069
1070 Handle class_loader (THREAD, JNIHandles::resolve(loader));
1071 Handle protection_domain (THREAD, JNIHandles::resolve(pd));
1072 const char* source = is_nestmate ? host_class->external_name() : "__JVM_LookupDefineClass__";
1073 ClassFileStream st((u1*)buf, len, source, ClassFileStream::verify);
1074
1075 if (!is_hidden) {
1076 k = SystemDictionary::resolve_from_stream(class_name,
1077 class_loader,
1078 protection_domain,
1079 &st,
1080 CHECK_NULL);
1081
1082 if (log_is_enabled(Debug, class, resolve) && k != NULL) {
1083 trace_class_resolution(k);
1084 }
1085 } else { // hidden
1086 Handle classData_h(THREAD, JNIHandles::resolve(classData));
1087 ClassLoadInfo cl_info(protection_domain,
1088 NULL, // unsafe_anonymous_host
1089 NULL, // cp_patches
1090 host_class,
1091 classData_h,
1092 is_hidden,
1093 is_weak,
1094 vm_annotations);
1095 k = SystemDictionary::parse_stream(class_name,
1096 class_loader,
1097 &st,
1098 cl_info,
1099 CHECK_NULL);
1100 if (k == NULL) {
1101 THROW_MSG_0(vmSymbols::java_lang_Error(), "Failure to define a hidden class");
1102 }
1103
1104 // The hidden class loader data has been artificially been kept alive to
1105 // this point. The mirror and any instances of this class have to keep
1106 // it alive afterwards.
1107 InstanceKlass::cast(k)->class_loader_data()->dec_keep_alive();
1108
1109 if (is_nestmate && log_is_enabled(Debug, class, nestmates)) {
1110 InstanceKlass* ik = InstanceKlass::cast(k);
1111 ModuleEntry* module = ik->module();
1112 const char * module_name = module->is_named() ? module->name()->as_C_string() : UNNAMED_MODULE;
1113 log_debug(class, nestmates)("Dynamic nestmate: %s/%s, nest_host %s, %s",
1114 module_name,
1115 ik->external_name(),
1116 host_class->external_name(),
1117 ik->is_hidden() ? "is hidden" : "is not hidden");
1118 }
1119 }
1120
1121 InstanceKlass* ik = InstanceKlass::cast(k);
1122 if (init) {
1123 ik->initialize(CHECK_NULL);
1124 } else {
1125 ik->link_class(CHECK_NULL);
1126 }
1127
1128 return (jclass) JNIHandles::make_local(env, k->java_mirror());
1129 }
1130
1131 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
1132 JVMWrapper("JVM_DefineClass");
1133
1134 return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, THREAD);
1135 JVM_END
1136
1137 /*
1138 * Define a class with the specified lookup class.
1139 * lookup: Lookup class
1140 * name: the name of the class
1141 * loader: defining class loader
1142 * buf: class bytes
1143 * len: length of class bytes
1144 * pd: protection domain
1145 * init: initialize the class
1146 * flags: properties of the class
1147 * classData: private static pre-initialized field
1148 */
1149 JVM_ENTRY(jclass, JVM_LookupDefineClass(JNIEnv *env, jclass lookup, const char *name, jobject loader,
1150 const jbyte *buf, jsize len, jobject pd, jboolean initialize, int flags, jobject classData))
1151 JVMWrapper("JVM_LookupDefineClass");
1152
1153 if (lookup == NULL) {
1154 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Lookup class is null");
1155 }
1156
1157 assert(buf != NULL, "buf must not be NULL");
1158
1159 return jvm_lookup_define_class(env, lookup, name, loader, buf, len, pd, initialize, flags, classData, THREAD);
1160 JVM_END
1161
1162 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
1163 JVMWrapper("JVM_DefineClassWithSource");
1164
1165 return jvm_define_class_common(env, name, loader, buf, len, pd, source, THREAD);
1166 JVM_END
1167
1168 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))
1169 JVMWrapper("JVM_FindLoadedClass");
1170 ResourceMark rm(THREAD);
1171
1172 Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
1173 char* str = java_lang_String::as_utf8_string(h_name());
1174
1175 // Sanity check, don't expect null
1176 if (str == NULL) return NULL;
1177
1178 // Internalize the string, converting '.' to '/' in string.
1179 char* p = (char*)str;
1180 while (*p != '\0') {
1303 }
1304 return (jobjectArray) JNIHandles::make_local(env, result());
1305 JVM_END
1306
1307
1308 JVM_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1309 JVMWrapper("JVM_IsInterface");
1310 oop mirror = JNIHandles::resolve_non_null(cls);
1311 if (java_lang_Class::is_primitive(mirror)) {
1312 return JNI_FALSE;
1313 }
1314 Klass* k = java_lang_Class::as_Klass(mirror);
1315 jboolean result = k->is_interface();
1316 assert(!result || k->is_instance_klass(),
1317 "all interfaces are instance types");
1318 // The compiler intrinsic for isInterface tests the
1319 // Klass::_access_flags bits in the same way.
1320 return result;
1321 JVM_END
1322
1323 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1324 JVMWrapper("JVM_IsHiddenClass");
1325 oop mirror = JNIHandles::resolve_non_null(cls);
1326 if (java_lang_Class::is_primitive(mirror)) {
1327 return JNI_FALSE;
1328 }
1329 Klass* k = java_lang_Class::as_Klass(mirror);
1330 return k->is_hidden();
1331 JVM_END
1332
1333 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1334 JVMWrapper("JVM_GetClassSigners");
1335 JvmtiVMObjectAllocEventCollector oam;
1336 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1337 // There are no signers for primitive types
1338 return NULL;
1339 }
1340
1341 objArrayHandle signers(THREAD, java_lang_Class::signers(JNIHandles::resolve_non_null(cls)));
1342
1343 // If there are no signers set in the class, or if the class
1344 // is an array, return NULL.
1345 if (signers == NULL) return NULL;
1346
1347 // copy of the signers array
1348 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1349 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1350 for (int index = 0; index < signers->length(); index++) {
1351 signers_copy->obj_at_put(index, signers->obj_at(index));
1579 return (jobjectArray)JNIHandles::make_local(env, res);
1580 }
1581
1582 return (jobjectArray)JNIHandles::make_local(env, result());
1583 JVM_END
1584
1585
1586 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1587 {
1588 // ofClass is a reference to a java_lang_Class object.
1589 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1590 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) {
1591 return NULL;
1592 }
1593
1594 bool inner_is_member = false;
1595 Klass* outer_klass
1596 = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))
1597 )->compute_enclosing_class(&inner_is_member, CHECK_NULL);
1598 if (outer_klass == NULL) return NULL; // already a top-level class
1599 if (!inner_is_member) return NULL; // a hidden or unsafe anonymous class (inside a method)
1600 return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror());
1601 }
1602 JVM_END
1603
1604 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv *env, jclass cls))
1605 {
1606 oop mirror = JNIHandles::resolve_non_null(cls);
1607 if (java_lang_Class::is_primitive(mirror) ||
1608 !java_lang_Class::as_Klass(mirror)->is_instance_klass()) {
1609 return NULL;
1610 }
1611 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
1612 int ooff = 0, noff = 0;
1613 if (k->find_inner_classes_attr(&ooff, &noff, THREAD)) {
1614 if (noff != 0) {
1615 constantPoolHandle i_cp(thread, k->constants());
1616 Symbol* name = i_cp->symbol_at(noff);
1617 Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL);
1618 return (jstring) JNIHandles::make_local(env, str());
1619 }
2025 length + 1, CHECK_NULL);
2026 objArrayHandle result (THREAD, r);
2027 result->obj_at_put(0, host->java_mirror());
2028 if (length != 0) {
2029 int i;
2030 for (i = 0; i < length; i++) {
2031 int cp_index = members->at(i);
2032 Klass* k = host->constants()->klass_at(cp_index, CHECK_NULL);
2033 if (k->is_instance_klass()) {
2034 InstanceKlass* nest_host_k =
2035 InstanceKlass::cast(k)->nest_host(icce, CHECK_NULL);
2036 if (nest_host_k == host) {
2037 result->obj_at_put(i+1, k->java_mirror());
2038 }
2039 else {
2040 // k's nest host is legal but it isn't our host so
2041 // throw ICCE
2042 ResourceMark rm(THREAD);
2043 Exceptions::fthrow(THREAD_AND_LOCATION,
2044 icce,
2045 "%s.getNestMembers: Nest member %s in %s declares a different nest host of %s",
2046 c->external_name(),
2047 k->external_name(),
2048 host->external_name(),
2049 nest_host_k->external_name()
2050 );
2051 return NULL;
2052 }
2053 }
2054 else {
2055 // we have a bad nest member entry - throw ICCE
2056 ResourceMark rm(THREAD);
2057 Exceptions::fthrow(THREAD_AND_LOCATION,
2058 icce,
2059 "Class %s can not be a nest member of %s",
2060 k->external_name(),
2061 host->external_name()
2062 );
2063 return NULL;
2064 }
2065 }
2066 }
2067 else {
2068 assert(host == ck || ck->is_hidden(), "must be singleton nest or dynamic nestmate");
2069 }
2070 return (jobjectArray)JNIHandles::make_local(THREAD, result());
2071 }
2072 }
2073 JVM_END
2074
2075 // Constant pool access //////////////////////////////////////////////////////////
2076
2077 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls))
2078 {
2079 JVMWrapper("JVM_GetClassConstantPool");
2080 JvmtiVMObjectAllocEventCollector oam;
2081
2082 // Return null for primitives and arrays
2083 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
2084 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2085 if (k->is_instance_klass()) {
2086 InstanceKlass* k_h = InstanceKlass::cast(k);
2087 Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
2088 reflect_ConstantPool::set_cp(jcp(), k_h->constants());
|