1 /*
  2  * Copyright (c) 2013, 2024, 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_STUBROUTINES_X86_HPP
 26 #define CPU_X86_STUBROUTINES_X86_HPP
 27 
 28 // This file holds the platform specific parts of the StubRoutines
 29 // definition. See stubRoutines.hpp for a description on how to
 30 // extend it.
 31 
 32 static bool returns_to_call_stub(address return_pc) { return return_pc == _call_stub_return_address; }
 33 
 34 enum platform_dependent_constants {
 35   // simply increase sizes if too small (assembler will crash if too small)
 36   _initial_stubs_code_size      = 20000 WINDOWS_ONLY(+1000),
 37   _continuation_stubs_code_size =  1000 LP64_ONLY(+2000),
 38   // AVX512 intrinsics add more code in 64-bit VM,
 39   // Windows have more code to save/restore registers
 40   _compiler_stubs_code_size     = 20000 LP64_ONLY(+46000) WINDOWS_ONLY(+2000),
 41   _final_stubs_code_size        = 10000 LP64_ONLY(+20000) WINDOWS_ONLY(+2000) ZGC_ONLY(+20000)
 42 };
 43 
 44 class x86 {
 45  friend class StubGenerator;
 46  friend class VMStructs;
 47 
 48 #ifdef _LP64
 49  private:
 50   static address _get_previous_sp_entry;
 51 
 52   static address _f2i_fixup;
 53   static address _f2l_fixup;
 54   static address _d2i_fixup;
 55   static address _d2l_fixup;
 56 
 57   static address _float_sign_mask;
 58   static address _float_sign_flip;
 59   static address _double_sign_mask;
 60   static address _double_sign_flip;
 61   static address _compress_perm_table32;
 62   static address _compress_perm_table64;
 63   static address _expand_perm_table32;
 64   static address _expand_perm_table64;
 65 
 66  public:
 67 
 68   static address get_previous_sp_entry() {
 69     return _get_previous_sp_entry;
 70   }
 71 
 72   static address f2i_fixup() {
 73     return _f2i_fixup;
 74   }
 75 
 76   static address f2l_fixup() {
 77     return _f2l_fixup;
 78   }
 79 
 80   static address d2i_fixup() {
 81     return _d2i_fixup;
 82   }
 83 
 84   static address d2l_fixup() {
 85     return _d2l_fixup;
 86   }
 87 
 88   static address float_sign_mask() {
 89     return _float_sign_mask;
 90   }
 91 
 92   static address float_sign_flip() {
 93     return _float_sign_flip;
 94   }
 95 
 96   static address double_sign_mask() {
 97     return _double_sign_mask;
 98   }
 99 
100   static address double_sign_flip() {
101     return _double_sign_flip;
102   }
103 
104 #else // !LP64
105 
106  private:
107   static address _verify_fpu_cntrl_wrd_entry;
108   static address _d2i_wrapper;
109   static address _d2l_wrapper;
110 
111   static jint    _fpu_cntrl_wrd_std;
112   static jint    _fpu_cntrl_wrd_24;
113   static jint    _fpu_cntrl_wrd_trunc;
114 
115   static jint    _fpu_subnormal_bias1[3];
116   static jint    _fpu_subnormal_bias2[3];
117 
118  public:
119   static address verify_fpu_cntrl_wrd_entry() { return _verify_fpu_cntrl_wrd_entry; }
120   static address d2i_wrapper()                { return _d2i_wrapper; }
121   static address d2l_wrapper()                { return _d2l_wrapper; }
122   static address addr_fpu_cntrl_wrd_std()     { return (address)&_fpu_cntrl_wrd_std;   }
123   static address addr_fpu_cntrl_wrd_24()      { return (address)&_fpu_cntrl_wrd_24;    }
124   static address addr_fpu_cntrl_wrd_trunc()   { return (address)&_fpu_cntrl_wrd_trunc; }
125   static address addr_fpu_subnormal_bias1()   { return (address)&_fpu_subnormal_bias1; }
126   static address addr_fpu_subnormal_bias2()   { return (address)&_fpu_subnormal_bias2; }
127 
128   static jint    fpu_cntrl_wrd_std()          { return _fpu_cntrl_wrd_std; }
129 #endif // !LP64
130 
131  private:
132   static jint    _mxcsr_std;
133 #ifdef _LP64
134   static jint    _mxcsr_rz;
135 #endif // _LP64
136 
137   static address _verify_mxcsr_entry;
138 
139   // masks and table for CRC32
140   static const uint64_t _crc_by128_masks[];
141   static const juint    _crc_table[];
142 #ifdef _LP64
143   static const juint    _crc_by128_masks_avx512[];
144   static const juint    _crc_table_avx512[];
145   static const juint    _crc32c_table_avx512[];
146   static const juint    _shuf_table_crc32_avx512[];
147 #endif // _LP64
148   // table for CRC32C
149   static juint* _crc32c_table;
150   // table for arrays_hashcode
151   static const jint _arrays_hashcode_powers_of_31[];
152 
153   // upper word mask for sha1
154   static address _upper_word_mask_addr;
155   // byte flip mask for sha1
156   static address _shuffle_byte_flip_mask_addr;
157 
158   //k256 table for sha256
159   static const juint _k256[];
160   static address _k256_adr;
161   static address _vector_short_to_byte_mask;
162   static address _vector_float_sign_mask;
163   static address _vector_float_sign_flip;
164   static address _vector_double_sign_mask;
165   static address _vector_double_sign_flip;
166   static address _vector_long_sign_mask;
167   static address _vector_all_bits_set;
168   static address _vector_int_mask_cmp_bits;
169   static address _vector_byte_perm_mask;
170   static address _vector_int_to_byte_mask;
171   static address _vector_int_to_short_mask;
172   static address _vector_32_bit_mask;
173   static address _vector_64_bit_mask;
174   static address _vector_int_shuffle_mask;
175   static address _vector_byte_shuffle_mask;
176   static address _vector_short_shuffle_mask;
177   static address _vector_long_shuffle_mask;
178   static address _vector_iota_indices;
179   static address _vector_popcount_lut;
180   static address _vector_count_leading_zeros_lut;
181   static address _vector_reverse_bit_lut;
182   static address _vector_reverse_byte_perm_mask_long;
183   static address _vector_reverse_byte_perm_mask_int;
184   static address _vector_reverse_byte_perm_mask_short;
185 #ifdef _LP64
186   static juint _k256_W[];
187   static address _k256_W_adr;
188   static const julong _k512_W[];
189   static address _k512_W_addr;
190   // byte flip mask for sha512
191   static address _pshuffle_byte_flip_mask_addr_sha512;
192   // Masks for base64
193   static address _encoding_table_base64;
194   static address _shuffle_base64;
195   static address _avx2_shuffle_base64;
196   static address _avx2_input_mask_base64;
197   static address _avx2_lut_base64;
198   static address _avx2_decode_tables_base64;
199   static address _avx2_decode_lut_tables_base64;
200   static address _lookup_lo_base64;
201   static address _lookup_hi_base64;
202   static address _lookup_lo_base64url;
203   static address _lookup_hi_base64url;
204   static address _pack_vec_base64;
205   static address _join_0_1_base64;
206   static address _join_1_2_base64;
207   static address _join_2_3_base64;
208   static address _decoding_table_base64;
209 #endif
210   // byte flip mask for sha256
211   static address _pshuffle_byte_flip_mask_addr;
212 
213  public:
214   static address addr_mxcsr_std()        { return (address)&_mxcsr_std; }
215 #ifdef _LP64
216   static address addr_mxcsr_rz()        { return (address)&_mxcsr_rz; }
217 #endif // _LP64
218   static address verify_mxcsr_entry()    { return _verify_mxcsr_entry; }
219   static address crc_by128_masks_addr()  { return (address)_crc_by128_masks; }
220 #ifdef _LP64
221   static address crc_by128_masks_avx512_addr()  { return (address)_crc_by128_masks_avx512; }
222   static address shuf_table_crc32_avx512_addr()  { return (address)_shuf_table_crc32_avx512; }
223   static address crc_table_avx512_addr()  { return (address)_crc_table_avx512; }
224   static address crc32c_table_avx512_addr()  { return (address)_crc32c_table_avx512; }
225 #endif // _LP64
226   static address upper_word_mask_addr() { return _upper_word_mask_addr; }
227   static address shuffle_byte_flip_mask_addr() { return _shuffle_byte_flip_mask_addr; }
228   static address k256_addr()      { return _k256_adr; }
229   static address method_entry_barrier() { return _method_entry_barrier; }
230 
231   static address vector_short_to_byte_mask() {
232     return _vector_short_to_byte_mask;
233   }
234   static address vector_float_sign_mask() {
235     return _vector_float_sign_mask;
236   }
237 
238   static address vector_float_sign_flip() {
239     return _vector_float_sign_flip;
240   }
241 
242   static address vector_double_sign_mask() {
243     return _vector_double_sign_mask;
244   }
245 
246   static address vector_double_sign_flip() {
247     return _vector_double_sign_flip;
248   }
249 
250   static address vector_all_bits_set() {
251     return _vector_all_bits_set;
252   }
253 
254   static address vector_int_mask_cmp_bits() {
255     return _vector_int_mask_cmp_bits;
256   }
257 
258   static address vector_byte_perm_mask() {
259     return _vector_byte_perm_mask;
260   }
261 
262   static address vector_int_to_byte_mask() {
263     return _vector_int_to_byte_mask;
264   }
265 
266   static address vector_int_to_short_mask() {
267     return _vector_int_to_short_mask;
268   }
269 
270   static address vector_32_bit_mask() {
271     return _vector_32_bit_mask;
272   }
273 
274   static address vector_64_bit_mask() {
275     return _vector_64_bit_mask;
276   }
277 
278   static address vector_int_shuffle_mask() {
279     return _vector_int_shuffle_mask;
280   }
281 
282   static address vector_byte_shuffle_mask() {
283     return _vector_byte_shuffle_mask;
284   }
285 
286   static address vector_short_shuffle_mask() {
287     return _vector_short_shuffle_mask;
288   }
289 
290   static address vector_long_shuffle_mask() {
291     return _vector_long_shuffle_mask;
292   }
293 
294   static address vector_long_sign_mask() {
295     return _vector_long_sign_mask;
296   }
297 
298   static address vector_iota_indices() {
299     return _vector_iota_indices;
300   }
301 
302   static address vector_count_leading_zeros_lut() {
303     return _vector_count_leading_zeros_lut;
304   }
305 
306   static address vector_reverse_bit_lut() {
307     return _vector_reverse_bit_lut;
308   }
309 
310   static address vector_reverse_byte_perm_mask_long() {
311     return _vector_reverse_byte_perm_mask_long;
312   }
313 
314   static address vector_reverse_byte_perm_mask_int() {
315     return _vector_reverse_byte_perm_mask_int;
316   }
317 
318   static address vector_reverse_byte_perm_mask_short() {
319     return _vector_reverse_byte_perm_mask_short;
320   }
321 
322   static address vector_popcount_lut() {
323     return _vector_popcount_lut;
324   }
325 #ifdef _LP64
326   static address k256_W_addr()    { return _k256_W_adr; }
327   static address k512_W_addr()    { return _k512_W_addr; }
328   static address pshuffle_byte_flip_mask_addr_sha512() { return _pshuffle_byte_flip_mask_addr_sha512; }
329   static address base64_encoding_table_addr() { return _encoding_table_base64; }
330   static address base64_shuffle_addr() { return _shuffle_base64; }
331   static address base64_avx2_shuffle_addr() { return _avx2_shuffle_base64; }
332   static address base64_avx2_input_mask_addr() { return _avx2_input_mask_base64; }
333   static address base64_avx2_lut_addr() { return _avx2_lut_base64; }
334   static address base64_vbmi_lookup_lo_addr() { return _lookup_lo_base64; }
335   static address base64_vbmi_lookup_hi_addr() { return _lookup_hi_base64; }
336   static address base64_vbmi_lookup_lo_url_addr() { return _lookup_lo_base64url; }
337   static address base64_vbmi_lookup_hi_url_addr() { return _lookup_hi_base64url; }
338   static address base64_vbmi_pack_vec_addr() { return _pack_vec_base64; }
339   static address base64_vbmi_join_0_1_addr() { return _join_0_1_base64; }
340   static address base64_vbmi_join_1_2_addr() { return _join_1_2_base64; }
341   static address base64_vbmi_join_2_3_addr() { return _join_2_3_base64; }
342   static address base64_decoding_table_addr() { return _decoding_table_base64; }
343   static address base64_AVX2_decode_tables_addr() { return _avx2_decode_tables_base64; }
344   static address base64_AVX2_decode_LUT_tables_addr() { return _avx2_decode_lut_tables_base64; }
345   static address compress_perm_table32() { return _compress_perm_table32; }
346   static address compress_perm_table64() { return _compress_perm_table64; }
347   static address expand_perm_table32() { return _expand_perm_table32; }
348   static address expand_perm_table64() { return _expand_perm_table64; }
349 #endif
350   static address pshuffle_byte_flip_mask_addr() { return _pshuffle_byte_flip_mask_addr; }
351   static address arrays_hashcode_powers_of_31() { return (address)_arrays_hashcode_powers_of_31; }
352   static void generate_CRC32C_table(bool is_pclmulqdq_supported);
353 };
354 
355 #endif // CPU_X86_STUBROUTINES_X86_HPP