< prev index next >

src/hotspot/share/oops/instanceKlass.hpp

Print this page

  58 //    [EMBEDDED implementor of the interface] only exist for interface
  59 
  60 
  61 // forward declaration for class -- see below for definition
  62 #if INCLUDE_JVMTI
  63 class BreakpointInfo;
  64 #endif
  65 class ClassFileParser;
  66 class ClassFileStream;
  67 class KlassDepChange;
  68 class DependencyContext;
  69 class fieldDescriptor;
  70 class jniIdMapBase;
  71 class JNIid;
  72 class JvmtiCachedClassFieldMap;
  73 class nmethodBucket;
  74 class OopMapCache;
  75 class InterpreterOopMap;
  76 class PackageEntry;
  77 class ModuleEntry;

  78 
  79 // This is used in iterators below.
  80 class FieldClosure: public StackObj {
  81 public:
  82   virtual void do_field(fieldDescriptor* fd) = 0;
  83 };
  84 
  85 // Print fields.
  86 // If "obj" argument to constructor is null, prints static fields, otherwise prints non-static fields.
  87 class FieldPrinter: public FieldClosure {
  88    oop _obj;
  89    outputStream* _st;
  90  public:
  91    FieldPrinter(outputStream* st, oop obj = nullptr) : _obj(obj), _st(st) {}
  92    void do_field(fieldDescriptor* fd);
  93 };
  94 
  95 // Describes where oops are located in instances of this klass.
  96 class OopMapBlock {
  97  public:

 218   int             _nonstatic_oop_map_size;  // size in words of nonstatic oop map blocks
 219   int             _itable_len;              // length of Java itable (in words)
 220 
 221   // The NestHost attribute. The class info index for the class
 222   // that is the nest-host of this class. This data has not been validated.
 223   u2              _nest_host_index;
 224   u2              _this_class_index;        // constant pool entry
 225   u2              _static_oop_field_count;  // number of static oop fields in this klass
 226 
 227   volatile u2     _idnum_allocated_count;   // JNI/JVMTI: increments with the addition of methods, old ids don't change
 228 
 229   volatile ClassState _init_state;          // state of class
 230 
 231   u1              _reference_type;          // reference type
 232 
 233   // State is set either at parse time or while executing, atomically to not disturb other state
 234   InstanceKlassFlags _misc_flags;
 235 
 236   Monitor*             _init_monitor;       // mutual exclusion to _init_state and _init_thread.
 237   JavaThread* volatile _init_thread;        // Pointer to current thread doing initialization (to handle recursive initialization)

 238 
 239   OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
 240   JNIid*          _jni_ids;              // First JNI identifier for static fields in this class
 241   jmethodID*      volatile _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or null if none
 242   nmethodBucket*  volatile _dep_context;          // packed DependencyContext structure
 243   uint64_t        volatile _dep_context_last_cleaned;
 244   nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
 245 #if INCLUDE_JVMTI
 246   BreakpointInfo* _breakpoints;          // bpt lists, managed by Method*
 247   // Linked instanceKlasses of previous versions
 248   InstanceKlass* _previous_versions;
 249   // JVMTI fields can be moved to their own structure - see 6315920
 250   // JVMTI: cached class file, before retransformable agent modified it in CFLH
 251   JvmtiCachedClassFileData* _cached_class_file;
 252 #endif
 253 
 254 #if INCLUDE_JVMTI
 255   JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
 256 #endif
 257 

 302   static bool is_finalization_enabled() { return _finalization_enabled; }
 303 
 304   // Sets finalization state
 305   static void set_finalization_enabled(bool val) { _finalization_enabled = val; }
 306 
 307   // The three BUILTIN class loader types
 308   bool is_shared_boot_class() const { return _misc_flags.is_shared_boot_class(); }
 309   bool is_shared_platform_class() const { return _misc_flags.is_shared_platform_class(); }
 310   bool is_shared_app_class() const {  return _misc_flags.is_shared_app_class(); }
 311   // The UNREGISTERED class loader type
 312   bool is_shared_unregistered_class() const { return _misc_flags.is_shared_unregistered_class(); }
 313 
 314   // Check if the class can be shared in CDS
 315   bool is_shareable() const;
 316 
 317   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 318 
 319   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 320 
 321 #if INCLUDE_CDS

 322   void set_shared_class_loader_type(s2 loader_type) { _misc_flags.set_shared_class_loader_type(loader_type); }
 323   void assign_class_loader_type() { _misc_flags.assign_class_loader_type(_class_loader_data); }
 324 #endif
 325 
 326   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 327   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 328 
 329   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 330   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 331 
 332   // field sizes
 333   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 334   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 335 
 336   int static_field_size() const            { return _static_field_size; }
 337   void set_static_field_size(int size)     { _static_field_size = size; }
 338 
 339   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 340   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 341 

 500   // We can safely access the name as long as we hold the _init_monitor.
 501   const char* init_thread_name() {
 502     assert(_init_monitor->owned_by_self(), "Must hold _init_monitor here");
 503     return init_thread()->name_raw();
 504   }
 505 
 506  public:
 507   // initialization state
 508   bool is_loaded() const                   { return init_state() >= loaded; }
 509   bool is_linked() const                   { return init_state() >= linked; }
 510   bool is_being_linked() const             { return init_state() == being_linked; }
 511   bool is_initialized() const              { return init_state() == fully_initialized; }
 512   bool is_not_initialized() const          { return init_state() <  being_initialized; }
 513   bool is_being_initialized() const        { return init_state() == being_initialized; }
 514   bool is_in_error_state() const           { return init_state() == initialization_error; }
 515   bool is_init_thread(JavaThread *thread)  { return thread == init_thread(); }
 516   ClassState  init_state() const           { return Atomic::load(&_init_state); }
 517   const char* init_state_name() const;
 518   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 519 
















 520   class LockLinkState : public StackObj {
 521     InstanceKlass* _ik;
 522     JavaThread*    _current;
 523    public:
 524     LockLinkState(InstanceKlass* ik, JavaThread* current) : _ik(ik), _current(current) {
 525       ik->check_link_state_and_wait(current);
 526     }
 527     ~LockLinkState() {
 528       if (!_ik->is_linked()) {
 529         // Reset to loaded if linking failed.
 530         _ik->set_initialization_state_and_notify(loaded, _current);
 531       }
 532     }
 533   };
 534 
 535   // is this a sealed class
 536   bool is_sealed() const;
 537 
 538   // defineClass specified verification
 539   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 540   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 541 
 542   // marking
 543   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 544   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 545 
 546   // initialization (virtuals from Klass)
 547   bool should_be_initialized() const;  // means that initialize should be called

 548   void initialize(TRAPS);
 549   void link_class(TRAPS);
 550   bool link_class_or_fail(TRAPS); // returns false on failure
 551   void rewrite_class(TRAPS);
 552   void link_methods(TRAPS);
 553   Method* class_initializer() const;
 554 
 555   // reference type
 556   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 557 
 558   // this class cp index
 559   u2 this_class_index() const             { return _this_class_index; }
 560   void set_this_class_index(u2 index)     { _this_class_index = index; }
 561 
 562   static ByteSize reference_type_offset() { return byte_offset_of(InstanceKlass, _reference_type); }
 563 
 564   // find local field, returns true if found
 565   bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 566   // find field in direct superinterfaces, returns the interface in which the field is defined
 567   Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;

 804   jmethodID jmethod_id_or_null(Method* method);
 805 
 806   // annotations support
 807   Annotations* annotations() const          { return _annotations; }
 808   void set_annotations(Annotations* anno)   { _annotations = anno; }
 809 
 810   AnnotationArray* class_annotations() const {
 811     return (_annotations != nullptr) ? _annotations->class_annotations() : nullptr;
 812   }
 813   Array<AnnotationArray*>* fields_annotations() const {
 814     return (_annotations != nullptr) ? _annotations->fields_annotations() : nullptr;
 815   }
 816   AnnotationArray* class_type_annotations() const {
 817     return (_annotations != nullptr) ? _annotations->class_type_annotations() : nullptr;
 818   }
 819   Array<AnnotationArray*>* fields_type_annotations() const {
 820     return (_annotations != nullptr) ? _annotations->fields_type_annotations() : nullptr;
 821   }
 822   // allocation
 823   instanceOop allocate_instance(TRAPS);
 824   static instanceOop allocate_instance(oop cls, TRAPS);
 825 
 826   // additional member function to return a handle
 827   instanceHandle allocate_instance_handle(TRAPS);
 828 
 829   objArrayOop allocate_objArray(int n, int length, TRAPS);
 830   // Helper function
 831   static instanceOop register_finalizer(instanceOop i, TRAPS);
 832 
 833   // Check whether reflection/jni/jvm code is allowed to instantiate this class;
 834   // if not, throw either an Error or an Exception.
 835   virtual void check_valid_for_instantiation(bool throwError, TRAPS);
 836 
 837   // initialization
 838   void call_class_initializer(TRAPS);
 839   void set_initialization_state_and_notify(ClassState state, JavaThread* current);
 840 
 841   // OopMapCache support
 842   OopMapCache* oop_map_cache()               { return _oop_map_cache; }
 843   void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
 844   void mask_for(const methodHandle& method, int bci, InterpreterOopMap* entry);

1084   static void clear_jmethod_ids(InstanceKlass* klass);
1085 
1086   // Lock during initialization
1087 public:
1088   // Returns the array class for the n'th dimension
1089   virtual ArrayKlass* array_klass(int n, TRAPS);
1090   virtual ArrayKlass* array_klass_or_null(int n);
1091 
1092   // Returns the array class with this class as element type
1093   virtual ArrayKlass* array_klass(TRAPS);
1094   virtual ArrayKlass* array_klass_or_null();
1095 
1096   static void clean_initialization_error_table();
1097 
1098   Monitor* init_monitor() const { return _init_monitor; }
1099 private:
1100   void check_link_state_and_wait(JavaThread* current);
1101   bool link_class_impl                           (TRAPS);
1102   bool verify_code                               (TRAPS);
1103   void initialize_impl                           (TRAPS);
1104   void initialize_super_interfaces               (TRAPS);
1105 
1106   void add_initialization_error(JavaThread* current, Handle exception);
1107   oop get_initialization_error(JavaThread* current);
1108 
1109   // find a local method (returns null if not found)
1110   Method* find_method_impl(const Symbol* name,
1111                            const Symbol* signature,
1112                            OverpassLookupMode overpass_mode,
1113                            StaticLookupMode static_mode,
1114                            PrivateLookupMode private_mode) const;
1115 
1116   static Method* find_method_impl(const Array<Method*>* methods,
1117                                   const Symbol* name,
1118                                   const Symbol* signature,
1119                                   OverpassLookupMode overpass_mode,
1120                                   StaticLookupMode static_mode,
1121                                   PrivateLookupMode private_mode);
1122 
1123 #if INCLUDE_JVMTI
1124   // RedefineClasses support

  58 //    [EMBEDDED implementor of the interface] only exist for interface
  59 
  60 
  61 // forward declaration for class -- see below for definition
  62 #if INCLUDE_JVMTI
  63 class BreakpointInfo;
  64 #endif
  65 class ClassFileParser;
  66 class ClassFileStream;
  67 class KlassDepChange;
  68 class DependencyContext;
  69 class fieldDescriptor;
  70 class jniIdMapBase;
  71 class JNIid;
  72 class JvmtiCachedClassFieldMap;
  73 class nmethodBucket;
  74 class OopMapCache;
  75 class InterpreterOopMap;
  76 class PackageEntry;
  77 class ModuleEntry;
  78 class KlassTrainingData;
  79 
  80 // This is used in iterators below.
  81 class FieldClosure: public StackObj {
  82 public:
  83   virtual void do_field(fieldDescriptor* fd) = 0;
  84 };
  85 
  86 // Print fields.
  87 // If "obj" argument to constructor is null, prints static fields, otherwise prints non-static fields.
  88 class FieldPrinter: public FieldClosure {
  89    oop _obj;
  90    outputStream* _st;
  91  public:
  92    FieldPrinter(outputStream* st, oop obj = nullptr) : _obj(obj), _st(st) {}
  93    void do_field(fieldDescriptor* fd);
  94 };
  95 
  96 // Describes where oops are located in instances of this klass.
  97 class OopMapBlock {
  98  public:

 219   int             _nonstatic_oop_map_size;  // size in words of nonstatic oop map blocks
 220   int             _itable_len;              // length of Java itable (in words)
 221 
 222   // The NestHost attribute. The class info index for the class
 223   // that is the nest-host of this class. This data has not been validated.
 224   u2              _nest_host_index;
 225   u2              _this_class_index;        // constant pool entry
 226   u2              _static_oop_field_count;  // number of static oop fields in this klass
 227 
 228   volatile u2     _idnum_allocated_count;   // JNI/JVMTI: increments with the addition of methods, old ids don't change
 229 
 230   volatile ClassState _init_state;          // state of class
 231 
 232   u1              _reference_type;          // reference type
 233 
 234   // State is set either at parse time or while executing, atomically to not disturb other state
 235   InstanceKlassFlags _misc_flags;
 236 
 237   Monitor*             _init_monitor;       // mutual exclusion to _init_state and _init_thread.
 238   JavaThread* volatile _init_thread;        // Pointer to current thread doing initialization (to handle recursive initialization)
 239   KlassTrainingData*   _training_data;      // Null except in training mode.
 240 
 241   OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
 242   JNIid*          _jni_ids;              // First JNI identifier for static fields in this class
 243   jmethodID*      volatile _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or null if none
 244   nmethodBucket*  volatile _dep_context;          // packed DependencyContext structure
 245   uint64_t        volatile _dep_context_last_cleaned;
 246   nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
 247 #if INCLUDE_JVMTI
 248   BreakpointInfo* _breakpoints;          // bpt lists, managed by Method*
 249   // Linked instanceKlasses of previous versions
 250   InstanceKlass* _previous_versions;
 251   // JVMTI fields can be moved to their own structure - see 6315920
 252   // JVMTI: cached class file, before retransformable agent modified it in CFLH
 253   JvmtiCachedClassFileData* _cached_class_file;
 254 #endif
 255 
 256 #if INCLUDE_JVMTI
 257   JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
 258 #endif
 259 

 304   static bool is_finalization_enabled() { return _finalization_enabled; }
 305 
 306   // Sets finalization state
 307   static void set_finalization_enabled(bool val) { _finalization_enabled = val; }
 308 
 309   // The three BUILTIN class loader types
 310   bool is_shared_boot_class() const { return _misc_flags.is_shared_boot_class(); }
 311   bool is_shared_platform_class() const { return _misc_flags.is_shared_platform_class(); }
 312   bool is_shared_app_class() const {  return _misc_flags.is_shared_app_class(); }
 313   // The UNREGISTERED class loader type
 314   bool is_shared_unregistered_class() const { return _misc_flags.is_shared_unregistered_class(); }
 315 
 316   // Check if the class can be shared in CDS
 317   bool is_shareable() const;
 318 
 319   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 320 
 321   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 322 
 323 #if INCLUDE_CDS
 324   int  shared_class_loader_type() const;
 325   void set_shared_class_loader_type(s2 loader_type) { _misc_flags.set_shared_class_loader_type(loader_type); }
 326   void assign_class_loader_type() { _misc_flags.assign_class_loader_type(_class_loader_data); }
 327 #endif
 328 
 329   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 330   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 331 
 332   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 333   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 334 
 335   // field sizes
 336   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 337   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 338 
 339   int static_field_size() const            { return _static_field_size; }
 340   void set_static_field_size(int size)     { _static_field_size = size; }
 341 
 342   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 343   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 344 

 503   // We can safely access the name as long as we hold the _init_monitor.
 504   const char* init_thread_name() {
 505     assert(_init_monitor->owned_by_self(), "Must hold _init_monitor here");
 506     return init_thread()->name_raw();
 507   }
 508 
 509  public:
 510   // initialization state
 511   bool is_loaded() const                   { return init_state() >= loaded; }
 512   bool is_linked() const                   { return init_state() >= linked; }
 513   bool is_being_linked() const             { return init_state() == being_linked; }
 514   bool is_initialized() const              { return init_state() == fully_initialized; }
 515   bool is_not_initialized() const          { return init_state() <  being_initialized; }
 516   bool is_being_initialized() const        { return init_state() == being_initialized; }
 517   bool is_in_error_state() const           { return init_state() == initialization_error; }
 518   bool is_init_thread(JavaThread *thread)  { return thread == init_thread(); }
 519   ClassState  init_state() const           { return Atomic::load(&_init_state); }
 520   const char* init_state_name() const;
 521   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 522 
 523   KlassTrainingData* training_data_or_null() const {
 524     // there is a lot of concurrent state around classes, so let's use atomics
 525     return Atomic::load_acquire(&_training_data);
 526   }
 527   bool init_training_data(KlassTrainingData* tdata) {
 528     return (_training_data == tdata ||
 529             Atomic::replace_if_null(&_training_data, tdata));
 530   }
 531   KlassTrainingData* training_data() const {
 532     KlassTrainingData* tdata = training_data_or_null();
 533     assert(tdata != nullptr, "call alloc_training_data first");
 534     return tdata;
 535   }
 536 
 537   static const char* state2name(ClassState state);
 538 
 539   class LockLinkState : public StackObj {
 540     InstanceKlass* _ik;
 541     JavaThread*    _current;
 542    public:
 543     LockLinkState(InstanceKlass* ik, JavaThread* current) : _ik(ik), _current(current) {
 544       ik->check_link_state_and_wait(current);
 545     }
 546     ~LockLinkState() {
 547       if (!_ik->is_linked()) {
 548         // Reset to loaded if linking failed.
 549         _ik->set_initialization_state_and_notify(loaded, _current);
 550       }
 551     }
 552   };
 553 
 554   // is this a sealed class
 555   bool is_sealed() const;
 556 
 557   // defineClass specified verification
 558   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 559   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 560 
 561   // marking
 562   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 563   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 564 
 565   // initialization (virtuals from Klass)
 566   bool should_be_initialized() const;  // means that initialize should be called
 567   void initialize_from_cds(TRAPS);
 568   void initialize(TRAPS);
 569   void link_class(TRAPS);
 570   bool link_class_or_fail(TRAPS); // returns false on failure
 571   void rewrite_class(TRAPS);
 572   void link_methods(TRAPS);
 573   Method* class_initializer() const;
 574 
 575   // reference type
 576   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 577 
 578   // this class cp index
 579   u2 this_class_index() const             { return _this_class_index; }
 580   void set_this_class_index(u2 index)     { _this_class_index = index; }
 581 
 582   static ByteSize reference_type_offset() { return byte_offset_of(InstanceKlass, _reference_type); }
 583 
 584   // find local field, returns true if found
 585   bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 586   // find field in direct superinterfaces, returns the interface in which the field is defined
 587   Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;

 824   jmethodID jmethod_id_or_null(Method* method);
 825 
 826   // annotations support
 827   Annotations* annotations() const          { return _annotations; }
 828   void set_annotations(Annotations* anno)   { _annotations = anno; }
 829 
 830   AnnotationArray* class_annotations() const {
 831     return (_annotations != nullptr) ? _annotations->class_annotations() : nullptr;
 832   }
 833   Array<AnnotationArray*>* fields_annotations() const {
 834     return (_annotations != nullptr) ? _annotations->fields_annotations() : nullptr;
 835   }
 836   AnnotationArray* class_type_annotations() const {
 837     return (_annotations != nullptr) ? _annotations->class_type_annotations() : nullptr;
 838   }
 839   Array<AnnotationArray*>* fields_type_annotations() const {
 840     return (_annotations != nullptr) ? _annotations->fields_type_annotations() : nullptr;
 841   }
 842   // allocation
 843   instanceOop allocate_instance(TRAPS);
 844   static instanceOop allocate_instance(oop cls, const char* who, TRAPS);
 845 
 846   // additional member function to return a handle
 847   instanceHandle allocate_instance_handle(TRAPS);
 848 
 849   objArrayOop allocate_objArray(int n, int length, TRAPS);
 850   // Helper function
 851   static instanceOop register_finalizer(instanceOop i, TRAPS);
 852 
 853   // Check whether reflection/jni/jvm code is allowed to instantiate this class;
 854   // if not, throw either an Error or an Exception.
 855   virtual void check_valid_for_instantiation(bool throwError, TRAPS);
 856 
 857   // initialization
 858   void call_class_initializer(TRAPS);
 859   void set_initialization_state_and_notify(ClassState state, JavaThread* current);
 860 
 861   // OopMapCache support
 862   OopMapCache* oop_map_cache()               { return _oop_map_cache; }
 863   void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
 864   void mask_for(const methodHandle& method, int bci, InterpreterOopMap* entry);

1104   static void clear_jmethod_ids(InstanceKlass* klass);
1105 
1106   // Lock during initialization
1107 public:
1108   // Returns the array class for the n'th dimension
1109   virtual ArrayKlass* array_klass(int n, TRAPS);
1110   virtual ArrayKlass* array_klass_or_null(int n);
1111 
1112   // Returns the array class with this class as element type
1113   virtual ArrayKlass* array_klass(TRAPS);
1114   virtual ArrayKlass* array_klass_or_null();
1115 
1116   static void clean_initialization_error_table();
1117 
1118   Monitor* init_monitor() const { return _init_monitor; }
1119 private:
1120   void check_link_state_and_wait(JavaThread* current);
1121   bool link_class_impl                           (TRAPS);
1122   bool verify_code                               (TRAPS);
1123   void initialize_impl                           (TRAPS);
1124   void initialize_super_interfaces(TRAPS);
1125 
1126   void add_initialization_error(JavaThread* current, Handle exception);
1127   oop get_initialization_error(JavaThread* current);
1128 
1129   // find a local method (returns null if not found)
1130   Method* find_method_impl(const Symbol* name,
1131                            const Symbol* signature,
1132                            OverpassLookupMode overpass_mode,
1133                            StaticLookupMode static_mode,
1134                            PrivateLookupMode private_mode) const;
1135 
1136   static Method* find_method_impl(const Array<Method*>* methods,
1137                                   const Symbol* name,
1138                                   const Symbol* signature,
1139                                   OverpassLookupMode overpass_mode,
1140                                   StaticLookupMode static_mode,
1141                                   PrivateLookupMode private_mode);
1142 
1143 #if INCLUDE_JVMTI
1144   // RedefineClasses support
< prev index next >