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