< prev index next >

src/hotspot/cpu/x86/c2_MacroAssembler_x86.hpp

Print this page

125 
126   void evmovdqu(BasicType type, KRegister kmask, XMMRegister dst, Address src, int vector_len);
127   void evmovdqu(BasicType type, KRegister kmask, Address dst, XMMRegister src, int vector_len);
128 
129   // extract
130   void extract(BasicType typ, Register dst, XMMRegister src, int idx);
131   XMMRegister get_lane(BasicType typ, XMMRegister dst, XMMRegister src, int elemindex);
132   void get_elem(BasicType typ, Register dst, XMMRegister src, int elemindex);
133   void get_elem(BasicType typ, XMMRegister dst, XMMRegister src, int elemindex, Register tmp = noreg, XMMRegister vtmp = xnoreg);
134 
135   // vector test
136   void vectortest(int bt, int vlen, XMMRegister src1, XMMRegister src2,
137                   XMMRegister vtmp1 = xnoreg, XMMRegister vtmp2 = xnoreg, KRegister mask = knoreg);
138 
139   // blend
140   void evpcmp(BasicType typ, KRegister kdmask, KRegister ksmask, XMMRegister src1, AddressLiteral adr, int comparison, int vector_len, Register scratch = rscratch1);
141   void evpcmp(BasicType typ, KRegister kdmask, KRegister ksmask, XMMRegister src1, XMMRegister src2, int comparison, int vector_len);
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, bool is_legacy);


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,

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,

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

125 
126   void evmovdqu(BasicType type, KRegister kmask, XMMRegister dst, Address src, int vector_len);
127   void evmovdqu(BasicType type, KRegister kmask, Address dst, XMMRegister src, int vector_len);
128 
129   // extract
130   void extract(BasicType typ, Register dst, XMMRegister src, int idx);
131   XMMRegister get_lane(BasicType typ, XMMRegister dst, XMMRegister src, int elemindex);
132   void get_elem(BasicType typ, Register dst, XMMRegister src, int elemindex);
133   void get_elem(BasicType typ, XMMRegister dst, XMMRegister src, int elemindex, Register tmp = noreg, XMMRegister vtmp = xnoreg);
134 
135   // vector test
136   void vectortest(int bt, int vlen, XMMRegister src1, XMMRegister src2,
137                   XMMRegister vtmp1 = xnoreg, XMMRegister vtmp2 = xnoreg, KRegister mask = knoreg);
138 
139   // blend
140   void evpcmp(BasicType typ, KRegister kdmask, KRegister ksmask, XMMRegister src1, AddressLiteral adr, int comparison, int vector_len, Register scratch = rscratch1);
141   void evpcmp(BasicType typ, KRegister kdmask, KRegister ksmask, XMMRegister src1, XMMRegister src2, int comparison, int vector_len);
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, bool is_legacy);
145   void load_vector_mask(KRegister dst, XMMRegister src, XMMRegister xtmp, Register tmp, bool novlbwdq, int vlen_enc);
146 
147   void load_iota_indices(XMMRegister dst, Register scratch, int vlen_in_bytes);
148 
149   // vector compare
150   void vpcmpu(BasicType typ, XMMRegister dst, XMMRegister src1, XMMRegister src2, ComparisonPredicate comparison, int vlen_in_bytes,
151               XMMRegister vtmp1, XMMRegister vtmp2, Register scratch);
152   void vpcmpu32(BasicType typ, XMMRegister dst, XMMRegister src1, XMMRegister src2, ComparisonPredicate comparison, int vlen_in_bytes,
153                 XMMRegister vtmp1, XMMRegister vtmp2, XMMRegister vtmp3, Register scratch);
154 
155   // Reductions for vectors of bytes, shorts, ints, longs, floats, and doubles.
156 
157   // dst = src1  reduce(op, src2) using vtmp as temps
158   void reduceI(int opcode, int vlen, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
159 #ifdef _LP64
160   void reduceL(int opcode, int vlen, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
161   void genmask(KRegister dst, Register len, Register temp);
162 #endif // _LP64
163 
164   // dst = reduce(op, src2) using vtmp as temps
165   void reduce_fp(int opcode, int vlen,
166                  XMMRegister dst, XMMRegister src,

207   void reduce8L(int opcode, Register dst, Register src1, XMMRegister src2, XMMRegister vtmp1, XMMRegister vtmp2);
208 #endif // _LP64
209 
210   // Float Reduction
211   void reduce2F (int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp);
212   void reduce4F (int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp);
213   void reduce8F (int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
214   void reduce16F(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
215 
216   // Double Reduction
217   void reduce2D(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp);
218   void reduce4D(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
219   void reduce8D(int opcode, XMMRegister dst, XMMRegister src, XMMRegister vtmp1, XMMRegister vtmp2);
220 
221   // Base reduction instruction
222   void reduce_operation_128(BasicType typ, int opcode, XMMRegister dst, XMMRegister src);
223   void reduce_operation_256(BasicType typ, int opcode, XMMRegister dst, XMMRegister src1, XMMRegister src2);
224 
225  public:
226 #ifdef _LP64
227   void vector_mask_operation(int opc, Register dst, KRegister mask, Register tmp, int masklen, int masksize, int vec_enc);

228 
229   void vector_mask_operation(int opc, Register dst, XMMRegister mask, XMMRegister xtmp, XMMRegister xtmp1,
230                              Register tmp, int masklen, int masksize, int vec_enc);
231 #endif
232   void string_indexof_char(Register str1, Register cnt1, Register ch, Register result,
233                            XMMRegister vec1, XMMRegister vec2, XMMRegister vec3, Register tmp);
234 
235   void stringL_indexof_char(Register str1, Register cnt1, Register ch, Register result,
236                            XMMRegister vec1, XMMRegister vec2, XMMRegister vec3, Register tmp);
237 
238   // IndexOf strings.
239   // Small strings are loaded through stack if they cross page boundary.
240   void string_indexof(Register str1, Register str2,
241                       Register cnt1, Register cnt2,
242                       int int_cnt2,  Register result,
243                       XMMRegister vec, Register tmp,
244                       int ae);
245 
246   // IndexOf for constant substrings with size >= 8 elements
247   // which don't need to be loaded through stack.
248   void string_indexofC8(Register str1, Register str2,
249                       Register cnt1, Register cnt2,
250                       int int_cnt2,  Register result,

257   // helper function for string_compare
258   void load_next_elements(Register elem1, Register elem2, Register str1, Register str2,
259                           Address::ScaleFactor scale, Address::ScaleFactor scale1,
260                           Address::ScaleFactor scale2, Register index, int ae);
261   // Compare strings.
262   void string_compare(Register str1, Register str2,
263                       Register cnt1, Register cnt2, Register result,
264                       XMMRegister vec1, int ae, KRegister mask = knoreg);
265 
266   // Search for Non-ASCII character (Negative byte value) in a byte array,
267   // return true if it has any and false otherwise.
268   void has_negatives(Register ary1, Register len,
269                      Register result, Register tmp1,
270                      XMMRegister vec1, XMMRegister vec2, KRegister mask1 = knoreg, KRegister mask2 = knoreg);
271 
272   // Compare char[] or byte[] arrays.
273   void arrays_equals(bool is_array_equ, Register ary1, Register ary2,
274                      Register limit, Register result, Register chr,
275                      XMMRegister vec1, XMMRegister vec2, bool is_char, KRegister mask = knoreg);
276 
277 
278   void evmasked_op(int ideal_opc, BasicType eType, KRegister mask,
279                    XMMRegister dst, XMMRegister src1, XMMRegister src2,
280                    bool merge, int vlen_enc, bool is_varshift = false);
281 
282   void evmasked_op(int ideal_opc, BasicType eType, KRegister mask,
283                    XMMRegister dst, XMMRegister src1, Address src2,
284                    bool merge, int vlen_enc);
285 
286   void evmasked_op(int ideal_opc, BasicType eType, KRegister mask, XMMRegister dst,
287                    XMMRegister src1, int imm8, bool merge, int vlen_enc);
288 
289   void masked_op(int ideal_opc, int mask_len, KRegister dst,
290                  KRegister src1, KRegister src2);
291 #endif // CPU_X86_C2_MACROASSEMBLER_X86_HPP
< prev index next >