author | pliden |
Tue, 17 Sep 2019 09:51:02 +0200 | |
changeset 58175 | 272910ccd7bb |
parent 58015 | dd84de796f2c |
child 58679 | 9c3209ff7550 |
child 58901 | 2700c409ff10 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
52271
diff
changeset
|
2 |
* Copyright (c) 1997, 2019, 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 |
||
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
52271
diff
changeset
|
25 |
#ifndef SHARE_OOPS_OOP_INLINE_HPP |
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
52271
diff
changeset
|
26 |
#define SHARE_OOPS_OOP_INLINE_HPP |
7397 | 27 |
|
49593
4dd58ecc9912
8200105: Remove cyclic dependency between oop.inline.hpp and collectedHeap.inline.hpp
stefank
parents:
49592
diff
changeset
|
28 |
#include "gc/shared/collectedHeap.hpp" |
54786 | 29 |
#include "memory/universe.hpp" |
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
30 |
#include "oops/access.inline.hpp" |
7397 | 31 |
#include "oops/arrayKlass.hpp" |
32 |
#include "oops/arrayOop.hpp" |
|
49592
77fb0be7d19f
8199946: Move load/store and encode/decode out of oopDesc
stefank
parents:
49452
diff
changeset
|
33 |
#include "oops/compressedOops.inline.hpp" |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
15484
diff
changeset
|
34 |
#include "oops/klass.inline.hpp" |
57811 | 35 |
#include "oops/markWord.inline.hpp" |
7397 | 36 |
#include "oops/oop.hpp" |
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
39695
diff
changeset
|
37 |
#include "runtime/atomic.hpp" |
50429
83aec1d357d4
8204301: Make OrderAccess functions available to hpp rather than inline.hpp files
coleenp
parents:
50398
diff
changeset
|
38 |
#include "runtime/orderAccess.hpp" |
7397 | 39 |
#include "runtime/os.hpp" |
46625 | 40 |
#include "utilities/align.hpp" |
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
13969
diff
changeset
|
41 |
#include "utilities/macros.hpp" |
7397 | 42 |
|
1 | 43 |
// Implementation of all inlined member functions defined in oop.hpp |
44 |
// We need a separate file to avoid circular references |
|
45 |
||
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
46 |
markWord oopDesc::mark() const { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
47 |
uintptr_t v = HeapAccess<MO_VOLATILE>::load_at(as_oop(), mark_offset_in_bytes()); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
48 |
return markWord(v); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
49 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
50 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
51 |
markWord oopDesc::mark_raw() const { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
52 |
return Atomic::load(&_mark); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
53 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
54 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
55 |
markWord* oopDesc::mark_addr_raw() const { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
56 |
return (markWord*) &_mark; |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
57 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
58 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
59 |
void oopDesc::set_mark(markWord m) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
60 |
HeapAccess<MO_VOLATILE>::store_at(as_oop(), mark_offset_in_bytes(), m.value()); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
61 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
62 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
63 |
void oopDesc::set_mark_raw(markWord m) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
64 |
Atomic::store(m, &_mark); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
65 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
66 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
67 |
void oopDesc::set_mark_raw(HeapWord* mem, markWord m) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
68 |
*(markWord*)(((char*)mem) + mark_offset_in_bytes()) = m; |
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
69 |
} |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
70 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
71 |
void oopDesc::release_set_mark(markWord m) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
72 |
HeapAccess<MO_RELEASE>::store_at(as_oop(), mark_offset_in_bytes(), m.value()); |
1 | 73 |
} |
74 |
||
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
75 |
markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
76 |
uintptr_t v = HeapAccess<>::atomic_cmpxchg_at(new_mark.value(), as_oop(), mark_offset_in_bytes(), old_mark.value()); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
77 |
return markWord(v); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
78 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
79 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
80 |
markWord oopDesc::cas_set_mark_raw(markWord new_mark, markWord old_mark, atomic_memory_order order) { |
50398
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
81 |
return Atomic::cmpxchg(new_mark, &_mark, old_mark, order); |
1 | 82 |
} |
83 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
84 |
void oopDesc::init_mark() { |
57812
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
85 |
set_mark(markWord::prototype_for_klass(klass())); |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
86 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
87 |
|
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
88 |
void oopDesc::init_mark_raw() { |
57812
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
89 |
set_mark_raw(markWord::prototype_for_klass(klass())); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
90 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
91 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
92 |
Klass* oopDesc::klass() const { |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
93 |
if (UseCompressedClassPointers) { |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
53244
diff
changeset
|
94 |
return CompressedKlassPointers::decode_not_null(_metadata._compressed_klass); |
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
95 |
} else { |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
96 |
return _metadata._klass; |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
97 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
98 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
99 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
100 |
Klass* oopDesc::klass_or_null() const volatile { |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
101 |
if (UseCompressedClassPointers) { |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
53244
diff
changeset
|
102 |
return CompressedKlassPointers::decode(_metadata._compressed_klass); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
103 |
} else { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
104 |
return _metadata._klass; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
105 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
106 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
107 |
|
41310 | 108 |
Klass* oopDesc::klass_or_null_acquire() const volatile { |
109 |
if (UseCompressedClassPointers) { |
|
110 |
// Workaround for non-const load_acquire parameter. |
|
111 |
const volatile narrowKlass* addr = &_metadata._compressed_klass; |
|
112 |
volatile narrowKlass* xaddr = const_cast<volatile narrowKlass*>(addr); |
|
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
53244
diff
changeset
|
113 |
return CompressedKlassPointers::decode(OrderAccess::load_acquire(xaddr)); |
41310 | 114 |
} else { |
47634
6a0c42c40cd1
8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents:
47624
diff
changeset
|
115 |
return OrderAccess::load_acquire(&_metadata._klass); |
41310 | 116 |
} |
117 |
} |
|
118 |
||
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
119 |
Klass** oopDesc::klass_addr(HeapWord* mem) { |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
120 |
// 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
|
121 |
// UseCompressedOops |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
122 |
assert(!UseCompressedClassPointers, "only supported with uncompressed klass pointers"); |
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
123 |
ByteSize offset = byte_offset_of(oopDesc, _metadata._klass); |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
124 |
return (Klass**) (((char*)mem) + in_bytes(offset)); |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
125 |
} |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
126 |
|
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
127 |
narrowKlass* oopDesc::compressed_klass_addr(HeapWord* mem) { |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
128 |
assert(UseCompressedClassPointers, "only called by compressed klass pointers"); |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
129 |
ByteSize offset = byte_offset_of(oopDesc, _metadata._compressed_klass); |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
130 |
return (narrowKlass*) (((char*)mem) + in_bytes(offset)); |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
131 |
} |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
132 |
|
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
133 |
Klass** oopDesc::klass_addr() { |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
134 |
return klass_addr((HeapWord*)this); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
135 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
136 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
137 |
narrowKlass* oopDesc::compressed_klass_addr() { |
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
138 |
return compressed_klass_addr((HeapWord*)this); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
139 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
140 |
|
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
141 |
#define CHECK_SET_KLASS(k) \ |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
142 |
do { \ |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
143 |
assert(Universe::is_bootstrapping() || k != NULL, "NULL Klass"); \ |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
144 |
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
|
145 |
} while (0) |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
146 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
147 |
void oopDesc::set_klass(Klass* k) { |
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
148 |
CHECK_SET_KLASS(k); |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
149 |
if (UseCompressedClassPointers) { |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
53244
diff
changeset
|
150 |
*compressed_klass_addr() = CompressedKlassPointers::encode_not_null(k); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
151 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
152 |
*klass_addr() = k; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
153 |
} |
1 | 154 |
} |
155 |
||
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
156 |
void oopDesc::release_set_klass(HeapWord* mem, Klass* klass) { |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
157 |
CHECK_SET_KLASS(klass); |
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
158 |
if (UseCompressedClassPointers) { |
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
159 |
OrderAccess::release_store(compressed_klass_addr(mem), |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
53244
diff
changeset
|
160 |
CompressedKlassPointers::encode_not_null(klass)); |
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
161 |
} else { |
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
162 |
OrderAccess::release_store(klass_addr(mem), klass); |
41177
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
163 |
} |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
164 |
} |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
165 |
|
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
166 |
#undef CHECK_SET_KLASS |
3869072fc2e1
8165808: Add release barriers when allocating objects with concurrent collection
kbarrett
parents:
40655
diff
changeset
|
167 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
168 |
int oopDesc::klass_gap() const { |
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
169 |
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
|
170 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
171 |
|
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
172 |
void oopDesc::set_klass_gap(HeapWord* mem, int v) { |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
173 |
if (UseCompressedClassPointers) { |
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
174 |
*(int*)(((char*)mem) + klass_gap_offset_in_bytes()) = v; |
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
175 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
176 |
} |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
177 |
|
50882
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
178 |
void oopDesc::set_klass_gap(int v) { |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
179 |
set_klass_gap((HeapWord*)this, v); |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
180 |
} |
80abf702eed8
8205683: Refactor heap allocation to separate concerns
eosterlund
parents:
50800
diff
changeset
|
181 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
182 |
void oopDesc::set_klass_to_list_ptr(oop k) { |
1 | 183 |
// This is only to be used during GC, for from-space objects, so no |
184 |
// barrier is needed. |
|
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19319
diff
changeset
|
185 |
if (UseCompressedClassPointers) { |
49592
77fb0be7d19f
8199946: Move load/store and encode/decode out of oopDesc
stefank
parents:
49452
diff
changeset
|
186 |
_metadata._compressed_klass = (narrowKlass)CompressedOops::encode(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
|
187 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
188 |
_metadata._klass = (Klass*)(address)k; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
189 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
190 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
191 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
192 |
oop oopDesc::list_ptr_from_klass() { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
193 |
// 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
|
194 |
if (UseCompressedClassPointers) { |
49592
77fb0be7d19f
8199946: Move load/store and encode/decode out of oopDesc
stefank
parents:
49452
diff
changeset
|
195 |
return CompressedOops::decode((narrowOop)_metadata._compressed_klass); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
196 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
197 |
// Special case for GC |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
198 |
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
|
199 |
} |
1 | 200 |
} |
201 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
202 |
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
|
203 |
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
|
204 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
205 |
|
35862
411842d0c882
8146395: Add inline qualifier in oop.hpp and fix inlining in gc files
goetz
parents:
35498
diff
changeset
|
206 |
int oopDesc::size() { |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
207 |
return size_given_klass(klass()); |
10540
92d59dba2407
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
8725
diff
changeset
|
208 |
} |
1 | 209 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
210 |
int oopDesc::size_given_klass(Klass* klass) { |
1 | 211 |
int lh = klass->layout_helper(); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
212 |
int s; |
1 | 213 |
|
214 |
// lh is now a value computed at class initialization that may hint |
|
215 |
// at the size. For instances, this is positive and equal to the |
|
216 |
// size. For arrays, this is negative and provides log2 of the |
|
217 |
// array element size. For other oops, it is zero and thus requires |
|
218 |
// a virtual call. |
|
219 |
// |
|
220 |
// We go to all this trouble because the size computation is at the |
|
221 |
// heart of phase 2 of mark-compaction, and called for every object, |
|
222 |
// alive or dead. So the speed here is equal in importance to the |
|
223 |
// speed of allocation. |
|
224 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
225 |
if (lh > Klass::_lh_neutral_value) { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
226 |
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
|
227 |
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
|
228 |
} else { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
229 |
s = klass->oop_size(this); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
230 |
} |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
231 |
} else if (lh <= Klass::_lh_neutral_value) { |
1 | 232 |
// The most common case is instances; fall through if so. |
233 |
if (lh < Klass::_lh_neutral_value) { |
|
234 |
// Second most common case is arrays. We have to fetch the |
|
235 |
// length of the array, shift (multiply) it appropriately, |
|
236 |
// up to wordSize, add the header, and align to object size. |
|
237 |
size_t size_in_bytes; |
|
238 |
size_t array_length = (size_t) ((arrayOop)this)->length(); |
|
239 |
size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh); |
|
240 |
size_in_bytes += Klass::layout_helper_header_size(lh); |
|
241 |
||
242 |
// This code could be simplified, but by keeping array_header_in_bytes |
|
243 |
// 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
|
244 |
// 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
|
245 |
s = (int)(align_up(size_in_bytes, MinObjAlignmentInBytes) / HeapWordSize); |
1 | 246 |
|
27898
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
247 |
// 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
|
248 |
// 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
|
249 |
// 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
|
250 |
// 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
|
251 |
// a concurrent change. |
27898
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
252 |
// ParNew also runs with promotion labs (which look like int |
1 | 253 |
// filler arrays) which are subject to changing their declared size |
254 |
// when finally retiring a PLAB; this also can cause the first disjunct |
|
255 |
// to fail for another worker thread that is concurrently walking the block |
|
256 |
// offset table. Both these invariant failures are benign for their |
|
257 |
// current uses; we relax the assertion checking to cover these two cases below: |
|
258 |
// is_objArray() && is_forwarded() // covers first scenario above |
|
259 |
// || is_typeArray() // covers second scenario above |
|
260 |
// 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
|
261 |
// technique, we will need to suitably modify the assertion. |
1 | 262 |
assert((s == klass->oop_size(this)) || |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
263 |
(Universe::heap()->is_gc_active() && |
27898
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
264 |
((is_typeArray() && UseConcMarkSweepGC) || |
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
25715
diff
changeset
|
265 |
(is_objArray() && is_forwarded() && (UseConcMarkSweepGC || UseParallelGC || UseG1GC)))), |
1 | 266 |
"wrong array object size"); |
267 |
} else { |
|
268 |
// Must be zero, so bite the bullet and take the virtual call. |
|
269 |
s = klass->oop_size(this); |
|
270 |
} |
|
271 |
} |
|
272 |
||
39695
946f1321c075
8158946: btree009 fails with assert(s > 0) failed: Bad size calculated
drwhite
parents:
37480
diff
changeset
|
273 |
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
|
274 |
assert(is_object_aligned(s), "Oop size is not properly aligned: %d", s); |
1 | 275 |
return s; |
276 |
} |
|
277 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
278 |
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
|
279 |
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
|
280 |
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
|
281 |
bool oopDesc::is_typeArray() const { return klass()->is_typeArray_klass(); } |
1 | 282 |
|
49041
44122f767467
8198286: Direct memory accessors in typeArrayOop.hpp should use Access API
eosterlund
parents:
48618
diff
changeset
|
283 |
void* oopDesc::field_addr_raw(int offset) const { return reinterpret_cast<void*>(cast_from_oop<intptr_t>(as_oop()) + offset); } |
44122f767467
8198286: Direct memory accessors in typeArrayOop.hpp should use Access API
eosterlund
parents:
48618
diff
changeset
|
284 |
void* oopDesc::field_addr(int offset) const { return Access<>::resolve(as_oop())->field_addr_raw(offset); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
285 |
|
49041
44122f767467
8198286: Direct memory accessors in typeArrayOop.hpp should use Access API
eosterlund
parents:
48618
diff
changeset
|
286 |
template <class T> |
44122f767467
8198286: Direct memory accessors in typeArrayOop.hpp should use Access API
eosterlund
parents:
48618
diff
changeset
|
287 |
T* oopDesc::obj_field_addr_raw(int offset) const { return (T*) field_addr_raw(offset); } |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
288 |
|
50191 | 289 |
template <typename T> |
290 |
size_t oopDesc::field_offset(T* p) const { return pointer_delta((void*)p, (void*)this, 1); } |
|
291 |
||
48618
688e5cbd0b91
8192003: Refactor weak references in StringTable to use the Access API
eosterlund
parents:
47998
diff
changeset
|
292 |
template <DecoratorSet decorators> |
688e5cbd0b91
8192003: Refactor weak references in StringTable to use the Access API
eosterlund
parents:
47998
diff
changeset
|
293 |
inline oop oopDesc::obj_field_access(int offset) const { return HeapAccess<decorators>::oop_load_at(as_oop(), offset); } |
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
294 |
inline oop oopDesc::obj_field(int offset) const { return HeapAccess<>::oop_load_at(as_oop(), offset); } |
48618
688e5cbd0b91
8192003: Refactor weak references in StringTable to use the Access API
eosterlund
parents:
47998
diff
changeset
|
295 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
296 |
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
|
297 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
298 |
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
|
299 |
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
|
300 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
301 |
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
|
302 |
inline void oopDesc::char_field_put(int offset, jchar value) { HeapAccess<>::store_at(as_oop(), offset, value); } |
1 | 303 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
304 |
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
|
305 |
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
|
306 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
307 |
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
|
308 |
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
|
309 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
310 |
inline jint oopDesc::int_field(int offset) const { return HeapAccess<>::load_at(as_oop(), offset); } |
51516
7c3891b9f1e0
8206457: Code paths from oop_iterate() must use barrier-free access
rkennke
parents:
50882
diff
changeset
|
311 |
inline jint oopDesc::int_field_raw(int offset) const { return RawAccess<>::load_at(as_oop(), offset); } |
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
312 |
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
|
313 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
314 |
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
|
315 |
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
|
316 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
317 |
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
|
318 |
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
|
319 |
|
47998
fb0275c320a0
8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents:
47634
diff
changeset
|
320 |
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
|
321 |
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
|
322 |
|
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
323 |
bool oopDesc::is_locked() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
324 |
return mark().is_locked(); |
1 | 325 |
} |
326 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
327 |
bool oopDesc::is_unlocked() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
328 |
return mark().is_unlocked(); |
1 | 329 |
} |
330 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
331 |
bool oopDesc::has_bias_pattern() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
332 |
return mark().has_bias_pattern(); |
1 | 333 |
} |
334 |
||
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
335 |
bool oopDesc::has_bias_pattern_raw() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
336 |
return mark_raw().has_bias_pattern(); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
337 |
} |
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
338 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
339 |
// Used only for markSweep, scavenging |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
340 |
bool oopDesc::is_gc_marked() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
341 |
return mark_raw().is_marked(); |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
342 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
343 |
|
1 | 344 |
// Used by scavengers |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
345 |
bool oopDesc::is_forwarded() const { |
1 | 346 |
// The extra heap check is needed since the obj might be locked, in which case the |
347 |
// mark would point to a stack location and have the sentinel bit cleared |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
348 |
return mark_raw().is_marked(); |
1 | 349 |
} |
350 |
||
351 |
// Used by scavengers |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
352 |
void oopDesc::forward_to(oop p) { |
58015
dd84de796f2c
8224815: Remove non-GC uses of CollectedHeap::is_in_reserved()
eosterlund
parents:
57812
diff
changeset
|
353 |
verify_forwardee(p); |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
354 |
markWord m = markWord::encode_pointer_as_mark(p); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
355 |
assert(m.decode_pointer() == p, "encoding must be reversable"); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
356 |
set_mark_raw(m); |
1 | 357 |
} |
358 |
||
359 |
// Used by parallel scavengers |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
360 |
bool oopDesc::cas_forward_to(oop p, markWord compare, atomic_memory_order order) { |
58015
dd84de796f2c
8224815: Remove non-GC uses of CollectedHeap::is_in_reserved()
eosterlund
parents:
57812
diff
changeset
|
361 |
verify_forwardee(p); |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
362 |
markWord m = markWord::encode_pointer_as_mark(p); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
363 |
assert(m.decode_pointer() == p, "encoding must be reversable"); |
50398
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
364 |
return cas_set_mark_raw(m, compare, order) == compare; |
1 | 365 |
} |
366 |
||
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
367 |
oop oopDesc::forward_to_atomic(oop p, markWord compare, atomic_memory_order order) { |
58015
dd84de796f2c
8224815: Remove non-GC uses of CollectedHeap::is_in_reserved()
eosterlund
parents:
57812
diff
changeset
|
368 |
verify_forwardee(p); |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
369 |
markWord m = markWord::encode_pointer_as_mark(p); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
370 |
assert(m.decode_pointer() == p, "encoding must be reversable"); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
371 |
markWord old_mark = cas_set_mark_raw(m, compare, order); |
52271 | 372 |
if (old_mark == compare) { |
373 |
return NULL; |
|
374 |
} else { |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
375 |
return (oop)old_mark.decode_pointer(); |
29689
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
376 |
} |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
377 |
} |
dc72789f83ae
8075249: Cleanup forward_to_atomic and ClaimedForwardPtr
stefank
parents:
29687
diff
changeset
|
378 |
|
1 | 379 |
// Note that the forwardee is not the same thing as the displaced_mark. |
380 |
// The forwardee is used when copying during scavenge and mark-sweep. |
|
381 |
// 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
|
382 |
oop oopDesc::forwardee() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
383 |
return (oop) mark_raw().decode_pointer(); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
384 |
} |
1 | 385 |
|
50398
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
386 |
// Note that the forwardee is not the same thing as the displaced_mark. |
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
387 |
// The forwardee is used when copying during scavenge and mark-sweep. |
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
388 |
// It does need to clear the low two locking- and GC-related bits. |
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
389 |
oop oopDesc::forwardee_acquire() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
390 |
return (oop) OrderAccess::load_acquire(&_mark).decode_pointer(); |
50398
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
391 |
} |
4d6a5c267541
8154736: enhancement of cmpxchg and copy_to_survivor for ppc64
mhorie
parents:
50191
diff
changeset
|
392 |
|
1 | 393 |
// 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
|
394 |
uint oopDesc::age() const { |
1 | 395 |
assert(!is_forwarded(), "Attempt to read age from forwarded mark"); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
396 |
if (has_displaced_mark_raw()) { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
397 |
return displaced_mark_raw().age(); |
1 | 398 |
} else { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
399 |
return mark_raw().age(); |
1 | 400 |
} |
401 |
} |
|
402 |
||
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
403 |
void oopDesc::incr_age() { |
1 | 404 |
assert(!is_forwarded(), "Attempt to increment age of forwarded mark"); |
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
405 |
if (has_displaced_mark_raw()) { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
406 |
set_displaced_mark_raw(displaced_mark_raw().incr_age()); |
1 | 407 |
} else { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
408 |
set_mark_raw(mark_raw().incr_age()); |
1 | 409 |
} |
410 |
} |
|
411 |
||
50752 | 412 |
template <typename OopClosureType> |
413 |
void oopDesc::oop_iterate(OopClosureType* cl) { |
|
414 |
OopIteratorClosureDispatch::oop_oop_iterate(cl, this, klass()); |
|
415 |
} |
|
416 |
||
417 |
template <typename OopClosureType> |
|
418 |
void oopDesc::oop_iterate(OopClosureType* cl, MemRegion mr) { |
|
419 |
OopIteratorClosureDispatch::oop_oop_iterate(cl, this, klass(), mr); |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
420 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
421 |
|
50752 | 422 |
template <typename OopClosureType> |
423 |
int oopDesc::oop_iterate_size(OopClosureType* cl) { |
|
424 |
Klass* k = klass(); |
|
425 |
int size = size_given_klass(k); |
|
426 |
OopIteratorClosureDispatch::oop_oop_iterate(cl, this, k); |
|
427 |
return size; |
|
428 |
} |
|
429 |
||
430 |
template <typename OopClosureType> |
|
431 |
int oopDesc::oop_iterate_size(OopClosureType* cl, MemRegion mr) { |
|
432 |
Klass* k = klass(); |
|
433 |
int size = size_given_klass(k); |
|
434 |
OopIteratorClosureDispatch::oop_oop_iterate(cl, this, k, mr); |
|
435 |
return size; |
|
436 |
} |
|
437 |
||
438 |
template <typename OopClosureType> |
|
439 |
void oopDesc::oop_iterate_backwards(OopClosureType* cl) { |
|
440 |
OopIteratorClosureDispatch::oop_oop_iterate_backwards(cl, this, klass()); |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
441 |
} |
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
442 |
|
49592
77fb0be7d19f
8199946: Move load/store and encode/decode out of oopDesc
stefank
parents:
49452
diff
changeset
|
443 |
bool oopDesc::is_instanceof_or_null(oop obj, Klass* klass) { |
77fb0be7d19f
8199946: Move load/store and encode/decode out of oopDesc
stefank
parents:
49452
diff
changeset
|
444 |
return obj == NULL || obj->klass()->is_subtype_of(klass); |
77fb0be7d19f
8199946: Move load/store and encode/decode out of oopDesc
stefank
parents:
49452
diff
changeset
|
445 |
} |
77fb0be7d19f
8199946: Move load/store and encode/decode out of oopDesc
stefank
parents:
49452
diff
changeset
|
446 |
|
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
33611
diff
changeset
|
447 |
intptr_t oopDesc::identity_hash() { |
1 | 448 |
// Fast case; if the object is unlocked and the hash value is set, no locking is needed |
449 |
// Note: The mark must be read into local variable to avoid concurrent updates. |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
450 |
markWord mrk = mark(); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
451 |
if (mrk.is_unlocked() && !mrk.has_no_hash()) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
452 |
return mrk.hash(); |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
453 |
} else if (mrk.is_marked()) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
454 |
return mrk.hash(); |
1 | 455 |
} else { |
456 |
return slow_identity_hash(); |
|
457 |
} |
|
458 |
} |
|
459 |
||
49722
a47d1e21b3f1
8199735: Mark word updates need to use Access API
rkennke
parents:
49593
diff
changeset
|
460 |
bool oopDesc::has_displaced_mark_raw() const { |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
461 |
return mark_raw().has_displaced_mark_helper(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
462 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
463 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
464 |
markWord oopDesc::displaced_mark_raw() const { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
465 |
return mark_raw().displaced_mark_helper(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
466 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10540
diff
changeset
|
467 |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
468 |
void oopDesc::set_displaced_mark_raw(markWord m) { |
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
54786
diff
changeset
|
469 |
mark_raw().set_displaced_mark_helper(m); |
1 | 470 |
} |
471 |
||
57812
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
472 |
// Supports deferred calling of obj->klass(). |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
473 |
class DeferredObjectToKlass { |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
474 |
const oopDesc* _obj; |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
475 |
|
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
476 |
public: |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
477 |
DeferredObjectToKlass(const oopDesc* obj) : _obj(obj) {} |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
478 |
|
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
479 |
// Implicitly convertible to const Klass*. |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
480 |
operator const Klass*() const { |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
481 |
return _obj->klass(); |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
482 |
} |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
483 |
}; |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
484 |
|
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
485 |
bool oopDesc::mark_must_be_preserved() const { |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
486 |
return mark_must_be_preserved(mark_raw()); |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
487 |
} |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
488 |
|
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
489 |
bool oopDesc::mark_must_be_preserved(markWord m) const { |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
490 |
// There's a circular dependency between oop.inline.hpp and |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
491 |
// markWord.inline.hpp because markWord::must_be_preserved wants to call |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
492 |
// oopDesc::klass(). This could be solved by calling klass() here. However, |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
493 |
// not all paths inside must_be_preserved calls klass(). Defer the call until |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
494 |
// the klass is actually needed. |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
495 |
return m.must_be_preserved(DeferredObjectToKlass(this)); |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
496 |
} |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
497 |
|
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
498 |
bool oopDesc::mark_must_be_preserved_for_promotion_failure(markWord m) const { |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
499 |
return m.must_be_preserved_for_promotion_failure(DeferredObjectToKlass(this)); |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
500 |
} |
9bb28ccc6106
8229839: Break circular dependency between oop.inline.hpp and markWord.inline.hpp
stefank
parents:
57811
diff
changeset
|
501 |
|
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
52271
diff
changeset
|
502 |
#endif // SHARE_OOPS_OOP_INLINE_HPP |