186 // create a new array of vtable_indices for default methods
187 Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {
188 Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL);
189 assert(default_vtable_indices() == NULL, "only create once");
190 set_default_vtable_indices(vtable_indices);
191 return vtable_indices;
192 }
193
194 InstanceKlass::InstanceKlass(int vtable_len,
195 int itable_len,
196 int static_field_size,
197 int nonstatic_oop_map_size,
198 unsigned kind,
199 ReferenceType rt,
200 AccessFlags access_flags,
201 bool is_anonymous) {
202 No_Safepoint_Verifier no_safepoint; // until k becomes parsable
203
204 int iksize = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,
205 access_flags.is_interface(), is_anonymous);
206
207 set_vtable_length(vtable_len);
208 set_itable_length(itable_len);
209 set_static_field_size(static_field_size);
210 set_nonstatic_oop_map_size(nonstatic_oop_map_size);
211 set_access_flags(access_flags);
212 _misc_flags = 0; // initialize to zero
213 set_kind(kind);
214 set_is_anonymous(is_anonymous);
215 assert(size() == iksize, "wrong size for object");
216
217 set_array_klasses(NULL);
218 set_methods(NULL);
219 set_method_ordering(NULL);
220 set_default_methods(NULL);
221 set_default_vtable_indices(NULL);
222 set_local_interfaces(NULL);
223 set_transitive_interfaces(NULL);
224 init_implementor();
225 set_fields(NULL, 0);
226 set_constants(NULL);
227 set_class_loader_data(NULL);
228 set_source_file_name_index(0);
229 set_source_debug_extension(NULL, 0);
230 set_array_name(NULL);
231 set_inner_classes(NULL);
232 set_static_oop_field_count(0);
233 set_nonstatic_field_size(0);
234 set_is_marked_dependent(false);
235 set_has_unloaded_dependent(false);
236 set_init_state(InstanceKlass::allocated);
237 set_init_thread(NULL);
238 set_reference_type(rt);
239 set_oop_map_cache(NULL);
240 set_jni_ids(NULL);
241 set_osr_nmethods_head(NULL);
242 set_breakpoints(NULL);
243 init_previous_versions();
244 set_generic_signature_index(0);
245 release_set_methods_jmethod_ids(NULL);
246 set_annotations(NULL);
247 set_jvmti_cached_class_field_map(NULL);
248 set_initial_method_idnum(0);
249 _dependencies = NULL;
250 set_jvmti_cached_class_field_map(NULL);
251 set_cached_class_file(NULL);
252 set_initial_method_idnum(0);
253 set_minor_version(0);
254 set_major_version(0);
255 NOT_PRODUCT(_verify_count = 0;)
256
257 // initialize the non-header words to zero
258 intptr_t* p = (intptr_t*)this;
259 for (int index = InstanceKlass::header_size(); index < iksize; index++) {
260 p[index] = NULL_WORD;
261 }
262
263 // Set temporary value until parseClassFile updates it with the real instance
264 // size.
265 set_layout_helper(Klass::instance_layout_helper(0, true));
266 }
267
268
269 void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data,
1847 size_t idnum = (size_t)method->method_idnum();
1848 jmethodID* jmeths = methods_jmethod_ids_acquire();
1849 size_t length; // length assigned as debugging crumb
1850 jmethodID id = NULL;
1851 if (jmeths != NULL && // If there is a cache
1852 (length = (size_t)jmeths[0]) > idnum) { // and if it is long enough,
1853 id = jmeths[idnum+1]; // Look up the id (may be NULL)
1854 }
1855 return id;
1856 }
1857
1858 int nmethodBucket::decrement() {
1859 return Atomic::add(-1, (volatile int *)&_count);
1860 }
1861
1862 //
1863 // Walk the list of dependent nmethods searching for nmethods which
1864 // are dependent on the changes that were passed in and mark them for
1865 // deoptimization. Returns the number of nmethods found.
1866 //
1867 int nmethodBucket::mark_dependent_nmethods(nmethodBucket* deps, DepChange& changes) {
1868 assert_locked_or_safepoint(CodeCache_lock);
1869 int found = 0;
1870 for (nmethodBucket* b = deps; b != NULL; b = b->next()) {
1871 nmethod* nm = b->get_nmethod();
1872 // since dependencies aren't removed until an nmethod becomes a zombie,
1873 // the dependency list may contain nmethods which aren't alive.
1874 if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {
1875 if (TraceDependencies) {
1876 ResourceMark rm;
1877 tty->print_cr("Marked for deoptimization");
1878 changes.print();
1879 nm->print();
1880 nm->print_dependencies();
1881 }
1882 nm->mark_for_deoptimization();
1883 found++;
1884 }
1885 }
1886 return found;
1887 }
1888
1889 //
1890 // Add an nmethodBucket to the list of dependencies for this nmethod.
1891 // It's possible that an nmethod has multiple dependencies on this klass
1892 // so a count is kept for each bucket to guarantee that creation and
1893 // deletion of dependencies is consistent. Returns new head of the list.
1894 //
1895 nmethodBucket* nmethodBucket::add_dependent_nmethod(nmethodBucket* deps, nmethod* nm) {
1896 assert_locked_or_safepoint(CodeCache_lock);
1897 for (nmethodBucket* b = deps; b != NULL; b = b->next()) {
1898 if (nm == b->get_nmethod()) {
1899 b->increment();
1900 return deps;
1901 }
1902 }
1903 return new nmethodBucket(nm, deps);
1904 }
1905
1906 //
1907 // Decrement count of the nmethod in the dependency list and remove
1908 // the bucket completely when the count goes to 0. This method must
1909 // find a corresponding bucket otherwise there's a bug in the
1910 // recording of dependencies. Returns true if the bucket was deleted,
1911 // or marked ready for reclaimation.
1912 bool nmethodBucket::remove_dependent_nmethod(nmethodBucket** deps, nmethod* nm, bool delete_immediately) {
1913 assert_locked_or_safepoint(CodeCache_lock);
1914
1915 nmethodBucket* first = *deps;
1916 nmethodBucket* last = NULL;
1917
1918 for (nmethodBucket* b = first; b != NULL; b = b->next()) {
1919 if (nm == b->get_nmethod()) {
1920 int val = b->decrement();
1921 guarantee(val >= 0, "Underflow: %d", val);
1922 if (val == 0) {
1923 if (delete_immediately) {
1924 if (last == NULL) {
1925 *deps = b->next();
1926 } else {
1927 last->set_next(b->next());
1928 }
1929 delete b;
1930 }
1931 }
1932 return true;
1933 }
1934 last = b;
1935 }
1936
1937 #ifdef ASSERT
1938 tty->print_raw_cr("### can't find dependent nmethod");
1939 nm->print();
1940 #endif // ASSERT
1941 ShouldNotReachHere();
1942 return false;
1943 }
1944
1945 // Convenience overload, for callers that don't want to delete the nmethodBucket entry.
1946 bool nmethodBucket::remove_dependent_nmethod(nmethodBucket* deps, nmethod* nm) {
1947 nmethodBucket** deps_addr = &deps;
1948 return remove_dependent_nmethod(deps_addr, nm, false /* Don't delete */);
1949 }
1950
1951 //
1952 // Reclaim all unused buckets. Returns new head of the list.
1953 //
1954 nmethodBucket* nmethodBucket::clean_dependent_nmethods(nmethodBucket* deps) {
1955 nmethodBucket* first = deps;
1956 nmethodBucket* last = NULL;
1957 nmethodBucket* b = first;
1958
1959 while (b != NULL) {
1960 assert(b->count() >= 0, "bucket count: %d", b->count());
1961 nmethodBucket* next = b->next();
1962 if (b->count() == 0) {
1963 if (last == NULL) {
1964 first = next;
1965 } else {
1966 last->set_next(next);
1967 }
1968 delete b;
1969 // last stays the same.
1970 } else {
1971 last = b;
1972 }
1973 b = next;
1974 }
1975 return first;
1976 }
1977
1978 #ifndef PRODUCT
1979 void nmethodBucket::print_dependent_nmethods(nmethodBucket* deps, bool verbose) {
1980 int idx = 0;
1981 for (nmethodBucket* b = deps; b != NULL; b = b->next()) {
1982 nmethod* nm = b->get_nmethod();
1983 tty->print("[%d] count=%d { ", idx++, b->count());
1984 if (!verbose) {
1985 nm->print_on(tty, "nmethod");
1986 tty->print_cr(" } ");
1987 } else {
1988 nm->print();
1989 nm->print_dependencies();
1990 tty->print_cr("--- } ");
1991 }
1992 }
1993 }
1994
1995 bool nmethodBucket::is_dependent_nmethod(nmethodBucket* deps, nmethod* nm) {
1996 for (nmethodBucket* b = deps; b != NULL; b = b->next()) {
1997 if (nm == b->get_nmethod()) {
1998 #ifdef ASSERT
1999 int count = b->count();
2000 assert(count >= 0, "count shouldn't be negative: %d", count);
2001 #endif
2002 return true;
2003 }
2004 }
2005 return false;
2006 }
2007 #endif //PRODUCT
2008
2009 int InstanceKlass::mark_dependent_nmethods(DepChange& changes) {
2010 assert_locked_or_safepoint(CodeCache_lock);
2011 return nmethodBucket::mark_dependent_nmethods(_dependencies, changes);
2012 }
2013
2014 void InstanceKlass::clean_dependent_nmethods() {
2015 assert_locked_or_safepoint(CodeCache_lock);
2016
2017 if (has_unloaded_dependent()) {
2018 _dependencies = nmethodBucket::clean_dependent_nmethods(_dependencies);
2019 set_has_unloaded_dependent(false);
2020 }
2021 #ifdef ASSERT
2022 else {
2023 // Verification
2024 for (nmethodBucket* b = _dependencies; b != NULL; b = b->next()) {
2025 assert(b->count() >= 0, "bucket count: %d", b->count());
2026 assert(b->count() != 0, "empty buckets need to be cleaned");
2027 }
2028 }
2029 #endif
2030 }
2031
2032 void InstanceKlass::add_dependent_nmethod(nmethod* nm) {
2033 assert_locked_or_safepoint(CodeCache_lock);
2034 _dependencies = nmethodBucket::add_dependent_nmethod(_dependencies, nm);
2035 }
2036
2037 void InstanceKlass::remove_dependent_nmethod(nmethod* nm, bool delete_immediately) {
2038 assert_locked_or_safepoint(CodeCache_lock);
2039
2040 if (nmethodBucket::remove_dependent_nmethod(&_dependencies, nm, delete_immediately)) {
2041 set_has_unloaded_dependent(true);
2042 }
2043 }
2044
2045 #ifndef PRODUCT
2046 void InstanceKlass::print_dependent_nmethods(bool verbose) {
2047 nmethodBucket::print_dependent_nmethods(_dependencies, verbose);
2048 }
2049
2050 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
2051 return nmethodBucket::is_dependent_nmethod(_dependencies, nm);
2052 }
2053 #endif //PRODUCT
2054
2055 void InstanceKlass::clean_weak_instanceklass_links(BoolObjectClosure* is_alive) {
2056 clean_implementors_list(is_alive);
2057 clean_method_data(is_alive);
2058
2059 clean_dependent_nmethods();
2060 }
2061
2062 void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) {
2063 assert(class_loader_data()->is_alive(is_alive), "this klass should be live");
2064 if (is_interface()) {
2065 if (ClassUnloading) {
2066 Klass* impl = implementor();
2067 if (impl != NULL) {
2068 if (!impl->is_loader_alive(is_alive)) {
2069 // remove this guy
2070 Klass** klass = adr_implementor();
2071 assert(klass != NULL, "null klass");
2072 if (klass != NULL) {
2073 *klass = NULL;
2074 }
2075 }
2076 }
2077 }
2078 }
2086 }
2087 }
2088 }
2089
2090
2091 static void remove_unshareable_in_class(Klass* k) {
2092 // remove klass's unshareable info
2093 k->remove_unshareable_info();
2094 }
2095
2096 void InstanceKlass::remove_unshareable_info() {
2097 Klass::remove_unshareable_info();
2098 // Unlink the class
2099 if (is_linked()) {
2100 unlink_class();
2101 }
2102 init_implementor();
2103
2104 constants()->remove_unshareable_info();
2105
2106 for (int i = 0; i < methods()->length(); i++) {
2107 Method* m = methods()->at(i);
2108 m->remove_unshareable_info();
2109 }
2110
2111 // do array classes also.
2112 array_klasses_do(remove_unshareable_in_class);
2113 }
2114
2115 static void restore_unshareable_in_class(Klass* k, TRAPS) {
2116 // Array classes have null protection domain.
2117 // --> see ArrayKlass::complete_create_array_klass()
2118 k->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK);
2119 }
2120
2121 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
2122 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
2123 instanceKlassHandle ik(THREAD, this);
2124
2125 Array<Method*>* methods = ik->methods();
2215 set_jni_ids(NULL);
2216
2217 jmethodID* jmeths = methods_jmethod_ids_acquire();
2218 if (jmeths != (jmethodID*)NULL) {
2219 release_set_methods_jmethod_ids(NULL);
2220 FreeHeap(jmeths);
2221 }
2222
2223 // Deallocate MemberNameTable
2224 {
2225 Mutex* lock_or_null = SafepointSynchronize::is_at_safepoint() ? NULL : MemberNameTable_lock;
2226 MutexLockerEx ml(lock_or_null, Mutex::_no_safepoint_check_flag);
2227 MemberNameTable* mnt = member_names();
2228 if (mnt != NULL) {
2229 delete mnt;
2230 set_member_names(NULL);
2231 }
2232 }
2233
2234 // release dependencies
2235 nmethodBucket* b = _dependencies;
2236 _dependencies = NULL;
2237 while (b != NULL) {
2238 nmethodBucket* next = b->next();
2239 delete b;
2240 b = next;
2241 }
2242
2243 // Deallocate breakpoint records
2244 if (breakpoints() != 0x0) {
2245 methods_do(clear_all_breakpoints);
2246 assert(breakpoints() == 0x0, "should have cleared breakpoints");
2247 }
2248
2249 // deallocate the cached class file
2250 if (_cached_class_file != NULL) {
2251 os::free(_cached_class_file);
2252 _cached_class_file = NULL;
2253 }
2254
2255 // Decrement symbol reference counts associated with the unloaded class.
2256 if (_name != NULL) _name->decrement_refcount();
2257 // unreference array name derived from this class name (arrays of an unloaded
2258 // class can't be referenced anymore).
2259 if (_array_name != NULL) _array_name->decrement_refcount();
2260 if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension);
3563 return NULL; // The version of klass is gone, no method is found
3564 }
3565 Method* method = holder->method_with_orig_idnum(idnum);
3566 return method;
3567 }
3568
3569
3570 jint InstanceKlass::get_cached_class_file_len() {
3571 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
3572 }
3573
3574 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
3575 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
3576 }
3577
3578
3579 /////////////// Unit tests ///////////////
3580
3581 #ifndef PRODUCT
3582
3583 class TestNmethodBucketContext {
3584 public:
3585 nmethod* _nmethodLast;
3586 nmethod* _nmethodMiddle;
3587 nmethod* _nmethodFirst;
3588
3589 nmethodBucket* _bucketLast;
3590 nmethodBucket* _bucketMiddle;
3591 nmethodBucket* _bucketFirst;
3592
3593 nmethodBucket* _bucketList;
3594
3595 TestNmethodBucketContext() {
3596 CodeCache_lock->lock_without_safepoint_check();
3597
3598 _nmethodLast = reinterpret_cast<nmethod*>(0x8 * 0);
3599 _nmethodMiddle = reinterpret_cast<nmethod*>(0x8 * 1);
3600 _nmethodFirst = reinterpret_cast<nmethod*>(0x8 * 2);
3601
3602 _bucketLast = new nmethodBucket(_nmethodLast, NULL);
3603 _bucketMiddle = new nmethodBucket(_nmethodMiddle, _bucketLast);
3604 _bucketFirst = new nmethodBucket(_nmethodFirst, _bucketMiddle);
3605
3606 _bucketList = _bucketFirst;
3607 }
3608
3609 ~TestNmethodBucketContext() {
3610 delete _bucketLast;
3611 delete _bucketMiddle;
3612 delete _bucketFirst;
3613
3614 CodeCache_lock->unlock();
3615 }
3616 };
3617
3618 class TestNmethodBucket {
3619 public:
3620 static void testRemoveDependentNmethodFirstDeleteImmediately() {
3621 TestNmethodBucketContext c;
3622
3623 nmethodBucket::remove_dependent_nmethod(&c._bucketList, c._nmethodFirst, true /* delete */);
3624
3625 assert(c._bucketList == c._bucketMiddle, "check");
3626 assert(c._bucketList->next() == c._bucketLast, "check");
3627 assert(c._bucketList->next()->next() == NULL, "check");
3628
3629 // Cleanup before context is deleted.
3630 c._bucketFirst = NULL;
3631 }
3632
3633 static void testRemoveDependentNmethodMiddleDeleteImmediately() {
3634 TestNmethodBucketContext c;
3635
3636 nmethodBucket::remove_dependent_nmethod(&c._bucketList, c._nmethodMiddle, true /* delete */);
3637
3638 assert(c._bucketList == c._bucketFirst, "check");
3639 assert(c._bucketList->next() == c._bucketLast, "check");
3640 assert(c._bucketList->next()->next() == NULL, "check");
3641
3642 // Cleanup before context is deleted.
3643 c._bucketMiddle = NULL;
3644 }
3645
3646 static void testRemoveDependentNmethodLastDeleteImmediately() {
3647 TestNmethodBucketContext c;
3648
3649 nmethodBucket::remove_dependent_nmethod(&c._bucketList, c._nmethodLast, true /* delete */);
3650
3651 assert(c._bucketList == c._bucketFirst, "check");
3652 assert(c._bucketList->next() == c._bucketMiddle, "check");
3653 assert(c._bucketList->next()->next() == NULL, "check");
3654
3655 // Cleanup before context is deleted.
3656 c._bucketLast = NULL;
3657 }
3658
3659 static void testRemoveDependentNmethodFirstDeleteDeferred() {
3660 TestNmethodBucketContext c;
3661
3662 nmethodBucket::remove_dependent_nmethod(&c._bucketList, c._nmethodFirst, false /* delete */);
3663
3664 assert(c._bucketList == c._bucketFirst, "check");
3665 assert(c._bucketList->next() == c._bucketMiddle, "check");
3666 assert(c._bucketList->next()->next() == c._bucketLast, "check");
3667 assert(c._bucketList->next()->next()->next() == NULL, "check");
3668
3669 assert(c._bucketFirst->count() == 0, "check");
3670 assert(c._bucketMiddle->count() == 1, "check");
3671 assert(c._bucketLast->count() == 1, "check");
3672 }
3673
3674 static void testRemoveDependentNmethodMiddleDeleteDeferred() {
3675 TestNmethodBucketContext c;
3676
3677 nmethodBucket::remove_dependent_nmethod(&c._bucketList, c._nmethodMiddle, false /* delete */);
3678
3679 assert(c._bucketList == c._bucketFirst, "check");
3680 assert(c._bucketList->next() == c._bucketMiddle, "check");
3681 assert(c._bucketList->next()->next() == c._bucketLast, "check");
3682 assert(c._bucketList->next()->next()->next() == NULL, "check");
3683
3684 assert(c._bucketFirst->count() == 1, "check");
3685 assert(c._bucketMiddle->count() == 0, "check");
3686 assert(c._bucketLast->count() == 1, "check");
3687 }
3688
3689 static void testRemoveDependentNmethodLastDeleteDeferred() {
3690 TestNmethodBucketContext c;
3691
3692 nmethodBucket::remove_dependent_nmethod(&c._bucketList, c._nmethodLast, false /* delete */);
3693
3694 assert(c._bucketList == c._bucketFirst, "check");
3695 assert(c._bucketList->next() == c._bucketMiddle, "check");
3696 assert(c._bucketList->next()->next() == c._bucketLast, "check");
3697 assert(c._bucketList->next()->next()->next() == NULL, "check");
3698
3699 assert(c._bucketFirst->count() == 1, "check");
3700 assert(c._bucketMiddle->count() == 1, "check");
3701 assert(c._bucketLast->count() == 0, "check");
3702 }
3703
3704 static void testRemoveDependentNmethodConvenienceFirst() {
3705 TestNmethodBucketContext c;
3706
3707 nmethodBucket::remove_dependent_nmethod(c._bucketList, c._nmethodFirst);
3708
3709 assert(c._bucketList == c._bucketFirst, "check");
3710 assert(c._bucketList->next() == c._bucketMiddle, "check");
3711 assert(c._bucketList->next()->next() == c._bucketLast, "check");
3712 assert(c._bucketList->next()->next()->next() == NULL, "check");
3713
3714 assert(c._bucketFirst->count() == 0, "check");
3715 assert(c._bucketMiddle->count() == 1, "check");
3716 assert(c._bucketLast->count() == 1, "check");
3717 }
3718
3719 static void testRemoveDependentNmethodConvenienceMiddle() {
3720 TestNmethodBucketContext c;
3721
3722 nmethodBucket::remove_dependent_nmethod(c._bucketList, c._nmethodMiddle);
3723
3724 assert(c._bucketList == c._bucketFirst, "check");
3725 assert(c._bucketList->next() == c._bucketMiddle, "check");
3726 assert(c._bucketList->next()->next() == c._bucketLast, "check");
3727 assert(c._bucketList->next()->next()->next() == NULL, "check");
3728
3729 assert(c._bucketFirst->count() == 1, "check");
3730 assert(c._bucketMiddle->count() == 0, "check");
3731 assert(c._bucketLast->count() == 1, "check");
3732 }
3733
3734 static void testRemoveDependentNmethodConvenienceLast() {
3735 TestNmethodBucketContext c;
3736
3737 nmethodBucket::remove_dependent_nmethod(c._bucketList, c._nmethodLast);
3738
3739 assert(c._bucketList == c._bucketFirst, "check");
3740 assert(c._bucketList->next() == c._bucketMiddle, "check");
3741 assert(c._bucketList->next()->next() == c._bucketLast, "check");
3742 assert(c._bucketList->next()->next()->next() == NULL, "check");
3743
3744 assert(c._bucketFirst->count() == 1, "check");
3745 assert(c._bucketMiddle->count() == 1, "check");
3746 assert(c._bucketLast->count() == 0, "check");
3747 }
3748
3749 static void testRemoveDependentNmethod() {
3750 testRemoveDependentNmethodFirstDeleteImmediately();
3751 testRemoveDependentNmethodMiddleDeleteImmediately();
3752 testRemoveDependentNmethodLastDeleteImmediately();
3753
3754 testRemoveDependentNmethodFirstDeleteDeferred();
3755 testRemoveDependentNmethodMiddleDeleteDeferred();
3756 testRemoveDependentNmethodLastDeleteDeferred();
3757
3758 testRemoveDependentNmethodConvenienceFirst();
3759 testRemoveDependentNmethodConvenienceMiddle();
3760 testRemoveDependentNmethodConvenienceLast();
3761 }
3762
3763 static void test() {
3764 testRemoveDependentNmethod();
3765 }
3766 };
3767
3768 void TestNmethodBucket_test() {
3769 TestNmethodBucket::test();
3770 }
3771
3772 #endif
|
186 // create a new array of vtable_indices for default methods
187 Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {
188 Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL);
189 assert(default_vtable_indices() == NULL, "only create once");
190 set_default_vtable_indices(vtable_indices);
191 return vtable_indices;
192 }
193
194 InstanceKlass::InstanceKlass(int vtable_len,
195 int itable_len,
196 int static_field_size,
197 int nonstatic_oop_map_size,
198 unsigned kind,
199 ReferenceType rt,
200 AccessFlags access_flags,
201 bool is_anonymous) {
202 No_Safepoint_Verifier no_safepoint; // until k becomes parsable
203
204 int iksize = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,
205 access_flags.is_interface(), is_anonymous);
206 set_vtable_length(vtable_len);
207 set_itable_length(itable_len);
208 set_static_field_size(static_field_size);
209 set_nonstatic_oop_map_size(nonstatic_oop_map_size);
210 set_access_flags(access_flags);
211 _misc_flags = 0; // initialize to zero
212 set_kind(kind);
213 set_is_anonymous(is_anonymous);
214 assert(size() == iksize, "wrong size for object");
215
216 set_array_klasses(NULL);
217 set_methods(NULL);
218 set_method_ordering(NULL);
219 set_default_methods(NULL);
220 set_default_vtable_indices(NULL);
221 set_local_interfaces(NULL);
222 set_transitive_interfaces(NULL);
223 init_implementor();
224 set_fields(NULL, 0);
225 set_constants(NULL);
226 set_class_loader_data(NULL);
227 set_source_file_name_index(0);
228 set_source_debug_extension(NULL, 0);
229 set_array_name(NULL);
230 set_inner_classes(NULL);
231 set_static_oop_field_count(0);
232 set_nonstatic_field_size(0);
233 set_is_marked_dependent(false);
234 _dep_context = DependencyContext::EMPTY;
235 set_init_state(InstanceKlass::allocated);
236 set_init_thread(NULL);
237 set_reference_type(rt);
238 set_oop_map_cache(NULL);
239 set_jni_ids(NULL);
240 set_osr_nmethods_head(NULL);
241 set_breakpoints(NULL);
242 init_previous_versions();
243 set_generic_signature_index(0);
244 release_set_methods_jmethod_ids(NULL);
245 set_annotations(NULL);
246 set_jvmti_cached_class_field_map(NULL);
247 set_initial_method_idnum(0);
248 set_jvmti_cached_class_field_map(NULL);
249 set_cached_class_file(NULL);
250 set_initial_method_idnum(0);
251 set_minor_version(0);
252 set_major_version(0);
253 NOT_PRODUCT(_verify_count = 0;)
254
255 // initialize the non-header words to zero
256 intptr_t* p = (intptr_t*)this;
257 for (int index = InstanceKlass::header_size(); index < iksize; index++) {
258 p[index] = NULL_WORD;
259 }
260
261 // Set temporary value until parseClassFile updates it with the real instance
262 // size.
263 set_layout_helper(Klass::instance_layout_helper(0, true));
264 }
265
266
267 void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data,
1845 size_t idnum = (size_t)method->method_idnum();
1846 jmethodID* jmeths = methods_jmethod_ids_acquire();
1847 size_t length; // length assigned as debugging crumb
1848 jmethodID id = NULL;
1849 if (jmeths != NULL && // If there is a cache
1850 (length = (size_t)jmeths[0]) > idnum) { // and if it is long enough,
1851 id = jmeths[idnum+1]; // Look up the id (may be NULL)
1852 }
1853 return id;
1854 }
1855
1856 int nmethodBucket::decrement() {
1857 return Atomic::add(-1, (volatile int *)&_count);
1858 }
1859
1860 //
1861 // Walk the list of dependent nmethods searching for nmethods which
1862 // are dependent on the changes that were passed in and mark them for
1863 // deoptimization. Returns the number of nmethods found.
1864 //
1865 int DependencyContext::mark_dependent_nmethods(DepChange& changes) {
1866 int found = 0;
1867 for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {
1868 nmethod* nm = b->get_nmethod();
1869 // since dependencies aren't removed until an nmethod becomes a zombie,
1870 // the dependency list may contain nmethods which aren't alive.
1871 if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {
1872 if (TraceDependencies) {
1873 ResourceMark rm;
1874 tty->print_cr("Marked for deoptimization");
1875 changes.print();
1876 nm->print();
1877 nm->print_dependencies();
1878 }
1879 nm->mark_for_deoptimization();
1880 found++;
1881 }
1882 }
1883 return found;
1884 }
1885
1886 //
1887 // Add an nmethod to the dependency context.
1888 // It's possible that an nmethod has multiple dependencies on this klass
1889 // so a count is kept for each bucket to guarantee that creation and
1890 // deletion of dependencies is consistent. Returns new head of the list.
1891 //
1892 void DependencyContext::add_dependent_nmethod(nmethod* nm) {
1893 assert_lock_strong(CodeCache_lock);
1894 for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {
1895 if (nm == b->get_nmethod()) {
1896 b->increment();
1897 return;
1898 }
1899 }
1900 set_dependencies(new nmethodBucket(nm, dependencies()));
1901 }
1902
1903 //
1904 // Decrement count of the nmethod in the dependency list and, optionally, remove
1905 // the bucket completely when the count goes to 0. This method must find
1906 // a corresponding bucket otherwise there's a bug in the recording of dependencies.
1907 void DependencyContext::remove_dependent_nmethod(nmethod* nm, bool delete_immediately) {
1908 assert_locked_or_safepoint(CodeCache_lock);
1909 nmethodBucket* first = dependencies();
1910 nmethodBucket* last = NULL;
1911 for (nmethodBucket* b = first; b != NULL; b = b->next()) {
1912 if (nm == b->get_nmethod()) {
1913 int val = b->decrement();
1914 guarantee(val >= 0, "Underflow: %d", val);
1915 if (val == 0) {
1916 if (delete_immediately) {
1917 if (last == NULL) {
1918 set_dependencies(b->next());
1919 } else {
1920 last->set_next(b->next());
1921 }
1922 delete b;
1923 } else {
1924 set_has_unloaded_dependent(true);
1925 }
1926 }
1927 return;
1928 }
1929 last = b;
1930 }
1931 #ifdef ASSERT
1932 tty->print_raw_cr("### can't find dependent nmethod");
1933 nm->print();
1934 #endif // ASSERT
1935 ShouldNotReachHere();
1936 }
1937
1938 //
1939 // Reclaim all unused buckets.
1940 //
1941 void DependencyContext::purge() {
1942 assert_locked_or_safepoint(CodeCache_lock);
1943 if (!has_unloaded_dependent()) {
1944 assert(!has_stale_entries(), "inconsistent info");
1945 return;
1946 }
1947 nmethodBucket* first = dependencies();
1948 nmethodBucket* last = NULL;
1949 for (nmethodBucket* b = first; b != NULL;) {
1950 assert(b->count() >= 0, "bucket count: %d", b->count());
1951 nmethodBucket* next = b->next();
1952 if (b->count() == 0) {
1953 if (last == NULL) {
1954 first = next;
1955 } else {
1956 last->set_next(next);
1957 }
1958 delete b;
1959 // last stays the same.
1960 } else {
1961 last = b;
1962 }
1963 b = next;
1964 }
1965 set_dependencies(first);
1966 set_has_unloaded_dependent(false);
1967 }
1968
1969 int DependencyContext::clear() {
1970 nmethodBucket* b = dependencies();
1971 set_dependencies(NULL);
1972 int marked = 0;
1973 while (b != NULL) {
1974 nmethod* nm = b->get_nmethod();
1975 if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization()) {
1976 nm->mark_for_deoptimization();
1977 marked++;
1978 }
1979 nmethodBucket* next = b->next();
1980 delete b;
1981 b = next;
1982 }
1983 set_has_unloaded_dependent(false);
1984 return marked;
1985 }
1986
1987 #ifndef PRODUCT
1988 void DependencyContext::print_dependent_nmethods(bool verbose) {
1989 int idx = 0;
1990 for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {
1991 nmethod* nm = b->get_nmethod();
1992 tty->print("[%d] count=%d { ", idx++, b->count());
1993 if (!verbose) {
1994 nm->print_on(tty, "nmethod");
1995 tty->print_cr(" } ");
1996 } else {
1997 nm->print();
1998 nm->print_dependencies();
1999 tty->print_cr("--- } ");
2000 }
2001 }
2002 }
2003
2004 bool DependencyContext::is_dependent_nmethod(nmethod* nm) {
2005 for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {
2006 if (nm == b->get_nmethod()) {
2007 #ifdef ASSERT
2008 int count = b->count();
2009 assert(count >= 0, "count shouldn't be negative: %d", count);
2010 #endif
2011 return true;
2012 }
2013 }
2014 return false;
2015 }
2016
2017 bool DependencyContext::has_stale_entries() {
2018 for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {
2019 if (b->count() == 0) return true;
2020 }
2021 return false;
2022 }
2023
2024 void DependencyContext::wipe() {
2025 nmethodBucket* b = dependencies();
2026 set_dependencies(NULL);
2027 set_has_unloaded_dependent(false);
2028 while (b != NULL) {
2029 nmethodBucket* next = b->next();
2030 delete b;
2031 b = next;
2032 }
2033 }
2034
2035 #endif //PRODUCT
2036
2037 int InstanceKlass::mark_dependent_nmethods(DepChange& changes) {
2038 DependencyContext dep_context(&_dep_context);
2039 return dep_context.mark_dependent_nmethods(changes);
2040 }
2041
2042 void InstanceKlass::add_dependent_nmethod(nmethod* nm) {
2043 DependencyContext dep_context(&_dep_context);
2044 dep_context.add_dependent_nmethod(nm);
2045 }
2046
2047 void InstanceKlass::remove_dependent_nmethod(nmethod* nm, bool delete_immediately) {
2048 DependencyContext dep_context(&_dep_context);
2049 dep_context.remove_dependent_nmethod(nm, delete_immediately);
2050 }
2051
2052 void InstanceKlass::clean_dependent_nmethods() {
2053 DependencyContext dep_context(&_dep_context);
2054 dep_context.purge();
2055 }
2056
2057 #ifndef PRODUCT
2058 void InstanceKlass::print_dependent_nmethods(bool verbose) {
2059 DependencyContext dep_context(&_dep_context);
2060 dep_context.print_dependent_nmethods(verbose);
2061 }
2062
2063 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
2064 DependencyContext dep_context(&_dep_context);
2065 return dep_context.is_dependent_nmethod(nm);
2066 }
2067 #endif //PRODUCT
2068
2069 void InstanceKlass::clean_weak_instanceklass_links(BoolObjectClosure* is_alive) {
2070 clean_implementors_list(is_alive);
2071 clean_method_data(is_alive);
2072 clean_dependent_nmethods();
2073 }
2074
2075 void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) {
2076 assert(class_loader_data()->is_alive(is_alive), "this klass should be live");
2077 if (is_interface()) {
2078 if (ClassUnloading) {
2079 Klass* impl = implementor();
2080 if (impl != NULL) {
2081 if (!impl->is_loader_alive(is_alive)) {
2082 // remove this guy
2083 Klass** klass = adr_implementor();
2084 assert(klass != NULL, "null klass");
2085 if (klass != NULL) {
2086 *klass = NULL;
2087 }
2088 }
2089 }
2090 }
2091 }
2099 }
2100 }
2101 }
2102
2103
2104 static void remove_unshareable_in_class(Klass* k) {
2105 // remove klass's unshareable info
2106 k->remove_unshareable_info();
2107 }
2108
2109 void InstanceKlass::remove_unshareable_info() {
2110 Klass::remove_unshareable_info();
2111 // Unlink the class
2112 if (is_linked()) {
2113 unlink_class();
2114 }
2115 init_implementor();
2116
2117 constants()->remove_unshareable_info();
2118
2119 assert(_dep_context == DependencyContext::EMPTY, "dependency context is not shareable");
2120
2121 for (int i = 0; i < methods()->length(); i++) {
2122 Method* m = methods()->at(i);
2123 m->remove_unshareable_info();
2124 }
2125
2126 // do array classes also.
2127 array_klasses_do(remove_unshareable_in_class);
2128 }
2129
2130 static void restore_unshareable_in_class(Klass* k, TRAPS) {
2131 // Array classes have null protection domain.
2132 // --> see ArrayKlass::complete_create_array_klass()
2133 k->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK);
2134 }
2135
2136 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
2137 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
2138 instanceKlassHandle ik(THREAD, this);
2139
2140 Array<Method*>* methods = ik->methods();
2230 set_jni_ids(NULL);
2231
2232 jmethodID* jmeths = methods_jmethod_ids_acquire();
2233 if (jmeths != (jmethodID*)NULL) {
2234 release_set_methods_jmethod_ids(NULL);
2235 FreeHeap(jmeths);
2236 }
2237
2238 // Deallocate MemberNameTable
2239 {
2240 Mutex* lock_or_null = SafepointSynchronize::is_at_safepoint() ? NULL : MemberNameTable_lock;
2241 MutexLockerEx ml(lock_or_null, Mutex::_no_safepoint_check_flag);
2242 MemberNameTable* mnt = member_names();
2243 if (mnt != NULL) {
2244 delete mnt;
2245 set_member_names(NULL);
2246 }
2247 }
2248
2249 // release dependencies
2250 {
2251 DependencyContext dep_ctx(&_dep_context);
2252 int marked = dep_ctx.clear();
2253 assert(marked == 0, "should not contain dependencies");
2254 }
2255
2256 // Deallocate breakpoint records
2257 if (breakpoints() != 0x0) {
2258 methods_do(clear_all_breakpoints);
2259 assert(breakpoints() == 0x0, "should have cleared breakpoints");
2260 }
2261
2262 // deallocate the cached class file
2263 if (_cached_class_file != NULL) {
2264 os::free(_cached_class_file);
2265 _cached_class_file = NULL;
2266 }
2267
2268 // Decrement symbol reference counts associated with the unloaded class.
2269 if (_name != NULL) _name->decrement_refcount();
2270 // unreference array name derived from this class name (arrays of an unloaded
2271 // class can't be referenced anymore).
2272 if (_array_name != NULL) _array_name->decrement_refcount();
2273 if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension);
3576 return NULL; // The version of klass is gone, no method is found
3577 }
3578 Method* method = holder->method_with_orig_idnum(idnum);
3579 return method;
3580 }
3581
3582
3583 jint InstanceKlass::get_cached_class_file_len() {
3584 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
3585 }
3586
3587 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
3588 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
3589 }
3590
3591
3592 /////////////// Unit tests ///////////////
3593
3594 #ifndef PRODUCT
3595
3596 class TestNmethodBucket {
3597 public:
3598 nmethod* _nmethods[3];
3599
3600 intptr_t _dependency_context;
3601
3602 TestNmethodBucket() : _dependency_context(DependencyContext::EMPTY) {
3603 CodeCache_lock->lock_without_safepoint_check();
3604
3605 DependencyContext depContext(&_dependency_context);
3606
3607 _nmethods[0] = reinterpret_cast<nmethod*>(0x8 * 0);
3608 _nmethods[1] = reinterpret_cast<nmethod*>(0x8 * 1);
3609 _nmethods[2] = reinterpret_cast<nmethod*>(0x8 * 2);
3610
3611 depContext.add_dependent_nmethod(_nmethods[2]);
3612 depContext.add_dependent_nmethod(_nmethods[1]);
3613 depContext.add_dependent_nmethod(_nmethods[0]);
3614 }
3615
3616 ~TestNmethodBucket() {
3617 DependencyContext depContext(&_dependency_context);
3618 depContext.wipe();
3619 CodeCache_lock->unlock();
3620 }
3621
3622 static void testRemoveDependentNmethod(int id, bool delete_immediately) {
3623 TestNmethodBucket c;
3624 DependencyContext depContext(&c._dependency_context);
3625 assert(!depContext.has_stale_entries(), "check");
3626
3627 nmethod* nm = c._nmethods[id];
3628 depContext.remove_dependent_nmethod(nm, delete_immediately);
3629
3630 if (!delete_immediately) {
3631 assert(depContext.has_stale_entries(), "check");
3632 assert(depContext.is_dependent_nmethod(nm), "check");
3633 depContext.purge();
3634 }
3635
3636 assert(!depContext.has_stale_entries(), "check");
3637 assert(!depContext.is_dependent_nmethod(nm), "check");
3638 }
3639
3640 static void testRemoveDependentNmethod() {
3641 testRemoveDependentNmethod(0, false);
3642 testRemoveDependentNmethod(1, false);
3643 testRemoveDependentNmethod(2, false);
3644
3645 testRemoveDependentNmethod(0, true);
3646 testRemoveDependentNmethod(1, true);
3647 testRemoveDependentNmethod(2, true);
3648 }
3649
3650 static void test() {
3651 testRemoveDependentNmethod();
3652 }
3653 };
3654
3655 void TestNmethodBucket_test() {
3656 TestNmethodBucket::test();
3657 }
3658
3659 #endif
|