author | mgronlun |
Tue, 01 Mar 2016 23:46:09 +0100 | |
changeset 36384 | b0b41336a9a8 |
parent 35913 | 928548a43408 |
child 37480 | 291ee208fb72 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
35877
a2a62511d0f8
8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents:
35135
diff
changeset
|
2 |
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4584
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4584
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4584
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_OOPS_KLASS_HPP |
26 |
#define SHARE_VM_OOPS_KLASS_HPP |
|
27 |
||
30764 | 28 |
#include "gc/shared/specialized_oop_closures.hpp" |
7397 | 29 |
#include "memory/iterator.hpp" |
30 |
#include "memory/memRegion.hpp" |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
31 |
#include "oops/metadata.hpp" |
7397 | 32 |
#include "oops/oop.hpp" |
11480
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
8725
diff
changeset
|
33 |
#include "trace/traceMacros.hpp" |
7397 | 34 |
#include "utilities/accessFlags.hpp" |
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
14816
diff
changeset
|
35 |
#include "utilities/macros.hpp" |
7397 | 36 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
37 |
// |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
38 |
// A Klass provides: |
1 | 39 |
// 1: language level class object (method dictionary etc.) |
40 |
// 2: provide vm dispatch behavior for the object |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
41 |
// Both functions are combined into one C++ class. |
1 | 42 |
|
43 |
// One reason for the oop/klass dichotomy in the implementation is |
|
44 |
// that we don't want a C++ vtbl pointer in every object. Thus, |
|
45 |
// normal oops don't have any virtual functions. Instead, they |
|
46 |
// forward all "virtual" functions to their klass, which does have |
|
47 |
// a vtbl and does the C++ dispatch depending on the object's |
|
48 |
// actual type. (See oop.inline.hpp for some of the forwarding code.) |
|
49 |
// ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"! |
|
50 |
||
51 |
// Forward declarations. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
52 |
template <class T> class Array; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
53 |
template <class T> class GrowableArray; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
54 |
class ClassLoaderData; |
1 | 55 |
class klassVtable; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
56 |
class ParCompactionManager; |
30150
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
57 |
class PSPromotionManager; |
15437 | 58 |
class KlassSizeStats; |
27020 | 59 |
class fieldDescriptor; |
35900 | 60 |
class vtableEntry; |
1 | 61 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
62 |
class Klass : public Metadata { |
1 | 63 |
friend class VMStructs; |
35123
b0b89d83bcf5
8134994: use separate VMStructs databases for SA and JVMCI
twisti
parents:
33611
diff
changeset
|
64 |
friend class JVMCIVMStructs; |
1 | 65 |
protected: |
66 |
// note: put frequently-used fields together at start of klass structure |
|
67 |
// for better cache behavior (may not make much of a difference but sure won't hurt) |
|
68 |
enum { _primary_super_limit = 8 }; |
|
69 |
||
70 |
// The "layout helper" is a combined descriptor of object layout. |
|
71 |
// For klasses which are neither instance nor array, the value is zero. |
|
72 |
// |
|
73 |
// For instances, layout helper is a positive number, the instance size. |
|
74 |
// This size is already passed through align_object_size and scaled to bytes. |
|
75 |
// The low order bit is set if instances of this class cannot be |
|
76 |
// allocated using the fastpath. |
|
77 |
// |
|
78 |
// For arrays, layout helper is a negative number, containing four |
|
79 |
// distinct bytes, as follows: |
|
80 |
// MSB:[tag, hsz, ebt, log2(esz)]:LSB |
|
81 |
// where: |
|
82 |
// tag is 0x80 if the elements are oops, 0xC0 if non-oops |
|
83 |
// hsz is array header size in bytes (i.e., offset of first element) |
|
84 |
// ebt is the BasicType of the elements |
|
85 |
// esz is the element size in bytes |
|
86 |
// This packed word is arranged so as to be quickly unpacked by the |
|
87 |
// various fast paths that use the various subfields. |
|
88 |
// |
|
89 |
// The esz bits can be used directly by a SLL instruction, without masking. |
|
90 |
// |
|
91 |
// Note that the array-kind tag looks like 0x00 for instance klasses, |
|
92 |
// since their length in bytes is always less than 24Mb. |
|
93 |
// |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
94 |
// Final note: This comes first, immediately after C++ vtable, |
1 | 95 |
// because it is frequently queried. |
96 |
jint _layout_helper; |
|
97 |
||
98 |
// The fields _super_check_offset, _secondary_super_cache, _secondary_supers |
|
99 |
// and _primary_supers all help make fast subtype checks. See big discussion |
|
100 |
// in doc/server_compiler/checktype.txt |
|
101 |
// |
|
102 |
// Where to look to observe a supertype (it is &_secondary_super_cache for |
|
103 |
// secondary supers, else is &_primary_supers[depth()]. |
|
104 |
juint _super_check_offset; |
|
105 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
106 |
// Class name. Instance classes: java/lang/String, etc. Array classes: [I, |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
107 |
// [Ljava/lang/String;, etc. Set to zero for all other kinds of classes. |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
108 |
Symbol* _name; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
109 |
|
1 | 110 |
// Cache of last observed secondary supertype |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
111 |
Klass* _secondary_super_cache; |
1 | 112 |
// Array of all secondary supertypes |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
113 |
Array<Klass*>* _secondary_supers; |
1 | 114 |
// Ordered list of all primary supertypes |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
115 |
Klass* _primary_supers[_primary_super_limit]; |
1 | 116 |
// java/lang/Class instance mirroring this class |
117 |
oop _java_mirror; |
|
118 |
// Superclass |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
119 |
Klass* _super; |
1 | 120 |
// First subclass (NULL if none); _subklass->next_sibling() is next one |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
121 |
Klass* _subklass; |
1 | 122 |
// Sibling link (or NULL); links all subklasses of a klass |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
123 |
Klass* _next_sibling; |
1 | 124 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
125 |
// All klasses loaded by a class loader are chained through these links |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
126 |
Klass* _next_link; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
127 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
128 |
// The VM's representation of the ClassLoader used to load this class. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
129 |
// Provide access the corresponding instance java.lang.ClassLoader. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
130 |
ClassLoaderData* _class_loader_data; |
1 | 131 |
|
132 |
jint _modifier_flags; // Processed access flags, for use by Class.getModifiers. |
|
133 |
AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here. |
|
134 |
||
36384 | 135 |
TRACE_DEFINE_TRACE_ID_FIELD; |
35899 | 136 |
|
15449
262003a04c6f
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
14816
diff
changeset
|
137 |
// Biased locking implementation and statistics |
262003a04c6f
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
14816
diff
changeset
|
138 |
// (the 64-bit chunk goes first, to avoid some fragmentation) |
262003a04c6f
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
14816
diff
changeset
|
139 |
jlong _last_biased_lock_bulk_revocation_time; |
262003a04c6f
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
14816
diff
changeset
|
140 |
markOop _prototype_header; // Used when biased locking is both enabled and disabled for this type |
262003a04c6f
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
14816
diff
changeset
|
141 |
jint _biased_lock_revocation_count; |
262003a04c6f
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
14816
diff
changeset
|
142 |
|
35899 | 143 |
// vtable length |
144 |
int _vtable_len; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
145 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
146 |
// Remembered sets support for the oops in the klasses. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
147 |
jbyte _modified_oops; // Card Table Equivalent (YC/CMS support) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
148 |
jbyte _accumulated_modified_oops; // Mod Union Equivalent (CMS support) |
1 | 149 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
150 |
private: |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
151 |
// This is an index into FileMapHeader::_classpath_entry_table[], to |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
152 |
// associate this class with the JAR file where it's loaded from during |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
153 |
// dump time. If a class is not loaded from the shared archive, this field is |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
154 |
// -1. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
155 |
jshort _shared_class_path_index; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
156 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
157 |
friend class SharedClassUtil; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
158 |
protected: |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
159 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
160 |
// Constructor |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
161 |
Klass(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
162 |
|
19696
bd5a0131bde1
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
19348
diff
changeset
|
163 |
void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw(); |
1 | 164 |
|
165 |
public: |
|
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
27020
diff
changeset
|
166 |
enum DefaultsLookupMode { find_defaults, skip_defaults }; |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
27020
diff
changeset
|
167 |
enum OverpassLookupMode { find_overpass, skip_overpass }; |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
27020
diff
changeset
|
168 |
enum StaticLookupMode { find_static, skip_static }; |
32189
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
30880
diff
changeset
|
169 |
enum PrivateLookupMode { find_private, skip_private }; |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23515
diff
changeset
|
170 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
171 |
bool is_klass() const volatile { return true; } |
1 | 172 |
|
173 |
// super |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
174 |
Klass* super() const { return _super; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
175 |
void set_super(Klass* k) { _super = k; } |
1 | 176 |
|
177 |
// initializes _super link, _primary_supers & _secondary_supers arrays |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
178 |
void initialize_supers(Klass* k, TRAPS); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
179 |
void initialize_supers_impl1(Klass* k); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
180 |
void initialize_supers_impl2(Klass* k); |
1 | 181 |
|
182 |
// klass-specific helper for initializing _secondary_supers |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
183 |
virtual GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots); |
1 | 184 |
|
185 |
// java_super is the Java-level super type as specified by Class.getSuperClass. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
186 |
virtual Klass* java_super() const { return NULL; } |
1 | 187 |
|
188 |
juint super_check_offset() const { return _super_check_offset; } |
|
189 |
void set_super_check_offset(juint o) { _super_check_offset = o; } |
|
190 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
191 |
Klass* secondary_super_cache() const { return _secondary_super_cache; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
192 |
void set_secondary_super_cache(Klass* k) { _secondary_super_cache = k; } |
1 | 193 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
194 |
Array<Klass*>* secondary_supers() const { return _secondary_supers; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
195 |
void set_secondary_supers(Array<Klass*>* k) { _secondary_supers = k; } |
1 | 196 |
|
197 |
// Return the element of the _super chain of the given depth. |
|
198 |
// If there is no such element, return either NULL or this. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
199 |
Klass* primary_super_of_depth(juint i) const { |
1 | 200 |
assert(i < primary_super_limit(), "oob"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
201 |
Klass* super = _primary_supers[i]; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
202 |
assert(super == NULL || super->super_depth() == i, "correct display"); |
1 | 203 |
return super; |
204 |
} |
|
205 |
||
206 |
// Can this klass be a primary super? False for interfaces and arrays of |
|
207 |
// interfaces. False also for arrays or classes with long super chains. |
|
208 |
bool can_be_primary_super() const { |
|
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
8725
diff
changeset
|
209 |
const juint secondary_offset = in_bytes(secondary_super_cache_offset()); |
1 | 210 |
return super_check_offset() != secondary_offset; |
211 |
} |
|
212 |
virtual bool can_be_primary_super_slow() const; |
|
213 |
||
214 |
// Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit]. |
|
215 |
juint super_depth() const { |
|
216 |
if (!can_be_primary_super()) { |
|
217 |
return primary_super_limit(); |
|
218 |
} else { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
219 |
juint d = (super_check_offset() - in_bytes(primary_supers_offset())) / sizeof(Klass*); |
1 | 220 |
assert(d < primary_super_limit(), "oob"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
221 |
assert(_primary_supers[d] == this, "proper init"); |
1 | 222 |
return d; |
223 |
} |
|
224 |
} |
|
225 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
226 |
// store an oop into a field of a Klass |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
227 |
void klass_oop_store(oop* p, oop v); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
228 |
void klass_oop_store(volatile oop* p, oop v); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
229 |
|
1 | 230 |
// java mirror |
231 |
oop java_mirror() const { return _java_mirror; } |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
232 |
void set_java_mirror(oop m) { klass_oop_store(&_java_mirror, m); } |
1 | 233 |
|
234 |
// modifier flags |
|
235 |
jint modifier_flags() const { return _modifier_flags; } |
|
236 |
void set_modifier_flags(jint flags) { _modifier_flags = flags; } |
|
237 |
||
238 |
// size helper |
|
239 |
int layout_helper() const { return _layout_helper; } |
|
240 |
void set_layout_helper(int lh) { _layout_helper = lh; } |
|
241 |
||
242 |
// Note: for instances layout_helper() may include padding. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
243 |
// Use InstanceKlass::contains_field_offset to classify field offsets. |
1 | 244 |
|
245 |
// sub/superklass links |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22908
diff
changeset
|
246 |
Klass* subklass() const { return _subklass; } |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22908
diff
changeset
|
247 |
Klass* next_sibling() const { return _next_sibling; } |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
248 |
InstanceKlass* superklass() const; |
1 | 249 |
void append_to_sibling_list(); // add newly created receiver to superklass' subklass list |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
250 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
251 |
void set_next_link(Klass* k) { _next_link = k; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
252 |
Klass* next_link() const { return _next_link; } // The next klass defined by the class loader. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
253 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
254 |
// class loader data |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
255 |
ClassLoaderData* class_loader_data() const { return _class_loader_data; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
256 |
void set_class_loader_data(ClassLoaderData* loader_data) { _class_loader_data = loader_data; } |
1 | 257 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
258 |
// The Klasses are not placed in the Heap, so the Card Table or |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
259 |
// the Mod Union Table can't be used to mark when klasses have modified oops. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
260 |
// The CT and MUT bits saves this information for the individual Klasses. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
261 |
void record_modified_oops() { _modified_oops = 1; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
262 |
void clear_modified_oops() { _modified_oops = 0; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
263 |
bool has_modified_oops() { return _modified_oops == 1; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
264 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
265 |
void accumulate_modified_oops() { if (has_modified_oops()) _accumulated_modified_oops = 1; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
266 |
void clear_accumulated_modified_oops() { _accumulated_modified_oops = 0; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
267 |
bool has_accumulated_modified_oops() { return _accumulated_modified_oops == 1; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
268 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
269 |
int shared_classpath_index() const { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
270 |
return _shared_class_path_index; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
271 |
}; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
272 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
273 |
void set_shared_classpath_index(int index) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
274 |
_shared_class_path_index = index; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
275 |
}; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
276 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
277 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
278 |
protected: // internal accessors |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
279 |
void set_subklass(Klass* s); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
280 |
void set_next_sibling(Klass* s); |
1 | 281 |
|
282 |
public: |
|
283 |
||
284 |
// Compiler support |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
285 |
static ByteSize super_offset() { return in_ByteSize(offset_of(Klass, _super)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
286 |
static ByteSize super_check_offset_offset() { return in_ByteSize(offset_of(Klass, _super_check_offset)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
287 |
static ByteSize primary_supers_offset() { return in_ByteSize(offset_of(Klass, _primary_supers)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
288 |
static ByteSize secondary_super_cache_offset() { return in_ByteSize(offset_of(Klass, _secondary_super_cache)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
289 |
static ByteSize secondary_supers_offset() { return in_ByteSize(offset_of(Klass, _secondary_supers)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
290 |
static ByteSize java_mirror_offset() { return in_ByteSize(offset_of(Klass, _java_mirror)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
291 |
static ByteSize modifier_flags_offset() { return in_ByteSize(offset_of(Klass, _modifier_flags)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
292 |
static ByteSize layout_helper_offset() { return in_ByteSize(offset_of(Klass, _layout_helper)); } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
293 |
static ByteSize access_flags_offset() { return in_ByteSize(offset_of(Klass, _access_flags)); } |
1 | 294 |
|
295 |
// Unpacking layout_helper: |
|
296 |
enum { |
|
297 |
_lh_neutral_value = 0, // neutral non-array non-instance value |
|
298 |
_lh_instance_slow_path_bit = 0x01, |
|
299 |
_lh_log2_element_size_shift = BitsPerByte*0, |
|
300 |
_lh_log2_element_size_mask = BitsPerLong-1, |
|
301 |
_lh_element_type_shift = BitsPerByte*1, |
|
302 |
_lh_element_type_mask = right_n_bits(BitsPerByte), // shifted mask |
|
303 |
_lh_header_size_shift = BitsPerByte*2, |
|
304 |
_lh_header_size_mask = right_n_bits(BitsPerByte), // shifted mask |
|
305 |
_lh_array_tag_bits = 2, |
|
306 |
_lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits, |
|
307 |
_lh_array_tag_type_value = ~0x00, // 0xC0000000 >> 30 |
|
308 |
_lh_array_tag_obj_value = ~0x01 // 0x80000000 >> 30 |
|
309 |
}; |
|
310 |
||
311 |
static int layout_helper_size_in_bytes(jint lh) { |
|
312 |
assert(lh > (jint)_lh_neutral_value, "must be instance"); |
|
313 |
return (int) lh & ~_lh_instance_slow_path_bit; |
|
314 |
} |
|
315 |
static bool layout_helper_needs_slow_path(jint lh) { |
|
316 |
assert(lh > (jint)_lh_neutral_value, "must be instance"); |
|
317 |
return (lh & _lh_instance_slow_path_bit) != 0; |
|
318 |
} |
|
319 |
static bool layout_helper_is_instance(jint lh) { |
|
320 |
return (jint)lh > (jint)_lh_neutral_value; |
|
321 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
322 |
static bool layout_helper_is_array(jint lh) { |
1 | 323 |
return (jint)lh < (jint)_lh_neutral_value; |
324 |
} |
|
325 |
static bool layout_helper_is_typeArray(jint lh) { |
|
326 |
// _lh_array_tag_type_value == (lh >> _lh_array_tag_shift); |
|
327 |
return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift); |
|
328 |
} |
|
329 |
static bool layout_helper_is_objArray(jint lh) { |
|
330 |
// _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift); |
|
331 |
return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift); |
|
332 |
} |
|
333 |
static int layout_helper_header_size(jint lh) { |
|
334 |
assert(lh < (jint)_lh_neutral_value, "must be array"); |
|
335 |
int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask; |
|
336 |
assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity"); |
|
337 |
return hsize; |
|
338 |
} |
|
339 |
static BasicType layout_helper_element_type(jint lh) { |
|
340 |
assert(lh < (jint)_lh_neutral_value, "must be array"); |
|
341 |
int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask; |
|
342 |
assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity"); |
|
343 |
return (BasicType) btvalue; |
|
344 |
} |
|
345 |
static int layout_helper_log2_element_size(jint lh) { |
|
346 |
assert(lh < (jint)_lh_neutral_value, "must be array"); |
|
347 |
int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask; |
|
19342
f3957eba8935
8023227: Enhance layout_helper_log2_element_size assert
stefank
parents:
18687
diff
changeset
|
348 |
assert(l2esz <= LogBitsPerLong, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32606
diff
changeset
|
349 |
"sanity. l2esz: 0x%x for lh: 0x%x", (uint)l2esz, (uint)lh); |
1 | 350 |
return l2esz; |
351 |
} |
|
352 |
static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) { |
|
353 |
return (tag << _lh_array_tag_shift) |
|
354 |
| (hsize << _lh_header_size_shift) |
|
355 |
| ((int)etype << _lh_element_type_shift) |
|
356 |
| (log2_esize << _lh_log2_element_size_shift); |
|
357 |
} |
|
358 |
static jint instance_layout_helper(jint size, bool slow_path_flag) { |
|
35898
ddc274f0052f
8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents:
35877
diff
changeset
|
359 |
return (size << LogBytesPerWord) |
1 | 360 |
| (slow_path_flag ? _lh_instance_slow_path_bit : 0); |
361 |
} |
|
362 |
static int layout_helper_to_size_helper(jint lh) { |
|
363 |
assert(lh > (jint)_lh_neutral_value, "must be instance"); |
|
364 |
// Note that the following expression discards _lh_instance_slow_path_bit. |
|
35898
ddc274f0052f
8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents:
35877
diff
changeset
|
365 |
return lh >> LogBytesPerWord; |
1 | 366 |
} |
367 |
// Out-of-line version computes everything based on the etype: |
|
368 |
static jint array_layout_helper(BasicType etype); |
|
369 |
||
370 |
// What is the maximum number of primary superclasses any klass can have? |
|
371 |
#ifdef PRODUCT |
|
372 |
static juint primary_super_limit() { return _primary_super_limit; } |
|
373 |
#else |
|
374 |
static juint primary_super_limit() { |
|
375 |
assert(FastSuperclassLimit <= _primary_super_limit, "parameter oob"); |
|
376 |
return FastSuperclassLimit; |
|
377 |
} |
|
378 |
#endif |
|
379 |
||
380 |
// vtables |
|
35900 | 381 |
klassVtable* vtable() const; |
35899 | 382 |
int vtable_length() const { return _vtable_len; } |
1 | 383 |
|
384 |
// subclass check |
|
17370
59a0620561fa
8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents:
15928
diff
changeset
|
385 |
bool is_subclass_of(const Klass* k) const; |
1 | 386 |
// subtype check: true if is_subclass_of, or if k is interface and receiver implements it |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
387 |
bool is_subtype_of(Klass* k) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
388 |
juint off = k->super_check_offset(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
389 |
Klass* sup = *(Klass**)( (address)this + off ); |
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
8725
diff
changeset
|
390 |
const juint secondary_offset = in_bytes(secondary_super_cache_offset()); |
1 | 391 |
if (sup == k) { |
392 |
return true; |
|
393 |
} else if (off != secondary_offset) { |
|
394 |
return false; |
|
395 |
} else { |
|
396 |
return search_secondary_supers(k); |
|
397 |
} |
|
398 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
399 |
bool search_secondary_supers(Klass* k) const; |
1 | 400 |
|
2131 | 401 |
// Find LCA in class hierarchy |
1 | 402 |
Klass *LCA( Klass *k ); |
403 |
||
404 |
// Check whether reflection/jni/jvm code is allowed to instantiate this class; |
|
405 |
// if not, throw either an Error or an Exception. |
|
406 |
virtual void check_valid_for_instantiation(bool throwError, TRAPS); |
|
407 |
||
408 |
// array copying |
|
409 |
virtual void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS); |
|
410 |
||
411 |
// tells if the class should be initialized |
|
412 |
virtual bool should_be_initialized() const { return false; } |
|
413 |
// initializes the klass |
|
414 |
virtual void initialize(TRAPS); |
|
415 |
// lookup operation for MethodLookupCache |
|
416 |
friend class MethodLookupCache; |
|
27020 | 417 |
virtual Klass* find_field(Symbol* name, Symbol* signature, fieldDescriptor* fd) const; |
34666 | 418 |
virtual Method* uncached_lookup_method(const Symbol* name, const Symbol* signature, OverpassLookupMode overpass_mode) const; |
1 | 419 |
public: |
34666 | 420 |
Method* lookup_method(const Symbol* name, const Symbol* signature) const { |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
27020
diff
changeset
|
421 |
return uncached_lookup_method(name, signature, find_overpass); |
1 | 422 |
} |
423 |
||
424 |
// array class with specific rank |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
425 |
Klass* array_klass(int rank, TRAPS) { return array_klass_impl(false, rank, THREAD); } |
1 | 426 |
|
427 |
// array class with this klass as element type |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
428 |
Klass* array_klass(TRAPS) { return array_klass_impl(false, THREAD); } |
1 | 429 |
|
430 |
// These will return NULL instead of allocating on the heap: |
|
431 |
// NB: these can block for a mutex, like other functions with TRAPS arg. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
432 |
Klass* array_klass_or_null(int rank); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
433 |
Klass* array_klass_or_null(); |
1 | 434 |
|
17826
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17373
diff
changeset
|
435 |
virtual oop protection_domain() const = 0; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
436 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
437 |
oop class_loader() const; |
1 | 438 |
|
14816 | 439 |
virtual oop klass_holder() const { return class_loader(); } |
440 |
||
1 | 441 |
protected: |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
442 |
virtual Klass* array_klass_impl(bool or_null, int rank, TRAPS); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
443 |
virtual Klass* array_klass_impl(bool or_null, TRAPS); |
1 | 444 |
|
35899 | 445 |
void set_vtable_length(int len) { _vtable_len= len; } |
446 |
||
35900 | 447 |
vtableEntry* start_of_vtable() const; |
1 | 448 |
public: |
35900 | 449 |
Method* method_at_vtable(int index); |
450 |
||
35899 | 451 |
static ByteSize vtable_start_offset(); |
452 |
static ByteSize vtable_length_offset() { |
|
453 |
return byte_offset_of(Klass, _vtable_len); |
|
454 |
} |
|
455 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
456 |
// CDS support - remove and restore oops from metadata. Oops are not shared. |
1 | 457 |
virtual void remove_unshareable_info(); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
458 |
virtual void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS); |
1 | 459 |
|
460 |
protected: |
|
461 |
// computes the subtype relationship |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
462 |
virtual bool compute_is_subtype_of(Klass* k); |
1 | 463 |
public: |
464 |
// subclass accessor (here for convenience; undefined for non-klass objects) |
|
465 |
virtual bool is_leaf_class() const { fatal("not a class"); return false; } |
|
466 |
public: |
|
467 |
// ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP |
|
468 |
// These functions describe behavior for the oop not the KLASS. |
|
469 |
||
470 |
// actual oop size of obj in memory |
|
471 |
virtual int oop_size(oop obj) const = 0; |
|
472 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
473 |
// Size of klass in word size. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
474 |
virtual int size() const = 0; |
15437 | 475 |
#if INCLUDE_SERVICES |
476 |
virtual void collect_statistics(KlassSizeStats *sz) const; |
|
477 |
#endif |
|
1 | 478 |
|
479 |
// Returns the Java name for a class (Resource allocated) |
|
480 |
// For arrays, this returns the name of the element with a leading '['. |
|
481 |
// For classes, this returns the name with the package separators |
|
482 |
// turned into '.'s. |
|
483 |
const char* external_name() const; |
|
484 |
// Returns the name for a class (Resource allocated) as the class |
|
485 |
// would appear in a signature. |
|
486 |
// For arrays, this returns the name of the element with a leading '['. |
|
487 |
// For classes, this returns the name with a leading 'L' and a trailing ';' |
|
488 |
// and the package separators as '/'. |
|
4094
1f424b2b2171
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
2154
diff
changeset
|
489 |
virtual const char* signature_name() const; |
1 | 490 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
491 |
// type testing operations |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
492 |
#ifdef ASSERT |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
493 |
protected: |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
494 |
virtual bool is_instance_klass_slow() const { return false; } |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
495 |
virtual bool is_array_klass_slow() const { return false; } |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
496 |
virtual bool is_objArray_klass_slow() const { return false; } |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
497 |
virtual bool is_typeArray_klass_slow() const { return false; } |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
498 |
#endif // ASSERT |
1 | 499 |
public: |
500 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
501 |
// Fast non-virtual versions |
1 | 502 |
#ifndef ASSERT |
503 |
#define assert_same_query(xval, xcheck) xval |
|
504 |
#else |
|
505 |
private: |
|
506 |
static bool assert_same_query(bool xval, bool xslow) { |
|
507 |
assert(xval == xslow, "slow and fast queries agree"); |
|
508 |
return xval; |
|
509 |
} |
|
510 |
public: |
|
511 |
#endif |
|
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
512 |
inline bool is_instance_klass() const { return assert_same_query( |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
513 |
layout_helper_is_instance(layout_helper()), |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
514 |
is_instance_klass_slow()); } |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
515 |
inline bool is_array_klass() const { return assert_same_query( |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
516 |
layout_helper_is_array(layout_helper()), |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
517 |
is_array_klass_slow()); } |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
518 |
inline bool is_objArray_klass() const { return assert_same_query( |
1 | 519 |
layout_helper_is_objArray(layout_helper()), |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
520 |
is_objArray_klass_slow()); } |
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
521 |
inline bool is_typeArray_klass() const { return assert_same_query( |
1 | 522 |
layout_helper_is_typeArray(layout_helper()), |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
523 |
is_typeArray_klass_slow()); } |
1 | 524 |
#undef assert_same_query |
525 |
||
526 |
// Access flags |
|
527 |
AccessFlags access_flags() const { return _access_flags; } |
|
528 |
void set_access_flags(AccessFlags flags) { _access_flags = flags; } |
|
529 |
||
530 |
bool is_public() const { return _access_flags.is_public(); } |
|
531 |
bool is_final() const { return _access_flags.is_final(); } |
|
532 |
bool is_interface() const { return _access_flags.is_interface(); } |
|
533 |
bool is_abstract() const { return _access_flags.is_abstract(); } |
|
534 |
bool is_super() const { return _access_flags.is_super(); } |
|
535 |
bool is_synthetic() const { return _access_flags.is_synthetic(); } |
|
536 |
void set_is_synthetic() { _access_flags.set_is_synthetic(); } |
|
537 |
bool has_finalizer() const { return _access_flags.has_finalizer(); } |
|
538 |
bool has_final_method() const { return _access_flags.has_final_method(); } |
|
539 |
void set_has_finalizer() { _access_flags.set_has_finalizer(); } |
|
540 |
void set_has_final_method() { _access_flags.set_has_final_method(); } |
|
541 |
bool has_vanilla_constructor() const { return _access_flags.has_vanilla_constructor(); } |
|
542 |
void set_has_vanilla_constructor() { _access_flags.set_has_vanilla_constructor(); } |
|
543 |
bool has_miranda_methods () const { return access_flags().has_miranda_methods(); } |
|
544 |
void set_has_miranda_methods() { _access_flags.set_has_miranda_methods(); } |
|
545 |
||
35544
c7ec868d0923
8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents:
35135
diff
changeset
|
546 |
bool is_cloneable() const; |
c7ec868d0923
8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents:
35135
diff
changeset
|
547 |
void set_is_cloneable(); |
c7ec868d0923
8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents:
35135
diff
changeset
|
548 |
|
1 | 549 |
// Biased locking support |
550 |
// Note: the prototype header is always set up to be at least the |
|
551 |
// prototype markOop. If biased locking is enabled it may further be |
|
552 |
// biasable and have an epoch. |
|
553 |
markOop prototype_header() const { return _prototype_header; } |
|
554 |
// NOTE: once instances of this klass are floating around in the |
|
555 |
// system, this header must only be updated at a safepoint. |
|
556 |
// NOTE 2: currently we only ever set the prototype header to the |
|
557 |
// biasable prototype for instanceKlasses. There is no technical |
|
558 |
// reason why it could not be done for arrayKlasses aside from |
|
559 |
// wanting to reduce the initial scope of this optimization. There |
|
560 |
// are potential problems in setting the bias pattern for |
|
561 |
// JVM-internal oops. |
|
562 |
inline void set_prototype_header(markOop header); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
563 |
static ByteSize prototype_header_offset() { return in_ByteSize(offset_of(Klass, _prototype_header)); } |
1 | 564 |
|
565 |
int biased_lock_revocation_count() const { return (int) _biased_lock_revocation_count; } |
|
566 |
// Atomically increments biased_lock_revocation_count and returns updated value |
|
567 |
int atomic_incr_biased_lock_revocation_count(); |
|
568 |
void set_biased_lock_revocation_count(int val) { _biased_lock_revocation_count = (jint) val; } |
|
569 |
jlong last_biased_lock_bulk_revocation_time() { return _last_biased_lock_bulk_revocation_time; } |
|
570 |
void set_last_biased_lock_bulk_revocation_time(jlong cur_time) { _last_biased_lock_bulk_revocation_time = cur_time; } |
|
571 |
||
36384 | 572 |
TRACE_DEFINE_TRACE_ID_METHODS; |
1 | 573 |
|
574 |
// garbage collection support |
|
26412
80741eb33ba2
8049105: Move array component mirror to instance of java/lang/Class (hotspot part 2)
coleenp
parents:
26135
diff
changeset
|
575 |
void oops_do(OopClosure* cl); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
576 |
|
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
577 |
// Iff the class loader (or mirror for anonymous classes) is alive the |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
578 |
// Klass is considered alive. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
579 |
// The is_alive closure passed in depends on the Garbage Collector used. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
580 |
bool is_loader_alive(BoolObjectClosure* is_alive); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
581 |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
582 |
static void clean_weak_klass_links(BoolObjectClosure* is_alive, bool clean_alive_klasses = true); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
583 |
static void clean_subklass_tree(BoolObjectClosure* is_alive) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
584 |
clean_weak_klass_links(is_alive, false /* clean_alive_klasses */); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
585 |
} |
1 | 586 |
|
30150
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
587 |
// GC specific object visitors |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
588 |
// |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
589 |
// Mark Sweep |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
590 |
virtual int oop_ms_adjust_pointers(oop obj) = 0; |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
591 |
#if INCLUDE_ALL_GCS |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
592 |
// Parallel Scavenge |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
593 |
virtual void oop_ps_push_contents( oop obj, PSPromotionManager* pm) = 0; |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
594 |
// Parallel Compact |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
595 |
virtual void oop_pc_follow_contents(oop obj, ParCompactionManager* cm) = 0; |
35877
a2a62511d0f8
8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents:
35135
diff
changeset
|
596 |
virtual void oop_pc_update_pointers(oop obj, ParCompactionManager* cm) = 0; |
30150
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
597 |
#endif |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
598 |
|
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
599 |
// Iterators specialized to particular subtypes |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
600 |
// of ExtendedOopClosure, to avoid closure virtual calls. |
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
601 |
#define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
602 |
virtual void oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) = 0; \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
603 |
/* Iterates "closure" over all the oops in "obj" (of type "this") within "mr". */ \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
604 |
virtual void oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr) = 0; |
30150
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
605 |
|
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
606 |
ALL_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL) |
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
28731
diff
changeset
|
607 |
ALL_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL) |
1 | 608 |
|
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
14816
diff
changeset
|
609 |
#if INCLUDE_ALL_GCS |
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
610 |
#define Klass_OOP_OOP_ITERATE_DECL_BACKWARDS(OopClosureType, nv_suffix) \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
611 |
virtual void oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) = 0; |
1 | 612 |
|
30880
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
613 |
ALL_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL_BACKWARDS) |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
614 |
ALL_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL_BACKWARDS) |
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
14816
diff
changeset
|
615 |
#endif // INCLUDE_ALL_GCS |
1 | 616 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
617 |
virtual void array_klasses_do(void f(Klass* k)) {} |
1 | 618 |
|
619 |
// Return self, except for abstract classes with exactly 1 |
|
620 |
// implementor. Then return the 1 concrete implementation. |
|
621 |
Klass *up_cast_abstract(); |
|
622 |
||
623 |
// klass name |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
624 |
Symbol* name() const { return _name; } |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
625 |
void set_name(Symbol* n); |
1 | 626 |
|
627 |
public: |
|
628 |
// jvm support |
|
629 |
virtual jint compute_modifier_flags(TRAPS) const; |
|
630 |
||
631 |
// JVMTI support |
|
632 |
virtual jint jvmti_class_status() const; |
|
633 |
||
634 |
// Printing |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
635 |
virtual void print_on(outputStream* st) const; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
636 |
|
4584
e2a449e8cc6f
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
4094
diff
changeset
|
637 |
virtual void oop_print_value_on(oop obj, outputStream* st); |
1 | 638 |
virtual void oop_print_on (oop obj, outputStream* st); |
639 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
640 |
virtual const char* internal_name() const = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
641 |
|
1 | 642 |
// Verification |
22794
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
20017
diff
changeset
|
643 |
virtual void verify_on(outputStream* st); |
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
20017
diff
changeset
|
644 |
void verify() { verify_on(tty); } |
1 | 645 |
|
646 |
#ifndef PRODUCT |
|
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19696
diff
changeset
|
647 |
bool verify_vtable_index(int index); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19696
diff
changeset
|
648 |
bool verify_itable_index(int index); |
1 | 649 |
#endif |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
650 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
651 |
virtual void oop_verify_on(oop obj, outputStream* st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
652 |
|
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
653 |
static bool is_null(narrowKlass obj); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
654 |
static bool is_null(Klass* obj); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
655 |
|
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
656 |
// klass encoding for klass pointer in objects. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
657 |
static narrowKlass encode_klass_not_null(Klass* v); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
658 |
static narrowKlass encode_klass(Klass* v); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
659 |
|
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
660 |
static Klass* decode_klass_not_null(narrowKlass v); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
661 |
static Klass* decode_klass(narrowKlass v); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18687
diff
changeset
|
662 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
663 |
private: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
664 |
// barriers used by klass_oop_store |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
665 |
void klass_update_barrier_set(oop v); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
666 |
void klass_update_barrier_set_pre(oop* p, oop v); |
1 | 667 |
}; |
7397 | 668 |
|
30880
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
669 |
// Helper to convert the oop iterate macro suffixes into bool values that can be used by template functions. |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
670 |
#define nvs_nv_to_bool true |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
671 |
#define nvs_v_to_bool false |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
672 |
#define nvs_to_bool(nv_suffix) nvs##nv_suffix##_to_bool |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
673 |
|
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
674 |
// Oop iteration macros for declarations. |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
675 |
// Used to generate declarations in the *Klass header files. |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
676 |
|
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
677 |
#define OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ |
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
678 |
void oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure); \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
679 |
void oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr); |
30880
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
680 |
|
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
681 |
#if INCLUDE_ALL_GCS |
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
682 |
#define OOP_OOP_ITERATE_DECL_BACKWARDS(OopClosureType, nv_suffix) \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
683 |
void oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure); |
30880
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
684 |
#endif // INCLUDE_ALL_GCS |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
685 |
|
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
686 |
|
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
687 |
// Oop iteration macros for definitions. |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
688 |
// Used to generate definitions in the *Klass.inline.hpp files. |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
689 |
|
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
690 |
#define OOP_OOP_ITERATE_DEFN(KlassType, OopClosureType, nv_suffix) \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
691 |
void KlassType::oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
692 |
oop_oop_iterate<nvs_to_bool(nv_suffix)>(obj, closure); \ |
30880
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
693 |
} |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
694 |
|
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
695 |
#if INCLUDE_ALL_GCS |
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
696 |
#define OOP_OOP_ITERATE_DEFN_BACKWARDS(KlassType, OopClosureType, nv_suffix) \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
697 |
void KlassType::oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
698 |
oop_oop_iterate_reverse<nvs_to_bool(nv_suffix)>(obj, closure); \ |
30880
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
699 |
} |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
700 |
#else |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
701 |
#define OOP_OOP_ITERATE_DEFN_BACKWARDS(KlassType, OopClosureType, nv_suffix) |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
702 |
#endif |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
703 |
|
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
704 |
#define OOP_OOP_ITERATE_DEFN_BOUNDED(KlassType, OopClosureType, nv_suffix) \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
705 |
void KlassType::oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr) { \ |
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32189
diff
changeset
|
706 |
oop_oop_iterate_bounded<nvs_to_bool(nv_suffix)>(obj, closure, mr); \ |
30880
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
707 |
} |
efe35e08179f
8080746: Refactor oop iteration macros to be more general
sjohanss
parents:
30764
diff
changeset
|
708 |
|
7397 | 709 |
#endif // SHARE_VM_OOPS_KLASS_HPP |