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.65 by gbeauche, 2005-07-03T22:02:01Z vs.
Revision 1.71 by gbeauche, 2006-07-09T12:15:48Z

# 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 177 | Line 178 | public:
178  
179          // Make sure the SIGSEGV handler can access CPU registers
180          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);
181   };
182  
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 –
183   sheepshaver_cpu::sheepshaver_cpu()
184          : powerpc_cpu(enable_jit_p())
185   {
# Line 377 | Line 336 | int sheepshaver_cpu::compile1(codegen_co
336                          status = COMPILE_CODE_OK;
337                          break;
338                  }
339 + #endif
340                  case NATIVE_CHECK_LOAD_INVOC:
341                          dg.gen_load_T0_GPR(3);
342                          dg.gen_load_T1_GPR(4);
# Line 385 | Line 345 | int sheepshaver_cpu::compile1(codegen_co
345                          dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))check_load_invoc);
346                          status = COMPILE_CODE_OK;
347                          break;
348 < #endif
349 <                case NATIVE_BITBLT:
348 >                case NATIVE_NAMED_CHECK_LOAD_INVOC:
349 >                        dg.gen_load_T0_GPR(3);
350 >                        dg.gen_load_T1_GPR(4);
351 >                        dg.gen_load_T2_GPR(5);
352 >                        dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))named_check_load_invoc);
353 >                        status = COMPILE_CODE_OK;
354 >                        break;
355 >                case NATIVE_NQD_SYNC_HOOK:
356 >                        dg.gen_load_T0_GPR(3);
357 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_sync_hook);
358 >                        dg.gen_store_T0_GPR(3);
359 >                        status = COMPILE_CODE_OK;
360 >                        break;
361 >                case NATIVE_NQD_BITBLT_HOOK:
362 >                        dg.gen_load_T0_GPR(3);
363 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_bitblt_hook);
364 >                        dg.gen_store_T0_GPR(3);
365 >                        status = COMPILE_CODE_OK;
366 >                        break;
367 >                case NATIVE_NQD_FILLRECT_HOOK:
368 >                        dg.gen_load_T0_GPR(3);
369 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_fillrect_hook);
370 >                        dg.gen_store_T0_GPR(3);
371 >                        status = COMPILE_CODE_OK;
372 >                        break;
373 >                case NATIVE_NQD_UNKNOWN_HOOK:
374 >                        dg.gen_load_T0_GPR(3);
375 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_unknown_hook);
376 >                        dg.gen_store_T0_GPR(3);
377 >                        status = COMPILE_CODE_OK;
378 >                        break;
379 >                case NATIVE_NQD_BITBLT:
380                          dg.gen_load_T0_GPR(3);
381                          dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt);
382                          status = COMPILE_CODE_OK;
383                          break;
384 <                case NATIVE_INVRECT:
384 >                case NATIVE_NQD_INVRECT:
385                          dg.gen_load_T0_GPR(3);
386                          dg.gen_invoke_T0((void (*)(uint32))NQD_invrect);
387                          status = COMPILE_CODE_OK;
388                          break;
389 <                case NATIVE_FILLRECT:
389 >                case NATIVE_NQD_FILLRECT:
390                          dg.gen_load_T0_GPR(3);
391                          dg.gen_invoke_T0((void (*)(uint32))NQD_fillrect);
392                          status = COMPILE_CODE_OK;
# Line 407 | Line 397 | int sheepshaver_cpu::compile1(codegen_co
397                          if (!FN_field::test(opcode))
398                                  cg_context.done_compile = false;
399                          else {
400 <                                dg.gen_load_A0_LR();
401 <                                dg.gen_set_PC_A0();
400 >                                dg.gen_load_T0_LR_aligned();
401 >                                dg.gen_set_PC_T0();
402                                  cg_context.done_compile = true;
403                          }
404                          break;
# Line 418 | Line 408 | int sheepshaver_cpu::compile1(codegen_co
408                  if (!FN_field::test(opcode))
409                          dg.gen_set_PC_im(cg_context.pc + 4);
410                  else {
411 <                        dg.gen_load_A0_LR();
412 <                        dg.gen_set_PC_A0();
411 >                        dg.gen_load_T0_LR_aligned();
412 >                        dg.gen_set_PC_T0();
413                  }
414                  dg.gen_mov_32_T0_im(selector);
415                  dg.gen_jmp(native_op_trampoline);
# Line 868 | Line 858 | void exit_emul_ppc(void)
858   #endif
859  
860          delete ppc_cpu;
861 +        ppc_cpu = NULL;
862   }
863  
864   #if PPC_ENABLE_JIT && PPC_REENTRANT_JIT
# Line 1012 | Line 1003 | void HandleInterrupt(powerpc_registers *
1003          }
1004   }
1005  
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 –
1006   // Execute NATIVE_OP routine
1007   void sheepshaver_cpu::execute_native_op(uint32 selector)
1008   {
# Line 1072 | Line 1057 | void sheepshaver_cpu::execute_native_op(
1057          case NATIVE_ETHER_RSRV:
1058                  gpr(3) = ether_rsrv((queue_t *)gpr(3));
1059                  break;
1060 <        case NATIVE_SYNC_HOOK:
1060 >        case NATIVE_NQD_SYNC_HOOK:
1061                  gpr(3) = NQD_sync_hook(gpr(3));
1062                  break;
1063 <        case NATIVE_BITBLT_HOOK:
1063 >        case NATIVE_NQD_UNKNOWN_HOOK:
1064 >                gpr(3) = NQD_unknown_hook(gpr(3));
1065 >                break;
1066 >        case NATIVE_NQD_BITBLT_HOOK:
1067                  gpr(3) = NQD_bitblt_hook(gpr(3));
1068                  break;
1069 <        case NATIVE_BITBLT:
1069 >        case NATIVE_NQD_BITBLT:
1070                  NQD_bitblt(gpr(3));
1071                  break;
1072 <        case NATIVE_FILLRECT_HOOK:
1072 >        case NATIVE_NQD_FILLRECT_HOOK:
1073                  gpr(3) = NQD_fillrect_hook(gpr(3));
1074                  break;
1075 <        case NATIVE_INVRECT:
1075 >        case NATIVE_NQD_INVRECT:
1076                  NQD_invrect(gpr(3));
1077                  break;
1078 <        case NATIVE_FILLRECT:
1078 >        case NATIVE_NQD_FILLRECT:
1079                  NQD_fillrect(gpr(3));
1080                  break;
1081          case NATIVE_SERIAL_NOTHING:
# Line 1111 | Line 1099 | void sheepshaver_cpu::execute_native_op(
1099                  break;
1100          }
1101          case NATIVE_GET_RESOURCE:
1102 +                get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1103 +                break;
1104          case NATIVE_GET_1_RESOURCE:
1105 +                get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1106 +                break;
1107          case NATIVE_GET_IND_RESOURCE:
1108 +                get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1109 +                break;
1110          case NATIVE_GET_1_IND_RESOURCE:
1111 <        case NATIVE_R_GET_RESOURCE: {
1112 <                typedef void (*GetResourceCallback)(void);
1113 <                static const GetResourceCallback get_resource_callbacks[] = {
1114 <                        ::get_resource,
1121 <                        ::get_1_resource,
1122 <                        ::get_ind_resource,
1123 <                        ::get_1_ind_resource,
1124 <                        ::r_get_resource
1125 <                };
1126 <                get_resource_callbacks[selector - NATIVE_GET_RESOURCE]();
1111 >                get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1112 >                break;
1113 >        case NATIVE_R_GET_RESOURCE:
1114 >                get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1115                  break;
1128 –        }
1116          case NATIVE_MAKE_EXECUTABLE:
1117                  MakeExecutable(0, gpr(4), gpr(5));
1118                  break;
1119          case NATIVE_CHECK_LOAD_INVOC:
1120                  check_load_invoc(gpr(3), gpr(4), gpr(5));
1121                  break;
1122 +        case NATIVE_NAMED_CHECK_LOAD_INVOC:
1123 +                named_check_load_invoc(gpr(3), gpr(4), gpr(5));
1124 +                break;
1125          default:
1126                  printf("FATAL: NATIVE_OP called with bogus selector %d\n", selector);
1127                  QuitEmulator();
# Line 1218 | Line 1208 | uint32 call_macos7(uint32 tvect, uint32
1208          const uint32 args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
1209          return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args);
1210   }
1221 –
1222 – /*
1223 – *  Resource Manager thunks
1224 – */
1225 –
1226 – void get_resource(void)
1227 – {
1228 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1229 – }
1230 –
1231 – void get_1_resource(void)
1232 – {
1233 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1234 – }
1235 –
1236 – void get_ind_resource(void)
1237 – {
1238 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1239 – }
1240 –
1241 – void get_1_ind_resource(void)
1242 – {
1243 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1244 – }
1245 –
1246 – void r_get_resource(void)
1247 – {
1248 –        ppc_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1249 – }

Diff Legend

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