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 #include "precompiled.hpp" 26 #include "classfile/javaClasses.hpp" 27 #include "classfile/symbolTable.hpp" 28 #include "classfile/systemDictionary.hpp" 29 #include "gc_interface/collectedHeap.inline.hpp" 30 #include "memory/filemap.hpp" 31 #include "memory/gcLocker.inline.hpp" 32 #include "oops/oop.inline.hpp" 33 #include "oops/oop.inline2.hpp" 34 #include "runtime/mutexLocker.hpp" 35 #include "utilities/hashtable.inline.hpp" 36 37 // -------------------------------------------------------------------------- 38 39 SymbolTable* SymbolTable::_the_table = NULL; 40 41 Symbol* SymbolTable::allocate_symbol(const u1* name, int len, TRAPS) { 42 // Don't allow symbols to be created which cannot fit in a Symbol*. 43 if (len > Symbol::max_length()) { 44 THROW_MSG_0(vmSymbols::java_lang_InternalError(), 45 "name is too long to represent"); 46 } 47 Symbol* sym = new (len) Symbol(name, len); 48 assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted"); 49 return sym; 50 } 51 52 bool SymbolTable::allocate_symbols(int names_count, const u1** names, 53 int* lengths, Symbol** syms, TRAPS) { 54 for (int i = 0; i< names_count; i++) { 55 if (lengths[i] > Symbol::max_length()) { 56 THROW_MSG_0(vmSymbols::java_lang_InternalError(), 57 "name is too long to represent"); 58 } 59 } 60 61 for (int i = 0; i< names_count; i++) { 62 int len = lengths[i]; 63 syms[i] = new (len) Symbol(names[i], len); 64 assert(syms[i] != NULL, "new should call vm_exit_out_of_memory if " 65 "C_HEAP is exhausted"); 66 } 67 return true; 68 } 69 70 // Call function for all symbols in the symbol table. 71 void SymbolTable::symbols_do(SymbolClosure *cl) { 72 const int n = the_table()->table_size(); 73 for (int i = 0; i < n; i++) { 74 for (HashtableEntry<Symbol*>* p = the_table()->bucket(i); 75 p != NULL; 76 p = p->next()) { 77 cl->do_symbol(p->literal_addr()); 78 } 79 } 80 } 81 82 int SymbolTable::symbols_removed = 0; 83 int SymbolTable::symbols_counted = 0; 84 85 // Remove unreferenced symbols from the symbol table 86 // This is done late during GC. This doesn't use the hash table unlink because 87 // it assumes that the literals are oops. 88 void SymbolTable::unlink() { 89 int removed = 0; 90 int total = 0; 91 size_t memory_total = 0; 92 for (int i = 0; i < the_table()->table_size(); ++i) { 93 for (HashtableEntry<Symbol*>** p = the_table()->bucket_addr(i); *p != NULL; ) { 94 HashtableEntry<Symbol*>* entry = *p; 95 if (entry->is_shared()) { 96 break; 97 } 98 Symbol* s = entry->literal(); 99 memory_total += s->object_size(); 100 total++; 101 assert(s != NULL, "just checking"); 102 // If reference count is zero, remove. 103 if (s->refcount() == 0) { 104 delete s; 105 removed++; 106 *p = entry->next(); 107 the_table()->free_entry(entry); 108 } else { 109 p = entry->next_addr(); 110 } 111 } 112 } 113 symbols_removed += removed; 114 symbols_counted += total; 115 // Exclude printing for normal PrintGCDetails because people parse 116 // this output. 117 if (PrintGCDetails && Verbose && WizardMode) { 118 gclog_or_tty->print(" [Symbols=%d size=" SIZE_FORMAT "K] ", total, 119 (memory_total*HeapWordSize)/1024); 120 } 121 } 122 123 124 // Lookup a symbol in a bucket. 125 126 Symbol* SymbolTable::lookup(int index, const char* name, 127 int len, unsigned int hash) { 128 for (HashtableEntry<Symbol*>* e = bucket(index); e != NULL; e = e->next()) { 129 if (e->hash() == hash) { 130 Symbol* sym = e->literal(); 131 if (sym->equals(name, len)) { 132 // something is referencing this symbol now. 133 sym->increment_refcount(); 134 return sym; 135 } 136 } 137 } 138 return NULL; 139 } 140 141 142 // We take care not to be blocking while holding the 143 // SymbolTable_lock. Otherwise, the system might deadlock, since the 144 // symboltable is used during compilation (VM_thread) The lock free 145 // synchronization is simplified by the fact that we do not delete 146 // entries in the symbol table during normal execution (only during 147 // safepoints). 148 149 Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) { 150 unsigned int hashValue = hash_symbol(name, len); 151 int index = the_table()->hash_to_index(hashValue); 152 153 Symbol* s = the_table()->lookup(index, name, len, hashValue); 154 155 // Found 156 if (s != NULL) return s; 157 158 // Otherwise, add to symbol to table 159 return the_table()->basic_add(index, (u1*)name, len, hashValue, CHECK_NULL); 160 } 161 162 Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) { 163 char* buffer; 164 int index, len; 165 unsigned int hashValue; 166 char* name; 167 { 168 debug_only(No_Safepoint_Verifier nsv;) 169 170 name = (char*)sym->base() + begin; 171 len = end - begin; 172 hashValue = hash_symbol(name, len); 173 index = the_table()->hash_to_index(hashValue); 174 Symbol* s = the_table()->lookup(index, name, len, hashValue); 175 176 // Found 177 if (s != NULL) return s; 178 } 179 180 // Otherwise, add to symbol to table. Copy to a C string first. 181 char stack_buf[128]; 182 ResourceMark rm(THREAD); 183 if (len <= 128) { 184 buffer = stack_buf; 185 } else { 186 buffer = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len); 187 } 188 for (int i=0; i<len; i++) { 189 buffer[i] = name[i]; 190 } 191 // Make sure there is no safepoint in the code above since name can't move. 192 // We can't include the code in No_Safepoint_Verifier because of the 193 // ResourceMark. 194 195 return the_table()->basic_add(index, (u1*)buffer, len, hashValue, CHECK_NULL); 196 } 197 198 Symbol* SymbolTable::lookup_only(const char* name, int len, 199 unsigned int& hash) { 200 hash = hash_symbol(name, len); 201 int index = the_table()->hash_to_index(hash); 202 203 Symbol* s = the_table()->lookup(index, name, len, hash); 204 return s; 205 } 206 207 // Suggestion: Push unicode-based lookup all the way into the hashing 208 // and probing logic, so there is no need for convert_to_utf8 until 209 // an actual new Symbol* is created. 210 Symbol* SymbolTable::lookup_unicode(const jchar* name, int utf16_length, TRAPS) { 211 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length); 212 char stack_buf[128]; 213 if (utf8_length < (int) sizeof(stack_buf)) { 214 char* chars = stack_buf; 215 UNICODE::convert_to_utf8(name, utf16_length, chars); 216 return lookup(chars, utf8_length, THREAD); 217 } else { 218 ResourceMark rm(THREAD); 219 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);; 220 UNICODE::convert_to_utf8(name, utf16_length, chars); 221 return lookup(chars, utf8_length, THREAD); 222 } 223 } 224 225 Symbol* SymbolTable::lookup_only_unicode(const jchar* name, int utf16_length, 226 unsigned int& hash) { 227 int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length); 228 char stack_buf[128]; 229 if (utf8_length < (int) sizeof(stack_buf)) { 230 char* chars = stack_buf; 231 UNICODE::convert_to_utf8(name, utf16_length, chars); 232 return lookup_only(chars, utf8_length, hash); 233 } else { 234 ResourceMark rm; 235 char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);; 236 UNICODE::convert_to_utf8(name, utf16_length, chars); 237 return lookup_only(chars, utf8_length, hash); 238 } 239 } 240 241 void SymbolTable::add(constantPoolHandle cp, int names_count, 242 const char** names, int* lengths, int* cp_indices, 243 unsigned int* hashValues, TRAPS) { 244 SymbolTable* table = the_table(); 245 bool added = table->basic_add(cp, names_count, names, lengths, 246 cp_indices, hashValues, CHECK); 247 if (!added) { 248 // do it the hard way 249 for (int i=0; i<names_count; i++) { 250 int index = table->hash_to_index(hashValues[i]); 251 Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], 252 hashValues[i], CHECK); 253 cp->symbol_at_put(cp_indices[i], sym); 254 } 255 } 256 } 257 258 Symbol* SymbolTable::basic_add(int index, u1 *name, int len, 259 unsigned int hashValue, TRAPS) { 260 assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), 261 "proposed name of symbol must be stable"); 262 263 // We assume that lookup() has been called already, that it failed, 264 // and symbol was not found. We create the symbol here. 265 Symbol* sym = allocate_symbol(name, len, CHECK_NULL); 266 267 // Allocation must be done before grabbing the SymbolTable_lock lock 268 MutexLocker ml(SymbolTable_lock, THREAD); 269 270 assert(sym->equals((char*)name, len), "symbol must be properly initialized"); 271 272 // Since look-up was done lock-free, we need to check if another 273 // thread beat us in the race to insert the symbol. 274 275 Symbol* test = lookup(index, (char*)name, len, hashValue); 276 if (test != NULL) { 277 // A race occurred and another thread introduced the symbol, this one 278 // will be dropped and collected. 279 delete sym; 280 assert(test->refcount() != 0, "lookup should have incremented the count"); 281 return test; 282 } 283 284 HashtableEntry<Symbol*>* entry = new_entry(hashValue, sym); 285 sym->increment_refcount(); 286 add_entry(index, entry); 287 return sym; 288 } 289 290 bool SymbolTable::basic_add(constantPoolHandle cp, int names_count, 291 const char** names, int* lengths, 292 int* cp_indices, unsigned int* hashValues, 293 TRAPS) { 294 Symbol* syms[symbol_alloc_batch_size]; 295 bool allocated = allocate_symbols(names_count, (const u1**)names, lengths, 296 syms, CHECK_false); 297 if (!allocated) { 298 return false; 299 } 300 301 // Allocation must be done before grabbing the SymbolTable_lock lock 302 MutexLocker ml(SymbolTable_lock, THREAD); 303 304 for (int i=0; i<names_count; i++) { 305 assert(syms[i]->equals(names[i], lengths[i]), "symbol must be properly initialized"); 306 // Since look-up was done lock-free, we need to check if another 307 // thread beat us in the race to insert the symbol. 308 int index = hash_to_index(hashValues[i]); 309 Symbol* test = lookup(index, names[i], lengths[i], hashValues[i]); 310 if (test != NULL) { 311 // A race occurred and another thread introduced the symbol, this one 312 // will be dropped and collected. Use test instead. 313 cp->symbol_at_put(cp_indices[i], test); 314 assert(test->refcount() != 0, "lookup should have incremented the count"); 315 delete syms[i]; 316 } else { 317 Symbol* sym = syms[i]; 318 HashtableEntry<Symbol*>* entry = new_entry(hashValues[i], sym); 319 sym->increment_refcount(); // increment refcount in external hashtable 320 add_entry(index, entry); 321 cp->symbol_at_put(cp_indices[i], sym); 322 } 323 } 324 325 return true; 326 } 327 328 329 void SymbolTable::verify() { 330 for (int i = 0; i < the_table()->table_size(); ++i) { 331 HashtableEntry<Symbol*>* p = the_table()->bucket(i); 332 for ( ; p != NULL; p = p->next()) { 333 Symbol* s = (Symbol*)(p->literal()); 334 guarantee(s != NULL, "symbol is NULL"); 335 unsigned int h = hash_symbol((char*)s->bytes(), s->utf8_length()); 336 guarantee(p->hash() == h, "broken hash in symbol table entry"); 337 guarantee(the_table()->hash_to_index(h) == i, 338 "wrong index in symbol table"); 339 } 340 } 341 } 342 343 344 //--------------------------------------------------------------------------- 345 // Non-product code 346 347 #ifndef PRODUCT 348 349 void SymbolTable::print_histogram() { 350 MutexLocker ml(SymbolTable_lock); 351 const int results_length = 100; 352 int results[results_length]; 353 int i,j; 354 355 // initialize results to zero 356 for (j = 0; j < results_length; j++) { 357 results[j] = 0; 358 } 359 360 int total = 0; 361 int max_symbols = 0; 362 int out_of_range = 0; 363 int memory_total = 0; 364 int count = 0; 365 for (i = 0; i < the_table()->table_size(); i++) { 366 HashtableEntry<Symbol*>* p = the_table()->bucket(i); 367 for ( ; p != NULL; p = p->next()) { 368 memory_total += p->literal()->object_size(); 369 count++; 370 int counter = p->literal()->utf8_length(); 371 total += counter; 372 if (counter < results_length) { 373 results[counter]++; 374 } else { 375 out_of_range++; 376 } 377 max_symbols = MAX2(max_symbols, counter); 378 } 379 } 380 tty->print_cr("Symbol Table:"); 381 tty->print_cr("Total number of symbols %5d", count); 382 tty->print_cr("Total size in memory %5dK", 383 (memory_total*HeapWordSize)/1024); 384 tty->print_cr("Total counted %5d", symbols_counted); 385 tty->print_cr("Total removed %5d", symbols_removed); 386 if (symbols_counted > 0) { 387 tty->print_cr("Percent removed %3.2f", 388 ((float)symbols_removed/(float)symbols_counted)* 100); 389 } 390 tty->print_cr("Reference counts %5d", Symbol::_total_count); 391 tty->print_cr("Histogram of symbol length:"); 392 tty->print_cr("%8s %5d", "Total ", total); 393 tty->print_cr("%8s %5d", "Maximum", max_symbols); 394 tty->print_cr("%8s %3.2f", "Average", 395 ((float) total / (float) the_table()->table_size())); 396 tty->print_cr("%s", "Histogram:"); 397 tty->print_cr(" %s %29s", "Length", "Number chains that length"); 398 for (i = 0; i < results_length; i++) { 399 if (results[i] > 0) { 400 tty->print_cr("%6d %10d", i, results[i]); 401 } 402 } 403 if (Verbose) { 404 int line_length = 70; 405 tty->print_cr("%s %30s", " Length", "Number chains that length"); 406 for (i = 0; i < results_length; i++) { 407 if (results[i] > 0) { 408 tty->print("%4d", i); 409 for (j = 0; (j < results[i]) && (j < line_length); j++) { 410 tty->print("%1s", "*"); 411 } 412 if (j == line_length) { 413 tty->print("%1s", "+"); 414 } 415 tty->cr(); 416 } 417 } 418 } 419 tty->print_cr(" %s %d: %d\n", "Number chains longer than", 420 results_length, out_of_range); 421 } 422 423 void SymbolTable::print() { 424 for (int i = 0; i < the_table()->table_size(); ++i) { 425 HashtableEntry<Symbol*>** p = the_table()->bucket_addr(i); 426 HashtableEntry<Symbol*>* entry = the_table()->bucket(i); 427 if (entry != NULL) { 428 while (entry != NULL) { 429 tty->print(PTR_FORMAT " ", entry->literal()); 430 entry->literal()->print(); 431 tty->print(" %d", entry->literal()->refcount()); 432 p = entry->next_addr(); 433 entry = (HashtableEntry<Symbol*>*)HashtableEntry<Symbol*>::make_ptr(*p); 434 } 435 tty->cr(); 436 } 437 } 438 } 439 440 #endif // PRODUCT 441 442 // -------------------------------------------------------------------------- 443 444 #ifdef ASSERT 445 class StableMemoryChecker : public StackObj { 446 enum { _bufsize = wordSize*4 }; 447 448 address _region; 449 jint _size; 450 u1 _save_buf[_bufsize]; 451 452 int sample(u1* save_buf) { 453 if (_size <= _bufsize) { 454 memcpy(save_buf, _region, _size); 455 return _size; 456 } else { 457 // copy head and tail 458 memcpy(&save_buf[0], _region, _bufsize/2); 459 memcpy(&save_buf[_bufsize/2], _region + _size - _bufsize/2, _bufsize/2); 460 return (_bufsize/2)*2; 461 } 462 } 463 464 public: 465 StableMemoryChecker(const void* region, jint size) { 466 _region = (address) region; 467 _size = size; 468 sample(_save_buf); 469 } 470 471 bool verify() { 472 u1 check_buf[sizeof(_save_buf)]; 473 int check_size = sample(check_buf); 474 return (0 == memcmp(_save_buf, check_buf, check_size)); 475 } 476 477 void set_region(const void* region) { _region = (address) region; } 478 }; 479 #endif 480 481 482 // -------------------------------------------------------------------------- 483 484 485 // Compute the hash value for a java.lang.String object which would 486 // contain the characters passed in. This hash value is used for at 487 // least two purposes. 488 // 489 // (a) As the hash value used by the StringTable for bucket selection 490 // and comparison (stored in the HashtableEntry structures). This 491 // is used in the String.intern() method. 492 // 493 // (b) As the hash value used by the String object itself, in 494 // String.hashCode(). This value is normally calculate in Java code 495 // in the String.hashCode method(), but is precomputed for String 496 // objects in the shared archive file. 497 // 498 // For this reason, THIS ALGORITHM MUST MATCH String.hashCode(). 499 500 int StringTable::hash_string(jchar* s, int len) { 501 unsigned h = 0; 502 while (len-- > 0) { 503 h = 31*h + (unsigned) *s; 504 s++; 505 } 506 return h; 507 } 508 509 510 StringTable* StringTable::_the_table = NULL; 511 512 oop StringTable::lookup(int index, jchar* name, 513 int len, unsigned int hash) { 514 for (HashtableEntry<oop>* l = bucket(index); l != NULL; l = l->next()) { 515 if (l->hash() == hash) { 516 if (java_lang_String::equals(l->literal(), name, len)) { 517 return l->literal(); 518 } 519 } 520 } 521 return NULL; 522 } 523 524 525 oop StringTable::basic_add(int index, Handle string_or_null, jchar* name, 526 int len, unsigned int hashValue, TRAPS) { 527 debug_only(StableMemoryChecker smc(name, len * sizeof(name[0]))); 528 assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), 529 "proposed name of symbol must be stable"); 530 531 Handle string; 532 // try to reuse the string if possible 533 if (!string_or_null.is_null() && (!JavaObjectsInPerm || string_or_null()->is_perm())) { 534 string = string_or_null; 535 } else { 536 string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL); 537 } 538 539 // Allocation must be done before grapping the SymbolTable_lock lock 540 MutexLocker ml(StringTable_lock, THREAD); 541 542 assert(java_lang_String::equals(string(), name, len), 543 "string must be properly initialized"); 544 545 // Since look-up was done lock-free, we need to check if another 546 // thread beat us in the race to insert the symbol. 547 548 oop test = lookup(index, name, len, hashValue); // calls lookup(u1*, int) 549 if (test != NULL) { 550 // Entry already added 551 return test; 552 } 553 554 HashtableEntry<oop>* entry = new_entry(hashValue, string()); 555 add_entry(index, entry); 556 return string(); 557 } 558 559 560 oop StringTable::lookup(Symbol* symbol) { 561 ResourceMark rm; 562 int length; 563 jchar* chars = symbol->as_unicode(length); 564 unsigned int hashValue = hash_string(chars, length); 565 int index = the_table()->hash_to_index(hashValue); 566 return the_table()->lookup(index, chars, length, hashValue); 567 } 568 569 570 oop StringTable::intern(Handle string_or_null, jchar* name, 571 int len, TRAPS) { 572 unsigned int hashValue = hash_string(name, len); 573 int index = the_table()->hash_to_index(hashValue); 574 oop string = the_table()->lookup(index, name, len, hashValue); 575 576 // Found 577 if (string != NULL) return string; 578 579 // Otherwise, add to symbol to table 580 return the_table()->basic_add(index, string_or_null, name, len, 581 hashValue, CHECK_NULL); 582 } 583 584 oop StringTable::intern(Symbol* symbol, TRAPS) { 585 if (symbol == NULL) return NULL; 586 ResourceMark rm(THREAD); 587 int length; 588 jchar* chars = symbol->as_unicode(length); 589 Handle string; 590 oop result = intern(string, chars, length, CHECK_NULL); 591 return result; 592 } 593 594 595 oop StringTable::intern(oop string, TRAPS) 596 { 597 if (string == NULL) return NULL; 598 ResourceMark rm(THREAD); 599 int length; 600 Handle h_string (THREAD, string); 601 jchar* chars = java_lang_String::as_unicode_string(string, length); 602 oop result = intern(h_string, chars, length, CHECK_NULL); 603 return result; 604 } 605 606 607 oop StringTable::intern(const char* utf8_string, TRAPS) { 608 if (utf8_string == NULL) return NULL; 609 ResourceMark rm(THREAD); 610 int length = UTF8::unicode_length(utf8_string); 611 jchar* chars = NEW_RESOURCE_ARRAY(jchar, length); 612 UTF8::convert_to_unicode(utf8_string, chars, length); 613 Handle string; 614 oop result = intern(string, chars, length, CHECK_NULL); 615 return result; 616 } 617 618 void StringTable::unlink(BoolObjectClosure* is_alive) { 619 // Readers of the table are unlocked, so we should only be removing 620 // entries at a safepoint. 621 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); 622 for (int i = 0; i < the_table()->table_size(); ++i) { 623 for (HashtableEntry<oop>** p = the_table()->bucket_addr(i); *p != NULL; ) { 624 HashtableEntry<oop>* entry = *p; 625 if (entry->is_shared()) { 626 break; 627 } 628 assert(entry->literal() != NULL, "just checking"); 629 if (is_alive->do_object_b(entry->literal())) { 630 p = entry->next_addr(); 631 } else { 632 *p = entry->next(); 633 the_table()->free_entry(entry); 634 } 635 } 636 } 637 } 638 639 void StringTable::oops_do(OopClosure* f) { 640 for (int i = 0; i < the_table()->table_size(); ++i) { 641 HashtableEntry<oop>** p = the_table()->bucket_addr(i); 642 HashtableEntry<oop>* entry = the_table()->bucket(i); 643 while (entry != NULL) { 644 f->do_oop((oop*)entry->literal_addr()); 645 646 // Did the closure remove the literal from the table? 647 if (entry->literal() == NULL) { 648 assert(!entry->is_shared(), "immutable hashtable entry?"); 649 *p = entry->next(); 650 the_table()->free_entry(entry); 651 } else { 652 p = entry->next_addr(); 653 } 654 entry = (HashtableEntry<oop>*)HashtableEntry<oop>::make_ptr(*p); 655 } 656 } 657 } 658 659 void StringTable::verify() { 660 for (int i = 0; i < the_table()->table_size(); ++i) { 661 HashtableEntry<oop>* p = the_table()->bucket(i); 662 for ( ; p != NULL; p = p->next()) { 663 oop s = p->literal(); 664 guarantee(s != NULL, "interned string is NULL"); 665 guarantee(s->is_perm() || !JavaObjectsInPerm, "interned string not in permspace"); 666 667 int length; 668 jchar* chars = java_lang_String::as_unicode_string(s, length); 669 unsigned int h = hash_string(chars, length); 670 guarantee(p->hash() == h, "broken hash in string table entry"); 671 guarantee(the_table()->hash_to_index(h) == i, 672 "wrong index in string table"); 673 } 674 } 675 }