1 /*
2 * Copyright (c) 2017, 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 "gc/shared/gcLocker.hpp"
27 #include "memory/allocation.hpp"
28 #include "oops/oop.inline.hpp"
29 #include "oops/method.hpp"
30 #include "oops/symbol.hpp"
31 #include "prims/resolvedMethodTable.hpp"
32 #include "runtime/handles.inline.hpp"
33 #include "runtime/mutexLocker.hpp"
34 #include "utilities/hashtable.inline.hpp"
35 #include "utilities/macros.hpp"
36 #if INCLUDE_ALL_GCS
37 #include "gc/g1/g1CollectedHeap.hpp"
38 #include "gc/g1/g1SATBCardTableModRefBS.hpp"
39 #include "gc/g1/g1StringDedup.hpp"
40 #endif
41
42
43 ResolvedMethodTable::ResolvedMethodTable()
44 : Hashtable<oop, mtClass>(_table_size, sizeof(ResolvedMethodEntry)) { }
45
46 oop ResolvedMethodTable::lookup(int index, unsigned int hash, Method* method) {
47 for (ResolvedMethodEntry* p = bucket(index); p != NULL; p = p->next()) {
48 if (p->hash() == hash) {
49 oop target = p->literal();
50 // The method is in the table as a target already
51 if (java_lang_invoke_ResolvedMethodName::vmtarget(target) == method) {
52 log_debug(membername, table) ("ResolvedMethod vmtarget entry found for %s index %d",
53 method->name_and_sig_as_C_string(), index);
54 return target;
55 }
56 }
57 }
58 return NULL;
59 }
60
61 unsigned int ResolvedMethodTable::compute_hash(Method* method) {
62 unsigned int name_hash = method->name()->identity_hash();
63 unsigned int signature_hash = method->signature()->identity_hash();
64 return name_hash ^ signature_hash;
65 }
66
67
68 oop ResolvedMethodTable::lookup(Method* method) {
69 unsigned int hash = compute_hash(method);
70 int index = hash_to_index(hash);
71 return lookup(index, hash, method);
72 }
73
74 // Tell the GC that this oop was looked up in the table
75 static void ensure_oop_alive(oop mname) {
76 // A lookup in the ResolvedMethodTable could return an object that was previously
77 // considered dead. The SATB part of G1 needs to get notified about this
78 // potential resurrection, otherwise the marking might not find the object.
79 #if INCLUDE_ALL_GCS
80 if (UseG1GC && mname != NULL) {
81 G1SATBCardTableModRefBS::enqueue(mname);
82 }
83 #endif
84 }
85
86 oop ResolvedMethodTable::basic_add(Method* method, oop vmtarget) {
87 assert_locked_or_safepoint(ResolvedMethodTable_lock);
88
89 unsigned int hash = compute_hash(method);
90 int index = hash_to_index(hash);
91
92 // One was added while aquiring the lock
93 oop entry = lookup(index, hash, method);
94 if (entry != NULL) {
95 ensure_oop_alive(entry);
96 return entry;
97 }
98
99 ResolvedMethodEntry* p = (ResolvedMethodEntry*) Hashtable<oop, mtClass>::new_entry(hash, vmtarget);
100 Hashtable<oop, mtClass>::add_entry(index, p);
101 log_debug(membername, table) ("ResolvedMethod vmtarget entry added for %s index %d",
102 method->name_and_sig_as_C_string(), index);
103 return p->literal();
104 }
105
106 ResolvedMethodTable* ResolvedMethodTable::_the_table = NULL;
107
108 oop ResolvedMethodTable::find_method(Method* vmtarget) {
109 oop entry = _the_table->lookup(vmtarget);
110 ensure_oop_alive(entry);
111 return entry;
112 }
113
114 oop ResolvedMethodTable::add_method(Handle mem_name_target) {
115 MutexLocker ml(ResolvedMethodTable_lock);
116 DEBUG_ONLY(NoSafepointVerifier nsv);
117
118 // Check if method has been redefined while taking out ResolvedMethodTable_lock, if so
119 // use new method.
120 Method* method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(mem_name_target());
121 assert(method->is_method(), "must be method");
122 if (method->is_old()) {
123 // Replace method with redefined version
124 InstanceKlass* holder = method->method_holder();
125 method = holder->method_with_idnum(method->method_idnum());
126 java_lang_invoke_ResolvedMethodName::set_vmtarget(mem_name_target(), method);
127 }
128 // Set flag in class to indicate this InstanceKlass has entries in the table
129 // to avoid walking table during redefinition if none of the redefined classes
130 // have any membernames in the table
131 method->method_holder()->set_has_resolved_methods();
132
133 return _the_table->basic_add(method, mem_name_target());
134 }
135
136 // Removing entries
137 int ResolvedMethodTable::_oops_removed = 0;
138 int ResolvedMethodTable::_oops_counted = 0;
139
140 // Serially invoke "f->do_oop" on the locations of all oops in the table.
141 // or remove deallocated vmtargets from the table
142 // This is done late during GC.
143 void ResolvedMethodTable::unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f) {
144 _oops_removed = 0;
145 _oops_counted = 0;
146 for (int i = 0; i < _the_table->table_size(); ++i) {
147 ResolvedMethodEntry** p = _the_table->bucket_addr(i);
148 ResolvedMethodEntry* entry = _the_table->bucket(i);
149 while (entry != NULL) {
150 _oops_counted++;
151 if (f != NULL) {
152 f->do_oop((oop*)entry->literal_addr());
153 p = entry->next_addr();
154 } else {
155 if (!is_alive->do_object_b(entry->literal())) {
156 _oops_removed++;
157 if (log_is_enabled(Debug, membername, table)) {
158 ResourceMark rm;
159 Method* m = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(entry->literal());
160 log_debug(membername, table) ("ResolvedMethod vmtarget entry removed for %s index %d",
161 m->name_and_sig_as_C_string(), i);
162 }
163 *p = entry->next();
164 _the_table->free_entry(entry);
165 } else {
166 p = entry->next_addr();
167 }
168 }
169 // get next entry
170 entry = (ResolvedMethodEntry*)HashtableEntry<oop, mtClass>::make_ptr(*p);
171 }
172 }
173 }
174
175 #ifndef PRODUCT
176 void ResolvedMethodTable::print() {
177 for (int i = 0; i < table_size(); ++i) {
178 ResolvedMethodEntry* entry = bucket(i);
179 while (entry != NULL) {
180 tty->print("%d : ", i);
181 oop vmtarget = entry->literal();
182 vmtarget->print();
183 Method* m = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(vmtarget);
184 m->print();
185 entry = entry->next();
186 }
187 }
188 }
189 #endif // PRODUCT
190
191 #if INCLUDE_JVMTI
192 // It is called at safepoint only for RedefineClasses
193 void ResolvedMethodTable::adjust_method_entries(bool * trace_name_printed) {
194 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
195 // For each entry in MNT, change to new method
196 for (int i = 0; i < _the_table->table_size(); ++i) {
197 ResolvedMethodEntry* entry = _the_table->bucket(i);
198 while (entry != NULL) {
199
200 oop mem_name = entry->literal();
201 Method* old_method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(mem_name);
202
203 if (old_method->is_old()) {
204
205 if (old_method->is_deleted()) {
206 // leave deleted method in ResolvedMethod for now (this is a bug that we don't mark
207 // these on_stack)
208 continue;
209 }
210
211 InstanceKlass* holder = old_method->method_holder();
212 Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());
213 assert(holder == new_method->method_holder(), "call after swapping redefined guts");
214
215 assert(new_method != NULL, "method_with_idnum() should not be NULL");
216 assert(old_method != new_method, "sanity check");
217
218 java_lang_invoke_ResolvedMethodName::set_vmtarget(mem_name, new_method);
219
220 if (log_is_enabled(Info, redefine, class, update)) {
221 ResourceMark rm;
222 if (!(*trace_name_printed)) {
223 log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
224 *trace_name_printed = true;
225 }
226 log_debug(redefine, class, update, constantpool)
227 ("ResolvedMethod method update: %s(%s)",
228 new_method->name()->as_C_string(), new_method->signature()->as_C_string());
229 }
230 }
231 entry = entry->next();
232 }
233 }
234 }
235 #endif // INCLUDE_JVMTI