git.maemo.org Git - qemu/blob - cpu-exec.c

   1 /*
   2  *  i386 emulator main execution loop
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include "config.h"
  21 #include "exec.h"
  22 #include "disas.h"
  23
  24 #if !defined(CONFIG_SOFTMMU)
  25 #undef EAX
  26 #undef ECX
  27 #undef EDX
  28 #undef EBX
  29 #undef ESP
  30 #undef EBP
  31 #undef ESI
  32 #undef EDI
  33 #undef EIP
  34 #include <signal.h>
  35 #include <sys/ucontext.h>
  36 #endif
  37
  38 int tb_invalidated_flag;
  39
  40 //#define DEBUG_EXEC
  41 //#define DEBUG_SIGNAL
  42
  43 #if defined(TARGET_ARM) || defined(TARGET_SPARC)
  44 /* XXX: unify with i386 target */
  45 void cpu_loop_exit(void)
  46 {
  47     longjmp(env->jmp_env, 1);
  48 }
  49 #endif
  50
  51 /* exit the current TB from a signal handler. The host registers are
  52    restored in a state compatible with the CPU emulator
  53  */
  54 void cpu_resume_from_signal(CPUState *env1, void *puc)
  55 {
  56 #if !defined(CONFIG_SOFTMMU)
  57     struct ucontext *uc = puc;
  58 #endif
  59
  60     env = env1;
  61
  62     /* XXX: restore cpu registers saved in host registers */
  63
  64 #if !defined(CONFIG_SOFTMMU)
  65     if (puc) {
  66         /* XXX: use siglongjmp ? */
  67         sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL);
  68     }
  69 #endif
  70     longjmp(env->jmp_env, 1);
  71 }
  72
  73 /* main execution loop */
  74
  75 int cpu_exec(CPUState *env1)
  76 {
  77     int saved_T0, saved_T1, saved_T2;
  78     CPUState *saved_env;
  79 #ifdef reg_EAX
  80     int saved_EAX;
  81 #endif
  82 #ifdef reg_ECX
  83     int saved_ECX;
  84 #endif
  85 #ifdef reg_EDX
  86     int saved_EDX;
  87 #endif
  88 #ifdef reg_EBX
  89     int saved_EBX;
  90 #endif
  91 #ifdef reg_ESP
  92     int saved_ESP;
  93 #endif
  94 #ifdef reg_EBP
  95     int saved_EBP;
  96 #endif
  97 #ifdef reg_ESI
  98     int saved_ESI;
  99 #endif
 100 #ifdef reg_EDI
 101     int saved_EDI;
 102 #endif
 103 #ifdef __sparc__
 104     int saved_i7, tmp_T0;
 105 #endif
 106     int code_gen_size, ret, interrupt_request;
 107     void (*gen_func)(void);
 108     TranslationBlock *tb, **ptb;
 109     target_ulong cs_base, pc;
 110     uint8_t *tc_ptr;
 111     unsigned int flags;
 112
 113     /* first we save global registers */
 114     saved_env = env;
 115     env = env1;
 116     saved_T0 = T0;
 117     saved_T1 = T1;
 118     saved_T2 = T2;
 119 #ifdef __sparc__
 120     /* we also save i7 because longjmp may not restore it */
 121     asm volatile ("mov %%i7, %0" : "=r" (saved_i7));
 122 #endif
 123
 124 #if defined(TARGET_I386)
 125 #ifdef reg_EAX
 126     saved_EAX = EAX;
 127 #endif
 128 #ifdef reg_ECX
 129     saved_ECX = ECX;
 130 #endif
 131 #ifdef reg_EDX
 132     saved_EDX = EDX;
 133 #endif
 134 #ifdef reg_EBX
 135     saved_EBX = EBX;
 136 #endif
 137 #ifdef reg_ESP
 138     saved_ESP = ESP;
 139 #endif
 140 #ifdef reg_EBP
 141     saved_EBP = EBP;
 142 #endif
 143 #ifdef reg_ESI
 144     saved_ESI = ESI;
 145 #endif
 146 #ifdef reg_EDI
 147     saved_EDI = EDI;
 148 #endif
 149
 150     env_to_regs();
 151     /* put eflags in CPU temporary format */
 152     CC_SRC = env->eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
 153     DF = 1 - (2 * ((env->eflags >> 10) & 1));
 154     CC_OP = CC_OP_EFLAGS;
 155     env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
 156 #elif defined(TARGET_ARM)
 157     {
 158         unsigned int psr;
 159         psr = env->cpsr;
 160         env->CF = (psr >> 29) & 1;
 161         env->NZF = (psr & 0xc0000000) ^ 0x40000000;
 162         env->VF = (psr << 3) & 0x80000000;
 163         env->QF = (psr >> 27) & 1;
 164         env->cpsr = psr & ~CACHED_CPSR_BITS;
 165     }
 166 #elif defined(TARGET_SPARC)
 167 #elif defined(TARGET_PPC)
 168 #else
 169 #error unsupported target CPU
 170 #endif
 171     env->exception_index = -1;
 172
 173     /* prepare setjmp context for exception handling */
 174     for(;;) {
 175         if (setjmp(env->jmp_env) == 0) {
 176             env->current_tb = NULL;
 177             /* if an exception is pending, we execute it here */
 178             if (env->exception_index >= 0) {
 179                 if (env->exception_index >= EXCP_INTERRUPT) {
 180                     /* exit request from the cpu execution loop */
 181                     ret = env->exception_index;
 182                     break;
 183                 } else if (env->user_mode_only) {
 184                     /* if user mode only, we simulate a fake exception
 185                        which will be hanlded outside the cpu execution
 186                        loop */
 187 #if defined(TARGET_I386)
 188                     do_interrupt_user(env->exception_index,
 189                                       env->exception_is_int,
 190                                       env->error_code,
 191                                       env->exception_next_eip);
 192 #endif
 193                     ret = env->exception_index;
 194                     break;
 195                 } else {
 196 #if defined(TARGET_I386)
 197                     /* simulate a real cpu exception. On i386, it can
 198                        trigger new exceptions, but we do not handle
 199                        double or triple faults yet. */
 200                     do_interrupt(env->exception_index,
 201                                  env->exception_is_int,
 202                                  env->error_code,
 203                                  env->exception_next_eip, 0);
 204 #elif defined(TARGET_PPC)
 205                     do_interrupt(env);
 206 #elif defined(TARGET_SPARC)
 207                     do_interrupt(env->exception_index);
 208 #endif
 209                 }
 210                 env->exception_index = -1;
 211             }
 212 #ifdef USE_KQEMU
 213             if (kqemu_is_ok(env) && env->interrupt_request == 0) {
 214                 int ret;
 215                 env->eflags = env->eflags | cc_table[CC_OP].compute_all() | (DF & DF_MASK);
 216                 ret = kqemu_cpu_exec(env);
 217                 /* put eflags in CPU temporary format */
 218                 CC_SRC = env->eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
 219                 DF = 1 - (2 * ((env->eflags >> 10) & 1));
 220                 CC_OP = CC_OP_EFLAGS;
 221                 env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
 222                 if (ret == 1) {
 223                     /* exception */
 224                     longjmp(env->jmp_env, 1);
 225                 } else if (ret == 2) {
 226                     /* softmmu execution needed */
 227                 } else {
 228                     if (env->interrupt_request != 0) {
 229                         /* hardware interrupt will be executed just after */
 230                     } else {
 231                         /* otherwise, we restart */
 232                         longjmp(env->jmp_env, 1);
 233                     }
 234                 }
 235             }
 236 #endif
 237
 238             T0 = 0; /* force lookup of first TB */
 239             for(;;) {
 240 #ifdef __sparc__
 241                 /* g1 can be modified by some libc? functions */
 242                 tmp_T0 = T0;
 243 #endif
 244                 interrupt_request = env->interrupt_request;
 245                 if (__builtin_expect(interrupt_request, 0)) {
 246 #if defined(TARGET_I386)
 247                     /* if hardware interrupt pending, we execute it */
 248                     if ((interrupt_request & CPU_INTERRUPT_HARD) &&
 249                         (env->eflags & IF_MASK) &&
 250                         !(env->hflags & HF_INHIBIT_IRQ_MASK)) {
 251                         int intno;
 252                         env->interrupt_request &= ~CPU_INTERRUPT_HARD;
 253                         intno = cpu_get_pic_interrupt(env);
 254                         if (loglevel & CPU_LOG_TB_IN_ASM) {
 255                             fprintf(logfile, "Servicing hardware INT=0x%02x\n", intno);
 256                         }
 257                         do_interrupt(intno, 0, 0, 0, 1);
 258                         /* ensure that no TB jump will be modified as
 259                            the program flow was changed */
 260 #ifdef __sparc__
 261                         tmp_T0 = 0;
 262 #else
 263                         T0 = 0;
 264 #endif
 265                     }
 266 #elif defined(TARGET_PPC)
 267 #if 0
 268                     if ((interrupt_request & CPU_INTERRUPT_RESET)) {
 269                         cpu_ppc_reset(env);
 270                     }
 271 #endif
 272                     if (msr_ee != 0) {
 273                     if ((interrupt_request & CPU_INTERRUPT_HARD)) {
 274                             /* Raise it */
 275                             env->exception_index = EXCP_EXTERNAL;
 276                             env->error_code = 0;
 277                             do_interrupt(env);
 278                         env->interrupt_request &= ~CPU_INTERRUPT_HARD;
 279                         } else if ((interrupt_request & CPU_INTERRUPT_TIMER)) {
 280                             /* Raise it */
 281                             env->exception_index = EXCP_DECR;
 282                             env->error_code = 0;
 283                             do_interrupt(env);
 284                             env->interrupt_request &= ~CPU_INTERRUPT_TIMER;
 285                         }
 286                     }
 287 #elif defined(TARGET_SPARC)
 288                     if (interrupt_request & CPU_INTERRUPT_HARD) {
 289                         do_interrupt(env->interrupt_index);
 290                         env->interrupt_request &= ~CPU_INTERRUPT_HARD;
 291                     } else if (interrupt_request & CPU_INTERRUPT_TIMER) {
 292                         //do_interrupt(0, 0, 0, 0, 0);
 293                         env->interrupt_request &= ~CPU_INTERRUPT_TIMER;
 294                     }
 295 #endif
 296                     if (interrupt_request & CPU_INTERRUPT_EXITTB) {
 297                         env->interrupt_request &= ~CPU_INTERRUPT_EXITTB;
 298                         /* ensure that no TB jump will be modified as
 299                            the program flow was changed */
 300 #ifdef __sparc__
 301                         tmp_T0 = 0;
 302 #else
 303                         T0 = 0;
 304 #endif
 305                     }
 306                     if (interrupt_request & CPU_INTERRUPT_EXIT) {
 307                         env->interrupt_request &= ~CPU_INTERRUPT_EXIT;
 308                         env->exception_index = EXCP_INTERRUPT;
 309                         cpu_loop_exit();
 310                     }
 311                 }
 312 #ifdef DEBUG_EXEC
 313                 if ((loglevel & CPU_LOG_EXEC)) {
 314 #if defined(TARGET_I386)
 315                     /* restore flags in standard format */
 316                     env->regs[R_EAX] = EAX;
 317                     env->regs[R_EBX] = EBX;
 318                     env->regs[R_ECX] = ECX;
 319                     env->regs[R_EDX] = EDX;
 320                     env->regs[R_ESI] = ESI;
 321                     env->regs[R_EDI] = EDI;
 322                     env->regs[R_EBP] = EBP;
 323                     env->regs[R_ESP] = ESP;
 324                     env->eflags = env->eflags | cc_table[CC_OP].compute_all() | (DF & DF_MASK);
 325                     cpu_dump_state(env, logfile, fprintf, X86_DUMP_CCOP);
 326                     env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
 327 #elif defined(TARGET_ARM)
 328                     env->cpsr = compute_cpsr();
 329                     cpu_dump_state(env, logfile, fprintf, 0);
 330                     env->cpsr &= ~CACHED_CPSR_BITS;
 331 #elif defined(TARGET_SPARC)
 332                     cpu_dump_state (env, logfile, fprintf, 0);
 333 #elif defined(TARGET_PPC)
 334                     cpu_dump_state(env, logfile, fprintf, 0);
 335 #else
 336 #error unsupported target CPU
 337 #endif
 338                 }
 339 #endif
 340                 /* we record a subset of the CPU state. It will
 341                    always be the same before a given translated block
 342                    is executed. */
 343 #if defined(TARGET_I386)
 344                 flags = env->hflags;
 345                 flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
 346                 cs_base = env->segs[R_CS].base;
 347                 pc = cs_base + env->eip;
 348 #elif defined(TARGET_ARM)
 349                 flags = env->thumb;
 350                 cs_base = 0;
 351                 pc = env->regs[15];
 352 #elif defined(TARGET_SPARC)
 353                 flags = 0;
 354                 cs_base = env->npc;
 355                 pc = env->pc;
 356 #elif defined(TARGET_PPC)
 357                 flags = (msr_pr << MSR_PR) | (msr_fp << MSR_FP) | (msr_se << MSR_SE);
 358                 cs_base = 0;
 359                 pc = env->nip;
 360 #else
 361 #error unsupported CPU
 362 #endif
 363                 tb = tb_find(&ptb, pc, cs_base,
 364                              flags);
 365                 if (!tb) {
 366                     TranslationBlock **ptb1;
 367                     unsigned int h;
 368                     target_ulong phys_pc, phys_page1, phys_page2, virt_page2;
 369
 370
 371                     spin_lock(&tb_lock);
 372
 373                     tb_invalidated_flag = 0;
 374
 375                     regs_to_env(); /* XXX: do it just before cpu_gen_code() */
 376
 377                     /* find translated block using physical mappings */
 378                     phys_pc = get_phys_addr_code(env, pc);
 379                     phys_page1 = phys_pc & TARGET_PAGE_MASK;
 380                     phys_page2 = -1;
 381                     h = tb_phys_hash_func(phys_pc);
 382                     ptb1 = &tb_phys_hash[h];
 383                     for(;;) {
 384                         tb = *ptb1;
 385                         if (!tb)
 386                             goto not_found;
 387                         if (tb->pc == pc &&
 388                             tb->page_addr[0] == phys_page1 &&
 389                             tb->cs_base == cs_base &&
 390                             tb->flags == flags) {
 391                             /* check next page if needed */
 392                             if (tb->page_addr[1] != -1) {
 393                                 virt_page2 = (pc & TARGET_PAGE_MASK) +
 394                                     TARGET_PAGE_SIZE;
 395                                 phys_page2 = get_phys_addr_code(env, virt_page2);
 396                                 if (tb->page_addr[1] == phys_page2)
 397                                     goto found;
 398                             } else {
 399                                 goto found;
 400                             }
 401                         }
 402                         ptb1 = &tb->phys_hash_next;
 403                     }
 404                 not_found:
 405                     /* if no translated code available, then translate it now */
 406                     tb = tb_alloc(pc);
 407                     if (!tb) {
 408                         /* flush must be done */
 409                         tb_flush(env);
 410                         /* cannot fail at this point */
 411                         tb = tb_alloc(pc);
 412                         /* don't forget to invalidate previous TB info */
 413                         ptb = &tb_hash[tb_hash_func(pc)];
 414                         T0 = 0;
 415                     }
 416                     tc_ptr = code_gen_ptr;
 417                     tb->tc_ptr = tc_ptr;
 418                     tb->cs_base = cs_base;
 419                     tb->flags = flags;
 420                     cpu_gen_code(env, tb, CODE_GEN_MAX_SIZE, &code_gen_size);
 421                     code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
 422
 423                     /* check next page if needed */
 424                     virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
 425                     phys_page2 = -1;
 426                     if ((pc & TARGET_PAGE_MASK) != virt_page2) {
 427                         phys_page2 = get_phys_addr_code(env, virt_page2);
 428                     }
 429                     tb_link_phys(tb, phys_pc, phys_page2);
 430
 431                 found:
 432                     if (tb_invalidated_flag) {
 433                         /* as some TB could have been invalidated because
 434                            of memory exceptions while generating the code, we
 435                            must recompute the hash index here */
 436                         ptb = &tb_hash[tb_hash_func(pc)];
 437                         while (*ptb != NULL)
 438                             ptb = &(*ptb)->hash_next;
 439                         T0 = 0;
 440                     }
 441                     /* we add the TB in the virtual pc hash table */
 442                     *ptb = tb;
 443                     tb->hash_next = NULL;
 444                     tb_link(tb);
 445                     spin_unlock(&tb_lock);
 446                 }
 447 #ifdef DEBUG_EXEC
 448                 if ((loglevel & CPU_LOG_EXEC)) {
 449                     fprintf(logfile, "Trace 0x%08lx [" TARGET_FMT_lx "] %s\n",
 450                             (long)tb->tc_ptr, tb->pc,
 451                             lookup_symbol(tb->pc));
 452                 }
 453 #endif
 454 #ifdef __sparc__
 455                 T0 = tmp_T0;
 456 #endif
 457                 /* see if we can patch the calling TB. */
 458                 {
 459                     if (T0 != 0
 460 #if defined(TARGET_I386) && defined(USE_CODE_COPY)
 461                     && (tb->cflags & CF_CODE_COPY) ==
 462                     (((TranslationBlock *)(T0 & ~3))->cflags & CF_CODE_COPY)
 463 #endif
 464                     ) {
 465                     spin_lock(&tb_lock);
 466                     tb_add_jump((TranslationBlock *)(long)(T0 & ~3), T0 & 3, tb);
 467 #if defined(USE_CODE_COPY)
 468                     /* propagates the FP use info */
 469                     ((TranslationBlock *)(T0 & ~3))->cflags |=
 470                         (tb->cflags & CF_FP_USED);
 471 #endif
 472                     spin_unlock(&tb_lock);
 473                 }
 474                 }
 475                 tc_ptr = tb->tc_ptr;
 476                 env->current_tb = tb;
 477                 /* execute the generated code */
 478                 gen_func = (void *)tc_ptr;
 479 #if defined(__sparc__)
 480                 __asm__ __volatile__("call      %0\n\t"
 481                                      "mov       %%o7,%%i0"
 482                                      : /* no outputs */
 483                                      : "r" (gen_func)
 484                                      : "i0", "i1", "i2", "i3", "i4", "i5");
 485 #elif defined(__arm__)
 486                 asm volatile ("mov pc, %0\n\t"
 487                               ".global exec_loop\n\t"
 488                               "exec_loop:\n\t"
 489                               : /* no outputs */
 490                               : "r" (gen_func)
 491                               : "r1", "r2", "r3", "r8", "r9", "r10", "r12", "r14");
 492 #elif defined(TARGET_I386) && defined(USE_CODE_COPY)
 493 {
 494     if (!(tb->cflags & CF_CODE_COPY)) {
 495         if ((tb->cflags & CF_FP_USED) && env->native_fp_regs) {
 496             save_native_fp_state(env);
 497         }
 498         gen_func();
 499     } else {
 500         if ((tb->cflags & CF_FP_USED) && !env->native_fp_regs) {
 501             restore_native_fp_state(env);
 502         }
 503         /* we work with native eflags */
 504         CC_SRC = cc_table[CC_OP].compute_all();
 505         CC_OP = CC_OP_EFLAGS;
 506         asm(".globl exec_loop\n"
 507             "\n"
 508             "debug1:\n"
 509             "    pushl %%ebp\n"
 510             "    fs movl %10, %9\n"
 511             "    fs movl %11, %%eax\n"
 512             "    andl $0x400, %%eax\n"
 513             "    fs orl %8, %%eax\n"
 514             "    pushl %%eax\n"
 515             "    popf\n"
 516             "    fs movl %%esp, %12\n"
 517             "    fs movl %0, %%eax\n"
 518             "    fs movl %1, %%ecx\n"
 519             "    fs movl %2, %%edx\n"
 520             "    fs movl %3, %%ebx\n"
 521             "    fs movl %4, %%esp\n"
 522             "    fs movl %5, %%ebp\n"
 523             "    fs movl %6, %%esi\n"
 524             "    fs movl %7, %%edi\n"
 525             "    fs jmp *%9\n"
 526             "exec_loop:\n"
 527             "    fs movl %%esp, %4\n"
 528             "    fs movl %12, %%esp\n"
 529             "    fs movl %%eax, %0\n"
 530             "    fs movl %%ecx, %1\n"
 531             "    fs movl %%edx, %2\n"
 532             "    fs movl %%ebx, %3\n"
 533             "    fs movl %%ebp, %5\n"
 534             "    fs movl %%esi, %6\n"
 535             "    fs movl %%edi, %7\n"
 536             "    pushf\n"
 537             "    popl %%eax\n"
 538             "    movl %%eax, %%ecx\n"
 539             "    andl $0x400, %%ecx\n"
 540             "    shrl $9, %%ecx\n"
 541             "    andl $0x8d5, %%eax\n"
 542             "    fs movl %%eax, %8\n"
 543             "    movl $1, %%eax\n"
 544             "    subl %%ecx, %%eax\n"
 545             "    fs movl %%eax, %11\n"
 546             "    fs movl %9, %%ebx\n" /* get T0 value */
 547             "    popl %%ebp\n"
 548             :
 549             : "m" (*(uint8_t *)offsetof(CPUState, regs[0])),
 550             "m" (*(uint8_t *)offsetof(CPUState, regs[1])),
 551             "m" (*(uint8_t *)offsetof(CPUState, regs[2])),
 552             "m" (*(uint8_t *)offsetof(CPUState, regs[3])),
 553             "m" (*(uint8_t *)offsetof(CPUState, regs[4])),
 554             "m" (*(uint8_t *)offsetof(CPUState, regs[5])),
 555             "m" (*(uint8_t *)offsetof(CPUState, regs[6])),
 556             "m" (*(uint8_t *)offsetof(CPUState, regs[7])),
 557             "m" (*(uint8_t *)offsetof(CPUState, cc_src)),
 558             "m" (*(uint8_t *)offsetof(CPUState, tmp0)),
 559             "a" (gen_func),
 560             "m" (*(uint8_t *)offsetof(CPUState, df)),
 561             "m" (*(uint8_t *)offsetof(CPUState, saved_esp))
 562             : "%ecx", "%edx"
 563             );
 564     }
 565 }
 566 #else
 567                 gen_func();
 568 #endif
 569                 env->current_tb = NULL;
 570                 /* reset soft MMU for next block (it can currently
 571                    only be set by a memory fault) */
 572 #if defined(TARGET_I386) && !defined(CONFIG_SOFTMMU)
 573                 if (env->hflags & HF_SOFTMMU_MASK) {
 574                     env->hflags &= ~HF_SOFTMMU_MASK;
 575                     /* do not allow linking to another block */
 576                     T0 = 0;
 577                 }
 578 #endif
 579             }
 580         } else {
 581             env_to_regs();
 582         }
 583     } /* for(;;) */
 584
 585
 586 #if defined(TARGET_I386)
 587 #if defined(USE_CODE_COPY)
 588     if (env->native_fp_regs) {
 589         save_native_fp_state(env);
 590     }
 591 #endif
 592     /* restore flags in standard format */
 593     env->eflags = env->eflags | cc_table[CC_OP].compute_all() | (DF & DF_MASK);
 594
 595     /* restore global registers */
 596 #ifdef reg_EAX
 597     EAX = saved_EAX;
 598 #endif
 599 #ifdef reg_ECX
 600     ECX = saved_ECX;
 601 #endif
 602 #ifdef reg_EDX
 603     EDX = saved_EDX;
 604 #endif
 605 #ifdef reg_EBX
 606     EBX = saved_EBX;
 607 #endif
 608 #ifdef reg_ESP
 609     ESP = saved_ESP;
 610 #endif
 611 #ifdef reg_EBP
 612     EBP = saved_EBP;
 613 #endif
 614 #ifdef reg_ESI
 615     ESI = saved_ESI;
 616 #endif
 617 #ifdef reg_EDI
 618     EDI = saved_EDI;
 619 #endif
 620 #elif defined(TARGET_ARM)
 621     env->cpsr = compute_cpsr();
 622 #elif defined(TARGET_SPARC)
 623 #elif defined(TARGET_PPC)
 624 #else
 625 #error unsupported target CPU
 626 #endif
 627 #ifdef __sparc__
 628     asm volatile ("mov %0, %%i7" : : "r" (saved_i7));
 629 #endif
 630     T0 = saved_T0;
 631     T1 = saved_T1;
 632     T2 = saved_T2;
 633     env = saved_env;
 634     return ret;
 635 }
 636
 637 /* must only be called from the generated code as an exception can be
 638    generated */
 639 void tb_invalidate_page_range(target_ulong start, target_ulong end)
 640 {
 641     /* XXX: cannot enable it yet because it yields to MMU exception
 642        where NIP != read address on PowerPC */
 643 #if 0
 644     target_ulong phys_addr;
 645     phys_addr = get_phys_addr_code(env, start);
 646     tb_invalidate_phys_page_range(phys_addr, phys_addr + end - start, 0);
 647 #endif
 648 }
 649
 650 #if defined(TARGET_I386) && defined(CONFIG_USER_ONLY)
 651
 652 void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector)
 653 {
 654     CPUX86State *saved_env;
 655
 656     saved_env = env;
 657     env = s;
 658     if (!(env->cr[0] & CR0_PE_MASK) || (env->eflags & VM_MASK)) {
 659         selector &= 0xffff;
 660         cpu_x86_load_seg_cache(env, seg_reg, selector,
 661                                (selector << 4), 0xffff, 0);
 662     } else {
 663         load_seg(seg_reg, selector);
 664     }
 665     env = saved_env;
 666 }
 667
 668 void cpu_x86_fsave(CPUX86State *s, uint8_t *ptr, int data32)
 669 {
 670     CPUX86State *saved_env;
 671
 672     saved_env = env;
 673     env = s;
 674
 675     helper_fsave((target_ulong)ptr, data32);
 676
 677     env = saved_env;
 678 }
 679
 680 void cpu_x86_frstor(CPUX86State *s, uint8_t *ptr, int data32)
 681 {
 682     CPUX86State *saved_env;
 683
 684     saved_env = env;
 685     env = s;
 686
 687     helper_frstor((target_ulong)ptr, data32);
 688
 689     env = saved_env;
 690 }
 691
 692 #endif /* TARGET_I386 */
 693
 694 #if !defined(CONFIG_SOFTMMU)
 695
 696 #if defined(TARGET_I386)
 697
 698 /* 'pc' is the host PC at which the exception was raised. 'address' is
 699    the effective address of the memory exception. 'is_write' is 1 if a
 700    write caused the exception and otherwise 0'. 'old_set' is the
 701    signal set which should be restored */
 702 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
 703                                     int is_write, sigset_t *old_set,
 704                                     void *puc)
 705 {
 706     TranslationBlock *tb;
 707     int ret;
 708
 709     if (cpu_single_env)
 710         env = cpu_single_env; /* XXX: find a correct solution for multithread */
 711 #if defined(DEBUG_SIGNAL)
 712     qemu_printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
 713                 pc, address, is_write, *(unsigned long *)old_set);
 714 #endif
 715     /* XXX: locking issue */
 716     if (is_write && page_unprotect(address, pc, puc)) {
 717         return 1;
 718     }
 719
 720     /* see if it is an MMU fault */
 721     ret = cpu_x86_handle_mmu_fault(env, address, is_write,
 722                                    ((env->hflags & HF_CPL_MASK) == 3), 0);
 723     if (ret < 0)
 724         return 0; /* not an MMU fault */
 725     if (ret == 0)
 726         return 1; /* the MMU fault was handled without causing real CPU fault */
 727     /* now we have a real cpu fault */
 728     tb = tb_find_pc(pc);
 729     if (tb) {
 730         /* the PC is inside the translated code. It means that we have
 731            a virtual CPU fault */
 732         cpu_restore_state(tb, env, pc, puc);
 733     }
 734     if (ret == 1) {
 735 #if 0
 736         printf("PF exception: EIP=0x%08x CR2=0x%08x error=0x%x\n",
 737                env->eip, env->cr[2], env->error_code);
 738 #endif
 739         /* we restore the process signal mask as the sigreturn should
 740            do it (XXX: use sigsetjmp) */
 741         sigprocmask(SIG_SETMASK, old_set, NULL);
 742         raise_exception_err(EXCP0E_PAGE, env->error_code);
 743     } else {
 744         /* activate soft MMU for this block */
 745         env->hflags |= HF_SOFTMMU_MASK;
 746         cpu_resume_from_signal(env, puc);
 747     }
 748     /* never comes here */
 749     return 1;
 750 }
 751
 752 #elif defined(TARGET_ARM)
 753 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
 754                                     int is_write, sigset_t *old_set,
 755                                     void *puc)
 756 {
 757     TranslationBlock *tb;
 758     int ret;
 759
 760     if (cpu_single_env)
 761         env = cpu_single_env; /* XXX: find a correct solution for multithread */
 762 #if defined(DEBUG_SIGNAL)
 763     printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
 764            pc, address, is_write, *(unsigned long *)old_set);
 765 #endif
 766     /* XXX: locking issue */
 767     if (is_write && page_unprotect(address, pc, puc)) {
 768         return 1;
 769     }
 770     /* see if it is an MMU fault */
 771     ret = cpu_arm_handle_mmu_fault(env, address, is_write, 1, 0);
 772     if (ret < 0)
 773         return 0; /* not an MMU fault */
 774     if (ret == 0)
 775         return 1; /* the MMU fault was handled without causing real CPU fault */
 776     /* now we have a real cpu fault */
 777     tb = tb_find_pc(pc);
 778     if (tb) {
 779         /* the PC is inside the translated code. It means that we have
 780            a virtual CPU fault */
 781         cpu_restore_state(tb, env, pc, puc);
 782     }
 783     /* we restore the process signal mask as the sigreturn should
 784        do it (XXX: use sigsetjmp) */
 785     sigprocmask(SIG_SETMASK, old_set, NULL);
 786     cpu_loop_exit();
 787 }
 788 #elif defined(TARGET_SPARC)
 789 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
 790                                     int is_write, sigset_t *old_set,
 791                                     void *puc)
 792 {
 793     TranslationBlock *tb;
 794     int ret;
 795
 796     if (cpu_single_env)
 797         env = cpu_single_env; /* XXX: find a correct solution for multithread */
 798 #if defined(DEBUG_SIGNAL)
 799     printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
 800            pc, address, is_write, *(unsigned long *)old_set);
 801 #endif
 802     /* XXX: locking issue */
 803     if (is_write && page_unprotect(address, pc, puc)) {
 804         return 1;
 805     }
 806     /* see if it is an MMU fault */
 807     ret = cpu_sparc_handle_mmu_fault(env, address, is_write, 1, 0);
 808     if (ret < 0)
 809         return 0; /* not an MMU fault */
 810     if (ret == 0)
 811         return 1; /* the MMU fault was handled without causing real CPU fault */
 812     /* now we have a real cpu fault */
 813     tb = tb_find_pc(pc);
 814     if (tb) {
 815         /* the PC is inside the translated code. It means that we have
 816            a virtual CPU fault */
 817         cpu_restore_state(tb, env, pc, puc);
 818     }
 819     /* we restore the process signal mask as the sigreturn should
 820        do it (XXX: use sigsetjmp) */
 821     sigprocmask(SIG_SETMASK, old_set, NULL);
 822     cpu_loop_exit();
 823 }
 824 #elif defined (TARGET_PPC)
 825 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
 826                                     int is_write, sigset_t *old_set,
 827                                     void *puc)
 828 {
 829     TranslationBlock *tb;
 830     int ret;
 831
 832     if (cpu_single_env)
 833         env = cpu_single_env; /* XXX: find a correct solution for multithread */
 834 #if defined(DEBUG_SIGNAL)
 835     printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
 836            pc, address, is_write, *(unsigned long *)old_set);
 837 #endif
 838     /* XXX: locking issue */
 839     if (is_write && page_unprotect(address, pc, puc)) {
 840         return 1;
 841     }
 842
 843     /* see if it is an MMU fault */
 844     ret = cpu_ppc_handle_mmu_fault(env, address, is_write, msr_pr, 0);
 845     if (ret < 0)
 846         return 0; /* not an MMU fault */
 847     if (ret == 0)
 848         return 1; /* the MMU fault was handled without causing real CPU fault */
 849
 850     /* now we have a real cpu fault */
 851     tb = tb_find_pc(pc);
 852     if (tb) {
 853         /* the PC is inside the translated code. It means that we have
 854            a virtual CPU fault */
 855         cpu_restore_state(tb, env, pc, puc);
 856     }
 857     if (ret == 1) {
 858 #if 0
 859         printf("PF exception: NIP=0x%08x error=0x%x %p\n",
 860                env->nip, env->error_code, tb);
 861 #endif
 862     /* we restore the process signal mask as the sigreturn should
 863        do it (XXX: use sigsetjmp) */
 864         sigprocmask(SIG_SETMASK, old_set, NULL);
 865         do_raise_exception_err(env->exception_index, env->error_code);
 866     } else {
 867         /* activate soft MMU for this block */
 868         cpu_resume_from_signal(env, puc);
 869     }
 870     /* never comes here */
 871     return 1;
 872 }
 873 #else
 874 #error unsupported target CPU
 875 #endif
 876
 877 #if defined(__i386__)
 878
 879 #if defined(USE_CODE_COPY)
 880 static void cpu_send_trap(unsigned long pc, int trap,
 881                           struct ucontext *uc)
 882 {
 883     TranslationBlock *tb;
 884
 885     if (cpu_single_env)
 886         env = cpu_single_env; /* XXX: find a correct solution for multithread */
 887     /* now we have a real cpu fault */
 888     tb = tb_find_pc(pc);
 889     if (tb) {
 890         /* the PC is inside the translated code. It means that we have
 891            a virtual CPU fault */
 892         cpu_restore_state(tb, env, pc, uc);
 893     }
 894     sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL);
 895     raise_exception_err(trap, env->error_code);
 896 }
 897 #endif
 898
 899 int cpu_signal_handler(int host_signum, struct siginfo *info,
 900                        void *puc)
 901 {
 902     struct ucontext *uc = puc;
 903     unsigned long pc;
 904     int trapno;
 905
 906 #ifndef REG_EIP
 907 /* for glibc 2.1 */
 908 #define REG_EIP    EIP
 909 #define REG_ERR    ERR
 910 #define REG_TRAPNO TRAPNO
 911 #endif
 912     pc = uc->uc_mcontext.gregs[REG_EIP];
 913     trapno = uc->uc_mcontext.gregs[REG_TRAPNO];
 914 #if defined(TARGET_I386) && defined(USE_CODE_COPY)
 915     if (trapno == 0x00 || trapno == 0x05) {
 916         /* send division by zero or bound exception */
 917         cpu_send_trap(pc, trapno, uc);
 918         return 1;
 919     } else
 920 #endif
 921         return handle_cpu_signal(pc, (unsigned long)info->si_addr,
 922                                  trapno == 0xe ?
 923                                  (uc->uc_mcontext.gregs[REG_ERR] >> 1) & 1 : 0,
 924                                  &uc->uc_sigmask, puc);
 925 }
 926
 927 #elif defined(__x86_64__)
 928
 929 int cpu_signal_handler(int host_signum, struct siginfo *info,
 930                        void *puc)
 931 {
 932     struct ucontext *uc = puc;
 933     unsigned long pc;
 934
 935     pc = uc->uc_mcontext.gregs[REG_RIP];
 936     return handle_cpu_signal(pc, (unsigned long)info->si_addr,
 937                              uc->uc_mcontext.gregs[REG_TRAPNO] == 0xe ?
 938                              (uc->uc_mcontext.gregs[REG_ERR] >> 1) & 1 : 0,
 939                              &uc->uc_sigmask, puc);
 940 }
 941
 942 #elif defined(__powerpc__)
 943
 944 /***********************************************************************
 945  * signal context platform-specific definitions
 946  * From Wine
 947  */
 948 #ifdef linux
 949 /* All Registers access - only for local access */
 950 # define REG_sig(reg_name, context)             ((context)->uc_mcontext.regs->reg_name)
 951 /* Gpr Registers access  */
 952 # define GPR_sig(reg_num, context)              REG_sig(gpr[reg_num], context)
 953 # define IAR_sig(context)                       REG_sig(nip, context)   /* Program counter */
 954 # define MSR_sig(context)                       REG_sig(msr, context)   /* Machine State Register (Supervisor) */
 955 # define CTR_sig(context)                       REG_sig(ctr, context)   /* Count register */
 956 # define XER_sig(context)                       REG_sig(xer, context) /* User's integer exception register */
 957 # define LR_sig(context)                        REG_sig(link, context) /* Link register */
 958 # define CR_sig(context)                        REG_sig(ccr, context) /* Condition register */
 959 /* Float Registers access  */
 960 # define FLOAT_sig(reg_num, context)            (((double*)((char*)((context)->uc_mcontext.regs+48*4)))[reg_num])
 961 # define FPSCR_sig(context)                     (*(int*)((char*)((context)->uc_mcontext.regs+(48+32*2)*4)))
 962 /* Exception Registers access */
 963 # define DAR_sig(context)                       REG_sig(dar, context)
 964 # define DSISR_sig(context)                     REG_sig(dsisr, context)
 965 # define TRAP_sig(context)                      REG_sig(trap, context)
 966 #endif /* linux */
 967
 968 #ifdef __APPLE__
 969 # include <sys/ucontext.h>
 970 typedef struct ucontext SIGCONTEXT;
 971 /* All Registers access - only for local access */
 972 # define REG_sig(reg_name, context)             ((context)->uc_mcontext->ss.reg_name)
 973 # define FLOATREG_sig(reg_name, context)        ((context)->uc_mcontext->fs.reg_name)
 974 # define EXCEPREG_sig(reg_name, context)        ((context)->uc_mcontext->es.reg_name)
 975 # define VECREG_sig(reg_name, context)          ((context)->uc_mcontext->vs.reg_name)
 976 /* Gpr Registers access */
 977 # define GPR_sig(reg_num, context)              REG_sig(r##reg_num, context)
 978 # define IAR_sig(context)                       REG_sig(srr0, context)  /* Program counter */
 979 # define MSR_sig(context)                       REG_sig(srr1, context)  /* Machine State Register (Supervisor) */
 980 # define CTR_sig(context)                       REG_sig(ctr, context)
 981 # define XER_sig(context)                       REG_sig(xer, context) /* Link register */
 982 # define LR_sig(context)                        REG_sig(lr, context)  /* User's integer exception register */
 983 # define CR_sig(context)                        REG_sig(cr, context)  /* Condition register */
 984 /* Float Registers access */
 985 # define FLOAT_sig(reg_num, context)            FLOATREG_sig(fpregs[reg_num], context)
 986 # define FPSCR_sig(context)                     ((double)FLOATREG_sig(fpscr, context))
 987 /* Exception Registers access */
 988 # define DAR_sig(context)                       EXCEPREG_sig(dar, context)     /* Fault registers for coredump */
 989 # define DSISR_sig(context)                     EXCEPREG_sig(dsisr, context)
 990 # define TRAP_sig(context)                      EXCEPREG_sig(exception, context) /* number of powerpc exception taken */
 991 #endif /* __APPLE__ */
 992
 993 int cpu_signal_handler(int host_signum, struct siginfo *info,
 994                        void *puc)
 995 {
 996     struct ucontext *uc = puc;
 997     unsigned long pc;
 998     int is_write;
 999
1000     pc = IAR_sig(uc);
1001     is_write = 0;
1002 #if 0
1003     /* ppc 4xx case */
1004     if (DSISR_sig(uc) & 0x00800000)
1005         is_write = 1;
1006 #else
1007     if (TRAP_sig(uc) != 0x400 && (DSISR_sig(uc) & 0x02000000))
1008         is_write = 1;
1009 #endif
1010     return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1011                              is_write, &uc->uc_sigmask, puc);
1012 }
1013
1014 #elif defined(__alpha__)
1015
1016 int cpu_signal_handler(int host_signum, struct siginfo *info,
1017                            void *puc)
1018 {
1019     struct ucontext *uc = puc;
1020     uint32_t *pc = uc->uc_mcontext.sc_pc;
1021     uint32_t insn = *pc;
1022     int is_write = 0;
1023
1024     /* XXX: need kernel patch to get write flag faster */
1025     switch (insn >> 26) {
1026     case 0x0d: // stw
1027     case 0x0e: // stb
1028     case 0x0f: // stq_u
1029     case 0x24: // stf
1030     case 0x25: // stg
1031     case 0x26: // sts
1032     case 0x27: // stt
1033     case 0x2c: // stl
1034     case 0x2d: // stq
1035     case 0x2e: // stl_c
1036     case 0x2f: // stq_c
1037         is_write = 1;
1038     }
1039
1040     return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1041                              is_write, &uc->uc_sigmask, puc);
1042 }
1043 #elif defined(__sparc__)
1044
1045 int cpu_signal_handler(int host_signum, struct siginfo *info,
1046                        void *puc)
1047 {
1048     uint32_t *regs = (uint32_t *)(info + 1);
1049     void *sigmask = (regs + 20);
1050     unsigned long pc;
1051     int is_write;
1052     uint32_t insn;
1053
1054     /* XXX: is there a standard glibc define ? */
1055     pc = regs[1];
1056     /* XXX: need kernel patch to get write flag faster */
1057     is_write = 0;
1058     insn = *(uint32_t *)pc;
1059     if ((insn >> 30) == 3) {
1060       switch((insn >> 19) & 0x3f) {
1061       case 0x05: // stb
1062       case 0x06: // sth
1063       case 0x04: // st
1064       case 0x07: // std
1065       case 0x24: // stf
1066       case 0x27: // stdf
1067       case 0x25: // stfsr
1068         is_write = 1;
1069         break;
1070       }
1071     }
1072     return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1073                              is_write, sigmask, NULL);
1074 }
1075
1076 #elif defined(__arm__)
1077
1078 int cpu_signal_handler(int host_signum, struct siginfo *info,
1079                        void *puc)
1080 {
1081     struct ucontext *uc = puc;
1082     unsigned long pc;
1083     int is_write;
1084
1085     pc = uc->uc_mcontext.gregs[R15];
1086     /* XXX: compute is_write */
1087     is_write = 0;
1088     return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1089                              is_write,
1090                              &uc->uc_sigmask);
1091 }
1092
1093 #elif defined(__mc68000)
1094
1095 int cpu_signal_handler(int host_signum, struct siginfo *info,
1096                        void *puc)
1097 {
1098     struct ucontext *uc = puc;
1099     unsigned long pc;
1100     int is_write;
1101
1102     pc = uc->uc_mcontext.gregs[16];
1103     /* XXX: compute is_write */
1104     is_write = 0;
1105     return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1106                              is_write,
1107                              &uc->uc_sigmask, puc);
1108 }
1109
1110 #else
1111
1112 #error host CPU specific signal handler needed
1113
1114 #endif
1115
1116 #endif /* !defined(CONFIG_SOFTMMU) */