6 // This code is free software; you can redistribute it and/or modify it
7 // under the terms of the GNU General Public License version 2 only, as
8 // published by the Free Software Foundation.
9 //
10 // This code is distributed in the hope that it will be useful, but WITHOUT
11 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 // version 2 for more details (a copy is included in the LICENSE file that
14 // accompanied this code).
15 //
16 // You should have received a copy of the GNU General Public License version
17 // 2 along with this work; if not, write to the Free Software Foundation,
18 // Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 //
20 // Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 // or visit www.oracle.com if you need additional information or have any
22 // questions.
23 //
24 //
25
26 source_hpp %{
27 #include "gc/shenandoah/shenandoahBarrierSet.hpp"
28 #include "gc/shenandoah/shenandoahBarrierSetAssembler.hpp"
29 %}
30
31 instruct compareAndSwapP_shenandoah(iRegINoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
32 match(Set res (ShenandoahCompareAndSwapP mem (Binary oldval newval)));
33 ins_cost(10 * DEFAULT_COST);
34
35 effect(TEMP tmp, KILL cr);
36
37 format %{
38 "cmpxchg_shenandoah $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval with temp $tmp, #@compareAndSwapP_shenandoah"
39 %}
40
41 ins_encode %{
42 Register tmp = $tmp$$Register;
43 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
44 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
45 Assembler::relaxed /* acquire */, Assembler::rl /* release */,
46 false /* is_cae */, $res$$Register);
47 %}
48
49 ins_pipe(pipe_slow);
50 %}
51
52 instruct compareAndSwapN_shenandoah(iRegINoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
53 match(Set res (ShenandoahCompareAndSwapN mem (Binary oldval newval)));
54 ins_cost(10 * DEFAULT_COST);
55
56 effect(TEMP tmp, KILL cr);
57
58 format %{
59 "cmpxchgw_shenandoah $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval with temp $tmp, #@compareAndSwapN_shenandoah"
60 %}
61
62 ins_encode %{
63 Register tmp = $tmp$$Register;
64 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
65 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
66 Assembler::relaxed /* acquire */, Assembler::rl /* release */,
67 false /* is_cae */, $res$$Register);
68 %}
69
70 ins_pipe(pipe_slow);
71 %}
72
73 instruct compareAndSwapPAcq_shenandoah(iRegINoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
74 predicate(needs_acquiring_load_reserved(n));
75 match(Set res (ShenandoahCompareAndSwapP mem (Binary oldval newval)));
76 ins_cost(10 * DEFAULT_COST);
77
78 effect(TEMP tmp, KILL cr);
79
80 format %{
81 "cmpxchg_acq_shenandoah_oop $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval with temp $tmp, #@compareAndSwapPAcq_shenandoah"
82 %}
83
84 ins_encode %{
85 Register tmp = $tmp$$Register;
86 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
87 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
88 Assembler::aq /* acquire */, Assembler::rl /* release */,
89 false /* is_cae */, $res$$Register);
90 %}
91
92 ins_pipe(pipe_slow);
93 %}
94
95 instruct compareAndSwapNAcq_shenandoah(iRegINoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
96 predicate(needs_acquiring_load_reserved(n));
97 match(Set res (ShenandoahCompareAndSwapN mem (Binary oldval newval)));
98 ins_cost(10 * DEFAULT_COST);
99
100 effect(TEMP tmp, KILL cr);
101
102 format %{
103 "cmpxchgw_acq_shenandoah_narrow_oop $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval with temp $tmp, #@compareAndSwapNAcq_shenandoah"
104 %}
105
106 ins_encode %{
107 Register tmp = $tmp$$Register;
108 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
109 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
110 Assembler::aq /* acquire */, Assembler::rl /* release */,
111 false /* is_cae */, $res$$Register);
112 %}
113
114 ins_pipe(pipe_slow);
115 %}
116
117 instruct compareAndExchangeN_shenandoah(iRegNNoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
118 match(Set res (ShenandoahCompareAndExchangeN mem (Binary oldval newval)));
119 ins_cost(10 * DEFAULT_COST);
120 effect(TEMP_DEF res, TEMP tmp, KILL cr);
121
122 format %{
123 "cmpxchgw_shenandoah $res = $mem, $oldval, $newval\t# (narrow oop, weak) if $mem == $oldval then $mem <-- $newval, #@compareAndExchangeN_shenandoah"
124 %}
125
126 ins_encode %{
127 Register tmp = $tmp$$Register;
128 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
129 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
130 Assembler::relaxed /* acquire */, Assembler::rl /* release */,
131 true /* is_cae */, $res$$Register);
132 %}
133
134 ins_pipe(pipe_slow);
135 %}
136
137 instruct compareAndExchangeP_shenandoah(iRegPNoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
138 match(Set res (ShenandoahCompareAndExchangeP mem (Binary oldval newval)));
139 ins_cost(10 * DEFAULT_COST);
140
141 effect(TEMP_DEF res, TEMP tmp, KILL cr);
142 format %{
143 "cmpxchg_shenandoah $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval with temp $tmp, #@compareAndExchangeP_shenandoah"
144 %}
145
146 ins_encode %{
147 Register tmp = $tmp$$Register;
148 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
149 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
150 Assembler::relaxed /* acquire */, Assembler::rl /* release */,
151 true /* is_cae */, $res$$Register);
152 %}
153
154 ins_pipe(pipe_slow);
155 %}
156
157 instruct weakCompareAndSwapN_shenandoah(iRegINoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
158 match(Set res (ShenandoahWeakCompareAndSwapN mem (Binary oldval newval)));
159 ins_cost(10 * DEFAULT_COST);
160
161 effect(TEMP tmp, KILL cr);
162 format %{
163 "cmpxchgw_shenandoah $res = $mem, $oldval, $newval\t# (narrow oop, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwapN_shenandoah"
164 "mv $res, EQ\t# $res <-- (EQ ? 1 : 0)"
165 %}
166
167 ins_encode %{
168 Register tmp = $tmp$$Register;
169 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
170 // Weak is not current supported by ShenandoahBarrierSet::cmpxchg_oop
171 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
172 Assembler::relaxed /* acquire */, Assembler::rl /* release */,
173 false /* is_cae */, $res$$Register);
174 %}
175
176 ins_pipe(pipe_slow);
177 %}
178
179 instruct compareAndExchangeNAcq_shenandoah(iRegNNoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
180 predicate(needs_acquiring_load_reserved(n));
181 match(Set res (ShenandoahCompareAndExchangeN mem (Binary oldval newval)));
182 ins_cost(10 * DEFAULT_COST);
183
184 effect(TEMP_DEF res, TEMP tmp, KILL cr);
185 format %{
186 "cmpxchgw_acq_shenandoah $res = $mem, $oldval, $newval\t# (narrow oop, weak) if $mem == $oldval then $mem <-- $newval, #@compareAndExchangeNAcq_shenandoah"
187 %}
188
189 ins_encode %{
190 Register tmp = $tmp$$Register;
191 __ mv(tmp, $oldval$$Register);
192 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
193 Assembler::aq /* acquire */, Assembler::rl /* release */,
194 true /* is_cae */, $res$$Register);
195 %}
196
197 ins_pipe(pipe_slow);
198 %}
199
200 instruct compareAndExchangePAcq_shenandoah(iRegPNoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
201 predicate(needs_acquiring_load_reserved(n));
202 match(Set res (ShenandoahCompareAndExchangeP mem (Binary oldval newval)));
203 ins_cost(10 * DEFAULT_COST);
204
205 effect(TEMP_DEF res, TEMP tmp, KILL cr);
206 format %{
207 "cmpxchg_acq_shenandoah $res = $mem, $oldval, $newval\t# (narrow oop, weak) if $mem == $oldval then $mem <-- $newval, #@compareAndExchangePAcq_shenandoah"
208 %}
209
210 ins_encode %{
211 Register tmp = $tmp$$Register;
212 __ mv(tmp, $oldval$$Register);
213 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
214 Assembler::aq /* acquire */, Assembler::rl /* release */,
215 true /* is_cae */, $res$$Register);
216 %}
217
218 ins_pipe(pipe_slow);
219 %}
220
221 instruct weakCompareAndSwapP_shenandoah(iRegINoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
222 match(Set res (ShenandoahWeakCompareAndSwapP mem (Binary oldval newval)));
223 ins_cost(10 * DEFAULT_COST);
224
225 effect(TEMP tmp, KILL cr);
226 format %{
227 "cmpxchg_shenandoah $res = $mem, $oldval, $newval\t# (ptr, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwapP_shenandoah"
228 %}
229
230 ins_encode %{
231 Register tmp = $tmp$$Register;
232 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
233 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
234 Assembler::relaxed /* acquire */, Assembler::rl /* release */,
235 false /* is_cae */, $res$$Register);
236 %}
237
238 ins_pipe(pipe_slow);
239 %}
240
241 instruct weakCompareAndSwapNAcq_shenandoah(iRegINoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
242 predicate(needs_acquiring_load_reserved(n));
243 match(Set res (ShenandoahWeakCompareAndSwapN mem (Binary oldval newval)));
244 ins_cost(10 * DEFAULT_COST);
245
246 effect(TEMP tmp, KILL cr);
247 format %{
248 "cmpxchgw_acq_shenandoah $res = $mem, $oldval, $newval\t# (ptr, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwapNAcq_shenandoah"
249 "mv $res, EQ\t# $res <-- (EQ ? 1 : 0)"
250 %}
251
252 ins_encode %{
253 Register tmp = $tmp$$Register;
254 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
255 // Weak is not current supported by ShenandoahBarrierSet::cmpxchg_oop
256 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
257 Assembler::aq /* acquire */, Assembler::rl /* release */,
258 false /* is_cae */, $res$$Register);
259 %}
260
261 ins_pipe(pipe_slow);
262 %}
263
264 instruct weakCompareAndSwapPAcq_shenandoah(iRegINoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
265 predicate(needs_acquiring_load_reserved(n));
266 match(Set res (ShenandoahWeakCompareAndSwapP mem (Binary oldval newval)));
267 ins_cost(10 * DEFAULT_COST);
268
269 effect(TEMP tmp, KILL cr);
270 format %{
271 "cmpxchg_acq_shenandoah $res = $mem, $oldval, $newval\t# (ptr, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwapPAcq_shenandoah"
272 "mv $res, EQ\t# $res <-- (EQ ? 1 : 0)"
273 %}
274
275 ins_encode %{
276 Register tmp = $tmp$$Register;
277 __ mv(tmp, $oldval$$Register); // Must not clobber oldval.
278 // Weak is not current supported by ShenandoahBarrierSet::cmpxchg_oop
279 ShenandoahBarrierSet::assembler()->cmpxchg_oop(masm, $mem$$Register, tmp, $newval$$Register,
280 Assembler::aq /* acquire */, Assembler::rl /* release */,
281 false /* is_cae */, $res$$Register);
282 %}
283
284 ins_pipe(pipe_slow);
285 %}
|
6 // This code is free software; you can redistribute it and/or modify it
7 // under the terms of the GNU General Public License version 2 only, as
8 // published by the Free Software Foundation.
9 //
10 // This code is distributed in the hope that it will be useful, but WITHOUT
11 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 // version 2 for more details (a copy is included in the LICENSE file that
14 // accompanied this code).
15 //
16 // You should have received a copy of the GNU General Public License version
17 // 2 along with this work; if not, write to the Free Software Foundation,
18 // Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 //
20 // Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 // or visit www.oracle.com if you need additional information or have any
22 // questions.
23 //
24 //
25
26 source %{
27 #include "gc/shenandoah/shenandoahBarrierSet.hpp"
28 #include "gc/shenandoah/shenandoahBarrierSetAssembler_riscv.hpp"
29 #include "gc/shenandoah/c2/shenandoahBarrierSetC2.hpp"
30 %}
31
32 // Load Pointer
33 instruct loadP_shenandoah(iRegPNoSp dst, memory mem)
34 %{
35 match(Set dst (LoadP mem));
36 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_Load()->barrier_data() != 0);
37
38 effect(TEMP_DEF dst);
39 ins_is_late_expanded_null_check_candidate(true);
40
41 ins_cost(3 * LOAD_COST);
42 format %{ "ld $dst, $mem\t# ptr, shenandoah late-barrier, #@loadP_shenandoah" %}
43
44 ins_encode %{
45 ShenandoahBarrierSet::assembler()->load_c2(this, masm, as_Register($dst$$reg),
46 Address(as_Register($mem$$base), $mem$$disp), false);
47 %}
48
49 ins_pipe(iload_reg_mem);
50 %}
51
52 // Load Pointer
53 instruct loadP_Acq_shenandoah(iRegPNoSp dst, memory mem)
54 %{
55 match(Set dst (LoadP mem));
56 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_Load()->barrier_data() != 0);
57
58 effect(TEMP_DEF dst);
59 ins_is_late_expanded_null_check_candidate(true);
60
61 ins_cost(3 * LOAD_COST);
62 format %{ "ld $dst, $mem\t# ptr, shenandoah late-barrier, #@loadP_shenandoah" %}
63
64 ins_encode %{
65 ShenandoahBarrierSet::assembler()->load_c2(this, masm, as_Register($dst$$reg),
66 Address(as_Register($mem$$base), $mem$$disp), true);
67 %}
68
69 ins_pipe(iload_reg_mem);
70 %}
71
72 // Load Compressed Pointer
73 instruct loadN_shenandoah(iRegNNoSp dst, memory mem)
74 %{
75 match(Set dst (LoadN mem));
76 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_Load()->barrier_data() != 0);
77
78 effect(TEMP_DEF dst);
79 ins_is_late_expanded_null_check_candidate(true);
80
81 ins_cost(3 * LOAD_COST);
82 format %{ "lwu $dst, $mem\t# compressed ptr, shenandoah late-barrier, #@loadN_shenandoah" %}
83
84 ins_encode %{
85 ShenandoahBarrierSet::assembler()->load_c2(this, masm, as_Register($dst$$reg),
86 Address(as_Register($mem$$base), $mem$$disp), false);
87 %}
88
89 ins_pipe(iload_reg_mem);
90 %}
91
92 // Load Compressed Pointer
93 instruct loadN_Acq_shenandoah(iRegNNoSp dst, memory mem)
94 %{
95 match(Set dst (LoadN mem));
96 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_Load()->barrier_data() != 0);
97
98 effect(TEMP_DEF dst);
99 ins_is_late_expanded_null_check_candidate(true);
100
101 ins_cost(3 * LOAD_COST);
102 format %{ "lwu $dst, $mem\t# compressed ptr, shenandoah late-barrier, #@loadN_shenandoah" %}
103
104 ins_encode %{
105 ShenandoahBarrierSet::assembler()->load_c2(this, masm, as_Register($dst$$reg),
106 Address(as_Register($mem$$base), $mem$$disp), true);
107 %}
108
109 ins_pipe(iload_reg_mem);
110 %}
111
112 // Store Pointer
113 instruct storeP_shenandoah(memory mem, iRegP src, iRegPNoSp tmp, rFlagsReg cr)
114 %{
115 match(Set mem (StoreP mem src));
116 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_Store()->barrier_data() != 0);
117
118 effect(TEMP tmp, KILL cr);
119
120 ins_cost(3 * STORE_COST);
121 format %{ "sd $src, $mem\t# ptr, shenandoah late-barrier, #@storeP_shenandoah" %}
122
123 ins_encode %{
124 ShenandoahBarrierSet::assembler()->store_c2(this, masm,
125 Address(as_Register($mem$$base), $mem$$disp),
126 /* dst_narrow = */ false,
127 as_Register($src$$reg),
128 /* src_narrow = */ false,
129 as_Register($tmp$$reg),
130 false);
131 %}
132
133 ins_pipe(istore_reg_mem);
134 %}
135
136 // Store Pointer
137 instruct storeP_Volatile_shenandoah(memory mem, iRegP src, iRegPNoSp tmp, rFlagsReg cr)
138 %{
139 match(Set mem (StoreP mem src));
140 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_Store()->barrier_data() != 0);
141
142 effect(TEMP tmp, KILL cr);
143
144 ins_cost(3 * STORE_COST);
145 format %{ "sd $src, $mem\t# ptr, shenandoah late-barrier, #@storeP_shenandoah" %}
146
147 ins_encode %{
148 ShenandoahBarrierSet::assembler()->store_c2(this, masm,
149 Address(as_Register($mem$$base), $mem$$disp),
150 /* dst_narrow = */ false,
151 as_Register($src$$reg),
152 /* src_narrow = */ false,
153 as_Register($tmp$$reg),
154 true);
155 %}
156
157 ins_pipe(istore_reg_mem);
158 %}
159
160 // Store Compressed Pointer
161 instruct storeN_shenandoah(memory mem, iRegN src, iRegNNoSp tmp, rFlagsReg cr)
162 %{
163 match(Set mem (StoreN mem src));
164 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_Store()->barrier_data() != 0);
165
166 effect(TEMP tmp, KILL cr);
167
168 ins_cost(3 * STORE_COST);
169 format %{ "sw $src, $mem\t# compressed ptr, shenandoah late-barrier, #@storeN_shenandoah" %}
170
171 ins_encode %{
172 ShenandoahBarrierSet::assembler()->store_c2(this, masm,
173 Address(as_Register($mem$$base), $mem$$disp),
174 /* dst_narrow = */ true,
175 as_Register($src$$reg),
176 /* src_narrow = */ true,
177 as_Register($tmp$$reg),
178 false);
179 %}
180
181 ins_pipe(istore_reg_mem);
182 %}
183
184 // Store Compressed Pointer
185 instruct storeN_Volatile_shenandoah(memory mem, iRegN src, iRegNNoSp tmp, rFlagsReg cr)
186 %{
187 match(Set mem (StoreN mem src));
188 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_Store()->barrier_data() != 0);
189
190 effect(TEMP tmp, KILL cr);
191
192 ins_cost(3 * STORE_COST);
193 format %{ "sw $src, $mem\t# compressed ptr, shenandoah late-barrier, #@storeN_shenandoah" %}
194
195 ins_encode %{
196 ShenandoahBarrierSet::assembler()->store_c2(this, masm,
197 Address(as_Register($mem$$base), $mem$$disp),
198 /* dst_narrow = */ true,
199 as_Register($src$$reg),
200 /* src_narrow = */ true,
201 as_Register($tmp$$reg),
202 true);
203 %}
204
205 ins_pipe(istore_reg_mem);
206 %}
207
208 // Encode and Store Compressed Pointer
209 instruct encodePAndStoreN_Volatile_shenandoah(memory mem, iRegP src, iRegPNoSp tmp, rFlagsReg cr)
210 %{
211 match(Set mem (StoreN mem (EncodeP src)));
212 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_Store()->barrier_data() != 0);
213
214 effect(TEMP tmp, KILL cr);
215
216 ins_cost(4 * STORE_COST);
217 format %{
218 "encode_heap_oop $tmp, $src\n\t"
219 "sw $tmp, $mem\t# compressed ptr, shenandoah late-barrier, #@encodePAndStoreN_shenandoah"
220 %}
221
222 ins_encode %{
223 ShenandoahBarrierSet::assembler()->store_c2(this, masm,
224 Address(as_Register($mem$$base), $mem$$disp),
225 /* dst_narrow = */ true,
226 as_Register($src$$reg),
227 /* src_narrow = */ false,
228 as_Register($tmp$$reg),
229 true);
230 %}
231
232 ins_pipe(istore_reg_mem);
233 %}
234
235 // Encode and Store Compressed Pointer
236 instruct encodePAndStoreN_shenandoah(memory mem, iRegP src, iRegPNoSp tmp, rFlagsReg cr)
237 %{
238 match(Set mem (StoreN mem (EncodeP src)));
239 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_Store()->barrier_data() != 0);
240
241 effect(TEMP tmp, KILL cr);
242
243 ins_cost(4 * STORE_COST);
244 format %{
245 "encode_heap_oop $tmp, $src\n\t"
246 "sw $tmp, $mem\t# compressed ptr, shenandoah late-barrier, #@encodePAndStoreN_shenandoah"
247 %}
248
249 ins_encode %{
250 ShenandoahBarrierSet::assembler()->store_c2(this, masm,
251 Address(as_Register($mem$$base), $mem$$disp),
252 /* dst_narrow = */ true,
253 as_Register($src$$reg),
254 /* src_narrow = */ false,
255 as_Register($tmp$$reg),
256 false);
257 %}
258
259 ins_pipe(istore_reg_mem);
260 %}
261
262 instruct compareAndSwap_P_A_shenandoah(iRegINoSp res, indirect mem, iRegPNoSp oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
263 match(Set res (CompareAndSwapP mem (Binary oldval newval)));
264 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
265 ins_cost(10 * DEFAULT_COST);
266
267 effect(TEMP_DEF res, TEMP tmp, KILL cr);
268
269 format %{
270 "cmpxchg_P_shenandoah $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval, #@compareAndSwap_P_shenandoah"
271 %}
272
273 ins_encode %{
274 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
275 as_Register($res$$reg),
276 as_Register($mem$$base),
277 as_Register($oldval$$reg),
278 as_Register($newval$$reg),
279 as_Register($tmp$$reg),
280 /* exchange */ false,
281 /* maybe_null */ true,
282 /* is_narrow */ false,
283 /* weak */ false,
284 /* acquire */ true);
285 %}
286
287 ins_pipe(pipe_slow);
288 %}
289
290 instruct compareAndSwap_P_shenandoah(iRegINoSp res, indirect mem, iRegPNoSp oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
291 match(Set res (CompareAndSwapP mem (Binary oldval newval)));
292 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
293 ins_cost(10 * DEFAULT_COST);
294
295 effect(TEMP_DEF res, TEMP tmp, KILL cr);
296
297 format %{
298 "cmpxchg_P_shenandoah $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval, #@compareAndSwap_P_shenandoah"
299 %}
300
301 ins_encode %{
302 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
303 as_Register($res$$reg),
304 as_Register($mem$$base),
305 as_Register($oldval$$reg),
306 as_Register($newval$$reg),
307 as_Register($tmp$$reg),
308 /* exchange */ false,
309 /* maybe_null */ true,
310 /* is_narrow */ false,
311 /* weak */ false,
312 /* acquire */ false);
313 %}
314
315 ins_pipe(pipe_slow);
316 %}
317
318 instruct compareAndSwap_N_A_shenandoah(iRegINoSp res, indirect mem, iRegNNoSp oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
319 match(Set res (CompareAndSwapN mem (Binary oldval newval)));
320 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
321 ins_cost(10 * DEFAULT_COST);
322
323 effect(TEMP_DEF res, TEMP tmp, KILL cr);
324
325 format %{
326 "cmpxchg_N_shenandoah $mem, $oldval, $newval\t# (narrow ptr) if $mem == $oldval then $mem <-- $newval, #@compareAndSwap_N_shenandoah"
327 %}
328
329 ins_encode %{
330 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
331 as_Register($res$$reg),
332 as_Register($mem$$base),
333 as_Register($oldval$$reg),
334 as_Register($newval$$reg),
335 as_Register($tmp$$reg),
336 /* exchange */ false,
337 /* maybe_null */ true,
338 /* is_narrow */ true,
339 /* weak */ false,
340 /* acquire */ true);
341 %}
342
343 ins_pipe(pipe_slow);
344 %}
345
346 instruct compareAndSwap_N_shenandoah(iRegINoSp res, indirect mem, iRegNNoSp oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
347 match(Set res (CompareAndSwapN mem (Binary oldval newval)));
348 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
349 ins_cost(10 * DEFAULT_COST);
350
351 effect(TEMP_DEF res, TEMP tmp, KILL cr);
352
353 format %{
354 "cmpxchg_N_shenandoah $mem, $oldval, $newval\t# (narrow ptr) if $mem == $oldval then $mem <-- $newval, #@compareAndSwap_N_shenandoah"
355 %}
356
357 ins_encode %{
358 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
359 as_Register($res$$reg),
360 as_Register($mem$$base),
361 as_Register($oldval$$reg),
362 as_Register($newval$$reg),
363 as_Register($tmp$$reg),
364 /* exchange */ false,
365 /* maybe_null */ true,
366 /* is_narrow */ true,
367 /* weak */ false,
368 /* acquire */ false);
369 %}
370
371 ins_pipe(pipe_slow);
372 %}
373
374 instruct compareAndExchange_N_A_shenandoah(iRegNNoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
375 match(Set res (CompareAndExchangeN mem (Binary oldval newval)));
376 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
377 ins_cost(10 * DEFAULT_COST);
378 effect(TEMP_DEF res, TEMP tmp, KILL cr);
379
380 format %{
381 "cae_N_shenandoah $res = $mem, $oldval, $newval\t# (narrow oop) if $mem == $oldval then $mem <-- $newval, #@compareAndExchange_N_shenandoah"
382 %}
383
384 ins_encode %{
385 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
386 as_Register($res$$reg),
387 as_Register($mem$$base),
388 as_Register($oldval$$reg),
389 as_Register($newval$$reg),
390 as_Register($tmp$$reg),
391 /* exchange */ true,
392 /* maybe_null */ (this->bottom_type()->make_ptr()->ptr() != TypePtr::NotNull),
393 /* is_narrow */ true,
394 /* weak */ false,
395 /* acquire */ true);
396 %}
397
398 ins_pipe(pipe_slow);
399 %}
400
401 instruct compareAndExchange_N_shenandoah(iRegNNoSp res, indirect mem, iRegN oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
402 match(Set res (CompareAndExchangeN mem (Binary oldval newval)));
403 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
404 ins_cost(10 * DEFAULT_COST);
405 effect(TEMP_DEF res, TEMP tmp, KILL cr);
406
407 format %{
408 "cae_N_shenandoah $res = $mem, $oldval, $newval\t# (narrow oop) if $mem == $oldval then $mem <-- $newval, #@compareAndExchange_N_shenandoah"
409 %}
410
411 ins_encode %{
412 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
413 as_Register($res$$reg),
414 as_Register($mem$$base),
415 as_Register($oldval$$reg),
416 as_Register($newval$$reg),
417 as_Register($tmp$$reg),
418 /* exchange */ true,
419 /* maybe_null */ (this->bottom_type()->make_ptr()->ptr() != TypePtr::NotNull),
420 /* is_narrow */ true,
421 /* weak */ false,
422 /* acquire */ false);
423 %}
424
425 ins_pipe(pipe_slow);
426 %}
427
428 instruct compareAndExchange_P_A_shenandoah(iRegPNoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
429 match(Set res (CompareAndExchangeP mem (Binary oldval newval)));
430 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
431 ins_cost(10 * DEFAULT_COST);
432
433 effect(TEMP_DEF res, TEMP tmp, KILL cr);
434 format %{
435 "cae_P_shenandoah $res = $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval, #@compareAndExchange_P_shenandoah"
436 %}
437
438 ins_encode %{
439 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
440 as_Register($res$$reg),
441 as_Register($mem$$base),
442 as_Register($oldval$$reg),
443 as_Register($newval$$reg),
444 as_Register($tmp$$reg),
445 /* exchange */ true,
446 /* maybe_null */ (this->bottom_type()->make_ptr()->ptr() != TypePtr::NotNull),
447 /* is_narrow */ false,
448 /* weak */ false,
449 /* acquire */ true);
450 %}
451
452 ins_pipe(pipe_slow);
453 %}
454
455 instruct compareAndExchange_P_shenandoah(iRegPNoSp res, indirect mem, iRegP oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
456 match(Set res (CompareAndExchangeP mem (Binary oldval newval)));
457 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
458 ins_cost(10 * DEFAULT_COST);
459
460 effect(TEMP_DEF res, TEMP tmp, KILL cr);
461 format %{
462 "cae_P_shenandoah $res = $mem, $oldval, $newval\t# (ptr) if $mem == $oldval then $mem <-- $newval, #@compareAndExchange_P_shenandoah"
463 %}
464
465 ins_encode %{
466 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
467 as_Register($res$$reg),
468 as_Register($mem$$base),
469 as_Register($oldval$$reg),
470 as_Register($newval$$reg),
471 as_Register($tmp$$reg),
472 /* exchange */ true,
473 /* maybe_null */ (this->bottom_type()->make_ptr()->ptr() != TypePtr::NotNull),
474 /* is_narrow */ false,
475 /* weak */ false,
476 /* acquire */ false);
477 %}
478
479 ins_pipe(pipe_slow);
480 %}
481
482 instruct weakCompareAndSwap_N_A_shenandoah(iRegINoSp res, indirect mem, iRegNNoSp oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
483 match(Set res (WeakCompareAndSwapN mem (Binary oldval newval)));
484 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
485 ins_cost(10 * DEFAULT_COST);
486
487 effect(TEMP_DEF res, TEMP tmp, KILL cr);
488 format %{
489 "cae_N_weak_shenandoah $res = $mem, $oldval, $newval\t# (N, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwap_N_shenandoah"
490 %}
491
492 ins_encode %{
493 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
494 as_Register($res$$reg),
495 as_Register($mem$$base),
496 as_Register($oldval$$reg),
497 as_Register($newval$$reg),
498 as_Register($tmp$$reg),
499 /* exchange */ false,
500 /* maybe_null */ true,
501 /* is_narrow */ true,
502 /* weak */ true,
503 /* acquire */ true);
504 %}
505
506 ins_pipe(pipe_slow);
507 %}
508
509 instruct weakCompareAndSwap_N_shenandoah(iRegINoSp res, indirect mem, iRegNNoSp oldval, iRegN newval, iRegNNoSp tmp, rFlagsReg cr) %{
510 match(Set res (WeakCompareAndSwapN mem (Binary oldval newval)));
511 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
512 ins_cost(10 * DEFAULT_COST);
513
514 effect(TEMP_DEF res, TEMP tmp, KILL cr);
515 format %{
516 "cae_N_weak_shenandoah $res = $mem, $oldval, $newval\t# (N, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwap_N_shenandoah"
517 %}
518
519 ins_encode %{
520 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
521 as_Register($res$$reg),
522 as_Register($mem$$base),
523 as_Register($oldval$$reg),
524 as_Register($newval$$reg),
525 as_Register($tmp$$reg),
526 /* exchange */ false,
527 /* maybe_null */ true,
528 /* is_narrow */ true,
529 /* weak */ true,
530 /* acquire */ false);
531 %}
532
533 ins_pipe(pipe_slow);
534 %}
535
536 instruct weakCompareAndSwap_P_A_shenandoah(iRegINoSp res, indirect mem, iRegPNoSp oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
537 match(Set res (WeakCompareAndSwapP mem (Binary oldval newval)));
538 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
539 ins_cost(10 * DEFAULT_COST);
540
541 effect(TEMP_DEF res, TEMP tmp, KILL cr);
542 format %{
543 "cae_P_weak_shenandoah $res = $mem, $oldval, $newval\t# (P, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwap_P_shenandoah"
544 %}
545
546 ins_encode %{
547 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
548 as_Register($res$$reg),
549 as_Register($mem$$base),
550 as_Register($oldval$$reg),
551 as_Register($newval$$reg),
552 as_Register($tmp$$reg),
553 /* exchange */ false,
554 /* maybe_null */ true,
555 /* is_narrow */ false,
556 /* weak */ true,
557 /* acquire */ true);
558 %}
559
560 ins_pipe(pipe_slow);
561 %}
562
563 instruct weakCompareAndSwap_P_shenandoah(iRegINoSp res, indirect mem, iRegPNoSp oldval, iRegP newval, iRegPNoSp tmp, rFlagsReg cr) %{
564 match(Set res (WeakCompareAndSwapP mem (Binary oldval newval)));
565 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
566 ins_cost(10 * DEFAULT_COST);
567
568 effect(TEMP_DEF res, TEMP tmp, KILL cr);
569 format %{
570 "cae_P_weak_shenandoah $res = $mem, $oldval, $newval\t# (P, weak) if $mem == $oldval then $mem <-- $newval, #@weakCompareAndSwap_P_shenandoah"
571 %}
572
573 ins_encode %{
574 ShenandoahBarrierSet::assembler()->compare_and_set_c2(this, masm,
575 as_Register($res$$reg),
576 as_Register($mem$$base),
577 as_Register($oldval$$reg),
578 as_Register($newval$$reg),
579 as_Register($tmp$$reg),
580 /* exchange */ false,
581 /* maybe_null */ true,
582 /* is_narrow */ false,
583 /* weak */ true,
584 /* acquire */ false);
585 %}
586
587 ins_pipe(pipe_slow);
588 %}
589
590 instruct getAndSet_P_shenandoah(indirect mem, iRegP newval, iRegPNoSp preval, iRegPNoSp tmp, rFlagsReg cr)
591 %{
592 match(Set preval (GetAndSetP mem newval));
593 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
594 effect(TEMP_DEF preval, TEMP tmp, KILL cr);
595 ins_cost(10 * DEFAULT_COST);
596 format %{ "get_and_set_P $preval, $newval, [$mem], #@getAndSet_P_shenandoah" %}
597 ins_encode %{
598 ShenandoahBarrierSet::assembler()->get_and_set_c2(this, masm,
599 as_Register($preval$$reg),
600 as_Register($newval$$reg),
601 as_Register($mem$$base),
602 as_Register($tmp$$reg),
603 /* acquire */ false);
604 %}
605 ins_pipe(pipe_slow);
606 %}
607
608 instruct getAndSet_P_A_shenandoah(indirect mem, iRegP newval, iRegPNoSp preval, iRegPNoSp tmp, rFlagsReg cr)
609 %{
610 match(Set preval (GetAndSetP mem newval));
611 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
612 effect(TEMP_DEF preval, TEMP tmp, KILL cr);
613 ins_cost(10 * DEFAULT_COST);
614 format %{ "get_and_set_P $preval, $newval, [$mem], #@getAndSet_P_shenandoah" %}
615 ins_encode %{
616 ShenandoahBarrierSet::assembler()->get_and_set_c2(this, masm,
617 as_Register($preval$$reg),
618 as_Register($newval$$reg),
619 as_Register($mem$$base),
620 as_Register($tmp$$reg),
621 /* acquire */ true);
622 %}
623 ins_pipe(pipe_slow);
624 %}
625
626 instruct getAndSet_N_A_shenandoah(indirect mem, iRegN newval, iRegNNoSp preval, iRegNNoSp tmp, rFlagsReg cr)
627 %{
628 match(Set preval (GetAndSetN mem newval));
629 predicate(UseShenandoahGC && needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
630 effect(TEMP_DEF preval, TEMP tmp, KILL cr);
631 ins_cost(10 * DEFAULT_COST);
632 format %{ "get_and_set_N $preval, $newval, [$mem], #@getAndSet_N_shenandoah" %}
633 ins_encode %{
634 ShenandoahBarrierSet::assembler()->get_and_set_c2(this, masm,
635 as_Register($preval$$reg),
636 as_Register($newval$$reg),
637 as_Register($mem$$base),
638 as_Register($tmp$$reg),
639 /* acquire */ true);
640 %}
641 ins_pipe(pipe_slow);
642 %}
643
644 instruct getAndSet_N_shenandoah(indirect mem, iRegN newval, iRegNNoSp preval, iRegNNoSp tmp, rFlagsReg cr)
645 %{
646 match(Set preval (GetAndSetN mem newval));
647 predicate(UseShenandoahGC && !needs_acquiring_load_reserved(n) && n->as_LoadStore()->barrier_data() != 0);
648 effect(TEMP_DEF preval, TEMP tmp, KILL cr);
649 ins_cost(10 * DEFAULT_COST);
650 format %{ "get_and_set_N $preval, $newval, [$mem], #@getAndSet_N_shenandoah" %}
651 ins_encode %{
652 ShenandoahBarrierSet::assembler()->get_and_set_c2(this, masm,
653 as_Register($preval$$reg),
654 as_Register($newval$$reg),
655 as_Register($mem$$base),
656 as_Register($tmp$$reg),
657 /* acquire */ false);
658 %}
659 ins_pipe(pipe_slow);
660 %}
|