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

equal deleted inserted replaced

-:45b520adf92d
+:e148e499e5cd
 #include "memory/universe.inline.hpp"
 #include "prims/jvmtiGetLoadedClasses.hpp"
 #include "runtime/thread.hpp"
+// The closure for GetLoadedClasses
-// The closure for GetLoadedClasses and GetClassLoaderClasses
+class LoadedClassesClosure : public KlassClosure {
+private:
+Stack<jclass, mtInternal> _classStack;
+JvmtiEnv* _env;
+public:
+LoadedClassesClosure(JvmtiEnv* env) {
+_env = env;
+}
+void do_klass(Klass* k) {
+// Collect all jclasses
+_classStack.push((jclass) _env->jni_reference(k->java_mirror()));
+}
+int extract(jclass* result_list) {
+// The size of the Stack will be 0 after extract, so get it here
+int count = (int)_classStack.size();
+int i = count;
+// Pop all jclasses, fill backwards
+while (!_classStack.is_empty()) {
+result_list[--i] = _classStack.pop();
+}
+// Return the number of elements written
+return count;
+}
+// Return current size of the Stack
+int get_count() {
+return (int)_classStack.size();
+}
+};
+// The closure for GetClassLoaderClasses
 class JvmtiGetLoadedClassesClosure : public StackObj {
 // Since the SystemDictionary::classes_do callback
 // doesn't pass a closureData pointer,
 // we use a thread-local slot to hold a pointer to
 // a stack allocated instance of this structure.
 for (int index = 0; index < _count; index += 1) {
 result[index] = (jclass) env->jni_reference(get_element(index));
 }
 }
-// Finally, the static methods that are the callbacks
-static void increment(Klass* k) {
-JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
-if (that->get_initiatingLoader() == NULL) {
-for (Klass* l = k; l != NULL; l = 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 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()) {
 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 add(Klass* k) {
-JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this();
-if (that->available()) {
-if (that->get_initiatingLoader() == NULL) {
-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);
-}
-} else if (k != NULL) {
-// if initiating loader not null, just include the instance with 1 dimension
-oop mirror = k->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();
 };
 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,
+LoadedClassesClosure closure(env);
-// 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
+// array classes aren't created.
-// classes aren't added to the system dictionary,
 MutexLocker ma(MultiArray_lock);
-MutexLocker sd(SystemDictionary_lock);
+// Iterate through all classes in ClassLoaderDataGraph
-// First, count the classes
+// and collect them using the LoadedClassesClosure
-SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::increment);
+ClassLoaderDataGraph::loaded_classes_do(&closure);
-Universe::basic_type_classes_do(&JvmtiGetLoadedClassesClosure::increment);
+}
-// Next, fill in the classes
-closure.allocate();
+// Return results by extracting the collected contents into a list
-SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::add);
+// allocated via JvmtiEnv
-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),
+jvmtiError error = env->Allocate(closure.get_count() * sizeof(jclass),
 (unsigned char**)&result_list);
-if (err != JVMTI_ERROR_NONE) {
-return err;
+if (error == JVMTI_ERROR_NONE) {
-}
+int count = closure.extract(result_list);
-closure.extract(env, result_list);
+*classCountPtr = count;
-*classCountPtr = closure.get_count();
+*classesPtr = result_list;
-*classesPtr = result_list;
+}
-return JVMTI_ERROR_NONE;
+return error;
 }
 jvmtiError
 JvmtiGetLoadedClasses::getClassLoaderClasses(JvmtiEnv *env, jobject initiatingLoader,
 jint* classCountPtr, jclass** classesPtr) {

changeset 21183	e148e499e5cd
parent 14488	ab48109f7d1b
child 22234	da823d78ad65