![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m68000.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to m68000.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari
3:
4: M68000 - CPU. This handles exception handling as well as a few OpCode's such as Line-F and Line-A.
5: We also have a function to save off the last 'x' instruction ran which is very handy for debugging
6: as we can see what code was run before a crash etc...
7: (Other CPU functions can be found in 'decode.asm/.inc')
8: */
9:
10: #include "main.h"
11: #include "bios.h"
12: #include "cart.h"
13: #include "debug.h"
14: #include "decode.h"
15: #include "disass.h"
16: #include "fdc.h"
17: #include "gemdos.h"
18: #include "ikbd.h"
19: #include "int.h"
20: #include "m68000.h"
21: #include "memAlloc.h"
22: #include "memorySnapShot.h"
23: #include "mfp.h"
24: #include "misc.h"
25: #include "psg.h"
26: #include "screen.h"
27: #include "stMemory.h"
28: #include "tos.h"
29: #include "vdi.h"
30: #include "view.h"
31: #include "xbios.h"
32:
33:
34: /* Taken from Decode.asm - Thothy */
35: /* These should be replaced with UAE's CPU core equivalents one day */
36: unsigned short SR_Before;
37: unsigned long ExceptionVector;
38: short int PendingInterruptFlag;
39: void *PendingInterruptFunction;
40: short int PendingInterruptCount;
41: int SoundCycles;
42: BOOL bInSuperMode;
43: unsigned long EmuCCode;
44: unsigned long BusAddressLocation;
45:
46:
47: /* Use these if want to bring up any bus/address error, else uses 68000 vector handler */
48: #ifndef FINAL_VERSION
49: // #define TRAP_BUSERROR_HISTORY // Output history on true Bus Error(bombs display)
50: // #define TRAP_ADDRESSERROR_HISTORY // Or Address Error
51: // #define TRAP_ILLEGALINSTRUCTIONERROR_HISTORY // Or Illegal Instruction
52: #endif
53:
54: BOOL bDoTraceException; /* Do TRACE? */
55:
56:
57: //-----------------------------------------------------------------------
58: /*
59: Reset CPU 68000 variables
60: */
61: void M68000_Reset(BOOL bCold)
62: {
63: int i;
64:
65: // Clear registers, set PC, SR and stack pointers
66: if (bCold) {
67: for(i=0; i<(16+1); i++)
68: Regs[i] = 0;
69: }
70: PC = TOSAddress; /* Start of TOS image, 0xfc0000 or 0xe00000 */
71: SR = 0x2700; /* Starting status register */
72: bDoTraceException = FALSE; /* No TRACE exceptions */
73: bInSuperMode = TRUE; /* We begin in supervisor mode */
74: Regs[REG_A7] = Regs[REG_A8] = 0x0000f000; /* Stack default */
75: Reg_SuperSP = (unsigned long)&Regs[REG_A7]; /* So use this register as our stack */
76: Reg_UserSP = (unsigned long)&Regs[REG_A8];
77: PendingInterruptFlag = 0; // Clear pending flag
78:
79: // Read Supervisor Stack/PC for warm reset
80: if (!bCold) {
81: Regs[REG_A8] = STMemory_ReadLong(0x00000000);
82: PC = STMemory_ReadLong(0x00000004);
83: }
84:
85: // Hold display for extended VDI resolutions(under init our VDI)
86: bHoldScreenDisplay = TRUE;
87: }
88:
89: //-----------------------------------------------------------------------
90: /*
91: Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
92: */
93: void M68000_MemorySnapShot_Capture(BOOL bSave)
94: {
95: // Save/Restore details
96: MemorySnapShot_Store(&bDoTraceException,sizeof(bDoTraceException));
97: }
98:
99: //-----------------------------------------------------------------------
100: /*
101: Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
102: This is for 'decode.asm' variables - as cannot use 'decode.c' as will overwrite assembler .obj file!
103: */
104: void M68000_Decode_MemorySnapShot_Capture(BOOL bSave)
105: {
106: int ID;
107:
108: // Save/Restore details
109: MemorySnapShot_Store(Regs,sizeof(Regs));
110: MemorySnapShot_Store(&STRamEnd,sizeof(STRamEnd));
111: MemorySnapShot_Store(&STRamEnd_BusErr,sizeof(STRamEnd_BusErr));
112: MemorySnapShot_Store(&PendingInterruptCount,sizeof(PendingInterruptCount));
113: MemorySnapShot_Store(&PendingInterruptFlag,sizeof(PendingInterruptFlag));
114: if (bSave) {
115: // Convert function to ID
116: ID = Int_HandlerFunctionToID(PendingInterruptFunction);
117: MemorySnapShot_Store(&ID,sizeof(int));
118: }
119: else {
120: // Convert ID to function
121: MemorySnapShot_Store(&ID,sizeof(int));
122: PendingInterruptFunction = Int_IDToHandlerFunction(ID);
123: }
124: MemorySnapShot_Store(&PC,sizeof(PC));
125: MemorySnapShot_Store(&SR,sizeof(SR));
126: MemorySnapShot_Store(&SR_Before,sizeof(SR_Before));
127: MemorySnapShot_Store(&bInSuperMode,sizeof(bInSuperMode));
128: MemorySnapShot_Store(&Reg_SuperSP,sizeof(Reg_SuperSP));
129: MemorySnapShot_Store(&Reg_UserSP,sizeof(Reg_UserSP));
130: MemorySnapShot_Store(&EmuCCode,sizeof(EmuCCode));
131: MemorySnapShot_Store(&ExceptionVector,sizeof(ExceptionVector));
132: }
133:
134: //-----------------------------------------------------------------------
135: /*
136: ILLEGAL - Unknown 68000 OpCode
137: */
138: void M68000_IllegalInstruction(void)
139: {
140: fprintf(stderr, "M68000_IllegalInstruction\n");
141: ADD_CYCLES(34,4,3);
142: ExceptionVector = EXCEPTION_ILLEGALINS; /* Illegal vector */
143: M68000_Exception(); /* Cause trap */
144: // RET;
145: }
146:
147: //-----------------------------------------------------------------------
148: /*
149: BUSERROR - Access outside valid memory range
150: */
151: void M68000_BusError(unsigned long addr)
152: {
153: /* Reset PC's stack to normal(as may have done many calls) so return to
154: correct level after exception.
155: Enter here with 'ebp' as address we tried to access */
156: fprintf(stderr, "M68000_BusError at address $%lx\n", (long)addr);
157: BusAddressLocation=addr; /* Store for exception frame */
158: ExceptionVector = EXCEPTION_BUSERROR; /* Handler */
159: M68000_Exception(); /* Cause trap */
160: /*
161: asm(" mov [BusAddressLocation],ebp\n" // Store for exception frame
162: " mov esp,[StackSave]\n" // Restore stack
163: " mov [ExceptionVector],EXCEPTION_BUSERROR\n"); // Handler
164: SAVE_ASSEM_REGS(); // Save assembly registers
165: asm(" call M68000_Exception\n"); // Cause trap
166: RESTORE_ASSEM_REGS(); // Restore assembly registers
167: RET; // Start decoding
168: */
169: }
170:
171: //-----------------------------------------------------------------------
172: /*
173: ADDRESSERROR - Access incorrect memory boundary, eg byte offset for a word access
174: */
175: void M68000_AddressError(unsigned long addr)
176: {
177: fprintf(stderr, "M68000_AddressError at address $%lx\n", (long)addr);
178: BusAddressLocation=addr; /* Store for exception frame */
179: ExceptionVector=EXCEPTION_ADDRERROR; /* Handler */
180: M68000_Exception(); /* Cause trap */
181: /*
182: // Reset PC's stack to normal(as may have done many calls) so return to correct level after exception
183: __asm {
184: // Enter here with 'ebp' as address we tried to access
185: mov [BusAddressLocation],ebp // Store for exception frame
186: mov esp,[StackSave] // Restore stack
187: mov [ExceptionVector],EXCEPTION_ADDRERROR // Handler
188: SAVE_ASSEM_REGS // Save assembly registers
189: call M68000_Exception // Cause trap
190: RESTORE_ASSEM_REGS // Restore assembly registers
191: }
192: RET // Start decoding
193: */
194: }
195:
196: //-----------------------------------------------------------------------
197: /*
198: See if in user/super mode and if need to swap SP
199: */
200: void M68000_CheckUserSuperToggle(void)
201: {
202: unsigned long *TempReg;
203: unsigned long TempSP;
204:
205: // Have we swapped mode?
206: if ( (SR_Before&SR_SUPERMODE)!=(SR&SR_SUPERMODE) ) {
207: // Yes, swap to ST's REG_A8!
208: TempSP = Regs[REG_A7];
209: Regs[REG_A7] = Regs[REG_A8];
210: Regs[REG_A8] = TempSP;
211:
212: // And keep track of which of our registers is the supermode stack pointer
213: TempReg = (unsigned long *)Reg_SuperSP;
214: Reg_SuperSP = Reg_UserSP;
215: Reg_UserSP = (unsigned long)TempReg;
216:
217: // Swap super flag
218: bInSuperMode^=TRUE;
219: }
220:
221: // Set/Clear trace mode
222: if (SR&SR_TRACEMODE) {
223: // Have we set the TRACE bit for the FIRST time? Don't let exception occur until NEXT instruction
224: // NOTE Sometimes the TRACE bit can be set many times, so only skip exception on FIRST one
225: if ((PendingInterruptFlag&PENDING_INTERRUPT_FLAG_TRACE)==0) {
226: PendingInterruptFlag |= PENDING_INTERRUPT_FLAG_TRACE;
227: bDoTraceException = FALSE;
228: }
229: }
230: else
231: PendingInterruptFlag &= CLEAR_PENDING_INTERRUPT_FLAG_TRACE;
232: }
233:
234: //-----------------------------------------------------------------------
235: /*
236: Called when TRACE bit is set. This causes 'exception' after each instruction, BUT
237: it does not execute after the FIRST 'move SR,xxxx' to set the bit
238: */
239: void M68000_TraceModeTriggered(void)
240: {
241: /* FIXME */
242: /*
243: __asm {
244: cmp [bDoTraceException],FALSE // First time around? Skip exception
245: je dont_need_expection
246:
247: mov [ExceptionVector],EXCEPTION_TRACE // Handler
248: SAVE_ASSEM_REGS // Save assembly registers
249: call M68000_Exception // Cause trap
250: RESTORE_ASSEM_REGS // Restore assembly registers
251:
252: dont_need_expection:;
253: mov [bDoTraceException],TRUE // Do TRACE exception next time around
254: ret
255: }
256: */
257: }
258:
259: //-----------------------------------------------------------------------
260: /*
261: Exception handler
262: */
263: void M68000_Exception(void)
264: {
265: unsigned long Vector,MFPBaseVector;
266: BOOL bRet=FALSE;
267:
268: /* At the moment, this functions ist just a wrapper to Exception() of the UAE CPU - Thothy */
269: Exception(ExceptionVector/4, m68k_getpc());
270: return;
271:
272: #if 0
273: // Was the CPU stopped, ie by a STOP instruction?
274: /* FIXME: */
275: /*
276: if (CPUStopped) {
277: PC += 4; // Skip after the STOP instruction as CPU is now to resume!
278: CPUStopped = FALSE; // All is go,go,go!
279: }
280: */
281: /* Find exception vector, keep 32-bit address as top byte is used by TOS */
282: /* exception vectors as an ID! */
283: Vector = STMemory_ReadLong(ExceptionVector);
284:
285: /* Check for intercept - The game 'Operation Wolf' re-directs traps, */
286: /* so double check is a TOS trap and not software! (ie Vector is >0xE00000) */
287: if ((Vector&0xffffff)>=0xE00000) {
288: if (ExceptionVector==EXCEPTION_TRAP13)
289: bRet = Bios();
290: else if (ExceptionVector==EXCEPTION_TRAP14)
291: bRet = XBios();
292: else if (ExceptionVector==EXCEPTION_TRAP1)
293: bRet = GemDOS();
294: else if (ExceptionVector==EXCEPTION_TRAP2) {
295: bRet = VDI();
296: if (!bRet) {
297: // Set 'PC' as address of 'VDI_OPCODE' illegal instruction
298: // This will call VDI_OpCode after completion of Trap call!
299: // Use to modify return structure from VDI
300: if (bUseVDIRes) {
301: VDI_OldPC = PC;
302: PC = CART_VDI_OPCODE_ADDR;
303: }
304: }
305: }
306:
307: // Do handly bit of debugging to trap bus/address errors, before goes to TOS handler
308: #ifdef TRAP_BUSERROR_HISTORY
309: if (ExceptionVector==EXCEPTION_BUSERROR) {
310: MessageBox(NULL,"TRAP BUS ERROR",PROG_NAME,MB_OK | MB_ICONSTOP);
311: Debug_File("TRAP BUS ERROR\n");
312: M68000_OutputHistory();
313: exit(0);
314: }
315: #endif
316: #ifdef TRAP_ADDRESSERROR_HISTORY
317: if (ExceptionVector==EXCEPTION_ADDRERROR) {
318: MessageBox(NULL,"TRAP ADDRESS ERROR",PROG_NAME,MB_OK | MB_ICONSTOP);
319: Debug_File("TRAP ADDRESS ERROR\n");
320: M68000_OutputHistory();
321: exit(0);
322: }
323: #endif
324: #ifdef TRAP_ILLEGALINSTRUCTIONERROR_HISTORY
325: if (ExceptionVector==EXCEPTION_ILLEGALINS) {
326: MessageBox(NULL,"TRAP ILLEGAL INSTRUCTION ERROR",PROG_NAME,MB_OK | MB_ICONSTOP);
327: Debug_File("TRAP ILLEGAL INSTRUCTION ERROR\n");
328: M68000_OutputHistory();
329: exit(0);
330: }
331: #endif
332: }
333:
334: // Did we re-direct call? No, so let's call it!
335: if (!bRet) {
336: // Save PC and SR to supervisor stack
337: /* FIXME */
338: /*
339: __asm {
340: push ebp
341:
342: mov edx,[Reg_SuperSP]
343:
344: sub DWORD PTR [edx],SIZE_LONG
345: mov ebp,[edx] // Stack pointer
346: and ebp,0xffffff // as 24-bit address in PC memory(note _C)
347: mov ecx,[PC] // Save PC
348: SWAP_ENDIAN_LONG_ECX
349: mov DWORD PTR STRam[ebp],ecx
350:
351: sub DWORD PTR [edx],SIZE_WORD
352: mov ebp,[edx] // Stack pointer
353: and ebp,0xffffff // as 24-bit address in PC memory(note _C)
354: mov cx,WORD PTR [SR]
355: and ecx,SR_MASK // Remove condition codes
356: mov eax,[EmuCCode]
357: shr eax,4 // Emulation codes in correct bits
358: and eax,SR_CCODE_MASK
359: or eax,ecx // Or in current condition codes
360: SWAP_ENDIAN_WORD_AX
361: mov WORD PTR STRam[ebp],ax
362:
363: pop ebp
364: }
365: */
366: // Exception frame, total 14 bytes (6 already put on stack, ie PC and SR)
367: // 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
368: // SSP->| |RW|IN|Func.cod| Higher
369: // address
370: // |High word access address |
371: // |Low word access address |
372: // |Instruction register |
373: // |Status register |
374: // |High word program counter |
375: // |Low word program counter | Lower address
376: //
377: // RW: Write=0, Read=1
378: // IN: Instruction=0, Not=1
379: if ( (ExceptionVector==EXCEPTION_BUSERROR) || (ExceptionVector==EXCEPTION_ADDRERROR) ) {
380: /* FIXME */
381: /*
382: __asm {
383: push ebp
384:
385: mov ebp,[InsPC] // Get PC of instruction last ran
386: mov cx,WORD PTR [ebp] // 'Opcode' in 68000 endian
387: mov edx,[Reg_SuperSP]
388: sub DWORD PTR [edx],SIZE_WORD
389: mov ebp,[edx] // Stack pointer
390: and ebp,0xffffff // as 24-bit address in PC memory(note _C)
391: mov WORD PTR STRam[ebp],cx // Store 'Instruction Register'
392:
393: sub DWORD PTR [edx],SIZE_LONG
394: mov ebp,[edx] // Stack pointer
395: and ebp,0xffffff // as 24-bit address in PC memory(note _C)
396: mov ecx,[BusAddressLocation] // Address which caused fault
397: SWAP_ENDIAN_LONG_ECX
398: mov DWORD PTR STRam[ebp],ecx
399:
400: sub DWORD PTR [edx],SIZE_WORD
401: mov ebp,[edx] // Stack pointer
402: and ebp,0xffffff // as 24-bit address in PC memory(note _C)
403: xor ecx,ecx
404: mov WORD PTR STRam[ebp],cx // '0' for now
405:
406: pop ebp
407: }
408: */
409: }
410:
411: SR_Before = SR;
412: SR &= SR_CLEAR_TRACEMODE; // Clear trace mode (bit 15)
413: SR |= SR_SUPERMODE; // Set super mode (bit 13)
414: M68000_CheckUserSuperToggle(); // Check if swapped mode
415:
416: // Do call to vector
417: // char szString[256];
418: // sprintf(szString,"0x%X (0x%X)",Vector,ExceptionVector);
419: // debug << szString << endl;
420: PC = Vector;
421: // Set Status Register so interrupt can ONLY be stopped by another interrupt of higher priority!
422: if (ExceptionVector==EXCEPTION_VBLANK)
423: SR = (SR&SR_CLEAR_IPL)|0x0400; // VBL, level 4
424: else if (ExceptionVector==EXCEPTION_HBLANK)
425: SR = (SR&SR_CLEAR_IPL)|0x0200; // HBL, level 2
426: else {
427: MFPBaseVector = (unsigned int)(MFP_VR&0xf0)<<2;
428: if ( (ExceptionVector>=MFPBaseVector) && (ExceptionVector<=(MFPBaseVector+0x34)) )
429: SR = (SR&SR_CLEAR_IPL)|0x0600; // MFP, level 6
430: }
431: }
432: #endif
433: }
434:
435: //-----------------------------------------------------------------------
436: /*
437: Handle Line-A OpCode exception(Top 4-bit in opcode are 0xA)
438: */
439: /*
440: void M68000_Line_A_OpCode_Execute(void)
441: {
442: PC -= SIZE_WORD; // PC needs to be at address of Line-A instruction
443: ExceptionVector = EXCEPTION_LINE_A;
444: M68000_Exception();
445: }
446:
447: void M68000_Line_A_OpCode(void)
448: {
449: //FIXME SAVE_ASSEM_REGS(); // Save assembly registers
450: M68000_Line_A_OpCode_Execute();
451: // RESTORE_ASSEM_REGS(); // Restore assembly registers
452: // RET;
453: }
454: */
455:
456: //-----------------------------------------------------------------------
457: /*
458: During init do 0xA000, followed by 0xA0FF - we use this to get pointer to Line-A structure details(to fix for extended VDI res)
459: */
460: void M68000_Line_A_Trap(void)
461: {
462: /* FIXME */
463: /*
464:
465: PUSH_ALL
466: __asm {
467: mov edx,DWORD PTR Regs[REG_D0*4]
468: mov [LineABase],edx
469: mov edx,DWORD PTR Regs[REG_A1*4]
470: mov [FontBase],edx
471: call VDI_LineA // Modify Line-A structure
472: }
473: POP_ALL
474: RET
475: */
476: }
477:
478: //-----------------------------------------------------------------------
479: /*
480: Handle Line-F OpCode exception(Top 4-bit in opcode are 0xF)
481: */
482: /*
483: void M68000_Line_F_OpCode_Execute(void)
484: {
485: PC -= SIZE_WORD; // PC needs to be at address of Line-F instruction
486: ExceptionVector = EXCEPTION_LINE_F;
487: M68000_Exception();
488: }
489:
490: void M68000_Line_F_OpCode(void)
491: {
492: //FIXME SAVE_ASSEM_REGS(); // Save assembly registers
493: M68000_Line_F_OpCode_Execute();
494: // RESTORE_ASSEM_REGS(); // Restore assembly registers
495: // RET;
496: }
497: */
498:
499: //-----------------------------------------------------------------------
500: /*
501: Use 'InsPC' to find how many cycles last instruction took to execute
502: */
503: int M68000_FindLastInstructionCycles(void)
504: {
505: unsigned short int OpCode;
506:
507: //FIXME OpCode = *(unsigned short int *)InsPC; // Read 'opcode'
508: //FIXME return( DecodeTable[(OpCode*SIZEOF_DECODE)+(DECODE_CYCLES/sizeof(long))] );
509: return 4; /* Ouargs ... this is an uggly hack */
510: }
511:
512: //-----------------------------------------------------------------------
513: /*
514: Output CPU instruction history(last 'x' instructions) for debugging
515: */
516: void M68000_OutputHistory(void)
517: {
518: #ifndef FINAL_VERSION
519: unsigned long StartPC;
520: int i;
521:
522: /* First, Return back into a Window */
523: Screen_ReturnFromFullScreen();
524: View_ToggleWindowsMouse(MOUSE_WINDOWS);
525:
526: Debug_File("HISTORY\n");
527:
528: for(i=0; i<(INSTRUCTION_HISTORY_SIZE-1); i++) {
529: StartPC = DisPC = InstructionHistory[(InstructionHistoryIndex+i+1)&INSTRUCTION_HISTORY_MASK];
530: Disass_DiassembleLine(); // Disassemble instruction
531:
532: Debug_File("%8.8X\t%s\n",StartPC,szOpString);
533: }
534: #endif
535: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.