author | hseigel |
Fri, 15 Dec 2017 11:23:50 -0500 | |
changeset 48463 | 474cec233fb2 |
parent 47998 | fb0275c320a0 |
child 48618 | 688e5cbd0b91 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
46415
7d5a286cdf89
8138737: Remove oop_ms_adjust_pointers and use oop_iterate instead
sjohanss
parents:
41310
diff
changeset
|
2 |
* Copyright (c) 1997, 2017, 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:
3262
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
3262
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:
3262
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_OOPS_OOP_INLINE_HPP |
26 |
#define SHARE_VM_OOPS_OOP_INLINE_HPP |
|
27 |
||
30764 | 28 |
#include "gc/shared/ageTable.hpp" |
29 |
#include "gc/shared/collectedHeap.inline.hpp" |
|
30 |
#include "gc/shared/genCollectedHeap.hpp" |
|
31 |
#include "gc/shared/generation.hpp" |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
32 |
#include "oops/access.inline.hpp" |
7397 | 33 |
#include "oops/arrayKlass.hpp" |
34 |
#include "oops/arrayOop.hpp" |
|
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
35 |
#include "oops/klass.inline.hpp" |
7397 | 36 |
#include "oops/markOop.inline.hpp" |
37 |
#include "oops/oop.hpp" |
|
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
39695
diff
changeset
|
38 |
#include "runtime/atomic.hpp" |
24351
61b33cc6d3cf
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
22908
diff
changeset
|
39 |
#include "runtime/orderAccess.inline.hpp" |
7397 | 40 |
#include "runtime/os.hpp" |
46625 | 41 |
#include "utilities/align.hpp" |
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
13969
diff
changeset
|
42 |
#include "utilities/macros.hpp" |
7397 | 43 |
|
1 | 44 |
// Implementation of all inlined member functions defined in oop.hpp |
45 |
// We need a separate file to avoid circular references |
|
46 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
47 |
void oopDesc::release_set_mark(markOop m) { |
47634
6a0c42c40cd1
8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents:
47624
diff
changeset
|
48 |
OrderAccess::release_store(&_mark, m); |
1 | 49 |
} |
50 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
51 |
markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) { |
46958
a13bd8c6b7a2
8186166: Generalize Atomic::cmpxchg with templates
eosterlund
parents:
46810
diff
changeset
|
52 |
return Atomic::cmpxchg(new_mark, &_mark, old_mark); |
1 | 53 |
} |
54 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
55 |
void oopDesc::init_mark() { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
56 |
set_mark(markOopDesc::prototype_for_object(this)); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
57 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
58 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
59 |
Klass* oopDesc::klass() const { |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
60 |
if (UseCompressedClassPointers) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
61 |
return Klass::decode_klass_not_null(_metadata._compressed_klass); |
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
62 |
} else { |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
63 |
return _metadata._klass; |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
64 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
65 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
66 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
67 |
Klass* oopDesc::klass_or_null() const volatile { |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
68 |
if (UseCompressedClassPointers) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
69 |
return Klass::decode_klass(_metadata._compressed_klass); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
70 |
} else { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
71 |
return _metadata._klass; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
72 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
73 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
74 |
|
41310 | 75 |
Klass* oopDesc::klass_or_null_acquire() const volatile { |
76 |
if (UseCompressedClassPointers) { |
|
77 |
// Workaround for non-const load_acquire parameter. |
|
78 |
const volatile narrowKlass* addr = &_metadata._compressed_klass; |
|
79 |
volatile narrowKlass* xaddr = const_cast<volatile narrowKlass*>(addr); |
|
80 |
return Klass::decode_klass(OrderAccess::load_acquire(xaddr)); |
|
81 |
} else { |
|
47634
6a0c42c40cd1
8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents:
47624
diff
changeset
|
82 |
return OrderAccess::load_acquire(&_metadata._klass); |
41310 | 83 |
} |
84 |
} |
|
85 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
86 |
Klass** oopDesc::klass_addr() { |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
87 |
// Only used internally and with CMS and will not work with |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
88 |
// UseCompressedOops |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
89 |
assert(!UseCompressedClassPointers, "only supported with uncompressed klass pointers"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
90 |
return (Klass**) &_metadata._klass; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
91 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
92 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
93 |
narrowKlass* oopDesc::compressed_klass_addr() { |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
94 |
assert(UseCompressedClassPointers, "only called by compressed klass pointers"); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
95 |
return &_metadata._compressed_klass; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
96 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
97 |
|
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
98 |
#define CHECK_SET_KLASS(k) \ |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
99 |
do { \ |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
100 |
assert(Universe::is_bootstrapping() || k != NULL, "NULL Klass"); \ |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
101 |
assert(Universe::is_bootstrapping() || k->is_klass(), "not a Klass"); \ |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
102 |
} while (0) |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
103 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
104 |
void oopDesc::set_klass(Klass* k) { |
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
105 |
CHECK_SET_KLASS(k); |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
106 |
if (UseCompressedClassPointers) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
107 |
*compressed_klass_addr() = Klass::encode_klass_not_null(k); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
108 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
109 |
*klass_addr() = k; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
110 |
} |
1 | 111 |
} |
112 |
||
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
113 |
void oopDesc::release_set_klass(Klass* k) { |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
114 |
CHECK_SET_KLASS(k); |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
115 |
if (UseCompressedClassPointers) { |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
116 |
OrderAccess::release_store(compressed_klass_addr(), |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
117 |
Klass::encode_klass_not_null(k)); |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
118 |
} else { |
47634
6a0c42c40cd1
8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents:
47624
diff
changeset
|
119 |
OrderAccess::release_store(klass_addr(), k); |
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
120 |
} |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
121 |
} |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
122 |
|
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
123 |
#undef CHECK_SET_KLASS |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
124 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
125 |
int oopDesc::klass_gap() const { |
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
126 |
return *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()); |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
127 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
128 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
129 |
void oopDesc::set_klass_gap(int v) { |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
130 |
if (UseCompressedClassPointers) { |
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
131 |
*(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v; |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
132 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
133 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
134 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
135 |
void oopDesc::set_klass_to_list_ptr(oop k) { |
1 | 136 |
// This is only to be used during GC, for from-space objects, so no |
137 |
// barrier is needed. |
|
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
138 |
if (UseCompressedClassPointers) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
139 |
_metadata._compressed_klass = (narrowKlass)encode_heap_oop(k); // may be null (parnew overflow handling) |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
140 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
141 |
_metadata._klass = (Klass*)(address)k; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
142 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
143 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
144 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
145 |
oop oopDesc::list_ptr_from_klass() { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
146 |
// This is only to be used during GC, for from-space objects. |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
147 |
if (UseCompressedClassPointers) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
148 |
return decode_heap_oop((narrowOop)_metadata._compressed_klass); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
149 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
150 |
// Special case for GC |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
151 |
return (oop)(address)_metadata._klass; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
152 |
} |
1 | 153 |
} |
154 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
155 |
bool oopDesc::is_a(Klass* k) const { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
156 |
return klass()->is_subtype_of(k); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
157 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
158 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
159 |
int oopDesc::size() { |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
160 |
return size_given_klass(klass()); |
10540
92d59dba2407
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
8725
diff
changeset
|
161 |
} |
1 | 162 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
163 |
int oopDesc::size_given_klass(Klass* klass) { |
1 | 164 |
int lh = klass->layout_helper(); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
165 |
int s; |
1 | 166 |
|
167 |
// lh is now a value computed at class initialization that may hint |
|
168 |
// at the size. For instances, this is positive and equal to the |
|
169 |
// size. For arrays, this is negative and provides log2 of the |
|
170 |
// array element size. For other oops, it is zero and thus requires |
|
171 |
// a virtual call. |
|
172 |
// |
|
173 |
// We go to all this trouble because the size computation is at the |
|
174 |
// heart of phase 2 of mark-compaction, and called for every object, |
|
175 |
// alive or dead. So the speed here is equal in importance to the |
|
176 |
// speed of allocation. |
|
177 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
178 |
if (lh > Klass::_lh_neutral_value) { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
179 |
if (!Klass::layout_helper_needs_slow_path(lh)) { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
180 |
s = lh >> LogHeapWordSize; // deliver size scaled by wordSize |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
181 |
} else { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
182 |
s = klass->oop_size(this); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
183 |
} |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
184 |
} else if (lh <= Klass::_lh_neutral_value) { |
1 | 185 |
// The most common case is instances; fall through if so. |
186 |
if (lh < Klass::_lh_neutral_value) { |
|
187 |
// Second most common case is arrays. We have to fetch the |
|
188 |
// length of the array, shift (multiply) it appropriately, |
|
189 |
// up to wordSize, add the header, and align to object size. |
|
190 |
size_t size_in_bytes; |
|
191 |
size_t array_length = (size_t) ((arrayOop)this)->length(); |
|
192 |
size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh); |
|
193 |
size_in_bytes += Klass::layout_helper_header_size(lh); |
|
194 |
||
195 |
// This code could be simplified, but by keeping array_header_in_bytes |
|
196 |
// in units of bytes and doing it this way we can round up just once, |
|
46620
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46529
diff
changeset
|
197 |
// skipping the intermediate round to HeapWordSize. |
750c6edff33b
8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents:
46529
diff
changeset
|
198 |
s = (int)(align_up(size_in_bytes, MinObjAlignmentInBytes) / HeapWordSize); |
1 | 199 |
|
27898
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
200 |
// ParNew (used by CMS), UseParallelGC and UseG1GC can change the length field |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
201 |
// of an "old copy" of an object array in the young gen so it indicates |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
202 |
// the grey portion of an already copied array. This will cause the first |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
203 |
// disjunct below to fail if the two comparands are computed across such |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
204 |
// a concurrent change. |
27898
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
205 |
// ParNew also runs with promotion labs (which look like int |
1 | 206 |
// filler arrays) which are subject to changing their declared size |
207 |
// when finally retiring a PLAB; this also can cause the first disjunct |
|
208 |
// to fail for another worker thread that is concurrently walking the block |
|
209 |
// offset table. Both these invariant failures are benign for their |
|
210 |
// current uses; we relax the assertion checking to cover these two cases below: |
|
211 |
// is_objArray() && is_forwarded() // covers first scenario above |
|
212 |
// || is_typeArray() // covers second scenario above |
|
213 |
// If and when UseParallelGC uses the same obj array oop stealing/chunking |
|
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
214 |
// technique, we will need to suitably modify the assertion. |
1 | 215 |
assert((s == klass->oop_size(this)) || |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
216 |
(Universe::heap()->is_gc_active() && |
27898
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
217 |
((is_typeArray() && UseConcMarkSweepGC) || |
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
218 |
(is_objArray() && is_forwarded() && (UseConcMarkSweepGC || UseParallelGC || UseG1GC)))), |
1 | 219 |
"wrong array object size"); |
220 |
} else { |
|
221 |
// Must be zero, so bite the bullet and take the virtual call. |
|
222 |
s = klass->oop_size(this); |
|
223 |
} |
|
224 |
} |
|
225 |
||
39695
946f1321c075
8158946: btree009 fails with assert(s > 0) failed: Bad size calculated
drwhite
parents:
37480
diff
changeset
|
226 |
assert(s > 0, "Oop size must be greater than zero, not %d", s); |
46683
33808f7eadd5
8184753: Asserts against MinObjectAlignment should avoid integer division
shade
parents:
46625
diff
changeset
|
227 |
assert(is_object_aligned(s), "Oop size is not properly aligned: %d", s); |
1 | 228 |
return s; |
229 |
} |
|
230 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
231 |
bool oopDesc::is_instance() const { return klass()->is_instance_klass(); } |
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
232 |
bool oopDesc::is_array() const { return klass()->is_array_klass(); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
233 |
bool oopDesc::is_objArray() const { return klass()->is_objArray_klass(); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
234 |
bool oopDesc::is_typeArray() const { return klass()->is_typeArray_klass(); } |
1 | 235 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
236 |
void* oopDesc::field_base(int offset) const { return (void*)&((char*)this)[offset]; } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
237 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
238 |
jbyte* oopDesc::byte_field_addr(int offset) const { return (jbyte*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
239 |
jchar* oopDesc::char_field_addr(int offset) const { return (jchar*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
240 |
jboolean* oopDesc::bool_field_addr(int offset) const { return (jboolean*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
241 |
jint* oopDesc::int_field_addr(int offset) const { return (jint*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
242 |
jshort* oopDesc::short_field_addr(int offset) const { return (jshort*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
243 |
jlong* oopDesc::long_field_addr(int offset) const { return (jlong*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
244 |
jfloat* oopDesc::float_field_addr(int offset) const { return (jfloat*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
245 |
jdouble* oopDesc::double_field_addr(int offset) const { return (jdouble*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
246 |
Metadata** oopDesc::metadata_field_addr(int offset) const { return (Metadata**)field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
247 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
248 |
template <class T> T* oopDesc::obj_field_addr(int offset) const { return (T*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
249 |
address* oopDesc::address_field_addr(int offset) const { return (address*) field_base(offset); } |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
250 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
251 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
252 |
// Functions for getting and setting oops within instance objects. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
253 |
// If the oops are compressed, the type passed to these overloaded functions |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
254 |
// is narrowOop. All functions are overloaded so they can be called by |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
255 |
// template functions without conditionals (the compiler instantiates via |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
256 |
// the right type and inlines the appopriate code). |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
257 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
258 |
// Algorithm for encoding and decoding oops from 64 bit pointers to 32 bit |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
259 |
// offset from the heap base. Saving the check for null can save instructions |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
260 |
// in inner GC loops so these are separated. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
261 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
262 |
inline bool check_obj_alignment(oop obj) { |
36572
bdbf53032b6a
8149973: Optimize object alignment check in debug builds.
ddmitriev
parents:
35877
diff
changeset
|
263 |
return (cast_from_oop<intptr_t>(obj) & MinObjAlignmentInBytesMask) == 0; |
1894
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1607
diff
changeset
|
264 |
} |
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1607
diff
changeset
|
265 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
266 |
oop oopDesc::decode_heap_oop_not_null(narrowOop v) { |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
267 |
assert(!is_null(v), "narrow oop value can never be zero"); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
268 |
address base = Universe::narrow_oop_base(); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
269 |
int shift = Universe::narrow_oop_shift(); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
270 |
oop result = (oop)(void*)((uintptr_t)base + ((uintptr_t)v << shift)); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
271 |
assert(check_obj_alignment(result), "address not aligned: " INTPTR_FORMAT, p2i((void*) result)); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
272 |
return result; |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
273 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
274 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
275 |
oop oopDesc::decode_heap_oop(narrowOop v) { |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
276 |
return is_null(v) ? (oop)NULL : decode_heap_oop_not_null(v); |
1 | 277 |
} |
278 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
279 |
narrowOop oopDesc::encode_heap_oop_not_null(oop v) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
280 |
assert(!is_null(v), "oop value can never be zero"); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
281 |
assert(check_obj_alignment(v), "Address not aligned"); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
282 |
assert(Universe::heap()->is_in_reserved(v), "Address not in heap"); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
283 |
address base = Universe::narrow_oop_base(); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
284 |
int shift = Universe::narrow_oop_shift(); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
285 |
uint64_t pd = (uint64_t)(pointer_delta((void*)v, (void*)base, 1)); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
286 |
assert(OopEncodingHeapMax > pd, "change encoding max if new encoding"); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
287 |
uint64_t result = pd >> shift; |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
288 |
assert((result & CONST64(0xffffffff00000000)) == 0, "narrow oop overflow"); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
289 |
assert(decode_heap_oop(result) == v, "reversibility"); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
290 |
return (narrowOop)result; |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
291 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
292 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
293 |
narrowOop oopDesc::encode_heap_oop(oop v) { |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
294 |
return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(v); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
295 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
296 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
297 |
narrowOop oopDesc::load_heap_oop(narrowOop* p) { return *p; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
298 |
oop oopDesc::load_heap_oop(oop* p) { return *p; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
299 |
|
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
300 |
void oopDesc::store_heap_oop(narrowOop* p, narrowOop v) { *p = v; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
301 |
void oopDesc::store_heap_oop(oop* p, oop v) { *p = v; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
302 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
303 |
// Load and decode an oop out of the Java heap into a wide oop. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
304 |
oop oopDesc::load_decode_heap_oop_not_null(narrowOop* p) { |
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
305 |
return decode_heap_oop_not_null(load_heap_oop(p)); |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
306 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
307 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
308 |
// Load and decode an oop out of the heap accepting null |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
309 |
oop oopDesc::load_decode_heap_oop(narrowOop* p) { |
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
310 |
return decode_heap_oop(load_heap_oop(p)); |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
311 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
312 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
313 |
oop oopDesc::load_decode_heap_oop_not_null(oop* p) { return *p; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
314 |
oop oopDesc::load_decode_heap_oop(oop* p) { return *p; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
315 |
|
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
316 |
void oopDesc::encode_store_heap_oop_not_null(oop* p, oop v) { *p = v; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
317 |
void oopDesc::encode_store_heap_oop(oop* p, oop v) { *p = v; } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
318 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
319 |
// Encode and store a heap oop. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
320 |
void oopDesc::encode_store_heap_oop_not_null(narrowOop* p, oop v) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
321 |
*p = encode_heap_oop_not_null(v); |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
322 |
} |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
323 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
324 |
// Encode and store a heap oop allowing for null. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
325 |
void oopDesc::encode_store_heap_oop(narrowOop* p, oop v) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
326 |
*p = encode_heap_oop(v); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
327 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
328 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
329 |
inline oop oopDesc::obj_field(int offset) const { return HeapAccess<>::oop_load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
330 |
inline void oopDesc::obj_field_put(int offset, oop value) { HeapAccess<>::oop_store_at(as_oop(), offset, value); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
331 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
332 |
inline jbyte oopDesc::byte_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
333 |
inline void oopDesc::byte_field_put(int offset, jbyte value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
334 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
335 |
inline jchar oopDesc::char_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
336 |
inline void oopDesc::char_field_put(int offset, jchar value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
1 | 337 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
338 |
inline jboolean oopDesc::bool_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
339 |
inline void oopDesc::bool_field_put(int offset, jboolean value) { HeapAccess<>::store_at(as_oop(), offset, jboolean(value & 1)); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
340 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
341 |
inline jshort oopDesc::short_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
342 |
inline void oopDesc::short_field_put(int offset, jshort value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
46722
ae2cfffe2e64
8185296: java_lang_Class::array_klass should be array_klass_acquire
coleenp
parents:
46710
diff
changeset
|
343 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
344 |
inline jint oopDesc::int_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
345 |
inline void oopDesc::int_field_put(int offset, jint value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
346 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
347 |
inline jlong oopDesc::long_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
348 |
inline void oopDesc::long_field_put(int offset, jlong value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
349 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
350 |
inline jfloat oopDesc::float_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
351 |
inline void oopDesc::float_field_put(int offset, jfloat value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
352 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
353 |
inline jdouble oopDesc::double_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
354 |
inline void oopDesc::double_field_put(int offset, jdouble value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
355 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
356 |
bool oopDesc::is_locked() const { |
1 | 357 |
return mark()->is_locked(); |
358 |
} |
|
359 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
360 |
bool oopDesc::is_unlocked() const { |
1 | 361 |
return mark()->is_unlocked(); |
362 |
} |
|
363 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
364 |
bool oopDesc::has_bias_pattern() const { |
1 | 365 |
return mark()->has_bias_pattern(); |
366 |
} |
|
367 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
368 |
// Used only for markSweep, scavenging |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
369 |
bool oopDesc::is_gc_marked() const { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
370 |
return mark()->is_marked(); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
371 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
372 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
373 |
bool oopDesc::is_scavengable() const { |
47624
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47609
diff
changeset
|
374 |
return Universe::heap()->is_scavengable(oop(const_cast<oopDesc*>(this))); |
29081
c61eb4914428
8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents:
27898
diff
changeset
|
375 |
} |
c61eb4914428
8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents:
27898
diff
changeset
|
376 |
|
1 | 377 |
// Used by scavengers |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
378 |
bool oopDesc::is_forwarded() const { |
1 | 379 |
// The extra heap check is needed since the obj might be locked, in which case the |
380 |
// mark would point to a stack location and have the sentinel bit cleared |
|
381 |
return mark()->is_marked(); |
|
382 |
} |
|
383 |
||
384 |
// Used by scavengers |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
385 |
void oopDesc::forward_to(oop p) { |
5694
1e0532a6abff
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
3262
diff
changeset
|
386 |
assert(check_obj_alignment(p), |
1e0532a6abff
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
3262
diff
changeset
|
387 |
"forwarding to something not aligned"); |
1 | 388 |
assert(Universe::heap()->is_in_reserved(p), |
389 |
"forwarding to something not in heap"); |
|
46810
7dad333205cd
8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents:
46722
diff
changeset
|
390 |
assert(!is_archive_object(oop(this)) && |
7dad333205cd
8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents:
46722
diff
changeset
|
391 |
!is_archive_object(p), |
7dad333205cd
8179302: Pre-resolve constant pool string entries and cache resolved_reference arrays in CDS archive.
jiangli
parents:
46722
diff
changeset
|
392 |
"forwarding archive object"); |
1 | 393 |
markOop m = markOopDesc::encode_pointer_as_mark(p); |
394 |
assert(m->decode_pointer() == p, "encoding must be reversable"); |
|
395 |
set_mark(m); |
|
396 |
} |
|
397 |
||
398 |
// Used by parallel scavengers |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
399 |
bool oopDesc::cas_forward_to(oop p, markOop compare) { |
5694
1e0532a6abff
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
3262
diff
changeset
|
400 |
assert(check_obj_alignment(p), |
1e0532a6abff
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
3262
diff
changeset
|
401 |
"forwarding to something not aligned"); |
1 | 402 |
assert(Universe::heap()->is_in_reserved(p), |
403 |
"forwarding to something not in heap"); |
|
404 |
markOop m = markOopDesc::encode_pointer_as_mark(p); |
|
405 |
assert(m->decode_pointer() == p, "encoding must be reversable"); |
|
406 |
return cas_set_mark(m, compare) == compare; |
|
407 |
} |
|
408 |
||
29689
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
409 |
#if INCLUDE_ALL_GCS |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
410 |
oop oopDesc::forward_to_atomic(oop p) { |
29689
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
411 |
markOop oldMark = mark(); |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
412 |
markOop forwardPtrMark = markOopDesc::encode_pointer_as_mark(p); |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
413 |
markOop curMark; |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
414 |
|
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
415 |
assert(forwardPtrMark->decode_pointer() == p, "encoding must be reversable"); |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
416 |
assert(sizeof(markOop) == sizeof(intptr_t), "CAS below requires this."); |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
417 |
|
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
418 |
while (!oldMark->is_marked()) { |
46958
a13bd8c6b7a2
8186166: Generalize Atomic::cmpxchg with templates
eosterlund
parents:
46810
diff
changeset
|
419 |
curMark = Atomic::cmpxchg(forwardPtrMark, &_mark, oldMark); |
29689
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
420 |
assert(is_forwarded(), "object should have been forwarded"); |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
421 |
if (curMark == oldMark) { |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
422 |
return NULL; |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
423 |
} |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
424 |
// If the CAS was unsuccessful then curMark->is_marked() |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
425 |
// should return true as another thread has CAS'd in another |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
426 |
// forwarding pointer. |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
427 |
oldMark = curMark; |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
428 |
} |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
429 |
return forwardee(); |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
430 |
} |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
431 |
#endif |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
432 |
|
1 | 433 |
// Note that the forwardee is not the same thing as the displaced_mark. |
434 |
// The forwardee is used when copying during scavenge and mark-sweep. |
|
435 |
// It does need to clear the low two locking- and GC-related bits. |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
436 |
oop oopDesc::forwardee() const { |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
437 |
return (oop) mark()->decode_pointer(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
438 |
} |
1 | 439 |
|
440 |
// The following method needs to be MT safe. |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
441 |
uint oopDesc::age() const { |
1 | 442 |
assert(!is_forwarded(), "Attempt to read age from forwarded mark"); |
443 |
if (has_displaced_mark()) { |
|
444 |
return displaced_mark()->age(); |
|
445 |
} else { |
|
446 |
return mark()->age(); |
|
447 |
} |
|
448 |
} |
|
449 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
450 |
void oopDesc::incr_age() { |
1 | 451 |
assert(!is_forwarded(), "Attempt to increment age of forwarded mark"); |
452 |
if (has_displaced_mark()) { |
|
453 |
set_displaced_mark(displaced_mark()->incr_age()); |
|
454 |
} else { |
|
455 |
set_mark(mark()->incr_age()); |
|
456 |
} |
|
457 |
} |
|
458 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
459 |
#if INCLUDE_ALL_GCS |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
460 |
void oopDesc::pc_follow_contents(ParCompactionManager* cm) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
461 |
klass()->oop_pc_follow_contents(this, cm); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
462 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
463 |
|
35877
a2a62511d0f8
8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents:
35862
diff
changeset
|
464 |
void oopDesc::pc_update_contents(ParCompactionManager* cm) { |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
465 |
Klass* k = klass(); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
466 |
if (!k->is_typeArray_klass()) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
467 |
// It might contain oops beyond the header, so take the virtual call. |
35877
a2a62511d0f8
8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents:
35862
diff
changeset
|
468 |
k->oop_pc_update_pointers(this, cm); |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
469 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
470 |
// Else skip it. The TypeArrayKlass in the header never needs scavenging. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
471 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
472 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
473 |
void oopDesc::ps_push_contents(PSPromotionManager* pm) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
474 |
Klass* k = klass(); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
475 |
if (!k->is_typeArray_klass()) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
476 |
// It might contain oops beyond the header, so take the virtual call. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
477 |
k->oop_ps_push_contents(this, pm); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
478 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
479 |
// Else skip it. The TypeArrayKlass in the header never needs scavenging. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
480 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
481 |
#endif // INCLUDE_ALL_GCS |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
482 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
483 |
#define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
484 |
\ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
485 |
void oopDesc::oop_iterate(OopClosureType* blk) { \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
486 |
klass()->oop_oop_iterate##nv_suffix(this, blk); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
487 |
} \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
488 |
\ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
489 |
void oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
490 |
klass()->oop_oop_iterate_bounded##nv_suffix(this, blk, mr); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
491 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
492 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
493 |
#define OOP_ITERATE_SIZE_DEFN(OopClosureType, nv_suffix) \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
494 |
\ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
495 |
int oopDesc::oop_iterate_size(OopClosureType* blk) { \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
496 |
Klass* k = klass(); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
497 |
int size = size_given_klass(k); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
498 |
k->oop_oop_iterate##nv_suffix(this, blk); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
499 |
return size; \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
500 |
} \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
501 |
\ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
502 |
int oopDesc::oop_iterate_size(OopClosureType* blk, MemRegion mr) { \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
503 |
Klass* k = klass(); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
504 |
int size = size_given_klass(k); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
505 |
k->oop_oop_iterate_bounded##nv_suffix(this, blk, mr); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
506 |
return size; \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
507 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
508 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
509 |
int oopDesc::oop_iterate_no_header(OopClosure* blk) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
510 |
// The NoHeaderExtendedOopClosure wraps the OopClosure and proxies all |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
511 |
// the do_oop calls, but turns off all other features in ExtendedOopClosure. |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
512 |
NoHeaderExtendedOopClosure cl(blk); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
513 |
return oop_iterate_size(&cl); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
514 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
515 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
516 |
int oopDesc::oop_iterate_no_header(OopClosure* blk, MemRegion mr) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
517 |
NoHeaderExtendedOopClosure cl(blk); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
518 |
return oop_iterate_size(&cl, mr); |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
519 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
520 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
521 |
#if INCLUDE_ALL_GCS |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
522 |
#define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
523 |
\ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
524 |
inline void oopDesc::oop_iterate_backwards(OopClosureType* blk) { \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
525 |
klass()->oop_oop_iterate_backwards##nv_suffix(this, blk); \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
526 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
527 |
#else |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
528 |
#define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
529 |
#endif // INCLUDE_ALL_GCS |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
530 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
531 |
#define ALL_OOPDESC_OOP_ITERATE(OopClosureType, nv_suffix) \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
532 |
OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
533 |
OOP_ITERATE_SIZE_DEFN(OopClosureType, nv_suffix) \ |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
534 |
OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
535 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
536 |
ALL_OOP_OOP_ITERATE_CLOSURES_1(ALL_OOPDESC_OOP_ITERATE) |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
537 |
ALL_OOP_OOP_ITERATE_CLOSURES_2(ALL_OOPDESC_OOP_ITERATE) |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
538 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
539 |
intptr_t oopDesc::identity_hash() { |
1 | 540 |
// Fast case; if the object is unlocked and the hash value is set, no locking is needed |
541 |
// Note: The mark must be read into local variable to avoid concurrent updates. |
|
542 |
markOop mrk = mark(); |
|
543 |
if (mrk->is_unlocked() && !mrk->has_no_hash()) { |
|
544 |
return mrk->hash(); |
|
545 |
} else if (mrk->is_marked()) { |
|
546 |
return mrk->hash(); |
|
547 |
} else { |
|
548 |
return slow_identity_hash(); |
|
549 |
} |
|
550 |
} |
|
551 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
552 |
bool oopDesc::has_displaced_mark() const { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
553 |
return mark()->has_displaced_mark_helper(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
554 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
555 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
556 |
markOop oopDesc::displaced_mark() const { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
557 |
return mark()->displaced_mark_helper(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
558 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
559 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
560 |
void oopDesc::set_displaced_mark(markOop m) { |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
561 |
mark()->set_displaced_mark_helper(m); |
1 | 562 |
} |
563 |
||
7397 | 564 |
#endif // SHARE_VM_OOPS_OOP_INLINE_HPP |