home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / libsrc87 / traps.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-30  |  17.8 KB  |  674 lines
  1. /*
  2.  * TOS traps for 32 bit lib
  3.  *    ++jrb
  4.  *
  5.  * 10/29/89
  6.  *    constraint changes corresponding to changes documented at the
  7.  *    top of <osbind.h>. (stricter constraint ("r") for inputs to
  8.  *    ensure that ea's are evaluated before we change the stack
  9.  *    from under gcc's nose (without a way of telling it so). See
  10.  *    osbind.h for more details.
  11.  */
  12.  
  13. #ifndef __MSHORT__
  14.  
  15. long trap_1_w(short n)
  16. {
  17.        register long retvalue;
  18.  
  19.        asm volatile
  20.        ("\
  21.                movw    %1,sp@-; \
  22.                trap    #1;      \
  23.                addqw   #2,sp;   \
  24.                movl d0,%0"
  25.         : "=g"(retvalue)                       /* outputs */
  26.          : "r"(n)                              /* inputs  */
  27.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  28.        );
  29.        return retvalue;
  30. }
  31.  
  32.  
  33. long trap_1_ww(short n, short a)
  34. {
  35.        register long retvalue;
  36.  
  37.        asm volatile
  38.        ("\
  39.                 movw   %2,sp@-; \
  40.                movw    %1,sp@-; \
  41.                trap    #1;      \
  42.                addqw   #4,sp;   \
  43.                movl    d0,%0"
  44.         : "=g"(retvalue)                       /* outputs */
  45.          : "r"(n), "r"(a)                      /* inputs  */
  46.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  47.        );
  48.        return retvalue;
  49. }
  50.  
  51. long trap_1_wl(short n, long a)
  52. {
  53.        register long retvalue;
  54.  
  55.        asm volatile
  56.        ("\
  57.                 movl   %2,sp@-; \
  58.                movw    %1,sp@-; \
  59.                trap    #1;      \
  60.                addqw   #6,sp;   \
  61.                movl    d0,%0"
  62.         : "=g"(retvalue)                       /* outputs */
  63.          : "r"(n), "r"(a)                      /* inputs  */
  64.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  65.        );
  66.        return retvalue;
  67. }
  68.  
  69.  
  70. long trap_1_wlw(short n, long a, short b)
  71. {
  72.        register long retvalue;
  73.  
  74.        asm volatile
  75.        ("\
  76.                movw    %3,sp@-; \
  77.                 movl   %2,sp@-; \
  78.                movw    %1,sp@-; \
  79.                trap    #1;      \
  80.                addqw   #8,sp;   \
  81.                movl    d0,%0"
  82.         : "=g"(retvalue)                       /* outputs */
  83.          : "r"(n), "r"(a), "r"(b)              /* inputs  */
  84.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  85.        );
  86.        return retvalue;
  87. }
  88.  
  89.  
  90. long trap_1_wwll(short n, short a, long b, long c)
  91. {
  92.        register long retvalue;
  93.  
  94.        asm volatile
  95.        ("\
  96.                movl    %4,sp@-; \
  97.                movl    %3,sp@-; \
  98.                 movw   %2,sp@-; \
  99.                movw    %1,sp@-; \
  100.                trap    #1;      \
  101.                addw    #12,sp;  \
  102.                movl    d0,%0"
  103.         : "=g"(retvalue)                       /* outputs */
  104.          : "r"(n), "r"(a), "r"(b), "r"(c)      /* inputs  */
  105.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  106.        );
  107.        return retvalue;
  108. }
  109.  
  110.  
  111. long trap_1_wlww(short n, long a, short b, short c)
  112. {
  113.        register long retvalue;
  114.  
  115.        asm volatile
  116.        ("\
  117.                movw    %4,sp@-; \
  118.                movw    %3,sp@-; \
  119.                 movl   %2,sp@-; \
  120.                movw    %1,sp@-; \
  121.                trap    #1;      \
  122.                addw    #10,sp;  \
  123.                movl    d0,%0"
  124.         : "=g"(retvalue)                       /* outputs */
  125.          : "r"(n), "r"(a), "r"(b), "r"(c)      /* inputs  */
  126.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  127.        );
  128.        return retvalue;
  129. }
  130.  
  131.  
  132. long trap_1_www(short n, short a, short b)
  133. {
  134.        register long retvalue;
  135.  
  136.        asm volatile
  137.        ("\
  138.                movw    %3,sp@-; \
  139.                 movw   %2,sp@-; \
  140.                movw    %1,sp@-; \
  141.                trap    #1;      \
  142.                addqw   #6,sp;   \
  143.                movl    d0,%0"
  144.         : "=g"(retvalue)                       /* outputs */
  145.          : "r"(n), "r"(a), "r"(b)              /* inputs  */
  146.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  147.        );
  148.        return retvalue;
  149. }
  150.  
  151.  
  152. long trap_1_wll(short n, long a, long b)
  153. {
  154.        register long retvalue;
  155.  
  156.        asm volatile
  157.        ("\
  158.                movl    %3,sp@-; \
  159.                 movl   %2,sp@-; \
  160.                movw    %1,sp@-; \
  161.                trap    #1;      \
  162.                addw    #10,sp;  \
  163.                movl    d0,%0"
  164.         : "=g"(retvalue)                       /* outputs */
  165.          : "r"(n), "r"(a), "r"(b)              /* inputs  */
  166.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  167.        );
  168.        return retvalue;
  169. }
  170.  
  171.  
  172. long trap_1_wwlll(short n, short a, long b, long c, long d)
  173. {
  174.        register long retvalue;
  175.  
  176.        asm volatile
  177.        ("\
  178.                movl    %4,sp@-; \
  179.                movl    %3,sp@-; \
  180.                movl    %2,sp@-; \
  181.                 movw   %1,sp@-; \
  182.                movw    %0,sp@-; "
  183.         :                      /* outputs */
  184.          : "r"(n), "r"(a), "r"(b), "r"(c), "r"(d) /* inputs  */
  185.        );
  186.        /* no more than 5 operand allowed in asm() -- therefore the split */
  187.  
  188.        asm volatile
  189.        ("\
  190.                trap    #1;      \
  191.                addw    #16,sp;  \
  192.                movl    d0,%0"
  193.         : "=g"(retvalue)                       /* outputs */
  194.          :                                     /* inputs  */
  195.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  196.        );
  197.        return retvalue;
  198. }
  199.  
  200.  
  201. long trap_13_wl(short n, long a)
  202. {
  203.        register long retvalue;
  204.  
  205.        asm volatile
  206.        ("\
  207.                 movl   %2,sp@-; \
  208.                movw    %1,sp@-; \
  209.                trap    #13;     \
  210.                addqw   #6,sp;   \
  211.                movl    d0,%0"
  212.         : "=g"(retvalue)                       /* outputs */
  213.          : "r"(n), "r"(a)                      /* inputs  */
  214.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  215.        );
  216.        return retvalue;
  217. }
  218.  
  219. long trap_13_w(short n)
  220. {
  221.        register long retvalue;
  222.  
  223.        asm volatile
  224.        ("\
  225.                movw    %1,sp@-; \
  226.                trap    #13;     \
  227.                addqw   #2,sp;   \
  228.                movl    d0,%0"
  229.         : "=g"(retvalue)                       /* outputs */
  230.          : "r"(n)                              /* inputs  */
  231.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  232.        );
  233.        return retvalue;
  234. }
  235.  
  236.  
  237. long trap_13_ww(short n, short a)
  238. {
  239.        register long retvalue;
  240.  
  241.        asm volatile
  242.        ("\
  243.                 movw   %2,sp@-; \
  244.                movw    %1,sp@-; \
  245.                trap    #13;     \
  246.                addqw   #4,sp;   \
  247.                movl    d0,%0"
  248.         : "=g"(retvalue)                       /* outputs */
  249.          : "r"(n), "r"(a)                      /* inputs  */
  250.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  251.        );
  252.        return retvalue;
  253. }
  254.  
  255.  
  256. long trap_13_www(short n, short a, short c)
  257. {
  258.        register long retvalue;
  259.  
  260.        asm volatile
  261.        ("\
  262.                movw    %3,sp@-; \
  263.                 movw   %2,sp@-; \
  264.                movw    %1,sp@-; \
  265.                trap    #13;     \
  266.                addqw   #6,sp;   \
  267.                movl    d0,%0"
  268.         : "=g"(retvalue)                       /* outputs */
  269.          : "r"(n), "r"(a), "r"(c)              /* inputs  */
  270.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  271.        );
  272.        return retvalue;
  273. }
  274.  
  275. long trap_13_wwlwww(short n, short a, long c, short d,
  276.                                  short e, short f)
  277. {
  278.        register long retvalue;
  279.  
  280.        asm volatile
  281.        ("\
  282.                movw    %4,sp@-; \
  283.                movw    %3,sp@-; \
  284.                movw    %2,sp@-; \
  285.                movl    %1,sp@-; \
  286.                 movw   %0,sp@-  "
  287.         :                                      /* outputs */
  288.          : "r"(a), "r"(c), "r"(d), "r"(e), "r"(f) /* inputs  */
  289.        );
  290.  
  291.         asm volatile
  292.         ("\
  293.                movw    %1,sp@-; \
  294.                trap    #13;     \
  295.                addw    #14,sp;  \
  296.                movl    d0,%0"
  297.         : "=g"(retvalue)                       /* outputs */
  298.          : "r"(n)                              /* inputs  */
  299.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  300.        );
  301.  
  302.        return retvalue;
  303. }
  304.  
  305. long trap_13_wwl(short n, short a, long c)
  306. {
  307.        register long retvalue;
  308.  
  309.        asm volatile
  310.        ("\
  311.                movl    %3,sp@-; \
  312.                 movw   %2,sp@-; \
  313.                movw    %1,sp@-; \
  314.                trap    #13;     \
  315.                addqw   #8,sp;   \
  316.                movl    d0,%0"
  317.         : "=g"(retvalue)                       /* outputs */
  318.          : "r"(n), "r"(a), "r"(c)              /* inputs  */
  319.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  320.        );
  321.        return retvalue;
  322. }
  323.  
  324.  
  325. long trap_14_wwl(short n, short a, long c)
  326. {
  327.     register long retvalue;
  328.  
  329.     asm volatile
  330.     ("\
  331.         movl    %3,sp@-; \
  332.         movw    %2,sp@-; \
  333.         movw    %1,sp@-; \
  334.         trap    #14;    \
  335.         addqw   #8,sp;    \
  336.         movl    d0,%0"
  337.     : "=g"(retvalue)            /* outputs */
  338.     : "r"(n), "r"(a), "r"(c)                /* inputs  */
  339.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */
  340.     );
  341.     return retvalue;
  342. }
  343.  
  344. long trap_14_wwll(short n, short a, long c, long d)
  345. {
  346.        register long retvalue;
  347.  
  348.        asm volatile
  349.        ("\
  350.                movl    %4,sp@-; \
  351.                movl    %3,sp@-; \
  352.                 movw   %2,sp@-; \
  353.                movw    %1,sp@-; \
  354.                trap    #14;     \
  355.                addw    #12,sp;  \
  356.                movl    d0,%0"
  357.         : "=g"(retvalue)                       /* outputs */
  358.          : "r"(n), "r"(a), "r"(c), "r"(d)      /* inputs  */
  359.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  360.        );
  361.        return retvalue;
  362. }
  363.  
  364. long trap_14_ww(short n, short a)
  365. {
  366.        register long retvalue;
  367.  
  368.        asm volatile
  369.        ("\
  370.                 movw   %2,sp@-; \
  371.                movw    %1,sp@-; \
  372.                trap    #14;     \
  373.                addqw   #4,sp;   \
  374.                movl    d0,%0"
  375.         : "=g"(retvalue)                       /* outputs */
  376.          : "r"(n), "r"(a)                      /* inputs  */
  377.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  378.        );
  379.        return retvalue;
  380. }
  381.  
  382. long trap_14_w(short n)
  383. {
  384.        register long retvalue;
  385.  
  386.        asm volatile
  387.        ("\
  388.                movw    %1,sp@-; \
  389.                trap    #14;     \
  390.                addqw   #2,sp;   \
  391.                movl    d0,%0"
  392.         : "=g"(retvalue)                       /* outputs */
  393.          : "r"(n)                              /* inputs  */
  394.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  395.        );
  396.        return retvalue;
  397. }
  398.  
  399.  
  400. long trap_14_wllw(short n, long a, long c, short d)
  401. {
  402.        register long retvalue;
  403.  
  404.        asm volatile
  405.        ("\
  406.                movw    %4,sp@-; \
  407.                movl    %3,sp@-; \
  408.                 movl   %2,sp@-; \
  409.                movw    %1,sp@-; \
  410.                trap    #14;     \
  411.                addw    #12,sp;  \
  412.                movl    d0,%0"
  413.         : "=g"(retvalue)                       /* outputs */
  414.          : "r"(n), "r"(a), "r"(c), "r"(d)      /* inputs  */
  415.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  416.        );
  417.        return retvalue;
  418. }
  419.  
  420.  
  421. long trap_14_wl(short n, long a)
  422. {
  423.        register long retvalue;
  424.  
  425.        asm volatile
  426.        ("\
  427.                 movl   %2,sp@-; \
  428.                movw    %1,sp@-; \
  429.                trap    #14;     \
  430.                addqw   #6,sp;   \
  431.                movl    d0,%0"
  432.         : "=g"(retvalue)                       /* outputs */
  433.          : "r"(n), "r"(a)                      /* inputs  */
  434.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  435.        );
  436.        return retvalue;
  437. }
  438.  
  439.  
  440. long trap_14_www(short n, short a, short c)
  441. {
  442.        register long retvalue;
  443.  
  444.        asm volatile
  445.        ("\
  446.                movw    %3,sp@-; \
  447.                 movw   %2,sp@-; \
  448.                movw    %1,sp@-; \
  449.                trap    #14;     \
  450.                addqw   #6,sp;   \
  451.                movl    d0,%0"
  452.         : "=g"(retvalue)                       /* outputs */
  453.          : "r"(n), "r"(a), "r"(c)              /* inputs  */
  454.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  455.        );
  456.        return retvalue;
  457. }
  458.  
  459.  
  460. long trap_14_wllwwwww(short n, long a, long b, short c,
  461.                                    short d, short e, short f, short g)
  462. {
  463.        register long retvalue;
  464.  
  465.        asm volatile
  466.        ("\
  467.                movw    %4,sp@-; \
  468.                movw    %3,sp@-; \
  469.                movw    %2,sp@-; \
  470.                movw    %1,sp@-; \
  471.                movw    %0,sp@-  "
  472.         :                                        /* outputs */
  473.          : "r"(c), "r"(d), "r"(e), "r"(f), "r"(g) /* inputs  */
  474.        );
  475.  
  476.        asm volatile
  477.        ("\
  478.                movl    %3,sp@-; \
  479.                 movl   %2,sp@-; \
  480.                movw    %1,sp@-; \
  481.                trap    #14;     \
  482.                addw    #20,sp;  \
  483.                movl    d0,%0"
  484.         : "=g"(retvalue)                       /* outputs */
  485.          : "r"(n), "r"(a), "r"(b)              /* inputs  */
  486.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  487.        );
  488.        return retvalue;
  489. }
  490.  
  491.  
  492. long trap_14_wllwwwwlw(short n, long a, long b, short c,
  493.                                     short d, short e, short f, long g,
  494.                                     short h)
  495. {
  496.        register long retvalue;
  497.  
  498.        asm volatile
  499.        ("\
  500.                movw    %4,sp@-; \
  501.                movl    %3,sp@-; \
  502.                movw    %2,sp@-; \
  503.                movw    %1,sp@-; \
  504.                movw    %0,sp@-; "
  505.         :                                      /* outputs */
  506.          : "r"(d), "r"(e), "r"(f), "r"(g), "r"(h) /* inputs  */
  507.        );
  508.  
  509.        asm volatile
  510.        ("\
  511.                movw    %4,sp@-; \
  512.                movl    %3,sp@-; \
  513.                 movl   %2,sp@-; \
  514.                movw    %1,sp@-; \
  515.                trap    #14;     \
  516.                addw    #24,sp;  \
  517.                movl    d0,%0"
  518.         : "=g"(retvalue)                       /* outputs */
  519.          : "r"(n), "r"(a), "r"(b), "r"(c)      /* inputs  */
  520.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  521.        );
  522.        return retvalue;
  523. }
  524.  
  525. long trap_14_wllwwwwwlw(short n, long a, long b, short c,
  526.                       short d, short e, short f, short g,
  527.                       long h, short i)
  528. {
  529.     register long retvalue;
  530.  
  531.     asm volatile
  532.     ("\
  533.         movw    %4,sp@-; \
  534.         movl    %3,sp@-; \
  535.         movw    %2,sp@-; \
  536.         movw    %1,sp@-; \
  537.         movw    %0,sp@-; "
  538.     :                    /* outputs */
  539.     : "r"(e), "r"(f), "r"(g), "r"(h), "r"(i) /* inputs  */
  540.     );
  541.  
  542.     asm volatile
  543.     ("\
  544.         movw    %4,sp@-; \
  545.         movw    %3,sp@-; \
  546.         movl    %2,sp@-; \
  547.         movl    %1,sp@-; \
  548.                 movw    %0,sp@-; "
  549.     :                     /* outputs */
  550.     : "r"(n), "r"(a), "r"(b), "r"(c), "r"(d) /* inputs  */
  551.     );
  552.     asm volatile
  553.     ("\
  554.         trap    #14;    \
  555.         addw    #26,sp;    \
  556.         movl    d0,%0"
  557.     : "=g"(retvalue)            /* outputs */
  558.     :                     /* inputs  */
  559.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */
  560.     );
  561.     return retvalue;
  562. }
  563.  
  564.  
  565. long trap_14_wwwwwww(short n, short a, short b, short c,
  566.                                    short d, short e, short f)
  567. {
  568.        register long retvalue;
  569.  
  570.        asm volatile
  571.        ("\
  572.                movw    %4,sp@-; \
  573.                movw    %3,sp@-; \
  574.                movw    %2,sp@-; \
  575.                movw    %1,sp@-; \
  576.                movw    %0,sp@-; "
  577.         :                                      /* outputs */
  578.          : "r"(b), "r"(c),
  579.           "r"(d), "r"(e), "r"(f)               /* inputs  */
  580.        );
  581.  
  582.        asm volatile
  583.        ("\
  584.                 movw   %2,sp@-; \
  585.                movw    %1,sp@-; \
  586.                trap    #14;     \
  587.                addw    #14,sp;  \
  588.                movl    d0,%0"
  589.         : "=g"(retvalue)                       /* outputs */
  590.          : "r"(n), "r"(a)                      /* inputs  */
  591.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  592.        );
  593.        return retvalue;
  594. }
  595.  
  596. long trap_14_wlll(short n, long a, long b, long c)
  597. {
  598.        register long retvalue;
  599.  
  600.        asm volatile
  601.        ("\
  602.                movl    %4,sp@-; \
  603.                movl    %3,sp@-; \
  604.                 movl   %2,sp@-; \
  605.                movw    %1,sp@-; \
  606.                trap    #14;     \
  607.                addw    #14,sp;  \
  608.                movl    d0,%0"
  609.         : "=g"(retvalue)                       /* outputs */
  610.          : "r"(n), "r"(a), "r"(b), "r"(c)      /* inputs  */
  611.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  612.        );
  613.        return retvalue;
  614. }
  615.  
  616.  
  617. long trap_14_wllww(short n, long a, long b, short c,
  618.                                 short d)
  619. {
  620.        register long retvalue;
  621.  
  622.        asm volatile
  623.        ("\
  624.                movw    %3,sp@-; \
  625.                movw    %2,sp@-; \
  626.                movl    %1,sp@-; \
  627.                movl    %0,sp@-; "
  628.          :                                     /* outputs */
  629.          : "r"(a), "r"(b), "r"(c), "r"(d)      /* inputs  */
  630.        );
  631.  
  632.        asm volatile
  633.        ("\
  634.                movw    %1,sp@-; \
  635.                trap    #14;     \
  636.                addw    #14,sp;  \
  637.                movl    d0,%0"
  638.         : "=g"(retvalue)                       /* outputs */
  639.         : "r"(n)                              /* inputs  */
  640.         : "d0", "d1", "d2", "a0", "a1", "a2"   /* clobbered regs */
  641.        );
  642.        return retvalue;
  643. }
  644.  
  645.  
  646. long trap_14_wwwwl(short n, short a, short b, short c, long d)
  647. {
  648.        register long retvalue;
  649.  
  650.        asm volatile
  651.        ("\
  652.                movl    %3,sp@-; \
  653.                movw    %2,sp@-; \
  654.                movw    %1,sp@-; \
  655.                movw    %0,sp@-; "
  656.          :                                     /* outputs */
  657.          : "r"(a), "r"(b), "r"(c), "r"(d)      /* inputs  */
  658.        );
  659.  
  660.        asm volatile
  661.        ("\
  662.                movw    %1,sp@-; \
  663.                trap    #14;     \
  664.                addw    #12,sp;  \
  665.                movl    d0,%0"
  666.          : "=g"(retvalue)                      /* outputs */
  667.          : "r"(n)                              /* inputs  */
  668.          : "d0", "d1", "d2", "a0", "a1", "a2"  /* clobbered regs */
  669.        );
  670.        return retvalue;
  671. }
  672.  
  673. #endif /* !__MSHORT__ */
  674.