truffle: src/share/vm/oops/instanceKlass.hpp comparison

comparison src/share/vm/oops/instanceKlass.hpp @ 6152:958bb4b7be49

Merge

author	asaha
date	Tue, 10 Apr 2012 10:42:34 -0700
parents	f7c4174b33ba
children	49036505ab5f c7ed11779ce8

comparison

equal deleted inserted replaced

-:e778c29768e6
+:958bb4b7be49
 // 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;
-// inner_classes attribute.
+// 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
+// [inner_class_info_index, outer_class_info_index,
+// inner_name_index, inner_class_access_flags] for the InnerClasses
+// attribute. If the EnclosingMethod attribute exists, it occupies the
+// last two shorts [class_index, method_index] of the array. If only
+// the InnerClasses attribute exists, the _inner_classes array length is
+// number_of_inner_classes * 4. If the class has both InnerClasses
+// and EnclosingMethod attributes the _inner_classes array length is
+// number_of_inner_classes * 4 + enclosing_method_attribute_size.
 typeArrayOop    _inner_classes;
 // Implementors of this interface (not valid if it overflows)
 klassOop        _implementors[implementors_limit];
 // Annotations for this class, or null if none.
 typeArrayOop    _class_annotations;
 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)
-ReferenceType   _reference_type;       // reference type
 OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
 JNIid*          _jni_ids;              // First JNI identifier for static fields in this class
 jmethodID*      _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or NULL if none
 int*            _methods_cached_itable_indices;  // itable_index cache for JNI invoke corresponding to methods idnum, or NULL
 nmethodBucket*  _dependencies;         // list of dependent nmethods
 BreakpointInfo* _breakpoints;          // bpt lists, managed by methodOop
 int             _nof_implementors;     // No of implementors of this interface (zero if not an interface)
 // Array of interesting part(s) of the previous version(s) of this
 // instanceKlass. See PreviousVersionWalker below.
 GrowableArray<PreviousVersionNode *>* _previous_versions;
-u2              _enclosing_method_class_index;  // Constant pool index for class of enclosing method, or 0 if none
-u2              _enclosing_method_method_index; // Constant pool index for name and type of enclosing method, or 0 if none
 // JVMTI fields can be moved to their own structure - see 6315920
 unsigned char * _cached_class_file_bytes;       // JVMTI: cached class file, before retransformable agent modified it in CFLH
 jint            _cached_class_file_len;         // JVMTI: length of above
 JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
 volatile u2     _idnum_allocated_count;         // JNI/JVMTI: increments with the addition of methods, old ids don't change
 // Class states are defined as ClassState (see above).
 // Place the _init_state here to utilize the unused 2-byte after
 // _idnum_allocated_count.
 u1              _init_state;                    // state of class
+u1              _reference_type;                // reference type
 // embedded Java vtable follows here
 // embedded Java itables follows here
 // embedded static fields follows here
 // embedded nonstatic oop-map blocks follows here
 inner_class_inner_class_info_offset = 0,
 inner_class_outer_class_info_offset = 1,
 inner_class_inner_name_offset = 2,
 inner_class_access_flags_offset = 3,
 inner_class_next_offset = 4
+};
+enum EnclosingMethodAttributeOffset {
+enclosing_method_class_index_offset = 0,
+enclosing_method_method_index_offset = 1,
+enclosing_method_attribute_size = 2
 };
 // method override check
 bool is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS);
 // set the class to initialized if no static initializer is present
 void eager_initialize(Thread *thread);
 // reference type
-ReferenceType reference_type() const     { return _reference_type; }
+ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
-void set_reference_type(ReferenceType t) { _reference_type = t; }
+void set_reference_type(ReferenceType t) {
+assert(t == (u1)t, "overflow");
+_reference_type = (u1)t;
+}
 static ByteSize reference_type_offset() { return in_ByteSize(sizeof(klassOopDesc) + offset_of(instanceKlass, _reference_type)); }
 // find local field, returns true if found
 bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 // generics support
 Symbol* generic_signature() const                   { return _generic_signature; }
 void set_generic_signature(Symbol* sig)             { _generic_signature = sig; }
-u2 enclosing_method_class_index() const             { return _enclosing_method_class_index; }
+u2 enclosing_method_data(int offset);
-u2 enclosing_method_method_index() const            { return _enclosing_method_method_index; }
+u2 enclosing_method_class_index() {
+return enclosing_method_data(enclosing_method_class_index_offset);
+}
+u2 enclosing_method_method_index() {
+return enclosing_method_data(enclosing_method_method_index_offset);
+}
 void set_enclosing_method_indices(u2 class_index,
-u2 method_index)  { _enclosing_method_class_index  = class_index;
+u2 method_index);
-_enclosing_method_method_index = method_index; }
 // jmethodID support
 static jmethodID get_jmethod_id(instanceKlassHandle ik_h,
 methodHandle method_h);
 static jmethodID get_jmethod_id_fetch_or_update(instanceKlassHandle ik_h,
 typeArrayOop get_method_default_annotations_of(int idnum)
 { return get_method_annotations_from(idnum, _methods_default_annotations); }
 void set_method_annotations_of(int idnum, typeArrayOop anno)
 { set_methods_annotations_of(idnum, anno, &_methods_annotations); }
 void set_method_parameter_annotations_of(int idnum, typeArrayOop anno)
-{ set_methods_annotations_of(idnum, anno, &_methods_annotations); }
+{ set_methods_annotations_of(idnum, anno, &_methods_parameter_annotations); }
 void set_method_default_annotations_of(int idnum, typeArrayOop anno)
-{ set_methods_annotations_of(idnum, anno, &_methods_annotations); }
+{ set_methods_annotations_of(idnum, anno, &_methods_default_annotations); }
 // allocation
 DEFINE_ALLOCATE_PERMANENT(instanceKlass);
 instanceOop allocate_instance(TRAPS);
 instanceOop allocate_permanent_instance(TRAPS);
 nmethodBucket* next()                   { return _next; }
 void set_next(nmethodBucket* b)         { _next = b; }
 nmethod* get_nmethod()                  { return _nmethod; }
 };
+// An iterator that's used to access the inner classes indices in the
+// instanceKlass::_inner_classes array.
+class InnerClassesIterator : public StackObj {
+private:
+typeArrayHandle _inner_classes;
+int _length;
+int _idx;
+public:
+InnerClassesIterator(instanceKlassHandle k) {
+_inner_classes = k->inner_classes();
+if (k->inner_classes() != NULL) {
+_length = _inner_classes->length();
+// The inner class array's length should be the multiple of
+// inner_class_next_offset if it only contains the InnerClasses
+// attribute data, or it should be
+// n*inner_class_next_offset+enclosing_method_attribute_size
+// if it also contains the EnclosingMethod data.
+assert((_length % instanceKlass::inner_class_next_offset == 0 ||
+_length % instanceKlass::inner_class_next_offset == instanceKlass::enclosing_method_attribute_size),
+"just checking");
+// Remove the enclosing_method portion if exists.
+if (_length % instanceKlass::inner_class_next_offset == instanceKlass::enclosing_method_attribute_size) {
+_length -= instanceKlass::enclosing_method_attribute_size;
+}
+} else {
+_length = 0;
+}
+_idx = 0;
+}
+int length() const {
+return _length;
+}
+void next() {
+_idx += instanceKlass::inner_class_next_offset;
+}
+bool done() const {
+return (_idx >= _length);
+}
+u2 inner_class_info_index() const {
+return _inner_classes->ushort_at(
+_idx + instanceKlass::inner_class_inner_class_info_offset);
+}
+void set_inner_class_info_index(u2 index) {
+_inner_classes->ushort_at_put(
+_idx + instanceKlass::inner_class_inner_class_info_offset, index);
+}
+u2 outer_class_info_index() const {
+return _inner_classes->ushort_at(
+_idx + instanceKlass::inner_class_outer_class_info_offset);
+}
+void set_outer_class_info_index(u2 index) {
+_inner_classes->ushort_at_put(
+_idx + instanceKlass::inner_class_outer_class_info_offset, index);
+}
+u2 inner_name_index() const {
+return _inner_classes->ushort_at(
+_idx + instanceKlass::inner_class_inner_name_offset);
+}
+void set_inner_name_index(u2 index) {
+_inner_classes->ushort_at_put(
+_idx + instanceKlass::inner_class_inner_name_offset, index);
+}
+u2 inner_access_flags() const {
+return _inner_classes->ushort_at(
+_idx + instanceKlass::inner_class_access_flags_offset);
+}
+};
 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP

Mercurial > hg > truffle

comparison src/share/vm/oops/instanceKlass.hpp @ 6152:958bb4b7be49