summaryrefslogblamecommitdiffstatshomepage
path: root/src/emu/cpu/m68000/m68kcpu.c
blob: 8a8e9e2ddf8772f14d93c0231af1836fd146b084 (plain) (tree)
1
2
3
4
5
6
7
8
9




                                                                              
                                      
           
                             
                                                          
                                                  




                                                                              
                                                                

















                                                                              
                   
                    
                    

                    


                                                 



                                                                              
                      
                                     




















                            
                                         
                                     







                                                                               
                                       









                                                                               
                                       

















                                                                               
                                                 






































































































































































































































































































                                                                                  
                                          






























                                                                              
                                                               
 
                                     
                                                  
                            



                                       

                                                        





































                                                                       
                                                        



 




                                                                              
                                                                       
 

                      







































                                                                                                                                 
                                       
                                              










                                                                                                         

 
                                                                                   


















                                                                                    

                                                                                           
                                                                                  
                                                        



                                                                                                   
                                                                         



                                                                                                   
                                                                        



                                                                                                   




                                                                                      
                                                                                   
                                                                                    
                                                                                                   
                                                                               




                                                       
                                                                                                               
 

                                                                                

 
                                                                                           
 
                                                                                  

 
                                                                                 
 
                                                                                        

 
                                                                                               
 
                                                                                          

 
                                                                               
 
                                                                                    

 
                                                                              
 
                                                                                    

 
                                                                                               
 
                                                                                      

 
                                                                                       
 
                                                                              

 
                                                                                           
 
                                                                                      



                       
                                                                   



                                         













                                                                                                          

                                         













                                                                                                          

                                         













                                                                                                          

                                           













                                                                                                          

                                         













                                                                                                          

                                                                                             













                                                                                                          





                                                                       
                                                      
 
                                                    

                                          

                                       
                                     
 
                                         
                          
         
                                                             
                                                                                      







                                                                                          
                                                                                      

                                                               
                                                                   




                                                                      


                                                                          


                                                                                      
                                              


                                                                                    
         
            
                                    
 
                                            
                                                       


 
                                         
 
                                                       

 
                                               
 
                                


                          
                                                            
 

                                       


 
                                             
 

                                                






                                                                             
                                                               
 

                                           


                                                                    
                                                            
                                         

 
                                                                                 
 

                                        




                                       
                                 



                                             
                                   

 
                                                                    
 
                                                         

 
                                    
 
                                                
        






                                                                                       








                                                    


                                     
                                           

                                                                   
                          
                            
 
                                                  

                              
                                          

                                       
                                
                            
                             
                       
                      
                                   
                                                         

                                           
                                                                     
                                 

                                                                



                                         
 
                                         


                                    
                                          
 
                                         






                                         
                              







                                                                              

                     





                      
                                                                        
 

                                              

                                                                       

 
                                                                 
 

                                                        
                                                                   
                                                                      
                                 

 
                                                                           
 
                                                                             
                                                           




                                                       




                                                          
                                                                
                                                               

                                                                     

                                                               

                                                                          

 


                                                                              
/* ======================================================================== */
/* ========================= LICENSING & COPYRIGHT ======================== */
/* ======================================================================== */

#if 0
static const char copyright_notice[] =
"MUSASHI\n"
"Version 3.32 (2007-12-15)\n"
"A portable Motorola M680x0 processor emulation engine.\n"
"Copyright Karl Stenerud.  All rights reserved.\n"
"\n"
"This code may be freely used for non-commercial purpooses as long as this\n"
"copyright notice remains unaltered in the source code and any binary files\n"
"containing this code in compiled form.\n"
"\n"
"All other licensing terms must be negotiated with the author\n"
"(Karl Stenerud).\n"
"\n"
"The latest version of this code can be obtained at:\n"
"http://kstenerud.cjb.net\n"
;
#endif


/* ======================================================================== */
/* ================================= NOTES ================================ */
/* ======================================================================== */



/* ======================================================================== */
/* ================================ INCLUDES ============================== */
/* ======================================================================== */

#include <setjmp.h>
#include "m68kcpu.h"
#include "m68kops.h"
#include "m68kfpu.c"

extern void m68040_fpu_op0(m68ki_cpu_core *m68k);
extern void m68040_fpu_op1(m68ki_cpu_core *m68k);

/* ======================================================================== */
/* ================================= DATA ================================= */
/* ======================================================================== */

#ifdef M68K_LOG_ENABLE
const char *const m68ki_cpu_names[] =
{
	"Invalid CPU",
	"M68000",
	"M68008",
	"Invalid CPU",
	"M68010",
	"Invalid CPU",
	"Invalid CPU",
	"Invalid CPU",
	"M68EC020",
	"Invalid CPU",
	"Invalid CPU",
	"Invalid CPU",
	"Invalid CPU",
	"Invalid CPU",
	"Invalid CPU",
	"Invalid CPU",
	"M68020"
};
#endif /* M68K_LOG_ENABLE */

/* Used by shift & rotate instructions */
const UINT8 m68ki_shift_8_table[65] =
{
	0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xff, 0xff, 0xff,
	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
	0xff, 0xff, 0xff, 0xff, 0xff
};
const UINT16 m68ki_shift_16_table[65] =
{
	0x0000, 0x8000, 0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00,
	0xff80, 0xffc0, 0xffe0, 0xfff0, 0xfff8, 0xfffc, 0xfffe, 0xffff, 0xffff,
	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
	0xffff, 0xffff
};
const UINT32 m68ki_shift_32_table[65] =
{
	0x00000000, 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 0xf8000000,
	0xfc000000, 0xfe000000, 0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
	0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, 0xffff8000,
	0xffffc000, 0xffffe000, 0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,
	0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, 0xfffffff8,
	0xfffffffc, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
};


/* Number of clock cycles to use for exception processing.
 * I used 4 for any vectors that are undocumented for processing times.
 */
const UINT8 m68ki_exception_cycle_table[4][256] =
{
	{ /* 000 */
		  4, /*  0: Reset - Initial Stack Pointer                      */
		  4, /*  1: Reset - Initial Program Counter                    */
		 50, /*  2: Bus Error                             (unemulated) */
		 50, /*  3: Address Error                         (unemulated) */
		 34, /*  4: Illegal Instruction                                */
		 38, /*  5: Divide by Zero -- ASG: changed from 42             */
		 40, /*  6: CHK -- ASG: chanaged from 44                       */
		 34, /*  7: TRAPV                                              */
		 34, /*  8: Privilege Violation                                */
		 34, /*  9: Trace                                              */
		  4, /* 10: 1010                                               */
		  4, /* 11: 1111                                               */
		  4, /* 12: RESERVED                                           */
		  4, /* 13: Coprocessor Protocol Violation        (unemulated) */
		  4, /* 14: Format Error                                       */
		 44, /* 15: Uninitialized Interrupt                            */
		  4, /* 16: RESERVED                                           */
		  4, /* 17: RESERVED                                           */
		  4, /* 18: RESERVED                                           */
		  4, /* 19: RESERVED                                           */
		  4, /* 20: RESERVED                                           */
		  4, /* 21: RESERVED                                           */
		  4, /* 22: RESERVED                                           */
		  4, /* 23: RESERVED                                           */
		 44, /* 24: Spurious Interrupt                                 */
		 44, /* 25: Level 1 Interrupt Autovector                       */
		 44, /* 26: Level 2 Interrupt Autovector                       */
		 44, /* 27: Level 3 Interrupt Autovector                       */
		 44, /* 28: Level 4 Interrupt Autovector                       */
		 44, /* 29: Level 5 Interrupt Autovector                       */
		 44, /* 30: Level 6 Interrupt Autovector                       */
		 44, /* 31: Level 7 Interrupt Autovector                       */
		 34, /* 32: TRAP #0 -- ASG: chanaged from 38                   */
		 34, /* 33: TRAP #1                                            */
		 34, /* 34: TRAP #2                                            */
		 34, /* 35: TRAP #3                                            */
		 34, /* 36: TRAP #4                                            */
		 34, /* 37: TRAP #5                                            */
		 34, /* 38: TRAP #6                                            */
		 34, /* 39: TRAP #7                                            */
		 34, /* 40: TRAP #8                                            */
		 34, /* 41: TRAP #9                                            */
		 34, /* 42: TRAP #10                                           */
		 34, /* 43: TRAP #11                                           */
		 34, /* 44: TRAP #12                                           */
		 34, /* 45: TRAP #13                                           */
		 34, /* 46: TRAP #14                                           */
		 34, /* 47: TRAP #15                                           */
		  4, /* 48: FP Branch or Set on Unknown Condition (unemulated) */
		  4, /* 49: FP Inexact Result                     (unemulated) */
		  4, /* 50: FP Divide by Zero                     (unemulated) */
		  4, /* 51: FP Underflow                          (unemulated) */
		  4, /* 52: FP Operand Error                      (unemulated) */
		  4, /* 53: FP Overflow                           (unemulated) */
		  4, /* 54: FP Signaling NAN                      (unemulated) */
		  4, /* 55: FP Unimplemented Data Type            (unemulated) */
		  4, /* 56: MMU Configuration Error               (unemulated) */
		  4, /* 57: MMU Illegal Operation Error           (unemulated) */
		  4, /* 58: MMU Access Level Violation Error      (unemulated) */
		  4, /* 59: RESERVED                                           */
		  4, /* 60: RESERVED                                           */
		  4, /* 61: RESERVED                                           */
		  4, /* 62: RESERVED                                           */
		  4, /* 63: RESERVED                                           */
		     /* 64-255: User Defined                                   */
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4
	},
	{ /* 010 */
		  4, /*  0: Reset - Initial Stack Pointer                      */
		  4, /*  1: Reset - Initial Program Counter                    */
		126, /*  2: Bus Error                             (unemulated) */
		126, /*  3: Address Error                         (unemulated) */
		 38, /*  4: Illegal Instruction                                */
		 44, /*  5: Divide by Zero                                     */
		 44, /*  6: CHK                                                */
		 34, /*  7: TRAPV                                              */
		 38, /*  8: Privilege Violation                                */
		 38, /*  9: Trace                                              */
		  4, /* 10: 1010                                               */
		  4, /* 11: 1111                                               */
		  4, /* 12: RESERVED                                           */
		  4, /* 13: Coprocessor Protocol Violation        (unemulated) */
		  4, /* 14: Format Error                                       */
		 44, /* 15: Uninitialized Interrupt                            */
		  4, /* 16: RESERVED                                           */
		  4, /* 17: RESERVED                                           */
		  4, /* 18: RESERVED                                           */
		  4, /* 19: RESERVED                                           */
		  4, /* 20: RESERVED                                           */
		  4, /* 21: RESERVED                                           */
		  4, /* 22: RESERVED                                           */
		  4, /* 23: RESERVED                                           */
		 46, /* 24: Spurious Interrupt                                 */
		 46, /* 25: Level 1 Interrupt Autovector                       */
		 46, /* 26: Level 2 Interrupt Autovector                       */
		 46, /* 27: Level 3 Interrupt Autovector                       */
		 46, /* 28: Level 4 Interrupt Autovector                       */
		 46, /* 29: Level 5 Interrupt Autovector                       */
		 46, /* 30: Level 6 Interrupt Autovector                       */
		 46, /* 31: Level 7 Interrupt Autovector                       */
		 38, /* 32: TRAP #0                                            */
		 38, /* 33: TRAP #1                                            */
		 38, /* 34: TRAP #2                                            */
		 38, /* 35: TRAP #3                                            */
		 38, /* 36: TRAP #4                                            */
		 38, /* 37: TRAP #5                                            */
		 38, /* 38: TRAP #6                                            */
		 38, /* 39: TRAP #7                                            */
		 38, /* 40: TRAP #8                                            */
		 38, /* 41: TRAP #9                                            */
		 38, /* 42: TRAP #10                                           */
		 38, /* 43: TRAP #11                                           */
		 38, /* 44: TRAP #12                                           */
		 38, /* 45: TRAP #13                                           */
		 38, /* 46: TRAP #14                                           */
		 38, /* 47: TRAP #15                                           */
		  4, /* 48: FP Branch or Set on Unknown Condition (unemulated) */
		  4, /* 49: FP Inexact Result                     (unemulated) */
		  4, /* 50: FP Divide by Zero                     (unemulated) */
		  4, /* 51: FP Underflow                          (unemulated) */
		  4, /* 52: FP Operand Error                      (unemulated) */
		  4, /* 53: FP Overflow                           (unemulated) */
		  4, /* 54: FP Signaling NAN                      (unemulated) */
		  4, /* 55: FP Unimplemented Data Type            (unemulated) */
		  4, /* 56: MMU Configuration Error               (unemulated) */
		  4, /* 57: MMU Illegal Operation Error           (unemulated) */
		  4, /* 58: MMU Access Level Violation Error      (unemulated) */
		  4, /* 59: RESERVED                                           */
		  4, /* 60: RESERVED                                           */
		  4, /* 61: RESERVED                                           */
		  4, /* 62: RESERVED                                           */
		  4, /* 63: RESERVED                                           */
		     /* 64-255: User Defined                                   */
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4
	},
	{ /* 020 */
		  4, /*  0: Reset - Initial Stack Pointer                      */
		  4, /*  1: Reset - Initial Program Counter                    */
		 50, /*  2: Bus Error                             (unemulated) */
		 50, /*  3: Address Error                         (unemulated) */
		 20, /*  4: Illegal Instruction                                */
		 38, /*  5: Divide by Zero                                     */
		 40, /*  6: CHK                                                */
		 20, /*  7: TRAPV                                              */
		 34, /*  8: Privilege Violation                                */
		 25, /*  9: Trace                                              */
		 20, /* 10: 1010                                               */
		 20, /* 11: 1111                                               */
		  4, /* 12: RESERVED                                           */
		  4, /* 13: Coprocessor Protocol Violation        (unemulated) */
		  4, /* 14: Format Error                                       */
		 30, /* 15: Uninitialized Interrupt                            */
		  4, /* 16: RESERVED                                           */
		  4, /* 17: RESERVED                                           */
		  4, /* 18: RESERVED                                           */
		  4, /* 19: RESERVED                                           */
		  4, /* 20: RESERVED                                           */
		  4, /* 21: RESERVED                                           */
		  4, /* 22: RESERVED                                           */
		  4, /* 23: RESERVED                                           */
		 30, /* 24: Spurious Interrupt                                 */
		 30, /* 25: Level 1 Interrupt Autovector                       */
		 30, /* 26: Level 2 Interrupt Autovector                       */
		 30, /* 27: Level 3 Interrupt Autovector                       */
		 30, /* 28: Level 4 Interrupt Autovector                       */
		 30, /* 29: Level 5 Interrupt Autovector                       */
		 30, /* 30: Level 6 Interrupt Autovector                       */
		 30, /* 31: Level 7 Interrupt Autovector                       */
		 20, /* 32: TRAP #0                                            */
		 20, /* 33: TRAP #1                                            */
		 20, /* 34: TRAP #2                                            */
		 20, /* 35: TRAP #3                                            */
		 20, /* 36: TRAP #4                                            */
		 20, /* 37: TRAP #5                                            */
		 20, /* 38: TRAP #6                                            */
		 20, /* 39: TRAP #7                                            */
		 20, /* 40: TRAP #8                                            */
		 20, /* 41: TRAP #9                                            */
		 20, /* 42: TRAP #10                                           */
		 20, /* 43: TRAP #11                                           */
		 20, /* 44: TRAP #12                                           */
		 20, /* 45: TRAP #13                                           */
		 20, /* 46: TRAP #14                                           */
		 20, /* 47: TRAP #15                                           */
		  4, /* 48: FP Branch or Set on Unknown Condition (unemulated) */
		  4, /* 49: FP Inexact Result                     (unemulated) */
		  4, /* 50: FP Divide by Zero                     (unemulated) */
		  4, /* 51: FP Underflow                          (unemulated) */
		  4, /* 52: FP Operand Error                      (unemulated) */
		  4, /* 53: FP Overflow                           (unemulated) */
		  4, /* 54: FP Signaling NAN                      (unemulated) */
		  4, /* 55: FP Unimplemented Data Type            (unemulated) */
		  4, /* 56: MMU Configuration Error               (unemulated) */
		  4, /* 57: MMU Illegal Operation Error           (unemulated) */
		  4, /* 58: MMU Access Level Violation Error      (unemulated) */
		  4, /* 59: RESERVED                                           */
		  4, /* 60: RESERVED                                           */
		  4, /* 61: RESERVED                                           */
		  4, /* 62: RESERVED                                           */
		  4, /* 63: RESERVED                                           */
		     /* 64-255: User Defined                                   */
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4
	},
	{ /* 040 */ // TODO: these values are not correct
		  4, /*  0: Reset - Initial Stack Pointer                      */
		  4, /*  1: Reset - Initial Program Counter                    */
		 50, /*  2: Bus Error                             (unemulated) */
		 50, /*  3: Address Error                         (unemulated) */
		 20, /*  4: Illegal Instruction                                */
		 38, /*  5: Divide by Zero                                     */
		 40, /*  6: CHK                                                */
		 20, /*  7: TRAPV                                              */
		 34, /*  8: Privilege Violation                                */
		 25, /*  9: Trace                                              */
		 20, /* 10: 1010                                               */
		 20, /* 11: 1111                                               */
		  4, /* 12: RESERVED                                           */
		  4, /* 13: Coprocessor Protocol Violation        (unemulated) */
		  4, /* 14: Format Error                                       */
		 30, /* 15: Uninitialized Interrupt                            */
		  4, /* 16: RESERVED                                           */
		  4, /* 17: RESERVED                                           */
		  4, /* 18: RESERVED                                           */
		  4, /* 19: RESERVED                                           */
		  4, /* 20: RESERVED                                           */
		  4, /* 21: RESERVED                                           */
		  4, /* 22: RESERVED                                           */
		  4, /* 23: RESERVED                                           */
		 30, /* 24: Spurious Interrupt                                 */
		 30, /* 25: Level 1 Interrupt Autovector                       */
		 30, /* 26: Level 2 Interrupt Autovector                       */
		 30, /* 27: Level 3 Interrupt Autovector                       */
		 30, /* 28: Level 4 Interrupt Autovector                       */
		 30, /* 29: Level 5 Interrupt Autovector                       */
		 30, /* 30: Level 6 Interrupt Autovector                       */
		 30, /* 31: Level 7 Interrupt Autovector                       */
		 20, /* 32: TRAP #0                                            */
		 20, /* 33: TRAP #1                                            */
		 20, /* 34: TRAP #2                                            */
		 20, /* 35: TRAP #3                                            */
		 20, /* 36: TRAP #4                                            */
		 20, /* 37: TRAP #5                                            */
		 20, /* 38: TRAP #6                                            */
		 20, /* 39: TRAP #7                                            */
		 20, /* 40: TRAP #8                                            */
		 20, /* 41: TRAP #9                                            */
		 20, /* 42: TRAP #10                                           */
		 20, /* 43: TRAP #11                                           */
		 20, /* 44: TRAP #12                                           */
		 20, /* 45: TRAP #13                                           */
		 20, /* 46: TRAP #14                                           */
		 20, /* 47: TRAP #15                                           */
		  4, /* 48: FP Branch or Set on Unknown Condition (unemulated) */
		  4, /* 49: FP Inexact Result                     (unemulated) */
		  4, /* 50: FP Divide by Zero                     (unemulated) */
		  4, /* 51: FP Underflow                          (unemulated) */
		  4, /* 52: FP Operand Error                      (unemulated) */
		  4, /* 53: FP Overflow                           (unemulated) */
		  4, /* 54: FP Signaling NAN                      (unemulated) */
		  4, /* 55: FP Unimplemented Data Type            (unemulated) */
		  4, /* 56: MMU Configuration Error               (unemulated) */
		  4, /* 57: MMU Illegal Operation Error           (unemulated) */
		  4, /* 58: MMU Access Level Violation Error      (unemulated) */
		  4, /* 59: RESERVED                                           */
		  4, /* 60: RESERVED                                           */
		  4, /* 61: RESERVED                                           */
		  4, /* 62: RESERVED                                           */
		  4, /* 63: RESERVED                                           */
		     /* 64-255: User Defined                                   */
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
		  4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4
	}
};

const UINT8 m68ki_ea_idx_cycle_table[64] =
{
	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	 0, /* ..01.000 no memory indirect, base NULL             */
	 5, /* ..01..01 memory indirect,    base NULL, outer NULL */
	 7, /* ..01..10 memory indirect,    base NULL, outer 16   */
	 7, /* ..01..11 memory indirect,    base NULL, outer 32   */
	 0,  5,  7,  7,  0,  5,  7,  7,  0,  5,  7,  7,
	 2, /* ..10.000 no memory indirect, base 16               */
	 7, /* ..10..01 memory indirect,    base 16,   outer NULL */
	 9, /* ..10..10 memory indirect,    base 16,   outer 16   */
	 9, /* ..10..11 memory indirect,    base 16,   outer 32   */
	 0,  7,  9,  9,  0,  7,  9,  9,  0,  7,  9,  9,
	 6, /* ..11.000 no memory indirect, base 32               */
	11, /* ..11..01 memory indirect,    base 32,   outer NULL */
	13, /* ..11..10 memory indirect,    base 32,   outer 16   */
	13, /* ..11..11 memory indirect,    base 32,   outer 32   */
	 0, 11, 13, 13,  0, 11, 13, 13,  0, 11, 13, 13
};



/* ======================================================================== */
/* =============================== CALLBACKS ============================== */
/* ======================================================================== */

/* Default callbacks used if the callback hasn't been set yet, or if the
 * callback is set to NULL
 */

/* Interrupt acknowledge */
static int default_int_ack_callback_data;
static int default_int_ack_callback(void *param, int int_level)
{
	m68ki_cpu_core *m68k = param;
	default_int_ack_callback_data = int_level;
	m68k->int_level = 0;
	return M68K_INT_ACK_AUTOVECTOR;
}

/* Breakpoint acknowledge */
static void default_bkpt_ack_callback(unsigned int data)
{
}

/* Called when a reset instruction is executed */
static void default_reset_instr_callback(void)
{
}

/* Called when a cmpi.l #v, dn instruction is executed */
static void default_cmpild_instr_callback(unsigned int val, int reg)
{
}

/* Called when a rte instruction is executed */
static void default_rte_instr_callback(void)
{
}

/* Called when a tas instruction is executed */
static int default_tas_instr_callback(void)
{
	return 1; // allow writeback
}

/* Called when the program counter changed by a large value */
static unsigned int default_pc_changed_callback_data;
static void default_pc_changed_callback(unsigned int new_pc)
{
	default_pc_changed_callback_data = new_pc;
}

/* Called every time there's bus activity (read/write to/from memory */
static unsigned int default_set_fc_callback_data;
static void default_set_fc_callback(unsigned int new_fc)
{
	default_set_fc_callback_data = new_fc;
}

/* Called every instruction cycle prior to execution */
static void default_instr_hook_callback(unsigned int pc)
{
}


/* ======================================================================== */
/* ================================= API ================================== */
/* ======================================================================== */

/* Access the internals of the CPU */
unsigned int m68k_get_reg(m68ki_cpu_core *m68k, m68k_register_t regnum)
{
	switch(regnum)
	{
		case M68K_REG_D0:	return m68k->dar[0];
		case M68K_REG_D1:	return m68k->dar[1];
		case M68K_REG_D2:	return m68k->dar[2];
		case M68K_REG_D3:	return m68k->dar[3];
		case M68K_REG_D4:	return m68k->dar[4];
		case M68K_REG_D5:	return m68k->dar[5];
		case M68K_REG_D6:	return m68k->dar[6];
		case M68K_REG_D7:	return m68k->dar[7];
		case M68K_REG_A0:	return m68k->dar[8];
		case M68K_REG_A1:	return m68k->dar[9];
		case M68K_REG_A2:	return m68k->dar[10];
		case M68K_REG_A3:	return m68k->dar[11];
		case M68K_REG_A4:	return m68k->dar[12];
		case M68K_REG_A5:	return m68k->dar[13];
		case M68K_REG_A6:	return m68k->dar[14];
		case M68K_REG_A7:	return m68k->dar[15];
		case M68K_REG_PC:	return MASK_OUT_ABOVE_32(m68k->pc);
		case M68K_REG_SR:	return	m68k->t1_flag						|
									m68k->t0_flag						|
									(m68k->s_flag << 11)					|
									(m68k->m_flag << 11)					|
									m68k->int_mask						|
									((m68k->x_flag & XFLAG_SET) >> 4)	|
									((m68k->n_flag & NFLAG_SET) >> 4)	|
									((!m68k->not_z_flag) << 2)			|
									((m68k->v_flag & VFLAG_SET) >> 6)	|
									((m68k->c_flag & CFLAG_SET) >> 8);
		case M68K_REG_SP:	return m68k->dar[15];
		case M68K_REG_USP:	return m68k->s_flag ? m68k->sp[0] : m68k->dar[15];
		case M68K_REG_ISP:	return m68k->s_flag && !m68k->m_flag ? m68k->dar[15] : m68k->sp[4];
		case M68K_REG_MSP:	return m68k->s_flag && m68k->m_flag ? m68k->dar[15] : m68k->sp[6];
		case M68K_REG_SFC:	return m68k->sfc;
		case M68K_REG_DFC:	return m68k->dfc;
		case M68K_REG_VBR:	return m68k->vbr;
		case M68K_REG_CACR:	return m68k->cacr;
		case M68K_REG_CAAR:	return m68k->caar;
		case M68K_REG_PREF_ADDR:	return m68k->pref_addr;
		case M68K_REG_PREF_DATA:	return m68k->pref_data;
		case M68K_REG_PPC:	return MASK_OUT_ABOVE_32(m68k->ppc);
		case M68K_REG_IR:	return m68k->ir;
		case M68K_REG_CPU_TYPE:
			switch(m68k->cpu_type)
			{
				case CPU_TYPE_000:		return (unsigned int)M68K_CPU_TYPE_68000;
				case CPU_TYPE_008:		return (unsigned int)M68K_CPU_TYPE_68008;
				case CPU_TYPE_010:		return (unsigned int)M68K_CPU_TYPE_68010;
				case CPU_TYPE_EC020:	return (unsigned int)M68K_CPU_TYPE_68EC020;
				case CPU_TYPE_020:		return (unsigned int)M68K_CPU_TYPE_68020;
				case CPU_TYPE_040:		return (unsigned int)M68K_CPU_TYPE_68040;
			}
			return M68K_CPU_TYPE_INVALID;
		default:			return 0;
	}
}

void m68k_set_reg(m68ki_cpu_core *m68k, m68k_register_t regnum, unsigned int value)
{
	switch(regnum)
	{
		case M68K_REG_D0:	REG_D[0] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_D1:	REG_D[1] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_D2:	REG_D[2] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_D3:	REG_D[3] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_D4:	REG_D[4] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_D5:	REG_D[5] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_D6:	REG_D[6] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_D7:	REG_D[7] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A0:	REG_A[0] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A1:	REG_A[1] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A2:	REG_A[2] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A3:	REG_A[3] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A4:	REG_A[4] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A5:	REG_A[5] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A6:	REG_A[6] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_A7:	REG_A[7] = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_PC:	m68ki_jump(m68k, MASK_OUT_ABOVE_32(value)); return;
		case M68K_REG_SR:	m68ki_set_sr(m68k, value); return;
		case M68K_REG_SP:	REG_SP = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_USP:	if(m68k->s_flag)
								REG_USP = MASK_OUT_ABOVE_32(value);
							else
								REG_SP = MASK_OUT_ABOVE_32(value);
							return;
		case M68K_REG_ISP:	if(m68k->s_flag && !m68k->m_flag)
								REG_SP = MASK_OUT_ABOVE_32(value);
							else
								REG_ISP = MASK_OUT_ABOVE_32(value);
							return;
		case M68K_REG_MSP:	if(m68k->s_flag && m68k->m_flag)
								REG_SP = MASK_OUT_ABOVE_32(value);
							else
								REG_MSP = MASK_OUT_ABOVE_32(value);
							return;
		case M68K_REG_VBR:	m68k->vbr = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_SFC:	m68k->sfc = value & 7; return;
		case M68K_REG_DFC:	m68k->dfc = value & 7; return;
		case M68K_REG_CACR:	m68k->cacr = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_CAAR:	m68k->caar = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_PPC:	REG_PPC = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_IR:	m68k->ir = MASK_OUT_ABOVE_16(value); return;
		case M68K_REG_PREF_ADDR:	m68k->pref_addr = MASK_OUT_ABOVE_32(value); return;
		case M68K_REG_CPU_TYPE: m68k_set_cpu_type(m68k, value); return;
		default:			return;
	}
}

/* Set the callbacks */
void m68k_set_int_ack_callback(m68ki_cpu_core *m68k, void *param, int  (*callback)(void *param, int int_level))
{
	m68k->int_ack_callback = callback ? callback : default_int_ack_callback;
	m68k->int_ack_param = callback ? param : m68k;
}

void m68k_set_bkpt_ack_callback(m68ki_cpu_core *m68k, void  (*callback)(unsigned int data))
{
	m68k->bkpt_ack_callback = callback ? callback : default_bkpt_ack_callback;
}

void m68k_set_reset_instr_callback(m68ki_cpu_core *m68k, void  (*callback)(void))
{
	m68k->reset_instr_callback = callback ? callback : default_reset_instr_callback;
}

void m68k_set_cmpild_instr_callback(m68ki_cpu_core *m68k, void  (*callback)(unsigned int, int))
{
	m68k->cmpild_instr_callback = callback ? callback : default_cmpild_instr_callback;
}

void m68k_set_rte_instr_callback(m68ki_cpu_core *m68k, void  (*callback)(void))
{
	m68k->rte_instr_callback = callback ? callback : default_rte_instr_callback;
}

void m68k_set_tas_instr_callback(m68ki_cpu_core *m68k, int  (*callback)(void))
{
	m68k->tas_instr_callback = callback ? callback : default_tas_instr_callback;
}

void m68k_set_pc_changed_callback(m68ki_cpu_core *m68k, void  (*callback)(unsigned int new_pc))
{
	m68k->pc_changed_callback = callback ? callback : default_pc_changed_callback;
}

void m68k_set_fc_callback(m68ki_cpu_core *m68k, void  (*callback)(unsigned int new_fc))
{
	m68k->set_fc_callback = callback ? callback : default_set_fc_callback;
}

void m68k_set_instr_hook_callback(m68ki_cpu_core *m68k, void  (*callback)(unsigned int pc))
{
	m68k->instr_hook_callback = callback ? callback : default_instr_hook_callback;
}

#include <stdio.h>
/* Set the CPU type. */
void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
{
	switch(cpu_type)
	{
		case M68K_CPU_TYPE_68000:
			m68k->cpu_type         = CPU_TYPE_000;
			m68k->address_mask = 0x00ffffff;
			m68k->sr_mask      = 0xa71f; /* T1 -- S  -- -- I2 I1 I0 -- -- -- X  N  Z  V  C  */
			m68k->cyc_instruction  = m68ki_cycles[0];
			m68k->cyc_exception    = m68ki_exception_cycle_table[0];
			m68k->cyc_bcc_notake_b = -2;
			m68k->cyc_bcc_notake_w = 2;
			m68k->cyc_dbcc_f_noexp = -2;
			m68k->cyc_dbcc_f_exp   = 2;
			m68k->cyc_scc_r_true   = 2;
			m68k->cyc_movem_w      = 2;
			m68k->cyc_movem_l      = 3;
			m68k->cyc_shift        = 1;
			m68k->cyc_reset        = 132;
			return;
		case M68K_CPU_TYPE_68008:
			m68k->cpu_type         = CPU_TYPE_008;
			m68k->address_mask = 0x003fffff;
			m68k->sr_mask      = 0xa71f; /* T1 -- S  -- -- I2 I1 I0 -- -- -- X  N  Z  V  C  */
			m68k->cyc_instruction  = m68ki_cycles[0];
			m68k->cyc_exception    = m68ki_exception_cycle_table[0];
			m68k->cyc_bcc_notake_b = -2;
			m68k->cyc_bcc_notake_w = 2;
			m68k->cyc_dbcc_f_noexp = -2;
			m68k->cyc_dbcc_f_exp   = 2;
			m68k->cyc_scc_r_true   = 2;
			m68k->cyc_movem_w      = 2;
			m68k->cyc_movem_l      = 3;
			m68k->cyc_shift        = 1;
			m68k->cyc_reset        = 132;
			return;
		case M68K_CPU_TYPE_68010:
			m68k->cpu_type         = CPU_TYPE_010;
			m68k->address_mask = 0x00ffffff;
			m68k->sr_mask      = 0xa71f; /* T1 -- S  -- -- I2 I1 I0 -- -- -- X  N  Z  V  C  */
			m68k->cyc_instruction  = m68ki_cycles[1];
			m68k->cyc_exception    = m68ki_exception_cycle_table[1];
			m68k->cyc_bcc_notake_b = -4;
			m68k->cyc_bcc_notake_w = 0;
			m68k->cyc_dbcc_f_noexp = 0;
			m68k->cyc_dbcc_f_exp   = 6;
			m68k->cyc_scc_r_true   = 0;
			m68k->cyc_movem_w      = 2;
			m68k->cyc_movem_l      = 3;
			m68k->cyc_shift        = 1;
			m68k->cyc_reset        = 130;
			return;
		case M68K_CPU_TYPE_68EC020:
			m68k->cpu_type         = CPU_TYPE_EC020;
			m68k->address_mask = 0x00ffffff;
			m68k->sr_mask      = 0xf71f; /* T1 T0 S  M  -- I2 I1 I0 -- -- -- X  N  Z  V  C  */
			m68k->cyc_instruction  = m68ki_cycles[2];
			m68k->cyc_exception    = m68ki_exception_cycle_table[2];
			m68k->cyc_bcc_notake_b = -2;
			m68k->cyc_bcc_notake_w = 0;
			m68k->cyc_dbcc_f_noexp = 0;
			m68k->cyc_dbcc_f_exp   = 4;
			m68k->cyc_scc_r_true   = 0;
			m68k->cyc_movem_w      = 2;
			m68k->cyc_movem_l      = 2;
			m68k->cyc_shift        = 0;
			m68k->cyc_reset        = 518;
			return;
		case M68K_CPU_TYPE_68020:
			m68k->cpu_type         = CPU_TYPE_020;
			m68k->address_mask = 0xffffffff;
			m68k->sr_mask      = 0xf71f; /* T1 T0 S  M  -- I2 I1 I0 -- -- -- X  N  Z  V  C  */
			m68k->cyc_instruction  = m68ki_cycles[2];
			m68k->cyc_exception    = m68ki_exception_cycle_table[2];
			m68k->cyc_bcc_notake_b = -2;
			m68k->cyc_bcc_notake_w = 0;
			m68k->cyc_dbcc_f_noexp = 0;
			m68k->cyc_dbcc_f_exp   = 4;
			m68k->cyc_scc_r_true   = 0;
			m68k->cyc_movem_w      = 2;
			m68k->cyc_movem_l      = 2;
			m68k->cyc_shift        = 0;
			m68k->cyc_reset        = 518;
			return;
		case M68K_CPU_TYPE_68040:		// TODO: these values are not correct
			m68k->cpu_type         = CPU_TYPE_040;
			m68k->address_mask = 0xffffffff;
			m68k->sr_mask      = 0xf71f; /* T1 T0 S  M  -- I2 I1 I0 -- -- -- X  N  Z  V  C  */
			m68k->cyc_instruction  = m68ki_cycles[2];
			m68k->cyc_exception    = m68ki_exception_cycle_table[2];
			m68k->cyc_bcc_notake_b = -2;
			m68k->cyc_bcc_notake_w = 0;
			m68k->cyc_dbcc_f_noexp = 0;
			m68k->cyc_dbcc_f_exp   = 4;
			m68k->cyc_scc_r_true   = 0;
			m68k->cyc_movem_w      = 2;
			m68k->cyc_movem_l      = 2;
			m68k->cyc_shift        = 0;
			m68k->cyc_reset        = 518;
			return;
	}
}

/* Execute some instructions until we use up num_cycles clock cycles */
/* ASG: removed per-instruction interrupt checks */
int m68k_execute(m68ki_cpu_core *m68k, int num_cycles)
{
	/* Set our pool of clock cycles available */
	SET_CYCLES(m68k, num_cycles);
	m68k->initial_cycles = num_cycles;

	/* See if interrupts came in */
	m68ki_check_interrupts(m68k);

	/* Make sure we're not stopped */
	if(!m68k->stopped)
	{
		/* Return point if we had an address error */
		m68ki_set_address_error_trap(m68k); /* auto-disable (see m68kcpu.h) */

		/* Main loop.  Keep going until we run out of clock cycles */
		do
		{
			/* Set tracing accodring to T1. (T0 is done inside instruction) */
			m68ki_trace_t1(); /* auto-disable (see m68kcpu.h) */

			/* Set the address space for reads */
			m68ki_use_data_space(m68k); /* auto-disable (see m68kcpu.h) */

			/* Call external hook to peek at CPU */
			debugger_instruction_hook(Machine, REG_PC);

			/* Record previous program counter */
			REG_PPC = REG_PC;

			/* Read an instruction and call its handler */
			m68k->ir = m68ki_read_imm_16(m68k);
			m68ki_instruction_jump_table[m68k->ir](m68k);
			USE_CYCLES(m68k, m68k->cyc_instruction[m68k->ir]);

			/* Trace m68k_exception, if necessary */
			m68ki_exception_if_trace(); /* auto-disable (see m68kcpu.h) */
		} while(GET_CYCLES(m68k) > 0);

		/* set previous PC to current PC for the next entry into the loop */
		REG_PPC = REG_PC;
	}
	else
		SET_CYCLES(m68k, 0);

	/* return how many clocks we used */
	return m68k->initial_cycles - GET_CYCLES(m68k);
}


int m68k_cycles_run(m68ki_cpu_core *m68k)
{
	return m68k->initial_cycles - GET_CYCLES(m68k);
}

int m68k_cycles_remaining(m68ki_cpu_core *m68k)
{
	return GET_CYCLES(m68k);
}

/* Change the timeslice */
void m68k_modify_timeslice(m68ki_cpu_core *m68k, int cycles)
{
	m68k->initial_cycles += cycles;
	ADD_CYCLES(m68k, cycles);
}


void m68k_end_timeslice(m68ki_cpu_core *m68k)
{
	m68k->initial_cycles = GET_CYCLES(m68k);
	SET_CYCLES(m68k, 0);
}


/* ASG: rewrote so that the int_level is a mask of the IPL0/IPL1/IPL2 bits */
/* KS: Modified so that IPL* bits match with mask positions in the SR
 *     and cleaned out remenants of the interrupt controller.
 */
void m68k_set_irq(m68ki_cpu_core *m68k, unsigned int int_level)
{
	UINT32 old_level = m68k->int_level;
	m68k->int_level = int_level << 8;

	/* A transition from < 7 to 7 always interrupts (NMI) */
	/* Note: Level 7 can also level trigger like a normal IRQ */
	if(old_level != 0x0700 && m68k->int_level == 0x0700)
		m68k->nmi_pending = TRUE;
}

void m68k_set_virq(m68ki_cpu_core *m68k, unsigned int level, unsigned int active)
{
	UINT32 state = m68k->virq_state;
	UINT32 blevel;

	if(active)
		state |= 1 << level;
	else
		state &= ~(1 << level);
	m68k->virq_state = state;

	for(blevel = 7; blevel > 0; blevel--)
		if(state & (1 << blevel))
			break;
	m68k_set_irq(m68k, blevel);
}

unsigned int m68k_get_virq(m68ki_cpu_core *m68k, unsigned int level)
{
	return (m68k->virq_state & (1 << level)) ? 1 : 0;
}

void m68k_init(m68ki_cpu_core *m68k)
{
	static UINT32 emulation_initialized = 0;
	
	/* The first call to this function initializes the opcode handler jump table */
	if(!emulation_initialized)
		{
		m68ki_build_opcode_table();
		emulation_initialized = 1;
	}

	m68k_set_int_ack_callback(m68k, NULL, NULL);
	m68k_set_bkpt_ack_callback(m68k, NULL);
	m68k_set_reset_instr_callback(m68k, NULL);
	m68k_set_cmpild_instr_callback(m68k, NULL);
	m68k_set_rte_instr_callback(m68k, NULL);
	m68k_set_tas_instr_callback(m68k, NULL);
	m68k_set_pc_changed_callback(m68k, NULL);
	m68k_set_fc_callback(m68k, NULL);
	m68k_set_instr_hook_callback(m68k, NULL);
}

/* Pulse the RESET line on the CPU */
void m68k_pulse_reset(m68ki_cpu_core *m68k)
{
	/* Clear all stop levels and eat up all remaining cycles */
	m68k->stopped = 0;
	SET_CYCLES(m68k, 0);

	m68k->run_mode = RUN_MODE_BERR_AERR_RESET;

	/* Turn off tracing */
	m68k->t1_flag = m68k->t0_flag = 0;
	m68ki_clear_trace();
	/* Interrupt mask to level 7 */
	m68k->int_mask = 0x0700;
	m68k->int_level = 0;
	m68k->virq_state = 0;
	/* Reset VBR */
	m68k->vbr = 0;
	/* Go to supervisor mode */
	m68ki_set_sm_flag(m68k, SFLAG_SET | MFLAG_CLEAR);

	/* Invalidate the prefetch queue */
	/* Set to arbitrary number since our first fetch is from 0 */
	m68k->pref_addr = 0x1000;

	/* Read the initial stack pointer and program counter */
	m68ki_jump(m68k, 0);
	REG_SP = m68ki_read_imm_32(m68k);
	REG_PC = m68ki_read_imm_32(m68k);
	m68ki_jump(m68k, REG_PC);

	m68k->run_mode = RUN_MODE_NORMAL;
}

/* Pulse the HALT line on the CPU */
void m68k_pulse_halt(m68ki_cpu_core *m68k)
{
	m68k->stopped |= STOP_LEVEL_HALT;
}


/* Get and set the current CPU context */
/* This is to allow for multiple CPUs */
unsigned int m68k_context_size()
{
	return sizeof(void *);
}



/* ======================================================================== */
/* ============================== MAME STUFF ============================== */
/* ======================================================================== */

#include "deprecat.h"

static struct {
	UINT16 sr;
	UINT8 stopped;
	UINT8 halted;
} m68k_substate;

static void m68k_prepare_substate(running_machine *machine, void *param)
{
	m68ki_cpu_core *m68k = param;
	m68k_substate.sr = m68ki_get_sr(m68k);
	m68k_substate.stopped = (m68k->stopped & STOP_LEVEL_STOP) != 0;
	m68k_substate.halted  = (m68k->stopped & STOP_LEVEL_HALT) != 0;
}

static void m68k_post_load(running_machine *machine, void *param)
{
	m68ki_cpu_core *m68k = param;
	m68ki_set_sr_noint_nosp(m68k, m68k_substate.sr);
	m68k->stopped = m68k_substate.stopped ? STOP_LEVEL_STOP : 0
		        | m68k_substate.halted  ? STOP_LEVEL_HALT : 0;
	m68ki_jump(m68k, REG_PC);
}

void m68k_state_register(m68ki_cpu_core *m68k, const char *type, int index)
{
	/* Note, D covers A because the dar array is common, REG_A=REG_D+8 */
	state_save_register_item_array(type, index, REG_D);
	state_save_register_item(type, index, REG_PPC);
	state_save_register_item(type, index, REG_PC);
	state_save_register_item(type, index, REG_USP);
	state_save_register_item(type, index, REG_ISP);
	state_save_register_item(type, index, REG_MSP);
	state_save_register_item(type, index, m68k->vbr);
	state_save_register_item(type, index, m68k->sfc);
	state_save_register_item(type, index, m68k->dfc);
	state_save_register_item(type, index, m68k->cacr);
	state_save_register_item(type, index, m68k->caar);
	state_save_register_item(type, index, m68k_substate.sr);
	state_save_register_item(type, index, m68k->int_level);
	state_save_register_item(type, index, m68k_substate.stopped);
	state_save_register_item(type, index, m68k_substate.halted);
	state_save_register_item(type, index, m68k->pref_addr);
	state_save_register_item(type, index, m68k->pref_data);
	state_save_register_presave(Machine, m68k_prepare_substate, m68k);
	state_save_register_postload(Machine, m68k_post_load, m68k);
}

/* ======================================================================== */
/* ============================== END OF FILE ============================= */
/* ======================================================================== */