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.67 by gbeauche, 2006-01-21T17:18:53Z 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 335 | 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 343 | 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 365 | 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 376 | 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 971 | Line 1003 | void HandleInterrupt(powerpc_registers *
1003          }
1004   }
1005  
974 – static void get_resource(void);
975 – static void get_1_resource(void);
976 – static void get_ind_resource(void);
977 – static void get_1_ind_resource(void);
978 – static void r_get_resource(void);
979 –
1006   // Execute NATIVE_OP routine
1007   void sheepshaver_cpu::execute_native_op(uint32 selector)
1008   {
# Line 1031 | 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 1070 | 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,
1080 <                        ::get_1_resource,
1081 <                        ::get_ind_resource,
1082 <                        ::get_1_ind_resource,
1083 <                        ::r_get_resource
1084 <                };
1085 <                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;
1087 –        }
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 1177 | 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   }
1180 –
1181 – /*
1182 – *  Resource Manager thunks
1183 – */
1184 –
1185 – void get_resource(void)
1186 – {
1187 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1188 – }
1189 –
1190 – void get_1_resource(void)
1191 – {
1192 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1193 – }
1194 –
1195 – void get_ind_resource(void)
1196 – {
1197 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1198 – }
1199 –
1200 – void get_1_ind_resource(void)
1201 – {
1202 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1203 – }
1204 –
1205 – void r_get_resource(void)
1206 – {
1207 –        ppc_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1208 – }

Diff Legend

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