1 /* 2 * Copyright (c) 1997, 2010, 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 #ifndef SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP 26 #define SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP 27 28 #include "oops/arrayOop.hpp" 29 #include "oops/cpCacheOop.hpp" 30 #include "oops/symbol.hpp" 31 #include "oops/typeArrayOop.hpp" 32 #include "utilities/constantTag.hpp" 33 #ifdef TARGET_ARCH_x86 34 # include "bytes_x86.hpp" 35 #endif 36 #ifdef TARGET_ARCH_sparc 37 # include "bytes_sparc.hpp" 38 #endif 39 #ifdef TARGET_ARCH_zero 40 # include "bytes_zero.hpp" 41 #endif 42 #ifdef TARGET_ARCH_arm 43 # include "bytes_arm.hpp" 44 #endif 45 #ifdef TARGET_ARCH_ppc 46 # include "bytes_ppc.hpp" 47 #endif 48 49 // A constantPool is an array containing class constants as described in the 50 // class file. 51 // 52 // Most of the constant pool entries are written during class parsing, which 53 // is safe. For klass and string types, the constant pool entry is 54 // modified when the entry is resolved. If a klass or string constant pool 55 // entry is read without a lock, only the resolved state guarantees that 56 // the entry in the constant pool is a klass or String object and 57 // not a Symbol*. 58 59 class SymbolHashMap; 60 61 class CPSlot VALUE_OBJ_CLASS_SPEC { 62 intptr_t _ptr; 63 public: 64 CPSlot(intptr_t ptr): _ptr(ptr) {} 65 CPSlot(void* ptr): _ptr((intptr_t)ptr) {} 66 CPSlot(oop ptr): _ptr((intptr_t)ptr) {} 67 CPSlot(Symbol* ptr): _ptr((intptr_t)ptr | 1) {} 68 69 intptr_t value() { return _ptr; } 70 bool is_oop() { return (_ptr & 1) == 0; } 71 bool is_metadata() { return (_ptr & 1) == 1; } 72 73 oop get_oop() { 74 assert(is_oop(), "bad call"); 75 return oop(_ptr); 76 } 77 Symbol* get_symbol() { 78 assert(is_metadata(), "bad call"); 79 return (Symbol*)(_ptr & ~1); 80 } 81 }; 82 83 class constantPoolOopDesc : public oopDesc { 84 friend class VMStructs; 85 friend class BytecodeInterpreter; // Directly extracts an oop in the pool for fast instanceof/checkcast 86 private: 87 typeArrayOop _tags; // the tag array describing the constant pool's contents 88 constantPoolCacheOop _cache; // the cache holding interpreter runtime information 89 klassOop _pool_holder; // the corresponding class 90 typeArrayOop _operands; // for variable-sized (InvokeDynamic) nodes, usually empty 91 int _flags; // a few header bits to describe contents for GC 92 int _length; // number of elements in the array 93 volatile bool _is_conc_safe; // if true, safe for concurrent 94 // GC processing 95 // only set to non-zero if constant pool is merged by RedefineClasses 96 int _orig_length; 97 98 void set_tags(typeArrayOop tags) { oop_store_without_check((oop*)&_tags, tags); } 99 void tag_at_put(int which, jbyte t) { tags()->byte_at_put(which, t); } 100 void release_tag_at_put(int which, jbyte t) { tags()->release_byte_at_put(which, t); } 101 102 void set_operands(typeArrayOop operands) { oop_store_without_check((oop*)&_operands, operands); } 103 104 enum FlagBit { 105 FB_has_invokedynamic = 1, 106 FB_has_pseudo_string = 2 107 }; 108 109 int flags() const { return _flags; } 110 void set_flags(int f) { _flags = f; } 111 bool flag_at(FlagBit fb) const { return (_flags & (1 << (int)fb)) != 0; } 112 void set_flag_at(FlagBit fb); 113 // no clear_flag_at function; they only increase 114 115 private: 116 intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(constantPoolOopDesc)); } 117 oop* tags_addr() { return (oop*)&_tags; } 118 oop* cache_addr() { return (oop*)&_cache; } 119 oop* operands_addr() { return (oop*)&_operands; } 120 121 CPSlot slot_at(int which) { 122 assert(is_within_bounds(which), "index out of bounds"); 123 // There's a transitional value of zero when converting from 124 // Symbol->0->Klass for G1 when resolving classes and strings. 125 // wait for the value to be non-zero (this is temporary) 126 volatile intptr_t adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which)); 127 if (adr == 0 && which != 0) { 128 constantTag t = tag_at(which); 129 if (t.is_unresolved_klass() || t.is_klass() || 130 t.is_unresolved_string() || t.is_string()) { 131 while ((adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))) == 0); 132 } 133 } 134 return CPSlot(adr); 135 } 136 137 void slot_at_put(int which, CPSlot s) const { 138 assert(is_within_bounds(which), "index out of bounds"); 139 *(intptr_t*)&base()[which] = s.value(); 140 } 141 oop* obj_at_addr_raw(int which) const { 142 assert(is_within_bounds(which), "index out of bounds"); 143 return (oop*) &base()[which]; 144 } 145 146 void obj_at_put_without_check(int which, oop o) { 147 assert(is_within_bounds(which), "index out of bounds"); 148 oop_store_without_check((volatile oop *)obj_at_addr_raw(which), o); 149 } 150 151 void obj_at_put(int which, oop o) const { 152 assert(is_within_bounds(which), "index out of bounds"); 153 oop_store((volatile oop*)obj_at_addr_raw(which), o); 154 } 155 156 jint* int_at_addr(int which) const { 157 assert(is_within_bounds(which), "index out of bounds"); 158 return (jint*) &base()[which]; 159 } 160 161 jlong* long_at_addr(int which) const { 162 assert(is_within_bounds(which), "index out of bounds"); 163 return (jlong*) &base()[which]; 164 } 165 166 jfloat* float_at_addr(int which) const { 167 assert(is_within_bounds(which), "index out of bounds"); 168 return (jfloat*) &base()[which]; 169 } 170 171 jdouble* double_at_addr(int which) const { 172 assert(is_within_bounds(which), "index out of bounds"); 173 return (jdouble*) &base()[which]; 174 } 175 176 public: 177 typeArrayOop tags() const { return _tags; } 178 typeArrayOop operands() const { return _operands; } 179 180 bool has_pseudo_string() const { return flag_at(FB_has_pseudo_string); } 181 bool has_invokedynamic() const { return flag_at(FB_has_invokedynamic); } 182 void set_pseudo_string() { set_flag_at(FB_has_pseudo_string); } 183 void set_invokedynamic() { set_flag_at(FB_has_invokedynamic); } 184 185 // Klass holding pool 186 klassOop pool_holder() const { return _pool_holder; } 187 void set_pool_holder(klassOop k) { oop_store_without_check((oop*)&_pool_holder, (oop) k); } 188 oop* pool_holder_addr() { return (oop*)&_pool_holder; } 189 190 // Interpreter runtime support 191 constantPoolCacheOop cache() const { return _cache; } 192 void set_cache(constantPoolCacheOop cache){ oop_store((oop*)&_cache, cache); } 193 194 // Assembly code support 195 static int tags_offset_in_bytes() { return offset_of(constantPoolOopDesc, _tags); } 196 static int cache_offset_in_bytes() { return offset_of(constantPoolOopDesc, _cache); } 197 static int operands_offset_in_bytes() { return offset_of(constantPoolOopDesc, _operands); } 198 static int pool_holder_offset_in_bytes() { return offset_of(constantPoolOopDesc, _pool_holder); } 199 200 // Storing constants 201 202 void klass_at_put(int which, klassOop k) { 203 // Overwrite the old index with a GC friendly value so 204 // that if G1 looks during the transition during oop_store it won't 205 // assert the symbol is not an oop. 206 *obj_at_addr_raw(which) = NULL; 207 assert(k != NULL, "resolved class shouldn't be null"); 208 obj_at_put_without_check(which, k); 209 // The interpreter assumes when the tag is stored, the klass is resolved 210 // and the klassOop is a klass rather than a Symbol*, so we need 211 // hardware store ordering here. 212 release_tag_at_put(which, JVM_CONSTANT_Class); 213 if (UseConcMarkSweepGC) { 214 // In case the earlier card-mark was consumed by a concurrent 215 // marking thread before the tag was updated, redirty the card. 216 obj_at_put_without_check(which, k); 217 } 218 } 219 220 // For temporary use while constructing constant pool 221 void klass_index_at_put(int which, int name_index) { 222 tag_at_put(which, JVM_CONSTANT_ClassIndex); 223 *int_at_addr(which) = name_index; 224 } 225 226 // Temporary until actual use 227 void unresolved_klass_at_put(int which, Symbol* s) { 228 release_tag_at_put(which, JVM_CONSTANT_UnresolvedClass); 229 slot_at_put(which, s); 230 } 231 232 void method_handle_index_at_put(int which, int ref_kind, int ref_index) { 233 tag_at_put(which, JVM_CONSTANT_MethodHandle); 234 *int_at_addr(which) = ((jint) ref_index<<16) | ref_kind; 235 } 236 237 void method_type_index_at_put(int which, int ref_index) { 238 tag_at_put(which, JVM_CONSTANT_MethodType); 239 *int_at_addr(which) = ref_index; 240 } 241 242 void invoke_dynamic_at_put(int which, int bootstrap_specifier_index, int name_and_type_index) { 243 tag_at_put(which, JVM_CONSTANT_InvokeDynamic); 244 *int_at_addr(which) = ((jint) name_and_type_index<<16) | bootstrap_specifier_index; 245 } 246 247 void invoke_dynamic_trans_at_put(int which, int bootstrap_method_index, int name_and_type_index) { 248 tag_at_put(which, JVM_CONSTANT_InvokeDynamicTrans); 249 *int_at_addr(which) = ((jint) name_and_type_index<<16) | bootstrap_method_index; 250 assert(AllowTransitionalJSR292, ""); 251 } 252 253 // Temporary until actual use 254 void unresolved_string_at_put(int which, Symbol* s) { 255 release_tag_at_put(which, JVM_CONSTANT_UnresolvedString); 256 slot_at_put(which, s); 257 } 258 259 void int_at_put(int which, jint i) { 260 tag_at_put(which, JVM_CONSTANT_Integer); 261 *int_at_addr(which) = i; 262 } 263 264 void long_at_put(int which, jlong l) { 265 tag_at_put(which, JVM_CONSTANT_Long); 266 // *long_at_addr(which) = l; 267 Bytes::put_native_u8((address)long_at_addr(which), *((u8*) &l)); 268 } 269 270 void float_at_put(int which, jfloat f) { 271 tag_at_put(which, JVM_CONSTANT_Float); 272 *float_at_addr(which) = f; 273 } 274 275 void double_at_put(int which, jdouble d) { 276 tag_at_put(which, JVM_CONSTANT_Double); 277 // *double_at_addr(which) = d; 278 // u8 temp = *(u8*) &d; 279 Bytes::put_native_u8((address) double_at_addr(which), *((u8*) &d)); 280 } 281 282 Symbol** symbol_at_addr(int which) const { 283 assert(is_within_bounds(which), "index out of bounds"); 284 return (Symbol**) &base()[which]; 285 } 286 287 void symbol_at_put(int which, Symbol* s) { 288 assert(s->refcount() != 0, "should have nonzero refcount"); 289 tag_at_put(which, JVM_CONSTANT_Utf8); 290 slot_at_put(which, s); 291 } 292 293 void string_at_put(int which, oop str) { 294 // Overwrite the old index with a GC friendly value so 295 // that if G1 looks during the transition during oop_store it won't 296 // assert the symbol is not an oop. 297 *obj_at_addr_raw(which) = NULL; 298 assert(str != NULL, "resolved string shouldn't be null"); 299 obj_at_put(which, str); 300 release_tag_at_put(which, JVM_CONSTANT_String); 301 if (UseConcMarkSweepGC) { 302 // In case the earlier card-mark was consumed by a concurrent 303 // marking thread before the tag was updated, redirty the card. 304 obj_at_put_without_check(which, str); 305 } 306 } 307 308 void object_at_put(int which, oop str) { 309 obj_at_put(which, str); 310 release_tag_at_put(which, JVM_CONSTANT_Object); 311 if (UseConcMarkSweepGC) { 312 // In case the earlier card-mark was consumed by a concurrent 313 // marking thread before the tag was updated, redirty the card. 314 obj_at_put_without_check(which, str); 315 } 316 } 317 318 // For temporary use while constructing constant pool 319 void string_index_at_put(int which, int string_index) { 320 tag_at_put(which, JVM_CONSTANT_StringIndex); 321 *int_at_addr(which) = string_index; 322 } 323 324 void field_at_put(int which, int class_index, int name_and_type_index) { 325 tag_at_put(which, JVM_CONSTANT_Fieldref); 326 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; 327 } 328 329 void method_at_put(int which, int class_index, int name_and_type_index) { 330 tag_at_put(which, JVM_CONSTANT_Methodref); 331 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; 332 } 333 334 void interface_method_at_put(int which, int class_index, int name_and_type_index) { 335 tag_at_put(which, JVM_CONSTANT_InterfaceMethodref); 336 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; // Not so nice 337 } 338 339 void name_and_type_at_put(int which, int name_index, int signature_index) { 340 tag_at_put(which, JVM_CONSTANT_NameAndType); 341 *int_at_addr(which) = ((jint) signature_index<<16) | name_index; // Not so nice 342 } 343 344 // Tag query 345 346 constantTag tag_at(int which) const { return (constantTag)tags()->byte_at_acquire(which); } 347 348 // Whether the entry is a pointer that must be GC'd. 349 bool is_pointer_entry(int which) { 350 constantTag tag = tag_at(which); 351 return tag.is_klass() || 352 tag.is_string() || 353 tag.is_object(); 354 } 355 356 // Whether the entry points to an object for ldc (resolved or not) 357 bool is_object_entry(int which) { 358 constantTag tag = tag_at(which); 359 return is_pointer_entry(which) || 360 tag.is_unresolved_klass() || 361 tag.is_unresolved_string() || 362 tag.is_symbol(); 363 } 364 365 // Fetching constants 366 367 klassOop klass_at(int which, TRAPS) { 368 constantPoolHandle h_this(THREAD, this); 369 return klass_at_impl(h_this, which, CHECK_NULL); 370 } 371 372 Symbol* klass_name_at(int which); // Returns the name, w/o resolving. 373 374 klassOop resolved_klass_at(int which) { // Used by Compiler 375 guarantee(tag_at(which).is_klass(), "Corrupted constant pool"); 376 // Must do an acquire here in case another thread resolved the klass 377 // behind our back, lest we later load stale values thru the oop. 378 return klassOop(CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop()); 379 } 380 381 // This method should only be used with a cpool lock or during parsing or gc 382 Symbol* unresolved_klass_at(int which) { // Temporary until actual use 383 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol(); 384 // check that the klass is still unresolved. 385 assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool"); 386 return s; 387 } 388 389 // RedefineClasses() API support: 390 Symbol* klass_at_noresolve(int which) { return klass_name_at(which); } 391 392 jint int_at(int which) { 393 assert(tag_at(which).is_int(), "Corrupted constant pool"); 394 return *int_at_addr(which); 395 } 396 397 jlong long_at(int which) { 398 assert(tag_at(which).is_long(), "Corrupted constant pool"); 399 // return *long_at_addr(which); 400 u8 tmp = Bytes::get_native_u8((address)&base()[which]); 401 return *((jlong*)&tmp); 402 } 403 404 jfloat float_at(int which) { 405 assert(tag_at(which).is_float(), "Corrupted constant pool"); 406 return *float_at_addr(which); 407 } 408 409 jdouble double_at(int which) { 410 assert(tag_at(which).is_double(), "Corrupted constant pool"); 411 u8 tmp = Bytes::get_native_u8((address)&base()[which]); 412 return *((jdouble*)&tmp); 413 } 414 415 Symbol* symbol_at(int which) { 416 assert(tag_at(which).is_utf8(), "Corrupted constant pool"); 417 return slot_at(which).get_symbol(); 418 } 419 420 oop string_at(int which, TRAPS) { 421 constantPoolHandle h_this(THREAD, this); 422 return string_at_impl(h_this, which, CHECK_NULL); 423 } 424 425 oop object_at(int which) { 426 assert(tag_at(which).is_object(), "Corrupted constant pool"); 427 return slot_at(which).get_oop(); 428 } 429 430 // A "pseudo-string" is an non-string oop that has found is way into 431 // a String entry. 432 // Under AnonymousClasses this can happen if the user patches a live 433 // object into a CONSTANT_String entry of an anonymous class. 434 // Method oops internally created for method handles may also 435 // use pseudo-strings to link themselves to related metaobjects. 436 437 bool is_pseudo_string_at(int which); 438 439 oop pseudo_string_at(int which) { 440 assert(tag_at(which).is_string(), "Corrupted constant pool"); 441 return slot_at(which).get_oop(); 442 } 443 444 void pseudo_string_at_put(int which, oop x) { 445 assert(AnonymousClasses, ""); 446 set_pseudo_string(); // mark header 447 assert(tag_at(which).is_string() || tag_at(which).is_unresolved_string(), "Corrupted constant pool"); 448 string_at_put(which, x); // this works just fine 449 } 450 451 // only called when we are sure a string entry is already resolved (via an 452 // earlier string_at call. 453 oop resolved_string_at(int which) { 454 assert(tag_at(which).is_string(), "Corrupted constant pool"); 455 // Must do an acquire here in case another thread resolved the klass 456 // behind our back, lest we later load stale values thru the oop. 457 return CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop(); 458 } 459 460 // This method should only be used with a cpool lock or during parsing or gc 461 Symbol* unresolved_string_at(int which) { // Temporary until actual use 462 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol(); 463 // check that the string is still unresolved. 464 assert(tag_at(which).is_unresolved_string(), "Corrupted constant pool"); 465 return s; 466 } 467 468 // Returns an UTF8 for a CONSTANT_String entry at a given index. 469 // UTF8 char* representation was chosen to avoid conversion of 470 // java_lang_Strings at resolved entries into Symbol*s 471 // or vice versa. 472 // Caller is responsible for checking for pseudo-strings. 473 char* string_at_noresolve(int which); 474 475 jint name_and_type_at(int which) { 476 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool"); 477 return *int_at_addr(which); 478 } 479 480 int method_handle_ref_kind_at(int which) { 481 assert(tag_at(which).is_method_handle(), "Corrupted constant pool"); 482 return extract_low_short_from_int(*int_at_addr(which)); // mask out unwanted ref_index bits 483 } 484 int method_handle_index_at(int which) { 485 assert(tag_at(which).is_method_handle(), "Corrupted constant pool"); 486 return extract_high_short_from_int(*int_at_addr(which)); // shift out unwanted ref_kind bits 487 } 488 int method_type_index_at(int which) { 489 assert(tag_at(which).is_method_type(), "Corrupted constant pool"); 490 return *int_at_addr(which); 491 } 492 // Derived queries: 493 Symbol* method_handle_name_ref_at(int which) { 494 int member = method_handle_index_at(which); 495 return impl_name_ref_at(member, true); 496 } 497 Symbol* method_handle_signature_ref_at(int which) { 498 int member = method_handle_index_at(which); 499 return impl_signature_ref_at(member, true); 500 } 501 int method_handle_klass_index_at(int which) { 502 int member = method_handle_index_at(which); 503 return impl_klass_ref_index_at(member, true); 504 } 505 Symbol* method_type_signature_at(int which) { 506 int sym = method_type_index_at(which); 507 return symbol_at(sym); 508 } 509 510 int invoke_dynamic_name_and_type_ref_index_at(int which) { 511 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool"); 512 return extract_high_short_from_int(*int_at_addr(which)); 513 } 514 int invoke_dynamic_bootstrap_specifier_index(int which) { 515 assert(tag_at(which).value() == JVM_CONSTANT_InvokeDynamic, "Corrupted constant pool"); 516 return extract_low_short_from_int(*int_at_addr(which)); 517 } 518 int invoke_dynamic_operand_base(int which) { 519 int bootstrap_specifier_index = invoke_dynamic_bootstrap_specifier_index(which); 520 return operand_offset_at(operands(), bootstrap_specifier_index); 521 } 522 // The first part of the operands array consists of an index into the second part. 523 // Extract a 32-bit index value from the first part. 524 static int operand_offset_at(typeArrayOop operands, int bootstrap_specifier_index) { 525 int n = (bootstrap_specifier_index * 2); 526 assert(n >= 0 && n+2 <= operands->length(), "oob"); 527 // The first 32-bit index points to the beginning of the second part 528 // of the operands array. Make sure this index is in the first part. 529 DEBUG_ONLY(int second_part = build_int_from_shorts(operands->short_at(0), 530 operands->short_at(1))); 531 assert(second_part == 0 || n+2 <= second_part, "oob (2)"); 532 int offset = build_int_from_shorts(operands->short_at(n+0), 533 operands->short_at(n+1)); 534 // The offset itself must point into the second part of the array. 535 assert(offset == 0 || offset >= second_part && offset <= operands->length(), "oob (3)"); 536 return offset; 537 } 538 static void operand_offset_at_put(typeArrayOop operands, int bootstrap_specifier_index, int offset) { 539 int n = bootstrap_specifier_index * 2; 540 assert(n >= 0 && n+2 <= operands->length(), "oob"); 541 operands->short_at_put(n+0, extract_low_short_from_int(offset)); 542 operands->short_at_put(n+1, extract_high_short_from_int(offset)); 543 } 544 static int operand_array_length(typeArrayOop operands) { 545 if (operands == NULL || operands->length() == 0) return 0; 546 int second_part = operand_offset_at(operands, 0); 547 return (second_part / 2); 548 } 549 550 #ifdef ASSERT 551 // operand tuples fit together exactly, end to end 552 static int operand_limit_at(typeArrayOop operands, int bootstrap_specifier_index) { 553 int nextidx = bootstrap_specifier_index + 1; 554 if (nextidx == operand_array_length(operands)) 555 return operands->length(); 556 else 557 return operand_offset_at(operands, nextidx); 558 } 559 int invoke_dynamic_operand_limit(int which) { 560 int bootstrap_specifier_index = invoke_dynamic_bootstrap_specifier_index(which); 561 return operand_limit_at(operands(), bootstrap_specifier_index); 562 } 563 #endif //ASSERT 564 565 // layout of InvokeDynamic bootstrap method specifier (in second part of operands array): 566 enum { 567 _indy_bsm_offset = 0, // CONSTANT_MethodHandle bsm 568 _indy_argc_offset = 1, // u2 argc 569 _indy_argv_offset = 2 // u2 argv[argc] 570 }; 571 int invoke_dynamic_bootstrap_method_ref_index_at(int which) { 572 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool"); 573 if (tag_at(which).value() == JVM_CONSTANT_InvokeDynamicTrans) 574 return extract_low_short_from_int(*int_at_addr(which)); 575 int op_base = invoke_dynamic_operand_base(which); 576 return operands()->short_at(op_base + _indy_bsm_offset); 577 } 578 int invoke_dynamic_argument_count_at(int which) { 579 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool"); 580 if (tag_at(which).value() == JVM_CONSTANT_InvokeDynamicTrans) 581 return 0; 582 int op_base = invoke_dynamic_operand_base(which); 583 int argc = operands()->short_at(op_base + _indy_argc_offset); 584 DEBUG_ONLY(int end_offset = op_base + _indy_argv_offset + argc; 585 int next_offset = invoke_dynamic_operand_limit(which)); 586 assert(end_offset == next_offset, "matched ending"); 587 return argc; 588 } 589 int invoke_dynamic_argument_index_at(int which, int j) { 590 int op_base = invoke_dynamic_operand_base(which); 591 DEBUG_ONLY(int argc = operands()->short_at(op_base + _indy_argc_offset)); 592 assert((uint)j < (uint)argc, "oob"); 593 return operands()->short_at(op_base + _indy_argv_offset + j); 594 } 595 596 // The following methods (name/signature/klass_ref_at, klass_ref_at_noresolve, 597 // name_and_type_ref_index_at) all expect to be passed indices obtained 598 // directly from the bytecode. 599 // If the indices are meant to refer to fields or methods, they are 600 // actually rewritten constant pool cache indices. 601 // The routine remap_instruction_operand_from_cache manages the adjustment 602 // of these values back to constant pool indices. 603 604 // There are also "uncached" versions which do not adjust the operand index; see below. 605 606 // FIXME: Consider renaming these with a prefix "cached_" to make the distinction clear. 607 // In a few cases (the verifier) there are uses before a cpcache has been built, 608 // which are handled by a dynamic check in remap_instruction_operand_from_cache. 609 // FIXME: Remove the dynamic check, and adjust all callers to specify the correct mode. 610 611 // Lookup for entries consisting of (klass_index, name_and_type index) 612 klassOop klass_ref_at(int which, TRAPS); 613 Symbol* klass_ref_at_noresolve(int which); 614 Symbol* name_ref_at(int which) { return impl_name_ref_at(which, false); } 615 Symbol* signature_ref_at(int which) { return impl_signature_ref_at(which, false); } 616 617 int klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, false); } 618 int name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, false); } 619 620 // Lookup for entries consisting of (name_index, signature_index) 621 int name_ref_index_at(int which_nt); // == low-order jshort of name_and_type_at(which_nt) 622 int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt) 623 624 BasicType basic_type_for_signature_at(int which); 625 626 // Resolve string constants (to prevent allocation during compilation) 627 void resolve_string_constants(TRAPS) { 628 constantPoolHandle h_this(THREAD, this); 629 resolve_string_constants_impl(h_this, CHECK); 630 } 631 632 private: 633 enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 }; 634 public: 635 636 // Resolve late bound constants. 637 oop resolve_constant_at(int index, TRAPS) { 638 constantPoolHandle h_this(THREAD, this); 639 return resolve_constant_at_impl(h_this, index, _no_index_sentinel, THREAD); 640 } 641 642 oop resolve_cached_constant_at(int cache_index, TRAPS) { 643 constantPoolHandle h_this(THREAD, this); 644 return resolve_constant_at_impl(h_this, _no_index_sentinel, cache_index, THREAD); 645 } 646 647 oop resolve_possibly_cached_constant_at(int pool_index, TRAPS) { 648 constantPoolHandle h_this(THREAD, this); 649 return resolve_constant_at_impl(h_this, pool_index, _possible_index_sentinel, THREAD); 650 } 651 652 // Klass name matches name at offset 653 bool klass_name_at_matches(instanceKlassHandle k, int which); 654 655 // Sizing 656 int length() const { return _length; } 657 void set_length(int length) { _length = length; } 658 659 // Tells whether index is within bounds. 660 bool is_within_bounds(int index) const { 661 return 0 <= index && index < length(); 662 } 663 664 static int header_size() { return sizeof(constantPoolOopDesc)/HeapWordSize; } 665 static int object_size(int length) { return align_object_size(header_size() + length); } 666 int object_size() { return object_size(length()); } 667 668 bool is_conc_safe() { return _is_conc_safe; } 669 void set_is_conc_safe(bool v) { _is_conc_safe = v; } 670 671 friend class constantPoolKlass; 672 friend class ClassFileParser; 673 friend class SystemDictionary; 674 675 // Used by compiler to prevent classloading. 676 static klassOop klass_at_if_loaded (constantPoolHandle this_oop, int which); 677 static klassOop klass_ref_at_if_loaded (constantPoolHandle this_oop, int which); 678 // Same as above - but does LinkResolving. 679 static klassOop klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS); 680 681 // Routines currently used for annotations (only called by jvm.cpp) but which might be used in the 682 // future by other Java code. These take constant pool indices rather than 683 // constant pool cache indices as do the peer methods above. 684 Symbol* uncached_klass_ref_at_noresolve(int which); 685 Symbol* uncached_name_ref_at(int which) { return impl_name_ref_at(which, true); } 686 Symbol* uncached_signature_ref_at(int which) { return impl_signature_ref_at(which, true); } 687 int uncached_klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, true); } 688 int uncached_name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, true); } 689 690 // Sharing 691 int pre_resolve_shared_klasses(TRAPS); 692 void shared_symbols_iterate(SymbolClosure* closure0); 693 void shared_tags_iterate(OopClosure* closure0); 694 void shared_strings_iterate(OopClosure* closure0); 695 696 // Debugging 697 const char* printable_name_at(int which) PRODUCT_RETURN0; 698 699 #ifdef ASSERT 700 enum { CPCACHE_INDEX_TAG = 0x10000 }; // helps keep CP cache indices distinct from CP indices 701 #else 702 enum { CPCACHE_INDEX_TAG = 0 }; // in product mode, this zero value is a no-op 703 #endif //ASSERT 704 705 private: 706 707 Symbol* impl_name_ref_at(int which, bool uncached); 708 Symbol* impl_signature_ref_at(int which, bool uncached); 709 int impl_klass_ref_index_at(int which, bool uncached); 710 int impl_name_and_type_ref_index_at(int which, bool uncached); 711 712 int remap_instruction_operand_from_cache(int operand); // operand must be biased by CPCACHE_INDEX_TAG 713 714 // Used while constructing constant pool (only by ClassFileParser) 715 jint klass_index_at(int which) { 716 assert(tag_at(which).is_klass_index(), "Corrupted constant pool"); 717 return *int_at_addr(which); 718 } 719 720 jint string_index_at(int which) { 721 assert(tag_at(which).is_string_index(), "Corrupted constant pool"); 722 return *int_at_addr(which); 723 } 724 725 // Performs the LinkResolver checks 726 static void verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle klass, TRAPS); 727 728 // Implementation of methods that needs an exposed 'this' pointer, in order to 729 // handle GC while executing the method 730 static klassOop klass_at_impl(constantPoolHandle this_oop, int which, TRAPS); 731 static oop string_at_impl(constantPoolHandle this_oop, int which, TRAPS); 732 733 // Resolve string constants (to prevent allocation during compilation) 734 static void resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS); 735 736 static oop resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS); 737 738 public: 739 // Merging constantPoolOop support: 740 bool compare_entry_to(int index1, constantPoolHandle cp2, int index2, TRAPS); 741 void copy_cp_to(int start_i, int end_i, constantPoolHandle to_cp, int to_i, TRAPS) { 742 constantPoolHandle h_this(THREAD, this); 743 copy_cp_to_impl(h_this, start_i, end_i, to_cp, to_i, THREAD); 744 } 745 static void copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i, constantPoolHandle to_cp, int to_i, TRAPS); 746 static void copy_entry_to(constantPoolHandle from_cp, int from_i, constantPoolHandle to_cp, int to_i, TRAPS); 747 int find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS); 748 int orig_length() const { return _orig_length; } 749 void set_orig_length(int orig_length) { _orig_length = orig_length; } 750 751 // Decrease ref counts of symbols that are in the constant pool 752 // when the holder class is unloaded 753 void unreference_symbols(); 754 755 // JVMTI accesss - GetConstantPool, RetransformClasses, ... 756 friend class JvmtiConstantPoolReconstituter; 757 758 private: 759 jint cpool_entry_size(jint idx); 760 jint hash_entries_to(SymbolHashMap *symmap, SymbolHashMap *classmap); 761 762 // Copy cpool bytes into byte array. 763 // Returns: 764 // int > 0, count of the raw cpool bytes that have been copied 765 // 0, OutOfMemory error 766 // -1, Internal error 767 int copy_cpool_bytes(int cpool_size, 768 SymbolHashMap* tbl, 769 unsigned char *bytes); 770 }; 771 772 class SymbolHashMapEntry : public CHeapObj { 773 private: 774 unsigned int _hash; // 32-bit hash for item 775 SymbolHashMapEntry* _next; // Next element in the linked list for this bucket 776 Symbol* _symbol; // 1-st part of the mapping: symbol => value 777 u2 _value; // 2-nd part of the mapping: symbol => value 778 779 public: 780 unsigned int hash() const { return _hash; } 781 void set_hash(unsigned int hash) { _hash = hash; } 782 783 SymbolHashMapEntry* next() const { return _next; } 784 void set_next(SymbolHashMapEntry* next) { _next = next; } 785 786 Symbol* symbol() const { return _symbol; } 787 void set_symbol(Symbol* sym) { _symbol = sym; } 788 789 u2 value() const { return _value; } 790 void set_value(u2 value) { _value = value; } 791 792 SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value) 793 : _hash(hash), _symbol(symbol), _value(value), _next(NULL) {} 794 795 }; // End SymbolHashMapEntry class 796 797 798 class SymbolHashMapBucket : public CHeapObj { 799 800 private: 801 SymbolHashMapEntry* _entry; 802 803 public: 804 SymbolHashMapEntry* entry() const { return _entry; } 805 void set_entry(SymbolHashMapEntry* entry) { _entry = entry; } 806 void clear() { _entry = NULL; } 807 808 }; // End SymbolHashMapBucket class 809 810 811 class SymbolHashMap: public CHeapObj { 812 813 private: 814 // Default number of entries in the table 815 enum SymbolHashMap_Constants { 816 _Def_HashMap_Size = 256 817 }; 818 819 int _table_size; 820 SymbolHashMapBucket* _buckets; 821 822 void initialize_table(int table_size) { 823 _table_size = table_size; 824 _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size); 825 for (int index = 0; index < table_size; index++) { 826 _buckets[index].clear(); 827 } 828 } 829 830 public: 831 832 int table_size() const { return _table_size; } 833 834 SymbolHashMap() { initialize_table(_Def_HashMap_Size); } 835 SymbolHashMap(int table_size) { initialize_table(table_size); } 836 837 // hash P(31) from Kernighan & Ritchie 838 static unsigned int compute_hash(const char* str, int len) { 839 unsigned int hash = 0; 840 while (len-- > 0) { 841 hash = 31*hash + (unsigned) *str; 842 str++; 843 } 844 return hash; 845 } 846 847 SymbolHashMapEntry* bucket(int i) { 848 return _buckets[i].entry(); 849 } 850 851 void add_entry(Symbol* sym, u2 value); 852 SymbolHashMapEntry* find_entry(Symbol* sym); 853 854 u2 symbol_to_value(Symbol* sym) { 855 SymbolHashMapEntry *entry = find_entry(sym); 856 return (entry == NULL) ? 0 : entry->value(); 857 } 858 859 ~SymbolHashMap() { 860 SymbolHashMapEntry* next; 861 for (int i = 0; i < _table_size; i++) { 862 for (SymbolHashMapEntry* cur = bucket(i); cur != NULL; cur = next) { 863 next = cur->next(); 864 delete(cur); 865 } 866 } 867 delete _buckets; 868 } 869 }; // End SymbolHashMap class 870 871 #endif // SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP