1 /*
   2  * Copyright (c) 1997, 2016, 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/altHashing.hpp"
  27 #include "classfile/compactHashtable.inline.hpp"
  28 #include "classfile/javaClasses.inline.hpp"
  29 #include "classfile/stringTable.hpp"
  30 #include "classfile/systemDictionary.hpp"
  31 #include "gc/shared/collectedHeap.inline.hpp"
  32 #include "gc/shared/gcLocker.inline.hpp"
  33 #include "memory/allocation.inline.hpp"
  34 #include "memory/filemap.hpp"
  35 #include "oops/oop.inline.hpp"
  36 #include "runtime/atomic.inline.hpp"
  37 #include "runtime/mutexLocker.hpp"
  38 #include "utilities/hashtable.inline.hpp"
  39 #include "utilities/macros.hpp"
  40 #if INCLUDE_ALL_GCS
  41 #include "gc/g1/g1CollectedHeap.hpp"
  42 #include "gc/g1/g1SATBCardTableModRefBS.hpp"
  43 #include "gc/g1/g1StringDedup.hpp"
  44 #endif
  45 
  46 // the number of buckets a thread claims
  47 const int ClaimChunkSize = 32;
  48 
  49 #ifdef ASSERT
  50 class StableMemoryChecker : public StackObj {
  51   enum { _bufsize = wordSize*4 };
  52 
  53   address _region;
  54   jint    _size;
  55   u1      _save_buf[_bufsize];
  56 
  57   int sample(u1* save_buf) {
  58     if (_size <= _bufsize) {
  59       memcpy(save_buf, _region, _size);
  60       return _size;
  61     } else {
  62       // copy head and tail
  63       memcpy(&save_buf[0],          _region,                      _bufsize/2);
  64       memcpy(&save_buf[_bufsize/2], _region + _size - _bufsize/2, _bufsize/2);
  65       return (_bufsize/2)*2;
  66     }
  67   }
  68 
  69  public:
  70   StableMemoryChecker(const void* region, jint size) {
  71     _region = (address) region;
  72     _size   = size;
  73     sample(_save_buf);
  74   }
  75 
  76   bool verify() {
  77     u1 check_buf[sizeof(_save_buf)];
  78     int check_size = sample(check_buf);
  79     return (0 == memcmp(_save_buf, check_buf, check_size));
  80   }
  81 
  82   void set_region(const void* region) { _region = (address) region; }
  83 };
  84 #endif
  85 
  86 
  87 // --------------------------------------------------------------------------
  88 StringTable* StringTable::_the_table = NULL;
  89 bool StringTable::_ignore_shared_strings = false;
  90 bool StringTable::_needs_rehashing = false;
  91 
  92 volatile int StringTable::_parallel_claimed_idx = 0;
  93 
  94 CompactHashtable<oop, char> StringTable::_shared_table;
  95 
  96 // Pick hashing algorithm
  97 template<typename T>
  98 unsigned int StringTable::hash_string(const T* s, int len) {
  99   return use_alternate_hashcode() ? AltHashing::murmur3_32(seed(), s, len) :
 100                                     java_lang_String::hash_code(s, len);
 101 }
 102 
 103 // Explicit instantiation for all supported types.
 104 template unsigned int StringTable::hash_string<jchar>(const jchar* s, int len);
 105 template unsigned int StringTable::hash_string<jbyte>(const jbyte* s, int len);
 106 
 107 oop StringTable::lookup_shared(jchar* name, int len) {
 108   // java_lang_String::hash_code() was used to compute hash values in the shared table. Don't
 109   // use the hash value from StringTable::hash_string() as it might use alternate hashcode.
 110   return _shared_table.lookup((const char*)name,
 111                               java_lang_String::hash_code(name, len), len);
 112 }
 113 
 114 oop StringTable::lookup_in_main_table(int index, jchar* name,
 115                                 int len, unsigned int hash) {
 116   int count = 0;
 117   for (HashtableEntry<oop, mtSymbol>* l = bucket(index); l != NULL; l = l->next()) {
 118     count++;
 119     if (l->hash() == hash) {
 120       if (java_lang_String::equals(l->literal(), name, len)) {
 121         return l->literal();
 122       }
 123     }
 124   }
 125   // If the bucket size is too deep check if this hash code is insufficient.
 126   if (count >= rehash_count && !needs_rehashing()) {
 127     _needs_rehashing = check_rehash_table(count);
 128   }
 129   return NULL;
 130 }
 131 
 132 
 133 oop StringTable::basic_add(int index_arg, Handle string, jchar* name,
 134                            int len, unsigned int hashValue_arg, TRAPS) {
 135 
 136   assert(java_lang_String::equals(string(), name, len),
 137          "string must be properly initialized");
 138   // Cannot hit a safepoint in this function because the "this" pointer can move.
 139   No_Safepoint_Verifier nsv;
 140 
 141   // Check if the symbol table has been rehashed, if so, need to recalculate
 142   // the hash value and index before second lookup.
 143   unsigned int hashValue;
 144   int index;
 145   if (use_alternate_hashcode()) {
 146     hashValue = hash_string(name, len);
 147     index = hash_to_index(hashValue);
 148   } else {
 149     hashValue = hashValue_arg;
 150     index = index_arg;
 151   }
 152 
 153   // Since look-up was done lock-free, we need to check if another
 154   // thread beat us in the race to insert the symbol.
 155 
 156   // No need to lookup the shared table from here since the caller (intern()) already did
 157   oop test = lookup_in_main_table(index, name, len, hashValue); // calls lookup(u1*, int)
 158   if (test != NULL) {
 159     // Entry already added
 160     return test;
 161   }
 162 
 163   HashtableEntry<oop, mtSymbol>* entry = new_entry(hashValue, string());
 164   add_entry(index, entry);
 165   return string();
 166 }
 167 
 168 
 169 oop StringTable::lookup(Symbol* symbol) {
 170   ResourceMark rm;
 171   int length;
 172   jchar* chars = symbol->as_unicode(length);
 173   return lookup(chars, length);
 174 }
 175 
 176 // Tell the GC that this string was looked up in the StringTable.
 177 static void ensure_string_alive(oop string) {
 178   // A lookup in the StringTable could return an object that was previously
 179   // considered dead. The SATB part of G1 needs to get notified about this
 180   // potential resurrection, otherwise the marking might not find the object.
 181 #if INCLUDE_ALL_GCS
 182   if (UseG1GC && string != NULL) {
 183     G1SATBCardTableModRefBS::enqueue(string);
 184   }
 185 #endif
 186 }
 187 
 188 oop StringTable::lookup(jchar* name, int len) {
 189   oop string = lookup_shared(name, len);
 190   if (string != NULL) {
 191     return string;
 192   }
 193 
 194   unsigned int hash = hash_string(name, len);
 195   int index = the_table()->hash_to_index(hash);
 196   string = the_table()->lookup_in_main_table(index, name, len, hash);
 197 
 198   ensure_string_alive(string);
 199 
 200   return string;
 201 }
 202 
 203 
 204 oop StringTable::intern(Handle string_or_null, jchar* name,
 205                         int len, TRAPS) {
 206   oop found_string = lookup_shared(name, len);
 207   if (found_string != NULL) {
 208     return found_string;
 209   }
 210 
 211   unsigned int hashValue = hash_string(name, len);
 212   int index = the_table()->hash_to_index(hashValue);
 213   found_string = the_table()->lookup_in_main_table(index, name, len, hashValue);
 214 
 215   // Found
 216   if (found_string != NULL) {
 217     ensure_string_alive(found_string);
 218     return found_string;
 219   }
 220 
 221   debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));
 222   assert(!Universe::heap()->is_in_reserved(name),
 223          "proposed name of symbol must be stable");
 224 
 225   Handle string;
 226   // try to reuse the string if possible
 227   if (!string_or_null.is_null()) {
 228     string = string_or_null;
 229   } else {
 230     string = java_lang_String::create_from_unicode(name, len, CHECK_NULL);
 231   }
 232 
 233 #if INCLUDE_ALL_GCS
 234   if (G1StringDedup::is_enabled()) {
 235     // Deduplicate the string before it is interned. Note that we should never
 236     // deduplicate a string after it has been interned. Doing so will counteract
 237     // compiler optimizations done on e.g. interned string literals.
 238     G1StringDedup::deduplicate(string());
 239   }
 240 #endif
 241 
 242   // Grab the StringTable_lock before getting the_table() because it could
 243   // change at safepoint.
 244   oop added_or_found;
 245   {
 246     MutexLocker ml(StringTable_lock, THREAD);
 247     // Otherwise, add to symbol to table
 248     added_or_found = the_table()->basic_add(index, string, name, len,
 249                                   hashValue, CHECK_NULL);
 250   }
 251 
 252   ensure_string_alive(added_or_found);
 253 
 254   return added_or_found;
 255 }
 256 
 257 oop StringTable::intern(Symbol* symbol, TRAPS) {
 258   if (symbol == NULL) return NULL;
 259   ResourceMark rm(THREAD);
 260   int length;
 261   jchar* chars = symbol->as_unicode(length);
 262   Handle string;
 263   oop result = intern(string, chars, length, CHECK_NULL);
 264   return result;
 265 }
 266 
 267 
 268 oop StringTable::intern(oop string, TRAPS)
 269 {
 270   if (string == NULL) return NULL;
 271   ResourceMark rm(THREAD);
 272   int length;
 273   Handle h_string (THREAD, string);
 274   jchar* chars = java_lang_String::as_unicode_string(string, length, CHECK_NULL);
 275   oop result = intern(h_string, chars, length, CHECK_NULL);
 276   return result;
 277 }
 278 
 279 
 280 oop StringTable::intern(const char* utf8_string, TRAPS) {
 281   if (utf8_string == NULL) return NULL;
 282   ResourceMark rm(THREAD);
 283   int length = UTF8::unicode_length(utf8_string);
 284   jchar* chars = NEW_RESOURCE_ARRAY(jchar, length);
 285   UTF8::convert_to_unicode(utf8_string, chars, length);
 286   Handle string;
 287   oop result = intern(string, chars, length, CHECK_NULL);
 288   return result;
 289 }
 290 
 291 void StringTable::unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int* processed, int* removed) {
 292   buckets_unlink_or_oops_do(is_alive, f, 0, the_table()->table_size(), processed, removed);
 293 }
 294 
 295 void StringTable::possibly_parallel_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int* processed, int* removed) {
 296   // Readers of the table are unlocked, so we should only be removing
 297   // entries at a safepoint.
 298   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 299   const int limit = the_table()->table_size();
 300 
 301   for (;;) {
 302     // Grab next set of buckets to scan
 303     int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;
 304     if (start_idx >= limit) {
 305       // End of table
 306       break;
 307     }
 308 
 309     int end_idx = MIN2(limit, start_idx + ClaimChunkSize);
 310     buckets_unlink_or_oops_do(is_alive, f, start_idx, end_idx, processed, removed);
 311   }
 312 }
 313 
 314 void StringTable::buckets_oops_do(OopClosure* f, int start_idx, int end_idx) {
 315   const int limit = the_table()->table_size();
 316 
 317   assert(0 <= start_idx && start_idx <= limit,
 318          "start_idx (%d) is out of bounds", start_idx);
 319   assert(0 <= end_idx && end_idx <= limit,
 320          "end_idx (%d) is out of bounds", end_idx);
 321   assert(start_idx <= end_idx,
 322          "Index ordering: start_idx=%d, end_idx=%d",
 323          start_idx, end_idx);
 324 
 325   for (int i = start_idx; i < end_idx; i += 1) {
 326     HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
 327     while (entry != NULL) {
 328       assert(!entry->is_shared(), "CDS not used for the StringTable");
 329 
 330       f->do_oop((oop*)entry->literal_addr());
 331 
 332       entry = entry->next();
 333     }
 334   }
 335 }
 336 
 337 void StringTable::buckets_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int start_idx, int end_idx, int* processed, int* removed) {
 338   const int limit = the_table()->table_size();
 339 
 340   assert(0 <= start_idx && start_idx <= limit,
 341          "start_idx (%d) is out of bounds", start_idx);
 342   assert(0 <= end_idx && end_idx <= limit,
 343          "end_idx (%d) is out of bounds", end_idx);
 344   assert(start_idx <= end_idx,
 345          "Index ordering: start_idx=%d, end_idx=%d",
 346          start_idx, end_idx);
 347 
 348   for (int i = start_idx; i < end_idx; ++i) {
 349     HashtableEntry<oop, mtSymbol>** p = the_table()->bucket_addr(i);
 350     HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
 351     while (entry != NULL) {
 352       assert(!entry->is_shared(), "CDS not used for the StringTable");
 353 
 354       if (is_alive->do_object_b(entry->literal())) {
 355         if (f != NULL) {
 356           f->do_oop((oop*)entry->literal_addr());
 357         }
 358         p = entry->next_addr();
 359       } else {
 360         *p = entry->next();
 361         the_table()->free_entry(entry);
 362         (*removed)++;
 363       }
 364       (*processed)++;
 365       entry = *p;
 366     }
 367   }
 368 }
 369 
 370 void StringTable::oops_do(OopClosure* f) {
 371   buckets_oops_do(f, 0, the_table()->table_size());
 372 }
 373 
 374 void StringTable::possibly_parallel_oops_do(OopClosure* f) {
 375   const int limit = the_table()->table_size();
 376 
 377   for (;;) {
 378     // Grab next set of buckets to scan
 379     int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;
 380     if (start_idx >= limit) {
 381       // End of table
 382       break;
 383     }
 384 
 385     int end_idx = MIN2(limit, start_idx + ClaimChunkSize);
 386     buckets_oops_do(f, start_idx, end_idx);
 387   }
 388 }
 389 
 390 // This verification is part of Universe::verify() and needs to be quick.
 391 // See StringTable::verify_and_compare() below for exhaustive verification.
 392 void StringTable::verify() {
 393   for (int i = 0; i < the_table()->table_size(); ++i) {
 394     HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
 395     for ( ; p != NULL; p = p->next()) {
 396       oop s = p->literal();
 397       guarantee(s != NULL, "interned string is NULL");
 398       unsigned int h = java_lang_String::hash_string(s);
 399       guarantee(p->hash() == h, "broken hash in string table entry");
 400       guarantee(the_table()->hash_to_index(h) == i,
 401                 "wrong index in string table");
 402     }
 403   }
 404 }
 405 
 406 void StringTable::dump(outputStream* st, bool verbose) {
 407   if (!verbose) {
 408     the_table()->dump_table(st, "StringTable");
 409   } else {
 410     Thread* THREAD = Thread::current();
 411     st->print_cr("VERSION: 1.1");
 412     for (int i = 0; i < the_table()->table_size(); ++i) {
 413       HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
 414       for ( ; p != NULL; p = p->next()) {
 415         oop s = p->literal();
 416         typeArrayOop value  = java_lang_String::value(s);
 417         int          length = java_lang_String::length(s);
 418         bool      is_latin1 = java_lang_String::is_latin1(s);
 419 
 420         if (length <= 0) {
 421           st->print("%d: ", length);
 422         } else {
 423           ResourceMark rm(THREAD);
 424           int utf8_length;
 425           char* utf8_string;
 426 
 427           if (!is_latin1) {
 428             jchar* chars = value->char_at_addr(0);
 429             utf8_length = UNICODE::utf8_length(chars, length);
 430             utf8_string = UNICODE::as_utf8(chars, length);
 431           } else {
 432             jbyte* bytes = value->byte_at_addr(0);
 433             utf8_length = UNICODE::utf8_length(bytes, length);
 434             utf8_string = UNICODE::as_utf8(bytes, length);
 435           }
 436 
 437           st->print("%d: ", utf8_length);
 438           HashtableTextDump::put_utf8(st, utf8_string, utf8_length);
 439         }
 440         st->cr();
 441       }
 442     }
 443   }
 444 }
 445 
 446 StringTable::VerifyRetTypes StringTable::compare_entries(
 447                                       int bkt1, int e_cnt1,
 448                                       HashtableEntry<oop, mtSymbol>* e_ptr1,
 449                                       int bkt2, int e_cnt2,
 450                                       HashtableEntry<oop, mtSymbol>* e_ptr2) {
 451   // These entries are sanity checked by verify_and_compare_entries()
 452   // before this function is called.
 453   oop str1 = e_ptr1->literal();
 454   oop str2 = e_ptr2->literal();
 455 
 456   if (str1 == str2) {
 457     tty->print_cr("ERROR: identical oop values (0x" PTR_FORMAT ") "
 458                   "in entry @ bucket[%d][%d] and entry @ bucket[%d][%d]",
 459                   p2i(str1), bkt1, e_cnt1, bkt2, e_cnt2);
 460     return _verify_fail_continue;
 461   }
 462 
 463   if (java_lang_String::equals(str1, str2)) {
 464     tty->print_cr("ERROR: identical String values in entry @ "
 465                   "bucket[%d][%d] and entry @ bucket[%d][%d]",
 466                   bkt1, e_cnt1, bkt2, e_cnt2);
 467     return _verify_fail_continue;
 468   }
 469 
 470   return _verify_pass;
 471 }
 472 
 473 StringTable::VerifyRetTypes StringTable::verify_entry(int bkt, int e_cnt,
 474                                       HashtableEntry<oop, mtSymbol>* e_ptr,
 475                                       StringTable::VerifyMesgModes mesg_mode) {
 476 
 477   VerifyRetTypes ret = _verify_pass;  // be optimistic
 478 
 479   oop str = e_ptr->literal();
 480   if (str == NULL) {
 481     if (mesg_mode == _verify_with_mesgs) {
 482       tty->print_cr("ERROR: NULL oop value in entry @ bucket[%d][%d]", bkt,
 483                     e_cnt);
 484     }
 485     // NULL oop means no more verifications are possible
 486     return _verify_fail_done;
 487   }
 488 
 489   if (str->klass() != SystemDictionary::String_klass()) {
 490     if (mesg_mode == _verify_with_mesgs) {
 491       tty->print_cr("ERROR: oop is not a String in entry @ bucket[%d][%d]",
 492                     bkt, e_cnt);
 493     }
 494     // not a String means no more verifications are possible
 495     return _verify_fail_done;
 496   }
 497 
 498   unsigned int h = java_lang_String::hash_string(str);
 499   if (e_ptr->hash() != h) {
 500     if (mesg_mode == _verify_with_mesgs) {
 501       tty->print_cr("ERROR: broken hash value in entry @ bucket[%d][%d], "
 502                     "bkt_hash=%d, str_hash=%d", bkt, e_cnt, e_ptr->hash(), h);
 503     }
 504     ret = _verify_fail_continue;
 505   }
 506 
 507   if (the_table()->hash_to_index(h) != bkt) {
 508     if (mesg_mode == _verify_with_mesgs) {
 509       tty->print_cr("ERROR: wrong index value for entry @ bucket[%d][%d], "
 510                     "str_hash=%d, hash_to_index=%d", bkt, e_cnt, h,
 511                     the_table()->hash_to_index(h));
 512     }
 513     ret = _verify_fail_continue;
 514   }
 515 
 516   return ret;
 517 }
 518 
 519 // See StringTable::verify() above for the quick verification that is
 520 // part of Universe::verify(). This verification is exhaustive and
 521 // reports on every issue that is found. StringTable::verify() only
 522 // reports on the first issue that is found.
 523 //
 524 // StringTable::verify_entry() checks:
 525 // - oop value != NULL (same as verify())
 526 // - oop value is a String
 527 // - hash(String) == hash in entry (same as verify())
 528 // - index for hash == index of entry (same as verify())
 529 //
 530 // StringTable::compare_entries() checks:
 531 // - oops are unique across all entries
 532 // - String values are unique across all entries
 533 //
 534 int StringTable::verify_and_compare_entries() {
 535   assert(StringTable_lock->is_locked(), "sanity check");
 536 
 537   int  fail_cnt = 0;
 538 
 539   // first, verify all the entries individually:
 540   for (int bkt = 0; bkt < the_table()->table_size(); bkt++) {
 541     HashtableEntry<oop, mtSymbol>* e_ptr = the_table()->bucket(bkt);
 542     for (int e_cnt = 0; e_ptr != NULL; e_ptr = e_ptr->next(), e_cnt++) {
 543       VerifyRetTypes ret = verify_entry(bkt, e_cnt, e_ptr, _verify_with_mesgs);
 544       if (ret != _verify_pass) {
 545         fail_cnt++;
 546       }
 547     }
 548   }
 549 
 550   // Optimization: if the above check did not find any failures, then
 551   // the comparison loop below does not need to call verify_entry()
 552   // before calling compare_entries(). If there were failures, then we
 553   // have to call verify_entry() to see if the entry can be passed to
 554   // compare_entries() safely. When we call verify_entry() in the loop
 555   // below, we do so quietly to void duplicate messages and we don't
 556   // increment fail_cnt because the failures have already been counted.
 557   bool need_entry_verify = (fail_cnt != 0);
 558 
 559   // second, verify all entries relative to each other:
 560   for (int bkt1 = 0; bkt1 < the_table()->table_size(); bkt1++) {
 561     HashtableEntry<oop, mtSymbol>* e_ptr1 = the_table()->bucket(bkt1);
 562     for (int e_cnt1 = 0; e_ptr1 != NULL; e_ptr1 = e_ptr1->next(), e_cnt1++) {
 563       if (need_entry_verify) {
 564         VerifyRetTypes ret = verify_entry(bkt1, e_cnt1, e_ptr1,
 565                                           _verify_quietly);
 566         if (ret == _verify_fail_done) {
 567           // cannot use the current entry to compare against other entries
 568           continue;
 569         }
 570       }
 571 
 572       for (int bkt2 = bkt1; bkt2 < the_table()->table_size(); bkt2++) {
 573         HashtableEntry<oop, mtSymbol>* e_ptr2 = the_table()->bucket(bkt2);
 574         int e_cnt2;
 575         for (e_cnt2 = 0; e_ptr2 != NULL; e_ptr2 = e_ptr2->next(), e_cnt2++) {
 576           if (bkt1 == bkt2 && e_cnt2 <= e_cnt1) {
 577             // skip the entries up to and including the one that
 578             // we're comparing against
 579             continue;
 580           }
 581 
 582           if (need_entry_verify) {
 583             VerifyRetTypes ret = verify_entry(bkt2, e_cnt2, e_ptr2,
 584                                               _verify_quietly);
 585             if (ret == _verify_fail_done) {
 586               // cannot compare against this entry
 587               continue;
 588             }
 589           }
 590 
 591           // compare two entries, report and count any failures:
 592           if (compare_entries(bkt1, e_cnt1, e_ptr1, bkt2, e_cnt2, e_ptr2)
 593               != _verify_pass) {
 594             fail_cnt++;
 595           }
 596         }
 597       }
 598     }
 599   }
 600   return fail_cnt;
 601 }
 602 
 603 // Create a new table and using alternate hash code, populate the new table
 604 // with the existing strings.   Set flag to use the alternate hash code afterwards.
 605 void StringTable::rehash_table() {
 606   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 607   // This should never happen with -Xshare:dump but it might in testing mode.
 608   if (DumpSharedSpaces) return;
 609   StringTable* new_table = new StringTable();
 610 
 611   // Rehash the table
 612   the_table()->move_to(new_table);
 613 
 614   // Delete the table and buckets (entries are reused in new table).
 615   delete _the_table;
 616   // Don't check if we need rehashing until the table gets unbalanced again.
 617   // Then rehash with a new global seed.
 618   _needs_rehashing = false;
 619   _the_table = new_table;
 620 }
 621 
 622 // Utility for dumping strings
 623 StringtableDCmd::StringtableDCmd(outputStream* output, bool heap) :
 624                                  DCmdWithParser(output, heap),
 625   _verbose("-verbose", "Dump the content of each string in the table",
 626            "BOOLEAN", false, "false") {
 627   _dcmdparser.add_dcmd_option(&_verbose);
 628 }
 629 
 630 void StringtableDCmd::execute(DCmdSource source, TRAPS) {
 631   VM_DumpHashtable dumper(output(), VM_DumpHashtable::DumpStrings,
 632                          _verbose.value());
 633   VMThread::execute(&dumper);
 634 }
 635 
 636 int StringtableDCmd::num_arguments() {
 637   ResourceMark rm;
 638   StringtableDCmd* dcmd = new StringtableDCmd(NULL, false);
 639   if (dcmd != NULL) {
 640     DCmdMark mark(dcmd);
 641     return dcmd->_dcmdparser.num_arguments();
 642   } else {
 643     return 0;
 644   }
 645 }
 646 
 647 // Sharing
 648 bool StringTable::copy_shared_string(GrowableArray<MemRegion> *string_space,
 649                                      CompactHashtableWriter* ch_table) {
 650 #if INCLUDE_CDS && INCLUDE_ALL_GCS && defined(_LP64) && !defined(_WINDOWS)
 651   assert(UseG1GC, "Only support G1 GC");
 652   assert(UseCompressedOops && UseCompressedClassPointers,
 653          "Only support UseCompressedOops and UseCompressedClassPointers enabled");
 654 
 655   Thread* THREAD = Thread::current();
 656   G1CollectedHeap::heap()->begin_archive_alloc_range();
 657   for (int i = 0; i < the_table()->table_size(); ++i) {
 658     HashtableEntry<oop, mtSymbol>* bucket = the_table()->bucket(i);
 659     for ( ; bucket != NULL; bucket = bucket->next()) {
 660       oop s = bucket->literal();
 661       unsigned int hash = java_lang_String::hash_code(s);
 662       if (hash == 0) {
 663         continue;
 664       }
 665 
 666       // allocate the new 'value' array first
 667       typeArrayOop v = java_lang_String::value(s);
 668       int v_len = v->size();
 669       typeArrayOop new_v;
 670       if (G1CollectedHeap::heap()->is_archive_alloc_too_large(v_len)) {
 671         continue; // skip the current String. The 'value' array is too large to handle
 672       } else {
 673         new_v = (typeArrayOop)G1CollectedHeap::heap()->archive_mem_allocate(v_len);
 674         if (new_v == NULL) {
 675           return false; // allocation failed
 676         }
 677       }
 678       // now allocate the new String object
 679       int s_len = s->size();
 680       oop new_s = (oop)G1CollectedHeap::heap()->archive_mem_allocate(s_len);
 681       if (new_s == NULL) {
 682         return false;
 683       }
 684 
 685       s->identity_hash();
 686       v->identity_hash();
 687 
 688       // copy the objects' data
 689       Copy::aligned_disjoint_words((HeapWord*)s, (HeapWord*)new_s, s_len);
 690       Copy::aligned_disjoint_words((HeapWord*)v, (HeapWord*)new_v, v_len);
 691 
 692       // adjust the pointer to the 'value' field in the new String oop. Also pre-compute and set the
 693       // 'hash' field. That avoids "write" to the shared strings at runtime by the deduplication process.
 694       java_lang_String::set_value_raw(new_s, new_v);
 695       if (java_lang_String::hash(new_s) == 0) {
 696         java_lang_String::set_hash(new_s, hash);
 697       }
 698 
 699       // add to the compact table
 700       ch_table->add(hash, new_s);
 701     }
 702   }
 703 
 704   G1CollectedHeap::heap()->end_archive_alloc_range(string_space, os::vm_allocation_granularity());
 705   assert(string_space->length() <= 2, "sanity");
 706 #endif
 707   return true;
 708 }
 709 
 710 bool StringTable::copy_compact_table(char** top, char *end, GrowableArray<MemRegion> *string_space,
 711                                      size_t* space_size) {
 712 #if INCLUDE_CDS && defined(_LP64) && !defined(_WINDOWS)
 713   if (!(UseG1GC && UseCompressedOops && UseCompressedClassPointers)) {
 714     if (PrintSharedSpaces) {
 715       tty->print_cr("Shared strings are excluded from the archive as UseG1GC, "
 716                     "UseCompressedOops and UseCompressedClassPointers are required.");
 717     }
 718     return true;
 719   }
 720 
 721   CompactHashtableWriter ch_table(CompactHashtable<oop, char>::_string_table,
 722                                   the_table()->number_of_entries(),
 723                                   &MetaspaceShared::stats()->string);
 724 
 725   // Copy the interned strings into the "string space" within the java heap
 726   if (!copy_shared_string(string_space, &ch_table)) {
 727     return false;
 728   }
 729 
 730   for (int i = 0; i < string_space->length(); i++) {
 731     *space_size += string_space->at(i).byte_size();
 732   }
 733 
 734   // Now dump the compact table
 735   if (*top + ch_table.get_required_bytes() > end) {
 736     // not enough space left
 737     return false;
 738   }
 739   ch_table.dump(top, end);
 740   *top = (char*)align_pointer_up(*top, sizeof(void*));
 741 
 742 #endif
 743   return true;
 744 }
 745 
 746 void StringTable::shared_oops_do(OopClosure* f) {
 747 #if INCLUDE_CDS && defined(_LP64) && !defined(_WINDOWS)
 748   _shared_table.oops_do(f);
 749 #endif
 750 }
 751 
 752 const char* StringTable::init_shared_table(FileMapInfo *mapinfo, char *buffer) {
 753 #if INCLUDE_CDS && defined(_LP64) && !defined(_WINDOWS)
 754   if (mapinfo->space_capacity(MetaspaceShared::first_string) == 0) {
 755     // no shared string data
 756     return buffer;
 757   }
 758 
 759   // initialize the shared table
 760   juint *p = (juint*)buffer;
 761   const char* end = _shared_table.init(
 762           CompactHashtable<oop, char>::_string_table, (char*)p);
 763   const char* aligned_end = (const char*)align_pointer_up(end, sizeof(void*));
 764 
 765   if (_ignore_shared_strings) {
 766     _shared_table.reset();
 767   }
 768 
 769   return aligned_end;
 770 #endif
 771 
 772   return buffer;
 773 }