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.62 by gbeauche, 2005-06-30T07:34:17Z vs.
Revision 1.72 by gbeauche, 2007-01-17T06:20:36Z

# 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 232 | Line 191 | void sheepshaver_cpu::init_decoder()
191          static const instr_info_t sheep_ii_table[] = {
192                  { "sheep",
193                    (execute_pmf)&sheepshaver_cpu::execute_sheep,
235 –                  NULL,
194                    PPC_I(SHEEP),
195                    D_form, 6, 0, CFLOW_JUMP | CFLOW_TRAP
196                  }
# Line 377 | Line 335 | int sheepshaver_cpu::compile1(codegen_co
335                          status = COMPILE_CODE_OK;
336                          break;
337                  }
338 + #endif
339                  case NATIVE_CHECK_LOAD_INVOC:
340                          dg.gen_load_T0_GPR(3);
341                          dg.gen_load_T1_GPR(4);
# Line 385 | Line 344 | int sheepshaver_cpu::compile1(codegen_co
344                          dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))check_load_invoc);
345                          status = COMPILE_CODE_OK;
346                          break;
347 < #endif
348 <                case NATIVE_BITBLT:
347 >                case NATIVE_NAMED_CHECK_LOAD_INVOC:
348 >                        dg.gen_load_T0_GPR(3);
349 >                        dg.gen_load_T1_GPR(4);
350 >                        dg.gen_load_T2_GPR(5);
351 >                        dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))named_check_load_invoc);
352 >                        status = COMPILE_CODE_OK;
353 >                        break;
354 >                case NATIVE_NQD_SYNC_HOOK:
355 >                        dg.gen_load_T0_GPR(3);
356 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_sync_hook);
357 >                        dg.gen_store_T0_GPR(3);
358 >                        status = COMPILE_CODE_OK;
359 >                        break;
360 >                case NATIVE_NQD_BITBLT_HOOK:
361 >                        dg.gen_load_T0_GPR(3);
362 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_bitblt_hook);
363 >                        dg.gen_store_T0_GPR(3);
364 >                        status = COMPILE_CODE_OK;
365 >                        break;
366 >                case NATIVE_NQD_FILLRECT_HOOK:
367 >                        dg.gen_load_T0_GPR(3);
368 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_fillrect_hook);
369 >                        dg.gen_store_T0_GPR(3);
370 >                        status = COMPILE_CODE_OK;
371 >                        break;
372 >                case NATIVE_NQD_UNKNOWN_HOOK:
373 >                        dg.gen_load_T0_GPR(3);
374 >                        dg.gen_invoke_T0_ret_T0((uint32 (*)(uint32))NQD_unknown_hook);
375 >                        dg.gen_store_T0_GPR(3);
376 >                        status = COMPILE_CODE_OK;
377 >                        break;
378 >                case NATIVE_NQD_BITBLT:
379                          dg.gen_load_T0_GPR(3);
380                          dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt);
381                          status = COMPILE_CODE_OK;
382                          break;
383 <                case NATIVE_INVRECT:
383 >                case NATIVE_NQD_INVRECT:
384                          dg.gen_load_T0_GPR(3);
385                          dg.gen_invoke_T0((void (*)(uint32))NQD_invrect);
386                          status = COMPILE_CODE_OK;
387                          break;
388 <                case NATIVE_FILLRECT:
388 >                case NATIVE_NQD_FILLRECT:
389                          dg.gen_load_T0_GPR(3);
390                          dg.gen_invoke_T0((void (*)(uint32))NQD_fillrect);
391                          status = COMPILE_CODE_OK;
# Line 407 | Line 396 | int sheepshaver_cpu::compile1(codegen_co
396                          if (!FN_field::test(opcode))
397                                  cg_context.done_compile = false;
398                          else {
399 <                                dg.gen_load_A0_LR();
400 <                                dg.gen_set_PC_A0();
399 >                                dg.gen_load_T0_LR_aligned();
400 >                                dg.gen_set_PC_T0();
401                                  cg_context.done_compile = true;
402                          }
403                          break;
# Line 418 | Line 407 | int sheepshaver_cpu::compile1(codegen_co
407                  if (!FN_field::test(opcode))
408                          dg.gen_set_PC_im(cg_context.pc + 4);
409                  else {
410 <                        dg.gen_load_A0_LR();
411 <                        dg.gen_set_PC_A0();
410 >                        dg.gen_load_T0_LR_aligned();
411 >                        dg.gen_set_PC_T0();
412                  }
413                  dg.gen_mov_32_T0_im(selector);
414                  dg.gen_jmp(native_op_trampoline);
# Line 868 | Line 857 | void exit_emul_ppc(void)
857   #endif
858  
859          delete ppc_cpu;
860 +        ppc_cpu = NULL;
861   }
862  
863   #if PPC_ENABLE_JIT && PPC_REENTRANT_JIT
# Line 915 | Line 905 | void emul_ppc(uint32 entry)
905  
906   void TriggerInterrupt(void)
907   {
908 +        idle_resume();
909   #if 0
910    WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1);
911   #else
# Line 935 | Line 926 | void HandleInterrupt(powerpc_registers *
926          if (int32(ReadMacInt32(XLM_IRQ_NEST)) > 0)
927                  return;
928  
929 <        // Do nothing if there is no pending interrupt
939 <        if (InterruptFlags == 0)
940 <                return;
941 <
942 <        // Current interrupt nest level
943 <        static int interrupt_depth = 0;
944 <        ++interrupt_depth;
929 >        // Update interrupt count
930   #if EMUL_TIME_STATS
931          interrupt_count++;
932   #endif
# Line 957 | Line 942 | void HandleInterrupt(powerpc_registers *
942   #if INTERRUPTS_IN_NATIVE_MODE
943          case MODE_NATIVE:
944                  // 68k emulator inactive, in nanokernel?
945 <                if (r->gpr[1] != KernelDataAddr && interrupt_depth == 1) {
945 >                if (r->gpr[1] != KernelDataAddr) {
946  
947                          // Prepare for 68k interrupt level 1
948                          WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1);
# Line 1015 | Line 1000 | void HandleInterrupt(powerpc_registers *
1000                  break;
1001   #endif
1002          }
1018 –
1019 –        // We are done with this interrupt
1020 –        --interrupt_depth;
1003   }
1004  
1023 – static void get_resource(void);
1024 – static void get_1_resource(void);
1025 – static void get_ind_resource(void);
1026 – static void get_1_ind_resource(void);
1027 – static void r_get_resource(void);
1028 –
1005   // Execute NATIVE_OP routine
1006   void sheepshaver_cpu::execute_native_op(uint32 selector)
1007   {
# Line 1047 | Line 1023 | void sheepshaver_cpu::execute_native_op(
1023          case NATIVE_VIDEO_DO_DRIVER_IO:
1024                  gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7));
1025                  break;
1026 +        case NATIVE_ETHER_AO_GET_HWADDR:
1027 +                AO_get_ethernet_address(gpr(3));
1028 +                break;
1029 +        case NATIVE_ETHER_AO_ADD_MULTI:
1030 +                AO_enable_multicast(gpr(3));
1031 +                break;
1032 +        case NATIVE_ETHER_AO_DEL_MULTI:
1033 +                AO_disable_multicast(gpr(3));
1034 +                break;
1035 +        case NATIVE_ETHER_AO_SEND_PACKET:
1036 +                AO_transmit_packet(gpr(3));
1037 +                break;
1038          case NATIVE_ETHER_IRQ:
1039                  EtherIRQ();
1040                  break;
# Line 1068 | Line 1056 | void sheepshaver_cpu::execute_native_op(
1056          case NATIVE_ETHER_RSRV:
1057                  gpr(3) = ether_rsrv((queue_t *)gpr(3));
1058                  break;
1059 <        case NATIVE_SYNC_HOOK:
1059 >        case NATIVE_NQD_SYNC_HOOK:
1060                  gpr(3) = NQD_sync_hook(gpr(3));
1061                  break;
1062 <        case NATIVE_BITBLT_HOOK:
1062 >        case NATIVE_NQD_UNKNOWN_HOOK:
1063 >                gpr(3) = NQD_unknown_hook(gpr(3));
1064 >                break;
1065 >        case NATIVE_NQD_BITBLT_HOOK:
1066                  gpr(3) = NQD_bitblt_hook(gpr(3));
1067                  break;
1068 <        case NATIVE_BITBLT:
1068 >        case NATIVE_NQD_BITBLT:
1069                  NQD_bitblt(gpr(3));
1070                  break;
1071 <        case NATIVE_FILLRECT_HOOK:
1071 >        case NATIVE_NQD_FILLRECT_HOOK:
1072                  gpr(3) = NQD_fillrect_hook(gpr(3));
1073                  break;
1074 <        case NATIVE_INVRECT:
1074 >        case NATIVE_NQD_INVRECT:
1075                  NQD_invrect(gpr(3));
1076                  break;
1077 <        case NATIVE_FILLRECT:
1077 >        case NATIVE_NQD_FILLRECT:
1078                  NQD_fillrect(gpr(3));
1079                  break;
1080          case NATIVE_SERIAL_NOTHING:
# Line 1107 | Line 1098 | void sheepshaver_cpu::execute_native_op(
1098                  break;
1099          }
1100          case NATIVE_GET_RESOURCE:
1101 +                get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1102 +                break;
1103          case NATIVE_GET_1_RESOURCE:
1104 +                get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1105 +                break;
1106          case NATIVE_GET_IND_RESOURCE:
1107 +                get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1108 +                break;
1109          case NATIVE_GET_1_IND_RESOURCE:
1110 <        case NATIVE_R_GET_RESOURCE: {
1111 <                typedef void (*GetResourceCallback)(void);
1112 <                static const GetResourceCallback get_resource_callbacks[] = {
1113 <                        ::get_resource,
1117 <                        ::get_1_resource,
1118 <                        ::get_ind_resource,
1119 <                        ::get_1_ind_resource,
1120 <                        ::r_get_resource
1121 <                };
1122 <                get_resource_callbacks[selector - NATIVE_GET_RESOURCE]();
1110 >                get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1111 >                break;
1112 >        case NATIVE_R_GET_RESOURCE:
1113 >                get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1114                  break;
1124 –        }
1115          case NATIVE_MAKE_EXECUTABLE:
1116                  MakeExecutable(0, gpr(4), gpr(5));
1117                  break;
1118          case NATIVE_CHECK_LOAD_INVOC:
1119                  check_load_invoc(gpr(3), gpr(4), gpr(5));
1120                  break;
1121 +        case NATIVE_NAMED_CHECK_LOAD_INVOC:
1122 +                named_check_load_invoc(gpr(3), gpr(4), gpr(5));
1123 +                break;
1124          default:
1125                  printf("FATAL: NATIVE_OP called with bogus selector %d\n", selector);
1126                  QuitEmulator();
# Line 1214 | Line 1207 | uint32 call_macos7(uint32 tvect, uint32
1207          const uint32 args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
1208          return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args);
1209   }
1217 –
1218 – /*
1219 – *  Resource Manager thunks
1220 – */
1221 –
1222 – void get_resource(void)
1223 – {
1224 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1225 – }
1226 –
1227 – void get_1_resource(void)
1228 – {
1229 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1230 – }
1231 –
1232 – void get_ind_resource(void)
1233 – {
1234 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1235 – }
1236 –
1237 – void get_1_ind_resource(void)
1238 – {
1239 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1240 – }
1241 –
1242 – void r_get_resource(void)
1243 – {
1244 –        ppc_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1245 – }

Diff Legend

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