prims (original) (raw)

1005 oop result = StringTable::intern((char*) name, CHECK_NULL); 1006 return (jstring) JNIHandles::make_local(env, result); 1007 JVM_END 1008 1009 1010 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls)) 1011 JVMWrapper("JVM_GetClassInterfaces"); 1012 JvmtiVMObjectAllocEventCollector oam; 1013 oop mirror = JNIHandles::resolve_non_null(cls); 1014 1015 // Special handling for primitive objects 1016 if (java_lang_Class::is_primitive(mirror)) { 1017 // Primitive objects does not have any interfaces 1018 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); 1019 return (jobjectArray) JNIHandles::make_local(env, r); 1020 } 1021 1022 KlassHandle klass(thread, java_lang_Class::as_Klass(mirror)); 1023 // Figure size of result array 1024 int size; 1025 if (klass->oop_is_instance()) { 1026 size = InstanceKlass::cast(klass())->local_interfaces()->length(); 1027 } else { 1028 assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass"); 1029 size = 2; 1030 } 1031 1032 // Allocate result array 1033 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), size, CHECK_NULL); 1034 objArrayHandle result (THREAD, r); 1035 // Fill in result 1036 if (klass->oop_is_instance()) { 1037 // Regular instance klass, fill in all local interfaces 1038 for (int index = 0; index < size; index++) { 1039 Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index); 1040 result->obj_at_put(index, k->java_mirror()); 1041 } 1042 } else { 1043 // All arrays implement java.lang.Cloneable and java.io.Serializable 1044 result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror()); 1045 result->obj_at_put(1, SystemDictionary::Serializable_klass()->java_mirror()); 1046 } 1047 return (jobjectArray) JNIHandles::make_local(env, result()); 1048 JVM_END 1049 1050 1051 JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv env, jclass cls)) 1052 JVMWrapper("JVM_IsInterface"); 1053 oop mirror = JNIHandles::resolve_non_null(cls); 1054 if (java_lang_Class::is_primitive(mirror)) { 1055 return JNI_FALSE; 1056 } 1057 Klass k = java_lang_Class::as_Klass(mirror); 1058 jboolean result = k->is_interface(); 1059 assert(!result || k->oop_is_instance(), 1060 "all interfaces are instance types"); 1061 // The compiler intrinsic for isInterface tests the 1062 // Klass::access_flags bits in the same way. 1063 return result; 1064 JVM_END 1065 1066 1067 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv env, jclass cls)) 1068 JVMWrapper("JVM_GetClassSigners"); 1069 JvmtiVMObjectAllocEventCollector oam; 1070 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1071 // There are no signers for primitive types 1072 return NULL; 1073 } 1074 1075 objArrayOop signers = java_lang_Class::signers(JNIHandles::resolve_non_null(cls)); 1076 1077 // If there are no signers set in the class, or if the class 1078 // is an array, return NULL. 1079 if (signers == NULL) return NULL; 1080 1081 // copy of the signers array 1082 Klass element = ObjArrayKlass::cast(signers->klass())->element_klass(); 1083 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL); 1084 for (int index = 0; index < signers->length(); index++) { 1085 signers_copy->obj_at_put(index, signers->obj_at(index)); 1086 } 1087 1088 // return the copy 1089 return (jobjectArray) JNIHandles::make_local(env, signers_copy); 1090 JVM_END 1091 1092 1093 JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv env, jclass cls, jobjectArray signers)) 1094 JVMWrapper("JVM_SetClassSigners"); 1095 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1096 // This call is ignored for primitive types and arrays. 1097 // Signers are only set once, ClassLoader.java, and thus shouldn't 1098 // be called with an array. Only the bootstrap loader creates arrays. 1099 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1100 if (k->oop_is_instance()) { 1101 java_lang_Class::set_signers(k->java_mirror(), objArrayOop(JNIHandles::resolve(signers))); 1102 } 1103 } 1104 JVM_END 1105 1106 1107 JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls)) 1108 JVMWrapper("JVM_GetProtectionDomain"); 1109 if (JNIHandles::resolve(cls) == NULL) { 1110 THROW(vmSymbols::java_lang_NullPointerException(), NULL); 1111 } 1112 1113 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1114 // Primitive types does not have a protection domain. 1115 return NULL; 1116 } 1117 1118 oop pd = java_lang_Class::protection_domain(JNIHandles::resolve(cls)); 1119 return (jobject) JNIHandles::make_local(env, pd); 1120 JVM_END

1339 } 1340 1341 // the resource area must be registered in case of a gc 1342 RegisterArrayForGC ragc(thread, local_array); 1343 objArrayOop context = oopFactory::new_objArray(SystemDictionary::ProtectionDomain_klass(), 1344 local_array->length(), CHECK_NULL); 1345 objArrayHandle h_context(thread, context); 1346 for (int index = 0; index < local_array->length(); index++) { 1347 h_context->obj_at_put(index, local_array->at(index)); 1348 } 1349 1350 oop result = java_security_AccessControlContext::create(h_context, is_privileged, privileged_context, CHECK_NULL); 1351 1352 return JNIHandles::make_local(env, result); 1353 JVM_END 1354 1355 1356 JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv env, jclass cls)) 1357 JVMWrapper("JVM_IsArrayClass"); 1358 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1359 return (k != NULL) && k->oop_is_array() ? true : false; 1360 JVM_END 1361 1362 1363 JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)) 1364 JVMWrapper("JVM_IsPrimitiveClass"); 1365 oop mirror = JNIHandles::resolve_non_null(cls); 1366 return (jboolean) java_lang_Class::is_primitive(mirror); 1367 JVM_END 1368 1369 1370 JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv env, jclass cls)) 1371 JVMWrapper("JVM_GetClassModifiers"); 1372 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1373 // Primitive type 1374 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; 1375 } 1376 1377 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1378 debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0)); 1379 assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK"); 1380 return k->modifier_flags(); 1381 JVM_END 1382 1383 1384 // Inner class reflection /////////////////////////////////////////////////////////////////////////////// 1385 1386 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)) 1387 JvmtiVMObjectAllocEventCollector oam; 1388 // ofClass is a reference to a java_lang_Class object. The mirror object 1389 // of an InstanceKlass 1390 1391 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1392 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_instance()) { 1393 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); 1394 return (jobjectArray)JNIHandles::make_local(env, result); 1395 } 1396 1397 instanceKlassHandle k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); 1398 InnerClassesIterator iter(k); 1399 1400 if (iter.length() == 0) { 1401 // Neither an inner nor outer class 1402 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); 1403 return (jobjectArray)JNIHandles::make_local(env, result); 1404 } 1405 1406 // find inner class info 1407 constantPoolHandle cp(thread, k->constants()); 1408 int length = iter.length(); 1409 1410 // Allocate temp. result array 1411 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), length/4, CHECK_NULL); 1412 objArrayHandle result (THREAD, r);

1436 } 1437 } 1438 1439 if (members != length) { 1440 // Return array of right length 1441 objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL); 1442 for(int i = 0; i < members; i++) { 1443 res->obj_at_put(i, result->obj_at(i)); 1444 } 1445 return (jobjectArray)JNIHandles::make_local(env, res); 1446 } 1447 1448 return (jobjectArray)JNIHandles::make_local(env, result()); 1449 JVM_END 1450 1451 1452 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv env, jclass ofClass)) 1453 { 1454 // ofClass is a reference to a java_lang_Class object. 1455 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1456 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_instance()) { 1457 return NULL; 1458 } 1459 1460 bool inner_is_member = false; 1461 Klass outer_klass 1462 = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)) 1463 )->compute_enclosing_class(&inner_is_member, CHECK_NULL); 1464 if (outer_klass == NULL) return NULL; // already a top-level class 1465 if (!inner_is_member) return NULL; // an anonymous class (inside a method) 1466 return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror()); 1467 } 1468 JVM_END 1469 1470 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv env, jclass cls)) 1471 { 1472 oop mirror = JNIHandles::resolve_non_null(cls); 1473 if (java_lang_Class::is_primitive(mirror) || 1474 !java_lang_Class::as_Klass(mirror)->oop_is_instance()) { 1475 return NULL; 1476 } 1477 instanceKlassHandle k(THREAD, InstanceKlass::cast(java_lang_Class::as_Klass(mirror))); 1478 int ooff = 0, noff = 0; 1479 if (InstanceKlass::find_inner_classes_attr(k, &ooff, &noff, THREAD)) { 1480 if (noff != 0) { 1481 constantPoolHandle i_cp(thread, k->constants()); 1482 Symbol name = i_cp->symbol_at(noff); 1483 Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL); 1484 return (jstring) JNIHandles::make_local(env, str()); 1485 } 1486 } 1487 return NULL; 1488 } 1489 JVM_END 1490 1491 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv env, jclass cls)) 1492 assert (cls != NULL, "illegal class"); 1493 JVMWrapper("JVM_GetClassSignature"); 1494 JvmtiVMObjectAllocEventCollector oam; 1495 ResourceMark rm(THREAD); 1496 // Return null for arrays and primatives 1497 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1498 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 1499 if (k->oop_is_instance()) { 1500 Symbol* sym = InstanceKlass::cast(k)->generic_signature(); 1501 if (sym == NULL) return NULL; 1502 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 1503 return (jstring) JNIHandles::make_local(env, str()); 1504 } 1505 } 1506 return NULL; 1507 JVM_END 1508 1509 1510 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv env, jclass cls)) 1511 assert (cls != NULL, "illegal class"); 1512 JVMWrapper("JVM_GetClassAnnotations"); 1513 1514 // Return null for arrays and primitives 1515 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1516 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 1517 if (k->oop_is_instance()) { 1518 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL); 1519 return (jbyteArray) JNIHandles::make_local(env, a); 1520 } 1521 } 1522 return NULL; 1523 JVM_END 1524 1525 1526 static bool jvm_get_field_common(jobject field, fieldDescriptor& fd, TRAPS) { 1527 // some of this code was adapted from from jni_FromReflectedField 1528 1529 oop reflected = JNIHandles::resolve_non_null(field); 1530 oop mirror = java_lang_reflect_Field::clazz(reflected); 1531 Klass* k = java_lang_Class::as_Klass(mirror); 1532 int slot = java_lang_reflect_Field::slot(reflected); 1533 int modifiers = java_lang_reflect_Field::modifiers(reflected); 1534 1535 KlassHandle kh(THREAD, k); 1536 intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot); 1537

1567 "wrong type"); 1568 mirror = java_lang_reflect_Method::clazz(reflected); 1569 slot = java_lang_reflect_Method::slot(reflected); 1570 } 1571 Klass* k = java_lang_Class::as_Klass(mirror); 1572 1573 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot); 1574 assert(m != NULL, "cannot find method"); 1575 return m; // caller has to deal with NULL in product mode 1576 } 1577 1578 /* Type use annotations support (JDK 1.8) / 1579 1580 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv env, jclass cls)) 1581 assert (cls != NULL, "illegal class"); 1582 JVMWrapper("JVM_GetClassTypeAnnotations"); 1583 ResourceMark rm(THREAD); 1584 // Return null for arrays and primitives 1585 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1586 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 1587 if (k->oop_is_instance()) { 1588 AnnotationArray type_annotations = InstanceKlass::cast(k)->class_type_annotations(); 1589 if (type_annotations != NULL) { 1590 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL); 1591 return (jbyteArray) JNIHandles::make_local(env, a); 1592 } 1593 } 1594 } 1595 return NULL; 1596 JVM_END 1597 1598 JVM_ENTRY(jbyteArray, JVM_GetMethodTypeAnnotations(JNIEnv env, jobject method)) 1599 assert (method != NULL, "illegal method"); 1600 JVMWrapper("JVM_GetMethodTypeAnnotations"); 1601 1602 // method is a handle to a java.lang.reflect.Method object 1603 Method m = jvm_get_method_common(method); 1604 if (m == NULL) { 1605 return NULL; 1606 } 1607

1676 mh->constants()->symbol_at(params[i].name_cp_index) : NULL; 1677 int flags = params[i].flags; 1678 oop param = Reflection::new_parameter(reflected_method, i, sym, 1679 flags, CHECK_NULL); 1680 result->obj_at_put(i, param); 1681 } 1682 return (jobjectArray)JNIHandles::make_local(env, result()); 1683 } 1684 } 1685 JVM_END 1686 1687 // New (JDK 1.4) reflection implementation ///////////////////////////////////// 1688 1689 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1690 { 1691 JVMWrapper("JVM_GetClassDeclaredFields"); 1692 JvmtiVMObjectAllocEventCollector oam; 1693 1694 // Exclude primitive types and array types 1695 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1696 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_array()) { 1697 // Return empty array 1698 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL); 1699 return (jobjectArray) JNIHandles::make_local(env, res); 1700 } 1701 1702 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); 1703 constantPoolHandle cp(THREAD, k->constants()); 1704 1705 // Ensure class is linked 1706 k->link_class(CHECK_NULL); 1707 1708 // 4496456 We need to filter out java.lang.Throwable.backtrace 1709 bool skip_backtrace = false; 1710 1711 // Allocate result 1712 int num_fields; 1713 1714 if (publicOnly) { 1715 num_fields = 0; 1716 for (JavaFieldStream fs(k()); !fs.done(); fs.next()) {

1750 JVM_END 1751 1752 static bool select_method(methodHandle method, bool want_constructor) { 1753 if (want_constructor) { 1754 return (method->is_initializer() && !method->is_static()); 1755 } else { 1756 return (!method->is_initializer() && !method->is_overpass()); 1757 } 1758 } 1759 1760 static jobjectArray get_class_declared_methods_helper( 1761 JNIEnv env, 1762 jclass ofClass, jboolean publicOnly, 1763 bool want_constructor, 1764 Klass klass, TRAPS) { 1765 1766 JvmtiVMObjectAllocEventCollector oam; 1767 1768 // Exclude primitive types and array types 1769 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) 1770 || java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_array()) { 1771 // Return empty array 1772 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL); 1773 return (jobjectArray) JNIHandles::make_local(env, res); 1774 } 1775 1776 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); 1777 1778 // Ensure class is linked 1779 k->link_class(CHECK_NULL); 1780 1781 Array<Method*>* methods = k->methods(); 1782 int methods_length = methods->length(); 1783 1784 // Save original method_idnum in case of redefinition, which can change 1785 // the idnum of obsolete methods. The new method will have the same idnum 1786 // but if we refresh the methods array, the counts will be wrong. 1787 ResourceMark rm(THREAD); 1788 GrowableArray* idnums = new GrowableArray(methods_length); 1789 int num_methods = 0; 1790

1851 // Primitive type 1852 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; 1853 } 1854 1855 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1856 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS; 1857 } 1858 JVM_END 1859 1860 1861 // Constant pool access ////////////////////////////////////////////////////////// 1862 1863 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv env, jclass cls)) 1864 { 1865 JVMWrapper("JVM_GetClassConstantPool"); 1866 JvmtiVMObjectAllocEventCollector oam; 1867 1868 // Return null for primitives and arrays 1869 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1870 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1871 if (k->oop_is_instance()) { 1872 instanceKlassHandle k_h(THREAD, k); 1873 Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL); 1874 sun_reflect_ConstantPool::set_cp(jcp(), k_h->constants()); 1875 return JNIHandles::make_local(jcp()); 1876 } 1877 } 1878 return NULL; 1879 } 1880 JVM_END 1881 1882 1883 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused)) 1884 { 1885 JVMWrapper("JVM_ConstantPoolGetSize"); 1886 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 1887 return cp->length(); 1888 } 1889 JVM_END 1890 1891

2119 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2120 } 2121 Symbol* sym = cp->symbol_at(index); 2122 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 2123 return (jstring) JNIHandles::make_local(str()); 2124 } 2125 JVM_END 2126 2127 2128 // Assertion support. ////////////////////////////////////////////////////////// 2129 2130 JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv env, jclass unused, jclass cls)) 2131 JVMWrapper("JVM_DesiredAssertionStatus"); 2132 assert(cls != NULL, "bad class"); 2133 2134 oop r = JNIHandles::resolve(cls); 2135 assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed"); 2136 if (java_lang_Class::is_primitive(r)) return false; 2137 2138 Klass k = java_lang_Class::as_Klass(r); 2139 assert(k->oop_is_instance(), "must be an instance klass"); 2140 if (! k->oop_is_instance()) return false; 2141 2142 ResourceMark rm(THREAD); 2143 const char* name = k->name()->as_C_string(); 2144 bool system_class = k->class_loader() == NULL; 2145 return JavaAssertions::enabled(name, system_class); 2146 2147 JVM_END 2148 2149 2150 // Return a new AssertionStatusDirectives object with the fields filled in with 2151 // command-line assertion arguments (i.e., -ea, -da). 2152 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)) 2153 JVMWrapper("JVM_AssertionStatusDirectives"); 2154 JvmtiVMObjectAllocEventCollector oam; 2155 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL); 2156 return JNIHandles::make_local(env, asd); 2157 JVM_END 2158 2159 // Verification //////////////////////////////////////////////////////////////////////////////// 2160

2165 // Klass* class_to_verify_considering_redefinition(Klass* klass). 2166 // The function returns a Klass* of the _scratch_class if the verifier 2167 // was invoked in the middle of the class redefinition. 2168 // Otherwise it returns its argument value which is the _the_class Klass*. 2169 // Please, refer to the description in the jvmtiThreadSate.hpp. 2170 2171 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv env, jclass cls)) 2172 JVMWrapper("JVM_GetClassNameUTF"); 2173 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2174 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2175 return k->name()->as_utf8(); 2176 JVM_END 2177 2178 2179 JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv env, jclass cls, unsigned char types)) 2180 JVMWrapper("JVM_GetClassCPTypes"); 2181 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2182 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2183 // types will have length zero if this is not an InstanceKlass 2184 // (length is determined by call to JVM_GetClassCPEntriesCount) 2185 if (k->oop_is_instance()) { 2186 ConstantPool cp = InstanceKlass::cast(k)->constants(); 2187 for (int index = cp->length() - 1; index >= 0; index--) { 2188 constantTag tag = cp->tag_at(index); 2189 types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : tag.value(); 2190 } 2191 } 2192 JVM_END 2193 2194 2195 JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv env, jclass cls)) 2196 JVMWrapper("JVM_GetClassCPEntriesCount"); 2197 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2198 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2199 if (!k->oop_is_instance()) 2200 return 0; 2201 return InstanceKlass::cast(k)->constants()->length(); 2202 JVM_END 2203 2204 2205 JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv env, jclass cls)) 2206 JVMWrapper("JVM_GetClassFieldsCount"); 2207 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2208 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2209 if (!k->oop_is_instance()) 2210 return 0; 2211 return InstanceKlass::cast(k)->java_fields_count(); 2212 JVM_END 2213 2214 2215 JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv env, jclass cls)) 2216 JVMWrapper("JVM_GetClassMethodsCount"); 2217 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2218 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2219 if (!k->oop_is_instance()) 2220 return 0; 2221 return InstanceKlass::cast(k)->methods()->length(); 2222 JVM_END 2223 2224 2225 // The following methods, used for the verifier, are never called with 2226 // array klasses, so a direct cast to InstanceKlass is safe. 2227 // Typically, these methods are called in a loop with bounds determined 2228 // by the results of JVM_GetClass{Fields,Methods}Count, which return 2229 // zero for arrays. 2230 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv env, jclass cls, jint method_index, unsigned short exceptions)) 2231 JVMWrapper("JVM_GetMethodIxExceptionIndexes"); 2232 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2233 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2234 Method method = InstanceKlass::cast(k)->methods()->at(method_index); 2235 int length = method->checked_exceptions_length(); 2236 if (length > 0) { 2237 CheckedExceptionElement* table= method->checked_exceptions_start(); 2238 for (int i = 0; i < length; i++) { 2239 exceptions[i] = table[i].class_cp_index; 2240 } 2241 }

3459 JVMWrapper("JVM_RawMonitorExit"); 3460 ((Mutex*) mon)->jvm_raw_unlock(); 3461 } 3462 3463 3464 // Shared JNI/JVM entry points ////////////////////////////////////////////////////////////// 3465 3466 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, 3467 Handle loader, Handle protection_domain, 3468 jboolean throwError, TRAPS) { 3469 // Security Note: 3470 // The Java level wrapper will perform the necessary security check allowing 3471 // us to pass the NULL as the initiating class loader. The VM is responsible for 3472 // the checkPackageAccess relative to the initiating class loader via the 3473 // protection_domain. The protection_domain is passed as NULL by the java code 3474 // if there is no security manager in 3-arg Class.forName(). 3475 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL); 3476 3477 KlassHandle klass_handle(THREAD, klass); 3478 // Check if we should initialize the class 3479 if (init && klass_handle->oop_is_instance()) { 3480 klass_handle->initialize(CHECK_NULL); 3481 } 3482 return (jclass) JNIHandles::make_local(env, klass_handle->java_mirror()); 3483 } 3484 3485 3486 // Method /////////////////////////////////////////////////////////////////////////////////////////// 3487 3488 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)) 3489 JVMWrapper("JVM_InvokeMethod"); 3490 Handle method_handle; 3491 if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) { 3492 method_handle = Handle(THREAD, JNIHandles::resolve(method)); 3493 Handle receiver(THREAD, JNIHandles::resolve(obj)); 3494 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0))); 3495 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL); 3496 jobject res = JNIHandles::make_local(env, result); 3497 if (JvmtiExport::should_post_vm_object_alloc()) { 3498 oop ret_type = java_lang_reflect_Method::return_type(method_handle()); 3499 assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");

3607 PUTPROP(props, "sun.java.command", Arguments::java_command()); 3608 PUTPROP(props, "sun.jvm.flags", Arguments::jvm_flags()); 3609 PUTPROP(props, "sun.jvm.args", Arguments::jvm_args()); 3610 return properties; 3611 JVM_END 3612 3613 JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv env, jclass ofClass)) 3614 { 3615 JVMWrapper("JVM_GetEnclosingMethodInfo"); 3616 JvmtiVMObjectAllocEventCollector oam; 3617 3618 if (ofClass == NULL) { 3619 return NULL; 3620 } 3621 Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass)); 3622 // Special handling for primitive objects 3623 if (java_lang_Class::is_primitive(mirror())) { 3624 return NULL; 3625 } 3626 Klass k = java_lang_Class::as_Klass(mirror()); 3627 if (!k->oop_is_instance()) { 3628 return NULL; 3629 } 3630 instanceKlassHandle ik_h(THREAD, k); 3631 int encl_method_class_idx = ik_h->enclosing_method_class_index(); 3632 if (encl_method_class_idx == 0) { 3633 return NULL; 3634 } 3635 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL); 3636 objArrayHandle dest(THREAD, dest_o); 3637 Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL); 3638 dest->obj_at_put(0, enc_k->java_mirror()); 3639 int encl_method_method_idx = ik_h->enclosing_method_method_index(); 3640 if (encl_method_method_idx != 0) { 3641 Symbol* sym = ik_h->constants()->symbol_at( 3642 extract_low_short_from_int( 3643 ik_h->constants()->name_and_type_at(encl_method_method_idx))); 3644 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 3645 dest->obj_at_put(1, str()); 3646 sym = ik_h->constants()->symbol_at( 3647 extract_high_short_from_int(

1005 oop result = StringTable::intern((char*) name, CHECK_NULL); 1006 return (jstring) JNIHandles::make_local(env, result); 1007 JVM_END 1008 1009 1010 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls)) 1011 JVMWrapper("JVM_GetClassInterfaces"); 1012 JvmtiVMObjectAllocEventCollector oam; 1013 oop mirror = JNIHandles::resolve_non_null(cls); 1014 1015 // Special handling for primitive objects 1016 if (java_lang_Class::is_primitive(mirror)) { 1017 // Primitive objects does not have any interfaces 1018 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); 1019 return (jobjectArray) JNIHandles::make_local(env, r); 1020 } 1021 1022 KlassHandle klass(thread, java_lang_Class::as_Klass(mirror)); 1023 // Figure size of result array 1024 int size; 1025 if (klass->is_instance_klass()) { 1026 size = InstanceKlass::cast(klass())->local_interfaces()->length(); 1027 } else { 1028 assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass"); 1029 size = 2; 1030 } 1031 1032 // Allocate result array 1033 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), size, CHECK_NULL); 1034 objArrayHandle result (THREAD, r); 1035 // Fill in result 1036 if (klass->is_instance_klass()) { 1037 // Regular instance klass, fill in all local interfaces 1038 for (int index = 0; index < size; index++) { 1039 Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index); 1040 result->obj_at_put(index, k->java_mirror()); 1041 } 1042 } else { 1043 // All arrays implement java.lang.Cloneable and java.io.Serializable 1044 result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror()); 1045 result->obj_at_put(1, SystemDictionary::Serializable_klass()->java_mirror()); 1046 } 1047 return (jobjectArray) JNIHandles::make_local(env, result()); 1048 JVM_END 1049 1050 1051 JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv env, jclass cls)) 1052 JVMWrapper("JVM_IsInterface"); 1053 oop mirror = JNIHandles::resolve_non_null(cls); 1054 if (java_lang_Class::is_primitive(mirror)) { 1055 return JNI_FALSE; 1056 } 1057 Klass k = java_lang_Class::as_Klass(mirror); 1058 jboolean result = k->is_interface(); 1059 assert(!result || k->is_instance_klass(), 1060 "all interfaces are instance types"); 1061 // The compiler intrinsic for isInterface tests the 1062 // Klass::access_flags bits in the same way. 1063 return result; 1064 JVM_END 1065 1066 1067 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv env, jclass cls)) 1068 JVMWrapper("JVM_GetClassSigners"); 1069 JvmtiVMObjectAllocEventCollector oam; 1070 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1071 // There are no signers for primitive types 1072 return NULL; 1073 } 1074 1075 objArrayOop signers = java_lang_Class::signers(JNIHandles::resolve_non_null(cls)); 1076 1077 // If there are no signers set in the class, or if the class 1078 // is an array, return NULL. 1079 if (signers == NULL) return NULL; 1080 1081 // copy of the signers array 1082 Klass element = ObjArrayKlass::cast(signers->klass())->element_klass(); 1083 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL); 1084 for (int index = 0; index < signers->length(); index++) { 1085 signers_copy->obj_at_put(index, signers->obj_at(index)); 1086 } 1087 1088 // return the copy 1089 return (jobjectArray) JNIHandles::make_local(env, signers_copy); 1090 JVM_END 1091 1092 1093 JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv env, jclass cls, jobjectArray signers)) 1094 JVMWrapper("JVM_SetClassSigners"); 1095 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1096 // This call is ignored for primitive types and arrays. 1097 // Signers are only set once, ClassLoader.java, and thus shouldn't 1098 // be called with an array. Only the bootstrap loader creates arrays. 1099 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1100 if (k->is_instance_klass()) { 1101 java_lang_Class::set_signers(k->java_mirror(), objArrayOop(JNIHandles::resolve(signers))); 1102 } 1103 } 1104 JVM_END 1105 1106 1107 JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls)) 1108 JVMWrapper("JVM_GetProtectionDomain"); 1109 if (JNIHandles::resolve(cls) == NULL) { 1110 THROW(vmSymbols::java_lang_NullPointerException(), NULL); 1111 } 1112 1113 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1114 // Primitive types does not have a protection domain. 1115 return NULL; 1116 } 1117 1118 oop pd = java_lang_Class::protection_domain(JNIHandles::resolve(cls)); 1119 return (jobject) JNIHandles::make_local(env, pd); 1120 JVM_END

1339 } 1340 1341 // the resource area must be registered in case of a gc 1342 RegisterArrayForGC ragc(thread, local_array); 1343 objArrayOop context = oopFactory::new_objArray(SystemDictionary::ProtectionDomain_klass(), 1344 local_array->length(), CHECK_NULL); 1345 objArrayHandle h_context(thread, context); 1346 for (int index = 0; index < local_array->length(); index++) { 1347 h_context->obj_at_put(index, local_array->at(index)); 1348 } 1349 1350 oop result = java_security_AccessControlContext::create(h_context, is_privileged, privileged_context, CHECK_NULL); 1351 1352 return JNIHandles::make_local(env, result); 1353 JVM_END 1354 1355 1356 JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv env, jclass cls)) 1357 JVMWrapper("JVM_IsArrayClass"); 1358 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1359 return (k != NULL) && k->is_array_klass() ? true : false; 1360 JVM_END 1361 1362 1363 JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls)) 1364 JVMWrapper("JVM_IsPrimitiveClass"); 1365 oop mirror = JNIHandles::resolve_non_null(cls); 1366 return (jboolean) java_lang_Class::is_primitive(mirror); 1367 JVM_END 1368 1369 1370 JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv env, jclass cls)) 1371 JVMWrapper("JVM_GetClassModifiers"); 1372 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1373 // Primitive type 1374 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; 1375 } 1376 1377 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1378 debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0)); 1379 assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK"); 1380 return k->modifier_flags(); 1381 JVM_END 1382 1383 1384 // Inner class reflection /////////////////////////////////////////////////////////////////////////////// 1385 1386 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)) 1387 JvmtiVMObjectAllocEventCollector oam; 1388 // ofClass is a reference to a java_lang_Class object. The mirror object 1389 // of an InstanceKlass 1390 1391 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1392 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) { 1393 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); 1394 return (jobjectArray)JNIHandles::make_local(env, result); 1395 } 1396 1397 instanceKlassHandle k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); 1398 InnerClassesIterator iter(k); 1399 1400 if (iter.length() == 0) { 1401 // Neither an inner nor outer class 1402 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); 1403 return (jobjectArray)JNIHandles::make_local(env, result); 1404 } 1405 1406 // find inner class info 1407 constantPoolHandle cp(thread, k->constants()); 1408 int length = iter.length(); 1409 1410 // Allocate temp. result array 1411 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), length/4, CHECK_NULL); 1412 objArrayHandle result (THREAD, r);

1436 } 1437 } 1438 1439 if (members != length) { 1440 // Return array of right length 1441 objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL); 1442 for(int i = 0; i < members; i++) { 1443 res->obj_at_put(i, result->obj_at(i)); 1444 } 1445 return (jobjectArray)JNIHandles::make_local(env, res); 1446 } 1447 1448 return (jobjectArray)JNIHandles::make_local(env, result()); 1449 JVM_END 1450 1451 1452 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv env, jclass ofClass)) 1453 { 1454 // ofClass is a reference to a java_lang_Class object. 1455 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1456 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) { 1457 return NULL; 1458 } 1459 1460 bool inner_is_member = false; 1461 Klass outer_klass 1462 = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)) 1463 )->compute_enclosing_class(&inner_is_member, CHECK_NULL); 1464 if (outer_klass == NULL) return NULL; // already a top-level class 1465 if (!inner_is_member) return NULL; // an anonymous class (inside a method) 1466 return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror()); 1467 } 1468 JVM_END 1469 1470 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv env, jclass cls)) 1471 { 1472 oop mirror = JNIHandles::resolve_non_null(cls); 1473 if (java_lang_Class::is_primitive(mirror) || 1474 !java_lang_Class::as_Klass(mirror)->is_instance_klass()) { 1475 return NULL; 1476 } 1477 instanceKlassHandle k(THREAD, InstanceKlass::cast(java_lang_Class::as_Klass(mirror))); 1478 int ooff = 0, noff = 0; 1479 if (InstanceKlass::find_inner_classes_attr(k, &ooff, &noff, THREAD)) { 1480 if (noff != 0) { 1481 constantPoolHandle i_cp(thread, k->constants()); 1482 Symbol name = i_cp->symbol_at(noff); 1483 Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL); 1484 return (jstring) JNIHandles::make_local(env, str()); 1485 } 1486 } 1487 return NULL; 1488 } 1489 JVM_END 1490 1491 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv env, jclass cls)) 1492 assert (cls != NULL, "illegal class"); 1493 JVMWrapper("JVM_GetClassSignature"); 1494 JvmtiVMObjectAllocEventCollector oam; 1495 ResourceMark rm(THREAD); 1496 // Return null for arrays and primatives 1497 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1498 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 1499 if (k->is_instance_klass()) { 1500 Symbol* sym = InstanceKlass::cast(k)->generic_signature(); 1501 if (sym == NULL) return NULL; 1502 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 1503 return (jstring) JNIHandles::make_local(env, str()); 1504 } 1505 } 1506 return NULL; 1507 JVM_END 1508 1509 1510 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv env, jclass cls)) 1511 assert (cls != NULL, "illegal class"); 1512 JVMWrapper("JVM_GetClassAnnotations"); 1513 1514 // Return null for arrays and primitives 1515 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1516 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 1517 if (k->is_instance_klass()) { 1518 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL); 1519 return (jbyteArray) JNIHandles::make_local(env, a); 1520 } 1521 } 1522 return NULL; 1523 JVM_END 1524 1525 1526 static bool jvm_get_field_common(jobject field, fieldDescriptor& fd, TRAPS) { 1527 // some of this code was adapted from from jni_FromReflectedField 1528 1529 oop reflected = JNIHandles::resolve_non_null(field); 1530 oop mirror = java_lang_reflect_Field::clazz(reflected); 1531 Klass* k = java_lang_Class::as_Klass(mirror); 1532 int slot = java_lang_reflect_Field::slot(reflected); 1533 int modifiers = java_lang_reflect_Field::modifiers(reflected); 1534 1535 KlassHandle kh(THREAD, k); 1536 intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot); 1537

1567 "wrong type"); 1568 mirror = java_lang_reflect_Method::clazz(reflected); 1569 slot = java_lang_reflect_Method::slot(reflected); 1570 } 1571 Klass* k = java_lang_Class::as_Klass(mirror); 1572 1573 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot); 1574 assert(m != NULL, "cannot find method"); 1575 return m; // caller has to deal with NULL in product mode 1576 } 1577 1578 /* Type use annotations support (JDK 1.8) / 1579 1580 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv env, jclass cls)) 1581 assert (cls != NULL, "illegal class"); 1582 JVMWrapper("JVM_GetClassTypeAnnotations"); 1583 ResourceMark rm(THREAD); 1584 // Return null for arrays and primitives 1585 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { 1586 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); 1587 if (k->is_instance_klass()) { 1588 AnnotationArray type_annotations = InstanceKlass::cast(k)->class_type_annotations(); 1589 if (type_annotations != NULL) { 1590 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL); 1591 return (jbyteArray) JNIHandles::make_local(env, a); 1592 } 1593 } 1594 } 1595 return NULL; 1596 JVM_END 1597 1598 JVM_ENTRY(jbyteArray, JVM_GetMethodTypeAnnotations(JNIEnv env, jobject method)) 1599 assert (method != NULL, "illegal method"); 1600 JVMWrapper("JVM_GetMethodTypeAnnotations"); 1601 1602 // method is a handle to a java.lang.reflect.Method object 1603 Method m = jvm_get_method_common(method); 1604 if (m == NULL) { 1605 return NULL; 1606 } 1607

1676 mh->constants()->symbol_at(params[i].name_cp_index) : NULL; 1677 int flags = params[i].flags; 1678 oop param = Reflection::new_parameter(reflected_method, i, sym, 1679 flags, CHECK_NULL); 1680 result->obj_at_put(i, param); 1681 } 1682 return (jobjectArray)JNIHandles::make_local(env, result()); 1683 } 1684 } 1685 JVM_END 1686 1687 // New (JDK 1.4) reflection implementation ///////////////////////////////////// 1688 1689 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly)) 1690 { 1691 JVMWrapper("JVM_GetClassDeclaredFields"); 1692 JvmtiVMObjectAllocEventCollector oam; 1693 1694 // Exclude primitive types and array types 1695 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || 1696 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_array_klass()) { 1697 // Return empty array 1698 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL); 1699 return (jobjectArray) JNIHandles::make_local(env, res); 1700 } 1701 1702 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); 1703 constantPoolHandle cp(THREAD, k->constants()); 1704 1705 // Ensure class is linked 1706 k->link_class(CHECK_NULL); 1707 1708 // 4496456 We need to filter out java.lang.Throwable.backtrace 1709 bool skip_backtrace = false; 1710 1711 // Allocate result 1712 int num_fields; 1713 1714 if (publicOnly) { 1715 num_fields = 0; 1716 for (JavaFieldStream fs(k()); !fs.done(); fs.next()) {

1750 JVM_END 1751 1752 static bool select_method(methodHandle method, bool want_constructor) { 1753 if (want_constructor) { 1754 return (method->is_initializer() && !method->is_static()); 1755 } else { 1756 return (!method->is_initializer() && !method->is_overpass()); 1757 } 1758 } 1759 1760 static jobjectArray get_class_declared_methods_helper( 1761 JNIEnv env, 1762 jclass ofClass, jboolean publicOnly, 1763 bool want_constructor, 1764 Klass klass, TRAPS) { 1765 1766 JvmtiVMObjectAllocEventCollector oam; 1767 1768 // Exclude primitive types and array types 1769 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) 1770 || java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_array_klass()) { 1771 // Return empty array 1772 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL); 1773 return (jobjectArray) JNIHandles::make_local(env, res); 1774 } 1775 1776 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); 1777 1778 // Ensure class is linked 1779 k->link_class(CHECK_NULL); 1780 1781 Array<Method*>* methods = k->methods(); 1782 int methods_length = methods->length(); 1783 1784 // Save original method_idnum in case of redefinition, which can change 1785 // the idnum of obsolete methods. The new method will have the same idnum 1786 // but if we refresh the methods array, the counts will be wrong. 1787 ResourceMark rm(THREAD); 1788 GrowableArray* idnums = new GrowableArray(methods_length); 1789 int num_methods = 0; 1790

1851 // Primitive type 1852 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; 1853 } 1854 1855 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1856 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS; 1857 } 1858 JVM_END 1859 1860 1861 // Constant pool access ////////////////////////////////////////////////////////// 1862 1863 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv env, jclass cls)) 1864 { 1865 JVMWrapper("JVM_GetClassConstantPool"); 1866 JvmtiVMObjectAllocEventCollector oam; 1867 1868 // Return null for primitives and arrays 1869 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { 1870 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 1871 if (k->is_instance_klass()) { 1872 instanceKlassHandle k_h(THREAD, k); 1873 Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL); 1874 sun_reflect_ConstantPool::set_cp(jcp(), k_h->constants()); 1875 return JNIHandles::make_local(jcp()); 1876 } 1877 } 1878 return NULL; 1879 } 1880 JVM_END 1881 1882 1883 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused)) 1884 { 1885 JVMWrapper("JVM_ConstantPoolGetSize"); 1886 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); 1887 return cp->length(); 1888 } 1889 JVM_END 1890 1891

2119 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); 2120 } 2121 Symbol* sym = cp->symbol_at(index); 2122 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 2123 return (jstring) JNIHandles::make_local(str()); 2124 } 2125 JVM_END 2126 2127 2128 // Assertion support. ////////////////////////////////////////////////////////// 2129 2130 JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv env, jclass unused, jclass cls)) 2131 JVMWrapper("JVM_DesiredAssertionStatus"); 2132 assert(cls != NULL, "bad class"); 2133 2134 oop r = JNIHandles::resolve(cls); 2135 assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed"); 2136 if (java_lang_Class::is_primitive(r)) return false; 2137 2138 Klass k = java_lang_Class::as_Klass(r); 2139 assert(k->is_instance_klass(), "must be an instance klass"); 2140 if (!k->is_instance_klass()) return false; 2141 2142 ResourceMark rm(THREAD); 2143 const char* name = k->name()->as_C_string(); 2144 bool system_class = k->class_loader() == NULL; 2145 return JavaAssertions::enabled(name, system_class); 2146 2147 JVM_END 2148 2149 2150 // Return a new AssertionStatusDirectives object with the fields filled in with 2151 // command-line assertion arguments (i.e., -ea, -da). 2152 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)) 2153 JVMWrapper("JVM_AssertionStatusDirectives"); 2154 JvmtiVMObjectAllocEventCollector oam; 2155 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL); 2156 return JNIHandles::make_local(env, asd); 2157 JVM_END 2158 2159 // Verification //////////////////////////////////////////////////////////////////////////////// 2160

2200 JVM_END 2201 2202 2203 JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv env, jclass cls)) 2204 JVMWrapper("JVM_GetClassFieldsCount"); 2205 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2206 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2207 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->java_fields_count();

2208 JVM_END 2209 2210 2211 JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv env, jclass cls)) 2212 JVMWrapper("JVM_GetClassMethodsCount"); 2213 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2214 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2215 return (!k->is_instance_klass()) ? 0 : InstanceKlass::cast(k)->methods()->length();

2216 JVM_END 2217 2218 2219 // The following methods, used for the verifier, are never called with 2220 // array klasses, so a direct cast to InstanceKlass is safe. 2221 // Typically, these methods are called in a loop with bounds determined 2222 // by the results of JVM_GetClass{Fields,Methods}Count, which return 2223 // zero for arrays. 2224 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv env, jclass cls, jint method_index, unsigned short exceptions)) 2225 JVMWrapper("JVM_GetMethodIxExceptionIndexes"); 2226 Klass k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); 2227 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); 2228 Method method = InstanceKlass::cast(k)->methods()->at(method_index); 2229 int length = method->checked_exceptions_length(); 2230 if (length > 0) { 2231 CheckedExceptionElement* table= method->checked_exceptions_start(); 2232 for (int i = 0; i < length; i++) { 2233 exceptions[i] = table[i].class_cp_index; 2234 } 2235 }

3453 JVMWrapper("JVM_RawMonitorExit"); 3454 ((Mutex*) mon)->jvm_raw_unlock(); 3455 } 3456 3457 3458 // Shared JNI/JVM entry points ////////////////////////////////////////////////////////////// 3459 3460 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, 3461 Handle loader, Handle protection_domain, 3462 jboolean throwError, TRAPS) { 3463 // Security Note: 3464 // The Java level wrapper will perform the necessary security check allowing 3465 // us to pass the NULL as the initiating class loader. The VM is responsible for 3466 // the checkPackageAccess relative to the initiating class loader via the 3467 // protection_domain. The protection_domain is passed as NULL by the java code 3468 // if there is no security manager in 3-arg Class.forName(). 3469 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL); 3470 3471 KlassHandle klass_handle(THREAD, klass); 3472 // Check if we should initialize the class 3473 if (init && klass_handle->is_instance_klass()) { 3474 klass_handle->initialize(CHECK_NULL); 3475 } 3476 return (jclass) JNIHandles::make_local(env, klass_handle->java_mirror()); 3477 } 3478 3479 3480 // Method /////////////////////////////////////////////////////////////////////////////////////////// 3481 3482 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)) 3483 JVMWrapper("JVM_InvokeMethod"); 3484 Handle method_handle; 3485 if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) { 3486 method_handle = Handle(THREAD, JNIHandles::resolve(method)); 3487 Handle receiver(THREAD, JNIHandles::resolve(obj)); 3488 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0))); 3489 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL); 3490 jobject res = JNIHandles::make_local(env, result); 3491 if (JvmtiExport::should_post_vm_object_alloc()) { 3492 oop ret_type = java_lang_reflect_Method::return_type(method_handle()); 3493 assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");

3601 PUTPROP(props, "sun.java.command", Arguments::java_command()); 3602 PUTPROP(props, "sun.jvm.flags", Arguments::jvm_flags()); 3603 PUTPROP(props, "sun.jvm.args", Arguments::jvm_args()); 3604 return properties; 3605 JVM_END 3606 3607 JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv env, jclass ofClass)) 3608 { 3609 JVMWrapper("JVM_GetEnclosingMethodInfo"); 3610 JvmtiVMObjectAllocEventCollector oam; 3611 3612 if (ofClass == NULL) { 3613 return NULL; 3614 } 3615 Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass)); 3616 // Special handling for primitive objects 3617 if (java_lang_Class::is_primitive(mirror())) { 3618 return NULL; 3619 } 3620 Klass k = java_lang_Class::as_Klass(mirror()); 3621 if (!k->is_instance_klass()) { 3622 return NULL; 3623 } 3624 instanceKlassHandle ik_h(THREAD, k); 3625 int encl_method_class_idx = ik_h->enclosing_method_class_index(); 3626 if (encl_method_class_idx == 0) { 3627 return NULL; 3628 } 3629 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL); 3630 objArrayHandle dest(THREAD, dest_o); 3631 Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL); 3632 dest->obj_at_put(0, enc_k->java_mirror()); 3633 int encl_method_method_idx = ik_h->enclosing_method_method_index(); 3634 if (encl_method_method_idx != 0) { 3635 Symbol* sym = ik_h->constants()->symbol_at( 3636 extract_low_short_from_int( 3637 ik_h->constants()->name_and_type_at(encl_method_method_idx))); 3638 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); 3639 dest->obj_at_put(1, str()); 3640 sym = ik_h->constants()->symbol_at( 3641 extract_high_short_from_int(