Merge branch 'upstream-merge'
[qemu-kvm.git] / target-m68k / op_helper.c
blobaa005048e10d3ad45b279fc32581f0f6dfb36c6c
1 /*
2 * M68K helper routines
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 "cpu.h"
20 #include "helpers.h"
22 #if defined(CONFIG_USER_ONLY)
24 void do_interrupt(CPUM68KState *env)
26 env->exception_index = -1;
29 void do_interrupt_m68k_hardirq(CPUM68KState *env)
33 #else
35 extern int semihosting_enabled;
37 #include "softmmu_exec.h"
39 #define MMUSUFFIX _mmu
41 #define SHIFT 0
42 #include "softmmu_template.h"
44 #define SHIFT 1
45 #include "softmmu_template.h"
47 #define SHIFT 2
48 #include "softmmu_template.h"
50 #define SHIFT 3
51 #include "softmmu_template.h"
53 /* Try to fill the TLB and return an exception if error. If retaddr is
54 NULL, it means that the function was called in C code (i.e. not
55 from generated code or from helper.c) */
56 void tlb_fill(CPUM68KState *env, target_ulong addr, int is_write, int mmu_idx,
57 uintptr_t retaddr)
59 TranslationBlock *tb;
60 int ret;
62 ret = cpu_m68k_handle_mmu_fault(env, addr, is_write, mmu_idx);
63 if (unlikely(ret)) {
64 if (retaddr) {
65 /* now we have a real cpu fault */
66 tb = tb_find_pc(retaddr);
67 if (tb) {
68 /* the PC is inside the translated code. It means that we have
69 a virtual CPU fault */
70 cpu_restore_state(tb, env, retaddr);
73 cpu_loop_exit(env);
77 static void do_rte(CPUM68KState *env)
79 uint32_t sp;
80 uint32_t fmt;
82 sp = env->aregs[7];
83 fmt = cpu_ldl_kernel(env, sp);
84 env->pc = cpu_ldl_kernel(env, sp + 4);
85 sp |= (fmt >> 28) & 3;
86 env->sr = fmt & 0xffff;
87 m68k_switch_sp(env);
88 env->aregs[7] = sp + 8;
91 static void do_interrupt_all(CPUM68KState *env, int is_hw)
93 uint32_t sp;
94 uint32_t fmt;
95 uint32_t retaddr;
96 uint32_t vector;
98 fmt = 0;
99 retaddr = env->pc;
101 if (!is_hw) {
102 switch (env->exception_index) {
103 case EXCP_RTE:
104 /* Return from an exception. */
105 do_rte(env);
106 return;
107 case EXCP_HALT_INSN:
108 if (semihosting_enabled
109 && (env->sr & SR_S) != 0
110 && (env->pc & 3) == 0
111 && cpu_lduw_code(env, env->pc - 4) == 0x4e71
112 && cpu_ldl_code(env, env->pc) == 0x4e7bf000) {
113 env->pc += 4;
114 do_m68k_semihosting(env, env->dregs[0]);
115 return;
117 env->halted = 1;
118 env->exception_index = EXCP_HLT;
119 cpu_loop_exit(env);
120 return;
122 if (env->exception_index >= EXCP_TRAP0
123 && env->exception_index <= EXCP_TRAP15) {
124 /* Move the PC after the trap instruction. */
125 retaddr += 2;
129 vector = env->exception_index << 2;
131 sp = env->aregs[7];
133 fmt |= 0x40000000;
134 fmt |= (sp & 3) << 28;
135 fmt |= vector << 16;
136 fmt |= env->sr;
138 env->sr |= SR_S;
139 if (is_hw) {
140 env->sr = (env->sr & ~SR_I) | (env->pending_level << SR_I_SHIFT);
141 env->sr &= ~SR_M;
143 m68k_switch_sp(env);
145 /* ??? This could cause MMU faults. */
146 sp &= ~3;
147 sp -= 4;
148 cpu_stl_kernel(env, sp, retaddr);
149 sp -= 4;
150 cpu_stl_kernel(env, sp, fmt);
151 env->aregs[7] = sp;
152 /* Jump to vector. */
153 env->pc = cpu_ldl_kernel(env, env->vbr + vector);
156 void do_interrupt(CPUM68KState *env)
158 do_interrupt_all(env, 0);
161 void do_interrupt_m68k_hardirq(CPUM68KState *env)
163 do_interrupt_all(env, 1);
165 #endif
167 static void raise_exception(CPUM68KState *env, int tt)
169 env->exception_index = tt;
170 cpu_loop_exit(env);
173 void HELPER(raise_exception)(CPUM68KState *env, uint32_t tt)
175 raise_exception(env, tt);
178 void HELPER(divu)(CPUM68KState *env, uint32_t word)
180 uint32_t num;
181 uint32_t den;
182 uint32_t quot;
183 uint32_t rem;
184 uint32_t flags;
186 num = env->div1;
187 den = env->div2;
188 /* ??? This needs to make sure the throwing location is accurate. */
189 if (den == 0) {
190 raise_exception(env, EXCP_DIV0);
192 quot = num / den;
193 rem = num % den;
194 flags = 0;
195 if (word && quot > 0xffff)
196 flags |= CCF_V;
197 if (quot == 0)
198 flags |= CCF_Z;
199 else if ((int32_t)quot < 0)
200 flags |= CCF_N;
201 env->div1 = quot;
202 env->div2 = rem;
203 env->cc_dest = flags;
206 void HELPER(divs)(CPUM68KState *env, uint32_t word)
208 int32_t num;
209 int32_t den;
210 int32_t quot;
211 int32_t rem;
212 int32_t flags;
214 num = env->div1;
215 den = env->div2;
216 if (den == 0) {
217 raise_exception(env, EXCP_DIV0);
219 quot = num / den;
220 rem = num % den;
221 flags = 0;
222 if (word && quot != (int16_t)quot)
223 flags |= CCF_V;
224 if (quot == 0)
225 flags |= CCF_Z;
226 else if (quot < 0)
227 flags |= CCF_N;
228 env->div1 = quot;
229 env->div2 = rem;
230 env->cc_dest = flags;