graal-compiler: src/share/vm/oops/klass.hpp annotate

annotate src/share/vm/oops/klass.hpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	3efdfd6ddbf2
children	b9a918201d47 92ef81e2f571

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7409 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	25 #ifndef SHARE_VM_OOPS_KLASS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	26 #define SHARE_VM_OOPS_KLASS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	28 #include "memory/genOopClosures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	29 #include "memory/iterator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	30 #include "memory/memRegion.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	31 #include "memory/specialized_oop_closures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	32 #include "oops/klassPS.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	33 #include "oops/metadata.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	34 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	35 #include "runtime/orderAccess.hpp"
4800 94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2376 diff changeset	36 #include "trace/traceMacros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	37 #include "utilities/accessFlags.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7409 diff changeset	38 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7409 diff changeset	39 #if INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	40 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	41 #include "gc_implementation/g1/g1OopClosures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	42 #include "gc_implementation/parNew/parOopClosures.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7409 diff changeset	43 #endif // INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	44
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	45 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	46 // A Klass provides:
0 a61af66fc99e Initial load duke parents: diff changeset	47 // 1: language level class object (method dictionary etc.)
a61af66fc99e Initial load duke parents: diff changeset	48 // 2: provide vm dispatch behavior for the object
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	49 // Both functions are combined into one C++ class.
0 a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 // One reason for the oop/klass dichotomy in the implementation is
a61af66fc99e Initial load duke parents: diff changeset	52 // that we don't want a C++ vtbl pointer in every object. Thus,
a61af66fc99e Initial load duke parents: diff changeset	53 // normal oops don't have any virtual functions. Instead, they
a61af66fc99e Initial load duke parents: diff changeset	54 // forward all "virtual" functions to their klass, which does have
a61af66fc99e Initial load duke parents: diff changeset	55 // a vtbl and does the C++ dispatch depending on the object's
a61af66fc99e Initial load duke parents: diff changeset	56 // actual type. (See oop.inline.hpp for some of the forwarding code.)
a61af66fc99e Initial load duke parents: diff changeset	57 // ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"!
a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 // Klass layout:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	60 // [C++ vtbl ptr ] (contained in Metadata)
0 a61af66fc99e Initial load duke parents: diff changeset	61 // [layout_helper ]
a61af66fc99e Initial load duke parents: diff changeset	62 // [super_check_offset ] for fast subtype checks
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	63 // [name ]
0 a61af66fc99e Initial load duke parents: diff changeset	64 // [secondary_super_cache] for fast subtype checks
a61af66fc99e Initial load duke parents: diff changeset	65 // [secondary_supers ] array of 2ndary supertypes
a61af66fc99e Initial load duke parents: diff changeset	66 // [primary_supers 0]
a61af66fc99e Initial load duke parents: diff changeset	67 // [primary_supers 1]
a61af66fc99e Initial load duke parents: diff changeset	68 // [primary_supers 2]
a61af66fc99e Initial load duke parents: diff changeset	69 // ...
a61af66fc99e Initial load duke parents: diff changeset	70 // [primary_supers 7]
a61af66fc99e Initial load duke parents: diff changeset	71 // [java_mirror ]
a61af66fc99e Initial load duke parents: diff changeset	72 // [super ]
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	73 // [subklass ] first subclass
0 a61af66fc99e Initial load duke parents: diff changeset	74 // [next_sibling ] link to chain additional subklasses
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	75 // [next_link ]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	76 // [class_loader_data]
0 a61af66fc99e Initial load duke parents: diff changeset	77 // [modifier_flags]
a61af66fc99e Initial load duke parents: diff changeset	78 // [access_flags ]
a61af66fc99e Initial load duke parents: diff changeset	79 // [last_biased_lock_bulk_revocation_time] (64 bits)
a61af66fc99e Initial load duke parents: diff changeset	80 // [prototype_header]
a61af66fc99e Initial load duke parents: diff changeset	81 // [biased_lock_revocation_count]
7968 44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7409 diff changeset	82 // [alloc_count ]
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	83 // [_modified_oops]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	84 // [_accumulated_modified_oops]
4800 94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2376 diff changeset	85 // [trace_id]
0 a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 // Forward declarations.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	89 template <class T> class Array;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	90 template <class T> class GrowableArray;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	91 class ClassLoaderData;
0 a61af66fc99e Initial load duke parents: diff changeset	92 class klassVtable;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	93 class ParCompactionManager;
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7409 diff changeset	94 class KlassSizeStats;
0 a61af66fc99e Initial load duke parents: diff changeset	95
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	96 class Klass : public Metadata {
0 a61af66fc99e Initial load duke parents: diff changeset	97 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	98 protected:
a61af66fc99e Initial load duke parents: diff changeset	99 // note: put frequently-used fields together at start of klass structure
a61af66fc99e Initial load duke parents: diff changeset	100 // for better cache behavior (may not make much of a difference but sure won't hurt)
a61af66fc99e Initial load duke parents: diff changeset	101 enum { _primary_super_limit = 8 };
a61af66fc99e Initial load duke parents: diff changeset	102
a61af66fc99e Initial load duke parents: diff changeset	103 // The "layout helper" is a combined descriptor of object layout.
a61af66fc99e Initial load duke parents: diff changeset	104 // For klasses which are neither instance nor array, the value is zero.
a61af66fc99e Initial load duke parents: diff changeset	105 //
a61af66fc99e Initial load duke parents: diff changeset	106 // For instances, layout helper is a positive number, the instance size.
a61af66fc99e Initial load duke parents: diff changeset	107 // This size is already passed through align_object_size and scaled to bytes.
a61af66fc99e Initial load duke parents: diff changeset	108 // The low order bit is set if instances of this class cannot be
a61af66fc99e Initial load duke parents: diff changeset	109 // allocated using the fastpath.
a61af66fc99e Initial load duke parents: diff changeset	110 //
a61af66fc99e Initial load duke parents: diff changeset	111 // For arrays, layout helper is a negative number, containing four
a61af66fc99e Initial load duke parents: diff changeset	112 // distinct bytes, as follows:
a61af66fc99e Initial load duke parents: diff changeset	113 // MSB:[tag, hsz, ebt, log2(esz)]:LSB
a61af66fc99e Initial load duke parents: diff changeset	114 // where:
a61af66fc99e Initial load duke parents: diff changeset	115 // tag is 0x80 if the elements are oops, 0xC0 if non-oops
a61af66fc99e Initial load duke parents: diff changeset	116 // hsz is array header size in bytes (i.e., offset of first element)
a61af66fc99e Initial load duke parents: diff changeset	117 // ebt is the BasicType of the elements
a61af66fc99e Initial load duke parents: diff changeset	118 // esz is the element size in bytes
a61af66fc99e Initial load duke parents: diff changeset	119 // This packed word is arranged so as to be quickly unpacked by the
a61af66fc99e Initial load duke parents: diff changeset	120 // various fast paths that use the various subfields.
a61af66fc99e Initial load duke parents: diff changeset	121 //
a61af66fc99e Initial load duke parents: diff changeset	122 // The esz bits can be used directly by a SLL instruction, without masking.
a61af66fc99e Initial load duke parents: diff changeset	123 //
a61af66fc99e Initial load duke parents: diff changeset	124 // Note that the array-kind tag looks like 0x00 for instance klasses,
a61af66fc99e Initial load duke parents: diff changeset	125 // since their length in bytes is always less than 24Mb.
a61af66fc99e Initial load duke parents: diff changeset	126 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	127 // Final note: This comes first, immediately after C++ vtable,
0 a61af66fc99e Initial load duke parents: diff changeset	128 // because it is frequently queried.
a61af66fc99e Initial load duke parents: diff changeset	129 jint _layout_helper;
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 // The fields _super_check_offset, _secondary_super_cache, _secondary_supers
a61af66fc99e Initial load duke parents: diff changeset	132 // and _primary_supers all help make fast subtype checks. See big discussion
a61af66fc99e Initial load duke parents: diff changeset	133 // in doc/server_compiler/checktype.txt
a61af66fc99e Initial load duke parents: diff changeset	134 //
a61af66fc99e Initial load duke parents: diff changeset	135 // Where to look to observe a supertype (it is &_secondary_super_cache for
a61af66fc99e Initial load duke parents: diff changeset	136 // secondary supers, else is &_primary_supers[depth()].
a61af66fc99e Initial load duke parents: diff changeset	137 juint _super_check_offset;
a61af66fc99e Initial load duke parents: diff changeset	138
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	139 // Class name. Instance classes: java/lang/String, etc. Array classes: [I,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	140 // [Ljava/lang/String;, etc. Set to zero for all other kinds of classes.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	141 Symbol* _name;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	142
0 a61af66fc99e Initial load duke parents: diff changeset	143 // Cache of last observed secondary supertype
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	144 Klass* _secondary_super_cache;
0 a61af66fc99e Initial load duke parents: diff changeset	145 // Array of all secondary supertypes
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	146 Array<Klass> _secondary_supers;
0 a61af66fc99e Initial load duke parents: diff changeset	147 // Ordered list of all primary supertypes
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	148 Klass* _primary_supers[_primary_super_limit];
0 a61af66fc99e Initial load duke parents: diff changeset	149 // java/lang/Class instance mirroring this class
a61af66fc99e Initial load duke parents: diff changeset	150 oop _java_mirror;
a61af66fc99e Initial load duke parents: diff changeset	151 // Superclass
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	152 Klass* _super;
0 a61af66fc99e Initial load duke parents: diff changeset	153 // First subclass (NULL if none); _subklass->next_sibling() is next one
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	154 Klass* _subklass;
0 a61af66fc99e Initial load duke parents: diff changeset	155 // Sibling link (or NULL); links all subklasses of a klass
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	156 Klass* _next_sibling;
0 a61af66fc99e Initial load duke parents: diff changeset	157
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	158 // All klasses loaded by a class loader are chained through these links
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	159 Klass* _next_link;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	160
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	161 // The VM's representation of the ClassLoader used to load this class.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	162 // Provide access the corresponding instance java.lang.ClassLoader.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	163 ClassLoaderData* _class_loader_data;
0 a61af66fc99e Initial load duke parents: diff changeset	164
a61af66fc99e Initial load duke parents: diff changeset	165 jint _modifier_flags; // Processed access flags, for use by Class.getModifiers.
a61af66fc99e Initial load duke parents: diff changeset	166 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here.
a61af66fc99e Initial load duke parents: diff changeset	167
7968 44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7409 diff changeset	168 // Biased locking implementation and statistics
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7409 diff changeset	169 // (the 64-bit chunk goes first, to avoid some fragmentation)
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7409 diff changeset	170 jlong _last_biased_lock_bulk_revocation_time;
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7409 diff changeset	171 markOop _prototype_header; // Used when biased locking is both enabled and disabled for this type
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7409 diff changeset	172 jint _biased_lock_revocation_count;
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7409 diff changeset	173
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	174 juint _alloc_count; // allocation profiling support
0 a61af66fc99e Initial load duke parents: diff changeset	175
4800 94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2376 diff changeset	176 TRACE_DEFINE_KLASS_TRACE_ID;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	177
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	178 // Remembered sets support for the oops in the klasses.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	179 jbyte _modified_oops; // Card Table Equivalent (YC/CMS support)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	180 jbyte _accumulated_modified_oops; // Mod Union Equivalent (CMS support)
0 a61af66fc99e Initial load duke parents: diff changeset	181
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	182 // Constructor
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	183 Klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	184
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	185 void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	186
a61af66fc99e Initial load duke parents: diff changeset	187 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	188 bool is_klass() const volatile { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 // super
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	191 Klass* super() const { return _super; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	192 void set_super(Klass* k) { _super = k; }
0 a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 // initializes _super link, _primary_supers & _secondary_supers arrays
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	195 void initialize_supers(Klass* k, TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	196 void initialize_supers_impl1(Klass* k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	197 void initialize_supers_impl2(Klass* k);
0 a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 // klass-specific helper for initializing _secondary_supers
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	200 virtual GrowableArray<Klass> compute_secondary_supers(int num_extra_slots);
0 a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 // java_super is the Java-level super type as specified by Class.getSuperClass.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	203 virtual Klass* java_super() const { return NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 juint super_check_offset() const { return _super_check_offset; }
a61af66fc99e Initial load duke parents: diff changeset	206 void set_super_check_offset(juint o) { _super_check_offset = o; }
a61af66fc99e Initial load duke parents: diff changeset	207
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	208 Klass* secondary_super_cache() const { return _secondary_super_cache; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	209 void set_secondary_super_cache(Klass* k) { _secondary_super_cache = k; }
0 a61af66fc99e Initial load duke parents: diff changeset	210
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	211 Array<Klass> secondary_supers() const { return _secondary_supers; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	212 void set_secondary_supers(Array<Klass> k) { _secondary_supers = k; }
0 a61af66fc99e Initial load duke parents: diff changeset	213
a61af66fc99e Initial load duke parents: diff changeset	214 // Return the element of the _super chain of the given depth.
a61af66fc99e Initial load duke parents: diff changeset	215 // If there is no such element, return either NULL or this.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	216 Klass* primary_super_of_depth(juint i) const {
0 a61af66fc99e Initial load duke parents: diff changeset	217 assert(i < primary_super_limit(), "oob");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	218 Klass* super = _primary_supers[i];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	219 assert(super == NULL \|\| super->super_depth() == i, "correct display");
0 a61af66fc99e Initial load duke parents: diff changeset	220 return super;
a61af66fc99e Initial load duke parents: diff changeset	221 }
a61af66fc99e Initial load duke parents: diff changeset	222
a61af66fc99e Initial load duke parents: diff changeset	223 // Can this klass be a primary super? False for interfaces and arrays of
a61af66fc99e Initial load duke parents: diff changeset	224 // interfaces. False also for arrays or classes with long super chains.
a61af66fc99e Initial load duke parents: diff changeset	225 bool can_be_primary_super() const {
4762 069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the Klass::_offset_in_bytes() functions stefank parents: 2376 diff changeset	226 const juint secondary_offset = in_bytes(secondary_super_cache_offset());
0 a61af66fc99e Initial load duke parents: diff changeset	227 return super_check_offset() != secondary_offset;
a61af66fc99e Initial load duke parents: diff changeset	228 }
a61af66fc99e Initial load duke parents: diff changeset	229 virtual bool can_be_primary_super_slow() const;
a61af66fc99e Initial load duke parents: diff changeset	230
a61af66fc99e Initial load duke parents: diff changeset	231 // Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit].
a61af66fc99e Initial load duke parents: diff changeset	232 juint super_depth() const {
a61af66fc99e Initial load duke parents: diff changeset	233 if (!can_be_primary_super()) {
a61af66fc99e Initial load duke parents: diff changeset	234 return primary_super_limit();
a61af66fc99e Initial load duke parents: diff changeset	235 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	236 juint d = (super_check_offset() - in_bytes(primary_supers_offset())) / sizeof(Klass*);
0 a61af66fc99e Initial load duke parents: diff changeset	237 assert(d < primary_super_limit(), "oob");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	238 assert(_primary_supers[d] == this, "proper init");
0 a61af66fc99e Initial load duke parents: diff changeset	239 return d;
a61af66fc99e Initial load duke parents: diff changeset	240 }
a61af66fc99e Initial load duke parents: diff changeset	241 }
a61af66fc99e Initial load duke parents: diff changeset	242
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	243 // store an oop into a field of a Klass
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	244 void klass_oop_store(oop* p, oop v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	245 void klass_oop_store(volatile oop* p, oop v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	246
0 a61af66fc99e Initial load duke parents: diff changeset	247 // java mirror
a61af66fc99e Initial load duke parents: diff changeset	248 oop java_mirror() const { return _java_mirror; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	249 void set_java_mirror(oop m) { klass_oop_store(&_java_mirror, m); }
0 a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251 // modifier flags
a61af66fc99e Initial load duke parents: diff changeset	252 jint modifier_flags() const { return _modifier_flags; }
a61af66fc99e Initial load duke parents: diff changeset	253 void set_modifier_flags(jint flags) { _modifier_flags = flags; }
a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255 // size helper
a61af66fc99e Initial load duke parents: diff changeset	256 int layout_helper() const { return _layout_helper; }
a61af66fc99e Initial load duke parents: diff changeset	257 void set_layout_helper(int lh) { _layout_helper = lh; }
a61af66fc99e Initial load duke parents: diff changeset	258
a61af66fc99e Initial load duke parents: diff changeset	259 // Note: for instances layout_helper() may include padding.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	260 // Use InstanceKlass::contains_field_offset to classify field offsets.
0 a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 // sub/superklass links
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	263 InstanceKlass* superklass() const;
0 a61af66fc99e Initial load duke parents: diff changeset	264 Klass* subklass() const;
a61af66fc99e Initial load duke parents: diff changeset	265 Klass* next_sibling() const;
a61af66fc99e Initial load duke parents: diff changeset	266 void append_to_sibling_list(); // add newly created receiver to superklass' subklass list
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	267
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	268 void set_next_link(Klass* k) { _next_link = k; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	269 Klass* next_link() const { return _next_link; } // The next klass defined by the class loader.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	270
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	271 // class loader data
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	272 ClassLoaderData* class_loader_data() const { return _class_loader_data; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	273 void set_class_loader_data(ClassLoaderData* loader_data) { _class_loader_data = loader_data; }
0 a61af66fc99e Initial load duke parents: diff changeset	274
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	275 // The Klasses are not placed in the Heap, so the Card Table or
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	276 // the Mod Union Table can't be used to mark when klasses have modified oops.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	277 // The CT and MUT bits saves this information for the individual Klasses.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	278 void record_modified_oops() { _modified_oops = 1; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	279 void clear_modified_oops() { _modified_oops = 0; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	280 bool has_modified_oops() { return _modified_oops == 1; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	281
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	282 void accumulate_modified_oops() { if (has_modified_oops()) _accumulated_modified_oops = 1; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	283 void clear_accumulated_modified_oops() { _accumulated_modified_oops = 0; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	284 bool has_accumulated_modified_oops() { return _accumulated_modified_oops == 1; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	285
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	286 protected: // internal accessors
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	287 Klass* subklass_oop() const { return _subklass; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	288 Klass* next_sibling_oop() const { return _next_sibling; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	289 void set_subklass(Klass* s);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	290 void set_next_sibling(Klass* s);
0 a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 public:
a61af66fc99e Initial load duke parents: diff changeset	293 // Allocation profiling support
a61af66fc99e Initial load duke parents: diff changeset	294 juint alloc_count() const { return _alloc_count; }
a61af66fc99e Initial load duke parents: diff changeset	295 void set_alloc_count(juint n) { _alloc_count = n; }
a61af66fc99e Initial load duke parents: diff changeset	296 virtual juint alloc_size() const = 0;
a61af66fc99e Initial load duke parents: diff changeset	297 virtual void set_alloc_size(juint n) = 0;
a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 // Compiler support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	300 static ByteSize super_offset() { return in_ByteSize(offset_of(Klass, _super)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	301 static ByteSize super_check_offset_offset() { return in_ByteSize(offset_of(Klass, _super_check_offset)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	302 static ByteSize primary_supers_offset() { return in_ByteSize(offset_of(Klass, _primary_supers)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	303 static ByteSize secondary_super_cache_offset() { return in_ByteSize(offset_of(Klass, _secondary_super_cache)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	304 static ByteSize secondary_supers_offset() { return in_ByteSize(offset_of(Klass, _secondary_supers)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	305 static ByteSize java_mirror_offset() { return in_ByteSize(offset_of(Klass, _java_mirror)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	306 static ByteSize modifier_flags_offset() { return in_ByteSize(offset_of(Klass, _modifier_flags)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	307 static ByteSize layout_helper_offset() { return in_ByteSize(offset_of(Klass, _layout_helper)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	308 static ByteSize access_flags_offset() { return in_ByteSize(offset_of(Klass, _access_flags)); }
0 a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310 // Unpacking layout_helper:
a61af66fc99e Initial load duke parents: diff changeset	311 enum {
a61af66fc99e Initial load duke parents: diff changeset	312 _lh_neutral_value = 0, // neutral non-array non-instance value
a61af66fc99e Initial load duke parents: diff changeset	313 _lh_instance_slow_path_bit = 0x01,
a61af66fc99e Initial load duke parents: diff changeset	314 _lh_log2_element_size_shift = BitsPerByte*0,
a61af66fc99e Initial load duke parents: diff changeset	315 _lh_log2_element_size_mask = BitsPerLong-1,
a61af66fc99e Initial load duke parents: diff changeset	316 _lh_element_type_shift = BitsPerByte*1,
a61af66fc99e Initial load duke parents: diff changeset	317 _lh_element_type_mask = right_n_bits(BitsPerByte), // shifted mask
a61af66fc99e Initial load duke parents: diff changeset	318 _lh_header_size_shift = BitsPerByte*2,
a61af66fc99e Initial load duke parents: diff changeset	319 _lh_header_size_mask = right_n_bits(BitsPerByte), // shifted mask
a61af66fc99e Initial load duke parents: diff changeset	320 _lh_array_tag_bits = 2,
a61af66fc99e Initial load duke parents: diff changeset	321 _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits,
a61af66fc99e Initial load duke parents: diff changeset	322 _lh_array_tag_type_value = ~0x00, // 0xC0000000 >> 30
a61af66fc99e Initial load duke parents: diff changeset	323 _lh_array_tag_obj_value = ~0x01 // 0x80000000 >> 30
a61af66fc99e Initial load duke parents: diff changeset	324 };
a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 static int layout_helper_size_in_bytes(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	327 assert(lh > (jint)_lh_neutral_value, "must be instance");
a61af66fc99e Initial load duke parents: diff changeset	328 return (int) lh & ~_lh_instance_slow_path_bit;
a61af66fc99e Initial load duke parents: diff changeset	329 }
a61af66fc99e Initial load duke parents: diff changeset	330 static bool layout_helper_needs_slow_path(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	331 assert(lh > (jint)_lh_neutral_value, "must be instance");
a61af66fc99e Initial load duke parents: diff changeset	332 return (lh & _lh_instance_slow_path_bit) != 0;
a61af66fc99e Initial load duke parents: diff changeset	333 }
a61af66fc99e Initial load duke parents: diff changeset	334 static bool layout_helper_is_instance(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	335 return (jint)lh > (jint)_lh_neutral_value;
a61af66fc99e Initial load duke parents: diff changeset	336 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	337 static bool layout_helper_is_array(jint lh) {
0 a61af66fc99e Initial load duke parents: diff changeset	338 return (jint)lh < (jint)_lh_neutral_value;
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340 static bool layout_helper_is_typeArray(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	341 // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift);
a61af66fc99e Initial load duke parents: diff changeset	342 return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift);
a61af66fc99e Initial load duke parents: diff changeset	343 }
a61af66fc99e Initial load duke parents: diff changeset	344 static bool layout_helper_is_objArray(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	345 // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift);
a61af66fc99e Initial load duke parents: diff changeset	346 return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift);
a61af66fc99e Initial load duke parents: diff changeset	347 }
a61af66fc99e Initial load duke parents: diff changeset	348 static int layout_helper_header_size(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	349 assert(lh < (jint)_lh_neutral_value, "must be array");
a61af66fc99e Initial load duke parents: diff changeset	350 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
a61af66fc99e Initial load duke parents: diff changeset	351 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	352 return hsize;
a61af66fc99e Initial load duke parents: diff changeset	353 }
a61af66fc99e Initial load duke parents: diff changeset	354 static BasicType layout_helper_element_type(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	355 assert(lh < (jint)_lh_neutral_value, "must be array");
a61af66fc99e Initial load duke parents: diff changeset	356 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
a61af66fc99e Initial load duke parents: diff changeset	357 assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	358 return (BasicType) btvalue;
a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360 static int layout_helper_log2_element_size(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	361 assert(lh < (jint)_lh_neutral_value, "must be array");
a61af66fc99e Initial load duke parents: diff changeset	362 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
a61af66fc99e Initial load duke parents: diff changeset	363 assert(l2esz <= LogBitsPerLong, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	364 return l2esz;
a61af66fc99e Initial load duke parents: diff changeset	365 }
a61af66fc99e Initial load duke parents: diff changeset	366 static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) {
a61af66fc99e Initial load duke parents: diff changeset	367 return (tag << _lh_array_tag_shift)
a61af66fc99e Initial load duke parents: diff changeset	368 \| (hsize << _lh_header_size_shift)
a61af66fc99e Initial load duke parents: diff changeset	369 \| ((int)etype << _lh_element_type_shift)
a61af66fc99e Initial load duke parents: diff changeset	370 \| (log2_esize << _lh_log2_element_size_shift);
a61af66fc99e Initial load duke parents: diff changeset	371 }
a61af66fc99e Initial load duke parents: diff changeset	372 static jint instance_layout_helper(jint size, bool slow_path_flag) {
a61af66fc99e Initial load duke parents: diff changeset	373 return (size << LogHeapWordSize)
a61af66fc99e Initial load duke parents: diff changeset	374 \| (slow_path_flag ? _lh_instance_slow_path_bit : 0);
a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376 static int layout_helper_to_size_helper(jint lh) {
a61af66fc99e Initial load duke parents: diff changeset	377 assert(lh > (jint)_lh_neutral_value, "must be instance");
a61af66fc99e Initial load duke parents: diff changeset	378 // Note that the following expression discards _lh_instance_slow_path_bit.
a61af66fc99e Initial load duke parents: diff changeset	379 return lh >> LogHeapWordSize;
a61af66fc99e Initial load duke parents: diff changeset	380 }
a61af66fc99e Initial load duke parents: diff changeset	381 // Out-of-line version computes everything based on the etype:
a61af66fc99e Initial load duke parents: diff changeset	382 static jint array_layout_helper(BasicType etype);
a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384 // What is the maximum number of primary superclasses any klass can have?
a61af66fc99e Initial load duke parents: diff changeset	385 #ifdef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	386 static juint primary_super_limit() { return _primary_super_limit; }
a61af66fc99e Initial load duke parents: diff changeset	387 #else
a61af66fc99e Initial load duke parents: diff changeset	388 static juint primary_super_limit() {
a61af66fc99e Initial load duke parents: diff changeset	389 assert(FastSuperclassLimit <= _primary_super_limit, "parameter oob");
a61af66fc99e Initial load duke parents: diff changeset	390 return FastSuperclassLimit;
a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392 #endif
a61af66fc99e Initial load duke parents: diff changeset	393
a61af66fc99e Initial load duke parents: diff changeset	394 // vtables
a61af66fc99e Initial load duke parents: diff changeset	395 virtual klassVtable* vtable() const { return NULL; }
a61af66fc99e Initial load duke parents: diff changeset	396
a61af66fc99e Initial load duke parents: diff changeset	397 // subclass check
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	398 bool is_subclass_of(Klass* k) const;
0 a61af66fc99e Initial load duke parents: diff changeset	399 // subtype check: true if is_subclass_of, or if k is interface and receiver implements it
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	400 bool is_subtype_of(Klass* k) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	401 juint off = k->super_check_offset();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	402 Klass* sup = (Klass*)( (address)this + off );
4762 069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the Klass::_offset_in_bytes() functions stefank parents: 2376 diff changeset	403 const juint secondary_offset = in_bytes(secondary_super_cache_offset());
0 a61af66fc99e Initial load duke parents: diff changeset	404 if (sup == k) {
a61af66fc99e Initial load duke parents: diff changeset	405 return true;
a61af66fc99e Initial load duke parents: diff changeset	406 } else if (off != secondary_offset) {
a61af66fc99e Initial load duke parents: diff changeset	407 return false;
a61af66fc99e Initial load duke parents: diff changeset	408 } else {
a61af66fc99e Initial load duke parents: diff changeset	409 return search_secondary_supers(k);
a61af66fc99e Initial load duke parents: diff changeset	410 }
a61af66fc99e Initial load duke parents: diff changeset	411 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	412 bool search_secondary_supers(Klass* k) const;
0 a61af66fc99e Initial load duke parents: diff changeset	413
605 98cb887364d3 6810672: Comment typos twisti parents: 518 diff changeset	414 // Find LCA in class hierarchy
0 a61af66fc99e Initial load duke parents: diff changeset	415 Klass LCA( Klass k );
a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 // Check whether reflection/jni/jvm code is allowed to instantiate this class;
a61af66fc99e Initial load duke parents: diff changeset	418 // if not, throw either an Error or an Exception.
a61af66fc99e Initial load duke parents: diff changeset	419 virtual void check_valid_for_instantiation(bool throwError, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	420
a61af66fc99e Initial load duke parents: diff changeset	421 // array copying
a61af66fc99e Initial load duke parents: diff changeset	422 virtual void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	423
a61af66fc99e Initial load duke parents: diff changeset	424 // tells if the class should be initialized
a61af66fc99e Initial load duke parents: diff changeset	425 virtual bool should_be_initialized() const { return false; }
a61af66fc99e Initial load duke parents: diff changeset	426 // initializes the klass
a61af66fc99e Initial load duke parents: diff changeset	427 virtual void initialize(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	428 // lookup operation for MethodLookupCache
a61af66fc99e Initial load duke parents: diff changeset	429 friend class MethodLookupCache;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	430 virtual Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
0 a61af66fc99e Initial load duke parents: diff changeset	431 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	432 Method* lookup_method(Symbol* name, Symbol* signature) const {
0 a61af66fc99e Initial load duke parents: diff changeset	433 return uncached_lookup_method(name, signature);
a61af66fc99e Initial load duke parents: diff changeset	434 }
a61af66fc99e Initial load duke parents: diff changeset	435
a61af66fc99e Initial load duke parents: diff changeset	436 // array class with specific rank
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	437 Klass* array_klass(int rank, TRAPS) { return array_klass_impl(false, rank, THREAD); }
0 a61af66fc99e Initial load duke parents: diff changeset	438
a61af66fc99e Initial load duke parents: diff changeset	439 // array class with this klass as element type
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	440 Klass* array_klass(TRAPS) { return array_klass_impl(false, THREAD); }
0 a61af66fc99e Initial load duke parents: diff changeset	441
a61af66fc99e Initial load duke parents: diff changeset	442 // These will return NULL instead of allocating on the heap:
a61af66fc99e Initial load duke parents: diff changeset	443 // NB: these can block for a mutex, like other functions with TRAPS arg.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	444 Klass* array_klass_or_null(int rank);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	445 Klass* array_klass_or_null();
0 a61af66fc99e Initial load duke parents: diff changeset	446
a61af66fc99e Initial load duke parents: diff changeset	447 virtual oop protection_domain() { return NULL; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	448
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	449 oop class_loader() const;
0 a61af66fc99e Initial load duke parents: diff changeset	450
7409 30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 7185 diff changeset	451 virtual oop klass_holder() const { return class_loader(); }
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 7185 diff changeset	452
0 a61af66fc99e Initial load duke parents: diff changeset	453 protected:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	454 virtual Klass* array_klass_impl(bool or_null, int rank, TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	455 virtual Klass* array_klass_impl(bool or_null, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	458 // CDS support - remove and restore oops from metadata. Oops are not shared.
0 a61af66fc99e Initial load duke parents: diff changeset	459 virtual void remove_unshareable_info();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	460 virtual void restore_unshareable_info(TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	461
a61af66fc99e Initial load duke parents: diff changeset	462 protected:
a61af66fc99e Initial load duke parents: diff changeset	463 // computes the subtype relationship
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	464 virtual bool compute_is_subtype_of(Klass* k);
0 a61af66fc99e Initial load duke parents: diff changeset	465 public:
a61af66fc99e Initial load duke parents: diff changeset	466 // subclass accessor (here for convenience; undefined for non-klass objects)
a61af66fc99e Initial load duke parents: diff changeset	467 virtual bool is_leaf_class() const { fatal("not a class"); return false; }
a61af66fc99e Initial load duke parents: diff changeset	468 public:
a61af66fc99e Initial load duke parents: diff changeset	469 // ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP
a61af66fc99e Initial load duke parents: diff changeset	470 // These functions describe behavior for the oop not the KLASS.
a61af66fc99e Initial load duke parents: diff changeset	471
a61af66fc99e Initial load duke parents: diff changeset	472 // actual oop size of obj in memory
a61af66fc99e Initial load duke parents: diff changeset	473 virtual int oop_size(oop obj) const = 0;
a61af66fc99e Initial load duke parents: diff changeset	474
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	475 // Size of klass in word size.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	476 virtual int size() const = 0;
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7409 diff changeset	477 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7409 diff changeset	478 virtual void collect_statistics(KlassSizeStats *sz) const;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7409 diff changeset	479 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	480
a61af66fc99e Initial load duke parents: diff changeset	481 // Returns the Java name for a class (Resource allocated)
a61af66fc99e Initial load duke parents: diff changeset	482 // For arrays, this returns the name of the element with a leading '['.
a61af66fc99e Initial load duke parents: diff changeset	483 // For classes, this returns the name with the package separators
a61af66fc99e Initial load duke parents: diff changeset	484 // turned into '.'s.
a61af66fc99e Initial load duke parents: diff changeset	485 const char* external_name() const;
a61af66fc99e Initial load duke parents: diff changeset	486 // Returns the name for a class (Resource allocated) as the class
a61af66fc99e Initial load duke parents: diff changeset	487 // would appear in a signature.
a61af66fc99e Initial load duke parents: diff changeset	488 // For arrays, this returns the name of the element with a leading '['.
a61af66fc99e Initial load duke parents: diff changeset	489 // For classes, this returns the name with a leading 'L' and a trailing ';'
a61af66fc99e Initial load duke parents: diff changeset	490 // and the package separators as '/'.
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 628 diff changeset	491 virtual const char* signature_name() const;
0 a61af66fc99e Initial load duke parents: diff changeset	492
a61af66fc99e Initial load duke parents: diff changeset	493 // garbage collection support
a61af66fc99e Initial load duke parents: diff changeset	494 virtual void oop_follow_contents(oop obj) = 0;
a61af66fc99e Initial load duke parents: diff changeset	495 virtual int oop_adjust_pointers(oop obj) = 0;
a61af66fc99e Initial load duke parents: diff changeset	496
a61af66fc99e Initial load duke parents: diff changeset	497 // Parallel Scavenge and Parallel Old
a61af66fc99e Initial load duke parents: diff changeset	498 PARALLEL_GC_DECLS_PV
a61af66fc99e Initial load duke parents: diff changeset	499
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	500 // type testing operations
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	501 protected:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	502 virtual bool oop_is_instance_slow() const { return false; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	503 virtual bool oop_is_array_slow() const { return false; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	504 virtual bool oop_is_objArray_slow() const { return false; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	505 virtual bool oop_is_typeArray_slow() const { return false; }
0 a61af66fc99e Initial load duke parents: diff changeset	506 public:
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2177 diff changeset	507 virtual bool oop_is_instanceMirror() const { return false; }
0 a61af66fc99e Initial load duke parents: diff changeset	508 virtual bool oop_is_instanceRef() const { return false; }
a61af66fc99e Initial load duke parents: diff changeset	509
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	510 // Fast non-virtual versions
0 a61af66fc99e Initial load duke parents: diff changeset	511 #ifndef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	512 #define assert_same_query(xval, xcheck) xval
a61af66fc99e Initial load duke parents: diff changeset	513 #else
a61af66fc99e Initial load duke parents: diff changeset	514 private:
a61af66fc99e Initial load duke parents: diff changeset	515 static bool assert_same_query(bool xval, bool xslow) {
a61af66fc99e Initial load duke parents: diff changeset	516 assert(xval == xslow, "slow and fast queries agree");
a61af66fc99e Initial load duke parents: diff changeset	517 return xval;
a61af66fc99e Initial load duke parents: diff changeset	518 }
a61af66fc99e Initial load duke parents: diff changeset	519 public:
a61af66fc99e Initial load duke parents: diff changeset	520 #endif
a61af66fc99e Initial load duke parents: diff changeset	521 inline bool oop_is_instance() const { return assert_same_query(
a61af66fc99e Initial load duke parents: diff changeset	522 layout_helper_is_instance(layout_helper()),
a61af66fc99e Initial load duke parents: diff changeset	523 oop_is_instance_slow()); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	524 inline bool oop_is_array() const { return assert_same_query(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	525 layout_helper_is_array(layout_helper()),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	526 oop_is_array_slow()); }
0 a61af66fc99e Initial load duke parents: diff changeset	527 inline bool oop_is_objArray() const { return assert_same_query(
a61af66fc99e Initial load duke parents: diff changeset	528 layout_helper_is_objArray(layout_helper()),
a61af66fc99e Initial load duke parents: diff changeset	529 oop_is_objArray_slow()); }
a61af66fc99e Initial load duke parents: diff changeset	530 inline bool oop_is_typeArray() const { return assert_same_query(
a61af66fc99e Initial load duke parents: diff changeset	531 layout_helper_is_typeArray(layout_helper()),
a61af66fc99e Initial load duke parents: diff changeset	532 oop_is_typeArray_slow()); }
a61af66fc99e Initial load duke parents: diff changeset	533 #undef assert_same_query
a61af66fc99e Initial load duke parents: diff changeset	534
a61af66fc99e Initial load duke parents: diff changeset	535 // Access flags
a61af66fc99e Initial load duke parents: diff changeset	536 AccessFlags access_flags() const { return _access_flags; }
a61af66fc99e Initial load duke parents: diff changeset	537 void set_access_flags(AccessFlags flags) { _access_flags = flags; }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 bool is_public() const { return _access_flags.is_public(); }
a61af66fc99e Initial load duke parents: diff changeset	540 bool is_final() const { return _access_flags.is_final(); }
a61af66fc99e Initial load duke parents: diff changeset	541 bool is_interface() const { return _access_flags.is_interface(); }
a61af66fc99e Initial load duke parents: diff changeset	542 bool is_abstract() const { return _access_flags.is_abstract(); }
a61af66fc99e Initial load duke parents: diff changeset	543 bool is_super() const { return _access_flags.is_super(); }
a61af66fc99e Initial load duke parents: diff changeset	544 bool is_synthetic() const { return _access_flags.is_synthetic(); }
a61af66fc99e Initial load duke parents: diff changeset	545 void set_is_synthetic() { _access_flags.set_is_synthetic(); }
a61af66fc99e Initial load duke parents: diff changeset	546 bool has_finalizer() const { return _access_flags.has_finalizer(); }
a61af66fc99e Initial load duke parents: diff changeset	547 bool has_final_method() const { return _access_flags.has_final_method(); }
a61af66fc99e Initial load duke parents: diff changeset	548 void set_has_finalizer() { _access_flags.set_has_finalizer(); }
a61af66fc99e Initial load duke parents: diff changeset	549 void set_has_final_method() { _access_flags.set_has_final_method(); }
a61af66fc99e Initial load duke parents: diff changeset	550 bool is_cloneable() const { return _access_flags.is_cloneable(); }
a61af66fc99e Initial load duke parents: diff changeset	551 void set_is_cloneable() { _access_flags.set_is_cloneable(); }
a61af66fc99e Initial load duke parents: diff changeset	552 bool has_vanilla_constructor() const { return _access_flags.has_vanilla_constructor(); }
a61af66fc99e Initial load duke parents: diff changeset	553 void set_has_vanilla_constructor() { _access_flags.set_has_vanilla_constructor(); }
a61af66fc99e Initial load duke parents: diff changeset	554 bool has_miranda_methods () const { return access_flags().has_miranda_methods(); }
a61af66fc99e Initial load duke parents: diff changeset	555 void set_has_miranda_methods() { _access_flags.set_has_miranda_methods(); }
a61af66fc99e Initial load duke parents: diff changeset	556
a61af66fc99e Initial load duke parents: diff changeset	557 // Biased locking support
a61af66fc99e Initial load duke parents: diff changeset	558 // Note: the prototype header is always set up to be at least the
a61af66fc99e Initial load duke parents: diff changeset	559 // prototype markOop. If biased locking is enabled it may further be
a61af66fc99e Initial load duke parents: diff changeset	560 // biasable and have an epoch.
a61af66fc99e Initial load duke parents: diff changeset	561 markOop prototype_header() const { return _prototype_header; }
a61af66fc99e Initial load duke parents: diff changeset	562 // NOTE: once instances of this klass are floating around in the
a61af66fc99e Initial load duke parents: diff changeset	563 // system, this header must only be updated at a safepoint.
a61af66fc99e Initial load duke parents: diff changeset	564 // NOTE 2: currently we only ever set the prototype header to the
a61af66fc99e Initial load duke parents: diff changeset	565 // biasable prototype for instanceKlasses. There is no technical
a61af66fc99e Initial load duke parents: diff changeset	566 // reason why it could not be done for arrayKlasses aside from
a61af66fc99e Initial load duke parents: diff changeset	567 // wanting to reduce the initial scope of this optimization. There
a61af66fc99e Initial load duke parents: diff changeset	568 // are potential problems in setting the bias pattern for
a61af66fc99e Initial load duke parents: diff changeset	569 // JVM-internal oops.
a61af66fc99e Initial load duke parents: diff changeset	570 inline void set_prototype_header(markOop header);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	571 static ByteSize prototype_header_offset() { return in_ByteSize(offset_of(Klass, _prototype_header)); }
0 a61af66fc99e Initial load duke parents: diff changeset	572
a61af66fc99e Initial load duke parents: diff changeset	573 int biased_lock_revocation_count() const { return (int) _biased_lock_revocation_count; }
a61af66fc99e Initial load duke parents: diff changeset	574 // Atomically increments biased_lock_revocation_count and returns updated value
a61af66fc99e Initial load duke parents: diff changeset	575 int atomic_incr_biased_lock_revocation_count();
a61af66fc99e Initial load duke parents: diff changeset	576 void set_biased_lock_revocation_count(int val) { _biased_lock_revocation_count = (jint) val; }
a61af66fc99e Initial load duke parents: diff changeset	577 jlong last_biased_lock_bulk_revocation_time() { return _last_biased_lock_bulk_revocation_time; }
a61af66fc99e Initial load duke parents: diff changeset	578 void set_last_biased_lock_bulk_revocation_time(jlong cur_time) { _last_biased_lock_bulk_revocation_time = cur_time; }
a61af66fc99e Initial load duke parents: diff changeset	579
4800 94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 2376 diff changeset	580 TRACE_DEFINE_KLASS_METHODS;
0 a61af66fc99e Initial load duke parents: diff changeset	581
a61af66fc99e Initial load duke parents: diff changeset	582 // garbage collection support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	583 virtual void oops_do(OopClosure* cl);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	584
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	585 // Iff the class loader (or mirror for anonymous classes) is alive the
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	586 // Klass is considered alive.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	587 // The is_alive closure passed in depends on the Garbage Collector used.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	588 bool is_loader_alive(BoolObjectClosure* is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	589
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	590 static void clean_weak_klass_links(BoolObjectClosure* is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	591
a61af66fc99e Initial load duke parents: diff changeset	592 // Prefetch within oop iterators. This is a macro because we
a61af66fc99e Initial load duke parents: diff changeset	593 // can't guarantee that the compiler will inline it. In 64-bit
a61af66fc99e Initial load duke parents: diff changeset	594 // it generally doesn't. Signature is
a61af66fc99e Initial load duke parents: diff changeset	595 //
a61af66fc99e Initial load duke parents: diff changeset	596 // static void prefetch_beyond(oop* const start,
a61af66fc99e Initial load duke parents: diff changeset	597 // oop* const end,
a61af66fc99e Initial load duke parents: diff changeset	598 // const intx foffset,
a61af66fc99e Initial load duke parents: diff changeset	599 // const Prefetch::style pstyle);
a61af66fc99e Initial load duke parents: diff changeset	600 #define prefetch_beyond(start, end, foffset, pstyle) { \
a61af66fc99e Initial load duke parents: diff changeset	601 const intx foffset_ = (foffset); \
a61af66fc99e Initial load duke parents: diff changeset	602 const Prefetch::style pstyle_ = (pstyle); \
a61af66fc99e Initial load duke parents: diff changeset	603 assert(foffset_ > 0, "prefetch beyond, not behind"); \
a61af66fc99e Initial load duke parents: diff changeset	604 if (pstyle_ != Prefetch::do_none) { \
a61af66fc99e Initial load duke parents: diff changeset	605 oop* ref = (start); \
a61af66fc99e Initial load duke parents: diff changeset	606 if (ref < (end)) { \
a61af66fc99e Initial load duke parents: diff changeset	607 switch (pstyle_) { \
a61af66fc99e Initial load duke parents: diff changeset	608 case Prefetch::do_read: \
a61af66fc99e Initial load duke parents: diff changeset	609 Prefetch::read(*ref, foffset_); \
a61af66fc99e Initial load duke parents: diff changeset	610 break; \
a61af66fc99e Initial load duke parents: diff changeset	611 case Prefetch::do_write: \
a61af66fc99e Initial load duke parents: diff changeset	612 Prefetch::write(*ref, foffset_); \
a61af66fc99e Initial load duke parents: diff changeset	613 break; \
a61af66fc99e Initial load duke parents: diff changeset	614 default: \
a61af66fc99e Initial load duke parents: diff changeset	615 ShouldNotReachHere(); \
a61af66fc99e Initial load duke parents: diff changeset	616 break; \
a61af66fc99e Initial load duke parents: diff changeset	617 } \
a61af66fc99e Initial load duke parents: diff changeset	618 } \
a61af66fc99e Initial load duke parents: diff changeset	619 } \
a61af66fc99e Initial load duke parents: diff changeset	620 }
a61af66fc99e Initial load duke parents: diff changeset	621
a61af66fc99e Initial load duke parents: diff changeset	622 // iterators
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	623 virtual int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	624 virtual int oop_oop_iterate_v(oop obj, ExtendedOopClosure* blk) {
0 a61af66fc99e Initial load duke parents: diff changeset	625 return oop_oop_iterate(obj, blk);
a61af66fc99e Initial load duke parents: diff changeset	626 }
a61af66fc99e Initial load duke parents: diff changeset	627
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7409 diff changeset	628 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	629 // In case we don't have a specialized backward scanner use forward
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	630 // iteration.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	631 virtual int oop_oop_iterate_backwards_v(oop obj, ExtendedOopClosure* blk) {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	632 return oop_oop_iterate_v(obj, blk);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	633 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7409 diff changeset	634 #endif // INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	635
0 a61af66fc99e Initial load duke parents: diff changeset	636 // Iterates "blk" over all the oops in "obj" (of type "this") within "mr".
a61af66fc99e Initial load duke parents: diff changeset	637 // (I don't see why the _m should be required, but without it the Solaris
a61af66fc99e Initial load duke parents: diff changeset	638 // C++ gives warning messages about overridings of the "oop_oop_iterate"
a61af66fc99e Initial load duke parents: diff changeset	639 // defined above "hiding" this virtual function. (DLD, 6/20/00)) */
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	640 virtual int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	641 virtual int oop_oop_iterate_v_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
0 a61af66fc99e Initial load duke parents: diff changeset	642 return oop_oop_iterate_m(obj, blk, mr);
a61af66fc99e Initial load duke parents: diff changeset	643 }
a61af66fc99e Initial load duke parents: diff changeset	644
a61af66fc99e Initial load duke parents: diff changeset	645 // Versions of the above iterators specialized to particular subtypes
a61af66fc99e Initial load duke parents: diff changeset	646 // of OopClosure, to avoid closure virtual calls.
a61af66fc99e Initial load duke parents: diff changeset	647 #define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	648 virtual int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk) { \
a61af66fc99e Initial load duke parents: diff changeset	649 /* Default implementation reverts to general version. */ \
a61af66fc99e Initial load duke parents: diff changeset	650 return oop_oop_iterate(obj, blk); \
a61af66fc99e Initial load duke parents: diff changeset	651 } \
a61af66fc99e Initial load duke parents: diff changeset	652 \
a61af66fc99e Initial load duke parents: diff changeset	653 /* Iterates "blk" over all the oops in "obj" (of type "this") within "mr". \
a61af66fc99e Initial load duke parents: diff changeset	654 (I don't see why the _m should be required, but without it the Solaris \
a61af66fc99e Initial load duke parents: diff changeset	655 C++ gives warning messages about overridings of the "oop_oop_iterate" \
a61af66fc99e Initial load duke parents: diff changeset	656 defined above "hiding" this virtual function. (DLD, 6/20/00)) */ \
a61af66fc99e Initial load duke parents: diff changeset	657 virtual int oop_oop_iterate##nv_suffix##_m(oop obj, \
a61af66fc99e Initial load duke parents: diff changeset	658 OopClosureType* blk, \
a61af66fc99e Initial load duke parents: diff changeset	659 MemRegion mr) { \
a61af66fc99e Initial load duke parents: diff changeset	660 return oop_oop_iterate_m(obj, blk, mr); \
a61af66fc99e Initial load duke parents: diff changeset	661 }
a61af66fc99e Initial load duke parents: diff changeset	662
a61af66fc99e Initial load duke parents: diff changeset	663 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	664 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	665
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7409 diff changeset	666 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	667 #define Klass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	668 virtual int oop_oop_iterate_backwards##nv_suffix(oop obj, \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	669 OopClosureType* blk) { \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	670 /* Default implementation reverts to general version. */ \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	671 return oop_oop_iterate_backwards_v(obj, blk); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	672 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	673
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	674 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	675 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7409 diff changeset	676 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	677
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	678 virtual void array_klasses_do(void f(Klass* k)) {}
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	679 virtual void with_array_klasses_do(void f(Klass* k));
0 a61af66fc99e Initial load duke parents: diff changeset	680
a61af66fc99e Initial load duke parents: diff changeset	681 // Return self, except for abstract classes with exactly 1
a61af66fc99e Initial load duke parents: diff changeset	682 // implementor. Then return the 1 concrete implementation.
a61af66fc99e Initial load duke parents: diff changeset	683 Klass *up_cast_abstract();
a61af66fc99e Initial load duke parents: diff changeset	684
a61af66fc99e Initial load duke parents: diff changeset	685 // klass name
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	686 Symbol* name() const { return _name; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	687 void set_name(Symbol* n);
0 a61af66fc99e Initial load duke parents: diff changeset	688
a61af66fc99e Initial load duke parents: diff changeset	689 public:
a61af66fc99e Initial load duke parents: diff changeset	690 // jvm support
a61af66fc99e Initial load duke parents: diff changeset	691 virtual jint compute_modifier_flags(TRAPS) const;
a61af66fc99e Initial load duke parents: diff changeset	692
a61af66fc99e Initial load duke parents: diff changeset	693 // JVMTI support
a61af66fc99e Initial load duke parents: diff changeset	694 virtual jint jvmti_class_status() const;
a61af66fc99e Initial load duke parents: diff changeset	695
a61af66fc99e Initial load duke parents: diff changeset	696 // Printing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	697 virtual void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	698
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1039 diff changeset	699 virtual void oop_print_value_on(oop obj, outputStream* st);
0 a61af66fc99e Initial load duke parents: diff changeset	700 virtual void oop_print_on (oop obj, outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	701
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	702 virtual const char* internal_name() const = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	703
0 a61af66fc99e Initial load duke parents: diff changeset	704 // Verification
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	705 virtual void verify_on(outputStream* st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	706 void verify() { verify_on(tty); }
0 a61af66fc99e Initial load duke parents: diff changeset	707
a61af66fc99e Initial load duke parents: diff changeset	708 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	709 void verify_vtable_index(int index);
a61af66fc99e Initial load duke parents: diff changeset	710 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	711
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	712 virtual void oop_verify_on(oop obj, outputStream* st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	713
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	714 private:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	715 // barriers used by klass_oop_store
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	716 void klass_update_barrier_set(oop v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	717 void klass_update_barrier_set_pre(void* p, oop v);
0 a61af66fc99e Initial load duke parents: diff changeset	718 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	719
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	720 #endif // SHARE_VM_OOPS_KLASS_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/oops/klass.hpp @ 10185:d50cc62e94ff