4 * Copyright (c) 2005 Samuel Tardieu
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.
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.
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/>.
19 #include "qemu/osdep.h"
21 #include "exec/helper-proto.h"
22 #include "exec/exec-all.h"
23 #include "exec/cpu_ldst.h"
24 #include "fpu/softfloat.h"
26 #ifndef CONFIG_USER_ONLY
28 void superh_cpu_do_unaligned_access(CPUState
*cs
, vaddr addr
,
29 MMUAccessType access_type
,
30 int mmu_idx
, uintptr_t retaddr
)
32 switch (access_type
) {
35 cs
->exception_index
= 0x0e0;
38 cs
->exception_index
= 0x100;
41 cpu_loop_exit_restore(cs
, retaddr
);
46 void helper_ldtlb(CPUSH4State
*env
)
48 #ifdef CONFIG_USER_ONLY
49 cpu_abort(env_cpu(env
), "Unhandled ldtlb");
55 static inline void QEMU_NORETURN
raise_exception(CPUSH4State
*env
, int index
,
58 CPUState
*cs
= env_cpu(env
);
60 cs
->exception_index
= index
;
61 cpu_loop_exit_restore(cs
, retaddr
);
64 void helper_raise_illegal_instruction(CPUSH4State
*env
)
66 raise_exception(env
, 0x180, 0);
69 void helper_raise_slot_illegal_instruction(CPUSH4State
*env
)
71 raise_exception(env
, 0x1a0, 0);
74 void helper_raise_fpu_disable(CPUSH4State
*env
)
76 raise_exception(env
, 0x800, 0);
79 void helper_raise_slot_fpu_disable(CPUSH4State
*env
)
81 raise_exception(env
, 0x820, 0);
84 void helper_sleep(CPUSH4State
*env
)
86 CPUState
*cs
= env_cpu(env
);
90 raise_exception(env
, EXCP_HLT
, 0);
93 void helper_trapa(CPUSH4State
*env
, uint32_t tra
)
96 raise_exception(env
, 0x160, 0);
99 void helper_exclusive(CPUSH4State
*env
)
101 /* We do not want cpu_restore_state to run. */
102 cpu_loop_exit_atomic(env_cpu(env
), 0);
105 void helper_movcal(CPUSH4State
*env
, uint32_t address
, uint32_t value
)
107 if (cpu_sh4_is_cached (env
, address
))
109 memory_content
*r
= g_new(memory_content
, 1);
111 r
->address
= address
;
115 *(env
->movcal_backup_tail
) = r
;
116 env
->movcal_backup_tail
= &(r
->next
);
120 void helper_discard_movcal_backup(CPUSH4State
*env
)
122 memory_content
*current
= env
->movcal_backup
;
126 memory_content
*next
= current
->next
;
128 env
->movcal_backup
= current
= next
;
130 env
->movcal_backup_tail
= &(env
->movcal_backup
);
134 void helper_ocbi(CPUSH4State
*env
, uint32_t address
)
136 memory_content
**current
= &(env
->movcal_backup
);
139 uint32_t a
= (*current
)->address
;
140 if ((a
& ~0x1F) == (address
& ~0x1F))
142 memory_content
*next
= (*current
)->next
;
143 cpu_stl_data(env
, a
, (*current
)->value
);
147 env
->movcal_backup_tail
= current
;
157 void helper_macl(CPUSH4State
*env
, uint32_t arg0
, uint32_t arg1
)
161 res
= ((uint64_t) env
->mach
<< 32) | env
->macl
;
162 res
+= (int64_t) (int32_t) arg0
*(int64_t) (int32_t) arg1
;
163 env
->mach
= (res
>> 32) & 0xffffffff;
164 env
->macl
= res
& 0xffffffff;
165 if (env
->sr
& (1u << SR_S
)) {
167 env
->mach
|= 0xffff0000;
169 env
->mach
&= 0x00007fff;
173 void helper_macw(CPUSH4State
*env
, uint32_t arg0
, uint32_t arg1
)
177 res
= ((uint64_t) env
->mach
<< 32) | env
->macl
;
178 res
+= (int64_t) (int16_t) arg0
*(int64_t) (int16_t) arg1
;
179 env
->mach
= (res
>> 32) & 0xffffffff;
180 env
->macl
= res
& 0xffffffff;
181 if (env
->sr
& (1u << SR_S
)) {
182 if (res
< -0x80000000) {
184 env
->macl
= 0x80000000;
185 } else if (res
> 0x000000007fffffff) {
187 env
->macl
= 0x7fffffff;
192 void helper_ld_fpscr(CPUSH4State
*env
, uint32_t val
)
194 env
->fpscr
= val
& FPSCR_MASK
;
195 if ((val
& FPSCR_RM_MASK
) == FPSCR_RM_ZERO
) {
196 set_float_rounding_mode(float_round_to_zero
, &env
->fp_status
);
198 set_float_rounding_mode(float_round_nearest_even
, &env
->fp_status
);
200 set_flush_to_zero((val
& FPSCR_DN
) != 0, &env
->fp_status
);
203 static void update_fpscr(CPUSH4State
*env
, uintptr_t retaddr
)
205 int xcpt
, cause
, enable
;
207 xcpt
= get_float_exception_flags(&env
->fp_status
);
209 /* Clear the cause entries */
210 env
->fpscr
&= ~FPSCR_CAUSE_MASK
;
212 if (unlikely(xcpt
)) {
213 if (xcpt
& float_flag_invalid
) {
214 env
->fpscr
|= FPSCR_CAUSE_V
;
216 if (xcpt
& float_flag_divbyzero
) {
217 env
->fpscr
|= FPSCR_CAUSE_Z
;
219 if (xcpt
& float_flag_overflow
) {
220 env
->fpscr
|= FPSCR_CAUSE_O
;
222 if (xcpt
& float_flag_underflow
) {
223 env
->fpscr
|= FPSCR_CAUSE_U
;
225 if (xcpt
& float_flag_inexact
) {
226 env
->fpscr
|= FPSCR_CAUSE_I
;
229 /* Accumulate in flag entries */
230 env
->fpscr
|= (env
->fpscr
& FPSCR_CAUSE_MASK
)
231 >> (FPSCR_CAUSE_SHIFT
- FPSCR_FLAG_SHIFT
);
233 /* Generate an exception if enabled */
234 cause
= (env
->fpscr
& FPSCR_CAUSE_MASK
) >> FPSCR_CAUSE_SHIFT
;
235 enable
= (env
->fpscr
& FPSCR_ENABLE_MASK
) >> FPSCR_ENABLE_SHIFT
;
236 if (cause
& enable
) {
237 raise_exception(env
, 0x120, retaddr
);
242 float32
helper_fadd_FT(CPUSH4State
*env
, float32 t0
, float32 t1
)
244 set_float_exception_flags(0, &env
->fp_status
);
245 t0
= float32_add(t0
, t1
, &env
->fp_status
);
246 update_fpscr(env
, GETPC());
250 float64
helper_fadd_DT(CPUSH4State
*env
, float64 t0
, float64 t1
)
252 set_float_exception_flags(0, &env
->fp_status
);
253 t0
= float64_add(t0
, t1
, &env
->fp_status
);
254 update_fpscr(env
, GETPC());
258 uint32_t helper_fcmp_eq_FT(CPUSH4State
*env
, float32 t0
, float32 t1
)
262 set_float_exception_flags(0, &env
->fp_status
);
263 relation
= float32_compare(t0
, t1
, &env
->fp_status
);
264 update_fpscr(env
, GETPC());
265 return relation
== float_relation_equal
;
268 uint32_t helper_fcmp_eq_DT(CPUSH4State
*env
, float64 t0
, float64 t1
)
272 set_float_exception_flags(0, &env
->fp_status
);
273 relation
= float64_compare(t0
, t1
, &env
->fp_status
);
274 update_fpscr(env
, GETPC());
275 return relation
== float_relation_equal
;
278 uint32_t helper_fcmp_gt_FT(CPUSH4State
*env
, float32 t0
, float32 t1
)
282 set_float_exception_flags(0, &env
->fp_status
);
283 relation
= float32_compare(t0
, t1
, &env
->fp_status
);
284 update_fpscr(env
, GETPC());
285 return relation
== float_relation_greater
;
288 uint32_t helper_fcmp_gt_DT(CPUSH4State
*env
, float64 t0
, float64 t1
)
292 set_float_exception_flags(0, &env
->fp_status
);
293 relation
= float64_compare(t0
, t1
, &env
->fp_status
);
294 update_fpscr(env
, GETPC());
295 return relation
== float_relation_greater
;
298 float64
helper_fcnvsd_FT_DT(CPUSH4State
*env
, float32 t0
)
301 set_float_exception_flags(0, &env
->fp_status
);
302 ret
= float32_to_float64(t0
, &env
->fp_status
);
303 update_fpscr(env
, GETPC());
307 float32
helper_fcnvds_DT_FT(CPUSH4State
*env
, float64 t0
)
310 set_float_exception_flags(0, &env
->fp_status
);
311 ret
= float64_to_float32(t0
, &env
->fp_status
);
312 update_fpscr(env
, GETPC());
316 float32
helper_fdiv_FT(CPUSH4State
*env
, float32 t0
, float32 t1
)
318 set_float_exception_flags(0, &env
->fp_status
);
319 t0
= float32_div(t0
, t1
, &env
->fp_status
);
320 update_fpscr(env
, GETPC());
324 float64
helper_fdiv_DT(CPUSH4State
*env
, float64 t0
, float64 t1
)
326 set_float_exception_flags(0, &env
->fp_status
);
327 t0
= float64_div(t0
, t1
, &env
->fp_status
);
328 update_fpscr(env
, GETPC());
332 float32
helper_float_FT(CPUSH4State
*env
, uint32_t t0
)
335 set_float_exception_flags(0, &env
->fp_status
);
336 ret
= int32_to_float32(t0
, &env
->fp_status
);
337 update_fpscr(env
, GETPC());
341 float64
helper_float_DT(CPUSH4State
*env
, uint32_t t0
)
344 set_float_exception_flags(0, &env
->fp_status
);
345 ret
= int32_to_float64(t0
, &env
->fp_status
);
346 update_fpscr(env
, GETPC());
350 float32
helper_fmac_FT(CPUSH4State
*env
, float32 t0
, float32 t1
, float32 t2
)
352 set_float_exception_flags(0, &env
->fp_status
);
353 t0
= float32_muladd(t0
, t1
, t2
, 0, &env
->fp_status
);
354 update_fpscr(env
, GETPC());
358 float32
helper_fmul_FT(CPUSH4State
*env
, float32 t0
, float32 t1
)
360 set_float_exception_flags(0, &env
->fp_status
);
361 t0
= float32_mul(t0
, t1
, &env
->fp_status
);
362 update_fpscr(env
, GETPC());
366 float64
helper_fmul_DT(CPUSH4State
*env
, float64 t0
, float64 t1
)
368 set_float_exception_flags(0, &env
->fp_status
);
369 t0
= float64_mul(t0
, t1
, &env
->fp_status
);
370 update_fpscr(env
, GETPC());
374 float32
helper_fsqrt_FT(CPUSH4State
*env
, float32 t0
)
376 set_float_exception_flags(0, &env
->fp_status
);
377 t0
= float32_sqrt(t0
, &env
->fp_status
);
378 update_fpscr(env
, GETPC());
382 float64
helper_fsqrt_DT(CPUSH4State
*env
, float64 t0
)
384 set_float_exception_flags(0, &env
->fp_status
);
385 t0
= float64_sqrt(t0
, &env
->fp_status
);
386 update_fpscr(env
, GETPC());
390 float32
helper_fsrra_FT(CPUSH4State
*env
, float32 t0
)
392 set_float_exception_flags(0, &env
->fp_status
);
393 /* "Approximate" 1/sqrt(x) via actual computation. */
394 t0
= float32_sqrt(t0
, &env
->fp_status
);
395 t0
= float32_div(float32_one
, t0
, &env
->fp_status
);
397 * Since this is supposed to be an approximation, an imprecision
398 * exception is required. One supposes this also follows the usual
399 * IEEE rule that other exceptions take precedence.
401 if (get_float_exception_flags(&env
->fp_status
) == 0) {
402 set_float_exception_flags(float_flag_inexact
, &env
->fp_status
);
404 update_fpscr(env
, GETPC());
408 float32
helper_fsub_FT(CPUSH4State
*env
, float32 t0
, float32 t1
)
410 set_float_exception_flags(0, &env
->fp_status
);
411 t0
= float32_sub(t0
, t1
, &env
->fp_status
);
412 update_fpscr(env
, GETPC());
416 float64
helper_fsub_DT(CPUSH4State
*env
, float64 t0
, float64 t1
)
418 set_float_exception_flags(0, &env
->fp_status
);
419 t0
= float64_sub(t0
, t1
, &env
->fp_status
);
420 update_fpscr(env
, GETPC());
424 uint32_t helper_ftrc_FT(CPUSH4State
*env
, float32 t0
)
427 set_float_exception_flags(0, &env
->fp_status
);
428 ret
= float32_to_int32_round_to_zero(t0
, &env
->fp_status
);
429 update_fpscr(env
, GETPC());
433 uint32_t helper_ftrc_DT(CPUSH4State
*env
, float64 t0
)
436 set_float_exception_flags(0, &env
->fp_status
);
437 ret
= float64_to_int32_round_to_zero(t0
, &env
->fp_status
);
438 update_fpscr(env
, GETPC());
442 void helper_fipr(CPUSH4State
*env
, uint32_t m
, uint32_t n
)
447 bank
= (env
->sr
& FPSCR_FR
) ? 16 : 0;
449 set_float_exception_flags(0, &env
->fp_status
);
451 for (i
= 0 ; i
< 4 ; i
++) {
452 p
= float32_mul(env
->fregs
[bank
+ m
+ i
],
453 env
->fregs
[bank
+ n
+ i
],
455 r
= float32_add(r
, p
, &env
->fp_status
);
457 update_fpscr(env
, GETPC());
459 env
->fregs
[bank
+ n
+ 3] = r
;
462 void helper_ftrv(CPUSH4State
*env
, uint32_t n
)
464 int bank_matrix
, bank_vector
;
469 bank_matrix
= (env
->sr
& FPSCR_FR
) ? 0 : 16;
470 bank_vector
= (env
->sr
& FPSCR_FR
) ? 16 : 0;
471 set_float_exception_flags(0, &env
->fp_status
);
472 for (i
= 0 ; i
< 4 ; i
++) {
474 for (j
= 0 ; j
< 4 ; j
++) {
475 p
= float32_mul(env
->fregs
[bank_matrix
+ 4 * j
+ i
],
476 env
->fregs
[bank_vector
+ j
],
478 r
[i
] = float32_add(r
[i
], p
, &env
->fp_status
);
481 update_fpscr(env
, GETPC());
483 for (i
= 0 ; i
< 4 ; i
++) {
484 env
->fregs
[bank_vector
+ i
] = r
[i
];