8373668: Add override keyword to *Klass classes

xmas92 · xmas92 · commit 78c2d57259ad · 2025-12-16T07:38:26.000Z
Reviewed-by: jwaters, dholmes, kbarrett, tschatzl
diff --git a/src/hotspot/share/oops/arrayKlass.hpp b/src/hotspot/share/oops/arrayKlass.hpp
@@ -51,15 +51,15 @@ class ArrayKlass: public Klass {
 
  public:
   // Testing operation
-  DEBUG_ONLY(bool is_array_klass_slow() const { return true; })
+  DEBUG_ONLY(bool is_array_klass_slow() const override { return true; })
 
   // Returns the ObjArrayKlass for n'th dimension.
-  ArrayKlass* array_klass(int n, TRAPS);
-  ArrayKlass* array_klass_or_null(int n);
+  ArrayKlass* array_klass(int n, TRAPS) override;
+  ArrayKlass* array_klass_or_null(int n) override;
 
   // Returns the array class with this class as element type.
-  ArrayKlass* array_klass(TRAPS);
-  ArrayKlass* array_klass_or_null();
+  ArrayKlass* array_klass(TRAPS) override;
+  ArrayKlass* array_klass_or_null() override;
 
   // Instance variables
   int dimension() const                 { return _dimension;      }
@@ -79,21 +79,21 @@ class ArrayKlass: public Klass {
   // type of elements (T_OBJECT for both oop arrays and array-arrays)
   BasicType element_type() const        { return layout_helper_element_type(layout_helper()); }
 
-  virtual InstanceKlass* java_super() const;
+  InstanceKlass* java_super() const override;
 
   // Allocation
   // Sizes points to the first dimension of the array, subsequent dimensions
   // are always in higher memory.  The callers of these set that up.
   virtual oop multi_allocate(int rank, jint* sizes, TRAPS);
 
   // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
-  Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
+  Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const override;
 
   // Lookup operations
   Method* uncached_lookup_method(const Symbol* name,
                                  const Symbol* signature,
                                  OverpassLookupMode overpass_mode,
-                                 PrivateLookupMode private_mode = PrivateLookupMode::find) const;
+                                 PrivateLookupMode private_mode = PrivateLookupMode::find) const override;
 
   static ArrayKlass* cast(Klass* k) {
     return const_cast<ArrayKlass*>(cast(const_cast<const Klass*>(k)));
@@ -105,38 +105,38 @@ class ArrayKlass: public Klass {
   }
 
   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
-                                                  Array<InstanceKlass*>* transitive_interfaces);
+                                                  Array<InstanceKlass*>* transitive_interfaces) override;
 
   // Sizing
   static int static_size(int header_size);
 
-  virtual void metaspace_pointers_do(MetaspaceClosure* iter);
+  void metaspace_pointers_do(MetaspaceClosure* iter) override;
 
   // Return a handle.
   static void     complete_create_array_klass(ArrayKlass* k, Klass* super_klass, ModuleEntry* module, TRAPS);
 
   // JVMTI support
-  jint jvmti_class_status() const;
+  jint jvmti_class_status() const override;
 
 #if INCLUDE_CDS
   // CDS support - remove and restore oops from metadata. Oops are not shared.
-  virtual void remove_unshareable_info();
-  virtual void remove_java_mirror();
+  void remove_unshareable_info() override;
+  void remove_java_mirror() override;
   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS);
   void cds_print_value_on(outputStream* st) const;
 #endif
 
   void log_array_class_load(Klass* k);
   // Printing
-  void print_on(outputStream* st) const;
-  void print_value_on(outputStream* st) const;
+  void print_on(outputStream* st) const override;
+  void print_value_on(outputStream* st) const override;
 
-  void oop_print_on(oop obj, outputStream* st);
+  void oop_print_on(oop obj, outputStream* st) override;
 
   // Verification
-  void verify_on(outputStream* st);
+  void verify_on(outputStream* st) override;
 
-  void oop_verify_on(oop obj, outputStream* st);
+  void oop_verify_on(oop obj, outputStream* st) override;
 };
 
 #endif // SHARE_OOPS_ARRAYKLASS_HPP
diff --git a/src/hotspot/share/oops/instanceKlass.hpp b/src/hotspot/share/oops/instanceKlass.hpp
@@ -313,8 +313,8 @@ class InstanceKlass: public Klass {
 
   bool is_public() const                { return _access_flags.is_public(); }
   bool is_final() const                 { return _access_flags.is_final(); }
-  bool is_interface() const             { return _access_flags.is_interface(); }
-  bool is_abstract() const              { return _access_flags.is_abstract(); }
+  bool is_interface() const override    { return _access_flags.is_interface(); }
+  bool is_abstract() const override     { return _access_flags.is_abstract(); }
   bool is_super() const                 { return _access_flags.is_super(); }
   bool is_synthetic() const             { return _access_flags.is_synthetic(); }
   void set_is_synthetic()               { _access_flags.set_is_synthetic(); }
@@ -494,8 +494,8 @@ class InstanceKlass: public Klass {
   };
 
   // package
-  PackageEntry* package() const     { return _package_entry; }
-  ModuleEntry* module() const;
+  PackageEntry* package() const override { return _package_entry; }
+  ModuleEntry* module() const override;
   bool in_javabase_module() const;
   bool in_unnamed_package() const   { return (_package_entry == nullptr); }
   void set_package(ClassLoaderData* loader_data, PackageEntry* pkg_entry, TRAPS);
@@ -552,11 +552,11 @@ class InstanceKlass: public Klass {
   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 
   // initialization (virtuals from Klass)
-  bool should_be_initialized() const;  // means that initialize should be called
+  bool should_be_initialized() const override;  // means that initialize should be called
   void initialize_with_aot_initialized_mirror(TRAPS);
   void assert_no_clinit_will_run_for_aot_initialized_class() const NOT_DEBUG_RETURN;
-  void initialize(TRAPS);
-  void initialize_preemptable(TRAPS);
+  void initialize(TRAPS) override;
+  void initialize_preemptable(TRAPS) override;
   void link_class(TRAPS);
   bool link_class_or_fail(TRAPS); // returns false on failure
   void rewrite_class(TRAPS);
@@ -578,7 +578,7 @@ class InstanceKlass: public Klass {
   // find field in direct superinterfaces, returns the interface in which the field is defined
   Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
   // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
-  Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
+  Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const override;
   // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined
   Klass* find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const;
 
@@ -637,7 +637,7 @@ class InstanceKlass: public Klass {
   Method* uncached_lookup_method(const Symbol* name,
                                  const Symbol* signature,
                                  OverpassLookupMode overpass_mode,
-                                 PrivateLookupMode private_mode = PrivateLookupMode::find) const;
+                                 PrivateLookupMode private_mode = PrivateLookupMode::find) const override;
 
   // lookup a method in all the interfaces that this class implements
   // (returns null if not found)
@@ -660,7 +660,7 @@ class InstanceKlass: public Klass {
   void set_constants(ConstantPool* c)    { _constants = c; }
 
   // protection domain
-  oop protection_domain() const;
+  oop protection_domain() const override;
 
   // signers
   objArrayOop signers() const;
@@ -834,7 +834,7 @@ class InstanceKlass: public Klass {
 
   // Check whether reflection/jni/jvm code is allowed to instantiate this class;
   // if not, throw either an Error or an Exception.
-  virtual void check_valid_for_instantiation(bool throwError, TRAPS);
+  void check_valid_for_instantiation(bool throwError, TRAPS) override;
 
   // initialization
   void call_class_initializer(TRAPS);
@@ -901,12 +901,12 @@ class InstanceKlass: public Klass {
  public:
   // virtual operations from Klass
   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
-                                                  Array<InstanceKlass*>* transitive_interfaces);
-  bool can_be_primary_super_slow() const;
-  size_t oop_size(oop obj)  const             { return size_helper(); }
+                                                  Array<InstanceKlass*>* transitive_interfaces) override;
+  bool can_be_primary_super_slow() const override;
+  size_t oop_size(oop obj) const override { return size_helper(); }
   // slow because it's a virtual call and used for verifying the layout_helper.
   // Using the layout_helper bits, we can call is_instance_klass without a virtual call.
-  DEBUG_ONLY(bool is_instance_klass_slow() const      { return true; })
+  DEBUG_ONLY(bool is_instance_klass_slow() const override { return true; })
 
   // Iterators
   void do_local_static_fields(FieldClosure* cl);
@@ -932,7 +932,7 @@ class InstanceKlass: public Klass {
     return (Klass::super() == nullptr) ? nullptr : InstanceKlass::cast(Klass::super());
   }
 
-  virtual InstanceKlass* java_super() const {
+  InstanceKlass* java_super() const override {
     return InstanceKlass::super();
   }
 
@@ -949,10 +949,10 @@ class InstanceKlass: public Klass {
            (is_interface ? (int)sizeof(Klass*)/wordSize : 0));
   }
 
-  int size() const                    { return size(vtable_length(),
-                                               itable_length(),
-                                               nonstatic_oop_map_size(),
-                                               is_interface());
+  int size() const override           { return size(vtable_length(),
+                                                    itable_length(),
+                                                    nonstatic_oop_map_size(),
+                                                    is_interface());
   }
 
 
@@ -1008,15 +1008,15 @@ class InstanceKlass: public Klass {
   void static deallocate_record_components(ClassLoaderData* loader_data,
                                            Array<RecordComponent*>* record_component);
 
-  virtual bool on_stack() const;
+  bool on_stack() const override;
 
   // callbacks for actions during class unloading
   static void unload_class(InstanceKlass* ik);
 
-  virtual void release_C_heap_structures(bool release_sub_metadata = true);
+  void release_C_heap_structures(bool release_sub_metadata = true) override;
 
   // Naming
-  const char* signature_name() const;
+  const char* signature_name() const override;
 
   // Oop fields (and metadata) iterators
   //
@@ -1095,12 +1095,12 @@ class InstanceKlass: public Klass {
   oop init_lock() const;
 
   // Returns the array class for the n'th dimension
-  virtual ArrayKlass* array_klass(int n, TRAPS);
-  virtual ArrayKlass* array_klass_or_null(int n);
+  ArrayKlass* array_klass(int n, TRAPS) override;
+  ArrayKlass* array_klass_or_null(int n) override;
 
   // Returns the array class with this class as element type
-  virtual ArrayKlass* array_klass(TRAPS);
-  virtual ArrayKlass* array_klass_or_null();
+  ArrayKlass* array_klass(TRAPS) override;
+  ArrayKlass* array_klass_or_null() override;
 
   static void clean_initialization_error_table();
 private:
@@ -1139,9 +1139,9 @@ class InstanceKlass: public Klass {
 
 #if INCLUDE_CDS
   // CDS support - remove and restore oops from metadata. Oops are not shared.
-  virtual void remove_unshareable_info();
+  void remove_unshareable_info() override;
   void remove_unshareable_flags();
-  virtual void remove_java_mirror();
+  void remove_java_mirror() override;
   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, PackageEntry* pkg_entry, TRAPS);
   void init_shared_package_entry();
   bool can_be_verified_at_dumptime() const;
@@ -1154,35 +1154,35 @@ class InstanceKlass: public Klass {
     _misc_flags.set_has_init_deps_processed(true);
   }
 
-  u2 compute_modifier_flags() const;
+  u2 compute_modifier_flags() const override;
 
 public:
   // JVMTI support
-  jint jvmti_class_status() const;
+  jint jvmti_class_status() const override;
 
-  virtual void metaspace_pointers_do(MetaspaceClosure* iter);
+  void metaspace_pointers_do(MetaspaceClosure* iter) override;
 
  public:
   // Printing
-  void print_on(outputStream* st) const;
-  void print_value_on(outputStream* st) const;
+  void print_on(outputStream* st) const override;
+  void print_value_on(outputStream* st) const override;
 
-  void oop_print_value_on(oop obj, outputStream* st);
+  void oop_print_value_on(oop obj, outputStream* st) override;
 
-  void oop_print_on      (oop obj, outputStream* st);
+  void oop_print_on      (oop obj, outputStream* st) override;
 
 #ifndef PRODUCT
   void print_dependent_nmethods(bool verbose = false);
   bool is_dependent_nmethod(nmethod* nm);
   bool verify_itable_index(int index);
 #endif
 
-  const char* internal_name() const;
+  const char* internal_name() const override;
 
   // Verification
-  void verify_on(outputStream* st);
+  void verify_on(outputStream* st) override;
 
-  void oop_verify_on(oop obj, outputStream* st);
+  void oop_verify_on(oop obj, outputStream* st) override;
 
   // Logging
   void print_class_load_logging(ClassLoaderData* loader_data,
diff --git a/src/hotspot/share/oops/instanceMirrorKlass.hpp b/src/hotspot/share/oops/instanceMirrorKlass.hpp
@@ -67,7 +67,7 @@ class InstanceMirrorKlass: public InstanceKlass {
   }
 
   // Returns the size of the instance including the extra static fields.
-  virtual size_t oop_size(oop obj) const;
+  size_t oop_size(oop obj) const override;
 
   // Static field offset is an offset into the Heap, should be converted by
   // based on UseCompressedOop for traversal
diff --git a/src/hotspot/share/oops/instanceRefKlass.hpp b/src/hotspot/share/oops/instanceRefKlass.hpp
@@ -126,7 +126,7 @@ class InstanceRefKlass: public InstanceKlass {
 
  public:
   // Verification
-  void oop_verify_on(oop obj, outputStream* st);
+  void oop_verify_on(oop obj, outputStream* st) override;
 };
 
 #endif // SHARE_OOPS_INSTANCEREFKLASS_HPP
diff --git a/src/hotspot/share/oops/klass.hpp b/src/hotspot/share/oops/klass.hpp
@@ -215,7 +215,7 @@ class Klass : public Metadata {
   enum class StaticLookupMode   { find, skip };
   enum class PrivateLookupMode  { find, skip };
 
-  virtual bool is_klass() const { return true; }
+  bool is_klass() const override { return true; }
 
   // super() cannot be InstanceKlass* -- Java arrays are covariant, and _super is used
   // to implement that. NB: the _super of "[Ljava/lang/Integer;" is "[Ljava/lang/Number;"
@@ -649,9 +649,6 @@ class Klass : public Metadata {
   // actual oop size of obj in memory in word size.
   virtual size_t oop_size(oop obj) const = 0;
 
-  // Size of klass in word size.
-  virtual int size() const = 0;
-
   // Returns the Java name for a class (Resource allocated)
   // For arrays, this returns the name of the element with a leading '['.
   // For classes, this returns the name with the package separators
@@ -728,8 +725,8 @@ class Klass : public Metadata {
 
   JFR_ONLY(DEFINE_TRACE_ID_METHODS;)
 
-  virtual void metaspace_pointers_do(MetaspaceClosure* iter);
-  virtual MetaspaceObj::Type type() const { return ClassType; }
+  void metaspace_pointers_do(MetaspaceClosure* iter) override;
+  MetaspaceObj::Type type() const override { return ClassType; }
 
   inline bool is_loader_alive() const;
   inline bool is_loader_present_and_alive() const;
@@ -764,15 +761,13 @@ class Klass : public Metadata {
   virtual jint jvmti_class_status() const;
 
   // Printing
-  virtual void print_on(outputStream* st) const;
+  void print_on(outputStream* st) const override;
 
   virtual void oop_print_value_on(oop obj, outputStream* st);
   virtual void oop_print_on      (oop obj, outputStream* st);
 
   void print_secondary_supers_on(outputStream* st) const;
 
-  virtual const char* internal_name() const = 0;
-
   // Verification
   virtual void verify_on(outputStream* st);
   void verify() { verify_on(tty); }
diff --git a/src/hotspot/share/oops/objArrayKlass.hpp b/src/hotspot/share/oops/objArrayKlass.hpp
diff --git a/src/hotspot/share/oops/typeArrayKlass.hpp b/src/hotspot/share/oops/typeArrayKlass.hpp

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ class InstanceMirrorKlass: public InstanceKlass {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`// Returns the size of the instance including the extra static fields.`
`70`		`- virtual size_t oop_size(oop obj) const;`
	`70`	`+ size_t oop_size(oop obj) const override;`
`71`	`71`
`72`	`72`	`// Static field offset is an offset into the Heap, should be converted by`
`73`	`73`	`// based on UseCompressedOop for traversal`