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.64 by gbeauche, 2005-06-30T10:17:58Z vs.
Revision 1.74 by gbeauche, 2007-12-30T09:18:40Z

# Line 89 | Line 89 | extern uintptr SignalStackBase();
89  
90   // From rsrc_patches.cpp
91   extern "C" void check_load_invoc(uint32 type, int16 id, uint32 h);
92 + extern "C" void named_check_load_invoc(uint32 type, uint32 name, uint32 h);
93  
94   // PowerPC EmulOp to exit from emulation looop
95   const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1;
# Line 117 | Line 118 | static uint8 *emul_op_trampoline;
118   static uint8 *native_op_trampoline;
119   #endif
120  
120 – // JIT Compiler enabled?
121 – static inline bool enable_jit_p()
122 – {
123 –        return PrefsFindBool("jit");
124 – }
125 –
121  
122   /**
123   *              PowerPC emulator glue with special 'sheep' opcodes
# Line 176 | Line 171 | public:
171          void interrupt(uint32 entry);
172  
173          // Make sure the SIGSEGV handler can access CPU registers
174 <        friend sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t);
180 <
181 <        // Memory allocator returning areas aligned on 16-byte boundaries
182 <        void *operator new(size_t size);
183 <        void operator delete(void *p);
174 >        friend sigsegv_return_t sigsegv_handler(sigsegv_info_t *sip);
175   };
176  
186 – // Memory allocator returning sheepshaver_cpu objects aligned on 16-byte boundaries
187 – // FORMAT: [ alignment ] magic identifier, offset to malloc'ed data, sheepshaver_cpu data
188 – void *sheepshaver_cpu::operator new(size_t size)
189 – {
190 –        const int ALIGN = 16;
191 –
192 –        // Allocate enough space for sheepshaver_cpu data + signature + align pad
193 –        uint8 *ptr = (uint8 *)malloc(size + ALIGN * 2);
194 –        if (ptr == NULL)
195 –                throw std::bad_alloc();
196 –
197 –        // Align memory
198 –        int ofs = 0;
199 –        while ((((uintptr)ptr) % ALIGN) != 0)
200 –                ofs++, ptr++;
201 –
202 –        // Insert signature and offset
203 –        struct aligned_block_t {
204 –                uint32 pad[(ALIGN - 8) / 4];
205 –                uint32 signature;
206 –                uint32 offset;
207 –                uint8  data[sizeof(sheepshaver_cpu)];
208 –        };
209 –        aligned_block_t *blk = (aligned_block_t *)ptr;
210 –        blk->signature = FOURCC('S','C','P','U');
211 –        blk->offset = ofs + (&blk->data[0] - (uint8 *)blk);
212 –        assert((((uintptr)&blk->data) % ALIGN) == 0);
213 –        return &blk->data[0];
214 – }
215 –
216 – void sheepshaver_cpu::operator delete(void *p)
217 – {
218 –        uint32 *blk = (uint32 *)p;
219 –        assert(blk[-2] == FOURCC('S','C','P','U'));
220 –        void *ptr = (void *)(((uintptr)p) - blk[-1]);
221 –        free(ptr);
222 – }
223 –
177   sheepshaver_cpu::sheepshaver_cpu()
225 –        : powerpc_cpu(enable_jit_p())
178   {
179          init_decoder();
180 +
181 + #if PPC_ENABLE_JIT
182 +        if (PrefsFindBool("jit"))
183 +                enable_jit();
184 + #endif
185   }
186  
187   void sheepshaver_cpu::init_decoder()
# Line 232 | Line 189 | void sheepshaver_cpu::init_decoder()
189          static const instr_info_t sheep_ii_table[] = {
190                  { "sheep",
191                    (execute_pmf)&sheepshaver_cpu::execute_sheep,
235 –                  NULL,
192                    PPC_I(SHEEP),
193                    D_form, 6, 0, CFLOW_JUMP | CFLOW_TRAP
194                  }
# Line 377 | Line 333 | int sheepshaver_cpu::compile1(codegen_co
333                          status = COMPILE_CODE_OK;
334                          break;
335                  }
336 + #endif
337                  case NATIVE_CHECK_LOAD_INVOC:
338                          dg.gen_load_T0_GPR(3);
339                          dg.gen_load_T1_GPR(4);
# Line 385 | Line 342 | int sheepshaver_cpu::compile1(codegen_co
342                          dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))check_load_invoc);
343                          status = COMPILE_CODE_OK;
344                          break;
345 < #endif
346 <                case NATIVE_BITBLT:
345 >                case NATIVE_NAMED_CHECK_LOAD_INVOC:
346 >                        dg.gen_load_T0_GPR(3);
347 >                        dg.gen_load_T1_GPR(4);
348 >                        dg.gen_load_T2_GPR(5);
349 >                        dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))named_check_load_invoc);
350 >                        status = COMPILE_CODE_OK;
351 >                        break;
352 >                case NATIVE_NQD_SYNC_HOOK:
353 >                        dg.gen_load_T0_GPR(3);
354 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_sync_hook);
355 >                        dg.gen_store_T0_GPR(3);
356 >                        status = COMPILE_CODE_OK;
357 >                        break;
358 >                case NATIVE_NQD_BITBLT_HOOK:
359 >                        dg.gen_load_T0_GPR(3);
360 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_bitblt_hook);
361 >                        dg.gen_store_T0_GPR(3);
362 >                        status = COMPILE_CODE_OK;
363 >                        break;
364 >                case NATIVE_NQD_FILLRECT_HOOK:
365 >                        dg.gen_load_T0_GPR(3);
366 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_fillrect_hook);
367 >                        dg.gen_store_T0_GPR(3);
368 >                        status = COMPILE_CODE_OK;
369 >                        break;
370 >                case NATIVE_NQD_UNKNOWN_HOOK:
371 >                        dg.gen_load_T0_GPR(3);
372 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_unknown_hook);
373 >                        dg.gen_store_T0_GPR(3);
374 >                        status = COMPILE_CODE_OK;
375 >                        break;
376 >                case NATIVE_NQD_BITBLT:
377                          dg.gen_load_T0_GPR(3);
378                          dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt);
379                          status = COMPILE_CODE_OK;
380                          break;
381 <                case NATIVE_INVRECT:
381 >                case NATIVE_NQD_INVRECT:
382                          dg.gen_load_T0_GPR(3);
383                          dg.gen_invoke_T0((void (*)(uint32))NQD_invrect);
384                          status = COMPILE_CODE_OK;
385                          break;
386 <                case NATIVE_FILLRECT:
386 >                case NATIVE_NQD_FILLRECT:
387                          dg.gen_load_T0_GPR(3);
388                          dg.gen_invoke_T0((void (*)(uint32))NQD_fillrect);
389                          status = COMPILE_CODE_OK;
# Line 407 | Line 394 | int sheepshaver_cpu::compile1(codegen_co
394                          if (!FN_field::test(opcode))
395                                  cg_context.done_compile = false;
396                          else {
397 <                                dg.gen_load_A0_LR();
398 <                                dg.gen_set_PC_A0();
397 >                                dg.gen_load_T0_LR_aligned();
398 >                                dg.gen_set_PC_T0();
399                                  cg_context.done_compile = true;
400                          }
401                          break;
# Line 418 | Line 405 | int sheepshaver_cpu::compile1(codegen_co
405                  if (!FN_field::test(opcode))
406                          dg.gen_set_PC_im(cg_context.pc + 4);
407                  else {
408 <                        dg.gen_load_A0_LR();
409 <                        dg.gen_set_PC_A0();
408 >                        dg.gen_load_T0_LR_aligned();
409 >                        dg.gen_set_PC_T0();
410                  }
411                  dg.gen_mov_32_T0_im(selector);
412                  dg.gen_jmp(native_op_trampoline);
# Line 743 | Line 730 | static void dump_log(void)
730   *  Initialize CPU emulation
731   */
732  
733 < sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction)
733 > sigsegv_return_t sigsegv_handler(sigsegv_info_t *sip)
734   {
735   #if ENABLE_VOSF
736          // Handle screen fault
737 <        extern bool Screen_fault_handler(sigsegv_address_t, sigsegv_address_t);
738 <        if (Screen_fault_handler(fault_address, fault_instruction))
737 >        extern bool Screen_fault_handler(sigsegv_info_t *sip);
738 >        if (Screen_fault_handler(sip))
739                  return SIGSEGV_RETURN_SUCCESS;
740   #endif
741  
742 <        const uintptr addr = (uintptr)fault_address;
742 >        const uintptr addr = (uintptr)sigsegv_get_fault_address(sip);
743   #if HAVE_SIGSEGV_SKIP_INSTRUCTION
744          // Ignore writes to ROM
745          if ((addr - (uintptr)ROMBaseHost) < ROM_SIZE)
# Line 803 | Line 790 | sigsegv_return_t sigsegv_handler(sigsegv
790   #endif
791  
792          fprintf(stderr, "SIGSEGV\n");
793 <        fprintf(stderr, "  pc %p\n", fault_instruction);
794 <        fprintf(stderr, "  ea %p\n", fault_address);
793 >        fprintf(stderr, "  pc %p\n", sigsegv_get_fault_instruction_address(sip));
794 >        fprintf(stderr, "  ea %p\n", sigsegv_get_fault_address(sip));
795          dump_registers();
796          ppc_cpu->dump_log();
797          enter_mon();
# Line 868 | Line 855 | void exit_emul_ppc(void)
855   #endif
856  
857          delete ppc_cpu;
858 +        ppc_cpu = NULL;
859   }
860  
861   #if PPC_ENABLE_JIT && PPC_REENTRANT_JIT
# Line 1012 | Line 1000 | void HandleInterrupt(powerpc_registers *
1000          }
1001   }
1002  
1015 – static void get_resource(void);
1016 – static void get_1_resource(void);
1017 – static void get_ind_resource(void);
1018 – static void get_1_ind_resource(void);
1019 – static void r_get_resource(void);
1020 –
1003   // Execute NATIVE_OP routine
1004   void sheepshaver_cpu::execute_native_op(uint32 selector)
1005   {
# Line 1039 | Line 1021 | void sheepshaver_cpu::execute_native_op(
1021          case NATIVE_VIDEO_DO_DRIVER_IO:
1022                  gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7));
1023                  break;
1024 +        case NATIVE_ETHER_AO_GET_HWADDR:
1025 +                AO_get_ethernet_address(gpr(3));
1026 +                break;
1027 +        case NATIVE_ETHER_AO_ADD_MULTI:
1028 +                AO_enable_multicast(gpr(3));
1029 +                break;
1030 +        case NATIVE_ETHER_AO_DEL_MULTI:
1031 +                AO_disable_multicast(gpr(3));
1032 +                break;
1033 +        case NATIVE_ETHER_AO_SEND_PACKET:
1034 +                AO_transmit_packet(gpr(3));
1035 +                break;
1036          case NATIVE_ETHER_IRQ:
1037                  EtherIRQ();
1038                  break;
# Line 1060 | Line 1054 | void sheepshaver_cpu::execute_native_op(
1054          case NATIVE_ETHER_RSRV:
1055                  gpr(3) = ether_rsrv((queue_t *)gpr(3));
1056                  break;
1057 <        case NATIVE_SYNC_HOOK:
1057 >        case NATIVE_NQD_SYNC_HOOK:
1058                  gpr(3) = NQD_sync_hook(gpr(3));
1059                  break;
1060 <        case NATIVE_BITBLT_HOOK:
1060 >        case NATIVE_NQD_UNKNOWN_HOOK:
1061 >                gpr(3) = NQD_unknown_hook(gpr(3));
1062 >                break;
1063 >        case NATIVE_NQD_BITBLT_HOOK:
1064                  gpr(3) = NQD_bitblt_hook(gpr(3));
1065                  break;
1066 <        case NATIVE_BITBLT:
1066 >        case NATIVE_NQD_BITBLT:
1067                  NQD_bitblt(gpr(3));
1068                  break;
1069 <        case NATIVE_FILLRECT_HOOK:
1069 >        case NATIVE_NQD_FILLRECT_HOOK:
1070                  gpr(3) = NQD_fillrect_hook(gpr(3));
1071                  break;
1072 <        case NATIVE_INVRECT:
1072 >        case NATIVE_NQD_INVRECT:
1073                  NQD_invrect(gpr(3));
1074                  break;
1075 <        case NATIVE_FILLRECT:
1075 >        case NATIVE_NQD_FILLRECT:
1076                  NQD_fillrect(gpr(3));
1077                  break;
1078          case NATIVE_SERIAL_NOTHING:
# Line 1099 | Line 1096 | void sheepshaver_cpu::execute_native_op(
1096                  break;
1097          }
1098          case NATIVE_GET_RESOURCE:
1099 +                get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1100 +                break;
1101          case NATIVE_GET_1_RESOURCE:
1102 +                get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1103 +                break;
1104          case NATIVE_GET_IND_RESOURCE:
1105 +                get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1106 +                break;
1107          case NATIVE_GET_1_IND_RESOURCE:
1108 <        case NATIVE_R_GET_RESOURCE: {
1109 <                typedef void (*GetResourceCallback)(void);
1110 <                static const GetResourceCallback get_resource_callbacks[] = {
1111 <                        ::get_resource,
1109 <                        ::get_1_resource,
1110 <                        ::get_ind_resource,
1111 <                        ::get_1_ind_resource,
1112 <                        ::r_get_resource
1113 <                };
1114 <                get_resource_callbacks[selector - NATIVE_GET_RESOURCE]();
1108 >                get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1109 >                break;
1110 >        case NATIVE_R_GET_RESOURCE:
1111 >                get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1112                  break;
1116 –        }
1113          case NATIVE_MAKE_EXECUTABLE:
1114                  MakeExecutable(0, gpr(4), gpr(5));
1115                  break;
1116          case NATIVE_CHECK_LOAD_INVOC:
1117                  check_load_invoc(gpr(3), gpr(4), gpr(5));
1118                  break;
1119 +        case NATIVE_NAMED_CHECK_LOAD_INVOC:
1120 +                named_check_load_invoc(gpr(3), gpr(4), gpr(5));
1121 +                break;
1122          default:
1123                  printf("FATAL: NATIVE_OP called with bogus selector %d\n", selector);
1124                  QuitEmulator();
# Line 1206 | Line 1205 | uint32 call_macos7(uint32 tvect, uint32
1205          const uint32 args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
1206          return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args);
1207   }
1209 –
1210 – /*
1211 – *  Resource Manager thunks
1212 – */
1213 –
1214 – void get_resource(void)
1215 – {
1216 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1217 – }
1218 –
1219 – void get_1_resource(void)
1220 – {
1221 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1222 – }
1223 –
1224 – void get_ind_resource(void)
1225 – {
1226 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1227 – }
1228 –
1229 – void get_1_ind_resource(void)
1230 – {
1231 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1232 – }
1233 –
1234 – void r_get_resource(void)
1235 – {
1236 –        ppc_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1237 – }

Diff Legend

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