home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / grtxbind / grtxbind.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-09  |  12.0 KB  |  460 lines
  1. /*
  2.  *    Micro RTX bindings for the gnu C compiler
  3.  *
  4.  *      ++jrb        bammi@dsrgsun.ces.cwru.edu
  5.  *
  6.  *  preprocessor symbols:
  7.  *    __NO_INLINE__    if #define'd do not generate inline traps. use
  8.  *            functional form of bindings in grtxbind.c (32 bit)
  9.  *            or srtxtraps.s (16 bit default ints).
  10.  *            you'll need to #define this when using some
  11.  *            debuggers, that otherwise get confused by
  12.  *            inline traps.
  13.  *
  14.  *    __MSHORT__    automatically defined when compiling with 16
  15.  *            bit integer defaults for `int'. automatically
  16.  *            undefined when compiling for 32 bit ints.
  17.  *
  18.  */
  19. #ifndef _RTXBIND_H
  20. #define _RTXBIND_H
  21.  
  22. #include <basepage.h>
  23. #include <osbind.h>
  24.  
  25. #if ((defined(__GNUC__)) && (!defined(__NO_INLINE__)))
  26. /*
  27.  * GNU C (pseudo inline) Statement Exprs for traps
  28.  *    note: use of statement expr instead of inline routines
  29.  *    due to brain damage in gcc 1.36.
  30.  *
  31.  *    to see the actual rtxbindings search for the string 'data struct'
  32.  *    forward in this file
  33.  */
  34.  
  35. #define _trap5_w(n)                            \
  36. ({                                    \
  37.     long retvalue;                            \
  38.                                         \
  39.     __asm__ volatile                        \
  40.     ("\
  41.         movw    %1,sp@-; \
  42.         trap    #5;    \
  43.         addqw   #2,sp;    \
  44.         movl    d0,%0"                        \
  45.     : "=g"(retvalue)            /* outputs */        \
  46.     : "r"(n)                /* inputs  */        \
  47.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  48.     );                                \
  49.     retvalue;                            \
  50. })
  51.  
  52. #define _trap5_wl(n, l1)                        \
  53. ({                                    \
  54.     long retvalue;                            \
  55.                                         \
  56.     __asm__ volatile                        \
  57.     ("\
  58.          movl    %2,sp@-; \
  59.         movw    %1,sp@-; \
  60.         trap    #5;    \
  61.         addqw   #6,sp;    \
  62.         movl    d0,%0"                        \
  63.     : "=g"(retvalue)            /* outputs */        \
  64.     : "r"(n), "r"(l1)            /* inputs  */        \
  65.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  66.     );                                \
  67.     retvalue;                            \
  68. })
  69.  
  70. #define _trap5_wlw(n, l1, w1)                        \
  71. ({                                    \
  72.     long retvalue;                            \
  73.                                         \
  74.     __asm__ volatile                        \
  75.     ("\
  76.          movw    %3,sp@-; \
  77.          movl    %2,sp@-; \
  78.         movw    %1,sp@-; \
  79.         trap    #5;    \
  80.         addqw   #8,sp;    \
  81.         movl    d0,%0"                        \
  82.     : "=g"(retvalue)            /* outputs */        \
  83.     : "r"(n), "r"(l1), "r"(w1)        /* inputs  */        \
  84.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  85.     );                                \
  86.     retvalue;                            \
  87. })
  88.  
  89. #define _trap5_wlwl(n, l1, w1, l2)                    \
  90. ({                                    \
  91.     long retvalue;                            \
  92.                                         \
  93.     __asm__ volatile                        \
  94.     ("\
  95.          movl    %4,sp@-; \
  96.          movw    %3,sp@-; \
  97.          movl    %2,sp@-; \
  98.         movw    %1,sp@-; \
  99.         trap    #5;    \
  100.         lea     sp@(12),sp;    \
  101.         movl    d0,%0"                        \
  102.     : "=g"(retvalue)            /* outputs */        \
  103.     : "r"(n), "r"(l1), "r"(w1), "r"(l2)    /* inputs  */        \
  104.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  105.     );                                \
  106.     retvalue;                            \
  107. })
  108.  
  109. #define _trap5_wll(n, l1, l2)                        \
  110. ({                                    \
  111.     long retvalue;                            \
  112.                                         \
  113.     __asm__ volatile                        \
  114.     ("\
  115.          movl    %3,sp@-; \
  116.          movl    %2,sp@-; \
  117.         movw    %1,sp@-; \
  118.         trap    #5;    \
  119.         lea     sp@(10),sp;    \
  120.         movl    d0,%0"                        \
  121.     : "=g"(retvalue)            /* outputs */        \
  122.     : "r"(n), "r"(l1), "r"(l2)        /* inputs  */        \
  123.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  124.     );                                \
  125.     retvalue;                            \
  126. })
  127.  
  128. #define _trap5_wlll(n, l1, l2, l3)                    \
  129. ({                                    \
  130.     long retvalue;                            \
  131.                                         \
  132.     __asm__ volatile                        \
  133.     ("\
  134.          movl    %4,sp@-; \
  135.          movl    %3,sp@-; \
  136.          movl    %2,sp@-; \
  137.         movw    %1,sp@-; \
  138.         trap    #5;    \
  139.         lea     sp@(14),sp;    \
  140.         movl    d0,%0"                        \
  141.     : "=g"(retvalue)            /* outputs */        \
  142.     : "r"(n), "r"(l1), "r"(l2), "r"(l3)    /* inputs  */        \
  143.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  144.     );                                \
  145.     retvalue;                            \
  146. })
  147.  
  148. #define _trap5_wwl(n, w1, l1)                        \
  149. ({                                    \
  150.     long retvalue;                            \
  151.                                         \
  152.     __asm__ volatile                        \
  153.     ("\
  154.          movl    %3,sp@-; \
  155.          movw    %2,sp@-; \
  156.         movw    %1,sp@-; \
  157.         trap    #5;    \
  158.         addqw   #8,sp;    \
  159.         movl    d0,%0"                        \
  160.     : "=g"(retvalue)            /* outputs */        \
  161.     : "r"(n), "r"(w1), "r"(l1)        /* inputs  */        \
  162.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  163.     );                                \
  164.     retvalue;                            \
  165. })
  166.  
  167. #define _trap5_wllwl(n, l1, l2, w1, l3)                    \
  168. ({                                    \
  169.     long retvalue;                            \
  170.                                         \
  171.     __asm__ volatile                        \
  172.     ("\
  173.          movl    %4,sp@-; \
  174.          movw    %3,sp@-; \
  175.         movl    %2,sp@-; \
  176.          movl    %1,sp@-; \
  177.         movw    %0,sp@-" \
  178.     :                         /* outputs */    \
  179.     : "r"(n), "r"(l1), "r"(l2), "r"(w1), "r"(l3)    /* inputs  */    \
  180.     );                                \
  181.     __asm__ volatile                        \
  182.     ("\
  183.         trap    #5;    \
  184.         lea     sp@(16),sp;    \
  185.         movl    d0,%0"                        \
  186.     : "=g"(retvalue)            /* outputs */        \
  187.     :                     /* inputs  */        \
  188.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  189.     );                                \
  190.     retvalue;                            \
  191. })
  192.  
  193. #define _trap5_wlwwlwll(n, l1, w1, w2, l2, w3, l3, l4)            \
  194. ({                                    \
  195.     long retvalue;                            \
  196.                                         \
  197.     __asm__ volatile                        \
  198.     ("\
  199.          movl    %4,sp@-; \
  200.          movl    %3,sp@-; \
  201.         movw    %2,sp@-; \
  202.          movl    %1,sp@-; \
  203.         movw    %0,sp@-" \
  204.     :                         /* outputs */    \
  205.     : "r"(w2), "r"(l2), "r"(w3), "r"(l3), "r"(l4)    /* inputs  */    \
  206.     );                                \
  207.     __asm__ volatile                        \
  208.     ("\
  209.          movw    %3,sp@-; \
  210.          movl    %2,sp@-; \
  211.         movw    %1,sp@-; \
  212.         trap    #5;    \
  213.         lea     sp@(24),sp;    \
  214.         movl    d0,%0"                        \
  215.     : "=g"(retvalue)            /* outputs */        \
  216.     : "r"(n), "r"(l1), "r"(w1)        /* inputs  */        \
  217.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  218.     );                                \
  219.     retvalue;                            \
  220. })
  221.  
  222. #define _trap5_wwllllll(n, w1, l1, l2, l3, l4, l5, l6)            \
  223. ({                                    \
  224.     long retvalue;                            \
  225.                                         \
  226.     __asm__ volatile                        \
  227.     ("\
  228.          movl    %4,sp@-; \
  229.          movl    %3,sp@-; \
  230.         movl    %2,sp@-; \
  231.          movl    %1,sp@-; \
  232.         movl    %0,sp@-" \
  233.     :                         /* outputs */    \
  234.     : "r"(l2), "r"(l3), "r"(l4), "r"(l5), "r"(l6)    /* inputs  */    \
  235.     );                                \
  236.     __asm__ volatile                        \
  237.     ("\
  238.          movl    %3,sp@-; \
  239.          movw    %2,sp@-; \
  240.         movw    %1,sp@-; \
  241.         trap    #5;    \
  242.         lea     sp@(28),sp;    \
  243.         movl    d0,%0"                        \
  244.     : "=g"(retvalue)            /* outputs */        \
  245.     : "r"(n), "r"(w1), "r"(l1)        /* inputs  */        \
  246.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  247.     );                                \
  248.     retvalue;                            \
  249. })
  250.  
  251. /*
  252.  * additional gemdos bindings (not in <osbind.h>)
  253.  */
  254. #define trap_1_wwwll(n, w1, w2, l1, l2)                    \
  255. ({                                    \
  256.     long retvalue;                            \
  257.                                     \
  258.     __asm__ volatile                        \
  259.     ("\
  260.         movl    %4,sp@-; \
  261.         movl    %3,sp@-; \
  262.         movw    %2,sp@-; \
  263.         movw    %1,sp@-; \
  264.         movw    %0,sp@- "                    \
  265.     :                     /* outputs */        \
  266.     : "r"(n), "r"(w1), "r"(w2), "r"(l1), "r"(l2) /* inputs  */    \
  267.     );                                \
  268.   /* no more than 5 operand allowed in asm() -- therefore the split */  \
  269.                                     \
  270.     __asm__ volatile                        \
  271.     ("\
  272.         trap    #1;    \
  273.         lea    sp@(14),sp;    \
  274.         movl    d0,%0"                        \
  275.     : "=g"(retvalue)            /* outputs */        \
  276.     :                    /* inputs  */        \
  277.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  278.     );                                \
  279.     retvalue;                            \
  280. })
  281.  
  282. #else /* __GNUC__ && !__NO_INLINE__ */
  283.  
  284. /* if inlines are not allowed, then declare things external */
  285. /* if __MSHORT__ is defined (16 bit integers) then use the
  286.    "traditional" rtxbind. Otherwise, pick up the
  287.    necessary stuff from the library(grtxbind.c), relying on the fact that the
  288.    default return type (int) is 32 bits, hence big enough to hold return
  289.    values.
  290. */
  291. #ifdef __MSHORT__
  292. extern long gemdos(), rtxbind();
  293. #define _trap5_w        rtxbind
  294. #define _trap5_wl        rtxbind
  295. #define _trap5_wlw        rtxbind
  296. #define _trap5_wlwl        rtxbind
  297. #define _trap5_wll        rtxbind
  298. #define _trap5_wlll        rtxbind
  299. #define _trap5_wwl        rtxbind
  300. #define _trap5_wllwl        rtxbind
  301. #define _trap5_wlwwlwll        rtxbind
  302. #define _trap5_wwllllll        rtxbind
  303. #define trap_1_wwwll        gemdos
  304.  
  305. #else
  306.  
  307. extern long
  308.         _trap5_w(), _trap5_wl(), _trap5_wlw(), _trap5_wlwl(), _trap5_wll(),
  309.     _trap5_wlll(), _trap5_wwl(), _trap5_wllwl(), _trap5_wlwwlwll(),
  310.     _trap5_wwllllll(), trap_1_wwwll();
  311.  
  312. #endif /* __MSHORT__ */
  313. #endif /* !__NO_INLINE__ */
  314.  
  315. /*
  316.  * data structs
  317.  */
  318. typedef struct {
  319.     BASEPAGE *basepage;        /* gemdos basepage (extern BASEPAGE *_base) */
  320.     short max_proc;        /* max processes                        */
  321.     short max_msgs;        /* max system message buffers                  */
  322.     short max_queues;        /* max message queue                        */
  323.     void (*create_call)();    /* process creation hook     */
  324.     void (*delete_call)();    /* process delete hook        */
  325.     void (*switch_call)();    /* process (re)schedule hook    */
  326. } CONFIG;
  327.  
  328. typedef struct {        /* RTX process status */
  329.     unsigned short    unused1:10;
  330.     unsigned short    EWAIT:1;    /* blocked for event */
  331.     unsigned short    QWAIT:1;    /* blocked for queue */
  332.     unsigned short    PAUSED:1;    /* blocked for timer */
  333.     unsigned short    RUNNING:1;    /* running         */
  334.     unsigned short    READY:1;    /* ready to run         */
  335.     unsigned short    unused2:1;
  336. } PROCESS_STATE;
  337.  
  338. typedef struct {    /* RTX sgtty */
  339.     unsigned short    unused1:7;
  340.     unsigned short    FD_RAWIO:1;
  341.     unsigned short    FD_NOECHO:1;
  342.     unsigned short    FD_CLOSED:1;
  343.     unsigned short    FD_PIPE:1;
  344.     unsigned short    FD_STD:1;
  345.     unsigned short    FD_WRITE:1;
  346.     unsigned short    FD_READ:1;
  347.     unsigned short    FD_FILE:1;
  348.     unsigned short    FD_TTY:1;
  349. } RTXTTY;
  350.  
  351.  
  352. #define rtx_install(conf) \
  353.     (char *)_trap5_wl((short)0x00, (CONFIG *)(conf))
  354.  
  355. #define p_create(name, priority, slice, load, arg_count, args, stack_size)  \
  356.     (char *)_trap5_wlwwlwll((short)0x01, (char *)(name), (short)(priority), \
  357.                 (short)(slice), (void(*)())(load),            \
  358.                 (short)(arg_count), (char *)(args),             \
  359.                 (long)(stack_size))
  360. #define     p_delete(pid) \
  361.     (short)_trap5_wl((short)0x02, (char *)(pid))
  362.  
  363. #define     p_priority(pid, delta) \
  364.     (short)_trap5_wlw((short)0x03, (char *)pid, (short)(delta))
  365.  
  366. #define        p_slice(pid, delta) \
  367.     (short)_trap5_wlw((short)0x04, (char *)(pid), (short)(delta))
  368.  
  369. #define        q_create(name, mode) \
  370.     (char *)_trap5_wlw((short)0x05, (char *)(name), (short)(mode))
  371.  
  372. #define     q_delete(qid) \
  373.     (short)_trap5_wl((short)0x06, (char *)(qid))
  374.  
  375. #define        q_send(qid, msg) \
  376.     (short)_trap5_wll((short)0x07, (char *)(qid), (long *)(msg))
  377.  
  378. #define        q_req(qid, msg, nowait_option, timeout) \
  379.     (short)_trap5_wllwl((short)0x08, (char *)(qid), (long *)(msg), \
  380.                       (short)(nowait_option), (long)(timeout))
  381.  
  382. #define        q_jam(qid, msg) \
  383.     (short)_trap5_wll((short)0x09, (char *)(qid), (long *)(msg))
  384.  
  385. #define        e_signal(pid, event) \
  386.     (short)_trap5_wlw((short)0x0a, (char *)(pid), (short)(event))
  387.  
  388. #define        e_wait(event, condition, timeout) \
  389.     (short)_trap5_wlwl((short)0x0b, (short *)(event), (short)(condition), \
  390.                (long)(timeout))
  391.  
  392. #define        p_pause(msec) \
  393.     (short)_trap5_wl((short)0x0c, (long)(msec))
  394.  
  395. #define        m_alloc(size) \
  396.     (void *)_trap5_wl((short)0x0d, (unsigned long)(size))
  397.  
  398. #define        m_free(segment) \
  399.     (short)_trap5_wl((short)0x0e, (void *)(segment))
  400.  
  401. #define     m_assign(segment, pid) \
  402.     (short)_trap5_wll((short)0x0f, (void *)(segment), (char *)(pid))
  403.  
  404. #define         p_lookup(name) \
  405.     (char *)_trap5_wl((short)0x010, (char *)(name))
  406.  
  407. #define         q_lookup(name) \
  408.     (char *)_trap5_wl((short)0x011, (char *)(name))
  409.  
  410.  
  411. #define        p_info(pid, state) \
  412.     (char *)_trap5_wll((short)0x012, (char *)(pid), (PROCESS_STATE *)(state))
  413.  
  414. #define     p_vector(pid, vector) \
  415.     (void *)_trap5_wll((short)0x013, (char *)(pid), (void *)(vector))
  416.  
  417. #define        p_suspend(pid)  /* ret type in manual does'nt jive */ \
  418.     (short)_trap5_wl((short)0x014, (char *)(pid))
  419.  
  420. #define        p_resume(pid)   /* ret type in manual does'nt jive */ \
  421.     (short)_trap5_wl((short)0x015, (char *)(pid))
  422.  
  423. #define        d_install(unit, name, constat, conin, conout, costat, cntrl) \
  424.     (short)_trap5_wwllllll((short)0x016, (short)(unit), (char *)(name), \
  425.                (void(*)())(constat), (void(*)())(conin),    \
  426.                (void(*)())(conout),  (void(*)())(costat),   \
  427.                (void(*)())(cntrl))
  428.  
  429. #define        d_cntrl(unit, parm) \
  430.     (short)_trap5_wwl((short)0x017, (short)(unit), (void *)(parm))
  431.  
  432. #define        q_info(qid, proc_q, msg_q) \
  433.     (short)_trap5_wlll((short)0x018, (char *)(qid), (short *)(proc_q), \
  434.                (short *)(msg_q))
  435.  
  436. #define     rtx_remove() \
  437.     (short)_trap5_w((short)0x0ff)
  438.  
  439. #define        Popen(fd) \
  440.     (short)trap_1_wl((short)0x100,(short *)(fd))
  441.  
  442. #define     Ftype(handle) \
  443.     (short)trap_1_ww((short)(0x101),(short)(handle))
  444.  
  445. #define        Flock(fd, flag, offset, length) \
  446.     (short)trap_1_wwwll((short)(0x102), (short)(fd), (short)(flag), \
  447.             (long)(offset), (long)(length))
  448.  
  449.  
  450. #define        Fcntrl(fd, mode) \
  451.     (RTXTTY)trap_1_www((short)(0x104), (short)(fd), (RTXTTY)(mode))
  452.     
  453. #define     Psettpa(size) \
  454.     (long)trap_1_wl((short)(0x103),(long)(size))
  455.  
  456. #define     Mquota(a) \
  457.     (long)trap_1_wl((short)(0x105), (long)(a))    /* is this correct?? */
  458.  
  459. #endif /* _RTXBIND_H */
  460.