Return to inline.h CVS log

Up to [Atari MiNT] / MiNT / src

Annotation of MiNT/src/inline.h, revision 1.1.1.2

1.1       root        1: /*
                      2: 
1.1.1.2 ! root        3: Copyright 1992 Eric R. Smith.
        !             4: 
        !             5: All rights reserved.
1.1       root        6: 
                      7:  */
                      8: 
                      9: 
                     10: 
                     11: /*
                     12: 
                     13:  * inlining of various utility functions, for speed
                     14: 
                     15:  * NOTE: ALL functions in this file must also have
                     16: 
                     17:  * "normal" equivalents in the .c or .s files;
                     18: 
                     19:  * don't put a function just into here!
                     20: 
                     21:  */
                     22: 
                     23: 
                     24: 
                     25: #ifdef __GNUC__
                     26: 
                     27: 
                     28: 
                     29: #define spl7()                 \
                     30: 
                     31: ({  register short retvalue;   \
                     32: 
                     33:     __asm__ volatile("         \
                     34: 
                     35:        movew sr,%0;            \
                     36: 
                     37:        oriw  #0x0700,sr "      \
                     38: 
1.1.1.2 ! root       39:     : "=d"(retvalue)           \
1.1       root       40: 
                     41:     ); retvalue; })
                     42: 
                     43: 
                     44: 
                     45: #define spl(N)                 \
                     46: 
                     47: ({                             \
                     48: 
                     49:     __asm__ volatile("         \
                     50: 
                     51:        movew %0,sr "           \
                     52: 
                     53:     :                          \
                     54: 
1.1.1.2 ! root       55:     : "d"(N) ); })
1.1       root       56: 
                     57: 
                     58: 
                     59: 
                     60: 
                     61: /*
                     62: 
                     63:  * note that we must save some registers ourselves,
                     64: 
                     65:  * or else gcc will run out of reggies to use
                     66: 
                     67:  * and complain
                     68: 
                     69:  */
                     70: 
                     71: 
                     72: 
                     73: #define callout1(func, a)                      \
                     74: 
                     75: ({                                             \
                     76: 
                     77:        register long retvalue __asm__("d0");   \
                     78: 
                     79:        long _f = func;                         \
                     80: 
                     81:        short _a = (short)(a);                  \
                     82: 
                     83:                                                \
                     84: 
                     85:        __asm__ volatile                        \
                     86: 
                     87:        ("  moveml d5-d7/a4-a6,sp@-;            \
                     88: 
                     89:            movew %2,sp@-;                      \
                     90: 
                     91:            jsr %1@;                            \
                     92: 
                     93:            addqw #2,sp;                        \
                     94: 
                     95:            moveml sp@+,d5-d7/a4-a6 "           \
                     96: 
                     97:        : "=r"(retvalue)        /* outputs */   \
                     98: 
                     99:        : "a"(_f), "r"(_a)      /* inputs */    \
                    100: 
                    101:        : "d0", "d1", "d2", "d3", "d4",         \
                    102: 
                    103:          "a0", "a1", "a2", "a3" /* clobbered regs */ \
                    104: 
                    105:        );                                      \
                    106: 
                    107:        retvalue;                               \
                    108: 
                    109: })
                    110: 
                    111: 
                    112: 
                    113: #define callout2(func, a, b)                   \
                    114: 
                    115: ({                                             \
                    116: 
                    117:        register long retvalue __asm__("d0");   \
                    118: 
                    119:        long _f = func;                         \
                    120: 
                    121:        short _a = (short)(a);                  \
                    122: 
                    123:        short _b = (short)(b);                  \
                    124: 
                    125:                                                \
                    126: 
                    127:        __asm__ volatile                        \
                    128: 
                    129:        ("  moveml d5-d7/a4-a6,sp@-;            \
                    130: 
                    131:            movew %3,sp@-;                      \
                    132: 
                    133:            movew %2,sp@-;                      \
                    134: 
                    135:            jsr %1@;                            \
                    136: 
                    137:            addqw #4,sp;                        \
                    138: 
                    139:            moveml sp@+,d5-d7/a4-a6 "           \
                    140: 
                    141:        : "=r"(retvalue)        /* outputs */   \
                    142: 
                    143:        : "a"(_f), "r"(_a), "r"(_b) /* inputs */ \
                    144: 
                    145:        : "d0", "d1", "d2", "d3", "d4",         \
                    146: 
                    147:          "a0", "a1", "a2", "a3" /* clobbered regs */ \
                    148: 
                    149:        );                                      \
                    150: 
                    151:        retvalue;                               \
                    152: 
                    153: })
                    154: 
                    155: 
                    156: 
                    157: #endif
                    158: 
                    159: 
                    160: 
                    161: #ifdef LATTICE
                    162: 
                    163: #pragma inline d0=spl7()       {"40c0007c0700";}
                    164: 
                    165: #pragma inline d0=spl(d0)      {"46c0";}
                    166: 
                    167: #endif
                    168: 

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