Mercurial > hg > truffle
view src/share/vm/prims/jvmtiGetLoadedClasses.cpp @ 4409:9f8e4aeec1a9
Merge
author | Andreas Woess <andreas.woess@jku.at> |
---|---|
date | Sun, 29 Jan 2012 11:40:04 +0100 |
parents | f95d63e2154a |
children | d2a62e0f25eb |
line wrap: on
line source
/* * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "precompiled.hpp" #include "classfile/systemDictionary.hpp" #include "memory/universe.inline.hpp" #include "prims/jvmtiGetLoadedClasses.hpp" #include "runtime/thread.hpp" // The closure for GetLoadedClasses and 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. private: jobject _initiatingLoader; int _count; Handle* _list; int _index; private: // Getting and setting the thread local pointer static JvmtiGetLoadedClassesClosure* get_this() { JvmtiGetLoadedClassesClosure* result = NULL; JavaThread* thread = JavaThread::current(); result = thread->get_jvmti_get_loaded_classes_closure(); return result; } static void set_this(JvmtiGetLoadedClassesClosure* that) { JavaThread* thread = JavaThread::current(); thread->set_jvmti_get_loaded_classes_closure(that); } public: // Constructor/Destructor JvmtiGetLoadedClassesClosure() { JvmtiGetLoadedClassesClosure* that = get_this(); assert(that == NULL, "JvmtiGetLoadedClassesClosure in use"); _initiatingLoader = NULL; _count = 0; _list = NULL; _index = 0; set_this(this); } JvmtiGetLoadedClassesClosure(jobject initiatingLoader) { JvmtiGetLoadedClassesClosure* that = get_this(); assert(that == NULL, "JvmtiGetLoadedClassesClosure in use"); _initiatingLoader = initiatingLoader; _count = 0; _list = NULL; _index = 0; set_this(this); } ~JvmtiGetLoadedClassesClosure() { JvmtiGetLoadedClassesClosure* that = get_this(); assert(that != NULL, "JvmtiGetLoadedClassesClosure not found"); set_this(NULL); _initiatingLoader = NULL; _count = 0; if (_list != NULL) { FreeHeap(_list); _list = NULL; } _index = 0; } // Accessors. jobject get_initiatingLoader() { return _initiatingLoader; } int get_count() { return _count; } void set_count(int value) { _count = value; } Handle* get_list() { return _list; } void set_list(Handle* value) { _list = value; } int get_index() { return _index; } void set_index(int value) { _index = value; } Handle get_element(int index) { if ((_list != NULL) && (index < _count)) { return _list[index]; } else { assert(false, "empty get_element"); return Handle(); } } void set_element(int index, Handle value) { if ((_list != NULL) && (index < _count)) { _list[index] = value; } else { assert(false, "bad set_element"); } } // Other predicates bool available() { return (_list != NULL); } #ifdef ASSERT // For debugging. void check(int limit) { for (int i = 0; i < limit; i += 1) { assert(Universe::heap()->is_in(get_element(i)()), "check fails"); } } #endif // Public methods that get called within the scope of the closure void allocate() { _list = NEW_C_HEAP_ARRAY(Handle, _count); assert(_list != NULL, "Out of memory"); if (_list == NULL) { _count = 0; } } void extract(JvmtiEnv *env, jclass* result) { 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(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 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 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); } } 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 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); } } } } // 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(klassOop k) { JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this(); assert(that != NULL, "no JvmtiGetLoadedClassesClosure"); for (klassOop l = k; l != NULL; l = Klass::cast(l)->array_klass_or_null()) { that->set_count(that->get_count() + 1); } } // add the basic type array class and its multi-dimensional array classes to the list static void add_for_basic_type_arrays(klassOop k) { JvmtiGetLoadedClassesClosure* that = JvmtiGetLoadedClassesClosure::get_this(); assert(that != NULL, "no JvmtiGetLoadedClassesClosure"); assert(that->available(), "no list"); 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); } } }; 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; } jvmtiError JvmtiGetLoadedClasses::getClassLoaderClasses(JvmtiEnv *env, jobject initiatingLoader, 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(initiatingLoader); { // 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 in the system dictionary which have this loader recorded // as an initiating loader. For basic type arrays this information is not recorded // so GetClassLoaderClasses will return all of the basic type arrays. This is okay // because the defining loader for basic type arrays is always the boot class loader // and these classes are "visible" to all loaders. SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::increment_with_loader); Universe::basic_type_classes_do(&JvmtiGetLoadedClassesClosure::increment_for_basic_type_arrays); // Next, fill in the classes closure.allocate(); SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::add_with_loader); Universe::basic_type_classes_do(&JvmtiGetLoadedClassesClosure::add_for_basic_type_arrays); // 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; }