C++ JvmtiGetLoadedClassesClosure类代码示例

 // increment the count for the given basic type array class (and any
 // multi-dimensional arrays). For example, for [B we check for
 // [[B, [[[B, .. and the count is incremented for each one that exists.
 static void increment_for_basic_type_arrays(Klass* k) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   assert(that != NULL, "no JvmtiGetLoadedClassesClosure");
   for (Klass* l = k; l != NULL; l = l->array_klass_or_null()) {
     that->set_count(that->get_count() + 1);
   }
 }

 static void prim_array_increment_with_loader(Klass* array, ClassLoaderData* loader_data) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   oop class_loader = loader_data->class_loader();
   if (class_loader == JNIHandles::resolve(that->get_initiatingLoader())) {
     that->set_count(that->get_count() + 1);
   }
 }

 static void increment_with_loader(klassOop k, oop loader) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   if (loader == JNIHandles::resolve(that->get_initiatingLoader())) {
     for (klassOop l = k; l != NULL; l = Klass::cast(l)->array_klass_or_null()) {
       that->set_count(that->get_count() + 1);
     }
   }
 }

 static void increment_with_loader(Klass* k, ClassLoaderData* loader_data) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   oop class_loader = loader_data->class_loader();
   if (class_loader == JNIHandles::resolve(that->get_initiatingLoader())) {
     for (Klass* l = k; l != NULL; l = l->array_klass_or_null()) {
       that->set_count(that->get_count() + 1);
     }
   }
 }

 static void add_with_loader(klassOop k, oop loader) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   if (that->available()) {
     if (loader == JNIHandles::resolve(that->get_initiatingLoader())) {
       for (klassOop l = k; l != NULL; l = Klass::cast(l)->array_klass_or_null()) {
         oop mirror = Klass::cast(l)->java_mirror();
         that->set_element(that->get_index(), mirror);
         that->set_index(that->get_index() + 1);
       }
     }
   }
 }

 static void add_with_loader(Klass* k, ClassLoaderData* loader_data) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   if (that->available()) {
     oop class_loader = loader_data->class_loader();
     if (class_loader == JNIHandles::resolve(that->get_initiatingLoader())) {
       for (Klass* l = k; l != NULL; l = l->array_klass_or_null()) {
         oop mirror = l->java_mirror();
         that->set_element(that->get_index(), mirror);
         that->set_index(that->get_index() + 1);
       }
     }
   }
 }

jvmtiError
JvmtiGetLoadedClasses::getLoadedClasses(JvmtiEnv *env, jint* classCountPtr, jclass** classesPtr) {
  // Since SystemDictionary::classes_do only takes a function pointer
  // and doesn't call back with a closure data pointer,
  // we can only pass static methods.

  JvmtiGetLoadedClassesClosure closure;
  {
    // To get a consistent list of classes we need MultiArray_lock to ensure
    // array classes aren't created, and SystemDictionary_lock to ensure that
    // classes aren't added to the system dictionary,
    MutexLocker ma(MultiArray_lock);
    MutexLocker sd(SystemDictionary_lock);

    // First, count the classes
    SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::increment);
    Universe::basic_type_classes_do(&JvmtiGetLoadedClassesClosure::increment);
    // Next, fill in the classes
    closure.allocate();
    SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::add);
    Universe::basic_type_classes_do(&JvmtiGetLoadedClassesClosure::add);
    // Drop the SystemDictionary_lock, so the results could be wrong from here,
    // but we still have a snapshot.
  }
  // Post results
  jclass* result_list;
  jvmtiError err = env->Allocate(closure.get_count() * sizeof(jclass),
                                 (unsigned char**)&result_list);
  if (err != JVMTI_ERROR_NONE) {
    return err;
  }
  closure.extract(env, result_list);
  *classCountPtr = closure.get_count();
  *classesPtr = result_list;
  return JVMTI_ERROR_NONE;
}

 // add the basic type array class and its multi-dimensional array classes to the list
 static void add_for_basic_type_arrays(Klass* k) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   assert(that != NULL, "no JvmtiGetLoadedClassesClosure");
   assert(that->available(), "no list");
   for (Klass* l = k; l != NULL; l = l->array_klass_or_null()) {
     oop mirror = l->java_mirror();
     that->set_element(that->get_index(), mirror);
     that->set_index(that->get_index() + 1);
   }
 }

 // Finally, the static methods that are the callbacks
 static void increment(klassOop k) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   if (that->get_initiatingLoader() == NULL) {
     for (klassOop l = k; l != NULL; l = Klass::cast(l)->array_klass_or_null()) {
       that->set_count(that->get_count() + 1);
     }
   } else if (k != NULL) {
     // if initiating loader not null, just include the instance with 1 dimension
     that->set_count(that->get_count() + 1);
   }
 }

 static void add(klassOop k) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   if (that->available()) {
     if (that->get_initiatingLoader() == NULL) {
       for (klassOop l = k; l != NULL; l = Klass::cast(l)->array_klass_or_null()) {
         oop mirror = Klass::cast(l)->java_mirror();
         that->set_element(that->get_index(), mirror);
         that->set_index(that->get_index() + 1);
       }
     } else if (k != NULL) {
       // if initiating loader not null, just include the instance with 1 dimension
       oop mirror = Klass::cast(k)->java_mirror();
       that->set_element(that->get_index(), mirror);
       that->set_index(that->get_index() + 1);
     }
   }
 }

 static void prim_array_increment_with_loader(klassOop array, oop loader) {
   JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
   if (loader == JNIHandles::resolve(that->get_initiatingLoader())) {
     that->set_count(that->get_count() + 1);
   }
 }