Mercurial > hg > truffle
annotate src/share/vm/oops/klass.hpp @ 3011:f00918f35c7f
inlining and runtime interface related changes:
added codeSize() and compilerStorage() to RiMethod
HotSpotMethodResolved uses reflective methods instead of vmIds and survives compilations
HotSpotResolvedType.isInitialized not represented as field (can change)
inlining stores graphs into method objects and reuses them
| author | Lukas Stadler <lukas.stadler@jku.at> |
|---|---|
| date | Thu, 16 Jun 2011 20:36:17 +0200 |
| parents | 75a99b4f1c98 |
| children | 7604c69a6301 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_KLASS_HPP |
| 26 #define SHARE_VM_OOPS_KLASS_HPP | |
| 27 | |
| 28 #include "memory/genOopClosures.hpp" | |
| 29 #include "memory/iterator.hpp" | |
| 30 #include "memory/memRegion.hpp" | |
| 31 #include "memory/specialized_oop_closures.hpp" | |
| 32 #include "oops/klassOop.hpp" | |
| 33 #include "oops/klassPS.hpp" | |
| 34 #include "oops/oop.hpp" | |
| 35 #include "runtime/orderAccess.hpp" | |
| 36 #include "utilities/accessFlags.hpp" | |
| 37 #ifndef SERIALGC | |
| 38 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp" | |
| 39 #include "gc_implementation/g1/g1OopClosures.hpp" | |
| 40 #include "gc_implementation/parNew/parOopClosures.hpp" | |
| 41 #endif | |
| 42 | |
| 0 | 43 // A Klass is the part of the klassOop that provides: |
| 44 // 1: language level class object (method dictionary etc.) | |
| 45 // 2: provide vm dispatch behavior for the object | |
| 46 // Both functions are combined into one C++ class. The toplevel class "Klass" | |
| 47 // implements purpose 1 whereas all subclasses provide extra virtual functions | |
| 48 // for purpose 2. | |
| 49 | |
| 50 // One reason for the oop/klass dichotomy in the implementation is | |
| 51 // that we don't want a C++ vtbl pointer in every object. Thus, | |
| 52 // normal oops don't have any virtual functions. Instead, they | |
| 53 // forward all "virtual" functions to their klass, which does have | |
| 54 // a vtbl and does the C++ dispatch depending on the object's | |
| 55 // actual type. (See oop.inline.hpp for some of the forwarding code.) | |
| 56 // ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"! | |
| 57 | |
| 58 // Klass layout: | |
| 59 // [header ] klassOop | |
| 60 // [klass pointer ] klassOop | |
| 61 // [C++ vtbl ptr ] (contained in Klass_vtbl) | |
| 62 // [layout_helper ] | |
| 63 // [super_check_offset ] for fast subtype checks | |
| 64 // [secondary_super_cache] for fast subtype checks | |
| 65 // [secondary_supers ] array of 2ndary supertypes | |
| 66 // [primary_supers 0] | |
| 67 // [primary_supers 1] | |
| 68 // [primary_supers 2] | |
| 69 // ... | |
| 70 // [primary_supers 7] | |
| 71 // [java_mirror ] | |
| 72 // [super ] | |
| 73 // [name ] | |
| 74 // [first subklass] | |
| 75 // [next_sibling ] link to chain additional subklasses | |
| 76 // [modifier_flags] | |
| 77 // [access_flags ] | |
| 78 // [verify_count ] - not in product | |
| 79 // [alloc_count ] | |
| 80 // [last_biased_lock_bulk_revocation_time] (64 bits) | |
| 81 // [prototype_header] | |
| 82 // [biased_lock_revocation_count] | |
| 83 | |
| 84 | |
| 85 // Forward declarations. | |
| 86 class klassVtable; | |
| 87 class KlassHandle; | |
| 88 class OrderAccess; | |
| 89 | |
| 90 // Holder (or cage) for the C++ vtable of each kind of Klass. | |
| 91 // We want to tightly constrain the location of the C++ vtable in the overall layout. | |
| 92 class Klass_vtbl { | |
| 93 protected: | |
| 94 // The following virtual exists only to force creation of a C++ vtable, | |
| 95 // so that this class truly is the location of the vtable of all Klasses. | |
| 96 virtual void unused_initial_virtual() { } | |
| 97 | |
| 98 public: | |
| 99 // The following virtual makes Klass_vtbl play a second role as a | |
| 100 // factory protocol for subclasses of Klass ("sub-Klasses"). | |
| 101 // Here's how it works.... | |
| 102 // | |
| 103 // This VM uses metaobjects as factories for their instances. | |
| 104 // | |
| 105 // In order to initialize the C++ vtable of a new instance, its | |
| 106 // metaobject is forced to use the C++ placed new operator to | |
| 107 // allocate the instance. In a typical C++-based system, each | |
| 108 // sub-class would have its own factory routine which | |
| 109 // directly uses the placed new operator on the desired class, | |
| 110 // and then calls the appropriate chain of C++ constructors. | |
| 111 // | |
| 112 // However, this system uses shared code to performs the first | |
| 113 // allocation and initialization steps for all sub-Klasses. | |
| 114 // (See base_create_klass() and base_create_array_klass().) | |
| 115 // This does not factor neatly into a hierarchy of C++ constructors. | |
| 116 // Each caller of these shared "base_create" routines knows | |
| 117 // exactly which sub-Klass it is creating, but the shared routine | |
| 118 // does not, even though it must perform the actual allocation. | |
| 119 // | |
| 120 // Therefore, the caller of the shared "base_create" must wrap | |
| 121 // the specific placed new call in a virtual function which | |
| 122 // performs the actual allocation and vtable set-up. That | |
| 123 // virtual function is here, Klass_vtbl::allocate_permanent. | |
| 124 // | |
| 125 // The arguments to Universe::allocate_permanent() are passed | |
| 126 // straight through the placed new operator, which in turn | |
| 127 // obtains them directly from this virtual call. | |
| 128 // | |
| 129 // This virtual is called on a temporary "example instance" of the | |
| 130 // sub-Klass being instantiated, a C++ auto variable. The "real" | |
| 131 // instance created by this virtual is on the VM heap, where it is | |
| 132 // equipped with a klassOopDesc header. | |
| 133 // | |
| 134 // It is merely an accident of implementation that we use "example | |
| 135 // instances", but that is why the virtual function which implements | |
| 136 // each sub-Klass factory happens to be defined by the same sub-Klass | |
| 137 // for which it creates instances. | |
| 138 // | |
| 139 // The vtbl_value() call (see below) is used to strip away the | |
| 140 // accidental Klass-ness from an "example instance" and present it as | |
| 141 // a factory. Think of each factory object as a mere container of the | |
| 142 // C++ vtable for the desired sub-Klass. Since C++ does not allow | |
| 143 // direct references to vtables, the factory must also be delegated | |
| 144 // the task of allocating the instance, but the essential point is | |
| 145 // that the factory knows how to initialize the C++ vtable with the | |
| 146 // right pointer value. All other common initializations are handled | |
| 147 // by the shared "base_create" subroutines. | |
| 148 // | |
| 149 virtual void* allocate_permanent(KlassHandle& klass, int size, TRAPS) const = 0; | |
| 150 void post_new_init_klass(KlassHandle& klass, klassOop obj, int size) const; | |
| 151 | |
| 152 // Every subclass on which vtbl_value is called must include this macro. | |
| 153 // Delay the installation of the klassKlass pointer until after the | |
| 154 // the vtable for a new klass has been installed (after the call to new()). | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
155 #define DEFINE_ALLOCATE_PERMANENT(thisKlass) \ |
| 0 | 156 void* allocate_permanent(KlassHandle& klass_klass, int size, TRAPS) const { \ |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
157 void* result = new(klass_klass, size, THREAD) thisKlass(); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
158 if (HAS_PENDING_EXCEPTION) return NULL; \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
159 klassOop new_klass = ((Klass*) result)->as_klassOop(); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
160 OrderAccess::storestore(); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
161 post_new_init_klass(klass_klass, new_klass, size); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
162 return result; \ |
| 0 | 163 } |
| 164 | |
| 165 bool null_vtbl() { return *(intptr_t*)this == 0; } | |
| 166 | |
| 167 protected: | |
| 168 void* operator new(size_t ignored, KlassHandle& klass, int size, TRAPS); | |
| 169 }; | |
| 170 | |
| 171 | |
| 172 class Klass : public Klass_vtbl { | |
| 173 friend class VMStructs; | |
| 174 protected: | |
| 175 // note: put frequently-used fields together at start of klass structure | |
| 176 // for better cache behavior (may not make much of a difference but sure won't hurt) | |
| 177 enum { _primary_super_limit = 8 }; | |
| 178 | |
| 179 // The "layout helper" is a combined descriptor of object layout. | |
| 180 // For klasses which are neither instance nor array, the value is zero. | |
| 181 // | |
| 182 // For instances, layout helper is a positive number, the instance size. | |
| 183 // This size is already passed through align_object_size and scaled to bytes. | |
| 184 // The low order bit is set if instances of this class cannot be | |
| 185 // allocated using the fastpath. | |
| 186 // | |
| 187 // For arrays, layout helper is a negative number, containing four | |
| 188 // distinct bytes, as follows: | |
| 189 // MSB:[tag, hsz, ebt, log2(esz)]:LSB | |
| 190 // where: | |
| 191 // tag is 0x80 if the elements are oops, 0xC0 if non-oops | |
| 192 // hsz is array header size in bytes (i.e., offset of first element) | |
| 193 // ebt is the BasicType of the elements | |
| 194 // esz is the element size in bytes | |
| 195 // This packed word is arranged so as to be quickly unpacked by the | |
| 196 // various fast paths that use the various subfields. | |
| 197 // | |
| 198 // The esz bits can be used directly by a SLL instruction, without masking. | |
| 199 // | |
| 200 // Note that the array-kind tag looks like 0x00 for instance klasses, | |
| 201 // since their length in bytes is always less than 24Mb. | |
| 202 // | |
| 203 // Final note: This comes first, immediately after Klass_vtbl, | |
| 204 // because it is frequently queried. | |
| 205 jint _layout_helper; | |
| 206 | |
| 207 // The fields _super_check_offset, _secondary_super_cache, _secondary_supers | |
| 208 // and _primary_supers all help make fast subtype checks. See big discussion | |
| 209 // in doc/server_compiler/checktype.txt | |
| 210 // | |
| 211 // Where to look to observe a supertype (it is &_secondary_super_cache for | |
| 212 // secondary supers, else is &_primary_supers[depth()]. | |
| 213 juint _super_check_offset; | |
| 214 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
215 // 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
|
216 // [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
|
217 Symbol* _name; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
218 |
| 0 | 219 public: |
| 220 oop* oop_block_beg() const { return adr_secondary_super_cache(); } | |
| 221 oop* oop_block_end() const { return adr_next_sibling() + 1; } | |
| 222 | |
| 223 protected: | |
| 224 // | |
| 225 // The oop block. All oop fields must be declared here and only oop fields | |
| 226 // may be declared here. In addition, the first and last fields in this block | |
| 227 // must remain first and last, unless oop_block_beg() and/or oop_block_end() | |
| 228 // are updated. Grouping the oop fields in a single block simplifies oop | |
| 229 // iteration. | |
| 230 // | |
| 231 | |
| 232 // Cache of last observed secondary supertype | |
| 233 klassOop _secondary_super_cache; | |
| 234 // Array of all secondary supertypes | |
| 235 objArrayOop _secondary_supers; | |
| 236 // Ordered list of all primary supertypes | |
| 237 klassOop _primary_supers[_primary_super_limit]; | |
| 238 // java/lang/Class instance mirroring this class | |
| 239 oop _java_mirror; | |
|
2874
d90bf514d647
Renamed packages.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2501
diff
changeset
|
240 // com/oracle/max/graal/runtime/HotSpotTypeResolved mirroring this class |
|
2891
75a99b4f1c98
Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2874
diff
changeset
|
241 oop _graal_mirror; |
| 0 | 242 // Superclass |
| 243 klassOop _super; | |
| 244 // First subclass (NULL if none); _subklass->next_sibling() is next one | |
| 245 klassOop _subklass; | |
| 246 // Sibling link (or NULL); links all subklasses of a klass | |
| 247 klassOop _next_sibling; | |
| 248 | |
| 249 // | |
| 250 // End of the oop block. | |
| 251 // | |
| 252 | |
| 253 jint _modifier_flags; // Processed access flags, for use by Class.getModifiers. | |
| 254 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here. | |
| 255 | |
| 256 #ifndef PRODUCT | |
| 257 int _verify_count; // to avoid redundant verifies | |
| 258 #endif | |
| 259 | |
| 260 juint _alloc_count; // allocation profiling support - update klass_size_in_bytes() if moved/deleted | |
| 261 | |
| 262 // Biased locking implementation and statistics | |
| 263 // (the 64-bit chunk goes first, to avoid some fragmentation) | |
| 264 jlong _last_biased_lock_bulk_revocation_time; | |
| 265 markOop _prototype_header; // Used when biased locking is both enabled and disabled for this type | |
| 266 jint _biased_lock_revocation_count; | |
| 267 | |
| 268 public: | |
| 269 | |
| 270 // returns the enclosing klassOop | |
| 271 klassOop as_klassOop() const { | |
| 272 // see klassOop.hpp for layout. | |
| 273 return (klassOop) (((char*) this) - sizeof(klassOopDesc)); | |
| 274 } | |
| 275 | |
| 276 public: | |
| 277 // Allocation | |
| 278 const Klass_vtbl& vtbl_value() const { return *this; } // used only on "example instances" | |
| 279 static KlassHandle base_create_klass(KlassHandle& klass, int size, const Klass_vtbl& vtbl, TRAPS); | |
| 280 static klassOop base_create_klass_oop(KlassHandle& klass, int size, const Klass_vtbl& vtbl, TRAPS); | |
| 281 | |
| 282 // super | |
| 283 klassOop super() const { return _super; } | |
| 284 void set_super(klassOop k) { oop_store_without_check((oop*) &_super, (oop) k); } | |
| 285 | |
| 286 // initializes _super link, _primary_supers & _secondary_supers arrays | |
| 287 void initialize_supers(klassOop k, TRAPS); | |
| 288 void initialize_supers_impl1(klassOop k); | |
| 289 void initialize_supers_impl2(klassOop k); | |
| 290 | |
| 291 // klass-specific helper for initializing _secondary_supers | |
| 292 virtual objArrayOop compute_secondary_supers(int num_extra_slots, TRAPS); | |
| 293 | |
| 294 // java_super is the Java-level super type as specified by Class.getSuperClass. | |
| 295 virtual klassOop java_super() const { return NULL; } | |
| 296 | |
| 297 juint super_check_offset() const { return _super_check_offset; } | |
| 298 void set_super_check_offset(juint o) { _super_check_offset = o; } | |
| 299 | |
| 300 klassOop secondary_super_cache() const { return _secondary_super_cache; } | |
| 301 void set_secondary_super_cache(klassOop k) { oop_store_without_check((oop*) &_secondary_super_cache, (oop) k); } | |
| 302 | |
| 303 objArrayOop secondary_supers() const { return _secondary_supers; } | |
| 304 void set_secondary_supers(objArrayOop k) { oop_store_without_check((oop*) &_secondary_supers, (oop) k); } | |
| 305 | |
| 306 // Return the element of the _super chain of the given depth. | |
| 307 // If there is no such element, return either NULL or this. | |
| 308 klassOop primary_super_of_depth(juint i) const { | |
| 309 assert(i < primary_super_limit(), "oob"); | |
| 310 klassOop super = _primary_supers[i]; | |
| 311 assert(super == NULL || super->klass_part()->super_depth() == i, "correct display"); | |
| 312 return super; | |
| 313 } | |
| 314 | |
| 315 // Can this klass be a primary super? False for interfaces and arrays of | |
| 316 // interfaces. False also for arrays or classes with long super chains. | |
| 317 bool can_be_primary_super() const { | |
| 318 const juint secondary_offset = secondary_super_cache_offset_in_bytes() + sizeof(oopDesc); | |
| 319 return super_check_offset() != secondary_offset; | |
| 320 } | |
| 321 virtual bool can_be_primary_super_slow() const; | |
| 322 | |
| 323 // Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit]. | |
| 324 juint super_depth() const { | |
| 325 if (!can_be_primary_super()) { | |
| 326 return primary_super_limit(); | |
| 327 } else { | |
| 328 juint d = (super_check_offset() - (primary_supers_offset_in_bytes() + sizeof(oopDesc))) / sizeof(klassOop); | |
| 329 assert(d < primary_super_limit(), "oob"); | |
| 330 assert(_primary_supers[d] == as_klassOop(), "proper init"); | |
| 331 return d; | |
| 332 } | |
| 333 } | |
| 334 | |
| 335 // java mirror | |
| 336 oop java_mirror() const { return _java_mirror; } | |
| 337 void set_java_mirror(oop m) { oop_store((oop*) &_java_mirror, m); } | |
| 338 | |
|
2891
75a99b4f1c98
Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2874
diff
changeset
|
339 // graal mirror |
|
75a99b4f1c98
Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2874
diff
changeset
|
340 oop graal_mirror() const { return _graal_mirror; } |
|
75a99b4f1c98
Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2874
diff
changeset
|
341 void set_graal_mirror(oop m) { oop_store((oop*) &_graal_mirror, m); } |
|
1941
79d04223b8a5
Added caching for resolved types and resolved fields.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents:
1681
diff
changeset
|
342 |
| 0 | 343 // modifier flags |
| 344 jint modifier_flags() const { return _modifier_flags; } | |
| 345 void set_modifier_flags(jint flags) { _modifier_flags = flags; } | |
| 346 | |
| 347 // size helper | |
| 348 int layout_helper() const { return _layout_helper; } | |
| 349 void set_layout_helper(int lh) { _layout_helper = lh; } | |
| 350 | |
| 351 // Note: for instances layout_helper() may include padding. | |
| 352 // Use instanceKlass::contains_field_offset to classify field offsets. | |
| 353 | |
| 354 // sub/superklass links | |
| 355 instanceKlass* superklass() const; | |
| 356 Klass* subklass() const; | |
| 357 Klass* next_sibling() const; | |
| 358 void append_to_sibling_list(); // add newly created receiver to superklass' subklass list | |
| 359 void remove_from_sibling_list(); // remove receiver from sibling list | |
| 360 protected: // internal accessors | |
| 361 klassOop subklass_oop() const { return _subklass; } | |
| 362 klassOop next_sibling_oop() const { return _next_sibling; } | |
| 363 void set_subklass(klassOop s); | |
| 364 void set_next_sibling(klassOop s); | |
| 365 | |
| 366 oop* adr_super() const { return (oop*)&_super; } | |
| 367 oop* adr_primary_supers() const { return (oop*)&_primary_supers[0]; } | |
| 368 oop* adr_secondary_super_cache() const { return (oop*)&_secondary_super_cache; } | |
| 369 oop* adr_secondary_supers()const { return (oop*)&_secondary_supers; } | |
| 370 oop* adr_java_mirror() const { return (oop*)&_java_mirror; } | |
|
3011
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2891
diff
changeset
|
371 oop* adr_graal_mirror() const { return (oop*)&_graal_mirror; } |
| 0 | 372 oop* adr_subklass() const { return (oop*)&_subklass; } |
| 373 oop* adr_next_sibling() const { return (oop*)&_next_sibling; } | |
| 374 | |
| 375 public: | |
| 376 // Allocation profiling support | |
| 377 juint alloc_count() const { return _alloc_count; } | |
| 378 void set_alloc_count(juint n) { _alloc_count = n; } | |
| 379 virtual juint alloc_size() const = 0; | |
| 380 virtual void set_alloc_size(juint n) = 0; | |
| 381 | |
| 382 // Compiler support | |
| 383 static int super_offset_in_bytes() { return offset_of(Klass, _super); } | |
| 384 static int super_check_offset_offset_in_bytes() { return offset_of(Klass, _super_check_offset); } | |
| 385 static int primary_supers_offset_in_bytes(){ return offset_of(Klass, _primary_supers); } | |
| 386 static int secondary_super_cache_offset_in_bytes() { return offset_of(Klass, _secondary_super_cache); } | |
| 387 static int secondary_supers_offset_in_bytes() { return offset_of(Klass, _secondary_supers); } | |
| 388 static int java_mirror_offset_in_bytes() { return offset_of(Klass, _java_mirror); } | |
| 389 static int modifier_flags_offset_in_bytes(){ return offset_of(Klass, _modifier_flags); } | |
| 390 static int layout_helper_offset_in_bytes() { return offset_of(Klass, _layout_helper); } | |
| 391 static int access_flags_offset_in_bytes() { return offset_of(Klass, _access_flags); } | |
| 392 | |
| 393 // Unpacking layout_helper: | |
| 394 enum { | |
| 395 _lh_neutral_value = 0, // neutral non-array non-instance value | |
| 396 _lh_instance_slow_path_bit = 0x01, | |
| 397 _lh_log2_element_size_shift = BitsPerByte*0, | |
| 398 _lh_log2_element_size_mask = BitsPerLong-1, | |
| 399 _lh_element_type_shift = BitsPerByte*1, | |
| 400 _lh_element_type_mask = right_n_bits(BitsPerByte), // shifted mask | |
| 401 _lh_header_size_shift = BitsPerByte*2, | |
| 402 _lh_header_size_mask = right_n_bits(BitsPerByte), // shifted mask | |
| 403 _lh_array_tag_bits = 2, | |
| 404 _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits, | |
| 405 _lh_array_tag_type_value = ~0x00, // 0xC0000000 >> 30 | |
| 406 _lh_array_tag_obj_value = ~0x01 // 0x80000000 >> 30 | |
| 407 }; | |
| 408 | |
| 409 static int layout_helper_size_in_bytes(jint lh) { | |
| 410 assert(lh > (jint)_lh_neutral_value, "must be instance"); | |
| 411 return (int) lh & ~_lh_instance_slow_path_bit; | |
| 412 } | |
| 413 static bool layout_helper_needs_slow_path(jint lh) { | |
| 414 assert(lh > (jint)_lh_neutral_value, "must be instance"); | |
| 415 return (lh & _lh_instance_slow_path_bit) != 0; | |
| 416 } | |
| 417 static bool layout_helper_is_instance(jint lh) { | |
| 418 return (jint)lh > (jint)_lh_neutral_value; | |
| 419 } | |
| 420 static bool layout_helper_is_javaArray(jint lh) { | |
| 421 return (jint)lh < (jint)_lh_neutral_value; | |
| 422 } | |
| 423 static bool layout_helper_is_typeArray(jint lh) { | |
| 424 // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift); | |
| 425 return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift); | |
| 426 } | |
| 427 static bool layout_helper_is_objArray(jint lh) { | |
| 428 // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift); | |
| 429 return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift); | |
| 430 } | |
| 431 static int layout_helper_header_size(jint lh) { | |
| 432 assert(lh < (jint)_lh_neutral_value, "must be array"); | |
| 433 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask; | |
| 434 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity"); | |
| 435 return hsize; | |
| 436 } | |
| 437 static BasicType layout_helper_element_type(jint lh) { | |
| 438 assert(lh < (jint)_lh_neutral_value, "must be array"); | |
| 439 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask; | |
| 440 assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity"); | |
| 441 return (BasicType) btvalue; | |
| 442 } | |
| 443 static int layout_helper_log2_element_size(jint lh) { | |
| 444 assert(lh < (jint)_lh_neutral_value, "must be array"); | |
| 445 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask; | |
| 446 assert(l2esz <= LogBitsPerLong, "sanity"); | |
| 447 return l2esz; | |
| 448 } | |
| 449 static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) { | |
| 450 return (tag << _lh_array_tag_shift) | |
| 451 | (hsize << _lh_header_size_shift) | |
| 452 | ((int)etype << _lh_element_type_shift) | |
| 453 | (log2_esize << _lh_log2_element_size_shift); | |
| 454 } | |
| 455 static jint instance_layout_helper(jint size, bool slow_path_flag) { | |
| 456 return (size << LogHeapWordSize) | |
| 457 | (slow_path_flag ? _lh_instance_slow_path_bit : 0); | |
| 458 } | |
| 459 static int layout_helper_to_size_helper(jint lh) { | |
| 460 assert(lh > (jint)_lh_neutral_value, "must be instance"); | |
| 461 // Note that the following expression discards _lh_instance_slow_path_bit. | |
| 462 return lh >> LogHeapWordSize; | |
| 463 } | |
| 464 // Out-of-line version computes everything based on the etype: | |
| 465 static jint array_layout_helper(BasicType etype); | |
| 466 | |
| 467 // What is the maximum number of primary superclasses any klass can have? | |
| 468 #ifdef PRODUCT | |
| 469 static juint primary_super_limit() { return _primary_super_limit; } | |
| 470 #else | |
| 471 static juint primary_super_limit() { | |
| 472 assert(FastSuperclassLimit <= _primary_super_limit, "parameter oob"); | |
| 473 return FastSuperclassLimit; | |
| 474 } | |
| 475 #endif | |
| 476 | |
| 477 // vtables | |
| 478 virtual klassVtable* vtable() const { return NULL; } | |
| 479 | |
| 480 static int klass_size_in_bytes() { return offset_of(Klass, _alloc_count) + sizeof(juint); } // all "visible" fields | |
| 481 | |
| 482 // subclass check | |
| 483 bool is_subclass_of(klassOop k) const; | |
| 484 // subtype check: true if is_subclass_of, or if k is interface and receiver implements it | |
| 485 bool is_subtype_of(klassOop k) const { | |
| 486 juint off = k->klass_part()->super_check_offset(); | |
| 487 klassOop sup = *(klassOop*)( (address)as_klassOop() + off ); | |
| 488 const juint secondary_offset = secondary_super_cache_offset_in_bytes() + sizeof(oopDesc); | |
| 489 if (sup == k) { | |
| 490 return true; | |
| 491 } else if (off != secondary_offset) { | |
| 492 return false; | |
| 493 } else { | |
| 494 return search_secondary_supers(k); | |
| 495 } | |
| 496 } | |
| 497 bool search_secondary_supers(klassOop k) const; | |
| 498 | |
| 605 | 499 // Find LCA in class hierarchy |
| 0 | 500 Klass *LCA( Klass *k ); |
| 501 | |
| 502 // Check whether reflection/jni/jvm code is allowed to instantiate this class; | |
| 503 // if not, throw either an Error or an Exception. | |
| 504 virtual void check_valid_for_instantiation(bool throwError, TRAPS); | |
| 505 | |
| 506 // Casting | |
| 507 static Klass* cast(klassOop k) { | |
| 508 assert(k->is_klass(), "cast to Klass"); | |
| 509 return k->klass_part(); | |
| 510 } | |
| 511 | |
| 512 // array copying | |
| 513 virtual void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS); | |
| 514 | |
| 515 // tells if the class should be initialized | |
| 516 virtual bool should_be_initialized() const { return false; } | |
| 517 // initializes the klass | |
| 518 virtual void initialize(TRAPS); | |
| 519 // lookup operation for MethodLookupCache | |
| 520 friend class MethodLookupCache; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
521 virtual methodOop uncached_lookup_method(Symbol* name, Symbol* signature) const; |
| 0 | 522 public: |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
523 methodOop lookup_method(Symbol* name, Symbol* signature) const { |
| 0 | 524 return uncached_lookup_method(name, signature); |
| 525 } | |
| 526 | |
| 527 // array class with specific rank | |
| 528 klassOop array_klass(int rank, TRAPS) { return array_klass_impl(false, rank, THREAD); } | |
| 529 | |
| 530 // array class with this klass as element type | |
| 531 klassOop array_klass(TRAPS) { return array_klass_impl(false, THREAD); } | |
| 532 | |
| 533 // These will return NULL instead of allocating on the heap: | |
| 534 // NB: these can block for a mutex, like other functions with TRAPS arg. | |
| 535 klassOop array_klass_or_null(int rank); | |
| 536 klassOop array_klass_or_null(); | |
| 537 | |
| 538 virtual oop protection_domain() { return NULL; } | |
| 539 virtual oop class_loader() const { return NULL; } | |
| 540 | |
| 541 protected: | |
| 542 virtual klassOop array_klass_impl(bool or_null, int rank, TRAPS); | |
| 543 virtual klassOop array_klass_impl(bool or_null, TRAPS); | |
| 544 | |
| 545 public: | |
| 546 virtual void remove_unshareable_info(); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
547 virtual void shared_symbols_iterate(SymbolClosure* closure); |
| 0 | 548 |
| 549 protected: | |
| 550 // computes the subtype relationship | |
| 551 virtual bool compute_is_subtype_of(klassOop k); | |
| 552 public: | |
| 553 // subclass accessor (here for convenience; undefined for non-klass objects) | |
| 554 virtual bool is_leaf_class() const { fatal("not a class"); return false; } | |
| 555 public: | |
| 556 // ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP | |
| 557 // These functions describe behavior for the oop not the KLASS. | |
| 558 | |
| 559 // actual oop size of obj in memory | |
| 560 virtual int oop_size(oop obj) const = 0; | |
| 561 | |
| 562 // actual oop size of this klass in memory | |
| 563 virtual int klass_oop_size() const = 0; | |
| 564 | |
| 565 // Returns the Java name for a class (Resource allocated) | |
| 566 // For arrays, this returns the name of the element with a leading '['. | |
| 567 // For classes, this returns the name with the package separators | |
| 568 // turned into '.'s. | |
| 569 const char* external_name() const; | |
| 570 // Returns the name for a class (Resource allocated) as the class | |
| 571 // would appear in a signature. | |
| 572 // For arrays, this returns the name of the element with a leading '['. | |
| 573 // For classes, this returns the name with a leading 'L' and a trailing ';' | |
| 574 // and the package separators as '/'. | |
|
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
628
diff
changeset
|
575 virtual const char* signature_name() const; |
| 0 | 576 |
| 577 // garbage collection support | |
| 578 virtual void oop_follow_contents(oop obj) = 0; | |
| 579 virtual int oop_adjust_pointers(oop obj) = 0; | |
| 580 | |
| 581 // Parallel Scavenge and Parallel Old | |
| 582 PARALLEL_GC_DECLS_PV | |
| 583 | |
| 584 public: | |
| 585 // type testing operations | |
| 586 virtual bool oop_is_instance_slow() const { return false; } | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
587 virtual bool oop_is_instanceMirror() const { return false; } |
| 0 | 588 virtual bool oop_is_instanceRef() const { return false; } |
| 589 virtual bool oop_is_array() const { return false; } | |
| 590 virtual bool oop_is_objArray_slow() const { return false; } | |
| 591 virtual bool oop_is_klass() const { return false; } | |
| 592 virtual bool oop_is_thread() const { return false; } | |
| 593 virtual bool oop_is_method() const { return false; } | |
| 594 virtual bool oop_is_constMethod() const { return false; } | |
| 595 virtual bool oop_is_methodData() const { return false; } | |
| 596 virtual bool oop_is_constantPool() const { return false; } | |
| 597 virtual bool oop_is_constantPoolCache() const { return false; } | |
| 598 virtual bool oop_is_typeArray_slow() const { return false; } | |
| 599 virtual bool oop_is_arrayKlass() const { return false; } | |
| 600 virtual bool oop_is_objArrayKlass() const { return false; } | |
| 601 virtual bool oop_is_typeArrayKlass() const { return false; } | |
| 602 virtual bool oop_is_compiledICHolder() const { return false; } | |
| 603 virtual bool oop_is_instanceKlass() const { return false; } | |
| 604 | |
| 605 bool oop_is_javaArray_slow() const { | |
| 606 return oop_is_objArray_slow() || oop_is_typeArray_slow(); | |
| 607 } | |
| 608 | |
| 609 // Fast non-virtual versions, used by oop.inline.hpp and elsewhere: | |
| 610 #ifndef ASSERT | |
| 611 #define assert_same_query(xval, xcheck) xval | |
| 612 #else | |
| 613 private: | |
| 614 static bool assert_same_query(bool xval, bool xslow) { | |
| 615 assert(xval == xslow, "slow and fast queries agree"); | |
| 616 return xval; | |
| 617 } | |
| 618 public: | |
| 619 #endif | |
| 620 inline bool oop_is_instance() const { return assert_same_query( | |
| 621 layout_helper_is_instance(layout_helper()), | |
| 622 oop_is_instance_slow()); } | |
| 623 inline bool oop_is_javaArray() const { return assert_same_query( | |
| 624 layout_helper_is_javaArray(layout_helper()), | |
| 625 oop_is_javaArray_slow()); } | |
| 626 inline bool oop_is_objArray() const { return assert_same_query( | |
| 627 layout_helper_is_objArray(layout_helper()), | |
| 628 oop_is_objArray_slow()); } | |
| 629 inline bool oop_is_typeArray() const { return assert_same_query( | |
| 630 layout_helper_is_typeArray(layout_helper()), | |
| 631 oop_is_typeArray_slow()); } | |
| 632 #undef assert_same_query | |
| 633 | |
| 634 // Unless overridden, oop is parsable if it has a klass pointer. | |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
635 // Parsability of an object is object specific. |
| 0 | 636 virtual bool oop_is_parsable(oop obj) const { return true; } |
| 637 | |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
638 // Unless overridden, oop is safe for concurrent GC processing |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
639 // after its allocation is complete. The exception to |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
640 // this is the case where objects are changed after allocation. |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
641 // Class redefinition is one of the known exceptions. During |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
642 // class redefinition, an allocated class can changed in order |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
643 // order to create a merged class (the combiniation of the |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
644 // old class definition that has to be perserved and the new class |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
645 // definition which is being created. |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
646 virtual bool oop_is_conc_safe(oop obj) const { return true; } |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
356
diff
changeset
|
647 |
| 0 | 648 // Access flags |
| 649 AccessFlags access_flags() const { return _access_flags; } | |
| 650 void set_access_flags(AccessFlags flags) { _access_flags = flags; } | |
| 651 | |
| 652 bool is_public() const { return _access_flags.is_public(); } | |
| 653 bool is_final() const { return _access_flags.is_final(); } | |
| 654 bool is_interface() const { return _access_flags.is_interface(); } | |
| 655 bool is_abstract() const { return _access_flags.is_abstract(); } | |
| 656 bool is_super() const { return _access_flags.is_super(); } | |
| 657 bool is_synthetic() const { return _access_flags.is_synthetic(); } | |
| 658 void set_is_synthetic() { _access_flags.set_is_synthetic(); } | |
| 659 bool has_finalizer() const { return _access_flags.has_finalizer(); } | |
| 660 bool has_final_method() const { return _access_flags.has_final_method(); } | |
| 661 void set_has_finalizer() { _access_flags.set_has_finalizer(); } | |
| 662 void set_has_final_method() { _access_flags.set_has_final_method(); } | |
| 663 bool is_cloneable() const { return _access_flags.is_cloneable(); } | |
| 664 void set_is_cloneable() { _access_flags.set_is_cloneable(); } | |
| 665 bool has_vanilla_constructor() const { return _access_flags.has_vanilla_constructor(); } | |
| 666 void set_has_vanilla_constructor() { _access_flags.set_has_vanilla_constructor(); } | |
| 667 bool has_miranda_methods () const { return access_flags().has_miranda_methods(); } | |
| 668 void set_has_miranda_methods() { _access_flags.set_has_miranda_methods(); } | |
| 669 | |
| 670 // Biased locking support | |
| 671 // Note: the prototype header is always set up to be at least the | |
| 672 // prototype markOop. If biased locking is enabled it may further be | |
| 673 // biasable and have an epoch. | |
| 674 markOop prototype_header() const { return _prototype_header; } | |
| 675 // NOTE: once instances of this klass are floating around in the | |
| 676 // system, this header must only be updated at a safepoint. | |
| 677 // NOTE 2: currently we only ever set the prototype header to the | |
| 678 // biasable prototype for instanceKlasses. There is no technical | |
| 679 // reason why it could not be done for arrayKlasses aside from | |
| 680 // wanting to reduce the initial scope of this optimization. There | |
| 681 // are potential problems in setting the bias pattern for | |
| 682 // JVM-internal oops. | |
| 683 inline void set_prototype_header(markOop header); | |
| 684 static int prototype_header_offset_in_bytes() { return offset_of(Klass, _prototype_header); } | |
| 685 | |
| 686 int biased_lock_revocation_count() const { return (int) _biased_lock_revocation_count; } | |
| 687 // Atomically increments biased_lock_revocation_count and returns updated value | |
| 688 int atomic_incr_biased_lock_revocation_count(); | |
| 689 void set_biased_lock_revocation_count(int val) { _biased_lock_revocation_count = (jint) val; } | |
| 690 jlong last_biased_lock_bulk_revocation_time() { return _last_biased_lock_bulk_revocation_time; } | |
| 691 void set_last_biased_lock_bulk_revocation_time(jlong cur_time) { _last_biased_lock_bulk_revocation_time = cur_time; } | |
| 692 | |
| 693 | |
| 694 // garbage collection support | |
| 695 virtual void follow_weak_klass_links( | |
| 696 BoolObjectClosure* is_alive, OopClosure* keep_alive); | |
| 697 | |
| 698 // Prefetch within oop iterators. This is a macro because we | |
| 699 // can't guarantee that the compiler will inline it. In 64-bit | |
| 700 // it generally doesn't. Signature is | |
| 701 // | |
| 702 // static void prefetch_beyond(oop* const start, | |
| 703 // oop* const end, | |
| 704 // const intx foffset, | |
| 705 // const Prefetch::style pstyle); | |
| 706 #define prefetch_beyond(start, end, foffset, pstyle) { \ | |
| 707 const intx foffset_ = (foffset); \ | |
| 708 const Prefetch::style pstyle_ = (pstyle); \ | |
| 709 assert(foffset_ > 0, "prefetch beyond, not behind"); \ | |
| 710 if (pstyle_ != Prefetch::do_none) { \ | |
| 711 oop* ref = (start); \ | |
| 712 if (ref < (end)) { \ | |
| 713 switch (pstyle_) { \ | |
| 714 case Prefetch::do_read: \ | |
| 715 Prefetch::read(*ref, foffset_); \ | |
| 716 break; \ | |
| 717 case Prefetch::do_write: \ | |
| 718 Prefetch::write(*ref, foffset_); \ | |
| 719 break; \ | |
| 720 default: \ | |
| 721 ShouldNotReachHere(); \ | |
| 722 break; \ | |
| 723 } \ | |
| 724 } \ | |
| 725 } \ | |
| 726 } | |
| 727 | |
| 728 // iterators | |
| 729 virtual int oop_oop_iterate(oop obj, OopClosure* blk) = 0; | |
| 730 virtual int oop_oop_iterate_v(oop obj, OopClosure* blk) { | |
| 731 return oop_oop_iterate(obj, blk); | |
| 732 } | |
| 733 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
734 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
735 // 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
|
736 // iteration. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
737 virtual int oop_oop_iterate_backwards_v(oop obj, OopClosure* blk) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
738 return oop_oop_iterate_v(obj, blk); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
739 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
740 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
741 |
| 0 | 742 // Iterates "blk" over all the oops in "obj" (of type "this") within "mr". |
| 743 // (I don't see why the _m should be required, but without it the Solaris | |
| 744 // C++ gives warning messages about overridings of the "oop_oop_iterate" | |
| 745 // defined above "hiding" this virtual function. (DLD, 6/20/00)) */ | |
| 746 virtual int oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) = 0; | |
| 747 virtual int oop_oop_iterate_v_m(oop obj, OopClosure* blk, MemRegion mr) { | |
| 748 return oop_oop_iterate_m(obj, blk, mr); | |
| 749 } | |
| 750 | |
| 751 // Versions of the above iterators specialized to particular subtypes | |
| 752 // of OopClosure, to avoid closure virtual calls. | |
| 753 #define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ | |
| 754 virtual int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk) { \ | |
| 755 /* Default implementation reverts to general version. */ \ | |
| 756 return oop_oop_iterate(obj, blk); \ | |
| 757 } \ | |
| 758 \ | |
| 759 /* Iterates "blk" over all the oops in "obj" (of type "this") within "mr". \ | |
| 760 (I don't see why the _m should be required, but without it the Solaris \ | |
| 761 C++ gives warning messages about overridings of the "oop_oop_iterate" \ | |
| 762 defined above "hiding" this virtual function. (DLD, 6/20/00)) */ \ | |
| 763 virtual int oop_oop_iterate##nv_suffix##_m(oop obj, \ | |
| 764 OopClosureType* blk, \ | |
| 765 MemRegion mr) { \ | |
| 766 return oop_oop_iterate_m(obj, blk, mr); \ | |
| 767 } | |
| 768 | |
| 769 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
|
770 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
|
771 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
772 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
773 #define Klass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
774 virtual int oop_oop_iterate_backwards##nv_suffix(oop obj, \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
775 OopClosureType* blk) { \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
776 /* Default implementation reverts to general version. */ \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
777 return oop_oop_iterate_backwards_v(obj, blk); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
778 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
779 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
780 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
|
781 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
782 #endif // !SERIALGC |
| 0 | 783 |
| 784 virtual void array_klasses_do(void f(klassOop k)) {} | |
| 785 virtual void with_array_klasses_do(void f(klassOop k)); | |
| 786 | |
| 787 // Return self, except for abstract classes with exactly 1 | |
| 788 // implementor. Then return the 1 concrete implementation. | |
| 789 Klass *up_cast_abstract(); | |
| 790 | |
| 791 // klass name | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
792 Symbol* name() const { return _name; } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
793 void set_name(Symbol* n); |
| 0 | 794 |
| 795 friend class klassKlass; | |
| 796 | |
| 797 public: | |
| 798 // jvm support | |
| 799 virtual jint compute_modifier_flags(TRAPS) const; | |
| 800 | |
| 801 // JVMTI support | |
| 802 virtual jint jvmti_class_status() const; | |
| 803 | |
| 804 // Printing | |
|
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1039
diff
changeset
|
805 virtual void oop_print_value_on(oop obj, outputStream* st); |
| 0 | 806 virtual void oop_print_on (oop obj, outputStream* st); |
| 807 | |
| 808 // Verification | |
| 809 virtual const char* internal_name() const = 0; | |
| 810 virtual void oop_verify_on(oop obj, outputStream* st); | |
| 811 virtual void oop_verify_old_oop(oop obj, oop* p, bool allow_dirty); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
812 virtual void oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty); |
| 0 | 813 // tells whether obj is partially constructed (gc during class loading) |
| 814 virtual bool oop_partially_loaded(oop obj) const { return false; } | |
| 815 virtual void oop_set_partially_loaded(oop obj) {}; | |
| 816 | |
| 817 #ifndef PRODUCT | |
| 818 void verify_vtable_index(int index); | |
| 819 #endif | |
| 820 }; | |
| 1972 | 821 |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
822 |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
823 inline oop klassOopDesc::java_mirror() const { return klass_part()->java_mirror(); } |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
824 |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
825 |
| 1972 | 826 #endif // SHARE_VM_OOPS_KLASS_HPP |