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