101 if (entry != NULL) {
102 return entry;
103 }
104
105 ClassLoaderWeakHandle w = ClassLoaderWeakHandle::create(rmethod_name);
106 ResolvedMethodEntry* p = (ResolvedMethodEntry*) Hashtable<ClassLoaderWeakHandle, mtClass>::new_entry(hash, w);
107 Hashtable<ClassLoaderWeakHandle, mtClass>::add_entry(index, p);
108 ResourceMark rm;
109 log_debug(membername, table) ("ResolvedMethod entry added for %s index %d",
110 method->name_and_sig_as_C_string(), index);
111 return rmethod_name();
112 }
113
114 ResolvedMethodTable* ResolvedMethodTable::_the_table = NULL;
115
116 oop ResolvedMethodTable::find_method(Method* method) {
117 oop entry = _the_table->lookup(method);
118 return entry;
119 }
120
121 oop ResolvedMethodTable::add_method(Handle resolved_method_name) {
122 MutexLocker ml(ResolvedMethodTable_lock);
123 DEBUG_ONLY(NoSafepointVerifier nsv);
124
125 // Check if method has been redefined while taking out ResolvedMethodTable_lock, if so
126 // use new method.
127 Method* method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method_name());
128 assert(method->is_method(), "must be method");
129 if (method->is_old()) {
130 // Replace method with redefined version
131 InstanceKlass* holder = method->method_holder();
132 method = holder->method_with_idnum(method->method_idnum());
133 java_lang_invoke_ResolvedMethodName::set_vmtarget(resolved_method_name(), method);
134 }
135 // Set flag in class to indicate this InstanceKlass has entries in the table
136 // to avoid walking table during redefinition if none of the redefined classes
137 // have any membernames in the table.
138 method->method_holder()->set_has_resolved_methods();
139
140 return _the_table->basic_add(method, resolved_method_name);
141 }
142
143 // Removing entries
144 int ResolvedMethodTable::_oops_removed = 0;
145 int ResolvedMethodTable::_oops_counted = 0;
146
147 // Serially invoke removed unused oops from the table.
148 // This is done late during GC.
149 void ResolvedMethodTable::unlink() {
150 _oops_removed = 0;
151 _oops_counted = 0;
152 for (int i = 0; i < _the_table->table_size(); ++i) {
195
196 #if INCLUDE_JVMTI
197 // It is called at safepoint only for RedefineClasses
198 void ResolvedMethodTable::adjust_method_entries(bool * trace_name_printed) {
199 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
200 // For each entry in RMT, change to new method
201 for (int i = 0; i < _the_table->table_size(); ++i) {
202 for (ResolvedMethodEntry* entry = _the_table->bucket(i);
203 entry != NULL;
204 entry = entry->next()) {
205
206 oop mem_name = entry->object_no_keepalive();
207 // except ones removed
208 if (mem_name == NULL) {
209 continue;
210 }
211 Method* old_method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(mem_name);
212
213 if (old_method->is_old()) {
214
215 if (old_method->is_deleted()) {
216 // leave deleted method in ResolvedMethod for now (this is a bug that we don't mark
217 // these on_stack)
218 continue;
219 }
220
221 InstanceKlass* holder = old_method->method_holder();
222 Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());
223 assert(holder == new_method->method_holder(), "call after swapping redefined guts");
224 assert(new_method != NULL, "method_with_idnum() should not be NULL");
225 assert(old_method != new_method, "sanity check");
226
227 java_lang_invoke_ResolvedMethodName::set_vmtarget(mem_name, new_method);
228
229 ResourceMark rm;
230 if (!(*trace_name_printed)) {
231 log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
232 *trace_name_printed = true;
233 }
234 log_debug(redefine, class, update, constantpool)
235 ("ResolvedMethod method update: %s(%s)",
236 new_method->name()->as_C_string(), new_method->signature()->as_C_string());
237 }
238 }
239 }
240 }
241 #endif // INCLUDE_JVMTI
|
101 if (entry != NULL) {
102 return entry;
103 }
104
105 ClassLoaderWeakHandle w = ClassLoaderWeakHandle::create(rmethod_name);
106 ResolvedMethodEntry* p = (ResolvedMethodEntry*) Hashtable<ClassLoaderWeakHandle, mtClass>::new_entry(hash, w);
107 Hashtable<ClassLoaderWeakHandle, mtClass>::add_entry(index, p);
108 ResourceMark rm;
109 log_debug(membername, table) ("ResolvedMethod entry added for %s index %d",
110 method->name_and_sig_as_C_string(), index);
111 return rmethod_name();
112 }
113
114 ResolvedMethodTable* ResolvedMethodTable::_the_table = NULL;
115
116 oop ResolvedMethodTable::find_method(Method* method) {
117 oop entry = _the_table->lookup(method);
118 return entry;
119 }
120
121 oop ResolvedMethodTable::add_method(const methodHandle& m, Handle resolved_method_name) {
122 MutexLocker ml(ResolvedMethodTable_lock);
123 DEBUG_ONLY(NoSafepointVerifier nsv);
124
125 Method* method = m();
126 // Check if method has been redefined while taking out ResolvedMethodTable_lock, if so
127 // use new method. The old method won't be deallocated because it's passed in as a Handle.
128 if (method->is_old()) {
129 // Replace method with redefined version
130 InstanceKlass* holder = method->method_holder();
131 method = holder->method_with_idnum(method->method_idnum());
132 if (method == NULL) {
133 // Replace deleted method with NSME.
134 method = Universe::throw_no_such_method_error();
135 }
136 java_lang_invoke_ResolvedMethodName::set_vmtarget(resolved_method_name(), method);
137 }
138 // Set flag in class to indicate this InstanceKlass has entries in the table
139 // to avoid walking table during redefinition if none of the redefined classes
140 // have any membernames in the table.
141 method->method_holder()->set_has_resolved_methods();
142
143 return _the_table->basic_add(method, resolved_method_name);
144 }
145
146 // Removing entries
147 int ResolvedMethodTable::_oops_removed = 0;
148 int ResolvedMethodTable::_oops_counted = 0;
149
150 // Serially invoke removed unused oops from the table.
151 // This is done late during GC.
152 void ResolvedMethodTable::unlink() {
153 _oops_removed = 0;
154 _oops_counted = 0;
155 for (int i = 0; i < _the_table->table_size(); ++i) {
198
199 #if INCLUDE_JVMTI
200 // It is called at safepoint only for RedefineClasses
201 void ResolvedMethodTable::adjust_method_entries(bool * trace_name_printed) {
202 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
203 // For each entry in RMT, change to new method
204 for (int i = 0; i < _the_table->table_size(); ++i) {
205 for (ResolvedMethodEntry* entry = _the_table->bucket(i);
206 entry != NULL;
207 entry = entry->next()) {
208
209 oop mem_name = entry->object_no_keepalive();
210 // except ones removed
211 if (mem_name == NULL) {
212 continue;
213 }
214 Method* old_method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(mem_name);
215
216 if (old_method->is_old()) {
217
218 Method* new_method;
219 if (old_method->is_deleted()) {
220 new_method = Universe::throw_no_such_method_error();
221 } else {
222 InstanceKlass* holder = old_method->method_holder();
223 new_method = holder->method_with_idnum(old_method->orig_method_idnum());
224 assert(holder == new_method->method_holder(), "call after swapping redefined guts");
225 assert(new_method != NULL, "method_with_idnum() should not be NULL");
226 assert(old_method != new_method, "sanity check");
227 }
228
229 java_lang_invoke_ResolvedMethodName::set_vmtarget(mem_name, new_method);
230
231 ResourceMark rm;
232 if (!(*trace_name_printed)) {
233 log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
234 *trace_name_printed = true;
235 }
236 log_debug(redefine, class, update, constantpool)
237 ("ResolvedMethod method update: %s(%s)",
238 new_method->name()->as_C_string(), new_method->signature()->as_C_string());
239 }
240 }
241 }
242 }
243 #endif // INCLUDE_JVMTI
|