1 /*
2 * Copyright (c) 1997, 2014, 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/classLoaderData.hpp"
27 #include "classfile/javaClasses.hpp"
28 #include "classfile/metadataOnStackMark.hpp"
29 #include "classfile/stringTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/vmSymbols.hpp"
32 #include "interpreter/linkResolver.hpp"
33 #include "memory/heapInspection.hpp"
34 #include "memory/metadataFactory.hpp"
35 #include "memory/oopFactory.hpp"
36 #include "oops/constantPool.hpp"
37 #include "oops/instanceKlass.hpp"
38 #include "oops/objArrayKlass.hpp"
39 #include "runtime/fieldType.hpp"
40 #include "runtime/init.hpp"
41 #include "runtime/javaCalls.hpp"
42 #include "runtime/signature.hpp"
43 #include "runtime/vframe.hpp"
44
45 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
46
47 ConstantPool* ConstantPool::allocate(ClassLoaderData* loader_data, int length, TRAPS) {
48 // Tags are RW but comment below applies to tags also.
49 Array<u1>* tags = MetadataFactory::new_writeable_array<u1>(loader_data, length, 0, CHECK_NULL);
50
51 int size = ConstantPool::size(length);
52
53 // CDS considerations:
54 // Allocate read-write but may be able to move to read-only at dumping time
55 // if all the klasses are resolved. The only other field that is writable is
56 // the resolved_references array, which is recreated at startup time.
57 // But that could be moved to InstanceKlass (although a pain to access from
58 // assembly code). Maybe it could be moved to the cpCache which is RW.
59 return new (loader_data, size, false, MetaspaceObj::ConstantPoolType, THREAD) ConstantPool(tags);
60 }
61
62 ConstantPool::ConstantPool(Array<u1>* tags) {
63 set_length(tags->length());
64 set_tags(NULL);
65 set_cache(NULL);
66 set_reference_map(NULL);
67 set_resolved_references(NULL);
68 set_operands(NULL);
69 set_pool_holder(NULL);
70 set_flags(0);
71
72 // only set to non-zero if constant pool is merged by RedefineClasses
73 set_version(0);
74
75 // initialize tag array
76 int length = tags->length();
77 for (int index = 0; index < length; index++) {
78 tags->at_put(index, JVM_CONSTANT_Invalid);
79 }
80 set_tags(tags);
81 }
82
83 void ConstantPool::deallocate_contents(ClassLoaderData* loader_data) {
84 MetadataFactory::free_metadata(loader_data, cache());
85 set_cache(NULL);
86 MetadataFactory::free_array<u2>(loader_data, reference_map());
87 set_reference_map(NULL);
88
89 MetadataFactory::free_array<jushort>(loader_data, operands());
90 set_operands(NULL);
91
92 release_C_heap_structures();
93
94 // free tag array
95 MetadataFactory::free_array<u1>(loader_data, tags());
96 set_tags(NULL);
97 }
98
99 void ConstantPool::release_C_heap_structures() {
100 // walk constant pool and decrement symbol reference counts
101 unreference_symbols();
102 }
103
104 objArrayOop ConstantPool::resolved_references() const {
105 return (objArrayOop)JNIHandles::resolve(_resolved_references);
106 }
107
108 // Create resolved_references array and mapping array for original cp indexes
109 // The ldc bytecode was rewritten to have the resolved reference array index so need a way
110 // to map it back for resolving and some unlikely miscellaneous uses.
111 // The objects created by invokedynamic are appended to this list.
112 void ConstantPool::initialize_resolved_references(ClassLoaderData* loader_data,
113 intStack reference_map,
114 int constant_pool_map_length,
115 TRAPS) {
116 // Initialized the resolved object cache.
117 int map_length = reference_map.length();
118 if (map_length > 0) {
119 // Only need mapping back to constant pool entries. The map isn't used for
120 // invokedynamic resolved_reference entries. For invokedynamic entries,
121 // the constant pool cache index has the mapping back to both the constant
122 // pool and to the resolved reference index.
123 if (constant_pool_map_length > 0) {
124 Array<u2>* om = MetadataFactory::new_array<u2>(loader_data, constant_pool_map_length, CHECK);
125
126 for (int i = 0; i < constant_pool_map_length; i++) {
127 int x = reference_map.at(i);
128 assert(x == (int)(jushort) x, "klass index is too big");
129 om->at_put(i, (jushort)x);
130 }
131 set_reference_map(om);
132 }
133
134 // Create Java array for holding resolved strings, methodHandles,
135 // methodTypes, invokedynamic and invokehandle appendix objects, etc.
136 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
137 Handle refs_handle (THREAD, (oop)stom); // must handleize.
138 set_resolved_references(loader_data->add_handle(refs_handle));
139 }
140 }
141
142 // CDS support. Create a new resolved_references array.
143 void ConstantPool::restore_unshareable_info(TRAPS) {
144
145 // Only create the new resolved references array if it hasn't been attempted before
146 if (resolved_references() != NULL) return;
147
148 // restore the C++ vtable from the shared archive
149 restore_vtable();
150
151 if (SystemDictionary::Object_klass_loaded()) {
152 // Recreate the object array and add to ClassLoaderData.
153 int map_length = resolved_reference_length();
154 if (map_length > 0) {
155 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
156 Handle refs_handle (THREAD, (oop)stom); // must handleize.
157
158 ClassLoaderData* loader_data = pool_holder()->class_loader_data();
159 set_resolved_references(loader_data->add_handle(refs_handle));
160 }
161 }
162 }
163
164 void ConstantPool::remove_unshareable_info() {
165 // Resolved references are not in the shared archive.
166 // Save the length for restoration. It is not necessarily the same length
167 // as reference_map.length() if invokedynamic is saved.
168 set_resolved_reference_length(
169 resolved_references() != NULL ? resolved_references()->length() : 0);
170 set_resolved_references(NULL);
171 }
172
173 int ConstantPool::cp_to_object_index(int cp_index) {
174 // this is harder don't do this so much.
175 int i = reference_map()->find(cp_index);
176 // We might not find the index for jsr292 call.
177 return (i < 0) ? _no_index_sentinel : i;
178 }
179
180 void ConstantPool::trace_class_resolution(constantPoolHandle this_cp, KlassHandle k) {
181 ResourceMark rm;
182 int line_number = -1;
183 const char * source_file = NULL;
184 if (JavaThread::current()->has_last_Java_frame()) {
185 // try to identify the method which called this function.
186 vframeStream vfst(JavaThread::current());
187 if (!vfst.at_end()) {
188 line_number = vfst.method()->line_number_from_bci(vfst.bci());
189 Symbol* s = vfst.method()->method_holder()->source_file_name();
190 if (s != NULL) {
191 source_file = s->as_C_string();
192 }
193 }
194 }
195 if (k() != this_cp->pool_holder()) {
196 // only print something if the classes are different
197 if (source_file != NULL) {
198 tty->print("RESOLVE %s %s %s:%d\n",
199 this_cp->pool_holder()->external_name(),
200 InstanceKlass::cast(k())->external_name(), source_file, line_number);
201 } else {
202 tty->print("RESOLVE %s %s\n",
203 this_cp->pool_holder()->external_name(),
204 InstanceKlass::cast(k())->external_name());
205 }
206 }
207 }
208
209 Klass* ConstantPool::klass_at_impl(constantPoolHandle this_cp, int which,
210 bool save_resolution_error, TRAPS) {
211 assert(THREAD->is_Java_thread(), "must be a Java thread");
212
213 // A resolved constantPool entry will contain a Klass*, otherwise a Symbol*.
214 // It is not safe to rely on the tag bit's here, since we don't have a lock, and
215 // the entry and tag is not updated atomicly.
216 CPSlot entry = this_cp->slot_at(which);
217 if (entry.is_resolved()) {
218 assert(entry.get_klass()->is_klass(), "must be");
219 // Already resolved - return entry.
220 return entry.get_klass();
221 }
222
223 // This tag doesn't change back to unresolved class unless at a safepoint.
224 if (this_cp->tag_at(which).is_unresolved_klass_in_error()) {
225 // The original attempt to resolve this constant pool entry failed so find the
226 // class of the original error and throw another error of the same class
227 // (JVMS 5.4.3).
228 // If there is a detail message, pass that detail message to the error.
229 // The JVMS does not strictly require us to duplicate the same detail message,
230 // or any internal exception fields such as cause or stacktrace. But since the
231 // detail message is often a class name or other literal string, we will repeat it
232 // if we can find it in the symbol table.
233 throw_resolution_error(this_cp, which, CHECK_0);
234 ShouldNotReachHere();
235 }
236
237 Handle mirror_handle;
238 Symbol* name = entry.get_symbol();
239 Handle loader (THREAD, this_cp->pool_holder()->class_loader());
240 Handle protection_domain (THREAD, this_cp->pool_holder()->protection_domain());
241 Klass* kk = SystemDictionary::resolve_or_fail(name, loader, protection_domain, true, THREAD);
242 KlassHandle k (THREAD, kk);
243 if (!HAS_PENDING_EXCEPTION) {
244 // preserve the resolved klass from unloading
245 mirror_handle = Handle(THREAD, kk->java_mirror());
246 // Do access check for klasses
247 verify_constant_pool_resolve(this_cp, k, THREAD);
248 }
249
250 // Failed to resolve class. We must record the errors so that subsequent attempts
251 // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).
252 if (HAS_PENDING_EXCEPTION) {
253 if (save_resolution_error) {
254 save_and_throw_exception(this_cp, which, constantTag(JVM_CONSTANT_UnresolvedClass), CHECK_NULL);
255 // If CHECK_NULL above doesn't return the exception, that means that
256 // some other thread has beaten us and has resolved the class.
257 // To preserve old behavior, we return the resolved class.
258 entry = this_cp->resolved_klass_at(which);
259 assert(entry.is_resolved(), "must be resolved if exception was cleared");
260 assert(entry.get_klass()->is_klass(), "must be resolved to a klass");
261 return entry.get_klass();
262 } else {
263 return NULL; // return the pending exception
264 }
265 }
266
267 // Make this class loader depend upon the class loader owning the class reference
268 ClassLoaderData* this_key = this_cp->pool_holder()->class_loader_data();
269 this_key->record_dependency(k(), CHECK_NULL); // Can throw OOM
270
271 if (TraceClassResolution && !k->oop_is_array()) {
272 // skip resolving the constant pool so that this code gets
273 // called the next time some bytecodes refer to this class.
274 trace_class_resolution(this_cp, k);
275 return k();
276 } else {
277 this_cp->klass_at_put(which, k());
278 }
279
280 entry = this_cp->resolved_klass_at(which);
281 assert(entry.is_resolved() && entry.get_klass()->is_klass(), "must be resolved at this point");
282 return entry.get_klass();
283 }
284
285
286 // Does not update ConstantPool* - to avoid any exception throwing. Used
287 // by compiler and exception handling. Also used to avoid classloads for
288 // instanceof operations. Returns NULL if the class has not been loaded or
289 // if the verification of constant pool failed
290 Klass* ConstantPool::klass_at_if_loaded(constantPoolHandle this_cp, int which) {
291 CPSlot entry = this_cp->slot_at(which);
292 if (entry.is_resolved()) {
293 assert(entry.get_klass()->is_klass(), "must be");
294 return entry.get_klass();
295 } else {
296 assert(entry.is_unresolved(), "must be either symbol or klass");
297 Thread *thread = Thread::current();
298 Symbol* name = entry.get_symbol();
299 oop loader = this_cp->pool_holder()->class_loader();
300 oop protection_domain = this_cp->pool_holder()->protection_domain();
301 Handle h_prot (thread, protection_domain);
302 Handle h_loader (thread, loader);
303 Klass* k = SystemDictionary::find(name, h_loader, h_prot, thread);
304
305 if (k != NULL) {
306 // Make sure that resolving is legal
307 EXCEPTION_MARK;
308 KlassHandle klass(THREAD, k);
309 // return NULL if verification fails
310 verify_constant_pool_resolve(this_cp, klass, THREAD);
311 if (HAS_PENDING_EXCEPTION) {
312 CLEAR_PENDING_EXCEPTION;
313 return NULL;
314 }
315 return klass();
316 } else {
317 return k;
318 }
319 }
320 }
321
322
323 Klass* ConstantPool::klass_ref_at_if_loaded(constantPoolHandle this_cp, int which) {
324 return klass_at_if_loaded(this_cp, this_cp->klass_ref_index_at(which));
325 }
326
327
328 Method* ConstantPool::method_at_if_loaded(constantPoolHandle cpool,
329 int which) {
330 if (cpool->cache() == NULL) return NULL; // nothing to load yet
331 int cache_index = decode_cpcache_index(which, true);
332 if (!(cache_index >= 0 && cache_index < cpool->cache()->length())) {
333 // FIXME: should be an assert
334 if (PrintMiscellaneous && (Verbose||WizardMode)) {
335 tty->print_cr("bad operand %d in:", which); cpool->print();
336 }
337 return NULL;
338 }
339 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
340 return e->method_if_resolved(cpool);
341 }
342
343
344 bool ConstantPool::has_appendix_at_if_loaded(constantPoolHandle cpool, int which) {
345 if (cpool->cache() == NULL) return false; // nothing to load yet
346 int cache_index = decode_cpcache_index(which, true);
347 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
348 return e->has_appendix();
349 }
350
351 oop ConstantPool::appendix_at_if_loaded(constantPoolHandle cpool, int which) {
352 if (cpool->cache() == NULL) return NULL; // nothing to load yet
353 int cache_index = decode_cpcache_index(which, true);
354 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
355 return e->appendix_if_resolved(cpool);
356 }
357
358
359 bool ConstantPool::has_method_type_at_if_loaded(constantPoolHandle cpool, int which) {
360 if (cpool->cache() == NULL) return false; // nothing to load yet
361 int cache_index = decode_cpcache_index(which, true);
362 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
363 return e->has_method_type();
364 }
365
366 oop ConstantPool::method_type_at_if_loaded(constantPoolHandle cpool, int which) {
367 if (cpool->cache() == NULL) return NULL; // nothing to load yet
368 int cache_index = decode_cpcache_index(which, true);
369 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
370 return e->method_type_if_resolved(cpool);
371 }
372
373
374 Symbol* ConstantPool::impl_name_ref_at(int which, bool uncached) {
375 int name_index = name_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
376 return symbol_at(name_index);
377 }
378
379
380 Symbol* ConstantPool::impl_signature_ref_at(int which, bool uncached) {
381 int signature_index = signature_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
382 return symbol_at(signature_index);
383 }
384
385
386 int ConstantPool::impl_name_and_type_ref_index_at(int which, bool uncached) {
387 int i = which;
388 if (!uncached && cache() != NULL) {
389 if (ConstantPool::is_invokedynamic_index(which)) {
390 // Invokedynamic index is index into resolved_references
391 int pool_index = invokedynamic_cp_cache_entry_at(which)->constant_pool_index();
392 pool_index = invoke_dynamic_name_and_type_ref_index_at(pool_index);
393 assert(tag_at(pool_index).is_name_and_type(), "");
394 return pool_index;
395 }
396 // change byte-ordering and go via cache
397 i = remap_instruction_operand_from_cache(which);
398 } else {
399 if (tag_at(which).is_invoke_dynamic()) {
400 int pool_index = invoke_dynamic_name_and_type_ref_index_at(which);
401 assert(tag_at(pool_index).is_name_and_type(), "");
402 return pool_index;
403 }
404 }
405 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
406 assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");
407 jint ref_index = *int_at_addr(i);
408 return extract_high_short_from_int(ref_index);
409 }
410
411
412 int ConstantPool::impl_klass_ref_index_at(int which, bool uncached) {
413 guarantee(!ConstantPool::is_invokedynamic_index(which),
414 "an invokedynamic instruction does not have a klass");
415 int i = which;
416 if (!uncached && cache() != NULL) {
417 // change byte-ordering and go via cache
418 i = remap_instruction_operand_from_cache(which);
419 }
420 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
421 jint ref_index = *int_at_addr(i);
422 return extract_low_short_from_int(ref_index);
423 }
424
425
426
427 int ConstantPool::remap_instruction_operand_from_cache(int operand) {
428 int cpc_index = operand;
429 DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);
430 assert((int)(u2)cpc_index == cpc_index, "clean u2");
431 int member_index = cache()->entry_at(cpc_index)->constant_pool_index();
432 return member_index;
433 }
434
435
436 void ConstantPool::verify_constant_pool_resolve(constantPoolHandle this_cp, KlassHandle k, TRAPS) {
437 if (k->oop_is_instance() || k->oop_is_objArray()) {
438 instanceKlassHandle holder (THREAD, this_cp->pool_holder());
439 Klass* elem = k->oop_is_instance() ? k() : ObjArrayKlass::cast(k())->bottom_klass();
440 KlassHandle element (THREAD, elem);
441
442 // The element type could be a typeArray - we only need the access check if it is
443 // an reference to another class
444 if (element->oop_is_instance()) {
445 LinkResolver::check_klass_accessability(holder, element, CHECK);
446 }
447 }
448 }
449
450
451 int ConstantPool::name_ref_index_at(int which_nt) {
452 jint ref_index = name_and_type_at(which_nt);
453 return extract_low_short_from_int(ref_index);
454 }
455
456
457 int ConstantPool::signature_ref_index_at(int which_nt) {
458 jint ref_index = name_and_type_at(which_nt);
459 return extract_high_short_from_int(ref_index);
460 }
461
462
463 Klass* ConstantPool::klass_ref_at(int which, TRAPS) {
464 return klass_at(klass_ref_index_at(which), CHECK_NULL);
465 }
466
467
468 Symbol* ConstantPool::klass_name_at(int which) {
469 assert(tag_at(which).is_unresolved_klass() || tag_at(which).is_klass(),
470 "Corrupted constant pool");
471 // A resolved constantPool entry will contain a Klass*, otherwise a Symbol*.
472 // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
473 // tag is not updated atomicly.
474 CPSlot entry = slot_at(which);
475 if (entry.is_resolved()) {
476 // Already resolved - return entry's name.
477 assert(entry.get_klass()->is_klass(), "must be");
478 return entry.get_klass()->name();
479 } else {
480 assert(entry.is_unresolved(), "must be either symbol or klass");
481 return entry.get_symbol();
482 }
483 }
484
485 Symbol* ConstantPool::klass_ref_at_noresolve(int which) {
486 jint ref_index = klass_ref_index_at(which);
487 return klass_at_noresolve(ref_index);
488 }
489
490 Symbol* ConstantPool::uncached_klass_ref_at_noresolve(int which) {
491 jint ref_index = uncached_klass_ref_index_at(which);
492 return klass_at_noresolve(ref_index);
493 }
494
495 char* ConstantPool::string_at_noresolve(int which) {
496 Symbol* s = unresolved_string_at(which);
497 if (s == NULL) {
498 return (char*)"<pseudo-string>";
499 } else {
500 return unresolved_string_at(which)->as_C_string();
501 }
502 }
503
504 BasicType ConstantPool::basic_type_for_signature_at(int which) {
505 return FieldType::basic_type(symbol_at(which));
506 }
507
508
509 void ConstantPool::resolve_string_constants_impl(constantPoolHandle this_cp, TRAPS) {
510 for (int index = 1; index < this_cp->length(); index++) { // Index 0 is unused
511 if (this_cp->tag_at(index).is_string()) {
512 this_cp->string_at(index, CHECK);
513 }
514 }
515 }
516
517 // Resolve all the classes in the constant pool. If they are all resolved,
518 // the constant pool is read-only. Enhancement: allocate cp entries to
519 // another metaspace, and copy to read-only or read-write space if this
520 // bit is set.
521 bool ConstantPool::resolve_class_constants(TRAPS) {
522 constantPoolHandle cp(THREAD, this);
523 for (int index = 1; index < length(); index++) { // Index 0 is unused
524 if (tag_at(index).is_unresolved_klass() &&
525 klass_at_if_loaded(cp, index) == NULL) {
526 return false;
527 }
528 }
529 // set_preresolution(); or some bit for future use
530 return true;
531 }
532
533 Symbol* ConstantPool::exception_message(constantPoolHandle this_cp, int which, constantTag tag, oop pending_exception) {
534 // Dig out the detailed message to reuse if possible
535 Symbol* message = java_lang_Throwable::detail_message(pending_exception);
536 if (message != NULL) {
537 return message;
538 }
539
540 // Return specific message for the tag
541 switch (tag.value()) {
542 case JVM_CONSTANT_UnresolvedClass:
543 // return the class name in the error message
544 message = this_cp->klass_name_at(which);
545 break;
546 case JVM_CONSTANT_MethodHandle:
547 // return the method handle name in the error message
548 message = this_cp->method_handle_name_ref_at(which);
549 break;
550 case JVM_CONSTANT_MethodType:
551 // return the method type signature in the error message
552 message = this_cp->method_type_signature_at(which);
553 break;
554 default:
555 ShouldNotReachHere();
556 }
557
558 return message;
559 }
560
561 void ConstantPool::throw_resolution_error(constantPoolHandle this_cp, int which, TRAPS) {
562 Symbol* message = NULL;
563 Symbol* error = SystemDictionary::find_resolution_error(this_cp, which, &message);
564 assert(error != NULL && message != NULL, "checking");
565 CLEAR_PENDING_EXCEPTION;
566 ResourceMark rm;
567 THROW_MSG(error, message->as_C_string());
568 }
569
570 // If resolution for Class, MethodHandle or MethodType fails, save the exception
571 // in the resolution error table, so that the same exception is thrown again.
572 void ConstantPool::save_and_throw_exception(constantPoolHandle this_cp, int which,
573 constantTag tag, TRAPS) {
574 Symbol* error = PENDING_EXCEPTION->klass()->name();
575
576 int error_tag = tag.error_value();
577
578 if (!PENDING_EXCEPTION->
579 is_a(SystemDictionary::LinkageError_klass())) {
580 // Just throw the exception and don't prevent these classes from
581 // being loaded due to virtual machine errors like StackOverflow
582 // and OutOfMemoryError, etc, or if the thread was hit by stop()
583 // Needs clarification to section 5.4.3 of the VM spec (see 6308271)
584 } else if (this_cp->tag_at(which).value() != error_tag) {
585 Symbol* message = exception_message(this_cp, which, tag, PENDING_EXCEPTION);
586 SystemDictionary::add_resolution_error(this_cp, which, error, message);
587 // CAS in the tag. If a thread beat us to registering this error that's fine.
588 // If another thread resolved the reference, this is a race condition. This
589 // thread may have had a security manager or something temporary.
590 // This doesn't deterministically get an error. So why do we save this?
591 // We save this because jvmti can add classes to the bootclass path after
592 // this error, so it needs to get the same error if the error is first.
593 jbyte old_tag = Atomic::cmpxchg((jbyte)error_tag,
594 (jbyte*)this_cp->tag_addr_at(which), (jbyte)tag.value());
595 if (old_tag != error_tag && old_tag != tag.value()) {
596 // MethodHandles and MethodType doesn't change to resolved version.
597 assert(this_cp->tag_at(which).is_klass(), "Wrong tag value");
598 // Forget the exception and use the resolved class.
599 CLEAR_PENDING_EXCEPTION;
600 }
601 } else {
602 // some other thread put this in error state
603 throw_resolution_error(this_cp, which, CHECK);
604 }
605 }
606
607 // Called to resolve constants in the constant pool and return an oop.
608 // Some constant pool entries cache their resolved oop. This is also
609 // called to create oops from constants to use in arguments for invokedynamic
610 oop ConstantPool::resolve_constant_at_impl(constantPoolHandle this_cp, int index, int cache_index, TRAPS) {
611 oop result_oop = NULL;
612 Handle throw_exception;
613
614 if (cache_index == _possible_index_sentinel) {
615 // It is possible that this constant is one which is cached in the objects.
616 // We'll do a linear search. This should be OK because this usage is rare.
617 assert(index > 0, "valid index");
618 cache_index = this_cp->cp_to_object_index(index);
619 }
620 assert(cache_index == _no_index_sentinel || cache_index >= 0, "");
621 assert(index == _no_index_sentinel || index >= 0, "");
622
623 if (cache_index >= 0) {
624 result_oop = this_cp->resolved_references()->obj_at(cache_index);
625 if (result_oop != NULL) {
626 return result_oop;
627 // That was easy...
628 }
629 index = this_cp->object_to_cp_index(cache_index);
630 }
631
632 jvalue prim_value; // temp used only in a few cases below
633
634 constantTag tag = this_cp->tag_at(index);
635
636 switch (tag.value()) {
637
638 case JVM_CONSTANT_UnresolvedClass:
639 case JVM_CONSTANT_UnresolvedClassInError:
640 case JVM_CONSTANT_Class:
641 {
642 assert(cache_index == _no_index_sentinel, "should not have been set");
643 Klass* resolved = klass_at_impl(this_cp, index, true, CHECK_NULL);
644 // ldc wants the java mirror.
645 result_oop = resolved->java_mirror();
646 break;
647 }
648
649 case JVM_CONSTANT_String:
650 assert(cache_index != _no_index_sentinel, "should have been set");
651 if (this_cp->is_pseudo_string_at(index)) {
652 result_oop = this_cp->pseudo_string_at(index, cache_index);
653 break;
654 }
655 result_oop = string_at_impl(this_cp, index, cache_index, CHECK_NULL);
656 break;
657
658 case JVM_CONSTANT_MethodHandleInError:
659 case JVM_CONSTANT_MethodTypeInError:
660 {
661 throw_resolution_error(this_cp, index, CHECK_NULL);
662 break;
663 }
664
665 case JVM_CONSTANT_MethodHandle:
666 {
667 int ref_kind = this_cp->method_handle_ref_kind_at(index);
668 int callee_index = this_cp->method_handle_klass_index_at(index);
669 Symbol* name = this_cp->method_handle_name_ref_at(index);
670 Symbol* signature = this_cp->method_handle_signature_ref_at(index);
671 if (PrintMiscellaneous)
672 tty->print_cr("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s",
673 ref_kind, index, this_cp->method_handle_index_at(index),
674 callee_index, name->as_C_string(), signature->as_C_string());
675 KlassHandle callee;
676 { Klass* k = klass_at_impl(this_cp, callee_index, true, CHECK_NULL);
677 callee = KlassHandle(THREAD, k);
678 }
679 KlassHandle klass(THREAD, this_cp->pool_holder());
680 Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,
681 callee, name, signature,
682 THREAD);
683 result_oop = value();
684 if (HAS_PENDING_EXCEPTION) {
685 save_and_throw_exception(this_cp, index, tag, CHECK_NULL);
686 }
687 break;
688 }
689
690 case JVM_CONSTANT_MethodType:
691 {
692 Symbol* signature = this_cp->method_type_signature_at(index);
693 if (PrintMiscellaneous)
694 tty->print_cr("resolve JVM_CONSTANT_MethodType [%d/%d] %s",
695 index, this_cp->method_type_index_at(index),
696 signature->as_C_string());
697 KlassHandle klass(THREAD, this_cp->pool_holder());
698 Handle value = SystemDictionary::find_method_handle_type(signature, klass, THREAD);
699 result_oop = value();
700 if (HAS_PENDING_EXCEPTION) {
701 save_and_throw_exception(this_cp, index, tag, CHECK_NULL);
702 }
703 break;
704 }
705
706 case JVM_CONSTANT_Integer:
707 assert(cache_index == _no_index_sentinel, "should not have been set");
708 prim_value.i = this_cp->int_at(index);
709 result_oop = java_lang_boxing_object::create(T_INT, &prim_value, CHECK_NULL);
710 break;
711
712 case JVM_CONSTANT_Float:
713 assert(cache_index == _no_index_sentinel, "should not have been set");
714 prim_value.f = this_cp->float_at(index);
715 result_oop = java_lang_boxing_object::create(T_FLOAT, &prim_value, CHECK_NULL);
716 break;
717
718 case JVM_CONSTANT_Long:
719 assert(cache_index == _no_index_sentinel, "should not have been set");
720 prim_value.j = this_cp->long_at(index);
721 result_oop = java_lang_boxing_object::create(T_LONG, &prim_value, CHECK_NULL);
722 break;
723
724 case JVM_CONSTANT_Double:
725 assert(cache_index == _no_index_sentinel, "should not have been set");
726 prim_value.d = this_cp->double_at(index);
727 result_oop = java_lang_boxing_object::create(T_DOUBLE, &prim_value, CHECK_NULL);
728 break;
729
730 default:
731 DEBUG_ONLY( tty->print_cr("*** %p: tag at CP[%d/%d] = %d",
732 this_cp(), index, cache_index, tag.value()));
733 assert(false, "unexpected constant tag");
734 break;
735 }
736
737 if (cache_index >= 0) {
738 // Benign race condition: resolved_references may already be filled in.
739 // The important thing here is that all threads pick up the same result.
740 // It doesn't matter which racing thread wins, as long as only one
741 // result is used by all threads, and all future queries.
742 oop old_result = this_cp->resolved_references()->atomic_compare_exchange_oop(cache_index, result_oop, NULL);
743 if (old_result == NULL) {
744 return result_oop; // was installed
745 } else {
746 // Return the winning thread's result. This can be different than
747 // the result here for MethodHandles.
748 return old_result;
749 }
750 } else {
751 return result_oop;
752 }
753 }
754
755 oop ConstantPool::uncached_string_at(int which, TRAPS) {
756 Symbol* sym = unresolved_string_at(which);
757 oop str = StringTable::intern(sym, CHECK_(NULL));
758 assert(java_lang_String::is_instance(str), "must be string");
759 return str;
760 }
761
762
763 oop ConstantPool::resolve_bootstrap_specifier_at_impl(constantPoolHandle this_cp, int index, TRAPS) {
764 assert(this_cp->tag_at(index).is_invoke_dynamic(), "Corrupted constant pool");
765
766 Handle bsm;
767 int argc;
768 {
769 // JVM_CONSTANT_InvokeDynamic is an ordered pair of [bootm, name&type], plus optional arguments
770 // The bootm, being a JVM_CONSTANT_MethodHandle, has its own cache entry.
771 // It is accompanied by the optional arguments.
772 int bsm_index = this_cp->invoke_dynamic_bootstrap_method_ref_index_at(index);
773 oop bsm_oop = this_cp->resolve_possibly_cached_constant_at(bsm_index, CHECK_NULL);
774 if (!java_lang_invoke_MethodHandle::is_instance(bsm_oop)) {
775 THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "BSM not an MethodHandle");
776 }
777
778 // Extract the optional static arguments.
779 argc = this_cp->invoke_dynamic_argument_count_at(index);
780 if (argc == 0) return bsm_oop;
781
782 bsm = Handle(THREAD, bsm_oop);
783 }
784
785 objArrayHandle info;
786 {
787 objArrayOop info_oop = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1+argc, CHECK_NULL);
788 info = objArrayHandle(THREAD, info_oop);
789 }
790
791 info->obj_at_put(0, bsm());
792 for (int i = 0; i < argc; i++) {
793 int arg_index = this_cp->invoke_dynamic_argument_index_at(index, i);
794 oop arg_oop = this_cp->resolve_possibly_cached_constant_at(arg_index, CHECK_NULL);
795 info->obj_at_put(1+i, arg_oop);
796 }
797
798 return info();
799 }
800
801 oop ConstantPool::string_at_impl(constantPoolHandle this_cp, int which, int obj_index, TRAPS) {
802 // If the string has already been interned, this entry will be non-null
803 oop str = this_cp->resolved_references()->obj_at(obj_index);
804 if (str != NULL) return str;
805 Symbol* sym = this_cp->unresolved_string_at(which);
806 str = StringTable::intern(sym, CHECK_(NULL));
807 this_cp->string_at_put(which, obj_index, str);
808 assert(java_lang_String::is_instance(str), "must be string");
809 return str;
810 }
811
812
813 bool ConstantPool::klass_name_at_matches(instanceKlassHandle k,
814 int which) {
815 // Names are interned, so we can compare Symbol*s directly
816 Symbol* cp_name = klass_name_at(which);
817 return (cp_name == k->name());
818 }
819
820
821 // Iterate over symbols and decrement ones which are Symbol*s
822 // This is done during GC.
823 // Only decrement the UTF8 symbols. Unresolved classes and strings point to
824 // these symbols but didn't increment the reference count.
825 void ConstantPool::unreference_symbols() {
826 for (int index = 1; index < length(); index++) { // Index 0 is unused
827 constantTag tag = tag_at(index);
828 if (tag.is_symbol()) {
829 symbol_at(index)->decrement_refcount();
830 }
831 }
832 }
833
834
835 // Compare this constant pool's entry at index1 to the constant pool
836 // cp2's entry at index2.
837 bool ConstantPool::compare_entry_to(int index1, constantPoolHandle cp2,
838 int index2, TRAPS) {
839
840 // The error tags are equivalent to non-error tags when comparing
841 jbyte t1 = tag_at(index1).non_error_value();
842 jbyte t2 = cp2->tag_at(index2).non_error_value();
843
844 if (t1 != t2) {
845 // Not the same entry type so there is nothing else to check. Note
846 // that this style of checking will consider resolved/unresolved
847 // class pairs as different.
848 // From the ConstantPool* API point of view, this is correct
849 // behavior. See VM_RedefineClasses::merge_constant_pools() to see how this
850 // plays out in the context of ConstantPool* merging.
851 return false;
852 }
853
854 switch (t1) {
855 case JVM_CONSTANT_Class:
856 {
857 Klass* k1 = klass_at(index1, CHECK_false);
858 Klass* k2 = cp2->klass_at(index2, CHECK_false);
859 if (k1 == k2) {
860 return true;
861 }
862 } break;
863
864 case JVM_CONSTANT_ClassIndex:
865 {
866 int recur1 = klass_index_at(index1);
867 int recur2 = cp2->klass_index_at(index2);
868 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
869 if (match) {
870 return true;
871 }
872 } break;
873
874 case JVM_CONSTANT_Double:
875 {
876 jdouble d1 = double_at(index1);
877 jdouble d2 = cp2->double_at(index2);
878 if (d1 == d2) {
879 return true;
880 }
881 } break;
882
883 case JVM_CONSTANT_Fieldref:
884 case JVM_CONSTANT_InterfaceMethodref:
885 case JVM_CONSTANT_Methodref:
886 {
887 int recur1 = uncached_klass_ref_index_at(index1);
888 int recur2 = cp2->uncached_klass_ref_index_at(index2);
889 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
890 if (match) {
891 recur1 = uncached_name_and_type_ref_index_at(index1);
892 recur2 = cp2->uncached_name_and_type_ref_index_at(index2);
893 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
894 if (match) {
895 return true;
896 }
897 }
898 } break;
899
900 case JVM_CONSTANT_Float:
901 {
902 jfloat f1 = float_at(index1);
903 jfloat f2 = cp2->float_at(index2);
904 if (f1 == f2) {
905 return true;
906 }
907 } break;
908
909 case JVM_CONSTANT_Integer:
910 {
911 jint i1 = int_at(index1);
912 jint i2 = cp2->int_at(index2);
913 if (i1 == i2) {
914 return true;
915 }
916 } break;
917
918 case JVM_CONSTANT_Long:
919 {
920 jlong l1 = long_at(index1);
921 jlong l2 = cp2->long_at(index2);
922 if (l1 == l2) {
923 return true;
924 }
925 } break;
926
927 case JVM_CONSTANT_NameAndType:
928 {
929 int recur1 = name_ref_index_at(index1);
930 int recur2 = cp2->name_ref_index_at(index2);
931 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
932 if (match) {
933 recur1 = signature_ref_index_at(index1);
934 recur2 = cp2->signature_ref_index_at(index2);
935 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
936 if (match) {
937 return true;
938 }
939 }
940 } break;
941
942 case JVM_CONSTANT_StringIndex:
943 {
944 int recur1 = string_index_at(index1);
945 int recur2 = cp2->string_index_at(index2);
946 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
947 if (match) {
948 return true;
949 }
950 } break;
951
952 case JVM_CONSTANT_UnresolvedClass:
953 {
954 Symbol* k1 = klass_name_at(index1);
955 Symbol* k2 = cp2->klass_name_at(index2);
956 if (k1 == k2) {
957 return true;
958 }
959 } break;
960
961 case JVM_CONSTANT_MethodType:
962 {
963 int k1 = method_type_index_at_error_ok(index1);
964 int k2 = cp2->method_type_index_at_error_ok(index2);
965 bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
966 if (match) {
967 return true;
968 }
969 } break;
970
971 case JVM_CONSTANT_MethodHandle:
972 {
973 int k1 = method_handle_ref_kind_at_error_ok(index1);
974 int k2 = cp2->method_handle_ref_kind_at_error_ok(index2);
975 if (k1 == k2) {
976 int i1 = method_handle_index_at_error_ok(index1);
977 int i2 = cp2->method_handle_index_at_error_ok(index2);
978 bool match = compare_entry_to(i1, cp2, i2, CHECK_false);
979 if (match) {
980 return true;
981 }
982 }
983 } break;
984
985 case JVM_CONSTANT_InvokeDynamic:
986 {
987 int k1 = invoke_dynamic_name_and_type_ref_index_at(index1);
988 int k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
989 int i1 = invoke_dynamic_bootstrap_specifier_index(index1);
990 int i2 = cp2->invoke_dynamic_bootstrap_specifier_index(index2);
991 // separate statements and variables because CHECK_false is used
992 bool match_entry = compare_entry_to(k1, cp2, k2, CHECK_false);
993 bool match_operand = compare_operand_to(i1, cp2, i2, CHECK_false);
994 return (match_entry && match_operand);
995 } break;
996
997 case JVM_CONSTANT_String:
998 {
999 Symbol* s1 = unresolved_string_at(index1);
1000 Symbol* s2 = cp2->unresolved_string_at(index2);
1001 if (s1 == s2) {
1002 return true;
1003 }
1004 } break;
1005
1006 case JVM_CONSTANT_Utf8:
1007 {
1008 Symbol* s1 = symbol_at(index1);
1009 Symbol* s2 = cp2->symbol_at(index2);
1010 if (s1 == s2) {
1011 return true;
1012 }
1013 } break;
1014
1015 // Invalid is used as the tag for the second constant pool entry
1016 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
1017 // not be seen by itself.
1018 case JVM_CONSTANT_Invalid: // fall through
1019
1020 default:
1021 ShouldNotReachHere();
1022 break;
1023 }
1024
1025 return false;
1026 } // end compare_entry_to()
1027
1028
1029 // Resize the operands array with delta_len and delta_size.
1030 // Used in RedefineClasses for CP merge.
1031 void ConstantPool::resize_operands(int delta_len, int delta_size, TRAPS) {
1032 int old_len = operand_array_length(operands());
1033 int new_len = old_len + delta_len;
1034 int min_len = (delta_len > 0) ? old_len : new_len;
1035
1036 int old_size = operands()->length();
1037 int new_size = old_size + delta_size;
1038 int min_size = (delta_size > 0) ? old_size : new_size;
1039
1040 ClassLoaderData* loader_data = pool_holder()->class_loader_data();
1041 Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, new_size, CHECK);
1042
1043 // Set index in the resized array for existing elements only
1044 for (int idx = 0; idx < min_len; idx++) {
1045 int offset = operand_offset_at(idx); // offset in original array
1046 operand_offset_at_put(new_ops, idx, offset + 2*delta_len); // offset in resized array
1047 }
1048 // Copy the bootstrap specifiers only
1049 Copy::conjoint_memory_atomic(operands()->adr_at(2*old_len),
1050 new_ops->adr_at(2*new_len),
1051 (min_size - 2*min_len) * sizeof(u2));
1052 // Explicitly deallocate old operands array.
1053 // Note, it is not needed for 7u backport.
1054 if ( operands() != NULL) { // the safety check
1055 MetadataFactory::free_array<u2>(loader_data, operands());
1056 }
1057 set_operands(new_ops);
1058 } // end resize_operands()
1059
1060
1061 // Extend the operands array with the length and size of the ext_cp operands.
1062 // Used in RedefineClasses for CP merge.
1063 void ConstantPool::extend_operands(constantPoolHandle ext_cp, TRAPS) {
1064 int delta_len = operand_array_length(ext_cp->operands());
1065 if (delta_len == 0) {
1066 return; // nothing to do
1067 }
1068 int delta_size = ext_cp->operands()->length();
1069
1070 assert(delta_len > 0 && delta_size > 0, "extended operands array must be bigger");
1071
1072 if (operand_array_length(operands()) == 0) {
1073 ClassLoaderData* loader_data = pool_holder()->class_loader_data();
1074 Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, delta_size, CHECK);
1075 // The first element index defines the offset of second part
1076 operand_offset_at_put(new_ops, 0, 2*delta_len); // offset in new array
1077 set_operands(new_ops);
1078 } else {
1079 resize_operands(delta_len, delta_size, CHECK);
1080 }
1081
1082 } // end extend_operands()
1083
1084
1085 // Shrink the operands array to a smaller array with new_len length.
1086 // Used in RedefineClasses for CP merge.
1087 void ConstantPool::shrink_operands(int new_len, TRAPS) {
1088 int old_len = operand_array_length(operands());
1089 if (new_len == old_len) {
1090 return; // nothing to do
1091 }
1092 assert(new_len < old_len, "shrunken operands array must be smaller");
1093
1094 int free_base = operand_next_offset_at(new_len - 1);
1095 int delta_len = new_len - old_len;
1096 int delta_size = 2*delta_len + free_base - operands()->length();
1097
1098 resize_operands(delta_len, delta_size, CHECK);
1099
1100 } // end shrink_operands()
1101
1102
1103 void ConstantPool::copy_operands(constantPoolHandle from_cp,
1104 constantPoolHandle to_cp,
1105 TRAPS) {
1106
1107 int from_oplen = operand_array_length(from_cp->operands());
1108 int old_oplen = operand_array_length(to_cp->operands());
1109 if (from_oplen != 0) {
1110 ClassLoaderData* loader_data = to_cp->pool_holder()->class_loader_data();
1111 // append my operands to the target's operands array
1112 if (old_oplen == 0) {
1113 // Can't just reuse from_cp's operand list because of deallocation issues
1114 int len = from_cp->operands()->length();
1115 Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, len, CHECK);
1116 Copy::conjoint_memory_atomic(
1117 from_cp->operands()->adr_at(0), new_ops->adr_at(0), len * sizeof(u2));
1118 to_cp->set_operands(new_ops);
1119 } else {
1120 int old_len = to_cp->operands()->length();
1121 int from_len = from_cp->operands()->length();
1122 int old_off = old_oplen * sizeof(u2);
1123 int from_off = from_oplen * sizeof(u2);
1124 // Use the metaspace for the destination constant pool
1125 Array<u2>* new_operands = MetadataFactory::new_array<u2>(loader_data, old_len + from_len, CHECK);
1126 int fillp = 0, len = 0;
1127 // first part of dest
1128 Copy::conjoint_memory_atomic(to_cp->operands()->adr_at(0),
1129 new_operands->adr_at(fillp),
1130 (len = old_off) * sizeof(u2));
1131 fillp += len;
1132 // first part of src
1133 Copy::conjoint_memory_atomic(from_cp->operands()->adr_at(0),
1134 new_operands->adr_at(fillp),
1135 (len = from_off) * sizeof(u2));
1136 fillp += len;
1137 // second part of dest
1138 Copy::conjoint_memory_atomic(to_cp->operands()->adr_at(old_off),
1139 new_operands->adr_at(fillp),
1140 (len = old_len - old_off) * sizeof(u2));
1141 fillp += len;
1142 // second part of src
1143 Copy::conjoint_memory_atomic(from_cp->operands()->adr_at(from_off),
1144 new_operands->adr_at(fillp),
1145 (len = from_len - from_off) * sizeof(u2));
1146 fillp += len;
1147 assert(fillp == new_operands->length(), "");
1148
1149 // Adjust indexes in the first part of the copied operands array.
1150 for (int j = 0; j < from_oplen; j++) {
1151 int offset = operand_offset_at(new_operands, old_oplen + j);
1152 assert(offset == operand_offset_at(from_cp->operands(), j), "correct copy");
1153 offset += old_len; // every new tuple is preceded by old_len extra u2's
1154 operand_offset_at_put(new_operands, old_oplen + j, offset);
1155 }
1156
1157 // replace target operands array with combined array
1158 to_cp->set_operands(new_operands);
1159 }
1160 }
1161 } // end copy_operands()
1162
1163
1164 // Copy this constant pool's entries at start_i to end_i (inclusive)
1165 // to the constant pool to_cp's entries starting at to_i. A total of
1166 // (end_i - start_i) + 1 entries are copied.
1167 void ConstantPool::copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i,
1168 constantPoolHandle to_cp, int to_i, TRAPS) {
1169
1170
1171 int dest_i = to_i; // leave original alone for debug purposes
1172
1173 for (int src_i = start_i; src_i <= end_i; /* see loop bottom */ ) {
1174 copy_entry_to(from_cp, src_i, to_cp, dest_i, CHECK);
1175
1176 switch (from_cp->tag_at(src_i).value()) {
1177 case JVM_CONSTANT_Double:
1178 case JVM_CONSTANT_Long:
1179 // double and long take two constant pool entries
1180 src_i += 2;
1181 dest_i += 2;
1182 break;
1183
1184 default:
1185 // all others take one constant pool entry
1186 src_i++;
1187 dest_i++;
1188 break;
1189 }
1190 }
1191 copy_operands(from_cp, to_cp, CHECK);
1192
1193 } // end copy_cp_to_impl()
1194
1195
1196 // Copy this constant pool's entry at from_i to the constant pool
1197 // to_cp's entry at to_i.
1198 void ConstantPool::copy_entry_to(constantPoolHandle from_cp, int from_i,
1199 constantPoolHandle to_cp, int to_i,
1200 TRAPS) {
1201
1202 int tag = from_cp->tag_at(from_i).value();
1203 switch (tag) {
1204 case JVM_CONSTANT_Class:
1205 {
1206 Klass* k = from_cp->klass_at(from_i, CHECK);
1207 to_cp->klass_at_put(to_i, k);
1208 } break;
1209
1210 case JVM_CONSTANT_ClassIndex:
1211 {
1212 jint ki = from_cp->klass_index_at(from_i);
1213 to_cp->klass_index_at_put(to_i, ki);
1214 } break;
1215
1216 case JVM_CONSTANT_Double:
1217 {
1218 jdouble d = from_cp->double_at(from_i);
1219 to_cp->double_at_put(to_i, d);
1220 // double takes two constant pool entries so init second entry's tag
1221 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
1222 } break;
1223
1224 case JVM_CONSTANT_Fieldref:
1225 {
1226 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1227 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1228 to_cp->field_at_put(to_i, class_index, name_and_type_index);
1229 } break;
1230
1231 case JVM_CONSTANT_Float:
1232 {
1233 jfloat f = from_cp->float_at(from_i);
1234 to_cp->float_at_put(to_i, f);
1235 } break;
1236
1237 case JVM_CONSTANT_Integer:
1238 {
1239 jint i = from_cp->int_at(from_i);
1240 to_cp->int_at_put(to_i, i);
1241 } break;
1242
1243 case JVM_CONSTANT_InterfaceMethodref:
1244 {
1245 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1246 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1247 to_cp->interface_method_at_put(to_i, class_index, name_and_type_index);
1248 } break;
1249
1250 case JVM_CONSTANT_Long:
1251 {
1252 jlong l = from_cp->long_at(from_i);
1253 to_cp->long_at_put(to_i, l);
1254 // long takes two constant pool entries so init second entry's tag
1255 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
1256 } break;
1257
1258 case JVM_CONSTANT_Methodref:
1259 {
1260 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1261 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1262 to_cp->method_at_put(to_i, class_index, name_and_type_index);
1263 } break;
1264
1265 case JVM_CONSTANT_NameAndType:
1266 {
1267 int name_ref_index = from_cp->name_ref_index_at(from_i);
1268 int signature_ref_index = from_cp->signature_ref_index_at(from_i);
1269 to_cp->name_and_type_at_put(to_i, name_ref_index, signature_ref_index);
1270 } break;
1271
1272 case JVM_CONSTANT_StringIndex:
1273 {
1274 jint si = from_cp->string_index_at(from_i);
1275 to_cp->string_index_at_put(to_i, si);
1276 } break;
1277
1278 case JVM_CONSTANT_UnresolvedClass:
1279 case JVM_CONSTANT_UnresolvedClassInError:
1280 {
1281 // Can be resolved after checking tag, so check the slot first.
1282 CPSlot entry = from_cp->slot_at(from_i);
1283 if (entry.is_resolved()) {
1284 assert(entry.get_klass()->is_klass(), "must be");
1285 // Already resolved
1286 to_cp->klass_at_put(to_i, entry.get_klass());
1287 } else {
1288 to_cp->unresolved_klass_at_put(to_i, entry.get_symbol());
1289 }
1290 } break;
1291
1292 case JVM_CONSTANT_String:
1293 {
1294 Symbol* s = from_cp->unresolved_string_at(from_i);
1295 to_cp->unresolved_string_at_put(to_i, s);
1296 } break;
1297
1298 case JVM_CONSTANT_Utf8:
1299 {
1300 Symbol* s = from_cp->symbol_at(from_i);
1301 // Need to increase refcount, the old one will be thrown away and deferenced
1302 s->increment_refcount();
1303 to_cp->symbol_at_put(to_i, s);
1304 } break;
1305
1306 case JVM_CONSTANT_MethodType:
1307 case JVM_CONSTANT_MethodTypeInError:
1308 {
1309 jint k = from_cp->method_type_index_at_error_ok(from_i);
1310 to_cp->method_type_index_at_put(to_i, k);
1311 } break;
1312
1313 case JVM_CONSTANT_MethodHandle:
1314 case JVM_CONSTANT_MethodHandleInError:
1315 {
1316 int k1 = from_cp->method_handle_ref_kind_at_error_ok(from_i);
1317 int k2 = from_cp->method_handle_index_at_error_ok(from_i);
1318 to_cp->method_handle_index_at_put(to_i, k1, k2);
1319 } break;
1320
1321 case JVM_CONSTANT_InvokeDynamic:
1322 {
1323 int k1 = from_cp->invoke_dynamic_bootstrap_specifier_index(from_i);
1324 int k2 = from_cp->invoke_dynamic_name_and_type_ref_index_at(from_i);
1325 k1 += operand_array_length(to_cp->operands()); // to_cp might already have operands
1326 to_cp->invoke_dynamic_at_put(to_i, k1, k2);
1327 } break;
1328
1329 // Invalid is used as the tag for the second constant pool entry
1330 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
1331 // not be seen by itself.
1332 case JVM_CONSTANT_Invalid: // fall through
1333
1334 default:
1335 {
1336 ShouldNotReachHere();
1337 } break;
1338 }
1339 } // end copy_entry_to()
1340
1341
1342 // Search constant pool search_cp for an entry that matches this
1343 // constant pool's entry at pattern_i. Returns the index of a
1344 // matching entry or zero (0) if there is no matching entry.
1345 int ConstantPool::find_matching_entry(int pattern_i,
1346 constantPoolHandle search_cp, TRAPS) {
1347
1348 // index zero (0) is not used
1349 for (int i = 1; i < search_cp->length(); i++) {
1350 bool found = compare_entry_to(pattern_i, search_cp, i, CHECK_0);
1351 if (found) {
1352 return i;
1353 }
1354 }
1355
1356 return 0; // entry not found; return unused index zero (0)
1357 } // end find_matching_entry()
1358
1359
1360 // Compare this constant pool's bootstrap specifier at idx1 to the constant pool
1361 // cp2's bootstrap specifier at idx2.
1362 bool ConstantPool::compare_operand_to(int idx1, constantPoolHandle cp2, int idx2, TRAPS) {
1363 int k1 = operand_bootstrap_method_ref_index_at(idx1);
1364 int k2 = cp2->operand_bootstrap_method_ref_index_at(idx2);
1365 bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
1366
1367 if (!match) {
1368 return false;
1369 }
1370 int argc = operand_argument_count_at(idx1);
1371 if (argc == cp2->operand_argument_count_at(idx2)) {
1372 for (int j = 0; j < argc; j++) {
1373 k1 = operand_argument_index_at(idx1, j);
1374 k2 = cp2->operand_argument_index_at(idx2, j);
1375 match = compare_entry_to(k1, cp2, k2, CHECK_false);
1376 if (!match) {
1377 return false;
1378 }
1379 }
1380 return true; // got through loop; all elements equal
1381 }
1382 return false;
1383 } // end compare_operand_to()
1384
1385 // Search constant pool search_cp for a bootstrap specifier that matches
1386 // this constant pool's bootstrap specifier at pattern_i index.
1387 // Return the index of a matching bootstrap specifier or (-1) if there is no match.
1388 int ConstantPool::find_matching_operand(int pattern_i,
1389 constantPoolHandle search_cp, int search_len, TRAPS) {
1390 for (int i = 0; i < search_len; i++) {
1391 bool found = compare_operand_to(pattern_i, search_cp, i, CHECK_(-1));
1392 if (found) {
1393 return i;
1394 }
1395 }
1396 return -1; // bootstrap specifier not found; return unused index (-1)
1397 } // end find_matching_operand()
1398
1399
1400 #ifndef PRODUCT
1401
1402 const char* ConstantPool::printable_name_at(int which) {
1403
1404 constantTag tag = tag_at(which);
1405
1406 if (tag.is_string()) {
1407 return string_at_noresolve(which);
1408 } else if (tag.is_klass() || tag.is_unresolved_klass()) {
1409 return klass_name_at(which)->as_C_string();
1410 } else if (tag.is_symbol()) {
1411 return symbol_at(which)->as_C_string();
1412 }
1413 return "";
1414 }
1415
1416 #endif // PRODUCT
1417
1418
1419 // JVMTI GetConstantPool support
1420
1421 // For debugging of constant pool
1422 const bool debug_cpool = false;
1423
1424 #define DBG(code) do { if (debug_cpool) { (code); } } while(0)
1425
1426 static void print_cpool_bytes(jint cnt, u1 *bytes) {
1427 const char* WARN_MSG = "Must not be such entry!";
1428 jint size = 0;
1429 u2 idx1, idx2;
1430
1431 for (jint idx = 1; idx < cnt; idx++) {
1432 jint ent_size = 0;
1433 u1 tag = *bytes++;
1434 size++; // count tag
1435
1436 printf("const #%03d, tag: %02d ", idx, tag);
1437 switch(tag) {
1438 case JVM_CONSTANT_Invalid: {
1439 printf("Invalid");
1440 break;
1441 }
1442 case JVM_CONSTANT_Unicode: {
1443 printf("Unicode %s", WARN_MSG);
1444 break;
1445 }
1446 case JVM_CONSTANT_Utf8: {
1447 u2 len = Bytes::get_Java_u2(bytes);
1448 char str[128];
1449 if (len > 127) {
1450 len = 127;
1451 }
1452 strncpy(str, (char *) (bytes+2), len);
1453 str[len] = '\0';
1454 printf("Utf8 \"%s\"", str);
1455 ent_size = 2 + len;
1456 break;
1457 }
1458 case JVM_CONSTANT_Integer: {
1459 u4 val = Bytes::get_Java_u4(bytes);
1460 printf("int %d", *(int *) &val);
1461 ent_size = 4;
1462 break;
1463 }
1464 case JVM_CONSTANT_Float: {
1465 u4 val = Bytes::get_Java_u4(bytes);
1466 printf("float %5.3ff", *(float *) &val);
1467 ent_size = 4;
1468 break;
1469 }
1470 case JVM_CONSTANT_Long: {
1471 u8 val = Bytes::get_Java_u8(bytes);
1472 printf("long "INT64_FORMAT, (int64_t) *(jlong *) &val);
1473 ent_size = 8;
1474 idx++; // Long takes two cpool slots
1475 break;
1476 }
1477 case JVM_CONSTANT_Double: {
1478 u8 val = Bytes::get_Java_u8(bytes);
1479 printf("double %5.3fd", *(jdouble *)&val);
1480 ent_size = 8;
1481 idx++; // Double takes two cpool slots
1482 break;
1483 }
1484 case JVM_CONSTANT_Class: {
1485 idx1 = Bytes::get_Java_u2(bytes);
1486 printf("class #%03d", idx1);
1487 ent_size = 2;
1488 break;
1489 }
1490 case JVM_CONSTANT_String: {
1491 idx1 = Bytes::get_Java_u2(bytes);
1492 printf("String #%03d", idx1);
1493 ent_size = 2;
1494 break;
1495 }
1496 case JVM_CONSTANT_Fieldref: {
1497 idx1 = Bytes::get_Java_u2(bytes);
1498 idx2 = Bytes::get_Java_u2(bytes+2);
1499 printf("Field #%03d, #%03d", (int) idx1, (int) idx2);
1500 ent_size = 4;
1501 break;
1502 }
1503 case JVM_CONSTANT_Methodref: {
1504 idx1 = Bytes::get_Java_u2(bytes);
1505 idx2 = Bytes::get_Java_u2(bytes+2);
1506 printf("Method #%03d, #%03d", idx1, idx2);
1507 ent_size = 4;
1508 break;
1509 }
1510 case JVM_CONSTANT_InterfaceMethodref: {
1511 idx1 = Bytes::get_Java_u2(bytes);
1512 idx2 = Bytes::get_Java_u2(bytes+2);
1513 printf("InterfMethod #%03d, #%03d", idx1, idx2);
1514 ent_size = 4;
1515 break;
1516 }
1517 case JVM_CONSTANT_NameAndType: {
1518 idx1 = Bytes::get_Java_u2(bytes);
1519 idx2 = Bytes::get_Java_u2(bytes+2);
1520 printf("NameAndType #%03d, #%03d", idx1, idx2);
1521 ent_size = 4;
1522 break;
1523 }
1524 case JVM_CONSTANT_ClassIndex: {
1525 printf("ClassIndex %s", WARN_MSG);
1526 break;
1527 }
1528 case JVM_CONSTANT_UnresolvedClass: {
1529 printf("UnresolvedClass: %s", WARN_MSG);
1530 break;
1531 }
1532 case JVM_CONSTANT_UnresolvedClassInError: {
1533 printf("UnresolvedClassInErr: %s", WARN_MSG);
1534 break;
1535 }
1536 case JVM_CONSTANT_StringIndex: {
1537 printf("StringIndex: %s", WARN_MSG);
1538 break;
1539 }
1540 }
1541 printf(";\n");
1542 bytes += ent_size;
1543 size += ent_size;
1544 }
1545 printf("Cpool size: %d\n", size);
1546 fflush(0);
1547 return;
1548 } /* end print_cpool_bytes */
1549
1550
1551 // Returns size of constant pool entry.
1552 jint ConstantPool::cpool_entry_size(jint idx) {
1553 switch(tag_at(idx).value()) {
1554 case JVM_CONSTANT_Invalid:
1555 case JVM_CONSTANT_Unicode:
1556 return 1;
1557
1558 case JVM_CONSTANT_Utf8:
1559 return 3 + symbol_at(idx)->utf8_length();
1560
1561 case JVM_CONSTANT_Class:
1562 case JVM_CONSTANT_String:
1563 case JVM_CONSTANT_ClassIndex:
1564 case JVM_CONSTANT_UnresolvedClass:
1565 case JVM_CONSTANT_UnresolvedClassInError:
1566 case JVM_CONSTANT_StringIndex:
1567 case JVM_CONSTANT_MethodType:
1568 case JVM_CONSTANT_MethodTypeInError:
1569 return 3;
1570
1571 case JVM_CONSTANT_MethodHandle:
1572 case JVM_CONSTANT_MethodHandleInError:
1573 return 4; //tag, ref_kind, ref_index
1574
1575 case JVM_CONSTANT_Integer:
1576 case JVM_CONSTANT_Float:
1577 case JVM_CONSTANT_Fieldref:
1578 case JVM_CONSTANT_Methodref:
1579 case JVM_CONSTANT_InterfaceMethodref:
1580 case JVM_CONSTANT_NameAndType:
1581 return 5;
1582
1583 case JVM_CONSTANT_InvokeDynamic:
1584 // u1 tag, u2 bsm, u2 nt
1585 return 5;
1586
1587 case JVM_CONSTANT_Long:
1588 case JVM_CONSTANT_Double:
1589 return 9;
1590 }
1591 assert(false, "cpool_entry_size: Invalid constant pool entry tag");
1592 return 1;
1593 } /* end cpool_entry_size */
1594
1595
1596 // SymbolHashMap is used to find a constant pool index from a string.
1597 // This function fills in SymbolHashMaps, one for utf8s and one for
1598 // class names, returns size of the cpool raw bytes.
1599 jint ConstantPool::hash_entries_to(SymbolHashMap *symmap,
1600 SymbolHashMap *classmap) {
1601 jint size = 0;
1602
1603 for (u2 idx = 1; idx < length(); idx++) {
1604 u2 tag = tag_at(idx).value();
1605 size += cpool_entry_size(idx);
1606
1607 switch(tag) {
1608 case JVM_CONSTANT_Utf8: {
1609 Symbol* sym = symbol_at(idx);
1610 symmap->add_entry(sym, idx);
1611 DBG(printf("adding symbol entry %s = %d\n", sym->as_utf8(), idx));
1612 break;
1613 }
1614 case JVM_CONSTANT_Class:
1615 case JVM_CONSTANT_UnresolvedClass:
1616 case JVM_CONSTANT_UnresolvedClassInError: {
1617 Symbol* sym = klass_name_at(idx);
1618 classmap->add_entry(sym, idx);
1619 DBG(printf("adding class entry %s = %d\n", sym->as_utf8(), idx));
1620 break;
1621 }
1622 case JVM_CONSTANT_Long:
1623 case JVM_CONSTANT_Double: {
1624 idx++; // Both Long and Double take two cpool slots
1625 break;
1626 }
1627 }
1628 }
1629 return size;
1630 } /* end hash_utf8_entries_to */
1631
1632
1633 // Copy cpool bytes.
1634 // Returns:
1635 // 0, in case of OutOfMemoryError
1636 // -1, in case of internal error
1637 // > 0, count of the raw cpool bytes that have been copied
1638 int ConstantPool::copy_cpool_bytes(int cpool_size,
1639 SymbolHashMap* tbl,
1640 unsigned char *bytes) {
1641 u2 idx1, idx2;
1642 jint size = 0;
1643 jint cnt = length();
1644 unsigned char *start_bytes = bytes;
1645
1646 for (jint idx = 1; idx < cnt; idx++) {
1647 u1 tag = tag_at(idx).value();
1648 jint ent_size = cpool_entry_size(idx);
1649
1650 assert(size + ent_size <= cpool_size, "Size mismatch");
1651
1652 *bytes = tag;
1653 DBG(printf("#%03hd tag=%03hd, ", idx, tag));
1654 switch(tag) {
1655 case JVM_CONSTANT_Invalid: {
1656 DBG(printf("JVM_CONSTANT_Invalid"));
1657 break;
1658 }
1659 case JVM_CONSTANT_Unicode: {
1660 assert(false, "Wrong constant pool tag: JVM_CONSTANT_Unicode");
1661 DBG(printf("JVM_CONSTANT_Unicode"));
1662 break;
1663 }
1664 case JVM_CONSTANT_Utf8: {
1665 Symbol* sym = symbol_at(idx);
1666 char* str = sym->as_utf8();
1667 // Warning! It's crashing on x86 with len = sym->utf8_length()
1668 int len = (int) strlen(str);
1669 Bytes::put_Java_u2((address) (bytes+1), (u2) len);
1670 for (int i = 0; i < len; i++) {
1671 bytes[3+i] = (u1) str[i];
1672 }
1673 DBG(printf("JVM_CONSTANT_Utf8: %s ", str));
1674 break;
1675 }
1676 case JVM_CONSTANT_Integer: {
1677 jint val = int_at(idx);
1678 Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1679 break;
1680 }
1681 case JVM_CONSTANT_Float: {
1682 jfloat val = float_at(idx);
1683 Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1684 break;
1685 }
1686 case JVM_CONSTANT_Long: {
1687 jlong val = long_at(idx);
1688 Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1689 idx++; // Long takes two cpool slots
1690 break;
1691 }
1692 case JVM_CONSTANT_Double: {
1693 jdouble val = double_at(idx);
1694 Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1695 idx++; // Double takes two cpool slots
1696 break;
1697 }
1698 case JVM_CONSTANT_Class:
1699 case JVM_CONSTANT_UnresolvedClass:
1700 case JVM_CONSTANT_UnresolvedClassInError: {
1701 *bytes = JVM_CONSTANT_Class;
1702 Symbol* sym = klass_name_at(idx);
1703 idx1 = tbl->symbol_to_value(sym);
1704 assert(idx1 != 0, "Have not found a hashtable entry");
1705 Bytes::put_Java_u2((address) (bytes+1), idx1);
1706 DBG(printf("JVM_CONSTANT_Class: idx=#%03hd, %s", idx1, sym->as_utf8()));
1707 break;
1708 }
1709 case JVM_CONSTANT_String: {
1710 *bytes = JVM_CONSTANT_String;
1711 Symbol* sym = unresolved_string_at(idx);
1712 idx1 = tbl->symbol_to_value(sym);
1713 assert(idx1 != 0, "Have not found a hashtable entry");
1714 Bytes::put_Java_u2((address) (bytes+1), idx1);
1715 DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, sym->as_utf8()));
1716 break;
1717 }
1718 case JVM_CONSTANT_Fieldref:
1719 case JVM_CONSTANT_Methodref:
1720 case JVM_CONSTANT_InterfaceMethodref: {
1721 idx1 = uncached_klass_ref_index_at(idx);
1722 idx2 = uncached_name_and_type_ref_index_at(idx);
1723 Bytes::put_Java_u2((address) (bytes+1), idx1);
1724 Bytes::put_Java_u2((address) (bytes+3), idx2);
1725 DBG(printf("JVM_CONSTANT_Methodref: %hd %hd", idx1, idx2));
1726 break;
1727 }
1728 case JVM_CONSTANT_NameAndType: {
1729 idx1 = name_ref_index_at(idx);
1730 idx2 = signature_ref_index_at(idx);
1731 Bytes::put_Java_u2((address) (bytes+1), idx1);
1732 Bytes::put_Java_u2((address) (bytes+3), idx2);
1733 DBG(printf("JVM_CONSTANT_NameAndType: %hd %hd", idx1, idx2));
1734 break;
1735 }
1736 case JVM_CONSTANT_ClassIndex: {
1737 *bytes = JVM_CONSTANT_Class;
1738 idx1 = klass_index_at(idx);
1739 Bytes::put_Java_u2((address) (bytes+1), idx1);
1740 DBG(printf("JVM_CONSTANT_ClassIndex: %hd", idx1));
1741 break;
1742 }
1743 case JVM_CONSTANT_StringIndex: {
1744 *bytes = JVM_CONSTANT_String;
1745 idx1 = string_index_at(idx);
1746 Bytes::put_Java_u2((address) (bytes+1), idx1);
1747 DBG(printf("JVM_CONSTANT_StringIndex: %hd", idx1));
1748 break;
1749 }
1750 case JVM_CONSTANT_MethodHandle:
1751 case JVM_CONSTANT_MethodHandleInError: {
1752 *bytes = JVM_CONSTANT_MethodHandle;
1753 int kind = method_handle_ref_kind_at_error_ok(idx);
1754 idx1 = method_handle_index_at_error_ok(idx);
1755 *(bytes+1) = (unsigned char) kind;
1756 Bytes::put_Java_u2((address) (bytes+2), idx1);
1757 DBG(printf("JVM_CONSTANT_MethodHandle: %d %hd", kind, idx1));
1758 break;
1759 }
1760 case JVM_CONSTANT_MethodType:
1761 case JVM_CONSTANT_MethodTypeInError: {
1762 *bytes = JVM_CONSTANT_MethodType;
1763 idx1 = method_type_index_at_error_ok(idx);
1764 Bytes::put_Java_u2((address) (bytes+1), idx1);
1765 DBG(printf("JVM_CONSTANT_MethodType: %hd", idx1));
1766 break;
1767 }
1768 case JVM_CONSTANT_InvokeDynamic: {
1769 *bytes = tag;
1770 idx1 = extract_low_short_from_int(*int_at_addr(idx));
1771 idx2 = extract_high_short_from_int(*int_at_addr(idx));
1772 assert(idx2 == invoke_dynamic_name_and_type_ref_index_at(idx), "correct half of u4");
1773 Bytes::put_Java_u2((address) (bytes+1), idx1);
1774 Bytes::put_Java_u2((address) (bytes+3), idx2);
1775 DBG(printf("JVM_CONSTANT_InvokeDynamic: %hd %hd", idx1, idx2));
1776 break;
1777 }
1778 }
1779 DBG(printf("\n"));
1780 bytes += ent_size;
1781 size += ent_size;
1782 }
1783 assert(size == cpool_size, "Size mismatch");
1784
1785 // Keep temorarily for debugging until it's stable.
1786 DBG(print_cpool_bytes(cnt, start_bytes));
1787 return (int)(bytes - start_bytes);
1788 } /* end copy_cpool_bytes */
1789
1790 #undef DBG
1791
1792
1793 void ConstantPool::set_on_stack(const bool value) {
1794 if (value) {
1795 int old_flags = *const_cast<volatile int *>(&_flags);
1796 while ((old_flags & _on_stack) == 0) {
1797 int new_flags = old_flags | _on_stack;
1798 int result = Atomic::cmpxchg(new_flags, &_flags, old_flags);
1799
1800 if (result == old_flags) {
1801 // Succeeded.
1802 MetadataOnStackMark::record(this, Thread::current());
1803 return;
1804 }
1805 old_flags = result;
1806 }
1807 } else {
1808 // Clearing is done single-threadedly.
1809 _flags &= ~_on_stack;
1810 }
1811 }
1812
1813 // JSR 292 support for patching constant pool oops after the class is linked and
1814 // the oop array for resolved references are created.
1815 // We can't do this during classfile parsing, which is how the other indexes are
1816 // patched. The other patches are applied early for some error checking
1817 // so only defer the pseudo_strings.
1818 void ConstantPool::patch_resolved_references(GrowableArray<Handle>* cp_patches) {
1819 for (int index = 1; index < cp_patches->length(); index++) { // Index 0 is unused
1820 Handle patch = cp_patches->at(index);
1821 if (patch.not_null()) {
1822 assert (tag_at(index).is_string(), "should only be string left");
1823 // Patching a string means pre-resolving it.
1824 // The spelling in the constant pool is ignored.
1825 // The constant reference may be any object whatever.
1826 // If it is not a real interned string, the constant is referred
1827 // to as a "pseudo-string", and must be presented to the CP
1828 // explicitly, because it may require scavenging.
1829 int obj_index = cp_to_object_index(index);
1830 pseudo_string_at_put(index, obj_index, patch());
1831 DEBUG_ONLY(cp_patches->at_put(index, Handle());)
1832 }
1833 }
1834 #ifdef ASSERT
1835 // Ensure that all the patches have been used.
1836 for (int index = 0; index < cp_patches->length(); index++) {
1837 assert(cp_patches->at(index).is_null(),
1838 err_msg("Unused constant pool patch at %d in class file %s",
1839 index,
1840 pool_holder()->external_name()));
1841 }
1842 #endif // ASSERT
1843 }
1844
1845 #ifndef PRODUCT
1846
1847 // CompileTheWorld support. Preload all classes loaded references in the passed in constantpool
1848 void ConstantPool::preload_and_initialize_all_classes(ConstantPool* obj, TRAPS) {
1849 guarantee(obj->is_constantPool(), "object must be constant pool");
1850 constantPoolHandle cp(THREAD, (ConstantPool*)obj);
1851 guarantee(cp->pool_holder() != NULL, "must be fully loaded");
1852
1853 for (int i = 0; i< cp->length(); i++) {
1854 if (cp->tag_at(i).is_unresolved_klass()) {
1855 // This will force loading of the class
1856 Klass* klass = cp->klass_at(i, CHECK);
1857 if (klass->oop_is_instance()) {
1858 // Force initialization of class
1859 InstanceKlass::cast(klass)->initialize(CHECK);
1860 }
1861 }
1862 }
1863 }
1864
1865 #endif
1866
1867
1868 // Printing
1869
1870 void ConstantPool::print_on(outputStream* st) const {
1871 assert(is_constantPool(), "must be constantPool");
1872 st->print_cr("%s", internal_name());
1873 if (flags() != 0) {
1874 st->print(" - flags: 0x%x", flags());
1875 if (has_preresolution()) st->print(" has_preresolution");
1876 if (on_stack()) st->print(" on_stack");
1877 st->cr();
1878 }
1879 if (pool_holder() != NULL) {
1880 st->print_cr(" - holder: " INTPTR_FORMAT, pool_holder());
1881 }
1882 st->print_cr(" - cache: " INTPTR_FORMAT, cache());
1883 st->print_cr(" - resolved_references: " INTPTR_FORMAT, (void *)resolved_references());
1884 st->print_cr(" - reference_map: " INTPTR_FORMAT, reference_map());
1885
1886 for (int index = 1; index < length(); index++) { // Index 0 is unused
1887 ((ConstantPool*)this)->print_entry_on(index, st);
1888 switch (tag_at(index).value()) {
1889 case JVM_CONSTANT_Long :
1890 case JVM_CONSTANT_Double :
1891 index++; // Skip entry following eigth-byte constant
1892 }
1893
1894 }
1895 st->cr();
1896 }
1897
1898 // Print one constant pool entry
1899 void ConstantPool::print_entry_on(const int index, outputStream* st) {
1900 EXCEPTION_MARK;
1901 st->print(" - %3d : ", index);
1902 tag_at(index).print_on(st);
1903 st->print(" : ");
1904 switch (tag_at(index).value()) {
1905 case JVM_CONSTANT_Class :
1906 { Klass* k = klass_at(index, CATCH);
1907 guarantee(k != NULL, "need klass");
1908 k->print_value_on(st);
1909 st->print(" {0x%lx}", (address)k);
1910 }
1911 break;
1912 case JVM_CONSTANT_Fieldref :
1913 case JVM_CONSTANT_Methodref :
1914 case JVM_CONSTANT_InterfaceMethodref :
1915 st->print("klass_index=%d", uncached_klass_ref_index_at(index));
1916 st->print(" name_and_type_index=%d", uncached_name_and_type_ref_index_at(index));
1917 break;
1918 case JVM_CONSTANT_String :
1919 if (is_pseudo_string_at(index)) {
1920 oop anObj = pseudo_string_at(index);
1921 anObj->print_value_on(st);
1922 st->print(" {0x%lx}", (address)anObj);
1923 } else {
1924 unresolved_string_at(index)->print_value_on(st);
1925 }
1926 break;
1927 case JVM_CONSTANT_Integer :
1928 st->print("%d", int_at(index));
1929 break;
1930 case JVM_CONSTANT_Float :
1931 st->print("%f", float_at(index));
1932 break;
1933 case JVM_CONSTANT_Long :
1934 st->print_jlong(long_at(index));
1935 break;
1936 case JVM_CONSTANT_Double :
1937 st->print("%lf", double_at(index));
1938 break;
1939 case JVM_CONSTANT_NameAndType :
1940 st->print("name_index=%d", name_ref_index_at(index));
1941 st->print(" signature_index=%d", signature_ref_index_at(index));
1942 break;
1943 case JVM_CONSTANT_Utf8 :
1944 symbol_at(index)->print_value_on(st);
1945 break;
1946 case JVM_CONSTANT_UnresolvedClass : // fall-through
1947 case JVM_CONSTANT_UnresolvedClassInError: {
1948 CPSlot entry = slot_at(index);
1949 if (entry.is_resolved()) {
1950 entry.get_klass()->print_value_on(st);
1951 } else {
1952 entry.get_symbol()->print_value_on(st);
1953 }
1954 }
1955 break;
1956 case JVM_CONSTANT_MethodHandle :
1957 case JVM_CONSTANT_MethodHandleInError :
1958 st->print("ref_kind=%d", method_handle_ref_kind_at_error_ok(index));
1959 st->print(" ref_index=%d", method_handle_index_at_error_ok(index));
1960 break;
1961 case JVM_CONSTANT_MethodType :
1962 case JVM_CONSTANT_MethodTypeInError :
1963 st->print("signature_index=%d", method_type_index_at_error_ok(index));
1964 break;
1965 case JVM_CONSTANT_InvokeDynamic :
1966 {
1967 st->print("bootstrap_method_index=%d", invoke_dynamic_bootstrap_method_ref_index_at(index));
1968 st->print(" name_and_type_index=%d", invoke_dynamic_name_and_type_ref_index_at(index));
1969 int argc = invoke_dynamic_argument_count_at(index);
1970 if (argc > 0) {
1971 for (int arg_i = 0; arg_i < argc; arg_i++) {
1972 int arg = invoke_dynamic_argument_index_at(index, arg_i);
1973 st->print((arg_i == 0 ? " arguments={%d" : ", %d"), arg);
1974 }
1975 st->print("}");
1976 }
1977 }
1978 break;
1979 default:
1980 ShouldNotReachHere();
1981 break;
1982 }
1983 st->cr();
1984 }
1985
1986 void ConstantPool::print_value_on(outputStream* st) const {
1987 assert(is_constantPool(), "must be constantPool");
1988 st->print("constant pool [%d]", length());
1989 if (has_preresolution()) st->print("/preresolution");
1990 if (operands() != NULL) st->print("/operands[%d]", operands()->length());
1991 print_address_on(st);
1992 st->print(" for ");
1993 pool_holder()->print_value_on(st);
1994 if (pool_holder() != NULL) {
1995 bool extra = (pool_holder()->constants() != this);
1996 if (extra) st->print(" (extra)");
1997 }
1998 if (cache() != NULL) {
1999 st->print(" cache=" PTR_FORMAT, cache());
2000 }
2001 }
2002
2003 #if INCLUDE_SERVICES
2004 // Size Statistics
2005 void ConstantPool::collect_statistics(KlassSizeStats *sz) const {
2006 sz->_cp_all_bytes += (sz->_cp_bytes = sz->count(this));
2007 sz->_cp_all_bytes += (sz->_cp_tags_bytes = sz->count_array(tags()));
2008 sz->_cp_all_bytes += (sz->_cp_cache_bytes = sz->count(cache()));
2009 sz->_cp_all_bytes += (sz->_cp_operands_bytes = sz->count_array(operands()));
2010 sz->_cp_all_bytes += (sz->_cp_refmap_bytes = sz->count_array(reference_map()));
2011
2012 sz->_ro_bytes += sz->_cp_operands_bytes + sz->_cp_tags_bytes +
2013 sz->_cp_refmap_bytes;
2014 sz->_rw_bytes += sz->_cp_bytes + sz->_cp_cache_bytes;
2015 }
2016 #endif // INCLUDE_SERVICES
2017
2018 // Verification
2019
2020 void ConstantPool::verify_on(outputStream* st) {
2021 guarantee(is_constantPool(), "object must be constant pool");
2022 for (int i = 0; i< length(); i++) {
2023 constantTag tag = tag_at(i);
2024 CPSlot entry = slot_at(i);
2025 if (tag.is_klass()) {
2026 if (entry.is_resolved()) {
2027 guarantee(entry.get_klass()->is_klass(), "should be klass");
2028 }
2029 } else if (tag.is_unresolved_klass()) {
2030 if (entry.is_resolved()) {
2031 guarantee(entry.get_klass()->is_klass(), "should be klass");
2032 }
2033 } else if (tag.is_symbol()) {
2034 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
2035 } else if (tag.is_string()) {
2036 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
2037 }
2038 }
2039 if (cache() != NULL) {
2040 // Note: cache() can be NULL before a class is completely setup or
2041 // in temporary constant pools used during constant pool merging
2042 guarantee(cache()->is_constantPoolCache(), "should be constant pool cache");
2043 }
2044 if (pool_holder() != NULL) {
2045 // Note: pool_holder() can be NULL in temporary constant pools
2046 // used during constant pool merging
2047 guarantee(pool_holder()->is_klass(), "should be klass");
2048 }
2049 }
2050
2051
2052 void SymbolHashMap::add_entry(Symbol* sym, u2 value) {
2053 char *str = sym->as_utf8();
2054 unsigned int hash = compute_hash(str, sym->utf8_length());
2055 unsigned int index = hash % table_size();
2056
2057 // check if already in map
2058 // we prefer the first entry since it is more likely to be what was used in
2059 // the class file
2060 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
2061 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
2062 if (en->hash() == hash && en->symbol() == sym) {
2063 return; // already there
2064 }
2065 }
2066
2067 SymbolHashMapEntry* entry = new SymbolHashMapEntry(hash, sym, value);
2068 entry->set_next(bucket(index));
2069 _buckets[index].set_entry(entry);
2070 assert(entry->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
2071 }
2072
2073 SymbolHashMapEntry* SymbolHashMap::find_entry(Symbol* sym) {
2074 assert(sym != NULL, "SymbolHashMap::find_entry - symbol is NULL");
2075 char *str = sym->as_utf8();
2076 int len = sym->utf8_length();
2077 unsigned int hash = SymbolHashMap::compute_hash(str, len);
2078 unsigned int index = hash % table_size();
2079 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
2080 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
2081 if (en->hash() == hash && en->symbol() == sym) {
2082 return en;
2083 }
2084 }
2085 return NULL;
2086 }