author | zgu |
Wed, 06 Nov 2019 09:50:53 -0500 | |
changeset 58946 | 83810b7d12e7 |
parent 58819 | ef8be51fff48 |
child 58985 | 5606867a5e6e |
permissions | -rw-r--r-- |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1 |
/* |
54763
2584e5772546
8222926: Shenandoah build fails with --with-jvm-features=-compiler1
aoqi
parents:
54755
diff
changeset
|
2 |
* Copyright (c) 2018, 2019, Red Hat, Inc. All rights reserved. |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
3 |
* |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
4 |
* This code is free software; you can redistribute it and/or modify it |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
5 |
* under the terms of the GNU General Public License version 2 only, as |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
6 |
* published by the Free Software Foundation. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
7 |
* |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
8 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
9 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
10 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
11 |
* version 2 for more details (a copy is included in the LICENSE file that |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
12 |
* accompanied this code). |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
13 |
* |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
14 |
* You should have received a copy of the GNU General Public License version |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
15 |
* 2 along with this work; if not, write to the Free Software Foundation, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
16 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
17 |
* |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
18 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
19 |
* or visit www.oracle.com if you need additional information or have any |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
20 |
* questions. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
21 |
* |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
22 |
*/ |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
23 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
24 |
#include "precompiled.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
25 |
#include "gc/shenandoah/shenandoahBarrierSetAssembler.hpp" |
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
26 |
#include "gc/shenandoah/shenandoahConcurrentRoots.hpp" |
54766
1321f8cf9de5
8223567: Rename ShenandoahBrooksPointer to ShenandoahForwarding
rkennke
parents:
54763
diff
changeset
|
27 |
#include "gc/shenandoah/shenandoahForwarding.hpp" |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
28 |
#include "gc/shenandoah/shenandoahHeap.inline.hpp" |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
29 |
#include "gc/shenandoah/shenandoahHeapRegion.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
30 |
#include "gc/shenandoah/shenandoahHeuristics.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
31 |
#include "gc/shenandoah/shenandoahRuntime.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
32 |
#include "gc/shenandoah/shenandoahThreadLocalData.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
33 |
#include "interpreter/interpreter.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
34 |
#include "interpreter/interp_masm.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
35 |
#include "runtime/sharedRuntime.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
36 |
#include "runtime/thread.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
37 |
#include "utilities/macros.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
38 |
#ifdef COMPILER1 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
39 |
#include "c1/c1_LIRAssembler.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
40 |
#include "c1/c1_MacroAssembler.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
41 |
#include "gc/shenandoah/c1/shenandoahBarrierSetC1.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
42 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
43 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
44 |
#define __ masm-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
45 |
|
54423 | 46 |
address ShenandoahBarrierSetAssembler::_shenandoah_lrb = NULL; |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
47 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
48 |
void ShenandoahBarrierSetAssembler::arraycopy_prologue(MacroAssembler* masm, DecoratorSet decorators, BasicType type, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
49 |
Register src, Register dst, Register count) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
50 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
51 |
bool dest_uninitialized = (decorators & IS_DEST_UNINITIALIZED) != 0; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
52 |
|
58273
08a5148e7c4e
8230505: Replace JVM type comparisons to T_OBJECT and T_ARRAY with call to is_reference_type
lfoltan
parents:
58272
diff
changeset
|
53 |
if (is_reference_type(type)) { |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
54 |
|
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
55 |
if ((ShenandoahSATBBarrier && !dest_uninitialized) || ShenandoahLoadRefBarrier) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
56 |
#ifdef _LP64 |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
57 |
Register thread = r15_thread; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
58 |
#else |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
59 |
Register thread = rax; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
60 |
if (thread == src || thread == dst || thread == count) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
61 |
thread = rbx; |
54755
de34f4b370b0
8223244: Fix usage of ARRAYCOPY_DISJOINT decorator
rkennke
parents:
54425
diff
changeset
|
62 |
} |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
63 |
if (thread == src || thread == dst || thread == count) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
64 |
thread = rcx; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
65 |
} |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
66 |
if (thread == src || thread == dst || thread == count) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
67 |
thread = rdx; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
68 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
69 |
__ push(thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
70 |
__ get_thread(thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
71 |
#endif |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
72 |
assert_different_registers(src, dst, count, thread); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
73 |
|
54383 | 74 |
Label done; |
75 |
// Short-circuit if count == 0. |
|
76 |
__ testptr(count, count); |
|
77 |
__ jcc(Assembler::zero, done); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
78 |
|
54383 | 79 |
// Avoid runtime call when not marking. |
80 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
|
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
81 |
int flags = ShenandoahHeap::HAS_FORWARDED; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
82 |
if (!dest_uninitialized) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
83 |
flags |= ShenandoahHeap::MARKING; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
84 |
} |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
85 |
__ testb(gc_state, flags); |
54383 | 86 |
__ jcc(Assembler::zero, done); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
87 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
88 |
__ pusha(); // push registers |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
89 |
#ifdef _LP64 |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
90 |
assert(src == rdi, "expected"); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
91 |
assert(dst == rsi, "expected"); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
92 |
assert(count == rdx, "expected"); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
93 |
if (UseCompressedOops) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
94 |
if (dest_uninitialized) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
95 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_array_pre_duinit_narrow_oop_entry), src, dst, count); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
96 |
} else { |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
97 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_array_pre_narrow_oop_entry), src, dst, count); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
98 |
} |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
99 |
} else |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
100 |
#endif |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
101 |
{ |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
102 |
if (dest_uninitialized) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
103 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_array_pre_duinit_oop_entry), src, dst, count); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
104 |
} else { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
105 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_array_pre_oop_entry), src, dst, count); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
106 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
107 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
108 |
__ popa(); |
54383 | 109 |
__ bind(done); |
110 |
NOT_LP64(__ pop(thread);) |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
111 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
112 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
113 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
114 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
115 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
116 |
void ShenandoahBarrierSetAssembler::shenandoah_write_barrier_pre(MacroAssembler* masm, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
117 |
Register obj, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
118 |
Register pre_val, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
119 |
Register thread, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
120 |
Register tmp, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
121 |
bool tosca_live, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
122 |
bool expand_call) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
123 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
124 |
if (ShenandoahSATBBarrier) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
125 |
satb_write_barrier_pre(masm, obj, pre_val, thread, tmp, tosca_live, expand_call); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
126 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
127 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
128 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
129 |
void ShenandoahBarrierSetAssembler::satb_write_barrier_pre(MacroAssembler* masm, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
130 |
Register obj, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
131 |
Register pre_val, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
132 |
Register thread, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
133 |
Register tmp, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
134 |
bool tosca_live, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
135 |
bool expand_call) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
136 |
// If expand_call is true then we expand the call_VM_leaf macro |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
137 |
// directly to skip generating the check by |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
138 |
// InterpreterMacroAssembler::call_VM_leaf_base that checks _last_sp. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
139 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
140 |
#ifdef _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
141 |
assert(thread == r15_thread, "must be"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
142 |
#endif // _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
143 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
144 |
Label done; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
145 |
Label runtime; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
146 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
147 |
assert(pre_val != noreg, "check this code"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
148 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
149 |
if (obj != noreg) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
150 |
assert_different_registers(obj, pre_val, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
151 |
assert(pre_val != rax, "check this code"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
152 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
153 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
154 |
Address in_progress(thread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_active_offset())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
155 |
Address index(thread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_index_offset())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
156 |
Address buffer(thread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_buffer_offset())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
157 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
158 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
159 |
__ testb(gc_state, ShenandoahHeap::MARKING | ShenandoahHeap::TRAVERSAL); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
160 |
__ jcc(Assembler::zero, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
161 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
162 |
// Do we need to load the previous value? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
163 |
if (obj != noreg) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
164 |
__ load_heap_oop(pre_val, Address(obj, 0), noreg, noreg, AS_RAW); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
165 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
166 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
167 |
// Is the previous value null? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
168 |
__ cmpptr(pre_val, (int32_t) NULL_WORD); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
169 |
__ jcc(Assembler::equal, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
170 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
171 |
// Can we store original value in the thread's buffer? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
172 |
// Is index == 0? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
173 |
// (The index field is typed as size_t.) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
174 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
175 |
__ movptr(tmp, index); // tmp := *index_adr |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
176 |
__ cmpptr(tmp, 0); // tmp == 0? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
177 |
__ jcc(Assembler::equal, runtime); // If yes, goto runtime |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
178 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
179 |
__ subptr(tmp, wordSize); // tmp := tmp - wordSize |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
180 |
__ movptr(index, tmp); // *index_adr := tmp |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
181 |
__ addptr(tmp, buffer); // tmp := tmp + *buffer_adr |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
182 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
183 |
// Record the previous value |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
184 |
__ movptr(Address(tmp, 0), pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
185 |
__ jmp(done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
186 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
187 |
__ bind(runtime); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
188 |
// save the live input values |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
189 |
if(tosca_live) __ push(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
190 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
191 |
if (obj != noreg && obj != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
192 |
__ push(obj); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
193 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
194 |
if (pre_val != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
195 |
__ push(pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
196 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
197 |
// Calling the runtime using the regular call_VM_leaf mechanism generates |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
198 |
// code (generated by InterpreterMacroAssember::call_VM_leaf_base) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
199 |
// that checks that the *(ebp+frame::interpreter_frame_last_sp) == NULL. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
200 |
// |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
201 |
// If we care generating the pre-barrier without a frame (e.g. in the |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
202 |
// intrinsified Reference.get() routine) then ebp might be pointing to |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
203 |
// the caller frame and so this check will most likely fail at runtime. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
204 |
// |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
205 |
// Expanding the call directly bypasses the generation of the check. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
206 |
// So when we do not have have a full interpreter frame on the stack |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
207 |
// expand_call should be passed true. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
208 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
209 |
NOT_LP64( __ push(thread); ) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
210 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
211 |
#ifdef _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
212 |
// We move pre_val into c_rarg0 early, in order to avoid smashing it, should |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
213 |
// pre_val be c_rarg1 (where the call prologue would copy thread argument). |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
214 |
// Note: this should not accidentally smash thread, because thread is always r15. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
215 |
assert(thread != c_rarg0, "smashed arg"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
216 |
if (c_rarg0 != pre_val) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
217 |
__ mov(c_rarg0, pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
218 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
219 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
220 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
221 |
if (expand_call) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
222 |
LP64_ONLY( assert(pre_val != c_rarg1, "smashed arg"); ) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
223 |
#ifdef _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
224 |
if (c_rarg1 != thread) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
225 |
__ mov(c_rarg1, thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
226 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
227 |
// Already moved pre_val into c_rarg0 above |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
228 |
#else |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
229 |
__ push(thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
230 |
__ push(pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
231 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
232 |
__ MacroAssembler::call_VM_leaf_base(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_field_pre_entry), 2); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
233 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
234 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_field_pre_entry), LP64_ONLY(c_rarg0) NOT_LP64(pre_val), thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
235 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
236 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
237 |
NOT_LP64( __ pop(thread); ) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
238 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
239 |
// save the live input values |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
240 |
if (pre_val != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
241 |
__ pop(pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
242 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
243 |
if (obj != noreg && obj != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
244 |
__ pop(obj); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
245 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
246 |
if(tosca_live) __ pop(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
247 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
248 |
__ bind(done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
249 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
250 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
251 |
void ShenandoahBarrierSetAssembler::load_reference_barrier_not_null(MacroAssembler* masm, Register dst, Address src) { |
54423 | 252 |
assert(ShenandoahLoadRefBarrier, "Should be enabled"); |
55146 | 253 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
254 |
Label done; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
255 |
|
55146 | 256 |
#ifdef _LP64 |
257 |
Register thread = r15_thread; |
|
258 |
#else |
|
259 |
Register thread = rcx; |
|
260 |
if (thread == dst) { |
|
261 |
thread = rbx; |
|
262 |
} |
|
263 |
__ push(thread); |
|
264 |
__ get_thread(thread); |
|
265 |
#endif |
|
266 |
||
267 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
268 |
__ testb(gc_state, ShenandoahHeap::HAS_FORWARDED); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
269 |
__ jccb(Assembler::zero, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
270 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
271 |
// Use rsi for src address |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
272 |
const Register src_addr = rsi; |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
273 |
// Setup address parameter first, if it does not clobber oop in dst |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
274 |
bool need_addr_setup = (src_addr != dst); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
275 |
|
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
276 |
if (need_addr_setup) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
277 |
__ push(src_addr); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
278 |
__ lea(src_addr, src); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
279 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
280 |
if (dst != rax) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
281 |
// Move obj into rax and save rax |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
282 |
__ push(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
283 |
__ movptr(rax, dst); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
284 |
} |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
285 |
} else { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
286 |
// dst == rsi |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
287 |
__ push(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
288 |
__ movptr(rax, dst); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
289 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
290 |
// we can clobber it, since it is outgoing register |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
291 |
__ lea(src_addr, src); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
292 |
} |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
293 |
|
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
294 |
__ call(RuntimeAddress(CAST_FROM_FN_PTR(address, ShenandoahBarrierSetAssembler::shenandoah_lrb()))); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
295 |
|
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
296 |
if (need_addr_setup) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
297 |
if (dst != rax) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
298 |
__ movptr(dst, rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
299 |
__ pop(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
300 |
} |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
301 |
__ pop(src_addr); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
302 |
} else { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
303 |
__ movptr(dst, rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
304 |
__ pop(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
305 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
306 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
307 |
__ bind(done); |
55146 | 308 |
|
309 |
#ifndef _LP64 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
310 |
__ pop(thread); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
311 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
312 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
313 |
|
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
314 |
void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler* masm, Register dst, Address src) { |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
315 |
if (!ShenandoahLoadRefBarrier) { |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
316 |
return; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
317 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
318 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
319 |
Label done; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
320 |
Label not_null; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
321 |
Label slow_path; |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
322 |
__ block_comment("load_reference_barrier_native { "); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
323 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
324 |
// null check |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
325 |
__ testptr(dst, dst); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
326 |
__ jcc(Assembler::notZero, not_null); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
327 |
__ jmp(done); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
328 |
__ bind(not_null); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
329 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
330 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
331 |
#ifdef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
332 |
Register thread = r15_thread; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
333 |
#else |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
334 |
Register thread = rcx; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
335 |
if (thread == dst) { |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
336 |
thread = rbx; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
337 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
338 |
__ push(thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
339 |
__ get_thread(thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
340 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
341 |
assert_different_registers(dst, thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
342 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
343 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
344 |
__ testb(gc_state, ShenandoahHeap::EVACUATION); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
345 |
#ifndef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
346 |
__ pop(thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
347 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
348 |
__ jccb(Assembler::notZero, slow_path); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
349 |
__ jmp(done); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
350 |
__ bind(slow_path); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
351 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
352 |
if (dst != rax) { |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
353 |
__ push(rax); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
354 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
355 |
__ push(rcx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
356 |
__ push(rdx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
357 |
__ push(rdi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
358 |
__ push(rsi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
359 |
#ifdef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
360 |
__ push(r8); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
361 |
__ push(r9); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
362 |
__ push(r10); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
363 |
__ push(r11); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
364 |
__ push(r12); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
365 |
__ push(r13); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
366 |
__ push(r14); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
367 |
__ push(r15); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
368 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
369 |
|
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
370 |
assert_different_registers(dst, rsi); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
371 |
__ lea(rsi, src); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
372 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native), dst, rsi); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
373 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
374 |
#ifdef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
375 |
__ pop(r15); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
376 |
__ pop(r14); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
377 |
__ pop(r13); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
378 |
__ pop(r12); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
379 |
__ pop(r11); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
380 |
__ pop(r10); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
381 |
__ pop(r9); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
382 |
__ pop(r8); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
383 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
384 |
__ pop(rsi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
385 |
__ pop(rdi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
386 |
__ pop(rdx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
387 |
__ pop(rcx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
388 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
389 |
if (dst != rax) { |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
390 |
__ movptr(dst, rax); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
391 |
__ pop(rax); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
392 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
393 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
394 |
__ bind(done); |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
395 |
__ block_comment("load_reference_barrier_native { "); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
396 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
397 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
398 |
void ShenandoahBarrierSetAssembler::storeval_barrier(MacroAssembler* masm, Register dst, Register tmp) { |
54423 | 399 |
if (ShenandoahStoreValEnqueueBarrier) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
400 |
storeval_barrier_impl(masm, dst, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
401 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
402 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
403 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
404 |
void ShenandoahBarrierSetAssembler::storeval_barrier_impl(MacroAssembler* masm, Register dst, Register tmp) { |
54423 | 405 |
assert(ShenandoahStoreValEnqueueBarrier, "should be enabled"); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
406 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
407 |
if (dst == noreg) return; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
408 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
409 |
if (ShenandoahStoreValEnqueueBarrier) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
410 |
// The set of registers to be saved+restored is the same as in the write-barrier above. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
411 |
// Those are the commonly used registers in the interpreter. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
412 |
__ pusha(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
413 |
// __ push_callee_saved_registers(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
414 |
__ subptr(rsp, 2 * Interpreter::stackElementSize); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
415 |
__ movdbl(Address(rsp, 0), xmm0); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
416 |
|
55146 | 417 |
#ifdef _LP64 |
418 |
Register thread = r15_thread; |
|
419 |
#else |
|
420 |
Register thread = rcx; |
|
421 |
if (thread == dst || thread == tmp) { |
|
422 |
thread = rdi; |
|
423 |
} |
|
424 |
if (thread == dst || thread == tmp) { |
|
425 |
thread = rbx; |
|
426 |
} |
|
427 |
__ get_thread(thread); |
|
428 |
#endif |
|
429 |
assert_different_registers(dst, tmp, thread); |
|
430 |
||
431 |
satb_write_barrier_pre(masm, noreg, dst, thread, tmp, true, false); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
432 |
__ movdbl(xmm0, Address(rsp, 0)); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
433 |
__ addptr(rsp, 2 * Interpreter::stackElementSize); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
434 |
//__ pop_callee_saved_registers(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
435 |
__ popa(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
436 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
437 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
438 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
439 |
void ShenandoahBarrierSetAssembler::load_reference_barrier(MacroAssembler* masm, Register dst, Address src) { |
54423 | 440 |
if (ShenandoahLoadRefBarrier) { |
441 |
Label done; |
|
442 |
__ testptr(dst, dst); |
|
443 |
__ jcc(Assembler::zero, done); |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
444 |
load_reference_barrier_not_null(masm, dst, src); |
54423 | 445 |
__ bind(done); |
446 |
} |
|
447 |
} |
|
448 |
||
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
449 |
// |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
450 |
// Arguments: |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
451 |
// |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
452 |
// Inputs: |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
453 |
// src: oop location, might be clobbered |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
454 |
// tmp1: scratch register, might not be valid. |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
455 |
// |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
456 |
// Output: |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
457 |
// dst: oop loaded from src location |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
458 |
// |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
459 |
// Kill: |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
460 |
// tmp1 (if it is valid) |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
461 |
// |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
462 |
void ShenandoahBarrierSetAssembler::load_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
463 |
Register dst, Address src, Register tmp1, Register tmp_thread) { |
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
464 |
// 1: non-reference load, no additional barrier is needed |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
465 |
if (!is_reference_type(type)) { |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
466 |
BarrierSetAssembler::load_at(masm, decorators, type, dst, src, tmp1, tmp_thread); |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
467 |
return; |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
468 |
} |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
469 |
|
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
470 |
// 2: load a reference from src location and apply LRB if ShenandoahLoadRefBarrier is set |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
471 |
if (ShenandoahLoadRefBarrier) { |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
472 |
Register result_dst = dst; |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
473 |
bool use_tmp1_for_dst = false; |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
474 |
|
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
475 |
// Preserve src location for LRB |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
476 |
if (dst == src.base() || dst == src.index()) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
477 |
// Use tmp1 for dst if possible, as it is not used in BarrierAssembler::load_at() |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
478 |
if (tmp1->is_valid() && tmp1 != src.base() && tmp1 != src.index()) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
479 |
dst = tmp1; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
480 |
use_tmp1_for_dst = true; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
481 |
} else { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
482 |
dst = rdi; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
483 |
__ push(dst); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
484 |
} |
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
485 |
assert_different_registers(dst, src.base(), src.index()); |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
486 |
} |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
487 |
|
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
488 |
BarrierSetAssembler::load_at(masm, decorators, type, dst, src, tmp1, tmp_thread); |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
489 |
|
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
490 |
// Native barrier is for concurrent root processing |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
491 |
bool in_native = (decorators & IN_NATIVE) != 0; |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
492 |
if (in_native && ShenandoahConcurrentRoots::can_do_concurrent_roots()) { |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
493 |
load_reference_barrier_native(masm, dst, src); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
494 |
} else { |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
495 |
load_reference_barrier(masm, dst, src); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
496 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
497 |
|
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
498 |
// Move loaded oop to final destination |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
499 |
if (dst != result_dst) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
500 |
__ movptr(result_dst, dst); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
501 |
|
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
502 |
if (!use_tmp1_for_dst) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
503 |
__ pop(dst); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
504 |
} |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
505 |
|
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
506 |
dst = result_dst; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
507 |
} |
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
508 |
} else { |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
509 |
BarrierSetAssembler::load_at(masm, decorators, type, dst, src, tmp1, tmp_thread); |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
510 |
} |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
511 |
|
58946
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
512 |
// 3: apply keep-alive barrier if ShenandoahKeepAliveBarrier is set |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
513 |
if (ShenandoahKeepAliveBarrier) { |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
514 |
bool on_weak = (decorators & ON_WEAK_OOP_REF) != 0; |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
515 |
bool on_phantom = (decorators & ON_PHANTOM_OOP_REF) != 0; |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
516 |
bool on_reference = on_weak || on_phantom; |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
517 |
bool is_traversal_mode = ShenandoahHeap::heap()->is_traversal_mode(); |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
518 |
bool keep_alive = ((decorators & AS_NO_KEEPALIVE) == 0) || is_traversal_mode; |
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
519 |
|
83810b7d12e7
8233401: Shenandoah: Refactor/cleanup Shenandoah load barrier code
zgu
parents:
58819
diff
changeset
|
520 |
if (on_reference && keep_alive) { |
54423 | 521 |
const Register thread = NOT_LP64(tmp_thread) LP64_ONLY(r15_thread); |
55146 | 522 |
assert_different_registers(dst, tmp1, tmp_thread); |
54423 | 523 |
NOT_LP64(__ get_thread(thread)); |
524 |
// Generate the SATB pre-barrier code to log the value of |
|
525 |
// the referent field in an SATB buffer. |
|
526 |
shenandoah_write_barrier_pre(masm /* masm */, |
|
527 |
noreg /* obj */, |
|
528 |
dst /* pre_val */, |
|
529 |
thread /* thread */, |
|
530 |
tmp1 /* tmp */, |
|
531 |
true /* tosca_live */, |
|
532 |
true /* expand_call */); |
|
533 |
} |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
534 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
535 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
536 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
537 |
void ShenandoahBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
538 |
Address dst, Register val, Register tmp1, Register tmp2) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
539 |
|
58273
08a5148e7c4e
8230505: Replace JVM type comparisons to T_OBJECT and T_ARRAY with call to is_reference_type
lfoltan
parents:
58272
diff
changeset
|
540 |
bool on_oop = is_reference_type(type); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
541 |
bool in_heap = (decorators & IN_HEAP) != 0; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
542 |
bool as_normal = (decorators & AS_NORMAL) != 0; |
54423 | 543 |
if (on_oop && in_heap) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
544 |
bool needs_pre_barrier = as_normal; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
545 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
546 |
Register tmp3 = LP64_ONLY(r8) NOT_LP64(rsi); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
547 |
Register rthread = LP64_ONLY(r15_thread) NOT_LP64(rcx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
548 |
// flatten object address if needed |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
549 |
// We do it regardless of precise because we need the registers |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
550 |
if (dst.index() == noreg && dst.disp() == 0) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
551 |
if (dst.base() != tmp1) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
552 |
__ movptr(tmp1, dst.base()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
553 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
554 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
555 |
__ lea(tmp1, dst); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
556 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
557 |
|
55146 | 558 |
assert_different_registers(val, tmp1, tmp2, tmp3, rthread); |
559 |
||
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
560 |
#ifndef _LP64 |
55146 | 561 |
__ get_thread(rthread); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
562 |
InterpreterMacroAssembler *imasm = static_cast<InterpreterMacroAssembler*>(masm); |
55146 | 563 |
imasm->save_bcp(); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
564 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
565 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
566 |
if (needs_pre_barrier) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
567 |
shenandoah_write_barrier_pre(masm /*masm*/, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
568 |
tmp1 /* obj */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
569 |
tmp2 /* pre_val */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
570 |
rthread /* thread */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
571 |
tmp3 /* tmp */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
572 |
val != noreg /* tosca_live */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
573 |
false /* expand_call */); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
574 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
575 |
if (val == noreg) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
576 |
BarrierSetAssembler::store_at(masm, decorators, type, Address(tmp1, 0), val, noreg, noreg); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
577 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
578 |
storeval_barrier(masm, val, tmp3); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
579 |
BarrierSetAssembler::store_at(masm, decorators, type, Address(tmp1, 0), val, noreg, noreg); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
580 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
581 |
NOT_LP64(imasm->restore_bcp()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
582 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
583 |
BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
584 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
585 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
586 |
|
57542
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
587 |
void ShenandoahBarrierSetAssembler::try_resolve_jobject_in_native(MacroAssembler* masm, Register jni_env, |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
588 |
Register obj, Register tmp, Label& slowpath) { |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
589 |
Label done; |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
590 |
// Resolve jobject |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
591 |
BarrierSetAssembler::try_resolve_jobject_in_native(masm, jni_env, obj, tmp, slowpath); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
592 |
|
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
593 |
// Check for null. |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
594 |
__ testptr(obj, obj); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
595 |
__ jcc(Assembler::zero, done); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
596 |
|
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
597 |
Address gc_state(jni_env, ShenandoahThreadLocalData::gc_state_offset() - JavaThread::jni_environment_offset()); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
598 |
__ testb(gc_state, ShenandoahHeap::EVACUATION); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
599 |
__ jccb(Assembler::notZero, slowpath); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
600 |
__ bind(done); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
601 |
} |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
602 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
603 |
// Special Shenandoah CAS implementation that handles false negatives |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
604 |
// due to concurrent evacuation. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
605 |
void ShenandoahBarrierSetAssembler::cmpxchg_oop(MacroAssembler* masm, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
606 |
Register res, Address addr, Register oldval, Register newval, |
53519
74a5ef4c81cc
8217016: Shenandoah: Streamline generation of CAS barriers
rkennke
parents:
52925
diff
changeset
|
607 |
bool exchange, Register tmp1, Register tmp2) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
608 |
assert(ShenandoahCASBarrier, "Should only be used when CAS barrier is enabled"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
609 |
assert(oldval == rax, "must be in rax for implicit use in cmpxchg"); |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
610 |
assert_different_registers(oldval, newval, tmp1, tmp2); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
611 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
612 |
Label L_success, L_failure; |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
613 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
614 |
// Remember oldval for retry logic below |
55146 | 615 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
616 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
617 |
__ movl(tmp1, oldval); |
55146 | 618 |
} else |
619 |
#endif |
|
620 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
621 |
__ movptr(tmp1, oldval); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
622 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
623 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
624 |
// Step 1. Fast-path. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
625 |
// |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
626 |
// Try to CAS with given arguments. If successful, then we are done. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
627 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
628 |
if (os::is_MP()) __ lock(); |
55146 | 629 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
630 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
631 |
__ cmpxchgl(newval, addr); |
55146 | 632 |
} else |
633 |
#endif |
|
634 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
635 |
__ cmpxchgptr(newval, addr); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
636 |
} |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
637 |
__ jcc(Assembler::equal, L_success); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
638 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
639 |
// Step 2. CAS had failed. This may be a false negative. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
640 |
// |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
641 |
// The trouble comes when we compare the to-space pointer with the from-space |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
642 |
// pointer to the same object. To resolve this, it will suffice to resolve |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
643 |
// the value from memory -- this will give both to-space pointers. |
54423 | 644 |
// If they mismatch, then it was a legitimate failure. |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
645 |
// |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
646 |
// Before reaching to resolve sequence, see if we can avoid the whole shebang |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
647 |
// with filters. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
648 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
649 |
// Filter: when offending in-memory value is NULL, the failure is definitely legitimate |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
650 |
__ testptr(oldval, oldval); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
651 |
__ jcc(Assembler::zero, L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
652 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
653 |
// Filter: when heap is stable, the failure is definitely legitimate |
55146 | 654 |
#ifdef _LP64 |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
655 |
const Register thread = r15_thread; |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
656 |
#else |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
657 |
const Register thread = tmp2; |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
658 |
__ get_thread(thread); |
55146 | 659 |
#endif |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
660 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
661 |
__ testb(gc_state, ShenandoahHeap::HAS_FORWARDED); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
662 |
__ jcc(Assembler::zero, L_failure); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
663 |
|
55146 | 664 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
665 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
666 |
__ movl(tmp2, oldval); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
667 |
__ decode_heap_oop(tmp2); |
55146 | 668 |
} else |
669 |
#endif |
|
670 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
671 |
__ movptr(tmp2, oldval); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
672 |
} |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
673 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
674 |
// Decode offending in-memory value. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
675 |
// Test if-forwarded |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
676 |
__ testb(Address(tmp2, oopDesc::mark_offset_in_bytes()), markWord::marked_value); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
677 |
__ jcc(Assembler::noParity, L_failure); // When odd number of bits, then not forwarded |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
678 |
__ jcc(Assembler::zero, L_failure); // When it is 00, then also not forwarded |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
679 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
680 |
// Load and mask forwarding pointer |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
681 |
__ movptr(tmp2, Address(tmp2, oopDesc::mark_offset_in_bytes())); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
682 |
__ shrptr(tmp2, 2); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
683 |
__ shlptr(tmp2, 2); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
684 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
685 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
686 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
687 |
__ decode_heap_oop(tmp1); // decode for comparison |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
688 |
} |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
689 |
#endif |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
690 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
691 |
// Now we have the forwarded offender in tmp2. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
692 |
// Compare and if they don't match, we have legitimate failure |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
693 |
__ cmpptr(tmp1, tmp2); |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
694 |
__ jcc(Assembler::notEqual, L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
695 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
696 |
// Step 3. Need to fix the memory ptr before continuing. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
697 |
// |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
698 |
// At this point, we have from-space oldval in the register, and its to-space |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
699 |
// address is in tmp2. Let's try to update it into memory. We don't care if it |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
700 |
// succeeds or not. If it does, then the retrying CAS would see it and succeed. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
701 |
// If this fixup fails, this means somebody else beat us to it, and necessarily |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
702 |
// with to-space ptr store. We still have to do the retry, because the GC might |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
703 |
// have updated the reference for us. |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
704 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
705 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
706 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
707 |
__ encode_heap_oop(tmp2); // previously decoded at step 2. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
708 |
} |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
709 |
#endif |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
710 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
711 |
if (os::is_MP()) __ lock(); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
712 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
713 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
714 |
__ cmpxchgl(tmp2, addr); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
715 |
} else |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
716 |
#endif |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
717 |
{ |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
718 |
__ cmpxchgptr(tmp2, addr); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
719 |
} |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
720 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
721 |
// Step 4. Try to CAS again. |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
722 |
// |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
723 |
// This is guaranteed not to have false negatives, because oldval is definitely |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
724 |
// to-space, and memory pointer is to-space as well. Nothing is able to store |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
725 |
// from-space ptr into memory anymore. Make sure oldval is restored, after being |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
726 |
// garbled during retries. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
727 |
// |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
728 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
729 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
730 |
__ movl(oldval, tmp2); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
731 |
} else |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
732 |
#endif |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
733 |
{ |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
734 |
__ movptr(oldval, tmp2); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
735 |
} |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
736 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
737 |
if (os::is_MP()) __ lock(); |
55146 | 738 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
739 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
740 |
__ cmpxchgl(newval, addr); |
55146 | 741 |
} else |
742 |
#endif |
|
743 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
744 |
__ cmpxchgptr(newval, addr); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
745 |
} |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
746 |
if (!exchange) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
747 |
__ jccb(Assembler::equal, L_success); // fastpath, peeking into Step 5, no need to jump |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
748 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
749 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
750 |
// Step 5. If we need a boolean result out of CAS, set the flag appropriately. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
751 |
// and promote the result. Note that we handle the flag from both the 1st and 2nd CAS. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
752 |
// Otherwise, failure witness for CAE is in oldval on all paths, and we can return. |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
753 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
754 |
if (exchange) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
755 |
__ bind(L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
756 |
__ bind(L_success); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
757 |
} else { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
758 |
assert(res != NULL, "need result register"); |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
759 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
760 |
Label exit; |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
761 |
__ bind(L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
762 |
__ xorptr(res, res); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
763 |
__ jmpb(exit); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
764 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
765 |
__ bind(L_success); |
55146 | 766 |
__ movptr(res, 1); |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
767 |
__ bind(exit); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
768 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
769 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
770 |
|
54763
2584e5772546
8222926: Shenandoah build fails with --with-jvm-features=-compiler1
aoqi
parents:
54755
diff
changeset
|
771 |
#undef __ |
2584e5772546
8222926: Shenandoah build fails with --with-jvm-features=-compiler1
aoqi
parents:
54755
diff
changeset
|
772 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
773 |
#ifdef COMPILER1 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
774 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
775 |
#define __ ce->masm()-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
776 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
777 |
void ShenandoahBarrierSetAssembler::gen_pre_barrier_stub(LIR_Assembler* ce, ShenandoahPreBarrierStub* stub) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
778 |
ShenandoahBarrierSetC1* bs = (ShenandoahBarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
779 |
// At this point we know that marking is in progress. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
780 |
// If do_load() is true then we have to emit the |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
781 |
// load of the previous value; otherwise it has already |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
782 |
// been loaded into _pre_val. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
783 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
784 |
__ bind(*stub->entry()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
785 |
assert(stub->pre_val()->is_register(), "Precondition."); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
786 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
787 |
Register pre_val_reg = stub->pre_val()->as_register(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
788 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
789 |
if (stub->do_load()) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
790 |
ce->mem2reg(stub->addr(), stub->pre_val(), T_OBJECT, stub->patch_code(), stub->info(), false /*wide*/, false /*unaligned*/); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
791 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
792 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
793 |
__ cmpptr(pre_val_reg, (int32_t)NULL_WORD); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
794 |
__ jcc(Assembler::equal, *stub->continuation()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
795 |
ce->store_parameter(stub->pre_val()->as_register(), 0); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
796 |
__ call(RuntimeAddress(bs->pre_barrier_c1_runtime_code_blob()->code_begin())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
797 |
__ jmp(*stub->continuation()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
798 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
799 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
800 |
|
54423 | 801 |
void ShenandoahBarrierSetAssembler::gen_load_reference_barrier_stub(LIR_Assembler* ce, ShenandoahLoadReferenceBarrierStub* stub) { |
57716 | 802 |
ShenandoahBarrierSetC1* bs = (ShenandoahBarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1(); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
803 |
__ bind(*stub->entry()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
804 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
805 |
Register obj = stub->obj()->as_register(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
806 |
Register res = stub->result()->as_register(); |
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
807 |
Register addr = stub->addr()->as_register(); |
57716 | 808 |
Register tmp1 = stub->tmp1()->as_register(); |
809 |
Register tmp2 = stub->tmp2()->as_register(); |
|
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
810 |
assert_different_registers(obj, res, addr, tmp1, tmp2); |
57716 | 811 |
|
812 |
Label slow_path; |
|
813 |
||
814 |
assert(res == rax, "result must arrive in rax"); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
815 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
816 |
if (res != obj) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
817 |
__ mov(res, obj); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
818 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
819 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
820 |
// Check for null. |
55735
08893cf52ee9
8228364: Shenandoah: Remove unused code from ShenandoahBarrierSetC1
rkennke
parents:
55718
diff
changeset
|
821 |
__ testptr(res, res); |
57716 | 822 |
__ jcc(Assembler::zero, *stub->continuation()); |
823 |
||
824 |
// Check for object being in the collection set. |
|
825 |
__ mov(tmp1, res); |
|
826 |
__ shrptr(tmp1, ShenandoahHeapRegion::region_size_bytes_shift_jint()); |
|
827 |
__ movptr(tmp2, (intptr_t) ShenandoahHeap::in_cset_fast_test_addr()); |
|
57748
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
828 |
#ifdef _LP64 |
57716 | 829 |
__ movbool(tmp2, Address(tmp2, tmp1, Address::times_1)); |
830 |
__ testbool(tmp2); |
|
57748
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
831 |
#else |
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
832 |
// On x86_32, C1 register allocator can give us the register without 8-bit support. |
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
833 |
// Do the full-register access and test to avoid compilation failures. |
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
834 |
__ movptr(tmp2, Address(tmp2, tmp1, Address::times_1)); |
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
835 |
__ testptr(tmp2, 0xFF); |
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
836 |
#endif |
57716 | 837 |
__ jcc(Assembler::zero, *stub->continuation()); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
838 |
|
57716 | 839 |
__ bind(slow_path); |
840 |
ce->store_parameter(res, 0); |
|
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
841 |
ce->store_parameter(addr, 1); |
57716 | 842 |
__ call(RuntimeAddress(bs->load_reference_barrier_rt_code_blob()->code_begin())); |
843 |
||
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
844 |
__ jmp(*stub->continuation()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
845 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
846 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
847 |
#undef __ |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
848 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
849 |
#define __ sasm-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
850 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
851 |
void ShenandoahBarrierSetAssembler::generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
852 |
__ prologue("shenandoah_pre_barrier", false); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
853 |
// arg0 : previous value of memory |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
854 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
855 |
__ push(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
856 |
__ push(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
857 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
858 |
const Register pre_val = rax; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
859 |
const Register thread = NOT_LP64(rax) LP64_ONLY(r15_thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
860 |
const Register tmp = rdx; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
861 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
862 |
NOT_LP64(__ get_thread(thread);) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
863 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
864 |
Address queue_index(thread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_index_offset())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
865 |
Address buffer(thread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_buffer_offset())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
866 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
867 |
Label done; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
868 |
Label runtime; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
869 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
870 |
// Is SATB still active? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
871 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
872 |
__ testb(gc_state, ShenandoahHeap::MARKING | ShenandoahHeap::TRAVERSAL); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
873 |
__ jcc(Assembler::zero, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
874 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
875 |
// Can we store original value in the thread's buffer? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
876 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
877 |
__ movptr(tmp, queue_index); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
878 |
__ testptr(tmp, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
879 |
__ jcc(Assembler::zero, runtime); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
880 |
__ subptr(tmp, wordSize); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
881 |
__ movptr(queue_index, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
882 |
__ addptr(tmp, buffer); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
883 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
884 |
// prev_val (rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
885 |
__ load_parameter(0, pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
886 |
__ movptr(Address(tmp, 0), pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
887 |
__ jmp(done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
888 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
889 |
__ bind(runtime); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
890 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
891 |
__ save_live_registers_no_oop_map(true); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
892 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
893 |
// load the pre-value |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
894 |
__ load_parameter(0, rcx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
895 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_field_pre_entry), rcx, thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
896 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
897 |
__ restore_live_registers(true); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
898 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
899 |
__ bind(done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
900 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
901 |
__ pop(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
902 |
__ pop(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
903 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
904 |
__ epilogue(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
905 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
906 |
|
57716 | 907 |
void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm) { |
908 |
__ prologue("shenandoah_load_reference_barrier", false); |
|
909 |
// arg0 : object to be resolved |
|
910 |
||
911 |
__ save_live_registers_no_oop_map(true); |
|
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
912 |
|
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
913 |
#ifdef _LP64 |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
914 |
__ load_parameter(0, c_rarg0); |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
915 |
__ load_parameter(1, c_rarg1); |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
916 |
if (UseCompressedOops) { |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
917 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow), c_rarg0, c_rarg1); |
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
918 |
} else { |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
919 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), c_rarg0, c_rarg1); |
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
920 |
} |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
921 |
#else |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
922 |
__ load_parameter(0, rax); |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
923 |
__ load_parameter(1, rbx); |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
924 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), rax, rbx); |
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
925 |
#endif |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
926 |
|
57716 | 927 |
__ restore_live_registers_except_rax(true); |
928 |
||
929 |
__ epilogue(); |
|
930 |
} |
|
931 |
||
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
932 |
#undef __ |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
933 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
934 |
#endif // COMPILER1 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
935 |
|
54423 | 936 |
address ShenandoahBarrierSetAssembler::shenandoah_lrb() { |
937 |
assert(_shenandoah_lrb != NULL, "need load reference barrier stub"); |
|
938 |
return _shenandoah_lrb; |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
939 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
940 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
941 |
#define __ cgen->assembler()-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
942 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
943 |
/* |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
944 |
* Incoming parameters: |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
945 |
* rax: oop |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
946 |
* rsi: load address |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
947 |
*/ |
54423 | 948 |
address ShenandoahBarrierSetAssembler::generate_shenandoah_lrb(StubCodeGenerator* cgen) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
949 |
__ align(CodeEntryAlignment); |
54423 | 950 |
StubCodeMark mark(cgen, "StubRoutines", "shenandoah_lrb"); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
951 |
address start = __ pc(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
952 |
|
57824
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
953 |
Label resolve_oop, slow_path; |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
954 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
955 |
// We use RDI, which also serves as argument register for slow call. |
57716 | 956 |
// RAX always holds the src object ptr, except after the slow call, |
957 |
// then it holds the result. R8/RBX is used as temporary register. |
|
55146 | 958 |
|
959 |
Register tmp1 = rdi; |
|
960 |
Register tmp2 = LP64_ONLY(r8) NOT_LP64(rbx); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
961 |
|
55146 | 962 |
__ push(tmp1); |
963 |
__ push(tmp2); |
|
964 |
||
965 |
// Check for object being in the collection set. |
|
966 |
__ mov(tmp1, rax); |
|
967 |
__ shrptr(tmp1, ShenandoahHeapRegion::region_size_bytes_shift_jint()); |
|
968 |
__ movptr(tmp2, (intptr_t) ShenandoahHeap::in_cset_fast_test_addr()); |
|
969 |
__ movbool(tmp2, Address(tmp2, tmp1, Address::times_1)); |
|
970 |
__ testbool(tmp2); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
971 |
__ jccb(Assembler::notZero, resolve_oop); |
55146 | 972 |
__ pop(tmp2); |
973 |
__ pop(tmp1); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
974 |
__ ret(0); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
975 |
|
57716 | 976 |
// Test if object is already resolved. |
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
977 |
__ bind(resolve_oop); |
55146 | 978 |
__ movptr(tmp2, Address(rax, oopDesc::mark_offset_in_bytes())); |
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
979 |
// Test if both lowest bits are set. We trick it by negating the bits |
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
980 |
// then test for both bits clear. |
55146 | 981 |
__ notptr(tmp2); |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
57748
diff
changeset
|
982 |
__ testb(tmp2, markWord::marked_value); |
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
983 |
__ jccb(Assembler::notZero, slow_path); |
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
984 |
// Clear both lower bits. It's still inverted, so set them, and then invert back. |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
57748
diff
changeset
|
985 |
__ orptr(tmp2, markWord::marked_value); |
55146 | 986 |
__ notptr(tmp2); |
987 |
// At this point, tmp2 contains the decoded forwarding pointer. |
|
988 |
__ mov(rax, tmp2); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
989 |
|
55146 | 990 |
__ pop(tmp2); |
991 |
__ pop(tmp1); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
992 |
__ ret(0); |
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
993 |
|
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
994 |
__ bind(slow_path); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
995 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
996 |
__ push(rcx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
997 |
__ push(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
998 |
__ push(rdi); |
55146 | 999 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1000 |
__ push(r8); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1001 |
__ push(r9); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1002 |
__ push(r10); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1003 |
__ push(r11); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1004 |
__ push(r12); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1005 |
__ push(r13); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1006 |
__ push(r14); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1007 |
__ push(r15); |
55146 | 1008 |
#endif |
57824
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
1009 |
__ push(rbp); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
1010 |
__ movptr(rbp, rsp); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
1011 |
__ andptr(rsp, -StackAlignmentInBytes); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
1012 |
__ push_FPU_state(); |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
1013 |
if (UseCompressedOops) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
1014 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow), rax, rsi); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
1015 |
} else { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
1016 |
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), rax, rsi); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
1017 |
} |
57824
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
1018 |
__ pop_FPU_state(); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
1019 |
__ movptr(rsp, rbp); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
1020 |
__ pop(rbp); |
55146 | 1021 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1022 |
__ pop(r15); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1023 |
__ pop(r14); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1024 |
__ pop(r13); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1025 |
__ pop(r12); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1026 |
__ pop(r11); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1027 |
__ pop(r10); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1028 |
__ pop(r9); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1029 |
__ pop(r8); |
55146 | 1030 |
#endif |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1031 |
__ pop(rdi); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1032 |
__ pop(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1033 |
__ pop(rcx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1034 |
|
55146 | 1035 |
__ pop(tmp2); |
1036 |
__ pop(tmp1); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1037 |
__ ret(0); |
55146 | 1038 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1039 |
return start; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1040 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1041 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1042 |
#undef __ |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1043 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1044 |
void ShenandoahBarrierSetAssembler::barrier_stubs_init() { |
54423 | 1045 |
if (ShenandoahLoadRefBarrier) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1046 |
int stub_code_size = 4096; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1047 |
ResourceMark rm; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1048 |
BufferBlob* bb = BufferBlob::create("shenandoah_barrier_stubs", stub_code_size); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1049 |
CodeBuffer buf(bb); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1050 |
StubCodeGenerator cgen(&buf); |
54423 | 1051 |
_shenandoah_lrb = generate_shenandoah_lrb(&cgen); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1052 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1053 |
} |