systemDictionary.hpp revision 665
553N/A * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved. 0N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 0N/A * This code is free software; you can redistribute it and/or modify it 0N/A * under the terms of the GNU General Public License version 2 only, as 0N/A * published by the Free Software Foundation. 0N/A * This code is distributed in the hope that it will be useful, but WITHOUT 0N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 0N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 0N/A * version 2 for more details (a copy is included in the LICENSE file that 0N/A * accompanied this code). 0N/A * You should have received a copy of the GNU General Public License version 0N/A * 2 along with this work; if not, write to the Free Software Foundation, 0N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 553N/A * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 553N/A * CA 95054 USA or visit www.sun.com if you need additional information or 0N/A// The system dictionary stores all loaded classes and maps: 0N/A// [class name,class loader] -> class i.e. [symbolOop,oop] -> klassOop 0N/A// Classes are loaded lazily. The default VM class loader is 0N/A// represented as NULL. 0N/A// The underlying data structure is an open hash table with a fixed number 0N/A// of buckets. During loading the loader object is locked, (for the VM loader 0N/A// a private lock object is used). Class loading can thus be done concurrently, 0N/A// but only by different loaders. 0N/A// During loading a placeholder (name, loader) is temporarily placed in 0N/A// a side data structure, and is used to detect ClassCircularityErrors 0N/A// and to perform verification during GC. A GC can occur in the midst // of class loading, as we call out to Java, have to take locks, etc. // When class loading is finished, a new entry is added to the system // dictionary and the place holder is removed. Note that the protection // domain field of the system dictionary has not yet been filled in when // the "real" system dictionary entry is created. // Clients of this class who are interested in finding if a class has // been completely loaded -- not classes in the process of being loaded -- // can read the SystemDictionary unlocked. This is safe because // - entries are only deleted at safepoints // - readers cannot come to a safepoint while actively examining // an entry (an entry cannot be deleted from under a reader) // - entries must be fully formed before they are available to concurrent // readers (we must ensure write ordering) // Note that placeholders are deleted at any time, as they are removed // when a class is completely loaded. Therefore, readers as well as writers // of placeholders must hold the SystemDictionary_lock. // Certain classes are preloaded, such as java.lang.Object and java.lang.String. // They are all "well-known", in the sense that no class loader is allowed // to provide a different definition. // These klasses must all have names defined in vmSymbols. // Each well-known class has a short klass name (like object_klass), // a vmSymbol name (like java_lang_Object), and a flag word // that makes some minor distinctions, like whether the klass // is preloaded, optional, release-specific, etc. // The order of these definitions is significant; it is the order in which // preloading is actually performed by initialize_preloaded_classes. /* well-known classes */ \
/* Preload ref klasses and set reference types */ \
/* NOTE: needed too early in bootstrapping process to have checks based on JDK version */ \
/* Universe::is_gte_jdk14x_version() is not set up by this point. */ \
/* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \
/* It's NULL in non-1.4 JDKs. */ \
/* Universe::is_gte_jdk14x_version() is not set up by this point. */ \
/* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \
/* If this class isn't present, it won't be referenced. */ \
/* Preload boxing klasses */ \
Pre,
// preloaded; error if not present // Order is significant. Options before this point require resolve_or_fail. // Options after this point will use resolve_or_null instead. Opt,
// preload tried; NULL if not present // Returns a class with a given class name and class loader. Loads the // class if needed. If not found a NoClassDefFoundError or a // ClassNotFoundException is thrown, depending on the value on the // throw_error flag. For most uses the throw_error argument should be set // Convenient call for null loader and protection domain. // handle error translation for resolve_or_null results // Returns a class with a given class name and class loader. // Loads the class if needed. If not found NULL is returned. // Version with null loader and protection domain // Resolve a superclass or superinterface. Called from ClassFileParser, // parse_interfaces, resolve_instance_class_or_null, load_shared_class // "child_name" is the class whose super class or interface is being resolved. // Parse new stream. This won't update the system dictionary or // class hierarchy, simply parse the stream. Used by JVMTI RedefineClasses. // Resolve from stream (called by jni_DefineClass and JVM_DefineClass) // Lookup an already loaded class. If not found NULL is returned. // Lookup an already loaded instance or array class. // Do not make any queries to class loaders; consult only the cache. // If not found NULL is returned. // If the given name is known to vmSymbols, return the well-know klass: // Lookup an instance or array class that has already been loaded // either into the given class loader, or else into another class // loader that is constrained (via loader constraints) to produce // a consistent class. Do not take protection domains into account. // Do not make any queries to class loaders; consult only the cache. // Return NULL if the class is not found. // This function is a strict superset of find_instance_or_array_klass. // This function (the unchecked version) makes a conservative prediction // of the result of the checked version, assuming successful lookup. // If both functions return non-null, they must return the same value. // Also, the unchecked version may sometimes be non-null where the // checked version is null. This can occur in several ways: // 1. No query has yet been made to the class loader. // 2. The class loader was queried, but chose not to delegate. // 3. ClassLoader.checkPackageAccess rejected a proposed protection domain. // 4. Loading was attempted, but there was a linkage error of some sort. // In all of these cases, the loader constraints on this type are // satisfied, and it is safe for classes in the given class loader // to manipulate strongly-typed values of the found class, subject // to local linkage and access checks. // Iterate over all klasses in dictionary // Just the classes from defining class loaders // Added for initialize_itable_for_klass to handle exceptions // All classes, and their class loaders // All classes, and their class loaders // (added for helpers that use HandleMarks and ResourceMarks) // All entries in the placeholder table and their class loaders // Iterate over all methods in all klasses in dictionary // Garbage collection support // This method applies "blk->do_oop" to all the pointers to "system" // This method applies "blk->do_oop" to all the placeholders. // Unload (that is, break root links to) all unmarked classes and // loaders. Returns "true" iff something was unloaded. // Applies "f->do_oop" to all root oops in the system dictionary. // Traverses preloaded oops: various system classes. These are // guaranteed to be in the perm gen. // Number of contained klasses // This is both fully loaded classes and classes in the process // Monotonically increasing counter which grows as classes are // of breakpoints are performed // Needed by evolution and breakpoint code // Verify class is in dictionary // Fast access to commonly used classes (preloaded) assert(k !=
NULL,
"preloaded klass not initialized");
// despite the optional loading, if you use this it must be present: // Local definition for direct access to the private array: // methods returning lazily loaded klasses // The corresponding method to load the class must be called before calling them. // Tells whether ClassLoader.loadClassInternal is present // Returns default system loader // Compute the default system loader // Mirrors for primitive classes (created eagerly) // Note: java_lang_Class::primitive_type is the inverse of java_mirror // Check class loader constraints // Utility for printing loader "name" as part of tracing constraints // Record the error when the first attempt to resolve a reference from a constant // pool entry to a class fails. // Hashtable holding loaded classes. // Hashtable holding placeholders for classes being loaded. // Hashtable holding classes from the shared archive. // Monotonically increasing counter which grows with // _number_of_classes as well as hot-swapping and breakpoint setting // Lock object for system class loader // Constraints on class loaders // for VM_CounterDecay iteration support // Basic loading operations // Wait on SystemDictionary_lock; unlocks lockObject before // waiting; relocks lockObject with correct recursion count // after waiting, but before reentering SystemDictionary_lock // to preserve lock order semantics. // Setup link to hierarchy // We pass in the hashtable index so we can calculate it outside of // the SystemDictionary_lock. // Basic find on loaded classes // Basic find on classes in the midst of being loaded // Basic find operation of loaded classes and classes in the midst // of loading; used for assertions and verification only. // Updating entry in dictionary // Add a completely loaded class // Add a placeholder for a class being loaded // Performs cleanups after resolve_super_or_fail. This typically needs // to be called on failure. // Won't throw, but can block. // Class loader constraints // Variables holding commonly used klasses (preloaded) // table of box klasses (int_klass, etc.) // Cf. vmSymbols vs. vmSymbolHandles