@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 749 lines 21.4 KB
Raw
1 /*
2 * m68k FPU helpers
3 *
4 * Copyright (c) 2006-2007 CodeSourcery
5 * Written by Paul Brook
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "qemu/osdep.h"
22 #include "cpu.h"
23 #include "exec/helper-proto.h"
24 #include "accel/tcg/cpu-ldst.h"
25 #include "softfloat.h"
26
27 /*
28 * Undefined offsets may be different on various FPU.
29 * On 68040 they return 0.0 (floatx80_zero)
30 */
31
32 static const floatx80 fpu_rom[128] = {
33 [0x00] = make_floatx80_init(0x4000, 0xc90fdaa22168c235ULL), /* Pi */
34 [0x0b] = make_floatx80_init(0x3ffd, 0x9a209a84fbcff798ULL), /* Log10(2) */
35 [0x0c] = make_floatx80_init(0x4000, 0xadf85458a2bb4a9aULL), /* e */
36 [0x0d] = make_floatx80_init(0x3fff, 0xb8aa3b295c17f0bcULL), /* Log2(e) */
37 [0x0e] = make_floatx80_init(0x3ffd, 0xde5bd8a937287195ULL), /* Log10(e) */
38 [0x0f] = make_floatx80_init(0x0000, 0x0000000000000000ULL), /* Zero */
39 [0x30] = make_floatx80_init(0x3ffe, 0xb17217f7d1cf79acULL), /* ln(2) */
40 [0x31] = make_floatx80_init(0x4000, 0x935d8dddaaa8ac17ULL), /* ln(10) */
41 [0x32] = make_floatx80_init(0x3fff, 0x8000000000000000ULL), /* 10^0 */
42 [0x33] = make_floatx80_init(0x4002, 0xa000000000000000ULL), /* 10^1 */
43 [0x34] = make_floatx80_init(0x4005, 0xc800000000000000ULL), /* 10^2 */
44 [0x35] = make_floatx80_init(0x400c, 0x9c40000000000000ULL), /* 10^4 */
45 [0x36] = make_floatx80_init(0x4019, 0xbebc200000000000ULL), /* 10^8 */
46 [0x37] = make_floatx80_init(0x4034, 0x8e1bc9bf04000000ULL), /* 10^16 */
47 [0x38] = make_floatx80_init(0x4069, 0x9dc5ada82b70b59eULL), /* 10^32 */
48 [0x39] = make_floatx80_init(0x40d3, 0xc2781f49ffcfa6d5ULL), /* 10^64 */
49 [0x3a] = make_floatx80_init(0x41a8, 0x93ba47c980e98ce0ULL), /* 10^128 */
50 [0x3b] = make_floatx80_init(0x4351, 0xaa7eebfb9df9de8eULL), /* 10^256 */
51 [0x3c] = make_floatx80_init(0x46a3, 0xe319a0aea60e91c7ULL), /* 10^512 */
52 [0x3d] = make_floatx80_init(0x4d48, 0xc976758681750c17ULL), /* 10^1024 */
53 [0x3e] = make_floatx80_init(0x5a92, 0x9e8b3b5dc53d5de5ULL), /* 10^2048 */
54 [0x3f] = make_floatx80_init(0x7525, 0xc46052028a20979bULL), /* 10^4096 */
55 };
56
57 int32_t HELPER(reds32)(CPUM68KState *env, FPReg *val)
58 {
59 return floatx80_to_int32(val->d, &env->fp_status);
60 }
61
62 float32 HELPER(redf32)(CPUM68KState *env, FPReg *val)
63 {
64 return floatx80_to_float32(val->d, &env->fp_status);
65 }
66
67 void HELPER(exts32)(CPUM68KState *env, FPReg *res, int32_t val)
68 {
69 res->d = int32_to_floatx80(val, &env->fp_status);
70 }
71
72 void HELPER(extf32)(CPUM68KState *env, FPReg *res, float32 val)
73 {
74 res->d = float32_to_floatx80(val, &env->fp_status);
75 }
76
77 void HELPER(extf64)(CPUM68KState *env, FPReg *res, float64 val)
78 {
79 res->d = float64_to_floatx80(val, &env->fp_status);
80 }
81
82 float64 HELPER(redf64)(CPUM68KState *env, FPReg *val)
83 {
84 return floatx80_to_float64(val->d, &env->fp_status);
85 }
86
87 void HELPER(firound)(CPUM68KState *env, FPReg *res, FPReg *val)
88 {
89 res->d = floatx80_round_to_int(val->d, &env->fp_status);
90 }
91
92 static void m68k_restore_precision_mode(CPUM68KState *env)
93 {
94 switch (env->fpcr & FPCR_PREC_MASK) {
95 case FPCR_PREC_X: /* extended */
96 set_floatx80_rounding_precision(floatx80_precision_x, &env->fp_status);
97 break;
98 case FPCR_PREC_S: /* single */
99 set_floatx80_rounding_precision(floatx80_precision_s, &env->fp_status);
100 break;
101 case FPCR_PREC_D: /* double */
102 set_floatx80_rounding_precision(floatx80_precision_d, &env->fp_status);
103 break;
104 case FPCR_PREC_U: /* undefined */
105 default:
106 break;
107 }
108 }
109
110 static void cf_restore_precision_mode(CPUM68KState *env)
111 {
112 if (env->fpcr & FPCR_PREC_S) { /* single */
113 set_floatx80_rounding_precision(floatx80_precision_s, &env->fp_status);
114 } else { /* double */
115 set_floatx80_rounding_precision(floatx80_precision_d, &env->fp_status);
116 }
117 }
118
119 static void restore_rounding_mode(CPUM68KState *env)
120 {
121 switch (env->fpcr & FPCR_RND_MASK) {
122 case FPCR_RND_N: /* round to nearest */
123 set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
124 break;
125 case FPCR_RND_Z: /* round to zero */
126 set_float_rounding_mode(float_round_to_zero, &env->fp_status);
127 break;
128 case FPCR_RND_M: /* round toward minus infinity */
129 set_float_rounding_mode(float_round_down, &env->fp_status);
130 break;
131 case FPCR_RND_P: /* round toward positive infinity */
132 set_float_rounding_mode(float_round_up, &env->fp_status);
133 break;
134 }
135 }
136
137 void cpu_m68k_restore_fp_status(CPUM68KState *env)
138 {
139 if (m68k_feature(env, M68K_FEATURE_CF_FPU)) {
140 cf_restore_precision_mode(env);
141 } else {
142 m68k_restore_precision_mode(env);
143 }
144 restore_rounding_mode(env);
145 }
146
147 void cpu_m68k_set_fpcr(CPUM68KState *env, uint32_t val)
148 {
149 env->fpcr = val & 0xffff;
150 cpu_m68k_restore_fp_status(env);
151 }
152
153 void HELPER(fitrunc)(CPUM68KState *env, FPReg *res, FPReg *val)
154 {
155 FloatRoundMode rounding_mode = get_float_rounding_mode(&env->fp_status);
156 set_float_rounding_mode(float_round_to_zero, &env->fp_status);
157 res->d = floatx80_round_to_int(val->d, &env->fp_status);
158 set_float_rounding_mode(rounding_mode, &env->fp_status);
159 }
160
161 void HELPER(set_fpcr)(CPUM68KState *env, uint32_t val)
162 {
163 cpu_m68k_set_fpcr(env, val);
164 }
165
166 /* Convert host exception flags to cpu_m68k form. */
167 static int cpu_m68k_exceptbits_from_host(int host_bits)
168 {
169 int target_bits = 0;
170
171 if (host_bits & float_flag_invalid) {
172 target_bits |= 0x80;
173 }
174 if (host_bits & float_flag_overflow) {
175 target_bits |= 0x40;
176 }
177 if (host_bits & (float_flag_underflow | float_flag_output_denormal_flushed)) {
178 target_bits |= 0x20;
179 }
180 if (host_bits & float_flag_divbyzero) {
181 target_bits |= 0x10;
182 }
183 if (host_bits & float_flag_inexact) {
184 target_bits |= 0x08;
185 }
186 return target_bits;
187 }
188
189 /* Convert cpu_m68k exception flags to target form. */
190 static int cpu_m68k_exceptbits_to_host(int target_bits)
191 {
192 int host_bits = 0;
193
194 if (target_bits & 0x80) {
195 host_bits |= float_flag_invalid;
196 }
197 if (target_bits & 0x40) {
198 host_bits |= float_flag_overflow;
199 }
200 if (target_bits & 0x20) {
201 host_bits |= float_flag_underflow;
202 }
203 if (target_bits & 0x10) {
204 host_bits |= float_flag_divbyzero;
205 }
206 if (target_bits & 0x08) {
207 host_bits |= float_flag_inexact;
208 }
209 return host_bits;
210 }
211
212 uint32_t cpu_m68k_get_fpsr(CPUM68KState *env)
213 {
214 int host_flags = get_float_exception_flags(&env->fp_status);
215 int target_flags = cpu_m68k_exceptbits_from_host(host_flags);
216 int except = (env->fpsr & ~(0xf8)) | target_flags;
217 return except;
218 }
219
220 uint32_t HELPER(get_fpsr)(CPUM68KState *env)
221 {
222 return cpu_m68k_get_fpsr(env);
223 }
224
225 void cpu_m68k_set_fpsr(CPUM68KState *env, uint32_t val)
226 {
227 env->fpsr = val;
228
229 int host_flags = cpu_m68k_exceptbits_to_host((int) env->fpsr);
230 set_float_exception_flags(host_flags, &env->fp_status);
231 }
232
233 void HELPER(set_fpsr)(CPUM68KState *env, uint32_t val)
234 {
235 cpu_m68k_set_fpsr(env, val);
236 }
237
238 #define PREC_BEGIN(prec) \
239 do { \
240 FloatX80RoundPrec old = \
241 get_floatx80_rounding_precision(&env->fp_status); \
242 set_floatx80_rounding_precision(prec, &env->fp_status) \
243
244 #define PREC_END() \
245 set_floatx80_rounding_precision(old, &env->fp_status); \
246 } while (0)
247
248 void HELPER(fsround)(CPUM68KState *env, FPReg *res, FPReg *val)
249 {
250 PREC_BEGIN(floatx80_precision_s);
251 res->d = floatx80_round(val->d, &env->fp_status);
252 PREC_END();
253 }
254
255 void HELPER(fdround)(CPUM68KState *env, FPReg *res, FPReg *val)
256 {
257 PREC_BEGIN(floatx80_precision_d);
258 res->d = floatx80_round(val->d, &env->fp_status);
259 PREC_END();
260 }
261
262 void HELPER(fsqrt)(CPUM68KState *env, FPReg *res, FPReg *val)
263 {
264 res->d = floatx80_sqrt(val->d, &env->fp_status);
265 }
266
267 void HELPER(fssqrt)(CPUM68KState *env, FPReg *res, FPReg *val)
268 {
269 PREC_BEGIN(floatx80_precision_s);
270 res->d = floatx80_sqrt(val->d, &env->fp_status);
271 PREC_END();
272 }
273
274 void HELPER(fdsqrt)(CPUM68KState *env, FPReg *res, FPReg *val)
275 {
276 PREC_BEGIN(floatx80_precision_d);
277 res->d = floatx80_sqrt(val->d, &env->fp_status);
278 PREC_END();
279 }
280
281 void HELPER(fabs)(CPUM68KState *env, FPReg *res, FPReg *val)
282 {
283 res->d = floatx80_round(floatx80_abs(val->d), &env->fp_status);
284 }
285
286 void HELPER(fsabs)(CPUM68KState *env, FPReg *res, FPReg *val)
287 {
288 PREC_BEGIN(floatx80_precision_s);
289 res->d = floatx80_round(floatx80_abs(val->d), &env->fp_status);
290 PREC_END();
291 }
292
293 void HELPER(fdabs)(CPUM68KState *env, FPReg *res, FPReg *val)
294 {
295 PREC_BEGIN(floatx80_precision_d);
296 res->d = floatx80_round(floatx80_abs(val->d), &env->fp_status);
297 PREC_END();
298 }
299
300 void HELPER(fneg)(CPUM68KState *env, FPReg *res, FPReg *val)
301 {
302 res->d = floatx80_round(floatx80_chs(val->d), &env->fp_status);
303 }
304
305 void HELPER(fsneg)(CPUM68KState *env, FPReg *res, FPReg *val)
306 {
307 PREC_BEGIN(floatx80_precision_s);
308 res->d = floatx80_round(floatx80_chs(val->d), &env->fp_status);
309 PREC_END();
310 }
311
312 void HELPER(fdneg)(CPUM68KState *env, FPReg *res, FPReg *val)
313 {
314 PREC_BEGIN(floatx80_precision_d);
315 res->d = floatx80_round(floatx80_chs(val->d), &env->fp_status);
316 PREC_END();
317 }
318
319 void HELPER(fadd)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
320 {
321 res->d = floatx80_add(val0->d, val1->d, &env->fp_status);
322 }
323
324 void HELPER(fsadd)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
325 {
326 PREC_BEGIN(floatx80_precision_s);
327 res->d = floatx80_add(val0->d, val1->d, &env->fp_status);
328 PREC_END();
329 }
330
331 void HELPER(fdadd)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
332 {
333 PREC_BEGIN(floatx80_precision_d);
334 res->d = floatx80_add(val0->d, val1->d, &env->fp_status);
335 PREC_END();
336 }
337
338 void HELPER(fsub)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
339 {
340 res->d = floatx80_sub(val1->d, val0->d, &env->fp_status);
341 }
342
343 void HELPER(fssub)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
344 {
345 PREC_BEGIN(floatx80_precision_s);
346 res->d = floatx80_sub(val1->d, val0->d, &env->fp_status);
347 PREC_END();
348 }
349
350 void HELPER(fdsub)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
351 {
352 PREC_BEGIN(floatx80_precision_d);
353 res->d = floatx80_sub(val1->d, val0->d, &env->fp_status);
354 PREC_END();
355 }
356
357 void HELPER(fmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
358 {
359 res->d = floatx80_mul(val0->d, val1->d, &env->fp_status);
360 }
361
362 void HELPER(fsmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
363 {
364 PREC_BEGIN(floatx80_precision_s);
365 res->d = floatx80_mul(val0->d, val1->d, &env->fp_status);
366 PREC_END();
367 }
368
369 void HELPER(fdmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
370 {
371 PREC_BEGIN(floatx80_precision_d);
372 res->d = floatx80_mul(val0->d, val1->d, &env->fp_status);
373 PREC_END();
374 }
375
376 void HELPER(fsglmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
377 {
378 FloatRoundMode rounding_mode = get_float_rounding_mode(&env->fp_status);
379 floatx80 a, b;
380
381 PREC_BEGIN(floatx80_precision_s);
382 set_float_rounding_mode(float_round_to_zero, &env->fp_status);
383 a = floatx80_round(val0->d, &env->fp_status);
384 b = floatx80_round(val1->d, &env->fp_status);
385 set_float_rounding_mode(rounding_mode, &env->fp_status);
386 res->d = floatx80_mul(a, b, &env->fp_status);
387 PREC_END();
388 }
389
390 void HELPER(fdiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
391 {
392 res->d = floatx80_div(val1->d, val0->d, &env->fp_status);
393 }
394
395 void HELPER(fsdiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
396 {
397 PREC_BEGIN(floatx80_precision_s);
398 res->d = floatx80_div(val1->d, val0->d, &env->fp_status);
399 PREC_END();
400 }
401
402 void HELPER(fddiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
403 {
404 PREC_BEGIN(floatx80_precision_d);
405 res->d = floatx80_div(val1->d, val0->d, &env->fp_status);
406 PREC_END();
407 }
408
409 void HELPER(fsgldiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
410 {
411 FloatRoundMode rounding_mode = get_float_rounding_mode(&env->fp_status);
412 floatx80 a, b;
413
414 PREC_BEGIN(floatx80_precision_s);
415 set_float_rounding_mode(float_round_to_zero, &env->fp_status);
416 a = floatx80_round(val1->d, &env->fp_status);
417 b = floatx80_round(val0->d, &env->fp_status);
418 set_float_rounding_mode(rounding_mode, &env->fp_status);
419 res->d = floatx80_div(a, b, &env->fp_status);
420 PREC_END();
421 }
422
423 static int float_comp_to_cc(FloatRelation float_compare)
424 {
425 switch (float_compare) {
426 case float_relation_equal:
427 return FPSR_CC_Z;
428 case float_relation_less:
429 return FPSR_CC_N;
430 case float_relation_unordered:
431 return FPSR_CC_A;
432 case float_relation_greater:
433 return 0;
434 default:
435 g_assert_not_reached();
436 }
437 }
438
439 void HELPER(fcmp)(CPUM68KState *env, FPReg *val0, FPReg *val1)
440 {
441 FloatRelation float_compare;
442
443 float_compare = floatx80_compare(val1->d, val0->d, &env->fp_status);
444 env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | float_comp_to_cc(float_compare);
445 }
446
447 void HELPER(ftst)(CPUM68KState *env, FPReg *val)
448 {
449 uint32_t cc = 0;
450
451 if (floatx80_is_neg(val->d)) {
452 cc |= FPSR_CC_N;
453 }
454
455 if (floatx80_is_any_nan(val->d)) {
456 cc |= FPSR_CC_A;
457 } else if (floatx80_is_infinity(val->d, &env->fp_status)) {
458 cc |= FPSR_CC_I;
459 } else if (floatx80_is_zero(val->d)) {
460 cc |= FPSR_CC_Z;
461 }
462 env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | cc;
463 }
464
465 void HELPER(fconst)(CPUM68KState *env, FPReg *val, uint32_t offset)
466 {
467 val->d = fpu_rom[offset];
468 }
469
470 typedef int (*float_access)(CPUM68KState *env, uint32_t addr, FPReg *fp,
471 uintptr_t ra);
472
473 static uint32_t fmovem_predec(CPUM68KState *env, uint32_t addr, uint32_t mask,
474 float_access access_fn)
475 {
476 uintptr_t ra = GETPC();
477 int i, size;
478
479 for (i = 7; i >= 0; i--, mask <<= 1) {
480 if (mask & 0x80) {
481 size = access_fn(env, addr, &env->fregs[i], ra);
482 if ((mask & 0xff) != 0x80) {
483 addr -= size;
484 }
485 }
486 }
487
488 return addr;
489 }
490
491 static uint32_t fmovem_postinc(CPUM68KState *env, uint32_t addr, uint32_t mask,
492 float_access access_fn)
493 {
494 uintptr_t ra = GETPC();
495 int i, size;
496
497 for (i = 0; i < 8; i++, mask <<= 1) {
498 if (mask & 0x80) {
499 size = access_fn(env, addr, &env->fregs[i], ra);
500 addr += size;
501 }
502 }
503
504 return addr;
505 }
506
507 static int cpu_ld_floatx80_ra(CPUM68KState *env, uint32_t addr, FPReg *fp,
508 uintptr_t ra)
509 {
510 uint32_t high;
511 uint64_t low;
512
513 high = cpu_ldl_be_data_ra(env, addr, ra);
514 low = cpu_ldq_be_data_ra(env, addr + 4, ra);
515
516 fp->l.upper = high >> 16;
517 fp->l.lower = low;
518
519 return 12;
520 }
521
522 static int cpu_st_floatx80_ra(CPUM68KState *env, uint32_t addr, FPReg *fp,
523 uintptr_t ra)
524 {
525 cpu_stl_be_data_ra(env, addr, fp->l.upper << 16, ra);
526 cpu_stq_be_data_ra(env, addr + 4, fp->l.lower, ra);
527
528 return 12;
529 }
530
531 static int cpu_ld_float64_ra(CPUM68KState *env, uint32_t addr, FPReg *fp,
532 uintptr_t ra)
533 {
534 uint64_t val;
535
536 val = cpu_ldq_be_data_ra(env, addr, ra);
537 fp->d = float64_to_floatx80(*(float64 *)&val, &env->fp_status);
538
539 return 8;
540 }
541
542 static int cpu_st_float64_ra(CPUM68KState *env, uint32_t addr, FPReg *fp,
543 uintptr_t ra)
544 {
545 float64 val;
546
547 val = floatx80_to_float64(fp->d, &env->fp_status);
548 cpu_stq_be_data_ra(env, addr, *(uint64_t *)&val, ra);
549
550 return 8;
551 }
552
553 uint32_t HELPER(fmovemx_st_predec)(CPUM68KState *env, uint32_t addr,
554 uint32_t mask)
555 {
556 return fmovem_predec(env, addr, mask, cpu_st_floatx80_ra);
557 }
558
559 uint32_t HELPER(fmovemx_st_postinc)(CPUM68KState *env, uint32_t addr,
560 uint32_t mask)
561 {
562 return fmovem_postinc(env, addr, mask, cpu_st_floatx80_ra);
563 }
564
565 uint32_t HELPER(fmovemx_ld_postinc)(CPUM68KState *env, uint32_t addr,
566 uint32_t mask)
567 {
568 return fmovem_postinc(env, addr, mask, cpu_ld_floatx80_ra);
569 }
570
571 uint32_t HELPER(fmovemd_st_predec)(CPUM68KState *env, uint32_t addr,
572 uint32_t mask)
573 {
574 return fmovem_predec(env, addr, mask, cpu_st_float64_ra);
575 }
576
577 uint32_t HELPER(fmovemd_st_postinc)(CPUM68KState *env, uint32_t addr,
578 uint32_t mask)
579 {
580 return fmovem_postinc(env, addr, mask, cpu_st_float64_ra);
581 }
582
583 uint32_t HELPER(fmovemd_ld_postinc)(CPUM68KState *env, uint32_t addr,
584 uint32_t mask)
585 {
586 return fmovem_postinc(env, addr, mask, cpu_ld_float64_ra);
587 }
588
589 static void make_quotient(CPUM68KState *env, int sign, uint32_t quotient)
590 {
591 quotient = (sign << 7) | (quotient & 0x7f);
592 env->fpsr = (env->fpsr & ~FPSR_QT_MASK) | (quotient << FPSR_QT_SHIFT);
593 }
594
595 void HELPER(fmod)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
596 {
597 uint64_t quotient;
598 int sign = extractFloatx80Sign(val1->d) ^ extractFloatx80Sign(val0->d);
599
600 res->d = floatx80_modrem(val1->d, val0->d, true, &quotient,
601 &env->fp_status);
602
603 if (floatx80_is_any_nan(res->d)) {
604 return;
605 }
606
607 make_quotient(env, sign, quotient);
608 }
609
610 void HELPER(frem)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
611 {
612 FPReg fp_quot;
613 floatx80 fp_rem;
614
615 fp_rem = floatx80_rem(val1->d, val0->d, &env->fp_status);
616 if (!floatx80_is_any_nan(fp_rem)) {
617 /* Use local temporary fp_status to set different rounding mode */
618 float_status fp_status = env->fp_status;
619 uint32_t quotient;
620 int sign;
621
622 /* Calculate quotient directly using round to nearest mode */
623 set_float_rounding_mode(float_round_nearest_even, &fp_status);
624 fp_quot.d = floatx80_div(val1->d, val0->d, &fp_status);
625
626 sign = extractFloatx80Sign(fp_quot.d);
627 quotient = floatx80_to_int32(floatx80_abs(fp_quot.d), &env->fp_status);
628 make_quotient(env, sign, quotient);
629 }
630
631 res->d = fp_rem;
632 }
633
634 void HELPER(fgetexp)(CPUM68KState *env, FPReg *res, FPReg *val)
635 {
636 res->d = floatx80_getexp(val->d, &env->fp_status);
637 }
638
639 void HELPER(fgetman)(CPUM68KState *env, FPReg *res, FPReg *val)
640 {
641 res->d = floatx80_getman(val->d, &env->fp_status);
642 }
643
644 void HELPER(fscale)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1)
645 {
646 res->d = floatx80_scale(val1->d, val0->d, &env->fp_status);
647 }
648
649 void HELPER(flognp1)(CPUM68KState *env, FPReg *res, FPReg *val)
650 {
651 res->d = floatx80_lognp1(val->d, &env->fp_status);
652 }
653
654 void HELPER(flogn)(CPUM68KState *env, FPReg *res, FPReg *val)
655 {
656 res->d = floatx80_logn(val->d, &env->fp_status);
657 }
658
659 void HELPER(flog10)(CPUM68KState *env, FPReg *res, FPReg *val)
660 {
661 res->d = floatx80_log10(val->d, &env->fp_status);
662 }
663
664 void HELPER(flog2)(CPUM68KState *env, FPReg *res, FPReg *val)
665 {
666 res->d = floatx80_log2(val->d, &env->fp_status);
667 }
668
669 void HELPER(fetox)(CPUM68KState *env, FPReg *res, FPReg *val)
670 {
671 res->d = floatx80_etox(val->d, &env->fp_status);
672 }
673
674 void HELPER(ftwotox)(CPUM68KState *env, FPReg *res, FPReg *val)
675 {
676 res->d = floatx80_twotox(val->d, &env->fp_status);
677 }
678
679 void HELPER(ftentox)(CPUM68KState *env, FPReg *res, FPReg *val)
680 {
681 res->d = floatx80_tentox(val->d, &env->fp_status);
682 }
683
684 void HELPER(ftan)(CPUM68KState *env, FPReg *res, FPReg *val)
685 {
686 res->d = floatx80_tan(val->d, &env->fp_status);
687 }
688
689 void HELPER(fsin)(CPUM68KState *env, FPReg *res, FPReg *val)
690 {
691 res->d = floatx80_sin(val->d, &env->fp_status);
692 }
693
694 void HELPER(fcos)(CPUM68KState *env, FPReg *res, FPReg *val)
695 {
696 res->d = floatx80_cos(val->d, &env->fp_status);
697 }
698
699 void HELPER(fsincos)(CPUM68KState *env, FPReg *res0, FPReg *res1, FPReg *val)
700 {
701 floatx80 a = val->d;
702 /*
703 * If res0 and res1 specify the same floating-point data register,
704 * the sine result is stored in the register, and the cosine
705 * result is discarded.
706 */
707 res1->d = floatx80_cos(a, &env->fp_status);
708 res0->d = floatx80_sin(a, &env->fp_status);
709 }
710
711 void HELPER(fatan)(CPUM68KState *env, FPReg *res, FPReg *val)
712 {
713 res->d = floatx80_atan(val->d, &env->fp_status);
714 }
715
716 void HELPER(fasin)(CPUM68KState *env, FPReg *res, FPReg *val)
717 {
718 res->d = floatx80_asin(val->d, &env->fp_status);
719 }
720
721 void HELPER(facos)(CPUM68KState *env, FPReg *res, FPReg *val)
722 {
723 res->d = floatx80_acos(val->d, &env->fp_status);
724 }
725
726 void HELPER(fatanh)(CPUM68KState *env, FPReg *res, FPReg *val)
727 {
728 res->d = floatx80_atanh(val->d, &env->fp_status);
729 }
730
731 void HELPER(fetoxm1)(CPUM68KState *env, FPReg *res, FPReg *val)
732 {
733 res->d = floatx80_etoxm1(val->d, &env->fp_status);
734 }
735
736 void HELPER(ftanh)(CPUM68KState *env, FPReg *res, FPReg *val)
737 {
738 res->d = floatx80_tanh(val->d, &env->fp_status);
739 }
740
741 void HELPER(fsinh)(CPUM68KState *env, FPReg *res, FPReg *val)
742 {
743 res->d = floatx80_sinh(val->d, &env->fp_status);
744 }
745
746 void HELPER(fcosh)(CPUM68KState *env, FPReg *res, FPReg *val)
747 {
748 res->d = floatx80_cosh(val->d, &env->fp_status);
749 }