4 * Copyright (c) 2007 CodeSourcery
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 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 "exec/semihost.h"
26 #if defined(CONFIG_USER_ONLY)
28 void m68k_cpu_do_interrupt(CPUState
*cs
)
30 cs
->exception_index
= -1;
33 static inline void do_interrupt_m68k_hardirq(CPUM68KState
*env
)
39 /* Try to fill the TLB and return an exception if error. If retaddr is
40 NULL, it means that the function was called in C code (i.e. not
41 from generated code or from helper.c) */
42 void tlb_fill(CPUState
*cs
, target_ulong addr
, MMUAccessType access_type
,
43 int mmu_idx
, uintptr_t retaddr
)
47 ret
= m68k_cpu_handle_mmu_fault(cs
, addr
, access_type
, mmu_idx
);
49 /* now we have a real cpu fault */
50 cpu_loop_exit_restore(cs
, retaddr
);
54 static void cf_rte(CPUM68KState
*env
)
60 fmt
= cpu_ldl_kernel(env
, sp
);
61 env
->pc
= cpu_ldl_kernel(env
, sp
+ 4);
62 sp
|= (fmt
>> 28) & 3;
63 env
->aregs
[7] = sp
+ 8;
65 cpu_m68k_set_sr(env
, fmt
);
68 static void m68k_rte(CPUM68KState
*env
)
76 sr
= cpu_lduw_kernel(env
, sp
);
78 env
->pc
= cpu_ldl_kernel(env
, sp
);
80 if (m68k_feature(env
, M68K_FEATURE_QUAD_MULDIV
)) {
81 /* all except 68000 */
82 fmt
= cpu_lduw_kernel(env
, sp
);
89 cpu_m68k_set_sr(env
, sr
);
104 cpu_m68k_set_sr(env
, sr
);
107 static const char *m68k_exception_name(int index
)
111 return "Access Fault";
113 return "Address Error";
115 return "Illegal Instruction";
117 return "Divide by Zero";
121 return "FTRAPcc, TRAPcc, TRAPV";
123 return "Privilege Violation";
130 case EXCP_DEBEGBP
: /* 68020/030 only */
131 return "Copro Protocol Violation";
133 return "Format Error";
134 case EXCP_UNINITIALIZED
:
135 return "Unitialized Interruot";
137 return "Spurious Interrupt";
138 case EXCP_INT_LEVEL_1
:
139 return "Level 1 Interrupt";
140 case EXCP_INT_LEVEL_1
+ 1:
141 return "Level 2 Interrupt";
142 case EXCP_INT_LEVEL_1
+ 2:
143 return "Level 3 Interrupt";
144 case EXCP_INT_LEVEL_1
+ 3:
145 return "Level 4 Interrupt";
146 case EXCP_INT_LEVEL_1
+ 4:
147 return "Level 5 Interrupt";
148 case EXCP_INT_LEVEL_1
+ 5:
149 return "Level 6 Interrupt";
150 case EXCP_INT_LEVEL_1
+ 6:
151 return "Level 7 Interrupt";
172 case EXCP_TRAP0
+ 10:
174 case EXCP_TRAP0
+ 11:
176 case EXCP_TRAP0
+ 12:
178 case EXCP_TRAP0
+ 13:
180 case EXCP_TRAP0
+ 14:
182 case EXCP_TRAP0
+ 15:
185 return "FP Branch/Set on unordered condition";
187 return "FP Inexact Result";
189 return "FP Divide by Zero";
191 return "FP Underflow";
193 return "FP Operand Error";
195 return "FP Overflow";
197 return "FP Signaling NAN";
199 return "FP Unimplemented Data Type";
200 case EXCP_MMU_CONF
: /* 68030/68851 only */
201 return "MMU Configuration Error";
202 case EXCP_MMU_ILLEGAL
: /* 68851 only */
203 return "MMU Illegal Operation";
204 case EXCP_MMU_ACCESS
: /* 68851 only */
205 return "MMU Access Level Violation";
207 return "User Defined Vector";
212 static void cf_interrupt_all(CPUM68KState
*env
, int is_hw
)
214 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
225 switch (cs
->exception_index
) {
227 /* Return from an exception. */
231 if (semihosting_enabled()
232 && (env
->sr
& SR_S
) != 0
233 && (env
->pc
& 3) == 0
234 && cpu_lduw_code(env
, env
->pc
- 4) == 0x4e71
235 && cpu_ldl_code(env
, env
->pc
) == 0x4e7bf000) {
237 do_m68k_semihosting(env
, env
->dregs
[0]);
241 cs
->exception_index
= EXCP_HLT
;
245 if (cs
->exception_index
>= EXCP_TRAP0
246 && cs
->exception_index
<= EXCP_TRAP15
) {
247 /* Move the PC after the trap instruction. */
252 vector
= cs
->exception_index
<< 2;
254 sr
= env
->sr
| cpu_m68k_get_ccr(env
);
255 if (qemu_loglevel_mask(CPU_LOG_INT
)) {
257 qemu_log("INT %6d: %s(%#x) pc=%08x sp=%08x sr=%04x\n",
258 ++count
, m68k_exception_name(cs
->exception_index
),
259 vector
, env
->pc
, env
->aregs
[7], sr
);
268 env
->sr
= (env
->sr
& ~SR_I
) | (env
->pending_level
<< SR_I_SHIFT
);
273 fmt
|= (sp
& 3) << 28;
275 /* ??? This could cause MMU faults. */
278 cpu_stl_kernel(env
, sp
, retaddr
);
280 cpu_stl_kernel(env
, sp
, fmt
);
282 /* Jump to vector. */
283 env
->pc
= cpu_ldl_kernel(env
, env
->vbr
+ vector
);
286 static inline void do_stack_frame(CPUM68KState
*env
, uint32_t *sp
,
287 uint16_t format
, uint16_t sr
,
288 uint32_t addr
, uint32_t retaddr
)
290 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
294 cpu_stl_kernel(env
, *sp
, env
->pc
);
296 cpu_stl_kernel(env
, *sp
, addr
);
301 cpu_stl_kernel(env
, *sp
, addr
);
305 cpu_stw_kernel(env
, *sp
, (format
<< 12) + (cs
->exception_index
<< 2));
307 cpu_stl_kernel(env
, *sp
, retaddr
);
309 cpu_stw_kernel(env
, *sp
, sr
);
312 static void m68k_interrupt_all(CPUM68KState
*env
, int is_hw
)
314 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
323 switch (cs
->exception_index
) {
325 /* Return from an exception. */
328 case EXCP_TRAP0
... EXCP_TRAP15
:
329 /* Move the PC after the trap instruction. */
335 vector
= cs
->exception_index
<< 2;
337 sr
= env
->sr
| cpu_m68k_get_ccr(env
);
338 if (qemu_loglevel_mask(CPU_LOG_INT
)) {
340 qemu_log("INT %6d: %s(%#x) pc=%08x sp=%08x sr=%04x\n",
341 ++count
, m68k_exception_name(cs
->exception_index
),
342 vector
, env
->pc
, env
->aregs
[7], sr
);
346 * MC68040UM/AD, chapter 9.3.10
349 /* "the processor first make an internal copy" */
351 /* "set the mode to supervisor" */
353 /* "suppress tracing" */
355 /* "sets the processor interrupt mask" */
357 sr
|= (env
->sr
& ~SR_I
) | (env
->pending_level
<< SR_I_SHIFT
);
359 cpu_m68k_set_sr(env
, sr
);
363 if (cs
->exception_index
== EXCP_ADDRESS
) {
364 do_stack_frame(env
, &sp
, 2, oldsr
, 0, retaddr
);
365 } else if (cs
->exception_index
== EXCP_ILLEGAL
||
366 cs
->exception_index
== EXCP_DIV0
||
367 cs
->exception_index
== EXCP_CHK
||
368 cs
->exception_index
== EXCP_TRAPCC
||
369 cs
->exception_index
== EXCP_TRACE
) {
370 /* FIXME: addr is not only env->pc */
371 do_stack_frame(env
, &sp
, 2, oldsr
, env
->pc
, retaddr
);
372 } else if (is_hw
&& oldsr
& SR_M
&&
373 cs
->exception_index
>= EXCP_SPURIOUS
&&
374 cs
->exception_index
<= EXCP_INT_LEVEL_7
) {
375 do_stack_frame(env
, &sp
, 0, oldsr
, 0, retaddr
);
378 cpu_m68k_set_sr(env
, sr
&= ~SR_M
);
379 sp
= env
->aregs
[7] & ~1;
380 do_stack_frame(env
, &sp
, 1, oldsr
, 0, retaddr
);
382 do_stack_frame(env
, &sp
, 0, oldsr
, 0, retaddr
);
386 /* Jump to vector. */
387 env
->pc
= cpu_ldl_kernel(env
, env
->vbr
+ vector
);
390 static void do_interrupt_all(CPUM68KState
*env
, int is_hw
)
392 if (m68k_feature(env
, M68K_FEATURE_M68000
)) {
393 m68k_interrupt_all(env
, is_hw
);
396 cf_interrupt_all(env
, is_hw
);
399 void m68k_cpu_do_interrupt(CPUState
*cs
)
401 M68kCPU
*cpu
= M68K_CPU(cs
);
402 CPUM68KState
*env
= &cpu
->env
;
404 do_interrupt_all(env
, 0);
407 static inline void do_interrupt_m68k_hardirq(CPUM68KState
*env
)
409 do_interrupt_all(env
, 1);
413 bool m68k_cpu_exec_interrupt(CPUState
*cs
, int interrupt_request
)
415 M68kCPU
*cpu
= M68K_CPU(cs
);
416 CPUM68KState
*env
= &cpu
->env
;
418 if (interrupt_request
& CPU_INTERRUPT_HARD
419 && ((env
->sr
& SR_I
) >> SR_I_SHIFT
) < env
->pending_level
) {
420 /* Real hardware gets the interrupt vector via an IACK cycle
421 at this point. Current emulated hardware doesn't rely on
422 this, so we provide/save the vector when the interrupt is
424 cs
->exception_index
= env
->pending_vector
;
425 do_interrupt_m68k_hardirq(env
);
431 static void raise_exception_ra(CPUM68KState
*env
, int tt
, uintptr_t raddr
)
433 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
435 cs
->exception_index
= tt
;
436 cpu_loop_exit_restore(cs
, raddr
);
439 static void raise_exception(CPUM68KState
*env
, int tt
)
441 raise_exception_ra(env
, tt
, 0);
444 void HELPER(raise_exception
)(CPUM68KState
*env
, uint32_t tt
)
446 raise_exception(env
, tt
);
449 void HELPER(divuw
)(CPUM68KState
*env
, int destr
, uint32_t den
)
451 uint32_t num
= env
->dregs
[destr
];
455 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
460 env
->cc_c
= 0; /* always cleared, even if overflow */
463 /* real 68040 keeps N and unset Z on overflow,
464 * whereas documentation says "undefined"
469 env
->dregs
[destr
] = deposit32(quot
, 16, 16, rem
);
470 env
->cc_z
= (int16_t)quot
;
471 env
->cc_n
= (int16_t)quot
;
475 void HELPER(divsw
)(CPUM68KState
*env
, int destr
, int32_t den
)
477 int32_t num
= env
->dregs
[destr
];
481 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
486 env
->cc_c
= 0; /* always cleared, even if overflow */
487 if (quot
!= (int16_t)quot
) {
489 /* nothing else is modified */
490 /* real 68040 keeps N and unset Z on overflow,
491 * whereas documentation says "undefined"
496 env
->dregs
[destr
] = deposit32(quot
, 16, 16, rem
);
497 env
->cc_z
= (int16_t)quot
;
498 env
->cc_n
= (int16_t)quot
;
502 void HELPER(divul
)(CPUM68KState
*env
, int numr
, int regr
, uint32_t den
)
504 uint32_t num
= env
->dregs
[numr
];
508 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
518 if (m68k_feature(env
, M68K_FEATURE_CF_ISA_A
)) {
520 env
->dregs
[numr
] = quot
;
522 env
->dregs
[regr
] = rem
;
525 env
->dregs
[regr
] = rem
;
526 env
->dregs
[numr
] = quot
;
530 void HELPER(divsl
)(CPUM68KState
*env
, int numr
, int regr
, int32_t den
)
532 int32_t num
= env
->dregs
[numr
];
536 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
546 if (m68k_feature(env
, M68K_FEATURE_CF_ISA_A
)) {
548 env
->dregs
[numr
] = quot
;
550 env
->dregs
[regr
] = rem
;
553 env
->dregs
[regr
] = rem
;
554 env
->dregs
[numr
] = quot
;
558 void HELPER(divull
)(CPUM68KState
*env
, int numr
, int regr
, uint32_t den
)
560 uint64_t num
= deposit64(env
->dregs
[numr
], 32, 32, env
->dregs
[regr
]);
565 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
570 env
->cc_c
= 0; /* always cleared, even if overflow */
571 if (quot
> 0xffffffffULL
) {
573 /* real 68040 keeps N and unset Z on overflow,
574 * whereas documentation says "undefined"
584 * If Dq and Dr are the same, the quotient is returned.
585 * therefore we set Dq last.
588 env
->dregs
[regr
] = rem
;
589 env
->dregs
[numr
] = quot
;
592 void HELPER(divsll
)(CPUM68KState
*env
, int numr
, int regr
, int32_t den
)
594 int64_t num
= deposit64(env
->dregs
[numr
], 32, 32, env
->dregs
[regr
]);
599 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
604 env
->cc_c
= 0; /* always cleared, even if overflow */
605 if (quot
!= (int32_t)quot
) {
607 /* real 68040 keeps N and unset Z on overflow,
608 * whereas documentation says "undefined"
618 * If Dq and Dr are the same, the quotient is returned.
619 * therefore we set Dq last.
622 env
->dregs
[regr
] = rem
;
623 env
->dregs
[numr
] = quot
;
626 /* We're executing in a serial context -- no need to be atomic. */
627 void HELPER(cas2w
)(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
, uint32_t a2
)
629 uint32_t Dc1
= extract32(regs
, 9, 3);
630 uint32_t Dc2
= extract32(regs
, 6, 3);
631 uint32_t Du1
= extract32(regs
, 3, 3);
632 uint32_t Du2
= extract32(regs
, 0, 3);
633 int16_t c1
= env
->dregs
[Dc1
];
634 int16_t c2
= env
->dregs
[Dc2
];
635 int16_t u1
= env
->dregs
[Du1
];
636 int16_t u2
= env
->dregs
[Du2
];
638 uintptr_t ra
= GETPC();
640 l1
= cpu_lduw_data_ra(env
, a1
, ra
);
641 l2
= cpu_lduw_data_ra(env
, a2
, ra
);
642 if (l1
== c1
&& l2
== c2
) {
643 cpu_stw_data_ra(env
, a1
, u1
, ra
);
644 cpu_stw_data_ra(env
, a2
, u2
, ra
);
654 env
->cc_op
= CC_OP_CMPW
;
655 env
->dregs
[Dc1
] = deposit32(env
->dregs
[Dc1
], 0, 16, l1
);
656 env
->dregs
[Dc2
] = deposit32(env
->dregs
[Dc2
], 0, 16, l2
);
659 static void do_cas2l(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
, uint32_t a2
,
662 uint32_t Dc1
= extract32(regs
, 9, 3);
663 uint32_t Dc2
= extract32(regs
, 6, 3);
664 uint32_t Du1
= extract32(regs
, 3, 3);
665 uint32_t Du2
= extract32(regs
, 0, 3);
666 uint32_t c1
= env
->dregs
[Dc1
];
667 uint32_t c2
= env
->dregs
[Dc2
];
668 uint32_t u1
= env
->dregs
[Du1
];
669 uint32_t u2
= env
->dregs
[Du2
];
671 uintptr_t ra
= GETPC();
672 #if defined(CONFIG_ATOMIC64) && !defined(CONFIG_USER_ONLY)
673 int mmu_idx
= cpu_mmu_index(env
, 0);
678 /* We're executing in a parallel context -- must be atomic. */
679 #ifdef CONFIG_ATOMIC64
681 if ((a1
& 7) == 0 && a2
== a1
+ 4) {
682 c
= deposit64(c2
, 32, 32, c1
);
683 u
= deposit64(u2
, 32, 32, u1
);
684 #ifdef CONFIG_USER_ONLY
685 l
= helper_atomic_cmpxchgq_be(env
, a1
, c
, u
);
687 oi
= make_memop_idx(MO_BEQ
, mmu_idx
);
688 l
= helper_atomic_cmpxchgq_be_mmu(env
, a1
, c
, u
, oi
, ra
);
692 } else if ((a2
& 7) == 0 && a1
== a2
+ 4) {
693 c
= deposit64(c1
, 32, 32, c2
);
694 u
= deposit64(u1
, 32, 32, u2
);
695 #ifdef CONFIG_USER_ONLY
696 l
= helper_atomic_cmpxchgq_be(env
, a2
, c
, u
);
698 oi
= make_memop_idx(MO_BEQ
, mmu_idx
);
699 l
= helper_atomic_cmpxchgq_be_mmu(env
, a2
, c
, u
, oi
, ra
);
706 /* Tell the main loop we need to serialize this insn. */
707 cpu_loop_exit_atomic(ENV_GET_CPU(env
), ra
);
710 /* We're executing in a serial context -- no need to be atomic. */
711 l1
= cpu_ldl_data_ra(env
, a1
, ra
);
712 l2
= cpu_ldl_data_ra(env
, a2
, ra
);
713 if (l1
== c1
&& l2
== c2
) {
714 cpu_stl_data_ra(env
, a1
, u1
, ra
);
715 cpu_stl_data_ra(env
, a2
, u2
, ra
);
726 env
->cc_op
= CC_OP_CMPL
;
727 env
->dregs
[Dc1
] = l1
;
728 env
->dregs
[Dc2
] = l2
;
731 void HELPER(cas2l
)(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
, uint32_t a2
)
733 do_cas2l(env
, regs
, a1
, a2
, false);
736 void HELPER(cas2l_parallel
)(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
,
739 do_cas2l(env
, regs
, a1
, a2
, true);
749 static struct bf_data
bf_prep(uint32_t addr
, int32_t ofs
, uint32_t len
)
753 /* Bound length; map 0 to 32. */
754 len
= ((len
- 1) & 31) + 1;
756 /* Note that ofs is signed. */
764 /* Compute the number of bytes required (minus one) to
765 satisfy the bitfield. */
766 blen
= (bofs
+ len
- 1) / 8;
768 /* Canonicalize the bit offset for data loaded into a 64-bit big-endian
769 word. For the cases where BLEN is not a power of 2, adjust ADDR so
770 that we can use the next power of two sized load without crossing a
771 page boundary, unless the field itself crosses the boundary. */
790 bofs
+= 8 * (addr
& 3);
795 g_assert_not_reached();
798 return (struct bf_data
){
806 static uint64_t bf_load(CPUM68KState
*env
, uint32_t addr
, int blen
,
811 return cpu_ldub_data_ra(env
, addr
, ra
);
813 return cpu_lduw_data_ra(env
, addr
, ra
);
816 return cpu_ldl_data_ra(env
, addr
, ra
);
818 return cpu_ldq_data_ra(env
, addr
, ra
);
820 g_assert_not_reached();
824 static void bf_store(CPUM68KState
*env
, uint32_t addr
, int blen
,
825 uint64_t data
, uintptr_t ra
)
829 cpu_stb_data_ra(env
, addr
, data
, ra
);
832 cpu_stw_data_ra(env
, addr
, data
, ra
);
836 cpu_stl_data_ra(env
, addr
, data
, ra
);
839 cpu_stq_data_ra(env
, addr
, data
, ra
);
842 g_assert_not_reached();
846 uint32_t HELPER(bfexts_mem
)(CPUM68KState
*env
, uint32_t addr
,
847 int32_t ofs
, uint32_t len
)
849 uintptr_t ra
= GETPC();
850 struct bf_data d
= bf_prep(addr
, ofs
, len
);
851 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
853 return (int64_t)(data
<< d
.bofs
) >> (64 - d
.len
);
856 uint64_t HELPER(bfextu_mem
)(CPUM68KState
*env
, uint32_t addr
,
857 int32_t ofs
, uint32_t len
)
859 uintptr_t ra
= GETPC();
860 struct bf_data d
= bf_prep(addr
, ofs
, len
);
861 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
863 /* Put CC_N at the top of the high word; put the zero-extended value
864 at the bottom of the low word. */
867 data
|= data
<< (64 - d
.len
);
872 uint32_t HELPER(bfins_mem
)(CPUM68KState
*env
, uint32_t addr
, uint32_t val
,
873 int32_t ofs
, uint32_t len
)
875 uintptr_t ra
= GETPC();
876 struct bf_data d
= bf_prep(addr
, ofs
, len
);
877 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
878 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
880 data
= (data
& ~mask
) | (((uint64_t)val
<< (64 - d
.len
)) >> d
.bofs
);
882 bf_store(env
, d
.addr
, d
.blen
, data
, ra
);
884 /* The field at the top of the word is also CC_N for CC_OP_LOGIC. */
885 return val
<< (32 - d
.len
);
888 uint32_t HELPER(bfchg_mem
)(CPUM68KState
*env
, uint32_t addr
,
889 int32_t ofs
, uint32_t len
)
891 uintptr_t ra
= GETPC();
892 struct bf_data d
= bf_prep(addr
, ofs
, len
);
893 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
894 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
896 bf_store(env
, d
.addr
, d
.blen
, data
^ mask
, ra
);
898 return ((data
& mask
) << d
.bofs
) >> 32;
901 uint32_t HELPER(bfclr_mem
)(CPUM68KState
*env
, uint32_t addr
,
902 int32_t ofs
, uint32_t len
)
904 uintptr_t ra
= GETPC();
905 struct bf_data d
= bf_prep(addr
, ofs
, len
);
906 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
907 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
909 bf_store(env
, d
.addr
, d
.blen
, data
& ~mask
, ra
);
911 return ((data
& mask
) << d
.bofs
) >> 32;
914 uint32_t HELPER(bfset_mem
)(CPUM68KState
*env
, uint32_t addr
,
915 int32_t ofs
, uint32_t len
)
917 uintptr_t ra
= GETPC();
918 struct bf_data d
= bf_prep(addr
, ofs
, len
);
919 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
920 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
922 bf_store(env
, d
.addr
, d
.blen
, data
| mask
, ra
);
924 return ((data
& mask
) << d
.bofs
) >> 32;
927 uint32_t HELPER(bfffo_reg
)(uint32_t n
, uint32_t ofs
, uint32_t len
)
929 return (n
? clz32(n
) : len
) + ofs
;
932 uint64_t HELPER(bfffo_mem
)(CPUM68KState
*env
, uint32_t addr
,
933 int32_t ofs
, uint32_t len
)
935 uintptr_t ra
= GETPC();
936 struct bf_data d
= bf_prep(addr
, ofs
, len
);
937 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
938 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
939 uint64_t n
= (data
& mask
) << d
.bofs
;
940 uint32_t ffo
= helper_bfffo_reg(n
>> 32, ofs
, d
.len
);
942 /* Return FFO in the low word and N in the high word.
943 Note that because of MASK and the shift, the low word
948 void HELPER(chk
)(CPUM68KState
*env
, int32_t val
, int32_t ub
)
951 * X: Not affected, C,V,Z: Undefined,
952 * N: Set if val < 0; cleared if val > ub, undefined otherwise
953 * We implement here values found from a real MC68040:
954 * X,V,Z: Not affected
955 * N: Set if val < 0; cleared if val >= 0
956 * C: if 0 <= ub: set if val < 0 or val > ub, cleared otherwise
957 * if 0 > ub: set if val > ub and val < 0, cleared otherwise
960 env
->cc_c
= 0 <= ub
? val
< 0 || val
> ub
: val
> ub
&& val
< 0;
962 if (val
< 0 || val
> ub
) {
963 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
965 /* Recover PC and CC_OP for the beginning of the insn. */
966 cpu_restore_state(cs
, GETPC());
968 /* flags have been modified by gen_flush_flags() */
969 env
->cc_op
= CC_OP_FLAGS
;
970 /* Adjust PC to end of the insn. */
973 cs
->exception_index
= EXCP_CHK
;
978 void HELPER(chk2
)(CPUM68KState
*env
, int32_t val
, int32_t lb
, int32_t ub
)
981 * X: Not affected, N,V: Undefined,
982 * Z: Set if val is equal to lb or ub
983 * C: Set if val < lb or val > ub, cleared otherwise
984 * We implement here values found from a real MC68040:
985 * X,N,V: Not affected
986 * Z: Set if val is equal to lb or ub
987 * C: if lb <= ub: set if val < lb or val > ub, cleared otherwise
988 * if lb > ub: set if val > ub and val < lb, cleared otherwise
990 env
->cc_z
= val
!= lb
&& val
!= ub
;
991 env
->cc_c
= lb
<= ub
? val
< lb
|| val
> ub
: val
> ub
&& val
< lb
;
994 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
996 /* Recover PC and CC_OP for the beginning of the insn. */
997 cpu_restore_state(cs
, GETPC());
999 /* flags have been modified by gen_flush_flags() */
1000 env
->cc_op
= CC_OP_FLAGS
;
1001 /* Adjust PC to end of the insn. */
1004 cs
->exception_index
= EXCP_CHK
;