ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp
(Generate patch)

Comparing SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp (file contents):
Revision 1.49 by gbeauche, 2004-07-11T06:42:28Z vs.
Revision 1.56 by gbeauche, 2005-01-30T21:12:07Z

# Line 42 | Line 42
42  
43   #include <stdio.h>
44   #include <stdlib.h>
45 + #ifdef HAVE_MALLOC_H
46 + #include <malloc.h>
47 + #endif
48  
49   #ifdef USE_SDL_VIDEO
50   #include <SDL_events.h>
# Line 106 | Line 109 | const uint32 POWERPC_EXEC_RETURN = POWER
109   #define INTERRUPTS_IN_NATIVE_MODE 1
110  
111   // Pointer to Kernel Data
112 < static KernelData * const kernel_data = (KernelData *)KERNEL_DATA_BASE;
112 > static KernelData * kernel_data;
113  
114   // SIGSEGV handler
115   sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t);
# Line 142 | Line 145 | class sheepshaver_cpu
145          // CPU context to preserve on interrupt
146          class interrupt_context {
147                  uint32 gpr[32];
148 +                double fpr[32];
149                  uint32 pc;
150                  uint32 lr;
151                  uint32 ctr;
152                  uint32 cr;
153                  uint32 xer;
154 +                uint32 fpscr;
155                  sheepshaver_cpu *cpu;
156                  const char *where;
157          public:
# Line 180 | Line 185 | public:
185          // Execute MacOS/PPC code
186          uint32 execute_macos_code(uint32 tvect, int nargs, uint32 const *args);
187  
188 + #if PPC_ENABLE_JIT
189          // Compile one instruction
190          virtual int compile1(codegen_context_t & cg_context);
191 <
191 > #endif
192          // Resource manager thunk
193          void get_resource(uint32 old_get_resource);
194  
# Line 192 | Line 198 | public:
198  
199          // Make sure the SIGSEGV handler can access CPU registers
200          friend sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t);
201 +
202 +        // Memory allocator returning areas aligned on 16-byte boundaries
203 +        void *operator new(size_t size);
204 +        void operator delete(void *p);
205   };
206  
207   // Memory allocator returning areas aligned on 16-byte boundaries
208 < void *operator new(size_t size)
208 > void *sheepshaver_cpu::operator new(size_t size)
209   {
210          void *p;
211  
# Line 214 | Line 224 | void *operator new(size_t size)
224          return p;
225   }
226  
227 < void operator delete(void *p)
227 > void sheepshaver_cpu::operator delete(void *p)
228   {
229   #if defined(HAVE_MEMALIGN) || defined(HAVE_VALLOC)
230   #if defined(__GLIBC__)
# Line 318 | Line 328 | void sheepshaver_cpu::execute_sheep(uint
328   }
329  
330   // Compile one instruction
331 + #if PPC_ENABLE_JIT
332   int sheepshaver_cpu::compile1(codegen_context_t & cg_context)
333   {
323 – #if PPC_ENABLE_JIT
334          const instr_info_t *ii = cg_context.instr_info;
335          if (ii->mnemo != PPC_I(SHEEP))
336                  return COMPILE_FAILURE;
# Line 466 | Line 476 | int sheepshaver_cpu::compile1(codegen_co
476          }
477          }
478          return status;
469 – #endif
470 –        return COMPILE_FAILURE;
479   }
480 + #endif
481  
482   // CPU context to preserve on interrupt
483   sheepshaver_cpu::interrupt_context::interrupt_context(sheepshaver_cpu *_cpu, const char *_where)
# Line 479 | Line 488 | sheepshaver_cpu::interrupt_context::inte
488  
489          // Save interrupt context
490          memcpy(&gpr[0], &cpu->gpr(0), sizeof(gpr));
491 +        memcpy(&fpr[0], &cpu->fpr(0), sizeof(fpr));
492          pc = cpu->pc();
493          lr = cpu->lr();
494          ctr = cpu->ctr();
495          cr = cpu->get_cr();
496          xer = cpu->get_xer();
497 +        fpscr = cpu->fpscr();
498   #endif
499   }
500  
# Line 497 | Line 508 | sheepshaver_cpu::interrupt_context::~int
508                          if (gpr[i] != cpu->gpr(i))
509                                  printf(" r%d: %08x -> %08x\n", i, gpr[i], cpu->gpr(i));
510          }
511 +        if (memcmp(&fpr[0], &cpu->fpr(0), sizeof(fpr)) != 0) {
512 +                printf("FATAL: %s: interrupt clobbers registers\n", where);
513 +                for (int i = 0; i < 32; i++)
514 +                        if (fpr[i] != cpu->fpr(i))
515 +                                printf(" r%d: %f -> %f\n", i, fpr[i], cpu->fpr(i));
516 +        }
517          if (pc != cpu->pc())
518                  printf("FATAL: %s: interrupt clobbers PC\n", where);
519          if (lr != cpu->lr())
# Line 507 | Line 524 | sheepshaver_cpu::interrupt_context::~int
524                  printf("FATAL: %s: interrupt clobbers CR\n", where);
525          if (xer != cpu->get_xer())
526                  printf("FATAL: %s: interrupt clobbers XER\n", where);
527 +        if (fpscr != cpu->fpscr())
528 +                printf("FATAL: %s: interrupt clobbers FPSCR\n", where);
529   #endif
530   }
531  
# Line 812 | Line 831 | sigsegv_return_t sigsegv_handler(sigsegv
831          const uintptr addr = (uintptr)fault_address;
832   #if HAVE_SIGSEGV_SKIP_INSTRUCTION
833          // Ignore writes to ROM
834 <        if ((addr - ROM_BASE) < ROM_SIZE)
834 >        if ((addr - (uintptr)ROMBaseHost) < ROM_SIZE)
835                  return SIGSEGV_RETURN_SKIP_INSTRUCTION;
836  
837          // Get program counter of target CPU
# Line 872 | Line 891 | sigsegv_return_t sigsegv_handler(sigsegv
891  
892   void init_emul_ppc(void)
893   {
894 +        // Get pointer to KernelData in host address space
895 +        kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE);
896 +
897          // Initialize main CPU emulator
898          ppc_cpu = new sheepshaver_cpu();
899          ppc_cpu->set_register(powerpc_registers::GPR(3), any_register((uint32)ROM_BASE + 0x30d000));
# Line 1042 | Line 1064 | void sheepshaver_cpu::handle_interrupt(v
1064                          M68kRegisters r;
1065                          uint32 old_r25 = ReadMacInt32(XLM_68K_R25);     // Save interrupt level
1066                          WriteMacInt32(XLM_68K_R25, 0x21);                       // Execute with interrupt level 1
1067 <                        static const uint8 proc[] = {
1067 >                        static const uint8 proc_template[] = {
1068                                  0x3f, 0x3c, 0x00, 0x00,                 // move.w       #$0000,-(sp)    (fake format word)
1069                                  0x48, 0x7a, 0x00, 0x0a,                 // pea          @1(pc)                  (return address)
1070                                  0x40, 0xe7,                                             // move         sr,-(sp)                (saved SR)
# Line 1050 | Line 1072 | void sheepshaver_cpu::handle_interrupt(v
1072                                  0x4e, 0xd0,                                             // jmp          (a0)
1073                                  M68K_RTS >> 8, M68K_RTS & 0xff  // @1
1074                          };
1075 <                        Execute68k((uint32)proc, &r);
1075 >                        BUILD_SHEEPSHAVER_PROCEDURE(proc);
1076 >                        Execute68k(proc, &r);
1077                          WriteMacInt32(XLM_68K_R25, old_r25);            // Restore interrupt level
1078   #else
1079                          // Only update cursor
# Line 1099 | Line 1122 | void sheepshaver_cpu::execute_native_op(
1122                  VideoVBL();
1123                  break;
1124          case NATIVE_VIDEO_DO_DRIVER_IO:
1125 <                gpr(3) = (int32)(int16)VideoDoDriverIO((void *)gpr(3), (void *)gpr(4),
1103 <                                                                                           (void *)gpr(5), gpr(6), gpr(7));
1125 >                gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7));
1126                  break;
1105 – #ifdef WORDS_BIGENDIAN
1127          case NATIVE_ETHER_IRQ:
1128                  EtherIRQ();
1129                  break;
# Line 1124 | Line 1145 | void sheepshaver_cpu::execute_native_op(
1145          case NATIVE_ETHER_RSRV:
1146                  gpr(3) = ether_rsrv((queue_t *)gpr(3));
1147                  break;
1127 – #else
1128 –        case NATIVE_ETHER_INIT:
1129 –                // FIXME: needs more complicated thunks
1130 –                gpr(3) = false;
1131 –                break;
1132 – #endif
1148          case NATIVE_SYNC_HOOK:
1149                  gpr(3) = NQD_sync_hook(gpr(3));
1150                  break;
# Line 1185 | Line 1200 | void sheepshaver_cpu::execute_native_op(
1200                  break;
1201          }
1202          case NATIVE_MAKE_EXECUTABLE:
1203 <                MakeExecutable(0, (void *)gpr(4), gpr(5));
1203 >                MakeExecutable(0, gpr(4), gpr(5));
1204                  break;
1205          case NATIVE_CHECK_LOAD_INVOC:
1206                  check_load_invoc(gpr(3), gpr(4), gpr(5));

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines