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_metadata(loader_data, cache());

    93     set_cache(NULL);

    94   }

    95 

    96   MetadataFactory::free_array<Klass*>(loader_data, resolved_klasses());

    97   set_resolved_klasses(NULL);

    98 

    99   MetadataFactory::free_array<jushort>(loader_data, operands());

   100   set_operands(NULL);

   101 

   102   release_C_heap_structures();

   103 

   104   // free tag array

   105   MetadataFactory::free_array<u1>(loader_data, tags());

   106   set_tags(NULL);

   107 }

   108 

   109 void ConstantPool::release_C_heap_structures() {

   110   // walk constant pool and decrement symbol reference counts

   111   unreference_symbols();

   112 }

   113 

   114 void ConstantPool::metaspace_pointers_do(MetaspaceClosure* it) {

   115   log_trace(cds)("Iter(ConstantPool): %p", this);

   116 

   117   it->push(&_tags, MetaspaceClosure::_writable);

   118   it->push(&_cache);

   119   it->push(&_pool_holder);

   120   it->push(&_operands);

   121   it->push(&_resolved_klasses, MetaspaceClosure::_writable);

   122 

   123   for (int i = 0; i < length(); i++) {

   124     // The only MSO's embedded in the CP entries are Symbols:

   125     //   JVM_CONSTANT_String (normal and pseudo)

   126     //   JVM_CONSTANT_Utf8

   127     constantTag ctag = tag_at(i);

   128     if (ctag.is_string() || ctag.is_utf8()) {

   129       it->push(symbol_at_addr(i));

   130     }

   131   }

   132 }

   133 

   134 objArrayOop ConstantPool::resolved_references() const {

   135   return (objArrayOop)_cache->resolved_references();

   136 }

   137 

   138 // Create resolved_references array and mapping array for original cp indexes

   139 // The ldc bytecode was rewritten to have the resolved reference array index so need a way

   140 // to map it back for resolving and some unlikely miscellaneous uses.

   141 // The objects created by invokedynamic are appended to this list.

   142 void ConstantPool::initialize_resolved_references(ClassLoaderData* loader_data,

   143                                                   const intStack& reference_map,

   144                                                   int constant_pool_map_length,

   145                                                   TRAPS) {

   146   // Initialized the resolved object cache.

   147   int map_length = reference_map.length();

   148   if (map_length > 0) {

   149     // Only need mapping back to constant pool entries.  The map isn't used for

   150     // invokedynamic resolved_reference entries.  For invokedynamic entries,

   151     // the constant pool cache index has the mapping back to both the constant

   152     // pool and to the resolved reference index.

   153     if (constant_pool_map_length > 0) {

   154       Array<u2>* om = MetadataFactory::new_array<u2>(loader_data, constant_pool_map_length, CHECK);

   155 

   156       for (int i = 0; i < constant_pool_map_length; i++) {

   157         int x = reference_map.at(i);

   158         assert(x == (int)(jushort) x, "klass index is too big");

   159         om->at_put(i, (jushort)x);

   160       }

   161       set_reference_map(om);

   162     }

   163 

   164     // Create Java array for holding resolved strings, methodHandles,

   165     // methodTypes, invokedynamic and invokehandle appendix objects, etc.

   166     objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);

   167     Handle refs_handle (THREAD, (oop)stom);  // must handleize.

   168     set_resolved_references(loader_data->add_handle(refs_handle));

   169   }

   170 }

   171 

   172 void ConstantPool::allocate_resolved_klasses(ClassLoaderData* loader_data, int num_klasses, TRAPS) {

   173   // A ConstantPool can't possibly have 0xffff valid class entries,

   174   // because entry #0 must be CONSTANT_Invalid, and each class entry must refer to a UTF8

   175   // entry for the class's name. So at most we will have 0xfffe class entries.

   176   // This allows us to use 0xffff (ConstantPool::_temp_resolved_klass_index) to indicate

   177   // UnresolvedKlass entries that are temporarily created during class redefinition.

   178   assert(num_klasses < CPKlassSlot::_temp_resolved_klass_index, "sanity");

   179   assert(resolved_klasses() == NULL, "sanity");

   180   Array<Klass*>* rk = MetadataFactory::new_array<Klass*>(loader_data, num_klasses, CHECK);

   181   set_resolved_klasses(rk);

   182 }

   183 

   184 void ConstantPool::initialize_unresolved_klasses(ClassLoaderData* loader_data, TRAPS) {

   185   int len = length();

   186   int num_klasses = 0;

   187   for (int i = 1; i <len; i++) {

   188     switch (tag_at(i).value()) {

   189     case JVM_CONSTANT_ClassIndex:

   190       {

   191         const int class_index = klass_index_at(i);

   192         unresolved_klass_at_put(i, class_index, num_klasses++);

   193       }

   194       break;

   195 #ifndef PRODUCT

   196     case JVM_CONSTANT_Class:

   197     case JVM_CONSTANT_UnresolvedClass:

   198     case JVM_CONSTANT_UnresolvedClassInError:

   199       // All of these should have been reverted back to ClassIndex before calling

   200       // this function.

   201       ShouldNotReachHere();

   202 #endif

   203     }

   204   }

   205   allocate_resolved_klasses(loader_data, num_klasses, THREAD);

   206 }

   207 

   208 // Anonymous class support:

   209 void ConstantPool::klass_at_put(int class_index, int name_index, int resolved_klass_index, Klass* k, Symbol* name) {

   210   assert(is_within_bounds(class_index), "index out of bounds");

   211   assert(is_within_bounds(name_index), "index out of bounds");

   212   assert((resolved_klass_index & 0xffff0000) == 0, "must be");

   213   *int_at_addr(class_index) =

   214     build_int_from_shorts((jushort)resolved_klass_index, (jushort)name_index);

   215 

   216   symbol_at_put(name_index, name);

   217   name->increment_refcount();

   218   Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);

   219   OrderAccess::release_store_ptr((Klass* volatile *)adr, k);

   220 

   221   // The interpreter assumes when the tag is stored, the klass is resolved

   222   // and the Klass* non-NULL, so we need hardware store ordering here.

   223   if (k != NULL) {

   224     release_tag_at_put(class_index, JVM_CONSTANT_Class);

   225   } else {

   226     release_tag_at_put(class_index, JVM_CONSTANT_UnresolvedClass);

   227   }

   228 }

   229 

   230 // Anonymous class support:

   231 void ConstantPool::klass_at_put(int class_index, Klass* k) {

   232   assert(k != NULL, "must be valid klass");

   233   CPKlassSlot kslot = klass_slot_at(class_index);

   234   int resolved_klass_index = kslot.resolved_klass_index();

   235   Klass** adr = resolved_klasses()->adr_at(resolved_klass_index);

   236   OrderAccess::release_store_ptr((Klass* volatile *)adr, k);

   237 

   238   // The interpreter assumes when the tag is stored, the klass is resolved

   239   // and the Klass* non-NULL, so we need hardware store ordering here.

   240   release_tag_at_put(class_index, JVM_CONSTANT_Class);

   241 }

   242 

   243 #if INCLUDE_CDS_JAVA_HEAP

   244 // Archive the resolved references

   245 void ConstantPool::archive_resolved_references(Thread* THREAD) {

   246   if (_cache == NULL) {

   247     return; // nothing to do

   248   }

   249 

   250   InstanceKlass *ik = pool_holder();

   251   if (!(ik->is_shared_boot_class() || ik->is_shared_platform_class() ||

   252         ik->is_shared_app_class())) {

   253     // Archiving resolved references for classes from non-builtin loaders

   254     // is not yet supported.

   255     set_resolved_references(NULL);

   256     return;

   257   }

   258 

   259   objArrayOop rr = resolved_references();

   260   Array<u2>* ref_map = reference_map();

   261   if (rr != NULL) {

   262     int ref_map_len = ref_map == NULL ? 0 : ref_map->length();

   263     int rr_len = rr->length();

   264     for (int i = 0; i < rr_len; i++) {

   265       oop p = rr->obj_at(i);

   266       rr->obj_at_put(i, NULL);

   267       if (p != NULL && i < ref_map_len) {

   268         int index = object_to_cp_index(i);

   269         // Skip the entry if the string hash code is 0 since the string

   270         // is not included in the shared string_table, see StringTable::copy_shared_string.

   271         if (tag_at(index).is_string() && java_lang_String::hash_code(p) != 0) {

   272           oop op = StringTable::create_archived_string(p, THREAD);

   273           // If the String object is not archived (possibly too large),

   274           // NULL is returned. Also set it in the array, so we won't

   275           // have a 'bad' reference in the archived resolved_reference

   276           // array.

   277           rr->obj_at_put(i, op);

   278         }

   279       }

   280     }

   281 

   282     oop archived = MetaspaceShared::archive_heap_object(rr, THREAD);

   283     _cache->set_archived_references(archived);

   284     set_resolved_references(NULL);

   285   }

   286 }

   287 #endif

   288 

   289 // CDS support. Create a new resolved_references array.

   290 void ConstantPool::restore_unshareable_info(TRAPS) {

   291   assert(is_constantPool(), "ensure C++ vtable is restored");

   292   assert(on_stack(), "should always be set for shared constant pools");

   293   assert(is_shared(), "should always be set for shared constant pools");

   294   assert(_cache != NULL, "constant pool _cache should not be NULL");

   295 

   296   // Only create the new resolved references array if it hasn't been attempted before

   297   if (resolved_references() != NULL) return;

   298 

   299   // restore the C++ vtable from the shared archive

   300   restore_vtable();

   301 

   302   if (SystemDictionary::Object_klass_loaded()) {

   303     ClassLoaderData* loader_data = pool_holder()->class_loader_data();

   304 #if INCLUDE_CDS_JAVA_HEAP

   305     if (MetaspaceShared::open_archive_heap_region_mapped() &&

   306         _cache->archived_references() != NULL) {

   307       oop archived = _cache->archived_references();

   308       // Make sure GC knows the cached object is now live. This is necessary after

   309       // initial GC marking and during concurrent marking as strong roots are only

   310       // scanned during initial marking (at the start of the GC marking).

   311       assert(UseG1GC, "Requires G1 GC");

   312       G1SATBCardTableModRefBS::enqueue(archived);

   313       // Create handle for the archived resolved reference array object

   314       Handle refs_handle(THREAD, (oop)archived);

   315       set_resolved_references(loader_data->add_handle(refs_handle));

   316     } else

   317 #endif

   318     {

   319       // No mapped archived resolved reference array

   320       // Recreate the object array and add to ClassLoaderData.

   321       int map_length = resolved_reference_length();

   322       if (map_length > 0) {

   323         objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);

   324         Handle refs_handle(THREAD, (oop)stom);  // must handleize.

   325         set_resolved_references(loader_data->add_handle(refs_handle));

   326       }

   327     }

   328   }

   329 }

   330 

   331 void ConstantPool::remove_unshareable_info() {

   332   // Resolved references are not in the shared archive.

   333   // Save the length for restoration.  It is not necessarily the same length

   334   // as reference_map.length() if invokedynamic is saved. It is needed when

   335   // re-creating the resolved reference array if archived heap data cannot be map

   336   // at runtime.

   337   set_resolved_reference_length(

   338     resolved_references() != NULL ? resolved_references()->length() : 0);

   339 

   340   // If archiving heap objects is not allowed, clear the resolved references.

   341   // Otherwise, it is cleared after the resolved references array is cached

   342   // (see archive_resolved_references()).

   343   if (!MetaspaceShared::is_heap_object_archiving_allowed()) {

   344     set_resolved_references(NULL);

   345   }

   346 

   347   // Shared ConstantPools are in the RO region, so the _flags cannot be modified.

   348   // The _on_stack flag is used to prevent ConstantPools from deallocation during

   349   // class redefinition. Since shared ConstantPools cannot be deallocated anyway,

   350   // we always set _on_stack to true to avoid having to change _flags during runtime.

   351   _flags |= (_on_stack | _is_shared);

   352   int num_klasses = 0;

   353   for (int index = 1; index < length(); index++) { // Index 0 is unused

   354     assert(!tag_at(index).is_unresolved_klass_in_error(), "This must not happen during dump time");

   355     if (tag_at(index).is_klass()) {

   356       // This class was resolved as a side effect of executing Java code

   357       // during dump time. We need to restore it back to an UnresolvedClass,

   358       // so that the proper class loading and initialization can happen

   359       // at runtime.

   360       CPKlassSlot kslot = klass_slot_at(index);

   361       int resolved_klass_index = kslot.resolved_klass_index();

   362       int name_index = kslot.name_index();

   363       assert(tag_at(name_index).is_symbol(), "sanity");

   364       resolved_klasses()->at_put(resolved_klass_index, NULL);

   365       tag_at_put(index, JVM_CONSTANT_UnresolvedClass);

   366       assert(klass_name_at(index) == symbol_at(name_index), "sanity");

   367     }

   368   }

   369   if (cache() != NULL) {

   370     cache()->remove_unshareable_info();

   371   }

   372 }

   373 

   374 int ConstantPool::cp_to_object_index(int cp_index) {

   375   // this is harder don't do this so much.

   376   int i = reference_map()->find(cp_index);

   377   // We might not find the index for jsr292 call.

   378   return (i < 0) ? _no_index_sentinel : i;

   379 }

   380 

   381 void ConstantPool::string_at_put(int which, int obj_index, oop str) {

   382   resolved_references()->obj_at_put(obj_index, str);

   383 }

   384 

   385 void ConstantPool::trace_class_resolution(const constantPoolHandle& this_cp, Klass* k) {

   386   ResourceMark rm;

   387   int line_number = -1;

   388   const char * source_file = NULL;

   389   if (JavaThread::current()->has_last_Java_frame()) {

   390     // try to identify the method which called this function.

   391     vframeStream vfst(JavaThread::current());

   392     if (!vfst.at_end()) {

   393       line_number = vfst.method()->line_number_from_bci(vfst.bci());

   394       Symbol* s = vfst.method()->method_holder()->source_file_name();

   395       if (s != NULL) {

   396         source_file = s->as_C_string();

   397       }

   398     }

   399   }

   400   if (k != this_cp->pool_holder()) {

   401     // only print something if the classes are different

   402     if (source_file != NULL) {

   403       log_debug(class, resolve)("%s %s %s:%d",

   404                  this_cp->pool_holder()->external_name(),

   405                  k->external_name(), source_file, line_number);

   406     } else {

   407       log_debug(class, resolve)("%s %s",

   408                  this_cp->pool_holder()->external_name(),

   409                  k->external_name());

   410     }

   411   }

   412 }

   413 

   414 Klass* ConstantPool::klass_at_impl(const constantPoolHandle& this_cp, int which,

   415                                    bool save_resolution_error, TRAPS) {

   416   assert(THREAD->is_Java_thread(), "must be a Java thread");

   417 

   418   // A resolved constantPool entry will contain a Klass*, otherwise a Symbol*.

   419   // It is not safe to rely on the tag bit's here, since we don't have a lock, and

   420   // the entry and tag is not updated atomicly.

   421   CPKlassSlot kslot = this_cp->klass_slot_at(which);

   422   int resolved_klass_index = kslot.resolved_klass_index();

   423   int name_index = kslot.name_index();

   424   assert(this_cp->tag_at(name_index).is_symbol(), "sanity");

   425 

   426   Klass* klass = this_cp->resolved_klasses()->at(resolved_klass_index);

   427   if (klass != NULL) {

   428     return klass;

   429   }

   430 

   431   // This tag doesn't change back to unresolved class unless at a safepoint.

   432   if (this_cp->tag_at(which).is_unresolved_klass_in_error()) {

   433     // The original attempt to resolve this constant pool entry failed so find the

   434     // class of the original error and throw another error of the same class

   435     // (JVMS 5.4.3).

   436     // If there is a detail message, pass that detail message to the error.

   437     // The JVMS does not strictly require us to duplicate the same detail message,

   438     // or any internal exception fields such as cause or stacktrace.  But since the

   439     // detail message is often a class name or other literal string, we will repeat it

   440     // if we can find it in the symbol table.

   441     throw_resolution_error(this_cp, which, CHECK_0);

   442     ShouldNotReachHere();

   443   }

   444 

   445   Handle mirror_handle;

   446   Symbol* name = this_cp->symbol_at(name_index);

   447   Handle loader (THREAD, this_cp->pool_holder()->class_loader());

   448   Handle protection_domain (THREAD, this_cp->pool_holder()->protection_domain());

   449   Klass* k = SystemDictionary::resolve_or_fail(name, loader, protection_domain, true, THREAD);

   450   if (!HAS_PENDING_EXCEPTION) {

   451     // preserve the resolved klass from unloading

   452     mirror_handle = Handle(THREAD, k->java_mirror());

   453     // Do access check for klasses

   454     verify_constant_pool_resolve(this_cp, k, THREAD);

   455   }

   456 

   457   // Failed to resolve class. We must record the errors so that subsequent attempts

   458   // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).

   459   if (HAS_PENDING_EXCEPTION) {

   460     if (save_resolution_error) {

   461       save_and_throw_exception(this_cp, which, constantTag(JVM_CONSTANT_UnresolvedClass), CHECK_NULL);

   462       // If CHECK_NULL above doesn't return the exception, that means that

   463       // some other thread has beaten us and has resolved the class.

   464       // To preserve old behavior, we return the resolved class.

   465       klass = this_cp->resolved_klasses()->at(resolved_klass_index);

   466       assert(klass != NULL, "must be resolved if exception was cleared");

   467       return klass;

   468     } else {

   469       return NULL;  // return the pending exception

   470     }

   471   }

   472 

   473   // Make this class loader depend upon the class loader owning the class reference

   474   ClassLoaderData* this_key = this_cp->pool_holder()->class_loader_data();

   475   this_key->record_dependency(k, CHECK_NULL); // Can throw OOM

   476 

   477   // logging for class+resolve.

   478   if (log_is_enabled(Debug, class, resolve)){

   479     trace_class_resolution(this_cp, k);

   480   }

   481   Klass** adr = this_cp->resolved_klasses()->adr_at(resolved_klass_index);

   482   OrderAccess::release_store_ptr((Klass* volatile *)adr, k);

   483   // The interpreter assumes when the tag is stored, the klass is resolved

   484   // and the Klass* stored in _resolved_klasses is non-NULL, so we need

   485   // hardware store ordering here.

   486   this_cp->release_tag_at_put(which, JVM_CONSTANT_Class);

   487   return k;

   488 }

   489 

   490 

   491 // Does not update ConstantPool* - to avoid any exception throwing. Used

   492 // by compiler and exception handling.  Also used to avoid classloads for

   493 // instanceof operations. Returns NULL if the class has not been loaded or

   494 // if the verification of constant pool failed

   495 Klass* ConstantPool::klass_at_if_loaded(const constantPoolHandle& this_cp, int which) {

   496   CPKlassSlot kslot = this_cp->klass_slot_at(which);

   497   int resolved_klass_index = kslot.resolved_klass_index();

   498   int name_index = kslot.name_index();

   499   assert(this_cp->tag_at(name_index).is_symbol(), "sanity");

   500 

   501   Klass* k = this_cp->resolved_klasses()->at(resolved_klass_index);

   502   if (k != NULL) {

   503     return k;

   504   } else {

   505     Thread *thread = Thread::current();

   506     Symbol* name = this_cp->symbol_at(name_index);

   507     oop loader = this_cp->pool_holder()->class_loader();

   508     oop protection_domain = this_cp->pool_holder()->protection_domain();

   509     Handle h_prot (thread, protection_domain);

   510     Handle h_loader (thread, loader);

   511     Klass* k = SystemDictionary::find(name, h_loader, h_prot, thread);

   512 

   513     if (k != NULL) {

   514       // Make sure that resolving is legal

   515       EXCEPTION_MARK;

   516       // return NULL if verification fails

   517       verify_constant_pool_resolve(this_cp, k, THREAD);

   518       if (HAS_PENDING_EXCEPTION) {

   519         CLEAR_PENDING_EXCEPTION;

   520         return NULL;

   521       }

   522       return k;

   523     } else {

   524       return k;

   525     }

   526   }

   527 }

   528 

   529 

   530 Klass* ConstantPool::klass_ref_at_if_loaded(const constantPoolHandle& this_cp, int which) {

   531   return klass_at_if_loaded(this_cp, this_cp->klass_ref_index_at(which));

   532 }

   533 

   534 

   535 Method* ConstantPool::method_at_if_loaded(const constantPoolHandle& cpool,

   536                                                    int which) {

   537   if (cpool->cache() == NULL)  return NULL;  // nothing to load yet

   538   int cache_index = decode_cpcache_index(which, true);

   539   if (!(cache_index >= 0 && cache_index < cpool->cache()->length())) {

   540     // FIXME: should be an assert

   541     log_debug(class, resolve)("bad operand %d in:", which); cpool->print();

   542     return NULL;

   543   }

   544   ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

   545   return e->method_if_resolved(cpool);

   546 }

   547 

   548 

   549 bool ConstantPool::has_appendix_at_if_loaded(const constantPoolHandle& cpool, int which) {

   550   if (cpool->cache() == NULL)  return false;  // nothing to load yet

   551   int cache_index = decode_cpcache_index(which, true);

   552   ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

   553   return e->has_appendix();

   554 }

   555 

   556 oop ConstantPool::appendix_at_if_loaded(const constantPoolHandle& cpool, int which) {

   557   if (cpool->cache() == NULL)  return NULL;  // nothing to load yet

   558   int cache_index = decode_cpcache_index(which, true);

   559   ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

   560   return e->appendix_if_resolved(cpool);

   561 }

   562 

   563 

   564 bool ConstantPool::has_method_type_at_if_loaded(const constantPoolHandle& cpool, int which) {

   565   if (cpool->cache() == NULL)  return false;  // nothing to load yet

   566   int cache_index = decode_cpcache_index(which, true);

   567   ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

   568   return e->has_method_type();

   569 }

   570 

   571 oop ConstantPool::method_type_at_if_loaded(const constantPoolHandle& cpool, int which) {

   572   if (cpool->cache() == NULL)  return NULL;  // nothing to load yet

   573   int cache_index = decode_cpcache_index(which, true);

   574   ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);

   575   return e->method_type_if_resolved(cpool);

   576 }

   577 

   578 

   579 Symbol* ConstantPool::impl_name_ref_at(int which, bool uncached) {

   580   int name_index = name_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));

   581   return symbol_at(name_index);

   582 }

   583 

   584 

   585 Symbol* ConstantPool::impl_signature_ref_at(int which, bool uncached) {

   586   int signature_index = signature_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));

   587   return symbol_at(signature_index);

   588 }

   589 

   590 

   591 int ConstantPool::impl_name_and_type_ref_index_at(int which, bool uncached) {

   592   int i = which;

   593   if (!uncached && cache() != NULL) {

   594     if (ConstantPool::is_invokedynamic_index(which)) {

   595       // Invokedynamic index is index into the constant pool cache

   596       int pool_index = invokedynamic_cp_cache_entry_at(which)->constant_pool_index();

   597       pool_index = invoke_dynamic_name_and_type_ref_index_at(pool_index);

   598       assert(tag_at(pool_index).is_name_and_type(), "");

   599       return pool_index;

   600     }

   601     // change byte-ordering and go via cache

   602     i = remap_instruction_operand_from_cache(which);

   603   } else {

   604     if (tag_at(which).is_invoke_dynamic()) {

   605       int pool_index = invoke_dynamic_name_and_type_ref_index_at(which);

   606       assert(tag_at(pool_index).is_name_and_type(), "");

   607       return pool_index;

   608     }

   609   }

   610   assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");

   611   assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");

   612   jint ref_index = *int_at_addr(i);

   613   return extract_high_short_from_int(ref_index);

   614 }

   615 

   616 constantTag ConstantPool::impl_tag_ref_at(int which, bool uncached) {

   617   int pool_index = which;

   618   if (!uncached && cache() != NULL) {

   619     if (ConstantPool::is_invokedynamic_index(which)) {

   620       // Invokedynamic index is index into resolved_references

   621       pool_index = invokedynamic_cp_cache_entry_at(which)->constant_pool_index();

   622     } else {

   623       // change byte-ordering and go via cache

   624       pool_index = remap_instruction_operand_from_cache(which);

   625     }

   626   }

   627   return tag_at(pool_index);

   628 }

   629 

   630 int ConstantPool::impl_klass_ref_index_at(int which, bool uncached) {

   631   guarantee(!ConstantPool::is_invokedynamic_index(which),

   632             "an invokedynamic instruction does not have a klass");

   633   int i = which;

   634   if (!uncached && cache() != NULL) {

   635     // change byte-ordering and go via cache

   636     i = remap_instruction_operand_from_cache(which);

   637   }

   638   assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");

   639   jint ref_index = *int_at_addr(i);

   640   return extract_low_short_from_int(ref_index);

   641 }

   642 

   643 

   644 

   645 int ConstantPool::remap_instruction_operand_from_cache(int operand) {

   646   int cpc_index = operand;

   647   DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);

   648   assert((int)(u2)cpc_index == cpc_index, "clean u2");

   649   int member_index = cache()->entry_at(cpc_index)->constant_pool_index();

   650   return member_index;

   651 }

   652 

   653 

   654 void ConstantPool::verify_constant_pool_resolve(const constantPoolHandle& this_cp, Klass* k, TRAPS) {

   655  if (k->is_instance_klass() || k->is_objArray_klass()) {

   656     InstanceKlass* holder = this_cp->pool_holder();

   657     Klass* elem = k->is_instance_klass() ? k : ObjArrayKlass::cast(k)->bottom_klass();

   658 

   659     // The element type could be a typeArray - we only need the access check if it is

   660     // an reference to another class

   661     if (elem->is_instance_klass()) {

   662       LinkResolver::check_klass_accessability(holder, elem, CHECK);

   663     }

   664   }

   665 }

   666 

   667 

   668 int ConstantPool::name_ref_index_at(int which_nt) {

   669   jint ref_index = name_and_type_at(which_nt);

   670   return extract_low_short_from_int(ref_index);

   671 }

   672 

   673 

   674 int ConstantPool::signature_ref_index_at(int which_nt) {

   675   jint ref_index = name_and_type_at(which_nt);

   676   return extract_high_short_from_int(ref_index);

   677 }

   678 

   679 

   680 Klass* ConstantPool::klass_ref_at(int which, TRAPS) {

   681   return klass_at(klass_ref_index_at(which), THREAD);

   682 }

   683 

   684 Symbol* ConstantPool::klass_name_at(int which) const {

   685   return symbol_at(klass_slot_at(which).name_index());

   686 }

   687 

   688 Symbol* ConstantPool::klass_ref_at_noresolve(int which) {

   689   jint ref_index = klass_ref_index_at(which);

   690   return klass_at_noresolve(ref_index);

   691 }

   692 

   693 Symbol* ConstantPool::uncached_klass_ref_at_noresolve(int which) {

   694   jint ref_index = uncached_klass_ref_index_at(which);

   695   return klass_at_noresolve(ref_index);

   696 }

   697 

   698 char* ConstantPool::string_at_noresolve(int which) {

   699   return unresolved_string_at(which)->as_C_string();

   700 }

   701 

   702 BasicType ConstantPool::basic_type_for_signature_at(int which) const {

   703   return FieldType::basic_type(symbol_at(which));

   704 }

   705 

   706 

   707 void ConstantPool::resolve_string_constants_impl(const constantPoolHandle& this_cp, TRAPS) {

   708   for (int index = 1; index < this_cp->length(); index++) { // Index 0 is unused

   709     if (this_cp->tag_at(index).is_string()) {

   710       this_cp->string_at(index, CHECK);

   711     }

   712   }

   713 }

   714 

   715 bool ConstantPool::resolve_class_constants(TRAPS) {

   716   constantPoolHandle cp(THREAD, this);

   717   for (int index = 1; index < length(); index++) { // Index 0 is unused

   718     if (tag_at(index).is_string()) {

   719       Symbol* sym = cp->unresolved_string_at(index);

   720       // Look up only. Only resolve references to already interned strings.

   721       oop str = StringTable::lookup(sym);

   722       if (str != NULL) {

   723         int cache_index = cp->cp_to_object_index(index);

   724         cp->string_at_put(index, cache_index, str);

   725       }

   726     }

   727   }

   728   return true;

   729 }

   730 

   731 Symbol* ConstantPool::exception_message(const constantPoolHandle& this_cp, int which, constantTag tag, oop pending_exception) {

   732   // Dig out the detailed message to reuse if possible

   733   Symbol* message = java_lang_Throwable::detail_message(pending_exception);

   734   if (message != NULL) {

   735     return message;

   736   }

   737 

   738   // Return specific message for the tag

   739   switch (tag.value()) {

   740   case JVM_CONSTANT_UnresolvedClass:

   741     // return the class name in the error message

   742     message = this_cp->klass_name_at(which);

   743     break;

   744   case JVM_CONSTANT_MethodHandle:

   745     // return the method handle name in the error message

   746     message = this_cp->method_handle_name_ref_at(which);

   747     break;

   748   case JVM_CONSTANT_MethodType:

   749     // return the method type signature in the error message

   750     message = this_cp->method_type_signature_at(which);

   751     break;

   752   default:

   753     ShouldNotReachHere();

   754   }

   755 

   756   return message;

   757 }

   758 

   759 void ConstantPool::throw_resolution_error(const constantPoolHandle& this_cp, int which, TRAPS) {

   760   Symbol* message = NULL;

   761   Symbol* error = SystemDictionary::find_resolution_error(this_cp, which, &message);

   762   assert(error != NULL && message != NULL, "checking");

   763   CLEAR_PENDING_EXCEPTION;

   764   ResourceMark rm;

   765   THROW_MSG(error, message->as_C_string());

   766 }

   767 

   768 // If resolution for Class, MethodHandle or MethodType fails, save the exception

   769 // in the resolution error table, so that the same exception is thrown again.

   770 void ConstantPool::save_and_throw_exception(const constantPoolHandle& this_cp, int which,

   771                                             constantTag tag, TRAPS) {

   772   Symbol* error = PENDING_EXCEPTION->klass()->name();

   773 

   774   int error_tag = tag.error_value();

   775 

   776   if (!PENDING_EXCEPTION->

   777     is_a(SystemDictionary::LinkageError_klass())) {

   778     // Just throw the exception and don't prevent these classes from

   779     // being loaded due to virtual machine errors like StackOverflow

   780     // and OutOfMemoryError, etc, or if the thread was hit by stop()

   781     // Needs clarification to section 5.4.3 of the VM spec (see 6308271)

   782   } else if (this_cp->tag_at(which).value() != error_tag) {

   783     Symbol* message = exception_message(this_cp, which, tag, PENDING_EXCEPTION);

   784     SystemDictionary::add_resolution_error(this_cp, which, error, message);

   785     // CAS in the tag.  If a thread beat us to registering this error that's fine.

   786     // If another thread resolved the reference, this is a race condition. This

   787     // thread may have had a security manager or something temporary.

   788     // This doesn't deterministically get an error.   So why do we save this?

   789     // We save this because jvmti can add classes to the bootclass path after

   790     // this error, so it needs to get the same error if the error is first.

   791     jbyte old_tag = Atomic::cmpxchg((jbyte)error_tag,

   792                             (jbyte*)this_cp->tag_addr_at(which), (jbyte)tag.value());

   793     if (old_tag != error_tag && old_tag != tag.value()) {

   794       // MethodHandles and MethodType doesn't change to resolved version.

   795       assert(this_cp->tag_at(which).is_klass(), "Wrong tag value");

   796       // Forget the exception and use the resolved class.

   797       CLEAR_PENDING_EXCEPTION;

   798     }

   799   } else {

   800     // some other thread put this in error state

   801     throw_resolution_error(this_cp, which, CHECK);

   802   }

   803 }

   804 

   805 // Called to resolve constants in the constant pool and return an oop.

   806 // Some constant pool entries cache their resolved oop. This is also

   807 // called to create oops from constants to use in arguments for invokedynamic

   808 oop ConstantPool::resolve_constant_at_impl(const constantPoolHandle& this_cp, int index, int cache_index, TRAPS) {

   809   oop result_oop = NULL;

   810   Handle throw_exception;

   811 

   812   if (cache_index == _possible_index_sentinel) {

   813     // It is possible that this constant is one which is cached in the objects.

   814     // We'll do a linear search.  This should be OK because this usage is rare.

   815     assert(index > 0, "valid index");

   816     cache_index = this_cp->cp_to_object_index(index);

   817   }

   818   assert(cache_index == _no_index_sentinel || cache_index >= 0, "");

   819   assert(index == _no_index_sentinel || index >= 0, "");

   820 

   821   if (cache_index >= 0) {

   822     result_oop = this_cp->resolved_references()->obj_at(cache_index);

   823     if (result_oop != NULL) {

   824       return result_oop;

   825       // That was easy...

   826     }

   827     index = this_cp->object_to_cp_index(cache_index);

   828   }

   829 

   830   jvalue prim_value;  // temp used only in a few cases below

   831 

   832   constantTag tag = this_cp->tag_at(index);

   833 

   834   switch (tag.value()) {

   835 

   836   case JVM_CONSTANT_UnresolvedClass:

   837   case JVM_CONSTANT_UnresolvedClassInError:

   838   case JVM_CONSTANT_Class:

   839     {

   840       assert(cache_index == _no_index_sentinel, "should not have been set");

   841       Klass* resolved = klass_at_impl(this_cp, index, true, CHECK_NULL);

   842       // ldc wants the java mirror.

   843       result_oop = resolved->java_mirror();

   844       break;

   845     }

   846 

   847   case JVM_CONSTANT_String:

   848     assert(cache_index != _no_index_sentinel, "should have been set");

   849     if (this_cp->is_pseudo_string_at(index)) {

   850       result_oop = this_cp->pseudo_string_at(index, cache_index);

   851       break;

   852     }

   853     result_oop = string_at_impl(this_cp, index, cache_index, CHECK_NULL);

   854     break;

   855 

   856   case JVM_CONSTANT_MethodHandleInError:

   857   case JVM_CONSTANT_MethodTypeInError:

   858     {

   859       throw_resolution_error(this_cp, index, CHECK_NULL);

   860       break;

   861     }

   862 

   863   case JVM_CONSTANT_MethodHandle:

   864     {

   865       int ref_kind                 = this_cp->method_handle_ref_kind_at(index);

   866       int callee_index             = this_cp->method_handle_klass_index_at(index);

   867       Symbol*  name =      this_cp->method_handle_name_ref_at(index);

   868       Symbol*  signature = this_cp->method_handle_signature_ref_at(index);

   869       constantTag m_tag  = this_cp->tag_at(this_cp->method_handle_index_at(index));

   870       { ResourceMark rm(THREAD);

   871         log_debug(class, resolve)("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s",

   872                               ref_kind, index, this_cp->method_handle_index_at(index),

   873                               callee_index, name->as_C_string(), signature->as_C_string());

   874       }

   875 

   876       Klass* callee = klass_at_impl(this_cp, callee_index, true, CHECK_NULL);

   877 

   878       // Check constant pool method consistency

   879       if ((callee->is_interface() && m_tag.is_method()) ||

   880           ((!callee->is_interface() && m_tag.is_interface_method()))) {

   881         ResourceMark rm(THREAD);

   882         char buf[400];

   883         jio_snprintf(buf, sizeof(buf),

   884           "Inconsistent constant pool data in classfile for class %s. "

   885           "Method %s%s at index %d is %s and should be %s",

   886           callee->name()->as_C_string(), name->as_C_string(), signature->as_C_string(), index,

   887           callee->is_interface() ? "CONSTANT_MethodRef" : "CONSTANT_InterfaceMethodRef",

   888           callee->is_interface() ? "CONSTANT_InterfaceMethodRef" : "CONSTANT_MethodRef");

   889         THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);

   890       }

   891 

   892       Klass* klass = this_cp->pool_holder();

   893       Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,

   894                                                                    callee, name, signature,

   895                                                                    THREAD);

   896       result_oop = value();

   897       if (HAS_PENDING_EXCEPTION) {

   898         save_and_throw_exception(this_cp, index, tag, CHECK_NULL);

   899       }

   900       break;

   901     }

   902 

   903   case JVM_CONSTANT_MethodType:

   904     {

   905       Symbol*  signature = this_cp->method_type_signature_at(index);

   906       { ResourceMark rm(THREAD);

   907         log_debug(class, resolve)("resolve JVM_CONSTANT_MethodType [%d/%d] %s",

   908                               index, this_cp->method_type_index_at(index),

   909                               signature->as_C_string());

   910       }

   911       Klass* klass = this_cp->pool_holder();

   912       Handle value = SystemDictionary::find_method_handle_type(signature, klass, THREAD);

   913       result_oop = value();

   914       if (HAS_PENDING_EXCEPTION) {

   915         save_and_throw_exception(this_cp, index, tag, CHECK_NULL);

   916       }

   917       break;

   918     }

   919 

   920   case JVM_CONSTANT_Integer:

   921     assert(cache_index == _no_index_sentinel, "should not have been set");

   922     prim_value.i = this_cp->int_at(index);

   923     result_oop = java_lang_boxing_object::create(T_INT, &prim_value, CHECK_NULL);

   924     break;

   925 

   926   case JVM_CONSTANT_Float:

   927     assert(cache_index == _no_index_sentinel, "should not have been set");

   928     prim_value.f = this_cp->float_at(index);

   929     result_oop = java_lang_boxing_object::create(T_FLOAT, &prim_value, CHECK_NULL);

   930     break;

   931 

   932   case JVM_CONSTANT_Long:

   933     assert(cache_index == _no_index_sentinel, "should not have been set");

   934     prim_value.j = this_cp->long_at(index);

   935     result_oop = java_lang_boxing_object::create(T_LONG, &prim_value, CHECK_NULL);

   936     break;

   937 

   938   case JVM_CONSTANT_Double:

   939     assert(cache_index == _no_index_sentinel, "should not have been set");

   940     prim_value.d = this_cp->double_at(index);

   941     result_oop = java_lang_boxing_object::create(T_DOUBLE, &prim_value, CHECK_NULL);

   942     break;

   943 

   944   default:

   945     DEBUG_ONLY( tty->print_cr("*** %p: tag at CP[%d/%d] = %d",

   946                               this_cp(), index, cache_index, tag.value()));

   947     assert(false, "unexpected constant tag");

   948     break;

   949   }

   950 

   951   if (cache_index >= 0) {

   952     // Benign race condition:  resolved_references may already be filled in.

   953     // The important thing here is that all threads pick up the same result.

   954     // It doesn't matter which racing thread wins, as long as only one

   955     // result is used by all threads, and all future queries.

   956     oop old_result = this_cp->resolved_references()->atomic_compare_exchange_oop(cache_index, result_oop, NULL);

   957     if (old_result == NULL) {

   958       return result_oop;  // was installed

   959     } else {

   960       // Return the winning thread's result.  This can be different than

   961       // the result here for MethodHandles.

   962       return old_result;

   963     }

   964   } else {

   965     return result_oop;

   966   }

   967 }

   968 

   969 oop ConstantPool::uncached_string_at(int which, TRAPS) {

   970   Symbol* sym = unresolved_string_at(which);

   971   oop str = StringTable::intern(sym, CHECK_(NULL));

   972   assert(java_lang_String::is_instance(str), "must be string");

   973   return str;

   974 }

   975 

   976 

   977 oop ConstantPool::resolve_bootstrap_specifier_at_impl(const constantPoolHandle& this_cp, int index, TRAPS) {

   978   assert(this_cp->tag_at(index).is_invoke_dynamic(), "Corrupted constant pool");

   979 

   980   Handle bsm;

   981   int argc;

   982   {

   983     // JVM_CONSTANT_InvokeDynamic is an ordered pair of [bootm, name&type], plus optional arguments

   984     // The bootm, being a JVM_CONSTANT_MethodHandle, has its own cache entry.

   985     // It is accompanied by the optional arguments.

   986     int bsm_index = this_cp->invoke_dynamic_bootstrap_method_ref_index_at(index);

   987     oop bsm_oop = this_cp->resolve_possibly_cached_constant_at(bsm_index, CHECK_NULL);

   988     if (!java_lang_invoke_MethodHandle::is_instance(bsm_oop)) {

   989       THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "BSM not an MethodHandle");

   990     }

   991 

   992     // Extract the optional static arguments.

   993     argc = this_cp->invoke_dynamic_argument_count_at(index);

   994     if (argc == 0)  return bsm_oop;

   995 

   996     bsm = Handle(THREAD, bsm_oop);

   997   }

   998 

   999   objArrayHandle info;

  1000   {

  1001     objArrayOop info_oop = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1+argc, CHECK_NULL);

  1002     info = objArrayHandle(THREAD, info_oop);

  1003   }

  1004 

  1005   info->obj_at_put(0, bsm());

  1006   for (int i = 0; i < argc; i++) {

  1007     int arg_index = this_cp->invoke_dynamic_argument_index_at(index, i);

  1008     oop arg_oop = this_cp->resolve_possibly_cached_constant_at(arg_index, CHECK_NULL);

  1009     info->obj_at_put(1+i, arg_oop);

  1010   }

  1011 

  1012   return info();

  1013 }

  1014 

  1015 oop ConstantPool::string_at_impl(const constantPoolHandle& this_cp, int which, int obj_index, TRAPS) {

  1016   // If the string has already been interned, this entry will be non-null

  1017   oop str = this_cp->resolved_references()->obj_at(obj_index);

  1018   if (str != NULL) return str;

  1019   Symbol* sym = this_cp->unresolved_string_at(which);

  1020   str = StringTable::intern(sym, CHECK_(NULL));

  1021   this_cp->string_at_put(which, obj_index, str);

  1022   assert(java_lang_String::is_instance(str), "must be string");

  1023   return str;

  1024 }

  1025 

  1026 

  1027 bool ConstantPool::klass_name_at_matches(const InstanceKlass* k, int which) {

  1028   // Names are interned, so we can compare Symbol*s directly

  1029   Symbol* cp_name = klass_name_at(which);

  1030   return (cp_name == k->name());

  1031 }

  1032 

  1033 

  1034 // Iterate over symbols and decrement ones which are Symbol*s

  1035 // This is done during GC.

  1036 // Only decrement the UTF8 symbols. Strings point to

  1037 // these symbols but didn't increment the reference count.

  1038 void ConstantPool::unreference_symbols() {

  1039   for (int index = 1; index < length(); index++) { // Index 0 is unused

  1040     constantTag tag = tag_at(index);

  1041     if (tag.is_symbol()) {

  1042       symbol_at(index)->decrement_refcount();

  1043     }

  1044   }

  1045 }

  1046 

  1047 

  1048 // Compare this constant pool's entry at index1 to the constant pool

  1049 // cp2's entry at index2.

  1050 bool ConstantPool::compare_entry_to(int index1, const constantPoolHandle& cp2,

  1051        int index2, TRAPS) {

  1052 

  1053   // The error tags are equivalent to non-error tags when comparing

  1054   jbyte t1 = tag_at(index1).non_error_value();

  1055   jbyte t2 = cp2->tag_at(index2).non_error_value();

  1056 

  1057   if (t1 != t2) {

  1058     // Not the same entry type so there is nothing else to check. Note

  1059     // that this style of checking will consider resolved/unresolved

  1060     // class pairs as different.

  1061     // From the ConstantPool* API point of view, this is correct

  1062     // behavior. See VM_RedefineClasses::merge_constant_pools() to see how this

  1063     // plays out in the context of ConstantPool* merging.

  1064     return false;

  1065   }

  1066 

  1067   switch (t1) {

  1068   case JVM_CONSTANT_Class:

  1069   {

  1070     Klass* k1 = klass_at(index1, CHECK_false);

  1071     Klass* k2 = cp2->klass_at(index2, CHECK_false);

  1072     if (k1 == k2) {

  1073       return true;

  1074     }

  1075   } break;

  1076 

  1077   case JVM_CONSTANT_ClassIndex:

  1078   {

  1079     int recur1 = klass_index_at(index1);

  1080     int recur2 = cp2->klass_index_at(index2);

  1081     bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);

  1082     if (match) {

  1083       return true;

  1084     }

  1085   } break;

  1086 

  1087   case JVM_CONSTANT_Double:

  1088   {

  1089     jdouble d1 = double_at(index1);

  1090     jdouble d2 = cp2->double_at(index2);

  1091     if (d1 == d2) {

  1092       return true;

  1093     }

  1094   } break;

  1095 

  1096   case JVM_CONSTANT_Fieldref:

  1097   case JVM_CONSTANT_InterfaceMethodref:

  1098   case JVM_CONSTANT_Methodref:

  1099   {

  1100     int recur1 = uncached_klass_ref_index_at(index1);

  1101     int recur2 = cp2->uncached_klass_ref_index_at(index2);

  1102     bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);

  1103     if (match) {

  1104       recur1 = uncached_name_and_type_ref_index_at(index1);

  1105       recur2 = cp2->uncached_name_and_type_ref_index_at(index2);

  1106       match = compare_entry_to(recur1, cp2, recur2, CHECK_false);

  1107       if (match) {

  1108         return true;

  1109       }

  1110     }

  1111   } break;

  1112 

  1113   case JVM_CONSTANT_Float:

  1114   {

  1115     jfloat f1 = float_at(index1);

  1116     jfloat f2 = cp2->float_at(index2);

  1117     if (f1 == f2) {

  1118       return true;

  1119     }

  1120   } break;

  1121 

  1122   case JVM_CONSTANT_Integer:

  1123   {

  1124     jint i1 = int_at(index1);

  1125     jint i2 = cp2->int_at(index2);

  1126     if (i1 == i2) {

  1127       return true;

  1128     }

  1129   } break;

  1130 

  1131   case JVM_CONSTANT_Long:

  1132   {

  1133     jlong l1 = long_at(index1);

  1134     jlong l2 = cp2->long_at(index2);