1 /*
   2  * Copyright (c) 1998, 2013, 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 "gc_implementation/shared/markSweep.inline.hpp"
  27 #include "interpreter/interpreter.hpp"
  28 #include "interpreter/rewriter.hpp"
  29 #include "memory/universe.inline.hpp"
  30 #include "oops/cpCache.hpp"
  31 #include "oops/objArrayOop.hpp"
  32 #include "oops/oop.inline.hpp"
  33 #include "prims/jvmtiRedefineClassesTrace.hpp"
  34 #include "prims/methodHandles.hpp"
  35 #include "runtime/handles.inline.hpp"
  36 #include "utilities/macros.hpp"
  37 #if INCLUDE_ALL_GCS
  38 # include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
  39 #endif // INCLUDE_ALL_GCS
  40 
  41 
  42 // Implememtation of ConstantPoolCacheEntry
  43 
  44 void ConstantPoolCacheEntry::initialize_entry(int index) {
  45   assert(0 < index && index < 0x10000, "sanity check");
  46   _indices = index;
  47   _f1 = NULL;
  48   _f2 = _flags = 0;
  49   assert(constant_pool_index() == index, "");
  50 }
  51 
  52 int ConstantPoolCacheEntry::make_flags(TosState state,
  53                                        int option_bits,
  54                                        int field_index_or_method_params) {
  55   assert(state < number_of_states, "Invalid state in make_flags");
  56   int f = ((int)state << tos_state_shift) | option_bits | field_index_or_method_params;
  57   // Preserve existing flag bit values
  58   // The low bits are a field offset, or else the method parameter size.
  59 #ifdef ASSERT
  60   TosState old_state = flag_state();
  61   assert(old_state == (TosState)0 || old_state == state,
  62          "inconsistent cpCache flags state");
  63 #endif
  64   return (_flags | f) ;
  65 }
  66 
  67 void ConstantPoolCacheEntry::set_bytecode_1(Bytecodes::Code code) {
  68 #ifdef ASSERT
  69   // Read once.
  70   volatile Bytecodes::Code c = bytecode_1();
  71   assert(c == 0 || c == code || code == 0, "update must be consistent");
  72 #endif
  73   // Need to flush pending stores here before bytecode is written.
  74   OrderAccess::release_store_ptr(&_indices, _indices | ((u_char)code << bytecode_1_shift));
  75 }
  76 
  77 void ConstantPoolCacheEntry::set_bytecode_2(Bytecodes::Code code) {
  78 #ifdef ASSERT
  79   // Read once.
  80   volatile Bytecodes::Code c = bytecode_2();
  81   assert(c == 0 || c == code || code == 0, "update must be consistent");
  82 #endif
  83   // Need to flush pending stores here before bytecode is written.
  84   OrderAccess::release_store_ptr(&_indices, _indices | ((u_char)code << bytecode_2_shift));
  85 }
  86 
  87 // Sets f1, ordering with previous writes.
  88 void ConstantPoolCacheEntry::release_set_f1(Metadata* f1) {
  89   assert(f1 != NULL, "");
  90   OrderAccess::release_store_ptr((HeapWord*) &_f1, f1);
  91 }
  92 
  93 // Sets flags, but only if the value was previously zero.
  94 bool ConstantPoolCacheEntry::init_flags_atomic(intptr_t flags) {
  95   intptr_t result = Atomic::cmpxchg_ptr(flags, &_flags, 0);
  96   return (result == 0);
  97 }
  98 
  99 // Note that concurrent update of both bytecodes can leave one of them
 100 // reset to zero.  This is harmless; the interpreter will simply re-resolve
 101 // the damaged entry.  More seriously, the memory synchronization is needed
 102 // to flush other fields (f1, f2) completely to memory before the bytecodes
 103 // are updated, lest other processors see a non-zero bytecode but zero f1/f2.
 104 void ConstantPoolCacheEntry::set_field(Bytecodes::Code get_code,
 105                                        Bytecodes::Code put_code,
 106                                        KlassHandle field_holder,
 107                                        int field_index,
 108                                        int field_offset,
 109                                        TosState field_type,
 110                                        bool is_final,
 111                                        bool is_volatile,
 112                                        Klass* root_klass) {
 113   set_f1(field_holder());
 114   set_f2(field_offset);
 115   assert((field_index & field_index_mask) == field_index,
 116          "field index does not fit in low flag bits");
 117   set_field_flags(field_type,
 118                   ((is_volatile ? 1 : 0) << is_volatile_shift) |
 119                   ((is_final    ? 1 : 0) << is_final_shift),
 120                   field_index);
 121   set_bytecode_1(get_code);
 122   set_bytecode_2(put_code);
 123   NOT_PRODUCT(verify(tty));
 124 }
 125 
 126 void ConstantPoolCacheEntry::set_parameter_size(int value) {
 127   // This routine is called only in corner cases where the CPCE is not yet initialized.
 128   // See AbstractInterpreter::deopt_continue_after_entry.
 129   assert(_flags == 0 || parameter_size() == 0 || parameter_size() == value,
 130          err_msg("size must not change: parameter_size=%d, value=%d", parameter_size(), value));
 131   // Setting the parameter size by itself is only safe if the
 132   // current value of _flags is 0, otherwise another thread may have
 133   // updated it and we don't want to overwrite that value.  Don't
 134   // bother trying to update it once it's nonzero but always make
 135   // sure that the final parameter size agrees with what was passed.
 136   if (_flags == 0) {
 137     Atomic::cmpxchg_ptr((value & parameter_size_mask), &_flags, 0);
 138   }
 139   guarantee(parameter_size() == value,
 140             err_msg("size must not change: parameter_size=%d, value=%d", parameter_size(), value));
 141 }
 142 
 143 void ConstantPoolCacheEntry::set_direct_or_vtable_call(Bytecodes::Code invoke_code,
 144                                                        methodHandle method,
 145                                                        int vtable_index) {
 146   bool is_vtable_call = (vtable_index >= 0);  // FIXME: split this method on this boolean
 147   assert(method->interpreter_entry() != NULL, "should have been set at this point");
 148   assert(!method->is_obsolete(),  "attempt to write obsolete method to cpCache");
 149 
 150   int byte_no = -1;
 151   bool change_to_virtual = false;
 152 
 153   switch (invoke_code) {
 154     case Bytecodes::_invokeinterface:
 155       // We get here from InterpreterRuntime::resolve_invoke when an invokeinterface
 156       // instruction somehow links to a non-interface method (in Object).
 157       // In that case, the method has no itable index and must be invoked as a virtual.
 158       // Set a flag to keep track of this corner case.
 159       change_to_virtual = true;
 160 
 161       // ...and fall through as if we were handling invokevirtual:
 162     case Bytecodes::_invokevirtual:
 163       {
 164         if (!is_vtable_call) {
 165           assert(method->can_be_statically_bound(), "");
 166           // set_f2_as_vfinal_method checks if is_vfinal flag is true.
 167           set_method_flags(as_TosState(method->result_type()),
 168                            (                             1      << is_vfinal_shift) |
 169                            ((method->is_final_method() ? 1 : 0) << is_final_shift)  |
 170                            ((change_to_virtual         ? 1 : 0) << is_forced_virtual_shift),
 171                            method()->size_of_parameters());
 172           set_f2_as_vfinal_method(method());
 173         } else {
 174           assert(!method->can_be_statically_bound(), "");
 175           assert(vtable_index >= 0, "valid index");
 176           assert(!method->is_final_method(), "sanity");
 177           set_method_flags(as_TosState(method->result_type()),
 178                            ((change_to_virtual ? 1 : 0) << is_forced_virtual_shift),
 179                            method()->size_of_parameters());
 180           set_f2(vtable_index);
 181         }
 182         byte_no = 2;
 183         break;
 184       }
 185 
 186     case Bytecodes::_invokespecial:
 187     case Bytecodes::_invokestatic:
 188       assert(!is_vtable_call, "");
 189       // Note:  Read and preserve the value of the is_vfinal flag on any
 190       // invokevirtual bytecode shared with this constant pool cache entry.
 191       // It is cheap and safe to consult is_vfinal() at all times.
 192       // Once is_vfinal is set, it must stay that way, lest we get a dangling oop.
 193       set_method_flags(as_TosState(method->result_type()),
 194                        ((is_vfinal()               ? 1 : 0) << is_vfinal_shift) |
 195                        ((method->is_final_method() ? 1 : 0) << is_final_shift),
 196                        method()->size_of_parameters());
 197       set_f1(method());
 198       byte_no = 1;
 199       break;
 200     default:
 201       ShouldNotReachHere();
 202       break;
 203   }
 204 
 205   // Note:  byte_no also appears in TemplateTable::resolve.
 206   if (byte_no == 1) {
 207     assert(invoke_code != Bytecodes::_invokevirtual &&
 208            invoke_code != Bytecodes::_invokeinterface, "");
 209     set_bytecode_1(invoke_code);
 210   } else if (byte_no == 2)  {
 211     if (change_to_virtual) {
 212       assert(invoke_code == Bytecodes::_invokeinterface, "");
 213       // NOTE: THIS IS A HACK - BE VERY CAREFUL!!!
 214       //
 215       // Workaround for the case where we encounter an invokeinterface, but we
 216       // should really have an _invokevirtual since the resolved method is a
 217       // virtual method in java.lang.Object. This is a corner case in the spec
 218       // but is presumably legal. javac does not generate this code.
 219       //
 220       // We set bytecode_1() to _invokeinterface, because that is the
 221       // bytecode # used by the interpreter to see if it is resolved.
 222       // We set bytecode_2() to _invokevirtual.
 223       // See also interpreterRuntime.cpp. (8/25/2000)
 224       // Only set resolved for the invokeinterface case if method is public.
 225       // Otherwise, the method needs to be reresolved with caller for each
 226       // interface call.
 227       if (method->is_public()) set_bytecode_1(invoke_code);
 228     } else {
 229       assert(invoke_code == Bytecodes::_invokevirtual, "");
 230     }
 231     // set up for invokevirtual, even if linking for invokeinterface also:
 232     set_bytecode_2(Bytecodes::_invokevirtual);
 233   } else {
 234     ShouldNotReachHere();
 235   }
 236   NOT_PRODUCT(verify(tty));
 237 }
 238 
 239 void ConstantPoolCacheEntry::set_direct_call(Bytecodes::Code invoke_code, methodHandle method) {
 240   int index = Method::nonvirtual_vtable_index;
 241   // index < 0; FIXME: inline and customize set_direct_or_vtable_call
 242   set_direct_or_vtable_call(invoke_code, method, index);
 243 }
 244 
 245 void ConstantPoolCacheEntry::set_vtable_call(Bytecodes::Code invoke_code, methodHandle method, int index) {
 246   // either the method is a miranda or its holder should accept the given index
 247   assert(method->method_holder()->is_interface() || method->method_holder()->verify_vtable_index(index), "");
 248   // index >= 0; FIXME: inline and customize set_direct_or_vtable_call
 249   set_direct_or_vtable_call(invoke_code, method, index);
 250 }
 251 
 252 void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code, methodHandle method, int index) {
 253   assert(method->method_holder()->verify_itable_index(index), "");
 254   assert(invoke_code == Bytecodes::_invokeinterface, "");
 255   InstanceKlass* interf = method->method_holder();
 256   assert(interf->is_interface(), "must be an interface");
 257   assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here");
 258   set_f1(interf);
 259   set_f2(index);
 260   set_method_flags(as_TosState(method->result_type()),
 261                    0,  // no option bits
 262                    method()->size_of_parameters());
 263   set_bytecode_1(Bytecodes::_invokeinterface);
 264 }
 265 
 266 
 267 void ConstantPoolCacheEntry::set_method_handle(constantPoolHandle cpool, const CallInfo &call_info) {
 268   set_method_handle_common(cpool, Bytecodes::_invokehandle, call_info);
 269 }
 270 
 271 void ConstantPoolCacheEntry::set_dynamic_call(constantPoolHandle cpool, const CallInfo &call_info) {
 272   set_method_handle_common(cpool, Bytecodes::_invokedynamic, call_info);
 273 }
 274 
 275 void ConstantPoolCacheEntry::set_method_handle_common(constantPoolHandle cpool,
 276                                                       Bytecodes::Code invoke_code,
 277                                                       const CallInfo &call_info) {
 278   // NOTE: This CPCE can be the subject of data races.
 279   // There are three words to update: flags, refs[f2], f1 (in that order).
 280   // Writers must store all other values before f1.
 281   // Readers must test f1 first for non-null before reading other fields.
 282   // Competing writers must acquire exclusive access via a lock.
 283   // A losing writer waits on the lock until the winner writes f1 and leaves
 284   // the lock, so that when the losing writer returns, he can use the linked
 285   // cache entry.
 286 
 287   oop cplock = cpool->lock();
 288   ObjectLocker ol(cplock, Thread::current(), cplock != NULL);
 289   if (!is_f1_null()) {
 290     return;
 291   }
 292 
 293   const methodHandle adapter = call_info.resolved_method();
 294   const Handle appendix      = call_info.resolved_appendix();
 295   const Handle method_type   = call_info.resolved_method_type();
 296   const bool has_appendix    = appendix.not_null();
 297   const bool has_method_type = method_type.not_null();
 298 
 299   // Write the flags.
 300   set_method_flags(as_TosState(adapter->result_type()),
 301                    ((has_appendix    ? 1 : 0) << has_appendix_shift   ) |
 302                    ((has_method_type ? 1 : 0) << has_method_type_shift) |
 303                    (                   1      << is_final_shift       ),
 304                    adapter->size_of_parameters());
 305 
 306   if (TraceInvokeDynamic) {
 307     tty->print_cr("set_method_handle bc=%d appendix="PTR_FORMAT"%s method_type="PTR_FORMAT"%s method="PTR_FORMAT" ",
 308                   invoke_code,
 309                   (intptr_t)appendix(),    (has_appendix    ? "" : " (unused)"),
 310                   (intptr_t)method_type(), (has_method_type ? "" : " (unused)"),
 311                   (intptr_t)adapter());
 312     adapter->print();
 313     if (has_appendix)  appendix()->print();
 314   }
 315 
 316   // Method handle invokes and invokedynamic sites use both cp cache words.
 317   // refs[f2], if not null, contains a value passed as a trailing argument to the adapter.
 318   // In the general case, this could be the call site's MethodType,
 319   // for use with java.lang.Invokers.checkExactType, or else a CallSite object.
 320   // f1 contains the adapter method which manages the actual call.
 321   // In the general case, this is a compiled LambdaForm.
 322   // (The Java code is free to optimize these calls by binding other
 323   // sorts of methods and appendices to call sites.)
 324   // JVM-level linking is via f1, as if for invokespecial, and signatures are erased.
 325   // The appendix argument (if any) is added to the signature, and is counted in the parameter_size bits.
 326   // Even with the appendix, the method will never take more than 255 parameter slots.
 327   //
 328   // This means that given a call site like (List)mh.invoke("foo"),
 329   // the f1 method has signature '(Ljl/Object;Ljl/invoke/MethodType;)Ljl/Object;',
 330   // not '(Ljava/lang/String;)Ljava/util/List;'.
 331   // The fact that String and List are involved is encoded in the MethodType in refs[f2].
 332   // This allows us to create fewer method oops, while keeping type safety.
 333   //
 334 
 335   objArrayHandle resolved_references = cpool->resolved_references();
 336   // Store appendix, if any.
 337   if (has_appendix) {
 338     const int appendix_index = f2_as_index() + _indy_resolved_references_appendix_offset;
 339     assert(appendix_index >= 0 && appendix_index < resolved_references->length(), "oob");
 340     assert(resolved_references->obj_at(appendix_index) == NULL, "init just once");
 341     resolved_references->obj_at_put(appendix_index, appendix());
 342   }
 343 
 344   // Store MethodType, if any.
 345   if (has_method_type) {
 346     const int method_type_index = f2_as_index() + _indy_resolved_references_method_type_offset;
 347     assert(method_type_index >= 0 && method_type_index < resolved_references->length(), "oob");
 348     assert(resolved_references->obj_at(method_type_index) == NULL, "init just once");
 349     resolved_references->obj_at_put(method_type_index, method_type());
 350   }
 351 
 352   release_set_f1(adapter());  // This must be the last one to set (see NOTE above)!
 353 
 354   // The interpreter assembly code does not check byte_2,
 355   // but it is used by is_resolved, method_if_resolved, etc.
 356   set_bytecode_1(invoke_code);
 357   NOT_PRODUCT(verify(tty));
 358   if (TraceInvokeDynamic) {
 359     this->print(tty, 0);
 360   }
 361 }
 362 
 363 Method* ConstantPoolCacheEntry::method_if_resolved(constantPoolHandle cpool) {
 364   // Decode the action of set_method and set_interface_call
 365   Bytecodes::Code invoke_code = bytecode_1();
 366   if (invoke_code != (Bytecodes::Code)0) {
 367     Metadata* f1 = (Metadata*)_f1;
 368     if (f1 != NULL) {
 369       switch (invoke_code) {
 370       case Bytecodes::_invokeinterface:
 371         assert(f1->is_klass(), "");
 372         return klassItable::method_for_itable_index((Klass*)f1, f2_as_index());
 373       case Bytecodes::_invokestatic:
 374       case Bytecodes::_invokespecial:
 375         assert(!has_appendix(), "");
 376       case Bytecodes::_invokehandle:
 377       case Bytecodes::_invokedynamic:
 378         assert(f1->is_method(), "");
 379         return (Method*)f1;
 380       }
 381     }
 382   }
 383   invoke_code = bytecode_2();
 384   if (invoke_code != (Bytecodes::Code)0) {
 385     switch (invoke_code) {
 386     case Bytecodes::_invokevirtual:
 387       if (is_vfinal()) {
 388         // invokevirtual
 389         Method* m = f2_as_vfinal_method();
 390         assert(m->is_method(), "");
 391         return m;
 392       } else {
 393         int holder_index = cpool->uncached_klass_ref_index_at(constant_pool_index());
 394         if (cpool->tag_at(holder_index).is_klass()) {
 395           Klass* klass = cpool->resolved_klass_at(holder_index);
 396           if (!klass->oop_is_instance())
 397             klass = SystemDictionary::Object_klass();
 398           return InstanceKlass::cast(klass)->method_at_vtable(f2_as_index());
 399         }
 400       }
 401       break;
 402     }
 403   }
 404   return NULL;
 405 }
 406 
 407 
 408 oop ConstantPoolCacheEntry::appendix_if_resolved(constantPoolHandle cpool) {
 409   if (is_f1_null() || !has_appendix())
 410     return NULL;
 411   const int ref_index = f2_as_index() + _indy_resolved_references_appendix_offset;
 412   objArrayOop resolved_references = cpool->resolved_references();
 413   return resolved_references->obj_at(ref_index);
 414 }
 415 
 416 
 417 oop ConstantPoolCacheEntry::method_type_if_resolved(constantPoolHandle cpool) {
 418   if (is_f1_null() || !has_method_type())
 419     return NULL;
 420   const int ref_index = f2_as_index() + _indy_resolved_references_method_type_offset;
 421   objArrayOop resolved_references = cpool->resolved_references();
 422   return resolved_references->obj_at(ref_index);
 423 }
 424 
 425 
 426 #if INCLUDE_JVMTI
 427 // RedefineClasses() API support:
 428 // If this ConstantPoolCacheEntry refers to old_method then update it
 429 // to refer to new_method.
 430 bool ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
 431        Method* new_method, bool * trace_name_printed) {
 432 
 433   if (is_vfinal()) {
 434     // virtual and final so _f2 contains method ptr instead of vtable index
 435     if (f2_as_vfinal_method() == old_method) {
 436       // match old_method so need an update
 437       // NOTE: can't use set_f2_as_vfinal_method as it asserts on different values
 438       _f2 = (intptr_t)new_method;
 439       if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
 440         if (!(*trace_name_printed)) {
 441           // RC_TRACE_MESG macro has an embedded ResourceMark
 442           RC_TRACE_MESG(("adjust: name=%s",
 443             old_method->method_holder()->external_name()));
 444           *trace_name_printed = true;
 445         }
 446         // RC_TRACE macro has an embedded ResourceMark
 447         RC_TRACE(0x00400000, ("cpc vf-entry update: %s(%s)",
 448           new_method->name()->as_C_string(),
 449           new_method->signature()->as_C_string()));
 450       }
 451 
 452       return true;
 453     }
 454 
 455     // f1() is not used with virtual entries so bail out
 456     return false;
 457   }
 458 
 459   if (_f1 == NULL) {
 460     // NULL f1() means this is a virtual entry so bail out
 461     // We are assuming that the vtable index does not need change.
 462     return false;
 463   }
 464 
 465   if (_f1 == old_method) {
 466     _f1 = new_method;
 467     if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
 468       if (!(*trace_name_printed)) {
 469         // RC_TRACE_MESG macro has an embedded ResourceMark
 470         RC_TRACE_MESG(("adjust: name=%s",
 471           old_method->method_holder()->external_name()));
 472         *trace_name_printed = true;
 473       }
 474       // RC_TRACE macro has an embedded ResourceMark
 475       RC_TRACE(0x00400000, ("cpc entry update: %s(%s)",
 476         new_method->name()->as_C_string(),
 477         new_method->signature()->as_C_string()));
 478     }
 479 
 480     return true;
 481   }
 482 
 483   return false;
 484 }
 485 
 486 // a constant pool cache entry should never contain old or obsolete methods
 487 bool ConstantPoolCacheEntry::check_no_old_or_obsolete_entries() {
 488   if (is_vfinal()) {
 489     // virtual and final so _f2 contains method ptr instead of vtable index
 490     Metadata* f2 = (Metadata*)_f2;
 491     // Return false if _f2 refers to an old or an obsolete method.
 492     // _f2 == NULL || !_f2->is_method() are just as unexpected here.
 493     return (f2 != NULL NOT_PRODUCT(&& f2->is_valid()) && f2->is_method() &&
 494             !((Method*)f2)->is_old() && !((Method*)f2)->is_obsolete());
 495   } else if (_f1 == NULL ||
 496              (NOT_PRODUCT(_f1->is_valid() &&) !_f1->is_method())) {
 497     // _f1 == NULL || !_f1->is_method() are OK here
 498     return true;
 499   }
 500   // return false if _f1 refers to an old or an obsolete method
 501   return (NOT_PRODUCT(_f1->is_valid() &&) _f1->is_method() &&
 502           !((Method*)_f1)->is_old() && !((Method*)_f1)->is_obsolete());
 503 }
 504 
 505 bool ConstantPoolCacheEntry::is_interesting_method_entry(Klass* k) {
 506   if (!is_method_entry()) {
 507     // not a method entry so not interesting by default
 508     return false;
 509   }
 510 
 511   Method* m = NULL;
 512   if (is_vfinal()) {
 513     // virtual and final so _f2 contains method ptr instead of vtable index
 514     m = f2_as_vfinal_method();
 515   } else if (is_f1_null()) {
 516     // NULL _f1 means this is a virtual entry so also not interesting
 517     return false;
 518   } else {
 519     if (!(_f1->is_method())) {
 520       // _f1 can also contain a Klass* for an interface
 521       return false;
 522     }
 523     m = f1_as_method();
 524   }
 525 
 526   assert(m != NULL && m->is_method(), "sanity check");
 527   if (m == NULL || !m->is_method() || (k != NULL && m->method_holder() != k)) {
 528     // robustness for above sanity checks or method is not in
 529     // the interesting class
 530     return false;
 531   }
 532 
 533   // the method is in the interesting class so the entry is interesting
 534   return true;
 535 }
 536 #endif // INCLUDE_JVMTI
 537 
 538 void ConstantPoolCacheEntry::print(outputStream* st, int index) const {
 539   // print separator
 540   if (index == 0) st->print_cr("                 -------------");
 541   // print entry
 542   st->print("%3d  ("PTR_FORMAT")  ", index, (intptr_t)this);
 543   st->print_cr("[%02x|%02x|%5d]", bytecode_2(), bytecode_1(),
 544                constant_pool_index());
 545   st->print_cr("                 [   "PTR_FORMAT"]", (intptr_t)_f1);
 546   st->print_cr("                 [   "PTR_FORMAT"]", (intptr_t)_f2);
 547   st->print_cr("                 [   "PTR_FORMAT"]", (intptr_t)_flags);
 548   st->print_cr("                 -------------");
 549 }
 550 
 551 void ConstantPoolCacheEntry::verify(outputStream* st) const {
 552   // not implemented yet
 553 }
 554 
 555 // Implementation of ConstantPoolCache
 556 
 557 ConstantPoolCache* ConstantPoolCache::allocate(ClassLoaderData* loader_data,
 558                                      int length,
 559                                      const intStack& index_map,
 560                                      const intStack& invokedynamic_map, TRAPS) {
 561   int size = ConstantPoolCache::size(length);
 562 
 563   return new (loader_data, size, false, MetaspaceObj::ConstantPoolCacheType, THREAD)
 564     ConstantPoolCache(length, index_map, invokedynamic_map);
 565 }
 566 
 567 void ConstantPoolCache::initialize(const intArray& inverse_index_map,
 568                                    const intArray& invokedynamic_references_map) {
 569   assert(inverse_index_map.length() == length(), "inverse index map must have same length as cache");
 570   for (int i = 0; i < length(); i++) {
 571     ConstantPoolCacheEntry* e = entry_at(i);
 572     int original_index = inverse_index_map[i];
 573     e->initialize_entry(original_index);
 574     assert(entry_at(i) == e, "sanity");
 575   }
 576   for (int ref = 0; ref < invokedynamic_references_map.length(); ref++) {
 577     const int cpci = invokedynamic_references_map[ref];
 578     if (cpci >= 0) {
 579 #ifdef ASSERT
 580       // invokedynamic and invokehandle have more entries; check if they
 581       // all point to the same constant pool cache entry.
 582       for (int entry = 1; entry < ConstantPoolCacheEntry::_indy_resolved_references_entries; entry++) {
 583         const int cpci_next = invokedynamic_references_map[ref + entry];
 584         assert(cpci == cpci_next, err_msg_res("%d == %d", cpci, cpci_next));
 585       }
 586 #endif
 587       entry_at(cpci)->initialize_resolved_reference_index(ref);
 588       ref += ConstantPoolCacheEntry::_indy_resolved_references_entries - 1;  // skip extra entries
 589     }
 590   }
 591 }
 592 
 593 #if INCLUDE_JVMTI
 594 // RedefineClasses() API support:
 595 // If any entry of this ConstantPoolCache points to any of
 596 // old_methods, replace it with the corresponding new_method.
 597 void ConstantPoolCache::adjust_method_entries(Method** old_methods, Method** new_methods,
 598                                                      int methods_length, bool * trace_name_printed) {
 599 
 600   if (methods_length == 0) {
 601     // nothing to do if there are no methods
 602     return;
 603   }
 604 
 605   // get shorthand for the interesting class
 606   Klass* old_holder = old_methods[0]->method_holder();
 607 
 608   for (int i = 0; i < length(); i++) {
 609     if (!entry_at(i)->is_interesting_method_entry(old_holder)) {
 610       // skip uninteresting methods
 611       continue;
 612     }
 613 
 614     // The ConstantPoolCache contains entries for several different
 615     // things, but we only care about methods. In fact, we only care
 616     // about methods in the same class as the one that contains the
 617     // old_methods. At this point, we have an interesting entry.
 618 
 619     for (int j = 0; j < methods_length; j++) {
 620       Method* old_method = old_methods[j];
 621       Method* new_method = new_methods[j];
 622 
 623       if (entry_at(i)->adjust_method_entry(old_method, new_method,
 624           trace_name_printed)) {
 625         // current old_method matched this entry and we updated it so
 626         // break out and get to the next interesting entry if there one
 627         break;
 628       }
 629     }
 630   }
 631 }
 632 
 633 // the constant pool cache should never contain old or obsolete methods
 634 bool ConstantPoolCache::check_no_old_or_obsolete_entries() {
 635   for (int i = 1; i < length(); i++) {
 636     if (entry_at(i)->is_interesting_method_entry(NULL) &&
 637         !entry_at(i)->check_no_old_or_obsolete_entries()) {
 638       return false;
 639     }
 640   }
 641   return true;
 642 }
 643 
 644 void ConstantPoolCache::dump_cache() {
 645   for (int i = 1; i < length(); i++) {
 646     if (entry_at(i)->is_interesting_method_entry(NULL)) {
 647       entry_at(i)->print(tty, i);
 648     }
 649   }
 650 }
 651 #endif // INCLUDE_JVMTI
 652 
 653 
 654 // Printing
 655 
 656 void ConstantPoolCache::print_on(outputStream* st) const {
 657   assert(is_constantPoolCache(), "obj must be constant pool cache");
 658   st->print_cr(internal_name());
 659   // print constant pool cache entries
 660   for (int i = 0; i < length(); i++) entry_at(i)->print(st, i);
 661 }
 662 
 663 void ConstantPoolCache::print_value_on(outputStream* st) const {
 664   assert(is_constantPoolCache(), "obj must be constant pool cache");
 665   st->print("cache [%d]", length());
 666   print_address_on(st);
 667   st->print(" for ");
 668   constant_pool()->print_value_on(st);
 669 }
 670 
 671 
 672 // Verification
 673 
 674 void ConstantPoolCache::verify_on(outputStream* st) {
 675   guarantee(is_constantPoolCache(), "obj must be constant pool cache");
 676   // print constant pool cache entries
 677   for (int i = 0; i < length(); i++) entry_at(i)->verify(st);
 678 }