Statistics
| Branch: | Revision:

root / linux-user / main.c @ eda52953

History | View | Annotate | Download (84.2 kB)

1
/*
2
 *  qemu user main
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, write to the Free Software
18
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
 */
20
#include <stdlib.h>
21
#include <stdio.h>
22
#include <stdarg.h>
23
#include <string.h>
24
#include <errno.h>
25
#include <unistd.h>
26

    
27
#include "qemu.h"
28
#include "qemu-common.h"
29
/* For tb_lock */
30
#include "exec-all.h"
31

    
32
#define DEBUG_LOGFILE "/tmp/qemu.log"
33

    
34
static const char *interp_prefix = CONFIG_QEMU_PREFIX;
35
const char *qemu_uname_release = CONFIG_UNAME_RELEASE;
36

    
37
#if defined(__i386__) && !defined(CONFIG_STATIC)
38
/* Force usage of an ELF interpreter even if it is an ELF shared
39
   object ! */
40
const char interp[] __attribute__((section(".interp"))) = "/lib/ld-linux.so.2";
41
#endif
42

    
43
/* for recent libc, we add these dummy symbols which are not declared
44
   when generating a linked object (bug in ld ?) */
45
#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(CONFIG_STATIC)
46
asm(".globl __preinit_array_start\n"
47
    ".globl __preinit_array_end\n"
48
    ".globl __init_array_start\n"
49
    ".globl __init_array_end\n"
50
    ".globl __fini_array_start\n"
51
    ".globl __fini_array_end\n"
52
    ".section \".rodata\"\n"
53
    "__preinit_array_start:\n"
54
    "__preinit_array_end:\n"
55
    "__init_array_start:\n"
56
    "__init_array_end:\n"
57
    "__fini_array_start:\n"
58
    "__fini_array_end:\n"
59
    ".long 0\n"
60
    ".previous\n");
61
#endif
62

    
63
/* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
64
   we allocate a bigger stack. Need a better solution, for example
65
   by remapping the process stack directly at the right place */
66
unsigned long x86_stack_size = 512 * 1024;
67

    
68
void gemu_log(const char *fmt, ...)
69
{
70
    va_list ap;
71

    
72
    va_start(ap, fmt);
73
    vfprintf(stderr, fmt, ap);
74
    va_end(ap);
75
}
76

    
77
void cpu_outb(CPUState *env, int addr, int val)
78
{
79
    fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);
80
}
81

    
82
void cpu_outw(CPUState *env, int addr, int val)
83
{
84
    fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);
85
}
86

    
87
void cpu_outl(CPUState *env, int addr, int val)
88
{
89
    fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);
90
}
91

    
92
int cpu_inb(CPUState *env, int addr)
93
{
94
    fprintf(stderr, "inb: port=0x%04x\n", addr);
95
    return 0;
96
}
97

    
98
int cpu_inw(CPUState *env, int addr)
99
{
100
    fprintf(stderr, "inw: port=0x%04x\n", addr);
101
    return 0;
102
}
103

    
104
int cpu_inl(CPUState *env, int addr)
105
{
106
    fprintf(stderr, "inl: port=0x%04x\n", addr);
107
    return 0;
108
}
109

    
110
#if defined(TARGET_I386)
111
int cpu_get_pic_interrupt(CPUState *env)
112
{
113
    return -1;
114
}
115
#endif
116

    
117
/* timers for rdtsc */
118

    
119
#if 0
120

121
static uint64_t emu_time;
122

123
int64_t cpu_get_real_ticks(void)
124
{
125
    return emu_time++;
126
}
127

128
#endif
129

    
130
#if defined(USE_NPTL)
131
/***********************************************************/
132
/* Helper routines for implementing atomic operations.  */
133

    
134
/* To implement exclusive operations we force all cpus to syncronise.
135
   We don't require a full sync, only that no cpus are executing guest code.
136
   The alternative is to map target atomic ops onto host equivalents,
137
   which requires quite a lot of per host/target work.  */
138
static pthread_mutex_t exclusive_lock = PTHREAD_MUTEX_INITIALIZER;
139
static pthread_cond_t exclusive_cond = PTHREAD_COND_INITIALIZER;
140
static pthread_cond_t exclusive_resume = PTHREAD_COND_INITIALIZER;
141
static int pending_cpus;
142

    
143
/* Make sure everything is in a consistent state for calling fork().  */
144
void fork_start(void)
145
{
146
    mmap_fork_start();
147
    pthread_mutex_lock(&tb_lock);
148
    pthread_mutex_lock(&exclusive_lock);
149
}
150

    
151
void fork_end(int child)
152
{
153
    if (child) {
154
        /* Child processes created by fork() only have a single thread.
155
           Discard information about the parent threads.  */
156
        first_cpu = thread_env;
157
        thread_env->next_cpu = NULL;
158
        pending_cpus = 0;
159
        pthread_mutex_init(&exclusive_lock, NULL);
160
        pthread_cond_init(&exclusive_cond, NULL);
161
        pthread_cond_init(&exclusive_resume, NULL);
162
        pthread_mutex_init(&tb_lock, NULL);
163
    } else {
164
        pthread_mutex_unlock(&exclusive_lock);
165
        pthread_mutex_unlock(&tb_lock);
166
    }
167
    mmap_fork_end(child);
168
}
169

    
170
/* Wait for pending exclusive operations to complete.  The exclusive lock
171
   must be held.  */
172
static inline void exclusive_idle(void)
173
{
174
    while (pending_cpus) {
175
        pthread_cond_wait(&exclusive_resume, &exclusive_lock);
176
    }
177
}
178

    
179
/* Start an exclusive operation.
180
   Must only be called from outside cpu_arm_exec.   */
181
static inline void start_exclusive(void)
182
{
183
    CPUState *other;
184
    pthread_mutex_lock(&exclusive_lock);
185
    exclusive_idle();
186

    
187
    pending_cpus = 1;
188
    /* Make all other cpus stop executing.  */
189
    for (other = first_cpu; other; other = other->next_cpu) {
190
        if (other->running) {
191
            pending_cpus++;
192
            cpu_interrupt(other, CPU_INTERRUPT_EXIT);
193
        }
194
    }
195
    if (pending_cpus > 1) {
196
        pthread_cond_wait(&exclusive_cond, &exclusive_lock);
197
    }
198
}
199

    
200
/* Finish an exclusive operation.  */
201
static inline void end_exclusive(void)
202
{
203
    pending_cpus = 0;
204
    pthread_cond_broadcast(&exclusive_resume);
205
    pthread_mutex_unlock(&exclusive_lock);
206
}
207

    
208
/* Wait for exclusive ops to finish, and begin cpu execution.  */
209
static inline void cpu_exec_start(CPUState *env)
210
{
211
    pthread_mutex_lock(&exclusive_lock);
212
    exclusive_idle();
213
    env->running = 1;
214
    pthread_mutex_unlock(&exclusive_lock);
215
}
216

    
217
/* Mark cpu as not executing, and release pending exclusive ops.  */
218
static inline void cpu_exec_end(CPUState *env)
219
{
220
    pthread_mutex_lock(&exclusive_lock);
221
    env->running = 0;
222
    if (pending_cpus > 1) {
223
        pending_cpus--;
224
        if (pending_cpus == 1) {
225
            pthread_cond_signal(&exclusive_cond);
226
        }
227
    }
228
    exclusive_idle();
229
    pthread_mutex_unlock(&exclusive_lock);
230
}
231
#else /* if !USE_NPTL */
232
/* These are no-ops because we are not threadsafe.  */
233
static inline void cpu_exec_start(CPUState *env)
234
{
235
}
236

    
237
static inline void cpu_exec_end(CPUState *env)
238
{
239
}
240

    
241
static inline void start_exclusive(void)
242
{
243
}
244

    
245
static inline void end_exclusive(void)
246
{
247
}
248

    
249
void fork_start(void)
250
{
251
}
252

    
253
void fork_end(int child)
254
{
255
}
256
#endif
257

    
258

    
259
#ifdef TARGET_I386
260
/***********************************************************/
261
/* CPUX86 core interface */
262

    
263
void cpu_smm_update(CPUState *env)
264
{
265
}
266

    
267
uint64_t cpu_get_tsc(CPUX86State *env)
268
{
269
    return cpu_get_real_ticks();
270
}
271

    
272
static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
273
                     int flags)
274
{
275
    unsigned int e1, e2;
276
    uint32_t *p;
277
    e1 = (addr << 16) | (limit & 0xffff);
278
    e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
279
    e2 |= flags;
280
    p = ptr;
281
    p[0] = tswap32(e1);
282
    p[1] = tswap32(e2);
283
}
284

    
285
#if TARGET_X86_64
286
uint64_t idt_table[512];
287

    
288
static void set_gate64(void *ptr, unsigned int type, unsigned int dpl,
289
                       uint64_t addr, unsigned int sel)
290
{
291
    uint32_t *p, e1, e2;
292
    e1 = (addr & 0xffff) | (sel << 16);
293
    e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
294
    p = ptr;
295
    p[0] = tswap32(e1);
296
    p[1] = tswap32(e2);
297
    p[2] = tswap32(addr >> 32);
298
    p[3] = 0;
299
}
300
/* only dpl matters as we do only user space emulation */
301
static void set_idt(int n, unsigned int dpl)
302
{
303
    set_gate64(idt_table + n * 2, 0, dpl, 0, 0);
304
}
305
#else
306
uint64_t idt_table[256];
307

    
308
static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
309
                     uint32_t addr, unsigned int sel)
310
{
311
    uint32_t *p, e1, e2;
312
    e1 = (addr & 0xffff) | (sel << 16);
313
    e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
314
    p = ptr;
315
    p[0] = tswap32(e1);
316
    p[1] = tswap32(e2);
317
}
318

    
319
/* only dpl matters as we do only user space emulation */
320
static void set_idt(int n, unsigned int dpl)
321
{
322
    set_gate(idt_table + n, 0, dpl, 0, 0);
323
}
324
#endif
325

    
326
void cpu_loop(CPUX86State *env)
327
{
328
    int trapnr;
329
    abi_ulong pc;
330
    target_siginfo_t info;
331

    
332
    for(;;) {
333
        trapnr = cpu_x86_exec(env);
334
        switch(trapnr) {
335
        case 0x80:
336
            /* linux syscall from int $0x80 */
337
            env->regs[R_EAX] = do_syscall(env,
338
                                          env->regs[R_EAX],
339
                                          env->regs[R_EBX],
340
                                          env->regs[R_ECX],
341
                                          env->regs[R_EDX],
342
                                          env->regs[R_ESI],
343
                                          env->regs[R_EDI],
344
                                          env->regs[R_EBP]);
345
            break;
346
#ifndef TARGET_ABI32
347
        case EXCP_SYSCALL:
348
            /* linux syscall from syscall intruction */
349
            env->regs[R_EAX] = do_syscall(env,
350
                                          env->regs[R_EAX],
351
                                          env->regs[R_EDI],
352
                                          env->regs[R_ESI],
353
                                          env->regs[R_EDX],
354
                                          env->regs[10],
355
                                          env->regs[8],
356
                                          env->regs[9]);
357
            env->eip = env->exception_next_eip;
358
            break;
359
#endif
360
        case EXCP0B_NOSEG:
361
        case EXCP0C_STACK:
362
            info.si_signo = SIGBUS;
363
            info.si_errno = 0;
364
            info.si_code = TARGET_SI_KERNEL;
365
            info._sifields._sigfault._addr = 0;
366
            queue_signal(env, info.si_signo, &info);
367
            break;
368
        case EXCP0D_GPF:
369
            /* XXX: potential problem if ABI32 */
370
#ifndef TARGET_X86_64
371
            if (env->eflags & VM_MASK) {
372
                handle_vm86_fault(env);
373
            } else
374
#endif
375
            {
376
                info.si_signo = SIGSEGV;
377
                info.si_errno = 0;
378
                info.si_code = TARGET_SI_KERNEL;
379
                info._sifields._sigfault._addr = 0;
380
                queue_signal(env, info.si_signo, &info);
381
            }
382
            break;
383
        case EXCP0E_PAGE:
384
            info.si_signo = SIGSEGV;
385
            info.si_errno = 0;
386
            if (!(env->error_code & 1))
387
                info.si_code = TARGET_SEGV_MAPERR;
388
            else
389
                info.si_code = TARGET_SEGV_ACCERR;
390
            info._sifields._sigfault._addr = env->cr[2];
391
            queue_signal(env, info.si_signo, &info);
392
            break;
393
        case EXCP00_DIVZ:
394
#ifndef TARGET_X86_64
395
            if (env->eflags & VM_MASK) {
396
                handle_vm86_trap(env, trapnr);
397
            } else
398
#endif
399
            {
400
                /* division by zero */
401
                info.si_signo = SIGFPE;
402
                info.si_errno = 0;
403
                info.si_code = TARGET_FPE_INTDIV;
404
                info._sifields._sigfault._addr = env->eip;
405
                queue_signal(env, info.si_signo, &info);
406
            }
407
            break;
408
        case EXCP01_SSTP:
409
        case EXCP03_INT3:
410
#ifndef TARGET_X86_64
411
            if (env->eflags & VM_MASK) {
412
                handle_vm86_trap(env, trapnr);
413
            } else
414
#endif
415
            {
416
                info.si_signo = SIGTRAP;
417
                info.si_errno = 0;
418
                if (trapnr == EXCP01_SSTP) {
419
                    info.si_code = TARGET_TRAP_BRKPT;
420
                    info._sifields._sigfault._addr = env->eip;
421
                } else {
422
                    info.si_code = TARGET_SI_KERNEL;
423
                    info._sifields._sigfault._addr = 0;
424
                }
425
                queue_signal(env, info.si_signo, &info);
426
            }
427
            break;
428
        case EXCP04_INTO:
429
        case EXCP05_BOUND:
430
#ifndef TARGET_X86_64
431
            if (env->eflags & VM_MASK) {
432
                handle_vm86_trap(env, trapnr);
433
            } else
434
#endif
435
            {
436
                info.si_signo = SIGSEGV;
437
                info.si_errno = 0;
438
                info.si_code = TARGET_SI_KERNEL;
439
                info._sifields._sigfault._addr = 0;
440
                queue_signal(env, info.si_signo, &info);
441
            }
442
            break;
443
        case EXCP06_ILLOP:
444
            info.si_signo = SIGILL;
445
            info.si_errno = 0;
446
            info.si_code = TARGET_ILL_ILLOPN;
447
            info._sifields._sigfault._addr = env->eip;
448
            queue_signal(env, info.si_signo, &info);
449
            break;
450
        case EXCP_INTERRUPT:
451
            /* just indicate that signals should be handled asap */
452
            break;
453
        case EXCP_DEBUG:
454
            {
455
                int sig;
456

    
457
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
458
                if (sig)
459
                  {
460
                    info.si_signo = sig;
461
                    info.si_errno = 0;
462
                    info.si_code = TARGET_TRAP_BRKPT;
463
                    queue_signal(env, info.si_signo, &info);
464
                  }
465
            }
466
            break;
467
        default:
468
            pc = env->segs[R_CS].base + env->eip;
469
            fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
470
                    (long)pc, trapnr);
471
            abort();
472
        }
473
        process_pending_signals(env);
474
    }
475
}
476
#endif
477

    
478
#ifdef TARGET_ARM
479

    
480
/* XXX: find a better solution */
481
extern void tb_invalidate_page_range(abi_ulong start, abi_ulong end);
482

    
483
static void arm_cache_flush(abi_ulong start, abi_ulong last)
484
{
485
    abi_ulong addr, last1;
486

    
487
    if (last < start)
488
        return;
489
    addr = start;
490
    for(;;) {
491
        last1 = ((addr + TARGET_PAGE_SIZE) & TARGET_PAGE_MASK) - 1;
492
        if (last1 > last)
493
            last1 = last;
494
        tb_invalidate_page_range(addr, last1 + 1);
495
        if (last1 == last)
496
            break;
497
        addr = last1 + 1;
498
    }
499
}
500

    
501
/* Handle a jump to the kernel code page.  */
502
static int
503
do_kernel_trap(CPUARMState *env)
504
{
505
    uint32_t addr;
506
    uint32_t cpsr;
507
    uint32_t val;
508

    
509
    switch (env->regs[15]) {
510
    case 0xffff0fa0: /* __kernel_memory_barrier */
511
        /* ??? No-op. Will need to do better for SMP.  */
512
        break;
513
    case 0xffff0fc0: /* __kernel_cmpxchg */
514
         /* XXX: This only works between threads, not between processes.
515
            It's probably possible to implement this with native host
516
            operations. However things like ldrex/strex are much harder so
517
            there's not much point trying.  */
518
        start_exclusive();
519
        cpsr = cpsr_read(env);
520
        addr = env->regs[2];
521
        /* FIXME: This should SEGV if the access fails.  */
522
        if (get_user_u32(val, addr))
523
            val = ~env->regs[0];
524
        if (val == env->regs[0]) {
525
            val = env->regs[1];
526
            /* FIXME: Check for segfaults.  */
527
            put_user_u32(val, addr);
528
            env->regs[0] = 0;
529
            cpsr |= CPSR_C;
530
        } else {
531
            env->regs[0] = -1;
532
            cpsr &= ~CPSR_C;
533
        }
534
        cpsr_write(env, cpsr, CPSR_C);
535
        end_exclusive();
536
        break;
537
    case 0xffff0fe0: /* __kernel_get_tls */
538
        env->regs[0] = env->cp15.c13_tls2;
539
        break;
540
    default:
541
        return 1;
542
    }
543
    /* Jump back to the caller.  */
544
    addr = env->regs[14];
545
    if (addr & 1) {
546
        env->thumb = 1;
547
        addr &= ~1;
548
    }
549
    env->regs[15] = addr;
550

    
551
    return 0;
552
}
553

    
554
void cpu_loop(CPUARMState *env)
555
{
556
    int trapnr;
557
    unsigned int n, insn;
558
    target_siginfo_t info;
559
    uint32_t addr;
560

    
561
    for(;;) {
562
        cpu_exec_start(env);
563
        trapnr = cpu_arm_exec(env);
564
        cpu_exec_end(env);
565
        switch(trapnr) {
566
        case EXCP_UDEF:
567
            {
568
                TaskState *ts = env->opaque;
569
                uint32_t opcode;
570
                int rc;
571

    
572
                /* we handle the FPU emulation here, as Linux */
573
                /* we get the opcode */
574
                /* FIXME - what to do if get_user() fails? */
575
                get_user_u32(opcode, env->regs[15]);
576

    
577
                rc = EmulateAll(opcode, &ts->fpa, env);
578
                if (rc == 0) { /* illegal instruction */
579
                    info.si_signo = SIGILL;
580
                    info.si_errno = 0;
581
                    info.si_code = TARGET_ILL_ILLOPN;
582
                    info._sifields._sigfault._addr = env->regs[15];
583
                    queue_signal(env, info.si_signo, &info);
584
                } else if (rc < 0) { /* FP exception */
585
                    int arm_fpe=0;
586

    
587
                    /* translate softfloat flags to FPSR flags */
588
                    if (-rc & float_flag_invalid)
589
                      arm_fpe |= BIT_IOC;
590
                    if (-rc & float_flag_divbyzero)
591
                      arm_fpe |= BIT_DZC;
592
                    if (-rc & float_flag_overflow)
593
                      arm_fpe |= BIT_OFC;
594
                    if (-rc & float_flag_underflow)
595
                      arm_fpe |= BIT_UFC;
596
                    if (-rc & float_flag_inexact)
597
                      arm_fpe |= BIT_IXC;
598

    
599
                    FPSR fpsr = ts->fpa.fpsr;
600
                    //printf("fpsr 0x%x, arm_fpe 0x%x\n",fpsr,arm_fpe);
601

    
602
                    if (fpsr & (arm_fpe << 16)) { /* exception enabled? */
603
                      info.si_signo = SIGFPE;
604
                      info.si_errno = 0;
605

    
606
                      /* ordered by priority, least first */
607
                      if (arm_fpe & BIT_IXC) info.si_code = TARGET_FPE_FLTRES;
608
                      if (arm_fpe & BIT_UFC) info.si_code = TARGET_FPE_FLTUND;
609
                      if (arm_fpe & BIT_OFC) info.si_code = TARGET_FPE_FLTOVF;
610
                      if (arm_fpe & BIT_DZC) info.si_code = TARGET_FPE_FLTDIV;
611
                      if (arm_fpe & BIT_IOC) info.si_code = TARGET_FPE_FLTINV;
612

    
613
                      info._sifields._sigfault._addr = env->regs[15];
614
                      queue_signal(env, info.si_signo, &info);
615
                    } else {
616
                      env->regs[15] += 4;
617
                    }
618

    
619
                    /* accumulate unenabled exceptions */
620
                    if ((!(fpsr & BIT_IXE)) && (arm_fpe & BIT_IXC))
621
                      fpsr |= BIT_IXC;
622
                    if ((!(fpsr & BIT_UFE)) && (arm_fpe & BIT_UFC))
623
                      fpsr |= BIT_UFC;
624
                    if ((!(fpsr & BIT_OFE)) && (arm_fpe & BIT_OFC))
625
                      fpsr |= BIT_OFC;
626
                    if ((!(fpsr & BIT_DZE)) && (arm_fpe & BIT_DZC))
627
                      fpsr |= BIT_DZC;
628
                    if ((!(fpsr & BIT_IOE)) && (arm_fpe & BIT_IOC))
629
                      fpsr |= BIT_IOC;
630
                    ts->fpa.fpsr=fpsr;
631
                } else { /* everything OK */
632
                    /* increment PC */
633
                    env->regs[15] += 4;
634
                }
635
            }
636
            break;
637
        case EXCP_SWI:
638
        case EXCP_BKPT:
639
            {
640
                env->eabi = 1;
641
                /* system call */
642
                if (trapnr == EXCP_BKPT) {
643
                    if (env->thumb) {
644
                        /* FIXME - what to do if get_user() fails? */
645
                        get_user_u16(insn, env->regs[15]);
646
                        n = insn & 0xff;
647
                        env->regs[15] += 2;
648
                    } else {
649
                        /* FIXME - what to do if get_user() fails? */
650
                        get_user_u32(insn, env->regs[15]);
651
                        n = (insn & 0xf) | ((insn >> 4) & 0xff0);
652
                        env->regs[15] += 4;
653
                    }
654
                } else {
655
                    if (env->thumb) {
656
                        /* FIXME - what to do if get_user() fails? */
657
                        get_user_u16(insn, env->regs[15] - 2);
658
                        n = insn & 0xff;
659
                    } else {
660
                        /* FIXME - what to do if get_user() fails? */
661
                        get_user_u32(insn, env->regs[15] - 4);
662
                        n = insn & 0xffffff;
663
                    }
664
                }
665

    
666
                if (n == ARM_NR_cacheflush) {
667
                    arm_cache_flush(env->regs[0], env->regs[1]);
668
                } else if (n == ARM_NR_semihosting
669
                           || n == ARM_NR_thumb_semihosting) {
670
                    env->regs[0] = do_arm_semihosting (env);
671
                } else if (n == 0 || n >= ARM_SYSCALL_BASE
672
                           || (env->thumb && n == ARM_THUMB_SYSCALL)) {
673
                    /* linux syscall */
674
                    if (env->thumb || n == 0) {
675
                        n = env->regs[7];
676
                    } else {
677
                        n -= ARM_SYSCALL_BASE;
678
                        env->eabi = 0;
679
                    }
680
                    if ( n > ARM_NR_BASE) {
681
                        switch (n) {
682
                        case ARM_NR_cacheflush:
683
                            arm_cache_flush(env->regs[0], env->regs[1]);
684
                            break;
685
                        case ARM_NR_set_tls:
686
                            cpu_set_tls(env, env->regs[0]);
687
                            env->regs[0] = 0;
688
                            break;
689
                        default:
690
                            gemu_log("qemu: Unsupported ARM syscall: 0x%x\n",
691
                                     n);
692
                            env->regs[0] = -TARGET_ENOSYS;
693
                            break;
694
                        }
695
                    } else {
696
                        env->regs[0] = do_syscall(env,
697
                                                  n,
698
                                                  env->regs[0],
699
                                                  env->regs[1],
700
                                                  env->regs[2],
701
                                                  env->regs[3],
702
                                                  env->regs[4],
703
                                                  env->regs[5]);
704
                    }
705
                } else {
706
                    goto error;
707
                }
708
            }
709
            break;
710
        case EXCP_INTERRUPT:
711
            /* just indicate that signals should be handled asap */
712
            break;
713
        case EXCP_PREFETCH_ABORT:
714
            addr = env->cp15.c6_insn;
715
            goto do_segv;
716
        case EXCP_DATA_ABORT:
717
            addr = env->cp15.c6_data;
718
            goto do_segv;
719
        do_segv:
720
            {
721
                info.si_signo = SIGSEGV;
722
                info.si_errno = 0;
723
                /* XXX: check env->error_code */
724
                info.si_code = TARGET_SEGV_MAPERR;
725
                info._sifields._sigfault._addr = addr;
726
                queue_signal(env, info.si_signo, &info);
727
            }
728
            break;
729
        case EXCP_DEBUG:
730
            {
731
                int sig;
732

    
733
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
734
                if (sig)
735
                  {
736
                    info.si_signo = sig;
737
                    info.si_errno = 0;
738
                    info.si_code = TARGET_TRAP_BRKPT;
739
                    queue_signal(env, info.si_signo, &info);
740
                  }
741
            }
742
            break;
743
        case EXCP_KERNEL_TRAP:
744
            if (do_kernel_trap(env))
745
              goto error;
746
            break;
747
        default:
748
        error:
749
            fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
750
                    trapnr);
751
            cpu_dump_state(env, stderr, fprintf, 0);
752
            abort();
753
        }
754
        process_pending_signals(env);
755
    }
756
}
757

    
758
#endif
759

    
760
#ifdef TARGET_SPARC
761

    
762
//#define DEBUG_WIN
763

    
764
/* WARNING: dealing with register windows _is_ complicated. More info
765
   can be found at http://www.sics.se/~psm/sparcstack.html */
766
static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
767
{
768
    index = (index + cwp * 16) % (16 * env->nwindows);
769
    /* wrap handling : if cwp is on the last window, then we use the
770
       registers 'after' the end */
771
    if (index < 8 && env->cwp == env->nwindows - 1)
772
        index += 16 * env->nwindows;
773
    return index;
774
}
775

    
776
/* save the register window 'cwp1' */
777
static inline void save_window_offset(CPUSPARCState *env, int cwp1)
778
{
779
    unsigned int i;
780
    abi_ulong sp_ptr;
781

    
782
    sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
783
#if defined(DEBUG_WIN)
784
    printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
785
           sp_ptr, cwp1);
786
#endif
787
    for(i = 0; i < 16; i++) {
788
        /* FIXME - what to do if put_user() fails? */
789
        put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
790
        sp_ptr += sizeof(abi_ulong);
791
    }
792
}
793

    
794
static void save_window(CPUSPARCState *env)
795
{
796
#ifndef TARGET_SPARC64
797
    unsigned int new_wim;
798
    new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) &
799
        ((1LL << env->nwindows) - 1);
800
    save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
801
    env->wim = new_wim;
802
#else
803
    save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
804
    env->cansave++;
805
    env->canrestore--;
806
#endif
807
}
808

    
809
static void restore_window(CPUSPARCState *env)
810
{
811
#ifndef TARGET_SPARC64
812
    unsigned int new_wim;
813
#endif
814
    unsigned int i, cwp1;
815
    abi_ulong sp_ptr;
816

    
817
#ifndef TARGET_SPARC64
818
    new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) &
819
        ((1LL << env->nwindows) - 1);
820
#endif
821

    
822
    /* restore the invalid window */
823
    cwp1 = cpu_cwp_inc(env, env->cwp + 1);
824
    sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
825
#if defined(DEBUG_WIN)
826
    printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
827
           sp_ptr, cwp1);
828
#endif
829
    for(i = 0; i < 16; i++) {
830
        /* FIXME - what to do if get_user() fails? */
831
        get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
832
        sp_ptr += sizeof(abi_ulong);
833
    }
834
#ifdef TARGET_SPARC64
835
    env->canrestore++;
836
    if (env->cleanwin < env->nwindows - 1)
837
        env->cleanwin++;
838
    env->cansave--;
839
#else
840
    env->wim = new_wim;
841
#endif
842
}
843

    
844
static void flush_windows(CPUSPARCState *env)
845
{
846
    int offset, cwp1;
847

    
848
    offset = 1;
849
    for(;;) {
850
        /* if restore would invoke restore_window(), then we can stop */
851
        cwp1 = cpu_cwp_inc(env, env->cwp + offset);
852
#ifndef TARGET_SPARC64
853
        if (env->wim & (1 << cwp1))
854
            break;
855
#else
856
        if (env->canrestore == 0)
857
            break;
858
        env->cansave++;
859
        env->canrestore--;
860
#endif
861
        save_window_offset(env, cwp1);
862
        offset++;
863
    }
864
    cwp1 = cpu_cwp_inc(env, env->cwp + 1);
865
#ifndef TARGET_SPARC64
866
    /* set wim so that restore will reload the registers */
867
    env->wim = 1 << cwp1;
868
#endif
869
#if defined(DEBUG_WIN)
870
    printf("flush_windows: nb=%d\n", offset - 1);
871
#endif
872
}
873

    
874
void cpu_loop (CPUSPARCState *env)
875
{
876
    int trapnr, ret;
877
    target_siginfo_t info;
878

    
879
    while (1) {
880
        trapnr = cpu_sparc_exec (env);
881

    
882
        switch (trapnr) {
883
#ifndef TARGET_SPARC64
884
        case 0x88:
885
        case 0x90:
886
#else
887
        case 0x110:
888
        case 0x16d:
889
#endif
890
            ret = do_syscall (env, env->gregs[1],
891
                              env->regwptr[0], env->regwptr[1],
892
                              env->regwptr[2], env->regwptr[3],
893
                              env->regwptr[4], env->regwptr[5]);
894
            if ((unsigned int)ret >= (unsigned int)(-515)) {
895
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
896
                env->xcc |= PSR_CARRY;
897
#else
898
                env->psr |= PSR_CARRY;
899
#endif
900
                ret = -ret;
901
            } else {
902
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
903
                env->xcc &= ~PSR_CARRY;
904
#else
905
                env->psr &= ~PSR_CARRY;
906
#endif
907
            }
908
            env->regwptr[0] = ret;
909
            /* next instruction */
910
            env->pc = env->npc;
911
            env->npc = env->npc + 4;
912
            break;
913
        case 0x83: /* flush windows */
914
#ifdef TARGET_ABI32
915
        case 0x103:
916
#endif
917
            flush_windows(env);
918
            /* next instruction */
919
            env->pc = env->npc;
920
            env->npc = env->npc + 4;
921
            break;
922
#ifndef TARGET_SPARC64
923
        case TT_WIN_OVF: /* window overflow */
924
            save_window(env);
925
            break;
926
        case TT_WIN_UNF: /* window underflow */
927
            restore_window(env);
928
            break;
929
        case TT_TFAULT:
930
        case TT_DFAULT:
931
            {
932
                info.si_signo = SIGSEGV;
933
                info.si_errno = 0;
934
                /* XXX: check env->error_code */
935
                info.si_code = TARGET_SEGV_MAPERR;
936
                info._sifields._sigfault._addr = env->mmuregs[4];
937
                queue_signal(env, info.si_signo, &info);
938
            }
939
            break;
940
#else
941
        case TT_SPILL: /* window overflow */
942
            save_window(env);
943
            break;
944
        case TT_FILL: /* window underflow */
945
            restore_window(env);
946
            break;
947
        case TT_TFAULT:
948
        case TT_DFAULT:
949
            {
950
                info.si_signo = SIGSEGV;
951
                info.si_errno = 0;
952
                /* XXX: check env->error_code */
953
                info.si_code = TARGET_SEGV_MAPERR;
954
                if (trapnr == TT_DFAULT)
955
                    info._sifields._sigfault._addr = env->dmmuregs[4];
956
                else
957
                    info._sifields._sigfault._addr = env->tsptr->tpc;
958
                queue_signal(env, info.si_signo, &info);
959
            }
960
            break;
961
#ifndef TARGET_ABI32
962
        case 0x16e:
963
            flush_windows(env);
964
            sparc64_get_context(env);
965
            break;
966
        case 0x16f:
967
            flush_windows(env);
968
            sparc64_set_context(env);
969
            break;
970
#endif
971
#endif
972
        case EXCP_INTERRUPT:
973
            /* just indicate that signals should be handled asap */
974
            break;
975
        case EXCP_DEBUG:
976
            {
977
                int sig;
978

    
979
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
980
                if (sig)
981
                  {
982
                    info.si_signo = sig;
983
                    info.si_errno = 0;
984
                    info.si_code = TARGET_TRAP_BRKPT;
985
                    queue_signal(env, info.si_signo, &info);
986
                  }
987
            }
988
            break;
989
        default:
990
            printf ("Unhandled trap: 0x%x\n", trapnr);
991
            cpu_dump_state(env, stderr, fprintf, 0);
992
            exit (1);
993
        }
994
        process_pending_signals (env);
995
    }
996
}
997

    
998
#endif
999

    
1000
#ifdef TARGET_PPC
1001
static inline uint64_t cpu_ppc_get_tb (CPUState *env)
1002
{
1003
    /* TO FIX */
1004
    return 0;
1005
}
1006

    
1007
uint32_t cpu_ppc_load_tbl (CPUState *env)
1008
{
1009
    return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
1010
}
1011

    
1012
uint32_t cpu_ppc_load_tbu (CPUState *env)
1013
{
1014
    return cpu_ppc_get_tb(env) >> 32;
1015
}
1016

    
1017
uint32_t cpu_ppc_load_atbl (CPUState *env)
1018
{
1019
    return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
1020
}
1021

    
1022
uint32_t cpu_ppc_load_atbu (CPUState *env)
1023
{
1024
    return cpu_ppc_get_tb(env) >> 32;
1025
}
1026

    
1027
uint32_t cpu_ppc601_load_rtcu (CPUState *env)
1028
__attribute__ (( alias ("cpu_ppc_load_tbu") ));
1029

    
1030
uint32_t cpu_ppc601_load_rtcl (CPUState *env)
1031
{
1032
    return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
1033
}
1034

    
1035
/* XXX: to be fixed */
1036
int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, target_ulong *valp)
1037
{
1038
    return -1;
1039
}
1040

    
1041
int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, target_ulong val)
1042
{
1043
    return -1;
1044
}
1045

    
1046
#define EXCP_DUMP(env, fmt, args...)                                         \
1047
do {                                                                          \
1048
    fprintf(stderr, fmt , ##args);                                            \
1049
    cpu_dump_state(env, stderr, fprintf, 0);                                  \
1050
    if (loglevel != 0) {                                                      \
1051
        fprintf(logfile, fmt , ##args);                                       \
1052
        cpu_dump_state(env, logfile, fprintf, 0);                             \
1053
    }                                                                         \
1054
} while (0)
1055

    
1056
void cpu_loop(CPUPPCState *env)
1057
{
1058
    target_siginfo_t info;
1059
    int trapnr;
1060
    uint32_t ret;
1061

    
1062
    for(;;) {
1063
        trapnr = cpu_ppc_exec(env);
1064
        switch(trapnr) {
1065
        case POWERPC_EXCP_NONE:
1066
            /* Just go on */
1067
            break;
1068
        case POWERPC_EXCP_CRITICAL: /* Critical input                        */
1069
            cpu_abort(env, "Critical interrupt while in user mode. "
1070
                      "Aborting\n");
1071
            break;
1072
        case POWERPC_EXCP_MCHECK:   /* Machine check exception               */
1073
            cpu_abort(env, "Machine check exception while in user mode. "
1074
                      "Aborting\n");
1075
            break;
1076
        case POWERPC_EXCP_DSI:      /* Data storage exception                */
1077
            EXCP_DUMP(env, "Invalid data memory access: 0x" ADDRX "\n",
1078
                      env->spr[SPR_DAR]);
1079
            /* XXX: check this. Seems bugged */
1080
            switch (env->error_code & 0xFF000000) {
1081
            case 0x40000000:
1082
                info.si_signo = TARGET_SIGSEGV;
1083
                info.si_errno = 0;
1084
                info.si_code = TARGET_SEGV_MAPERR;
1085
                break;
1086
            case 0x04000000:
1087
                info.si_signo = TARGET_SIGILL;
1088
                info.si_errno = 0;
1089
                info.si_code = TARGET_ILL_ILLADR;
1090
                break;
1091
            case 0x08000000:
1092
                info.si_signo = TARGET_SIGSEGV;
1093
                info.si_errno = 0;
1094
                info.si_code = TARGET_SEGV_ACCERR;
1095
                break;
1096
            default:
1097
                /* Let's send a regular segfault... */
1098
                EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
1099
                          env->error_code);
1100
                info.si_signo = TARGET_SIGSEGV;
1101
                info.si_errno = 0;
1102
                info.si_code = TARGET_SEGV_MAPERR;
1103
                break;
1104
            }
1105
            info._sifields._sigfault._addr = env->nip;
1106
            queue_signal(env, info.si_signo, &info);
1107
            break;
1108
        case POWERPC_EXCP_ISI:      /* Instruction storage exception         */
1109
            EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" ADDRX "\n",
1110
                      env->spr[SPR_SRR0]);
1111
            /* XXX: check this */
1112
            switch (env->error_code & 0xFF000000) {
1113
            case 0x40000000:
1114
                info.si_signo = TARGET_SIGSEGV;
1115
            info.si_errno = 0;
1116
                info.si_code = TARGET_SEGV_MAPERR;
1117
                break;
1118
            case 0x10000000:
1119
            case 0x08000000:
1120
                info.si_signo = TARGET_SIGSEGV;
1121
                info.si_errno = 0;
1122
                info.si_code = TARGET_SEGV_ACCERR;
1123
                break;
1124
            default:
1125
                /* Let's send a regular segfault... */
1126
                EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
1127
                          env->error_code);
1128
                info.si_signo = TARGET_SIGSEGV;
1129
                info.si_errno = 0;
1130
                info.si_code = TARGET_SEGV_MAPERR;
1131
                break;
1132
            }
1133
            info._sifields._sigfault._addr = env->nip - 4;
1134
            queue_signal(env, info.si_signo, &info);
1135
            break;
1136
        case POWERPC_EXCP_EXTERNAL: /* External input                        */
1137
            cpu_abort(env, "External interrupt while in user mode. "
1138
                      "Aborting\n");
1139
            break;
1140
        case POWERPC_EXCP_ALIGN:    /* Alignment exception                   */
1141
            EXCP_DUMP(env, "Unaligned memory access\n");
1142
            /* XXX: check this */
1143
            info.si_signo = TARGET_SIGBUS;
1144
            info.si_errno = 0;
1145
            info.si_code = TARGET_BUS_ADRALN;
1146
            info._sifields._sigfault._addr = env->nip - 4;
1147
            queue_signal(env, info.si_signo, &info);
1148
            break;
1149
        case POWERPC_EXCP_PROGRAM:  /* Program exception                     */
1150
            /* XXX: check this */
1151
            switch (env->error_code & ~0xF) {
1152
            case POWERPC_EXCP_FP:
1153
                EXCP_DUMP(env, "Floating point program exception\n");
1154
                info.si_signo = TARGET_SIGFPE;
1155
                info.si_errno = 0;
1156
                switch (env->error_code & 0xF) {
1157
                case POWERPC_EXCP_FP_OX:
1158
                    info.si_code = TARGET_FPE_FLTOVF;
1159
                    break;
1160
                case POWERPC_EXCP_FP_UX:
1161
                    info.si_code = TARGET_FPE_FLTUND;
1162
                    break;
1163
                case POWERPC_EXCP_FP_ZX:
1164
                case POWERPC_EXCP_FP_VXZDZ:
1165
                    info.si_code = TARGET_FPE_FLTDIV;
1166
                    break;
1167
                case POWERPC_EXCP_FP_XX:
1168
                    info.si_code = TARGET_FPE_FLTRES;
1169
                    break;
1170
                case POWERPC_EXCP_FP_VXSOFT:
1171
                    info.si_code = TARGET_FPE_FLTINV;
1172
                    break;
1173
                case POWERPC_EXCP_FP_VXSNAN:
1174
                case POWERPC_EXCP_FP_VXISI:
1175
                case POWERPC_EXCP_FP_VXIDI:
1176
                case POWERPC_EXCP_FP_VXIMZ:
1177
                case POWERPC_EXCP_FP_VXVC:
1178
                case POWERPC_EXCP_FP_VXSQRT:
1179
                case POWERPC_EXCP_FP_VXCVI:
1180
                    info.si_code = TARGET_FPE_FLTSUB;
1181
                    break;
1182
                default:
1183
                    EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
1184
                              env->error_code);
1185
                    break;
1186
                }
1187
                break;
1188
            case POWERPC_EXCP_INVAL:
1189
                EXCP_DUMP(env, "Invalid instruction\n");
1190
                info.si_signo = TARGET_SIGILL;
1191
                info.si_errno = 0;
1192
                switch (env->error_code & 0xF) {
1193
                case POWERPC_EXCP_INVAL_INVAL:
1194
                    info.si_code = TARGET_ILL_ILLOPC;
1195
                    break;
1196
                case POWERPC_EXCP_INVAL_LSWX:
1197
                    info.si_code = TARGET_ILL_ILLOPN;
1198
                    break;
1199
                case POWERPC_EXCP_INVAL_SPR:
1200
                    info.si_code = TARGET_ILL_PRVREG;
1201
                    break;
1202
                case POWERPC_EXCP_INVAL_FP:
1203
                    info.si_code = TARGET_ILL_COPROC;
1204
                    break;
1205
                default:
1206
                    EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
1207
                              env->error_code & 0xF);
1208
                    info.si_code = TARGET_ILL_ILLADR;
1209
                    break;
1210
                }
1211
                break;
1212
            case POWERPC_EXCP_PRIV:
1213
                EXCP_DUMP(env, "Privilege violation\n");
1214
                info.si_signo = TARGET_SIGILL;
1215
                info.si_errno = 0;
1216
                switch (env->error_code & 0xF) {
1217
                case POWERPC_EXCP_PRIV_OPC:
1218
                    info.si_code = TARGET_ILL_PRVOPC;
1219
                    break;
1220
                case POWERPC_EXCP_PRIV_REG:
1221
                    info.si_code = TARGET_ILL_PRVREG;
1222
                    break;
1223
                default:
1224
                    EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
1225
                              env->error_code & 0xF);
1226
                    info.si_code = TARGET_ILL_PRVOPC;
1227
                    break;
1228
                }
1229
                break;
1230
            case POWERPC_EXCP_TRAP:
1231
                cpu_abort(env, "Tried to call a TRAP\n");
1232
                break;
1233
            default:
1234
                /* Should not happen ! */
1235
                cpu_abort(env, "Unknown program exception (%02x)\n",
1236
                          env->error_code);
1237
                break;
1238
            }
1239
            info._sifields._sigfault._addr = env->nip - 4;
1240
            queue_signal(env, info.si_signo, &info);
1241
            break;
1242
        case POWERPC_EXCP_FPU:      /* Floating-point unavailable exception  */
1243
            EXCP_DUMP(env, "No floating point allowed\n");
1244
            info.si_signo = TARGET_SIGILL;
1245
            info.si_errno = 0;
1246
            info.si_code = TARGET_ILL_COPROC;
1247
            info._sifields._sigfault._addr = env->nip - 4;
1248
            queue_signal(env, info.si_signo, &info);
1249
            break;
1250
        case POWERPC_EXCP_SYSCALL:  /* System call exception                 */
1251
            cpu_abort(env, "Syscall exception while in user mode. "
1252
                      "Aborting\n");
1253
            break;
1254
        case POWERPC_EXCP_APU:      /* Auxiliary processor unavailable       */
1255
            EXCP_DUMP(env, "No APU instruction allowed\n");
1256
            info.si_signo = TARGET_SIGILL;
1257
            info.si_errno = 0;
1258
            info.si_code = TARGET_ILL_COPROC;
1259
            info._sifields._sigfault._addr = env->nip - 4;
1260
            queue_signal(env, info.si_signo, &info);
1261
            break;
1262
        case POWERPC_EXCP_DECR:     /* Decrementer exception                 */
1263
            cpu_abort(env, "Decrementer interrupt while in user mode. "
1264
                      "Aborting\n");
1265
            break;
1266
        case POWERPC_EXCP_FIT:      /* Fixed-interval timer interrupt        */
1267
            cpu_abort(env, "Fix interval timer interrupt while in user mode. "
1268
                      "Aborting\n");
1269
            break;
1270
        case POWERPC_EXCP_WDT:      /* Watchdog timer interrupt              */
1271
            cpu_abort(env, "Watchdog timer interrupt while in user mode. "
1272
                      "Aborting\n");
1273
            break;
1274
        case POWERPC_EXCP_DTLB:     /* Data TLB error                        */
1275
            cpu_abort(env, "Data TLB exception while in user mode. "
1276
                      "Aborting\n");
1277
            break;
1278
        case POWERPC_EXCP_ITLB:     /* Instruction TLB error                 */
1279
            cpu_abort(env, "Instruction TLB exception while in user mode. "
1280
                      "Aborting\n");
1281
            break;
1282
        case POWERPC_EXCP_DEBUG:    /* Debug interrupt                       */
1283
            /* XXX: check this */
1284
            {
1285
                int sig;
1286

    
1287
                sig = gdb_handlesig(env, TARGET_SIGTRAP);
1288
                if (sig) {
1289
                    info.si_signo = sig;
1290
                    info.si_errno = 0;
1291
                    info.si_code = TARGET_TRAP_BRKPT;
1292
                    queue_signal(env, info.si_signo, &info);
1293
                  }
1294
            }
1295
            break;
1296
        case POWERPC_EXCP_SPEU:     /* SPE/embedded floating-point unavail.  */
1297
            EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n");
1298
            info.si_signo = TARGET_SIGILL;
1299
            info.si_errno = 0;
1300
            info.si_code = TARGET_ILL_COPROC;
1301
            info._sifields._sigfault._addr = env->nip - 4;
1302
            queue_signal(env, info.si_signo, &info);
1303
            break;
1304
        case POWERPC_EXCP_EFPDI:    /* Embedded floating-point data IRQ      */
1305
            cpu_abort(env, "Embedded floating-point data IRQ not handled\n");
1306
            break;
1307
        case POWERPC_EXCP_EFPRI:    /* Embedded floating-point round IRQ     */
1308
            cpu_abort(env, "Embedded floating-point round IRQ not handled\n");
1309
            break;
1310
        case POWERPC_EXCP_EPERFM:   /* Embedded performance monitor IRQ      */
1311
            cpu_abort(env, "Performance monitor exception not handled\n");
1312
            break;
1313
        case POWERPC_EXCP_DOORI:    /* Embedded doorbell interrupt           */
1314
            cpu_abort(env, "Doorbell interrupt while in user mode. "
1315
                       "Aborting\n");
1316
            break;
1317
        case POWERPC_EXCP_DOORCI:   /* Embedded doorbell critical interrupt  */
1318
            cpu_abort(env, "Doorbell critical interrupt while in user mode. "
1319
                      "Aborting\n");
1320
            break;
1321
        case POWERPC_EXCP_RESET:    /* System reset exception                */
1322
            cpu_abort(env, "Reset interrupt while in user mode. "
1323
                      "Aborting\n");
1324
            break;
1325
        case POWERPC_EXCP_DSEG:     /* Data segment exception                */
1326
            cpu_abort(env, "Data segment exception while in user mode. "
1327
                      "Aborting\n");
1328
            break;
1329
        case POWERPC_EXCP_ISEG:     /* Instruction segment exception         */
1330
            cpu_abort(env, "Instruction segment exception "
1331
                      "while in user mode. Aborting\n");
1332
            break;
1333
        /* PowerPC 64 with hypervisor mode support */
1334
        case POWERPC_EXCP_HDECR:    /* Hypervisor decrementer exception      */
1335
            cpu_abort(env, "Hypervisor decrementer interrupt "
1336
                      "while in user mode. Aborting\n");
1337
            break;
1338
        case POWERPC_EXCP_TRACE:    /* Trace exception                       */
1339
            /* Nothing to do:
1340
             * we use this exception to emulate step-by-step execution mode.
1341
             */
1342
            break;
1343
        /* PowerPC 64 with hypervisor mode support */
1344
        case POWERPC_EXCP_HDSI:     /* Hypervisor data storage exception     */
1345
            cpu_abort(env, "Hypervisor data storage exception "
1346
                      "while in user mode. Aborting\n");
1347
            break;
1348
        case POWERPC_EXCP_HISI:     /* Hypervisor instruction storage excp   */
1349
            cpu_abort(env, "Hypervisor instruction storage exception "
1350
                      "while in user mode. Aborting\n");
1351
            break;
1352
        case POWERPC_EXCP_HDSEG:    /* Hypervisor data segment exception     */
1353
            cpu_abort(env, "Hypervisor data segment exception "
1354
                      "while in user mode. Aborting\n");
1355
            break;
1356
        case POWERPC_EXCP_HISEG:    /* Hypervisor instruction segment excp   */
1357
            cpu_abort(env, "Hypervisor instruction segment exception "
1358
                      "while in user mode. Aborting\n");
1359
            break;
1360
        case POWERPC_EXCP_VPU:      /* Vector unavailable exception          */
1361
            EXCP_DUMP(env, "No Altivec instructions allowed\n");
1362
            info.si_signo = TARGET_SIGILL;
1363
            info.si_errno = 0;
1364
            info.si_code = TARGET_ILL_COPROC;
1365
            info._sifields._sigfault._addr = env->nip - 4;
1366
            queue_signal(env, info.si_signo, &info);
1367
            break;
1368
        case POWERPC_EXCP_PIT:      /* Programmable interval timer IRQ       */
1369
            cpu_abort(env, "Programable interval timer interrupt "
1370
                      "while in user mode. Aborting\n");
1371
            break;
1372
        case POWERPC_EXCP_IO:       /* IO error exception                    */
1373
            cpu_abort(env, "IO error exception while in user mode. "
1374
                      "Aborting\n");
1375
            break;
1376
        case POWERPC_EXCP_RUNM:     /* Run mode exception                    */
1377
            cpu_abort(env, "Run mode exception while in user mode. "
1378
                      "Aborting\n");
1379
            break;
1380
        case POWERPC_EXCP_EMUL:     /* Emulation trap exception              */
1381
            cpu_abort(env, "Emulation trap exception not handled\n");
1382
            break;
1383
        case POWERPC_EXCP_IFTLB:    /* Instruction fetch TLB error           */
1384
            cpu_abort(env, "Instruction fetch TLB exception "
1385
                      "while in user-mode. Aborting");
1386
            break;
1387
        case POWERPC_EXCP_DLTLB:    /* Data load TLB miss                    */
1388
            cpu_abort(env, "Data load TLB exception while in user-mode. "
1389
                      "Aborting");
1390
            break;
1391
        case POWERPC_EXCP_DSTLB:    /* Data store TLB miss                   */
1392
            cpu_abort(env, "Data store TLB exception while in user-mode. "
1393
                      "Aborting");
1394
            break;
1395
        case POWERPC_EXCP_FPA:      /* Floating-point assist exception       */
1396
            cpu_abort(env, "Floating-point assist exception not handled\n");
1397
            break;
1398
        case POWERPC_EXCP_IABR:     /* Instruction address breakpoint        */
1399
            cpu_abort(env, "Instruction address breakpoint exception "
1400
                      "not handled\n");
1401
            break;
1402
        case POWERPC_EXCP_SMI:      /* System management interrupt           */
1403
            cpu_abort(env, "System management interrupt while in user mode. "
1404
                      "Aborting\n");
1405
            break;
1406
        case POWERPC_EXCP_THERM:    /* Thermal interrupt                     */
1407
            cpu_abort(env, "Thermal interrupt interrupt while in user mode. "
1408
                      "Aborting\n");
1409
            break;
1410
        case POWERPC_EXCP_PERFM:   /* Embedded performance monitor IRQ      */
1411
            cpu_abort(env, "Performance monitor exception not handled\n");
1412
            break;
1413
        case POWERPC_EXCP_VPUA:     /* Vector assist exception               */
1414
            cpu_abort(env, "Vector assist exception not handled\n");
1415
            break;
1416
        case POWERPC_EXCP_SOFTP:    /* Soft patch exception                  */
1417
            cpu_abort(env, "Soft patch exception not handled\n");
1418
            break;
1419
        case POWERPC_EXCP_MAINT:    /* Maintenance exception                 */
1420
            cpu_abort(env, "Maintenance exception while in user mode. "
1421
                      "Aborting\n");
1422
            break;
1423
        case POWERPC_EXCP_STOP:     /* stop translation                      */
1424
            /* We did invalidate the instruction cache. Go on */
1425
            break;
1426
        case POWERPC_EXCP_BRANCH:   /* branch instruction:                   */
1427
            /* We just stopped because of a branch. Go on */
1428
            break;
1429
        case POWERPC_EXCP_SYSCALL_USER:
1430
            /* system call in user-mode emulation */
1431
            /* WARNING:
1432
             * PPC ABI uses overflow flag in cr0 to signal an error
1433
             * in syscalls.
1434
             */
1435
#if 0
1436
            printf("syscall %d 0x%08x 0x%08x 0x%08x 0x%08x\n", env->gpr[0],
1437
                   env->gpr[3], env->gpr[4], env->gpr[5], env->gpr[6]);
1438
#endif
1439
            env->crf[0] &= ~0x1;
1440
            ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
1441
                             env->gpr[5], env->gpr[6], env->gpr[7],
1442
                             env->gpr[8]);
1443
            if (ret > (uint32_t)(-515)) {
1444
                env->crf[0] |= 0x1;
1445
                ret = -ret;
1446
            }
1447
            env->gpr[3] = ret;
1448
#if 0
1449
            printf("syscall returned 0x%08x (%d)\n", ret, ret);
1450
#endif
1451
            break;
1452
        case EXCP_INTERRUPT:
1453
            /* just indicate that signals should be handled asap */
1454
            break;
1455
        default:
1456
            cpu_abort(env, "Unknown exception 0x%d. Aborting\n", trapnr);
1457
            break;
1458
        }
1459
        process_pending_signals(env);
1460
    }
1461
}
1462
#endif
1463

    
1464
#ifdef TARGET_MIPS
1465

    
1466
#define MIPS_SYS(name, args) args,
1467

    
1468
static const uint8_t mips_syscall_args[] = {
1469
        MIPS_SYS(sys_syscall        , 0)        /* 4000 */
1470
        MIPS_SYS(sys_exit        , 1)
1471
        MIPS_SYS(sys_fork        , 0)
1472
        MIPS_SYS(sys_read        , 3)
1473
        MIPS_SYS(sys_write        , 3)
1474
        MIPS_SYS(sys_open        , 3)        /* 4005 */
1475
        MIPS_SYS(sys_close        , 1)
1476
        MIPS_SYS(sys_waitpid        , 3)
1477
        MIPS_SYS(sys_creat        , 2)
1478
        MIPS_SYS(sys_link        , 2)
1479
        MIPS_SYS(sys_unlink        , 1)        /* 4010 */
1480
        MIPS_SYS(sys_execve        , 0)
1481
        MIPS_SYS(sys_chdir        , 1)
1482
        MIPS_SYS(sys_time        , 1)
1483
        MIPS_SYS(sys_mknod        , 3)
1484
        MIPS_SYS(sys_chmod        , 2)        /* 4015 */
1485
        MIPS_SYS(sys_lchown        , 3)
1486
        MIPS_SYS(sys_ni_syscall        , 0)
1487
        MIPS_SYS(sys_ni_syscall        , 0)        /* was sys_stat */
1488
        MIPS_SYS(sys_lseek        , 3)
1489
        MIPS_SYS(sys_getpid        , 0)        /* 4020 */
1490
        MIPS_SYS(sys_mount        , 5)
1491
        MIPS_SYS(sys_oldumount        , 1)
1492
        MIPS_SYS(sys_setuid        , 1)
1493
        MIPS_SYS(sys_getuid        , 0)
1494
        MIPS_SYS(sys_stime        , 1)        /* 4025 */
1495
        MIPS_SYS(sys_ptrace        , 4)
1496
        MIPS_SYS(sys_alarm        , 1)
1497
        MIPS_SYS(sys_ni_syscall        , 0)        /* was sys_fstat */
1498
        MIPS_SYS(sys_pause        , 0)
1499
        MIPS_SYS(sys_utime        , 2)        /* 4030 */
1500
        MIPS_SYS(sys_ni_syscall        , 0)
1501
        MIPS_SYS(sys_ni_syscall        , 0)
1502
        MIPS_SYS(sys_access        , 2)
1503
        MIPS_SYS(sys_nice        , 1)
1504
        MIPS_SYS(sys_ni_syscall        , 0)        /* 4035 */
1505
        MIPS_SYS(sys_sync        , 0)
1506
        MIPS_SYS(sys_kill        , 2)
1507
        MIPS_SYS(sys_rename        , 2)
1508
        MIPS_SYS(sys_mkdir        , 2)
1509
        MIPS_SYS(sys_rmdir        , 1)        /* 4040 */
1510
        MIPS_SYS(sys_dup                , 1)
1511
        MIPS_SYS(sys_pipe        , 0)
1512
        MIPS_SYS(sys_times        , 1)
1513
        MIPS_SYS(sys_ni_syscall        , 0)
1514
        MIPS_SYS(sys_brk                , 1)        /* 4045 */
1515
        MIPS_SYS(sys_setgid        , 1)
1516
        MIPS_SYS(sys_getgid        , 0)
1517
        MIPS_SYS(sys_ni_syscall        , 0)        /* was signal(2) */
1518
        MIPS_SYS(sys_geteuid        , 0)
1519
        MIPS_SYS(sys_getegid        , 0)        /* 4050 */
1520
        MIPS_SYS(sys_acct        , 0)
1521
        MIPS_SYS(sys_umount        , 2)
1522
        MIPS_SYS(sys_ni_syscall        , 0)
1523
        MIPS_SYS(sys_ioctl        , 3)
1524
        MIPS_SYS(sys_fcntl        , 3)        /* 4055 */
1525
        MIPS_SYS(sys_ni_syscall        , 2)
1526
        MIPS_SYS(sys_setpgid        , 2)
1527
        MIPS_SYS(sys_ni_syscall        , 0)
1528
        MIPS_SYS(sys_olduname        , 1)
1529
        MIPS_SYS(sys_umask        , 1)        /* 4060 */
1530
        MIPS_SYS(sys_chroot        , 1)
1531
        MIPS_SYS(sys_ustat        , 2)
1532
        MIPS_SYS(sys_dup2        , 2)
1533
        MIPS_SYS(sys_getppid        , 0)
1534
        MIPS_SYS(sys_getpgrp        , 0)        /* 4065 */
1535
        MIPS_SYS(sys_setsid        , 0)
1536
        MIPS_SYS(sys_sigaction        , 3)
1537
        MIPS_SYS(sys_sgetmask        , 0)
1538
        MIPS_SYS(sys_ssetmask        , 1)
1539
        MIPS_SYS(sys_setreuid        , 2)        /* 4070 */
1540
        MIPS_SYS(sys_setregid        , 2)
1541
        MIPS_SYS(sys_sigsuspend        , 0)
1542
        MIPS_SYS(sys_sigpending        , 1)
1543
        MIPS_SYS(sys_sethostname        , 2)
1544
        MIPS_SYS(sys_setrlimit        , 2)        /* 4075 */
1545
        MIPS_SYS(sys_getrlimit        , 2)
1546
        MIPS_SYS(sys_getrusage        , 2)
1547
        MIPS_SYS(sys_gettimeofday, 2)
1548
        MIPS_SYS(sys_settimeofday, 2)
1549
        MIPS_SYS(sys_getgroups        , 2)        /* 4080 */
1550
        MIPS_SYS(sys_setgroups        , 2)
1551
        MIPS_SYS(sys_ni_syscall        , 0)        /* old_select */
1552
        MIPS_SYS(sys_symlink        , 2)
1553
        MIPS_SYS(sys_ni_syscall        , 0)        /* was sys_lstat */
1554
        MIPS_SYS(sys_readlink        , 3)        /* 4085 */
1555
        MIPS_SYS(sys_uselib        , 1)
1556
        MIPS_SYS(sys_swapon        , 2)
1557
        MIPS_SYS(sys_reboot        , 3)
1558
        MIPS_SYS(old_readdir        , 3)
1559
        MIPS_SYS(old_mmap        , 6)        /* 4090 */
1560
        MIPS_SYS(sys_munmap        , 2)
1561
        MIPS_SYS(sys_truncate        , 2)
1562
        MIPS_SYS(sys_ftruncate        , 2)
1563
        MIPS_SYS(sys_fchmod        , 2)
1564
        MIPS_SYS(sys_fchown        , 3)        /* 4095 */
1565
        MIPS_SYS(sys_getpriority        , 2)
1566
        MIPS_SYS(sys_setpriority        , 3)
1567
        MIPS_SYS(sys_ni_syscall        , 0)
1568
        MIPS_SYS(sys_statfs        , 2)
1569
        MIPS_SYS(sys_fstatfs        , 2)        /* 4100 */
1570
        MIPS_SYS(sys_ni_syscall        , 0)        /* was ioperm(2) */
1571
        MIPS_SYS(sys_socketcall        , 2)
1572
        MIPS_SYS(sys_syslog        , 3)
1573
        MIPS_SYS(sys_setitimer        , 3)
1574
        MIPS_SYS(sys_getitimer        , 2)        /* 4105 */
1575
        MIPS_SYS(sys_newstat        , 2)
1576
        MIPS_SYS(sys_newlstat        , 2)
1577
        MIPS_SYS(sys_newfstat        , 2)
1578
        MIPS_SYS(sys_uname        , 1)
1579
        MIPS_SYS(sys_ni_syscall        , 0)        /* 4110 was iopl(2) */
1580
        MIPS_SYS(sys_vhangup        , 0)
1581
        MIPS_SYS(sys_ni_syscall        , 0)        /* was sys_idle() */
1582
        MIPS_SYS(sys_ni_syscall        , 0)        /* was sys_vm86 */
1583
        MIPS_SYS(sys_wait4        , 4)
1584
        MIPS_SYS(sys_swapoff        , 1)        /* 4115 */
1585
        MIPS_SYS(sys_sysinfo        , 1)
1586
        MIPS_SYS(sys_ipc                , 6)
1587
        MIPS_SYS(sys_fsync        , 1)
1588
        MIPS_SYS(sys_sigreturn        , 0)
1589
        MIPS_SYS(sys_clone        , 0)        /* 4120 */
1590
        MIPS_SYS(sys_setdomainname, 2)
1591
        MIPS_SYS(sys_newuname        , 1)
1592
        MIPS_SYS(sys_ni_syscall        , 0)        /* sys_modify_ldt */
1593
        MIPS_SYS(sys_adjtimex        , 1)
1594
        MIPS_SYS(sys_mprotect        , 3)        /* 4125 */
1595
        MIPS_SYS(sys_sigprocmask        , 3)
1596
        MIPS_SYS(sys_ni_syscall        , 0)        /* was create_module */
1597
        MIPS_SYS(sys_init_module        , 5)
1598
        MIPS_SYS(sys_delete_module, 1)
1599
        MIPS_SYS(sys_ni_syscall        , 0)        /* 4130        was get_kernel_syms */
1600
        MIPS_SYS(sys_quotactl        , 0)
1601
        MIPS_SYS(sys_getpgid        , 1)
1602
        MIPS_SYS(sys_fchdir        , 1)
1603
        MIPS_SYS(sys_bdflush        , 2)
1604
        MIPS_SYS(sys_sysfs        , 3)        /* 4135 */
1605
        MIPS_SYS(sys_personality        , 1)
1606
        MIPS_SYS(sys_ni_syscall        , 0)        /* for afs_syscall */
1607
        MIPS_SYS(sys_setfsuid        , 1)
1608
        MIPS_SYS(sys_setfsgid        , 1)
1609
        MIPS_SYS(sys_llseek        , 5)        /* 4140 */
1610
        MIPS_SYS(sys_getdents        , 3)
1611
        MIPS_SYS(sys_select        , 5)
1612
        MIPS_SYS(sys_flock        , 2)
1613
        MIPS_SYS(sys_msync        , 3)
1614
        MIPS_SYS(sys_readv        , 3)        /* 4145 */
1615
        MIPS_SYS(sys_writev        , 3)
1616
        MIPS_SYS(sys_cacheflush        , 3)
1617
        MIPS_SYS(sys_cachectl        , 3)
1618
        MIPS_SYS(sys_sysmips        , 4)
1619
        MIPS_SYS(sys_ni_syscall        , 0)        /* 4150 */
1620
        MIPS_SYS(sys_getsid        , 1)
1621
        MIPS_SYS(sys_fdatasync        , 0)
1622
        MIPS_SYS(sys_sysctl        , 1)
1623
        MIPS_SYS(sys_mlock        , 2)
1624
        MIPS_SYS(sys_munlock        , 2)        /* 4155 */
1625
        MIPS_SYS(sys_mlockall        , 1)
1626
        MIPS_SYS(sys_munlockall        , 0)
1627
        MIPS_SYS(sys_sched_setparam, 2)
1628
        MIPS_SYS(sys_sched_getparam, 2)
1629
        MIPS_SYS(sys_sched_setscheduler, 3)        /* 4160 */
1630
        MIPS_SYS(sys_sched_getscheduler, 1)
1631
        MIPS_SYS(sys_sched_yield        , 0)
1632
        MIPS_SYS(sys_sched_get_priority_max, 1)
1633
        MIPS_SYS(sys_sched_get_priority_min, 1)
1634
        MIPS_SYS(sys_sched_rr_get_interval, 2)        /* 4165 */
1635
        MIPS_SYS(sys_nanosleep,        2)
1636
        MIPS_SYS(sys_mremap        , 4)
1637
        MIPS_SYS(sys_accept        , 3)
1638
        MIPS_SYS(sys_bind        , 3)
1639
        MIPS_SYS(sys_connect        , 3)        /* 4170 */
1640
        MIPS_SYS(sys_getpeername        , 3)
1641
        MIPS_SYS(sys_getsockname        , 3)
1642
        MIPS_SYS(sys_getsockopt        , 5)
1643
        MIPS_SYS(sys_listen        , 2)
1644
        MIPS_SYS(sys_recv        , 4)        /* 4175 */
1645
        MIPS_SYS(sys_recvfrom        , 6)
1646
        MIPS_SYS(sys_recvmsg        , 3)
1647
        MIPS_SYS(sys_send        , 4)
1648
        MIPS_SYS(sys_sendmsg        , 3)
1649
        MIPS_SYS(sys_sendto        , 6)        /* 4180 */
1650
        MIPS_SYS(sys_setsockopt        , 5)
1651
        MIPS_SYS(sys_shutdown        , 2)
1652
        MIPS_SYS(sys_socket        , 3)
1653
        MIPS_SYS(sys_socketpair        , 4)
1654
        MIPS_SYS(sys_setresuid        , 3)        /* 4185 */
1655
        MIPS_SYS(sys_getresuid        , 3)
1656
        MIPS_SYS(sys_ni_syscall        , 0)        /* was sys_query_module */
1657
        MIPS_SYS(sys_poll        , 3)
1658
        MIPS_SYS(sys_nfsservctl        , 3)
1659
        MIPS_SYS(sys_setresgid        , 3)        /* 4190 */
1660
        MIPS_SYS(sys_getresgid        , 3)
1661
        MIPS_SYS(sys_prctl        , 5)
1662
        MIPS_SYS(sys_rt_sigreturn, 0)
1663
        MIPS_SYS(sys_rt_sigaction, 4)
1664
        MIPS_SYS(sys_rt_sigprocmask, 4)        /* 4195 */
1665
        MIPS_SYS(sys_rt_sigpending, 2)
1666
        MIPS_SYS(sys_rt_sigtimedwait, 4)
1667
        MIPS_SYS(sys_rt_sigqueueinfo, 3)
1668
        MIPS_SYS(sys_rt_sigsuspend, 0)
1669
        MIPS_SYS(sys_pread64        , 6)        /* 4200 */
1670
        MIPS_SYS(sys_pwrite64        , 6)
1671
        MIPS_SYS(sys_chown        , 3)
1672
        MIPS_SYS(sys_getcwd        , 2)
1673
        MIPS_SYS(sys_capget        , 2)
1674
        MIPS_SYS(sys_capset        , 2)        /* 4205 */
1675
        MIPS_SYS(sys_sigaltstack        , 0)
1676
        MIPS_SYS(sys_sendfile        , 4)
1677
        MIPS_SYS(sys_ni_syscall        , 0)
1678
        MIPS_SYS(sys_ni_syscall        , 0)
1679
        MIPS_SYS(sys_mmap2        , 6)        /* 4210 */
1680
        MIPS_SYS(sys_truncate64        , 4)
1681
        MIPS_SYS(sys_ftruncate64        , 4)
1682
        MIPS_SYS(sys_stat64        , 2)
1683
        MIPS_SYS(sys_lstat64        , 2)
1684
        MIPS_SYS(sys_fstat64        , 2)        /* 4215 */
1685
        MIPS_SYS(sys_pivot_root        , 2)
1686
        MIPS_SYS(sys_mincore        , 3)
1687
        MIPS_SYS(sys_madvise        , 3)
1688
        MIPS_SYS(sys_getdents64        , 3)
1689
        MIPS_SYS(sys_fcntl64        , 3)        /* 4220 */
1690
        MIPS_SYS(sys_ni_syscall        , 0)
1691
        MIPS_SYS(sys_gettid        , 0)
1692
        MIPS_SYS(sys_readahead        , 5)
1693
        MIPS_SYS(sys_setxattr        , 5)
1694
        MIPS_SYS(sys_lsetxattr        , 5)        /* 4225 */
1695
        MIPS_SYS(sys_fsetxattr        , 5)
1696
        MIPS_SYS(sys_getxattr        , 4)
1697
        MIPS_SYS(sys_lgetxattr        , 4)
1698
        MIPS_SYS(sys_fgetxattr        , 4)
1699
        MIPS_SYS(sys_listxattr        , 3)        /* 4230 */
1700
        MIPS_SYS(sys_llistxattr        , 3)
1701
        MIPS_SYS(sys_flistxattr        , 3)
1702
        MIPS_SYS(sys_removexattr        , 2)
1703
        MIPS_SYS(sys_lremovexattr, 2)
1704
        MIPS_SYS(sys_fremovexattr, 2)        /* 4235 */
1705
        MIPS_SYS(sys_tkill        , 2)
1706
        MIPS_SYS(sys_sendfile64        , 5)
1707
        MIPS_SYS(sys_futex        , 2)
1708
        MIPS_SYS(sys_sched_setaffinity, 3)
1709
        MIPS_SYS(sys_sched_getaffinity, 3)        /* 4240 */
1710
        MIPS_SYS(sys_io_setup        , 2)
1711
        MIPS_SYS(sys_io_destroy        , 1)
1712
        MIPS_SYS(sys_io_getevents, 5)
1713
        MIPS_SYS(sys_io_submit        , 3)
1714
        MIPS_SYS(sys_io_cancel        , 3)        /* 4245 */
1715
        MIPS_SYS(sys_exit_group        , 1)
1716
        MIPS_SYS(sys_lookup_dcookie, 3)
1717
        MIPS_SYS(sys_epoll_create, 1)
1718
        MIPS_SYS(sys_epoll_ctl        , 4)
1719
        MIPS_SYS(sys_epoll_wait        , 3)        /* 4250 */
1720
        MIPS_SYS(sys_remap_file_pages, 5)
1721
        MIPS_SYS(sys_set_tid_address, 1)
1722
        MIPS_SYS(sys_restart_syscall, 0)
1723
        MIPS_SYS(sys_fadvise64_64, 7)
1724
        MIPS_SYS(sys_statfs64        , 3)        /* 4255 */
1725
        MIPS_SYS(sys_fstatfs64        , 2)
1726
        MIPS_SYS(sys_timer_create, 3)
1727
        MIPS_SYS(sys_timer_settime, 4)
1728
        MIPS_SYS(sys_timer_gettime, 2)
1729
        MIPS_SYS(sys_timer_getoverrun, 1)        /* 4260 */
1730
        MIPS_SYS(sys_timer_delete, 1)
1731
        MIPS_SYS(sys_clock_settime, 2)
1732
        MIPS_SYS(sys_clock_gettime, 2)
1733
        MIPS_SYS(sys_clock_getres, 2)
1734
        MIPS_SYS(sys_clock_nanosleep, 4)        /* 4265 */
1735
        MIPS_SYS(sys_tgkill        , 3)
1736
        MIPS_SYS(sys_utimes        , 2)
1737
        MIPS_SYS(sys_mbind        , 4)
1738
        MIPS_SYS(sys_ni_syscall        , 0)        /* sys_get_mempolicy */
1739
        MIPS_SYS(sys_ni_syscall        , 0)        /* 4270 sys_set_mempolicy */
1740
        MIPS_SYS(sys_mq_open        , 4)
1741
        MIPS_SYS(sys_mq_unlink        , 1)
1742
        MIPS_SYS(sys_mq_timedsend, 5)
1743
        MIPS_SYS(sys_mq_timedreceive, 5)
1744
        MIPS_SYS(sys_mq_notify        , 2)        /* 4275 */
1745
        MIPS_SYS(sys_mq_getsetattr, 3)
1746
        MIPS_SYS(sys_ni_syscall        , 0)        /* sys_vserver */
1747
        MIPS_SYS(sys_waitid        , 4)
1748
        MIPS_SYS(sys_ni_syscall        , 0)        /* available, was setaltroot */
1749
        MIPS_SYS(sys_add_key        , 5)
1750
        MIPS_SYS(sys_request_key, 4)
1751
        MIPS_SYS(sys_keyctl        , 5)
1752
        MIPS_SYS(sys_set_thread_area, 1)
1753
        MIPS_SYS(sys_inotify_init, 0)
1754
        MIPS_SYS(sys_inotify_add_watch, 3) /* 4285 */
1755
        MIPS_SYS(sys_inotify_rm_watch, 2)
1756
        MIPS_SYS(sys_migrate_pages, 4)
1757
        MIPS_SYS(sys_openat, 4)
1758
        MIPS_SYS(sys_mkdirat, 3)
1759
        MIPS_SYS(sys_mknodat, 4)        /* 4290 */
1760
        MIPS_SYS(sys_fchownat, 5)
1761
        MIPS_SYS(sys_futimesat, 3)
1762
        MIPS_SYS(sys_fstatat64, 4)
1763
        MIPS_SYS(sys_unlinkat, 3)
1764
        MIPS_SYS(sys_renameat, 4)        /* 4295 */
1765
        MIPS_SYS(sys_linkat, 5)
1766
        MIPS_SYS(sys_symlinkat, 3)
1767
        MIPS_SYS(sys_readlinkat, 4)
1768
        MIPS_SYS(sys_fchmodat, 3)
1769
        MIPS_SYS(sys_faccessat, 3)        /* 4300 */
1770
        MIPS_SYS(sys_pselect6, 6)
1771
        MIPS_SYS(sys_ppoll, 5)
1772
        MIPS_SYS(sys_unshare, 1)
1773
        MIPS_SYS(sys_splice, 4)
1774
        MIPS_SYS(sys_sync_file_range, 7) /* 4305 */
1775
        MIPS_SYS(sys_tee, 4)
1776
        MIPS_SYS(sys_vmsplice, 4)
1777
        MIPS_SYS(sys_move_pages, 6)
1778
        MIPS_SYS(sys_set_robust_list, 2)
1779
        MIPS_SYS(sys_get_robust_list, 3) /* 4310 */
1780
        MIPS_SYS(sys_kexec_load, 4)
1781
        MIPS_SYS(sys_getcpu, 3)
1782
        MIPS_SYS(sys_epoll_pwait, 6)
1783
        MIPS_SYS(sys_ioprio_set, 3)
1784
        MIPS_SYS(sys_ioprio_get, 2)
1785
};
1786

    
1787
#undef MIPS_SYS
1788

    
1789
void cpu_loop(CPUMIPSState *env)
1790
{
1791
    target_siginfo_t info;
1792
    int trapnr, ret;
1793
    unsigned int syscall_num;
1794

    
1795
    for(;;) {
1796
        trapnr = cpu_mips_exec(env);
1797
        switch(trapnr) {
1798
        case EXCP_SYSCALL:
1799
            syscall_num = env->active_tc.gpr[2] - 4000;
1800
            env->active_tc.PC += 4;
1801
            if (syscall_num >= sizeof(mips_syscall_args)) {
1802
                ret = -ENOSYS;
1803
            } else {
1804
                int nb_args;
1805
                abi_ulong sp_reg;
1806
                abi_ulong arg5 = 0, arg6 = 0, arg7 = 0, arg8 = 0;
1807

    
1808
                nb_args = mips_syscall_args[syscall_num];
1809
                sp_reg = env->active_tc.gpr[29];
1810
                switch (nb_args) {
1811
                /* these arguments are taken from the stack */
1812
                /* FIXME - what to do if get_user() fails? */
1813
                case 8: get_user_ual(arg8, sp_reg + 28);
1814
                case 7: get_user_ual(arg7, sp_reg + 24);
1815
                case 6: get_user_ual(arg6, sp_reg + 20);
1816
                case 5: get_user_ual(arg5, sp_reg + 16);
1817
                default:
1818
                    break;
1819
                }
1820
                ret = do_syscall(env, env->active_tc.gpr[2],
1821
                                 env->active_tc.gpr[4],
1822
                                 env->active_tc.gpr[5],
1823
                                 env->active_tc.gpr[6],
1824
                                 env->active_tc.gpr[7],
1825
                                 arg5, arg6/*, arg7, arg8*/);
1826
            }
1827
            if ((unsigned int)ret >= (unsigned int)(-1133)) {
1828
                env->active_tc.gpr[7] = 1; /* error flag */
1829
                ret = -ret;
1830
            } else {
1831
                env->active_tc.gpr[7] = 0; /* error flag */
1832
            }
1833
            env->active_tc.gpr[2] = ret;
1834
            break;
1835
        case EXCP_TLBL:
1836
        case EXCP_TLBS:
1837
        case EXCP_CpU:
1838
        case EXCP_RI:
1839
            info.si_signo = TARGET_SIGILL;
1840
            info.si_errno = 0;
1841
            info.si_code = 0;
1842
            queue_signal(env, info.si_signo, &info);
1843
            break;
1844
        case EXCP_INTERRUPT:
1845
            /* just indicate that signals should be handled asap */
1846
            break;
1847
        case EXCP_DEBUG:
1848
            {
1849
                int sig;
1850

    
1851
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
1852
                if (sig)
1853
                  {
1854
                    info.si_signo = sig;
1855
                    info.si_errno = 0;
1856
                    info.si_code = TARGET_TRAP_BRKPT;
1857
                    queue_signal(env, info.si_signo, &info);
1858
                  }
1859
            }
1860
            break;
1861
        default:
1862
            //        error:
1863
            fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
1864
                    trapnr);
1865
            cpu_dump_state(env, stderr, fprintf, 0);
1866
            abort();
1867
        }
1868
        process_pending_signals(env);
1869
    }
1870
}
1871
#endif
1872

    
1873
#ifdef TARGET_SH4
1874
void cpu_loop (CPUState *env)
1875
{
1876
    int trapnr, ret;
1877
    target_siginfo_t info;
1878

    
1879
    while (1) {
1880
        trapnr = cpu_sh4_exec (env);
1881

    
1882
        switch (trapnr) {
1883
        case 0x160:
1884
            ret = do_syscall(env,
1885
                             env->gregs[3],
1886
                             env->gregs[4],
1887
                             env->gregs[5],
1888
                             env->gregs[6],
1889
                             env->gregs[7],
1890
                             env->gregs[0],
1891
                             env->gregs[1]);
1892
            env->gregs[0] = ret;
1893
            env->pc += 2;
1894
            break;
1895
        case EXCP_INTERRUPT:
1896
            /* just indicate that signals should be handled asap */
1897
            break;
1898
        case EXCP_DEBUG:
1899
            {
1900
                int sig;
1901

    
1902
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
1903
                if (sig)
1904
                  {
1905
                    info.si_signo = sig;
1906
                    info.si_errno = 0;
1907
                    info.si_code = TARGET_TRAP_BRKPT;
1908
                    queue_signal(env, info.si_signo, &info);
1909
                  }
1910
            }
1911
            break;
1912
        case 0xa0:
1913
        case 0xc0:
1914
            info.si_signo = SIGSEGV;
1915
            info.si_errno = 0;
1916
            info.si_code = TARGET_SEGV_MAPERR;
1917
            info._sifields._sigfault._addr = env->tea;
1918
            queue_signal(env, info.si_signo, &info);
1919
            break;
1920

    
1921
        default:
1922
            printf ("Unhandled trap: 0x%x\n", trapnr);
1923
            cpu_dump_state(env, stderr, fprintf, 0);
1924
            exit (1);
1925
        }
1926
        process_pending_signals (env);
1927
    }
1928
}
1929
#endif
1930

    
1931
#ifdef TARGET_CRIS
1932
void cpu_loop (CPUState *env)
1933
{
1934
    int trapnr, ret;
1935
    target_siginfo_t info;
1936
    
1937
    while (1) {
1938
        trapnr = cpu_cris_exec (env);
1939
        switch (trapnr) {
1940
        case 0xaa:
1941
            {
1942
                info.si_signo = SIGSEGV;
1943
                info.si_errno = 0;
1944
                /* XXX: check env->error_code */
1945
                info.si_code = TARGET_SEGV_MAPERR;
1946
                info._sifields._sigfault._addr = env->pregs[PR_EDA];
1947
                queue_signal(env, info.si_signo, &info);
1948
            }
1949
            break;
1950
        case EXCP_INTERRUPT:
1951
          /* just indicate that signals should be handled asap */
1952
          break;
1953
        case EXCP_BREAK:
1954
            ret = do_syscall(env, 
1955
                             env->regs[9], 
1956
                             env->regs[10], 
1957
                             env->regs[11], 
1958
                             env->regs[12], 
1959
                             env->regs[13], 
1960
                             env->pregs[7], 
1961
                             env->pregs[11]);
1962
            env->regs[10] = ret;
1963
            env->pc += 2;
1964
            break;
1965
        case EXCP_DEBUG:
1966
            {
1967
                int sig;
1968

    
1969
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
1970
                if (sig)
1971
                  {
1972
                    info.si_signo = sig;
1973
                    info.si_errno = 0;
1974
                    info.si_code = TARGET_TRAP_BRKPT;
1975
                    queue_signal(env, info.si_signo, &info);
1976
                  }
1977
            }
1978
            break;
1979
        default:
1980
            printf ("Unhandled trap: 0x%x\n", trapnr);
1981
            cpu_dump_state(env, stderr, fprintf, 0);
1982
            exit (1);
1983
        }
1984
        process_pending_signals (env);
1985
    }
1986
}
1987
#endif
1988

    
1989
#ifdef TARGET_M68K
1990

    
1991
void cpu_loop(CPUM68KState *env)
1992
{
1993
    int trapnr;
1994
    unsigned int n;
1995
    target_siginfo_t info;
1996
    TaskState *ts = env->opaque;
1997

    
1998
    for(;;) {
1999
        trapnr = cpu_m68k_exec(env);
2000
        switch(trapnr) {
2001
        case EXCP_ILLEGAL:
2002
            {
2003
                if (ts->sim_syscalls) {
2004
                    uint16_t nr;
2005
                    nr = lduw(env->pc + 2);
2006
                    env->pc += 4;
2007
                    do_m68k_simcall(env, nr);
2008
                } else {
2009
                    goto do_sigill;
2010
                }
2011
            }
2012
            break;
2013
        case EXCP_HALT_INSN:
2014
            /* Semihosing syscall.  */
2015
            env->pc += 4;
2016
            do_m68k_semihosting(env, env->dregs[0]);
2017
            break;
2018
        case EXCP_LINEA:
2019
        case EXCP_LINEF:
2020
        case EXCP_UNSUPPORTED:
2021
        do_sigill:
2022
            info.si_signo = SIGILL;
2023
            info.si_errno = 0;
2024
            info.si_code = TARGET_ILL_ILLOPN;
2025
            info._sifields._sigfault._addr = env->pc;
2026
            queue_signal(env, info.si_signo, &info);
2027
            break;
2028
        case EXCP_TRAP0:
2029
            {
2030
                ts->sim_syscalls = 0;
2031
                n = env->dregs[0];
2032
                env->pc += 2;
2033
                env->dregs[0] = do_syscall(env,
2034
                                          n,
2035
                                          env->dregs[1],
2036
                                          env->dregs[2],
2037
                                          env->dregs[3],
2038
                                          env->dregs[4],
2039
                                          env->dregs[5],
2040
                                          env->aregs[0]);
2041
            }
2042
            break;
2043
        case EXCP_INTERRUPT:
2044
            /* just indicate that signals should be handled asap */
2045
            break;
2046
        case EXCP_ACCESS:
2047
            {
2048
                info.si_signo = SIGSEGV;
2049
                info.si_errno = 0;
2050
                /* XXX: check env->error_code */
2051
                info.si_code = TARGET_SEGV_MAPERR;
2052
                info._sifields._sigfault._addr = env->mmu.ar;
2053
                queue_signal(env, info.si_signo, &info);
2054
            }
2055
            break;
2056
        case EXCP_DEBUG:
2057
            {
2058
                int sig;
2059

    
2060
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
2061
                if (sig)
2062
                  {
2063
                    info.si_signo = sig;
2064
                    info.si_errno = 0;
2065
                    info.si_code = TARGET_TRAP_BRKPT;
2066
                    queue_signal(env, info.si_signo, &info);
2067
                  }
2068
            }
2069
            break;
2070
        default:
2071
            fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
2072
                    trapnr);
2073
            cpu_dump_state(env, stderr, fprintf, 0);
2074
            abort();
2075
        }
2076
        process_pending_signals(env);
2077
    }
2078
}
2079
#endif /* TARGET_M68K */
2080

    
2081
#ifdef TARGET_ALPHA
2082
void cpu_loop (CPUState *env)
2083
{
2084
    int trapnr;
2085
    target_siginfo_t info;
2086

    
2087
    while (1) {
2088
        trapnr = cpu_alpha_exec (env);
2089

    
2090
        switch (trapnr) {
2091
        case EXCP_RESET:
2092
            fprintf(stderr, "Reset requested. Exit\n");
2093
            exit(1);
2094
            break;
2095
        case EXCP_MCHK:
2096
            fprintf(stderr, "Machine check exception. Exit\n");
2097
            exit(1);
2098
            break;
2099
        case EXCP_ARITH:
2100
            fprintf(stderr, "Arithmetic trap.\n");
2101
            exit(1);
2102
            break;
2103
        case EXCP_HW_INTERRUPT:
2104
            fprintf(stderr, "External interrupt. Exit\n");
2105
            exit(1);
2106
            break;
2107
        case EXCP_DFAULT:
2108
            fprintf(stderr, "MMU data fault\n");
2109
            exit(1);
2110
            break;
2111
        case EXCP_DTB_MISS_PAL:
2112
            fprintf(stderr, "MMU data TLB miss in PALcode\n");
2113
            exit(1);
2114
            break;
2115
        case EXCP_ITB_MISS:
2116
            fprintf(stderr, "MMU instruction TLB miss\n");
2117
            exit(1);
2118
            break;
2119
        case EXCP_ITB_ACV:
2120
            fprintf(stderr, "MMU instruction access violation\n");
2121
            exit(1);
2122
            break;
2123
        case EXCP_DTB_MISS_NATIVE:
2124
            fprintf(stderr, "MMU data TLB miss\n");
2125
            exit(1);
2126
            break;
2127
        case EXCP_UNALIGN:
2128
            fprintf(stderr, "Unaligned access\n");
2129
            exit(1);
2130
            break;
2131
        case EXCP_OPCDEC:
2132
            fprintf(stderr, "Invalid instruction\n");
2133
            exit(1);
2134
            break;
2135
        case EXCP_FEN:
2136
            fprintf(stderr, "Floating-point not allowed\n");
2137
            exit(1);
2138
            break;
2139
        case EXCP_CALL_PAL ... (EXCP_CALL_PALP - 1):
2140
            fprintf(stderr, "Call to PALcode\n");
2141
            call_pal(env, (trapnr >> 6) | 0x80);
2142
            break;
2143
        case EXCP_CALL_PALP ... (EXCP_CALL_PALE - 1):
2144
            fprintf(stderr, "Privileged call to PALcode\n");
2145
            exit(1);
2146
            break;
2147
        case EXCP_DEBUG:
2148
            {
2149
                int sig;
2150

    
2151
                sig = gdb_handlesig (env, TARGET_SIGTRAP);
2152
                if (sig)
2153
                  {
2154
                    info.si_signo = sig;
2155
                    info.si_errno = 0;
2156
                    info.si_code = TARGET_TRAP_BRKPT;
2157
                    queue_signal(env, info.si_signo, &info);
2158
                  }
2159
            }
2160
            break;
2161
        default:
2162
            printf ("Unhandled trap: 0x%x\n", trapnr);
2163
            cpu_dump_state(env, stderr, fprintf, 0);
2164
            exit (1);
2165
        }
2166
        process_pending_signals (env);
2167
    }
2168
}
2169
#endif /* TARGET_ALPHA */
2170

    
2171
static void usage(void)
2172
{
2173
    printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
2174
           "usage: qemu-" TARGET_ARCH " [options] program [arguments...]\n"
2175
           "Linux CPU emulator (compiled for %s emulation)\n"
2176
           "\n"
2177
           "Standard options:\n"
2178
           "-h                print this help\n"
2179
           "-g port           wait gdb connection to port\n"
2180
           "-L path           set the elf interpreter prefix (default=%s)\n"
2181
           "-s size           set the stack size in bytes (default=%ld)\n"
2182
           "-cpu model        select CPU (-cpu ? for list)\n"
2183
           "-drop-ld-preload  drop LD_PRELOAD for target process\n"
2184
           "\n"
2185
           "Debug options:\n"
2186
           "-d options   activate log (logfile=%s)\n"
2187
           "-p pagesize  set the host page size to 'pagesize'\n"
2188
           "-strace      log system calls\n"
2189
           "\n"
2190
           "Environment variables:\n"
2191
           "QEMU_STRACE       Print system calls and arguments similar to the\n"
2192
           "                  'strace' program.  Enable by setting to any value.\n"
2193
           ,
2194
           TARGET_ARCH,
2195
           interp_prefix,
2196
           x86_stack_size,
2197
           DEBUG_LOGFILE);
2198
    _exit(1);
2199
}
2200

    
2201
THREAD CPUState *thread_env;
2202

    
2203
/* Assumes contents are already zeroed.  */
2204
void init_task_state(TaskState *ts)
2205
{
2206
    int i;
2207
 
2208
    ts->used = 1;
2209
    ts->first_free = ts->sigqueue_table;
2210
    for (i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) {
2211
        ts->sigqueue_table[i].next = &ts->sigqueue_table[i + 1];
2212
    }
2213
    ts->sigqueue_table[i].next = NULL;
2214
}
2215
 
2216
int main(int argc, char **argv)
2217
{
2218
    const char *filename;
2219
    const char *cpu_model;
2220
    struct target_pt_regs regs1, *regs = &regs1;
2221
    struct image_info info1, *info = &info1;
2222
    TaskState ts1, *ts = &ts1;
2223
    CPUState *env;
2224
    int optind;
2225
    const char *r;
2226
    int gdbstub_port = 0;
2227
    int drop_ld_preload = 0, environ_count = 0;
2228
    char **target_environ, **wrk, **dst;
2229

    
2230
    if (argc <= 1)
2231
        usage();
2232

    
2233
    /* init debug */
2234
    cpu_set_log_filename(DEBUG_LOGFILE);
2235

    
2236
    cpu_model = NULL;
2237
    optind = 1;
2238
    for(;;) {
2239
        if (optind >= argc)
2240
            break;
2241
        r = argv[optind];
2242
        if (r[0] != '-')
2243
            break;
2244
        optind++;
2245
        r++;
2246
        if (!strcmp(r, "-")) {
2247
            break;
2248
        } else if (!strcmp(r, "d")) {
2249
            int mask;
2250
            CPULogItem *item;
2251

    
2252
            if (optind >= argc)
2253
                break;
2254

    
2255
            r = argv[optind++];
2256
            mask = cpu_str_to_log_mask(r);
2257
            if (!mask) {
2258
                printf("Log items (comma separated):\n");
2259
                for(item = cpu_log_items; item->mask != 0; item++) {
2260
                    printf("%-10s %s\n", item->name, item->help);
2261
                }
2262
                exit(1);
2263
            }
2264
            cpu_set_log(mask);
2265
        } else if (!strcmp(r, "s")) {
2266
            r = argv[optind++];
2267
            x86_stack_size = strtol(r, (char **)&r, 0);
2268
            if (x86_stack_size <= 0)
2269
                usage();
2270
            if (*r == 'M')
2271
                x86_stack_size *= 1024 * 1024;
2272
            else if (*r == 'k' || *r == 'K')
2273
                x86_stack_size *= 1024;
2274
        } else if (!strcmp(r, "L")) {
2275
            interp_prefix = argv[optind++];
2276
        } else if (!strcmp(r, "p")) {
2277
            qemu_host_page_size = atoi(argv[optind++]);
2278
            if (qemu_host_page_size == 0 ||
2279
                (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
2280
                fprintf(stderr, "page size must be a power of two\n");
2281
                exit(1);
2282
            }
2283
        } else if (!strcmp(r, "g")) {
2284
            gdbstub_port = atoi(argv[optind++]);
2285
        } else if (!strcmp(r, "r")) {
2286
            qemu_uname_release = argv[optind++];
2287
        } else if (!strcmp(r, "cpu")) {
2288
            cpu_model = argv[optind++];
2289
            if (strcmp(cpu_model, "?") == 0) {
2290
/* XXX: implement xxx_cpu_list for targets that still miss it */
2291
#if defined(cpu_list)
2292
                    cpu_list(stdout, &fprintf);
2293
#endif
2294
                _exit(1);
2295
            }
2296
        } else if (!strcmp(r, "drop-ld-preload")) {
2297
            drop_ld_preload = 1;
2298
        } else if (!strcmp(r, "strace")) {
2299
            do_strace = 1;
2300
        } else
2301
        {
2302
            usage();
2303
        }
2304
    }
2305
    if (optind >= argc)
2306
        usage();
2307
    filename = argv[optind];
2308

    
2309
    /* Zero out regs */
2310
    memset(regs, 0, sizeof(struct target_pt_regs));
2311

    
2312
    /* Zero out image_info */
2313
    memset(info, 0, sizeof(struct image_info));
2314

    
2315
    /* Scan interp_prefix dir for replacement files. */
2316
    init_paths(interp_prefix);
2317

    
2318
    if (cpu_model == NULL) {
2319
#if defined(TARGET_I386)
2320
#ifdef TARGET_X86_64
2321
        cpu_model = "qemu64";
2322
#else
2323
        cpu_model = "qemu32";
2324
#endif
2325
#elif defined(TARGET_ARM)
2326
        cpu_model = "arm926";
2327
#elif defined(TARGET_M68K)
2328
        cpu_model = "any";
2329
#elif defined(TARGET_SPARC)
2330
#ifdef TARGET_SPARC64
2331
        cpu_model = "TI UltraSparc II";
2332
#else
2333
        cpu_model = "Fujitsu MB86904";
2334
#endif
2335
#elif defined(TARGET_MIPS)
2336
#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
2337
        cpu_model = "20Kc";
2338
#else
2339
        cpu_model = "24Kf";
2340
#endif
2341
#elif defined(TARGET_PPC)
2342
#ifdef TARGET_PPC64
2343
        cpu_model = "970";
2344
#else
2345
        cpu_model = "750";
2346
#endif
2347
#else
2348
        cpu_model = "any";
2349
#endif
2350
    }
2351
    cpu_exec_init_all(0);
2352
    /* NOTE: we need to init the CPU at this stage to get
2353
       qemu_host_page_size */
2354
    env = cpu_init(cpu_model);
2355
    if (!env) {
2356
        fprintf(stderr, "Unable to find CPU definition\n");
2357
        exit(1);
2358
    }
2359
    thread_env = env;
2360

    
2361
    if (getenv("QEMU_STRACE")) {
2362
        do_strace = 1;
2363
    }
2364

    
2365
    wrk = environ;
2366
    while (*(wrk++))
2367
        environ_count++;
2368

    
2369
    target_environ = malloc((environ_count + 1) * sizeof(char *));
2370
    if (!target_environ)
2371
        abort();
2372
    for (wrk = environ, dst = target_environ; *wrk; wrk++) {
2373
        if (drop_ld_preload && !strncmp(*wrk, "LD_PRELOAD=", 11))
2374
            continue;
2375
        *(dst++) = strdup(*wrk);
2376
    }
2377
    *dst = NULL; /* NULL terminate target_environ */
2378

    
2379
    if (loader_exec(filename, argv+optind, target_environ, regs, info) != 0) {
2380
        printf("Error loading %s\n", filename);
2381
        _exit(1);
2382
    }
2383

    
2384
    for (wrk = target_environ; *wrk; wrk++) {
2385
        free(*wrk);
2386
    }
2387

    
2388
    free(target_environ);
2389

    
2390
    if (loglevel) {
2391
        page_dump(logfile);
2392

    
2393
        fprintf(logfile, "start_brk   0x" TARGET_ABI_FMT_lx "\n", info->start_brk);
2394
        fprintf(logfile, "end_code    0x" TARGET_ABI_FMT_lx "\n", info->end_code);
2395
        fprintf(logfile, "start_code  0x" TARGET_ABI_FMT_lx "\n",
2396
                info->start_code);
2397
        fprintf(logfile, "start_data  0x" TARGET_ABI_FMT_lx "\n",
2398
                info->start_data);
2399
        fprintf(logfile, "end_data    0x" TARGET_ABI_FMT_lx "\n", info->end_data);
2400
        fprintf(logfile, "start_stack 0x" TARGET_ABI_FMT_lx "\n",
2401
                info->start_stack);
2402
        fprintf(logfile, "brk         0x" TARGET_ABI_FMT_lx "\n", info->brk);
2403
        fprintf(logfile, "entry       0x" TARGET_ABI_FMT_lx "\n", info->entry);
2404
    }
2405

    
2406
    target_set_brk(info->brk);
2407
    syscall_init();
2408
    signal_init();
2409

    
2410
    /* build Task State */
2411
    memset(ts, 0, sizeof(TaskState));
2412
    init_task_state(ts);
2413
    ts->info = info;
2414
    env->opaque = ts;
2415
    env->user_mode_only = 1;
2416

    
2417
#if defined(TARGET_I386)
2418
    cpu_x86_set_cpl(env, 3);
2419

    
2420
    env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
2421
    env->hflags |= HF_PE_MASK;
2422
    if (env->cpuid_features & CPUID_SSE) {
2423
        env->cr[4] |= CR4_OSFXSR_MASK;
2424
        env->hflags |= HF_OSFXSR_MASK;
2425
    }
2426
#ifndef TARGET_ABI32
2427
    /* enable 64 bit mode if possible */
2428
    if (!(env->cpuid_ext2_features & CPUID_EXT2_LM)) {
2429
        fprintf(stderr, "The selected x86 CPU does not support 64 bit mode\n");
2430
        exit(1);
2431
    }
2432
    env->cr[4] |= CR4_PAE_MASK;
2433
    env->efer |= MSR_EFER_LMA | MSR_EFER_LME;
2434
    env->hflags |= HF_LMA_MASK;
2435
#endif
2436

    
2437
    /* flags setup : we activate the IRQs by default as in user mode */
2438
    env->eflags |= IF_MASK;
2439

    
2440
    /* linux register setup */
2441
#ifndef TARGET_ABI32
2442
    env->regs[R_EAX] = regs->rax;
2443
    env->regs[R_EBX] = regs->rbx;
2444
    env->regs[R_ECX] = regs->rcx;
2445
    env->regs[R_EDX] = regs->rdx;
2446
    env->regs[R_ESI] = regs->rsi;
2447
    env->regs[R_EDI] = regs->rdi;
2448
    env->regs[R_EBP] = regs->rbp;
2449
    env->regs[R_ESP] = regs->rsp;
2450
    env->eip = regs->rip;
2451
#else
2452
    env->regs[R_EAX] = regs->eax;
2453
    env->regs[R_EBX] = regs->ebx;
2454
    env->regs[R_ECX] = regs->ecx;
2455
    env->regs[R_EDX] = regs->edx;
2456
    env->regs[R_ESI] = regs->esi;
2457
    env->regs[R_EDI] = regs->edi;
2458
    env->regs[R_EBP] = regs->ebp;
2459
    env->regs[R_ESP] = regs->esp;
2460
    env->eip = regs->eip;
2461
#endif
2462

    
2463
    /* linux interrupt setup */
2464
    env->idt.base = h2g(idt_table);
2465
    env->idt.limit = sizeof(idt_table) - 1;
2466
    set_idt(0, 0);
2467
    set_idt(1, 0);
2468
    set_idt(2, 0);
2469
    set_idt(3, 3);
2470
    set_idt(4, 3);
2471
    set_idt(5, 0);
2472
    set_idt(6, 0);
2473
    set_idt(7, 0);
2474
    set_idt(8, 0);
2475
    set_idt(9, 0);
2476
    set_idt(10, 0);
2477
    set_idt(11, 0);
2478
    set_idt(12, 0);
2479
    set_idt(13, 0);
2480
    set_idt(14, 0);
2481
    set_idt(15, 0);
2482
    set_idt(16, 0);
2483
    set_idt(17, 0);
2484
    set_idt(18, 0);
2485
    set_idt(19, 0);
2486
    set_idt(0x80, 3);
2487

    
2488
    /* linux segment setup */
2489
    {
2490
        uint64_t *gdt_table;
2491
        gdt_table = qemu_mallocz(sizeof(uint64_t) * TARGET_GDT_ENTRIES);
2492
        env->gdt.base = h2g((unsigned long)gdt_table);
2493
        env->gdt.limit = sizeof(uint64_t) * TARGET_GDT_ENTRIES - 1;
2494
#ifdef TARGET_ABI32
2495
        write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
2496
                 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
2497
                 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
2498
#else
2499
        /* 64 bit code segment */
2500
        write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
2501
                 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
2502
                 DESC_L_MASK |
2503
                 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
2504
#endif
2505
        write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,
2506
                 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
2507
                 (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
2508
    }
2509
    cpu_x86_load_seg(env, R_CS, __USER_CS);
2510
    cpu_x86_load_seg(env, R_SS, __USER_DS);
2511
#ifdef TARGET_ABI32
2512
    cpu_x86_load_seg(env, R_DS, __USER_DS);
2513
    cpu_x86_load_seg(env, R_ES, __USER_DS);
2514
    cpu_x86_load_seg(env, R_FS, __USER_DS);
2515
    cpu_x86_load_seg(env, R_GS, __USER_DS);
2516
    /* This hack makes Wine work... */
2517
    env->segs[R_FS].selector = 0;
2518
#else
2519
    cpu_x86_load_seg(env, R_DS, 0);
2520
    cpu_x86_load_seg(env, R_ES, 0);
2521
    cpu_x86_load_seg(env, R_FS, 0);
2522
    cpu_x86_load_seg(env, R_GS, 0);
2523
#endif
2524
#elif defined(TARGET_ARM)
2525
    {
2526
        int i;
2527
        cpsr_write(env, regs->uregs[16], 0xffffffff);
2528
        for(i = 0; i < 16; i++) {
2529
            env->regs[i] = regs->uregs[i];
2530
        }
2531
    }
2532
#elif defined(TARGET_SPARC)
2533
    {
2534
        int i;
2535
        env->pc = regs->pc;
2536
        env->npc = regs->npc;
2537
        env->y = regs->y;
2538
        for(i = 0; i < 8; i++)
2539
            env->gregs[i] = regs->u_regs[i];
2540
        for(i = 0; i < 8; i++)
2541
            env->regwptr[i] = regs->u_regs[i + 8];
2542
    }
2543
#elif defined(TARGET_PPC)
2544
    {
2545
        int i;
2546

    
2547
#if defined(TARGET_PPC64)
2548
#if defined(TARGET_ABI32)
2549
        env->msr &= ~((target_ulong)1 << MSR_SF);
2550
#else
2551
        env->msr |= (target_ulong)1 << MSR_SF;
2552
#endif
2553
#endif
2554
        env->nip = regs->nip;
2555
        for(i = 0; i < 32; i++) {
2556
            env->gpr[i] = regs->gpr[i];
2557
        }
2558
    }
2559
#elif defined(TARGET_M68K)
2560
    {
2561
        env->pc = regs->pc;
2562
        env->dregs[0] = regs->d0;
2563
        env->dregs[1] = regs->d1;
2564
        env->dregs[2] = regs->d2;
2565
        env->dregs[3] = regs->d3;
2566
        env->dregs[4] = regs->d4;
2567
        env->dregs[5] = regs->d5;
2568
        env->dregs[6] = regs->d6;
2569
        env->dregs[7] = regs->d7;
2570
        env->aregs[0] = regs->a0;
2571
        env->aregs[1] = regs->a1;
2572
        env->aregs[2] = regs->a2;
2573
        env->aregs[3] = regs->a3;
2574
        env->aregs[4] = regs->a4;
2575
        env->aregs[5] = regs->a5;
2576
        env->aregs[6] = regs->a6;
2577
        env->aregs[7] = regs->usp;
2578
        env->sr = regs->sr;
2579
        ts->sim_syscalls = 1;
2580
    }
2581
#elif defined(TARGET_MIPS)
2582
    {
2583
        int i;
2584

    
2585
        for(i = 0; i < 32; i++) {
2586
            env->active_tc.gpr[i] = regs->regs[i];
2587
        }
2588
        env->active_tc.PC = regs->cp0_epc;
2589
    }
2590
#elif defined(TARGET_SH4)
2591
    {
2592
        int i;
2593

    
2594
        for(i = 0; i < 16; i++) {
2595
            env->gregs[i] = regs->regs[i];
2596
        }
2597
        env->pc = regs->pc;
2598
    }
2599
#elif defined(TARGET_ALPHA)
2600
    {
2601
        int i;
2602

    
2603
        for(i = 0; i < 28; i++) {
2604
            env->ir[i] = ((abi_ulong *)regs)[i];
2605
        }
2606
        env->ipr[IPR_USP] = regs->usp;
2607
        env->ir[30] = regs->usp;
2608
        env->pc = regs->pc;
2609
        env->unique = regs->unique;
2610
    }
2611
#elif defined(TARGET_CRIS)
2612
    {
2613
            env->regs[0] = regs->r0;
2614
            env->regs[1] = regs->r1;
2615
            env->regs[2] = regs->r2;
2616
            env->regs[3] = regs->r3;
2617
            env->regs[4] = regs->r4;
2618
            env->regs[5] = regs->r5;
2619
            env->regs[6] = regs->r6;
2620
            env->regs[7] = regs->r7;
2621
            env->regs[8] = regs->r8;
2622
            env->regs[9] = regs->r9;
2623
            env->regs[10] = regs->r10;
2624
            env->regs[11] = regs->r11;
2625
            env->regs[12] = regs->r12;
2626
            env->regs[13] = regs->r13;
2627
            env->regs[14] = info->start_stack;
2628
            env->regs[15] = regs->acr;            
2629
            env->pc = regs->erp;
2630
    }
2631
#else
2632
#error unsupported target CPU
2633
#endif
2634

    
2635
#if defined(TARGET_ARM) || defined(TARGET_M68K)
2636
    ts->stack_base = info->start_stack;
2637
    ts->heap_base = info->brk;
2638
    /* This will be filled in on the first SYS_HEAPINFO call.  */
2639
    ts->heap_limit = 0;
2640
#endif
2641

    
2642
    if (gdbstub_port) {
2643
        gdbserver_start (gdbstub_port);
2644
        gdb_handlesig(env, 0);
2645
    }
2646
    cpu_loop(env);
2647
    /* never exits */
2648
    return 0;
2649
}