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