xref: /openbmc/qemu/linux-user/ppc/cpu_loop.c (revision eeae5466)
1 /*
2  *  qemu user cpu loop
3  *
4  *  Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program 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
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include "qemu/osdep.h"
21 #include "qemu-common.h"
22 #include "qemu.h"
23 #include "cpu_loop-common.h"
24 
25 static inline uint64_t cpu_ppc_get_tb(CPUPPCState *env)
26 {
27     return cpu_get_host_ticks();
28 }
29 
30 uint64_t cpu_ppc_load_tbl(CPUPPCState *env)
31 {
32     return cpu_ppc_get_tb(env);
33 }
34 
35 uint32_t cpu_ppc_load_tbu(CPUPPCState *env)
36 {
37     return cpu_ppc_get_tb(env) >> 32;
38 }
39 
40 uint64_t cpu_ppc_load_atbl(CPUPPCState *env)
41 {
42     return cpu_ppc_get_tb(env);
43 }
44 
45 uint32_t cpu_ppc_load_atbu(CPUPPCState *env)
46 {
47     return cpu_ppc_get_tb(env) >> 32;
48 }
49 
50 uint64_t cpu_ppc_load_vtb(CPUPPCState *env)
51 {
52     return cpu_ppc_get_tb(env);
53 }
54 
55 uint32_t cpu_ppc601_load_rtcu(CPUPPCState *env)
56 __attribute__ (( alias ("cpu_ppc_load_tbu") ));
57 
58 uint32_t cpu_ppc601_load_rtcl(CPUPPCState *env)
59 {
60     return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
61 }
62 
63 /* XXX: to be fixed */
64 int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, uint32_t *valp)
65 {
66     return -1;
67 }
68 
69 int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val)
70 {
71     return -1;
72 }
73 
74 void cpu_loop(CPUPPCState *env)
75 {
76     CPUState *cs = env_cpu(env);
77     target_siginfo_t info;
78     int trapnr;
79     target_ulong ret;
80 
81     for(;;) {
82         bool arch_interrupt;
83 
84         cpu_exec_start(cs);
85         trapnr = cpu_exec(cs);
86         cpu_exec_end(cs);
87         process_queued_cpu_work(cs);
88 
89         arch_interrupt = true;
90         switch (trapnr) {
91         case POWERPC_EXCP_NONE:
92             /* Just go on */
93             break;
94         case POWERPC_EXCP_CRITICAL: /* Critical input                        */
95             cpu_abort(cs, "Critical interrupt while in user mode. "
96                       "Aborting\n");
97             break;
98         case POWERPC_EXCP_MCHECK:   /* Machine check exception               */
99             cpu_abort(cs, "Machine check exception while in user mode. "
100                       "Aborting\n");
101             break;
102         case POWERPC_EXCP_DSI:      /* Data storage exception                */
103             /* XXX: check this. Seems bugged */
104             switch (env->error_code & 0xFF000000) {
105             case 0x40000000:
106             case 0x42000000:
107                 info.si_signo = TARGET_SIGSEGV;
108                 info.si_errno = 0;
109                 info.si_code = TARGET_SEGV_MAPERR;
110                 break;
111             case 0x04000000:
112                 info.si_signo = TARGET_SIGILL;
113                 info.si_errno = 0;
114                 info.si_code = TARGET_ILL_ILLADR;
115                 break;
116             case 0x08000000:
117                 info.si_signo = TARGET_SIGSEGV;
118                 info.si_errno = 0;
119                 info.si_code = TARGET_SEGV_ACCERR;
120                 break;
121             default:
122                 /* Let's send a regular segfault... */
123                 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
124                           env->error_code);
125                 info.si_signo = TARGET_SIGSEGV;
126                 info.si_errno = 0;
127                 info.si_code = TARGET_SEGV_MAPERR;
128                 break;
129             }
130             info._sifields._sigfault._addr = env->spr[SPR_DAR];
131             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
132             break;
133         case POWERPC_EXCP_ISI:      /* Instruction storage exception         */
134             /* XXX: check this */
135             switch (env->error_code & 0xFF000000) {
136             case 0x40000000:
137                 info.si_signo = TARGET_SIGSEGV;
138             info.si_errno = 0;
139                 info.si_code = TARGET_SEGV_MAPERR;
140                 break;
141             case 0x10000000:
142             case 0x08000000:
143                 info.si_signo = TARGET_SIGSEGV;
144                 info.si_errno = 0;
145                 info.si_code = TARGET_SEGV_ACCERR;
146                 break;
147             default:
148                 /* Let's send a regular segfault... */
149                 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
150                           env->error_code);
151                 info.si_signo = TARGET_SIGSEGV;
152                 info.si_errno = 0;
153                 info.si_code = TARGET_SEGV_MAPERR;
154                 break;
155             }
156             info._sifields._sigfault._addr = env->nip - 4;
157             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
158             break;
159         case POWERPC_EXCP_EXTERNAL: /* External input                        */
160             cpu_abort(cs, "External interrupt while in user mode. "
161                       "Aborting\n");
162             break;
163         case POWERPC_EXCP_ALIGN:    /* Alignment exception                   */
164             /* XXX: check this */
165             info.si_signo = TARGET_SIGBUS;
166             info.si_errno = 0;
167             info.si_code = TARGET_BUS_ADRALN;
168             info._sifields._sigfault._addr = env->nip;
169             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
170             break;
171         case POWERPC_EXCP_PROGRAM:  /* Program exception                     */
172         case POWERPC_EXCP_HV_EMU:   /* HV emulation                          */
173             /* XXX: check this */
174             switch (env->error_code & ~0xF) {
175             case POWERPC_EXCP_FP:
176                 info.si_signo = TARGET_SIGFPE;
177                 info.si_errno = 0;
178                 switch (env->error_code & 0xF) {
179                 case POWERPC_EXCP_FP_OX:
180                     info.si_code = TARGET_FPE_FLTOVF;
181                     break;
182                 case POWERPC_EXCP_FP_UX:
183                     info.si_code = TARGET_FPE_FLTUND;
184                     break;
185                 case POWERPC_EXCP_FP_ZX:
186                 case POWERPC_EXCP_FP_VXZDZ:
187                     info.si_code = TARGET_FPE_FLTDIV;
188                     break;
189                 case POWERPC_EXCP_FP_XX:
190                     info.si_code = TARGET_FPE_FLTRES;
191                     break;
192                 case POWERPC_EXCP_FP_VXSOFT:
193                     info.si_code = TARGET_FPE_FLTINV;
194                     break;
195                 case POWERPC_EXCP_FP_VXSNAN:
196                 case POWERPC_EXCP_FP_VXISI:
197                 case POWERPC_EXCP_FP_VXIDI:
198                 case POWERPC_EXCP_FP_VXIMZ:
199                 case POWERPC_EXCP_FP_VXVC:
200                 case POWERPC_EXCP_FP_VXSQRT:
201                 case POWERPC_EXCP_FP_VXCVI:
202                     info.si_code = TARGET_FPE_FLTSUB;
203                     break;
204                 default:
205                     EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
206                               env->error_code);
207                     break;
208                 }
209                 break;
210             case POWERPC_EXCP_INVAL:
211                 info.si_signo = TARGET_SIGILL;
212                 info.si_errno = 0;
213                 switch (env->error_code & 0xF) {
214                 case POWERPC_EXCP_INVAL_INVAL:
215                     info.si_code = TARGET_ILL_ILLOPC;
216                     break;
217                 case POWERPC_EXCP_INVAL_LSWX:
218                     info.si_code = TARGET_ILL_ILLOPN;
219                     break;
220                 case POWERPC_EXCP_INVAL_SPR:
221                     info.si_code = TARGET_ILL_PRVREG;
222                     break;
223                 case POWERPC_EXCP_INVAL_FP:
224                     info.si_code = TARGET_ILL_COPROC;
225                     break;
226                 default:
227                     EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
228                               env->error_code & 0xF);
229                     info.si_code = TARGET_ILL_ILLADR;
230                     break;
231                 }
232                 break;
233             case POWERPC_EXCP_PRIV:
234                 info.si_signo = TARGET_SIGILL;
235                 info.si_errno = 0;
236                 switch (env->error_code & 0xF) {
237                 case POWERPC_EXCP_PRIV_OPC:
238                     info.si_code = TARGET_ILL_PRVOPC;
239                     break;
240                 case POWERPC_EXCP_PRIV_REG:
241                     info.si_code = TARGET_ILL_PRVREG;
242                     break;
243                 default:
244                     EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
245                               env->error_code & 0xF);
246                     info.si_code = TARGET_ILL_PRVOPC;
247                     break;
248                 }
249                 break;
250             case POWERPC_EXCP_TRAP:
251                 cpu_abort(cs, "Tried to call a TRAP\n");
252                 break;
253             default:
254                 /* Should not happen ! */
255                 cpu_abort(cs, "Unknown program exception (%02x)\n",
256                           env->error_code);
257                 break;
258             }
259             info._sifields._sigfault._addr = env->nip;
260             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
261             break;
262         case POWERPC_EXCP_FPU:      /* Floating-point unavailable exception  */
263             info.si_signo = TARGET_SIGILL;
264             info.si_errno = 0;
265             info.si_code = TARGET_ILL_COPROC;
266             info._sifields._sigfault._addr = env->nip;
267             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
268             break;
269         case POWERPC_EXCP_SYSCALL:  /* System call exception                 */
270         case POWERPC_EXCP_SYSCALL_VECTORED:
271             cpu_abort(cs, "Syscall exception while in user mode. "
272                       "Aborting\n");
273             break;
274         case POWERPC_EXCP_APU:      /* Auxiliary processor unavailable       */
275             info.si_signo = TARGET_SIGILL;
276             info.si_errno = 0;
277             info.si_code = TARGET_ILL_COPROC;
278             info._sifields._sigfault._addr = env->nip;
279             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
280             break;
281         case POWERPC_EXCP_DECR:     /* Decrementer exception                 */
282             cpu_abort(cs, "Decrementer interrupt while in user mode. "
283                       "Aborting\n");
284             break;
285         case POWERPC_EXCP_FIT:      /* Fixed-interval timer interrupt        */
286             cpu_abort(cs, "Fix interval timer interrupt while in user mode. "
287                       "Aborting\n");
288             break;
289         case POWERPC_EXCP_WDT:      /* Watchdog timer interrupt              */
290             cpu_abort(cs, "Watchdog timer interrupt while in user mode. "
291                       "Aborting\n");
292             break;
293         case POWERPC_EXCP_DTLB:     /* Data TLB error                        */
294             cpu_abort(cs, "Data TLB exception while in user mode. "
295                       "Aborting\n");
296             break;
297         case POWERPC_EXCP_ITLB:     /* Instruction TLB error                 */
298             cpu_abort(cs, "Instruction TLB exception while in user mode. "
299                       "Aborting\n");
300             break;
301         case POWERPC_EXCP_SPEU:     /* SPE/embedded floating-point unavail.  */
302             info.si_signo = TARGET_SIGILL;
303             info.si_errno = 0;
304             info.si_code = TARGET_ILL_COPROC;
305             info._sifields._sigfault._addr = env->nip;
306             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
307             break;
308         case POWERPC_EXCP_EFPDI:    /* Embedded floating-point data IRQ      */
309             cpu_abort(cs, "Embedded floating-point data IRQ not handled\n");
310             break;
311         case POWERPC_EXCP_EFPRI:    /* Embedded floating-point round IRQ     */
312             cpu_abort(cs, "Embedded floating-point round IRQ not handled\n");
313             break;
314         case POWERPC_EXCP_EPERFM:   /* Embedded performance monitor IRQ      */
315             cpu_abort(cs, "Performance monitor exception not handled\n");
316             break;
317         case POWERPC_EXCP_DOORI:    /* Embedded doorbell interrupt           */
318             cpu_abort(cs, "Doorbell interrupt while in user mode. "
319                        "Aborting\n");
320             break;
321         case POWERPC_EXCP_DOORCI:   /* Embedded doorbell critical interrupt  */
322             cpu_abort(cs, "Doorbell critical interrupt while in user mode. "
323                       "Aborting\n");
324             break;
325         case POWERPC_EXCP_RESET:    /* System reset exception                */
326             cpu_abort(cs, "Reset interrupt while in user mode. "
327                       "Aborting\n");
328             break;
329         case POWERPC_EXCP_DSEG:     /* Data segment exception                */
330             cpu_abort(cs, "Data segment exception while in user mode. "
331                       "Aborting\n");
332             break;
333         case POWERPC_EXCP_ISEG:     /* Instruction segment exception         */
334             cpu_abort(cs, "Instruction segment exception "
335                       "while in user mode. Aborting\n");
336             break;
337         /* PowerPC 64 with hypervisor mode support */
338         case POWERPC_EXCP_HDECR:    /* Hypervisor decrementer exception      */
339             cpu_abort(cs, "Hypervisor decrementer interrupt "
340                       "while in user mode. Aborting\n");
341             break;
342         case POWERPC_EXCP_TRACE:    /* Trace exception                       */
343             /* Nothing to do:
344              * we use this exception to emulate step-by-step execution mode.
345              */
346             break;
347         /* PowerPC 64 with hypervisor mode support */
348         case POWERPC_EXCP_HDSI:     /* Hypervisor data storage exception     */
349             cpu_abort(cs, "Hypervisor data storage exception "
350                       "while in user mode. Aborting\n");
351             break;
352         case POWERPC_EXCP_HISI:     /* Hypervisor instruction storage excp   */
353             cpu_abort(cs, "Hypervisor instruction storage exception "
354                       "while in user mode. Aborting\n");
355             break;
356         case POWERPC_EXCP_HDSEG:    /* Hypervisor data segment exception     */
357             cpu_abort(cs, "Hypervisor data segment exception "
358                       "while in user mode. Aborting\n");
359             break;
360         case POWERPC_EXCP_HISEG:    /* Hypervisor instruction segment excp   */
361             cpu_abort(cs, "Hypervisor instruction segment exception "
362                       "while in user mode. Aborting\n");
363             break;
364         case POWERPC_EXCP_VPU:      /* Vector unavailable exception          */
365             info.si_signo = TARGET_SIGILL;
366             info.si_errno = 0;
367             info.si_code = TARGET_ILL_COPROC;
368             info._sifields._sigfault._addr = env->nip;
369             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
370             break;
371         case POWERPC_EXCP_PIT:      /* Programmable interval timer IRQ       */
372             cpu_abort(cs, "Programmable interval timer interrupt "
373                       "while in user mode. Aborting\n");
374             break;
375         case POWERPC_EXCP_IO:       /* IO error exception                    */
376             cpu_abort(cs, "IO error exception while in user mode. "
377                       "Aborting\n");
378             break;
379         case POWERPC_EXCP_RUNM:     /* Run mode exception                    */
380             cpu_abort(cs, "Run mode exception while in user mode. "
381                       "Aborting\n");
382             break;
383         case POWERPC_EXCP_EMUL:     /* Emulation trap exception              */
384             cpu_abort(cs, "Emulation trap exception not handled\n");
385             break;
386         case POWERPC_EXCP_IFTLB:    /* Instruction fetch TLB error           */
387             cpu_abort(cs, "Instruction fetch TLB exception "
388                       "while in user-mode. Aborting");
389             break;
390         case POWERPC_EXCP_DLTLB:    /* Data load TLB miss                    */
391             cpu_abort(cs, "Data load TLB exception while in user-mode. "
392                       "Aborting");
393             break;
394         case POWERPC_EXCP_DSTLB:    /* Data store TLB miss                   */
395             cpu_abort(cs, "Data store TLB exception while in user-mode. "
396                       "Aborting");
397             break;
398         case POWERPC_EXCP_FPA:      /* Floating-point assist exception       */
399             cpu_abort(cs, "Floating-point assist exception not handled\n");
400             break;
401         case POWERPC_EXCP_IABR:     /* Instruction address breakpoint        */
402             cpu_abort(cs, "Instruction address breakpoint exception "
403                       "not handled\n");
404             break;
405         case POWERPC_EXCP_SMI:      /* System management interrupt           */
406             cpu_abort(cs, "System management interrupt while in user mode. "
407                       "Aborting\n");
408             break;
409         case POWERPC_EXCP_THERM:    /* Thermal interrupt                     */
410             cpu_abort(cs, "Thermal interrupt interrupt while in user mode. "
411                       "Aborting\n");
412             break;
413         case POWERPC_EXCP_PERFM:   /* Embedded performance monitor IRQ      */
414             cpu_abort(cs, "Performance monitor exception not handled\n");
415             break;
416         case POWERPC_EXCP_VPUA:     /* Vector assist exception               */
417             cpu_abort(cs, "Vector assist exception not handled\n");
418             break;
419         case POWERPC_EXCP_SOFTP:    /* Soft patch exception                  */
420             cpu_abort(cs, "Soft patch exception not handled\n");
421             break;
422         case POWERPC_EXCP_MAINT:    /* Maintenance exception                 */
423             cpu_abort(cs, "Maintenance exception while in user mode. "
424                       "Aborting\n");
425             break;
426         case POWERPC_EXCP_SYSCALL_USER:
427             /* system call in user-mode emulation */
428             /* WARNING:
429              * PPC ABI uses overflow flag in cr0 to signal an error
430              * in syscalls.
431              */
432             env->crf[0] &= ~0x1;
433             env->nip += 4;
434             ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
435                              env->gpr[5], env->gpr[6], env->gpr[7],
436                              env->gpr[8], 0, 0);
437             if (ret == -TARGET_ERESTARTSYS) {
438                 env->nip -= 4;
439                 break;
440             }
441             if (ret == (target_ulong)(-TARGET_QEMU_ESIGRETURN)) {
442                 /* Returning from a successful sigreturn syscall.
443                    Avoid corrupting register state.  */
444                 break;
445             }
446             if (ret > (target_ulong)(-515)) {
447                 env->crf[0] |= 0x1;
448                 ret = -ret;
449             }
450             env->gpr[3] = ret;
451             break;
452         case EXCP_DEBUG:
453             info.si_signo = TARGET_SIGTRAP;
454             info.si_errno = 0;
455             info.si_code = TARGET_TRAP_BRKPT;
456             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
457             break;
458         case EXCP_INTERRUPT:
459             /* just indicate that signals should be handled asap */
460             break;
461         case EXCP_ATOMIC:
462             cpu_exec_step_atomic(cs);
463             arch_interrupt = false;
464             break;
465         default:
466             cpu_abort(cs, "Unknown exception 0x%x. Aborting\n", trapnr);
467             break;
468         }
469         process_pending_signals(env);
470 
471         /* Most of the traps imply a transition through kernel mode,
472          * which implies an REI instruction has been executed.  Which
473          * means that RX and LOCK_ADDR should be cleared.  But there
474          * are a few exceptions for traps internal to QEMU.
475          */
476         if (arch_interrupt) {
477             env->reserve_addr = -1;
478         }
479     }
480 }
481 
482 void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs)
483 {
484     int i;
485 
486 #if defined(TARGET_PPC64)
487     int flag = (env->insns_flags2 & PPC2_BOOKE206) ? MSR_CM : MSR_SF;
488 #if defined(TARGET_ABI32)
489     ppc_store_msr(env, env->msr & ~((target_ulong)1 << flag));
490 #else
491     ppc_store_msr(env, env->msr | (target_ulong)1 << flag);
492 #endif
493 #endif
494 
495     env->nip = regs->nip;
496     for(i = 0; i < 32; i++) {
497         env->gpr[i] = regs->gpr[i];
498     }
499 }
500