1 /*
2 * Copyright (c) 1998, 2019, 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/resolutionErrors.hpp"
27 #include "interpreter/bytecodeStream.hpp"
28 #include "interpreter/bytecodes.hpp"
29 #include "interpreter/interpreter.hpp"
30 #include "interpreter/linkResolver.hpp"
31 #include "interpreter/rewriter.hpp"
32 #include "logging/log.hpp"
33 #include "memory/heapShared.hpp"
34 #include "memory/metadataFactory.hpp"
35 #include "memory/metaspaceClosure.hpp"
36 #include "memory/metaspaceShared.hpp"
37 #include "memory/resourceArea.hpp"
38 #include "memory/universe.hpp"
39 #include "oops/access.inline.hpp"
40 #include "oops/constantPool.inline.hpp"
41 #include "oops/cpCache.inline.hpp"
42 #include "oops/objArrayOop.inline.hpp"
43 #include "oops/oop.inline.hpp"
44 #include "prims/methodHandles.hpp"
45 #include "runtime/atomic.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "runtime/orderAccess.hpp"
48 #include "utilities/macros.hpp"
49
50 // Implementation of ConstantPoolCacheEntry
51
52 void ConstantPoolCacheEntry::initialize_entry(int index) {
53 assert(0 < index && index < 0x10000, "sanity check");
54 _indices = index;
55 _f1 = NULL;
56 _f2 = _flags = 0;
57 assert(constant_pool_index() == index, "");
58 }
59
60 void ConstantPoolCacheEntry::verify_just_initialized(bool f2_used) {
61 assert((_indices & (~cp_index_mask)) == 0, "sanity");
62 assert(_f1 == NULL, "sanity");
63 assert(_flags == 0, "sanity");
64 if (!f2_used) {
65 assert(_f2 == 0, "sanity");
66 }
67 }
68
69 void ConstantPoolCacheEntry::reinitialize(bool f2_used) {
70 _indices &= cp_index_mask;
71 _f1 = NULL;
72 _flags = 0;
73 if (!f2_used) {
74 _f2 = 0;
75 }
76 }
77
78 int ConstantPoolCacheEntry::make_flags(TosState state,
79 int option_bits,
80 int field_index_or_method_params) {
81 assert(state < number_of_states, "Invalid state in make_flags");
82 int f = ((int)state << tos_state_shift) | option_bits | field_index_or_method_params;
83 // Preserve existing flag bit values
84 // The low bits are a field offset, or else the method parameter size.
85 #ifdef ASSERT
86 TosState old_state = flag_state();
87 assert(old_state == (TosState)0 || old_state == state,
88 "inconsistent cpCache flags state");
89 #endif
90 return (_flags | f) ;
91 }
92
93 void ConstantPoolCacheEntry::set_bytecode_1(Bytecodes::Code code) {
94 #ifdef ASSERT
95 // Read once.
96 volatile Bytecodes::Code c = bytecode_1();
97 assert(c == 0 || c == code || code == 0, "update must be consistent");
98 #endif
99 // Need to flush pending stores here before bytecode is written.
100 OrderAccess::release_store(&_indices, _indices | ((u_char)code << bytecode_1_shift));
101 }
102
103 void ConstantPoolCacheEntry::set_bytecode_2(Bytecodes::Code code) {
104 #ifdef ASSERT
105 // Read once.
106 volatile Bytecodes::Code c = bytecode_2();
107 assert(c == 0 || c == code || code == 0, "update must be consistent");
108 #endif
109 // Need to flush pending stores here before bytecode is written.
110 OrderAccess::release_store(&_indices, _indices | ((u_char)code << bytecode_2_shift));
111 }
112
113 // Sets f1, ordering with previous writes.
114 void ConstantPoolCacheEntry::release_set_f1(Metadata* f1) {
115 assert(f1 != NULL, "");
116 OrderAccess::release_store(&_f1, f1);
117 }
118
119 void ConstantPoolCacheEntry::set_indy_resolution_failed() {
120 OrderAccess::release_store(&_flags, _flags | (1 << indy_resolution_failed_shift));
121 }
122
123 // Note that concurrent update of both bytecodes can leave one of them
124 // reset to zero. This is harmless; the interpreter will simply re-resolve
125 // the damaged entry. More seriously, the memory synchronization is needed
126 // to flush other fields (f1, f2) completely to memory before the bytecodes
127 // are updated, lest other processors see a non-zero bytecode but zero f1/f2.
128 void ConstantPoolCacheEntry::set_field(Bytecodes::Code get_code,
129 Bytecodes::Code put_code,
130 Klass* field_holder,
131 int field_index,
132 int field_offset,
133 TosState field_type,
134 bool is_final,
135 bool is_volatile,
136 bool is_flattened,
137 bool is_flattenable,
138 Klass* root_klass) {
139 set_f1(field_holder);
140 set_f2(field_offset);
141 assert((field_index & field_index_mask) == field_index,
142 "field index does not fit in low flag bits");
143 assert(!is_flattened || is_flattenable, "Sanity check");
144 set_field_flags(field_type,
145 ((is_volatile ? 1 : 0) << is_volatile_shift) |
146 ((is_final ? 1 : 0) << is_final_shift) |
147 ((is_flattened ? 1 : 0) << is_flattened_field_shift) |
148 ((is_flattenable ? 1 : 0) << is_flattenable_field_shift),
149 field_index);
150 set_bytecode_1(get_code);
151 set_bytecode_2(put_code);
152 NOT_PRODUCT(verify(tty));
153 }
154
155 void ConstantPoolCacheEntry::set_parameter_size(int value) {
156 // This routine is called only in corner cases where the CPCE is not yet initialized.
157 // See AbstractInterpreter::deopt_continue_after_entry.
158 assert(_flags == 0 || parameter_size() == 0 || parameter_size() == value,
159 "size must not change: parameter_size=%d, value=%d", parameter_size(), value);
160 // Setting the parameter size by itself is only safe if the
161 // current value of _flags is 0, otherwise another thread may have
162 // updated it and we don't want to overwrite that value. Don't
163 // bother trying to update it once it's nonzero but always make
164 // sure that the final parameter size agrees with what was passed.
165 if (_flags == 0) {
166 intx newflags = (value & parameter_size_mask);
167 Atomic::cmpxchg(newflags, &_flags, (intx)0);
168 }
169 guarantee(parameter_size() == value,
170 "size must not change: parameter_size=%d, value=%d", parameter_size(), value);
171 }
172
173 void ConstantPoolCacheEntry::set_direct_or_vtable_call(Bytecodes::Code invoke_code,
174 const methodHandle& method,
175 int vtable_index,
176 bool sender_is_interface) {
177 bool is_vtable_call = (vtable_index >= 0); // FIXME: split this method on this boolean
178 assert(method->interpreter_entry() != NULL, "should have been set at this point");
179 assert(!method->is_obsolete(), "attempt to write obsolete method to cpCache");
180
181 int byte_no = -1;
182 bool change_to_virtual = false;
183 InstanceKlass* holder = NULL; // have to declare this outside the switch
184 switch (invoke_code) {
185 case Bytecodes::_invokeinterface:
186 holder = method->method_holder();
187 // check for private interface method invocations
188 if (vtable_index == Method::nonvirtual_vtable_index && holder->is_interface() ) {
189 assert(method->is_private(), "unexpected non-private method");
190 assert(method->can_be_statically_bound(), "unexpected non-statically-bound method");
191 // set_f2_as_vfinal_method checks if is_vfinal flag is true.
192 set_method_flags(as_TosState(method->result_type()),
193 ( 1 << is_vfinal_shift) |
194 ((method->is_final_method() ? 1 : 0) << is_final_shift),
195 method()->size_of_parameters());
196 set_f2_as_vfinal_method(method());
197 byte_no = 2;
198 set_f1(holder); // interface klass*
199 break;
200 }
201 else {
202 // We get here from InterpreterRuntime::resolve_invoke when an invokeinterface
203 // instruction links to a non-interface method (in Object). This can happen when
204 // an interface redeclares an Object method (like CharSequence declaring toString())
205 // or when invokeinterface is used explicitly.
206 // In that case, the method has no itable index and must be invoked as a virtual.
207 // Set a flag to keep track of this corner case.
208 assert(holder->is_interface() || holder == SystemDictionary::Object_klass(), "unexpected holder class");
209 assert(method->is_public(), "Calling non-public method in Object with invokeinterface");
210 change_to_virtual = true;
211
212 // ...and fall through as if we were handling invokevirtual:
213 }
214 case Bytecodes::_invokevirtual:
215 {
216 if (!is_vtable_call) {
217 assert(method->can_be_statically_bound(), "");
218 // set_f2_as_vfinal_method checks if is_vfinal flag is true.
219 set_method_flags(as_TosState(method->result_type()),
220 ( 1 << is_vfinal_shift) |
221 ((method->is_final_method() ? 1 : 0) << is_final_shift) |
222 ((change_to_virtual ? 1 : 0) << is_forced_virtual_shift),
223 method()->size_of_parameters());
224 set_f2_as_vfinal_method(method());
225 } else {
226 assert(!method->can_be_statically_bound(), "");
227 assert(vtable_index >= 0, "valid index");
228 assert(!method->is_final_method(), "sanity");
229 set_method_flags(as_TosState(method->result_type()),
230 ((change_to_virtual ? 1 : 0) << is_forced_virtual_shift),
231 method()->size_of_parameters());
232 set_f2(vtable_index);
233 }
234 byte_no = 2;
235 break;
236 }
237
238 case Bytecodes::_invokespecial:
239 case Bytecodes::_invokestatic:
240 assert(!is_vtable_call, "");
241 // Note: Read and preserve the value of the is_vfinal flag on any
242 // invokevirtual bytecode shared with this constant pool cache entry.
243 // It is cheap and safe to consult is_vfinal() at all times.
244 // Once is_vfinal is set, it must stay that way, lest we get a dangling oop.
245 set_method_flags(as_TosState(method->result_type()),
246 ((is_vfinal() ? 1 : 0) << is_vfinal_shift) |
247 ((method->is_final_method() ? 1 : 0) << is_final_shift),
248 method()->size_of_parameters());
249 set_f1(method());
250 byte_no = 1;
251 break;
252 default:
253 ShouldNotReachHere();
254 break;
255 }
256
257 // Note: byte_no also appears in TemplateTable::resolve.
258 if (byte_no == 1) {
259 assert(invoke_code != Bytecodes::_invokevirtual &&
260 invoke_code != Bytecodes::_invokeinterface, "");
261 bool do_resolve = true;
262 // Don't mark invokespecial to method as resolved if sender is an interface. The receiver
263 // has to be checked that it is a subclass of the current class every time this bytecode
264 // is executed.
265 if (invoke_code == Bytecodes::_invokespecial && sender_is_interface &&
266 method->name() != vmSymbols::object_initializer_name()) {
267 do_resolve = false;
268 }
269 // Don't mark invokestatic to method as resolved if the holder class has not yet completed
270 // initialization. An invokestatic must only proceed if the class is initialized, but if
271 // we resolve it before then that class initialization check is skipped.
272 if (invoke_code == Bytecodes::_invokestatic && !method->method_holder()->is_initialized()) {
273 do_resolve = false;
274 }
275 if (do_resolve) {
276 set_bytecode_1(invoke_code);
277 }
278 } else if (byte_no == 2) {
279 if (change_to_virtual) {
280 assert(invoke_code == Bytecodes::_invokeinterface, "");
281 // NOTE: THIS IS A HACK - BE VERY CAREFUL!!!
282 //
283 // Workaround for the case where we encounter an invokeinterface, but we
284 // should really have an _invokevirtual since the resolved method is a
285 // virtual method in java.lang.Object. This is a corner case in the spec
286 // but is presumably legal. javac does not generate this code.
287 //
288 // We do not set bytecode_1() to _invokeinterface, because that is the
289 // bytecode # used by the interpreter to see if it is resolved. In this
290 // case, the method gets reresolved with caller for each interface call
291 // because the actual selected method may not be public.
292 //
293 // We set bytecode_2() to _invokevirtual.
294 // See also interpreterRuntime.cpp. (8/25/2000)
295 invoke_code = Bytecodes::_invokevirtual;
296 } else {
297 assert(invoke_code == Bytecodes::_invokevirtual ||
298 (invoke_code == Bytecodes::_invokeinterface &&
299 ((method->is_private() ||
300 (method->is_final() && method->method_holder() == SystemDictionary::Object_klass())))),
301 "unexpected invocation mode");
302 if (invoke_code == Bytecodes::_invokeinterface &&
303 (method->is_private() || method->is_final())) {
304 // We set bytecode_1() to _invokeinterface, because that is the
305 // bytecode # used by the interpreter to see if it is resolved.
306 // We set bytecode_2() to _invokevirtual.
307 set_bytecode_1(invoke_code);
308 }
309 }
310 // set up for invokevirtual, even if linking for invokeinterface also:
311 set_bytecode_2(invoke_code);
312 } else {
313 ShouldNotReachHere();
314 }
315 NOT_PRODUCT(verify(tty));
316 }
317
318 void ConstantPoolCacheEntry::set_direct_call(Bytecodes::Code invoke_code, const methodHandle& method,
319 bool sender_is_interface) {
320 int index = Method::nonvirtual_vtable_index;
321 // index < 0; FIXME: inline and customize set_direct_or_vtable_call
322 set_direct_or_vtable_call(invoke_code, method, index, sender_is_interface);
323 }
324
325 void ConstantPoolCacheEntry::set_vtable_call(Bytecodes::Code invoke_code, const methodHandle& method, int index) {
326 // either the method is a miranda or its holder should accept the given index
327 assert(method->method_holder()->is_interface() || method->method_holder()->verify_vtable_index(index), "");
328 // index >= 0; FIXME: inline and customize set_direct_or_vtable_call
329 set_direct_or_vtable_call(invoke_code, method, index, false);
330 }
331
332 void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code,
333 Klass* referenced_klass,
334 const methodHandle& method, int index) {
335 assert(method->method_holder()->verify_itable_index(index), "");
336 assert(invoke_code == Bytecodes::_invokeinterface, "");
337 InstanceKlass* interf = method->method_holder();
338 assert(interf->is_interface(), "must be an interface");
339 assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here");
340 set_f1(referenced_klass);
341 set_f2((intx)method());
342 set_method_flags(as_TosState(method->result_type()),
343 0, // no option bits
344 method()->size_of_parameters());
345 set_bytecode_1(Bytecodes::_invokeinterface);
346 }
347
348
349 void ConstantPoolCacheEntry::set_method_handle(const constantPoolHandle& cpool, const CallInfo &call_info) {
350 set_method_handle_common(cpool, Bytecodes::_invokehandle, call_info);
351 }
352
353 void ConstantPoolCacheEntry::set_dynamic_call(const constantPoolHandle& cpool, const CallInfo &call_info) {
354 set_method_handle_common(cpool, Bytecodes::_invokedynamic, call_info);
355 }
356
357 void ConstantPoolCacheEntry::set_method_handle_common(const constantPoolHandle& cpool,
358 Bytecodes::Code invoke_code,
359 const CallInfo &call_info) {
360 // NOTE: This CPCE can be the subject of data races.
361 // There are three words to update: flags, refs[f2], f1 (in that order).
362 // Writers must store all other values before f1.
363 // Readers must test f1 first for non-null before reading other fields.
364 // Competing writers must acquire exclusive access via a lock.
365 // A losing writer waits on the lock until the winner writes f1 and leaves
366 // the lock, so that when the losing writer returns, he can use the linked
367 // cache entry.
368
369 objArrayHandle resolved_references(Thread::current(), cpool->resolved_references());
370 // Use the resolved_references() lock for this cpCache entry.
371 // resolved_references are created for all classes with Invokedynamic, MethodHandle
372 // or MethodType constant pool cache entries.
373 assert(resolved_references() != NULL,
374 "a resolved_references array should have been created for this class");
375 ObjectLocker ol(resolved_references, Thread::current());
376 if (!is_f1_null()) {
377 return;
378 }
379
380 if (indy_resolution_failed()) {
381 // Before we got here, another thread got a LinkageError exception during
382 // resolution. Ignore our success and throw their exception.
383 ConstantPoolCache* cpCache = cpool->cache();
384 int index = -1;
385 for (int i = 0; i < cpCache->length(); i++) {
386 if (cpCache->entry_at(i) == this) {
387 index = i;
388 break;
389 }
390 }
391 guarantee(index >= 0, "Didn't find cpCache entry!");
392 int encoded_index = ResolutionErrorTable::encode_cpcache_index(
393 ConstantPool::encode_invokedynamic_index(index));
394 Thread* THREAD = Thread::current();
395 ConstantPool::throw_resolution_error(cpool, encoded_index, THREAD);
396 return;
397 }
398
399 const methodHandle adapter = call_info.resolved_method();
400 const Handle appendix = call_info.resolved_appendix();
401 const bool has_appendix = appendix.not_null();
402
403 // Write the flags.
404 // MHs and indy are always sig-poly and have a local signature.
405 set_method_flags(as_TosState(adapter->result_type()),
406 ((has_appendix ? 1 : 0) << has_appendix_shift ) |
407 ( 1 << has_local_signature_shift ) |
408 ( 1 << is_final_shift ),
409 adapter->size_of_parameters());
410
411 if (TraceInvokeDynamic) {
412 ttyLocker ttyl;
413 tty->print_cr("set_method_handle bc=%d appendix=" PTR_FORMAT "%s method=" PTR_FORMAT " (local signature) ",
414 invoke_code,
415 p2i(appendix()),
416 (has_appendix ? "" : " (unused)"),
417 p2i(adapter()));
418 adapter->print();
419 if (has_appendix) appendix()->print();
420 }
421
422 // Method handle invokes and invokedynamic sites use both cp cache words.
423 // refs[f2], if not null, contains a value passed as a trailing argument to the adapter.
424 // In the general case, this could be the call site's MethodType,
425 // for use with java.lang.Invokers.checkExactType, or else a CallSite object.
426 // f1 contains the adapter method which manages the actual call.
427 // In the general case, this is a compiled LambdaForm.
428 // (The Java code is free to optimize these calls by binding other
429 // sorts of methods and appendices to call sites.)
430 // JVM-level linking is via f1, as if for invokespecial, and signatures are erased.
431 // The appendix argument (if any) is added to the signature, and is counted in the parameter_size bits.
432 // Even with the appendix, the method will never take more than 255 parameter slots.
433 //
434 // This means that given a call site like (List)mh.invoke("foo"),
435 // the f1 method has signature '(Ljl/Object;Ljl/invoke/MethodType;)Ljl/Object;',
436 // not '(Ljava/lang/String;)Ljava/util/List;'.
437 // The fact that String and List are involved is encoded in the MethodType in refs[f2].
438 // This allows us to create fewer Methods, while keeping type safety.
439 //
440
441 // Store appendix, if any.
442 if (has_appendix) {
443 const int appendix_index = f2_as_index();
444 assert(appendix_index >= 0 && appendix_index < resolved_references->length(), "oob");
445 assert(resolved_references->obj_at(appendix_index) == NULL, "init just once");
446 resolved_references->obj_at_put(appendix_index, appendix());
447 }
448
449 release_set_f1(adapter()); // This must be the last one to set (see NOTE above)!
450
451 // The interpreter assembly code does not check byte_2,
452 // but it is used by is_resolved, method_if_resolved, etc.
453 set_bytecode_1(invoke_code);
454 NOT_PRODUCT(verify(tty));
455 if (TraceInvokeDynamic) {
456 ttyLocker ttyl;
457 this->print(tty, 0);
458 }
459
460 assert(has_appendix == this->has_appendix(), "proper storage of appendix flag");
461 assert(this->has_local_signature(), "proper storage of signature flag");
462 }
463
464 bool ConstantPoolCacheEntry::save_and_throw_indy_exc(
465 const constantPoolHandle& cpool, int cpool_index, int index, constantTag tag, TRAPS) {
466
467 assert(HAS_PENDING_EXCEPTION, "No exception got thrown!");
468 assert(PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass()),
469 "No LinkageError exception");
470
471 // Use the resolved_references() lock for this cpCache entry.
472 // resolved_references are created for all classes with Invokedynamic, MethodHandle
473 // or MethodType constant pool cache entries.
474 objArrayHandle resolved_references(Thread::current(), cpool->resolved_references());
475 assert(resolved_references() != NULL,
476 "a resolved_references array should have been created for this class");
477 ObjectLocker ol(resolved_references, THREAD);
478
479 // if f1 is not null or the indy_resolution_failed flag is set then another
480 // thread either succeeded in resolving the method or got a LinkageError
481 // exception, before this thread was able to record its failure. So, clear
482 // this thread's exception and return false so caller can use the earlier
483 // thread's result.
484 if (!is_f1_null() || indy_resolution_failed()) {
485 CLEAR_PENDING_EXCEPTION;
486 return false;
487 }
488
489 Symbol* error = PENDING_EXCEPTION->klass()->name();
490 Symbol* message = java_lang_Throwable::detail_message(PENDING_EXCEPTION);
491
492 SystemDictionary::add_resolution_error(cpool, index, error, message);
493 set_indy_resolution_failed();
494 return true;
495 }
496
497 Method* ConstantPoolCacheEntry::method_if_resolved(const constantPoolHandle& cpool) {
498 // Decode the action of set_method and set_interface_call
499 Bytecodes::Code invoke_code = bytecode_1();
500 if (invoke_code != (Bytecodes::Code)0) {
501 Metadata* f1 = f1_ord();
502 if (f1 != NULL) {
503 switch (invoke_code) {
504 case Bytecodes::_invokeinterface:
505 assert(f1->is_klass(), "");
506 return klassItable::method_for_itable_index((InstanceKlass*)f1, f2_as_index());
507 case Bytecodes::_invokestatic:
508 case Bytecodes::_invokespecial:
509 assert(!has_appendix(), "");
510 case Bytecodes::_invokehandle:
511 case Bytecodes::_invokedynamic:
512 assert(f1->is_method(), "");
513 return (Method*)f1;
514 default:
515 break;
516 }
517 }
518 }
519 invoke_code = bytecode_2();
520 if (invoke_code != (Bytecodes::Code)0) {
521 switch (invoke_code) {
522 case Bytecodes::_invokevirtual:
523 if (is_vfinal()) {
524 // invokevirtual
525 Method* m = f2_as_vfinal_method();
526 assert(m->is_method(), "");
527 return m;
528 } else {
529 int holder_index = cpool->uncached_klass_ref_index_at(constant_pool_index());
530 if (cpool->tag_at(holder_index).is_klass()) {
531 Klass* klass = cpool->resolved_klass_at(holder_index);
532 return klass->method_at_vtable(f2_as_index());
533 }
534 }
535 break;
536 default:
537 break;
538 }
539 }
540 return NULL;
541 }
542
543
544 oop ConstantPoolCacheEntry::appendix_if_resolved(const constantPoolHandle& cpool) {
545 if (!has_appendix())
546 return NULL;
547 const int ref_index = f2_as_index();
548 objArrayOop resolved_references = cpool->resolved_references();
549 return resolved_references->obj_at(ref_index);
550 }
551
552
553 #if INCLUDE_JVMTI
554
555 void log_adjust(const char* entry_type, Method* old_method, Method* new_method, bool* trace_name_printed) {
556 if (log_is_enabled(Info, redefine, class, update)) {
557 ResourceMark rm;
558 if (!(*trace_name_printed)) {
559 log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
560 *trace_name_printed = true;
561 }
562 log_debug(redefine, class, update, constantpool)
563 ("cpc %s entry update: %s(%s)", entry_type, new_method->name()->as_C_string(), new_method->signature()->as_C_string());
564 }
565 }
566
567 // RedefineClasses() API support:
568 // If this ConstantPoolCacheEntry refers to old_method then update it
569 // to refer to new_method.
570 void ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
571 Method* new_method, bool * trace_name_printed) {
572
573 if (is_vfinal()) {
574 // virtual and final so _f2 contains method ptr instead of vtable index
575 if (f2_as_vfinal_method() == old_method) {
576 // match old_method so need an update
577 // NOTE: can't use set_f2_as_vfinal_method as it asserts on different values
578 _f2 = (intptr_t)new_method;
579 log_adjust("vfinal", old_method, new_method, trace_name_printed);
580 }
581 return;
582 }
583
584 assert (_f1 != NULL, "should not call with uninteresting entry");
585
586 if (!(_f1->is_method())) {
587 // _f1 is a Klass* for an interface, _f2 is the method
588 if (f2_as_interface_method() == old_method) {
589 _f2 = (intptr_t)new_method;
590 log_adjust("interface", old_method, new_method, trace_name_printed);
591 }
592 } else if (_f1 == old_method) {
593 _f1 = new_method;
594 log_adjust("special, static or dynamic", old_method, new_method, trace_name_printed);
595 }
596 }
597
598 // a constant pool cache entry should never contain old or obsolete methods
599 bool ConstantPoolCacheEntry::check_no_old_or_obsolete_entries() {
600 Method* m = get_interesting_method_entry();
601 // return false if m refers to a non-deleted old or obsolete method
602 if (m != NULL) {
603 assert(m->is_valid() && m->is_method(), "m is a valid method");
604 return !m->is_old() && !m->is_obsolete(); // old is always set for old and obsolete
605 } else {
606 return true;
607 }
608 }
609
610 Method* ConstantPoolCacheEntry::get_interesting_method_entry() {
611 if (!is_method_entry()) {
612 // not a method entry so not interesting by default
613 return NULL;
614 }
615 Method* m = NULL;
616 if (is_vfinal()) {
617 // virtual and final so _f2 contains method ptr instead of vtable index
618 m = f2_as_vfinal_method();
619 } else if (is_f1_null()) {
620 // NULL _f1 means this is a virtual entry so also not interesting
621 return NULL;
622 } else {
623 if (!(_f1->is_method())) {
624 // _f1 is a Klass* for an interface
625 m = f2_as_interface_method();
626 } else {
627 m = f1_as_method();
628 }
629 }
630 assert(m != NULL && m->is_method(), "sanity check");
631 if (m == NULL || !m->is_method()) {
632 return NULL;
633 }
634 return m;
635 }
636 #endif // INCLUDE_JVMTI
637
638 void ConstantPoolCacheEntry::print(outputStream* st, int index) const {
639 // print separator
640 if (index == 0) st->print_cr(" -------------");
641 // print entry
642 st->print("%3d (" PTR_FORMAT ") ", index, (intptr_t)this);
643 st->print_cr("[%02x|%02x|%5d]", bytecode_2(), bytecode_1(),
644 constant_pool_index());
645 st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_f1);
646 st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_f2);
647 st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_flags);
648 st->print_cr(" -------------");
649 }
650
651 void ConstantPoolCacheEntry::verify(outputStream* st) const {
652 // not implemented yet
653 }
654
655 // Implementation of ConstantPoolCache
656
657 ConstantPoolCache* ConstantPoolCache::allocate(ClassLoaderData* loader_data,
658 const intStack& index_map,
659 const intStack& invokedynamic_index_map,
660 const intStack& invokedynamic_map, TRAPS) {
661
662 const int length = index_map.length() + invokedynamic_index_map.length();
663 int size = ConstantPoolCache::size(length);
664
665 return new (loader_data, size, MetaspaceObj::ConstantPoolCacheType, THREAD)
666 ConstantPoolCache(length, index_map, invokedynamic_index_map, invokedynamic_map);
667 }
668
669 void ConstantPoolCache::initialize(const intArray& inverse_index_map,
670 const intArray& invokedynamic_inverse_index_map,
671 const intArray& invokedynamic_references_map) {
672 for (int i = 0; i < inverse_index_map.length(); i++) {
673 ConstantPoolCacheEntry* e = entry_at(i);
674 int original_index = inverse_index_map.at(i);
675 e->initialize_entry(original_index);
676 assert(entry_at(i) == e, "sanity");
677 }
678
679 // Append invokedynamic entries at the end
680 int invokedynamic_offset = inverse_index_map.length();
681 for (int i = 0; i < invokedynamic_inverse_index_map.length(); i++) {
682 int offset = i + invokedynamic_offset;
683 ConstantPoolCacheEntry* e = entry_at(offset);
684 int original_index = invokedynamic_inverse_index_map.at(i);
685 e->initialize_entry(original_index);
686 assert(entry_at(offset) == e, "sanity");
687 }
688
689 for (int ref = 0; ref < invokedynamic_references_map.length(); ref++) {
690 const int cpci = invokedynamic_references_map.at(ref);
691 if (cpci >= 0) {
692 entry_at(cpci)->initialize_resolved_reference_index(ref);
693 }
694 }
695 }
696
697 void ConstantPoolCache::verify_just_initialized() {
698 DEBUG_ONLY(walk_entries_for_initialization(/*check_only = */ true));
699 }
700
701 void ConstantPoolCache::remove_unshareable_info() {
702 walk_entries_for_initialization(/*check_only = */ false);
703 }
704
705 void ConstantPoolCache::walk_entries_for_initialization(bool check_only) {
706 assert(DumpSharedSpaces, "sanity");
707 // When dumping the archive, we want to clean up the ConstantPoolCache
708 // to remove any effect of linking due to the execution of Java code --
709 // each ConstantPoolCacheEntry will have the same contents as if
710 // ConstantPoolCache::initialize has just returned:
711 //
712 // - We keep the ConstantPoolCache::constant_pool_index() bits for all entries.
713 // - We keep the "f2" field for entries used by invokedynamic and invokehandle
714 // - All other bits in the entries are cleared to zero.
715 ResourceMark rm;
716
717 InstanceKlass* ik = constant_pool()->pool_holder();
718 bool* f2_used = NEW_RESOURCE_ARRAY(bool, length());
719 memset(f2_used, 0, sizeof(bool) * length());
720
721 // Find all the slots that we need to preserve f2
722 for (int i = 0; i < ik->methods()->length(); i++) {
723 Method* m = ik->methods()->at(i);
724 RawBytecodeStream bcs(m);
725 while (!bcs.is_last_bytecode()) {
726 Bytecodes::Code opcode = bcs.raw_next();
727 switch (opcode) {
728 case Bytecodes::_invokedynamic: {
729 int index = Bytes::get_native_u4(bcs.bcp() + 1);
730 int cp_cache_index = constant_pool()->invokedynamic_cp_cache_index(index);
731 f2_used[cp_cache_index] = 1;
732 }
733 break;
734 case Bytecodes::_invokehandle: {
735 int cp_cache_index = Bytes::get_native_u2(bcs.bcp() + 1);
736 f2_used[cp_cache_index] = 1;
737 }
738 break;
739 default:
740 break;
741 }
742 }
743 }
744
745 if (check_only) {
746 DEBUG_ONLY(
747 for (int i=0; i<length(); i++) {
748 entry_at(i)->verify_just_initialized(f2_used[i]);
749 })
750 } else {
751 for (int i=0; i<length(); i++) {
752 entry_at(i)->reinitialize(f2_used[i]);
753 }
754 }
755 }
756
757 void ConstantPoolCache::deallocate_contents(ClassLoaderData* data) {
758 assert(!is_shared(), "shared caches are not deallocated");
759 data->remove_handle(_resolved_references);
760 set_resolved_references(NULL);
761 MetadataFactory::free_array<u2>(data, _reference_map);
762 set_reference_map(NULL);
763 }
764
765 #if INCLUDE_CDS_JAVA_HEAP
766 oop ConstantPoolCache::archived_references() {
767 if (CompressedOops::is_null(_archived_references)) {
768 return NULL;
769 }
770 return HeapShared::materialize_archived_object(_archived_references);
771 }
772
773 void ConstantPoolCache::set_archived_references(oop o) {
774 assert(DumpSharedSpaces, "called only during runtime");
775 _archived_references = CompressedOops::encode(o);
776 }
777 #endif
778
779 #if INCLUDE_JVMTI
780 // RedefineClasses() API support:
781 // If any entry of this ConstantPoolCache points to any of
782 // old_methods, replace it with the corresponding new_method.
783 void ConstantPoolCache::adjust_method_entries(bool * trace_name_printed) {
784 for (int i = 0; i < length(); i++) {
785 ConstantPoolCacheEntry* entry = entry_at(i);
786 Method* old_method = entry->get_interesting_method_entry();
787 if (old_method == NULL || !old_method->is_old()) {
788 continue; // skip uninteresting entries
789 }
790 if (old_method->is_deleted()) {
791 // clean up entries with deleted methods
792 entry->initialize_entry(entry->constant_pool_index());
793 continue;
794 }
795 Method* new_method = old_method->get_new_method();
796 entry_at(i)->adjust_method_entry(old_method, new_method, trace_name_printed);
797 }
798 }
799
800 // the constant pool cache should never contain old or obsolete methods
801 bool ConstantPoolCache::check_no_old_or_obsolete_entries() {
802 for (int i = 1; i < length(); i++) {
803 if (entry_at(i)->get_interesting_method_entry() != NULL &&
804 !entry_at(i)->check_no_old_or_obsolete_entries()) {
805 return false;
806 }
807 }
808 return true;
809 }
810
811 void ConstantPoolCache::dump_cache() {
812 for (int i = 1; i < length(); i++) {
813 if (entry_at(i)->get_interesting_method_entry() != NULL) {
814 entry_at(i)->print(tty, i);
815 }
816 }
817 }
818 #endif // INCLUDE_JVMTI
819
820 void ConstantPoolCache::metaspace_pointers_do(MetaspaceClosure* it) {
821 log_trace(cds)("Iter(ConstantPoolCache): %p", this);
822 it->push(&_constant_pool);
823 it->push(&_reference_map);
824 }
825
826 // Printing
827
828 void ConstantPoolCache::print_on(outputStream* st) const {
829 st->print_cr("%s", internal_name());
830 // print constant pool cache entries
831 for (int i = 0; i < length(); i++) entry_at(i)->print(st, i);
832 }
833
834 void ConstantPoolCache::print_value_on(outputStream* st) const {
835 st->print("cache [%d]", length());
836 print_address_on(st);
837 st->print(" for ");
838 constant_pool()->print_value_on(st);
839 }
840
841
842 // Verification
843
844 void ConstantPoolCache::verify_on(outputStream* st) {
845 // print constant pool cache entries
846 for (int i = 0; i < length(); i++) entry_at(i)->verify(st);
847 }