2 // m68kinterface.c: Code interface to the UAE 68000 core and support code
5 // (C) 2011 Underground Software
7 // JLH = James Hammons <jlhamm@acm.org>
10 // --- ---------- -------------------------------------------------------------
11 // JLH 10/28/2011 Created this file ;-)
14 #include "m68kinterface.h"
15 //#include <pthread.h>
21 // Exception Vectors handled by emulation
22 #define EXCEPTION_BUS_ERROR 2 /* This one is not emulated! */
23 #define EXCEPTION_ADDRESS_ERROR 3 /* This one is partially emulated (doesn't stack a proper frame yet) */
24 #define EXCEPTION_ILLEGAL_INSTRUCTION 4
25 #define EXCEPTION_ZERO_DIVIDE 5
26 #define EXCEPTION_CHK 6
27 #define EXCEPTION_TRAPV 7
28 #define EXCEPTION_PRIVILEGE_VIOLATION 8
29 #define EXCEPTION_TRACE 9
30 #define EXCEPTION_1010 10
31 #define EXCEPTION_1111 11
32 #define EXCEPTION_FORMAT_ERROR 14
33 #define EXCEPTION_UNINITIALIZED_INTERRUPT 15
34 #define EXCEPTION_SPURIOUS_INTERRUPT 24
35 #define EXCEPTION_INTERRUPT_AUTOVECTOR 24
36 #define EXCEPTION_TRAP_BASE 32
38 // These are found in obj/cpustbl.c (generated by gencpu)
40 //extern const struct cputbl op_smalltbl_0_ff[]; /* 68040 */
41 //extern const struct cputbl op_smalltbl_1_ff[]; /* 68020 + 68881 */
42 //extern const struct cputbl op_smalltbl_2_ff[]; /* 68020 */
43 //extern const struct cputbl op_smalltbl_3_ff[]; /* 68010 */
44 extern const struct cputbl op_smalltbl_4_ff[]; /* 68000 */
45 extern const struct cputbl op_smalltbl_5_ff[]; /* 68000 slow but compatible. */
47 // Externs, supplied by the user...
48 //extern int irq_ack_handler(int);
50 // Function prototypes...
51 STATIC_INLINE void m68ki_check_interrupts(void);
52 void m68ki_exception_interrupt(uint32_t intLevel);
53 STATIC_INLINE uint32_t m68ki_init_exception(void);
54 STATIC_INLINE void m68ki_stack_frame_3word(uint32_t pc, uint32_t sr);
55 unsigned long IllegalOpcode(uint32_t opcode);
56 void BuildCPUFunctionTable(void);
57 void m68k_set_irq2(unsigned int intLevel);
59 // Local "Global" vars
60 static int32_t initialCycles;
61 cpuop_func * cpuFunctionTable[65536];
63 // By virtue of the fact that m68k_set_irq() can be called asychronously by
64 // another thread, we need something along the lines of this:
65 static int checkForIRQToHandle = 0;
66 //static pthread_mutex_t executionLock = PTHREAD_MUTEX_INITIALIZER;
67 static int IRQLevelToHandle = 0;
70 #define ADD_CYCLES(A) m68ki_remaining_cycles += (A)
71 #define USE_CYCLES(A) m68ki_remaining_cycles -= (A)
72 #define SET_CYCLES(A) m68ki_remaining_cycles = A
73 #define GET_CYCLES() m68ki_remaining_cycles
74 #define USE_ALL_CYCLES() m68ki_remaining_cycles = 0
76 #define CPU_INT_LEVEL m68ki_cpu.int_level /* ASG: changed from CPU_INTS_PENDING */
77 #define CPU_INT_CYCLES m68ki_cpu.int_cycles /* ASG */
78 #define CPU_STOPPED m68ki_cpu.stopped
79 #define CPU_PREF_ADDR m68ki_cpu.pref_addr
80 #define CPU_PREF_DATA m68ki_cpu.pref_data
81 #define CPU_ADDRESS_MASK m68ki_cpu.address_mask
82 #define CPU_SR_MASK m68ki_cpu.sr_mask
88 void Dasm(uint32_t offset, uint32_t qt)
91 // back up a few instructions...
93 static char buffer[2048];//, mem[64];
94 int pc = offset, oldpc;
100 for(int j=0; j<64; j++)
101 mem[j^0x01] = jaguar_byte_read(pc + j);
103 pc += Dasm68000((char *)mem, buffer, 0);
104 WriteLog("%08X: %s\n", oldpc, buffer);//*/
106 pc += m68k_disassemble(buffer, pc, 0);//M68K_CPU_TYPE_68000);
107 // WriteLog("%08X: %s\n", oldpc, buffer);//*/
108 printf("%08X: %s\n", oldpc, buffer);//*/
115 void DumpRegisters(void)
121 printf("%s%i: %08X ", (i < 8 ? "D" : "A"), i & 0x7, regs.regs[i]);
130 void M68KDebugHalt(void)
132 regs.spcflags |= SPCFLAG_DEBUGGER;
136 void M68KDebugResume(void)
138 regs.spcflags &= ~SPCFLAG_DEBUGGER;
142 void m68k_set_cpu_type(unsigned int type)
147 // Pulse the RESET line on the CPU
148 void m68k_pulse_reset(void)
150 static uint32_t emulation_initialized = 0;
152 // The first call to this function initializes the opcode handler jump table
153 if (!emulation_initialized)
156 m68ki_build_opcode_table();
157 m68k_set_int_ack_callback(NULL);
158 m68k_set_bkpt_ack_callback(NULL);
159 m68k_set_reset_instr_callback(NULL);
160 m68k_set_pc_changed_callback(NULL);
161 m68k_set_fc_callback(NULL);
162 m68k_set_instr_hook_callback(NULL);
164 // Build opcode handler table here...
167 BuildCPUFunctionTable();
169 emulation_initialized = 1;
172 // if (CPU_TYPE == 0) /* KW 990319 */
173 // m68k_set_cpu_type(M68K_CPU_TYPE_68000);
176 /* Clear all stop levels and eat up all remaining cycles */
180 /* Turn off tracing */
181 FLAG_T1 = FLAG_T0 = 0;
183 /* Interrupt mask to level 7 */
184 FLAG_INT_MASK = 0x0700;
187 /* Go to supervisor mode */
188 m68ki_set_sm_flag(SFLAG_SET | MFLAG_CLEAR);
190 /* Invalidate the prefetch queue */
191 #if M68K_EMULATE_PREFETCH
192 /* Set to arbitrary number since our first fetch is from 0 */
193 CPU_PREF_ADDR = 0x1000;
194 #endif /* M68K_EMULATE_PREFETCH */
196 /* Read the initial stack pointer and program counter */
198 REG_SP = m68ki_read_imm_32();
199 REG_PC = m68ki_read_imm_32();
202 checkForIRQToHandle = 0;
205 regs.remainingCycles = 0;
208 regs.s = 1; // Supervisor mode ON
210 // Read initial SP and PC
211 m68k_areg(regs, 7) = m68k_read_memory_32(0);
212 m68k_setpc(m68k_read_memory_32(4));
213 refill_prefetch(m68k_getpc(), 0);
218 int m68k_execute(int num_cycles)
222 regs.remainingCycles = 0; // int32_t
223 regs.interruptCycles = 0; // uint32_t
229 /* Set our pool of clock cycles available */
230 SET_CYCLES(num_cycles);
231 m68ki_initial_cycles = num_cycles;
233 /* ASG: update cycles */
234 USE_CYCLES(CPU_INT_CYCLES);
237 /* Return point if we had an address error */
238 m68ki_set_address_error_trap(); /* auto-disable (see m68kcpu.h) */
240 regs.remainingCycles = num_cycles;
241 /*int32_t*/ initialCycles = num_cycles;
243 regs.remainingCycles -= regs.interruptCycles;
244 regs.interruptCycles = 0;
247 /* Main loop. Keep going until we run out of clock cycles */
250 // This is so our debugging code can break in on a dime.
251 // Otherwise, this is just extra slow down :-P
252 if (regs.spcflags & SPCFLAG_DEBUGGER)
254 // Not sure this is correct... :-P
255 num_cycles = initialCycles - regs.remainingCycles;
256 regs.remainingCycles = 0; // int32_t
257 regs.interruptCycles = 0; // uint32_t
262 /* Set tracing accodring to T1. (T0 is done inside instruction) */
263 m68ki_trace_t1(); /* auto-disable (see m68kcpu.h) */
265 /* Set the address space for reads */
266 m68ki_use_data_space(); /* auto-disable (see m68kcpu.h) */
268 /* Call external hook to peek at CPU */
269 m68ki_instr_hook(); /* auto-disable (see m68kcpu.h) */
271 /* Record previous program counter */
274 /* Read an instruction and call its handler */
275 REG_IR = m68ki_read_imm_16();
276 m68ki_instruction_jump_table[REG_IR]();
277 USE_CYCLES(CYC_INSTRUCTION[REG_IR]);
279 /* Trace m68k_exception, if necessary */
280 m68ki_exception_if_trace(); /* auto-disable (see m68kcpu.h) */
282 //Testing Hover Strike...
285 static int hitCount = 0;
286 static int inRoutine = 0;
289 //if (regs.pc == 0x80340A)
290 if (regs.pc == 0x803416)
295 printf("%i: $80340A start. A0=%08X, A1=%08X ", hitCount, regs.regs[8], regs.regs[9]);
297 else if (regs.pc == 0x803422)
300 printf("(%i instructions)\n", instSeen);
306 // AvP testing... (problem was: 32 bit addresses on 24 bit address cpu--FIXED)
310 if (regs.pc == 0x94BA)
316 if (regs.pc == 0x94C6)
319 // if (regs.regs[10] == 0xFFFFFFFF && go)
322 // printf("A2=-1, PC=%08X\n", regs.pc);
324 // Dasm(regs.pc, 130);
328 //94BA: 2468 0000 MOVEA.L (A0,$0000) == $0002328A, A2
329 //94BE: 200A MOVE.L A2, D0
330 //94C0: 6A02 BPL.B $94C4
331 //94C2: 2452 MOVEA.L (A2), A2 ; <--- HERE
332 //94C4: 4283 CLR.L D3
334 // pthread_mutex_lock(&executionLock);
335 if (checkForIRQToHandle)
337 checkForIRQToHandle = 0;
338 m68k_set_irq2(IRQLevelToHandle);
341 #ifdef M68K_HOOK_FUNCTION
342 M68KInstructionHook();
344 uint32_t opcode = get_iword(0);
345 //if ((opcode & 0xFFF8) == 0x31C0)
347 // printf("MOVE.W D%i, EA\n", opcode & 0x07);
349 int32_t cycles = (int32_t)(*cpuFunctionTable[opcode])(opcode);
350 regs.remainingCycles -= cycles;
351 // pthread_mutex_unlock(&executionLock);
353 //printf("Executed opcode $%04X (%i cycles)...\n", opcode, cycles);
356 while (regs.remainingCycles > 0);
359 /* set previous PC to current PC for the next entry into the loop */
362 /* ASG: update cycles */
363 USE_CYCLES(CPU_INT_CYCLES);
366 /* return how many clocks we used */
367 return m68ki_initial_cycles - GET_CYCLES();
369 regs.remainingCycles -= regs.interruptCycles;
370 regs.interruptCycles = 0;
372 // Return # of clock cycles used
373 return initialCycles - regs.remainingCycles;
378 void m68k_set_irq(unsigned int intLevel)
380 // We need to check for stopped state as well...
383 m68k_set_irq2(intLevel);
387 // Since this can be called asynchronously, we need to fix it so that it
388 // doesn't fuck up the main execution loop.
389 IRQLevelToHandle = intLevel;
390 checkForIRQToHandle = 1;
394 /* ASG: rewrote so that the int_level is a mask of the IPL0/IPL1/IPL2 bits */
395 void m68k_set_irq2(unsigned int intLevel)
397 // pthread_mutex_lock(&executionLock);
398 // printf("m68k_set_irq: Could not get the lock!!!\n");
400 int oldLevel = regs.intLevel;
401 regs.intLevel = intLevel;
403 // A transition from < 7 to 7 always interrupts (NMI)
404 // Note: Level 7 can also level trigger like a normal IRQ
405 if (oldLevel != 0x07 && regs.intLevel == 0x07)
406 m68ki_exception_interrupt(7); // Edge triggered level 7 (NMI)
408 m68ki_check_interrupts(); // Level triggered (IRQ)
410 // pthread_mutex_unlock(&executionLock);
414 // Check for interrupts
415 STATIC_INLINE void m68ki_check_interrupts(void)
418 if(CPU_INT_LEVEL > FLAG_INT_MASK)
419 m68ki_exception_interrupt(CPU_INT_LEVEL>>8);
421 if (regs.intLevel > regs.intmask)
422 m68ki_exception_interrupt(regs.intLevel);
427 // Service an interrupt request and start exception processing
428 void m68ki_exception_interrupt(uint32_t intLevel)
435 /* Turn off the stopped state */
436 CPU_STOPPED &= ~STOP_LEVEL_STOP;
438 /* If we are halted, don't do anything */
442 /* Acknowledge the interrupt */
443 vector = m68ki_int_ack(int_level);
445 /* Get the interrupt vector */
446 if(vector == M68K_INT_ACK_AUTOVECTOR)
447 /* Use the autovectors. This is the most commonly used implementation */
448 vector = EXCEPTION_INTERRUPT_AUTOVECTOR+int_level;
449 else if(vector == M68K_INT_ACK_SPURIOUS)
450 /* Called if no devices respond to the interrupt acknowledge */
451 vector = EXCEPTION_SPURIOUS_INTERRUPT;
452 else if(vector > 255)
454 M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: Interrupt acknowledge returned invalid vector $%x\n",
455 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC), vector));
459 /* Start exception processing */
460 sr = m68ki_init_exception();
462 /* Set the interrupt mask to the level of the one being serviced */
463 FLAG_INT_MASK = int_level<<8;
466 new_pc = m68ki_read_data_32((vector<<2) + REG_VBR);
468 /* If vector is uninitialized, call the uninitialized interrupt vector */
470 new_pc = m68ki_read_data_32((EXCEPTION_UNINITIALIZED_INTERRUPT<<2) + REG_VBR);
472 /* Generate a stack frame */
473 m68ki_stack_frame_0000(REG_PC, sr, vector);
475 if(FLAG_M && CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
477 /* Create throwaway frame */
478 m68ki_set_sm_flag(FLAG_S); /* clear M */
479 sr |= 0x2000; /* Same as SR in master stack frame except S is forced high */
480 m68ki_stack_frame_0001(REG_PC, sr, vector);
485 /* Defer cycle counting until later */
486 CPU_INT_CYCLES += CYC_EXCEPTION[vector];
488 #if !M68K_EMULATE_INT_ACK
489 /* Automatically clear IRQ if we are not using an acknowledge scheme */
491 #endif /* M68K_EMULATE_INT_ACK */
493 // Turn off the stopped state (N.B.: normal 68K behavior!)
496 //JLH: need to add halt state?
497 // prolly, for debugging/alpine mode... :-/
498 // but then again, this should be handled already by the main execution loop :-P
499 // If we are halted, don't do anything
503 // Acknowledge the interrupt (NOTE: This is a user supplied function!)
504 uint32_t vector = irq_ack_handler(intLevel);
506 // Get the interrupt vector
507 if (vector == M68K_INT_ACK_AUTOVECTOR)
508 // Use the autovectors. This is the most commonly used implementation
509 vector = EXCEPTION_INTERRUPT_AUTOVECTOR + intLevel;
510 else if (vector == M68K_INT_ACK_SPURIOUS)
511 // Called if no devices respond to the interrupt acknowledge
512 vector = EXCEPTION_SPURIOUS_INTERRUPT;
513 else if (vector > 255)
515 // M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: Interrupt acknowledge returned invalid vector $%x\n",
516 // m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC), vector));
520 // Start exception processing
521 uint32_t sr = m68ki_init_exception();
523 // Set the interrupt mask to the level of the one being serviced
524 regs.intmask = intLevel;
527 extern int startM68KTracing;
528 if (startM68KTracing)
530 printf("IRQ: old PC=%06X, ", regs.pc);
535 uint32_t newPC = m68k_read_memory_32(vector << 2);
538 if (startM68KTracing)
540 printf("new PC=%06X, vector=%u, ", newPC, vector);
544 // If vector is uninitialized, call the uninitialized interrupt vector
546 newPC = m68k_read_memory_32(EXCEPTION_UNINITIALIZED_INTERRUPT << 2);
548 // Generate a stack frame
549 m68ki_stack_frame_3word(regs.pc, sr);
553 if (startM68KTracing)
555 printf("(PC=%06X)\n", regs.pc);
559 // Defer cycle counting until later
560 regs.interruptCycles += 56; // NOT ACCURATE-- !!! FIX !!!
561 // CPU_INT_CYCLES += CYC_EXCEPTION[vector];
566 // Initiate exception processing
567 STATIC_INLINE uint32_t m68ki_init_exception(void)
570 /* Save the old status register */
571 uint sr = m68ki_get_sr();
573 /* Turn off trace flag, clear pending traces */
574 FLAG_T1 = FLAG_T0 = 0;
576 /* Enter supervisor mode */
577 m68ki_set_s_flag(SFLAG_SET);
582 uint32_t sr = regs.sr; // Save old status register
583 regs.s = 1; // Set supervisor mode
590 // 3 word stack frame (68000 only)
591 STATIC_INLINE void m68ki_stack_frame_3word(uint32_t pc, uint32_t sr)
598 m68k_areg(regs, 7) -= 4;
599 m68k_write_memory_32(m68k_areg(regs, 7), pc);
601 m68k_areg(regs, 7) -= 2;
602 m68k_write_memory_16(m68k_areg(regs, 7), sr);
607 unsigned int m68k_get_reg(void * context, m68k_register_t reg)
609 if (reg <= M68K_REG_A7)
610 return regs.regs[reg];
611 else if (reg == M68K_REG_PC)
613 else if (reg == M68K_REG_SR)
618 else if (reg == M68K_REG_SP)
619 return regs.regs[15];
625 void m68k_set_reg(m68k_register_t reg, unsigned int value)
627 if (reg <= M68K_REG_A7)
628 regs.regs[reg] = value;
629 else if (reg == M68K_REG_PC)
631 else if (reg == M68K_REG_SR)
636 else if (reg == M68K_REG_SP)
637 regs.regs[15] = value;
642 // Check if the instruction is a valid one
644 unsigned int m68k_is_valid_instruction(unsigned int instruction, unsigned int cpu_type)
646 instruction &= 0xFFFF;
648 if (cpuFunctionTable[instruction] == IllegalOpcode)
655 // Dummy functions, for now, until we prove the concept here. :-)
657 // Temp, while we're using the Musashi disassembler...
659 unsigned int m68k_disassemble(char * str_buff, unsigned int pc, unsigned int cpu_type)
665 int m68k_cycles_run(void) {} /* Number of cycles run so far */
666 int m68k_cycles_remaining(void) {} /* Number of cycles left */
667 //void m68k_modify_timeslice(int cycles) {} /* Modify cycles left */
668 //void m68k_end_timeslice(void) {} /* End timeslice now */
671 void m68k_modify_timeslice(int cycles)
673 regs.remainingCycles = cycles;
677 void m68k_end_timeslice(void)
680 m68ki_initial_cycles = GET_CYCLES();
683 initialCycles = regs.remainingCycles;
684 regs.remainingCycles = 0;
689 unsigned long IllegalOpcode(uint32_t opcode)
692 uint32_t pc = m68k_getpc ();
694 if ((opcode & 0xF000) == 0xF000)
696 Exception(0x0B, 0, M68000_EXC_SRC_CPU); // LineF exception...
699 else if ((opcode & 0xF000) == 0xA000)
701 Exception(0x0A, 0, M68000_EXC_SRC_CPU); // LineA exception...
706 write_log ("Illegal instruction: %04x at %08lx\n", opcode, (long)pc);
709 Exception(0x04, 0, M68000_EXC_SRC_CPU); // Illegal opcode exception...
714 void BuildCPUFunctionTable(void)
717 unsigned long opcode;
719 // We're only using the "fast" 68000 emulation here, not the "compatible"
720 // ("fast" doesn't throw exceptions, so we're using "compatible" now :-P)
722 const struct cputbl * tbl = (currprefs.cpu_compatible
723 ? op_smalltbl_5_ff : op_smalltbl_4_ff);
725 //let's try "compatible" and see what happens here...
726 // const struct cputbl * tbl = op_smalltbl_4_ff;
727 const struct cputbl * tbl = op_smalltbl_5_ff;
730 // Log_Printf(LOG_DEBUG, "Building CPU function table (%d %d %d).\n",
731 // currprefs.cpu_level, currprefs.cpu_compatible, currprefs.address_space_24);
733 // Set all instructions to Illegal...
734 for(opcode=0; opcode<65536; opcode++)
735 cpuFunctionTable[opcode] = IllegalOpcode;
737 // Move functions from compact table into our full function table...
738 for(i=0; tbl[i].handler!=NULL; i++)
739 cpuFunctionTable[tbl[i].opcode] = tbl[i].handler;
741 //JLH: According to readcpu.c, handler is set to -1 and never changes.
742 // Actually, it does read this crap in readcpu.c, do_merges() does it... :-P
743 // Again, seems like a build time thing could be done here...
745 for(opcode=0; opcode<65536; opcode++)
747 // if (table68k[opcode].mnemo == i_ILLG || table68k[opcode].clev > currprefs.cpu_level)
748 if (table68k[opcode].mnemo == i_ILLG || table68k[opcode].clev > 0)
751 if (table68k[opcode].handler != -1)
753 //printf("Relocate: $%04X->$%04X\n", table68k[opcode].handler, opcode);
754 cpuop_func * f = cpuFunctionTable[table68k[opcode].handler];
756 if (f == IllegalOpcode)
759 cpuFunctionTable[opcode] = f;