2362N/A * Copyright (c) 1997, 2012, Oracle and/or its affiliates. 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. 2362N/A * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 0N/A// A Klass is the part of the klassOop that provides: 0N/A// 1: language level class object (method dictionary etc.) 0N/A// 2: provide vm dispatch behavior for the object 0N/A// Both functions are combined into one C++ class. The toplevel class "Klass" 0N/A// implements purpose 1 whereas all subclasses provide extra virtual functions 0N/A// One reason for the oop/klass dichotomy in the implementation is 0N/A// that we don't want a C++ vtbl pointer in every object. Thus, 0N/A// normal oops don't have any virtual functions. Instead, they 0N/A// forward all "virtual" functions to their klass, which does have 0N/A// a vtbl and does the C++ dispatch depending on the object's 0N/A// ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"! 0N/A// [header ] klassOop 0N/A// [klass pointer ] klassOop 0N/A// [C++ vtbl ptr ] (contained in Klass_vtbl) 0N/A// [super_check_offset ] for fast subtype checks 0N/A// [secondary_super_cache] for fast subtype checks 0N/A// [secondary_supers ] array of 2ndary supertypes 0N/A// [primary_supers 0] 0N/A// [primary_supers 1] 0N/A// [primary_supers 2] // [next_sibling ] link to chain additional subklasses // [verify_count ] - not in product // [last_biased_lock_bulk_revocation_time] (64 bits) // [biased_lock_revocation_count] // Holder (or cage) for the C++ vtable of each kind of Klass. // We want to tightly constrain the location of the C++ vtable in the overall layout. // The following virtual exists only to force creation of a C++ vtable, // so that this class truly is the location of the vtable of all Klasses. // The following virtual makes Klass_vtbl play a second role as a // factory protocol for subclasses of Klass ("sub-Klasses"). // Here's how it works.... // This VM uses metaobjects as factories for their instances. // In order to initialize the C++ vtable of a new instance, its // metaobject is forced to use the C++ placed new operator to // allocate the instance. In a typical C++-based system, each // sub-class would have its own factory routine which // directly uses the placed new operator on the desired class, // and then calls the appropriate chain of C++ constructors. // However, this system uses shared code to performs the first // allocation and initialization steps for all sub-Klasses. // (See base_create_klass() and base_create_array_klass().) // This does not factor neatly into a hierarchy of C++ constructors. // Each caller of these shared "base_create" routines knows // exactly which sub-Klass it is creating, but the shared routine // does not, even though it must perform the actual allocation. // Therefore, the caller of the shared "base_create" must wrap // the specific placed new call in a virtual function which // performs the actual allocation and vtable set-up. That // virtual function is here, Klass_vtbl::allocate_permanent. // The arguments to Universe::allocate_permanent() are passed // straight through the placed new operator, which in turn // obtains them directly from this virtual call. // This virtual is called on a temporary "example instance" of the // sub-Klass being instantiated, a C++ auto variable. The "real" // instance created by this virtual is on the VM heap, where it is // equipped with a klassOopDesc header. // It is merely an accident of implementation that we use "example // instances", but that is why the virtual function which implements // each sub-Klass factory happens to be defined by the same sub-Klass // for which it creates instances. // The vtbl_value() call (see below) is used to strip away the // accidental Klass-ness from an "example instance" and present it as // a factory. Think of each factory object as a mere container of the // C++ vtable for the desired sub-Klass. Since C++ does not allow // direct references to vtables, the factory must also be delegated // the task of allocating the instance, but the essential point is // that the factory knows how to initialize the C++ vtable with the // right pointer value. All other common initializations are handled // by the shared "base_create" subroutines. // Every subclass on which vtbl_value is called must include this macro. // Delay the installation of the klassKlass pointer until after the // the vtable for a new klass has been installed (after the call to new()). // note: put frequently-used fields together at start of klass structure // for better cache behavior (may not make much of a difference but sure won't hurt) // The "layout helper" is a combined descriptor of object layout. // For klasses which are neither instance nor array, the value is zero. // For instances, layout helper is a positive number, the instance size. // This size is already passed through align_object_size and scaled to bytes. // The low order bit is set if instances of this class cannot be // allocated using the fastpath. // For arrays, layout helper is a negative number, containing four // distinct bytes, as follows: // MSB:[tag, hsz, ebt, log2(esz)]:LSB // tag is 0x80 if the elements are oops, 0xC0 if non-oops // hsz is array header size in bytes (i.e., offset of first element) // ebt is the BasicType of the elements // esz is the element size in bytes // This packed word is arranged so as to be quickly unpacked by the // various fast paths that use the various subfields. // The esz bits can be used directly by a SLL instruction, without masking. // Note that the array-kind tag looks like 0x00 for instance klasses, // since their length in bytes is always less than 24Mb. // Final note: This comes first, immediately after Klass_vtbl, // because it is frequently queried. // The fields _super_check_offset, _secondary_super_cache, _secondary_supers // and _primary_supers all help make fast subtype checks. See big discussion // Where to look to observe a supertype (it is &_secondary_super_cache for // secondary supers, else is &_primary_supers[depth()]. // Class name. Instance classes: java/lang/String, etc. Array classes: [I, // The oop block. All oop fields must be declared here and only oop fields // may be declared here. In addition, the first and last fields in this block // must remain first and last, unless oop_block_beg() and/or oop_block_end() // are updated. Grouping the oop fields in a single block simplifies oop // Cache of last observed secondary supertype // Array of all secondary supertypes // Ordered list of all primary supertypes // First subclass (NULL if none); _subklass->next_sibling() is next one // Sibling link (or NULL); links all subklasses of a klass // Biased locking implementation and statistics // (the 64-bit chunk goes first, to avoid some fragmentation) // returns the enclosing klassOop // initializes _super link, _primary_supers & _secondary_supers arrays // klass-specific helper for initializing _secondary_supers // java_super is the Java-level super type as specified by Class.getSuperClass. // Return the element of the _super chain of the given depth. // If there is no such element, return either NULL or this. // Can this klass be a primary super? False for interfaces and arrays of // interfaces. False also for arrays or classes with long super chains. // Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit]. // Note: for instances layout_helper() may include padding. // Use instanceKlass::contains_field_offset to classify field offsets. protected:
// internal accessors // Allocation profiling support // Unpacking layout_helper: // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift); // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift); // Note that the following expression discards _lh_instance_slow_path_bit. // Out-of-line version computes everything based on the etype: // What is the maximum number of primary superclasses any klass can have? // subtype check: true if is_subclass_of, or if k is interface and receiver implements it // Find LCA in class hierarchy // if not, throw either an Error or an Exception. // tells if the class should be initialized // lookup operation for MethodLookupCache // array class with specific rank // array class with this klass as element type // These will return NULL instead of allocating on the heap: // NB: these can block for a mutex, like other functions with TRAPS arg. // computes the subtype relationship // subclass accessor (here for convenience; undefined for non-klass objects) // ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP // These functions describe behavior for the oop not the KLASS. // actual oop size of obj in memory // actual oop size of this klass in memory // Returns the Java name for a class (Resource allocated) // For arrays, this returns the name of the element with a leading '['. // For classes, this returns the name with the package separators // Returns the name for a class (Resource allocated) as the class // would appear in a signature. // For arrays, this returns the name of the element with a leading '['. // For classes, this returns the name with a leading 'L' and a trailing ';' // and the package separators as '/'. // garbage collection support // Parallel Scavenge and Parallel Old // type testing operations // Unless overridden, oop is parsable if it has a klass pointer. // Parsability of an object is object specific. // Unless overridden, oop is safe for concurrent GC processing // after its allocation is complete. The exception to // this is the case where objects are changed after allocation. // Class redefinition is one of the known exceptions. During // class redefinition, an allocated class can changed in order // order to create a merged class (the combiniation of the // old class definition that has to be perserved and the new class // definition which is being created. // Biased locking support // Note: the prototype header is always set up to be at least the // prototype markOop. If biased locking is enabled it may further be // biasable and have an epoch. // NOTE: once instances of this klass are floating around in the // system, this header must only be updated at a safepoint. // NOTE 2: currently we only ever set the prototype header to the // biasable prototype for instanceKlasses. There is no technical // reason why it could not be done for arrayKlasses aside from // wanting to reduce the initial scope of this optimization. There // are potential problems in setting the bias pattern for // Atomically increments biased_lock_revocation_count and returns updated value // garbage collection support // Prefetch within oop iterators. This is a macro because we // can't guarantee that the compiler will inline it. In 64-bit // it generally doesn't. Signature is // static void prefetch_beyond(oop* const start, // const Prefetch::style pstyle); // In case we don't have a specialized backward scanner use forward // Iterates "blk" over all the oops in "obj" (of type "this") within "mr". // (I don't see why the _m should be required, but without it the Solaris // C++ gives warning messages about overridings of the "oop_oop_iterate" // defined above "hiding" this virtual function. (DLD, 6/20/00)) */ // Versions of the above iterators specialized to particular subtypes // of OopClosure, to avoid closure virtual calls. /* Default implementation reverts to general version. */ \
/* Iterates "blk" over all the oops in "obj" (of type "this") within "mr". \ (I don't see why the _m should be required, but without it the Solaris \ C++ gives warning messages about overridings of the "oop_oop_iterate" \ defined above "hiding" this virtual function. (DLD, 6/20/00)) */ \
/* Default implementation reverts to general version. */ \
// Return self, except for abstract classes with exactly 1 // implementor. Then return the 1 concrete implementation. // tells whether obj is partially constructed (gc during class loading) #
endif // SHARE_VM_OOPS_KLASS_HPP