< prev index next >

src/share/vm/prims/jvmtiTagMap.cpp

Print this page

        

@@ -780,11 +780,11 @@
 
   // 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

@@ -816,20 +816,20 @@
 // 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());

@@ -841,21 +841,21 @@
 // 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());

@@ -1005,13 +1005,13 @@
   }
   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) {
-  if (!klass_filter.is_null()) {
-    if (obj->klass() != klass_filter()) {
+static inline bool is_filtered_by_klass_filter(oop obj, Klass* klass_filter) {
+  if (klass_filter != NULL) {
+    if (obj->klass() != klass_filter) {
       return true;
     }
   }
   return false;
 }

@@ -1269,30 +1269,30 @@
 // 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),

@@ -1313,11 +1313,11 @@
 
   // 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);
 

@@ -1342,20 +1342,20 @@
 
 // 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; }

@@ -1371,11 +1371,11 @@
     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),

@@ -1467,11 +1467,11 @@
 };
 
 
 // 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,

@@ -1484,11 +1484,11 @@
 }
 
 
 // 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,

@@ -1795,28 +1795,28 @@
 // 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 {

@@ -3285,11 +3285,11 @@
   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);
< prev index next >