< prev index next >

src/hotspot/share/oops/instanceKlass.hpp

Print this page

 507                                        TRAPS);
 508 
 509   JavaThread* init_thread()  { return Atomic::load(&_init_thread); }
 510   const char* init_thread_name() {
 511     return init_thread()->name_raw();
 512   }
 513 
 514  public:
 515   // initialization state
 516   bool is_loaded() const                   { return init_state() >= loaded; }
 517   bool is_linked() const                   { return init_state() >= linked; }
 518   bool is_initialized() const              { return init_state() == fully_initialized; }
 519   bool is_not_initialized() const          { return init_state() <  being_initialized; }
 520   bool is_being_initialized() const        { return init_state() == being_initialized; }
 521   bool is_in_error_state() const           { return init_state() == initialization_error; }
 522   bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 523   ClassState  init_state() const           { return Atomic::load_acquire(&_init_state); }
 524   const char* init_state_name() const;
 525   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 526 


 527   // is this a sealed class
 528   bool is_sealed() const;
 529 
 530   // defineClass specified verification
 531   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 532   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 533 
 534   // marking
 535   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 536   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 537 
 538   // initialization (virtuals from Klass)
 539   bool should_be_initialized() const;  // means that initialize should be called
 540   void initialize_with_aot_initialized_mirror(TRAPS);
 541   void assert_no_clinit_will_run_for_aot_initialized_class() const NOT_DEBUG_RETURN;
 542   void initialize(TRAPS);
 543   void link_class(TRAPS);
 544   bool link_class_or_fail(TRAPS); // returns false on failure
 545   void rewrite_class(TRAPS);
 546   void link_methods(TRAPS);

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

 507                                        TRAPS);
 508 
 509   JavaThread* init_thread()  { return Atomic::load(&_init_thread); }
 510   const char* init_thread_name() {
 511     return init_thread()->name_raw();
 512   }
 513 
 514  public:
 515   // initialization state
 516   bool is_loaded() const                   { return init_state() >= loaded; }
 517   bool is_linked() const                   { return init_state() >= linked; }
 518   bool is_initialized() const              { return init_state() == fully_initialized; }
 519   bool is_not_initialized() const          { return init_state() <  being_initialized; }
 520   bool is_being_initialized() const        { return init_state() == being_initialized; }
 521   bool is_in_error_state() const           { return init_state() == initialization_error; }
 522   bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 523   ClassState  init_state() const           { return Atomic::load_acquire(&_init_state); }
 524   const char* init_state_name() const;
 525   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 526 
 527   static const char* state2name(ClassState state);
 528 
 529   // is this a sealed class
 530   bool is_sealed() const;
 531 
 532   // defineClass specified verification
 533   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 534   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 535 
 536   // marking
 537   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 538   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 539 
 540   // initialization (virtuals from Klass)
 541   bool should_be_initialized() const;  // means that initialize should be called
 542   void initialize_with_aot_initialized_mirror(TRAPS);
 543   void assert_no_clinit_will_run_for_aot_initialized_class() const NOT_DEBUG_RETURN;
 544   void initialize(TRAPS);
 545   void link_class(TRAPS);
 546   bool link_class_or_fail(TRAPS); // returns false on failure
 547   void rewrite_class(TRAPS);
 548   void link_methods(TRAPS);

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