4 * Copyright (c) 2019 Yoshinori Sato
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2 or later, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program. If not, see <http://www.gnu.org/licenses/>.
19 #include "qemu/osdep.h"
20 #include "qemu/bitops.h"
22 #include "exec/exec-all.h"
23 #include "exec/helper-proto.h"
24 #include "exec/cpu_ldst.h"
25 #include "fpu/softfloat.h"
27 static inline G_NORETURN
28 void raise_exception(CPURXState
*env
, int index
,
31 static void _set_psw(CPURXState
*env
, uint32_t psw
, uint32_t rte
)
35 rx_cpu_unpack_psw(env
, psw
, rte
);
36 if (prev_u
!= env
->psw_u
) {
39 env
->isp
= env
->regs
[0];
40 env
->regs
[0] = env
->usp
;
42 env
->usp
= env
->regs
[0];
43 env
->regs
[0] = env
->isp
;
48 void helper_set_psw(CPURXState
*env
, uint32_t psw
)
50 _set_psw(env
, psw
, 0);
53 void helper_set_psw_rte(CPURXState
*env
, uint32_t psw
)
55 _set_psw(env
, psw
, 1);
58 uint32_t helper_pack_psw(CPURXState
*env
)
60 return rx_cpu_pack_psw(env
);
65 env->fpsw = FIELD_DP32(env->fpsw, FPSW, C ## b, 1); \
66 if (!FIELD_EX32(env->fpsw, FPSW, E ## b)) { \
67 env->fpsw = FIELD_DP32(env->fpsw, FPSW, F ## b, 1); \
72 static void update_fpsw(CPURXState
*env
, float32 ret
, uintptr_t retaddr
)
74 int xcpt
, cause
, enable
;
76 env
->psw_z
= ret
& ~(1 << 31); /* mask sign bit */
79 xcpt
= get_float_exception_flags(&env
->fp_status
);
81 /* Clear the cause entries */
82 env
->fpsw
= FIELD_DP32(env
->fpsw
, FPSW
, CAUSE
, 0);
86 if (xcpt
& float_flag_invalid
) {
89 if (xcpt
& float_flag_divbyzero
) {
92 if (xcpt
& float_flag_overflow
) {
95 if (xcpt
& float_flag_underflow
) {
98 if (xcpt
& float_flag_inexact
) {
101 if ((xcpt
& (float_flag_input_denormal
102 | float_flag_output_denormal
))
103 && !FIELD_EX32(env
->fpsw
, FPSW
, DN
)) {
104 env
->fpsw
= FIELD_DP32(env
->fpsw
, FPSW
, CE
, 1);
107 /* update FPSW_FLAG_S */
108 if (FIELD_EX32(env
->fpsw
, FPSW
, FLAGS
) != 0) {
109 env
->fpsw
= FIELD_DP32(env
->fpsw
, FPSW
, FS
, 1);
112 /* Generate an exception if enabled */
113 cause
= FIELD_EX32(env
->fpsw
, FPSW
, CAUSE
);
114 enable
= FIELD_EX32(env
->fpsw
, FPSW
, ENABLE
);
115 enable
|= 1 << 5; /* CE always enabled */
116 if (cause
& enable
) {
117 raise_exception(env
, 21, retaddr
);
122 void helper_set_fpsw(CPURXState
*env
, uint32_t val
)
124 static const int roundmode
[] = {
125 float_round_nearest_even
,
130 uint32_t fpsw
= env
->fpsw
;
134 FIELD_DP32(fpsw
, FPSW
, FS
, FIELD_EX32(fpsw
, FPSW
, FLAGS
) != 0);
136 set_float_rounding_mode(roundmode
[FIELD_EX32(env
->fpsw
, FPSW
, RM
)],
140 #define FLOATOP(op, func) \
141 float32 helper_##op(CPURXState *env, float32 t0, float32 t1) \
144 ret = func(t0, t1, &env->fp_status); \
145 update_fpsw(env, *(uint32_t *)&ret, GETPC()); \
149 FLOATOP(fadd
, float32_add
)
150 FLOATOP(fsub
, float32_sub
)
151 FLOATOP(fmul
, float32_mul
)
152 FLOATOP(fdiv
, float32_div
)
154 void helper_fcmp(CPURXState
*env
, float32 t0
, float32 t1
)
157 st
= float32_compare(t0
, t1
, &env
->fp_status
);
158 update_fpsw(env
, 0, GETPC());
160 env
->psw_s
= env
->psw_o
= 0;
162 case float_relation_equal
:
165 case float_relation_less
:
168 case float_relation_unordered
:
174 uint32_t helper_ftoi(CPURXState
*env
, float32 t0
)
177 ret
= float32_to_int32_round_to_zero(t0
, &env
->fp_status
);
178 update_fpsw(env
, ret
, GETPC());
182 uint32_t helper_round(CPURXState
*env
, float32 t0
)
185 ret
= float32_to_int32(t0
, &env
->fp_status
);
186 update_fpsw(env
, ret
, GETPC());
190 float32
helper_itof(CPURXState
*env
, uint32_t t0
)
193 ret
= int32_to_float32(t0
, &env
->fp_status
);
194 update_fpsw(env
, ret
, GETPC());
198 /* string operations */
199 void helper_scmpu(CPURXState
*env
)
202 if (env
->regs
[3] == 0) {
206 tmp0
= cpu_ldub_data_ra(env
, env
->regs
[1]++, GETPC());
207 tmp1
= cpu_ldub_data_ra(env
, env
->regs
[2]++, GETPC());
209 if (tmp0
!= tmp1
|| tmp0
== '\0') {
212 } while (env
->regs
[3] != 0);
213 env
->psw_z
= tmp0
- tmp1
;
214 env
->psw_c
= (tmp0
>= tmp1
);
217 static uint32_t (* const cpu_ldufn
[])(CPUArchState
*env
,
219 uintptr_t retaddr
) = {
220 cpu_ldub_data_ra
, cpu_lduw_data_ra
, cpu_ldl_data_ra
,
223 static uint32_t (* const cpu_ldfn
[])(CPUArchState
*env
,
225 uintptr_t retaddr
) = {
226 cpu_ldub_data_ra
, cpu_lduw_data_ra
, cpu_ldl_data_ra
,
229 static void (* const cpu_stfn
[])(CPUArchState
*env
,
232 uintptr_t retaddr
) = {
233 cpu_stb_data_ra
, cpu_stw_data_ra
, cpu_stl_data_ra
,
236 void helper_sstr(CPURXState
*env
, uint32_t sz
)
238 tcg_debug_assert(sz
< 3);
239 while (env
->regs
[3] != 0) {
240 cpu_stfn
[sz
](env
, env
->regs
[1], env
->regs
[2], GETPC());
241 env
->regs
[1] += 1 << sz
;
250 static void smov(uint32_t mode
, CPURXState
*env
)
255 dir
= (mode
& OP_SMOVB
) ? -1 : 1;
256 while (env
->regs
[3] != 0) {
257 tmp
= cpu_ldub_data_ra(env
, env
->regs
[2], GETPC());
258 cpu_stb_data_ra(env
, env
->regs
[1], tmp
, GETPC());
262 if ((mode
& OP_SMOVU
) && tmp
== 0) {
268 void helper_smovu(CPURXState
*env
)
273 void helper_smovf(CPURXState
*env
)
278 void helper_smovb(CPURXState
*env
)
284 void helper_suntil(CPURXState
*env
, uint32_t sz
)
287 tcg_debug_assert(sz
< 3);
288 if (env
->regs
[3] == 0) {
292 tmp
= cpu_ldufn
[sz
](env
, env
->regs
[1], GETPC());
293 env
->regs
[1] += 1 << sz
;
295 if (tmp
== env
->regs
[2]) {
298 } while (env
->regs
[3] != 0);
299 env
->psw_z
= tmp
- env
->regs
[2];
300 env
->psw_c
= (tmp
<= env
->regs
[2]);
303 void helper_swhile(CPURXState
*env
, uint32_t sz
)
306 tcg_debug_assert(sz
< 3);
307 if (env
->regs
[3] == 0) {
311 tmp
= cpu_ldufn
[sz
](env
, env
->regs
[1], GETPC());
312 env
->regs
[1] += 1 << sz
;
314 if (tmp
!= env
->regs
[2]) {
317 } while (env
->regs
[3] != 0);
318 env
->psw_z
= env
->regs
[3];
319 env
->psw_c
= (tmp
<= env
->regs
[2]);
322 /* accumulator operations */
323 void helper_rmpa(CPURXState
*env
, uint32_t sz
)
325 uint64_t result_l
, prev
;
329 if (env
->regs
[3] == 0) {
332 result_l
= env
->regs
[5];
334 result_l
|= env
->regs
[4];
335 result_h
= env
->regs
[6];
338 while (env
->regs
[3] != 0) {
339 tmp0
= cpu_ldfn
[sz
](env
, env
->regs
[1], GETPC());
340 tmp1
= cpu_ldfn
[sz
](env
, env
->regs
[2], GETPC());
346 if (prev
> result_l
) {
350 if (prev
< result_l
) {
355 env
->regs
[1] += 1 << sz
;
356 env
->regs
[2] += 1 << sz
;
358 env
->psw_s
= result_h
;
359 env
->psw_o
= (result_h
!= 0 && result_h
!= -1) << 31;
360 env
->regs
[6] = result_h
;
361 env
->regs
[5] = result_l
>> 32;
362 env
->regs
[4] = result_l
& 0xffffffff;
365 void helper_racw(CPURXState
*env
, uint32_t imm
)
370 acc
+= 0x0000000080000000LL
;
371 if (acc
> 0x00007fff00000000LL
) {
372 acc
= 0x00007fff00000000LL
;
373 } else if (acc
< -0x800000000000LL
) {
374 acc
= -0x800000000000LL
;
376 acc
&= 0xffffffff00000000LL
;
381 void helper_satr(CPURXState
*env
)
383 if (env
->psw_o
>> 31) {
384 if ((int)env
->psw_s
< 0) {
385 env
->regs
[6] = 0x00000000;
386 env
->regs
[5] = 0x7fffffff;
387 env
->regs
[4] = 0xffffffff;
389 env
->regs
[6] = 0xffffffff;
390 env
->regs
[5] = 0x80000000;
391 env
->regs
[4] = 0x00000000;
397 uint32_t helper_div(CPURXState
*env
, uint32_t num
, uint32_t den
)
400 if (!((num
== INT_MIN
&& den
== -1) || den
== 0)) {
401 ret
= (int32_t)num
/ (int32_t)den
;
409 uint32_t helper_divu(CPURXState
*env
, uint32_t num
, uint32_t den
)
422 static inline G_NORETURN
423 void raise_exception(CPURXState
*env
, int index
,
426 CPUState
*cs
= env_cpu(env
);
428 cs
->exception_index
= index
;
429 cpu_loop_exit_restore(cs
, retaddr
);
432 G_NORETURN
void helper_raise_privilege_violation(CPURXState
*env
)
434 raise_exception(env
, 20, GETPC());
437 G_NORETURN
void helper_raise_access_fault(CPURXState
*env
)
439 raise_exception(env
, 21, GETPC());
442 G_NORETURN
void helper_raise_illegal_instruction(CPURXState
*env
)
444 raise_exception(env
, 23, GETPC());
447 G_NORETURN
void helper_wait(CPURXState
*env
)
449 CPUState
*cs
= env_cpu(env
);
454 raise_exception(env
, EXCP_HLT
, 0);
457 G_NORETURN
void helper_rxint(CPURXState
*env
, uint32_t vec
)
459 raise_exception(env
, 0x100 + vec
, 0);
462 G_NORETURN
void helper_rxbrk(CPURXState
*env
)
464 raise_exception(env
, 0x100, 0);