Shamusworld >> Repos - virtualjaguar/blob - src/m68kcpu.h

   1 #include <stdio.h>
   2 /* ======================================================================== */
   3 /* ========================= LICENSING & COPYRIGHT ======================== */
   4 /* ======================================================================== */
   5 /*
   6  *                                  MUSASHI
   7  *                                Version 3.3
   8  *
   9  * A portable Motorola M680x0 processor emulation engine.
  10  * Copyright 1998-2001 Karl Stenerud.  All rights reserved.
  11  *
  12  * This code may be freely used for non-commercial purposes as long as this
  13  * copyright notice remains unaltered in the source code and any binary files
  14  * containing this code in compiled form.
  15  *
  16  * All other lisencing terms must be negotiated with the author
  17  * (Karl Stenerud).
  18  *
  19  * The latest version of this code can be obtained at:
  20  * http://kstenerud.cjb.net
  21  */
  22
  23
  24
  25
  26 #ifndef M68KCPU__HEADER
  27 #define M68KCPU__HEADER
  28
  29 #include "m68k.h"
  30 #include <limits.h>
  31
  32 #if M68K_EMULATE_ADDRESS_ERROR
  33 #include <setjmp.h>
  34 #endif /* M68K_EMULATE_ADDRESS_ERROR */
  35
  36 /* ======================================================================== */
  37 /* ==================== ARCHITECTURE-DEPENDANT DEFINES ==================== */
  38 /* ======================================================================== */
  39
  40 /* Check for > 32bit sizes */
  41 #if UINT_MAX > 0xffffffff
  42         #define M68K_INT_GT_32_BIT  1
  43 #endif
  44
  45 /* Data types used in this emulation core */
  46 #undef sint8
  47 #undef sint16
  48 #undef sint32
  49 #undef sint64
  50 #undef uint8
  51 #undef uint16
  52 #undef uint32
  53 #undef uint64
  54 #undef sint
  55 #undef uint
  56
  57 #define sint8  signed   char                    /* ASG: changed from char to signed char */
  58 #define sint16 signed   short
  59 #define sint32 signed   long
  60 #define uint8  unsigned char
  61 #define uint16 unsigned short
  62 #define uint32 unsigned long
  63
  64 /* signed and unsigned int must be at least 32 bits wide */
  65 #define sint   signed   int
  66 #define uint   unsigned int
  67
  68
  69 #if M68K_USE_64_BIT
  70 #define sint64 signed   long long
  71 #define uint64 unsigned long long
  72 #else
  73 #define sint64 sint32
  74 #define uint64 uint32
  75 #endif /* M68K_USE_64_BIT */
  76
  77
  78
  79 /* Allow for architectures that don't have 8-bit sizes */
  80 #if UCHAR_MAX == 0xff
  81         #define MAKE_INT_8(A) (sint8)(A)
  82 #else
  83         #undef  sint8
  84         #define sint8  signed   int
  85         #undef  uint8
  86         #define uint8  unsigned int
  87         INLINE sint MAKE_INT_8(uint value)
  88         {
  89                 return (value & 0x80) ? value | ~0xff : value & 0xff;
  90         }
  91 #endif /* UCHAR_MAX == 0xff */
  92
  93
  94 /* Allow for architectures that don't have 16-bit sizes */
  95 #if USHRT_MAX == 0xffff
  96         #define MAKE_INT_16(A) (sint16)(A)
  97 #else
  98         #undef  sint16
  99         #define sint16 signed   int
 100         #undef  uint16
 101         #define uint16 unsigned int
 102         INLINE sint MAKE_INT_16(uint value)
 103         {
 104                 return (value & 0x8000) ? value | ~0xffff : value & 0xffff;
 105         }
 106 #endif /* USHRT_MAX == 0xffff */
 107
 108
 109 /* Allow for architectures that don't have 32-bit sizes */
 110 #if ULONG_MAX == 0xffffffff
 111         #define MAKE_INT_32(A) (sint32)(A)
 112 #else
 113         #undef  sint32
 114         #define sint32  signed   int
 115         #undef  uint32
 116         #define uint32  unsigned int
 117         INLINE sint MAKE_INT_32(uint value)
 118         {
 119                 return (value & 0x80000000) ? value | ~0xffffffff : value & 0xffffffff;
 120         }
 121 #endif /* ULONG_MAX == 0xffffffff */
 122
 123
 124
 125
 126 /* ======================================================================== */
 127 /* ============================ GENERAL DEFINES =========================== */
 128 /* ======================================================================== */
 129
 130 /* Exception Vectors handled by emulation */
 131 #define EXCEPTION_BUS_ERROR                2 /* This one is not emulated! */
 132 #define EXCEPTION_ADDRESS_ERROR            3 /* This one is partially emulated (doesn't stack a proper frame yet) */
 133 #define EXCEPTION_ILLEGAL_INSTRUCTION      4
 134 #define EXCEPTION_ZERO_DIVIDE              5
 135 #define EXCEPTION_CHK                      6
 136 #define EXCEPTION_TRAPV                    7
 137 #define EXCEPTION_PRIVILEGE_VIOLATION      8
 138 #define EXCEPTION_TRACE                    9
 139 #define EXCEPTION_1010                    10
 140 #define EXCEPTION_1111                    11
 141 #define EXCEPTION_FORMAT_ERROR            14
 142 #define EXCEPTION_UNINITIALIZED_INTERRUPT 15
 143 #define EXCEPTION_SPURIOUS_INTERRUPT      24
 144 #define EXCEPTION_INTERRUPT_AUTOVECTOR    24
 145 #define EXCEPTION_TRAP_BASE               32
 146
 147 /* Function codes set by CPU during data/address bus activity */
 148 #define FUNCTION_CODE_USER_DATA          1
 149 #define FUNCTION_CODE_USER_PROGRAM       2
 150 #define FUNCTION_CODE_SUPERVISOR_DATA    5
 151 #define FUNCTION_CODE_SUPERVISOR_PROGRAM 6
 152 #define FUNCTION_CODE_CPU_SPACE          7
 153
 154 /* CPU types for deciding what to emulate */
 155 #define CPU_TYPE_000   1
 156 #define CPU_TYPE_010   2
 157 #define CPU_TYPE_EC020 4
 158 #define CPU_TYPE_020   8
 159
 160 /* Different ways to stop the CPU */
 161 #define STOP_LEVEL_STOP 1
 162 #define STOP_LEVEL_HALT 2
 163
 164 #ifndef NULL
 165 #define NULL ((void*)0)
 166 #endif
 167
 168 /* ======================================================================== */
 169 /* ================================ MACROS ================================ */
 170 /* ======================================================================== */
 171
 172
 173 /* ---------------------------- General Macros ---------------------------- */
 174
 175 /* Bit Isolation Macros */
 176 #define BIT_0(A)  ((A) & 0x00000001)
 177 #define BIT_1(A)  ((A) & 0x00000002)
 178 #define BIT_2(A)  ((A) & 0x00000004)
 179 #define BIT_3(A)  ((A) & 0x00000008)
 180 #define BIT_4(A)  ((A) & 0x00000010)
 181 #define BIT_5(A)  ((A) & 0x00000020)
 182 #define BIT_6(A)  ((A) & 0x00000040)
 183 #define BIT_7(A)  ((A) & 0x00000080)
 184 #define BIT_8(A)  ((A) & 0x00000100)
 185 #define BIT_9(A)  ((A) & 0x00000200)
 186 #define BIT_A(A)  ((A) & 0x00000400)
 187 #define BIT_B(A)  ((A) & 0x00000800)
 188 #define BIT_C(A)  ((A) & 0x00001000)
 189 #define BIT_D(A)  ((A) & 0x00002000)
 190 #define BIT_E(A)  ((A) & 0x00004000)
 191 #define BIT_F(A)  ((A) & 0x00008000)
 192 #define BIT_10(A) ((A) & 0x00010000)
 193 #define BIT_11(A) ((A) & 0x00020000)
 194 #define BIT_12(A) ((A) & 0x00040000)
 195 #define BIT_13(A) ((A) & 0x00080000)
 196 #define BIT_14(A) ((A) & 0x00100000)
 197 #define BIT_15(A) ((A) & 0x00200000)
 198 #define BIT_16(A) ((A) & 0x00400000)
 199 #define BIT_17(A) ((A) & 0x00800000)
 200 #define BIT_18(A) ((A) & 0x01000000)
 201 #define BIT_19(A) ((A) & 0x02000000)
 202 #define BIT_1A(A) ((A) & 0x04000000)
 203 #define BIT_1B(A) ((A) & 0x08000000)
 204 #define BIT_1C(A) ((A) & 0x10000000)
 205 #define BIT_1D(A) ((A) & 0x20000000)
 206 #define BIT_1E(A) ((A) & 0x40000000)
 207 #define BIT_1F(A) ((A) & 0x80000000)
 208
 209 /* Get the most significant bit for specific sizes */
 210 #define GET_MSB_8(A)  ((A) & 0x80)
 211 #define GET_MSB_9(A)  ((A) & 0x100)
 212 #define GET_MSB_16(A) ((A) & 0x8000)
 213 #define GET_MSB_17(A) ((A) & 0x10000)
 214 #define GET_MSB_32(A) ((A) & 0x80000000)
 215 #if M68K_USE_64_BIT
 216 #define GET_MSB_33(A) ((A) & 0x100000000)
 217 #endif /* M68K_USE_64_BIT */
 218
 219 /* Isolate nibbles */
 220 #define LOW_NIBBLE(A)  ((A) & 0x0f)
 221 #define HIGH_NIBBLE(A) ((A) & 0xf0)
 222
 223 /* These are used to isolate 8, 16, and 32 bit sizes */
 224 #define MASK_OUT_ABOVE_2(A)  ((A) & 3)
 225 #define MASK_OUT_ABOVE_8(A)  ((A) & 0xff)
 226 #define MASK_OUT_ABOVE_16(A) ((A) & 0xffff)
 227 #define MASK_OUT_BELOW_2(A)  ((A) & ~3)
 228 #define MASK_OUT_BELOW_8(A)  ((A) & ~0xff)
 229 #define MASK_OUT_BELOW_16(A) ((A) & ~0xffff)
 230
 231 /* No need to mask if we are 32 bit */
 232 #if M68K_INT_GT_32BIT || M68K_USE_64_BIT
 233         #define MASK_OUT_ABOVE_32(A) ((A) & 0xffffffff)
 234         #define MASK_OUT_BELOW_32(A) ((A) & ~0xffffffff)
 235 #else
 236         #define MASK_OUT_ABOVE_32(A) (A)
 237         #define MASK_OUT_BELOW_32(A) 0
 238 #endif /* M68K_INT_GT_32BIT || M68K_USE_64_BIT */
 239
 240 /* Simulate address lines of 68k family */
 241 #define ADDRESS_68K(A) ((A)&CPU_ADDRESS_MASK)
 242
 243
 244 /* Shift & Rotate Macros. */
 245 #define LSL(A, C) ((A) << (C))
 246 #define LSR(A, C) ((A) >> (C))
 247
 248 /* Some > 32-bit optimizations */
 249 #if M68K_INT_GT_32BIT
 250         /* Shift left and right */
 251         #define LSR_32(A, C) ((A) >> (C))
 252         #define LSL_32(A, C) ((A) << (C))
 253 #else
 254         /* We have to do this because the morons at ANSI decided that shifts
 255          * by >= data size are undefined.
 256          */
 257         #define LSR_32(A, C) ((C) < 32 ? (A) >> (C) : 0)
 258         #define LSL_32(A, C) ((C) < 32 ? (A) << (C) : 0)
 259 #endif /* M68K_INT_GT_32BIT */
 260
 261 #if M68K_USE_64_BIT
 262         #define LSL_32_64(A, C) ((A) << (C))
 263         #define LSR_32_64(A, C) ((A) >> (C))
 264         #define ROL_33_64(A, C) (LSL_32_64(A, C) | LSR_32_64(A, 33-(C)))
 265         #define ROR_33_64(A, C) (LSR_32_64(A, C) | LSL_32_64(A, 33-(C)))
 266 #endif /* M68K_USE_64_BIT */
 267
 268 #define ROL_8(A, C)      MASK_OUT_ABOVE_8(LSL(A, C) | LSR(A, 8-(C)))
 269 #define ROL_9(A, C)                      (LSL(A, C) | LSR(A, 9-(C)))
 270 #define ROL_16(A, C)    MASK_OUT_ABOVE_16(LSL(A, C) | LSR(A, 16-(C)))
 271 #define ROL_17(A, C)                     (LSL(A, C) | LSR(A, 17-(C)))
 272 #define ROL_32(A, C)    MASK_OUT_ABOVE_32(LSL_32(A, C) | LSR_32(A, 32-(C)))
 273 #define ROL_33(A, C)                     (LSL_32(A, C) | LSR_32(A, 33-(C)))
 274
 275 #define ROR_8(A, C)      MASK_OUT_ABOVE_8(LSR(A, C) | LSL(A, 8-(C)))
 276 #define ROR_9(A, C)                      (LSR(A, C) | LSL(A, 9-(C)))
 277 #define ROR_16(A, C)    MASK_OUT_ABOVE_16(LSR(A, C) | LSL(A, 16-(C)))
 278 #define ROR_17(A, C)                     (LSR(A, C) | LSL(A, 17-(C)))
 279 #define ROR_32(A, C)    MASK_OUT_ABOVE_32(LSR_32(A, C) | LSL_32(A, 32-(C)))
 280 #define ROR_33(A, C)                     (LSR_32(A, C) | LSL_32(A, 33-(C)))
 281
 282
 283
 284 /* ------------------------------ CPU Access ------------------------------ */
 285
 286 /* Access the CPU registers */
 287 #define CPU_TYPE         m68ki_cpu.cpu_type
 288
 289 #define REG_DA           m68ki_cpu.dar /* easy access to data and address regs */
 290 #define REG_D            m68ki_cpu.dar
 291 #define REG_A            (m68ki_cpu.dar+8)
 292 #define REG_PPC                  m68ki_cpu.ppc
 293 #define REG_PC           m68ki_cpu.pc
 294 #define REG_SP_BASE      m68ki_cpu.sp
 295 #define REG_USP          m68ki_cpu.sp[0]
 296 #define REG_ISP          m68ki_cpu.sp[4]
 297 #define REG_MSP          m68ki_cpu.sp[6]
 298 #define REG_SP           m68ki_cpu.dar[15]
 299 #define REG_VBR          m68ki_cpu.vbr
 300 #define REG_SFC          m68ki_cpu.sfc
 301 #define REG_DFC          m68ki_cpu.dfc
 302 #define REG_CACR         m68ki_cpu.cacr
 303 #define REG_CAAR         m68ki_cpu.caar
 304 #define REG_IR           m68ki_cpu.ir
 305
 306 #define FLAG_T1          m68ki_cpu.t1_flag
 307 #define FLAG_T0          m68ki_cpu.t0_flag
 308 #define FLAG_S           m68ki_cpu.s_flag
 309 #define FLAG_M           m68ki_cpu.m_flag
 310 #define FLAG_X           m68ki_cpu.x_flag
 311 #define FLAG_N           m68ki_cpu.n_flag
 312 #define FLAG_Z           m68ki_cpu.not_z_flag
 313 #define FLAG_V           m68ki_cpu.v_flag
 314 #define FLAG_C           m68ki_cpu.c_flag
 315 #define FLAG_INT_MASK    m68ki_cpu.int_mask
 316
 317 #define CPU_INT_LEVEL    m68ki_cpu.int_level /* ASG: changed from CPU_INTS_PENDING */
 318 #define CPU_INT_CYCLES   m68ki_cpu.int_cycles /* ASG */
 319 #define CPU_STOPPED      m68ki_cpu.stopped
 320 #define CPU_PREF_ADDR    m68ki_cpu.pref_addr
 321 #define CPU_PREF_DATA    m68ki_cpu.pref_data
 322 #define CPU_ADDRESS_MASK m68ki_cpu.address_mask
 323 #define CPU_SR_MASK      m68ki_cpu.sr_mask
 324
 325 #define CYC_INSTRUCTION  m68ki_cpu.cyc_instruction
 326 #define CYC_EXCEPTION    m68ki_cpu.cyc_exception
 327 #define CYC_BCC_NOTAKE_B m68ki_cpu.cyc_bcc_notake_b
 328 #define CYC_BCC_NOTAKE_W m68ki_cpu.cyc_bcc_notake_w
 329 #define CYC_DBCC_F_NOEXP m68ki_cpu.cyc_dbcc_f_noexp
 330 #define CYC_DBCC_F_EXP   m68ki_cpu.cyc_dbcc_f_exp
 331 #define CYC_SCC_R_FALSE  m68ki_cpu.cyc_scc_r_false
 332 #define CYC_MOVEM_W      m68ki_cpu.cyc_movem_w
 333 #define CYC_MOVEM_L      m68ki_cpu.cyc_movem_l
 334 #define CYC_SHIFT        m68ki_cpu.cyc_shift
 335 #define CYC_RESET        m68ki_cpu.cyc_reset
 336
 337
 338 #define CALLBACK_INT_ACK     m68ki_cpu.int_ack_callback
 339 #define CALLBACK_BKPT_ACK    m68ki_cpu.bkpt_ack_callback
 340 #define CALLBACK_RESET_INSTR m68ki_cpu.reset_instr_callback
 341 #define CALLBACK_PC_CHANGED  m68ki_cpu.pc_changed_callback
 342 #define CALLBACK_SET_FC      m68ki_cpu.set_fc_callback
 343 #define CALLBACK_INSTR_HOOK  m68ki_cpu.instr_hook_callback
 344
 345
 346
 347 /* ----------------------------- Configuration ---------------------------- */
 348
 349 /* These defines are dependant on the configuration defines in m68kconf.h */
 350
 351 /* Disable certain comparisons if we're not using all CPU types */
 352 #if M68K_EMULATE_020
 353         #define CPU_TYPE_IS_020_PLUS(A)    ((A) & CPU_TYPE_020)
 354         #define CPU_TYPE_IS_020_LESS(A)    1
 355 #else
 356         #define CPU_TYPE_IS_020_PLUS(A)    0
 357         #define CPU_TYPE_IS_020_LESS(A)    1
 358 #endif
 359
 360 #if M68K_EMULATE_EC020
 361         #define CPU_TYPE_IS_EC020_PLUS(A)  ((A) & (CPU_TYPE_EC020 | CPU_TYPE_020))
 362         #define CPU_TYPE_IS_EC020_LESS(A)  ((A) & (CPU_TYPE_000 | CPU_TYPE_010 | CPU_TYPE_EC020))
 363 #else
 364         #define CPU_TYPE_IS_EC020_PLUS(A)  CPU_TYPE_IS_020_PLUS(A)
 365         #define CPU_TYPE_IS_EC020_LESS(A)  CPU_TYPE_IS_020_LESS(A)
 366 #endif
 367
 368 #if M68K_EMULATE_010
 369         #define CPU_TYPE_IS_010(A)         ((A) == CPU_TYPE_010)
 370         #define CPU_TYPE_IS_010_PLUS(A)    ((A) & (CPU_TYPE_010 | CPU_TYPE_EC020 | CPU_TYPE_020))
 371         #define CPU_TYPE_IS_010_LESS(A)    ((A) & (CPU_TYPE_000 | CPU_TYPE_010))
 372 #else
 373         #define CPU_TYPE_IS_010(A)         0
 374         #define CPU_TYPE_IS_010_PLUS(A)    CPU_TYPE_IS_EC020_PLUS(A)
 375         #define CPU_TYPE_IS_010_LESS(A)    CPU_TYPE_IS_EC020_LESS(A)
 376 #endif
 377
 378 #if M68K_EMULATE_020 || M68K_EMULATE_EC020
 379         #define CPU_TYPE_IS_020_VARIANT(A) ((A) & (CPU_TYPE_EC020 | CPU_TYPE_020))
 380 #else
 381         #define CPU_TYPE_IS_020_VARIANT(A) 0
 382 #endif
 383
 384 #if M68K_EMULATE_020 || M68K_EMULATE_EC020 || M68K_EMULATE_010
 385         #define CPU_TYPE_IS_000(A)         ((A) == CPU_TYPE_000)
 386 #else
 387         #define CPU_TYPE_IS_000(A)         1
 388 #endif
 389
 390
 391 #if !M68K_SEPARATE_READS
 392 #define m68k_read_immediate_16(A) m68ki_read_program_16(A)
 393 #define m68k_read_immediate_32(A) m68ki_read_program_32(A)
 394
 395 #define m68k_read_pcrelative_8(A) m68ki_read_program_8(A)
 396 #define m68k_read_pcrelative_16(A) m68ki_read_program_16(A)
 397 #define m68k_read_pcrelative_32(A) m68ki_read_program_32(A)
 398 #endif /* M68K_SEPARATE_READS */
 399
 400
 401 /* Enable or disable callback functions */
 402 #if M68K_EMULATE_INT_ACK
 403         #if M68K_EMULATE_INT_ACK == OPT_SPECIFY_HANDLER
 404                 #define m68ki_int_ack(A) M68K_INT_ACK_CALLBACK(A)
 405         #else
 406                 #define m68ki_int_ack(A) CALLBACK_INT_ACK(A)
 407         #endif
 408 #else
 409         /* Default action is to used autovector mode, which is most common */
 410         #define m68ki_int_ack(A) M68K_INT_ACK_AUTOVECTOR
 411 #endif /* M68K_EMULATE_INT_ACK */
 412
 413 #if M68K_EMULATE_BKPT_ACK
 414         #if M68K_EMULATE_BKPT_ACK == OPT_SPECIFY_HANDLER
 415                 #define m68ki_bkpt_ack(A) M68K_BKPT_ACK_CALLBACK(A)
 416         #else
 417                 #define m68ki_bkpt_ack(A) CALLBACK_BKPT_ACK(A)
 418         #endif
 419 #else
 420         #define m68ki_bkpt_ack(A)
 421 #endif /* M68K_EMULATE_BKPT_ACK */
 422
 423 #if M68K_EMULATE_RESET
 424         #if M68K_EMULATE_RESET == OPT_SPECIFY_HANDLER
 425                 #define m68ki_output_reset() M68K_RESET_CALLBACK()
 426         #else
 427                 #define m68ki_output_reset() CALLBACK_RESET_INSTR()
 428         #endif
 429 #else
 430         #define m68ki_output_reset()
 431 #endif /* M68K_EMULATE_RESET */
 432
 433 #if M68K_INSTRUCTION_HOOK
 434         #if M68K_INSTRUCTION_HOOK == OPT_SPECIFY_HANDLER
 435                 #define m68ki_instr_hook() M68K_INSTRUCTION_CALLBACK()
 436         #else
 437                 #define m68ki_instr_hook() CALLBACK_INSTR_HOOK()
 438         #endif
 439 #else
 440         #define m68ki_instr_hook()
 441 #endif /* M68K_INSTRUCTION_HOOK */
 442
 443 #if M68K_MONITOR_PC
 444         #if M68K_MONITOR_PC == OPT_SPECIFY_HANDLER
 445                 #define m68ki_pc_changed(A) M68K_SET_PC_CALLBACK(ADDRESS_68K(A))
 446         #else
 447                 #define m68ki_pc_changed(A) CALLBACK_PC_CHANGED(ADDRESS_68K(A))
 448         #endif
 449 #else
 450         #define m68ki_pc_changed(A)
 451 #endif /* M68K_MONITOR_PC */
 452
 453
 454 /* Enable or disable function code emulation */
 455 #if M68K_EMULATE_FC
 456         #if M68K_EMULATE_FC == OPT_SPECIFY_HANDLER
 457                 #define m68ki_set_fc(A) M68K_SET_FC_CALLBACK(A)
 458         #else
 459                 #define m68ki_set_fc(A) CALLBACK_SET_FC(A)
 460         #endif
 461         #define m68ki_use_data_space() m68ki_address_space = FUNCTION_CODE_USER_DATA
 462         #define m68ki_use_program_space() m68ki_address_space = FUNCTION_CODE_USER_PROGRAM
 463         #define m68ki_get_address_space() m68ki_address_space
 464 #else
 465         #define m68ki_set_fc(A)
 466         #define m68ki_use_data_space()
 467         #define m68ki_use_program_space()
 468         #define m68ki_get_address_space() FUNCTION_CODE_USER_DATA
 469 #endif /* M68K_EMULATE_FC */
 470
 471
 472 /* Enable or disable trace emulation */
 473 #if M68K_EMULATE_TRACE
 474         /* Initiates trace checking before each instruction (t1) */
 475         #define m68ki_trace_t1() m68ki_tracing = FLAG_T1
 476         /* adds t0 to trace checking if we encounter change of flow */
 477         #define m68ki_trace_t0() m68ki_tracing |= FLAG_T0
 478         /* Clear all tracing */
 479         #define m68ki_clear_trace() m68ki_tracing = 0
 480         /* Cause a trace exception if we are tracing */
 481         #define m68ki_exception_if_trace() if(m68ki_tracing) m68ki_exception_trace()
 482 #else
 483         #define m68ki_trace_t1()
 484         #define m68ki_trace_t0()
 485         #define m68ki_clear_trace()
 486         #define m68ki_exception_if_trace()
 487 #endif /* M68K_EMULATE_TRACE */
 488
 489
 490
 491 /* Address error */
 492 #if M68K_EMULATE_ADDRESS_ERROR
 493         extern jmp_buf m68ki_address_error_trap;
 494         #define m68ki_set_address_error_trap() if(setjmp(m68ki_address_error_trap)) m68ki_exception_address_error();
 495         #define m68ki_check_address_error(A) if((A)&1) longjmp(m68ki_address_error_jump, 1);
 496 #else
 497         #define m68ki_set_address_error_trap()
 498         #define m68ki_check_address_error(A)
 499 #endif /* M68K_ADDRESS_ERROR */
 500
 501 /* Logging */
 502 #if M68K_LOG_ENABLE
 503         #include <stdio.h>
 504         extern FILE* M68K_LOG_FILEHANDLE
 505         extern char* m68ki_cpu_names[];
 506
 507         #define M68K_DO_LOG(A) if(M68K_LOG_FILEHANDLE) fprintf A
 508         #if M68K_LOG_1010_1111
 509                 #define M68K_DO_LOG_EMU(A) if(M68K_LOG_FILEHANDLE) fprintf A
 510         #else
 511                 #define M68K_DO_LOG_EMU(A)
 512         #endif
 513 #else
 514         #define M68K_DO_LOG(A)
 515         #define M68K_DO_LOG_EMU(A)
 516 #endif
 517
 518
 519
 520 /* -------------------------- EA / Operand Access ------------------------- */
 521
 522 /*
 523  * The general instruction format follows this pattern:
 524  * .... XXX. .... .YYY
 525  * where XXX is register X and YYY is register Y
 526  */
 527 /* Data Register Isolation */
 528 #define DX (REG_D[(REG_IR >> 9) & 7])
 529 #define DY (REG_D[REG_IR & 7])
 530 /* Address Register Isolation */
 531 #define AX (REG_A[(REG_IR >> 9) & 7])
 532 #define AY (REG_A[REG_IR & 7])
 533
 534
 535 /* Effective Address Calculations */
 536 #define EA_AY_AI_8()   AY                                    /* address register indirect */
 537 #define EA_AY_AI_16()  EA_AY_AI_8()
 538 #define EA_AY_AI_32()  EA_AY_AI_8()
 539 #define EA_AY_PI_8()   (AY++)                                /* postincrement (size = byte) */
 540 #define EA_AY_PI_16()  ((AY+=2)-2)                           /* postincrement (size = word) */
 541 #define EA_AY_PI_32()  ((AY+=4)-4)                           /* postincrement (size = long) */
 542 #define EA_AY_PD_8()   (--AY)                                /* predecrement (size = byte) */
 543 #define EA_AY_PD_16()  (AY-=2)                               /* predecrement (size = word) */
 544 #define EA_AY_PD_32()  (AY-=4)                               /* predecrement (size = long) */
 545 #define EA_AY_DI_8()   (AY+MAKE_INT_16(m68ki_read_imm_16())) /* displacement */
 546 #define EA_AY_DI_16()  EA_AY_DI_8()
 547 #define EA_AY_DI_32()  EA_AY_DI_8()
 548 #define EA_AY_IX_8()   m68ki_get_ea_ix(AY)                   /* indirect + index */
 549 #define EA_AY_IX_16()  EA_AY_IX_8()
 550 #define EA_AY_IX_32()  EA_AY_IX_8()
 551
 552 #define EA_AX_AI_8()   AX
 553 #define EA_AX_AI_16()  EA_AX_AI_8()
 554 #define EA_AX_AI_32()  EA_AX_AI_8()
 555 #define EA_AX_PI_8()   (AX++)
 556 #define EA_AX_PI_16()  ((AX+=2)-2)
 557 #define EA_AX_PI_32()  ((AX+=4)-4)
 558 #define EA_AX_PD_8()   (--AX)
 559 #define EA_AX_PD_16()  (AX-=2)
 560 #define EA_AX_PD_32()  (AX-=4)
 561 #define EA_AX_DI_8()   (AX+MAKE_INT_16(m68ki_read_imm_16()))
 562 #define EA_AX_DI_16()  EA_AX_DI_8()
 563 #define EA_AX_DI_32()  EA_AX_DI_8()
 564 #define EA_AX_IX_8()   m68ki_get_ea_ix(AX)
 565 #define EA_AX_IX_16()  EA_AX_IX_8()
 566 #define EA_AX_IX_32()  EA_AX_IX_8()
 567
 568 #define EA_A7_PI_8()   ((REG_A[7]+=2)-2)
 569 #define EA_A7_PD_8()   (REG_A[7]-=2)
 570
 571 #define EA_AW_8()      MAKE_INT_16(m68ki_read_imm_16())      /* absolute word */
 572 #define EA_AW_16()     EA_AW_8()
 573 #define EA_AW_32()     EA_AW_8()
 574 #define EA_AL_8()      m68ki_read_imm_32()                   /* absolute long */
 575 #define EA_AL_16()     EA_AL_8()
 576 #define EA_AL_32()     EA_AL_8()
 577 #define EA_PCDI_8()    m68ki_get_ea_pcdi()                   /* pc indirect + displacement */
 578 #define EA_PCDI_16()   EA_PCDI_8()
 579 #define EA_PCDI_32()   EA_PCDI_8()
 580 #define EA_PCIX_8()    m68ki_get_ea_pcix()                   /* pc indirect + index */
 581 #define EA_PCIX_16()   EA_PCIX_8()
 582 #define EA_PCIX_32()   EA_PCIX_8()
 583
 584
 585 #define OPER_I_8()     m68ki_read_imm_8()
 586 #define OPER_I_16()    m68ki_read_imm_16()
 587 #define OPER_I_32()    m68ki_read_imm_32()
 588
 589
 590
 591 /* --------------------------- Status Register ---------------------------- */
 592
 593 /* Flag Calculation Macros */
 594 #define CFLAG_8(A) (A)
 595 #define CFLAG_16(A) ((A)>>8)
 596
 597 #if M68K_INT_GT_32_BIT
 598         #define CFLAG_ADD_32(S, D, R) ((R)>>24)
 599         #define CFLAG_SUB_32(S, D, R) ((R)>>24)
 600 #else
 601         #define CFLAG_ADD_32(S, D, R) (((S & D) | (~R & (S | D)))>>23)
 602         #define CFLAG_SUB_32(S, D, R) (((S & R) | (~D & (S | R)))>>23)
 603 #endif /* M68K_INT_GT_32_BIT */
 604
 605 #define VFLAG_ADD_8(S, D, R) ((S^R) & (D^R))
 606 #define VFLAG_ADD_16(S, D, R) (((S^R) & (D^R))>>8)
 607 #define VFLAG_ADD_32(S, D, R) (((S^R) & (D^R))>>24)
 608
 609 #define VFLAG_SUB_8(S, D, R) ((S^D) & (R^D))
 610 #define VFLAG_SUB_16(S, D, R) (((S^D) & (R^D))>>8)
 611 #define VFLAG_SUB_32(S, D, R) (((S^D) & (R^D))>>24)
 612
 613 #define NFLAG_8(A) (A)
 614 #define NFLAG_16(A) ((A)>>8)
 615 #define NFLAG_32(A) ((A)>>24)
 616 #define NFLAG_64(A) ((A)>>56)
 617
 618 #define ZFLAG_8(A) MASK_OUT_ABOVE_8(A)
 619 #define ZFLAG_16(A) MASK_OUT_ABOVE_16(A)
 620 #define ZFLAG_32(A) MASK_OUT_ABOVE_32(A)
 621
 622
 623 /* Flag values */
 624 #define NFLAG_SET   0x80
 625 #define NFLAG_CLEAR 0
 626 #define CFLAG_SET   0x100
 627 #define CFLAG_CLEAR 0
 628 #define XFLAG_SET   0x100
 629 #define XFLAG_CLEAR 0
 630 #define VFLAG_SET   0x80
 631 #define VFLAG_CLEAR 0
 632 #define ZFLAG_SET   0
 633 #define ZFLAG_CLEAR 0xffffffff
 634
 635 #define SFLAG_SET   4
 636 #define SFLAG_CLEAR 0
 637 #define MFLAG_SET   2
 638 #define MFLAG_CLEAR 0
 639
 640 /* Turn flag values into 1 or 0 */
 641 #define XFLAG_AS_1() ((FLAG_X>>8)&1)
 642 #define NFLAG_AS_1() ((FLAG_N>>7)&1)
 643 #define VFLAG_AS_1() ((FLAG_V>>7)&1)
 644 #define ZFLAG_AS_1() (!FLAG_Z)
 645 #define CFLAG_AS_1() ((FLAG_C>>8)&1)
 646
 647
 648 /* Conditions */
 649 #define COND_CS() (FLAG_C&0x100)
 650 #define COND_CC() (!COND_CS())
 651 #define COND_VS() (FLAG_V&0x80)
 652 #define COND_VC() (!COND_VS())
 653 #define COND_NE() FLAG_Z
 654 #define COND_EQ() (!COND_NE())
 655 #define COND_MI() (FLAG_N&0x80)
 656 #define COND_PL() (!COND_MI())
 657 #define COND_LT() ((FLAG_N^FLAG_V)&0x80)
 658 #define COND_GE() (!COND_LT())
 659 #define COND_HI() (COND_CC() && COND_NE())
 660 #define COND_LS() (COND_CS() || COND_EQ())
 661 #define COND_GT() (COND_GE() && COND_NE())
 662 #define COND_LE() (COND_LT() || COND_EQ())
 663
 664 /* Reversed conditions */
 665 #define COND_NOT_CS() COND_CC()
 666 #define COND_NOT_CC() COND_CS()
 667 #define COND_NOT_VS() COND_VC()
 668 #define COND_NOT_VC() COND_VS()
 669 #define COND_NOT_NE() COND_EQ()
 670 #define COND_NOT_EQ() COND_NE()
 671 #define COND_NOT_MI() COND_PL()
 672 #define COND_NOT_PL() COND_MI()
 673 #define COND_NOT_LT() COND_GE()
 674 #define COND_NOT_GE() COND_LT()
 675 #define COND_NOT_HI() COND_LS()
 676 #define COND_NOT_LS() COND_HI()
 677 #define COND_NOT_GT() COND_LE()
 678 #define COND_NOT_LE() COND_GT()
 679
 680 /* Not real conditions, but here for convenience */
 681 #define COND_XS() (FLAG_X&0x100)
 682 #define COND_XC() (!COND_XS)
 683
 684
 685 /* Get the condition code register */
 686 #define m68ki_get_ccr() ((COND_XS() >> 4) | \
 687                                                  (COND_MI() >> 4) | \
 688                                                  (COND_EQ() << 2) | \
 689                                                  (COND_VS() >> 6) | \
 690                                                  (COND_CS() >> 8))
 691
 692 /* Get the status register */
 693 #define m68ki_get_sr() ( FLAG_T1              | \
 694                                                  FLAG_T0              | \
 695                                                 (FLAG_S        << 11) | \
 696                                                 (FLAG_M        << 11) | \
 697                                                  FLAG_INT_MASK        | \
 698                                                  m68ki_get_ccr())
 699
 700
 701
 702 /* ---------------------------- Cycle Counting ---------------------------- */
 703
 704 #define ADD_CYCLES(A)    m68ki_remaining_cycles += (A)
 705 #define USE_CYCLES(A)    m68ki_remaining_cycles -= (A)
 706 #define SET_CYCLES(A)    m68ki_remaining_cycles = A
 707 #define GET_CYCLES()     m68ki_remaining_cycles
 708 #define USE_ALL_CYCLES() m68ki_remaining_cycles = 0
 709
 710
 711
 712 /* ----------------------------- Read / Write ----------------------------- */
 713
 714 /* Read from the current address space */
 715 #define m68ki_read_8(A)  m68ki_read_8_fc (A, FLAG_S | m68ki_get_address_space())
 716 #define m68ki_read_16(A) m68ki_read_16_fc(A, FLAG_S | m68ki_get_address_space())
 717 #define m68ki_read_32(A) m68ki_read_32_fc(A, FLAG_S | m68ki_get_address_space())
 718
 719 /* Write to the current data space */
 720 #define m68ki_write_8(A, V)  m68ki_write_8_fc (A, FLAG_S | FUNCTION_CODE_USER_DATA, V)
 721 #define m68ki_write_16(A, V) m68ki_write_16_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA, V)
 722 #define m68ki_write_32(A, V) m68ki_write_32_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA, V)
 723
 724 /* map read immediate 8 to read immediate 16 */
 725 #define m68ki_read_imm_8() MASK_OUT_ABOVE_8(m68ki_read_imm_16())
 726
 727 /* Map PC-relative reads */
 728 #define m68ki_read_pcrel_8(A) m68k_read_pcrelative_8(A)
 729 #define m68ki_read_pcrel_16(A) m68k_read_pcrelative_16(A)
 730 #define m68ki_read_pcrel_32(A) m68k_read_pcrelative_32(A)
 731
 732 /* Read from the program space */
 733 #define m68ki_read_program_8(A)         m68ki_read_8_fc(A, FLAG_S | FUNCTION_CODE_USER_PROGRAM)
 734 #define m68ki_read_program_16(A)        m68ki_read_16_fc(A, FLAG_S | FUNCTION_CODE_USER_PROGRAM)
 735 #define m68ki_read_program_32(A)        m68ki_read_32_fc(A, FLAG_S | FUNCTION_CODE_USER_PROGRAM)
 736
 737 /* Read from the data space */
 738 #define m68ki_read_data_8(A)    m68ki_read_8_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA)
 739 #define m68ki_read_data_16(A)   m68ki_read_16_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA)
 740 #define m68ki_read_data_32(A)   m68ki_read_32_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA)
 741
 742
 743
 744 /* ======================================================================== */
 745 /* =============================== PROTOTYPES ============================= */
 746 /* ======================================================================== */
 747
 748 typedef struct
 749 {
 750         uint cpu_type;     /* CPU Type: 68000, 68010, 68EC020, or 68020 */
 751         uint dar[16];      /* Data and Address Registers */
 752         uint ppc;                  /* Previous program counter */
 753         uint pc;           /* Program Counter */
 754         uint sp[7];        /* User, Interrupt, and Master Stack Pointers */
 755         uint vbr;          /* Vector Base Register (m68010+) */
 756         uint sfc;          /* Source Function Code Register (m68010+) */
 757         uint dfc;          /* Destination Function Code Register (m68010+) */
 758         uint cacr;         /* Cache Control Register (m68020, unemulated) */
 759         uint caar;         /* Cache Address Register (m68020, unemulated) */
 760         uint ir;           /* Instruction Register */
 761         uint t1_flag;      /* Trace 1 */
 762         uint t0_flag;      /* Trace 0 */
 763         uint s_flag;       /* Supervisor */
 764         uint m_flag;       /* Master/Interrupt state */
 765         uint x_flag;       /* Extend */
 766         uint n_flag;       /* Negative */
 767         uint not_z_flag;   /* Zero, inverted for speedups */
 768         uint v_flag;       /* Overflow */
 769         uint c_flag;       /* Carry */
 770         uint int_mask;     /* I0-I2 */
 771         uint int_level;    /* State of interrupt pins IPL0-IPL2 -- ASG: changed from ints_pending */
 772         uint int_cycles;   /* ASG: extra cycles from generated interrupts */
 773         uint stopped;      /* Stopped state */
 774         uint pref_addr;    /* Last prefetch address */
 775         uint pref_data;    /* Data in the prefetch queue */
 776         uint address_mask; /* Available address pins */
 777         uint sr_mask;      /* Implemented status register bits */
 778
 779         /* Clocks required for instructions / exceptions */
 780         uint cyc_bcc_notake_b;
 781         uint cyc_bcc_notake_w;
 782         uint cyc_dbcc_f_noexp;
 783         uint cyc_dbcc_f_exp;
 784         uint cyc_scc_r_false;
 785         uint cyc_movem_w;
 786         uint cyc_movem_l;
 787         uint cyc_shift;
 788         uint cyc_reset;
 789         uint8* cyc_instruction;
 790         uint8* cyc_exception;
 791
 792         /* Callbacks to host */
 793         int  (*int_ack_callback)(int int_line);           /* Interrupt Acknowledge */
 794         void (*bkpt_ack_callback)(unsigned int data);     /* Breakpoint Acknowledge */
 795         void (*reset_instr_callback)(void);               /* Called when a RESET instruction is encountered */
 796         void (*pc_changed_callback)(unsigned int new_pc); /* Called when the PC changes by a large amount */
 797         void (*set_fc_callback)(unsigned int new_fc);     /* Called when the CPU function code changes */
 798         void (*instr_hook_callback)(void);                /* Called every instruction cycle prior to execution */
 799
 800 } m68ki_cpu_core;
 801
 802
 803 extern m68ki_cpu_core m68ki_cpu;
 804 extern sint           m68ki_remaining_cycles;
 805 extern uint           m68ki_tracing;
 806 extern uint8          m68ki_shift_8_table[];
 807 extern uint16         m68ki_shift_16_table[];
 808 extern uint           m68ki_shift_32_table[];
 809 extern uint8          m68ki_exception_cycle_table[][256];
 810 extern uint           m68ki_address_space;
 811 extern uint8          m68ki_ea_idx_cycle_table[];
 812
 813
 814 /* Read data immediately after the program counter */
 815 INLINE uint m68ki_read_imm_16(void);
 816 INLINE uint m68ki_read_imm_32(void);
 817
 818 /* Read data with specific function code */
 819 INLINE uint m68ki_read_8_fc  (uint address, uint fc);
 820 INLINE uint m68ki_read_16_fc (uint address, uint fc);
 821 INLINE uint m68ki_read_32_fc (uint address, uint fc);
 822
 823 /* Write data with specific function code */
 824 INLINE void m68ki_write_8_fc (uint address, uint fc, uint value);
 825 INLINE void m68ki_write_16_fc(uint address, uint fc, uint value);
 826 INLINE void m68ki_write_32_fc(uint address, uint fc, uint value);
 827
 828 /* Indexed and PC-relative ea fetching */
 829 INLINE uint m68ki_get_ea_pcdi(void);
 830 INLINE uint m68ki_get_ea_pcix(void);
 831 INLINE uint m68ki_get_ea_ix(uint An);
 832
 833 /* Operand fetching */
 834 INLINE uint OPER_AY_AI_8(void);
 835 INLINE uint OPER_AY_AI_16(void);
 836 INLINE uint OPER_AY_AI_32(void);
 837 INLINE uint OPER_AY_PI_8(void);
 838 INLINE uint OPER_AY_PI_16(void);
 839 INLINE uint OPER_AY_PI_32(void);
 840 INLINE uint OPER_AY_PD_8(void);
 841 INLINE uint OPER_AY_PD_16(void);
 842 INLINE uint OPER_AY_PD_32(void);
 843 INLINE uint OPER_AY_DI_8(void);
 844 INLINE uint OPER_AY_DI_16(void);
 845 INLINE uint OPER_AY_DI_32(void);
 846 INLINE uint OPER_AY_IX_8(void);
 847 INLINE uint OPER_AY_IX_16(void);
 848 INLINE uint OPER_AY_IX_32(void);
 849
 850 INLINE uint OPER_AX_AI_8(void);
 851 INLINE uint OPER_AX_AI_16(void);
 852 INLINE uint OPER_AX_AI_32(void);
 853 INLINE uint OPER_AX_PI_8(void);
 854 INLINE uint OPER_AX_PI_16(void);
 855 INLINE uint OPER_AX_PI_32(void);
 856 INLINE uint OPER_AX_PD_8(void);
 857 INLINE uint OPER_AX_PD_16(void);
 858 INLINE uint OPER_AX_PD_32(void);
 859 INLINE uint OPER_AX_DI_8(void);
 860 INLINE uint OPER_AX_DI_16(void);
 861 INLINE uint OPER_AX_DI_32(void);
 862 INLINE uint OPER_AX_IX_8(void);
 863 INLINE uint OPER_AX_IX_16(void);
 864 INLINE uint OPER_AX_IX_32(void);
 865
 866 INLINE uint OPER_A7_PI_8(void);
 867 INLINE uint OPER_A7_PD_8(void);
 868
 869 INLINE uint OPER_AW_8(void);
 870 INLINE uint OPER_AW_16(void);
 871 INLINE uint OPER_AW_32(void);
 872 INLINE uint OPER_AL_8(void);
 873 INLINE uint OPER_AL_16(void);
 874 INLINE uint OPER_AL_32(void);
 875 INLINE uint OPER_PCDI_8(void);
 876 INLINE uint OPER_PCDI_16(void);
 877 INLINE uint OPER_PCDI_32(void);
 878 INLINE uint OPER_PCIX_8(void);
 879 INLINE uint OPER_PCIX_16(void);
 880 INLINE uint OPER_PCIX_32(void);
 881
 882 /* Stack operations */
 883 INLINE void m68ki_push_16(uint value);
 884 INLINE void m68ki_push_32(uint value);
 885 INLINE uint m68ki_pull_16(void);
 886 INLINE uint m68ki_pull_32(void);
 887
 888 /* Program flow operations */
 889 INLINE void m68ki_jump(uint new_pc);
 890 INLINE void m68ki_jump_vector(uint vector);
 891 INLINE void m68ki_branch_8(uint offset);
 892 INLINE void m68ki_branch_16(uint offset);
 893 INLINE void m68ki_branch_32(uint offset);
 894
 895 /* Status register operations. */
 896 INLINE void m68ki_set_s_flag(uint value);            /* Only bit 2 of value should be set (i.e. 4 or 0) */
 897 INLINE void m68ki_set_sm_flag(uint value);           /* only bits 1 and 2 of value should be set */
 898 INLINE void m68ki_set_ccr(uint value);               /* set the condition code register */
 899 INLINE void m68ki_set_sr(uint value);                /* set the status register */
 900 INLINE void m68ki_set_sr_noint(uint value);          /* set the status register */
 901
 902 /* Exception processing */
 903 INLINE uint m68ki_init_exception(void);              /* Initial exception processing */
 904
 905 INLINE void m68ki_stack_frame_3word(uint pc, uint sr); /* Stack various frame types */
 906 INLINE void m68ki_stack_frame_buserr(uint pc, uint sr, uint address, uint write, uint instruction, uint fc);
 907
 908 INLINE void m68ki_stack_frame_0000(uint pc, uint sr, uint vector);
 909 INLINE void m68ki_stack_frame_0001(uint pc, uint sr, uint vector);
 910 INLINE void m68ki_stack_frame_0010(uint sr, uint vector);
 911 INLINE void m68ki_stack_frame_1000(uint pc, uint sr, uint vector);
 912 INLINE void m68ki_stack_frame_1010(uint sr, uint vector, uint pc);
 913 INLINE void m68ki_stack_frame_1011(uint sr, uint vector, uint pc);
 914
 915 INLINE void m68ki_exception_trap(uint vector);
 916 INLINE void m68ki_exception_trapN(uint vector);
 917 INLINE void m68ki_exception_trace(void);
 918 INLINE void m68ki_exception_privilege_violation(void);
 919 INLINE void m68ki_exception_1010(void);
 920 INLINE void m68ki_exception_1111(void);
 921 INLINE void m68ki_exception_illegal(void);
 922 INLINE void m68ki_exception_format_error(void);
 923 INLINE void m68ki_exception_address_error(void);
 924 INLINE void m68ki_exception_interrupt(uint int_level);
 925 INLINE void m68ki_check_interrupts(void);            /* ASG: check for interrupts */
 926
 927 /* quick disassembly (used for logging) */
 928 char* m68ki_disassemble_quick(unsigned int pc, unsigned int cpu_type);
 929
 930
 931 /* ======================================================================== */
 932 /* =========================== UTILITY FUNCTIONS ========================== */
 933 /* ======================================================================== */
 934
 935
 936 /* ---------------------------- Read Immediate ---------------------------- */
 937
 938 /* Handles all immediate reads, does address error check, function code setting,
 939  * and prefetching if they are enabled in m68kconf.h
 940  */
 941 INLINE uint m68ki_read_imm_16(void)
 942 {
 943         m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
 944         m68ki_check_address_error(REG_PC); /* auto-disable (see m68kcpu.h) */
 945 #if M68K_EMULATE_PREFETCH
 946         if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)
 947         {
 948                 CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);
 949                 CPU_PREF_DATA = m68k_read_immediate_32(ADDRESS_68K(CPU_PREF_ADDR));
 950         }
 951         REG_PC += 2;
 952         return MASK_OUT_ABOVE_16(CPU_PREF_DATA >> ((2-((REG_PC-2)&2))<<3));
 953 #else
 954         REG_PC += 2;
 955         return m68k_read_immediate_16(ADDRESS_68K(REG_PC-2));
 956 #endif /* M68K_EMULATE_PREFETCH */
 957 }
 958 INLINE uint m68ki_read_imm_32(void)
 959 {
 960 #if M68K_EMULATE_PREFETCH
 961         uint temp_val;
 962
 963         m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
 964         m68ki_check_address_error(REG_PC); /* auto-disable (see m68kcpu.h) */
 965         if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)
 966         {
 967                 CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);
 968                 CPU_PREF_DATA = m68k_read_immediate_32(ADDRESS_68K(CPU_PREF_ADDR));
 969         }
 970         temp_val = CPU_PREF_DATA;
 971         REG_PC += 2;
 972         if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)
 973         {
 974                 CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);
 975                 CPU_PREF_DATA = m68k_read_immediate_32(ADDRESS_68K(CPU_PREF_ADDR));
 976                 temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | (CPU_PREF_DATA >> 16));
 977         }
 978         REG_PC += 2;
 979
 980         return temp_val;
 981 #else
 982         m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
 983         m68ki_check_address_error(REG_PC); /* auto-disable (see m68kcpu.h) */
 984         REG_PC += 4;
 985         return m68k_read_immediate_32(ADDRESS_68K(REG_PC-4));
 986 #endif /* M68K_EMULATE_PREFETCH */
 987 }
 988
 989
 990
 991 /* ------------------------- Top level read/write ------------------------- */
 992
 993 /* Handles all memory accesses (except for immediate reads if they are
 994  * configured to use separate functions in m68kconf.h).
 995  * All memory accesses must go through these top level functions.
 996  * These functions will also check for address error and set the function
 997  * code if they are enabled in m68kconf.h.
 998  */
 999 INLINE uint m68ki_read_8_fc(uint address, uint fc)
1000 {
1001         m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
1002         return m68k_read_memory_8(ADDRESS_68K(address));
1003 }
1004 INLINE uint m68ki_read_16_fc(uint address, uint fc)
1005 {
1006         m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
1007         m68ki_check_address_error(address); /* auto-disable (see m68kcpu.h) */
1008         return m68k_read_memory_16(ADDRESS_68K(address));
1009 }
1010 INLINE uint m68ki_read_32_fc(uint address, uint fc)
1011 {
1012         m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
1013         m68ki_check_address_error(address); /* auto-disable (see m68kcpu.h) */
1014         return m68k_read_memory_32(ADDRESS_68K(address));
1015 }
1016
1017 INLINE void m68ki_write_8_fc(uint address, uint fc, uint value)
1018 {
1019         m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
1020         m68k_write_memory_8(ADDRESS_68K(address), value);
1021 }
1022 INLINE void m68ki_write_16_fc(uint address, uint fc, uint value)
1023 {
1024         m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
1025         m68ki_check_address_error(address); /* auto-disable (see m68kcpu.h) */
1026         m68k_write_memory_16(ADDRESS_68K(address), value);
1027 }
1028 INLINE void m68ki_write_32_fc(uint address, uint fc, uint value)
1029 {
1030         m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
1031         m68ki_check_address_error(address); /* auto-disable (see m68kcpu.h) */
1032         m68k_write_memory_32(ADDRESS_68K(address), value);
1033 }
1034
1035
1036
1037 /* --------------------- Effective Address Calculation -------------------- */
1038
1039 /* The program counter relative addressing modes cause operands to be
1040  * retrieved from program space, not data space.
1041  */
1042 INLINE uint m68ki_get_ea_pcdi(void)
1043 {
1044         uint old_pc = REG_PC;
1045         m68ki_use_program_space(); /* auto-disable */
1046         return old_pc + MAKE_INT_16(m68ki_read_imm_16());
1047 }
1048
1049
1050 INLINE uint m68ki_get_ea_pcix(void)
1051 {
1052         m68ki_use_program_space(); /* auto-disable */
1053         return m68ki_get_ea_ix(REG_PC);
1054 }
1055
1056 /* Indexed addressing modes are encoded as follows:
1057  *
1058  * Base instruction format:
1059  * F E D C B A 9 8 7 6 | 5 4 3 | 2 1 0
1060  * x x x x x x x x x x | 1 1 0 | BASE REGISTER      (An)
1061  *
1062  * Base instruction format for destination EA in move instructions:
1063  * F E D C | B A 9    | 8 7 6 | 5 4 3 2 1 0
1064  * x x x x | BASE REG | 1 1 0 | X X X X X X       (An)
1065  *
1066  * Brief extension format:
1067  *  F  |  E D C   |  B  |  A 9  | 8 | 7 6 5 4 3 2 1 0
1068  * D/A | REGISTER | W/L | SCALE | 0 |  DISPLACEMENT
1069  *
1070  * Full extension format:
1071  *  F     E D C      B     A 9    8   7    6    5 4       3   2 1 0
1072  * D/A | REGISTER | W/L | SCALE | 1 | BS | IS | BD SIZE | 0 | I/IS
1073  * BASE DISPLACEMENT (0, 16, 32 bit)                (bd)
1074  * OUTER DISPLACEMENT (0, 16, 32 bit)               (od)
1075  *
1076  * D/A:     0 = Dn, 1 = An                          (Xn)
1077  * W/L:     0 = W (sign extend), 1 = L              (.SIZE)
1078  * SCALE:   00=1, 01=2, 10=4, 11=8                  (*SCALE)
1079  * BS:      0=add base reg, 1=suppress base reg     (An suppressed)
1080  * IS:      0=add index, 1=suppress index           (Xn suppressed)
1081  * BD SIZE: 00=reserved, 01=NULL, 10=Word, 11=Long  (size of bd)
1082  *
1083  * IS I/IS Operation
1084  * 0  000  No Memory Indirect
1085  * 0  001  indir prex with null outer
1086  * 0  010  indir prex with word outer
1087  * 0  011  indir prex with long outer
1088  * 0  100  reserved
1089  * 0  101  indir postx with null outer
1090  * 0  110  indir postx with word outer
1091  * 0  111  indir postx with long outer
1092  * 1  000  no memory indirect
1093  * 1  001  mem indir with null outer
1094  * 1  010  mem indir with word outer
1095  * 1  011  mem indir with long outer
1096  * 1  100-111  reserved
1097  */
1098 INLINE uint m68ki_get_ea_ix(uint An)
1099 {
1100         /* An = base register */
1101         uint extension = m68ki_read_imm_16();
1102         uint Xn = 0;                        /* Index register */
1103         uint bd = 0;                        /* Base Displacement */
1104         uint od = 0;                        /* Outer Displacement */
1105
1106         if(CPU_TYPE_IS_010_LESS(CPU_TYPE))
1107         {
1108                 /* Calculate index */
1109                 Xn = REG_DA[extension>>12];     /* Xn */
1110                 if(!BIT_B(extension))           /* W/L */
1111                         Xn = MAKE_INT_16(Xn);
1112
1113                 /* Add base register and displacement and return */
1114                 return An + Xn + MAKE_INT_8(extension);
1115         }
1116
1117         /* Brief extension format */
1118         if(!BIT_8(extension))
1119         {
1120                 /* Calculate index */
1121                 Xn = REG_DA[extension>>12];     /* Xn */
1122                 if(!BIT_B(extension))           /* W/L */
1123                         Xn = MAKE_INT_16(Xn);
1124                 /* Add scale if proper CPU type */
1125                 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
1126                         Xn <<= (extension>>9) & 3;  /* SCALE */
1127
1128                 /* Add base register and displacement and return */
1129                 return An + Xn + MAKE_INT_8(extension);
1130         }
1131
1132         /* Full extension format */
1133
1134         USE_CYCLES(m68ki_ea_idx_cycle_table[extension&0x3f]);
1135
1136         /* Check if base register is present */
1137         if(BIT_7(extension))                /* BS */
1138                 An = 0;                         /* An */
1139
1140         /* Check if index is present */
1141         if(!BIT_6(extension))               /* IS */
1142         {
1143                 Xn = REG_DA[extension>>12];     /* Xn */
1144                 if(!BIT_B(extension))           /* W/L */
1145                         Xn = MAKE_INT_16(Xn);
1146                 Xn <<= (extension>>9) & 3;      /* SCALE */
1147         }
1148
1149         /* Check if base displacement is present */
1150         if(BIT_5(extension))                /* BD SIZE */
1151                 bd = BIT_4(extension) ? m68ki_read_imm_32() : MAKE_INT_16(m68ki_read_imm_16());
1152
1153         /* If no indirect action, we are done */
1154         if(!(extension&7))                  /* No Memory Indirect */
1155                 return An + bd + Xn;
1156
1157         /* Check if outer displacement is present */
1158         if(BIT_1(extension))                /* I/IS:  od */
1159                 od = BIT_0(extension) ? m68ki_read_imm_32() : MAKE_INT_16(m68ki_read_imm_16());
1160
1161         /* Postindex */
1162         if(BIT_2(extension))                /* I/IS:  0 = preindex, 1 = postindex */
1163                 return m68ki_read_32(An + bd) + Xn + od;
1164
1165         /* Preindex */
1166         return m68ki_read_32(An + bd + Xn) + od;
1167 }
1168
1169
1170 /* Fetch operands */
1171 INLINE uint OPER_AY_AI_8(void)  {uint ea = EA_AY_AI_8();  return m68ki_read_8(ea); }
1172 INLINE uint OPER_AY_AI_16(void) {uint ea = EA_AY_AI_16(); return m68ki_read_16(ea);}
1173 INLINE uint OPER_AY_AI_32(void) {uint ea = EA_AY_AI_32(); return m68ki_read_32(ea);}
1174 INLINE uint OPER_AY_PI_8(void)  {uint ea = EA_AY_PI_8();  return m68ki_read_8(ea); }
1175 INLINE uint OPER_AY_PI_16(void) {uint ea = EA_AY_PI_16(); return m68ki_read_16(ea);}
1176 INLINE uint OPER_AY_PI_32(void) {uint ea = EA_AY_PI_32(); return m68ki_read_32(ea);}
1177 INLINE uint OPER_AY_PD_8(void)  {uint ea = EA_AY_PD_8();  return m68ki_read_8(ea); }
1178 INLINE uint OPER_AY_PD_16(void) {uint ea = EA_AY_PD_16(); return m68ki_read_16(ea);}
1179 INLINE uint OPER_AY_PD_32(void) {uint ea = EA_AY_PD_32(); return m68ki_read_32(ea);}
1180 INLINE uint OPER_AY_DI_8(void)  {uint ea = EA_AY_DI_8();  return m68ki_read_8(ea); }
1181 INLINE uint OPER_AY_DI_16(void) {uint ea = EA_AY_DI_16(); return m68ki_read_16(ea);}
1182 INLINE uint OPER_AY_DI_32(void) {uint ea = EA_AY_DI_32(); return m68ki_read_32(ea);}
1183 INLINE uint OPER_AY_IX_8(void)  {uint ea = EA_AY_IX_8();  return m68ki_read_8(ea); }
1184 INLINE uint OPER_AY_IX_16(void) {uint ea = EA_AY_IX_16(); return m68ki_read_16(ea);}
1185 INLINE uint OPER_AY_IX_32(void) {uint ea = EA_AY_IX_32(); return m68ki_read_32(ea);}
1186
1187 INLINE uint OPER_AX_AI_8(void)  {uint ea = EA_AX_AI_8();  return m68ki_read_8(ea); }
1188 INLINE uint OPER_AX_AI_16(void) {uint ea = EA_AX_AI_16(); return m68ki_read_16(ea);}
1189 INLINE uint OPER_AX_AI_32(void) {uint ea = EA_AX_AI_32(); return m68ki_read_32(ea);}
1190 INLINE uint OPER_AX_PI_8(void)  {uint ea = EA_AX_PI_8();  return m68ki_read_8(ea); }
1191 INLINE uint OPER_AX_PI_16(void) {uint ea = EA_AX_PI_16(); return m68ki_read_16(ea);}
1192 INLINE uint OPER_AX_PI_32(void) {uint ea = EA_AX_PI_32(); return m68ki_read_32(ea);}
1193 INLINE uint OPER_AX_PD_8(void)  {uint ea = EA_AX_PD_8();  return m68ki_read_8(ea); }
1194 INLINE uint OPER_AX_PD_16(void) {uint ea = EA_AX_PD_16(); return m68ki_read_16(ea);}
1195 INLINE uint OPER_AX_PD_32(void) {uint ea = EA_AX_PD_32(); return m68ki_read_32(ea);}
1196 INLINE uint OPER_AX_DI_8(void)  {uint ea = EA_AX_DI_8();  return m68ki_read_8(ea); }
1197 INLINE uint OPER_AX_DI_16(void) {uint ea = EA_AX_DI_16(); return m68ki_read_16(ea);}
1198 INLINE uint OPER_AX_DI_32(void) {uint ea = EA_AX_DI_32(); return m68ki_read_32(ea);}
1199 INLINE uint OPER_AX_IX_8(void)  {uint ea = EA_AX_IX_8();  return m68ki_read_8(ea); }
1200 INLINE uint OPER_AX_IX_16(void) {uint ea = EA_AX_IX_16(); return m68ki_read_16(ea);}
1201 INLINE uint OPER_AX_IX_32(void) {uint ea = EA_AX_IX_32(); return m68ki_read_32(ea);}
1202
1203 INLINE uint OPER_A7_PI_8(void)  {uint ea = EA_A7_PI_8();  return m68ki_read_8(ea); }
1204 INLINE uint OPER_A7_PD_8(void)  {uint ea = EA_A7_PD_8();  return m68ki_read_8(ea); }
1205
1206 INLINE uint OPER_AW_8(void)     {uint ea = EA_AW_8();     return m68ki_read_8(ea); }
1207 INLINE uint OPER_AW_16(void)    {uint ea = EA_AW_16();    return m68ki_read_16(ea);}
1208 INLINE uint OPER_AW_32(void)    {uint ea = EA_AW_32();    return m68ki_read_32(ea);}
1209 INLINE uint OPER_AL_8(void)     {uint ea = EA_AL_8();     return m68ki_read_8(ea); }
1210 INLINE uint OPER_AL_16(void)    {uint ea = EA_AL_16();    return m68ki_read_16(ea);}
1211 INLINE uint OPER_AL_32(void)    {uint ea = EA_AL_32();    return m68ki_read_32(ea);}
1212 INLINE uint OPER_PCDI_8(void)   {uint ea = EA_PCDI_8();   return m68ki_read_pcrel_8(ea); }
1213 INLINE uint OPER_PCDI_16(void)  {uint ea = EA_PCDI_16();  return m68ki_read_pcrel_16(ea);}
1214 INLINE uint OPER_PCDI_32(void)  {uint ea = EA_PCDI_32();  return m68ki_read_pcrel_32(ea);}
1215 INLINE uint OPER_PCIX_8(void)   {uint ea = EA_PCIX_8();   return m68ki_read_pcrel_8(ea); }
1216 INLINE uint OPER_PCIX_16(void)  {uint ea = EA_PCIX_16();  return m68ki_read_pcrel_16(ea);}
1217 INLINE uint OPER_PCIX_32(void)  {uint ea = EA_PCIX_32();  return m68ki_read_pcrel_32(ea);}
1218
1219
1220
1221 /* ---------------------------- Stack Functions --------------------------- */
1222
1223 /* Push/pull data from the stack */
1224 INLINE void m68ki_push_16(uint value)
1225 {
1226         REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2);
1227         m68ki_write_16(REG_SP, value);
1228 }
1229
1230 INLINE void m68ki_push_32(uint value)
1231 {
1232         REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4);
1233         m68ki_write_32(REG_SP, value);
1234 }
1235
1236 INLINE uint m68ki_pull_16(void)
1237 {
1238         REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2);
1239         return m68ki_read_16(REG_SP-2);
1240 }
1241
1242 INLINE uint m68ki_pull_32(void)
1243 {
1244         REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4);
1245         return m68ki_read_32(REG_SP-4);
1246 }
1247
1248
1249 /* Increment/decrement the stack as if doing a push/pull but
1250  * don't do any memory access.
1251  */
1252 INLINE void m68ki_fake_push_16(void)
1253 {
1254         REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2);
1255 }
1256
1257 INLINE void m68ki_fake_push_32(void)
1258 {
1259         REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4);
1260 }
1261
1262 INLINE void m68ki_fake_pull_16(void)
1263 {
1264         REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2);
1265 }
1266
1267 INLINE void m68ki_fake_pull_32(void)
1268 {
1269         REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4);
1270 }
1271
1272
1273 /* ----------------------------- Program Flow ----------------------------- */
1274
1275 /* Jump to a new program location or vector.
1276  * These functions will also call the pc_changed callback if it was enabled
1277  * in m68kconf.h.
1278  */
1279 INLINE void m68ki_jump(uint new_pc)
1280 {
1281         REG_PC = new_pc;
1282         m68ki_pc_changed(REG_PC);
1283 }
1284
1285 INLINE void m68ki_jump_vector(uint vector)
1286 {
1287         REG_PC = (vector<<2) + REG_VBR;
1288         REG_PC = m68ki_read_data_32(REG_PC);
1289         m68ki_pc_changed(REG_PC);
1290 }
1291
1292
1293 /* Branch to a new memory location.
1294  * The 32-bit branch will call pc_changed if it was enabled in m68kconf.h.
1295  * So far I've found no problems with not calling pc_changed for 8 or 16
1296  * bit branches.
1297  */
1298 INLINE void m68ki_branch_8(uint offset)
1299 {
1300         REG_PC += MAKE_INT_8(offset);
1301 }
1302
1303 INLINE void m68ki_branch_16(uint offset)
1304 {
1305         REG_PC += MAKE_INT_16(offset);
1306 }
1307
1308 INLINE void m68ki_branch_32(uint offset)
1309 {
1310         REG_PC += offset;
1311         m68ki_pc_changed(REG_PC);
1312 }
1313
1314
1315
1316 /* ---------------------------- Status Register --------------------------- */
1317
1318 /* Set the S flag and change the active stack pointer.
1319  * Note that value MUST be 4 or 0.
1320  */
1321 INLINE void m68ki_set_s_flag(uint value)
1322 {
1323         /* Backup the old stack pointer */
1324         REG_SP_BASE[FLAG_S | ((FLAG_S>>1) & FLAG_M)] = REG_SP;
1325         /* Set the S flag */
1326         FLAG_S = value;
1327         /* Set the new stack pointer */
1328         REG_SP = REG_SP_BASE[FLAG_S | ((FLAG_S>>1) & FLAG_M)];
1329 }
1330
1331 /* Set the S and M flags and change the active stack pointer.
1332  * Note that value MUST be 0, 2, 4, or 6 (bit2 = S, bit1 = M).
1333  */
1334 INLINE void m68ki_set_sm_flag(uint value)
1335 {
1336         /* Backup the old stack pointer */
1337         REG_SP_BASE[FLAG_S | ((FLAG_S>>1) & FLAG_M)] = REG_SP;
1338         /* Set the S and M flags */
1339         FLAG_S = value & SFLAG_SET;
1340         FLAG_M = value & MFLAG_SET;
1341         /* Set the new stack pointer */
1342         REG_SP = REG_SP_BASE[FLAG_S | ((FLAG_S>>1) & FLAG_M)];
1343 }
1344
1345
1346 /* Set the condition code register */
1347 INLINE void m68ki_set_ccr(uint value)
1348 {
1349         FLAG_X = BIT_4(value)  << 4;
1350         FLAG_N = BIT_3(value)  << 4;
1351         FLAG_Z = !BIT_2(value);
1352         FLAG_V = BIT_1(value)  << 6;
1353         FLAG_C = BIT_0(value)  << 8;
1354 }
1355
1356 /* Set the status register but don't check for interrupts */
1357 INLINE void m68ki_set_sr_noint(uint value)
1358 {
1359         /* Mask out the "unimplemented" bits */
1360         value &= CPU_SR_MASK;
1361
1362         /* Now set the status register */
1363         FLAG_T1 = BIT_F(value);
1364         FLAG_T0 = BIT_E(value);
1365         FLAG_INT_MASK = value & 0x0700;
1366         m68ki_set_ccr(value);
1367         m68ki_set_sm_flag((value >> 11) & 6);
1368 }
1369
1370 /* Set the status register and check for interrupts */
1371 INLINE void m68ki_set_sr(uint value)
1372 {
1373         m68ki_set_sr_noint(value);
1374         m68ki_check_interrupts();
1375 }
1376
1377
1378 /* ------------------------- Exception Processing ------------------------- */
1379
1380 /* Initiate exception processing */
1381 INLINE uint m68ki_init_exception(void)
1382 {
1383         /* Save the old status register */
1384         uint sr = m68ki_get_sr();
1385
1386         /* Turn off trace flag, clear pending traces */
1387         FLAG_T1 = FLAG_T0 = 0;
1388         m68ki_clear_trace();
1389         /* Enter supervisor mode */
1390         m68ki_set_s_flag(SFLAG_SET);
1391
1392         return sr;
1393 }
1394
1395 /* 3 word stack frame (68000 only) */
1396 INLINE void m68ki_stack_frame_3word(uint pc, uint sr)
1397 {
1398         m68ki_push_32(pc);
1399         m68ki_push_16(sr);
1400 }
1401
1402 /* Format 0 stack frame.
1403  * This is the standard stack frame for 68010+.
1404  */
1405 INLINE void m68ki_stack_frame_0000(uint pc, uint sr, uint vector)
1406 {
1407         /* Stack a 3-word frame if we are 68000 */
1408         if(CPU_TYPE == CPU_TYPE_000)
1409         {
1410                 m68ki_stack_frame_3word(pc, sr);
1411                 return;
1412         }
1413         m68ki_push_16(vector<<2);
1414         m68ki_push_32(pc);
1415         m68ki_push_16(sr);
1416 }
1417
1418 /* Format 1 stack frame (68020).
1419  * For 68020, this is the 4 word throwaway frame.
1420  */
1421 INLINE void m68ki_stack_frame_0001(uint pc, uint sr, uint vector)
1422 {
1423         m68ki_push_16(0x1000 | (vector<<2));
1424         m68ki_push_32(pc);
1425         m68ki_push_16(sr);
1426 }
1427
1428 /* Format 2 stack frame.
1429  * This is used only by 68020 for trap exceptions.
1430  */
1431 INLINE void m68ki_stack_frame_0010(uint sr, uint vector)
1432 {
1433         m68ki_push_32(REG_PPC);
1434         m68ki_push_16(0x2000 | (vector<<2));
1435         m68ki_push_32(REG_PC);
1436         m68ki_push_16(sr);
1437 }
1438
1439
1440 /* Bus error stack frame (68000 only).
1441  */
1442 INLINE void m68ki_stack_frame_buserr(uint pc, uint sr, uint address, uint write, uint instruction, uint fc)
1443 {
1444         m68ki_push_32(pc);
1445         m68ki_push_16(sr);
1446         m68ki_push_16(REG_IR);
1447         m68ki_push_32(address); /* access address */
1448         /* 0 0 0 0 0 0 0 0 0 0 0 R/W I/N FC
1449          * R/W  0 = write, 1 = read
1450          * I/N  0 = instruction, 1 = not
1451          * FC   3-bit function code
1452          */
1453         m68ki_push_16(((!write)<<4) | ((!instruction)<<3) | fc);
1454 }
1455
1456 /* Format 8 stack frame (68010).
1457  * 68010 only.  This is the 29 word bus/address error frame.
1458  */
1459 void m68ki_stack_frame_1000(uint pc, uint sr, uint vector)
1460 {
1461         /* VERSION
1462          * NUMBER
1463          * INTERNAL INFORMATION, 16 WORDS
1464          */
1465         m68ki_fake_push_32();
1466         m68ki_fake_push_32();
1467         m68ki_fake_push_32();
1468         m68ki_fake_push_32();
1469         m68ki_fake_push_32();
1470         m68ki_fake_push_32();
1471         m68ki_fake_push_32();
1472         m68ki_fake_push_32();
1473
1474         /* INSTRUCTION INPUT BUFFER */
1475         m68ki_push_16(0);
1476
1477         /* UNUSED, RESERVED (not written) */
1478         m68ki_fake_push_16();
1479
1480         /* DATA INPUT BUFFER */
1481         m68ki_push_16(0);
1482
1483         /* UNUSED, RESERVED (not written) */
1484         m68ki_fake_push_16();
1485
1486         /* DATA OUTPUT BUFFER */
1487         m68ki_push_16(0);
1488
1489         /* UNUSED, RESERVED (not written) */
1490         m68ki_fake_push_16();
1491
1492         /* FAULT ADDRESS */
1493         m68ki_push_32(0);
1494
1495         /* SPECIAL STATUS WORD */
1496         m68ki_push_16(0);
1497
1498         /* 1000, VECTOR OFFSET */
1499         m68ki_push_16(0x8000 | (vector<<2));
1500
1501         /* PROGRAM COUNTER */
1502         m68ki_push_32(pc);
1503
1504         /* STATUS REGISTER */
1505         m68ki_push_16(sr);
1506 }
1507
1508 /* Format A stack frame (short bus fault).
1509  * This is used only by 68020 for bus fault and address error
1510  * if the error happens at an instruction boundary.
1511  * PC stacked is address of next instruction.
1512  */
1513 void m68ki_stack_frame_1010(uint sr, uint vector, uint pc)
1514 {
1515         /* INTERNAL REGISTER */
1516         m68ki_push_16(0);
1517
1518         /* INTERNAL REGISTER */
1519         m68ki_push_16(0);
1520
1521         /* DATA OUTPUT BUFFER (2 words) */
1522         m68ki_push_32(0);
1523
1524         /* INTERNAL REGISTER */
1525         m68ki_push_16(0);
1526
1527         /* INTERNAL REGISTER */
1528         m68ki_push_16(0);
1529
1530         /* DATA CYCLE FAULT ADDRESS (2 words) */
1531         m68ki_push_32(0);
1532
1533         /* INSTRUCTION PIPE STAGE B */
1534         m68ki_push_16(0);
1535
1536         /* INSTRUCTION PIPE STAGE C */
1537         m68ki_push_16(0);
1538
1539         /* SPECIAL STATUS REGISTER */
1540         m68ki_push_16(0);
1541
1542         /* INTERNAL REGISTER */
1543         m68ki_push_16(0);
1544
1545         /* 1010, VECTOR OFFSET */
1546         m68ki_push_16(0xa000 | (vector<<2));
1547
1548         /* PROGRAM COUNTER */
1549         m68ki_push_32(pc);
1550
1551         /* STATUS REGISTER */
1552         m68ki_push_16(sr);
1553 }
1554
1555 /* Format B stack frame (long bus fault).
1556  * This is used only by 68020 for bus fault and address error
1557  * if the error happens during instruction execution.
1558  * PC stacked is address of instruction in progress.
1559  */
1560 void m68ki_stack_frame_1011(uint sr, uint vector, uint pc)
1561 {
1562         /* INTERNAL REGISTERS (18 words) */
1563         m68ki_push_32(0);
1564         m68ki_push_32(0);
1565         m68ki_push_32(0);
1566         m68ki_push_32(0);
1567         m68ki_push_32(0);
1568         m68ki_push_32(0);
1569         m68ki_push_32(0);
1570         m68ki_push_32(0);
1571         m68ki_push_32(0);
1572
1573         /* VERSION# (4 bits), INTERNAL INFORMATION */
1574         m68ki_push_16(0);
1575
1576         /* INTERNAL REGISTERS (3 words) */
1577         m68ki_push_32(0);
1578         m68ki_push_16(0);
1579
1580         /* DATA INTPUT BUFFER (2 words) */
1581         m68ki_push_32(0);
1582
1583         /* INTERNAL REGISTERS (2 words) */
1584         m68ki_push_32(0);
1585
1586         /* STAGE B ADDRESS (2 words) */
1587         m68ki_push_32(0);
1588
1589         /* INTERNAL REGISTER (4 words) */
1590         m68ki_push_32(0);
1591         m68ki_push_32(0);
1592
1593         /* DATA OUTPUT BUFFER (2 words) */
1594         m68ki_push_32(0);
1595
1596         /* INTERNAL REGISTER */
1597         m68ki_push_16(0);
1598
1599         /* INTERNAL REGISTER */
1600         m68ki_push_16(0);
1601
1602         /* DATA CYCLE FAULT ADDRESS (2 words) */
1603         m68ki_push_32(0);
1604
1605         /* INSTRUCTION PIPE STAGE B */
1606         m68ki_push_16(0);
1607
1608         /* INSTRUCTION PIPE STAGE C */
1609         m68ki_push_16(0);
1610
1611         /* SPECIAL STATUS REGISTER */
1612         m68ki_push_16(0);
1613
1614         /* INTERNAL REGISTER */
1615         m68ki_push_16(0);
1616
1617         /* 1011, VECTOR OFFSET */
1618         m68ki_push_16(0xb000 | (vector<<2));
1619
1620         /* PROGRAM COUNTER */
1621         m68ki_push_32(pc);
1622
1623         /* STATUS REGISTER */
1624         m68ki_push_16(sr);
1625 }
1626
1627
1628 /* Used for Group 2 exceptions.
1629  * These stack a type 2 frame on the 020.
1630  */
1631 INLINE void m68ki_exception_trap(uint vector)
1632 {
1633         uint sr = m68ki_init_exception();
1634
1635         if(CPU_TYPE_IS_010_LESS(CPU_TYPE))
1636                 m68ki_stack_frame_0000(REG_PC, sr, vector);
1637         else
1638                 m68ki_stack_frame_0010(sr, vector);
1639
1640         m68ki_jump_vector(vector);
1641
1642         /* Use up some clock cycles */
1643         USE_CYCLES(CYC_EXCEPTION[vector]);
1644 }
1645
1646 /* Trap#n stacks a 0 frame but behaves like group2 otherwise */
1647 INLINE void m68ki_exception_trapN(uint vector)
1648 {
1649         uint sr = m68ki_init_exception();
1650         m68ki_stack_frame_0000(REG_PC, sr, vector);
1651         m68ki_jump_vector(vector);
1652
1653         /* Use up some clock cycles */
1654         USE_CYCLES(CYC_EXCEPTION[vector]);
1655 }
1656
1657 /* Exception for trace mode */
1658 INLINE void m68ki_exception_trace(void)
1659 {
1660         uint sr = m68ki_init_exception();
1661
1662         if(CPU_TYPE_IS_010_LESS(CPU_TYPE))
1663                 m68ki_stack_frame_0000(REG_PC, sr, EXCEPTION_TRACE);
1664         else
1665                 m68ki_stack_frame_0010(sr, EXCEPTION_TRACE);
1666
1667         m68ki_jump_vector(EXCEPTION_TRACE);
1668
1669         /* Trace nullifies a STOP instruction */
1670         CPU_STOPPED &= ~STOP_LEVEL_STOP;
1671
1672         /* Use up some clock cycles */
1673         USE_CYCLES(CYC_EXCEPTION[EXCEPTION_TRACE]);
1674 }
1675
1676 /* Exception for privilege violation */
1677 INLINE void m68ki_exception_privilege_violation(void)
1678 {
1679         uint sr = m68ki_init_exception();
1680         m68ki_stack_frame_0000(REG_PC, sr, EXCEPTION_PRIVILEGE_VIOLATION);
1681         m68ki_jump_vector(EXCEPTION_PRIVILEGE_VIOLATION);
1682
1683         /* Use up some clock cycles and undo the instruction's cycles */
1684         USE_CYCLES(CYC_EXCEPTION[EXCEPTION_PRIVILEGE_VIOLATION] - CYC_INSTRUCTION[REG_IR]);
1685 }
1686
1687 /* Exception for A-Line instructions */
1688 INLINE void m68ki_exception_1010(void)
1689 {
1690         uint sr;
1691 #if M68K_LOG_1010_1111 == OPT_ON
1692         M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: called 1010 instruction %04x (%s)\n",
1693                                          m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PPC), REG_IR,
1694                                          m68ki_disassemble_quick(ADDRESS_68K(REG_PPC))));
1695 #endif
1696
1697         sr = m68ki_init_exception();
1698         m68ki_stack_frame_0000(REG_PC-2, sr, EXCEPTION_1010);
1699         m68ki_jump_vector(EXCEPTION_1010);
1700
1701         /* Use up some clock cycles and undo the instruction's cycles */
1702         USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1010] - CYC_INSTRUCTION[REG_IR]);
1703 }
1704
1705 /* Exception for F-Line instructions */
1706 INLINE void m68ki_exception_1111(void)
1707 {
1708         uint sr;
1709
1710 #if M68K_LOG_1010_1111 == OPT_ON
1711         M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: called 1111 instruction %04x (%s)\n",
1712                                          m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PPC), REG_IR,
1713                                          m68ki_disassemble_quick(ADDRESS_68K(REG_PPC))));
1714 #endif
1715
1716         sr = m68ki_init_exception();
1717         m68ki_stack_frame_0000(REG_PC-2, sr, EXCEPTION_1111);
1718         m68ki_jump_vector(EXCEPTION_1111);
1719
1720         /* Use up some clock cycles and undo the instruction's cycles */
1721         USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1111] - CYC_INSTRUCTION[REG_IR]);
1722 }
1723
1724 /* Exception for illegal instructions */
1725 INLINE void m68ki_exception_illegal(void)
1726 {
1727         uint sr;
1728
1729         M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: illegal instruction %04x (%s)\n",
1730                                  m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PPC), REG_IR,
1731                                  m68ki_disassemble_quick(ADDRESS_68K(REG_PPC))));
1732
1733         sr = m68ki_init_exception();
1734         m68ki_stack_frame_0000(REG_PC, sr, EXCEPTION_ILLEGAL_INSTRUCTION);
1735         m68ki_jump_vector(EXCEPTION_ILLEGAL_INSTRUCTION);
1736
1737         /* Use up some clock cycles and undo the instruction's cycles */
1738         USE_CYCLES(CYC_EXCEPTION[EXCEPTION_ILLEGAL_INSTRUCTION] - CYC_INSTRUCTION[REG_IR]);
1739 }
1740
1741 /* Exception for format errror in RTE */
1742 INLINE void m68ki_exception_format_error(void)
1743 {
1744         uint sr = m68ki_init_exception();
1745         m68ki_stack_frame_0000(REG_PC, sr, EXCEPTION_FORMAT_ERROR);
1746         m68ki_jump_vector(EXCEPTION_FORMAT_ERROR);
1747
1748         /* Use up some clock cycles and undo the instruction's cycles */
1749         USE_CYCLES(CYC_EXCEPTION[EXCEPTION_FORMAT_ERROR] - CYC_INSTRUCTION[REG_IR]);
1750 }
1751
1752 /* Exception for address error */
1753 INLINE void m68ki_exception_address_error(void)
1754 {
1755         /* Not emulated yet */
1756 }
1757
1758
1759 /* Service an interrupt request and start exception processing */
1760 void m68ki_exception_interrupt(uint int_level)
1761 {
1762         uint vector;
1763         uint sr;
1764         uint new_pc;
1765
1766         /* Turn off the stopped state */
1767         CPU_STOPPED &= ~STOP_LEVEL_STOP;
1768
1769         /* If we are halted, don't do anything */
1770         if(CPU_STOPPED)
1771                 return;
1772
1773         /* Acknowledge the interrupt */
1774         vector = m68ki_int_ack(int_level);
1775
1776         /* Get the interrupt vector */
1777         if(vector == M68K_INT_ACK_AUTOVECTOR)
1778                 /* Use the autovectors.  This is the most commonly used implementation */
1779                 vector = EXCEPTION_INTERRUPT_AUTOVECTOR+int_level;
1780         else if(vector == M68K_INT_ACK_SPURIOUS)
1781                 /* Called if no devices respond to the interrupt acknowledge */
1782                 vector = EXCEPTION_SPURIOUS_INTERRUPT;
1783         else if(vector > 255)
1784         {
1785                 M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: Interrupt acknowledge returned invalid vector $%x\n",
1786                                  m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC), vector));
1787                 return;
1788         }
1789
1790         /* Start exception processing */
1791         sr = m68ki_init_exception();
1792
1793         /* Set the interrupt mask to the level of the one being serviced */
1794         FLAG_INT_MASK = int_level<<8;
1795
1796         /* Get the new PC */
1797         new_pc = m68ki_read_data_32((vector<<2) + REG_VBR);
1798
1799         /* If vector is uninitialized, call the uninitialized interrupt vector */
1800         if(new_pc == 0)
1801                 new_pc = m68ki_read_data_32((EXCEPTION_UNINITIALIZED_INTERRUPT<<2) + REG_VBR);
1802
1803         /* Generate a stack frame */
1804         m68ki_stack_frame_0000(REG_PC, sr, vector);
1805         if(FLAG_M && CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
1806         {
1807                 /* Create throwaway frame */
1808                 m68ki_set_sm_flag(FLAG_S);      /* clear M */
1809                 sr |= 0x2000; /* Same as SR in master stack frame except S is forced high */
1810                 m68ki_stack_frame_0001(REG_PC, sr, vector);
1811         }
1812
1813         m68ki_jump(new_pc);
1814
1815         /* Defer cycle counting until later */
1816         CPU_INT_CYCLES += CYC_EXCEPTION[vector];
1817
1818 #if !M68K_EMULATE_INT_ACK
1819         /* Automatically clear IRQ if we are not using an acknowledge scheme */
1820         CPU_INT_LEVEL = 0;
1821 #endif /* M68K_EMULATE_INT_ACK */
1822 }
1823
1824
1825 /* ASG: Check for interrupts */
1826 INLINE void m68ki_check_interrupts(void)
1827 {
1828         if(CPU_INT_LEVEL > FLAG_INT_MASK)
1829                 m68ki_exception_interrupt(CPU_INT_LEVEL>>8);
1830 }
1831
1832
1833
1834 /* ======================================================================== */
1835 /* ============================== END OF FILE ============================= */
1836 /* ======================================================================== */
1837
1838 #endif /* M68KCPU__HEADER */