1381 return i;
1382 }
1383
1384 instanceHandle InstanceKlass::allocate_instance_handle(TRAPS) {
1385 return instanceHandle(THREAD, allocate_instance(THREAD));
1386 }
1387
1388 void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) {
1389 if (is_interface() || is_abstract()) {
1390 ResourceMark rm(THREAD);
1391 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
1392 : vmSymbols::java_lang_InstantiationException(), external_name());
1393 }
1394 if (this == SystemDictionary::Class_klass()) {
1395 ResourceMark rm(THREAD);
1396 THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError()
1397 : vmSymbols::java_lang_IllegalAccessException(), external_name());
1398 }
1399 }
1400
1401 Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) {
1402 // Need load-acquire for lock-free read
1403 if (array_klasses_acquire() == NULL) {
1404 if (or_null) return NULL;
1405
1406 ResourceMark rm;
1407 JavaThread *jt = (JavaThread *)THREAD;
1408 {
1409 // Atomic creation of array_klasses
1410 MutexLocker ma(MultiArray_lock, THREAD);
1411
1412 // Check if update has already taken place
1413 if (array_klasses() == NULL) {
1414 Klass* k = ObjArrayKlass::allocate_objArray_klass(class_loader_data(), 1, this, CHECK_NULL);
1415 // use 'release' to pair with lock-free load
1416 release_set_array_klasses(k);
1417 }
1418 }
1419 }
1420 // _this will always be set at this point
1421 ObjArrayKlass* oak = (ObjArrayKlass*)array_klasses();
1422 if (or_null) {
1423 return oak->array_klass_or_null(n);
1424 }
1425 return oak->array_klass(n, THREAD);
1426 }
1427
1428 Klass* InstanceKlass::array_klass_impl(bool or_null, TRAPS) {
1429 return array_klass_impl(or_null, 1, THREAD);
1430 }
1431
1432 static int call_class_initializer_counter = 0; // for debugging
1433
1434 Method* InstanceKlass::class_initializer() const {
1435 Method* clinit = find_method(
1436 vmSymbols::class_initializer_name(), vmSymbols::void_method_signature());
1437 if (clinit != NULL && clinit->has_valid_initializer_flags()) {
1438 return clinit;
1439 }
1440 return NULL;
1441 }
1442
1443 void InstanceKlass::call_class_initializer(TRAPS) {
1444 if (ReplayCompiles &&
1445 (ReplaySuppressInitializers == 1 ||
1446 (ReplaySuppressInitializers >= 2 && class_loader() != NULL))) {
1447 // Hide the existence of the initializer for the purpose of replaying the compile
1448 return;
1449 }
1633 fd.reinitialize(this, i);
1634 if (!fd.is_static()) {
1635 fields_sorted[j + 0] = fd.offset();
1636 fields_sorted[j + 1] = i;
1637 j += 2;
1638 }
1639 }
1640 if (j > 0) {
1641 length = j;
1642 // _sort_Fn is defined in growableArray.hpp.
1643 qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset);
1644 for (int i = 0; i < length; i += 2) {
1645 fd.reinitialize(this, fields_sorted[i + 1]);
1646 assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
1647 cl->do_field(&fd);
1648 }
1649 }
1650 FREE_C_HEAP_ARRAY(int, fields_sorted);
1651 }
1652
1653
1654 void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
1655 if (array_klasses() != NULL)
1656 ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD);
1657 }
1658
1659 void InstanceKlass::array_klasses_do(void f(Klass* k)) {
1660 if (array_klasses() != NULL)
1661 ArrayKlass::cast(array_klasses())->array_klasses_do(f);
1662 }
1663
1664 #ifdef ASSERT
1665 static int linear_search(const Array<Method*>* methods,
1666 const Symbol* name,
1667 const Symbol* signature) {
1668 const int len = methods->length();
1669 for (int index = 0; index < len; index++) {
1670 const Method* const m = methods->at(index);
1671 assert(m->is_method(), "must be method");
1672 if (m->signature() == signature && m->name() == name) {
1673 return index;
1674 }
1675 }
1676 return -1;
1677 }
|
1381 return i;
1382 }
1383
1384 instanceHandle InstanceKlass::allocate_instance_handle(TRAPS) {
1385 return instanceHandle(THREAD, allocate_instance(THREAD));
1386 }
1387
1388 void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) {
1389 if (is_interface() || is_abstract()) {
1390 ResourceMark rm(THREAD);
1391 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
1392 : vmSymbols::java_lang_InstantiationException(), external_name());
1393 }
1394 if (this == SystemDictionary::Class_klass()) {
1395 ResourceMark rm(THREAD);
1396 THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError()
1397 : vmSymbols::java_lang_IllegalAccessException(), external_name());
1398 }
1399 }
1400
1401 Klass* InstanceKlass::array_klass_impl(ArrayStorageProperties storage_props, bool or_null, int n, TRAPS) {
1402 assert(!storage_props.is_flattened(), "Can't be flattened");
1403 // Need load-acquire for lock-free read
1404 if (array_klasses_acquire() == NULL) {
1405 if (or_null) return NULL;
1406
1407 ResourceMark rm;
1408 JavaThread *jt = (JavaThread *)THREAD;
1409 {
1410 // Atomic creation of array_klasses
1411 MutexLocker ma(MultiArray_lock, THREAD);
1412
1413 // Check if update has already taken place
1414 if (array_klasses() == NULL) {
1415 Klass* k = ObjArrayKlass::allocate_objArray_klass(storage_props, 1, this, CHECK_NULL);
1416 // use 'release' to pair with lock-free load
1417 release_set_array_klasses(k);
1418 }
1419 }
1420 }
1421 // _this will always be set at this point
1422 ObjArrayKlass* oak = (ObjArrayKlass*)array_klasses();
1423 if (or_null) {
1424 return oak->array_klass_or_null(storage_props, n);
1425 }
1426 return oak->array_klass(storage_props, n, THREAD);
1427 }
1428
1429 Klass* InstanceKlass::array_klass_impl(ArrayStorageProperties storage_props, bool or_null, TRAPS) {
1430 return array_klass_impl(storage_props, or_null, 1, THREAD);
1431 }
1432
1433 static int call_class_initializer_counter = 0; // for debugging
1434
1435 Method* InstanceKlass::class_initializer() const {
1436 Method* clinit = find_method(
1437 vmSymbols::class_initializer_name(), vmSymbols::void_method_signature());
1438 if (clinit != NULL && clinit->has_valid_initializer_flags()) {
1439 return clinit;
1440 }
1441 return NULL;
1442 }
1443
1444 void InstanceKlass::call_class_initializer(TRAPS) {
1445 if (ReplayCompiles &&
1446 (ReplaySuppressInitializers == 1 ||
1447 (ReplaySuppressInitializers >= 2 && class_loader() != NULL))) {
1448 // Hide the existence of the initializer for the purpose of replaying the compile
1449 return;
1450 }
1634 fd.reinitialize(this, i);
1635 if (!fd.is_static()) {
1636 fields_sorted[j + 0] = fd.offset();
1637 fields_sorted[j + 1] = i;
1638 j += 2;
1639 }
1640 }
1641 if (j > 0) {
1642 length = j;
1643 // _sort_Fn is defined in growableArray.hpp.
1644 qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset);
1645 for (int i = 0; i < length; i += 2) {
1646 fd.reinitialize(this, fields_sorted[i + 1]);
1647 assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
1648 cl->do_field(&fd);
1649 }
1650 }
1651 FREE_C_HEAP_ARRAY(int, fields_sorted);
1652 }
1653
1654
1655 void InstanceKlass::array_klasses_do(void f(Klass* k)) {
1656 if (array_klasses() != NULL)
1657 ArrayKlass::cast(array_klasses())->array_klasses_do(f);
1658 }
1659
1660 #ifdef ASSERT
1661 static int linear_search(const Array<Method*>* methods,
1662 const Symbol* name,
1663 const Symbol* signature) {
1664 const int len = methods->length();
1665 for (int index = 0; index < len; index++) {
1666 const Method* const m = methods->at(index);
1667 assert(m->is_method(), "must be method");
1668 if (m->signature() == signature && m->name() == name) {
1669 return index;
1670 }
1671 }
1672 return -1;
1673 }
|