1287 assert(!result || k->is_instance_klass(),
1288 "all interfaces are instance types");
1289 // The compiler intrinsic for isInterface tests the
1290 // Klass::_access_flags bits in the same way.
1291 return result;
1292 JVM_END
1293
1294 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1295 JVMWrapper("JVM_IsHiddenClass");
1296 oop mirror = JNIHandles::resolve_non_null(cls);
1297 if (java_lang_Class::is_primitive(mirror)) {
1298 return JNI_FALSE;
1299 }
1300 Klass* k = java_lang_Class::as_Klass(mirror);
1301 return k->is_hidden();
1302 JVM_END
1303
1304 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1305 JVMWrapper("JVM_GetClassSigners");
1306 JvmtiVMObjectAllocEventCollector oam;
1307 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1308 // There are no signers for primitive types
1309 return NULL;
1310 }
1311
1312 objArrayHandle signers(THREAD, java_lang_Class::signers(JNIHandles::resolve_non_null(cls)));
1313
1314 // If there are no signers set in the class, or if the class
1315 // is an array, return NULL.
1316 if (signers == NULL) return NULL;
1317
1318 // copy of the signers array
1319 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1320 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1321 for (int index = 0; index < signers->length(); index++) {
1322 signers_copy->obj_at_put(index, signers->obj_at(index));
1323 }
1324
1325 // return the copy
1326 return (jobjectArray) JNIHandles::make_local(THREAD, signers_copy);
1327 JVM_END
1328
1329
1330 JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers))
1331 JVMWrapper("JVM_SetClassSigners");
1332 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1333 // This call is ignored for primitive types and arrays.
1334 // Signers are only set once, ClassLoader.java, and thus shouldn't
1335 // be called with an array. Only the bootstrap loader creates arrays.
1336 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1337 if (k->is_instance_klass()) {
1338 java_lang_Class::set_signers(k->java_mirror(), objArrayOop(JNIHandles::resolve(signers)));
1339 }
1340 }
1341 JVM_END
1342
1343
1344 JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls))
1345 JVMWrapper("JVM_GetProtectionDomain");
1346 if (JNIHandles::resolve(cls) == NULL) {
1347 THROW_(vmSymbols::java_lang_NullPointerException(), NULL);
1348 }
1349
1350 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1351 // Primitive types does not have a protection domain.
1352 return NULL;
1353 }
1354
1355 oop pd = java_lang_Class::protection_domain(JNIHandles::resolve(cls));
1356 return (jobject) JNIHandles::make_local(THREAD, pd);
1357 JVM_END
1358
1359
1360 // Returns the inherited_access_control_context field of the running thread.
1361 JVM_ENTRY(jobject, JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls))
1362 JVMWrapper("JVM_GetInheritedAccessControlContext");
1363 oop result = java_lang_Thread::inherited_access_control_context(thread->threadObj());
1364 return JNIHandles::make_local(THREAD, result);
1365 JVM_END
1366
1367 class RegisterArrayForGC {
1368 private:
1369 JavaThread *_thread;
1370 public:
1371 RegisterArrayForGC(JavaThread *thread, GrowableArray<oop>* array) {
1372 _thread = thread;
1373 _thread->register_array_for_gc(array);
1374 }
1375
1457 return JNIHandles::make_local(THREAD, result);
1458 JVM_END
1459
1460
1461 JVM_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
1462 JVMWrapper("JVM_IsArrayClass");
1463 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1464 return (k != NULL) && k->is_array_klass() ? true : false;
1465 JVM_END
1466
1467
1468 JVM_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))
1469 JVMWrapper("JVM_IsPrimitiveClass");
1470 oop mirror = JNIHandles::resolve_non_null(cls);
1471 return (jboolean) java_lang_Class::is_primitive(mirror);
1472 JVM_END
1473
1474
1475 JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv *env, jclass cls))
1476 JVMWrapper("JVM_GetClassModifiers");
1477 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1478 // Primitive type
1479 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
1480 }
1481
1482 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1483 debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0));
1484 assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK");
1485 return k->modifier_flags();
1486 JVM_END
1487
1488
1489 // Inner class reflection ///////////////////////////////////////////////////////////////////////////////
1490
1491 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
1492 JvmtiVMObjectAllocEventCollector oam;
1493 // ofClass is a reference to a java_lang_Class object. The mirror object
1494 // of an InstanceKlass
1495
1496 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1497 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) {
1498 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
1499 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1500 }
1501
1502 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
1503 InnerClassesIterator iter(k);
1504
1505 if (iter.length() == 0) {
1506 // Neither an inner nor outer class
1507 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
1508 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1509 }
1510
1511 // find inner class info
1512 constantPoolHandle cp(thread, k->constants());
1513 int length = iter.length();
1514
1515 // Allocate temp. result array
1516 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), length/4, CHECK_NULL);
1517 objArrayHandle result (THREAD, r);
1518 int members = 0;
1519
1520 for (; !iter.done(); iter.next()) {
1521 int ioff = iter.inner_class_info_index();
1522 int ooff = iter.outer_class_info_index();
1540 }
1541 }
1542 }
1543
1544 if (members != length) {
1545 // Return array of right length
1546 objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL);
1547 for(int i = 0; i < members; i++) {
1548 res->obj_at_put(i, result->obj_at(i));
1549 }
1550 return (jobjectArray)JNIHandles::make_local(THREAD, res);
1551 }
1552
1553 return (jobjectArray)JNIHandles::make_local(THREAD, result());
1554 JVM_END
1555
1556
1557 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1558 {
1559 // ofClass is a reference to a java_lang_Class object.
1560 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1561 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) {
1562 return NULL;
1563 }
1564
1565 bool inner_is_member = false;
1566 Klass* outer_klass
1567 = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))
1568 )->compute_enclosing_class(&inner_is_member, CHECK_NULL);
1569 if (outer_klass == NULL) return NULL; // already a top-level class
1570 if (!inner_is_member) return NULL; // a hidden or unsafe anonymous class (inside a method)
1571 return (jclass) JNIHandles::make_local(THREAD, outer_klass->java_mirror());
1572 }
1573 JVM_END
1574
1575 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv *env, jclass cls))
1576 {
1577 oop mirror = JNIHandles::resolve_non_null(cls);
1578 if (java_lang_Class::is_primitive(mirror) ||
1579 !java_lang_Class::as_Klass(mirror)->is_instance_klass()) {
1580 return NULL;
1581 }
1582 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
1583 int ooff = 0, noff = 0;
1584 if (k->find_inner_classes_attr(&ooff, &noff, THREAD)) {
1585 if (noff != 0) {
1586 constantPoolHandle i_cp(thread, k->constants());
1587 Symbol* name = i_cp->symbol_at(noff);
1588 Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL);
1589 return (jstring) JNIHandles::make_local(THREAD, str());
1590 }
1591 }
1592 return NULL;
1593 }
1594 JVM_END
1595
1596 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls))
1597 assert (cls != NULL, "illegal class");
1598 JVMWrapper("JVM_GetClassSignature");
1599 JvmtiVMObjectAllocEventCollector oam;
1600 ResourceMark rm(THREAD);
1601 // Return null for arrays and primatives
1602 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1603 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1604 if (k->is_instance_klass()) {
1605 Symbol* sym = InstanceKlass::cast(k)->generic_signature();
1606 if (sym == NULL) return NULL;
1607 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
1608 return (jstring) JNIHandles::make_local(THREAD, str());
1609 }
1610 }
1611 return NULL;
1612 JVM_END
1613
1614
1615 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls))
1616 assert (cls != NULL, "illegal class");
1617 JVMWrapper("JVM_GetClassAnnotations");
1618
1619 // Return null for arrays and primitives
1620 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1621 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1622 if (k->is_instance_klass()) {
1623 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
1624 return (jbyteArray) JNIHandles::make_local(THREAD, a);
1625 }
1626 }
1627 return NULL;
1628 JVM_END
1629
1630
1631 static bool jvm_get_field_common(jobject field, fieldDescriptor& fd, TRAPS) {
1632 // some of this code was adapted from from jni_FromReflectedField
1633
1634 oop reflected = JNIHandles::resolve_non_null(field);
1635 oop mirror = java_lang_reflect_Field::clazz(reflected);
1636 Klass* k = java_lang_Class::as_Klass(mirror);
1637 int slot = java_lang_reflect_Field::slot(reflected);
1638 int modifiers = java_lang_reflect_Field::modifiers(reflected);
1639
1640 InstanceKlass* ik = InstanceKlass::cast(k);
1641 intptr_t offset = ik->field_offset(slot);
1780 // For a 0 index, give a NULL symbol
1781 Symbol* sym = 0 != params[i].name_cp_index ?
1782 mh->constants()->symbol_at(params[i].name_cp_index) : NULL;
1783 int flags = params[i].flags;
1784 oop param = Reflection::new_parameter(reflected_method, i, sym,
1785 flags, CHECK_NULL);
1786 result->obj_at_put(i, param);
1787 }
1788 return (jobjectArray)JNIHandles::make_local(THREAD, result());
1789 }
1790 }
1791 JVM_END
1792
1793 // New (JDK 1.4) reflection implementation /////////////////////////////////////
1794
1795 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1796 {
1797 JVMWrapper("JVM_GetClassDeclaredFields");
1798 JvmtiVMObjectAllocEventCollector oam;
1799
1800 // Exclude primitive types and array types
1801 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1802 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_array_klass()) {
1803 // Return empty array
1804 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL);
1805 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1806 }
1807
1808 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
1809 constantPoolHandle cp(THREAD, k->constants());
1810
1811 // Ensure class is linked
1812 k->link_class(CHECK_NULL);
1813
1814 // Allocate result
1815 int num_fields;
1816
1817 if (publicOnly) {
1818 num_fields = 0;
1819 for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
1820 if (fs.access_flags().is_public()) ++num_fields;
1821 }
1822 } else {
1823 num_fields = k->java_fields_count();
1824 }
1825
1826 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), num_fields, CHECK_NULL);
1827 objArrayHandle result (THREAD, r);
1828
1888 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1889 }
1890 JVM_END
1891
1892 static bool select_method(const methodHandle& method, bool want_constructor) {
1893 if (want_constructor) {
1894 return (method->is_initializer() && !method->is_static());
1895 } else {
1896 return (!method->is_initializer() && !method->is_overpass());
1897 }
1898 }
1899
1900 static jobjectArray get_class_declared_methods_helper(
1901 JNIEnv *env,
1902 jclass ofClass, jboolean publicOnly,
1903 bool want_constructor,
1904 Klass* klass, TRAPS) {
1905
1906 JvmtiVMObjectAllocEventCollector oam;
1907
1908 // Exclude primitive types and array types
1909 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
1910 || java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_array_klass()) {
1911 // Return empty array
1912 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1913 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1914 }
1915
1916 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
1917
1918 // Ensure class is linked
1919 k->link_class(CHECK_NULL);
1920
1921 Array<Method*>* methods = k->methods();
1922 int methods_length = methods->length();
1923
1924 // Save original method_idnum in case of redefinition, which can change
1925 // the idnum of obsolete methods. The new method will have the same idnum
1926 // but if we refresh the methods array, the counts will be wrong.
1927 ResourceMark rm(THREAD);
1928 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1929 int num_methods = 0;
1930
1931 for (int i = 0; i < methods_length; i++) {
1932 methodHandle method(THREAD, methods->at(i));
1933 if (select_method(method, want_constructor)) {
1934 if (!publicOnly || method->is_public()) {
1935 idnums->push(method->method_idnum());
1936 ++num_methods;
1970 {
1971 JVMWrapper("JVM_GetClassDeclaredMethods");
1972 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1973 /*want_constructor*/ false,
1974 SystemDictionary::reflect_Method_klass(), THREAD);
1975 }
1976 JVM_END
1977
1978 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1979 {
1980 JVMWrapper("JVM_GetClassDeclaredConstructors");
1981 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1982 /*want_constructor*/ true,
1983 SystemDictionary::reflect_Constructor_klass(), THREAD);
1984 }
1985 JVM_END
1986
1987 JVM_ENTRY(jint, JVM_GetClassAccessFlags(JNIEnv *env, jclass cls))
1988 {
1989 JVMWrapper("JVM_GetClassAccessFlags");
1990 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1991 // Primitive type
1992 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
1993 }
1994
1995 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1996 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS;
1997 }
1998 JVM_END
1999
2000 JVM_ENTRY(jboolean, JVM_AreNestMates(JNIEnv *env, jclass current, jclass member))
2001 {
2002 JVMWrapper("JVM_AreNestMates");
2003 Klass* c = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(current));
2004 assert(c->is_instance_klass(), "must be");
2005 InstanceKlass* ck = InstanceKlass::cast(c);
2006 Klass* m = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(member));
2007 assert(m->is_instance_klass(), "must be");
2008 InstanceKlass* mk = InstanceKlass::cast(m);
2009 return ck->has_nestmate_access_to(mk, THREAD);
2010 }
2011 JVM_END
2012
2013 JVM_ENTRY(jclass, JVM_GetNestHost(JNIEnv* env, jclass current))
2014 {
2015 // current is not a primitive or array class
2090 objArrayOop r2 = oopFactory::new_objArray(SystemDictionary::Class_klass(),
2091 count + 1, CHECK_NULL);
2092 objArrayHandle result2(THREAD, r2);
2093 for (int i = 0; i < count + 1; i++) {
2094 result2->obj_at_put(i, result->obj_at(i));
2095 }
2096 return (jobjectArray)JNIHandles::make_local(THREAD, result2());
2097 }
2098 }
2099 else {
2100 assert(host == ck || ck->is_hidden(), "must be singleton nest or dynamic nestmate");
2101 }
2102 return (jobjectArray)JNIHandles::make_local(THREAD, result());
2103 }
2104 }
2105 JVM_END
2106
2107 JVM_ENTRY(jobjectArray, JVM_GetPermittedSubclasses(JNIEnv* env, jclass current))
2108 {
2109 JVMWrapper("JVM_GetPermittedSubclasses");
2110 assert(!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(current)), "should not be");
2111 Klass* c = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(current));
2112 assert(c->is_instance_klass(), "must be");
2113 InstanceKlass* ik = InstanceKlass::cast(c);
2114 {
2115 JvmtiVMObjectAllocEventCollector oam;
2116 Array<u2>* subclasses = ik->permitted_subclasses();
2117 int length = subclasses == NULL ? 0 : subclasses->length();
2118 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
2119 length, CHECK_NULL);
2120 objArrayHandle result(THREAD, r);
2121 for (int i = 0; i < length; i++) {
2122 int cp_index = subclasses->at(i);
2123 // This returns <package-name>/<class-name>.
2124 Symbol* klass_name = ik->constants()->klass_name_at(cp_index);
2125 assert(klass_name != NULL, "Unexpected null klass_name");
2126 Handle perm_subtype_h = java_lang_String::create_from_symbol(klass_name, CHECK_NULL);
2127 result->obj_at_put(i, perm_subtype_h());
2128 }
2129 return (jobjectArray)JNIHandles::make_local(THREAD, result());
2130 }
2131 }
2132 JVM_END
2133
2134 // Constant pool access //////////////////////////////////////////////////////////
2135
2136 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls))
2137 {
2138 JVMWrapper("JVM_GetClassConstantPool");
2139 JvmtiVMObjectAllocEventCollector oam;
2140
2141 // Return null for primitives and arrays
2142 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
2143 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2144 if (k->is_instance_klass()) {
2145 InstanceKlass* k_h = InstanceKlass::cast(k);
2146 Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
2147 reflect_ConstantPool::set_cp(jcp(), k_h->constants());
2148 return JNIHandles::make_local(THREAD, jcp());
2149 }
2150 }
2151 return NULL;
2152 }
2153 JVM_END
2154
2155
2156 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused))
2157 {
2158 JVMWrapper("JVM_ConstantPoolGetSize");
2159 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2160 return cp->length();
2161 }
2162 JVM_END
2163
|
1287 assert(!result || k->is_instance_klass(),
1288 "all interfaces are instance types");
1289 // The compiler intrinsic for isInterface tests the
1290 // Klass::_access_flags bits in the same way.
1291 return result;
1292 JVM_END
1293
1294 JVM_ENTRY(jboolean, JVM_IsHiddenClass(JNIEnv *env, jclass cls))
1295 JVMWrapper("JVM_IsHiddenClass");
1296 oop mirror = JNIHandles::resolve_non_null(cls);
1297 if (java_lang_Class::is_primitive(mirror)) {
1298 return JNI_FALSE;
1299 }
1300 Klass* k = java_lang_Class::as_Klass(mirror);
1301 return k->is_hidden();
1302 JVM_END
1303
1304 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1305 JVMWrapper("JVM_GetClassSigners");
1306 JvmtiVMObjectAllocEventCollector oam;
1307 oop mirror = JNIHandles::resolve_non_null(cls);
1308 if (java_lang_Class::is_primitive(mirror)) {
1309 // There are no signers for primitive types
1310 return NULL;
1311 }
1312
1313 objArrayHandle signers(THREAD, java_lang_Class::signers(mirror));
1314
1315 // If there are no signers set in the class, or if the class
1316 // is an array, return NULL.
1317 if (signers == NULL) return NULL;
1318
1319 // copy of the signers array
1320 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1321 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1322 for (int index = 0; index < signers->length(); index++) {
1323 signers_copy->obj_at_put(index, signers->obj_at(index));
1324 }
1325
1326 // return the copy
1327 return (jobjectArray) JNIHandles::make_local(THREAD, signers_copy);
1328 JVM_END
1329
1330
1331 JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers))
1332 JVMWrapper("JVM_SetClassSigners");
1333 oop mirror = JNIHandles::resolve_non_null(cls);
1334 if (!java_lang_Class::is_primitive(mirror)) {
1335 // This call is ignored for primitive types and arrays.
1336 // Signers are only set once, ClassLoader.java, and thus shouldn't
1337 // be called with an array. Only the bootstrap loader creates arrays.
1338 Klass* k = java_lang_Class::as_Klass(mirror);
1339 if (k->is_instance_klass()) {
1340 java_lang_Class::set_signers(k->java_mirror(), objArrayOop(JNIHandles::resolve(signers)));
1341 }
1342 }
1343 JVM_END
1344
1345
1346 JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls))
1347 JVMWrapper("JVM_GetProtectionDomain");
1348 oop mirror = JNIHandles::resolve_non_null(cls);
1349 if (mirror == NULL) {
1350 THROW_(vmSymbols::java_lang_NullPointerException(), NULL);
1351 }
1352
1353 if (java_lang_Class::is_primitive(mirror)) {
1354 // Primitive types does not have a protection domain.
1355 return NULL;
1356 }
1357
1358 oop pd = java_lang_Class::protection_domain(mirror);
1359 return (jobject) JNIHandles::make_local(THREAD, pd);
1360 JVM_END
1361
1362
1363 // Returns the inherited_access_control_context field of the running thread.
1364 JVM_ENTRY(jobject, JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls))
1365 JVMWrapper("JVM_GetInheritedAccessControlContext");
1366 oop result = java_lang_Thread::inherited_access_control_context(thread->threadObj());
1367 return JNIHandles::make_local(THREAD, result);
1368 JVM_END
1369
1370 class RegisterArrayForGC {
1371 private:
1372 JavaThread *_thread;
1373 public:
1374 RegisterArrayForGC(JavaThread *thread, GrowableArray<oop>* array) {
1375 _thread = thread;
1376 _thread->register_array_for_gc(array);
1377 }
1378
1460 return JNIHandles::make_local(THREAD, result);
1461 JVM_END
1462
1463
1464 JVM_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
1465 JVMWrapper("JVM_IsArrayClass");
1466 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1467 return (k != NULL) && k->is_array_klass() ? true : false;
1468 JVM_END
1469
1470
1471 JVM_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))
1472 JVMWrapper("JVM_IsPrimitiveClass");
1473 oop mirror = JNIHandles::resolve_non_null(cls);
1474 return (jboolean) java_lang_Class::is_primitive(mirror);
1475 JVM_END
1476
1477
1478 JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv *env, jclass cls))
1479 JVMWrapper("JVM_GetClassModifiers");
1480 oop mirror = JNIHandles::resolve_non_null(cls);
1481 if (java_lang_Class::is_primitive(mirror)) {
1482 // Primitive type
1483 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
1484 }
1485
1486 Klass* k = java_lang_Class::as_Klass(mirror);
1487 debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0));
1488 assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK");
1489 return k->modifier_flags();
1490 JVM_END
1491
1492
1493 // Inner class reflection ///////////////////////////////////////////////////////////////////////////////
1494
1495 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
1496 JvmtiVMObjectAllocEventCollector oam;
1497 // ofClass is a reference to a java_lang_Class object. The mirror object
1498 // of an InstanceKlass
1499 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1500 if (java_lang_Class::is_primitive(ofMirror) ||
1501 ! java_lang_Class::as_Klass(ofMirror)->is_instance_klass()) {
1502 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
1503 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1504 }
1505
1506 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
1507 InnerClassesIterator iter(k);
1508
1509 if (iter.length() == 0) {
1510 // Neither an inner nor outer class
1511 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
1512 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1513 }
1514
1515 // find inner class info
1516 constantPoolHandle cp(thread, k->constants());
1517 int length = iter.length();
1518
1519 // Allocate temp. result array
1520 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), length/4, CHECK_NULL);
1521 objArrayHandle result (THREAD, r);
1522 int members = 0;
1523
1524 for (; !iter.done(); iter.next()) {
1525 int ioff = iter.inner_class_info_index();
1526 int ooff = iter.outer_class_info_index();
1544 }
1545 }
1546 }
1547
1548 if (members != length) {
1549 // Return array of right length
1550 objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL);
1551 for(int i = 0; i < members; i++) {
1552 res->obj_at_put(i, result->obj_at(i));
1553 }
1554 return (jobjectArray)JNIHandles::make_local(THREAD, res);
1555 }
1556
1557 return (jobjectArray)JNIHandles::make_local(THREAD, result());
1558 JVM_END
1559
1560
1561 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1562 {
1563 // ofClass is a reference to a java_lang_Class object.
1564 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1565 if (java_lang_Class::is_primitive(ofMirror)) {
1566 return NULL;
1567 }
1568 Klass* klass = java_lang_Class::as_Klass(ofMirror);
1569 if (!klass->is_instance_klass()) {
1570 return NULL;
1571 }
1572
1573 bool inner_is_member = false;
1574 Klass* outer_klass
1575 = InstanceKlass::cast(klass)->compute_enclosing_class(&inner_is_member, CHECK_NULL);
1576 if (outer_klass == NULL) return NULL; // already a top-level class
1577 if (!inner_is_member) return NULL; // a hidden or unsafe anonymous class (inside a method)
1578 return (jclass) JNIHandles::make_local(THREAD, outer_klass->java_mirror());
1579 }
1580 JVM_END
1581
1582 JVM_ENTRY(jstring, JVM_GetSimpleBinaryName(JNIEnv *env, jclass cls))
1583 {
1584 oop mirror = JNIHandles::resolve_non_null(cls);
1585 if (java_lang_Class::is_primitive(mirror)) {
1586 return NULL;
1587 }
1588 Klass* klass = java_lang_Class::as_Klass(mirror);
1589 if (!klass->is_instance_klass()) {
1590 return NULL;
1591 }
1592 InstanceKlass* k = InstanceKlass::cast(klass);
1593 int ooff = 0, noff = 0;
1594 if (k->find_inner_classes_attr(&ooff, &noff, THREAD)) {
1595 if (noff != 0) {
1596 constantPoolHandle i_cp(thread, k->constants());
1597 Symbol* name = i_cp->symbol_at(noff);
1598 Handle str = java_lang_String::create_from_symbol(name, CHECK_NULL);
1599 return (jstring) JNIHandles::make_local(THREAD, str());
1600 }
1601 }
1602 return NULL;
1603 }
1604 JVM_END
1605
1606 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls))
1607 assert (cls != NULL, "illegal class");
1608 JVMWrapper("JVM_GetClassSignature");
1609 JvmtiVMObjectAllocEventCollector oam;
1610 ResourceMark rm(THREAD);
1611 oop mirror = JNIHandles::resolve_non_null(cls);
1612 // Return null for arrays and primatives
1613 if (!java_lang_Class::is_primitive(mirror)) {
1614 Klass* k = java_lang_Class::as_Klass(mirror);
1615 if (k->is_instance_klass()) {
1616 Symbol* sym = InstanceKlass::cast(k)->generic_signature();
1617 if (sym == NULL) return NULL;
1618 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
1619 return (jstring) JNIHandles::make_local(THREAD, str());
1620 }
1621 }
1622 return NULL;
1623 JVM_END
1624
1625
1626 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls))
1627 assert (cls != NULL, "illegal class");
1628 JVMWrapper("JVM_GetClassAnnotations");
1629 oop mirror = JNIHandles::resolve_non_null(cls);
1630 // Return null for arrays and primitives
1631 if (!java_lang_Class::is_primitive(mirror)) {
1632 Klass* k = java_lang_Class::as_Klass(mirror);
1633 if (k->is_instance_klass()) {
1634 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
1635 return (jbyteArray) JNIHandles::make_local(THREAD, a);
1636 }
1637 }
1638 return NULL;
1639 JVM_END
1640
1641
1642 static bool jvm_get_field_common(jobject field, fieldDescriptor& fd, TRAPS) {
1643 // some of this code was adapted from from jni_FromReflectedField
1644
1645 oop reflected = JNIHandles::resolve_non_null(field);
1646 oop mirror = java_lang_reflect_Field::clazz(reflected);
1647 Klass* k = java_lang_Class::as_Klass(mirror);
1648 int slot = java_lang_reflect_Field::slot(reflected);
1649 int modifiers = java_lang_reflect_Field::modifiers(reflected);
1650
1651 InstanceKlass* ik = InstanceKlass::cast(k);
1652 intptr_t offset = ik->field_offset(slot);
1791 // For a 0 index, give a NULL symbol
1792 Symbol* sym = 0 != params[i].name_cp_index ?
1793 mh->constants()->symbol_at(params[i].name_cp_index) : NULL;
1794 int flags = params[i].flags;
1795 oop param = Reflection::new_parameter(reflected_method, i, sym,
1796 flags, CHECK_NULL);
1797 result->obj_at_put(i, param);
1798 }
1799 return (jobjectArray)JNIHandles::make_local(THREAD, result());
1800 }
1801 }
1802 JVM_END
1803
1804 // New (JDK 1.4) reflection implementation /////////////////////////////////////
1805
1806 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1807 {
1808 JVMWrapper("JVM_GetClassDeclaredFields");
1809 JvmtiVMObjectAllocEventCollector oam;
1810
1811 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1812 // Exclude primitive types and array types
1813 if (java_lang_Class::is_primitive(ofMirror) ||
1814 java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1815 // Return empty array
1816 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL);
1817 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1818 }
1819
1820 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
1821 constantPoolHandle cp(THREAD, k->constants());
1822
1823 // Ensure class is linked
1824 k->link_class(CHECK_NULL);
1825
1826 // Allocate result
1827 int num_fields;
1828
1829 if (publicOnly) {
1830 num_fields = 0;
1831 for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
1832 if (fs.access_flags().is_public()) ++num_fields;
1833 }
1834 } else {
1835 num_fields = k->java_fields_count();
1836 }
1837
1838 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), num_fields, CHECK_NULL);
1839 objArrayHandle result (THREAD, r);
1840
1900 return (jobjectArray)JNIHandles::make_local(THREAD, result);
1901 }
1902 JVM_END
1903
1904 static bool select_method(const methodHandle& method, bool want_constructor) {
1905 if (want_constructor) {
1906 return (method->is_initializer() && !method->is_static());
1907 } else {
1908 return (!method->is_initializer() && !method->is_overpass());
1909 }
1910 }
1911
1912 static jobjectArray get_class_declared_methods_helper(
1913 JNIEnv *env,
1914 jclass ofClass, jboolean publicOnly,
1915 bool want_constructor,
1916 Klass* klass, TRAPS) {
1917
1918 JvmtiVMObjectAllocEventCollector oam;
1919
1920 oop ofMirror = JNIHandles::resolve_non_null(ofClass);
1921 // Exclude primitive types and array types
1922 if (java_lang_Class::is_primitive(ofMirror)
1923 || java_lang_Class::as_Klass(ofMirror)->is_array_klass()) {
1924 // Return empty array
1925 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1926 return (jobjectArray) JNIHandles::make_local(THREAD, res);
1927 }
1928
1929 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(ofMirror));
1930
1931 // Ensure class is linked
1932 k->link_class(CHECK_NULL);
1933
1934 Array<Method*>* methods = k->methods();
1935 int methods_length = methods->length();
1936
1937 // Save original method_idnum in case of redefinition, which can change
1938 // the idnum of obsolete methods. The new method will have the same idnum
1939 // but if we refresh the methods array, the counts will be wrong.
1940 ResourceMark rm(THREAD);
1941 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1942 int num_methods = 0;
1943
1944 for (int i = 0; i < methods_length; i++) {
1945 methodHandle method(THREAD, methods->at(i));
1946 if (select_method(method, want_constructor)) {
1947 if (!publicOnly || method->is_public()) {
1948 idnums->push(method->method_idnum());
1949 ++num_methods;
1983 {
1984 JVMWrapper("JVM_GetClassDeclaredMethods");
1985 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1986 /*want_constructor*/ false,
1987 SystemDictionary::reflect_Method_klass(), THREAD);
1988 }
1989 JVM_END
1990
1991 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1992 {
1993 JVMWrapper("JVM_GetClassDeclaredConstructors");
1994 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1995 /*want_constructor*/ true,
1996 SystemDictionary::reflect_Constructor_klass(), THREAD);
1997 }
1998 JVM_END
1999
2000 JVM_ENTRY(jint, JVM_GetClassAccessFlags(JNIEnv *env, jclass cls))
2001 {
2002 JVMWrapper("JVM_GetClassAccessFlags");
2003 oop mirror = JNIHandles::resolve_non_null(cls);
2004 if (java_lang_Class::is_primitive(mirror)) {
2005 // Primitive type
2006 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
2007 }
2008
2009 Klass* k = java_lang_Class::as_Klass(mirror);
2010 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS;
2011 }
2012 JVM_END
2013
2014 JVM_ENTRY(jboolean, JVM_AreNestMates(JNIEnv *env, jclass current, jclass member))
2015 {
2016 JVMWrapper("JVM_AreNestMates");
2017 Klass* c = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(current));
2018 assert(c->is_instance_klass(), "must be");
2019 InstanceKlass* ck = InstanceKlass::cast(c);
2020 Klass* m = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(member));
2021 assert(m->is_instance_klass(), "must be");
2022 InstanceKlass* mk = InstanceKlass::cast(m);
2023 return ck->has_nestmate_access_to(mk, THREAD);
2024 }
2025 JVM_END
2026
2027 JVM_ENTRY(jclass, JVM_GetNestHost(JNIEnv* env, jclass current))
2028 {
2029 // current is not a primitive or array class
2104 objArrayOop r2 = oopFactory::new_objArray(SystemDictionary::Class_klass(),
2105 count + 1, CHECK_NULL);
2106 objArrayHandle result2(THREAD, r2);
2107 for (int i = 0; i < count + 1; i++) {
2108 result2->obj_at_put(i, result->obj_at(i));
2109 }
2110 return (jobjectArray)JNIHandles::make_local(THREAD, result2());
2111 }
2112 }
2113 else {
2114 assert(host == ck || ck->is_hidden(), "must be singleton nest or dynamic nestmate");
2115 }
2116 return (jobjectArray)JNIHandles::make_local(THREAD, result());
2117 }
2118 }
2119 JVM_END
2120
2121 JVM_ENTRY(jobjectArray, JVM_GetPermittedSubclasses(JNIEnv* env, jclass current))
2122 {
2123 JVMWrapper("JVM_GetPermittedSubclasses");
2124 oop mirror = JNIHandles::resolve_non_null(current);
2125 assert(!java_lang_Class::is_primitive(mirror), "should not be");
2126 Klass* c = java_lang_Class::as_Klass(mirror);
2127 assert(c->is_instance_klass(), "must be");
2128 InstanceKlass* ik = InstanceKlass::cast(c);
2129 {
2130 JvmtiVMObjectAllocEventCollector oam;
2131 Array<u2>* subclasses = ik->permitted_subclasses();
2132 int length = subclasses == NULL ? 0 : subclasses->length();
2133 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
2134 length, CHECK_NULL);
2135 objArrayHandle result(THREAD, r);
2136 for (int i = 0; i < length; i++) {
2137 int cp_index = subclasses->at(i);
2138 // This returns <package-name>/<class-name>.
2139 Symbol* klass_name = ik->constants()->klass_name_at(cp_index);
2140 assert(klass_name != NULL, "Unexpected null klass_name");
2141 Handle perm_subtype_h = java_lang_String::create_from_symbol(klass_name, CHECK_NULL);
2142 result->obj_at_put(i, perm_subtype_h());
2143 }
2144 return (jobjectArray)JNIHandles::make_local(THREAD, result());
2145 }
2146 }
2147 JVM_END
2148
2149 // Constant pool access //////////////////////////////////////////////////////////
2150
2151 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls))
2152 {
2153 JVMWrapper("JVM_GetClassConstantPool");
2154 JvmtiVMObjectAllocEventCollector oam;
2155 oop mirror = JNIHandles::resolve_non_null(cls);
2156 // Return null for primitives and arrays
2157 if (!java_lang_Class::is_primitive(mirror)) {
2158 Klass* k = java_lang_Class::as_Klass(mirror);
2159 if (k->is_instance_klass()) {
2160 InstanceKlass* k_h = InstanceKlass::cast(k);
2161 Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
2162 reflect_ConstantPool::set_cp(jcp(), k_h->constants());
2163 return JNIHandles::make_local(THREAD, jcp());
2164 }
2165 }
2166 return NULL;
2167 }
2168 JVM_END
2169
2170
2171 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused))
2172 {
2173 JVMWrapper("JVM_ConstantPoolGetSize");
2174 constantPoolHandle cp = constantPoolHandle(THREAD, reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2175 return cp->length();
2176 }
2177 JVM_END
2178
|