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

comparison src/share/vm/oops/instanceKlass.hpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	6b0fd0964b87 0f37d1badced
children	096c224171c4

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 // 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.
 Array<jushort>* _inner_classes;
-// Name of source file containing this klass, NULL if not specified.
-Symbol*         _source_file_name;
 // the source debug extension for this klass, NULL if not specified.
 // Specified as UTF-8 string without terminating zero byte in the classfile,
 // it is stored in the instanceklass as a NULL-terminated UTF-8 string
 char*           _source_debug_extension;
-// Generic signature, or null if none.
-Symbol*         _generic_signature;
 // Array name derived from this class which needs unreferencing
 // if this class is unloaded.
 Symbol*         _array_name;
 // Number of heapOopSize words used by non-static fields in this klass
 // (including inherited fields but after header_size()).
 int             _nonstatic_field_size;
 int             _static_field_size;    // number words used by static fields (oop and non-oop) in this klass
+// Constant pool index to the utf8 entry of the Generic signature,
+// or 0 if none.
+u2              _generic_signature_index;
+// Constant pool index to the utf8 entry for the name of source file
+// containing this klass, 0 if not specified.
+u2              _source_file_name_index;
 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
 // _is_marked_dependent can be set concurrently, thus cannot be part of the
 int             _itable_len;           // length of Java itable (in words)
 OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
 MemberNameTable* _member_names;        // Member names
 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
 nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
 BreakpointInfo* _breakpoints;          // bpt lists, managed by Method*
 // Array of interesting part(s) of the previous version(s) of this
 // InstanceKlass. See PreviousVersionWalker below.
 _misc_flags &= ~_misc_is_contended;
 }
 }
 // source file name
-Symbol* source_file_name() const         { return _source_file_name; }
+Symbol* source_file_name() const               {
-void set_source_file_name(Symbol* n);
+return (_source_file_name_index == 0) ?
+(Symbol*)NULL : _constants->symbol_at(_source_file_name_index);
+}
+u2 source_file_name_index() const              {
+return _source_file_name_index;
+}
+void set_source_file_name_index(u2 sourcefile_index) {
+_source_file_name_index = sourcefile_index;
+}
 // minor and major version numbers of class file
 u2 minor_version() const                 { return _minor_version; }
 void set_minor_version(u2 minor_version) { _minor_version = minor_version; }
 u2 major_version() const                 { return _major_version; }
 // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
 inline u2 next_method_idnum();
 void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }
 // generics support
-Symbol* generic_signature() const                   { return _generic_signature; }
+Symbol* generic_signature() const                   {
-void set_generic_signature(Symbol* sig)             { _generic_signature = sig; }
+return (_generic_signature_index == 0) ?
+(Symbol*)NULL : _constants->symbol_at(_generic_signature_index);
+}
+u2 generic_signature_index() const                  {
+return _generic_signature_index;
+}
+void set_generic_signature_index(u2 sig_index)      {
+_generic_signature_index = sig_index;
+}
 u2 enclosing_method_data(int offset);
 u2 enclosing_method_class_index() {
 return enclosing_method_data(enclosing_method_class_index_offset);
 }
 jmethodID* to_dealloc_id_p,
 jmethodID** to_dealloc_jmeths_p);
 static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum,
 size_t *length_p, jmethodID* id_p);
 jmethodID jmethod_id_or_null(Method* method);
-// cached itable index support
-void set_cached_itable_index(size_t idnum, int index);
-int cached_itable_index(size_t idnum);
 // annotations support
 Annotations* annotations() const          { return _annotations; }
 void set_annotations(Annotations* anno)   { _annotations = anno; }
 bool idnum_can_increment() const      { return has_been_redefined(); }
 jmethodID* methods_jmethod_ids_acquire() const
 { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); }
 void release_set_methods_jmethod_ids(jmethodID* jmeths)
 { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); }
-int* methods_cached_itable_indices_acquire() const
-{ return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); }
-void release_set_methods_cached_itable_indices(int* indices)
-{ OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); }
 // Lock during initialization
 public:
 // Lock for (1) initialization; (2) access to the ConstantPool of this class.
 // Must be one per class and it has to be a VM internal object so java code
 class BreakpointInfo;
 // A collection point for interesting information about the previous
-// version(s) of an InstanceKlass. This class uses weak references to
+// version(s) of an InstanceKlass.  A GrowableArray of PreviousVersionNodes
-// the information so that the information may be collected as needed
+// is attached to the InstanceKlass as needed. See PreviousVersionWalker below.
-// by the system. If the information is shared, then a regular
-// reference must be used because a weak reference would be seen as
-// collectible. A GrowableArray of PreviousVersionNodes is attached
-// to the InstanceKlass as needed. See PreviousVersionWalker below.
 class PreviousVersionNode : public CHeapObj<mtClass> {
 private:
-// A shared ConstantPool is never collected so we'll always have
+ConstantPool*    _prev_constant_pool;
-// a reference to it so we can update items in the cache. We'll
-// have a weak reference to a non-shared ConstantPool until all
-// of the methods (EMCP or obsolete) have been collected; the
-// non-shared ConstantPool becomes collectible at that point.
-ConstantPool*    _prev_constant_pool;  // regular or weak reference
-bool    _prev_cp_is_weak;     // true if not a shared ConstantPool
 // If the previous version of the InstanceKlass doesn't have any
 // EMCP methods, then _prev_EMCP_methods will be NULL. If all the
 // EMCP methods have been collected, then _prev_EMCP_methods can
 // have a length of zero.
 GrowableArray<Method*>* _prev_EMCP_methods;
 public:
-PreviousVersionNode(ConstantPool* prev_constant_pool, bool prev_cp_is_weak,
+PreviousVersionNode(ConstantPool* prev_constant_pool,
 GrowableArray<Method*>* prev_EMCP_methods);
 ~PreviousVersionNode();
 ConstantPool* prev_constant_pool() const {
 return _prev_constant_pool;
 }
 GrowableArray<Method*>* prev_EMCP_methods() const {
 return _prev_EMCP_methods;
 }
 };
-// A Handle-ized version of PreviousVersionNode.
+// Helper object for walking previous versions.
-class PreviousVersionInfo : public ResourceObj {
-private:
-constantPoolHandle   _prev_constant_pool_handle;
-// If the previous version of the InstanceKlass doesn't have any
-// EMCP methods, then _prev_EMCP_methods will be NULL. Since the
-// methods cannot be collected while we hold a handle,
-// _prev_EMCP_methods should never have a length of zero.
-GrowableArray<methodHandle>* _prev_EMCP_method_handles;
-public:
-PreviousVersionInfo(PreviousVersionNode *pv_node);
-~PreviousVersionInfo();
-constantPoolHandle prev_constant_pool_handle() const {
-return _prev_constant_pool_handle;
-}
-GrowableArray<methodHandle>* prev_EMCP_method_handles() const {
-return _prev_EMCP_method_handles;
-}
-};
-// Helper object for walking previous versions. This helper cleans up
-// the Handles that it allocates when the helper object is destroyed.
-// The PreviousVersionInfo object returned by next_previous_version()
-// is only valid until a subsequent call to next_previous_version() or
-// the helper object is destroyed.
 class PreviousVersionWalker : public StackObj {
 private:
+Thread*                               _thread;
 GrowableArray<PreviousVersionNode *>* _previous_versions;
 int                                   _current_index;
-// Fields for cleaning up when we are done walking the previous versions:
-// A HandleMark for the PreviousVersionInfo handles:
+// A pointer to the current node object so we can handle the deletes.
-HandleMark                            _hm;
+PreviousVersionNode*                  _current_p;
-// It would be nice to have a ResourceMark field in this helper also,
+// The constant pool handle keeps all the methods in this class from being
-// but the ResourceMark code says to be careful to delete handles held
+// deallocated from the metaspace during class unloading.
-// in GrowableArrays _before_ deleting the GrowableArray. Since we
+constantPoolHandle                    _current_constant_pool_handle;
-// can't guarantee the order in which the fields are destroyed, we
-// have to let the creator of the PreviousVersionWalker object do
-// the right thing. Also, adding a ResourceMark here causes an
-// include loop.
-// A pointer to the current info object so we can handle the deletes.
-PreviousVersionInfo *                 _current_p;
 public:
-PreviousVersionWalker(InstanceKlass *ik);
+PreviousVersionWalker(Thread* thread, InstanceKlass *ik);
-~PreviousVersionWalker();
 // Return the interesting information for the next previous version
 // of the klass. Returns NULL if there are no more previous versions.
-PreviousVersionInfo* next_previous_version();
+PreviousVersionNode* next_previous_version();
 };
 //
 // nmethodBucket is used to record dependent nmethods for

Mercurial > hg > truffle

comparison src/share/vm/oops/instanceKlass.hpp @ 12355:cefad50507d8