1 /*
2 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "logging/log.hpp"
28 #include "memory/allocation.hpp"
29 #include "memory/resourceArea.hpp"
30 #include "oops/access.inline.hpp"
31 #include "oops/oop.inline.hpp"
32 #include "oops/method.hpp"
33 #include "oops/symbol.hpp"
34 #include "oops/weakHandle.inline.hpp"
35 #include "prims/resolvedMethodTable.hpp"
36 #include "runtime/handles.inline.hpp"
37 #include "runtime/mutexLocker.hpp"
38 #include "runtime/safepointVerifiers.hpp"
39 #include "utilities/hashtable.inline.hpp"
40 #include "utilities/macros.hpp"
41
42
43 oop ResolvedMethodEntry::object() {
44 return literal().resolve();
45 }
46
47 oop ResolvedMethodEntry::object_no_keepalive() {
48 // The AS_NO_KEEPALIVE peeks at the oop without keeping it alive.
49 // This is dangerous in general but is okay if the loaded oop does
50 // not leak out past a thread transition where a safepoint can happen.
51 // A subsequent oop_load without AS_NO_KEEPALIVE (the object() accessor)
52 // keeps the oop alive before doing so.
53 return literal().peek();
54 }
55
56 ResolvedMethodTable::ResolvedMethodTable()
57 : Hashtable<ClassLoaderWeakHandle, mtClass>(_table_size, sizeof(ResolvedMethodEntry)) { }
58
59 oop ResolvedMethodTable::lookup(int index, unsigned int hash, Method* method) {
60 assert_locked_or_safepoint(ResolvedMethodTable_lock);
61 for (ResolvedMethodEntry* p = bucket(index); p != NULL; p = p->next()) {
62 if (p->hash() == hash) {
63
64 // Peek the object to check if it is the right target.
65 oop target = p->object_no_keepalive();
66
67 // The method is in the table as a target already
68 if (target != NULL && java_lang_invoke_ResolvedMethodName::vmtarget(target) == method) {
69 ResourceMark rm;
70 log_debug(membername, table) ("ResolvedMethod entry found for %s index %d",
71 method->name_and_sig_as_C_string(), index);
72 // The object() accessor makes sure the target object is kept alive before
73 // leaking out.
74 return p->object();
75 }
76 }
77 }
78 return NULL;
79 }
80
81 unsigned int ResolvedMethodTable::compute_hash(Method* method) {
82 unsigned int name_hash = method->name()->identity_hash();
83 unsigned int signature_hash = method->signature()->identity_hash();
84 return name_hash ^ signature_hash;
85 }
86
87
88 oop ResolvedMethodTable::lookup(Method* method) {
89 unsigned int hash = compute_hash(method);
90 int index = hash_to_index(hash);
91 return lookup(index, hash, method);
92 }
93
94 oop ResolvedMethodTable::basic_add(Method* method, Handle rmethod_name) {
95 assert_locked_or_safepoint(ResolvedMethodTable_lock);
96
97 unsigned int hash = compute_hash(method);
98 int index = hash_to_index(hash);
99
100 // One was added while aquiring the lock
101 oop entry = lookup(index, hash, method);
102 if (entry != NULL) {
103 return entry;
104 }
105
106 ClassLoaderWeakHandle w = ClassLoaderWeakHandle::create(rmethod_name);
107 ResolvedMethodEntry* p = (ResolvedMethodEntry*) Hashtable<ClassLoaderWeakHandle, mtClass>::new_entry(hash, w);
108 Hashtable<ClassLoaderWeakHandle, mtClass>::add_entry(index, p);
109 ResourceMark rm;
110 log_debug(membername, table) ("ResolvedMethod entry added for %s index %d",
111 method->name_and_sig_as_C_string(), index);
112 return rmethod_name();
113 }
114
115 ResolvedMethodTable* ResolvedMethodTable::_the_table = NULL;
116
117 oop ResolvedMethodTable::find_method(Method* method) {
118 MutexLocker ml(ResolvedMethodTable_lock);
119 oop entry = _the_table->lookup(method);
120 return entry;
121 }
122
123 oop ResolvedMethodTable::add_method(Handle resolved_method_name) {
124 MutexLocker ml(ResolvedMethodTable_lock);
125 DEBUG_ONLY(NoSafepointVerifier nsv);
126
127 // Check if method has been redefined while taking out ResolvedMethodTable_lock, if so
128 // use new method.
129 Method* method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method_name());
130 assert(method->is_method(), "must be method");
131 if (method->is_old()) {
132 // Replace method with redefined version
133 InstanceKlass* holder = method->method_holder();
134 method = holder->method_with_idnum(method->method_idnum());
135 java_lang_invoke_ResolvedMethodName::set_vmtarget(resolved_method_name(), method);
136 }
137 // Set flag in class to indicate this InstanceKlass has entries in the table
138 // to avoid walking table during redefinition if none of the redefined classes
139 // have any membernames in the table.
140 method->method_holder()->set_has_resolved_methods();
141
142 return _the_table->basic_add(method, resolved_method_name);
143 }
144
145 // Removing entries
146 int ResolvedMethodTable::_oops_removed = 0;
147 int ResolvedMethodTable::_oops_counted = 0;
148
149 // There are no dead entries at start
150 bool ResolvedMethodTable::_dead_entries = false;
151
152 void ResolvedMethodTable::trigger_cleanup() {
153 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
154 _dead_entries = true;
155 Service_lock->notify_all();
156 }
157
158 // Serially invoke removed unused oops from the table.
159 // This is done by the ServiceThread after being notified on class unloading
160 void ResolvedMethodTable::unlink() {
161 MutexLocker ml(ResolvedMethodTable_lock);
162 _oops_removed = 0;
163 _oops_counted = 0;
164 for (int i = 0; i < _the_table->table_size(); ++i) {
165 ResolvedMethodEntry** p = _the_table->bucket_addr(i);
166 ResolvedMethodEntry* entry = _the_table->bucket(i);
167 while (entry != NULL) {
168 _oops_counted++;
169 oop l = entry->object_no_keepalive();
170 if (l != NULL) {
171 p = entry->next_addr();
172 } else {
173 // Entry has been removed.
174 _oops_removed++;
175 if (log_is_enabled(Debug, membername, table)) {
176 log_debug(membername, table) ("ResolvedMethod entry removed for index %d", i);
177 }
178 entry->literal().release();
179 *p = entry->next();
180 _the_table->free_entry(entry);
181 }
182 // get next entry
183 entry = (ResolvedMethodEntry*)HashtableEntry<ClassLoaderWeakHandle, mtClass>::make_ptr(*p);
184 }
185 }
186 log_debug(membername, table) ("ResolvedMethod entries counted %d removed %d",
187 _oops_counted, _oops_removed);
188 _dead_entries = false;
189 }
190
191 #ifndef PRODUCT
192 void ResolvedMethodTable::print() {
193 MutexLocker ml(ResolvedMethodTable_lock);
194 for (int i = 0; i < table_size(); ++i) {
195 ResolvedMethodEntry* entry = bucket(i);
196 while (entry != NULL) {
197 tty->print("%d : ", i);
198 oop rmethod_name = entry->object_no_keepalive();
199 if (rmethod_name != NULL) {
200 rmethod_name->print();
201 Method* m = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(rmethod_name);
202 m->print();
203 }
204 entry = entry->next();
205 }
206 }
207 }
208 #endif // PRODUCT
209
210 #if INCLUDE_JVMTI
211 // It is called at safepoint only for RedefineClasses
212 void ResolvedMethodTable::adjust_method_entries(bool * trace_name_printed) {
213 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
214 // For each entry in RMT, change to new method
215 for (int i = 0; i < _the_table->table_size(); ++i) {
216 for (ResolvedMethodEntry* entry = _the_table->bucket(i);
217 entry != NULL;
218 entry = entry->next()) {
219
220 oop mem_name = entry->object_no_keepalive();
221 // except ones removed
222 if (mem_name == NULL) {
223 continue;
224 }
225 Method* old_method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(mem_name);
226
227 if (old_method->is_old()) {
228
229 if (old_method->is_deleted()) {
230 // leave deleted method in ResolvedMethod for now (this is a bug that we don't mark
231 // these on_stack)
232 continue;
233 }
234
235 InstanceKlass* holder = old_method->method_holder();
236 Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());
237 assert(holder == new_method->method_holder(), "call after swapping redefined guts");
238 assert(new_method != NULL, "method_with_idnum() should not be NULL");
239 assert(old_method != new_method, "sanity check");
240
241 java_lang_invoke_ResolvedMethodName::set_vmtarget(mem_name, new_method);
242
243 ResourceMark rm;
244 if (!(*trace_name_printed)) {
245 log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
246 *trace_name_printed = true;
247 }
248 log_debug(redefine, class, update, constantpool)
249 ("ResolvedMethod method update: %s(%s)",
250 new_method->name()->as_C_string(), new_method->signature()->as_C_string());
251 }
252 }
253 }
254 }
255 #endif // INCLUDE_JVMTI