Return to mmu_common.h CVS log

Up to [Previous NeXT emulator] / previous / src / cpu

Annotation of previous/src/cpu/mmu_common.h, revision 1.1

1.1     ! root        1: 
        !             2: #ifndef MMU_COMMON_H
        !             3: #define MMU_COMMON_H
        !             4: 
        !             5: #if 0
        !             6: struct m68k_exception {
        !             7:        int prb;
        !             8:        m68k_exception (int exc) : prb (exc) {}
        !             9:        operator int() { return prb; }
        !            10: };
        !            11: #define SAVE_EXCEPTION
        !            12: #define RESTORE_EXCEPTION
        !            13: #define TRY(var) try
        !            14: #define CATCH(var) catch(m68k_exception var)
        !            15: #define THROW(n) throw m68k_exception(n)
        !            16: #define THROW_AGAIN(var) throw
        !            17: 
        !            18: #else
        !            19: /* we are in plain C, just use a stack of long jumps */
        !            20: #include <setjmp.h>
        !            21: extern jmp_buf __exbuf;
        !            22: extern int     __exvalue;
        !            23: #define TRY(DUMMY)       __exvalue=setjmp(__exbuf);       \
        !            24:                   if (__exvalue==0) { __pushtry(&__exbuf);
        !            25: #define CATCH(x)  __poptry(); } else { fprintf(stderr,"Gotcha! %d %s in %d\n",__exvalue,__FILE__,__LINE__);
        !            26: #define ENDTRY    __poptry();}
        !            27: #define THROW(x) if (__is_catched()) {fprintf(stderr,"Longjumping %s in %d\n",__FILE__,__LINE__);longjmp(__exbuf,x);}
        !            28: #define THROW_AGAIN(var) if (__is_catched()) longjmp(*__poptry(),__exvalue)
        !            29: #define SAVE_EXCEPTION
        !            30: #define RESTORE_EXCEPTION
        !            31: jmp_buf* __poptry(void);
        !            32: void __pushtry(jmp_buf *j);
        !            33: int __is_catched(void);
        !            34: 
        !            35: typedef  int m68k_exception;
        !            36: 
        !            37: #endif
        !            38: 
        !            39: /* special status word (access error stack frame) */
        !            40: /* this is only valid for 68040 */
        !            41: /* TODO: correctly handle SSW on 68030 */
        !            42: #define MMU_SSW_TM             0x0007
        !            43: #define MMU_SSW_TT             0x0018
        !            44: #define MMU_SSW_SIZE   0x0060
        !            45: #define MMU_SSW_SIZE_B 0x0020
        !            46: #define MMU_SSW_SIZE_W 0x0040
        !            47: #define MMU_SSW_SIZE_L 0x0000
        !            48: #define MMU_SSW_RW             0x0100
        !            49: #define MMU_SSW_LK             0x0200
        !            50: #define MMU_SSW_ATC            0x0400
        !            51: #define MMU_SSW_MA             0x0800
        !            52: #define MMU_SSW_CM     0x1000
        !            53: #define MMU_SSW_CT     0x2000
        !            54: #define MMU_SSW_CU     0x4000
        !            55: #define MMU_SSW_CP     0x8000
        !            56: 
        !            57: #define MMU030_SSW_FC       0x8000
        !            58: #define MMU030_SSW_FB       0x4000
        !            59: #define MMU030_SSW_RC       0x2000
        !            60: #define MMU030_SSW_RB       0x1000
        !            61: #define MMU030_SSW_DF       0x0100
        !            62: #define MMU030_SSW_RM       0x0080
        !            63: #define MMU030_SSW_RW       0x0040
        !            64: #define MMU030_SSW_SIZE_MASK    0x0030
        !            65: #define MMU030_SSW_SIZE_B       0x0010 /* correct ? */
        !            66: #define MMU030_SSW_SIZE_W       0x0020 /* correct ? */
        !            67: #define MMU030_SSW_SIZE_L       0x0000 /* correct ? */
        !            68: #define MMU030_SSW_FC_MASK      0x0007
        !            69: 
        !            70: 
        !            71: #define ALWAYS_INLINE __inline
        !            72: 
        !            73: // take care of 2 kinds of alignement, bus size and page
        !            74: static inline bool is_unaligned(uaecptr addr, int size)
        !            75: {
        !            76:     return unlikely((addr & (size - 1)) && (addr ^ (addr + size - 1)) & 0x1000);
        !            77: }
        !            78: 
        !            79: static ALWAYS_INLINE void phys_put_long(uaecptr addr, uae_u32 l)
        !            80: {
        !            81:     longput(addr, l);
        !            82: }
        !            83: static ALWAYS_INLINE void phys_put_word(uaecptr addr, uae_u32 w)
        !            84: {
        !            85:     wordput(addr, w);
        !            86: }
        !            87: static ALWAYS_INLINE void phys_put_byte(uaecptr addr, uae_u32 b)
        !            88: {
        !            89:     byteput(addr, b);
        !            90: }
        !            91: static ALWAYS_INLINE uae_u32 phys_get_long(uaecptr addr)
        !            92: {
        !            93:     return longget (addr);
        !            94: }
        !            95: static ALWAYS_INLINE uae_u32 phys_get_word(uaecptr addr)
        !            96: {
        !            97:     return wordget (addr);
        !            98: }
        !            99: static ALWAYS_INLINE uae_u32 phys_get_byte(uaecptr addr)
        !           100: {
        !           101:     return byteget (addr);
        !           102: }
        !           103: 
        !           104: #endif

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