src/share/vm/oops/instanceKlass.hpp

@@ -462,34 +462,23 @@
                                     const Symbol* class_name1,
                                     oop class_loader2,
                                     const Symbol* class_name2);
 
   // find an enclosing class
-  InstanceKlass* compute_enclosing_class(bool* inner_is_member, TRAPS) const {
-    return compute_enclosing_class_impl(this, inner_is_member, THREAD);
-  }
-  static InstanceKlass* compute_enclosing_class_impl(const InstanceKlass* self,
-                                                     bool* inner_is_member,
-                                                     TRAPS);
+  InstanceKlass* compute_enclosing_class(bool* inner_is_member, TRAPS) const;
 
-  // Find InnerClasses attribute for k and return outer_class_info_index & inner_name_index.
-  static bool find_inner_classes_attr(const InstanceKlass* k,
-                                      int* ooff, int* noff, TRAPS);
+  // Find InnerClasses attribute and return outer_class_info_index & inner_name_index.
+  bool find_inner_classes_attr(int* ooff, int* noff, TRAPS) const;
 
  private:
   // Check prohibited package ("java/" only loadable by boot or platform loaders)
   static void check_prohibited_package(Symbol* class_name,
                                        Handle class_loader,
                                        TRAPS);
  public:
   // tell if two classes have the same enclosing class (at package level)
-  bool is_same_package_member(const Klass* class2, TRAPS) const {
-    return is_same_package_member_impl(this, class2, THREAD);
-  }
-  static bool is_same_package_member_impl(const InstanceKlass* self,
-                                          const Klass* class2,
-                                          TRAPS);
+  bool is_same_package_member(const Klass* class2, TRAPS) const;
 
   // initialization state
   bool is_loaded() const                   { return _init_state >= loaded; }
   bool is_linked() const                   { return _init_state >= linked; }
   bool is_initialized() const              { return _init_state == fully_initialized; }

@@ -881,14 +870,13 @@
   }
   void set_enclosing_method_indices(u2 class_index,
                                     u2 method_index);
 
   // jmethodID support
-  static jmethodID get_jmethod_id(InstanceKlass* ik,
-                     const methodHandle& method_h);
-  static jmethodID get_jmethod_id_fetch_or_update(InstanceKlass* ik,
-                     size_t idnum, jmethodID new_id, jmethodID* new_jmeths,
+  jmethodID get_jmethod_id(const methodHandle& method_h);
+  jmethodID get_jmethod_id_fetch_or_update(size_t idnum,
+                     jmethodID new_id, jmethodID* new_jmeths,
                      jmethodID* to_dealloc_id_p,
                      jmethodID** to_dealloc_jmeths_p);
   static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum,
                 size_t *length_p, jmethodID* id_p);
   void ensure_space_for_methodids(int start_offset = 0);

@@ -1304,23 +1292,17 @@
   // It has to be an object not a Mutex because it's held through java calls.
   oop init_lock() const;
 private:
   void fence_and_clear_init_lock();
 
-  // Static methods that are used to implement member methods where an exposed this pointer
-  // is needed due to possible GCs
-  static bool link_class_impl                           (InstanceKlass* this_k, bool throw_verifyerror, TRAPS);
-  static bool verify_code                               (InstanceKlass* this_k, bool throw_verifyerror, TRAPS);
-  static void initialize_impl                           (InstanceKlass* this_k, TRAPS);
-  static void initialize_super_interfaces               (InstanceKlass* this_k, TRAPS);
-  static void eager_initialize_impl                     (InstanceKlass* this_k);
-  static void set_initialization_state_and_notify_impl  (InstanceKlass* this_k, ClassState state, TRAPS);
-  static void call_class_initializer_impl               (InstanceKlass* this_k, TRAPS);
-  static Klass* array_klass_impl                        (InstanceKlass* this_k, bool or_null, int n, TRAPS);
-  static void do_local_static_fields_impl               (InstanceKlass* this_k, void f(fieldDescriptor* fd, Handle, TRAPS), Handle, TRAPS);
+  bool link_class_impl                           (bool throw_verifyerror, TRAPS);
+  bool verify_code                               (bool throw_verifyerror, TRAPS);
+  void initialize_impl                           (TRAPS);
+  void initialize_super_interfaces               (TRAPS);
+  void eager_initialize_impl                     ();
   /* jni_id_for_impl for jfieldID only */
-  static JNIid* jni_id_for_impl                         (InstanceKlass* this_k, int offset);
+  JNIid* jni_id_for_impl                         (int offset);
 
   // Returns the array class for the n'th dimension
   Klass* array_klass_impl(bool or_null, int n, TRAPS);
 
   // Returns the array class with this class as element type