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
);
50 /* now we have a real cpu fault */
51 cpu_restore_state(cs
, retaddr
);
57 static void do_rte(CPUM68KState
*env
)
63 fmt
= cpu_ldl_kernel(env
, sp
);
64 env
->pc
= cpu_ldl_kernel(env
, sp
+ 4);
65 sp
|= (fmt
>> 28) & 3;
66 env
->aregs
[7] = sp
+ 8;
68 helper_set_sr(env
, fmt
);
71 static void do_interrupt_all(CPUM68KState
*env
, int is_hw
)
73 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
83 switch (cs
->exception_index
) {
85 /* Return from an exception. */
89 if (semihosting_enabled()
90 && (env
->sr
& SR_S
) != 0
92 && cpu_lduw_code(env
, env
->pc
- 4) == 0x4e71
93 && cpu_ldl_code(env
, env
->pc
) == 0x4e7bf000) {
95 do_m68k_semihosting(env
, env
->dregs
[0]);
99 cs
->exception_index
= EXCP_HLT
;
103 if (cs
->exception_index
>= EXCP_TRAP0
104 && cs
->exception_index
<= EXCP_TRAP15
) {
105 /* Move the PC after the trap instruction. */
110 vector
= cs
->exception_index
<< 2;
115 fmt
|= cpu_m68k_get_ccr(env
);
119 env
->sr
= (env
->sr
& ~SR_I
) | (env
->pending_level
<< SR_I_SHIFT
);
124 fmt
|= (sp
& 3) << 28;
126 /* ??? This could cause MMU faults. */
129 cpu_stl_kernel(env
, sp
, retaddr
);
131 cpu_stl_kernel(env
, sp
, fmt
);
133 /* Jump to vector. */
134 env
->pc
= cpu_ldl_kernel(env
, env
->vbr
+ vector
);
137 void m68k_cpu_do_interrupt(CPUState
*cs
)
139 M68kCPU
*cpu
= M68K_CPU(cs
);
140 CPUM68KState
*env
= &cpu
->env
;
142 do_interrupt_all(env
, 0);
145 static inline void do_interrupt_m68k_hardirq(CPUM68KState
*env
)
147 do_interrupt_all(env
, 1);
151 bool m68k_cpu_exec_interrupt(CPUState
*cs
, int interrupt_request
)
153 M68kCPU
*cpu
= M68K_CPU(cs
);
154 CPUM68KState
*env
= &cpu
->env
;
156 if (interrupt_request
& CPU_INTERRUPT_HARD
157 && ((env
->sr
& SR_I
) >> SR_I_SHIFT
) < env
->pending_level
) {
158 /* Real hardware gets the interrupt vector via an IACK cycle
159 at this point. Current emulated hardware doesn't rely on
160 this, so we provide/save the vector when the interrupt is
162 cs
->exception_index
= env
->pending_vector
;
163 do_interrupt_m68k_hardirq(env
);
169 static void QEMU_NORETURN
raise_exception_ra(CPUM68KState
*env
, int tt
, uintptr_t raddr
)
171 CPUState
*cs
= CPU(m68k_env_get_cpu(env
));
173 cs
->exception_index
= tt
;
174 cpu_loop_exit_restore(cs
, raddr
);
177 static void QEMU_NORETURN
raise_exception(CPUM68KState
*env
, int tt
)
179 raise_exception_ra(env
, tt
, 0);
182 void QEMU_NORETURN
HELPER(raise_exception
)(CPUM68KState
*env
, uint32_t tt
)
184 raise_exception(env
, tt
);
187 void HELPER(divuw
)(CPUM68KState
*env
, int destr
, uint32_t den
)
189 uint32_t num
= env
->dregs
[destr
];
193 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
198 env
->cc_c
= 0; /* always cleared, even if overflow */
201 /* real 68040 keeps N and unset Z on overflow,
202 * whereas documentation says "undefined"
207 env
->dregs
[destr
] = deposit32(quot
, 16, 16, rem
);
208 env
->cc_z
= (int16_t)quot
;
209 env
->cc_n
= (int16_t)quot
;
213 void HELPER(divsw
)(CPUM68KState
*env
, int destr
, int32_t den
)
215 int32_t num
= env
->dregs
[destr
];
219 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
224 env
->cc_c
= 0; /* always cleared, even if overflow */
225 if (quot
!= (int16_t)quot
) {
227 /* nothing else is modified */
228 /* real 68040 keeps N and unset Z on overflow,
229 * whereas documentation says "undefined"
234 env
->dregs
[destr
] = deposit32(quot
, 16, 16, rem
);
235 env
->cc_z
= (int16_t)quot
;
236 env
->cc_n
= (int16_t)quot
;
240 void HELPER(divul
)(CPUM68KState
*env
, int numr
, int regr
, uint32_t den
)
242 uint32_t num
= env
->dregs
[numr
];
246 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
256 if (m68k_feature(env
, M68K_FEATURE_CF_ISA_A
)) {
258 env
->dregs
[numr
] = quot
;
260 env
->dregs
[regr
] = rem
;
263 env
->dregs
[regr
] = rem
;
264 env
->dregs
[numr
] = quot
;
268 void HELPER(divsl
)(CPUM68KState
*env
, int numr
, int regr
, int32_t den
)
270 int32_t num
= env
->dregs
[numr
];
274 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
284 if (m68k_feature(env
, M68K_FEATURE_CF_ISA_A
)) {
286 env
->dregs
[numr
] = quot
;
288 env
->dregs
[regr
] = rem
;
291 env
->dregs
[regr
] = rem
;
292 env
->dregs
[numr
] = quot
;
296 void HELPER(divull
)(CPUM68KState
*env
, int numr
, int regr
, uint32_t den
)
298 uint64_t num
= deposit64(env
->dregs
[numr
], 32, 32, env
->dregs
[regr
]);
303 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
308 env
->cc_c
= 0; /* always cleared, even if overflow */
309 if (quot
> 0xffffffffULL
) {
311 /* real 68040 keeps N and unset Z on overflow,
312 * whereas documentation says "undefined"
322 * If Dq and Dr are the same, the quotient is returned.
323 * therefore we set Dq last.
326 env
->dregs
[regr
] = rem
;
327 env
->dregs
[numr
] = quot
;
330 void HELPER(divsll
)(CPUM68KState
*env
, int numr
, int regr
, int32_t den
)
332 int64_t num
= deposit64(env
->dregs
[numr
], 32, 32, env
->dregs
[regr
]);
337 raise_exception_ra(env
, EXCP_DIV0
, GETPC());
342 env
->cc_c
= 0; /* always cleared, even if overflow */
343 if (quot
!= (int32_t)quot
) {
345 /* real 68040 keeps N and unset Z on overflow,
346 * whereas documentation says "undefined"
356 * If Dq and Dr are the same, the quotient is returned.
357 * therefore we set Dq last.
360 env
->dregs
[regr
] = rem
;
361 env
->dregs
[numr
] = quot
;
364 /* We're executing in a serial context -- no need to be atomic. */
365 void HELPER(cas2w
)(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
, uint32_t a2
)
367 uint32_t Dc1
= extract32(regs
, 9, 3);
368 uint32_t Dc2
= extract32(regs
, 6, 3);
369 uint32_t Du1
= extract32(regs
, 3, 3);
370 uint32_t Du2
= extract32(regs
, 0, 3);
371 int16_t c1
= env
->dregs
[Dc1
];
372 int16_t c2
= env
->dregs
[Dc2
];
373 int16_t u1
= env
->dregs
[Du1
];
374 int16_t u2
= env
->dregs
[Du2
];
376 uintptr_t ra
= GETPC();
378 l1
= cpu_lduw_data_ra(env
, a1
, ra
);
379 l2
= cpu_lduw_data_ra(env
, a2
, ra
);
380 if (l1
== c1
&& l2
== c2
) {
381 cpu_stw_data_ra(env
, a1
, u1
, ra
);
382 cpu_stw_data_ra(env
, a2
, u2
, ra
);
392 env
->cc_op
= CC_OP_CMPW
;
393 env
->dregs
[Dc1
] = deposit32(env
->dregs
[Dc1
], 0, 16, l1
);
394 env
->dregs
[Dc2
] = deposit32(env
->dregs
[Dc2
], 0, 16, l2
);
397 static void do_cas2l(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
, uint32_t a2
,
400 uint32_t Dc1
= extract32(regs
, 9, 3);
401 uint32_t Dc2
= extract32(regs
, 6, 3);
402 uint32_t Du1
= extract32(regs
, 3, 3);
403 uint32_t Du2
= extract32(regs
, 0, 3);
404 uint32_t c1
= env
->dregs
[Dc1
];
405 uint32_t c2
= env
->dregs
[Dc2
];
406 uint32_t u1
= env
->dregs
[Du1
];
407 uint32_t u2
= env
->dregs
[Du2
];
409 uintptr_t ra
= GETPC();
410 #if defined(CONFIG_ATOMIC64) && !defined(CONFIG_USER_ONLY)
411 int mmu_idx
= cpu_mmu_index(env
, 0);
416 /* We're executing in a parallel context -- must be atomic. */
417 #ifdef CONFIG_ATOMIC64
419 if ((a1
& 7) == 0 && a2
== a1
+ 4) {
420 c
= deposit64(c2
, 32, 32, c1
);
421 u
= deposit64(u2
, 32, 32, u1
);
422 #ifdef CONFIG_USER_ONLY
423 l
= helper_atomic_cmpxchgq_be(env
, a1
, c
, u
);
425 oi
= make_memop_idx(MO_BEQ
, mmu_idx
);
426 l
= helper_atomic_cmpxchgq_be_mmu(env
, a1
, c
, u
, oi
, ra
);
430 } else if ((a2
& 7) == 0 && a1
== a2
+ 4) {
431 c
= deposit64(c1
, 32, 32, c2
);
432 u
= deposit64(u1
, 32, 32, u2
);
433 #ifdef CONFIG_USER_ONLY
434 l
= helper_atomic_cmpxchgq_be(env
, a2
, c
, u
);
436 oi
= make_memop_idx(MO_BEQ
, mmu_idx
);
437 l
= helper_atomic_cmpxchgq_be_mmu(env
, a2
, c
, u
, oi
, ra
);
444 /* Tell the main loop we need to serialize this insn. */
445 cpu_loop_exit_atomic(ENV_GET_CPU(env
), ra
);
448 /* We're executing in a serial context -- no need to be atomic. */
449 l1
= cpu_ldl_data_ra(env
, a1
, ra
);
450 l2
= cpu_ldl_data_ra(env
, a2
, ra
);
451 if (l1
== c1
&& l2
== c2
) {
452 cpu_stl_data_ra(env
, a1
, u1
, ra
);
453 cpu_stl_data_ra(env
, a2
, u2
, ra
);
464 env
->cc_op
= CC_OP_CMPL
;
465 env
->dregs
[Dc1
] = l1
;
466 env
->dregs
[Dc2
] = l2
;
469 void HELPER(cas2l
)(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
, uint32_t a2
)
471 do_cas2l(env
, regs
, a1
, a2
, false);
474 void HELPER(cas2l_parallel
)(CPUM68KState
*env
, uint32_t regs
, uint32_t a1
,
477 do_cas2l(env
, regs
, a1
, a2
, true);
487 static struct bf_data
bf_prep(uint32_t addr
, int32_t ofs
, uint32_t len
)
491 /* Bound length; map 0 to 32. */
492 len
= ((len
- 1) & 31) + 1;
494 /* Note that ofs is signed. */
502 /* Compute the number of bytes required (minus one) to
503 satisfy the bitfield. */
504 blen
= (bofs
+ len
- 1) / 8;
506 /* Canonicalize the bit offset for data loaded into a 64-bit big-endian
507 word. For the cases where BLEN is not a power of 2, adjust ADDR so
508 that we can use the next power of two sized load without crossing a
509 page boundary, unless the field itself crosses the boundary. */
528 bofs
+= 8 * (addr
& 3);
533 g_assert_not_reached();
536 return (struct bf_data
){
544 static uint64_t bf_load(CPUM68KState
*env
, uint32_t addr
, int blen
,
549 return cpu_ldub_data_ra(env
, addr
, ra
);
551 return cpu_lduw_data_ra(env
, addr
, ra
);
554 return cpu_ldl_data_ra(env
, addr
, ra
);
556 return cpu_ldq_data_ra(env
, addr
, ra
);
558 g_assert_not_reached();
562 static void bf_store(CPUM68KState
*env
, uint32_t addr
, int blen
,
563 uint64_t data
, uintptr_t ra
)
567 cpu_stb_data_ra(env
, addr
, data
, ra
);
570 cpu_stw_data_ra(env
, addr
, data
, ra
);
574 cpu_stl_data_ra(env
, addr
, data
, ra
);
577 cpu_stq_data_ra(env
, addr
, data
, ra
);
580 g_assert_not_reached();
584 uint32_t HELPER(bfexts_mem
)(CPUM68KState
*env
, uint32_t addr
,
585 int32_t ofs
, uint32_t len
)
587 uintptr_t ra
= GETPC();
588 struct bf_data d
= bf_prep(addr
, ofs
, len
);
589 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
591 return (int64_t)(data
<< d
.bofs
) >> (64 - d
.len
);
594 uint64_t HELPER(bfextu_mem
)(CPUM68KState
*env
, uint32_t addr
,
595 int32_t ofs
, uint32_t len
)
597 uintptr_t ra
= GETPC();
598 struct bf_data d
= bf_prep(addr
, ofs
, len
);
599 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
601 /* Put CC_N at the top of the high word; put the zero-extended value
602 at the bottom of the low word. */
605 data
|= data
<< (64 - d
.len
);
610 uint32_t HELPER(bfins_mem
)(CPUM68KState
*env
, uint32_t addr
, uint32_t val
,
611 int32_t ofs
, uint32_t len
)
613 uintptr_t ra
= GETPC();
614 struct bf_data d
= bf_prep(addr
, ofs
, len
);
615 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
616 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
618 data
= (data
& ~mask
) | (((uint64_t)val
<< (64 - d
.len
)) >> d
.bofs
);
620 bf_store(env
, d
.addr
, d
.blen
, data
, ra
);
622 /* The field at the top of the word is also CC_N for CC_OP_LOGIC. */
623 return val
<< (32 - d
.len
);
626 uint32_t HELPER(bfchg_mem
)(CPUM68KState
*env
, uint32_t addr
,
627 int32_t ofs
, uint32_t len
)
629 uintptr_t ra
= GETPC();
630 struct bf_data d
= bf_prep(addr
, ofs
, len
);
631 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
632 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
634 bf_store(env
, d
.addr
, d
.blen
, data
^ mask
, ra
);
636 return ((data
& mask
) << d
.bofs
) >> 32;
639 uint32_t HELPER(bfclr_mem
)(CPUM68KState
*env
, uint32_t addr
,
640 int32_t ofs
, uint32_t len
)
642 uintptr_t ra
= GETPC();
643 struct bf_data d
= bf_prep(addr
, ofs
, len
);
644 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
645 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
647 bf_store(env
, d
.addr
, d
.blen
, data
& ~mask
, ra
);
649 return ((data
& mask
) << d
.bofs
) >> 32;
652 uint32_t HELPER(bfset_mem
)(CPUM68KState
*env
, uint32_t addr
,
653 int32_t ofs
, uint32_t len
)
655 uintptr_t ra
= GETPC();
656 struct bf_data d
= bf_prep(addr
, ofs
, len
);
657 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
658 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
660 bf_store(env
, d
.addr
, d
.blen
, data
| mask
, ra
);
662 return ((data
& mask
) << d
.bofs
) >> 32;
665 uint32_t HELPER(bfffo_reg
)(uint32_t n
, uint32_t ofs
, uint32_t len
)
667 return (n
? clz32(n
) : len
) + ofs
;
670 uint64_t HELPER(bfffo_mem
)(CPUM68KState
*env
, uint32_t addr
,
671 int32_t ofs
, uint32_t len
)
673 uintptr_t ra
= GETPC();
674 struct bf_data d
= bf_prep(addr
, ofs
, len
);
675 uint64_t data
= bf_load(env
, d
.addr
, d
.blen
, ra
);
676 uint64_t mask
= -1ull << (64 - d
.len
) >> d
.bofs
;
677 uint64_t n
= (data
& mask
) << d
.bofs
;
678 uint32_t ffo
= helper_bfffo_reg(n
>> 32, ofs
, d
.len
);
680 /* Return FFO in the low word and N in the high word.
681 Note that because of MASK and the shift, the low word