500 TRAPS);
501
502 JavaThread* init_thread() { return Atomic::load(&_init_thread); }
503 const char* init_thread_name() {
504 return init_thread()->name_raw();
505 }
506
507 public:
508 // initialization state
509 bool is_loaded() const { return init_state() >= loaded; }
510 bool is_linked() const { return init_state() >= 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_reentrant_initialization(Thread *thread) { return thread == _init_thread; }
516 ClassState init_state() const { return Atomic::load_acquire(&_init_state); }
517 const char* init_state_name() const;
518 bool is_rewritten() const { return _misc_flags.rewritten(); }
519
520 // is this a sealed class
521 bool is_sealed() const;
522
523 // defineClass specified verification
524 bool should_verify_class() const { return _misc_flags.should_verify_class(); }
525 void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
526
527 // marking
528 bool is_marked_dependent() const { return _misc_flags.is_marked_dependent(); }
529 void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
530
531 // initialization (virtuals from Klass)
532 bool should_be_initialized() const; // means that initialize should be called
533 void initialize_with_aot_initialized_mirror(TRAPS);
534 void assert_no_clinit_will_run_for_aot_initialized_class() const NOT_DEBUG_RETURN;
535 void initialize(TRAPS);
536 void link_class(TRAPS);
537 bool link_class_or_fail(TRAPS); // returns false on failure
538 void rewrite_class(TRAPS);
539 void link_methods(TRAPS);
783 void update_methods_jmethod_cache();
784
785 // annotations support
786 Annotations* annotations() const { return _annotations; }
787 void set_annotations(Annotations* anno) { _annotations = anno; }
788
789 AnnotationArray* class_annotations() const {
790 return (_annotations != nullptr) ? _annotations->class_annotations() : nullptr;
791 }
792 Array<AnnotationArray*>* fields_annotations() const {
793 return (_annotations != nullptr) ? _annotations->fields_annotations() : nullptr;
794 }
795 AnnotationArray* class_type_annotations() const {
796 return (_annotations != nullptr) ? _annotations->class_type_annotations() : nullptr;
797 }
798 Array<AnnotationArray*>* fields_type_annotations() const {
799 return (_annotations != nullptr) ? _annotations->fields_type_annotations() : nullptr;
800 }
801 // allocation
802 instanceOop allocate_instance(TRAPS);
803 static instanceOop allocate_instance(oop cls, TRAPS);
804
805 // additional member function to return a handle
806 instanceHandle allocate_instance_handle(TRAPS);
807
808 objArrayOop allocate_objArray(int n, int length, TRAPS);
809 // Helper function
810 static instanceOop register_finalizer(instanceOop i, TRAPS);
811
812 // Check whether reflection/jni/jvm code is allowed to instantiate this class;
813 // if not, throw either an Error or an Exception.
814 virtual void check_valid_for_instantiation(bool throwError, TRAPS);
815
816 // initialization
817 void call_class_initializer(TRAPS);
818 void set_initialization_state_and_notify(ClassState state, TRAPS);
819
820 // OopMapCache support
821 OopMapCache* oop_map_cache() { return _oop_map_cache; }
822 void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
823 void mask_for(const methodHandle& method, int bci, InterpreterOopMap* entry);
|
500 TRAPS);
501
502 JavaThread* init_thread() { return Atomic::load(&_init_thread); }
503 const char* init_thread_name() {
504 return init_thread()->name_raw();
505 }
506
507 public:
508 // initialization state
509 bool is_loaded() const { return init_state() >= loaded; }
510 bool is_linked() const { return init_state() >= 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_reentrant_initialization(Thread *thread) { return thread == _init_thread; }
516 ClassState init_state() const { return Atomic::load_acquire(&_init_state); }
517 const char* init_state_name() const;
518 bool is_rewritten() const { return _misc_flags.rewritten(); }
519
520 static const char* state2name(ClassState state);
521
522 // is this a sealed class
523 bool is_sealed() const;
524
525 // defineClass specified verification
526 bool should_verify_class() const { return _misc_flags.should_verify_class(); }
527 void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
528
529 // marking
530 bool is_marked_dependent() const { return _misc_flags.is_marked_dependent(); }
531 void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
532
533 // initialization (virtuals from Klass)
534 bool should_be_initialized() const; // means that initialize should be called
535 void initialize_with_aot_initialized_mirror(TRAPS);
536 void assert_no_clinit_will_run_for_aot_initialized_class() const NOT_DEBUG_RETURN;
537 void initialize(TRAPS);
538 void link_class(TRAPS);
539 bool link_class_or_fail(TRAPS); // returns false on failure
540 void rewrite_class(TRAPS);
541 void link_methods(TRAPS);
785 void update_methods_jmethod_cache();
786
787 // annotations support
788 Annotations* annotations() const { return _annotations; }
789 void set_annotations(Annotations* anno) { _annotations = anno; }
790
791 AnnotationArray* class_annotations() const {
792 return (_annotations != nullptr) ? _annotations->class_annotations() : nullptr;
793 }
794 Array<AnnotationArray*>* fields_annotations() const {
795 return (_annotations != nullptr) ? _annotations->fields_annotations() : nullptr;
796 }
797 AnnotationArray* class_type_annotations() const {
798 return (_annotations != nullptr) ? _annotations->class_type_annotations() : nullptr;
799 }
800 Array<AnnotationArray*>* fields_type_annotations() const {
801 return (_annotations != nullptr) ? _annotations->fields_type_annotations() : nullptr;
802 }
803 // allocation
804 instanceOop allocate_instance(TRAPS);
805 static instanceOop allocate_instance(oop cls, const char* who, TRAPS);
806
807 // additional member function to return a handle
808 instanceHandle allocate_instance_handle(TRAPS);
809
810 objArrayOop allocate_objArray(int n, int length, TRAPS);
811 // Helper function
812 static instanceOop register_finalizer(instanceOop i, TRAPS);
813
814 // Check whether reflection/jni/jvm code is allowed to instantiate this class;
815 // if not, throw either an Error or an Exception.
816 virtual void check_valid_for_instantiation(bool throwError, TRAPS);
817
818 // initialization
819 void call_class_initializer(TRAPS);
820 void set_initialization_state_and_notify(ClassState state, TRAPS);
821
822 // OopMapCache support
823 OopMapCache* oop_map_cache() { return _oop_map_cache; }
824 void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
825 void mask_for(const methodHandle& method, int bci, InterpreterOopMap* entry);
|