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

comparison src/share/vm/oops/instanceKlass.hpp @ 4137:04b9a2566eec

Merge with hsx23/hotspot.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sat, 17 Dec 2011 21:40:27 +0100
parents	f198b24093f3 f6f3bb0ee072
children	33df1aeaebbf

comparison

equal deleted inserted replaced

-:9dc19b7d89a3
+:04b9a2566eec
 #ifndef SHARE_VM_OOPS_INSTANCEKLASS_HPP
 #define SHARE_VM_OOPS_INSTANCEKLASS_HPP
 #include "oops/constMethodOop.hpp"
 #include "oops/constantPoolOop.hpp"
+#include "oops/fieldInfo.hpp"
 #include "oops/instanceOop.hpp"
 #include "oops/klassOop.hpp"
 #include "oops/klassVtable.hpp"
 #include "oops/objArrayOop.hpp"
 #include "runtime/handles.hpp"
 // (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
 int             _static_oop_field_count;// number of static oop fields in this klass
 int             _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
+int             _java_fields_count;    // The number of declared Java fields
 bool            _is_marked_dependent;  // used for marking during flushing and deoptimization
 bool            _rewritten;            // methods rewritten.
 bool            _has_nonstatic_fields; // for sizing with UseCompressedOops
 bool            _should_verify_class;  // allow caching of preverification
 u2              _minor_version;        // minor version number of class file
 objArrayOop local_interfaces() const          { return _local_interfaces; }
 void set_local_interfaces(objArrayOop a)      { oop_store_without_check((oop*) &_local_interfaces, (oop) a); }
 objArrayOop transitive_interfaces() const     { return _transitive_interfaces; }
 void set_transitive_interfaces(objArrayOop a) { oop_store_without_check((oop*) &_transitive_interfaces, (oop) a); }
-// fields
+private:
-// Field info extracted from the class file and stored
+friend class fieldDescriptor;
-// as an array of 7 shorts
+FieldInfo* field(int index) const { return FieldInfo::from_field_array(_fields, index); }
-enum FieldOffset {
-access_flags_offset    = 0,
+public:
-name_index_offset      = 1,
+int     field_offset      (int index) const { return field(index)->offset(); }
-signature_index_offset = 2,
+int     field_access_flags(int index) const { return field(index)->access_flags(); }
-initval_index_offset   = 3,
+Symbol* field_name        (int index) const { return field(index)->name(constants()); }
-low_offset             = 4,
+Symbol* field_signature   (int index) const { return field(index)->signature(constants()); }
-high_offset            = 5,
-generic_signature_offset = 6,
+// Number of Java declared fields
-next_offset            = 7
+int java_fields_count() const           { return _java_fields_count; }
-};
+// Number of fields including any injected fields
+int all_fields_count() const            { return _fields->length() / sizeof(FieldInfo::field_slots); }
 typeArrayOop fields() const              { return _fields; }
-int offset_from_fields( int index ) const {
-return build_int_from_shorts( fields()->ushort_at(index + low_offset),
+void set_fields(typeArrayOop f, int java_fields_count) {
-fields()->ushort_at(index + high_offset) );
+oop_store_without_check((oop*) &_fields, (oop) f);
-}
+_java_fields_count = java_fields_count;
+}
-void set_fields(typeArrayOop f)          { oop_store_without_check((oop*) &_fields, (oop) f); }
 // inner classes
 typeArrayOop inner_classes() const       { return _inner_classes; }
 void set_inner_classes(typeArrayOop f)   { oop_store_without_check((oop*) &_inner_classes, (oop) f); }
 bool is_dependent_nmethod(nmethod* nm);
 // Verification
 const char* internal_name() const;
 void oop_verify_on(oop obj, outputStream* st);
-#ifndef PRODUCT
-static void verify_class_klass_nonstatic_oop_maps(klassOop k) PRODUCT_RETURN;
-#endif
 };
 inline methodOop instanceKlass::method_at_vtable(int index)  {
 #ifndef PRODUCT
 assert(index >= 0, "valid vtable index");
 // 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();
 };
+//
+// nmethodBucket is used to record dependent nmethods for
+// deoptimization.  nmethod dependencies are actually <klass, method>
+// pairs but we really only care about the klass part for purposes of
+// finding nmethods which might need to be deoptimized.  Instead of
+// recording the method, a count of how many times a particular nmethod
+// was recorded is kept.  This ensures that any recording errors are
+// noticed since an nmethod should be removed as many times are it's
+// added.
+//
+class nmethodBucket: public CHeapObj {
+friend class VMStructs;
+private:
+nmethod*       _nmethod;
+int            _count;
+nmethodBucket* _next;
+public:
+nmethodBucket(nmethod* nmethod, nmethodBucket* next) {
+_nmethod = nmethod;
+_next = next;
+_count = 1;
+}
+int count()                             { return _count; }
+int increment()                         { _count += 1; return _count; }
+int decrement()                         { _count -= 1; assert(_count >= 0, "don't underflow"); return _count; }
+nmethodBucket* next()                   { return _next; }
+void set_next(nmethodBucket* b)         { _next = b; }
+nmethod* get_nmethod()                  { return _nmethod; }
+};
 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP

Mercurial > hg > truffle

comparison src/share/vm/oops/instanceKlass.hpp @ 4137:04b9a2566eec