CoCalc -- c2_MacroAssembler

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/src/hotspot/cpu/x86/c2_MacroAssembler_x86.hpp
⁴¹¹⁴⁴ views
1
/*
2
 * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 *
23
 */
24

25
#ifndef CPU_X86_C2_MACROASSEMBLER_X86_HPP
26
#define CPU_X86_C2_MACROASSEMBLER_X86_HPP
27

28
// C2_MacroAssembler contains high-level macros for C2
29

30
public:
31
  Assembler::AvxVectorLen vector_length_encoding(int vlen_in_bytes);
32

33
  // special instructions for EVEX
34
  void setvectmask(Register dst, Register src, KRegister mask);
35
  void restorevectmask(KRegister mask);
36

37
  // Code used by cmpFastLock and cmpFastUnlock mach instructions in .ad file.
38
  // See full desription in macroAssembler_x86.cpp.
39
  void fast_lock(Register obj, Register box, Register tmp,
40
                 Register scr, Register cx1, Register cx2,
41
                 BiasedLockingCounters* counters,
42
                 RTMLockingCounters* rtm_counters,
43
                 RTMLockingCounters* stack_rtm_counters,
44
                 Metadata* method_data,
45
                 bool use_rtm, bool profile_rtm);
46
  void fast_unlock(Register obj, Register box, Register tmp, bool use_rtm);
47

48
#if INCLUDE_RTM_OPT
49
  void rtm_counters_update(Register abort_status, Register rtm_counters);
50
  void branch_on_random_using_rdtsc(Register tmp, Register scr, int count, Label& brLabel);
51
  void rtm_abort_ratio_calculation(Register tmp, Register rtm_counters_reg,
52
                                   RTMLockingCounters* rtm_counters,
53
                                   Metadata* method_data);
54
  void rtm_profiling(Register abort_status_Reg, Register rtm_counters_Reg,
55
                     RTMLockingCounters* rtm_counters, Metadata* method_data, bool profile_rtm);
56
  void rtm_retry_lock_on_abort(Register retry_count, Register abort_status, Label& retryLabel);
57
  void rtm_retry_lock_on_busy(Register retry_count, Register box, Register tmp, Register scr, Label& retryLabel);
58
  void rtm_stack_locking(Register obj, Register tmp, Register scr,
59
                         Register retry_on_abort_count,
60
                         RTMLockingCounters* stack_rtm_counters,
61
                         Metadata* method_data, bool profile_rtm,
62
                         Label& DONE_LABEL, Label& IsInflated);
63
  void rtm_inflated_locking(Register obj, Register box, Register tmp,
64
                            Register scr, Register retry_on_busy_count,
65
                            Register retry_on_abort_count,
66
                            RTMLockingCounters* rtm_counters,
67
                            Metadata* method_data, bool profile_rtm,
68
                            Label& DONE_LABEL);
69
#endif
70

71
  // Generic instructions support for use in .ad files C2 code generation
72
  void vabsnegd(int opcode, XMMRegister dst, XMMRegister src, Register scr);
73
  void vabsnegd(int opcode, XMMRegister dst, XMMRegister src, int vector_len, Register scr);
74
  void vabsnegf(int opcode, XMMRegister dst, XMMRegister src, Register scr);
75
  void vabsnegf(int opcode, XMMRegister dst, XMMRegister src, int vector_len, Register scr);
76

77
  void pminmax(int opcode, BasicType elem_bt, XMMRegister dst, XMMRegister src,
78
               XMMRegister tmp = xnoreg);
79
  void vpminmax(int opcode, BasicType elem_bt,
80
                XMMRegister dst, XMMRegister src1, XMMRegister src2,
81
                int vlen_enc);
82

83
  void vminmax_fp(int opcode, BasicType elem_bt,
84
                  XMMRegister dst, XMMRegister a, XMMRegister b,
85
                  XMMRegister tmp, XMMRegister atmp, XMMRegister btmp,
86
                  int vlen_enc);
87
  void evminmax_fp(int opcode, BasicType elem_bt,
88
                   XMMRegister dst, XMMRegister a, XMMRegister b,
89
                   KRegister ktmp, XMMRegister atmp, XMMRegister btmp,
90
                   int vlen_enc);
91

92
  void signum_fp(int opcode, XMMRegister dst,
93
                 XMMRegister zero, XMMRegister one,
94
                 Register scratch);
95

96
  void vextendbw(bool sign, XMMRegister dst, XMMRegister src, int vector_len);
97
  void vextendbw(bool sign, XMMRegister dst, XMMRegister src);
98
  void vextendbd(bool sign, XMMRegister dst, XMMRegister src, int vector_len);
99
  void vextendwd(bool sign, XMMRegister dst, XMMRegister src, int vector_len);
100

101
  void vshiftd(int opcode, XMMRegister dst, XMMRegister shift);
102
  void vshiftd_imm(int opcode, XMMRegister dst, int shift);
103
  void vshiftd(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vlen_enc);
104
  void vshiftd_imm(int opcode, XMMRegister dst, XMMRegister nds, int shift, int vector_len);
105
  void vshiftw(int opcode, XMMRegister dst, XMMRegister shift);
106
  void vshiftw(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vlen_enc);
107
  void vshiftq(int opcode, XMMRegister dst, XMMRegister shift);
108
  void vshiftq_imm(int opcode, XMMRegister dst, int shift);
109
  void vshiftq(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vlen_enc);
110
  void vshiftq_imm(int opcode, XMMRegister dst, XMMRegister nds, int shift, int vector_len);
111

112
  void vprotate_imm(int opcode, BasicType etype, XMMRegister dst, XMMRegister src, int shift, int vector_len);
113
  void vprotate_var(int opcode, BasicType etype, XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
114

115
  void varshiftd(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vlen_enc);
116
  void varshiftw(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vlen_enc);
117
  void varshiftq(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vlen_enc, XMMRegister vtmp = xnoreg);
118
  void varshiftbw(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len, XMMRegister vtmp, Register scratch);
119
  void evarshiftb(int opcode, XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len, XMMRegister vtmp, Register scratch);
120

121
  void insert(BasicType typ, XMMRegister dst, Register val, int idx);
122
  void vinsert(BasicType typ, XMMRegister dst, XMMRegister src, Register val, int idx);
123
  void vgather(BasicType typ, XMMRegister dst, Register base, XMMRegister idx, XMMRegister mask, int vector_len);
124
  void evgather(BasicType typ, XMMRegister dst, KRegister mask, Register base, XMMRegister idx, int vector_len);
125
  void evscatter(BasicType typ, Register base, XMMRegister idx, KRegister mask, XMMRegister src, int vector_len);
126

127
  void evmovdqu(BasicType type, KRegister kmask, XMMRegister dst, Address src, int vector_len);
128
  void evmovdqu(BasicType type, KRegister kmask, Address dst, XMMRegister src, int vector_len);
129

130
  // extract
131
  void extract(BasicType typ, Register dst, XMMRegister src, int idx);
132
  XMMRegister get_lane(BasicType typ, XMMRegister dst, XMMRegister src, int elemindex);
133
  void get_elem(BasicType typ, Register dst, XMMRegister src, int elemindex);
134
  void get_elem(BasicType typ, XMMRegister dst, XMMRegister src, int elemindex, Register tmp = noreg, XMMRegister vtmp = xnoreg);
135

136
  // vector test
137
  void vectortest(int bt, int vlen, XMMRegister src1, XMMRegister src2,
138
                  XMMRegister vtmp1 = xnoreg, XMMRegister vtmp2 = xnoreg, KRegister mask = knoreg);
139

140
  // blend
141
  void evpcmp(BasicType typ, KRegister kdmask, KRegister ksmask, XMMRegister src1, AddressLiteral adr, int comparison, int vector_len, Register scratch = rscratch1);
142
  void evpblend(BasicType typ, XMMRegister dst, KRegister kmask, XMMRegister src1, XMMRegister src2, bool merge, int vector_len);
143

144
  void load_vector_mask(XMMRegister dst, XMMRegister src, int vlen_in_bytes, BasicType elem_bt);
145
  void load_iota_indices(XMMRegister dst, Register scratch, int vlen_in_bytes);
146

147
  // vector compare
148
  void vpcmpu(BasicType typ, XMMRegister dst, XMMRegister src1, XMMRegister src2, ComparisonPredicate comparison, int vlen_in_bytes,
149
              XMMRegister vtmp1, XMMRegister vtmp2, Register scratch);
150
  void vpcmpu32(BasicType typ, XMMRegister dst, XMMRegister src1, XMMRegister src2, ComparisonPredicate comparison, int vlen_in_bytes,
151
                XMMRegister vtmp1, XMMRegister vtmp2, XMMRegister vtmp3, Register scratch);
152

153
  // Reductions for vectors of bytes, shorts, ints, longs, floats, and doubles.
154

155
  // dst = src1  reduce(op, src2) using vtmp as temps
156
  void reduceI(int opcode, int vlen, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
157
#ifdef _LP64
158
  void reduceL(int opcode, int vlen, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
159
  void genmask(KRegister dst, Register len, Register temp);
160
#endif // _LP64
161

162
  // dst = reduce(op, src2) using vtmp as temps
163
  void reduce_fp(int opcode, int vlen,
164
                 XMMRegister dst, XMMRegister src,
165
                 XMMRegister vtmp1, XMMRegister vtmp2 = xnoreg);
166
  void reduceB(int opcode, int vlen, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
167
  void mulreduceB(int opcode, int vlen, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
168
  void reduceS(int opcode, int vlen, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
169
  void reduceFloatMinMax(int opcode, int vlen, bool is_dst_valid,
170
                         XMMRegister dst, XMMRegister src,
171
                         XMMRegister tmp, XMMRegister atmp, XMMRegister btmp, XMMRegister xmm_0, XMMRegister xmm_1 = xnoreg);
172
  void reduceDoubleMinMax(int opcode, int vlen, bool is_dst_valid,
173
                          XMMRegister dst, XMMRegister src,
174
                          XMMRegister tmp, XMMRegister atmp, XMMRegister btmp, XMMRegister xmm_0, XMMRegister xmm_1 = xnoreg);
175
 private:
176
  void reduceF(int opcode, int vlen, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
177
  void reduceD(int opcode, int vlen, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
178

179
  // Int Reduction
180
  void reduce2I (int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
181
  void reduce4I (int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
182
  void reduce8I (int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
183
  void reduce16I(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
184

185
  // Byte Reduction
186
  void reduce8B (int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
187
  void reduce16B(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
188
  void reduce32B(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
189
  void reduce64B(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
190
  void mulreduce8B (int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
191
  void mulreduce16B(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
192
  void mulreduce32B(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
193
  void mulreduce64B(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
194

195
  // Short Reduction
196
  void reduce4S (int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
197
  void reduce8S (int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
198
  void reduce16S(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
199
  void reduce32S(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
200

201
  // Long Reduction
202
#ifdef _LP64
203
  void reduce2L(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
204
  void reduce4L(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
205
  void reduce8L(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
206
#endif // _LP64
207

208
  // Float Reduction
209
  void reduce2F (int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp);
210
  void reduce4F (int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp);
211
  void reduce8F (int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
212
  void reduce16F(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
213

214
  // Double Reduction
215
  void reduce2D(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp);
216
  void reduce4D(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
217
  void reduce8D(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
218

219
  // Base reduction instruction
220
  void reduce_operation_128(BasicType typ, int opcode, XMMRegister dst, XMMRegister src);
221
  void reduce_operation_256(BasicType typ, int opcode, XMMRegister dst, XMMRegister src1, XMMRegister src2);
222

223
 public:
224
#ifdef _LP64
225
  void vector_mask_operation(int opc, Register dst, XMMRegister mask, XMMRegister xtmp, Register tmp,
226
                             KRegister ktmp, int masklen, int vec_enc);
227

228
  void vector_mask_operation(int opc, Register dst, XMMRegister mask, XMMRegister xtmp, XMMRegister xtmp1,
229
                             Register tmp, int masklen, int vec_enc);
230
#endif
231
  void string_indexof_char(Register str1, Register cnt1, Register ch, Register result,
232
                           XMMRegister vec1, XMMRegister vec2, XMMRegister vec3, Register tmp);
233

234
  void stringL_indexof_char(Register str1, Register cnt1, Register ch, Register result,
235
                           XMMRegister vec1, XMMRegister vec2, XMMRegister vec3, Register tmp);
236

237
  // IndexOf strings.
238
  // Small strings are loaded through stack if they cross page boundary.
239
  void string_indexof(Register str1, Register str2,
240
                      Register cnt1, Register cnt2,
241
                      int int_cnt2,  Register result,
242
                      XMMRegister vec, Register tmp,
243
                      int ae);
244

245
  // IndexOf for constant substrings with size >= 8 elements
246
  // which don't need to be loaded through stack.
247
  void string_indexofC8(Register str1, Register str2,
248
                      Register cnt1, Register cnt2,
249
                      int int_cnt2,  Register result,
250
                      XMMRegister vec, Register tmp,
251
                      int ae);
252

253
    // Smallest code: we don't need to load through stack,
254
    // check string tail.
255

256
  // helper function for string_compare
257
  void load_next_elements(Register elem1, Register elem2, Register str1, Register str2,
258
                          Address::ScaleFactor scale, Address::ScaleFactor scale1,
259
                          Address::ScaleFactor scale2, Register index, int ae);
260
  // Compare strings.
261
  void string_compare(Register str1, Register str2,
262
                      Register cnt1, Register cnt2, Register result,
263
                      XMMRegister vec1, int ae, KRegister mask = knoreg);
264

265
  // Search for Non-ASCII character (Negative byte value) in a byte array,
266
  // return true if it has any and false otherwise.
267
  void has_negatives(Register ary1, Register len,
268
                     Register result, Register tmp1,
269
                     XMMRegister vec1, XMMRegister vec2, KRegister mask1 = knoreg, KRegister mask2 = knoreg);
270

271
  // Compare char[] or byte[] arrays.
272
  void arrays_equals(bool is_array_equ, Register ary1, Register ary2,
273
                     Register limit, Register result, Register chr,
274
                     XMMRegister vec1, XMMRegister vec2, bool is_char, KRegister mask = knoreg);
275

276
#endif // CPU_X86_C2_MACROASSEMBLER_X86_HPP
277

278
Product

Resources

Company
