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