graal-jvmci-8: src/share/vm/oops/instanceKlass.hpp comparison

comparison src/share/vm/oops/instanceKlass.hpp @ 6038:8bafad97cd26

7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. Summary: Change the _host_klass to be conditionally created embedded instanceKlass field. Reviewed-by: jrose, coleenp, dholmes

author	jiangli
date	Wed, 02 May 2012 13:21:36 -0400
parents	0105f367a14c
children	2766551175a0

comparison

equal deleted inserted replaced

-:973046802b6f
+:8bafad97cd26
 //    [EMBEDDED Java vtable             ] size in words = vtable_len
 //    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
 //      The embedded nonstatic oop-map blocks are short pairs (offset, length)
 //      indicating where oops are located in instances of this klass.
 //    [EMBEDDED implementor of the interface] only exist for interface
+//    [EMBEDDED host klass        ] only exist for an anonymous class (JSR 292 enabled)
 // forward declaration for class -- see below for definition
 class SuperTypeClosure;
 class JNIid;
 constantPoolOop _constants;
 // Class loader used to load this class, NULL if VM loader used.
 oop             _class_loader;
 // Protection domain.
 oop             _protection_domain;
-// Host class, which grants its access privileges to this class also.
-// This is only non-null for an anonymous class (JSR 292 enabled).
-// The host class is either named, or a previously loaded anonymous class.
-klassOop        _host_klass;
 // Class signers.
 objArrayOop     _signers;
 // The InnerClasses attribute and EnclosingMethod attribute. The
 // _inner_classes is an array of shorts. If the class has InnerClasses
 // attribute, then the _inner_classes array begins with 4-tuples of shorts
 u2              _static_oop_field_count;// number of static oop fields in this klass
 u2              _java_fields_count;    // The number of declared Java fields
 int             _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
 bool            _is_marked_dependent;  // used for marking during flushing and deoptimization
-bool            _rewritten;            // methods rewritten.
+enum {
-bool            _has_nonstatic_fields; // for sizing with UseCompressedOops
+_misc_rewritten            = 1 << 0, // methods rewritten.
-bool            _should_verify_class;  // allow caching of preverification
+_misc_has_nonstatic_fields = 1 << 1, // for sizing with UseCompressedOops
+_misc_should_verify_class  = 1 << 2, // allow caching of preverification
+_misc_is_anonymous         = 1 << 3  // has embedded _inner_classes field
+};
+u2              _misc_flags;
 u2              _minor_version;        // minor version number of class file
 u2              _major_version;        // major version number of class file
 Thread*         _init_thread;          // Pointer to current thread doing initialization (to handle recusive initialization)
 int             _vtable_len;           // length of Java vtable (in words)
 int             _itable_len;           // length of Java itable (in words)
 //   iterface. The possible values of the implementor fall into following
 //   three cases:
 //     NULL: no implementor.
 //     A klassOop that's not itself: one implementor.
 //     Itsef: more than one implementors.
+// embedded host klass follows here
+//   The embedded host klass only exists in an anonymous class for
+//   dynamic language support (JSR 292 enabled). The host class grants
+//   its access privileges to this class also. The host class is either
+//   named, or a previously loaded anonymous class. A non-anonymous class
+//   or an anonymous class loaded through normal classloading does not
+//   have this embedded field.
+//
 friend class instanceKlassKlass;
 friend class SystemDictionary;
 public:
-bool has_nonstatic_fields() const        { return _has_nonstatic_fields; }
+bool has_nonstatic_fields() const        {
-void set_has_nonstatic_fields(bool b)    { _has_nonstatic_fields = b; }
+return (_misc_flags & _misc_has_nonstatic_fields) != 0;
+}
+void set_has_nonstatic_fields(bool b)    {
+if (b) {
+_misc_flags |= _misc_has_nonstatic_fields;
+} else {
+_misc_flags &= ~_misc_has_nonstatic_fields;
+}
+}
 // field sizes
 int nonstatic_field_size() const         { return _nonstatic_field_size; }
 void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 bool is_not_initialized() const          { return _init_state <  being_initialized; }
 bool is_being_initialized() const        { return _init_state == being_initialized; }
 bool is_in_error_state() const           { return _init_state == initialization_error; }
 bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 ClassState  init_state()                 { return (ClassState)_init_state; }
-bool is_rewritten() const                { return _rewritten; }
+bool is_rewritten() const                { return (_misc_flags & _misc_rewritten) != 0; }
 // defineClass specified verification
-bool should_verify_class() const         { return _should_verify_class; }
+bool should_verify_class() const         {
-void set_should_verify_class(bool value) { _should_verify_class = value; }
+return (_misc_flags & _misc_should_verify_class) != 0;
+}
+void set_should_verify_class(bool value) {
+if (value) {
+_misc_flags |= _misc_should_verify_class;
+} else {
+_misc_flags &= ~_misc_should_verify_class;
+}
+}
 // marking
 bool is_marked_dependent() const         { return _is_marked_dependent; }
 void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
 // protection domain
 oop protection_domain()                  { return _protection_domain; }
 void set_protection_domain(oop pd)       { oop_store((oop*) &_protection_domain, pd); }
 // host class
-oop host_klass() const                   { return _host_klass; }
+oop host_klass() const                   {
-void set_host_klass(oop host)            { oop_store((oop*) &_host_klass, host); }
+oop* hk = adr_host_klass();
-bool is_anonymous() const                { return _host_klass != NULL; }
+if (hk == NULL) {
+return NULL;
+} else {
+return *hk;
+}
+}
+void set_host_klass(oop host)            {
+assert(is_anonymous(), "not anonymous");
+oop* addr = adr_host_klass();
+assert(addr != NULL, "no reversed space");
+oop_store(addr, host);
+}
+bool is_anonymous() const                {
+return (_misc_flags & _misc_is_anonymous) != 0;
+}
+void set_is_anonymous(bool value)        {
+if (value) {
+_misc_flags |= _misc_is_anonymous;
+} else {
+_misc_flags &= ~_misc_is_anonymous;
+}
+}
 // signers
 objArrayOop signers() const              { return _signers; }
 void set_signers(objArrayOop s)          { oop_store((oop*) &_signers, oop(s)); }
 bool implements_interface(klassOop k) const;
 // Access to the implementor of an interface.
 klassOop implementor() const
 {
-klassOop* k = start_of_implementor();
+klassOop* k = (klassOop*)adr_implementor();
 if (k == NULL) {
 return NULL;
 } else {
 return *k;
 }
 }
 void set_implementor(klassOop k) {
 assert(is_interface(), "not interface");
-oop* addr = (oop*)start_of_implementor();
+oop* addr = adr_implementor();
 oop_store_without_check(addr, k);
 }
 int  nof_implementors() const       {
 klassOop k = implementor();
 int object_size() const
 {
 return object_size(align_object_offset(vtable_length()) +
 align_object_offset(itable_length()) +
-(is_interface() ?
+((is_interface() || is_anonymous()) ?
-(align_object_offset(nonstatic_oop_map_size()) + (int)sizeof(klassOop)/HeapWordSize) :
+align_object_offset(nonstatic_oop_map_size()) :
-nonstatic_oop_map_size()));
+nonstatic_oop_map_size()) +
+(is_interface() ? (int)sizeof(klassOop)/HeapWordSize : 0) +
+(is_anonymous() ? (int)sizeof(klassOop)/HeapWordSize : 0));
 }
 static int vtable_start_offset()    { return header_size(); }
 static int vtable_length_offset()   { return oopDesc::header_size() + offset_of(instanceKlass, _vtable_len) / HeapWordSize; }
 static int object_size(int extra)   { return align_object_size(header_size() + extra); }
 OopMapBlock* start_of_nonstatic_oop_maps() const {
 return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length()));
 }
-klassOop* start_of_implementor() const {
+oop* adr_implementor() const {
 if (is_interface()) {
-return (klassOop*)(start_of_nonstatic_oop_maps() +
+return (oop*)(start_of_nonstatic_oop_maps() +
 nonstatic_oop_map_count());
 } else {
 return NULL;
 }
 };
+oop* adr_host_klass() const {
+if (is_anonymous()) {
+oop* adr_impl = adr_implementor();
+if (adr_impl != NULL) {
+return adr_impl + 1;
+} else {
+return (oop*)(start_of_nonstatic_oop_maps() +
+nonstatic_oop_map_count());
+}
+} else {
+return NULL;
+}
+}
 // Allocation profiling support
 juint alloc_size() const            { return _alloc_count * size_helper(); }
 void set_alloc_size(juint n)        {}
 #ifdef ASSERT
 void set_init_state(ClassState state);
 #else
 void set_init_state(ClassState state) { _init_state = (u1)state; }
 #endif
-void set_rewritten()                  { _rewritten = true; }
+void set_rewritten()                  { _misc_flags |= _misc_rewritten; }
 void set_init_thread(Thread *thread)  { _init_thread = thread; }
 u2 idnum_allocated_count() const      { return _idnum_allocated_count; }
 // The RedefineClasses() API can cause new method idnums to be needed
 // which will cause the caches to grow. Safety requires different
 oop* adr_transitive_interfaces() const  { return (oop*)&this->_transitive_interfaces;}
 oop* adr_fields() const            { return (oop*)&this->_fields;}
 oop* adr_constants() const         { return (oop*)&this->_constants;}
 oop* adr_class_loader() const      { return (oop*)&this->_class_loader;}
 oop* adr_protection_domain() const { return (oop*)&this->_protection_domain;}
-oop* adr_host_klass() const        { return (oop*)&this->_host_klass;}
 oop* adr_signers() const           { return (oop*)&this->_signers;}
 oop* adr_inner_classes() const     { return (oop*)&this->_inner_classes;}
-oop* adr_implementor() const       { return (oop*)start_of_implementor(); }
 oop* adr_methods_jmethod_ids() const             { return (oop*)&this->_methods_jmethod_ids;}
 oop* adr_methods_cached_itable_indices() const   { return (oop*)&this->_methods_cached_itable_indices;}
 oop* adr_class_annotations() const   { return (oop*)&this->_class_annotations;}
 oop* adr_fields_annotations() const  { return (oop*)&this->_fields_annotations;}
 oop* adr_methods_annotations() const { return (oop*)&this->_methods_annotations;}

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/oops/instanceKlass.hpp @ 6038:8bafad97cd26