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