home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / libsrc87 / sflonum.s < prev    next >
Encoding:
Text File  |  1993-07-30  |  8.9 KB  |  431 lines
  1. #
  2. #    Single prec. Floating point support code.  
  3. #
  4. #    A float looks like:
  5. #
  6. #    |S|E.x.p ... |M.a.n.t.i.s.s.a ... |
  7. #    +-+----------+--------------------+
  8. #
  9. #    where s is the sign bit, Exp is 8 bits of exponent, interpreted
  10. #    as E + 126, and Mantissa is 23 bits of fraction, with a
  11. #    hidden bit.  The point is to the left of the hidden bit.
  12. #
  13. #    All these routines have calling sequences like c routines,
  14. #    ie args on stack in backwards order, return values in d0
  15. #
  16.  
  17.  
  18. .text
  19.     .even
  20. .globl ___addsf3
  21. .globl __addsf3
  22. ___addsf3:
  23. __addsf3:
  24.     link    a6,#0        | dont need any locals
  25.     moveml    #0x3F00,sp@-    | save all data registers
  26.     movel    a6@(8),d0    | get a
  27.     beq    addsf_ret_b    |  zero .. just return b
  28.     movel    #23,d6        | shift count
  29.     movel    d0,d2        | get the exponent
  30.     lsrl    d6,d2        | and shift right
  31.     andl    #0xFF,d2    | no sign bit
  32.     subl    #126,d2        | offset the exponent
  33.     movel    a6@(12),d1    | get b
  34.     beq    addsf_ret_a
  35.     movel    d1,d3        | get the exponent for b
  36.     lsrl    d6,d3        | and shift right, with implicit extend
  37.     andl    #0xFF,d3    | make sure we didnt get a sign bit
  38.     subl    #126,d3        | off set this one too
  39.  
  40.     andl    #0x7FFFFF,d0    | mask a for mantissa
  41.     orl    #0x800000,d0    | and put in hidden bit
  42.     tstl    a6@(8)        | test the original value
  43.     bpl    addsf_1        | pos, ok
  44.     negl    d0        | neg, negate the mantissa
  45. addsf_1:
  46.     andl    #0x7FFFFF,d1    | mask b for mantissa
  47.     orl    #0x800000,d1    | ditto
  48.     tstl    a6@(12)        | test ...
  49.     bpl    addsf_2
  50.     negl    d1        | negate this one
  51. addsf_2:
  52.     cmpl    d2,d3        | compare Ea to Eb
  53.     blt    addsf_3        | Ea > Eb
  54.  
  55.     movel    d3,d5        | get Eb
  56.     subl    d2,d5        | subtract Ea
  57.     asrl    d5,d0        |  yielding count to shift Ma right
  58.     movel    d3,d5        | use this as resultant exponent
  59.     bra    addsf_4        | and go rejoin common part
  60. addsf_3:
  61.     movel    d2,d5        | get Ea
  62.     subl    d3,d5        | subtract Eb
  63.     asrl    d5,d1        |  yielding count to shift Mb right
  64.     movel    d2,d5        | use this as resultant exponent
  65.  
  66. addsf_4:
  67.     clrl    d7        | zap sign flag
  68.     addl    d1,d0        | add Mb to Ma
  69.  
  70.  
  71.     beq    addsf_z        | zero? ok, go return zero
  72.     bpl    addsf_5        | positive? ok, go scale it
  73.     negl    d0        | negate Mr
  74.     movel    #1,d7        | remember sign
  75. addsf_5:
  76.     btst    #24,d0        | carry?
  77.     beq    addsf_6        | nope, its ok as is
  78.     asrl    #1,d0        | shift right one
  79.     addql    #1,d5        | inc exp
  80.  
  81. | zzz check for overflow in here someplace
  82.  
  83. addsf_6:
  84.     btst    #23,d0        | got a bit in the right place yet?
  85.     bne    addsf_7        | yes, were done
  86.     lsll    #1,d0        | shift left one
  87.     subql    #1,d5        | dec exponent
  88.     bra    addsf_6
  89. addsf_7:
  90.     andl    #0x7FFFFF,d0    | zap out hidden bit
  91.     addl    #126,d5        | add offset to exp
  92.     andl    #0xFF,d5    | zap to 8 bits
  93.     movel    #23,d6        | shift count
  94.     lsll    d6,d5        | shift the exp up
  95.     orl    d5,d0        | stick the exp in
  96.     tstl    d7        | negative?
  97.     beq    addsf_ret_a
  98.     orl    #0x80000000,d0    | yup, negate it
  99.     bra    addsf_ret_a
  100. addsf_z:
  101.     clrl    d0
  102.     bra    addsf_ret_a
  103. addsf_ret_b:
  104.     movel    a6@(12),d0
  105. addsf_ret_a:
  106.     moveml    sp@+,#0x00FC    | snarf back all regs
  107.     unlk    a6
  108.     rts            | sigh
  109. # 
  110. # #ifdef L_negsf2
  111. # int
  112. # _negsf2 (a)
  113. #      union flt_or_int a;
  114. # {
  115. #   union flt_or_int intify;
  116. #   return INTIFY (-a.f);
  117. # }
  118. # #endif
  119.  
  120. .text
  121.     .even
  122. .globl ___negsf2
  123. .globl __negsf2
  124. ___negsf2:
  125. __negsf2:
  126.     movel    sp@(4),d0
  127.     beq    negsf2_z
  128.     eorl    #0x80000000,d0
  129. negsf2_z:
  130.     rts            | sigh
  131. # 
  132. # #ifdef L_subsf3
  133. # int
  134. # _subsf3 (a, b)
  135. #      union flt_or_int a, b;
  136. # {
  137. #   union flt_or_int intify;
  138. #   return INTIFY (a.f - b.f);
  139. # }
  140. # #endif
  141.  
  142. .text
  143.     .even
  144. .globl ___subsf3
  145. .globl __subsf3
  146. ___subsf3:
  147. __subsf3:
  148.     tstl    sp@(8)        | kludge.  just negate b and add
  149.     beq    subsf_bz    | zero.  dont bother
  150.     eorl    #0x80000000,sp@(8)    | negate it
  151.     jmp    ___addsf3
  152. subsf_bz:
  153.     movel    sp@(4),d0
  154.     rts
  155.  
  156. # 
  157. # #ifdef L_cmpsf2
  158. # int
  159. # _cmpsf2 (a, b)
  160. #      union flt_or_int a, b;
  161. # {
  162. #   union flt_or_int intify;
  163. #   if (a.f > b.f)
  164. #     return 1;
  165. #   else if (a.f < b.f)
  166. #     return -1;
  167. #   return 0;
  168. # }
  169. # #endif
  170.  
  171. .text
  172.     .even
  173. .globl ___cmpsf2
  174. .globl __cmpsf2
  175. ___cmpsf2:
  176. __cmpsf2:
  177.     movel    sp@(4),d0    | get a
  178.     movel    sp@(8),d1    | get b
  179.  
  180.     bpl    cmpsf2_p
  181.     tstl    d0
  182.     bpl    cmpsf2_p
  183.     cmpl    d1,d0
  184.     bgt    cmpsf2_m
  185.     blt    cmpsf2_1
  186. cmpsf2_z:
  187.     clrl    d0
  188.     rts
  189. cmpsf2_p:
  190.     cmpl    d1,d0
  191.     bgt    cmpsf2_1
  192.     beq    cmpsf2_z
  193. cmpsf2_m:
  194.     movel    #-1,d0
  195.     rts
  196. cmpsf2_1:
  197.     movel    #1,d0
  198.     rts            | sigh
  199. # 
  200. # #ifdef L_mulsf3
  201. # int
  202. # _mulsf3 (a, b)
  203. #      union flt_or_int a, b;
  204. # {
  205. #   union flt_or_int intify;
  206. #   return INTIFY (a.f * b.f);
  207. # }
  208. # #endif
  209.  
  210. .text
  211.     .even
  212. .globl ___mulsf3
  213. .globl __mulsf3
  214. ___mulsf3:
  215. __mulsf3:
  216. |
  217. | multiply.  take the numbers apart.  shift each exponent down to
  218. | 16 bits.  unsigned multiply those.  shift that down to 24 bits.
  219. | exponent is Ea + Eb.
  220. |
  221.  
  222.     link    a6,#-8        | 64 bit accum for mult
  223.     moveml    #0x3F00,sp@-    | save all data registers
  224.     movel    a6@(8),d0    | get a
  225.     beq    mulsf3_z
  226.     movel    a6@(12),d1    | get b
  227.     beq    mulsf3_z
  228.     movel    #23,d6        | shift count
  229.     movel    d0,d2        | get the exponent
  230.     lsrl    d6,d2        | and shift right
  231.     andl    #0xFF,d2
  232.     subl    #126,d2        | offset the exponent
  233.     movel    d1,d3        | get the exponent for b
  234.     lsrl    d6,d3        | and shift right
  235.     andl    #0xFF,d2
  236.     subl    #126,d3        | off set this one too
  237.  
  238.     clrl    d7        | negative result flag
  239.     andl    #0x7FFFFF,d0    | mask a for mantissa
  240.     orl    #0x800000,d0    | and put in hidden bit
  241.     tstl    a6@(8)        | test the original value
  242.     bpl    mulsf3_1    | pos, ok
  243.     eorl    #1,d7        | remember negative
  244. mulsf3_1:
  245.     andl    #0x7FFFFF,d1    | mask b for mantissa
  246.     orl    #0x800000,d1    | ditto
  247.     tstl    a6@(12)        | test ...
  248.     bpl    mulsf3_2
  249.     eorl    #1,d7
  250. mulsf3_2:
  251. |    lsrl    #8,d1        | shift this one down
  252. |    lsrl    #8,d0        | this one too...
  253. |    mulu    d1,d0        | do the multiply
  254.  
  255. |    beq    mulsf3_ret    | zero? ok, just return
  256. |    lsrl    #8,d0        | shift right again
  257.  
  258. |
  259. | we have mantissas as follows:
  260. |
  261. |    |...ah...|...al...|    |...bh...|...bl...|
  262. |
  263. | product is composed as:
  264. |
  265. |            |....al * bl....|
  266. |        |....al * bh....|
  267. |        |....ah * bl....|
  268. |    |....ah * bh....|
  269. |
  270. | then take the 24 bit chunk thats 16 bits in.
  271.  
  272.     movel    d0,d4
  273.     andl    #0xFFFF,d4    | al
  274.     movel    d1,d5
  275.     andl    #0xFFFF,d5    | bl
  276.     mulu    d5,d4        | thats al * bl
  277.     movel    d4,a6@(-4)    | into the accum
  278.     clrl    a6@(-8)        | zap the top part
  279.  
  280.     movel    d0,d4
  281.     andl    #0xFFFF,d4    | al
  282.     movel    d1,d5
  283.     movel    #16,d6        | shift count
  284.     lsrl    d6,d5        | bh
  285.     mulu    d5,d4        | al * bh
  286.     addl    d4,a6@(-6)
  287.  
  288.     movel    d0,d4
  289.     lsrl    d6,d4        | ah
  290.     movel    d1,d5
  291.     andl    #0xFFFF,d5    | bl
  292.     mulu    d5,d4        | ah * bl
  293.     addl    d4,a6@(-6)
  294.  
  295.     movel    d0,d4
  296.     lsrl    d6,d4        | ah
  297.     movel    d1,d5
  298.     lsrl    d6,d5        | bh
  299.     mulu    d5,d4        | ah * bh
  300.     addl    d4,a6@(-8)
  301.  
  302.     movel    a6@(-6),d0    | get the relevant part
  303.     lsrl    #8,d0        | and shift it down
  304.  
  305. mulsf3_norm:
  306.     btst    #23,d0        | normalized?
  307.     bne    mulsf3_ok
  308.     lsll    #1,d0
  309.     subql    #1,d2
  310.     bra    mulsf3_norm
  311.  
  312. mulsf3_ok:
  313.     andl    #0x7FFFFF,d0    | zap hidden bit
  314.     addl    d3,d2        | add Eb to Ea
  315.     addl    #126,d2        | fix offset
  316.     andl    #0xFF,d2    | whack to 8 bits
  317.     movel    #23,d6        | shift count
  318.     lsll    d6,d2        | shift up to right place
  319.     orl    d2,d0        | shove it in
  320.     tstl    d7        | sign neg?
  321.     beq    mulsf3_ret
  322.     orl    #0x80000000,d0    | set sign bit
  323.     bra    mulsf3_ret
  324. mulsf3_z:
  325.     clrl    d0
  326. mulsf3_ret:
  327.     moveml    sp@+,#0x00FC    | snarf back all regs
  328.     unlk    a6
  329.     rts            | sigh
  330. # 
  331. # #ifdef L_divsf3
  332. # int
  333. # _divsf3 (a, b)
  334. #      union flt_or_int a, b;
  335. # {
  336. #   union flt_or_int intify;
  337. #   return INTIFY (a.f / b.f);
  338. # }
  339. # #endif
  340.  
  341. .text
  342.     .even
  343. .globl ___divsf3
  344. .globl __divsf3
  345. ___divsf3:
  346. __divsf3:
  347. |
  348. | divide.  sort of like mult, exc we do shifts and subtracts to
  349. | do the division of the mantissa.  resultant exponent is Ea - Eb.
  350. |
  351.  
  352.     link    a6,#0        | dont need any locals
  353.     moveml    #0x3F00,sp@-    | save all data registers
  354.     movel    a6@(8),d0    | get a
  355.     movel    a6@(12),d1    | get b
  356.     movel    #23,d6        | shift count
  357.     movel    d0,d2        | get the exponent
  358.     lsrl    d6,d2        | and shift right
  359.     andl    #0xFF,d2
  360.     subl    #127,d2        | offset the exponent
  361.     movel    d1,d3        | get the exponent for b
  362.     lsrl    d6,d3        | and shift right
  363.     andl    #0xFF,d3
  364.     subl    #127,d3        | off set this one too
  365.  
  366.     clrl    d7        | negative result flag
  367.     andl    #0x7FFFFF,d0    | mask a for mantissa
  368.     orl    #0x800000,d0    | and put in hidden bit
  369.     tstl    a6@(8)        | test the original value
  370.     bpl    divsf3_1    | pos, ok
  371.     eorl    #1,d7        | remember negative
  372. divsf3_1:
  373.     andl    #0x7FFFFF,d1    | mask b for mantissa
  374.     orl    #0x800000,d1    | ditto
  375.     tstl    a6@(12)        | test ...
  376.     bpl    divsf3_2
  377.     eorl    #1,d7
  378. divsf3_2:
  379. |
  380. | for now, kludge.  shift Ma left and Mb right, then do an unsigned divide
  381. | and shift the result left.  Blech
  382. |
  383.  
  384. |    lsrl    #8,d1        | shift this one down
  385. |    lsll    #7,d0        | this one up
  386. |    divu    d1,d0        | do the divide
  387. |    andl    #0xFFFF,d0    | and mask off cruft
  388.  
  389. |    beq    divsf3_ret    | zero? ok, just return
  390. |    lsll    #8,d0        | shift left again
  391.  
  392. | same sort of trick as long divide, exc its easier here, cause
  393. | the numbers (mantissas) are already bit-aligned.
  394.  
  395.     clrl    d4        | accumulator
  396.     movel    #0x800000,d5    | bit
  397.     lsll    #7,d0        | buy a little extra accuracy...
  398.     lsll    #7,d1
  399. divsf3_2a:
  400.     cmpl    d1,d0        | compare dividend to divisor
  401.     bmi    divsf3_2b    | nope, no bit here
  402.     orl    d5,d4        | put in the bit
  403.     subl    d1,d0        | and subtract
  404. divsf3_2b:
  405.     lsrl    #1,d1        | slide divisor down
  406.     lsrl    #1,d5        | slide bit down
  407.     bne    divsf3_2a    | and go round again
  408.     movel    d4,d0        | leave the result here
  409.  
  410. divsf3_3:
  411.     btst    #23,d0        | right place yet?
  412.     bne    divsf3_4
  413.     lsll    #1,d0
  414.     subql    #1,d2
  415.     bra    divsf3_3
  416. divsf3_4:
  417.     andl    #0x7FFFFF,d0    | zap hidden bit
  418.     subl    d3,d2        | sub Eb from Ea
  419.     addl    #127,d2        | fix offset
  420.     andl    #0xFF,d2    | whack to 8 bits
  421.     lsll    d6,d2        | shift up to right place
  422.     orl    d2,d0        | shove it in
  423.     tstl    d7        | sign neg?
  424.     beq    divsf3_ret
  425.     orl    #0x80000000,d0    | set sign bit
  426. divsf3_ret:
  427.     moveml    sp@+,#0x00FC    | snarf back all regs
  428.     unlk    a6
  429.  
  430.     rts            | sigh
  431.