Return to m68000.c CVS log

Up to [Tom Morton FrontierVM] / frontvm / hardware

Annotation of frontvm/hardware/m68000.c, revision 1.1.1.1

1.1       root        1: /*
                      2:   Hatari - m68000.c
                      3: 
                      4:   This file is distributed under the GNU Public License, version 2 or at
                      5:   your option any later version. Read the file gpl.txt for details.
                      6: 
                      7:   These routines originally (in WinSTon) handled exceptions as well as some
                      8:   few OpCode's such as Line-F and Line-A. In Hatari it has mainly become a
                      9:   wrapper between the WinSTon sources and the UAE CPU code.
                     10: */
                     11: 
                     12: #include <SDL.h>
                     13: #include "main.h"
                     14: #include "decode.h"
                     15: #include "hatari-glue.h"
                     16: #include "int.h"
                     17: #include "m68000.h"
                     18: #include "stMemory.h"
                     19: #include "disasm.h"
                     20: 
                     21: unsigned long ExceptionVector;
                     22: short int PendingInterruptFlag;
                     23: void *PendingInterruptFunction;
                     24: short int PendingInterruptCount;
                     25: Uint32 BusAddressLocation;       /* Stores the offending address for bus-/address errors */
                     26: Uint32 BusErrorPC;               /* Value of the PC when bus error occurs */
                     27: Uint16 BusErrorOpcode;           /* Opcode of faulting instruction */
                     28: 
                     29: 
                     30: /*-----------------------------------------------------------------------*/
                     31: /*
                     32:   Reset CPU 68000 variables
                     33: */
                     34: void M68000_Reset(BOOL bCold)
                     35: {
                     36:   int i;
                     37: 
                     38:   /* Clear registers */
                     39:   if (bCold)
                     40:   {
                     41:     for(i=0; i<(16+1); i++)
                     42:       Regs[i] = 0;
                     43:   }
                     44: 
                     45:   PendingInterruptFlag = 0;     /* Clear pending flag */
                     46: 
                     47:   /* Now directly reset the UAE CPU core: */
                     48:   m68k_reset();
                     49: }
                     50: 
                     51: static void dump_registers ()
                     52: {
                     53:        int i;
                     54:        for (i=0; i<8; i++) {
                     55:                fprintf (stderr, "D%d: 0x%08x\t\tA%d: 0x%08x\n", i, Regs[i], i, Regs[i+8]);
                     56:        }
                     57: }
                     58: 
                     59: void M68000_Crash (int exception)
                     60: {
                     61:        int pc = m68k_getpc();
                     62:        
                     63:        fprintf(stderr, "Exception (-> %i bombs) at 0x%x!\n\n", exception, pc);
                     64:        dump_registers ();
                     65:        dump_code (pc, 32);
                     66:        SDL_Quit ();
                     67:        exit (-2);
                     68: }
                     69: 
                     70: /*-----------------------------------------------------------------------*/
                     71: /*
                     72:   Exception handler
                     73: */
                     74: void M68000_Exception(void)
                     75: {
                     76:   int exceptionNr = ExceptionVector/4;
                     77: 
                     78:   if(exceptionNr>24 && exceptionNr<32)  /* 68k autovector interrupt? */
                     79:   {
                     80:     /* Handle autovector interrupts the UAE's way
                     81:      * (see intlev() and do_specialties() in UAE CPU core) */
                     82: #if 1
                     83:     if(requestedInterrupt != -1)
                     84:       fprintf(stderr,"Warning: Overriding interrupt %d with %d\n",
                     85:               requestedInterrupt, exceptionNr-24);
                     86: #endif
                     87:     requestedInterrupt = exceptionNr - 24;
                     88:     set_special(SPCFLAG_INT);
                     89:   }
                     90:   else
                     91:   {
                     92:     /* Was the CPU stopped, i.e. by a STOP instruction? */
                     93:     regs.stopped = 0;
                     94:     unset_special(SPCFLAG_STOP);        /* All is go,go,go! */
                     95: 
                     96:     /* 68k exceptions are handled by Exception() of the UAE CPU core */
                     97:     Exception(exceptionNr, m68k_getpc());
                     98: 
                     99:     MakeSR();
                    100:     /* Set Status Register so interrupt can ONLY be stopped by another interrupt
                    101:      * of higher priority! */
                    102: #if 0  /* VBL and HBL are handled in the UAE CPU core (see above). */
                    103:     if (ExceptionVector==EXCEPTION_VBLANK)
                    104:       SR = (SR&SR_CLEAR_IPL)|0x0400;  /* VBL, level 4 */
                    105:     else if (ExceptionVector==EXCEPTION_HBLANK)
                    106:       SR = (SR&SR_CLEAR_IPL)|0x0200;  /* HBL, level 2 */
                    107:     else
                    108: #endif
                    109:     MakeFromSR();
                    110:   }
                    111: }
                    112: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.