← Back to branch summary

~ubuntu-branches/ubuntu/raring/mame/raring-proposed

« back to all changes in this revision

Viewing changes to src/emu/cpu/m68000/m68kcpu.h

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Jordi Mallach, Emmanuel Kasper
  • Date: 2011-12-19 22:56:27 UTC
  • mfrom: (0.1.2)
  • Revision ID: package-import@ubuntu.com-20111219225627-ub5oga1oys4ogqzm
Tags: 0.144-1
http://bugs.debian.org/651538
[ Jordi Mallach ]
* Fix syntax errors in DEP5 copyright file (lintian).
* Use a versioned copyright Format specification field.
* Update Vcs-* URLs.
* Move transitional packages to the new metapackages section, and make
  them priority extra.
* Remove references to GNU/Linux and MESS sources from copyright.
* Add build variables for s390x.
* Use .xz tarballs as it cuts 4MB for the upstream sources.
* Add nplayers.ini as a patch. Update copyright file to add CC-BY-SA-3.0.

[ Emmanuel Kasper ]
* New upstream release. Closes: #651538.
* Add Free Desktop compliant png icons of various sizes taken from
  the hydroxygen iconset
* Mess is now built from a new source package, to avoid possible source
  incompatibilities between mame and the mess overlay.
* Mame-tools are not built from the mame source package anymore, but
  from the mess source package

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/emu/cpu/m68000/m68kcpu.h
25
25
#ifndef __M68KCPU_H__
26
26
#define __M68KCPU_H__
27
27
 
28
 
typedef struct _m68ki_cpu_core m68ki_cpu_core;
 
28
typedef class _m68ki_cpu_core m68ki_cpu_core;
29
29
 
30
30
 
31
31
#include "m68000.h"
86
86
#define CPU_TYPE_LC040  (0x00000100)
87
87
#define CPU_TYPE_040    (0x00000200)
88
88
#define CPU_TYPE_SCC070 (0x00000400)
 
89
#define CPU_TYPE_68340  (0x00000800)
 
90
#define CPU_TYPE_COLDFIRE (0x00001000)
89
91
 
90
92
/* Different ways to stop the CPU */
91
93
#define STOP_LEVEL_STOP 1
211
213
/* ------------------------------ CPU Access ------------------------------ */
212
214
 
213
215
/* Access the CPU registers */
214
 
#define REG_DA           m68k->dar /* easy access to data and address regs */
215
 
#define REG_D            m68k->dar
216
 
#define REG_A            (m68k->dar+8)
217
 
#define REG_PPC                  m68k->ppc
218
 
#define REG_PC           m68k->pc
219
 
#define REG_SP_BASE      m68k->sp
220
 
#define REG_USP          m68k->sp[0]
221
 
#define REG_ISP          m68k->sp[4]
222
 
#define REG_MSP          m68k->sp[6]
223
 
#define REG_SP           m68k->dar[15]
 
216
#define REG_DA(M)           (M)->dar /* easy access to data and address regs */
 
217
#define REG_D(M)            (M)->dar
 
218
#define REG_A(M)            ((M)->dar+8)
 
219
#define REG_PPC(M)                      (M)->ppc
 
220
#define REG_PC(M)           (M)->pc
 
221
#define REG_SP_BASE(M)      (M)->sp
 
222
#define REG_USP(M)          (M)->sp[0]
 
223
#define REG_ISP(M)          (M)->sp[4]
 
224
#define REG_MSP(M)          (M)->sp[6]
 
225
#define REG_SP(M)           (M)->dar[15]
224
226
 
225
 
#define REG_FP           m68k->fpr
226
 
#define REG_FPCR         m68k->fpcr
227
 
#define REG_FPSR         m68k->fpsr
228
 
#define REG_FPIAR        m68k->fpiar
 
227
#define REG_FP(M)           (M)->fpr
 
228
#define REG_FPCR(M)         (M)->fpcr
 
229
#define REG_FPSR(M)         (M)->fpsr
 
230
#define REG_FPIAR(M)        (M)->fpiar
229
231
 
230
232
 
231
233
/* ----------------------------- Configuration ---------------------------- */
233
235
/* These defines are dependant on the configuration defines in m68kconf.h */
234
236
 
235
237
/* Disable certain comparisons if we're not using all CPU types */
 
238
#define CPU_TYPE_IS_COLDFIRE(A)    ((A) & (CPU_TYPE_COLDFIRE))
 
239
 
236
240
#define CPU_TYPE_IS_040_PLUS(A)    ((A) & (CPU_TYPE_040 | CPU_TYPE_EC040))
237
241
#define CPU_TYPE_IS_040_LESS(A)    1
238
242
 
239
243
#define CPU_TYPE_IS_030_PLUS(A)    ((A) & (CPU_TYPE_030 | CPU_TYPE_EC030 | CPU_TYPE_040 | CPU_TYPE_EC040))
240
244
#define CPU_TYPE_IS_030_LESS(A)    1
241
245
 
242
 
#define CPU_TYPE_IS_020_PLUS(A)    ((A) & (CPU_TYPE_020 | CPU_TYPE_030 | CPU_TYPE_EC030 | CPU_TYPE_040 | CPU_TYPE_EC040))
 
246
#define CPU_TYPE_IS_020_PLUS(A)    ((A) & (CPU_TYPE_020 | CPU_TYPE_030 | CPU_TYPE_EC030 | CPU_TYPE_040 | CPU_TYPE_EC040 | CPU_TYPE_68340 | CPU_TYPE_COLDFIRE))
243
247
#define CPU_TYPE_IS_020_LESS(A)    1
244
248
 
245
 
#define CPU_TYPE_IS_020_VARIANT(A) ((A) & (CPU_TYPE_EC020 | CPU_TYPE_020))
 
249
#define CPU_TYPE_IS_020_VARIANT(A) ((A) & (CPU_TYPE_EC020 | CPU_TYPE_020 | CPU_TYPE_68340))
246
250
 
247
 
#define CPU_TYPE_IS_EC020_PLUS(A)  ((A) & (CPU_TYPE_EC020 | CPU_TYPE_020 | CPU_TYPE_030 | CPU_TYPE_EC030 | CPU_TYPE_040 | CPU_TYPE_EC040))
 
251
#define CPU_TYPE_IS_EC020_PLUS(A)  ((A) & (CPU_TYPE_EC020 | CPU_TYPE_020 | CPU_TYPE_030 | CPU_TYPE_EC030 | CPU_TYPE_040 | CPU_TYPE_EC040 | CPU_TYPE_68340 | CPU_TYPE_COLDFIRE))
248
252
#define CPU_TYPE_IS_EC020_LESS(A)  ((A) & (CPU_TYPE_000 | CPU_TYPE_008 | CPU_TYPE_010 | CPU_TYPE_EC020))
249
253
 
250
254
#define CPU_TYPE_IS_010(A)         ((A) == CPU_TYPE_010)
251
 
#define CPU_TYPE_IS_010_PLUS(A)    ((A) & (CPU_TYPE_010 | CPU_TYPE_EC020 | CPU_TYPE_020 | CPU_TYPE_EC030 | CPU_TYPE_030 | CPU_TYPE_040 | CPU_TYPE_EC040))
 
255
#define CPU_TYPE_IS_010_PLUS(A)    ((A) & (CPU_TYPE_010 | CPU_TYPE_EC020 | CPU_TYPE_020 | CPU_TYPE_EC030 | CPU_TYPE_030 | CPU_TYPE_040 | CPU_TYPE_EC040 | CPU_TYPE_68340 | CPU_TYPE_COLDFIRE))
252
256
#define CPU_TYPE_IS_010_LESS(A)    ((A) & (CPU_TYPE_000 | CPU_TYPE_008 | CPU_TYPE_010))
253
257
 
254
258
#define CPU_TYPE_IS_000(A)         ((A) == CPU_TYPE_000 || (A) == CPU_TYPE_008)
255
259
 
256
260
 
257
 
/* Configuration switches (see m68kconf.h for explanation) */
258
 
#define M68K_EMULATE_TRACE          0
259
 
 
260
 
/* Enable or disable trace emulation */
261
 
#if M68K_EMULATE_TRACE
262
 
        /* Initiates trace checking before each instruction (t1) */
263
 
        #define m68ki_trace_t1() m68ki_tracing = m68k->t1_flag
264
 
        /* adds t0 to trace checking if we encounter change of flow */
265
 
        #define m68ki_trace_t0() m68ki_tracing |= m68k->t0_flag
266
 
        /* Clear all tracing */
267
 
        #define m68ki_clear_trace() m68ki_tracing = 0
268
 
        /* Cause a trace exception if we are tracing */
269
 
        #define m68ki_exception_if_trace() if(m68ki_tracing) m68ki_exception_trace(m68k)
270
 
#else
271
 
        #define m68ki_trace_t1()
272
 
        #define m68ki_trace_t0()
273
 
        #define m68ki_clear_trace()
274
 
        #define m68ki_exception_if_trace()
275
 
#endif /* M68K_EMULATE_TRACE */
276
 
 
 
261
/* Initiates trace checking before each instruction (t1) */
 
262
#define m68ki_trace_t1(m68k) m68k->tracing = m68k->t1_flag
 
263
/* adds t0 to trace checking if we encounter change of flow */
 
264
#define m68ki_trace_t0(m68k) m68k->tracing |= m68k->t0_flag
 
265
/* Clear all tracing */
 
266
#define m68ki_clear_trace(m68k) m68k->tracing = 0
 
267
/* Cause a trace exception if we are tracing */
 
268
#define m68ki_exception_if_trace(m68k) if(m68k->tracing) m68ki_exception_trace(m68k)
277
269
 
278
270
 
279
271
/* Address error */
301
293
        }
302
294
#else
303
295
#define m68ki_set_address_error_trap(m68k) \
 
296
        SETJMP_GNUC_PROTECT(); \
304
297
        if(setjmp(m68k->aerr_trap) != 0) \
305
298
        { \
306
299
                m68ki_exception_address_error(m68k); \
331
324
 * where XXX is register X and YYY is register Y
332
325
 */
333
326
/* Data Register Isolation */
334
 
#define DX (REG_D[(m68k->ir >> 9) & 7])
335
 
#define DY (REG_D[m68k->ir & 7])
 
327
#define DX(M) (REG_D(M)[((M)->ir >> 9) & 7])
 
328
#define DY(M) (REG_D(M)[(M)->ir & 7])
336
329
/* Address Register Isolation */
337
 
#define AX (REG_A[(m68k->ir >> 9) & 7])
338
 
#define AY (REG_A[m68k->ir & 7])
 
330
#define AX(M) (REG_A(M)[((M)->ir >> 9) & 7])
 
331
#define AY(M) (REG_A(M)[(M)->ir & 7])
339
332
 
340
333
 
341
334
/* Effective Address Calculations */
342
 
#define EA_AY_AI_8(m68k)   AY                                    /* address register indirect */
343
 
#define EA_AY_AI_16(m68k)  EA_AY_AI_8(m68k)
344
 
#define EA_AY_AI_32(m68k)  EA_AY_AI_8(m68k)
345
 
#define EA_AY_PI_8(m68k)   (AY++)                                /* postincrement (size = byte) */
346
 
#define EA_AY_PI_16(m68k)  ((AY+=2)-2)                           /* postincrement (size = word) */
347
 
#define EA_AY_PI_32(m68k)  ((AY+=4)-4)                           /* postincrement (size = long) */
348
 
#define EA_AY_PD_8(m68k)   (--AY)                                /* predecrement (size = byte) */
349
 
#define EA_AY_PD_16(m68k)  (AY-=2)                               /* predecrement (size = word) */
350
 
#define EA_AY_PD_32(m68k)  (AY-=4)                               /* predecrement (size = long) */
351
 
#define EA_AY_DI_8(m68k)   (AY+MAKE_INT_16(m68ki_read_imm_16(m68k))) /* displacement */
352
 
#define EA_AY_DI_16(m68k)  EA_AY_DI_8(m68k)
353
 
#define EA_AY_DI_32(m68k)  EA_AY_DI_8(m68k)
354
 
#define EA_AY_IX_8(m68k)   m68ki_get_ea_ix(m68k, AY)                   /* indirect + index */
355
 
#define EA_AY_IX_16(m68k)  EA_AY_IX_8(m68k)
356
 
#define EA_AY_IX_32(m68k)  EA_AY_IX_8(m68k)
357
 
 
358
 
#define EA_AX_AI_8(m68k)   AX
359
 
#define EA_AX_AI_16(m68k)  EA_AX_AI_8(m68k)
360
 
#define EA_AX_AI_32(m68k)  EA_AX_AI_8(m68k)
361
 
#define EA_AX_PI_8(m68k)   (AX++)
362
 
#define EA_AX_PI_16(m68k)  ((AX+=2)-2)
363
 
#define EA_AX_PI_32(m68k)  ((AX+=4)-4)
364
 
#define EA_AX_PD_8(m68k)   (--AX)
365
 
#define EA_AX_PD_16(m68k)  (AX-=2)
366
 
#define EA_AX_PD_32(m68k)  (AX-=4)
367
 
#define EA_AX_DI_8(m68k)   (AX+MAKE_INT_16(m68ki_read_imm_16(m68k)))
368
 
#define EA_AX_DI_16(m68k)  EA_AX_DI_8(m68k)
369
 
#define EA_AX_DI_32(m68k)  EA_AX_DI_8(m68k)
370
 
#define EA_AX_IX_8(m68k)   m68ki_get_ea_ix(m68k, AX)
371
 
#define EA_AX_IX_16(m68k)  EA_AX_IX_8(m68k)
372
 
#define EA_AX_IX_32(m68k)  EA_AX_IX_8(m68k)
373
 
 
374
 
#define EA_A7_PI_8(m68k)   ((REG_A[7]+=2)-2)
375
 
#define EA_A7_PD_8(m68k)   (REG_A[7]-=2)
 
335
#define EA_AY_AI_8(M)   AY(M)                              /* address register indirect */
 
336
#define EA_AY_AI_16(M)  EA_AY_AI_8(M)
 
337
#define EA_AY_AI_32(M)  EA_AY_AI_8(M)
 
338
#define EA_AY_PI_8(M)   (AY(M)++)                                /* postincrement (size = byte) */
 
339
#define EA_AY_PI_16(M)  ((AY(M)+=2)-2)                           /* postincrement (size = word) */
 
340
#define EA_AY_PI_32(M)  ((AY(M)+=4)-4)                           /* postincrement (size = long) */
 
341
#define EA_AY_PD_8(M)   (--AY(M))                                /* predecrement (size = byte) */
 
342
#define EA_AY_PD_16(M)  (AY(M)-=2)                               /* predecrement (size = word) */
 
343
#define EA_AY_PD_32(M)  (AY(M)-=4)                               /* predecrement (size = long) */
 
344
#define EA_AY_DI_8(M)   (AY(M)+MAKE_INT_16(m68ki_read_imm_16(M))) /* displacement */
 
345
#define EA_AY_DI_16(M)  EA_AY_DI_8(M)
 
346
#define EA_AY_DI_32(M)  EA_AY_DI_8(M)
 
347
#define EA_AY_IX_8(M)   m68ki_get_ea_ix(M, AY(M))                   /* indirect + index */
 
348
#define EA_AY_IX_16(M)  EA_AY_IX_8(M)
 
349
#define EA_AY_IX_32(M)  EA_AY_IX_8(M)
 
350
 
 
351
#define EA_AX_AI_8(M)   AX(M)
 
352
#define EA_AX_AI_16(M)  EA_AX_AI_8(M)
 
353
#define EA_AX_AI_32(M)  EA_AX_AI_8(M)
 
354
#define EA_AX_PI_8(M)   (AX(M)++)
 
355
#define EA_AX_PI_16(M)  ((AX(M)+=2)-2)
 
356
#define EA_AX_PI_32(M)  ((AX(M)+=4)-4)
 
357
#define EA_AX_PD_8(M)   (--AX(M))
 
358
#define EA_AX_PD_16(M)  (AX(M)-=2)
 
359
#define EA_AX_PD_32(M)  (AX(M)-=4)
 
360
#define EA_AX_DI_8(M)   (AX(M)+MAKE_INT_16(m68ki_read_imm_16(M)))
 
361
#define EA_AX_DI_16(M)  EA_AX_DI_8(M)
 
362
#define EA_AX_DI_32(M)  EA_AX_DI_8(M)
 
363
#define EA_AX_IX_8(M)   m68ki_get_ea_ix(M, AX(M))
 
364
#define EA_AX_IX_16(M)  EA_AX_IX_8(M)
 
365
#define EA_AX_IX_32(M)  EA_AX_IX_8(M)
 
366
 
 
367
#define EA_A7_PI_8(m68k)   ((REG_A(m68k)[7]+=2)-2)
 
368
#define EA_A7_PD_8(m68k)   (REG_A(m68k)[7]-=2)
376
369
 
377
370
#define EA_AW_8(m68k)      MAKE_INT_16(m68ki_read_imm_16(m68k))      /* absolute word */
378
371
#define EA_AW_16(m68k)     EA_AW_8(m68k)
503
496
/* ----------------------------- Read / Write ----------------------------- */
504
497
 
505
498
/* Read from the current address space */
506
 
#define m68ki_read_8(M, A)                      m68ki_read_8_fc (M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA)
507
 
#define m68ki_read_16(M, A)                     m68ki_read_16_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA)
508
 
#define m68ki_read_32(M, A)                     m68ki_read_32_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA)
 
499
#define m68ki_read_8(M, A)                      m68ki_read_8_fc (M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA)
 
500
#define m68ki_read_16(M, A)                     m68ki_read_16_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA)
 
501
#define m68ki_read_32(M, A)                     m68ki_read_32_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA)
509
502
 
510
503
/* Write to the current data space */
511
 
#define m68ki_write_8(M, A, V)          m68ki_write_8_fc (M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA, V)
512
 
#define m68ki_write_16(M, A, V)         m68ki_write_16_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA, V)
513
 
#define m68ki_write_32(M, A, V)         m68ki_write_32_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA, V)
514
 
#define m68ki_write_32_pd(M, A, V)      m68ki_write_32_pd_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA, V)
 
504
#define m68ki_write_8(M, A, V)          m68ki_write_8_fc (M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA, V)
 
505
#define m68ki_write_16(M, A, V)         m68ki_write_16_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA, V)
 
506
#define m68ki_write_32(M, A, V)         m68ki_write_32_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA, V)
 
507
#define m68ki_write_32_pd(M, A, V)      m68ki_write_32_pd_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA, V)
515
508
 
516
509
/* map read immediate 8 to read immediate 16 */
517
510
#define m68ki_read_imm_8(M)                     MASK_OUT_ABOVE_8(m68ki_read_imm_16(M))
522
515
#define m68ki_read_pcrel_32(M, A)       m68k_read_pcrelative_32(M, A)
523
516
 
524
517
/* Read from the program space */
525
 
#define m68ki_read_program_8(M, A)      m68ki_read_8_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM)
526
 
#define m68ki_read_program_16(M, A) m68ki_read_16_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM)
527
 
#define m68ki_read_program_32(M, A) m68ki_read_32_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM)
 
518
#define m68ki_read_program_8(M, A)      m68ki_read_8_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_PROGRAM)
 
519
#define m68ki_read_program_16(M, A) m68ki_read_16_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_PROGRAM)
 
520
#define m68ki_read_program_32(M, A) m68ki_read_32_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_PROGRAM)
528
521
 
529
522
/* Read from the data space */
530
 
#define m68ki_read_data_8(M, A)         m68ki_read_8_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA)
531
 
#define m68ki_read_data_16(M, A)        m68ki_read_16_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA)
532
 
#define m68ki_read_data_32(M, A)        m68ki_read_32_fc(M, A, m68k->s_flag | FUNCTION_CODE_USER_DATA)
 
523
#define m68ki_read_data_8(M, A)         m68ki_read_8_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA)
 
524
#define m68ki_read_data_16(M, A)        m68ki_read_16_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA)
 
525
#define m68ki_read_data_32(M, A)        m68ki_read_32_fc(M, A, (M)->s_flag | FUNCTION_CODE_USER_DATA)
533
526
 
534
527
 
535
528
 
598
591
        m68ki_cpu_core *m_cpustate;
599
592
};
600
593
 
601
 
struct _m68ki_cpu_core
 
594
class _m68ki_cpu_core
602
595
{
 
596
public:
 
597
 
603
598
        UINT32 cpu_type;     /* CPU Type: 68000, 68008, 68010, 68EC020, 68020, 68EC030, 68030, 68EC040, or 68040 */
604
599
        UINT32 dasm_type;        /* disassembly type */
605
600
        UINT32 dar[16];      /* Data and Address Registers */
669
664
        UINT32 virq_state;
670
665
        UINT32 nmi_pending;
671
666
 
 
667
        void (**jump_table)(m68ki_cpu_core *m68k);
672
668
        const UINT8* cyc_instruction;
673
669
        const UINT8* cyc_exception;
674
670
 
696
692
        /* PMMU registers */
697
693
        UINT32 mmu_crp_aptr, mmu_crp_limit;
698
694
        UINT32 mmu_srp_aptr, mmu_srp_limit;
 
695
        UINT32 mmu_urp_aptr;    /* 040 only */
699
696
        UINT32 mmu_tc;
700
697
        UINT16 mmu_sr;
 
698
        UINT32 mmu_sr_040;
701
699
        UINT32 mmu_atc_tag[MMU_ATC_ENTRIES], mmu_atc_data[MMU_ATC_ENTRIES];
702
700
        UINT32 mmu_atc_rr;
703
701
        UINT32 mmu_tt0, mmu_tt1;
 
702
        UINT32 mmu_itt0, mmu_itt1, mmu_dtt0, mmu_dtt1;
 
703
        UINT32 mmu_acr0, mmu_acr1, mmu_acr2, mmu_acr3;
704
704
 
705
705
        UINT16 mmu_tmp_sr;      /* temporary hack: status code for ptest and to handle write protection */
706
706
        UINT16 mmu_tmp_fc;      /* temporary hack: function code for the mmu (moves) */
714
714
        /* external instruction hook (does not depend on debug mode) */
715
715
        typedef int (*instruction_hook_t)(device_t *device, offs_t curpc);
716
716
        instruction_hook_t instruction_hook;
 
717
 
 
718
        #define OPCODE_PROTOTYPES
 
719
        #include "m68kops.h"
 
720
        #undef OPCODE_PROTOTYPES
717
721
};
718
722
 
719
723
 
903
907
 
904
908
INLINE UINT32 m68ki_ic_readimm16(m68ki_cpu_core *m68k, UINT32 address)
905
909
{
906
 
        if(CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type) && (m68k->cacr & M68K_CACR_EI))
907
 
        {
908
 
                UINT32 ic_offset = (address >> 1) % M68K_IC_SIZE;
909
 
                if (m68k->ic_address[ic_offset] == address)
910
 
                {
911
 
                        return m68k->ic_data[ic_offset];
912
 
                }
913
 
                else
914
 
                {
915
 
                        UINT32 data = m68k->memory.readimm16(address);
916
 
                        if (!m68k->mmu_tmp_buserror_occurred)
917
 
                        {
918
 
                                m68k->ic_data[ic_offset] = data;
919
 
                                m68k->ic_address[ic_offset] = address;
920
 
                        }
921
 
                        return data;
922
 
                }
923
 
        }
924
 
        else
 
910
/*  if(CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type) && (m68k->cacr & M68K_CACR_EI))
 
911
    {
 
912
        UINT32 ic_offset = (address >> 1) % M68K_IC_SIZE;
 
913
        if (m68k->ic_address[ic_offset] == address)
 
914
        {
 
915
            return m68k->ic_data[ic_offset];
 
916
        }
 
917
        else
 
918
        {
 
919
            UINT32 data = m68k->memory.readimm16(address);
 
920
            if (!m68k->mmu_tmp_buserror_occurred)
 
921
            {
 
922
                m68k->ic_data[ic_offset] = data;
 
923
                m68k->ic_address[ic_offset] = address;
 
924
            }
 
925
            return data;
 
926
        }
 
927
    }
 
928
    else*/
925
929
        {
926
930
                return m68k->memory.readimm16(address);
927
931
        }
928
932
 
929
933
        // this can't happen, but Apple GCC insists
930
 
        return 0;
 
934
//  return 0;
931
935
}
932
936
 
933
937
/* Handles all immediate reads, does address error check, function code setting,
940
944
        m68k->mmu_tmp_fc = m68k->s_flag | FUNCTION_CODE_USER_PROGRAM;
941
945
        m68k->mmu_tmp_rw = 1;
942
946
 
943
 
        m68ki_check_address_error(m68k, REG_PC, MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
 
947
        m68ki_check_address_error(m68k, REG_PC(m68k), MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
944
948
 
945
 
        if(REG_PC != m68k->pref_addr)
 
949
        if(REG_PC(m68k) != m68k->pref_addr)
946
950
        {
947
 
                m68k->pref_data = m68ki_ic_readimm16(m68k, REG_PC);
948
 
                m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC;
 
951
                m68k->pref_data = m68ki_ic_readimm16(m68k, REG_PC(m68k));
 
952
                m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC(m68k);
949
953
        }
950
954
        result = MASK_OUT_ABOVE_16(m68k->pref_data);
951
 
        REG_PC += 2;
 
955
        REG_PC(m68k) += 2;
952
956
        if (!m68k->mmu_tmp_buserror_occurred) {
953
957
                // prefetch only if no bus error occurred in opcode fetch
954
 
                m68k->pref_data = m68ki_ic_readimm16(m68k, REG_PC);
955
 
                m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC;
 
958
                m68k->pref_data = m68ki_ic_readimm16(m68k, REG_PC(m68k));
 
959
                m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC(m68k);
956
960
                // ignore bus error on prefetch
957
961
                m68k->mmu_tmp_buserror_occurred = 0;
958
962
        }
967
971
        m68k->mmu_tmp_fc = m68k->s_flag | FUNCTION_CODE_USER_PROGRAM;
968
972
        m68k->mmu_tmp_rw = 1;
969
973
 
970
 
        m68ki_check_address_error(m68k, REG_PC, MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
 
974
        m68ki_check_address_error(m68k, REG_PC(m68k), MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
971
975
 
972
 
        if(REG_PC != m68k->pref_addr)
 
976
        if(REG_PC(m68k) != m68k->pref_addr)
973
977
        {
974
 
                m68k->pref_addr = REG_PC;
 
978
                m68k->pref_addr = REG_PC(m68k);
975
979
                m68k->pref_data = m68ki_ic_readimm16(m68k, m68k->pref_addr);
976
980
        }
977
981
        temp_val = MASK_OUT_ABOVE_16(m68k->pref_data);
978
 
        REG_PC += 2;
979
 
        m68k->pref_addr = REG_PC;
 
982
        REG_PC(m68k) += 2;
 
983
        m68k->pref_addr = REG_PC(m68k);
980
984
        m68k->pref_data = m68ki_ic_readimm16(m68k, m68k->pref_addr);
981
985
 
982
986
        temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | MASK_OUT_ABOVE_16(m68k->pref_data));
983
 
        REG_PC += 2;
984
 
        m68k->pref_data = m68ki_ic_readimm16(m68k, REG_PC);
985
 
        m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC;
 
987
        REG_PC(m68k) += 2;
 
988
        m68k->pref_data = m68ki_ic_readimm16(m68k, REG_PC(m68k));
 
989
        m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC(m68k);
986
990
 
987
991
        return temp_val;
988
992
}
1076
1080
 */
1077
1081
INLINE UINT32 m68ki_get_ea_pcdi(m68ki_cpu_core *m68k)
1078
1082
{
1079
 
        UINT32 old_pc = REG_PC;
 
1083
        UINT32 old_pc = REG_PC(m68k);
1080
1084
        return old_pc + MAKE_INT_16(m68ki_read_imm_16(m68k));
1081
1085
}
1082
1086
 
1083
1087
 
1084
1088
INLINE UINT32 m68ki_get_ea_pcix(m68ki_cpu_core *m68k)
1085
1089
{
1086
 
        return m68ki_get_ea_ix(m68k, REG_PC);
 
1090
        return m68ki_get_ea_ix(m68k, REG_PC(m68k));
1087
1091
}
1088
1092
 
1089
1093
/* Indexed addressing modes are encoded as follows:
1139
1143
        if(CPU_TYPE_IS_010_LESS(m68k->cpu_type))
1140
1144
        {
1141
1145
                /* Calculate index */
1142
 
                Xn = REG_DA[extension>>12];     /* Xn */
 
1146
                Xn = REG_DA(m68k)[extension>>12];     /* Xn */
1143
1147
                if(!BIT_B(extension))           /* W/L */
1144
1148
                        Xn = MAKE_INT_16(Xn);
1145
1149
 
1151
1155
        if(!BIT_8(extension))
1152
1156
        {
1153
1157
                /* Calculate index */
1154
 
                Xn = REG_DA[extension>>12];     /* Xn */
 
1158
                Xn = REG_DA(m68k)[extension>>12];     /* Xn */
1155
1159
                if(!BIT_B(extension))           /* W/L */
1156
1160
                        Xn = MAKE_INT_16(Xn);
1157
1161
                /* Add scale if proper CPU type */
1173
1177
        /* Check if index is present */
1174
1178
        if(!BIT_6(extension))               /* IS */
1175
1179
        {
1176
 
                Xn = REG_DA[extension>>12];     /* Xn */
 
1180
                Xn = REG_DA(m68k)[extension>>12];     /* Xn */
1177
1181
                if(!BIT_B(extension))           /* W/L */
1178
1182
                        Xn = MAKE_INT_16(Xn);
1179
1183
                Xn <<= (extension>>9) & 3;      /* SCALE */
1256
1260
/* Push/pull data from the stack */
1257
1261
INLINE void m68ki_push_16(m68ki_cpu_core *m68k, UINT32 value)
1258
1262
{
1259
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2);
1260
 
        m68ki_write_16(m68k, REG_SP, value);
 
1263
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) - 2);
 
1264
        m68ki_write_16(m68k, REG_SP(m68k), value);
1261
1265
}
1262
1266
 
1263
1267
INLINE void m68ki_push_32(m68ki_cpu_core *m68k, UINT32 value)
1264
1268
{
1265
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4);
1266
 
        m68ki_write_32(m68k, REG_SP, value);
 
1269
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) - 4);
 
1270
        m68ki_write_32(m68k, REG_SP(m68k), value);
1267
1271
}
1268
1272
 
1269
1273
INLINE UINT32 m68ki_pull_16(m68ki_cpu_core *m68k)
1270
1274
{
1271
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2);
1272
 
        return m68ki_read_16(m68k, REG_SP-2);
 
1275
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) + 2);
 
1276
        return m68ki_read_16(m68k, REG_SP(m68k)-2);
1273
1277
}
1274
1278
 
1275
1279
INLINE UINT32 m68ki_pull_32(m68ki_cpu_core *m68k)
1276
1280
{
1277
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4);
1278
 
        return m68ki_read_32(m68k, REG_SP-4);
 
1281
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) + 4);
 
1282
        return m68ki_read_32(m68k, REG_SP(m68k)-4);
1279
1283
}
1280
1284
 
1281
1285
 
1284
1288
 */
1285
1289
INLINE void m68ki_fake_push_16(m68ki_cpu_core *m68k)
1286
1290
{
1287
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2);
 
1291
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) - 2);
1288
1292
}
1289
1293
 
1290
1294
INLINE void m68ki_fake_push_32(m68ki_cpu_core *m68k)
1291
1295
{
1292
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4);
 
1296
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) - 4);
1293
1297
}
1294
1298
 
1295
1299
INLINE void m68ki_fake_pull_16(m68ki_cpu_core *m68k)
1296
1300
{
1297
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2);
 
1301
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) + 2);
1298
1302
}
1299
1303
 
1300
1304
INLINE void m68ki_fake_pull_32(m68ki_cpu_core *m68k)
1301
1305
{
1302
 
        REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4);
 
1306
        REG_SP(m68k) = MASK_OUT_ABOVE_32(REG_SP(m68k) + 4);
1303
1307
}
1304
1308
 
1305
1309
 
1311
1315
 */
1312
1316
INLINE void m68ki_jump(m68ki_cpu_core *m68k, UINT32 new_pc)
1313
1317
{
1314
 
        REG_PC = new_pc;
 
1318
        REG_PC(m68k) = new_pc;
1315
1319
}
1316
1320
 
1317
1321
INLINE void m68ki_jump_vector(m68ki_cpu_core *m68k, UINT32 vector)
1318
1322
{
1319
 
        REG_PC = (vector<<2) + m68k->vbr;
1320
 
        REG_PC = m68ki_read_data_32(m68k, REG_PC);
 
1323
        REG_PC(m68k) = (vector<<2) + m68k->vbr;
 
1324
        REG_PC(m68k) = m68ki_read_data_32(m68k, REG_PC(m68k));
1321
1325
}
1322
1326
 
1323
1327
 
1328
1332
 */
1329
1333
INLINE void m68ki_branch_8(m68ki_cpu_core *m68k, UINT32 offset)
1330
1334
{
1331
 
        REG_PC += MAKE_INT_8(offset);
 
1335
        REG_PC(m68k) += MAKE_INT_8(offset);
1332
1336
}
1333
1337
 
1334
1338
INLINE void m68ki_branch_16(m68ki_cpu_core *m68k, UINT32 offset)
1335
1339
{
1336
 
        REG_PC += MAKE_INT_16(offset);
 
1340
        REG_PC(m68k) += MAKE_INT_16(offset);
1337
1341
}
1338
1342
 
1339
1343
INLINE void m68ki_branch_32(m68ki_cpu_core *m68k, UINT32 offset)
1340
1344
{
1341
 
        REG_PC += offset;
 
1345
        REG_PC(m68k) += offset;
1342
1346
}
1343
1347
 
1344
1348
 
1351
1355
INLINE void m68ki_set_s_flag(m68ki_cpu_core *m68k, UINT32 value)
1352
1356
{
1353
1357
        /* Backup the old stack pointer */
1354
 
        REG_SP_BASE[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)] = REG_SP;
 
1358
        REG_SP_BASE(m68k)[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)] = REG_SP(m68k);
1355
1359
        /* Set the S flag */
1356
1360
        m68k->s_flag = value;
1357
1361
        /* Set the new stack pointer */
1358
 
        REG_SP = REG_SP_BASE[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)];
 
1362
        REG_SP(m68k) = REG_SP_BASE(m68k)[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)];
1359
1363
}
1360
1364
 
1361
1365
/* Set the S and M flags and change the active stack pointer.
1364
1368
INLINE void m68ki_set_sm_flag(m68ki_cpu_core *m68k, UINT32 value)
1365
1369
{
1366
1370
        /* Backup the old stack pointer */
1367
 
        REG_SP_BASE[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)] = REG_SP;
 
1371
        REG_SP_BASE(m68k)[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)] = REG_SP(m68k);
1368
1372
        /* Set the S and M flags */
1369
1373
        m68k->s_flag = value & SFLAG_SET;
1370
1374
        m68k->m_flag = value & MFLAG_SET;
1371
1375
        /* Set the new stack pointer */
1372
 
        REG_SP = REG_SP_BASE[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)];
 
1376
        REG_SP(m68k) = REG_SP_BASE(m68k)[m68k->s_flag | ((m68k->s_flag>>1) & m68k->m_flag)];
1373
1377
}
1374
1378
 
1375
1379
/* Set the S and M flags.  Don't touch the stack pointer. */
1439
1443
 
1440
1444
        /* Turn off trace flag, clear pending traces */
1441
1445
        m68k->t1_flag = m68k->t0_flag = 0;
1442
 
        m68ki_clear_trace();
 
1446
        m68ki_clear_trace(m68k);
1443
1447
        /* Enter supervisor mode */
1444
1448
        m68ki_set_s_flag(m68k, SFLAG_SET);
1445
1449
 
1484
1488
 */
1485
1489
INLINE void m68ki_stack_frame_0010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector)
1486
1490
{
1487
 
        m68ki_push_32(m68k, REG_PPC);
 
1491
        m68ki_push_32(m68k, REG_PPC(m68k));
1488
1492
        m68ki_push_16(m68k, 0x2000 | (vector<<2));
1489
 
        m68ki_push_32(m68k, REG_PC);
 
1493
        m68ki_push_32(m68k, REG_PC(m68k));
1490
1494
        m68ki_push_16(m68k, sr);
1491
1495
}
1492
1496
 
1495
1499
 */
1496
1500
INLINE void m68ki_stack_frame_buserr(m68ki_cpu_core *m68k, UINT32 sr)
1497
1501
{
1498
 
        m68ki_push_32(m68k, REG_PC);
 
1502
        m68ki_push_32(m68k, REG_PC(m68k));
1499
1503
        m68ki_push_16(m68k, sr);
1500
1504
        m68ki_push_16(m68k, m68k->ir);
1501
1505
        m68ki_push_32(m68k, m68k->aerr_address);        /* access address */
1566
1570
 */
1567
1571
void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address)
1568
1572
{
 
1573
        int orig_rw = m68k->mmu_tmp_rw; // this gets splatted by the following pushes, so save it now
 
1574
 
1569
1575
        /* INTERNAL REGISTER */
1570
1576
        m68ki_push_16(m68k, 0);
1571
1577
 
1593
1599
        /* SPECIAL STATUS REGISTER */
1594
1600
        // set bit for: Rerun Faulted bus Cycle, or run pending prefetch
1595
1601
        // set FC
1596
 
        m68ki_push_16(m68k, 0x0100 | m68k->mmu_tmp_fc );
 
1602
        m68ki_push_16(m68k, 0x0100 | m68k->mmu_tmp_fc | orig_rw<<6);
1597
1603
 
1598
1604
        /* INTERNAL REGISTER */
1599
1605
        m68ki_push_16(m68k, 0);
1615
1621
 */
1616
1622
void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address)
1617
1623
{
 
1624
        int orig_rw = m68k->mmu_tmp_rw; // this gets splatted by the following pushes, so save it now
 
1625
 
1618
1626
        /* INTERNAL REGISTERS (18 words) */
1619
1627
        m68ki_push_32(m68k, 0);
1620
1628
        m68ki_push_32(m68k, 0);
1665
1673
        m68ki_push_16(m68k, 0);
1666
1674
 
1667
1675
        /* SPECIAL STATUS REGISTER */
1668
 
        m68ki_push_16(m68k, 0x0100 | m68k->mmu_tmp_fc);
 
1676
        m68ki_push_16(m68k, 0x0100 | m68k->mmu_tmp_fc | orig_rw<<6);
1669
1677
 
1670
1678
        /* INTERNAL REGISTER */
1671
1679
        m68ki_push_16(m68k, 0);
1689
1697
        UINT32 sr = m68ki_init_exception(m68k);
1690
1698
 
1691
1699
        if(CPU_TYPE_IS_010_LESS(m68k->cpu_type))
1692
 
                m68ki_stack_frame_0000(m68k, REG_PC, sr, vector);
 
1700
                m68ki_stack_frame_0000(m68k, REG_PC(m68k), sr, vector);
1693
1701
        else
1694
1702
                m68ki_stack_frame_0010(m68k, sr, vector);
1695
1703
 
1703
1711
INLINE void m68ki_exception_trapN(m68ki_cpu_core *m68k, UINT32 vector)
1704
1712
{
1705
1713
        UINT32 sr = m68ki_init_exception(m68k);
1706
 
        m68ki_stack_frame_0000(m68k, REG_PC, sr, vector);
 
1714
        m68ki_stack_frame_0000(m68k, REG_PC(m68k), sr, vector);
1707
1715
        m68ki_jump_vector(m68k, vector);
1708
1716
 
1709
1717
        /* Use up some clock cycles */
1721
1729
                {
1722
1730
                        m68k->instr_mode = INSTRUCTION_NO;
1723
1731
                }
1724
 
                m68ki_stack_frame_0000(m68k, REG_PC, sr, EXCEPTION_TRACE);
 
1732
                m68ki_stack_frame_0000(m68k, REG_PC(m68k), sr, EXCEPTION_TRACE);
1725
1733
        }
1726
1734
        else
1727
1735
                m68ki_stack_frame_0010(m68k, sr, EXCEPTION_TRACE);
1745
1753
                m68k->instr_mode = INSTRUCTION_NO;
1746
1754
        }
1747
1755
 
1748
 
        m68ki_stack_frame_0000(m68k, REG_PPC, sr, EXCEPTION_PRIVILEGE_VIOLATION);
 
1756
        m68ki_stack_frame_0000(m68k, REG_PPC(m68k), sr, EXCEPTION_PRIVILEGE_VIOLATION);
1749
1757
        m68ki_jump_vector(m68k, EXCEPTION_PRIVILEGE_VIOLATION);
1750
1758
 
1751
1759
        /* Use up some clock cycles and undo the instruction's cycles */
1758
1766
        UINT32 sr;
1759
1767
 
1760
1768
        sr = m68ki_init_exception(m68k);
1761
 
        m68ki_stack_frame_0000(m68k, REG_PPC, sr, EXCEPTION_1010);
 
1769
        m68ki_stack_frame_0000(m68k, REG_PPC(m68k), sr, EXCEPTION_1010);
1762
1770
        m68ki_jump_vector(m68k, EXCEPTION_1010);
1763
1771
 
1764
1772
        /* Use up some clock cycles and undo the instruction's cycles */
1771
1779
        UINT32 sr;
1772
1780
 
1773
1781
        sr = m68ki_init_exception(m68k);
1774
 
        m68ki_stack_frame_0000(m68k, REG_PPC, sr, EXCEPTION_1111);
 
1782
        m68ki_stack_frame_0000(m68k, REG_PPC(m68k), sr, EXCEPTION_1111);
1775
1783
        m68ki_jump_vector(m68k, EXCEPTION_1111);
1776
1784
 
1777
1785
        /* Use up some clock cycles and undo the instruction's cycles */
1790
1798
                m68k->instr_mode = INSTRUCTION_NO;
1791
1799
        }
1792
1800
 
1793
 
        m68ki_stack_frame_0000(m68k, REG_PPC, sr, EXCEPTION_ILLEGAL_INSTRUCTION);
 
1801
        m68ki_stack_frame_0000(m68k, REG_PPC(m68k), sr, EXCEPTION_ILLEGAL_INSTRUCTION);
1794
1802
        m68ki_jump_vector(m68k, EXCEPTION_ILLEGAL_INSTRUCTION);
1795
1803
 
1796
1804
        /* Use up some clock cycles and undo the instruction's cycles */
1801
1809
INLINE void m68ki_exception_format_error(m68ki_cpu_core *m68k)
1802
1810
{
1803
1811
        UINT32 sr = m68ki_init_exception(m68k);
1804
 
        m68ki_stack_frame_0000(m68k, REG_PC, sr, EXCEPTION_FORMAT_ERROR);
 
1812
        m68ki_stack_frame_0000(m68k, REG_PC(m68k), sr, EXCEPTION_FORMAT_ERROR);
1805
1813
        m68ki_jump_vector(m68k, EXCEPTION_FORMAT_ERROR);
1806
1814
 
1807
1815
        /* Use up some clock cycles and undo the instruction's cycles */
1881
1889
                new_pc = m68ki_read_data_32(m68k, (EXCEPTION_UNINITIALIZED_INTERRUPT<<2) + m68k->vbr);
1882
1890
 
1883
1891
        /* Generate a stack frame */
1884
 
        m68ki_stack_frame_0000(m68k, REG_PC, sr, vector);
 
1892
        m68ki_stack_frame_0000(m68k, REG_PC(m68k), sr, vector);
1885
1893
        if(m68k->m_flag && CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type))
1886
1894
        {
1887
1895
                /* Create throwaway frame */
1888
1896
                m68ki_set_sm_flag(m68k, m68k->s_flag);  /* clear M */
1889
1897
                sr |= 0x2000; /* Same as SR in master stack frame except S is forced high */
1890
 
                m68ki_stack_frame_0001(m68k, REG_PC, sr, vector);
 
1898
                m68ki_stack_frame_0001(m68k, REG_PC(m68k), sr, vector);
1891
1899
        }
1892
1900
 
1893
1901
        m68ki_jump(m68k, new_pc);