1 /*
2 * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2017, 2022, Red Hat, Inc. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "code/codeCache.hpp"
27 #include "code/nmethod.hpp"
28 #include "gc/shared/classUnloadingContext.hpp"
29 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
30 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
31 #include "gc/shenandoah/shenandoahNMethod.inline.hpp"
32 #include "gc/shenandoah/shenandoahStackWatermark.hpp"
33 #include "gc/shenandoah/shenandoahUtils.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "memory/universe.hpp"
36 #include "runtime/atomicAccess.hpp"
37 #include "runtime/icache.hpp"
38 #include "utilities/powerOfTwo.hpp"
39
40
41 ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;
42 int ShenandoahCodeRoots::_disarmed_value = 1;
43
44 void ShenandoahCodeRoots::initialize() {
45 _nmethod_table = new ShenandoahNMethodTable();
46 }
47
48 void ShenandoahCodeRoots::register_nmethod(nmethod* nm) {
49 assert(CodeCache_lock->owned_by_self(), "Must have CodeCache_lock held");
50 _nmethod_table->register_nmethod(nm);
51 }
52
53 void ShenandoahCodeRoots::unregister_nmethod(nmethod* nm) {
54 assert_locked_or_safepoint(CodeCache_lock);
55 _nmethod_table->unregister_nmethod(nm);
56 }
57
58 class ShenandoahNMethodUnlinkClosure : public NMethodClosure {
59 private:
60 bool _unloading_occurred;
61 ShenandoahHeap* const _heap;
62 BarrierSetNMethod* const _bs;
63
64 public:
65 ShenandoahNMethodUnlinkClosure(bool unloading_occurred) :
66 _unloading_occurred(unloading_occurred),
67 _heap(ShenandoahHeap::heap()),
68 _bs(ShenandoahBarrierSet::barrier_set()->barrier_set_nmethod()) {}
69
70 virtual void do_nmethod(nmethod* nm) {
71 assert(_heap->is_concurrent_weak_root_in_progress(), "Only this phase");
72
73 ShenandoahNMethod* nm_data = ShenandoahNMethod::gc_data(nm);
74 assert(!nm_data->is_unregistered(), "Should not see unregistered entry");
75
76 if (nm->is_unloading()) {
77 ShenandoahNMethodLocker locker(nm_data->lock());
78 nm->unlink();
79 return;
80 }
81
82 if (_heap->is_evacuation_in_progress()) {
83 ShenandoahNMethodLocker locker(nm_data->lock());
84
85 // Heal oops
86 if (_bs->is_armed(nm)) {
87 ICacheInvalidationContext icic;
88 ShenandoahNMethod::heal_nmethod_metadata(nm_data, &icic);
89 // Must remain armed to complete remaining work in nmethod entry barrier
90 assert(_bs->is_armed(nm), "Should remain armed");
91 }
92 }
93
94 // Clear compiled ICs and exception caches
95 ShenandoahNMethodLocker locker(nm_data->ic_lock());
96 nm->unload_nmethod_caches(_unloading_occurred);
97 }
98 };
99
100 class ShenandoahUnlinkTask : public WorkerTask {
101 private:
102 ShenandoahNMethodUnlinkClosure _cl;
103 ShenandoahConcurrentNMethodIterator _iterator;
104
105 public:
106 ShenandoahUnlinkTask(bool unloading_occurred) :
107 WorkerTask("Shenandoah Unlink NMethods"),
108 _cl(unloading_occurred),
109 _iterator(ShenandoahCodeRoots::table()) {}
110
111 virtual void work(uint worker_id) {
112 _iterator.nmethods_do(&_cl);
113 }
114 };
115
116 void ShenandoahCodeRoots::unlink(WorkerThreads* workers, bool unloading_occurred) {
117 assert(ShenandoahHeap::heap()->unload_classes(), "Only when running concurrent class unloading");
118
119 ShenandoahUnlinkTask task(unloading_occurred);
120 workers->run_task(&task);
121 }
122
123 void ShenandoahCodeRoots::purge() {
124 assert(ShenandoahHeap::heap()->unload_classes(), "Only when running concurrent class unloading");
125
126 ClassUnloadingContext::context()->purge_and_free_nmethods();
127 }
128
129 ShenandoahCodeRootsIterator::ShenandoahCodeRootsIterator() :
130 _table_snapshot(nullptr) {
131 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint");
132 MutexLocker locker(CodeCache_lock, Mutex::_no_safepoint_check_flag);
133 _table_snapshot = ShenandoahCodeRoots::table()->snapshot_for_iteration();
134 }
135
136 ShenandoahCodeRootsIterator::~ShenandoahCodeRootsIterator() {
137 MonitorLocker locker(CodeCache_lock, Mutex::_no_safepoint_check_flag);
138 ShenandoahCodeRoots::table()->finish_iteration(_table_snapshot);
139 _table_snapshot = nullptr;
140 locker.notify_all();
141 }
142
143 void ShenandoahCodeRootsIterator::possibly_parallel_nmethods_do(NMethodClosure *f) {
144 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint");
145 assert(_table_snapshot != nullptr, "Sanity");
146 _table_snapshot->parallel_nmethods_do(f);
147 }