home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / programm / programi / gcc_9112.lzh / include20 / inline / mathtrans.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-15  |  5.7 KB  |  292 lines
  1. #include <inline/stub.h>
  2. #ifndef BASE_EXT_DECL
  3. #define BASE_EXT_DECL extern struct MathTransBase * MathTransBase;
  4. #endif
  5. #ifndef BASE_PAR_DECL
  6. #define BASE_PAR_DECL
  7. #define BASE_PAR_DECL0 void
  8. #endif
  9. #ifndef BASE_NAME
  10. #define BASE_NAME MathTransBase
  11. #endif
  12. __inline static FLOAT SPAtan(BASE_PAR_DECL FLOAT parm)
  13. {
  14.     BASE_EXT_DECL
  15.     register FLOAT res __asm("d0");
  16.     register void *a6 __asm ("a6");
  17.     register FLOAT d0 __asm("d0");
  18.  
  19.     a6 = BASE_NAME;
  20.     d0 = parm;
  21.     __asm volatile ("
  22.     jsr a6@(-0x1e)"
  23.     : "=g" (res)
  24.     : "g" (a6), "g" (d0)
  25.     : "d0", "d1", "a0", "a1");
  26.     return res;
  27. }
  28. __inline static FLOAT SPSin(BASE_PAR_DECL FLOAT parm)
  29. {
  30.     BASE_EXT_DECL
  31.     register FLOAT res __asm("d0");
  32.     register void *a6 __asm ("a6");
  33.     register FLOAT d0 __asm("d0");
  34.  
  35.     a6 = BASE_NAME;
  36.     d0 = parm;
  37.     __asm volatile ("
  38.     jsr a6@(-0x24)"
  39.     : "=g" (res)
  40.     : "g" (a6), "g" (d0)
  41.     : "d0", "d1", "a0", "a1");
  42.     return res;
  43. }
  44. __inline static FLOAT SPCos(BASE_PAR_DECL FLOAT parm)
  45. {
  46.     BASE_EXT_DECL
  47.     register FLOAT res __asm("d0");
  48.     register void *a6 __asm ("a6");
  49.     register FLOAT d0 __asm("d0");
  50.  
  51.     a6 = BASE_NAME;
  52.     d0 = parm;
  53.     __asm volatile ("
  54.     jsr a6@(-0x2a)"
  55.     : "=g" (res)
  56.     : "g" (a6), "g" (d0)
  57.     : "d0", "d1", "a0", "a1");
  58.     return res;
  59. }
  60. __inline static FLOAT SPTan(BASE_PAR_DECL FLOAT parm)
  61. {
  62.     BASE_EXT_DECL
  63.     register FLOAT res __asm("d0");
  64.     register void *a6 __asm ("a6");
  65.     register FLOAT d0 __asm("d0");
  66.  
  67.     a6 = BASE_NAME;
  68.     d0 = parm;
  69.     __asm volatile ("
  70.     jsr a6@(-0x30)"
  71.     : "=g" (res)
  72.     : "g" (a6), "g" (d0)
  73.     : "d0", "d1", "a0", "a1");
  74.     return res;
  75. }
  76. __inline static FLOAT SPSincos(BASE_PAR_DECL FLOAT* cosResult, FLOAT parm)
  77. {
  78.     BASE_EXT_DECL
  79.     register FLOAT res __asm("d0");
  80.     register void *a6 __asm ("a6");
  81.     register FLOAT* d1 __asm("d1");
  82.     register FLOAT d0 __asm("d0");
  83.  
  84.     a6 = BASE_NAME;
  85.     d1 = cosResult;
  86.     d0 = parm;
  87.     __asm volatile ("
  88.     jsr a6@(-0x36)"
  89.     : "=g" (res)
  90.     : "g" (a6), "g" (d1), "g" (d0)
  91.     : "d0", "d1", "a0", "a1");
  92.     return res;
  93. }
  94. __inline static FLOAT SPSinh(BASE_PAR_DECL FLOAT parm)
  95. {
  96.     BASE_EXT_DECL
  97.     register FLOAT res __asm("d0");
  98.     register void *a6 __asm ("a6");
  99.     register FLOAT d0 __asm("d0");
  100.  
  101.     a6 = BASE_NAME;
  102.     d0 = parm;
  103.     __asm volatile ("
  104.     jsr a6@(-0x3c)"
  105.     : "=g" (res)
  106.     : "g" (a6), "g" (d0)
  107.     : "d0", "d1", "a0", "a1");
  108.     return res;
  109. }
  110. __inline static FLOAT SPCosh(BASE_PAR_DECL FLOAT parm)
  111. {
  112.     BASE_EXT_DECL
  113.     register FLOAT res __asm("d0");
  114.     register void *a6 __asm ("a6");
  115.     register FLOAT d0 __asm("d0");
  116.  
  117.     a6 = BASE_NAME;
  118.     d0 = parm;
  119.     __asm volatile ("
  120.     jsr a6@(-0x42)"
  121.     : "=g" (res)
  122.     : "g" (a6), "g" (d0)
  123.     : "d0", "d1", "a0", "a1");
  124.     return res;
  125. }
  126. __inline static FLOAT SPTanh(BASE_PAR_DECL FLOAT parm)
  127. {
  128.     BASE_EXT_DECL
  129.     register FLOAT res __asm("d0");
  130.     register void *a6 __asm ("a6");
  131.     register FLOAT d0 __asm("d0");
  132.  
  133.     a6 = BASE_NAME;
  134.     d0 = parm;
  135.     __asm volatile ("
  136.     jsr a6@(-0x48)"
  137.     : "=g" (res)
  138.     : "g" (a6), "g" (d0)
  139.     : "d0", "d1", "a0", "a1");
  140.     return res;
  141. }
  142. __inline static FLOAT SPExp(BASE_PAR_DECL FLOAT parm)
  143. {
  144.     BASE_EXT_DECL
  145.     register FLOAT res __asm("d0");
  146.     register void *a6 __asm ("a6");
  147.     register FLOAT d0 __asm("d0");
  148.  
  149.     a6 = BASE_NAME;
  150.     d0 = parm;
  151.     __asm volatile ("
  152.     jsr a6@(-0x4e)"
  153.     : "=g" (res)
  154.     : "g" (a6), "g" (d0)
  155.     : "d0", "d1", "a0", "a1");
  156.     return res;
  157. }
  158. __inline static FLOAT SPLog(BASE_PAR_DECL FLOAT parm)
  159. {
  160.     BASE_EXT_DECL
  161.     register FLOAT res __asm("d0");
  162.     register void *a6 __asm ("a6");
  163.     register FLOAT d0 __asm("d0");
  164.  
  165.     a6 = BASE_NAME;
  166.     d0 = parm;
  167.     __asm volatile ("
  168.     jsr a6@(-0x54)"
  169.     : "=g" (res)
  170.     : "g" (a6), "g" (d0)
  171.     : "d0", "d1", "a0", "a1");
  172.     return res;
  173. }
  174. __inline static FLOAT SPPow(BASE_PAR_DECL FLOAT power, FLOAT arg)
  175. {
  176.     BASE_EXT_DECL
  177.     register FLOAT res __asm("d0");
  178.     register void *a6 __asm ("a6");
  179.     register FLOAT d1 __asm("d1");
  180.     register FLOAT d0 __asm("d0");
  181.  
  182.     a6 = BASE_NAME;
  183.     d1 = power;
  184.     d0 = arg;
  185.     __asm volatile ("
  186.     jsr a6@(-0x5a)"
  187.     : "=g" (res)
  188.     : "g" (a6), "g" (d1), "g" (d0)
  189.     : "d0", "d1", "a0", "a1");
  190.     return res;
  191. }
  192. __inline static FLOAT SPSqrt(BASE_PAR_DECL FLOAT parm)
  193. {
  194.     BASE_EXT_DECL
  195.     register FLOAT res __asm("d0");
  196.     register void *a6 __asm ("a6");
  197.     register FLOAT d0 __asm("d0");
  198.  
  199.     a6 = BASE_NAME;
  200.     d0 = parm;
  201.     __asm volatile ("
  202.     jsr a6@(-0x60)"
  203.     : "=g" (res)
  204.     : "g" (a6), "g" (d0)
  205.     : "d0", "d1", "a0", "a1");
  206.     return res;
  207. }
  208. __inline static FLOAT SPTieee(BASE_PAR_DECL FLOAT parm)
  209. {
  210.     BASE_EXT_DECL
  211.     register FLOAT res __asm("d0");
  212.     register void *a6 __asm ("a6");
  213.     register FLOAT d0 __asm("d0");
  214.  
  215.     a6 = BASE_NAME;
  216.     d0 = parm;
  217.     __asm volatile ("
  218.     jsr a6@(-0x66)"
  219.     : "=g" (res)
  220.     : "g" (a6), "g" (d0)
  221.     : "d0", "d1", "a0", "a1");
  222.     return res;
  223. }
  224. __inline static FLOAT SPFieee(BASE_PAR_DECL FLOAT parm)
  225. {
  226.     BASE_EXT_DECL
  227.     register FLOAT res __asm("d0");
  228.     register void *a6 __asm ("a6");
  229.     register FLOAT d0 __asm("d0");
  230.  
  231.     a6 = BASE_NAME;
  232.     d0 = parm;
  233.     __asm volatile ("
  234.     jsr a6@(-0x6c)"
  235.     : "=g" (res)
  236.     : "g" (a6), "g" (d0)
  237.     : "d0", "d1", "a0", "a1");
  238.     return res;
  239. }
  240. __inline static FLOAT SPAsin(BASE_PAR_DECL FLOAT parm)
  241. {
  242.     BASE_EXT_DECL
  243.     register FLOAT res __asm("d0");
  244.     register void *a6 __asm ("a6");
  245.     register FLOAT d0 __asm("d0");
  246.  
  247.     a6 = BASE_NAME;
  248.     d0 = parm;
  249.     __asm volatile ("
  250.     jsr a6@(-0x72)"
  251.     : "=g" (res)
  252.     : "g" (a6), "g" (d0)
  253.     : "d0", "d1", "a0", "a1");
  254.     return res;
  255. }
  256. __inline static FLOAT SPAcos(BASE_PAR_DECL FLOAT parm)
  257. {
  258.     BASE_EXT_DECL
  259.     register FLOAT res __asm("d0");
  260.     register void *a6 __asm ("a6");
  261.     register FLOAT d0 __asm("d0");
  262.  
  263.     a6 = BASE_NAME;
  264.     d0 = parm;
  265.     __asm volatile ("
  266.     jsr a6@(-0x78)"
  267.     : "=g" (res)
  268.     : "g" (a6), "g" (d0)
  269.     : "d0", "d1", "a0", "a1");
  270.     return res;
  271. }
  272. __inline static FLOAT SPLog10(BASE_PAR_DECL FLOAT parm)
  273. {
  274.     BASE_EXT_DECL
  275.     register FLOAT res __asm("d0");
  276.     register void *a6 __asm ("a6");
  277.     register FLOAT d0 __asm("d0");
  278.  
  279.     a6 = BASE_NAME;
  280.     d0 = parm;
  281.     __asm volatile ("
  282.     jsr a6@(-0x7e)"
  283.     : "=g" (res)
  284.     : "g" (a6), "g" (d0)
  285.     : "d0", "d1", "a0", "a1");
  286.     return res;
  287. }
  288. #undef BASE_EXT_DECL
  289. #undef BASE_PAR_DECL
  290. #undef BASE_PAR_DECL0
  291. #undef BASE_NAME
  292.