]>
Commit | Line | Data |
---|---|---|
5c39f954 PMD |
1 | /* |
2 | * Helpers for HPPA FPU instructions. | |
3 | * | |
4 | * Copyright (c) 2016 Richard Henderson <rth@twiddle.net> | |
5 | * | |
6 | * This library is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2.1 of the License, or (at your option) any later version. | |
10 | * | |
11 | * This library is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | ||
20 | #include "qemu/osdep.h" | |
21 | #include "cpu.h" | |
22 | #include "exec/exec-all.h" | |
23 | #include "exec/helper-proto.h" | |
24 | #include "fpu/softfloat.h" | |
25 | ||
26 | void HELPER(loaded_fr0)(CPUHPPAState *env) | |
27 | { | |
28 | uint32_t shadow = env->fr[0] >> 32; | |
29 | int rm, d; | |
30 | ||
31 | env->fr0_shadow = shadow; | |
32 | ||
33 | switch (extract32(shadow, 9, 2)) { | |
34 | default: | |
35 | rm = float_round_nearest_even; | |
36 | break; | |
37 | case 1: | |
38 | rm = float_round_to_zero; | |
39 | break; | |
40 | case 2: | |
41 | rm = float_round_up; | |
42 | break; | |
43 | case 3: | |
44 | rm = float_round_down; | |
45 | break; | |
46 | } | |
47 | set_float_rounding_mode(rm, &env->fp_status); | |
48 | ||
49 | d = extract32(shadow, 5, 1); | |
50 | set_flush_to_zero(d, &env->fp_status); | |
51 | set_flush_inputs_to_zero(d, &env->fp_status); | |
52 | } | |
53 | ||
54 | void cpu_hppa_loaded_fr0(CPUHPPAState *env) | |
55 | { | |
56 | helper_loaded_fr0(env); | |
57 | } | |
58 | ||
59 | #define CONVERT_BIT(X, SRC, DST) \ | |
60 | ((SRC) > (DST) \ | |
61 | ? (X) / ((SRC) / (DST)) & (DST) \ | |
62 | : ((X) & (SRC)) * ((DST) / (SRC))) | |
63 | ||
64 | static void update_fr0_op(CPUHPPAState *env, uintptr_t ra) | |
65 | { | |
66 | uint32_t soft_exp = get_float_exception_flags(&env->fp_status); | |
67 | uint32_t hard_exp = 0; | |
68 | uint32_t shadow = env->fr0_shadow; | |
69 | ||
70 | if (likely(soft_exp == 0)) { | |
71 | env->fr[0] = (uint64_t)shadow << 32; | |
72 | return; | |
73 | } | |
74 | set_float_exception_flags(0, &env->fp_status); | |
75 | ||
76 | hard_exp |= CONVERT_BIT(soft_exp, float_flag_inexact, 1u << 0); | |
77 | hard_exp |= CONVERT_BIT(soft_exp, float_flag_underflow, 1u << 1); | |
78 | hard_exp |= CONVERT_BIT(soft_exp, float_flag_overflow, 1u << 2); | |
79 | hard_exp |= CONVERT_BIT(soft_exp, float_flag_divbyzero, 1u << 3); | |
80 | hard_exp |= CONVERT_BIT(soft_exp, float_flag_invalid, 1u << 4); | |
81 | shadow |= hard_exp << (32 - 5); | |
82 | env->fr0_shadow = shadow; | |
83 | env->fr[0] = (uint64_t)shadow << 32; | |
84 | ||
85 | if (hard_exp & shadow) { | |
86 | hppa_dynamic_excp(env, EXCP_ASSIST, ra); | |
87 | } | |
88 | } | |
89 | ||
90 | float32 HELPER(fsqrt_s)(CPUHPPAState *env, float32 arg) | |
91 | { | |
92 | float32 ret = float32_sqrt(arg, &env->fp_status); | |
93 | update_fr0_op(env, GETPC()); | |
94 | return ret; | |
95 | } | |
96 | ||
97 | float32 HELPER(frnd_s)(CPUHPPAState *env, float32 arg) | |
98 | { | |
99 | float32 ret = float32_round_to_int(arg, &env->fp_status); | |
100 | update_fr0_op(env, GETPC()); | |
101 | return ret; | |
102 | } | |
103 | ||
104 | float32 HELPER(fadd_s)(CPUHPPAState *env, float32 a, float32 b) | |
105 | { | |
106 | float32 ret = float32_add(a, b, &env->fp_status); | |
107 | update_fr0_op(env, GETPC()); | |
108 | return ret; | |
109 | } | |
110 | ||
111 | float32 HELPER(fsub_s)(CPUHPPAState *env, float32 a, float32 b) | |
112 | { | |
113 | float32 ret = float32_sub(a, b, &env->fp_status); | |
114 | update_fr0_op(env, GETPC()); | |
115 | return ret; | |
116 | } | |
117 | ||
118 | float32 HELPER(fmpy_s)(CPUHPPAState *env, float32 a, float32 b) | |
119 | { | |
120 | float32 ret = float32_mul(a, b, &env->fp_status); | |
121 | update_fr0_op(env, GETPC()); | |
122 | return ret; | |
123 | } | |
124 | ||
125 | float32 HELPER(fdiv_s)(CPUHPPAState *env, float32 a, float32 b) | |
126 | { | |
127 | float32 ret = float32_div(a, b, &env->fp_status); | |
128 | update_fr0_op(env, GETPC()); | |
129 | return ret; | |
130 | } | |
131 | ||
132 | float64 HELPER(fsqrt_d)(CPUHPPAState *env, float64 arg) | |
133 | { | |
134 | float64 ret = float64_sqrt(arg, &env->fp_status); | |
135 | update_fr0_op(env, GETPC()); | |
136 | return ret; | |
137 | } | |
138 | ||
139 | float64 HELPER(frnd_d)(CPUHPPAState *env, float64 arg) | |
140 | { | |
141 | float64 ret = float64_round_to_int(arg, &env->fp_status); | |
142 | update_fr0_op(env, GETPC()); | |
143 | return ret; | |
144 | } | |
145 | ||
146 | float64 HELPER(fadd_d)(CPUHPPAState *env, float64 a, float64 b) | |
147 | { | |
148 | float64 ret = float64_add(a, b, &env->fp_status); | |
149 | update_fr0_op(env, GETPC()); | |
150 | return ret; | |
151 | } | |
152 | ||
153 | float64 HELPER(fsub_d)(CPUHPPAState *env, float64 a, float64 b) | |
154 | { | |
155 | float64 ret = float64_sub(a, b, &env->fp_status); | |
156 | update_fr0_op(env, GETPC()); | |
157 | return ret; | |
158 | } | |
159 | ||
160 | float64 HELPER(fmpy_d)(CPUHPPAState *env, float64 a, float64 b) | |
161 | { | |
162 | float64 ret = float64_mul(a, b, &env->fp_status); | |
163 | update_fr0_op(env, GETPC()); | |
164 | return ret; | |
165 | } | |
166 | ||
167 | float64 HELPER(fdiv_d)(CPUHPPAState *env, float64 a, float64 b) | |
168 | { | |
169 | float64 ret = float64_div(a, b, &env->fp_status); | |
170 | update_fr0_op(env, GETPC()); | |
171 | return ret; | |
172 | } | |
173 | ||
174 | float64 HELPER(fcnv_s_d)(CPUHPPAState *env, float32 arg) | |
175 | { | |
176 | float64 ret = float32_to_float64(arg, &env->fp_status); | |
177 | update_fr0_op(env, GETPC()); | |
178 | return ret; | |
179 | } | |
180 | ||
181 | float32 HELPER(fcnv_d_s)(CPUHPPAState *env, float64 arg) | |
182 | { | |
183 | float32 ret = float64_to_float32(arg, &env->fp_status); | |
184 | update_fr0_op(env, GETPC()); | |
185 | return ret; | |
186 | } | |
187 | ||
188 | float32 HELPER(fcnv_w_s)(CPUHPPAState *env, int32_t arg) | |
189 | { | |
190 | float32 ret = int32_to_float32(arg, &env->fp_status); | |
191 | update_fr0_op(env, GETPC()); | |
192 | return ret; | |
193 | } | |
194 | ||
195 | float32 HELPER(fcnv_dw_s)(CPUHPPAState *env, int64_t arg) | |
196 | { | |
197 | float32 ret = int64_to_float32(arg, &env->fp_status); | |
198 | update_fr0_op(env, GETPC()); | |
199 | return ret; | |
200 | } | |
201 | ||
202 | float64 HELPER(fcnv_w_d)(CPUHPPAState *env, int32_t arg) | |
203 | { | |
204 | float64 ret = int32_to_float64(arg, &env->fp_status); | |
205 | update_fr0_op(env, GETPC()); | |
206 | return ret; | |
207 | } | |
208 | ||
209 | float64 HELPER(fcnv_dw_d)(CPUHPPAState *env, int64_t arg) | |
210 | { | |
211 | float64 ret = int64_to_float64(arg, &env->fp_status); | |
212 | update_fr0_op(env, GETPC()); | |
213 | return ret; | |
214 | } | |
215 | ||
216 | int32_t HELPER(fcnv_s_w)(CPUHPPAState *env, float32 arg) | |
217 | { | |
218 | int32_t ret = float32_to_int32(arg, &env->fp_status); | |
219 | update_fr0_op(env, GETPC()); | |
220 | return ret; | |
221 | } | |
222 | ||
223 | int32_t HELPER(fcnv_d_w)(CPUHPPAState *env, float64 arg) | |
224 | { | |
225 | int32_t ret = float64_to_int32(arg, &env->fp_status); | |
226 | update_fr0_op(env, GETPC()); | |
227 | return ret; | |
228 | } | |
229 | ||
230 | int64_t HELPER(fcnv_s_dw)(CPUHPPAState *env, float32 arg) | |
231 | { | |
232 | int64_t ret = float32_to_int64(arg, &env->fp_status); | |
233 | update_fr0_op(env, GETPC()); | |
234 | return ret; | |
235 | } | |
236 | ||
237 | int64_t HELPER(fcnv_d_dw)(CPUHPPAState *env, float64 arg) | |
238 | { | |
239 | int64_t ret = float64_to_int64(arg, &env->fp_status); | |
240 | update_fr0_op(env, GETPC()); | |
241 | return ret; | |
242 | } | |
243 | ||
244 | int32_t HELPER(fcnv_t_s_w)(CPUHPPAState *env, float32 arg) | |
245 | { | |
246 | int32_t ret = float32_to_int32_round_to_zero(arg, &env->fp_status); | |
247 | update_fr0_op(env, GETPC()); | |
248 | return ret; | |
249 | } | |
250 | ||
251 | int32_t HELPER(fcnv_t_d_w)(CPUHPPAState *env, float64 arg) | |
252 | { | |
253 | int32_t ret = float64_to_int32_round_to_zero(arg, &env->fp_status); | |
254 | update_fr0_op(env, GETPC()); | |
255 | return ret; | |
256 | } | |
257 | ||
258 | int64_t HELPER(fcnv_t_s_dw)(CPUHPPAState *env, float32 arg) | |
259 | { | |
260 | int64_t ret = float32_to_int64_round_to_zero(arg, &env->fp_status); | |
261 | update_fr0_op(env, GETPC()); | |
262 | return ret; | |
263 | } | |
264 | ||
265 | int64_t HELPER(fcnv_t_d_dw)(CPUHPPAState *env, float64 arg) | |
266 | { | |
267 | int64_t ret = float64_to_int64_round_to_zero(arg, &env->fp_status); | |
268 | update_fr0_op(env, GETPC()); | |
269 | return ret; | |
270 | } | |
271 | ||
272 | float32 HELPER(fcnv_uw_s)(CPUHPPAState *env, uint32_t arg) | |
273 | { | |
274 | float32 ret = uint32_to_float32(arg, &env->fp_status); | |
275 | update_fr0_op(env, GETPC()); | |
276 | return ret; | |
277 | } | |
278 | ||
279 | float32 HELPER(fcnv_udw_s)(CPUHPPAState *env, uint64_t arg) | |
280 | { | |
281 | float32 ret = uint64_to_float32(arg, &env->fp_status); | |
282 | update_fr0_op(env, GETPC()); | |
283 | return ret; | |
284 | } | |
285 | ||
286 | float64 HELPER(fcnv_uw_d)(CPUHPPAState *env, uint32_t arg) | |
287 | { | |
288 | float64 ret = uint32_to_float64(arg, &env->fp_status); | |
289 | update_fr0_op(env, GETPC()); | |
290 | return ret; | |
291 | } | |
292 | ||
293 | float64 HELPER(fcnv_udw_d)(CPUHPPAState *env, uint64_t arg) | |
294 | { | |
295 | float64 ret = uint64_to_float64(arg, &env->fp_status); | |
296 | update_fr0_op(env, GETPC()); | |
297 | return ret; | |
298 | } | |
299 | ||
300 | uint32_t HELPER(fcnv_s_uw)(CPUHPPAState *env, float32 arg) | |
301 | { | |
302 | uint32_t ret = float32_to_uint32(arg, &env->fp_status); | |
303 | update_fr0_op(env, GETPC()); | |
304 | return ret; | |
305 | } | |
306 | ||
307 | uint32_t HELPER(fcnv_d_uw)(CPUHPPAState *env, float64 arg) | |
308 | { | |
309 | uint32_t ret = float64_to_uint32(arg, &env->fp_status); | |
310 | update_fr0_op(env, GETPC()); | |
311 | return ret; | |
312 | } | |
313 | ||
314 | uint64_t HELPER(fcnv_s_udw)(CPUHPPAState *env, float32 arg) | |
315 | { | |
316 | uint64_t ret = float32_to_uint64(arg, &env->fp_status); | |
317 | update_fr0_op(env, GETPC()); | |
318 | return ret; | |
319 | } | |
320 | ||
321 | uint64_t HELPER(fcnv_d_udw)(CPUHPPAState *env, float64 arg) | |
322 | { | |
323 | uint64_t ret = float64_to_uint64(arg, &env->fp_status); | |
324 | update_fr0_op(env, GETPC()); | |
325 | return ret; | |
326 | } | |
327 | ||
328 | uint32_t HELPER(fcnv_t_s_uw)(CPUHPPAState *env, float32 arg) | |
329 | { | |
330 | uint32_t ret = float32_to_uint32_round_to_zero(arg, &env->fp_status); | |
331 | update_fr0_op(env, GETPC()); | |
332 | return ret; | |
333 | } | |
334 | ||
335 | uint32_t HELPER(fcnv_t_d_uw)(CPUHPPAState *env, float64 arg) | |
336 | { | |
337 | uint32_t ret = float64_to_uint32_round_to_zero(arg, &env->fp_status); | |
338 | update_fr0_op(env, GETPC()); | |
339 | return ret; | |
340 | } | |
341 | ||
342 | uint64_t HELPER(fcnv_t_s_udw)(CPUHPPAState *env, float32 arg) | |
343 | { | |
344 | uint64_t ret = float32_to_uint64_round_to_zero(arg, &env->fp_status); | |
345 | update_fr0_op(env, GETPC()); | |
346 | return ret; | |
347 | } | |
348 | ||
349 | uint64_t HELPER(fcnv_t_d_udw)(CPUHPPAState *env, float64 arg) | |
350 | { | |
351 | uint64_t ret = float64_to_uint64_round_to_zero(arg, &env->fp_status); | |
352 | update_fr0_op(env, GETPC()); | |
353 | return ret; | |
354 | } | |
355 | ||
356 | static void update_fr0_cmp(CPUHPPAState *env, uint32_t y, | |
357 | uint32_t c, FloatRelation r) | |
358 | { | |
359 | uint32_t shadow = env->fr0_shadow; | |
360 | ||
361 | switch (r) { | |
362 | case float_relation_greater: | |
363 | c = extract32(c, 4, 1); | |
364 | break; | |
365 | case float_relation_less: | |
366 | c = extract32(c, 3, 1); | |
367 | break; | |
368 | case float_relation_equal: | |
369 | c = extract32(c, 2, 1); | |
370 | break; | |
371 | case float_relation_unordered: | |
372 | c = extract32(c, 1, 1); | |
373 | break; | |
374 | default: | |
375 | g_assert_not_reached(); | |
376 | } | |
377 | ||
378 | if (y) { | |
379 | /* targeted comparison */ | |
380 | /* set fpsr[ca[y - 1]] to current compare */ | |
381 | shadow = deposit32(shadow, 21 - (y - 1), 1, c); | |
382 | } else { | |
383 | /* queued comparison */ | |
384 | /* shift cq right by one place */ | |
385 | shadow = deposit32(shadow, 11, 10, extract32(shadow, 12, 10)); | |
386 | /* move fpsr[c] to fpsr[cq[0]] */ | |
387 | shadow = deposit32(shadow, 21, 1, extract32(shadow, 26, 1)); | |
388 | /* set fpsr[c] to current compare */ | |
389 | shadow = deposit32(shadow, 26, 1, c); | |
390 | } | |
391 | ||
392 | env->fr0_shadow = shadow; | |
393 | env->fr[0] = (uint64_t)shadow << 32; | |
394 | } | |
395 | ||
396 | void HELPER(fcmp_s)(CPUHPPAState *env, float32 a, float32 b, | |
397 | uint32_t y, uint32_t c) | |
398 | { | |
399 | FloatRelation r; | |
400 | if (c & 1) { | |
401 | r = float32_compare(a, b, &env->fp_status); | |
402 | } else { | |
403 | r = float32_compare_quiet(a, b, &env->fp_status); | |
404 | } | |
405 | update_fr0_op(env, GETPC()); | |
406 | update_fr0_cmp(env, y, c, r); | |
407 | } | |
408 | ||
409 | void HELPER(fcmp_d)(CPUHPPAState *env, float64 a, float64 b, | |
410 | uint32_t y, uint32_t c) | |
411 | { | |
412 | FloatRelation r; | |
413 | if (c & 1) { | |
414 | r = float64_compare(a, b, &env->fp_status); | |
415 | } else { | |
416 | r = float64_compare_quiet(a, b, &env->fp_status); | |
417 | } | |
418 | update_fr0_op(env, GETPC()); | |
419 | update_fr0_cmp(env, y, c, r); | |
420 | } | |
421 | ||
422 | float32 HELPER(fmpyfadd_s)(CPUHPPAState *env, float32 a, float32 b, float32 c) | |
423 | { | |
424 | float32 ret = float32_muladd(a, b, c, 0, &env->fp_status); | |
425 | update_fr0_op(env, GETPC()); | |
426 | return ret; | |
427 | } | |
428 | ||
429 | float32 HELPER(fmpynfadd_s)(CPUHPPAState *env, float32 a, float32 b, float32 c) | |
430 | { | |
431 | float32 ret = float32_muladd(a, b, c, float_muladd_negate_product, | |
432 | &env->fp_status); | |
433 | update_fr0_op(env, GETPC()); | |
434 | return ret; | |
435 | } | |
436 | ||
437 | float64 HELPER(fmpyfadd_d)(CPUHPPAState *env, float64 a, float64 b, float64 c) | |
438 | { | |
439 | float64 ret = float64_muladd(a, b, c, 0, &env->fp_status); | |
440 | update_fr0_op(env, GETPC()); | |
441 | return ret; | |
442 | } | |
443 | ||
444 | float64 HELPER(fmpynfadd_d)(CPUHPPAState *env, float64 a, float64 b, float64 c) | |
445 | { | |
446 | float64 ret = float64_muladd(a, b, c, float_muladd_negate_product, | |
447 | &env->fp_status); | |
448 | update_fr0_op(env, GETPC()); | |
449 | return ret; | |
450 | } |