8256424: Move ciSymbol::symbol_name() to ciSymbols::symbol_name()

Reviewed-by: kvn, iklam

Author: cl4es

src/hotspot/share/aot/aotCodeHeap.cpp

@@ -27,6 +27,7 @@
 #include "aot/aotLoader.hpp"
 #include "ci/ciUtilities.inline.hpp"
 #include "classfile/javaAssertions.hpp"
+#include "classfile/vmSymbols.hpp"
 #include "gc/shared/cardTable.hpp"
 #include "gc/shared/cardTableBarrierSet.hpp"
 #include "gc/shared/gcConfig.hpp"

src/hotspot/share/c1/c1_GraphBuilder.cpp

@@ -32,6 +32,7 @@
 #include "ci/ciField.hpp"
 #include "ci/ciKlass.hpp"
 #include "ci/ciMemberName.hpp"
+#include "ci/ciSymbols.hpp"
 #include "ci/ciUtilities.inline.hpp"
 #include "compiler/compilationPolicy.hpp"
 #include "compiler/compileBroker.hpp"
@@ -1477,7 +1478,7 @@ void GraphBuilder::method_return(Value x, bool ignore_return) {
 
   // The conditions for a memory barrier are described in Parse::do_exits().
   bool need_mem_bar = false;
-  if (method()->name() == ciSymbol::object_initializer_name() &&
+  if (method()->name() == ciSymbols::object_initializer_name() &&
        (scope()->wrote_final() ||
          (AlwaysSafeConstructors && scope()->wrote_fields()) ||
          (support_IRIW_for_not_multiple_copy_atomic_cpu && scope()->wrote_volatile()))) {
@@ -3820,7 +3821,7 @@ bool GraphBuilder::try_inline_full(ciMethod* callee, bool holder_known, bool ign
     }
 
     // don't inline throwable methods unless the inlining tree is rooted in a throwable class
-    if (callee->name() == ciSymbol::object_initializer_name() &&
+    if (callee->name() == ciSymbols::object_initializer_name() &&
         callee->holder()->is_subclass_of(ciEnv::current()->Throwable_klass())) {
       // Throwable constructor call
       IRScope* top = scope();

src/hotspot/share/c1/c1_InstructionPrinter.cpp

@@ -23,6 +23,7 @@
  */
 
 #include "precompiled.hpp"
+#include "classfile/vmSymbols.hpp"
 #include "c1/c1_InstructionPrinter.hpp"
 #include "c1/c1_ValueStack.hpp"
 #include "ci/ciArray.hpp"

src/hotspot/share/ci/bcEscapeAnalyzer.cpp

@@ -23,6 +23,7 @@
  */
 
 #include "precompiled.hpp"
+#include "classfile/vmIntrinsics.hpp"
 #include "ci/bcEscapeAnalyzer.hpp"
 #include "ci/ciConstant.hpp"
 #include "ci/ciField.hpp"
@@ -1204,8 +1205,8 @@ void BCEscapeAnalyzer::do_analysis() {
   iterate_blocks(arena);
 }
 
-vmIntrinsics::ID BCEscapeAnalyzer::known_intrinsic() {
-  vmIntrinsics::ID iid = method()->intrinsic_id();
+vmIntrinsicID BCEscapeAnalyzer::known_intrinsic() {
+  vmIntrinsicID iid = method()->intrinsic_id();
   if (iid == vmIntrinsics::_getClass ||
       iid == vmIntrinsics::_hashCode) {
     return iid;
@@ -1214,7 +1215,7 @@ vmIntrinsics::ID BCEscapeAnalyzer::known_intrinsic() {
   }
 }
 
-void BCEscapeAnalyzer::compute_escape_for_intrinsic(vmIntrinsics::ID iid) {
+void BCEscapeAnalyzer::compute_escape_for_intrinsic(vmIntrinsicID iid) {
   switch (iid) {
     case vmIntrinsics::_getClass:
       _return_local = false;
@@ -1293,7 +1294,7 @@ void BCEscapeAnalyzer::compute_escape_info() {
   int i;
   assert(!methodData()->has_escape_info(), "do not overwrite escape info");
 
-  vmIntrinsics::ID iid = known_intrinsic();
+  vmIntrinsicID iid = known_intrinsic();
 
   // check if method can be analyzed
   if (iid == vmIntrinsics::_none && (method()->is_abstract() || method()->is_native() || !method()->holder()->is_initialized()

src/hotspot/share/ci/bcEscapeAnalyzer.hpp

@@ -98,8 +98,8 @@ class BCEscapeAnalyzer : public ResourceObj {
   void initialize();
   void clear_escape_info();
   void compute_escape_info();
-  vmIntrinsics::ID known_intrinsic();
-  void compute_escape_for_intrinsic(vmIntrinsics::ID iid);
+  vmIntrinsicID known_intrinsic();
+  void compute_escape_for_intrinsic(vmIntrinsicID iid);
   void do_analysis();
 
   void read_escape_info();

src/hotspot/share/ci/ciEnv.cpp

@@ -32,6 +32,7 @@
 #include "ci/ciMethod.hpp"
 #include "ci/ciNullObject.hpp"
 #include "ci/ciReplay.hpp"
+#include "ci/ciSymbols.hpp"
 #include "ci/ciUtilities.inline.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/symbolTable.hpp"
@@ -798,7 +799,7 @@ ciMethod* ciEnv::get_method_by_index_impl(const constantPoolHandle& cpool,
 
     // Fake a method that is equivalent to a declared method.
     ciInstanceKlass* holder    = get_instance_klass(SystemDictionary::MethodHandle_klass());
-    ciSymbol*        name      = ciSymbol::invokeBasic_name();
+    ciSymbol*        name      = ciSymbols::invokeBasic_name();
     ciSymbol*        signature = get_symbol(cpool->signature_ref_at(index));
     return get_unloaded_method(holder, name, signature, accessor);
   } else {

src/hotspot/share/ci/ciField.cpp

@@ -25,6 +25,7 @@
 #include "precompiled.hpp"
 #include "ci/ciField.hpp"
 #include "ci/ciInstanceKlass.hpp"
+#include "ci/ciSymbols.hpp"
 #include "ci/ciUtilities.inline.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/systemDictionary.hpp"
@@ -218,7 +219,7 @@ ciField::ciField(fieldDescriptor *fd) :
 static bool trust_final_non_static_fields(ciInstanceKlass* holder) {
   if (holder == NULL)
     return false;
-  if (holder->name() == ciSymbol::java_lang_System())
+  if (holder->name() == ciSymbols::java_lang_System())
     // Never trust strangely unstable finals:  System.out, etc.
     return false;
   // Even if general trusting is disabled, trust system-built closures in these packages.
@@ -239,14 +240,14 @@ static bool trust_final_non_static_fields(ciInstanceKlass* holder) {
   if (holder->is_record())
     return true;
   // Trust final fields in String
-  if (holder->name() == ciSymbol::java_lang_String())
+  if (holder->name() == ciSymbols::java_lang_String())
     return true;
   // Trust Atomic*FieldUpdaters: they are very important for performance, and make up one
   // more reason not to use Unsafe, if their final fields are trusted. See more in JDK-8140483.
-  if (holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicIntegerFieldUpdater_Impl() ||
-      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_CASUpdater() ||
-      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater() ||
-      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicReferenceFieldUpdater_Impl()) {
+  if (holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicIntegerFieldUpdater_Impl() ||
+      holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicLongFieldUpdater_CASUpdater() ||
+      holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater() ||
+      holder->name() == ciSymbols::java_util_concurrent_atomic_AtomicReferenceFieldUpdater_Impl()) {
     return true;
   }
   return TrustFinalNonStaticFields;
@@ -417,6 +418,24 @@ bool ciField::will_link(ciMethod* accessing_method,
   return true;
 }
 
+bool ciField::is_call_site_target() {
+  ciInstanceKlass* callsite_klass = CURRENT_ENV->CallSite_klass();
+  if (callsite_klass == NULL)
+    return false;
+  return (holder()->is_subclass_of(callsite_klass) && (name() == ciSymbols::target_name()));
+}
+
+bool ciField::is_autobox_cache() {
+  ciSymbol* klass_name = holder()->name();
+  return (name() == ciSymbols::cache_field_name() &&
+          holder()->uses_default_loader() &&
+          (klass_name == ciSymbols::java_lang_Character_CharacterCache() ||
+            klass_name == ciSymbols::java_lang_Byte_ByteCache() ||
+            klass_name == ciSymbols::java_lang_Short_ShortCache() ||
+            klass_name == ciSymbols::java_lang_Integer_IntegerCache() ||
+            klass_name == ciSymbols::java_lang_Long_LongCache()));
+}
+
 // ------------------------------------------------------------------
 // ciField::print
 void ciField::print() {

src/hotspot/share/ci/ciField.hpp

@@ -178,23 +178,9 @@ class ciField : public ResourceObj {
   // (or class/initializer methods if the field is static).
   bool has_initialized_final_update() const { return flags().has_initialized_final_update(); }
 
-  bool is_call_site_target() {
-    ciInstanceKlass* callsite_klass = CURRENT_ENV->CallSite_klass();
-    if (callsite_klass == NULL)
-      return false;
-    return (holder()->is_subclass_of(callsite_klass) && (name() == ciSymbol::target_name()));
-  }
+  bool is_call_site_target();
 
-  bool is_autobox_cache() {
-    ciSymbol* klass_name = holder()->name();
-    return (name() == ciSymbol::cache_field_name() &&
-            holder()->uses_default_loader() &&
-            (klass_name == ciSymbol::java_lang_Character_CharacterCache() ||
-             klass_name == ciSymbol::java_lang_Byte_ByteCache() ||
-             klass_name == ciSymbol::java_lang_Short_ShortCache() ||
-             klass_name == ciSymbol::java_lang_Integer_IntegerCache() ||
-             klass_name == ciSymbol::java_lang_Long_LongCache()));
-  }
+  bool is_autobox_cache();
 
   // Debugging output
   void print();

src/hotspot/share/ci/ciMethod.cpp

@@ -32,6 +32,7 @@
 #include "ci/ciStreams.hpp"
 #include "ci/ciSymbol.hpp"
 #include "ci/ciReplay.hpp"
+#include "ci/ciSymbols.hpp"
 #include "ci/ciUtilities.inline.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "compiler/abstractCompiler.hpp"
@@ -946,7 +947,7 @@ bool ciMethod::is_compiled_lambda_form() const {
 // ciMethod::is_object_initializer
 //
 bool ciMethod::is_object_initializer() const {
-   return name() == ciSymbol::object_initializer_name();
+   return name() == ciSymbols::object_initializer_name();
 }
 
 // ------------------------------------------------------------------

src/hotspot/share/ci/ciMethod.hpp

@@ -29,6 +29,7 @@
 #include "ci/ciInstanceKlass.hpp"
 #include "ci/ciObject.hpp"
 #include "ci/ciSignature.hpp"
+#include "classfile/vmIntrinsics.hpp"
 #include "compiler/methodLiveness.hpp"
 #include "runtime/handles.hpp"
 #include "utilities/bitMap.hpp"
@@ -75,7 +76,7 @@ class ciMethod : public ciMetadata {
   int _code_size;
   int _max_stack;
   int _max_locals;
-  vmIntrinsics::ID _intrinsic_id;
+  vmIntrinsicID _intrinsic_id;
   int _handler_count;
   int _nmethod_age;
   int _interpreter_invocation_count;
@@ -181,7 +182,7 @@ class ciMethod : public ciMetadata {
   int code_size() const                          { check_is_loaded(); return _code_size; }
   int max_stack() const                          { check_is_loaded(); return _max_stack; }
   int max_locals() const                         { check_is_loaded(); return _max_locals; }
-  vmIntrinsics::ID intrinsic_id() const          { check_is_loaded(); return _intrinsic_id; }
+  vmIntrinsicID intrinsic_id() const             { check_is_loaded(); return _intrinsic_id; }
   bool has_exception_handlers() const            { check_is_loaded(); return _handler_count > 0; }
   int exception_table_length() const             { check_is_loaded(); return _handler_count; }
   int interpreter_invocation_count() const       { check_is_loaded(); return _interpreter_invocation_count; }