8311661: Resolve duplicate symbol of StringTable::StringTable with JDK static linking

src/hotspot/share/cds/heapShared.cpp

@@ -416,13 +416,13 @@ void HeapShared::archive_java_mirrors() {
 }
 
 void HeapShared::archive_strings() {
-  oop shared_strings_array = JavaClassFile::StringTable::init_shared_table(_dumped_interned_strings);
+  oop shared_strings_array = StringTable::init_shared_table(_dumped_interned_strings);
   bool success = archive_reachable_objects_from(1, _default_subgraph_info, shared_strings_array);
   // We must succeed because:
   // - _dumped_interned_strings do not contain any large strings.
   // - StringTable::init_shared_table() doesn't create any large arrays.
   assert(success, "shared strings array must not point to arrays or strings that are too large to archive");
-  JavaClassFile::StringTable::set_shared_strings_array_index(append_root(shared_strings_array));
+  StringTable::set_shared_strings_array_index(append_root(shared_strings_array));
 }
 
 void HeapShared::mark_native_pointers(oop orig_obj) {

src/hotspot/share/cds/metaspaceShared.cpp

@@ -320,7 +320,7 @@ void MetaspaceShared::read_extra_data(JavaThread* current, const char* filename)
       assert(prefix_type == HashtableTextDump::StringPrefix, "Sanity");
       ExceptionMark em(current);
       JavaThread* THREAD = current; // For exception macros.
-      oop str = JavaClassFile::StringTable::intern(utf8_buffer, THREAD);
+      oop str = StringTable::intern(utf8_buffer, THREAD);
 
       if (HAS_PENDING_EXCEPTION) {
         log_warning(cds, heap)("[line %d] extra interned string allocation failed; size too large: %d",
@@ -375,7 +375,7 @@ void MetaspaceShared::serialize(SerializeClosure* soc) {
 
   // Dump/restore the symbol/string/subgraph_info tables
   SymbolTable::serialize_shared_table_header(soc);
-  JavaClassFile::StringTable::serialize_shared_table_header(soc);
+  StringTable::serialize_shared_table_header(soc);
   HeapShared::serialize_tables(soc);
   SystemDictionaryShared::serialize_dictionary_headers(soc);
 
@@ -778,7 +778,7 @@ void MetaspaceShared::preload_and_dump_impl(TRAPS) {
   log_info(cds)("Rewriting and linking classes: done");
 
 #if INCLUDE_CDS_JAVA_HEAP
-  JavaClassFile::StringTable::allocate_shared_strings_array(CHECK);
+  StringTable::allocate_shared_strings_array(CHECK);
   ArchiveHeapWriter::init();
   if (use_full_module_graph()) {
     HeapShared::reset_archived_object_states(CHECK);
@@ -1500,8 +1500,7 @@ void MetaspaceShared::initialize_shared_spaces() {
     CountSharedSymbols cl;
     SymbolTable::shared_symbols_do(&cl);
     tty->print_cr("Number of shared symbols: %d", cl.total());
-    tty->print_cr("Number of shared strings: %zu",
-                  JavaClassFile::StringTable::shared_entry_count());
+    tty->print_cr("Number of shared strings: %zu", StringTable::shared_entry_count());
     tty->print_cr("VM version: %s\r\n", static_mapinfo->vm_version());
     if (FileMapInfo::current_info() == nullptr || _archive_loading_failed) {
       tty->print_cr("archive is invalid");

src/hotspot/share/classfile/javaClasses.cpp

@@ -1238,8 +1238,7 @@ oop java_lang_Class::name(Handle java_class, TRAPS) {
   assert(_name_offset != 0, "must be set");
   oop o = java_class->obj_field(_name_offset);
   if (o == nullptr) {
-    o = JavaClassFile::StringTable::intern(as_external_name(java_class()),
-                                           THREAD);
+    o = StringTable::intern(as_external_name(java_class()), THREAD);
     java_class->obj_field_put(_name_offset, o);
   }
   return o;
@@ -2875,17 +2874,17 @@ void java_lang_StackTraceElement::fill_in(Handle element,
   }
 
   // Fill in method name
-  oop methodname = JavaClassFile::StringTable::intern(name, CHECK);
+  oop methodname = StringTable::intern(name, CHECK);
   java_lang_StackTraceElement::set_methodName(element(), methodname);
 
   // Fill in module name and version
   ModuleEntry* module = holder->module();
   if (module->is_named()) {
-    oop module_name = JavaClassFile::StringTable::intern(module->name(), CHECK);
+    oop module_name = StringTable::intern(module->name(), CHECK);
     java_lang_StackTraceElement::set_moduleName(element(), module_name);
     oop module_version;
     if (module->version() != nullptr) {
-      module_version = JavaClassFile::StringTable::intern(module->version(), CHECK);
+      module_version = StringTable::intern(module->version(), CHECK);
     } else {
       module_version = nullptr;
     }
@@ -2922,7 +2921,7 @@ void java_lang_StackTraceElement::decode_file_and_line(Handle java_class,
     // Class was not redefined. We can trust its cache if set,
     // else we have to initialize it.
     if (source_file == nullptr) {
-      source_file = JavaClassFile::StringTable::intern(source, CHECK);
+      source_file = StringTable::intern(source, CHECK);
       java_lang_Class::set_source_file(java_class(), source_file);
     }
   } else {
@@ -3393,7 +3392,7 @@ oop java_lang_reflect_RecordComponent::create(InstanceKlass* holder, RecordCompo
   java_lang_reflect_RecordComponent::set_clazz(element(), decl_class());
 
   Symbol* name = holder->constants()->symbol_at(component->name_index()); // name_index is a utf8
-  oop component_name = JavaClassFile::StringTable::intern(name, CHECK_NULL);
+  oop component_name = StringTable::intern(name, CHECK_NULL);
   java_lang_reflect_RecordComponent::set_name(element(), component_name);
 
   Symbol* type = holder->constants()->symbol_at(component->descriptor_index());
@@ -3423,7 +3422,7 @@ oop java_lang_reflect_RecordComponent::create(InstanceKlass* holder, RecordCompo
   int sig_index = component->generic_signature_index();
   if (sig_index > 0) {
     Symbol* sig = holder->constants()->symbol_at(sig_index); // sig_index is a utf8
-    oop component_sig = JavaClassFile::StringTable::intern(sig, CHECK_NULL);
+    oop component_sig = StringTable::intern(sig, CHECK_NULL);
     java_lang_reflect_RecordComponent::set_signature(element(), component_sig);
   } else {
     java_lang_reflect_RecordComponent::set_signature(element(), nullptr);

src/hotspot/share/classfile/stringTable.cpp

@@ -63,7 +63,7 @@
 #include "gc/g1/g1CollectedHeap.hpp"
 #endif
 
-namespace JavaClassFile {
+namespace hotspot_jvm {
 
 // We prefer short chains of avg 2
 const double PREF_AVG_LIST_LEN = 2.0;
@@ -766,7 +766,7 @@ void StringTable::dump(outputStream* st, bool verbose) {
   }
 }
 
-} // namespace JavaClassFile
+} // namespace hotspot_jvm
 
 // Utility for dumping strings
 StringtableDCmd::StringtableDCmd(outputStream* output, bool heap) :
@@ -782,7 +782,7 @@ void StringtableDCmd::execute(DCmdSource source, TRAPS) {
   VMThread::execute(&dumper);
 }
 
-namespace JavaClassFile {
+namespace hotspot_jvm {
 
 // Sharing
 #if INCLUDE_CDS_JAVA_HEAP
@@ -942,4 +942,4 @@ void StringTable::serialize_shared_table_header(SerializeClosure* soc) {
 }
 #endif //INCLUDE_CDS_JAVA_HEAP
 
-} // namespace JavaClassFile
+} // namespace hotspot_jvm

src/hotspot/share/classfile/stringTable.hpp

@@ -37,7 +37,7 @@ class DumpedInternedStrings;
 class JavaThread;
 class SerializeClosure;
 
-namespace JavaClassFile {
+namespace hotspot_jvm {
 
 class StringTable;
 class StringTableConfig;
@@ -160,6 +160,6 @@ class StringTable : public CHeapObj<mtSymbol>{
   static void verify();
 };
 
-} // namespace JavaClassFile
+} // namespace hotspot_jvm
 
 #endif // SHARE_CLASSFILE_STRINGTABLE_HPP

src/hotspot/share/classfile/systemDictionary.cpp

@@ -2058,7 +2058,7 @@ Method* SystemDictionary::find_method_handle_invoker(Klass* klass,
     SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_NULL);
 
   int ref_kind = JVM_REF_invokeVirtual;
-  oop name_oop = JavaClassFile::StringTable::intern(name, CHECK_NULL);
+  oop name_oop = StringTable::intern(name, CHECK_NULL);
   Handle name_str (THREAD, name_oop);
   objArrayHandle appendix_box = oopFactory::new_objArray_handle(vmClasses::Object_klass(), 1, CHECK_NULL);
   assert(appendix_box->obj_at(0) == nullptr, "");

src/hotspot/share/gc/shared/stringdedup/stringDedupTable.cpp

@@ -529,7 +529,7 @@ bool StringDedup::Table::try_deduplicate_shared(oop java_string) {
     // non-latin1, and deduplicating if we find a match.  For deduplication we
     // only care if the arrays consist of the same sequence of bytes.
     const jchar* chars = static_cast<jchar*>(value->base(T_CHAR));
-    oop found = JavaClassFile::StringTable::lookup_shared(chars, length >> 1);
+    oop found = StringTable::lookup_shared(chars, length >> 1);
     // If found is latin1, then it's byte array differs from the unicode
     // table key, so not actually a match to value.
     if ((found != nullptr) &&
@@ -553,7 +553,7 @@ bool StringDedup::Table::try_deduplicate_shared(oop java_string) {
   for (int i = 0; i < length; ++i) {
     chars[i] = value->byte_at(i) & 0xff;
   }
-  oop found = JavaClassFile::StringTable::lookup_shared(chars, length);
+  oop found = StringTable::lookup_shared(chars, length);
   if (found == nullptr) return false;
   assert(java_lang_String::is_latin1(found), "invariant");
   return try_deduplicate_found_shared(java_string, found);
@@ -610,7 +610,7 @@ bool StringDedup::Table::deduplicate_if_permitted(oop java_string,
 void StringDedup::Table::deduplicate(oop java_string) {
   assert(java_lang_String::is_instance(java_string), "precondition");
   _cur_stat.inc_inspected();
-  if ((JavaClassFile::StringTable::shared_entry_count() > 0) &&
+  if ((StringTable::shared_entry_count() > 0) &&
       try_deduplicate_shared(java_string)) {
     return;                     // Done if deduplicated against shared StringTable.
   }

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp

@@ -638,7 +638,7 @@ TRACE_REQUEST_FUNC(SymbolTableStatistics) {
 }
 
 TRACE_REQUEST_FUNC(StringTableStatistics) {
-  TableStatistics statistics = JavaClassFile::StringTable::get_table_statistics();
+  TableStatistics statistics = StringTable::get_table_statistics();
   emit_table_statistics<EventStringTableStatistics>(statistics);
 }
 

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -1976,7 +1976,7 @@ C2V_VMENTRY_0(jboolean, isInternedString, (JNIEnv* env, jobject, jobject object)
   }
   int len;
   jchar* name = java_lang_String::as_unicode_string(str(), len, CHECK_false);
-  return (JavaClassFile::StringTable::lookup(name, len) != nullptr);
+  return (StringTable::lookup(name, len) != nullptr);
 C2V_END
 
 

src/hotspot/share/jvmci/jvmciEnv.cpp

@@ -1088,14 +1088,14 @@ JVMCIObject JVMCIEnv::new_StackTraceElement(const methodHandle& method, int bci,
     oop objOop = HotSpotJVMCI::StackTraceElement::klass()->allocate_instance(CHECK_(JVMCIObject()));
     Handle obj = Handle(THREAD, objOop);
 
-    oop declaring_class = JavaClassFile::StringTable::intern((char*) declaring_class_str, CHECK_(JVMCIObject()));
+    oop declaring_class = StringTable::intern((char*) declaring_class_str, CHECK_(JVMCIObject()));
     HotSpotJVMCI::StackTraceElement::set_declaringClass(this, obj(), declaring_class);
 
-    oop method_name = JavaClassFile::StringTable::intern(method_name_sym, CHECK_(JVMCIObject()));
+    oop method_name = StringTable::intern(method_name_sym, CHECK_(JVMCIObject()));
     HotSpotJVMCI::StackTraceElement::set_methodName(this, obj(), method_name);
 
     if (file_name_sym != nullptr) {
-      oop file_name = JavaClassFile::StringTable::intern(file_name_sym, CHECK_(JVMCIObject()));
+      oop file_name = StringTable::intern(file_name_sym, CHECK_(JVMCIObject()));
       HotSpotJVMCI::StackTraceElement::set_fileName(this, obj(), file_name);
     }
     HotSpotJVMCI::StackTraceElement::set_lineNumber(this, obj(), line_number);

src/hotspot/share/memory/universe.cpp

@@ -356,9 +356,9 @@ void Universe::genesis(TRAPS) {
     SystemDictionary::initialize(CHECK);
 
     // Create string constants
-    oop s = JavaClassFile::StringTable::intern("null", CHECK);
+    oop s = StringTable::intern("null", CHECK);
     _the_null_string = OopHandle(vm_global(), s);
-    s = JavaClassFile::StringTable::intern("-2147483648", CHECK);
+    s = StringTable::intern("-2147483648", CHECK);
     _the_min_jint_string = OopHandle(vm_global(), s);
 
 
@@ -828,7 +828,7 @@ jint universe_init() {
 #endif
 
   SymbolTable::create_table();
-  JavaClassFile::StringTable::create_table();
+  StringTable::create_table();
 
   if (strlen(VerifySubSet) > 0) {
     Universe::initialize_verify_flags();
@@ -1155,7 +1155,7 @@ void Universe::verify(VerifyOption option, const char* prefix) {
   }
   if (should_verify_subset(Verify_StringTable)) {
     log_debug(gc, verify)("StringTable");
-    JavaClassFile::StringTable::verify();
+    StringTable::verify();
   }
   if (should_verify_subset(Verify_CodeCache)) {
     log_debug(gc, verify)("CodeCache");

src/hotspot/share/oops/constantPool.cpp

@@ -1201,7 +1201,7 @@ oop ConstantPool::resolve_constant_at_impl(const constantPoolHandle& this_cp,
 
 oop ConstantPool::uncached_string_at(int which, TRAPS) {
   Symbol* sym = unresolved_string_at(which);
-  oop str = JavaClassFile::StringTable::intern(sym, CHECK_(nullptr));
+  oop str = StringTable::intern(sym, CHECK_(nullptr));
   assert(java_lang_String::is_instance(str), "must be string");
   return str;
 }
@@ -1249,7 +1249,7 @@ oop ConstantPool::string_at_impl(const constantPoolHandle& this_cp, int which, i
   assert(str != Universe::the_null_sentinel(), "");
   if (str != nullptr) return str;
   Symbol* sym = this_cp->unresolved_string_at(which);
-  str = JavaClassFile::StringTable::intern(sym, CHECK_(nullptr));
+  str = StringTable::intern(sym, CHECK_(nullptr));
   this_cp->string_at_put(which, obj_index, str);
   assert(java_lang_String::is_instance(str), "must be string");
   return str;

src/hotspot/share/precompiled/precompiled.hpp

@@ -25,6 +25,12 @@
 // Precompiled headers are turned off if the user passes
 // --disable-precompiled-headers to configure.
 
+// The hotspot_jvm namespace using directive must be placed outside
+// #ifndef DONT_USE_PRECOMPILED_HEADER. That ensures it works with and
+// without precompiled headers.
+namespace hotspot_jvm {}
+using namespace hotspot_jvm;
+
 #ifndef DONT_USE_PRECOMPILED_HEADER
 
 // These header files are included in at least 130 C++ files, as of

src/hotspot/share/prims/jvm.cpp

@@ -3471,7 +3471,7 @@ JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
   JvmtiVMObjectAllocEventCollector oam;
   if (str == nullptr) return nullptr;
   oop string = JNIHandles::resolve_non_null(str);
-  oop result = JavaClassFile::StringTable::intern(string, CHECK_NULL);
+  oop result = StringTable::intern(string, CHECK_NULL);
   return (jstring) JNIHandles::make_local(THREAD, result);
 JVM_END
 

src/hotspot/share/prims/methodHandles.cpp

@@ -659,7 +659,7 @@ static oop object_java_mirror() {
 
 oop MethodHandles::field_name_or_null(Symbol* s) {
   if (s == nullptr)  return nullptr;
-  return JavaClassFile::StringTable::lookup(s);
+  return StringTable::lookup(s);
 }
 
 oop MethodHandles::field_signature_type_or_null(Symbol* s) {
@@ -890,7 +890,7 @@ void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
       }
       if (!have_name) {
         //not java_lang_String::create_from_symbol; let's intern member names
-        oop name = JavaClassFile::StringTable::intern(m->name(), CHECK);
+        oop name = StringTable::intern(m->name(), CHECK);
         java_lang_invoke_MemberName::set_name(mname(), name);
       }
       if (!have_type) {
@@ -914,7 +914,7 @@ void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
         break;                  // cannot expand
       if (!have_name) {
         //not java_lang_String::create_from_symbol; let's intern member names
-        oop name = JavaClassFile::StringTable::intern(fd.name(), CHECK);
+        oop name = StringTable::intern(fd.name(), CHECK);
         java_lang_invoke_MemberName::set_name(mname(), name);
       }
       if (!have_type) {

src/hotspot/share/prims/whitebox.cpp

@@ -1445,7 +1445,7 @@ WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString
   ResourceMark rm(THREAD);
   int len;
   jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
-  return (JavaClassFile::StringTable::lookup(name, len) != nullptr);
+  return (StringTable::lookup(name, len) != nullptr);
 WB_END
 
 WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
@@ -2054,7 +2054,7 @@ WB_ENTRY(jboolean, WB_IsSharedInternedString(JNIEnv* env, jobject wb, jobject st
   oop str_oop = JNIHandles::resolve(str);
   int length;
   jchar* chars = java_lang_String::as_unicode_string(str_oop, length, CHECK_(false));
-  return JavaClassFile::StringTable::lookup_shared(chars, length) == str_oop;
+  return StringTable::lookup_shared(chars, length) == str_oop;
 WB_END
 
 WB_ENTRY(jboolean, WB_IsSharedClass(JNIEnv* env, jobject wb, jclass clazz))

src/hotspot/share/runtime/init.cpp

@@ -198,7 +198,7 @@ void exit_globals() {
     SafepointTracing::statistics_exit_log();
     if (PrintStringTableStatistics) {
       SymbolTable::dump(tty);
-      JavaClassFile::StringTable::dump(tty);
+      StringTable::dump(tty);
     }
     ostream_exit();
 #ifdef LEAK_SANITIZER

src/hotspot/share/runtime/java.cpp

@@ -525,7 +525,7 @@ void before_exit(JavaThread* thread, bool halt) {
   }
 
   if (VerifyStringTableAtExit) {
-    size_t fail_cnt = JavaClassFile::StringTable::verify_and_compare_entries();
+    size_t fail_cnt = StringTable::verify_and_compare_entries();
     if (fail_cnt != 0) {
       tty->print_cr("ERROR: fail_cnt=" SIZE_FORMAT, fail_cnt);
       guarantee(fail_cnt == 0, "unexpected StringTable verification failures");

src/hotspot/share/runtime/reflection.cpp

@@ -791,7 +791,7 @@ oop Reflection::new_method(const methodHandle& method, bool for_constant_pool_ac
   assert(!exception_types.is_null(), "cannot return null");
 
   Symbol*  method_name = method->name();
-  oop name_oop = JavaClassFile::StringTable::intern(method_name, CHECK_NULL);
+  oop name_oop = StringTable::intern(method_name, CHECK_NULL);
   Handle name = Handle(THREAD, name_oop);
   if (name == nullptr) return nullptr;
 
@@ -861,7 +861,7 @@ oop Reflection::new_constructor(const methodHandle& method, TRAPS) {
 
 oop Reflection::new_field(fieldDescriptor* fd, TRAPS) {
   Symbol*  field_name = fd->name();
-  oop name_oop = JavaClassFile::StringTable::intern(field_name, CHECK_NULL);
+  oop name_oop = StringTable::intern(field_name, CHECK_NULL);
   Handle name = Handle(THREAD, name_oop);
   Symbol*  signature  = fd->signature();
   InstanceKlass* holder = fd->field_holder();