1 /*
   2  * Copyright (c) 1997, 2011, 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/javaClasses.hpp"
  27 #include "classfile/symbolTable.hpp"
  28 #include "classfile/systemDictionary.hpp"
  29 #include "classfile/vmSymbols.hpp"
  30 #include "interpreter/linkResolver.hpp"
  31 #include "memory/oopFactory.hpp"
  32 #include "memory/universe.inline.hpp"
  33 #include "oops/constantPoolOop.hpp"
  34 #include "oops/instanceKlass.hpp"
  35 #include "oops/objArrayKlass.hpp"
  36 #include "oops/oop.inline.hpp"
  37 #include "runtime/fieldType.hpp"
  38 #include "runtime/init.hpp"
  39 #include "runtime/signature.hpp"
  40 #include "runtime/vframe.hpp"
  41 
  42 void constantPoolOopDesc::set_flag_at(FlagBit fb) {
  43   const int MAX_STATE_CHANGES = 2;
  44   for (int i = MAX_STATE_CHANGES + 10; i > 0; i--) {
  45     int oflags = _flags;
  46     int nflags = oflags | (1 << (int)fb);
  47     if (Atomic::cmpxchg(nflags, &_flags, oflags) == oflags)
  48       return;
  49   }
  50   assert(false, "failed to cmpxchg flags");
  51   _flags |= (1 << (int)fb);     // better than nothing
  52 }
  53 
  54 klassOop constantPoolOopDesc::klass_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
  55   // A resolved constantPool entry will contain a klassOop, otherwise a Symbol*.
  56   // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
  57   // tag is not updated atomicly.
  58   CPSlot entry = this_oop->slot_at(which);
  59   if (entry.is_oop()) {
  60     assert(entry.get_oop()->is_klass(), "must be");
  61     // Already resolved - return entry.
  62     return (klassOop)entry.get_oop();
  63   }
  64 
  65   // Acquire lock on constant oop while doing update. After we get the lock, we check if another object
  66   // already has updated the object
  67   assert(THREAD->is_Java_thread(), "must be a Java thread");
  68   bool do_resolve = false;
  69   bool in_error = false;
  70 
  71   Symbol* name = NULL;
  72   Handle       loader;
  73   { ObjectLocker ol(this_oop, THREAD);
  74 
  75     if (this_oop->tag_at(which).is_unresolved_klass()) {
  76       if (this_oop->tag_at(which).is_unresolved_klass_in_error()) {
  77         in_error = true;
  78       } else {
  79         do_resolve = true;
  80         name   = this_oop->unresolved_klass_at(which);
  81         loader = Handle(THREAD, instanceKlass::cast(this_oop->pool_holder())->class_loader());
  82       }
  83     }
  84   } // unlocking constantPool
  85 
  86 
  87   // The original attempt to resolve this constant pool entry failed so find the
  88   // original error and throw it again (JVMS 5.4.3).
  89   if (in_error) {
  90     Symbol* error = SystemDictionary::find_resolution_error(this_oop, which);
  91     guarantee(error != (Symbol*)NULL, "tag mismatch with resolution error table");
  92     ResourceMark rm;
  93     // exception text will be the class name
  94     const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
  95     THROW_MSG_0(error, className);
  96   }
  97 
  98   if (do_resolve) {
  99     // this_oop must be unlocked during resolve_or_fail
 100     oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
 101     Handle h_prot (THREAD, protection_domain);
 102     klassOop k_oop = SystemDictionary::resolve_or_fail(name, loader, h_prot, true, THREAD);
 103     KlassHandle k;
 104     if (!HAS_PENDING_EXCEPTION) {
 105       k = KlassHandle(THREAD, k_oop);
 106       // Do access check for klasses
 107       verify_constant_pool_resolve(this_oop, k, THREAD);
 108     }
 109 
 110     // Failed to resolve class. We must record the errors so that subsequent attempts
 111     // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).
 112     if (HAS_PENDING_EXCEPTION) {
 113       ResourceMark rm;
 114       Symbol* error = PENDING_EXCEPTION->klass()->klass_part()->name();
 115 
 116       bool throw_orig_error = false;
 117       {
 118         ObjectLocker ol (this_oop, THREAD);
 119 
 120         // some other thread has beaten us and has resolved the class.
 121         if (this_oop->tag_at(which).is_klass()) {
 122           CLEAR_PENDING_EXCEPTION;
 123           entry = this_oop->resolved_klass_at(which);
 124           return (klassOop)entry.get_oop();
 125         }
 126 
 127         if (!PENDING_EXCEPTION->
 128               is_a(SystemDictionary::LinkageError_klass())) {
 129           // Just throw the exception and don't prevent these classes from
 130           // being loaded due to virtual machine errors like StackOverflow
 131           // and OutOfMemoryError, etc, or if the thread was hit by stop()
 132           // Needs clarification to section 5.4.3 of the VM spec (see 6308271)
 133         }
 134         else if (!this_oop->tag_at(which).is_unresolved_klass_in_error()) {
 135           SystemDictionary::add_resolution_error(this_oop, which, error);
 136           this_oop->tag_at_put(which, JVM_CONSTANT_UnresolvedClassInError);
 137         } else {
 138           // some other thread has put the class in error state.
 139           error = SystemDictionary::find_resolution_error(this_oop, which);
 140           assert(error != NULL, "checking");
 141           throw_orig_error = true;
 142         }
 143       } // unlocked
 144 
 145       if (throw_orig_error) {
 146         CLEAR_PENDING_EXCEPTION;
 147         ResourceMark rm;
 148         const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
 149         THROW_MSG_0(error, className);
 150       }
 151 
 152       return 0;
 153     }
 154 
 155     if (TraceClassResolution && !k()->klass_part()->oop_is_array()) {
 156       // skip resolving the constant pool so that this code get's
 157       // called the next time some bytecodes refer to this class.
 158       ResourceMark rm;
 159       int line_number = -1;
 160       const char * source_file = NULL;
 161       if (JavaThread::current()->has_last_Java_frame()) {
 162         // try to identify the method which called this function.
 163         vframeStream vfst(JavaThread::current());
 164         if (!vfst.at_end()) {
 165           line_number = vfst.method()->line_number_from_bci(vfst.bci());
 166           Symbol* s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name();
 167           if (s != NULL) {
 168             source_file = s->as_C_string();
 169           }
 170         }
 171       }
 172       if (k() != this_oop->pool_holder()) {
 173         // only print something if the classes are different
 174         if (source_file != NULL) {
 175           tty->print("RESOLVE %s %s %s:%d\n",
 176                      instanceKlass::cast(this_oop->pool_holder())->external_name(),
 177                      instanceKlass::cast(k())->external_name(), source_file, line_number);
 178         } else {
 179           tty->print("RESOLVE %s %s\n",
 180                      instanceKlass::cast(this_oop->pool_holder())->external_name(),
 181                      instanceKlass::cast(k())->external_name());
 182         }
 183       }
 184       return k();
 185     } else {
 186       ObjectLocker ol (this_oop, THREAD);
 187       // Only updated constant pool - if it is resolved.
 188       do_resolve = this_oop->tag_at(which).is_unresolved_klass();
 189       if (do_resolve) {
 190         this_oop->klass_at_put(which, k());
 191       }
 192     }
 193   }
 194 
 195   entry = this_oop->resolved_klass_at(which);
 196   assert(entry.is_oop() && entry.get_oop()->is_klass(), "must be resolved at this point");
 197   return (klassOop)entry.get_oop();
 198 }
 199 
 200 
 201 // Does not update constantPoolOop - to avoid any exception throwing. Used
 202 // by compiler and exception handling.  Also used to avoid classloads for
 203 // instanceof operations. Returns NULL if the class has not been loaded or
 204 // if the verification of constant pool failed
 205 klassOop constantPoolOopDesc::klass_at_if_loaded(constantPoolHandle this_oop, int which) {
 206   CPSlot entry = this_oop->slot_at(which);
 207   if (entry.is_oop()) {
 208     assert(entry.get_oop()->is_klass(), "must be");
 209     return (klassOop)entry.get_oop();
 210   } else {
 211     assert(entry.is_metadata(), "must be either symbol or klass");
 212     Thread *thread = Thread::current();
 213     Symbol* name = entry.get_symbol();
 214     oop loader = instanceKlass::cast(this_oop->pool_holder())->class_loader();
 215     oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
 216     Handle h_prot (thread, protection_domain);
 217     Handle h_loader (thread, loader);
 218     klassOop k = SystemDictionary::find(name, h_loader, h_prot, thread);
 219 
 220     if (k != NULL) {
 221       // Make sure that resolving is legal
 222       EXCEPTION_MARK;
 223       KlassHandle klass(THREAD, k);
 224       // return NULL if verification fails
 225       verify_constant_pool_resolve(this_oop, klass, THREAD);
 226       if (HAS_PENDING_EXCEPTION) {
 227         CLEAR_PENDING_EXCEPTION;
 228         return NULL;
 229       }
 230       return klass();
 231     } else {
 232       return k;
 233     }
 234   }
 235 }
 236 
 237 
 238 klassOop constantPoolOopDesc::klass_ref_at_if_loaded(constantPoolHandle this_oop, int which) {
 239   return klass_at_if_loaded(this_oop, this_oop->klass_ref_index_at(which));
 240 }
 241 
 242 
 243 // This is an interface for the compiler that allows accessing non-resolved entries
 244 // in the constant pool - but still performs the validations tests. Must be used
 245 // in a pre-parse of the compiler - to determine what it can do and not do.
 246 // Note: We cannot update the ConstantPool from the vm_thread.
 247 klassOop constantPoolOopDesc::klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int index, TRAPS) {
 248   int which = this_oop->klass_ref_index_at(index);
 249   CPSlot entry = this_oop->slot_at(which);
 250   if (entry.is_oop()) {
 251     assert(entry.get_oop()->is_klass(), "must be");
 252     return (klassOop)entry.get_oop();
 253   } else {
 254     assert(entry.is_metadata(), "must be either symbol or klass");
 255     Symbol*  name  = entry.get_symbol();
 256     oop loader = instanceKlass::cast(this_oop->pool_holder())->class_loader();
 257     oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
 258     Handle h_loader(THREAD, loader);
 259     Handle h_prot  (THREAD, protection_domain);
 260     KlassHandle k(THREAD, SystemDictionary::find(name, h_loader, h_prot, THREAD));
 261 
 262     // Do access check for klasses
 263     if( k.not_null() ) verify_constant_pool_resolve(this_oop, k, CHECK_NULL);
 264     return k();
 265   }
 266 }
 267 
 268 
 269 methodOop constantPoolOopDesc::method_at_if_loaded(constantPoolHandle cpool,
 270                                                    int which, Bytecodes::Code invoke_code) {
 271   assert(!constantPoolCacheOopDesc::is_secondary_index(which), "no indy instruction here");
 272   if (cpool->cache() == NULL)  return false;  // nothing to load yet
 273   int cache_index = which - CPCACHE_INDEX_TAG;
 274   if (!(cache_index >= 0 && cache_index < cpool->cache()->length())) {
 275     if (PrintMiscellaneous && (Verbose||WizardMode)) {
 276       tty->print_cr("bad operand %d for %d in:", which, invoke_code); cpool->print();
 277     }
 278     return NULL;
 279   }
 280   ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
 281   if (invoke_code != Bytecodes::_illegal)
 282     return e->get_method_if_resolved(invoke_code, cpool);
 283   Bytecodes::Code bc;
 284   if ((bc = e->bytecode_1()) != (Bytecodes::Code)0)
 285     return e->get_method_if_resolved(bc, cpool);
 286   if ((bc = e->bytecode_2()) != (Bytecodes::Code)0)
 287     return e->get_method_if_resolved(bc, cpool);
 288   return NULL;
 289 }
 290 
 291 
 292 Symbol* constantPoolOopDesc::impl_name_ref_at(int which, bool uncached) {
 293   int name_index = name_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
 294   return symbol_at(name_index);
 295 }
 296 
 297 
 298 Symbol* constantPoolOopDesc::impl_signature_ref_at(int which, bool uncached) {
 299   int signature_index = signature_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
 300   return symbol_at(signature_index);
 301 }
 302 
 303 
 304 int constantPoolOopDesc::impl_name_and_type_ref_index_at(int which, bool uncached) {
 305   int i = which;
 306   if (!uncached && cache() != NULL) {
 307     if (constantPoolCacheOopDesc::is_secondary_index(which)) {
 308       // Invokedynamic index.
 309       int pool_index = cache()->main_entry_at(which)->constant_pool_index();
 310       pool_index = invoke_dynamic_name_and_type_ref_index_at(pool_index);
 311       assert(tag_at(pool_index).is_name_and_type(), "");
 312       return pool_index;
 313     }
 314     // change byte-ordering and go via cache
 315     i = remap_instruction_operand_from_cache(which);
 316   } else {
 317     if (tag_at(which).is_invoke_dynamic()) {
 318       int pool_index = invoke_dynamic_name_and_type_ref_index_at(which);
 319       assert(tag_at(pool_index).is_name_and_type(), "");
 320       return pool_index;
 321     }
 322   }
 323   assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
 324   assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");
 325   jint ref_index = *int_at_addr(i);
 326   return extract_high_short_from_int(ref_index);
 327 }
 328 
 329 
 330 int constantPoolOopDesc::impl_klass_ref_index_at(int which, bool uncached) {
 331   guarantee(!constantPoolCacheOopDesc::is_secondary_index(which),
 332             "an invokedynamic instruction does not have a klass");
 333   int i = which;
 334   if (!uncached && cache() != NULL) {
 335     // change byte-ordering and go via cache
 336     i = remap_instruction_operand_from_cache(which);
 337   }
 338   assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
 339   jint ref_index = *int_at_addr(i);
 340   return extract_low_short_from_int(ref_index);
 341 }
 342 
 343 
 344 
 345 int constantPoolOopDesc::remap_instruction_operand_from_cache(int operand) {
 346   int cpc_index = operand;
 347   DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);
 348   assert((int)(u2)cpc_index == cpc_index, "clean u2");
 349   int member_index = cache()->entry_at(cpc_index)->constant_pool_index();
 350   return member_index;
 351 }
 352 
 353 
 354 void constantPoolOopDesc::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {
 355  if (k->oop_is_instance() || k->oop_is_objArray()) {
 356     instanceKlassHandle holder (THREAD, this_oop->pool_holder());
 357     klassOop elem_oop = k->oop_is_instance() ? k() : objArrayKlass::cast(k())->bottom_klass();
 358     KlassHandle element (THREAD, elem_oop);
 359 
 360     // The element type could be a typeArray - we only need the access check if it is
 361     // an reference to another class
 362     if (element->oop_is_instance()) {
 363       LinkResolver::check_klass_accessability(holder, element, CHECK);
 364     }
 365   }
 366 }
 367 
 368 
 369 int constantPoolOopDesc::name_ref_index_at(int which_nt) {
 370   jint ref_index = name_and_type_at(which_nt);
 371   return extract_low_short_from_int(ref_index);
 372 }
 373 
 374 
 375 int constantPoolOopDesc::signature_ref_index_at(int which_nt) {
 376   jint ref_index = name_and_type_at(which_nt);
 377   return extract_high_short_from_int(ref_index);
 378 }
 379 
 380 
 381 klassOop constantPoolOopDesc::klass_ref_at(int which, TRAPS) {
 382   return klass_at(klass_ref_index_at(which), CHECK_NULL);
 383 }
 384 
 385 
 386 Symbol* constantPoolOopDesc::klass_name_at(int which) {
 387   assert(tag_at(which).is_unresolved_klass() || tag_at(which).is_klass(),
 388          "Corrupted constant pool");
 389   // A resolved constantPool entry will contain a klassOop, otherwise a Symbol*.
 390   // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
 391   // tag is not updated atomicly.
 392   CPSlot entry = slot_at(which);
 393   if (entry.is_oop()) {
 394     // Already resolved - return entry's name.
 395     assert(entry.get_oop()->is_klass(), "must be");
 396     return klassOop(entry.get_oop())->klass_part()->name();
 397   } else {
 398     assert(entry.is_metadata(), "must be either symbol or klass");
 399     return entry.get_symbol();
 400   }
 401 }
 402 
 403 Symbol* constantPoolOopDesc::klass_ref_at_noresolve(int which) {
 404   jint ref_index = klass_ref_index_at(which);
 405   return klass_at_noresolve(ref_index);
 406 }
 407 
 408 Symbol* constantPoolOopDesc::uncached_klass_ref_at_noresolve(int which) {
 409   jint ref_index = uncached_klass_ref_index_at(which);
 410   return klass_at_noresolve(ref_index);
 411 }
 412 
 413 char* constantPoolOopDesc::string_at_noresolve(int which) {
 414   // Test entry type in case string is resolved while in here.
 415   CPSlot entry = slot_at(which);
 416   if (entry.is_metadata()) {
 417     return (entry.get_symbol())->as_C_string();
 418   } else if (java_lang_String::is_instance(entry.get_oop())) {
 419     return java_lang_String::as_utf8_string(entry.get_oop());
 420   } else {
 421     return (char*)"<pseudo-string>";
 422   }
 423 }
 424 
 425 
 426 BasicType constantPoolOopDesc::basic_type_for_signature_at(int which) {
 427   return FieldType::basic_type(symbol_at(which));
 428 }
 429 
 430 
 431 void constantPoolOopDesc::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {
 432   for (int index = 1; index < this_oop->length(); index++) { // Index 0 is unused
 433     if (this_oop->tag_at(index).is_unresolved_string()) {
 434       this_oop->string_at(index, CHECK);
 435     }
 436   }
 437 }
 438 
 439 // A resolved constant value in the CP cache is represented as a non-null
 440 // value.  As a special case, this value can be a 'systemObjArray'
 441 // which masks an exception object to throw.
 442 // This allows a MethodHandle constant reference to throw a consistent
 443 // exception every time, if it fails to resolve.
 444 static oop decode_exception_from_f1(oop result_oop, TRAPS) {
 445   if (result_oop->klass() != Universe::systemObjArrayKlassObj())
 446     return result_oop;
 447 
 448   // Special cases here:  Masked null, saved exception.
 449   objArrayOop sys_array = (objArrayOop) result_oop;
 450   assert(sys_array->length() == 1, "bad system array");
 451   if (sys_array->length() == 1) {
 452     THROW_OOP_(sys_array->obj_at(0), NULL);
 453   }
 454   return NULL;
 455 }
 456 
 457 oop constantPoolOopDesc::resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS) {
 458   oop result_oop = NULL;
 459   Handle throw_exception;
 460 
 461   if (cache_index == _possible_index_sentinel) {
 462     // It is possible that this constant is one which is cached in the CP cache.
 463     // We'll do a linear search.  This should be OK because this usage is rare.
 464     assert(index > 0, "valid index");
 465     constantPoolCacheOop cache = this_oop()->cache();
 466     for (int i = 0, len = cache->length(); i < len; i++) {
 467       ConstantPoolCacheEntry* cpc_entry = cache->entry_at(i);
 468       if (!cpc_entry->is_secondary_entry() && cpc_entry->constant_pool_index() == index) {
 469         // Switch the query to use this CPC entry.
 470         cache_index = i;
 471         index = _no_index_sentinel;
 472         break;
 473       }
 474     }
 475     if (cache_index == _possible_index_sentinel)
 476       cache_index = _no_index_sentinel;  // not found
 477   }
 478   assert(cache_index == _no_index_sentinel || cache_index >= 0, "");
 479   assert(index == _no_index_sentinel || index >= 0, "");
 480 
 481   if (cache_index >= 0) {
 482     assert(index == _no_index_sentinel, "only one kind of index at a time");
 483     ConstantPoolCacheEntry* cpc_entry = this_oop->cache()->entry_at(cache_index);
 484     result_oop = cpc_entry->f1();
 485     if (result_oop != NULL) {
 486       return decode_exception_from_f1(result_oop, THREAD);
 487       // That was easy...
 488     }
 489     index = cpc_entry->constant_pool_index();
 490   }
 491 
 492   jvalue prim_value;  // temp used only in a few cases below
 493 
 494   int tag_value = this_oop->tag_at(index).value();
 495   switch (tag_value) {
 496 
 497   case JVM_CONSTANT_UnresolvedClass:
 498   case JVM_CONSTANT_UnresolvedClassInError:
 499   case JVM_CONSTANT_Class:
 500     {
 501       klassOop resolved = klass_at_impl(this_oop, index, CHECK_NULL);
 502       // ldc wants the java mirror.
 503       result_oop = resolved->java_mirror();
 504       break;
 505     }
 506 
 507   case JVM_CONSTANT_String:
 508   case JVM_CONSTANT_UnresolvedString:
 509     if (this_oop->is_pseudo_string_at(index)) {
 510       result_oop = this_oop->pseudo_string_at(index);
 511       break;
 512     }
 513     result_oop = string_at_impl(this_oop, index, CHECK_NULL);
 514     break;
 515 
 516   case JVM_CONSTANT_Object:
 517     result_oop = this_oop->object_at(index);
 518     break;
 519 
 520   case JVM_CONSTANT_MethodHandle:
 521     {
 522       int ref_kind                 = this_oop->method_handle_ref_kind_at(index);
 523       int callee_index             = this_oop->method_handle_klass_index_at(index);
 524       Symbol*  name =      this_oop->method_handle_name_ref_at(index);
 525       Symbol*  signature = this_oop->method_handle_signature_ref_at(index);
 526       if (PrintMiscellaneous)
 527         tty->print_cr("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s",
 528                       ref_kind, index, this_oop->method_handle_index_at(index),
 529                       callee_index, name->as_C_string(), signature->as_C_string());
 530       KlassHandle callee;
 531       { klassOop k = klass_at_impl(this_oop, callee_index, CHECK_NULL);
 532         callee = KlassHandle(THREAD, k);
 533       }
 534       KlassHandle klass(THREAD, this_oop->pool_holder());
 535       Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,
 536                                                                    callee, name, signature,
 537                                                                    THREAD);
 538       if (HAS_PENDING_EXCEPTION) {
 539         throw_exception = Handle(THREAD, PENDING_EXCEPTION);
 540         CLEAR_PENDING_EXCEPTION;
 541         break;
 542       }
 543       result_oop = value();
 544       assert(result_oop != NULL, "");
 545       break;
 546     }
 547 
 548   case JVM_CONSTANT_MethodType:
 549     {
 550       Symbol*  signature = this_oop->method_type_signature_at(index);
 551       if (PrintMiscellaneous)
 552         tty->print_cr("resolve JVM_CONSTANT_MethodType [%d/%d] %s",
 553                       index, this_oop->method_type_index_at(index),
 554                       signature->as_C_string());
 555       KlassHandle klass(THREAD, this_oop->pool_holder());
 556       bool ignore_is_on_bcp = false;
 557       Handle value = SystemDictionary::find_method_handle_type(signature,
 558                                                                klass,
 559                                                                false,
 560                                                                ignore_is_on_bcp,
 561                                                                THREAD);
 562       if (HAS_PENDING_EXCEPTION) {
 563         throw_exception = Handle(THREAD, PENDING_EXCEPTION);
 564         CLEAR_PENDING_EXCEPTION;
 565         break;
 566       }
 567       result_oop = value();
 568       assert(result_oop != NULL, "");
 569       break;
 570     }
 571 
 572   case JVM_CONSTANT_Integer:
 573     prim_value.i = this_oop->int_at(index);
 574     result_oop = java_lang_boxing_object::create(T_INT, &prim_value, CHECK_NULL);
 575     break;
 576 
 577   case JVM_CONSTANT_Float:
 578     prim_value.f = this_oop->float_at(index);
 579     result_oop = java_lang_boxing_object::create(T_FLOAT, &prim_value, CHECK_NULL);
 580     break;
 581 
 582   case JVM_CONSTANT_Long:
 583     prim_value.j = this_oop->long_at(index);
 584     result_oop = java_lang_boxing_object::create(T_LONG, &prim_value, CHECK_NULL);
 585     break;
 586 
 587   case JVM_CONSTANT_Double:
 588     prim_value.d = this_oop->double_at(index);
 589     result_oop = java_lang_boxing_object::create(T_DOUBLE, &prim_value, CHECK_NULL);
 590     break;
 591 
 592   default:
 593     DEBUG_ONLY( tty->print_cr("*** %p: tag at CP[%d/%d] = %d",
 594                               this_oop(), index, cache_index, tag_value) );
 595     assert(false, "unexpected constant tag");
 596     break;
 597   }
 598 
 599   if (cache_index >= 0) {
 600     // Cache the oop here also.
 601     if (throw_exception.not_null()) {
 602       objArrayOop sys_array = oopFactory::new_system_objArray(1, CHECK_NULL);
 603       sys_array->obj_at_put(0, throw_exception());
 604       result_oop = sys_array;
 605       throw_exception = Handle();  // be tidy
 606     }
 607     Handle result_handle(THREAD, result_oop);
 608     result_oop = NULL;  // safety
 609     ObjectLocker ol(this_oop, THREAD);
 610     ConstantPoolCacheEntry* cpc_entry = this_oop->cache()->entry_at(cache_index);
 611     result_oop = cpc_entry->f1();
 612     // Benign race condition:  f1 may already be filled in while we were trying to lock.
 613     // The important thing here is that all threads pick up the same result.
 614     // It doesn't matter which racing thread wins, as long as only one
 615     // result is used by all threads, and all future queries.
 616     // That result may be either a resolved constant or a failure exception.
 617     if (result_oop == NULL) {
 618       result_oop = result_handle();
 619       cpc_entry->set_f1(result_oop);
 620     }
 621     return decode_exception_from_f1(result_oop, THREAD);
 622   } else {
 623     if (throw_exception.not_null()) {
 624       THROW_HANDLE_(throw_exception, NULL);
 625     }
 626     return result_oop;
 627   }
 628 }
 629 
 630 oop constantPoolOopDesc::string_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
 631   oop str = NULL;
 632   CPSlot entry = this_oop->slot_at(which);
 633   if (entry.is_metadata()) {
 634     ObjectLocker ol(this_oop, THREAD);
 635     if (this_oop->tag_at(which).is_unresolved_string()) {
 636       // Intern string
 637       Symbol* sym = this_oop->unresolved_string_at(which);
 638       str = StringTable::intern(sym, CHECK_(constantPoolOop(NULL)));
 639       this_oop->string_at_put(which, str);
 640     } else {
 641       // Another thread beat us and interned string, read string from constant pool
 642       str = this_oop->resolved_string_at(which);
 643     }
 644   } else {
 645     str = entry.get_oop();
 646   }
 647   assert(java_lang_String::is_instance(str), "must be string");
 648   return str;
 649 }
 650 
 651 
 652 bool constantPoolOopDesc::is_pseudo_string_at(int which) {
 653   CPSlot entry = slot_at(which);
 654   if (entry.is_metadata())
 655     // Not yet resolved, but it will resolve to a string.
 656     return false;
 657   else if (java_lang_String::is_instance(entry.get_oop()))
 658     return false; // actually, it might be a non-interned or non-perm string
 659   else
 660     // truly pseudo
 661     return true;
 662 }
 663 
 664 
 665 bool constantPoolOopDesc::klass_name_at_matches(instanceKlassHandle k,
 666                                                 int which) {
 667   // Names are interned, so we can compare Symbol*s directly
 668   Symbol* cp_name = klass_name_at(which);
 669   return (cp_name == k->name());
 670 }
 671 
 672 
 673 int constantPoolOopDesc::pre_resolve_shared_klasses(TRAPS) {
 674   ResourceMark rm;
 675   int count = 0;
 676   for (int index = 1; index < tags()->length(); index++) { // Index 0 is unused
 677     if (tag_at(index).is_unresolved_string()) {
 678       // Intern string
 679       Symbol* sym = unresolved_string_at(index);
 680       oop entry = StringTable::intern(sym, CHECK_(-1));
 681       string_at_put(index, entry);
 682     }
 683   }
 684   return count;
 685 }
 686 
 687 // Iterate over symbols and decrement ones which are Symbol*s.
 688 // This is done during GC so do not need to lock constantPool unless we
 689 // have per-thread safepoints.
 690 // Only decrement the UTF8 symbols. Unresolved classes and strings point to
 691 // these symbols but didn't increment the reference count.
 692 void constantPoolOopDesc::unreference_symbols() {
 693   for (int index = 1; index < length(); index++) { // Index 0 is unused
 694     constantTag tag = tag_at(index);
 695     if (tag.is_symbol()) {
 696       symbol_at(index)->decrement_refcount();
 697     }
 698   }
 699 }
 700 
 701 // Iterate over symbols which are used as class, field, method names and
 702 // signatures (in preparation for writing to the shared archive).
 703 
 704 void constantPoolOopDesc::shared_symbols_iterate(SymbolClosure* closure) {
 705   for (int index = 1; index < length(); index++) { // Index 0 is unused
 706     switch (tag_at(index).value()) {
 707 
 708     case JVM_CONSTANT_UnresolvedClass:
 709     case JVM_CONSTANT_UnresolvedString:
 710     case JVM_CONSTANT_Utf8:
 711       assert(slot_at(index).is_metadata(), "must be symbol");
 712       closure->do_symbol(symbol_at_addr(index));
 713       break;
 714 
 715     case JVM_CONSTANT_NameAndType:
 716       {
 717         int i = *int_at_addr(index);
 718         closure->do_symbol(symbol_at_addr((unsigned)i >> 16));
 719         closure->do_symbol(symbol_at_addr((unsigned)i & 0xffff));
 720       }
 721       break;
 722 
 723     case JVM_CONSTANT_Class:
 724     case JVM_CONSTANT_InterfaceMethodref:
 725     case JVM_CONSTANT_Fieldref:
 726     case JVM_CONSTANT_Methodref:
 727     case JVM_CONSTANT_Integer:
 728     case JVM_CONSTANT_Float:
 729       // Do nothing!  Not an oop.
 730       // These constant types do not reference symbols at this point.
 731       break;
 732 
 733     case JVM_CONSTANT_String:
 734       // Do nothing!  Not a symbol.
 735       break;
 736 
 737     case JVM_CONSTANT_Long:
 738     case JVM_CONSTANT_Double:
 739       // Do nothing!  Not an oop. (But takes two pool entries.)
 740       ++index;
 741       break;
 742 
 743     default:
 744       ShouldNotReachHere();
 745       break;
 746     }
 747   }
 748 }
 749 
 750 
 751 // Iterate over the [one] tags array (in preparation for writing to the
 752 // shared archive).
 753 
 754 void constantPoolOopDesc::shared_tags_iterate(OopClosure* closure) {
 755   closure->do_oop(tags_addr());
 756   closure->do_oop(operands_addr());
 757 }
 758 
 759 
 760 // Iterate over String objects (in preparation for writing to the shared
 761 // archive).
 762 
 763 void constantPoolOopDesc::shared_strings_iterate(OopClosure* closure) {
 764   for (int index = 1; index < length(); index++) { // Index 0 is unused
 765     switch (tag_at(index).value()) {
 766 
 767     case JVM_CONSTANT_UnresolvedClass:
 768     case JVM_CONSTANT_NameAndType:
 769       // Do nothing!  Not a String.
 770       break;
 771 
 772     case JVM_CONSTANT_Class:
 773     case JVM_CONSTANT_InterfaceMethodref:
 774     case JVM_CONSTANT_Fieldref:
 775     case JVM_CONSTANT_Methodref:
 776     case JVM_CONSTANT_Integer:
 777     case JVM_CONSTANT_Float:
 778       // Do nothing!  Not an oop.
 779       // These constant types do not reference symbols at this point.
 780       break;
 781 
 782     case JVM_CONSTANT_String:
 783       closure->do_oop(obj_at_addr_raw(index));
 784       break;
 785 
 786     case JVM_CONSTANT_UnresolvedString:
 787     case JVM_CONSTANT_Utf8:
 788       // These constants are symbols, but unless these symbols are
 789       // actually to be used for something, we don't want to mark them.
 790       break;
 791 
 792     case JVM_CONSTANT_Long:
 793     case JVM_CONSTANT_Double:
 794       // Do nothing!  Not an oop. (But takes two pool entries.)
 795       ++index;
 796       break;
 797 
 798     default:
 799       ShouldNotReachHere();
 800       break;
 801     }
 802   }
 803 }
 804 
 805 
 806 // Compare this constant pool's entry at index1 to the constant pool
 807 // cp2's entry at index2.
 808 bool constantPoolOopDesc::compare_entry_to(int index1, constantPoolHandle cp2,
 809        int index2, TRAPS) {
 810 
 811   jbyte t1 = tag_at(index1).value();
 812   jbyte t2 = cp2->tag_at(index2).value();
 813 
 814 
 815   // JVM_CONSTANT_UnresolvedClassInError is equal to JVM_CONSTANT_UnresolvedClass
 816   // when comparing
 817   if (t1 == JVM_CONSTANT_UnresolvedClassInError) {
 818     t1 = JVM_CONSTANT_UnresolvedClass;
 819   }
 820   if (t2 == JVM_CONSTANT_UnresolvedClassInError) {
 821     t2 = JVM_CONSTANT_UnresolvedClass;
 822   }
 823 
 824   if (t1 != t2) {
 825     // Not the same entry type so there is nothing else to check. Note
 826     // that this style of checking will consider resolved/unresolved
 827     // class pairs and resolved/unresolved string pairs as different.
 828     // From the constantPoolOop API point of view, this is correct
 829     // behavior. See constantPoolKlass::merge() to see how this plays
 830     // out in the context of constantPoolOop merging.
 831     return false;
 832   }
 833 
 834   switch (t1) {
 835   case JVM_CONSTANT_Class:
 836   {
 837     klassOop k1 = klass_at(index1, CHECK_false);
 838     klassOop k2 = cp2->klass_at(index2, CHECK_false);
 839     if (k1 == k2) {
 840       return true;
 841     }
 842   } break;
 843 
 844   case JVM_CONSTANT_ClassIndex:
 845   {
 846     int recur1 = klass_index_at(index1);
 847     int recur2 = cp2->klass_index_at(index2);
 848     bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
 849     if (match) {
 850       return true;
 851     }
 852   } break;
 853 
 854   case JVM_CONSTANT_Double:
 855   {
 856     jdouble d1 = double_at(index1);
 857     jdouble d2 = cp2->double_at(index2);
 858     if (d1 == d2) {
 859       return true;
 860     }
 861   } break;
 862 
 863   case JVM_CONSTANT_Fieldref:
 864   case JVM_CONSTANT_InterfaceMethodref:
 865   case JVM_CONSTANT_Methodref:
 866   {
 867     int recur1 = uncached_klass_ref_index_at(index1);
 868     int recur2 = cp2->uncached_klass_ref_index_at(index2);
 869     bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
 870     if (match) {
 871       recur1 = uncached_name_and_type_ref_index_at(index1);
 872       recur2 = cp2->uncached_name_and_type_ref_index_at(index2);
 873       match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
 874       if (match) {
 875         return true;
 876       }
 877     }
 878   } break;
 879 
 880   case JVM_CONSTANT_Float:
 881   {
 882     jfloat f1 = float_at(index1);
 883     jfloat f2 = cp2->float_at(index2);
 884     if (f1 == f2) {
 885       return true;
 886     }
 887   } break;
 888 
 889   case JVM_CONSTANT_Integer:
 890   {
 891     jint i1 = int_at(index1);
 892     jint i2 = cp2->int_at(index2);
 893     if (i1 == i2) {
 894       return true;
 895     }
 896   } break;
 897 
 898   case JVM_CONSTANT_Long:
 899   {
 900     jlong l1 = long_at(index1);
 901     jlong l2 = cp2->long_at(index2);
 902     if (l1 == l2) {
 903       return true;
 904     }
 905   } break;
 906 
 907   case JVM_CONSTANT_NameAndType:
 908   {
 909     int recur1 = name_ref_index_at(index1);
 910     int recur2 = cp2->name_ref_index_at(index2);
 911     bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
 912     if (match) {
 913       recur1 = signature_ref_index_at(index1);
 914       recur2 = cp2->signature_ref_index_at(index2);
 915       match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
 916       if (match) {
 917         return true;
 918       }
 919     }
 920   } break;
 921 
 922   case JVM_CONSTANT_String:
 923   {
 924     oop s1 = string_at(index1, CHECK_false);
 925     oop s2 = cp2->string_at(index2, CHECK_false);
 926     if (s1 == s2) {
 927       return true;
 928     }
 929   } break;
 930 
 931   case JVM_CONSTANT_StringIndex:
 932   {
 933     int recur1 = string_index_at(index1);
 934     int recur2 = cp2->string_index_at(index2);
 935     bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
 936     if (match) {
 937       return true;
 938     }
 939   } break;
 940 
 941   case JVM_CONSTANT_UnresolvedClass:
 942   {
 943     Symbol* k1 = unresolved_klass_at(index1);
 944     Symbol* k2 = cp2->unresolved_klass_at(index2);
 945     if (k1 == k2) {
 946       return true;
 947     }
 948   } break;
 949 
 950   case JVM_CONSTANT_MethodType:
 951   {
 952     int k1 = method_type_index_at(index1);
 953     int k2 = cp2->method_type_index_at(index2);
 954     bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
 955     if (match) {
 956       return true;
 957     }
 958   } break;
 959 
 960   case JVM_CONSTANT_MethodHandle:
 961   {
 962     int k1 = method_handle_ref_kind_at(index1);
 963     int k2 = cp2->method_handle_ref_kind_at(index2);
 964     if (k1 == k2) {
 965       int i1 = method_handle_index_at(index1);
 966       int i2 = cp2->method_handle_index_at(index2);
 967       bool match = compare_entry_to(i1, cp2, i2, CHECK_false);
 968       if (match) {
 969         return true;
 970       }
 971     }
 972   } break;
 973 
 974   case JVM_CONSTANT_InvokeDynamic:
 975   {
 976     int k1 = invoke_dynamic_bootstrap_method_ref_index_at(index1);
 977     int k2 = cp2->invoke_dynamic_bootstrap_method_ref_index_at(index2);
 978     bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
 979     if (!match)  return false;
 980     k1 = invoke_dynamic_name_and_type_ref_index_at(index1);
 981     k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
 982     match = compare_entry_to(k1, cp2, k2, CHECK_false);
 983     if (!match)  return false;
 984     int argc = invoke_dynamic_argument_count_at(index1);
 985     if (argc == cp2->invoke_dynamic_argument_count_at(index2)) {
 986       for (int j = 0; j < argc; j++) {
 987         k1 = invoke_dynamic_argument_index_at(index1, j);
 988         k2 = cp2->invoke_dynamic_argument_index_at(index2, j);
 989         match = compare_entry_to(k1, cp2, k2, CHECK_false);
 990         if (!match)  return false;
 991       }
 992       return true;           // got through loop; all elements equal
 993     }
 994   } break;
 995 
 996   case JVM_CONSTANT_UnresolvedString:
 997   {
 998     Symbol* s1 = unresolved_string_at(index1);
 999     Symbol* s2 = cp2->unresolved_string_at(index2);
1000     if (s1 == s2) {
1001       return true;
1002     }
1003   } break;
1004 
1005   case JVM_CONSTANT_Utf8:
1006   {
1007     Symbol* s1 = symbol_at(index1);
1008     Symbol* s2 = cp2->symbol_at(index2);
1009     if (s1 == s2) {
1010       return true;
1011     }
1012   } break;
1013 
1014   // Invalid is used as the tag for the second constant pool entry
1015   // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
1016   // not be seen by itself.
1017   case JVM_CONSTANT_Invalid: // fall through
1018 
1019   default:
1020     ShouldNotReachHere();
1021     break;
1022   }
1023 
1024   return false;
1025 } // end compare_entry_to()
1026 
1027 
1028 // Copy this constant pool's entries at start_i to end_i (inclusive)
1029 // to the constant pool to_cp's entries starting at to_i. A total of
1030 // (end_i - start_i) + 1 entries are copied.
1031 void constantPoolOopDesc::copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i,
1032        constantPoolHandle to_cp, int to_i, TRAPS) {
1033 
1034   int dest_i = to_i;  // leave original alone for debug purposes
1035 
1036   for (int src_i = start_i; src_i <= end_i; /* see loop bottom */ ) {
1037     copy_entry_to(from_cp, src_i, to_cp, dest_i, CHECK);
1038 
1039     switch (from_cp->tag_at(src_i).value()) {
1040     case JVM_CONSTANT_Double:
1041     case JVM_CONSTANT_Long:
1042       // double and long take two constant pool entries
1043       src_i += 2;
1044       dest_i += 2;
1045       break;
1046 
1047     default:
1048       // all others take one constant pool entry
1049       src_i++;
1050       dest_i++;
1051       break;
1052     }
1053   }
1054 
1055   int from_oplen = operand_array_length(from_cp->operands());
1056   int old_oplen  = operand_array_length(to_cp->operands());
1057   if (from_oplen != 0) {
1058     // append my operands to the target's operands array
1059     if (old_oplen == 0) {
1060       to_cp->set_operands(from_cp->operands());  // reuse; do not merge
1061     } else {
1062       int old_len  = to_cp->operands()->length();
1063       int from_len = from_cp->operands()->length();
1064       int old_off  = old_oplen * sizeof(u2);
1065       int from_off = from_oplen * sizeof(u2);
1066       typeArrayHandle new_operands = oopFactory::new_permanent_shortArray(old_len + from_len, CHECK);
1067       int fillp = 0, len = 0;
1068       // first part of dest
1069       Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(0),
1070                                    new_operands->short_at_addr(fillp),
1071                                    (len = old_off) * sizeof(u2));
1072       fillp += len;
1073       // first part of src
1074       Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(0),
1075                                    new_operands->short_at_addr(fillp),
1076                                    (len = from_off) * sizeof(u2));
1077       fillp += len;
1078       // second part of dest
1079       Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(old_off),
1080                                    new_operands->short_at_addr(fillp),
1081                                    (len = old_len - old_off) * sizeof(u2));
1082       fillp += len;
1083       // second part of src
1084       Copy::conjoint_memory_atomic(to_cp->operands()->short_at_addr(from_off),
1085                                    new_operands->short_at_addr(fillp),
1086                                    (len = from_len - from_off) * sizeof(u2));
1087       fillp += len;
1088       assert(fillp == new_operands->length(), "");
1089 
1090       // Adjust indexes in the first part of the copied operands array.
1091       for (int j = 0; j < from_oplen; j++) {
1092         int offset = operand_offset_at(new_operands(), old_oplen + j);
1093         assert(offset == operand_offset_at(from_cp->operands(), j), "correct copy");
1094         offset += old_len;  // every new tuple is preceded by old_len extra u2's
1095         operand_offset_at_put(new_operands(), old_oplen + j, offset);
1096       }
1097 
1098       // replace target operands array with combined array
1099       to_cp->set_operands(new_operands());
1100     }
1101   }
1102 
1103 } // end copy_cp_to()
1104 
1105 
1106 // Copy this constant pool's entry at from_i to the constant pool
1107 // to_cp's entry at to_i.
1108 void constantPoolOopDesc::copy_entry_to(constantPoolHandle from_cp, int from_i,
1109                                         constantPoolHandle to_cp, int to_i,
1110                                         TRAPS) {
1111 
1112   int tag = from_cp->tag_at(from_i).value();
1113   switch (tag) {
1114   case JVM_CONSTANT_Class:
1115   {
1116     klassOop k = from_cp->klass_at(from_i, CHECK);
1117     to_cp->klass_at_put(to_i, k);
1118   } break;
1119 
1120   case JVM_CONSTANT_ClassIndex:
1121   {
1122     jint ki = from_cp->klass_index_at(from_i);
1123     to_cp->klass_index_at_put(to_i, ki);
1124   } break;
1125 
1126   case JVM_CONSTANT_Double:
1127   {
1128     jdouble d = from_cp->double_at(from_i);
1129     to_cp->double_at_put(to_i, d);
1130     // double takes two constant pool entries so init second entry's tag
1131     to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
1132   } break;
1133 
1134   case JVM_CONSTANT_Fieldref:
1135   {
1136     int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1137     int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1138     to_cp->field_at_put(to_i, class_index, name_and_type_index);
1139   } break;
1140 
1141   case JVM_CONSTANT_Float:
1142   {
1143     jfloat f = from_cp->float_at(from_i);
1144     to_cp->float_at_put(to_i, f);
1145   } break;
1146 
1147   case JVM_CONSTANT_Integer:
1148   {
1149     jint i = from_cp->int_at(from_i);
1150     to_cp->int_at_put(to_i, i);
1151   } break;
1152 
1153   case JVM_CONSTANT_InterfaceMethodref:
1154   {
1155     int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1156     int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1157     to_cp->interface_method_at_put(to_i, class_index, name_and_type_index);
1158   } break;
1159 
1160   case JVM_CONSTANT_Long:
1161   {
1162     jlong l = from_cp->long_at(from_i);
1163     to_cp->long_at_put(to_i, l);
1164     // long takes two constant pool entries so init second entry's tag
1165     to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
1166   } break;
1167 
1168   case JVM_CONSTANT_Methodref:
1169   {
1170     int class_index = from_cp->uncached_klass_ref_index_at(from_i);
1171     int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
1172     to_cp->method_at_put(to_i, class_index, name_and_type_index);
1173   } break;
1174 
1175   case JVM_CONSTANT_NameAndType:
1176   {
1177     int name_ref_index = from_cp->name_ref_index_at(from_i);
1178     int signature_ref_index = from_cp->signature_ref_index_at(from_i);
1179     to_cp->name_and_type_at_put(to_i, name_ref_index, signature_ref_index);
1180   } break;
1181 
1182   case JVM_CONSTANT_String:
1183   {
1184     oop s = from_cp->string_at(from_i, CHECK);
1185     to_cp->string_at_put(to_i, s);
1186   } break;
1187 
1188   case JVM_CONSTANT_StringIndex:
1189   {
1190     jint si = from_cp->string_index_at(from_i);
1191     to_cp->string_index_at_put(to_i, si);
1192   } break;
1193 
1194   case JVM_CONSTANT_UnresolvedClass:
1195   {
1196     // Can be resolved after checking tag, so check the slot first.
1197     CPSlot entry = from_cp->slot_at(from_i);
1198     if (entry.is_oop()) {
1199       assert(entry.get_oop()->is_klass(), "must be");
1200       // Already resolved
1201       to_cp->klass_at_put(to_i, (klassOop)entry.get_oop());
1202     } else {
1203       to_cp->unresolved_klass_at_put(to_i, entry.get_symbol());
1204     }
1205   } break;
1206 
1207   case JVM_CONSTANT_UnresolvedClassInError:
1208   {
1209     Symbol* k = from_cp->unresolved_klass_at(from_i);
1210     to_cp->unresolved_klass_at_put(to_i, k);
1211     to_cp->tag_at_put(to_i, JVM_CONSTANT_UnresolvedClassInError);
1212   } break;
1213 
1214 
1215   case JVM_CONSTANT_UnresolvedString:
1216   {
1217     // Can be resolved after checking tag, so check the slot first.
1218     CPSlot entry = from_cp->slot_at(from_i);
1219     if (entry.is_oop()) {
1220       // Already resolved (either string or pseudo-string)
1221       to_cp->string_at_put(to_i, entry.get_oop());
1222     } else {
1223       to_cp->unresolved_string_at_put(to_i, entry.get_symbol());
1224     }
1225   } break;
1226 
1227   case JVM_CONSTANT_Utf8:
1228   {
1229     Symbol* s = from_cp->symbol_at(from_i);
1230     to_cp->symbol_at_put(to_i, s);
1231     // This constantPool has the same lifetime as the original, so don't
1232     // increase reference counts for the copy.
1233   } break;
1234 
1235   case JVM_CONSTANT_MethodType:
1236   {
1237     jint k = from_cp->method_type_index_at(from_i);
1238     to_cp->method_type_index_at_put(to_i, k);
1239   } break;
1240 
1241   case JVM_CONSTANT_MethodHandle:
1242   {
1243     int k1 = from_cp->method_handle_ref_kind_at(from_i);
1244     int k2 = from_cp->method_handle_index_at(from_i);
1245     to_cp->method_handle_index_at_put(to_i, k1, k2);
1246   } break;
1247 
1248   case JVM_CONSTANT_InvokeDynamic:
1249   {
1250     int k1 = from_cp->invoke_dynamic_bootstrap_specifier_index(from_i);
1251     int k2 = from_cp->invoke_dynamic_name_and_type_ref_index_at(from_i);
1252     k1 += operand_array_length(to_cp->operands());  // to_cp might already have operands
1253     to_cp->invoke_dynamic_at_put(to_i, k1, k2);
1254   } break;
1255 
1256   // Invalid is used as the tag for the second constant pool entry
1257   // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
1258   // not be seen by itself.
1259   case JVM_CONSTANT_Invalid: // fall through
1260 
1261   default:
1262   {
1263     ShouldNotReachHere();
1264   } break;
1265   }
1266 } // end copy_entry_to()
1267 
1268 
1269 // Search constant pool search_cp for an entry that matches this
1270 // constant pool's entry at pattern_i. Returns the index of a
1271 // matching entry or zero (0) if there is no matching entry.
1272 int constantPoolOopDesc::find_matching_entry(int pattern_i,
1273       constantPoolHandle search_cp, TRAPS) {
1274 
1275   // index zero (0) is not used
1276   for (int i = 1; i < search_cp->length(); i++) {
1277     bool found = compare_entry_to(pattern_i, search_cp, i, CHECK_0);
1278     if (found) {
1279       return i;
1280     }
1281   }
1282 
1283   return 0;  // entry not found; return unused index zero (0)
1284 } // end find_matching_entry()
1285 
1286 
1287 #ifndef PRODUCT
1288 
1289 const char* constantPoolOopDesc::printable_name_at(int which) {
1290 
1291   constantTag tag = tag_at(which);
1292 
1293   if (tag.is_unresolved_string() || tag.is_string()) {
1294     return string_at_noresolve(which);
1295   } else if (tag.is_klass() || tag.is_unresolved_klass()) {
1296     return klass_name_at(which)->as_C_string();
1297   } else if (tag.is_symbol()) {
1298     return symbol_at(which)->as_C_string();
1299   }
1300   return "";
1301 }
1302 
1303 #endif // PRODUCT
1304 
1305 
1306 // JVMTI GetConstantPool support
1307 
1308 // For temporary use until code is stable.
1309 #define DBG(code)
1310 
1311 static const char* WARN_MSG = "Must not be such entry!";
1312 
1313 static void print_cpool_bytes(jint cnt, u1 *bytes) {
1314   jint size = 0;
1315   u2   idx1, idx2;
1316 
1317   for (jint idx = 1; idx < cnt; idx++) {
1318     jint ent_size = 0;
1319     u1   tag  = *bytes++;
1320     size++;                       // count tag
1321 
1322     printf("const #%03d, tag: %02d ", idx, tag);
1323     switch(tag) {
1324       case JVM_CONSTANT_Invalid: {
1325         printf("Invalid");
1326         break;
1327       }
1328       case JVM_CONSTANT_Unicode: {
1329         printf("Unicode      %s", WARN_MSG);
1330         break;
1331       }
1332       case JVM_CONSTANT_Utf8: {
1333         u2 len = Bytes::get_Java_u2(bytes);
1334         char str[128];
1335         if (len > 127) {
1336            len = 127;
1337         }
1338         strncpy(str, (char *) (bytes+2), len);
1339         str[len] = '\0';
1340         printf("Utf8          \"%s\"", str);
1341         ent_size = 2 + len;
1342         break;
1343       }
1344       case JVM_CONSTANT_Integer: {
1345         u4 val = Bytes::get_Java_u4(bytes);
1346         printf("int          %d", *(int *) &val);
1347         ent_size = 4;
1348         break;
1349       }
1350       case JVM_CONSTANT_Float: {
1351         u4 val = Bytes::get_Java_u4(bytes);
1352         printf("float        %5.3ff", *(float *) &val);
1353         ent_size = 4;
1354         break;
1355       }
1356       case JVM_CONSTANT_Long: {
1357         u8 val = Bytes::get_Java_u8(bytes);
1358         printf("long         "INT64_FORMAT, *(jlong *) &val);
1359         ent_size = 8;
1360         idx++; // Long takes two cpool slots
1361         break;
1362       }
1363       case JVM_CONSTANT_Double: {
1364         u8 val = Bytes::get_Java_u8(bytes);
1365         printf("double       %5.3fd", *(jdouble *)&val);
1366         ent_size = 8;
1367         idx++; // Double takes two cpool slots
1368         break;
1369       }
1370       case JVM_CONSTANT_Class: {
1371         idx1 = Bytes::get_Java_u2(bytes);
1372         printf("class        #%03d", idx1);
1373         ent_size = 2;
1374         break;
1375       }
1376       case JVM_CONSTANT_String: {
1377         idx1 = Bytes::get_Java_u2(bytes);
1378         printf("String       #%03d", idx1);
1379         ent_size = 2;
1380         break;
1381       }
1382       case JVM_CONSTANT_Fieldref: {
1383         idx1 = Bytes::get_Java_u2(bytes);
1384         idx2 = Bytes::get_Java_u2(bytes+2);
1385         printf("Field        #%03d, #%03d", (int) idx1, (int) idx2);
1386         ent_size = 4;
1387         break;
1388       }
1389       case JVM_CONSTANT_Methodref: {
1390         idx1 = Bytes::get_Java_u2(bytes);
1391         idx2 = Bytes::get_Java_u2(bytes+2);
1392         printf("Method       #%03d, #%03d", idx1, idx2);
1393         ent_size = 4;
1394         break;
1395       }
1396       case JVM_CONSTANT_InterfaceMethodref: {
1397         idx1 = Bytes::get_Java_u2(bytes);
1398         idx2 = Bytes::get_Java_u2(bytes+2);
1399         printf("InterfMethod #%03d, #%03d", idx1, idx2);
1400         ent_size = 4;
1401         break;
1402       }
1403       case JVM_CONSTANT_NameAndType: {
1404         idx1 = Bytes::get_Java_u2(bytes);
1405         idx2 = Bytes::get_Java_u2(bytes+2);
1406         printf("NameAndType  #%03d, #%03d", idx1, idx2);
1407         ent_size = 4;
1408         break;
1409       }
1410       case JVM_CONSTANT_ClassIndex: {
1411         printf("ClassIndex  %s", WARN_MSG);
1412         break;
1413       }
1414       case JVM_CONSTANT_UnresolvedClass: {
1415         printf("UnresolvedClass: %s", WARN_MSG);
1416         break;
1417       }
1418       case JVM_CONSTANT_UnresolvedClassInError: {
1419         printf("UnresolvedClassInErr: %s", WARN_MSG);
1420         break;
1421       }
1422       case JVM_CONSTANT_StringIndex: {
1423         printf("StringIndex: %s", WARN_MSG);
1424         break;
1425       }
1426       case JVM_CONSTANT_UnresolvedString: {
1427         printf("UnresolvedString: %s", WARN_MSG);
1428         break;
1429       }
1430     }
1431     printf(";\n");
1432     bytes += ent_size;
1433     size  += ent_size;
1434   }
1435   printf("Cpool size: %d\n", size);
1436   fflush(0);
1437   return;
1438 } /* end print_cpool_bytes */
1439 
1440 
1441 // Returns size of constant pool entry.
1442 jint constantPoolOopDesc::cpool_entry_size(jint idx) {
1443   switch(tag_at(idx).value()) {
1444     case JVM_CONSTANT_Invalid:
1445     case JVM_CONSTANT_Unicode:
1446       return 1;
1447 
1448     case JVM_CONSTANT_Utf8:
1449       return 3 + symbol_at(idx)->utf8_length();
1450 
1451     case JVM_CONSTANT_Class:
1452     case JVM_CONSTANT_String:
1453     case JVM_CONSTANT_ClassIndex:
1454     case JVM_CONSTANT_UnresolvedClass:
1455     case JVM_CONSTANT_UnresolvedClassInError:
1456     case JVM_CONSTANT_StringIndex:
1457     case JVM_CONSTANT_UnresolvedString:
1458     case JVM_CONSTANT_MethodType:
1459       return 3;
1460 
1461     case JVM_CONSTANT_MethodHandle:
1462       return 4; //tag, ref_kind, ref_index
1463 
1464     case JVM_CONSTANT_Integer:
1465     case JVM_CONSTANT_Float:
1466     case JVM_CONSTANT_Fieldref:
1467     case JVM_CONSTANT_Methodref:
1468     case JVM_CONSTANT_InterfaceMethodref:
1469     case JVM_CONSTANT_NameAndType:
1470       return 5;
1471 
1472     case JVM_CONSTANT_InvokeDynamic:
1473       // u1 tag, u2 bsm, u2 nt
1474       return 5;
1475 
1476     case JVM_CONSTANT_Long:
1477     case JVM_CONSTANT_Double:
1478       return 9;
1479   }
1480   assert(false, "cpool_entry_size: Invalid constant pool entry tag");
1481   return 1;
1482 } /* end cpool_entry_size */
1483 
1484 
1485 // SymbolHashMap is used to find a constant pool index from a string.
1486 // This function fills in SymbolHashMaps, one for utf8s and one for
1487 // class names, returns size of the cpool raw bytes.
1488 jint constantPoolOopDesc::hash_entries_to(SymbolHashMap *symmap,
1489                                           SymbolHashMap *classmap) {
1490   jint size = 0;
1491 
1492   for (u2 idx = 1; idx < length(); idx++) {
1493     u2 tag = tag_at(idx).value();
1494     size += cpool_entry_size(idx);
1495 
1496     switch(tag) {
1497       case JVM_CONSTANT_Utf8: {
1498         Symbol* sym = symbol_at(idx);
1499         symmap->add_entry(sym, idx);
1500         DBG(printf("adding symbol entry %s = %d\n", sym->as_utf8(), idx));
1501         break;
1502       }
1503       case JVM_CONSTANT_Class:
1504       case JVM_CONSTANT_UnresolvedClass:
1505       case JVM_CONSTANT_UnresolvedClassInError: {
1506         Symbol* sym = klass_name_at(idx);
1507         classmap->add_entry(sym, idx);
1508         DBG(printf("adding class entry %s = %d\n", sym->as_utf8(), idx));
1509         break;
1510       }
1511       case JVM_CONSTANT_Long:
1512       case JVM_CONSTANT_Double: {
1513         idx++; // Both Long and Double take two cpool slots
1514         break;
1515       }
1516     }
1517   }
1518   return size;
1519 } /* end hash_utf8_entries_to */
1520 
1521 
1522 // Copy cpool bytes.
1523 // Returns:
1524 //    0, in case of OutOfMemoryError
1525 //   -1, in case of internal error
1526 //  > 0, count of the raw cpool bytes that have been copied
1527 int constantPoolOopDesc::copy_cpool_bytes(int cpool_size,
1528                                           SymbolHashMap* tbl,
1529                                           unsigned char *bytes) {
1530   u2   idx1, idx2;
1531   jint size  = 0;
1532   jint cnt   = length();
1533   unsigned char *start_bytes = bytes;
1534 
1535   for (jint idx = 1; idx < cnt; idx++) {
1536     u1   tag      = tag_at(idx).value();
1537     jint ent_size = cpool_entry_size(idx);
1538 
1539     assert(size + ent_size <= cpool_size, "Size mismatch");
1540 
1541     *bytes = tag;
1542     DBG(printf("#%03hd tag=%03hd, ", idx, tag));
1543     switch(tag) {
1544       case JVM_CONSTANT_Invalid: {
1545         DBG(printf("JVM_CONSTANT_Invalid"));
1546         break;
1547       }
1548       case JVM_CONSTANT_Unicode: {
1549         assert(false, "Wrong constant pool tag: JVM_CONSTANT_Unicode");
1550         DBG(printf("JVM_CONSTANT_Unicode"));
1551         break;
1552       }
1553       case JVM_CONSTANT_Utf8: {
1554         Symbol* sym = symbol_at(idx);
1555         char*     str = sym->as_utf8();
1556         // Warning! It's crashing on x86 with len = sym->utf8_length()
1557         int       len = (int) strlen(str);
1558         Bytes::put_Java_u2((address) (bytes+1), (u2) len);
1559         for (int i = 0; i < len; i++) {
1560             bytes[3+i] = (u1) str[i];
1561         }
1562         DBG(printf("JVM_CONSTANT_Utf8: %s ", str));
1563         break;
1564       }
1565       case JVM_CONSTANT_Integer: {
1566         jint val = int_at(idx);
1567         Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1568         break;
1569       }
1570       case JVM_CONSTANT_Float: {
1571         jfloat val = float_at(idx);
1572         Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
1573         break;
1574       }
1575       case JVM_CONSTANT_Long: {
1576         jlong val = long_at(idx);
1577         Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1578         idx++;             // Long takes two cpool slots
1579         break;
1580       }
1581       case JVM_CONSTANT_Double: {
1582         jdouble val = double_at(idx);
1583         Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
1584         idx++;             // Double takes two cpool slots
1585         break;
1586       }
1587       case JVM_CONSTANT_Class:
1588       case JVM_CONSTANT_UnresolvedClass:
1589       case JVM_CONSTANT_UnresolvedClassInError: {
1590         *bytes = JVM_CONSTANT_Class;
1591         Symbol* sym = klass_name_at(idx);
1592         idx1 = tbl->symbol_to_value(sym);
1593         assert(idx1 != 0, "Have not found a hashtable entry");
1594         Bytes::put_Java_u2((address) (bytes+1), idx1);
1595         DBG(printf("JVM_CONSTANT_Class: idx=#%03hd, %s", idx1, sym->as_utf8()));
1596         break;
1597       }
1598       case JVM_CONSTANT_String: {
1599         unsigned int hash;
1600         char *str = string_at_noresolve(idx);
1601         TempNewSymbol sym = SymbolTable::lookup_only(str, (int) strlen(str), hash);
1602         if (sym == NULL) {
1603           // sym can be NULL if string refers to incorrectly encoded JVM_CONSTANT_Utf8
1604           // this can happen with JVM TI; see CR 6839599 for more details
1605           oop string = *(obj_at_addr_raw(idx));
1606           assert(java_lang_String::is_instance(string),"Not a String");
1607           DBG(printf("Error #%03hd tag=%03hd\n", idx, tag));
1608           idx1 = 0;
1609           for (int j = 0; j < tbl->table_size() && idx1 == 0; j++) {
1610             for (SymbolHashMapEntry* cur = tbl->bucket(j); cur != NULL; cur = cur->next()) {
1611               int length;
1612               Symbol* s = cur->symbol();
1613               jchar* chars = s->as_unicode(length);
1614               if (java_lang_String::equals(string, chars, length)) {
1615                 idx1 = cur->value();
1616                 DBG(printf("Index found: %d\n",idx1));
1617                 break;
1618               }
1619             }
1620           }
1621         } else {
1622           idx1 = tbl->symbol_to_value(sym);
1623         }
1624         assert(idx1 != 0, "Have not found a hashtable entry");
1625         Bytes::put_Java_u2((address) (bytes+1), idx1);
1626         DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, str));
1627         break;
1628       }
1629       case JVM_CONSTANT_UnresolvedString: {
1630         *bytes = JVM_CONSTANT_String;
1631         Symbol* sym = unresolved_string_at(idx);
1632         idx1 = tbl->symbol_to_value(sym);
1633         assert(idx1 != 0, "Have not found a hashtable entry");
1634         Bytes::put_Java_u2((address) (bytes+1), idx1);
1635         DBG(char *str = sym->as_utf8());
1636         DBG(printf("JVM_CONSTANT_UnresolvedString: idx=#%03hd, %s", idx1, str));
1637         break;
1638       }
1639       case JVM_CONSTANT_Fieldref:
1640       case JVM_CONSTANT_Methodref:
1641       case JVM_CONSTANT_InterfaceMethodref: {
1642         idx1 = uncached_klass_ref_index_at(idx);
1643         idx2 = uncached_name_and_type_ref_index_at(idx);
1644         Bytes::put_Java_u2((address) (bytes+1), idx1);
1645         Bytes::put_Java_u2((address) (bytes+3), idx2);
1646         DBG(printf("JVM_CONSTANT_Methodref: %hd %hd", idx1, idx2));
1647         break;
1648       }
1649       case JVM_CONSTANT_NameAndType: {
1650         idx1 = name_ref_index_at(idx);
1651         idx2 = signature_ref_index_at(idx);
1652         Bytes::put_Java_u2((address) (bytes+1), idx1);
1653         Bytes::put_Java_u2((address) (bytes+3), idx2);
1654         DBG(printf("JVM_CONSTANT_NameAndType: %hd %hd", idx1, idx2));
1655         break;
1656       }
1657       case JVM_CONSTANT_ClassIndex: {
1658         *bytes = JVM_CONSTANT_Class;
1659         idx1 = klass_index_at(idx);
1660         Bytes::put_Java_u2((address) (bytes+1), idx1);
1661         DBG(printf("JVM_CONSTANT_ClassIndex: %hd", idx1));
1662         break;
1663       }
1664       case JVM_CONSTANT_StringIndex: {
1665         *bytes = JVM_CONSTANT_String;
1666         idx1 = string_index_at(idx);
1667         Bytes::put_Java_u2((address) (bytes+1), idx1);
1668         DBG(printf("JVM_CONSTANT_StringIndex: %hd", idx1));
1669         break;
1670       }
1671       case JVM_CONSTANT_MethodHandle: {
1672         *bytes = JVM_CONSTANT_MethodHandle;
1673         int kind = method_handle_ref_kind_at(idx);
1674         idx1 = method_handle_index_at(idx);
1675         *(bytes+1) = (unsigned char) kind;
1676         Bytes::put_Java_u2((address) (bytes+2), idx1);
1677         DBG(printf("JVM_CONSTANT_MethodHandle: %d %hd", kind, idx1));
1678         break;
1679       }
1680       case JVM_CONSTANT_MethodType: {
1681         *bytes = JVM_CONSTANT_MethodType;
1682         idx1 = method_type_index_at(idx);
1683         Bytes::put_Java_u2((address) (bytes+1), idx1);
1684         DBG(printf("JVM_CONSTANT_MethodType: %hd", idx1));
1685         break;
1686       }
1687       case JVM_CONSTANT_InvokeDynamic: {
1688         *bytes = tag;
1689         idx1 = extract_low_short_from_int(*int_at_addr(idx));
1690         idx2 = extract_high_short_from_int(*int_at_addr(idx));
1691         assert(idx2 == invoke_dynamic_name_and_type_ref_index_at(idx), "correct half of u4");
1692         Bytes::put_Java_u2((address) (bytes+1), idx1);
1693         Bytes::put_Java_u2((address) (bytes+3), idx2);
1694         DBG(printf("JVM_CONSTANT_InvokeDynamic: %hd %hd", idx1, idx2));
1695         break;
1696       }
1697     }
1698     DBG(printf("\n"));
1699     bytes += ent_size;
1700     size  += ent_size;
1701   }
1702   assert(size == cpool_size, "Size mismatch");
1703 
1704   // Keep temorarily for debugging until it's stable.
1705   DBG(print_cpool_bytes(cnt, start_bytes));
1706   return (int)(bytes - start_bytes);
1707 } /* end copy_cpool_bytes */
1708 
1709 
1710 void SymbolHashMap::add_entry(Symbol* sym, u2 value) {
1711   char *str = sym->as_utf8();
1712   unsigned int hash = compute_hash(str, sym->utf8_length());
1713   unsigned int index = hash % table_size();
1714 
1715   // check if already in map
1716   // we prefer the first entry since it is more likely to be what was used in
1717   // the class file
1718   for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
1719     assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
1720     if (en->hash() == hash && en->symbol() == sym) {
1721         return;  // already there
1722     }
1723   }
1724 
1725   SymbolHashMapEntry* entry = new SymbolHashMapEntry(hash, sym, value);
1726   entry->set_next(bucket(index));
1727   _buckets[index].set_entry(entry);
1728   assert(entry->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
1729 }
1730 
1731 SymbolHashMapEntry* SymbolHashMap::find_entry(Symbol* sym) {
1732   assert(sym != NULL, "SymbolHashMap::find_entry - symbol is NULL");
1733   char *str = sym->as_utf8();
1734   int   len = sym->utf8_length();
1735   unsigned int hash = SymbolHashMap::compute_hash(str, len);
1736   unsigned int index = hash % table_size();
1737   for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
1738     assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
1739     if (en->hash() == hash && en->symbol() == sym) {
1740       return en;
1741     }
1742   }
1743   return NULL;
1744 }