Mercurial > hg > graal-compiler
comparison src/share/vm/runtime/reflection.cpp @ 3895:19241ae0d839
7082263: Reflection::resolve_field/field_get/field_set are broken
Reviewed-by: kvn, dholmes, stefank, coleenp
author | never |
---|---|
date | Tue, 30 Aug 2011 00:54:09 -0700 |
parents | c7f3d0b4570f |
children | f7c4174b33ba |
comparison
equal
deleted
inserted
replaced
3894:b27c72d69fd1 | 3895:19241ae0d839 |
---|---|
841 java_lang_reflect_Field::set_annotations(rh(), fd->annotations()); | 841 java_lang_reflect_Field::set_annotations(rh(), fd->annotations()); |
842 } | 842 } |
843 return rh(); | 843 return rh(); |
844 } | 844 } |
845 | 845 |
846 | |
847 //--------------------------------------------------------------------------- | |
848 // | |
849 // Supporting routines for old native code-based reflection (pre-JDK 1.4). | |
850 // | |
851 // See reflection.hpp for details. | |
852 // | |
853 //--------------------------------------------------------------------------- | |
854 | |
855 #ifdef SUPPORT_OLD_REFLECTION | |
856 | 846 |
857 methodHandle Reflection::resolve_interface_call(instanceKlassHandle klass, methodHandle method, | 847 methodHandle Reflection::resolve_interface_call(instanceKlassHandle klass, methodHandle method, |
858 KlassHandle recv_klass, Handle receiver, TRAPS) { | 848 KlassHandle recv_klass, Handle receiver, TRAPS) { |
859 assert(!method.is_null() , "method should not be null"); | 849 assert(!method.is_null() , "method should not be null"); |
860 | 850 |
1079 BasicType Reflection::basic_type_mirror_to_basic_type(oop basic_type_mirror, TRAPS) { | 1069 BasicType Reflection::basic_type_mirror_to_basic_type(oop basic_type_mirror, TRAPS) { |
1080 assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking"); | 1070 assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking"); |
1081 return java_lang_Class::primitive_type(basic_type_mirror); | 1071 return java_lang_Class::primitive_type(basic_type_mirror); |
1082 } | 1072 } |
1083 | 1073 |
1084 | |
1085 bool Reflection::match_parameter_types(methodHandle method, objArrayHandle types, int parameter_count, TRAPS) { | |
1086 int types_len = types.is_null() ? 0 : types->length(); | |
1087 if (types_len != parameter_count) return false; | |
1088 if (parameter_count > 0) { | |
1089 objArrayHandle method_types = get_parameter_types(method, parameter_count, NULL, CHECK_false); | |
1090 for (int index = 0; index < parameter_count; index++) { | |
1091 if (types->obj_at(index) != method_types->obj_at(index)) { | |
1092 return false; | |
1093 } | |
1094 } | |
1095 } | |
1096 return true; | |
1097 } | |
1098 | |
1099 | |
1100 oop Reflection::new_field(FieldStream* st, TRAPS) { | |
1101 Symbol* field_name = st->name(); | |
1102 Handle name = java_lang_String::create_from_symbol(field_name, CHECK_NULL); | |
1103 Symbol* signature = st->signature(); | |
1104 Handle type = new_type(signature, st->klass(), CHECK_NULL); | |
1105 Handle rh = java_lang_reflect_Field::create(CHECK_NULL); | |
1106 oop result = rh(); | |
1107 | |
1108 java_lang_reflect_Field::set_clazz(result, st->klass()->java_mirror()); | |
1109 java_lang_reflect_Field::set_slot(result, st->index()); | |
1110 java_lang_reflect_Field::set_name(result, name()); | |
1111 java_lang_reflect_Field::set_type(result, type()); | |
1112 // Note the ACC_ANNOTATION bit, which is a per-class access flag, is never set here. | |
1113 java_lang_reflect_Field::set_modifiers(result, st->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS); | |
1114 java_lang_reflect_Field::set_override(result, false); | |
1115 return result; | |
1116 } | |
1117 | |
1118 | |
1119 bool Reflection::resolve_field(Handle field_mirror, Handle& receiver, fieldDescriptor* fd, bool check_final, TRAPS) { | |
1120 if (field_mirror.is_null()) { | |
1121 THROW_(vmSymbols::java_lang_NullPointerException(), false); | |
1122 } | |
1123 | |
1124 instanceKlassHandle klass (THREAD, java_lang_Class::as_klassOop(java_lang_reflect_Field::clazz(field_mirror()))); | |
1125 int slot = java_lang_reflect_Field::slot(field_mirror()); | |
1126 | |
1127 // Ensure klass is initialized | |
1128 klass->initialize(CHECK_false); | |
1129 fd->initialize(klass(), slot); | |
1130 | |
1131 bool is_static = fd->is_static(); | |
1132 KlassHandle receiver_klass; | |
1133 | |
1134 if (is_static) { | |
1135 receiver = KlassHandle(THREAD, klass()); | |
1136 receiver_klass = klass; | |
1137 } else { | |
1138 // Check object is a non-null instance of declaring class | |
1139 if (receiver.is_null()) { | |
1140 THROW_(vmSymbols::java_lang_NullPointerException(), false); | |
1141 } | |
1142 if (!receiver->is_a(klass())) { | |
1143 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "object is not an instance of declaring class", false); | |
1144 } | |
1145 receiver_klass = KlassHandle(THREAD, receiver->klass()); | |
1146 } | |
1147 | |
1148 // Access checking (unless overridden by Field) | |
1149 if (!java_lang_reflect_Field::override(field_mirror())) { | |
1150 if (!(klass->is_public() && fd->is_public())) { | |
1151 bool access_check = reflect_check_access(klass(), fd->access_flags(), receiver_klass(), false, CHECK_false); | |
1152 if (!access_check) { | |
1153 return false; // exception | |
1154 } | |
1155 } | |
1156 } | |
1157 | |
1158 if (check_final && fd->is_final()) { | |
1159 // In 1.3 we always throw an error when attempting to set a final field. | |
1160 // In 1.2.x, this was allowed in the override bit was set by calling Field.setAccessible(true). | |
1161 // We currently maintain backwards compatibility. See bug 4250960. | |
1162 bool strict_final_check = !JDK_Version::is_jdk12x_version(); | |
1163 if (strict_final_check || !java_lang_reflect_Field::override(field_mirror())) { | |
1164 THROW_MSG_(vmSymbols::java_lang_IllegalAccessException(), "field is final", false); | |
1165 } | |
1166 } | |
1167 return true; | |
1168 } | |
1169 | |
1170 | |
1171 BasicType Reflection::field_get(jvalue* value, fieldDescriptor* fd, Handle receiver) { | |
1172 BasicType field_type = fd->field_type(); | |
1173 int offset = fd->offset(); | |
1174 switch (field_type) { | |
1175 case T_BOOLEAN: | |
1176 value->z = receiver->bool_field(offset); | |
1177 break; | |
1178 case T_CHAR: | |
1179 value->c = receiver->char_field(offset); | |
1180 break; | |
1181 case T_FLOAT: | |
1182 value->f = receiver->float_field(offset); | |
1183 break; | |
1184 case T_DOUBLE: | |
1185 value->d = receiver->double_field(offset); | |
1186 break; | |
1187 case T_BYTE: | |
1188 value->b = receiver->byte_field(offset); | |
1189 break; | |
1190 case T_SHORT: | |
1191 value->s = receiver->short_field(offset); | |
1192 break; | |
1193 case T_INT: | |
1194 value->i = receiver->int_field(offset); | |
1195 break; | |
1196 case T_LONG: | |
1197 value->j = receiver->long_field(offset); | |
1198 break; | |
1199 case T_OBJECT: | |
1200 case T_ARRAY: | |
1201 value->l = (jobject) receiver->obj_field(offset); | |
1202 break; | |
1203 default: | |
1204 return T_ILLEGAL; | |
1205 } | |
1206 return field_type; | |
1207 } | |
1208 | |
1209 | |
1210 void Reflection::field_set(jvalue* value, fieldDescriptor* fd, Handle receiver, BasicType value_type, TRAPS) { | |
1211 BasicType field_type = fd->field_type(); | |
1212 if (field_type != value_type) { | |
1213 widen(value, value_type, field_type, CHECK); | |
1214 } | |
1215 | |
1216 int offset = fd->offset(); | |
1217 switch (field_type) { | |
1218 case T_BOOLEAN: | |
1219 receiver->bool_field_put(offset, value->z); | |
1220 break; | |
1221 case T_CHAR: | |
1222 receiver->char_field_put(offset, value->c); | |
1223 break; | |
1224 case T_FLOAT: | |
1225 receiver->float_field_put(offset, value->f); | |
1226 break; | |
1227 case T_DOUBLE: | |
1228 receiver->double_field_put(offset, value->d); | |
1229 break; | |
1230 case T_BYTE: | |
1231 receiver->byte_field_put(offset, value->b); | |
1232 break; | |
1233 case T_SHORT: | |
1234 receiver->short_field_put(offset, value->s); | |
1235 break; | |
1236 case T_INT: | |
1237 receiver->int_field_put(offset, value->i); | |
1238 break; | |
1239 case T_LONG: | |
1240 receiver->long_field_put(offset, value->j); | |
1241 break; | |
1242 case T_OBJECT: | |
1243 case T_ARRAY: { | |
1244 Handle obj(THREAD, (oop) value->l); | |
1245 if (obj.not_null()) { | |
1246 Symbol* signature = fd->signature(); | |
1247 Handle loader (THREAD, fd->loader()); | |
1248 Handle protect (THREAD, Klass::cast(fd->field_holder())->protection_domain()); | |
1249 klassOop k = SystemDictionary::resolve_or_fail(signature, loader, protect, true, CHECK); // may block | |
1250 if (!obj->is_a(k)) { | |
1251 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch"); | |
1252 } | |
1253 } | |
1254 receiver->obj_field_put(offset, obj()); | |
1255 break; | |
1256 } | |
1257 default: | |
1258 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch"); | |
1259 } | |
1260 } | |
1261 | |
1262 | |
1263 oop Reflection::reflect_field(oop mirror, Symbol* field_name, jint which, TRAPS) { | |
1264 // Exclude primitive types and array types | |
1265 if (java_lang_Class::is_primitive(mirror)) return NULL; | |
1266 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) return NULL; | |
1267 | |
1268 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror)); | |
1269 bool local_fields_only = (which == DECLARED); | |
1270 | |
1271 // Ensure class is linked | |
1272 k->link_class(CHECK_NULL); | |
1273 | |
1274 // Search class and interface fields | |
1275 for (FieldStream st(k, local_fields_only, false); !st.eos(); st.next()) { | |
1276 if (st.name() == field_name) { | |
1277 if (local_fields_only || st.access_flags().is_public()) { | |
1278 return new_field(&st, THREAD); | |
1279 } | |
1280 } | |
1281 } | |
1282 | |
1283 return NULL; | |
1284 } | |
1285 | |
1286 | |
1287 objArrayOop Reflection::reflect_fields(oop mirror, jint which, TRAPS) { | |
1288 // Exclude primitive types and array types | |
1289 if (java_lang_Class::is_primitive(mirror) | |
1290 || Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) { | |
1291 Symbol* name = vmSymbols::java_lang_reflect_Field(); | |
1292 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL); | |
1293 return oopFactory::new_objArray(klass, 0, CHECK_NULL); // Return empty array | |
1294 } | |
1295 | |
1296 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror)); | |
1297 | |
1298 // Ensure class is linked | |
1299 k->link_class(CHECK_NULL); | |
1300 | |
1301 bool local_fields_only = (which == DECLARED); | |
1302 int count = 0; | |
1303 { // Compute fields count for class and interface fields | |
1304 for (FieldStream st(k, local_fields_only, false); !st.eos(); st.next()) { | |
1305 if (local_fields_only || st.access_flags().is_public()) { | |
1306 count++; | |
1307 } | |
1308 } | |
1309 } | |
1310 | |
1311 // Allocate result | |
1312 Symbol* name = vmSymbols::java_lang_reflect_Field(); | |
1313 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL); | |
1314 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL); | |
1315 objArrayHandle result (THREAD, r); | |
1316 | |
1317 // Fill in results backwards | |
1318 { | |
1319 for (FieldStream st(k, local_fields_only, false); !st.eos(); st.next()) { | |
1320 if (local_fields_only || st.access_flags().is_public()) { | |
1321 oop field = new_field(&st, CHECK_NULL); | |
1322 result->obj_at_put(--count, field); | |
1323 } | |
1324 } | |
1325 assert(count == 0, "just checking"); | |
1326 } | |
1327 return result(); | |
1328 } | |
1329 | |
1330 | |
1331 oop Reflection::reflect_method(oop mirror, Symbol* method_name, objArrayHandle types, jint which, TRAPS) { | |
1332 if (java_lang_Class::is_primitive(mirror)) return NULL; | |
1333 klassOop klass = java_lang_Class::as_klassOop(mirror); | |
1334 if (Klass::cast(klass)->oop_is_array() && which == MEMBER_DECLARED) return NULL; | |
1335 | |
1336 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) { | |
1337 klass = SystemDictionary::Object_klass(); | |
1338 } | |
1339 instanceKlassHandle h_k(THREAD, klass); | |
1340 | |
1341 // Ensure klass is linked (need not be initialized) | |
1342 h_k->link_class(CHECK_NULL); | |
1343 | |
1344 // For interfaces include static initializers under jdk1.2.x (since classic does that) | |
1345 bool include_clinit = JDK_Version::is_jdk12x_version() && h_k->is_interface(); | |
1346 | |
1347 switch (which) { | |
1348 case MEMBER_PUBLIC: | |
1349 // First the public non-static methods (works if method holder is an interface) | |
1350 // Note that we can ignore checks for overridden methods, since we go up the hierarchy. | |
1351 { | |
1352 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) { | |
1353 methodHandle m(THREAD, st.method()); | |
1354 // For interfaces include static initializers since classic does that! | |
1355 if (method_name == m->name() && (include_clinit || (m->is_public() && !m->is_static() && !m->is_initializer()))) { | |
1356 Symbol* signature = m->signature(); | |
1357 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); | |
1358 if (parameter_match) { | |
1359 return new_method(m, false, false, THREAD); | |
1360 } | |
1361 } | |
1362 } | |
1363 } | |
1364 // Then the public static methods (works if method holder is an interface) | |
1365 { | |
1366 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) { | |
1367 methodHandle m(THREAD, st.method()); | |
1368 if (method_name == m->name() && m->is_public() && m->is_static() && !m->is_initializer()) { | |
1369 Symbol* signature = m->signature(); | |
1370 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); | |
1371 if (parameter_match) { | |
1372 return new_method(m, false, false, THREAD); | |
1373 } | |
1374 } | |
1375 } | |
1376 } | |
1377 break; | |
1378 case MEMBER_DECLARED: | |
1379 // All local methods | |
1380 { | |
1381 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) { | |
1382 methodHandle m(THREAD, st.method()); | |
1383 if (method_name == m->name() && !m->is_initializer()) { | |
1384 Symbol* signature = m->signature(); | |
1385 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); | |
1386 if (parameter_match) { | |
1387 return new_method(m, false, false, THREAD); | |
1388 } | |
1389 } | |
1390 } | |
1391 } | |
1392 break; | |
1393 default: | |
1394 break; | |
1395 } | |
1396 return NULL; | |
1397 } | |
1398 | |
1399 | |
1400 objArrayOop Reflection::reflect_methods(oop mirror, jint which, TRAPS) { | |
1401 // Exclude primitive types | |
1402 if (java_lang_Class::is_primitive(mirror) || | |
1403 (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array() && (which == MEMBER_DECLARED))) { | |
1404 klassOop klass = SystemDictionary::reflect_Method_klass(); | |
1405 return oopFactory::new_objArray(klass, 0, CHECK_NULL); // Return empty array | |
1406 } | |
1407 | |
1408 klassOop klass = java_lang_Class::as_klassOop(mirror); | |
1409 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) { | |
1410 klass = SystemDictionary::Object_klass(); | |
1411 } | |
1412 instanceKlassHandle h_k(THREAD, klass); | |
1413 | |
1414 // Ensure klass is linked (need not be initialized) | |
1415 h_k->link_class(CHECK_NULL); | |
1416 | |
1417 // We search the (super)interfaces only if h_k is an interface itself | |
1418 bool is_interface = h_k->is_interface(); | |
1419 | |
1420 // For interfaces include static initializers under jdk1.2.x (since classic does that) | |
1421 bool include_clinit = JDK_Version::is_jdk12x_version() && is_interface; | |
1422 | |
1423 switch (which) { | |
1424 case MEMBER_PUBLIC: | |
1425 { | |
1426 | |
1427 // Count public methods (non-static and static) | |
1428 int count = 0; | |
1429 { | |
1430 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) { | |
1431 methodOop m = st.method(); | |
1432 // For interfaces include static initializers since classic does that! | |
1433 if (include_clinit || (!m->is_initializer() && m->is_public() && !m->is_overridden_in(h_k()))) { | |
1434 count++; | |
1435 } | |
1436 } | |
1437 } | |
1438 | |
1439 // Allocate result | |
1440 klassOop klass = SystemDictionary::reflect_Method_klass(); | |
1441 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL); | |
1442 objArrayHandle h_result (THREAD, r); | |
1443 | |
1444 // Fill in results backwards | |
1445 { | |
1446 // First the non-static public methods | |
1447 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) { | |
1448 methodHandle m (THREAD, st.method()); | |
1449 if (!m->is_static() && !m->is_initializer() && m->is_public() && !m->is_overridden_in(h_k())) { | |
1450 oop method = new_method(m, false, false, CHECK_NULL); | |
1451 if (method == NULL) { | |
1452 return NULL; | |
1453 } else { | |
1454 h_result->obj_at_put(--count, method); | |
1455 } | |
1456 } | |
1457 } | |
1458 } | |
1459 { | |
1460 // Then the static public methods | |
1461 for (MethodStream st(h_k, false, !is_interface); !st.eos(); st.next()) { | |
1462 methodHandle m (THREAD, st.method()); | |
1463 if (m->is_static() && (include_clinit || (!m->is_initializer()) && m->is_public() && !m->is_overridden_in(h_k()))) { | |
1464 oop method = new_method(m, false, false, CHECK_NULL); | |
1465 if (method == NULL) { | |
1466 return NULL; | |
1467 } else { | |
1468 h_result->obj_at_put(--count, method); | |
1469 } | |
1470 } | |
1471 } | |
1472 } | |
1473 | |
1474 assert(count == 0, "just checking"); | |
1475 return h_result(); | |
1476 } | |
1477 | |
1478 case MEMBER_DECLARED: | |
1479 { | |
1480 // Count all methods | |
1481 int count = 0; | |
1482 { | |
1483 for (MethodStream st(h_k, true, !is_interface); !st.eos(); st.next()) { | |
1484 methodOop m = st.method(); | |
1485 if (!m->is_initializer()) { | |
1486 count++; | |
1487 } | |
1488 } | |
1489 } | |
1490 // Allocate result | |
1491 klassOop klass = SystemDictionary::reflect_Method_klass(); | |
1492 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL); | |
1493 objArrayHandle h_result (THREAD, r); | |
1494 | |
1495 // Fill in results backwards | |
1496 { | |
1497 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) { | |
1498 methodHandle m (THREAD, st.method()); | |
1499 if (!m->is_initializer()) { | |
1500 oop method = new_method(m, false, false, CHECK_NULL); | |
1501 if (method == NULL) { | |
1502 return NULL; | |
1503 } else { | |
1504 h_result->obj_at_put(--count, method); | |
1505 } | |
1506 } | |
1507 } | |
1508 } | |
1509 assert(count == 0, "just checking"); | |
1510 return h_result(); | |
1511 } | |
1512 } | |
1513 ShouldNotReachHere(); | |
1514 return NULL; | |
1515 } | |
1516 | |
1517 | |
1518 oop Reflection::reflect_constructor(oop mirror, objArrayHandle types, jint which, TRAPS) { | |
1519 | |
1520 // Exclude primitive, interface and array types | |
1521 bool prim = java_lang_Class::is_primitive(mirror); | |
1522 Klass* klass = prim ? NULL : Klass::cast(java_lang_Class::as_klassOop(mirror)); | |
1523 if (prim || klass->is_interface() || klass->oop_is_array()) return NULL; | |
1524 | |
1525 // Must be instance klass | |
1526 instanceKlassHandle h_k(THREAD, java_lang_Class::as_klassOop(mirror)); | |
1527 | |
1528 // Ensure klass is linked (need not be initialized) | |
1529 h_k->link_class(CHECK_NULL); | |
1530 | |
1531 bool local_only = (which == MEMBER_DECLARED); | |
1532 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) { | |
1533 methodHandle m(THREAD, st.method()); | |
1534 if (m->name() == vmSymbols::object_initializer_name() && (local_only || m->is_public())) { | |
1535 Symbol* signature = m->signature(); | |
1536 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); | |
1537 if (parameter_match) { | |
1538 return new_constructor(m, THREAD); | |
1539 } | |
1540 } | |
1541 } | |
1542 | |
1543 return NULL; | |
1544 } | |
1545 | |
1546 | |
1547 objArrayOop Reflection::reflect_constructors(oop mirror, jint which, TRAPS) { | |
1548 // Exclude primitive, interface and array types | |
1549 bool prim = java_lang_Class::is_primitive(mirror); | |
1550 Klass* k = prim ? NULL : Klass::cast(java_lang_Class::as_klassOop(mirror)); | |
1551 if (prim || k->is_interface() || k->oop_is_array()) { | |
1552 return oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), 0, CHECK_NULL); // Return empty array | |
1553 } | |
1554 | |
1555 // Must be instanceKlass at this point | |
1556 instanceKlassHandle h_k(THREAD, java_lang_Class::as_klassOop(mirror)); | |
1557 | |
1558 // Ensure klass is linked (need not be initialized) | |
1559 h_k->link_class(CHECK_NULL); | |
1560 | |
1561 bool local_only = (which == MEMBER_DECLARED); | |
1562 int count = 0; | |
1563 { | |
1564 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) { | |
1565 methodOop m = st.method(); | |
1566 if (m->name() == vmSymbols::object_initializer_name() && (local_only || m->is_public())) { | |
1567 count++; | |
1568 } | |
1569 } | |
1570 } | |
1571 | |
1572 // Allocate result | |
1573 Symbol* name = vmSymbols::java_lang_reflect_Constructor(); | |
1574 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL); | |
1575 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL); | |
1576 objArrayHandle h_result (THREAD, r); | |
1577 | |
1578 // Fill in results backwards | |
1579 { | |
1580 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) { | |
1581 methodHandle m (THREAD, st.method()); | |
1582 if (m->name() == vmSymbols::object_initializer_name() && (local_only || m->is_public())) { | |
1583 oop constr = new_constructor(m, CHECK_NULL); | |
1584 if (constr == NULL) { | |
1585 return NULL; | |
1586 } else { | |
1587 h_result->obj_at_put(--count, constr); | |
1588 } | |
1589 } | |
1590 } | |
1591 assert(count == 0, "just checking"); | |
1592 } | |
1593 return h_result(); | |
1594 } | |
1595 | |
1596 | |
1597 // This would be nicer if, say, java.lang.reflect.Method was a subclass | 1074 // This would be nicer if, say, java.lang.reflect.Method was a subclass |
1598 // of java.lang.reflect.Constructor | 1075 // of java.lang.reflect.Constructor |
1599 | 1076 |
1600 oop Reflection::invoke_method(oop method_mirror, Handle receiver, objArrayHandle args, TRAPS) { | 1077 oop Reflection::invoke_method(oop method_mirror, Handle receiver, objArrayHandle args, TRAPS) { |
1601 oop mirror = java_lang_reflect_Method::clazz(method_mirror); | 1078 oop mirror = java_lang_reflect_Method::clazz(method_mirror); |
1645 | 1122 |
1646 // Ignore result from call and return receiver | 1123 // Ignore result from call and return receiver |
1647 invoke(klass, method, receiver, override, ptypes, T_VOID, args, false, CHECK_NULL); | 1124 invoke(klass, method, receiver, override, ptypes, T_VOID, args, false, CHECK_NULL); |
1648 return receiver(); | 1125 return receiver(); |
1649 } | 1126 } |
1650 | |
1651 | |
1652 #endif /* SUPPORT_OLD_REFLECTION */ |