jdk-sandbox: comparison hotspot/src/share/vm/prims/jvmtiTagMap.cpp

equal deleted inserted replaced

-:6061df52d610
+:53ccc37bda19
 // add a field
 void add(int index, char type, int offset);
 // returns the field count for the given class
-static int compute_field_count(instanceKlassHandle ikh);
+static int compute_field_count(InstanceKlass* ik);
 public:
 ~ClassFieldMap();
 // access
 // Returns a heap allocated ClassFieldMap to describe the static fields
 // of the given class.
 //
 ClassFieldMap* ClassFieldMap::create_map_of_static_fields(Klass* k) {
 HandleMark hm;
-instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
+InstanceKlass* ik = InstanceKlass::cast(k);
 // create the field map
 ClassFieldMap* field_map = new ClassFieldMap();
-FilteredFieldStream f(ikh, false, false);
+FilteredFieldStream f(ik, false, false);
 int max_field_index = f.field_count()-1;
 int index = 0;
-for (FilteredFieldStream fld(ikh, true, true); !fld.eos(); fld.next(), index++) {
+for (FilteredFieldStream fld(ik, true, true); !fld.eos(); fld.next(), index++) {
 // ignore instance fields
 if (!fld.access_flags().is_static()) {
 continue;
 }
 field_map->add(max_field_index - index, fld.signature()->byte_at(0), fld.offset());
 // of the given class. All instance fields are included (this means public
 // and private fields declared in superclasses and superinterfaces too).
 //
 ClassFieldMap* ClassFieldMap::create_map_of_instance_fields(oop obj) {
 HandleMark hm;
-instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), obj->klass());
+InstanceKlass* ik = InstanceKlass::cast(obj->klass());
 // create the field map
 ClassFieldMap* field_map = new ClassFieldMap();
-FilteredFieldStream f(ikh, false, false);
+FilteredFieldStream f(ik, false, false);
 int max_field_index = f.field_count()-1;
 int index = 0;
-for (FilteredFieldStream fld(ikh, false, false); !fld.eos(); fld.next(), index++) {
+for (FilteredFieldStream fld(ik, false, false); !fld.eos(); fld.next(), index++) {
 // ignore static fields
 if (fld.access_flags().is_static()) {
 continue;
 }
 field_map->add(max_field_index - index, fld.signature()->byte_at(0), fld.offset());
 }
 return false;
 }
 // helper function to indicate if an object is filtered by a klass filter
-static inline bool is_filtered_by_klass_filter(oop obj, KlassHandle klass_filter) {
+static inline bool is_filtered_by_klass_filter(oop obj, Klass* klass_filter) {
-if (!klass_filter.is_null()) {
+if (klass_filter != NULL) {
-if (obj->klass() != klass_filter()) {
+if (obj->klass() != klass_filter) {
 return true;
 }
 }
 return false;
 }
 // An ObjectClosure used to support the deprecated IterateOverHeap and
 // IterateOverInstancesOfClass functions
 class IterateOverHeapObjectClosure: public ObjectClosure {
 private:
 JvmtiTagMap* _tag_map;
-KlassHandle _klass;
+Klass* _klass;
 jvmtiHeapObjectFilter _object_filter;
 jvmtiHeapObjectCallback _heap_object_callback;
 const void* _user_data;
 // accessors
 JvmtiTagMap* tag_map() const                    { return _tag_map; }
 jvmtiHeapObjectFilter object_filter() const     { return _object_filter; }
 jvmtiHeapObjectCallback object_callback() const { return _heap_object_callback; }
-KlassHandle klass() const                       { return _klass; }
+Klass* klass() const                            { return _klass; }
 const void* user_data() const                   { return _user_data; }
 // indicates if iteration has been aborted
 bool _iteration_aborted;
 bool is_iteration_aborted() const               { return _iteration_aborted; }
 void set_iteration_aborted(bool aborted)        { _iteration_aborted = aborted; }
 public:
 IterateOverHeapObjectClosure(JvmtiTagMap* tag_map,
-KlassHandle klass,
+Klass* klass,
 jvmtiHeapObjectFilter object_filter,
 jvmtiHeapObjectCallback heap_object_callback,
 const void* user_data) :
 _tag_map(tag_map),
 _klass(klass),
 // ignore any objects that aren't visible to profiler
 if (!ServiceUtil::visible_oop(o)) return;
 // instanceof check when filtering by klass
-if (!klass().is_null() && !o->is_a(klass()())) {
+if (klass() != NULL && !o->is_a(klass())) {
 return;
 }
 // prepare for the calllback
 CallbackWrapper wrapper(tag_map(), o);
 // An ObjectClosure used to support the IterateThroughHeap function
 class IterateThroughHeapObjectClosure: public ObjectClosure {
 private:
 JvmtiTagMap* _tag_map;
-KlassHandle _klass;
+Klass* _klass;
 int _heap_filter;
 const jvmtiHeapCallbacks* _callbacks;
 const void* _user_data;
 // accessor functions
 JvmtiTagMap* tag_map() const                     { return _tag_map; }
 int heap_filter() const                          { return _heap_filter; }
 const jvmtiHeapCallbacks* callbacks() const      { return _callbacks; }
-KlassHandle klass() const                        { return _klass; }
+Klass* klass() const                             { return _klass; }
 const void* user_data() const                    { return _user_data; }
 // indicates if the iteration has been aborted
 bool _iteration_aborted;
 bool is_iteration_aborted() const                { return _iteration_aborted; }
 return is_abort;
 }
 public:
 IterateThroughHeapObjectClosure(JvmtiTagMap* tag_map,
-KlassHandle klass,
+Klass* klass,
 int heap_filter,
 const jvmtiHeapCallbacks* heap_callbacks,
 const void* user_data) :
 _tag_map(tag_map),
 _klass(klass),
 };
 // Deprecated function to iterate over all objects in the heap
 void JvmtiTagMap::iterate_over_heap(jvmtiHeapObjectFilter object_filter,
-KlassHandle klass,
+Klass* klass,
 jvmtiHeapObjectCallback heap_object_callback,
 const void* user_data)
 {
 MutexLocker ml(Heap_lock);
 IterateOverHeapObjectClosure blk(this,
 }
 // Iterates over all objects in the heap
 void JvmtiTagMap::iterate_through_heap(jint heap_filter,
-KlassHandle klass,
+Klass* klass,
 const jvmtiHeapCallbacks* callbacks,
 const void* user_data)
 {
 MutexLocker ml(Heap_lock);
 IterateThroughHeapObjectClosure blk(this,
 // The advanced heap walk context for the FollowReferences functions.
 // The context is the callbacks, and the fields used for filtering.
 class AdvancedHeapWalkContext: public HeapWalkContext {
 private:
 jint _heap_filter;
-KlassHandle _klass_filter;
+Klass* _klass_filter;
 const jvmtiHeapCallbacks* _heap_callbacks;
 public:
 AdvancedHeapWalkContext() : HeapWalkContext(false) { }
 AdvancedHeapWalkContext(jint heap_filter,
-KlassHandle klass_filter,
+Klass* klass_filter,
 const jvmtiHeapCallbacks* heap_callbacks) :
 HeapWalkContext(true),
 _heap_filter(heap_filter),
 _klass_filter(klass_filter),
 _heap_callbacks(heap_callbacks) {
 }
 // accessors
 jint heap_filter() const         { return _heap_filter; }
-KlassHandle klass_filter() const { return _klass_filter; }
+Klass* klass_filter() const      { return _klass_filter; }
 const jvmtiHeapReferenceCallback heap_reference_callback() const {
 return _heap_callbacks->heap_reference_callback;
 };
 const jvmtiPrimitiveFieldCallback primitive_field_callback() const {
 VMThread::execute(&op);
 }
 // follow references from an initial object or the GC roots
 void JvmtiTagMap::follow_references(jint heap_filter,
-KlassHandle klass,
+Klass* klass,
 jobject object,
 const jvmtiHeapCallbacks* callbacks,
 const void* user_data)
 {
 oop obj = JNIHandles::resolve(object);

changeset 46329	53ccc37bda19
parent 43944	23334f30b9b2