236   set_has_unloaded_dependent(false);

   236   _dep_context = DependencyContext::EMPTY;

   822   if (this_k->has_default_methods()) {

   824   if (!this_k->is_interface() && this_k->has_default_methods()) {

  1860 int nmethodBucket::decrement() {

  1862 inline DependencyContext InstanceKlass::dependencies() {

  1861   return Atomic::add(-1, (volatile int *)&_count);

  1863   DependencyContext dep_context(&_dep_context);

  1862 }

  1864   return dep_context;

  1863 

  1865 }

  1864 //

  1865 // Walk the list of dependent nmethods searching for nmethods which

  1866 // are dependent on the changes that were passed in and mark them for

  1867 // deoptimization.  Returns the number of nmethods found.

  1868 //

  1869 int nmethodBucket::mark_dependent_nmethods(nmethodBucket* deps, DepChange& changes) {

  1870   assert_locked_or_safepoint(CodeCache_lock);

  1871   int found = 0;

  1872   for (nmethodBucket* b = deps; b != NULL; b = b->next()) {

  1873     nmethod* nm = b->get_nmethod();

  1874     // since dependencies aren't removed until an nmethod becomes a zombie,

  1875     // the dependency list may contain nmethods which aren't alive.

  1876     if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {

  1877       if (TraceDependencies) {

  1878         ResourceMark rm;

  1879         tty->print_cr("Marked for deoptimization");

  1880         changes.print();

  1881         nm->print();

  1882         nm->print_dependencies();

  1883       }

  1884       nm->mark_for_deoptimization();

  1885       found++;

  1886     }

  1887   }

  1888   return found;

  1889 }

  1890 

  1891 //

  1892 // Add an nmethodBucket to the list of dependencies for this nmethod.

  1893 // It's possible that an nmethod has multiple dependencies on this klass

  1894 // so a count is kept for each bucket to guarantee that creation and

  1895 // deletion of dependencies is consistent. Returns new head of the list.

  1896 //

  1897 nmethodBucket* nmethodBucket::add_dependent_nmethod(nmethodBucket* deps, nmethod* nm) {

  1898   assert_locked_or_safepoint(CodeCache_lock);

  1899   for (nmethodBucket* b = deps; b != NULL; b = b->next()) {

  1900     if (nm == b->get_nmethod()) {

  1901       b->increment();

  1902       return deps;

  1903     }

  1904   }

  1905   return new nmethodBucket(nm, deps);

  1906 }

  1907 

  1908 //

  1909 // Decrement count of the nmethod in the dependency list and remove

  1910 // the bucket completely when the count goes to 0.  This method must

  1911 // find a corresponding bucket otherwise there's a bug in the

  1912 // recording of dependencies. Returns true if the bucket was deleted,

  1913 // or marked ready for reclaimation.

  1914 bool nmethodBucket::remove_dependent_nmethod(nmethodBucket** deps, nmethod* nm, bool delete_immediately) {

  1915   assert_locked_or_safepoint(CodeCache_lock);

  1916 

  1917   nmethodBucket* first = *deps;

  1918   nmethodBucket* last = NULL;

  1919 

  1920   for (nmethodBucket* b = first; b != NULL; b = b->next()) {

  1921     if (nm == b->get_nmethod()) {

  1922       int val = b->decrement();

  1923       guarantee(val >= 0, "Underflow: %d", val);

  1924       if (val == 0) {

  1925         if (delete_immediately) {

  1926           if (last == NULL) {

  1927             *deps = b->next();

  1928           } else {

  1929             last->set_next(b->next());

  1930           }

  1931           delete b;

  1932         }

  1933       }

  1934       return true;

  1935     }

  1936     last = b;

  1937   }

  1938 

  1939 #ifdef ASSERT

  1940   tty->print_raw_cr("### can't find dependent nmethod");

  1941   nm->print();

  1942 #endif // ASSERT

  1943   ShouldNotReachHere();

  1944   return false;

  1945 }

  1946 

  1947 // Convenience overload, for callers that don't want to delete the nmethodBucket entry.

  1948 bool nmethodBucket::remove_dependent_nmethod(nmethodBucket* deps, nmethod* nm) {

  1949   nmethodBucket** deps_addr = &deps;

  1950   return remove_dependent_nmethod(deps_addr, nm, false /* Don't delete */);

  1951 }

  1952 

  1953 //

  1954 // Reclaim all unused buckets. Returns new head of the list.

  1955 //

  1956 nmethodBucket* nmethodBucket::clean_dependent_nmethods(nmethodBucket* deps) {

  1957   nmethodBucket* first = deps;

  1958   nmethodBucket* last = NULL;

  1959   nmethodBucket* b = first;

  1960 

  1961   while (b != NULL) {

  1962     assert(b->count() >= 0, "bucket count: %d", b->count());

  1963     nmethodBucket* next = b->next();

  1964     if (b->count() == 0) {

  1965       if (last == NULL) {

  1966         first = next;

  1967       } else {

  1968         last->set_next(next);

  1969       }

  1970       delete b;

  1971       // last stays the same.

  1972     } else {

  1973       last = b;

  1974     }

  1975     b = next;

  1976   }

  1977   return first;

  1978 }

  1979 

  1980 #ifndef PRODUCT

  1981 void nmethodBucket::print_dependent_nmethods(nmethodBucket* deps, bool verbose) {

  1982   int idx = 0;

  1983   for (nmethodBucket* b = deps; b != NULL; b = b->next()) {

  1984     nmethod* nm = b->get_nmethod();

  1985     tty->print("[%d] count=%d { ", idx++, b->count());

  1986     if (!verbose) {

  1987       nm->print_on(tty, "nmethod");

  1988       tty->print_cr(" } ");

  1989     } else {

  1990       nm->print();

  1991       nm->print_dependencies();

  1992       tty->print_cr("--- } ");

  1993     }

  1994   }

  1995 }

  1996 

  1997 bool nmethodBucket::is_dependent_nmethod(nmethodBucket* deps, nmethod* nm) {

  1998   for (nmethodBucket* b = deps; b != NULL; b = b->next()) {

  1999     if (nm == b->get_nmethod()) {

  2000 #ifdef ASSERT

  2001       int count = b->count();

  2002       assert(count >= 0, "count shouldn't be negative: %d", count);

  2003 #endif

  2004       return true;

  2005     }

  2006   }

  2007   return false;

  2008 }

  2009 #endif //PRODUCT

  2012   assert_locked_or_safepoint(CodeCache_lock);

  1868   return dependencies().mark_dependent_nmethods(changes);

  2013   return nmethodBucket::mark_dependent_nmethods(_dependencies, changes);

  2014 }

  2015 

  2016 void InstanceKlass::clean_dependent_nmethods() {

  2017   assert_locked_or_safepoint(CodeCache_lock);

  2018 

  2019   if (has_unloaded_dependent()) {

  2020     _dependencies = nmethodBucket::clean_dependent_nmethods(_dependencies);

  2021     set_has_unloaded_dependent(false);

  2022   }

  2023 #ifdef ASSERT

  2024   else {

  2025     // Verification

  2026     for (nmethodBucket* b = _dependencies; b != NULL; b = b->next()) {

  2027       assert(b->count() >= 0, "bucket count: %d", b->count());

  2028       assert(b->count() != 0, "empty buckets need to be cleaned");

  2029     }

  2030   }

  2031 #endif

  2035   assert_locked_or_safepoint(CodeCache_lock);

  1872   dependencies().add_dependent_nmethod(nm);

  2036   _dependencies = nmethodBucket::add_dependent_nmethod(_dependencies, nm);

  2040   assert_locked_or_safepoint(CodeCache_lock);

  1876   dependencies().remove_dependent_nmethod(nm, delete_immediately);

  2041 

  2042   if (nmethodBucket::remove_dependent_nmethod(&_dependencies, nm, delete_immediately)) {

  2043     set_has_unloaded_dependent(true);

  2044   }

  2049   nmethodBucket::print_dependent_nmethods(_dependencies, verbose);

  1881   dependencies().print_dependent_nmethods(verbose);

  2053   return nmethodBucket::is_dependent_nmethod(_dependencies, nm);

  1885   return dependencies().is_dependent_nmethod(nm);

  2061   clean_dependent_nmethods();

  1893   // Since GC iterates InstanceKlasses sequentially, it is safe to remove stale entries here.

  1894   DependencyContext dep_context(&_dep_context);

  1895   dep_context.expunge_stale_entries();

  2236   // release dependencies

  2072   // Release dependencies.

  2237   nmethodBucket* b = _dependencies;

  2073   // It is desirable to use DC::remove_all_dependents() here, but, unfortunately,

  2238   _dependencies = NULL;

  2074   // it is not safe (see JDK-8143408). The problem is that the klass dependency

  2239   while (b != NULL) {

  2075   // context can contain live dependencies, since there's a race between nmethod &

  2240     nmethodBucket* next = b->next();

  2076   // klass unloading. If the klass is dead when nmethod unloading happens, relevant

  2241     delete b;

  2077   // dependencies aren't removed from the context associated with the class (see

  2242     b = next;

  2078   // nmethod::flush_dependencies). It ends up during klass unloading as seemingly

  2243   }

  2079   // live dependencies pointing to unloaded nmethods and causes a crash in

  2080   // DC::remove_all_dependents() when it touches unloaded nmethod.

  2081   dependencies().wipe();