xref: /openbmc/qemu/target/rx/op_helper.c (revision d044b7c3) 
1 /*
2  *  RX helper functions
3  *
4  *  Copyright (c) 2019 Yoshinori Sato
5  *
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.
9  *
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
13  * more details.
14  *
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/>.
17  */
18 
19 #include "qemu/osdep.h"
20 #include "qemu/bitops.h"
21 #include "cpu.h"
22 #include "exec/exec-all.h"
23 #include "exec/helper-proto.h"
24 #include "exec/cpu_ldst.h"
25 #include "fpu/softfloat.h"
26 
27 static inline G_NORETURN
28 void raise_exception(CPURXState *env, int index,
29                      uintptr_t retaddr);
30 
31 static void _set_psw(CPURXState *env, uint32_t psw, uint32_t rte)
32 {
33     uint32_t prev_u;
34     prev_u = env->psw_u;
35     rx_cpu_unpack_psw(env, psw, rte);
36     if (prev_u != env->psw_u) {
37         /* switch r0  */
38         if (env->psw_u) {
39             env->isp = env->regs[0];
40             env->regs[0] = env->usp;
41         } else {
42             env->usp = env->regs[0];
43             env->regs[0] = env->isp;
44         }
45     }
46 }
47 
48 void helper_set_psw(CPURXState *env, uint32_t psw)
49 {
50     _set_psw(env, psw, 0);
51 }
52 
53 void helper_set_psw_rte(CPURXState *env, uint32_t psw)
54 {
55     _set_psw(env, psw, 1);
56 }
57 
58 uint32_t helper_pack_psw(CPURXState *env)
59 {
60     return rx_cpu_pack_psw(env);
61 }
62 
63 #define SET_FPSW(b)                                             \
64     do {                                                        \
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); \
68         }                                                       \
69     } while (0)
70 
71 /* fp operations */
72 static void update_fpsw(CPURXState *env, float32 ret, uintptr_t retaddr)
73 {
74     int xcpt, cause, enable;
75 
76     env->psw_z = ret & ~(1 << 31); /* mask sign bit */
77     env->psw_s = ret;
78 
79     xcpt = get_float_exception_flags(&env->fp_status);
80 
81     /* Clear the cause entries */
82     env->fpsw = FIELD_DP32(env->fpsw, FPSW, CAUSE, 0);
83 
84     /* set FPSW */
85     if (unlikely(xcpt)) {
86         if (xcpt & float_flag_invalid) {
87             SET_FPSW(V);
88         }
89         if (xcpt & float_flag_divbyzero) {
90             SET_FPSW(Z);
91         }
92         if (xcpt & float_flag_overflow) {
93             SET_FPSW(O);
94         }
95         if (xcpt & float_flag_underflow) {
96             SET_FPSW(U);
97         }
98         if (xcpt & float_flag_inexact) {
99             SET_FPSW(X);
100         }
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);
105         }
106 
107         /* update FPSW_FLAG_S */
108         if (FIELD_EX32(env->fpsw, FPSW, FLAGS) != 0) {
109             env->fpsw = FIELD_DP32(env->fpsw, FPSW, FS, 1);
110         }
111 
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);
118         }
119     }
120 }
121 
122 void helper_set_fpsw(CPURXState *env, uint32_t val)
123 {
124     static const int roundmode[] = {
125         float_round_nearest_even,
126         float_round_to_zero,
127         float_round_up,
128         float_round_down,
129     };
130     uint32_t fpsw = env->fpsw;
131     fpsw |= 0x7fffff03;
132     val &= ~0x80000000;
133     fpsw &= val;
134     FIELD_DP32(fpsw, FPSW, FS, FIELD_EX32(fpsw, FPSW, FLAGS) != 0);
135     env->fpsw = fpsw;
136     set_float_rounding_mode(roundmode[FIELD_EX32(env->fpsw, FPSW, RM)],
137                             &env->fp_status);
138 }
139 
140 #define FLOATOP(op, func)                                           \
141     float32 helper_##op(CPURXState *env, float32 t0, float32 t1)    \
142     {                                                               \
143         float32 ret;                                                \
144         ret = func(t0, t1, &env->fp_status);                        \
145         update_fpsw(env, *(uint32_t *)&ret, GETPC());               \
146         return ret;                                                 \
147     }
148 
149 FLOATOP(fadd, float32_add)
150 FLOATOP(fsub, float32_sub)
151 FLOATOP(fmul, float32_mul)
152 FLOATOP(fdiv, float32_div)
153 
154 void helper_fcmp(CPURXState *env, float32 t0, float32 t1)
155 {
156     int st;
157     st = float32_compare(t0, t1, &env->fp_status);
158     update_fpsw(env, 0, GETPC());
159     env->psw_z = 1;
160     env->psw_s = env->psw_o = 0;
161     switch (st) {
162     case float_relation_equal:
163         env->psw_z = 0;
164         break;
165     case float_relation_less:
166         env->psw_s = -1;
167         break;
168     case float_relation_unordered:
169         env->psw_o = -1;
170         break;
171     }
172 }
173 
174 uint32_t helper_ftoi(CPURXState *env, float32 t0)
175 {
176     uint32_t ret;
177     ret = float32_to_int32_round_to_zero(t0, &env->fp_status);
178     update_fpsw(env, ret, GETPC());
179     return ret;
180 }
181 
182 uint32_t helper_round(CPURXState *env, float32 t0)
183 {
184     uint32_t ret;
185     ret = float32_to_int32(t0, &env->fp_status);
186     update_fpsw(env, ret, GETPC());
187     return ret;
188 }
189 
190 float32 helper_itof(CPURXState *env, uint32_t t0)
191 {
192     float32 ret;
193     ret = int32_to_float32(t0, &env->fp_status);
194     update_fpsw(env, ret, GETPC());
195     return ret;
196 }
197 
198 /* string operations */
199 void helper_scmpu(CPURXState *env)
200 {
201     uint8_t tmp0, tmp1;
202     if (env->regs[3] == 0) {
203         return;
204     }
205     do {
206         tmp0 = cpu_ldub_data_ra(env, env->regs[1]++, GETPC());
207         tmp1 = cpu_ldub_data_ra(env, env->regs[2]++, GETPC());
208         env->regs[3]--;
209         if (tmp0 != tmp1 || tmp0 == '\0') {
210             break;
211         }
212     } while (env->regs[3] != 0);
213     env->psw_z = tmp0 - tmp1;
214     env->psw_c = (tmp0 >= tmp1);
215 }
216 
217 static uint32_t (* const cpu_ldufn[])(CPUArchState *env,
218                                      target_ulong ptr,
219                                      uintptr_t retaddr) = {
220     cpu_ldub_data_ra, cpu_lduw_data_ra, cpu_ldl_data_ra,
221 };
222 
223 static uint32_t (* const cpu_ldfn[])(CPUArchState *env,
224                                      target_ulong ptr,
225                                      uintptr_t retaddr) = {
226     cpu_ldub_data_ra, cpu_lduw_data_ra, cpu_ldl_data_ra,
227 };
228 
229 static void (* const cpu_stfn[])(CPUArchState *env,
230                                  target_ulong ptr,
231                                  uint32_t val,
232                                  uintptr_t retaddr) = {
233     cpu_stb_data_ra, cpu_stw_data_ra, cpu_stl_data_ra,
234 };
235 
236 void helper_sstr(CPURXState *env, uint32_t sz)
237 {
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;
242         env->regs[3]--;
243     }
244 }
245 
246 #define OP_SMOVU 1
247 #define OP_SMOVF 0
248 #define OP_SMOVB 2
249 
250 static void smov(uint32_t mode, CPURXState *env)
251 {
252     uint8_t tmp;
253     int dir;
254 
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());
259         env->regs[1] += dir;
260         env->regs[2] += dir;
261         env->regs[3]--;
262         if ((mode & OP_SMOVU) && tmp == 0) {
263             break;
264         }
265     }
266 }
267 
268 void helper_smovu(CPURXState *env)
269 {
270     smov(OP_SMOVU, env);
271 }
272 
273 void helper_smovf(CPURXState *env)
274 {
275     smov(OP_SMOVF, env);
276 }
277 
278 void helper_smovb(CPURXState *env)
279 {
280     smov(OP_SMOVB, env);
281 }
282 
283 
284 void helper_suntil(CPURXState *env, uint32_t sz)
285 {
286     uint32_t tmp;
287     tcg_debug_assert(sz < 3);
288     if (env->regs[3] == 0) {
289         return;
290     }
291     do {
292         tmp = cpu_ldufn[sz](env, env->regs[1], GETPC());
293         env->regs[1] += 1 << sz;
294         env->regs[3]--;
295         if (tmp == env->regs[2]) {
296             break;
297         }
298     } while (env->regs[3] != 0);
299     env->psw_z = tmp - env->regs[2];
300     env->psw_c = (tmp <= env->regs[2]);
301 }
302 
303 void helper_swhile(CPURXState *env, uint32_t sz)
304 {
305     uint32_t tmp;
306     tcg_debug_assert(sz < 3);
307     if (env->regs[3] == 0) {
308         return;
309     }
310     do {
311         tmp = cpu_ldufn[sz](env, env->regs[1], GETPC());
312         env->regs[1] += 1 << sz;
313         env->regs[3]--;
314         if (tmp != env->regs[2]) {
315             break;
316         }
317     } while (env->regs[3] != 0);
318     env->psw_z = env->regs[3];
319     env->psw_c = (tmp <= env->regs[2]);
320 }
321 
322 /* accumulator operations */
323 void helper_rmpa(CPURXState *env, uint32_t sz)
324 {
325     uint64_t result_l, prev;
326     int32_t result_h;
327     int64_t tmp0, tmp1;
328 
329     if (env->regs[3] == 0) {
330         return;
331     }
332     result_l = env->regs[5];
333     result_l <<= 32;
334     result_l |= env->regs[4];
335     result_h = env->regs[6];
336     env->psw_o = 0;
337 
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());
341         tmp0 *= tmp1;
342         prev = result_l;
343         result_l += tmp0;
344         /* carry / bollow */
345         if (tmp0 < 0) {
346             if (prev > result_l) {
347                 result_h--;
348             }
349         } else {
350             if (prev < result_l) {
351                 result_h++;
352             }
353         }
354 
355         env->regs[1] += 1 << sz;
356         env->regs[2] += 1 << sz;
357     }
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;
363 }
364 
365 void helper_racw(CPURXState *env, uint32_t imm)
366 {
367     int64_t acc;
368     acc = env->acc;
369     acc <<= (imm + 1);
370     acc += 0x0000000080000000LL;
371     if (acc > 0x00007fff00000000LL) {
372         acc = 0x00007fff00000000LL;
373     } else if (acc < -0x800000000000LL) {
374         acc = -0x800000000000LL;
375     } else {
376         acc &= 0xffffffff00000000LL;
377     }
378     env->acc = acc;
379 }
380 
381 void helper_satr(CPURXState *env)
382 {
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;
388         } else {
389             env->regs[6] = 0xffffffff;
390             env->regs[5] = 0x80000000;
391             env->regs[4] = 0x00000000;
392         }
393     }
394 }
395 
396 /* div */
397 uint32_t helper_div(CPURXState *env, uint32_t num, uint32_t den)
398 {
399     uint32_t ret = num;
400     if (!((num == INT_MIN && den == -1) || den == 0)) {
401         ret = (int32_t)num / (int32_t)den;
402         env->psw_o = 0;
403     } else {
404         env->psw_o = -1;
405     }
406     return ret;
407 }
408 
409 uint32_t helper_divu(CPURXState *env, uint32_t num, uint32_t den)
410 {
411     uint32_t ret = num;
412     if (den != 0) {
413         ret = num / den;
414         env->psw_o = 0;
415     } else {
416         env->psw_o = -1;
417     }
418     return ret;
419 }
420 
421 /* exception */
422 static inline G_NORETURN
423 void raise_exception(CPURXState *env, int index,
424                      uintptr_t retaddr)
425 {
426     CPUState *cs = env_cpu(env);
427 
428     cs->exception_index = index;
429     cpu_loop_exit_restore(cs, retaddr);
430 }
431 
432 G_NORETURN void helper_raise_privilege_violation(CPURXState *env)
433 {
434     raise_exception(env, 20, GETPC());
435 }
436 
437 G_NORETURN void helper_raise_access_fault(CPURXState *env)
438 {
439     raise_exception(env, 21, GETPC());
440 }
441 
442 G_NORETURN void helper_raise_illegal_instruction(CPURXState *env)
443 {
444     raise_exception(env, 23, GETPC());
445 }
446 
447 G_NORETURN void helper_wait(CPURXState *env)
448 {
449     CPUState *cs = env_cpu(env);
450 
451     cs->halted = 1;
452     env->in_sleep = 1;
453     env->psw_i = 1;
454     raise_exception(env, EXCP_HLT, 0);
455 }
456 
457 G_NORETURN void helper_rxint(CPURXState *env, uint32_t vec)
458 {
459     raise_exception(env, 0x100 + vec, 0);
460 }
461 
462 G_NORETURN void helper_rxbrk(CPURXState *env)
463 {
464     raise_exception(env, 0x100, 0);
465 }
466