Annotation of hatari/src/cpu/cpummu030.h, revision 1.1.1.3

1.1.1.3 ! root        1: #ifndef UAE_CPUMMU030_H
        !             2: #define UAE_CPUMMU030_H
        !             3: 
        !             4: #include "uae/types.h"
1.1       root        5: 
                      6: #include "mmu_common.h"
                      7: 
1.1.1.2   root        8: extern uae_u64 srp_030, crp_030;
                      9: extern uae_u32 tt0_030, tt1_030, tc_030;
                     10: extern uae_u16 mmusr_030;
                     11: 
                     12: #define MAX_MMU030_ACCESS 10
                     13: extern uae_u32 mm030_stageb_address;
                     14: extern int mmu030_idx;
                     15: extern bool mmu030_retry;
                     16: extern int mmu030_opcode, mmu030_opcode_stageb;
                     17: extern int mmu030_fake_prefetch;
                     18: extern uaecptr mmu030_fake_prefetch_addr;
                     19: extern uae_u16 mmu030_state[3];
                     20: extern uae_u32 mmu030_data_buffer;
                     21: extern uae_u32 mmu030_disp_store[2];
                     22: extern uae_u32 mmu030_fmovem_store[2];
                     23: 
                     24: #define MMU030_STATEFLAG1_FMOVEM 0x2000
                     25: #define MMU030_STATEFLAG1_MOVEM1 0x4000
                     26: #define MMU030_STATEFLAG1_MOVEM2 0x8000
                     27: #define MMU030_STATEFLAG1_DISP0 0x0001
                     28: #define MMU030_STATEFLAG1_DISP1 0x0002
                     29: 
                     30: struct mmu030_access
                     31: {
                     32:        bool done;
                     33:        uae_u32 val;
                     34: };
                     35: extern struct mmu030_access mmu030_ad[MAX_MMU030_ACCESS];
                     36: 
                     37: uae_u32 REGPARAM3 get_disp_ea_020_mmu030 (uae_u32 base, int idx) REGPARAM;
                     38: void mmu030_page_fault(uaecptr addr, bool read, int flags, uae_u32 fc);
                     39: 
                     40: bool mmu_op30_pmove (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
                     41: bool mmu_op30_ptest (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
                     42: bool mmu_op30_pload (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
                     43: bool mmu_op30_pflush (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
1.1       root       44: 
                     45: uae_u32 mmu_op30_helper_get_fc(uae_u16 next);
                     46: 
                     47: void mmu030_ptest_atc_search(uaecptr logical_addr, uae_u32 fc, bool write);
                     48: uae_u32 mmu030_ptest_table_search(uaecptr extra, uae_u32 fc, bool write, int level);
                     49: uae_u32 mmu030_table_search(uaecptr addr, uae_u32 fc, bool write, int level);
                     50: 
                     51: 
                     52: typedef struct {
                     53:     uae_u32 addr_base;
                     54:     uae_u32 addr_mask;
                     55:     uae_u32 fc_base;
                     56:     uae_u32 fc_mask;
                     57: } TT_info;
                     58: 
                     59: TT_info mmu030_decode_tt(uae_u32 TT);
1.1.1.2   root       60: bool mmu030_decode_tc(uae_u32 TC);
                     61: bool mmu030_decode_rp(uae_u64 RP);
1.1       root       62: 
                     63: int mmu030_logical_is_in_atc(uaecptr addr, uae_u32 fc, bool write);
                     64: void mmu030_atc_handle_history_bit(int entry_num);
                     65: 
1.1.1.2   root       66: void mmu030_put_long_atc(uaecptr addr, uae_u32 val, int l, uae_u32 fc);
                     67: void mmu030_put_word_atc(uaecptr addr, uae_u16 val, int l, uae_u32 fc);
                     68: void mmu030_put_byte_atc(uaecptr addr, uae_u8 val, int l, uae_u32 fc);
                     69: uae_u32 mmu030_get_long_atc(uaecptr addr, int l, uae_u32 fc);
                     70: uae_u16 mmu030_get_word_atc(uaecptr addr, int l, uae_u32 fc);
                     71: uae_u8 mmu030_get_byte_atc(uaecptr addr, int l, uae_u32 fc);
                     72: 
                     73: void mmu030_put_atc_generic(uaecptr addr, uae_u32 val, int l, uae_u32 fc, int size, int flags);
                     74: uae_u32 mmu030_get_atc_generic(uaecptr addr, int l, uae_u32 fc, int size, int flags, bool checkwrite);
1.1       root       75: 
                     76: void mmu030_flush_atc_fc(uae_u32 fc_base, uae_u32 fc_mask);
                     77: void mmu030_flush_atc_page(uaecptr logical_addr);
                     78: void mmu030_flush_atc_page_fc(uaecptr logical_addr, uae_u32 fc_base, uae_u32 fc_mask);
                     79: void mmu030_flush_atc_all(void);
                     80: void mmu030_reset(int hardreset);
1.1.1.2   root       81: void mmu030_set_funcs(void);
                     82: uaecptr mmu030_translate(uaecptr addr, bool super, bool data, bool write);
1.1       root       83: 
                     84: int mmu030_match_ttr(uaecptr addr, uae_u32 fc, bool write);
1.1.1.2   root       85: int mmu030_match_ttr_access(uaecptr addr, uae_u32 fc, bool write);
                     86: int mmu030_match_lrmw_ttr_access(uaecptr addr, uae_u32 fc);
1.1       root       87: int mmu030_do_match_ttr(uae_u32 tt, TT_info masks, uaecptr addr, uae_u32 fc, bool write);
1.1.1.2   root       88: int mmu030_do_match_lrmw_ttr(uae_u32 tt, TT_info masks, uaecptr addr, uae_u32 fc);
1.1       root       89: 
1.1.1.2   root       90: void mmu030_put_long(uaecptr addr, uae_u32 val, uae_u32 fc);
                     91: void mmu030_put_word(uaecptr addr, uae_u16 val, uae_u32 fc);
                     92: void mmu030_put_byte(uaecptr addr, uae_u8  val, uae_u32 fc);
                     93: uae_u32 mmu030_get_long(uaecptr addr, uae_u32 fc);
                     94: uae_u16 mmu030_get_word(uaecptr addr, uae_u32 fc);
                     95: uae_u8  mmu030_get_byte(uaecptr addr, uae_u32 fc);
                     96: uae_u32 mmu030_get_ilong(uaecptr addr, uae_u32 fc);
                     97: uae_u16 mmu030_get_iword(uaecptr addr, uae_u32 fc);
                     98: 
                     99: uae_u32 uae_mmu030_get_lrmw(uaecptr addr, int size);
                    100: void uae_mmu030_put_lrmw(uaecptr addr, uae_u32 val, int size);
                    101: 
                    102: void mmu030_put_generic(uaecptr addr, uae_u32 val, uae_u32 fc, int size, int accesssize, int flags);
                    103: uae_u32 mmu030_get_generic(uaecptr addr, uae_u32 fc, int size, int accesssize, int flags);
                    104: 
                    105: extern uae_u16 REGPARAM3 mmu030_get_word_unaligned(uaecptr addr, uae_u32 fc, int flags) REGPARAM;
                    106: extern uae_u32 REGPARAM3 mmu030_get_long_unaligned(uaecptr addr, uae_u32 fc, int flags) REGPARAM;
                    107: extern uae_u32 REGPARAM3 mmu030_get_ilong_unaligned(uaecptr addr, uae_u32 fc, int flags) REGPARAM;
                    108: extern uae_u16 REGPARAM3 mmu030_get_lrmw_word_unaligned(uaecptr addr, uae_u32 fc, int flags) REGPARAM;
                    109: extern uae_u32 REGPARAM3 mmu030_get_lrmw_long_unaligned(uaecptr addr, uae_u32 fc, int flags) REGPARAM;
                    110: extern void REGPARAM3 mmu030_put_word_unaligned(uaecptr addr, uae_u16 val, uae_u32 fc, int flags) REGPARAM;
                    111: extern void REGPARAM3 mmu030_put_long_unaligned(uaecptr addr, uae_u32 val, uae_u32 fc, int flags) REGPARAM;
1.1       root      112: 
                    113: static ALWAYS_INLINE uae_u32 uae_mmu030_get_ilong(uaecptr addr)
                    114: {
                    115:     uae_u32 fc = (regs.s ? 4 : 0) | 2;
                    116: 
                    117:        if (unlikely(is_unaligned(addr, 4)))
1.1.1.2   root      118:                return mmu030_get_ilong_unaligned(addr, fc, 0);
                    119:        return mmu030_get_ilong(addr, fc);
1.1       root      120: }
                    121: static ALWAYS_INLINE uae_u16 uae_mmu030_get_iword(uaecptr addr)
                    122: {
                    123:     uae_u32 fc = (regs.s ? 4 : 0) | 2;
1.1.1.2   root      124:        return mmu030_get_iword(addr, fc);
1.1       root      125: }
                    126: static ALWAYS_INLINE uae_u16 uae_mmu030_get_ibyte(uaecptr addr)
                    127: {
                    128:     uae_u32 fc = (regs.s ? 4 : 0) | 2;
                    129: 
1.1.1.2   root      130:        return mmu030_get_byte(addr, fc);
1.1       root      131: }
                    132: static ALWAYS_INLINE uae_u32 uae_mmu030_get_long(uaecptr addr)
                    133: {
                    134:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
                    135: 
                    136:        if (unlikely(is_unaligned(addr, 4)))
1.1.1.2   root      137:                return mmu030_get_long_unaligned(addr, fc, 0);
                    138:        return mmu030_get_long(addr, fc);
1.1       root      139: }
                    140: static ALWAYS_INLINE uae_u16 uae_mmu030_get_word(uaecptr addr)
                    141: {
                    142:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
                    143: 
                    144:        if (unlikely(is_unaligned(addr, 2)))
1.1.1.2   root      145:                return mmu030_get_word_unaligned(addr, fc, 0);
                    146:        return mmu030_get_word(addr, fc);
1.1       root      147: }
                    148: static ALWAYS_INLINE uae_u8 uae_mmu030_get_byte(uaecptr addr)
                    149: {
                    150:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
                    151: 
1.1.1.2   root      152:        return mmu030_get_byte(addr, fc);
1.1       root      153: }
                    154: static ALWAYS_INLINE void uae_mmu030_put_long(uaecptr addr, uae_u32 val)
                    155: {
                    156:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
1.1.1.2   root      157:     
1.1       root      158:        if (unlikely(is_unaligned(addr, 4)))
1.1.1.2   root      159:                mmu030_put_long_unaligned(addr, val, fc, 0);
1.1       root      160:        else
1.1.1.2   root      161:                mmu030_put_long(addr, val, fc);
1.1       root      162: }
                    163: static ALWAYS_INLINE void uae_mmu030_put_word(uaecptr addr, uae_u16 val)
                    164: {
                    165:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
                    166: 
                    167:        if (unlikely(is_unaligned(addr, 2)))
1.1.1.2   root      168:                mmu030_put_word_unaligned(addr, val, fc, 0);
1.1       root      169:        else
1.1.1.2   root      170:                mmu030_put_word(addr, val, fc);
1.1       root      171: }
                    172: static ALWAYS_INLINE void uae_mmu030_put_byte(uaecptr addr, uae_u8 val)
                    173: {
                    174:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
                    175: 
1.1.1.2   root      176:        mmu030_put_byte(addr, val, fc);
1.1       root      177: }
                    178: 
                    179: static ALWAYS_INLINE uae_u32 sfc030_get_long(uaecptr addr)
                    180: {
1.1.1.2   root      181:     uae_u32 fc = regs.sfc;
                    182: #if MMUDEBUG > 2
                    183:        write_log(_T("sfc030_get_long: FC = %i\n"),fc);
                    184: #endif
                    185:        if (unlikely(is_unaligned(addr, 4)))
                    186:                return mmu030_get_long_unaligned(addr, fc, 0);
                    187:        return mmu030_get_long(addr, fc);
1.1       root      188: }
                    189: 
                    190: static ALWAYS_INLINE uae_u16 sfc030_get_word(uaecptr addr)
                    191: {
1.1.1.2   root      192:     uae_u32 fc = regs.sfc;
                    193: #if MMUDEBUG > 2
                    194:        write_log(_T("sfc030_get_word: FC = %i\n"),fc);
                    195: #endif
1.1       root      196:     if (unlikely(is_unaligned(addr, 2)))
1.1.1.2   root      197:                return mmu030_get_word_unaligned(addr, fc, 0);
                    198:        return mmu030_get_word(addr, fc);
1.1       root      199: }
                    200: 
                    201: static ALWAYS_INLINE uae_u8 sfc030_get_byte(uaecptr addr)
                    202: {
1.1.1.2   root      203:     uae_u32 fc = regs.sfc;
                    204: #if MMUDEBUG > 2
                    205:        write_log(_T("sfc030_get_byte: FC = %i\n"),fc);
                    206: #endif
                    207:        return mmu030_get_byte(addr, fc);
1.1       root      208: }
                    209: 
                    210: static ALWAYS_INLINE void dfc030_put_long(uaecptr addr, uae_u32 val)
                    211: {
1.1.1.2   root      212:     uae_u32 fc = regs.dfc;
                    213: #if MMUDEBUG > 2
                    214:        write_log(_T("dfc030_put_long: %08X = %08X FC = %i\n"), addr, val, fc);
                    215: #endif
1.1       root      216:     if (unlikely(is_unaligned(addr, 4)))
1.1.1.2   root      217:                mmu030_put_long_unaligned(addr, val, fc, 0);
1.1       root      218:        else
1.1.1.2   root      219:                mmu030_put_long(addr, val, fc);
1.1       root      220: }
                    221: 
                    222: static ALWAYS_INLINE void dfc030_put_word(uaecptr addr, uae_u16 val)
                    223: {
1.1.1.2   root      224:     uae_u32 fc = regs.dfc;
                    225: #if MMUDEBUG > 2
                    226:        write_log(_T("dfc030_put_word: %08X = %04X FC = %i\n"), addr, val, fc);
                    227: #endif
                    228:        if (unlikely(is_unaligned(addr, 2)))
                    229:                mmu030_put_word_unaligned(addr, val, fc, 0);
1.1       root      230:        else
1.1.1.2   root      231:                mmu030_put_word(addr, val, fc);
1.1       root      232: }
                    233: 
                    234: static ALWAYS_INLINE void dfc030_put_byte(uaecptr addr, uae_u8 val)
                    235: {
1.1.1.2   root      236:     uae_u32 fc = regs.dfc;
                    237: #if MMUDEBUG > 2
                    238:        write_log(_T("dfc030_put_byte: %08X = %02X FC = %i\n"), addr, val, fc);
                    239: #endif
                    240:        mmu030_put_byte(addr, val, fc);
1.1       root      241: }
                    242: 
1.1.1.2   root      243: #define ACCESS_CHECK_PUT \
                    244:        if (!mmu030_ad[mmu030_idx].done) { \
                    245:                mmu030_ad[mmu030_idx].val = v; \
                    246:        } else if (mmu030_ad[mmu030_idx].done) { \
                    247:                mmu030_idx++; \
                    248:                return; \
                    249:        }
                    250: 
                    251: #define ACCESS_CHECK_GET \
                    252:        if (mmu030_ad[mmu030_idx].done) { \
                    253:                v = mmu030_ad[mmu030_idx].val; \
                    254:                mmu030_idx++; \
                    255:                return v; \
                    256:        }
                    257: 
                    258: #define ACCESS_CHECK_GET_PC(pc) \
                    259:        if (mmu030_ad[mmu030_idx].done) { \
                    260:                v = mmu030_ad[mmu030_idx].val; \
                    261:                mmu030_idx++; \
                    262:                m68k_incpci (pc); \
                    263:                return v; \
                    264:        }
                    265: 
                    266: #define ACCESS_EXIT_PUT \
                    267:        mmu030_ad[mmu030_idx].done = true; \
                    268:        mmu030_idx++; \
                    269:        mmu030_ad[mmu030_idx].done = false;
                    270: 
                    271: #define ACCESS_EXIT_GET \
                    272:        mmu030_ad[mmu030_idx].val = v; \
                    273:        mmu030_ad[mmu030_idx].done = true; \
                    274:        mmu030_idx++; \
                    275:        mmu030_ad[mmu030_idx].done = false;
                    276: 
                    277: STATIC_INLINE void put_byte_mmu030_state (uaecptr addr, uae_u32 v)
1.1       root      278: {
1.1.1.2   root      279:        ACCESS_CHECK_PUT
1.1       root      280:     uae_mmu030_put_byte (addr, v);
1.1.1.2   root      281:        ACCESS_EXIT_PUT
1.1       root      282: }
1.1.1.2   root      283: STATIC_INLINE void put_lrmw_byte_mmu030_state (uaecptr addr, uae_u32 v)
                    284: {
                    285:        ACCESS_CHECK_PUT
                    286:     uae_mmu030_put_lrmw (addr, v, sz_byte);
                    287:        ACCESS_EXIT_PUT
                    288: }
                    289: STATIC_INLINE void put_word_mmu030_state (uaecptr addr, uae_u32 v)
1.1       root      290: {
1.1.1.2   root      291:        ACCESS_CHECK_PUT
1.1       root      292:     uae_mmu030_put_word (addr, v);
1.1.1.2   root      293:        ACCESS_EXIT_PUT
1.1       root      294: }
1.1.1.2   root      295: STATIC_INLINE void put_lrmw_word_mmu030_state (uaecptr addr, uae_u32 v)
1.1       root      296: {
1.1.1.2   root      297:        ACCESS_CHECK_PUT
                    298:     uae_mmu030_put_lrmw (addr, v, sz_word);
                    299:        ACCESS_EXIT_PUT
                    300: }
                    301: STATIC_INLINE void put_long_mmu030_state (uaecptr addr, uae_u32 v)
                    302: {
                    303:        ACCESS_CHECK_PUT
1.1       root      304:     uae_mmu030_put_long (addr, v);
1.1.1.2   root      305:        ACCESS_EXIT_PUT
                    306: }
                    307: STATIC_INLINE void put_lrmw_long_mmu030_state (uaecptr addr, uae_u32 v)
                    308: {
                    309:        ACCESS_CHECK_PUT
                    310:     uae_mmu030_put_lrmw (addr, v, sz_long);
                    311:        ACCESS_EXIT_PUT
                    312: }
                    313: 
                    314: STATIC_INLINE uae_u32 get_byte_mmu030_state (uaecptr addr)
                    315: {
                    316:        uae_u32 v;
                    317:        ACCESS_CHECK_GET
                    318:     v = uae_mmu030_get_byte (addr);
                    319:        ACCESS_EXIT_GET
                    320:        return v;
                    321: }
                    322: STATIC_INLINE uae_u32 get_lrmw_byte_mmu030_state (uaecptr addr)
                    323: {
                    324:        uae_u32 v;
                    325:        ACCESS_CHECK_GET
                    326:     v = uae_mmu030_get_lrmw (addr, sz_byte);
                    327:        ACCESS_EXIT_GET
                    328:        return v;
                    329: }
                    330: 
                    331: STATIC_INLINE uae_u32 get_word_mmu030_state (uaecptr addr)
                    332: {
                    333:        uae_u32 v;
                    334:        ACCESS_CHECK_GET
                    335:        v = uae_mmu030_get_word (addr);
                    336:        ACCESS_EXIT_GET
                    337:        return v;
                    338: }
                    339: STATIC_INLINE uae_u32 get_lrmw_word_mmu030_state (uaecptr addr)
                    340: {
                    341:        uae_u32 v;
                    342:        ACCESS_CHECK_GET
                    343:     v = uae_mmu030_get_lrmw (addr, sz_word);
                    344:        ACCESS_EXIT_GET
                    345:        return v;
                    346: }
                    347: STATIC_INLINE uae_u32 get_long_mmu030_state (uaecptr addr)
                    348: {
                    349:        uae_u32 v;
                    350:        ACCESS_CHECK_GET
                    351:        v = uae_mmu030_get_long (addr);
                    352:        ACCESS_EXIT_GET
                    353:        return v;
                    354: }
                    355: STATIC_INLINE uae_u32 get_lrmw_long_mmu030_state (uaecptr addr)
                    356: {
                    357:        uae_u32 v;
                    358:        ACCESS_CHECK_GET
                    359:     v = uae_mmu030_get_lrmw (addr, sz_long);
                    360:        ACCESS_EXIT_GET
                    361:        return v;
                    362: }
                    363: 
                    364: STATIC_INLINE uae_u32 get_ibyte_mmu030_state (int o)
                    365: {
                    366:        uae_u32 v;
                    367:     uae_u32 addr = m68k_getpci () + o;
                    368:        ACCESS_CHECK_GET
                    369:     v = uae_mmu030_get_iword (addr);
                    370:        ACCESS_EXIT_GET
                    371:        return v;
                    372: }
                    373: STATIC_INLINE uae_u32 get_iword_mmu030_state (int o)
                    374: {
                    375:        uae_u32 v;
                    376:     uae_u32 addr = m68k_getpci () + o;
                    377:        ACCESS_CHECK_GET
                    378:     v = uae_mmu030_get_iword (addr);
                    379:        ACCESS_EXIT_GET
                    380:        return v;
                    381: }
                    382: STATIC_INLINE uae_u32 get_ilong_mmu030_state (int o)
                    383: {
                    384:        uae_u32 v;
                    385:     uae_u32 addr = m68k_getpci () + o;
                    386:        ACCESS_CHECK_GET
                    387:     v = uae_mmu030_get_ilong (addr);
                    388:        ACCESS_EXIT_GET
                    389:        return v;
                    390: }
                    391: STATIC_INLINE uae_u32 next_iword_mmu030_state (void)
                    392: {
                    393:        uae_u32 v;
                    394:     uae_u32 addr = m68k_getpci ();
                    395:        ACCESS_CHECK_GET_PC(2);
                    396:     v = uae_mmu030_get_iword (addr);
                    397:     m68k_incpci (2);
                    398:        ACCESS_EXIT_GET
                    399:        return v;
                    400: }
                    401: STATIC_INLINE uae_u32 next_ilong_mmu030_state (void)
                    402: {
                    403:        uae_u32 v;
                    404:     uae_u32 addr = m68k_getpci ();
                    405:        ACCESS_CHECK_GET_PC(4);
                    406:     v = uae_mmu030_get_ilong (addr);
                    407:     m68k_incpci (4);
                    408:        ACCESS_EXIT_GET
                    409:        return v;
1.1       root      410: }
1.1.1.2   root      411: 
1.1       root      412: STATIC_INLINE uae_u32 get_byte_mmu030 (uaecptr addr)
                    413: {
1.1.1.2   root      414:        return uae_mmu030_get_byte (addr);
1.1       root      415: }
                    416: STATIC_INLINE uae_u32 get_word_mmu030 (uaecptr addr)
                    417: {
1.1.1.2   root      418:        return uae_mmu030_get_word (addr);
1.1       root      419: }
                    420: STATIC_INLINE uae_u32 get_long_mmu030 (uaecptr addr)
                    421: {
1.1.1.2   root      422:        return uae_mmu030_get_long (addr);
                    423: }
                    424: STATIC_INLINE void put_byte_mmu030 (uaecptr addr, uae_u32 v)
                    425: {
                    426:     uae_mmu030_put_byte (addr, v);
1.1       root      427: }
1.1.1.2   root      428: 
                    429: STATIC_INLINE void put_word_mmu030 (uaecptr addr, uae_u32 v)
                    430: {
                    431:     uae_mmu030_put_word (addr, v);
                    432: }
                    433: STATIC_INLINE void put_long_mmu030 (uaecptr addr, uae_u32 v)
                    434: {
                    435:     uae_mmu030_put_long (addr, v);
                    436: }
                    437: 
1.1       root      438: STATIC_INLINE uae_u32 get_ibyte_mmu030 (int o)
                    439: {
1.1.1.2   root      440:     uae_u32 pc = m68k_getpci () + o;
1.1       root      441:     return uae_mmu030_get_iword (pc);
                    442: }
                    443: STATIC_INLINE uae_u32 get_iword_mmu030 (int o)
                    444: {
1.1.1.2   root      445:     uae_u32 pc = m68k_getpci () + o;
1.1       root      446:     return uae_mmu030_get_iword (pc);
                    447: }
                    448: STATIC_INLINE uae_u32 get_ilong_mmu030 (int o)
                    449: {
1.1.1.2   root      450:     uae_u32 pc = m68k_getpci () + o;
1.1       root      451:     return uae_mmu030_get_ilong (pc);
                    452: }
                    453: STATIC_INLINE uae_u32 next_iword_mmu030 (void)
                    454: {
1.1.1.2   root      455:        uae_u32 v;
                    456:     uae_u32 pc = m68k_getpci ();
                    457:     v = uae_mmu030_get_iword (pc);
1.1       root      458:     m68k_incpci (2);
1.1.1.2   root      459:        return v;
1.1       root      460: }
                    461: STATIC_INLINE uae_u32 next_ilong_mmu030 (void)
                    462: {
1.1.1.2   root      463:        uae_u32 v;
                    464:     uae_u32 pc = m68k_getpci ();
                    465:     v = uae_mmu030_get_ilong (pc);
1.1       root      466:     m68k_incpci (4);
1.1.1.2   root      467:        return v;
1.1       root      468: }
                    469: 
                    470: extern void m68k_do_rts_mmu030 (void);
                    471: extern void m68k_do_rte_mmu030 (uaecptr a7);
                    472: extern void flush_mmu030 (uaecptr, int);
                    473: extern void m68k_do_bsr_mmu030 (uaecptr oldpc, uae_s32 offset);
                    474: 
1.1.1.3 ! root      475: #endif /* UAE_CPUMMU030_H */

unix.superglobalmegacorp.com

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