author | zgu |
Mon, 28 Oct 2019 11:33:28 -0400 | |
changeset 58819 | ef8be51fff48 |
parent 58788 | 6a147ac7a68f |
child 58946 | 83810b7d12e7 |
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" |
54766
1321f8cf9de5
8223567: Rename ShenandoahBrooksPointer to ShenandoahForwarding
rkennke
parents:
54763
diff
changeset
|
26 |
#include "gc/shenandoah/shenandoahForwarding.hpp" |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
27 |
#include "gc/shenandoah/shenandoahHeap.inline.hpp" |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
28 |
#include "gc/shenandoah/shenandoahHeapRegion.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
29 |
#include "gc/shenandoah/shenandoahHeuristics.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
30 |
#include "gc/shenandoah/shenandoahRuntime.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
31 |
#include "gc/shenandoah/shenandoahThreadLocalData.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
32 |
#include "interpreter/interpreter.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
33 |
#include "interpreter/interp_masm.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
34 |
#include "runtime/sharedRuntime.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
35 |
#include "runtime/thread.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
36 |
#include "utilities/macros.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
37 |
#ifdef COMPILER1 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
38 |
#include "c1/c1_LIRAssembler.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
39 |
#include "c1/c1_MacroAssembler.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
40 |
#include "gc/shenandoah/c1/shenandoahBarrierSetC1.hpp" |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
41 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
42 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
43 |
#define __ masm-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
44 |
|
54423 | 45 |
address ShenandoahBarrierSetAssembler::_shenandoah_lrb = NULL; |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
46 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
47 |
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
|
48 |
Register src, Register dst, Register count) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
49 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
50 |
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
|
51 |
|
58273
08a5148e7c4e
8230505: Replace JVM type comparisons to T_OBJECT and T_ARRAY with call to is_reference_type
lfoltan
parents:
58272
diff
changeset
|
52 |
if (is_reference_type(type)) { |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
53 |
|
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
54 |
if ((ShenandoahSATBBarrier && !dest_uninitialized) || ShenandoahLoadRefBarrier) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
55 |
#ifdef _LP64 |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
56 |
Register thread = r15_thread; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
57 |
#else |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
58 |
Register thread = rax; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
59 |
if (thread == src || thread == dst || thread == count) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
60 |
thread = rbx; |
54755
de34f4b370b0
8223244: Fix usage of ARRAYCOPY_DISJOINT decorator
rkennke
parents:
54425
diff
changeset
|
61 |
} |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
62 |
if (thread == src || thread == dst || thread == count) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
63 |
thread = rcx; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
64 |
} |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
65 |
if (thread == src || thread == dst || thread == count) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
66 |
thread = rdx; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
67 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
68 |
__ push(thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
69 |
__ get_thread(thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
70 |
#endif |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
71 |
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
|
72 |
|
54383 | 73 |
Label done; |
74 |
// Short-circuit if count == 0. |
|
75 |
__ testptr(count, count); |
|
76 |
__ jcc(Assembler::zero, done); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
77 |
|
54383 | 78 |
// Avoid runtime call when not marking. |
79 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
|
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
80 |
int flags = ShenandoahHeap::HAS_FORWARDED; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
81 |
if (!dest_uninitialized) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
82 |
flags |= ShenandoahHeap::MARKING; |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
83 |
} |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
84 |
__ testb(gc_state, flags); |
54383 | 85 |
__ jcc(Assembler::zero, done); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
86 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
87 |
__ pusha(); // push registers |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
88 |
#ifdef _LP64 |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
89 |
assert(src == rdi, "expected"); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
90 |
assert(dst == rsi, "expected"); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
91 |
assert(count == rdx, "expected"); |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
92 |
if (UseCompressedOops) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
93 |
if (dest_uninitialized) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
94 |
__ 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
|
95 |
} else { |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
96 |
__ 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
|
97 |
} |
58218
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
98 |
} else |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
99 |
#endif |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
100 |
{ |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
101 |
if (dest_uninitialized) { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
102 |
__ 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
|
103 |
} else { |
0d7877278adf
8231086: Shenandoah: Stronger invariant for object-arraycopy
rkennke
parents:
57824
diff
changeset
|
104 |
__ 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
|
105 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
106 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
107 |
__ popa(); |
54383 | 108 |
__ bind(done); |
109 |
NOT_LP64(__ pop(thread);) |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
110 |
} |
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 |
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
|
116 |
Register obj, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
117 |
Register pre_val, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
118 |
Register thread, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
119 |
Register tmp, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
120 |
bool tosca_live, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
121 |
bool expand_call) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
122 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
123 |
if (ShenandoahSATBBarrier) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
124 |
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
|
125 |
} |
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 |
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
|
129 |
Register obj, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
130 |
Register pre_val, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
131 |
Register thread, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
132 |
Register tmp, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
133 |
bool tosca_live, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
134 |
bool expand_call) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
135 |
// 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
|
136 |
// directly to skip generating the check by |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
137 |
// 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
|
138 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
139 |
#ifdef _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
140 |
assert(thread == r15_thread, "must be"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
141 |
#endif // _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
142 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
143 |
Label done; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
144 |
Label runtime; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
145 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
146 |
assert(pre_val != noreg, "check this code"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
147 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
148 |
if (obj != noreg) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
149 |
assert_different_registers(obj, pre_val, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
150 |
assert(pre_val != rax, "check this code"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
151 |
} |
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 |
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
|
154 |
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
|
155 |
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
|
156 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
157 |
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
|
158 |
__ testb(gc_state, ShenandoahHeap::MARKING | ShenandoahHeap::TRAVERSAL); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
159 |
__ jcc(Assembler::zero, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
160 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
161 |
// 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
|
162 |
if (obj != noreg) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
163 |
__ 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
|
164 |
} |
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 |
// Is the previous value null? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
167 |
__ cmpptr(pre_val, (int32_t) NULL_WORD); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
168 |
__ jcc(Assembler::equal, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
169 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
170 |
// 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
|
171 |
// Is index == 0? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
172 |
// (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
|
173 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
174 |
__ movptr(tmp, index); // tmp := *index_adr |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
175 |
__ cmpptr(tmp, 0); // tmp == 0? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
176 |
__ 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
|
177 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
178 |
__ subptr(tmp, wordSize); // tmp := tmp - wordSize |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
179 |
__ movptr(index, tmp); // *index_adr := tmp |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
180 |
__ addptr(tmp, buffer); // tmp := tmp + *buffer_adr |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
181 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
182 |
// Record the previous value |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
183 |
__ movptr(Address(tmp, 0), pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
184 |
__ jmp(done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
185 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
186 |
__ bind(runtime); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
187 |
// save the live input values |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
188 |
if(tosca_live) __ push(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
189 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
190 |
if (obj != noreg && obj != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
191 |
__ push(obj); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
192 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
193 |
if (pre_val != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
194 |
__ push(pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
195 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
196 |
// 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
|
197 |
// 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
|
198 |
// 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
|
199 |
// |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
200 |
// 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
|
201 |
// 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
|
202 |
// 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
|
203 |
// |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
204 |
// 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
|
205 |
// 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
|
206 |
// expand_call should be passed true. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
207 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
208 |
NOT_LP64( __ push(thread); ) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
209 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
210 |
#ifdef _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
211 |
// 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
|
212 |
// 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
|
213 |
// 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
|
214 |
assert(thread != c_rarg0, "smashed arg"); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
215 |
if (c_rarg0 != pre_val) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
216 |
__ mov(c_rarg0, pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
217 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
218 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
219 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
220 |
if (expand_call) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
221 |
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
|
222 |
#ifdef _LP64 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
223 |
if (c_rarg1 != thread) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
224 |
__ mov(c_rarg1, thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
225 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
226 |
// 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
|
227 |
#else |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
228 |
__ push(thread); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
229 |
__ push(pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
230 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
231 |
__ 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
|
232 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
233 |
__ 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
|
234 |
} |
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 |
NOT_LP64( __ pop(thread); ) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
237 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
238 |
// save the live input values |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
239 |
if (pre_val != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
240 |
__ pop(pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
241 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
242 |
if (obj != noreg && obj != rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
243 |
__ pop(obj); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
244 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
245 |
if(tosca_live) __ pop(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
246 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
247 |
__ bind(done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
248 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
249 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
250 |
void ShenandoahBarrierSetAssembler::load_reference_barrier_not_null(MacroAssembler* masm, Register dst, Address src) { |
54423 | 251 |
assert(ShenandoahLoadRefBarrier, "Should be enabled"); |
55146 | 252 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
253 |
Label done; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
254 |
|
55146 | 255 |
#ifdef _LP64 |
256 |
Register thread = r15_thread; |
|
257 |
#else |
|
258 |
Register thread = rcx; |
|
259 |
if (thread == dst) { |
|
260 |
thread = rbx; |
|
261 |
} |
|
262 |
__ push(thread); |
|
263 |
__ get_thread(thread); |
|
264 |
#endif |
|
265 |
||
266 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
267 |
__ testb(gc_state, ShenandoahHeap::HAS_FORWARDED); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
268 |
__ jccb(Assembler::zero, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
269 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
270 |
// Use rsi for src address |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
271 |
const Register src_addr = rsi; |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
272 |
// 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
|
273 |
bool need_addr_setup = (src_addr != dst); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
274 |
|
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
275 |
if (need_addr_setup) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
276 |
__ push(src_addr); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
277 |
__ lea(src_addr, src); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
278 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
279 |
if (dst != rax) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
280 |
// Move obj into rax and save rax |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
281 |
__ push(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
282 |
__ movptr(rax, dst); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
283 |
} |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
284 |
} else { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
285 |
// dst == rsi |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
286 |
__ push(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
287 |
__ movptr(rax, dst); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
288 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
289 |
// we can clobber it, since it is outgoing register |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
290 |
__ lea(src_addr, src); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
291 |
} |
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 |
__ call(RuntimeAddress(CAST_FROM_FN_PTR(address, ShenandoahBarrierSetAssembler::shenandoah_lrb()))); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
294 |
|
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
295 |
if (need_addr_setup) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
296 |
if (dst != rax) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
297 |
__ movptr(dst, rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
298 |
__ pop(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
299 |
} |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
300 |
__ pop(src_addr); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
301 |
} else { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
302 |
__ movptr(dst, rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
303 |
__ pop(rax); |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
304 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
305 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
306 |
__ bind(done); |
55146 | 307 |
|
308 |
#ifndef _LP64 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
309 |
__ pop(thread); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
310 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
311 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
312 |
|
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
313 |
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
|
314 |
if (!ShenandoahLoadRefBarrier) { |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
315 |
return; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
316 |
} |
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 |
Label done; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
319 |
Label not_null; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
320 |
Label slow_path; |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
321 |
__ block_comment("load_reference_barrier_native { "); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
322 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
323 |
// null check |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
324 |
__ testptr(dst, dst); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
325 |
__ jcc(Assembler::notZero, not_null); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
326 |
__ jmp(done); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
327 |
__ bind(not_null); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
328 |
|
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 |
#ifdef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
331 |
Register thread = r15_thread; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
332 |
#else |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
333 |
Register thread = rcx; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
334 |
if (thread == dst) { |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
335 |
thread = rbx; |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
336 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
337 |
__ push(thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
338 |
__ get_thread(thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
339 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
340 |
assert_different_registers(dst, thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
341 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
342 |
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
|
343 |
__ testb(gc_state, ShenandoahHeap::EVACUATION); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
344 |
#ifndef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
345 |
__ pop(thread); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
346 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
347 |
__ jccb(Assembler::notZero, slow_path); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
348 |
__ jmp(done); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
349 |
__ bind(slow_path); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
350 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
351 |
if (dst != rax) { |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
352 |
__ push(rax); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
353 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
354 |
__ push(rcx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
355 |
__ push(rdx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
356 |
__ push(rdi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
357 |
__ push(rsi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
358 |
#ifdef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
359 |
__ push(r8); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
360 |
__ push(r9); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
361 |
__ push(r10); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
362 |
__ push(r11); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
363 |
__ push(r12); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
364 |
__ push(r13); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
365 |
__ push(r14); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
366 |
__ push(r15); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
367 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
368 |
|
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
369 |
assert_different_registers(dst, rsi); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
370 |
__ lea(rsi, src); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
371 |
__ 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
|
372 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
373 |
#ifdef _LP64 |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
374 |
__ pop(r15); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
375 |
__ pop(r14); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
376 |
__ pop(r13); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
377 |
__ pop(r12); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
378 |
__ pop(r11); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
379 |
__ pop(r10); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
380 |
__ pop(r9); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
381 |
__ pop(r8); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
382 |
#endif |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
383 |
__ pop(rsi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
384 |
__ pop(rdi); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
385 |
__ pop(rdx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
386 |
__ pop(rcx); |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
387 |
|
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
388 |
if (dst != rax) { |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
389 |
__ movptr(dst, rax); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
390 |
__ pop(rax); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
391 |
} |
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 |
__ bind(done); |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
394 |
__ block_comment("load_reference_barrier_native { "); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
395 |
} |
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
396 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
397 |
void ShenandoahBarrierSetAssembler::storeval_barrier(MacroAssembler* masm, Register dst, Register tmp) { |
54423 | 398 |
if (ShenandoahStoreValEnqueueBarrier) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
399 |
storeval_barrier_impl(masm, dst, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
400 |
} |
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 |
void ShenandoahBarrierSetAssembler::storeval_barrier_impl(MacroAssembler* masm, Register dst, Register tmp) { |
54423 | 404 |
assert(ShenandoahStoreValEnqueueBarrier, "should be enabled"); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
405 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
406 |
if (dst == noreg) return; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
407 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
408 |
if (ShenandoahStoreValEnqueueBarrier) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
409 |
// 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
|
410 |
// 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
|
411 |
__ pusha(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
412 |
// __ push_callee_saved_registers(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
413 |
__ subptr(rsp, 2 * Interpreter::stackElementSize); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
414 |
__ movdbl(Address(rsp, 0), xmm0); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
415 |
|
55146 | 416 |
#ifdef _LP64 |
417 |
Register thread = r15_thread; |
|
418 |
#else |
|
419 |
Register thread = rcx; |
|
420 |
if (thread == dst || thread == tmp) { |
|
421 |
thread = rdi; |
|
422 |
} |
|
423 |
if (thread == dst || thread == tmp) { |
|
424 |
thread = rbx; |
|
425 |
} |
|
426 |
__ get_thread(thread); |
|
427 |
#endif |
|
428 |
assert_different_registers(dst, tmp, thread); |
|
429 |
||
430 |
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
|
431 |
__ movdbl(xmm0, Address(rsp, 0)); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
432 |
__ addptr(rsp, 2 * Interpreter::stackElementSize); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
433 |
//__ pop_callee_saved_registers(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
434 |
__ popa(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
435 |
} |
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 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
438 |
void ShenandoahBarrierSetAssembler::load_reference_barrier(MacroAssembler* masm, Register dst, Address src) { |
54423 | 439 |
if (ShenandoahLoadRefBarrier) { |
440 |
Label done; |
|
441 |
__ testptr(dst, dst); |
|
442 |
__ jcc(Assembler::zero, done); |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
443 |
load_reference_barrier_not_null(masm, dst, src); |
54423 | 444 |
__ bind(done); |
445 |
} |
|
446 |
} |
|
447 |
||
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
448 |
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
|
449 |
Register dst, Address src, Register tmp1, Register tmp_thread) { |
58273
08a5148e7c4e
8230505: Replace JVM type comparisons to T_OBJECT and T_ARRAY with call to is_reference_type
lfoltan
parents:
58272
diff
changeset
|
450 |
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
|
451 |
bool on_weak = (decorators & ON_WEAK_OOP_REF) != 0; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
452 |
bool on_phantom = (decorators & ON_PHANTOM_OOP_REF) != 0; |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
453 |
bool not_in_heap = (decorators & IN_NATIVE) != 0; |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
454 |
bool on_reference = on_weak || on_phantom; |
58272
e27564cd10e3
8231250: Shenandoah: Traversal GC should keep alive weak load from heap
zgu
parents:
58219
diff
changeset
|
455 |
bool is_traversal_mode = ShenandoahHeap::heap()->is_traversal_mode(); |
e27564cd10e3
8231250: Shenandoah: Traversal GC should keep alive weak load from heap
zgu
parents:
58219
diff
changeset
|
456 |
bool keep_alive = ((decorators & AS_NO_KEEPALIVE) == 0) || is_traversal_mode; |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
457 |
|
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
458 |
Register result_dst = dst; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
459 |
bool use_tmp1_for_dst = false; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
460 |
|
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
461 |
if (on_oop) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
462 |
// We want to preserve src |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
463 |
if (dst == src.base() || dst == src.index()) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
464 |
// 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
|
465 |
if (tmp1->is_valid() && tmp1 != src.base() && tmp1 != src.index()) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
466 |
dst = tmp1; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
467 |
use_tmp1_for_dst = true; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
468 |
} else { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
469 |
dst = rdi; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
470 |
__ push(dst); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
471 |
} |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
472 |
} |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
473 |
assert_different_registers(dst, src.base(), src.index()); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
474 |
} |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
475 |
|
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
476 |
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
|
477 |
|
54423 | 478 |
if (on_oop) { |
58272
e27564cd10e3
8231250: Shenandoah: Traversal GC should keep alive weak load from heap
zgu
parents:
58219
diff
changeset
|
479 |
if (not_in_heap && !is_traversal_mode) { |
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
480 |
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
|
481 |
} else { |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
482 |
load_reference_barrier(masm, dst, src); |
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
483 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
484 |
|
58693
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
485 |
if (dst != result_dst) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
486 |
__ movptr(result_dst, dst); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
487 |
|
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
488 |
if (!use_tmp1_for_dst) { |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
489 |
__ pop(dst); |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
490 |
} |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
491 |
|
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
492 |
dst = result_dst; |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
493 |
} |
3f35a9efd7de
8232010: Shenandoah: implement self-fixing native barrier
zgu
parents:
58407
diff
changeset
|
494 |
|
55718
9fbc32392798
8227635: Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
zgu
parents:
55679
diff
changeset
|
495 |
if (ShenandoahKeepAliveBarrier && on_reference && keep_alive) { |
54423 | 496 |
const Register thread = NOT_LP64(tmp_thread) LP64_ONLY(r15_thread); |
55146 | 497 |
assert_different_registers(dst, tmp1, tmp_thread); |
54423 | 498 |
NOT_LP64(__ get_thread(thread)); |
499 |
// Generate the SATB pre-barrier code to log the value of |
|
500 |
// the referent field in an SATB buffer. |
|
501 |
shenandoah_write_barrier_pre(masm /* masm */, |
|
502 |
noreg /* obj */, |
|
503 |
dst /* pre_val */, |
|
504 |
thread /* thread */, |
|
505 |
tmp1 /* tmp */, |
|
506 |
true /* tosca_live */, |
|
507 |
true /* expand_call */); |
|
508 |
} |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
509 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
510 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
511 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
512 |
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
|
513 |
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
|
514 |
|
58273
08a5148e7c4e
8230505: Replace JVM type comparisons to T_OBJECT and T_ARRAY with call to is_reference_type
lfoltan
parents:
58272
diff
changeset
|
515 |
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
|
516 |
bool in_heap = (decorators & IN_HEAP) != 0; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
517 |
bool as_normal = (decorators & AS_NORMAL) != 0; |
54423 | 518 |
if (on_oop && in_heap) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
519 |
bool needs_pre_barrier = as_normal; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
520 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
521 |
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
|
522 |
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
|
523 |
// flatten object address if needed |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
524 |
// 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
|
525 |
if (dst.index() == noreg && dst.disp() == 0) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
526 |
if (dst.base() != tmp1) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
527 |
__ movptr(tmp1, dst.base()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
528 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
529 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
530 |
__ lea(tmp1, dst); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
531 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
532 |
|
55146 | 533 |
assert_different_registers(val, tmp1, tmp2, tmp3, rthread); |
534 |
||
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
535 |
#ifndef _LP64 |
55146 | 536 |
__ get_thread(rthread); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
537 |
InterpreterMacroAssembler *imasm = static_cast<InterpreterMacroAssembler*>(masm); |
55146 | 538 |
imasm->save_bcp(); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
539 |
#endif |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
540 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
541 |
if (needs_pre_barrier) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
542 |
shenandoah_write_barrier_pre(masm /*masm*/, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
543 |
tmp1 /* obj */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
544 |
tmp2 /* pre_val */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
545 |
rthread /* thread */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
546 |
tmp3 /* tmp */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
547 |
val != noreg /* tosca_live */, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
548 |
false /* expand_call */); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
549 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
550 |
if (val == noreg) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
551 |
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
|
552 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
553 |
storeval_barrier(masm, val, tmp3); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
554 |
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
|
555 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
556 |
NOT_LP64(imasm->restore_bcp()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
557 |
} else { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
558 |
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
|
559 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
560 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
561 |
|
57542
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
562 |
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
|
563 |
Register obj, Register tmp, Label& slowpath) { |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
564 |
Label done; |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
565 |
// Resolve jobject |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
566 |
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
|
567 |
|
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
568 |
// Check for null. |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
569 |
__ testptr(obj, obj); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
570 |
__ jcc(Assembler::zero, done); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
571 |
|
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
572 |
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
|
573 |
__ testb(gc_state, ShenandoahHeap::EVACUATION); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
574 |
__ jccb(Assembler::notZero, slowpath); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
575 |
__ bind(done); |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
576 |
} |
db740ced41c4
8228532: Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
zgu
parents:
55735
diff
changeset
|
577 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
578 |
// 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
|
579 |
// due to concurrent evacuation. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
580 |
void ShenandoahBarrierSetAssembler::cmpxchg_oop(MacroAssembler* masm, |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
581 |
Register res, Address addr, Register oldval, Register newval, |
53519
74a5ef4c81cc
8217016: Shenandoah: Streamline generation of CAS barriers
rkennke
parents:
52925
diff
changeset
|
582 |
bool exchange, Register tmp1, Register tmp2) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
583 |
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
|
584 |
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
|
585 |
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
|
586 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
587 |
Label L_success, L_failure; |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
588 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
589 |
// Remember oldval for retry logic below |
55146 | 590 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
591 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
592 |
__ movl(tmp1, oldval); |
55146 | 593 |
} else |
594 |
#endif |
|
595 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
596 |
__ movptr(tmp1, oldval); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
597 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
598 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
599 |
// Step 1. Fast-path. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
600 |
// |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
601 |
// 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
|
602 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
603 |
if (os::is_MP()) __ lock(); |
55146 | 604 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
605 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
606 |
__ cmpxchgl(newval, addr); |
55146 | 607 |
} else |
608 |
#endif |
|
609 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
610 |
__ cmpxchgptr(newval, addr); |
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 |
__ jcc(Assembler::equal, L_success); |
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 |
// 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
|
615 |
// |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
616 |
// 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
|
617 |
// 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
|
618 |
// the value from memory -- this will give both to-space pointers. |
54423 | 619 |
// 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
|
620 |
// |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
621 |
// 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
|
622 |
// with filters. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
623 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
624 |
// 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
|
625 |
__ testptr(oldval, oldval); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
626 |
__ jcc(Assembler::zero, L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
627 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
628 |
// Filter: when heap is stable, the failure is definitely legitimate |
55146 | 629 |
#ifdef _LP64 |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
630 |
const Register thread = r15_thread; |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
631 |
#else |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
632 |
const Register thread = tmp2; |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
633 |
__ get_thread(thread); |
55146 | 634 |
#endif |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
635 |
Address gc_state(thread, in_bytes(ShenandoahThreadLocalData::gc_state_offset())); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
636 |
__ testb(gc_state, ShenandoahHeap::HAS_FORWARDED); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
637 |
__ jcc(Assembler::zero, L_failure); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
638 |
|
55146 | 639 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
640 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
641 |
__ movl(tmp2, oldval); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
642 |
__ decode_heap_oop(tmp2); |
55146 | 643 |
} else |
644 |
#endif |
|
645 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
646 |
__ movptr(tmp2, oldval); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
647 |
} |
58788
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 |
// Decode offending in-memory value. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
650 |
// Test if-forwarded |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
651 |
__ 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
|
652 |
__ 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
|
653 |
__ 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
|
654 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
655 |
// Load and mask forwarding pointer |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
656 |
__ movptr(tmp2, Address(tmp2, oopDesc::mark_offset_in_bytes())); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
657 |
__ shrptr(tmp2, 2); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
658 |
__ shlptr(tmp2, 2); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
659 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
660 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
661 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
662 |
__ decode_heap_oop(tmp1); // decode for comparison |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
663 |
} |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
664 |
#endif |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
665 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
666 |
// Now we have the forwarded offender in tmp2. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
667 |
// 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
|
668 |
__ cmpptr(tmp1, tmp2); |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
669 |
__ jcc(Assembler::notEqual, L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
670 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
671 |
// Step 3. Need to fix the memory ptr before continuing. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
672 |
// |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
673 |
// 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
|
674 |
// 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
|
675 |
// 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
|
676 |
// 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
|
677 |
// 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
|
678 |
// have updated the reference for us. |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
679 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
680 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
681 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
682 |
__ encode_heap_oop(tmp2); // previously decoded at step 2. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
683 |
} |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
684 |
#endif |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
685 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
686 |
if (os::is_MP()) __ lock(); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
687 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
688 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
689 |
__ cmpxchgl(tmp2, addr); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
690 |
} else |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
691 |
#endif |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
692 |
{ |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
693 |
__ cmpxchgptr(tmp2, addr); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
694 |
} |
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 4. Try to CAS again. |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
697 |
// |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
698 |
// 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
|
699 |
// 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
|
700 |
// 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
|
701 |
// garbled during retries. |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
702 |
// |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
703 |
#ifdef _LP64 |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
704 |
if (UseCompressedOops) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
705 |
__ movl(oldval, tmp2); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
706 |
} else |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
707 |
#endif |
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 |
__ movptr(oldval, tmp2); |
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 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
712 |
if (os::is_MP()) __ lock(); |
55146 | 713 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
714 |
if (UseCompressedOops) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
715 |
__ cmpxchgl(newval, addr); |
55146 | 716 |
} else |
717 |
#endif |
|
718 |
{ |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
719 |
__ cmpxchgptr(newval, addr); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
720 |
} |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
721 |
if (!exchange) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
722 |
__ 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
|
723 |
} |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
724 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
725 |
// 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
|
726 |
// 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
|
727 |
// 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
|
728 |
|
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
729 |
if (exchange) { |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
730 |
__ bind(L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
731 |
__ bind(L_success); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
732 |
} else { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
733 |
assert(res != NULL, "need result register"); |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
734 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
735 |
Label exit; |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
736 |
__ bind(L_failure); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
737 |
__ xorptr(res, res); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
738 |
__ jmpb(exit); |
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
739 |
|
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
740 |
__ bind(L_success); |
55146 | 741 |
__ movptr(res, 1); |
58788
6a147ac7a68f
8222766: Shenandoah: streamline post-LRB CAS barrier (x86)
shade
parents:
58693
diff
changeset
|
742 |
__ bind(exit); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
743 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
744 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
745 |
|
54763
2584e5772546
8222926: Shenandoah build fails with --with-jvm-features=-compiler1
aoqi
parents:
54755
diff
changeset
|
746 |
#undef __ |
2584e5772546
8222926: Shenandoah build fails with --with-jvm-features=-compiler1
aoqi
parents:
54755
diff
changeset
|
747 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
748 |
#ifdef COMPILER1 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
749 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
750 |
#define __ ce->masm()-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
751 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
752 |
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
|
753 |
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
|
754 |
// 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
|
755 |
// 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
|
756 |
// 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
|
757 |
// been loaded into _pre_val. |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
758 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
759 |
__ bind(*stub->entry()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
760 |
assert(stub->pre_val()->is_register(), "Precondition."); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
761 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
762 |
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
|
763 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
764 |
if (stub->do_load()) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
765 |
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
|
766 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
767 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
768 |
__ 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
|
769 |
__ jcc(Assembler::equal, *stub->continuation()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
770 |
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
|
771 |
__ 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
|
772 |
__ jmp(*stub->continuation()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
773 |
|
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 |
|
54423 | 776 |
void ShenandoahBarrierSetAssembler::gen_load_reference_barrier_stub(LIR_Assembler* ce, ShenandoahLoadReferenceBarrierStub* stub) { |
57716 | 777 |
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
|
778 |
__ bind(*stub->entry()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
779 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
780 |
Register obj = stub->obj()->as_register(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
781 |
Register res = stub->result()->as_register(); |
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
782 |
Register addr = stub->addr()->as_register(); |
57716 | 783 |
Register tmp1 = stub->tmp1()->as_register(); |
784 |
Register tmp2 = stub->tmp2()->as_register(); |
|
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
785 |
assert_different_registers(obj, res, addr, tmp1, tmp2); |
57716 | 786 |
|
787 |
Label slow_path; |
|
788 |
||
789 |
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
|
790 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
791 |
if (res != obj) { |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
792 |
__ mov(res, obj); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
793 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
794 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
795 |
// Check for null. |
55735
08893cf52ee9
8228364: Shenandoah: Remove unused code from ShenandoahBarrierSetC1
rkennke
parents:
55718
diff
changeset
|
796 |
__ testptr(res, res); |
57716 | 797 |
__ jcc(Assembler::zero, *stub->continuation()); |
798 |
||
799 |
// Check for object being in the collection set. |
|
800 |
__ mov(tmp1, res); |
|
801 |
__ shrptr(tmp1, ShenandoahHeapRegion::region_size_bytes_shift_jint()); |
|
802 |
__ 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
|
803 |
#ifdef _LP64 |
57716 | 804 |
__ movbool(tmp2, Address(tmp2, tmp1, Address::times_1)); |
805 |
__ testbool(tmp2); |
|
57748
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
806 |
#else |
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
807 |
// 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
|
808 |
// 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
|
809 |
__ 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
|
810 |
__ testptr(tmp2, 0xFF); |
9bddbd69351c
8229709: x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
shade
parents:
57716
diff
changeset
|
811 |
#endif |
57716 | 812 |
__ jcc(Assembler::zero, *stub->continuation()); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
813 |
|
57716 | 814 |
__ bind(slow_path); |
815 |
ce->store_parameter(res, 0); |
|
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
816 |
ce->store_parameter(addr, 1); |
57716 | 817 |
__ call(RuntimeAddress(bs->load_reference_barrier_rt_code_blob()->code_begin())); |
818 |
||
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
819 |
__ jmp(*stub->continuation()); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
820 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
821 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
822 |
#undef __ |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
823 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
824 |
#define __ sasm-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
825 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
826 |
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
|
827 |
__ prologue("shenandoah_pre_barrier", false); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
828 |
// arg0 : previous value of memory |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
829 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
830 |
__ push(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
831 |
__ push(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
832 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
833 |
const Register pre_val = rax; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
834 |
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
|
835 |
const Register tmp = rdx; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
836 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
837 |
NOT_LP64(__ get_thread(thread);) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
838 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
839 |
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
|
840 |
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
|
841 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
842 |
Label done; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
843 |
Label runtime; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
844 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
845 |
// Is SATB still active? |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
846 |
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
|
847 |
__ testb(gc_state, ShenandoahHeap::MARKING | ShenandoahHeap::TRAVERSAL); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
848 |
__ jcc(Assembler::zero, done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
849 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
850 |
// 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
|
851 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
852 |
__ movptr(tmp, queue_index); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
853 |
__ testptr(tmp, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
854 |
__ jcc(Assembler::zero, runtime); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
855 |
__ subptr(tmp, wordSize); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
856 |
__ movptr(queue_index, tmp); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
857 |
__ addptr(tmp, buffer); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
858 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
859 |
// prev_val (rax) |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
860 |
__ load_parameter(0, pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
861 |
__ movptr(Address(tmp, 0), pre_val); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
862 |
__ jmp(done); |
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 |
__ bind(runtime); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
865 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
866 |
__ save_live_registers_no_oop_map(true); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
867 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
868 |
// load the pre-value |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
869 |
__ load_parameter(0, rcx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
870 |
__ 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
|
871 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
872 |
__ restore_live_registers(true); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
873 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
874 |
__ bind(done); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
875 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
876 |
__ pop(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
877 |
__ pop(rax); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
878 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
879 |
__ epilogue(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
880 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
881 |
|
57716 | 882 |
void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm) { |
883 |
__ prologue("shenandoah_load_reference_barrier", false); |
|
884 |
// arg0 : object to be resolved |
|
885 |
||
886 |
__ save_live_registers_no_oop_map(true); |
|
58219
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
887 |
|
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
888 |
#ifdef _LP64 |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
889 |
__ load_parameter(0, c_rarg0); |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
890 |
__ load_parameter(1, c_rarg1); |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
891 |
if (UseCompressedOops) { |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
892 |
__ 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
|
893 |
} else { |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
894 |
__ 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
|
895 |
} |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
896 |
#else |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
897 |
__ load_parameter(0, rax); |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
898 |
__ load_parameter(1, rbx); |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
899 |
__ 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
|
900 |
#endif |
bc0648405d67
8231087: Shenandoah: Self-fixing load reference barriers for C1/C2
rkennke
parents:
58218
diff
changeset
|
901 |
|
57716 | 902 |
__ restore_live_registers_except_rax(true); |
903 |
||
904 |
__ epilogue(); |
|
905 |
} |
|
906 |
||
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
907 |
#undef __ |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
908 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
909 |
#endif // COMPILER1 |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
910 |
|
54423 | 911 |
address ShenandoahBarrierSetAssembler::shenandoah_lrb() { |
912 |
assert(_shenandoah_lrb != NULL, "need load reference barrier stub"); |
|
913 |
return _shenandoah_lrb; |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
914 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
915 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
916 |
#define __ cgen->assembler()-> |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
917 |
|
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
918 |
/* |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
919 |
* Incoming parameters: |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
920 |
* rax: oop |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
921 |
* rsi: load address |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
922 |
*/ |
54423 | 923 |
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
|
924 |
__ align(CodeEntryAlignment); |
54423 | 925 |
StubCodeMark mark(cgen, "StubRoutines", "shenandoah_lrb"); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
926 |
address start = __ pc(); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
927 |
|
57824
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
928 |
Label resolve_oop, slow_path; |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
929 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
930 |
// We use RDI, which also serves as argument register for slow call. |
57716 | 931 |
// RAX always holds the src object ptr, except after the slow call, |
932 |
// then it holds the result. R8/RBX is used as temporary register. |
|
55146 | 933 |
|
934 |
Register tmp1 = rdi; |
|
935 |
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
|
936 |
|
55146 | 937 |
__ push(tmp1); |
938 |
__ push(tmp2); |
|
939 |
||
940 |
// Check for object being in the collection set. |
|
941 |
__ mov(tmp1, rax); |
|
942 |
__ shrptr(tmp1, ShenandoahHeapRegion::region_size_bytes_shift_jint()); |
|
943 |
__ movptr(tmp2, (intptr_t) ShenandoahHeap::in_cset_fast_test_addr()); |
|
944 |
__ movbool(tmp2, Address(tmp2, tmp1, Address::times_1)); |
|
945 |
__ testbool(tmp2); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
946 |
__ jccb(Assembler::notZero, resolve_oop); |
55146 | 947 |
__ pop(tmp2); |
948 |
__ pop(tmp1); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
949 |
__ ret(0); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
950 |
|
57716 | 951 |
// Test if object is already resolved. |
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
952 |
__ bind(resolve_oop); |
55146 | 953 |
__ movptr(tmp2, Address(rax, oopDesc::mark_offset_in_bytes())); |
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
954 |
// 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
|
955 |
// then test for both bits clear. |
55146 | 956 |
__ notptr(tmp2); |
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
57748
diff
changeset
|
957 |
__ testb(tmp2, markWord::marked_value); |
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
958 |
__ jccb(Assembler::notZero, slow_path); |
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
959 |
// 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
|
960 |
__ orptr(tmp2, markWord::marked_value); |
55146 | 961 |
__ notptr(tmp2); |
962 |
// At this point, tmp2 contains the decoded forwarding pointer. |
|
963 |
__ mov(rax, tmp2); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
964 |
|
55146 | 965 |
__ pop(tmp2); |
966 |
__ pop(tmp1); |
|
55076
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
967 |
__ ret(0); |
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
968 |
|
785a12e0f89b
8224584: Shenandoah: Eliminate forwarding pointer word
rkennke
parents:
54766
diff
changeset
|
969 |
__ bind(slow_path); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
970 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
971 |
__ push(rcx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
972 |
__ push(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
973 |
__ push(rdi); |
55146 | 974 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
975 |
__ push(r8); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
976 |
__ push(r9); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
977 |
__ push(r10); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
978 |
__ push(r11); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
979 |
__ push(r12); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
980 |
__ push(r13); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
981 |
__ push(r14); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
982 |
__ push(r15); |
55146 | 983 |
#endif |
57824
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
984 |
__ push(rbp); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
985 |
__ movptr(rbp, rsp); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
986 |
__ andptr(rsp, -StackAlignmentInBytes); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
987 |
__ push_FPU_state(); |
58819
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
988 |
if (UseCompressedOops) { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
989 |
__ 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
|
990 |
} else { |
ef8be51fff48
8232992: Shenandoah: Implement self-fixing interpreter LRB
zgu
parents:
58788
diff
changeset
|
991 |
__ 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
|
992 |
} |
57824
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
993 |
__ pop_FPU_state(); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
994 |
__ movptr(rsp, rbp); |
253c817653b6
8229977: Shenandoah: save/restore FPU state aroud LRB runtime call
rkennke
parents:
57777
diff
changeset
|
995 |
__ pop(rbp); |
55146 | 996 |
#ifdef _LP64 |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
997 |
__ pop(r15); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
998 |
__ pop(r14); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
999 |
__ pop(r13); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1000 |
__ pop(r12); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1001 |
__ pop(r11); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1002 |
__ pop(r10); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1003 |
__ pop(r9); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1004 |
__ pop(r8); |
55146 | 1005 |
#endif |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1006 |
__ pop(rdi); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1007 |
__ pop(rdx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1008 |
__ pop(rcx); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1009 |
|
55146 | 1010 |
__ pop(tmp2); |
1011 |
__ pop(tmp1); |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1012 |
__ ret(0); |
55146 | 1013 |
|
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1014 |
return start; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1015 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1016 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1017 |
#undef __ |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1018 |
|
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1019 |
void ShenandoahBarrierSetAssembler::barrier_stubs_init() { |
54423 | 1020 |
if (ShenandoahLoadRefBarrier) { |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1021 |
int stub_code_size = 4096; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1022 |
ResourceMark rm; |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1023 |
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
|
1024 |
CodeBuffer buf(bb); |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1025 |
StubCodeGenerator cgen(&buf); |
54423 | 1026 |
_shenandoah_lrb = generate_shenandoah_lrb(&cgen); |
52925
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1027 |
} |
9c18c9d839d3
8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents:
diff
changeset
|
1028 |
} |