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.59 by gbeauche, 2005-03-05T18:33:30Z vs.
Revision 1.69 by gbeauche, 2006-05-13T17:12:18Z

# 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 areas aligned on 16-byte boundaries
187 – void *sheepshaver_cpu::operator new(size_t size)
188 – {
189 –        void *p;
190 –
191 – #if defined(HAVE_POSIX_MEMALIGN)
192 –        if (posix_memalign(&p, 16, size) != 0)
193 –                throw std::bad_alloc();
194 – #elif defined(HAVE_MEMALIGN)
195 –        p = memalign(16, size);
196 – #elif defined(HAVE_VALLOC)
197 –        p = valloc(size); // page-aligned!
198 – #else
199 –        /* XXX: handle padding ourselves */
200 –        p = malloc(size);
201 – #endif
202 –
203 –        return p;
204 – }
205 –
206 – void sheepshaver_cpu::operator delete(void *p)
207 – {
208 – #if defined(HAVE_MEMALIGN) || defined(HAVE_VALLOC)
209 – #if defined(__GLIBC__)
210 –        // this is known to work only with GNU libc
211 –        free(p);
212 – #endif
213 – #else
214 –        free(p);
215 – #endif
216 – }
217 –
183   sheepshaver_cpu::sheepshaver_cpu()
184          : powerpc_cpu(enable_jit_p())
185   {
# Line 263 | Line 228 | void sheepshaver_cpu::execute_emul_op(ui
228          for (int i = 0; i < 7; i++)
229                  r68.a[i] = gpr(16 + i);
230          r68.a[7] = gpr(1);
231 <        uint32 saved_cr = get_cr() & CR_field<2>::mask();
231 >        uint32 saved_cr = get_cr() & 0xff9fffff; // mask_operand::compute(11, 8)
232          uint32 saved_xer = get_xer();
233          EmulOp(&r68, gpr(24), emul_op);
234          set_cr(saved_cr);
# Line 379 | 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 +                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   #endif
355 <                case NATIVE_BITBLT:
355 >                case NATIVE_NQD_BITBLT:
356                          dg.gen_load_T0_GPR(3);
357                          dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt);
358                          status = COMPILE_CODE_OK;
359                          break;
360 <                case NATIVE_INVRECT:
360 >                case NATIVE_NQD_INVRECT:
361                          dg.gen_load_T0_GPR(3);
362                          dg.gen_invoke_T0((void (*)(uint32))NQD_invrect);
363                          status = COMPILE_CODE_OK;
364                          break;
365 <                case NATIVE_FILLRECT:
365 >                case NATIVE_NQD_FILLRECT:
366                          dg.gen_load_T0_GPR(3);
367                          dg.gen_invoke_T0((void (*)(uint32))NQD_fillrect);
368                          status = COMPILE_CODE_OK;
# Line 796 | Line 768 | sigsegv_return_t sigsegv_handler(sigsegv
768   #error "FIXME: You don't have the capability to skip instruction within signal handlers"
769   #endif
770  
771 <        printf("SIGSEGV\n");
772 <        printf("  pc %p\n", fault_instruction);
773 <        printf("  ea %p\n", fault_address);
771 >        fprintf(stderr, "SIGSEGV\n");
772 >        fprintf(stderr, "  pc %p\n", fault_instruction);
773 >        fprintf(stderr, "  ea %p\n", fault_address);
774          dump_registers();
775          ppc_cpu->dump_log();
776          enter_mon();
# Line 862 | Line 834 | void exit_emul_ppc(void)
834   #endif
835  
836          delete ppc_cpu;
837 +        ppc_cpu = NULL;
838   }
839  
840   #if PPC_ENABLE_JIT && PPC_REENTRANT_JIT
# Line 909 | Line 882 | void emul_ppc(uint32 entry)
882  
883   void TriggerInterrupt(void)
884   {
885 +        idle_resume();
886   #if 0
887    WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1);
888   #else
# Line 929 | Line 903 | void HandleInterrupt(powerpc_registers *
903          if (int32(ReadMacInt32(XLM_IRQ_NEST)) > 0)
904                  return;
905  
906 <        // Do nothing if there is no pending interrupt
933 <        if (InterruptFlags == 0)
934 <                return;
935 <
936 <        // Current interrupt nest level
937 <        static int interrupt_depth = 0;
938 <        ++interrupt_depth;
906 >        // Update interrupt count
907   #if EMUL_TIME_STATS
908          interrupt_count++;
909   #endif
# Line 951 | Line 919 | void HandleInterrupt(powerpc_registers *
919   #if INTERRUPTS_IN_NATIVE_MODE
920          case MODE_NATIVE:
921                  // 68k emulator inactive, in nanokernel?
922 <                if (r->gpr[1] != KernelDataAddr && interrupt_depth == 1) {
922 >                if (r->gpr[1] != KernelDataAddr) {
923  
924                          // Prepare for 68k interrupt level 1
925                          WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1);
# Line 1009 | Line 977 | void HandleInterrupt(powerpc_registers *
977                  break;
978   #endif
979          }
1012 –
1013 –        // We are done with this interrupt
1014 –        --interrupt_depth;
980   }
981  
1017 – static void get_resource(void);
1018 – static void get_1_resource(void);
1019 – static void get_ind_resource(void);
1020 – static void get_1_ind_resource(void);
1021 – static void r_get_resource(void);
1022 –
982   // Execute NATIVE_OP routine
983   void sheepshaver_cpu::execute_native_op(uint32 selector)
984   {
# Line 1041 | Line 1000 | void sheepshaver_cpu::execute_native_op(
1000          case NATIVE_VIDEO_DO_DRIVER_IO:
1001                  gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7));
1002                  break;
1003 +        case NATIVE_ETHER_AO_GET_HWADDR:
1004 +                AO_get_ethernet_address(gpr(3));
1005 +                break;
1006 +        case NATIVE_ETHER_AO_ADD_MULTI:
1007 +                AO_enable_multicast(gpr(3));
1008 +                break;
1009 +        case NATIVE_ETHER_AO_DEL_MULTI:
1010 +                AO_disable_multicast(gpr(3));
1011 +                break;
1012 +        case NATIVE_ETHER_AO_SEND_PACKET:
1013 +                AO_transmit_packet(gpr(3));
1014 +                break;
1015          case NATIVE_ETHER_IRQ:
1016                  EtherIRQ();
1017                  break;
# Line 1062 | Line 1033 | void sheepshaver_cpu::execute_native_op(
1033          case NATIVE_ETHER_RSRV:
1034                  gpr(3) = ether_rsrv((queue_t *)gpr(3));
1035                  break;
1036 <        case NATIVE_SYNC_HOOK:
1036 >        case NATIVE_NQD_SYNC_HOOK:
1037                  gpr(3) = NQD_sync_hook(gpr(3));
1038                  break;
1039 <        case NATIVE_BITBLT_HOOK:
1039 >        case NATIVE_NQD_BITBLT_HOOK:
1040                  gpr(3) = NQD_bitblt_hook(gpr(3));
1041                  break;
1042 <        case NATIVE_BITBLT:
1042 >        case NATIVE_NQD_BITBLT:
1043                  NQD_bitblt(gpr(3));
1044                  break;
1045 <        case NATIVE_FILLRECT_HOOK:
1045 >        case NATIVE_NQD_FILLRECT_HOOK:
1046                  gpr(3) = NQD_fillrect_hook(gpr(3));
1047                  break;
1048 <        case NATIVE_INVRECT:
1048 >        case NATIVE_NQD_INVRECT:
1049                  NQD_invrect(gpr(3));
1050                  break;
1051 <        case NATIVE_FILLRECT:
1051 >        case NATIVE_NQD_FILLRECT:
1052                  NQD_fillrect(gpr(3));
1053                  break;
1054          case NATIVE_SERIAL_NOTHING:
# Line 1101 | Line 1072 | void sheepshaver_cpu::execute_native_op(
1072                  break;
1073          }
1074          case NATIVE_GET_RESOURCE:
1075 +                get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1076 +                break;
1077          case NATIVE_GET_1_RESOURCE:
1078 +                get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1079 +                break;
1080          case NATIVE_GET_IND_RESOURCE:
1081 +                get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1082 +                break;
1083          case NATIVE_GET_1_IND_RESOURCE:
1084 <        case NATIVE_R_GET_RESOURCE: {
1085 <                typedef void (*GetResourceCallback)(void);
1086 <                static const GetResourceCallback get_resource_callbacks[] = {
1087 <                        ::get_resource,
1111 <                        ::get_1_resource,
1112 <                        ::get_ind_resource,
1113 <                        ::get_1_ind_resource,
1114 <                        ::r_get_resource
1115 <                };
1116 <                get_resource_callbacks[selector - NATIVE_GET_RESOURCE]();
1084 >                get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1085 >                break;
1086 >        case NATIVE_R_GET_RESOURCE:
1087 >                get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1088                  break;
1118 –        }
1089          case NATIVE_MAKE_EXECUTABLE:
1090                  MakeExecutable(0, gpr(4), gpr(5));
1091                  break;
1092          case NATIVE_CHECK_LOAD_INVOC:
1093                  check_load_invoc(gpr(3), gpr(4), gpr(5));
1094                  break;
1095 +        case NATIVE_NAMED_CHECK_LOAD_INVOC:
1096 +                named_check_load_invoc(gpr(3), gpr(4), gpr(5));
1097 +                break;
1098          default:
1099                  printf("FATAL: NATIVE_OP called with bogus selector %d\n", selector);
1100                  QuitEmulator();
# Line 1208 | Line 1181 | uint32 call_macos7(uint32 tvect, uint32
1181          const uint32 args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7 };
1182          return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args);
1183   }
1211 –
1212 – /*
1213 – *  Resource Manager thunks
1214 – */
1215 –
1216 – void get_resource(void)
1217 – {
1218 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE));
1219 – }
1220 –
1221 – void get_1_resource(void)
1222 – {
1223 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE));
1224 – }
1225 –
1226 – void get_ind_resource(void)
1227 – {
1228 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE));
1229 – }
1230 –
1231 – void get_1_ind_resource(void)
1232 – {
1233 –        ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE));
1234 – }
1235 –
1236 – void r_get_resource(void)
1237 – {
1238 –        ppc_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE));
1239 – }

Diff Legend

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