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