Mercurial > hg > graal-jvmci-8

comparison src/share/vm/oops/instanceKlass.cpp @ 2491:0654ee04b214

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with OpenJDK.
author Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date Fri, 22 Apr 2011 15:30:53 +0200
parents 2ab52cda08e5 2cd0180da6e1
children be4ca325525a
comparison
equal deleted inserted replaced
2490:29246b1d2d3c 2491:0654ee04b214
35 #include "jvmtifiles/jvmti.h" 35 #include "jvmtifiles/jvmti.h"
36 #include "memory/genOopClosures.inline.hpp" 36 #include "memory/genOopClosures.inline.hpp"
37 #include "memory/oopFactory.hpp" 37 #include "memory/oopFactory.hpp"
38 #include "memory/permGen.hpp" 38 #include "memory/permGen.hpp"
39 #include "oops/instanceKlass.hpp" 39 #include "oops/instanceKlass.hpp"
40 #include "oops/instanceMirrorKlass.hpp"
40 #include "oops/instanceOop.hpp" 41 #include "oops/instanceOop.hpp"
41 #include "oops/methodOop.hpp" 42 #include "oops/methodOop.hpp"
42 #include "oops/objArrayKlassKlass.hpp" 43 #include "oops/objArrayKlassKlass.hpp"
43 #include "oops/oop.inline.hpp" 44 #include "oops/oop.inline.hpp"
44 #include "oops/symbol.hpp" 45 #include "oops/symbol.hpp"
647 JavaCalls::call(&result, mh, &args, CHECK_NULL); 648 JavaCalls::call(&result, mh, &args, CHECK_NULL);
648 return h_i(); 649 return h_i();
649 } 650 }
650 651
651 instanceOop instanceKlass::allocate_instance(TRAPS) { 652 instanceOop instanceKlass::allocate_instance(TRAPS) {
653 assert(!oop_is_instanceMirror(), "wrong allocation path");
652 bool has_finalizer_flag = has_finalizer(); // Query before possible GC 654 bool has_finalizer_flag = has_finalizer(); // Query before possible GC
653 int size = size_helper(); // Query before forming handle. 655 int size = size_helper(); // Query before forming handle.
654 656
655 KlassHandle h_k(THREAD, as_klassOop()); 657 KlassHandle h_k(THREAD, as_klassOop());
656 658
667 // Finalizer registration occurs in the Object.<init> constructor 669 // Finalizer registration occurs in the Object.<init> constructor
668 // and constructors normally aren't run when allocating perm 670 // and constructors normally aren't run when allocating perm
669 // instances so simply disallow finalizable perm objects. This can 671 // instances so simply disallow finalizable perm objects. This can
670 // be relaxed if a need for it is found. 672 // be relaxed if a need for it is found.
671 assert(!has_finalizer(), "perm objects not allowed to have finalizers"); 673 assert(!has_finalizer(), "perm objects not allowed to have finalizers");
674 assert(!oop_is_instanceMirror(), "wrong allocation path");
672 int size = size_helper(); // Query before forming handle. 675 int size = size_helper(); // Query before forming handle.
673 KlassHandle h_k(THREAD, as_klassOop()); 676 KlassHandle h_k(THREAD, as_klassOop());
674 instanceOop i = (instanceOop) 677 instanceOop i = (instanceOop)
675 CollectedHeap::permanent_obj_allocate(h_k, size, CHECK_NULL); 678 CollectedHeap::permanent_obj_allocate(h_k, size, CHECK_NULL);
676 return i; 679 return i;
733 } 736 }
734 737
735 static int call_class_initializer_impl_counter = 0; // for debugging 738 static int call_class_initializer_impl_counter = 0; // for debugging
736 739
737 methodOop instanceKlass::class_initializer() { 740 methodOop instanceKlass::class_initializer() {
738 return find_method(vmSymbols::class_initializer_name(), vmSymbols::void_method_signature()); 741 methodOop clinit = find_method(
742 vmSymbols::class_initializer_name(), vmSymbols::void_method_signature());
743 if (clinit != NULL && clinit->has_valid_initializer_flags()) {
744 return clinit;
745 }
746 return NULL;
739 } 747 }
740 748
741 void instanceKlass::call_class_initializer_impl(instanceKlassHandle this_oop, TRAPS) { 749 void instanceKlass::call_class_initializer_impl(instanceKlassHandle this_oop, TRAPS) {
742 methodHandle h_method(THREAD, this_oop->class_initializer()); 750 methodHandle h_method(THREAD, this_oop->class_initializer());
743 assert(!this_oop->is_initialized(), "we cannot initialize twice"); 751 assert(!this_oop->is_initialized(), "we cannot initialize twice");
890 methodOop m = methodOop(methods()->obj_at(index)); 898 methodOop m = methodOop(methods()->obj_at(index));
891 assert(m->is_method(), "must be method"); 899 assert(m->is_method(), "must be method");
892 f(m); 900 f(m);
893 } 901 }
894 } 902 }
903
895 904
896 void instanceKlass::do_local_static_fields(FieldClosure* cl) { 905 void instanceKlass::do_local_static_fields(FieldClosure* cl) {
897 fieldDescriptor fd; 906 fieldDescriptor fd;
898 int length = fields()->length(); 907 int length = fields()->length();
899 for (int i = 0; i < length; i += next_offset) { 908 for (int i = 0; i < length; i += next_offset) {
1602 1611
1603 1612
1604 // The following macros call specialized macros, passing either oop or 1613 // The following macros call specialized macros, passing either oop or
1605 // narrowOop as the specialization type. These test the UseCompressedOops 1614 // narrowOop as the specialization type. These test the UseCompressedOops
1606 // flag. 1615 // flag.
1607 #define InstanceKlass_OOP_ITERATE(start_p, count, \
1608 do_oop, assert_fn) \
1609 { \
1610 if (UseCompressedOops) { \
1611 InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
1612 start_p, count, \
1613 do_oop, assert_fn) \
1614 } else { \
1615 InstanceKlass_SPECIALIZED_OOP_ITERATE(oop, \
1616 start_p, count, \
1617 do_oop, assert_fn) \
1618 } \
1619 }
1620
1621 #define InstanceKlass_BOUNDED_OOP_ITERATE(start_p, count, low, high, \
1622 do_oop, assert_fn) \
1623 { \
1624 if (UseCompressedOops) { \
1625 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
1626 start_p, count, \
1627 low, high, \
1628 do_oop, assert_fn) \
1629 } else { \
1630 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
1631 start_p, count, \
1632 low, high, \
1633 do_oop, assert_fn) \
1634 } \
1635 }
1636
1637 #define InstanceKlass_OOP_MAP_ITERATE(obj, do_oop, assert_fn) \ 1616 #define InstanceKlass_OOP_MAP_ITERATE(obj, do_oop, assert_fn) \
1638 { \ 1617 { \
1639 /* Compute oopmap block range. The common case \ 1618 /* Compute oopmap block range. The common case \
1640 is nonstatic_oop_map_size == 1. */ \ 1619 is nonstatic_oop_map_size == 1. */ \
1641 OopMapBlock* map = start_of_nonstatic_oop_maps(); \ 1620 OopMapBlock* map = start_of_nonstatic_oop_maps(); \
1704 ++map; \ 1683 ++map; \
1705 } \ 1684 } \
1706 } \ 1685 } \
1707 } 1686 }
1708 1687
1709 void instanceKlass::follow_static_fields() {
1710 InstanceKlass_OOP_ITERATE( \
1711 start_of_static_fields(), static_oop_field_size(), \
1712 MarkSweep::mark_and_push(p), \
1713 assert_is_in_closed_subset)
1714 }
1715
1716 #ifndef SERIALGC
1717 void instanceKlass::follow_static_fields(ParCompactionManager* cm) {
1718 InstanceKlass_OOP_ITERATE( \
1719 start_of_static_fields(), static_oop_field_size(), \
1720 PSParallelCompact::mark_and_push(cm, p), \
1721 assert_is_in)
1722 }
1723 #endif // SERIALGC
1724
1725 void instanceKlass::adjust_static_fields() {
1726 InstanceKlass_OOP_ITERATE( \
1727 start_of_static_fields(), static_oop_field_size(), \
1728 MarkSweep::adjust_pointer(p), \
1729 assert_nothing)
1730 }
1731
1732 #ifndef SERIALGC
1733 void instanceKlass::update_static_fields() {
1734 InstanceKlass_OOP_ITERATE( \
1735 start_of_static_fields(), static_oop_field_size(), \
1736 PSParallelCompact::adjust_pointer(p), \
1737 assert_nothing)
1738 }
1739 #endif // SERIALGC
1740
1741 void instanceKlass::oop_follow_contents(oop obj) { 1688 void instanceKlass::oop_follow_contents(oop obj) {
1742 assert(obj != NULL, "can't follow the content of NULL object"); 1689 assert(obj != NULL, "can't follow the content of NULL object");
1743 obj->follow_header(); 1690 obj->follow_header();
1744 InstanceKlass_OOP_MAP_ITERATE( \ 1691 InstanceKlass_OOP_MAP_ITERATE( \
1745 obj, \ 1692 obj, \
1822 #ifndef SERIALGC 1769 #ifndef SERIALGC
1823 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN) 1770 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
1824 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN) 1771 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
1825 #endif // !SERIALGC 1772 #endif // !SERIALGC
1826 1773
1827 void instanceKlass::iterate_static_fields(OopClosure* closure) {
1828 InstanceKlass_OOP_ITERATE( \
1829 start_of_static_fields(), static_oop_field_size(), \
1830 closure->do_oop(p), \
1831 assert_is_in_reserved)
1832 }
1833
1834 void instanceKlass::iterate_static_fields(OopClosure* closure,
1835 MemRegion mr) {
1836 InstanceKlass_BOUNDED_OOP_ITERATE( \
1837 start_of_static_fields(), static_oop_field_size(), \
1838 mr.start(), mr.end(), \
1839 (closure)->do_oop_v(p), \
1840 assert_is_in_closed_subset)
1841 }
1842
1843 int instanceKlass::oop_adjust_pointers(oop obj) { 1774 int instanceKlass::oop_adjust_pointers(oop obj) {
1844 int size = size_helper(); 1775 int size = size_helper();
1845 InstanceKlass_OOP_MAP_ITERATE( \ 1776 InstanceKlass_OOP_MAP_ITERATE( \
1846 obj, \ 1777 obj, \
1847 MarkSweep::adjust_pointer(p), \ 1778 MarkSweep::adjust_pointer(p), \
1866 PSParallelCompact::adjust_pointer(p), \ 1797 PSParallelCompact::adjust_pointer(p), \
1867 assert_nothing) 1798 assert_nothing)
1868 return size_helper(); 1799 return size_helper();
1869 } 1800 }
1870 1801
1871 void instanceKlass::push_static_fields(PSPromotionManager* pm) {
1872 InstanceKlass_OOP_ITERATE( \
1873 start_of_static_fields(), static_oop_field_size(), \
1874 if (PSScavenge::should_scavenge(p)) { \
1875 pm->claim_or_forward_depth(p); \
1876 }, \
1877 assert_nothing )
1878 }
1879
1880 void instanceKlass::copy_static_fields(ParCompactionManager* cm) {
1881 InstanceKlass_OOP_ITERATE( \
1882 start_of_static_fields(), static_oop_field_size(), \
1883 PSParallelCompact::adjust_pointer(p), \
1884 assert_is_in)
1885 }
1886 #endif // SERIALGC 1802 #endif // SERIALGC
1887 1803
1888 // This klass is alive but the implementor link is not followed/updated. 1804 // This klass is alive but the implementor link is not followed/updated.
1889 // Subklass and sibling links are handled by Klass::follow_weak_klass_links 1805 // Subklass and sibling links are handled by Klass::follow_weak_klass_links
1890 1806
1994 1910
1995 void instanceKlass::set_source_debug_extension(Symbol* n) { 1911 void instanceKlass::set_source_debug_extension(Symbol* n) {
1996 _source_debug_extension = n; 1912 _source_debug_extension = n;
1997 if (_source_debug_extension != NULL) _source_debug_extension->increment_refcount(); 1913 if (_source_debug_extension != NULL) _source_debug_extension->increment_refcount();
1998 } 1914 }
1915
1916 address instanceKlass::static_field_addr(int offset) {
1917 return (address)(offset + instanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror());
1918 }
1919
1999 1920
2000 const char* instanceKlass::signature_name() const { 1921 const char* instanceKlass::signature_name() const {
2001 const char* src = (const char*) (name()->as_C_string()); 1922 const char* src = (const char*) (name()->as_C_string());
2002 const int src_length = (int)strlen(src); 1923 const int src_length = (int)strlen(src);
2003 char* dest = NEW_RESOURCE_ARRAY(char, src_length + 3); 1924 char* dest = NEW_RESOURCE_ARRAY(char, src_length + 3);
2362 2283
2363 #define BULLET " - " 2284 #define BULLET " - "
2364 2285
2365 void FieldPrinter::do_field(fieldDescriptor* fd) { 2286 void FieldPrinter::do_field(fieldDescriptor* fd) {
2366 _st->print(BULLET); 2287 _st->print(BULLET);
2367 if (fd->is_static() || (_obj == NULL)) { 2288 if (_obj == NULL) {
2368 fd->print_on(_st); 2289 fd->print_on(_st);
2369 _st->cr(); 2290 _st->cr();
2370 } else { 2291 } else {
2371 fd->print_on_for(_st, _obj); 2292 fd->print_on_for(_st, _obj);
2372 _st->cr(); 2293 _st->cr();
2392 if (!WizardMode) return; // that is enough 2313 if (!WizardMode) return; // that is enough
2393 } 2314 }
2394 } 2315 }
2395 2316
2396 st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj)); 2317 st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj));
2397 FieldPrinter print_nonstatic_field(st, obj); 2318 FieldPrinter print_field(st, obj);
2398 do_nonstatic_fields(&print_nonstatic_field); 2319 do_nonstatic_fields(&print_field);
2399 2320
2400 if (as_klassOop() == SystemDictionary::Class_klass()) { 2321 if (as_klassOop() == SystemDictionary::Class_klass()) {
2401 st->print(BULLET"signature: "); 2322 st->print(BULLET"signature: ");
2402 java_lang_Class::print_signature(obj, st); 2323 java_lang_Class::print_signature(obj, st);
2403 st->cr(); 2324 st->cr();
2411 klassOop array_klass = java_lang_Class::array_klass(obj); 2332 klassOop array_klass = java_lang_Class::array_klass(obj);
2412 st->cr(); 2333 st->cr();
2413 st->print(BULLET"fake entry for array: "); 2334 st->print(BULLET"fake entry for array: ");
2414 array_klass->print_value_on(st); 2335 array_klass->print_value_on(st);
2415 st->cr(); 2336 st->cr();
2337 st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj));
2338 st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj));
2339 klassOop real_klass = java_lang_Class::as_klassOop(obj);
2340 if (real_klass != NULL && real_klass->klass_part()->oop_is_instance()) {
2341 instanceKlass::cast(real_klass)->do_local_static_fields(&print_field);
2342 }
2416 } else if (as_klassOop() == SystemDictionary::MethodType_klass()) { 2343 } else if (as_klassOop() == SystemDictionary::MethodType_klass()) {
2417 st->print(BULLET"signature: "); 2344 st->print(BULLET"signature: ");
2418 java_dyn_MethodType::print_signature(obj, st); 2345 java_lang_invoke_MethodType::print_signature(obj, st);
2419 st->cr(); 2346 st->cr();
2420 } 2347 }
2421 } 2348 }
2422 2349
2423 #endif //PRODUCT 2350 #endif //PRODUCT
2444 const char* tname = type2name(java_lang_Class::primitive_type(obj)); 2371 const char* tname = type2name(java_lang_Class::primitive_type(obj));
2445 st->print("%s", tname ? tname : "type?"); 2372 st->print("%s", tname ? tname : "type?");
2446 } 2373 }
2447 } else if (as_klassOop() == SystemDictionary::MethodType_klass()) { 2374 } else if (as_klassOop() == SystemDictionary::MethodType_klass()) {
2448 st->print(" = "); 2375 st->print(" = ");
2449 java_dyn_MethodType::print_signature(obj, st); 2376 java_lang_invoke_MethodType::print_signature(obj, st);
2450 } else if (java_lang_boxing_object::is_instance(obj)) { 2377 } else if (java_lang_boxing_object::is_instance(obj)) {
2451 st->print(" = "); 2378 st->print(" = ");
2452 java_lang_boxing_object::print(obj, st); 2379 java_lang_boxing_object::print(obj, st);
2453 } 2380 }
2454 } 2381 }
2553 } 2480 }
2554 } 2481 }
2555 2482
2556 2483
2557 void JNIid::verify(klassOop holder) { 2484 void JNIid::verify(klassOop holder) {
2558 int first_field_offset = instanceKlass::cast(holder)->offset_of_static_fields(); 2485 int first_field_offset = instanceMirrorKlass::offset_of_static_fields();
2559 int end_field_offset; 2486 int end_field_offset;
2560 end_field_offset = first_field_offset + (instanceKlass::cast(holder)->static_field_size() * wordSize); 2487 end_field_offset = first_field_offset + (instanceKlass::cast(holder)->static_field_size() * wordSize);
2561 2488
2562 JNIid* current = this; 2489 JNIid* current = this;
2563 while (current != NULL) { 2490 while (current != NULL) {