开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
uss_dpopns.s
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：32k
源码类别：

VxWorks

开发平台：

C/C++

uss_dpopns.s：源码内容
  1. /* Copyright 1991-1992 Wind River Systems, Inc. */
  2. .data
  3. .globl _copyright_wind_river
  4. .long _copyright_wind_river
  6. /*
  7. modification history
  8. --------------------
  9. 01h,04sep98,yh   fixed DAINT for floor function.
  10. 01g,14mar95,tmk  inverted conditional assembly logic for 68000/10 to allow for
  11.  CPUs other than 68020.
  12. 01f,23aug92,jcf  changed bxxx to jxx.
  13. 01e,26may92,rrr  the tree shuffle
  14. 01d,30mar92,kdl  added include of "uss_fp.h"; commented-out ".set" directives
  15.  (SPR #1398).
  16. 01c,04oct91,rrr  passed through the ansification filter
  17.   -changed ASMLANGUAGE to _ASMLANGUAGE
  18.   -changed copyright notice
  19. 01b,29jan91,kdl  added include of vxWorks.h for conditional assembly.
  20. 01a,28jan91,kdl  modified original US Software version to use conditional
  21.  assembly for 68000/10 multiply and divide operations.
  22. */
  25. /*
  26. DESCRIPTION
  28. |       ttl     FPAC 68K/DPOPNS: IEEE Double Precision Operations
  29. |DPOPNS idnt    1,0             ; IEEE Double Precision Operations
  30. |                               ; DPOPNS.A68
  31. |
  32. | * * * * * * * * * *
  33. |
  34. |       Copyright (c) 1985,1989 by
  35. |       United States Software Corporation
  36. |       14215 N.W. Science Park Drive
  37. |       Portland, Oregon  97229
  38. |
  39. |       This software is furnished under a license and may be used
  40. |       and copied only in accordance with the terms of such license
  41. |       and with the inclusion of the above copyright notice.
  42. |       This software or any other copies thereof may not be provided
  43. |       or otherwise made available to any other person.  No title to
  44. |       and ownership of the software is hereby transferred.
  45. |
  46. |       The information in this software is subject to change without
  47. |       notice and should not be construed as a commitment by United
  48. |       States Software Corporation.
  49. |
  50. |       Released:       12 January 1989         V2.0
  51. |
  52. | * * * * * * * * * *
  53. |
  54. |
  56. NOMANUAL
  57. */
  59. #define _ASMLANGUAGE
  60. #include "vxWorks.h"
  61. #include "uss_fp.h"
  63. |      .set    comp64,0                |flag for 64 bit multiply/divide
  65. |       opt     BRS             ; Default to forward branches SHORT
  66. |
  67.         .globl  DFLOAT
  68.         .globl  DFIX
  69.         .globl  DINT
  70.         .globl  DAINT
  71.         .globl  DPADD
  72.         .globl  DPMUL
  73.         .globl  DPDIV
  74.         .globl  DPRDIV
  75.         .globl  DPCMP
  76. |
  77.         .globl  DNANRS
  78.         .globl  DINFRS
  79.         .globl  DUNFRS
  80.         .globl  DZERRS
  81. |
  82.         .globl  GETDP1,DOPRSL
  83. |
  84. |
  85. |
  86. |       .set    DBIAS,1023              | Double precision format exponent bias
  87. |
  88. |
  89. |       .set    CCRC,0x01               | Carry bit in CCR
  90. |       .set    CCRV,0x02               | Overflow bit in CCR
  91. |       .set    CCRZ,0x04               | Zero bit in CCR
  92. |       .set    CCRN,0x08               | Negative bit in CCR
  93. |       .set    CCRX,0x10               | Extend bit in CCR
  94. |
  95. |
  96. |       .set    ERNAN,3
  97. |       .set    EROVF,2
  98. |       .set    ERUNF,1
  99. |
  100. |       xref    FPERR
  101. |       xref    NANFLG
  102. |       xref    INFFLG
  103. |       xref    UNFFLG
  104. |
  105. |
  106.         .text
  107. |
  108. /*
  109. |       page
  110. |
  111. |  DFLOAT
  112. |  ======
  113. |  Float the integer value in D0:D1 into a double precision floating
  114. |  point value on the stack.
  115. |
  116. */
  118. DFLOAT:
  119.         moveal  sp@+,a0 | Return addr into a0
  120.         subal   a2,a2           | Set a2 = 0
  121.         andl    d0,d0
  122.         jne     DFLT01          | J/ value <> 0
  123.         andl    d1,d1
  124.         jne     DFLT02          | J/ value > 0
  125. |
  126.         movel   d0,sp@- | Place 0 value on stack
  127.         movel   d0,sp@-
  128.         jmp     a0@             | Return
  129. |
  130. DFLT01:
  131.         jge     DFLT02          | J/ value > 0
  132.         subql   #1,a2           | Set a2 = -1
  133.         negl    d1
  134.         negxl   d0
  135. |
  136. DFLT02:
  137.         movel   #DBIAS+63,d2    | Default bias value
  138.         andl    d0,d0
  139.         jne     DFLT03          | J/ 32 bit shift not required
  140. |
  141.         subw    #32,d2          | Reduce exponent
  142.         exg     d0,d1           | Do shift (since d0 is zero)
  143. |
  144. DFLT03:
  145.         cmpil   #0x0000FFFF,d0
  146.         jhi     DFLT04          | J/ 16 bit shift not required
  147. |
  148.         swap    d0              | Do the shift
  149.         swap    d1
  150.         movew   d1,d0
  151.         clrw    d1
  152.         subiw   #16,d2
  153. |
  154. DFLT04:
  155.         andl    d0,d0
  156.         jmi     DFLT07          | J/ value normalized
  157. |
  158. DFLT05:
  159.         subqw   #1,d2           | Dec exponent, shift mantissa
  160.         asll    #1,d1
  161.         roxll   #1,d0
  162.         jpl     DFLT05          | J/ more shifts to do
  163. |
  164. DFLT07:
  165.         exg     d0,d2           | Position to standard d0/d2:d3/a2 form
  166.         movel   d1,d3
  167.         jra     DOPRSL          | J/ double precision result (w/ round)
  168. /*
  169. |
  170. |       page
  171. |
  172. |  DFIX
  173. |  ====
  174. |  Routine to convert the double precision argument on the stack
  175. |  to an integer value (with a dropoff flag).
  176. |
  177. */
  179. DFIX:
  180.         bsr     GETDP1          | Extract/unpack one double prec val
  181.         bsr     DFIX00          | Use internal routine
  182.         jmp     a0@             | Return to caller
  183. |
  184. |
  185. DFIX00:
  186.         andw    d0,d0
  187.         jne     DFIX01          | J/ value <> 0.0
  188. |
  189.         subl    d0,d0           | Return a zero value, no drop off
  190.         clrl    d1
  191.         rts
  192. |
  193. DFIX01:
  194.         cmpiw   #DBIAS,d0
  195.         jcc     DFIX02          | J/ abs() >= 1.0  [BCC == BHS]
  196. |
  197.         clrl    d0              | Return a zero value
  198.         clrl    d1
  199.         orib    #CCRC+CCRX,ccr  | Set carry/extend bits
  200. | ##    ORI     #$11,CCR
  201.         rts
  202. |
  203. DFIX02:
  204.         subiw   #DBIAS+63,d0
  205.         jlt     DFIX03          | J/ abs() < 2^63
  206. |
  207.         moveq   #-1,d0          | Set d0:d1 to the maximum integer value
  208.         moveq   #-1,d1
  209.         lsrl    #1,d0           | d0:d1 = 0x7FFFFFFFFFFFFFFF
  210.         movel   a2,d2
  211.         subl    d2,d1           | Account for the sign of the arg.
  212.         subxl   d2,d0
  213.         rts
  214. |
  215. DFIX03:
  216.         clrl    d1              | Clear bit drop off accum
  217. |
  218.         negw    d0              | Positive shift count
  219.         cmpiw   #32,d0
  220.         jlt     DFIX04          | J/ less than a word shift
  221. |
  222.         andl    d3,d3
  223.         sne     d1              | Set d1 = 0FFH if d3 <> 0
  224. |
  225.         movel   d2,d3
  226.         clrl    d2
  227. |
  228.         subiw   #32,d0
  229. |
  230. DFIX04:
  231.         cmpiw   #16,d0
  232.         jlt     DFIX05          | J/ less than a swap left
  233. |
  234.         orw     d3,d1           | Accum any bits dropped off
  235. |
  236.         movew   d2,d3           | Do a swap shift (16 bits)
  237.         swap    d3
  238.         clrw    d2
  239.         swap    d2
  240. |
  241.         subiw   #16,d0
  242. |
  243. DFIX05:
  244.         subqw   #1,d0
  245.         jlt     DFIX07          | J/ shifting complete
  246. |
  247. DFIX06:
  248.         lsrl    #1,d2
  249.         roxrl   #1,d3
  250. |
  251.         roxll   #1,d1
  252. |
  253.         dbra    d0,DFIX06
  254. |
  255. DFIX07:
  256.         cmpaw   #0,a2           | Check for negative value
  257.         jeq     DFIX08          | J/ positive
  258. |
  259.         negl    d3
  260.         negxl   d2
  261. |
  262. DFIX08:
  263.         moveq   #-1,d0
  264.         addl    d1,d0           | Set carry if bits lost
  265. |
  266.         exg     d2,d0           | Move integer result to d0:d1
  267.         exg     d3,d1
  268.         rts
  269. /*
  270. |
  271. |       page
  272. |
  273. |  DINT
  274. |  ====
  275. |  Return the largest integer smaller than the argument provided
  276. |
  277. */
  279. DINT:
  280.         bsr     GETDP1
  281.         bsr     DFIX00
  282. |
  283.         jcc     DINT00          | J/ no bits lost
  284.         cmpaw   #0,a2
  285.         jeq     DINT00          | J/ not negative
  286.         subql   #1,d1           | Decrement integer value
  287.         jcc     DINT00          | J/ no borrow
  288.         subql   #1,d0
  289. DINT00:
  290.         jmp     a0@
  291. /*
  292. |
  293. |       page
  294. |
  295. |  DAINT
  296. |  =====
  297. |  Floating point corollary to the DINT function
  298. |
  299. */
  301. DAINT:
  302.         bsr     GETDP1
  303.         cmpiw   #DBIAS+52,d0    | Check for value too large
  304.         jcc     DAIN10          | J/ return with same value
  305. |
  306.         movew   d0,d4           | Copy the exponent value
  307.         subiw   #DBIAS-1,d4
  308.         jgt     DAIN02          | J/ abs() >= 1.0
  309. |
  310. cmpiw   #0, d2          | check if mantissa is zero
  311. jne     DAIN09
  312. cmpiw   #0, d3
  313. jeq     DAIN08
  315. DAIN09:
  316.         movew   a2,d4
  317.         jne     DAIN01          | J/ 0.0 > value > -1.0
  318. |
  319. DAIN08:
  320.         clrl    sp@-            | Return a zero value
  321.         clrl    sp@-
  322.         jmp     a0@
  323. |
  324. DAIN01:
  325.         clrl    sp@-            | Return -1.0
  326.         movel   #0xBFF00000,sp@-
  327.         jmp     a0@
  328. |
  329. DAIN02:
  330.         moveq   #-1,d1          | Fill d1 with ones
  331. |
  332.         cmpiw   #32,d4          | See which word needs to be masked
  333.         jle     DAIN03          | J/ low order word zeroed, mask hi wd
  334. |
  335.         subiw   #32,d4
  336.         lsrl    d4,d1           | Adjust mask
  337.         movel   d3,d4
  338.         andl    d1,d4           | Extract bits to drop
  339.         jeq     DAIN10          | J/ no drop off, return as provided
  340. |
  341.         eorl    d4,d3           | Strip the bits
  342.         cmpaw   #0,a2
  343.         jeq     DAIN10          | J/ positive number
  344. |
  345.         clrl    d4              | (for ADDX below)
  346.         addql   #1,d1           | Change mask to increment value
  347.         addl    d1,d3
  348.         addxl   d4,d2           | Perform any carry
  349.         jra     DAIN04          | J/ rejoin flow
  350. |
  351. DAIN03:
  352.         lsrl    d4,d1           | Adjust high word mask
  353.         movel   d2,d4
  354.         andl    d1,d4           | Get bits to strip
  355.         eorl    d4,d2           | Strip bits
  356. |
  357.         orl     d3,d4           | Record any dropped bits from lo word
  358.         clrl    d3              | Clear the low word
  359. |
  360.         tstl    d4
  361.         jeq     DAIN10          | J/ no dropoff
  362.         cmpaw   #0,a2
  363.         jeq     DAIN10          | J/ positive number
  364. |
  365.         addql   #1,d1           | Turn mask into increment value
  366.         addl    d1,d2
  367. |
  368. DAIN04:
  369.         jcc     DAIN10          | J/ no overflow
  370. |
  371.         roxrl   #1,d2           | Right shift the mantissa
  372. |**     ROXR.L  #1,D3           ; (not nec -> mantissa = 80..00)
  373.         addqw   #1,d0           | Bump the exponent
  374. |
  375. DAIN10:
  376.         jra     DOPRSL          | Return computed value
  377. /*
  378. |
  379. |       page
  380. |
  381. |  DPADD
  382. |  =====
  383. |  Double precision add routine
  384. |
  385. */
  387. DPADD:
  388.         bsr     GETDP2          | Fetch both operands
  389.         cmpiw   #0x7FF,d0
  390. |
  391.         jne     DPA010          | J/ operand not NaN/INF
  392. |
  393.         lsll    #1,d2           | Remove implicit bit
  394.         jne     DNANRS          | J/  ?  + NaN -> NaN
  395. |
  396.         cmpiw   #0x7FF,d1
  397.         jne     DINFRS          | J/  0,num + INF -> INF
  398. |
  399.         lsll    #1,d4           | Remove implicit bit
  400.         jne     DNANRS          | J/ INF + NaN -> NaN
  401. |
  402.         cmpal   a2,a3
  403.         jne     DNANRS          | J/ INF - INF -> NaN
  404.         jra     DINFRS          |    INF + INF -> INF
  405. |
  406. |
  407. DPA010:
  408.         cmpiw   #0x7FF,d1
  409.         jne     DPA040          | J/ not NaN or INF
  410. |
  411.         lsll    #1,d4           | Remove implicit bit
  412.         jne     DNANRS          | J/ NaN + 0,num -> NaN
  413. |
  414.         moveal  a3,a2           | Move sign over
  415.         jra     DINFRS          | INF result
  416. |
  417. |
  418. DPXSUB:
  419.         |dsw    0               | Entry for DPCMP
  420. |
  421. DPA040:
  422.         andw    d1,d1
  423.         jeq     DOPRSL          | J/ 0,num + 0 -> 0,num
  424. |
  425.         andw    d0,d0
  426.         jne     DPA045          | J/ no zeroes involved
  427. |
  428.         movew   d1,d0           | Copy over data
  429.         movel   d4,d2
  430.         movel   d5,d3
  431.         moveal  a3,a2
  432.         jra     DOPRSL
  433. |
  434. |
  435. DPA045:
  436.         |dsw    0
  437. |
  438.         cmpw    d1,d0
  439.         jcc     DPA060          | J/ op1.exp >= op2.exp
  440. |
  441.         exg     d2,d4           | Flip mantissas
  442.         exg     d3,d5
  443.         exg     d0,d1
  444.         exg     a2,a3
  445. |
  446. DPA060:
  447.         subw    d0,d1
  448.         negw    d1
  449.         cmpiw   #53,d1
  450.         jhi     DOPRSL          | J/ op2 too small to matter
  451. |
  452.         cmpiw   #32,d1
  453.         jlt     DPA061          | J/ less than a word shift
  454. |
  455.         movel   d4,d5
  456.         clrl    d4
  457. |
  458.         subiw   #32,d1
  459. |
  460. DPA061:
  461.         cmpiw   #16,d1
  462.         jlt     DPA062          | J/ less than a swap shift left
  463. |
  464.         movew   d4,d5           | Do a swap shift (16 bits)
  465.         clrw    d4
  466.         swap    d5
  467.         swap    d4
  468. |
  469.         subiw   #16,d1
  470. |
  471. DPA062:
  472.         moveq   #-1,d7          | Mask in d7
  473.         lsrl    d1,d7
  474.         rorl    d1,d4
  475.         rorl    d1,d5
  476.         andl    d7,d5           | Trim bits
  477.         eorl    d4,d5           | Mix in d4 -> d5 bits
  478.         andl    d7,d4           | Strip d4 -> d5 bits
  479.         eorl    d4,d5           | Finish   LSL  d0,d4:d5
  480. |
  481.         cmpal   a2,a3
  482.         jne     DPS100          | J/ subtract operation
  483. |
  484.         addl    d5,d3
  485.         addxl   d4,d2
  486.         jcc     DOPRSL          | J/ no carry out
  487. |
  488.         roxrl   #1,d2           | Handle carry out
  489.         roxrl   #1,d3
  490.         addqw   #1,d0           | Bump the exponent
  491.         jra     DOPRSL
  492. |
  493. |
  494. DPS100:
  495.         subl    d5,d3           | Do the subtract
  496.         subxl   d4,d2
  497.         jcc     DPS110
  498. |
  499.         negl    d3
  500.         negxl   d2
  501. |
  502.         moveal  a3,a2           | Flip sign
  503. |
  504. DPS110:
  505.         andl    d2,d2           | Normalization section
  506.         jne     DPS115          | J/ top word is not zero
  507. |
  508.         exg     d2,d3
  509.         subiw   #32,d0          | Reduce exponent appropriately
  510. |
  511.         andl    d2,d2
  512.         jeq     DZERRS          | J/ zero result
  513. |
  514. DPS115:
  515.         cmpil   #0x0000FFFF,d2
  516.         jhi     DPS118          | J/ less than a swap shift left
  517. |
  518.         swap    d2              | Do a swap shift (16 bits)
  519.         swap    d3
  520.         movew   d3,d2
  521.         clrw    d3
  522. |
  523.         subiw   #16,d0
  524. |
  525. DPS118:
  526.         tstl    d2
  527.         jmi     DOPRSL          | J/ normalized
  528. |
  529.         subqw   #1,d0           | Decrease exponent value
  530. DPS120:
  531.         lsll    #1,d3
  532.         roxll   #1,d2
  533.         dbmi    d0,DPS120       | J/ not normalized
  534. |
  535.         jra     DOPRSL
  536. /*
  537. |
  538. |       page
  539. |
  540. |  DPMUL
  541. |  =====
  542. |  Single precision multiply routine.
  543. |
  544. */
  546. DPMUL:
  547.         bsr     GETDP2          | Fetch both operands
  548.         movew   a2,d6
  549.         movew   a3,d7
  550.         eorw    d6,d7
  551.         moveaw  d7,a2           | /* Result's sign */
  552. |
  553.         andw    d0,d0
  554.         jne     DPM010          | J/ operand <> 0.0
  555. |
  556.         cmpiw   #0x7FF,d1
  557.         jeq     DNANRS          | J/ 0.0 * NaN,INF -> NaN
  558.         jra     DZERRS          | J/ 0.0 * 0.0,num -> 0.0
  559. |
  560. DPM010:
  561.         cmpiw   #0x7FF,d0
  562.         jne     DPM020          | J/ operand is a number
  563. |
  564.         lsll    #1,d2
  565.         jne     DNANRS          | J/ NaN *  ?  -> NaN
  566. |
  567.         andw    d1,d1
  568.         jeq     DNANRS          | J/ INF * 0.0 -> NaN
  569. |
  570.         cmpiw   #0x7FF,d1
  571.         jne     DINFRS          | J/ INF * num -> INF
  572.         lsll    #1,d4
  573.         jeq     DINFRS          | J/ INF * INF -> INF
  574.         jra     DNANRS          | J/ INF * NaN -> NaN
  575. |
  576. DPM020:
  577.         andw    d1,d1
  578.         jeq     DZERRS          | J/ num * 0.0 -> 0.0
  579. |
  580.         cmpiw   #0x7FF,d1
  581.         jne     DPM040          | J/ num * num
  582. |
  583.         lsll    #1,d4
  584.         jeq     DINFRS          | J/ num * INF -> INF
  585.         jra     DNANRS          | J/ num * NaN -> NaN
  586. |
  587. |
  588. DPM040:
  589.         addw    d1,d0           | Calculate result`s exponent
  590.         subw    #DBIAS-1,d0     | Remove double bias, assume shift
  591.         movew   d0,a3           | Save exponent in a3, free up d0
  592. |
  593. DPM050:
  594.         |dsw    0               | Entry for DPDIV......
  595.         movel   d2,d0           | A * D
  596.         movel   d5,d1
  597. #if (CPU != MC68000 && CPU != MC68010)
  598. |       ifne    comp64-1        ;+++++
  599.         mulul   d0,d0:d1
  600. #else
  601.         bsr     DPM500          | 32 x 32 partial multiply
  602. #endif
  603. |       endc                    ;+++++
  604.         movel   d0,d5           | Save word
  605. |
  606.         movel   d3,d0           | B * C
  607.         movel   d4,d1
  608. #if (CPU != MC68000 && CPU != MC68010)
  609. |       ifne    comp64-1        ;+++++
  610.         mulul   d0,d0:d1
  611. #else
  612.         bsr     DPM500          | 32 x 32 partial multiply
  613. #endif
  614. |       endc                    ;+++++
  615.         movel   d0,d3
  616. |
  617.         movel   d2,d0           | A * C
  618.         movel   d4,d1
  620. #if (CPU != MC68000 && CPU != MC68010)
  621. |       ifne    comp64-1        ;+++++
  622.         mulul   d0,d0:d1
  623. #else
  624.         bsr     DPM500          | 32 x 32 partial multiply
  625. #endif
  626. |       endc                    ;+++++
  627. |
  628.         clrl    d2              | Sum partial multiply results
  629.         addl    d5,d3
  630.         addxl   d2,d2           | Preserve possible carry out
  631.         addl    d1,d3
  632.         addxl   d0,d2
  633.         movew   a3,d0           | Restore exponent
  634. |
  635.         tstl    d2              | Check for normalized result
  636.         jmi     DOPRSL          | J/ result normalized
  637. |
  638.         asll    #1,d3           | One left shift to normalize
  639.         roxll   #1,d2
  640.         subqw   #1,d0
  641.         jra     DOPRSL
  643. #if (CPU == MC68000 || CPU == MC68010)
  644. |       ifne    comp64-1        ;+++++
  645. |
  646. |  DPM500: 32 x 32 partial multiply routine
  647. |
  648. |  Multiply D0 by D1 (long words) yielding a 64 bit result.
  649. |
  650. DPM500:
  651.         movew   d0,d6           | Copy over B
  652.         swap    d1
  653.         mulu    d1,d6           | Produce BC
  654.         swap    d0
  655.         swap    d1
  656.         movew   d1,d7
  657.         mulu    d0,d7           | Produce AD
  658.         addl    d6,d7           | Produce BC+AD in d6:d7
  659.         subxl   d6,d6
  660.         negl    d6
  661.         swap    d6              | Properly position BC+AD
  662.         swap    d7
  663.         movew   d7,d6
  664. |
  665.         movew   d1,d7           | Save D (slide in under BC+AD)
  666.         swap    d1
  667.         mulu    d0,d1           | Produce AC
  668.         swap    d0
  669.         mulu    d7,d0
  670.         clrw    d7              | Restore d6:d7
  671.         exg     d0,d1           | AC:BD, then result, in d0:d1
  672.         addl    d7,d1
  673.         addxl   d6,d0
  674.         rts
  675. #endif
  676. /*
  677. |       endc                    ;+++++
  678. |
  679. |       page
  680. |
  681. |  DPDIV
  682. |  =====
  683. |  Double precision division operation.
  684. |
  685. */
  687. DPRDIV:
  688.         bsr     GETDP2          | Get both operands
  689.         exg     a2,a3           | Flip the operands
  690.         exg     d0,d1
  691.         exg     d2,d4
  692.         exg     d3,d5
  693.         jra     DPD001
  694. |
  695. DPDIV:
  696.         bsr     GETDP2
  697. |
  698. DPD001:
  699.         movew   a2,d6           | /* Compute result's sign */
  700.         movew   a3,d7
  701.         eorw    d6,d7
  702.         moveaw  d7,a2
  703. |
  704.         andw    d0,d0
  705.         jne     DPD010          | J/ divisor is not zero
  706. |
  707.         andw    d1,d1
  708.         jeq     DNANRS          | J/ 0.0 / 0.0 -> NaN
  709.         cmpiw   #0x7FF,d1
  710.         jne     DINFRS          | J/ num / 0.0 -> INF
  711.         lsll    #1,d4
  712.         jeq     DINFRS          | J/ INF / 0.0 -> INF
  713.         jra     DNANRS          | J/ NaN / 0.0 -> NaN
  714. |
  715. DPD010:
  716.         cmpiw   #0x7FF,d0
  717.         jne     DPD020          | J/ divisor is a normal number
  718. |
  719.         lsll    #1,d2
  720.         jne     DNANRS          | J/  ?  / NaN -> NaN
  721.         andw    d1,d1
  722.         jeq     DZERRS          | J/ 0.0 / INF -> 0.0
  723.         cmpiw   #0x7FF,d1
  724.         jne     DUNFRS          | J/ num / INF -> 0.0 (w/ underflow)
  725.         jra     DNANRS          | J/ NaN,INF / INF -> NaN
  726. |
  727. DPD020:
  728.         andw    d1,d1
  729.         jeq     DZERRS          | J/ 0.0 / num -> 0.0
  730.         cmpiw   #0x7FF,d1
  731.         jne     DPD040          | J/ num / num
  732. |
  733.         lsll    #1,d4
  734.         jeq     DINFRS          | J/ INF / num -> INF
  735.         jra     DNANRS          | J/ NaN / num -> NaN
  737. DPD040:
  738. #if (CPU != MC68000 && CPU != MC68010)
  739.         subw    d0,d1
  740.         addw    #DBIAS,d1
  741.         movew   d1,d0
  742.         lsrl    #1,d4
  743.         roxrl   #1,d5
  744.         divul   d2,d4:d5
  745.         movel   d5,d7
  746.         mulul   d3,d6:d7
  747.         negl    d7
  748.         subxl   d6,d4
  749.         jcc     dpd54
  750. dpd53:
  751.         subl    #1,d5
  752.         addl    d3,d7
  753.         addxl   d2,d4
  754.         jcc     dpd53
  755.         cmpl    d2,d4
  756.         jne     dpd54
  757.         addl    #1,d5
  758.         clrl    d3
  759.         jra     dpd55
  760. dpd54:
  761.         divul   d2,d4:d7
  762.         movel   d7,d3
  763. dpd55:
  764.         movel   d5,d2
  765.         jmi     dpd52
  766.         addl    d3,d3
  767.         addxl   d2,d2
  768.         subl    #1,d0
  769. dpd52:
  770.         jra     DOPRSL
  773. #else
  775. |       ifne    comp64-1        ;+++++
  776. |
  777. /*
  778. |  Division Algorithm:
  779. |
  780. |  (1)  Use a two stage recipication approximation to obtain 1/B
  781. |       (a)  X0 = 1 / (B0 + B1)    (B0 is ms 16 bits of B, B1 = B - B0)
  782. |               = 1/B0 * (1 - B1/B0)  { accurate to 28+ bits)
  783. |       (b)  X1 = X0 * (2 - B*X0)  (N-R iteration, 55+ bits accuracy)
  784. |  (2)  Use DPMUL entry to produce A * X1 (64 bit computation)
  785. */
  787. |
  788. |
  789. |DPD040:
  790.         subw    d0,d1
  791.         addw    #DBIAS,d1               | Restore bias
  792.         movew   d1,a3           | Save exponent in a3
  793. |
  794.         movel   d5,sp@- | Save dividend mantissa on stack
  795.         movel   d4,sp@-
  796. |
  797.         moveq   #1,d6           | Create a 1.0 entry
  798.         rorl    #2,d6           | Set d4 = 4000 0000H
  799.         swap    d2
  800.         divu    d2,d6           | Top fifteen bits of 1/B
  801.         movew   d6,d4           | 1/B ultimately into d4:d5
  802.         movew   d6,d7           | Save for correction term
  803.         swap    d4              | Position MS word
  804.         clrw    d6              | Zero low order bits in d6
  805.         divu    d2,d6           | Division of shifted remainder
  806.         movew   d6,d4           | Complete 1/B approximation
  807. |
  808.         movel   d2,d6
  809.         clrw    d6              | Create a shifted C in d6 (16 bits)
  810.         lsrl    #1,d6           | Insure no division overflow
  811.         divu    d2,d6           | C/B approximation
  812.         mulu    d7,d6
  813.         lsrl    #8,d6           | Position correction term
  814.         lsrl    #7,d6
  815.         subl    d6,d4
  816.         lsll    #1,d4           | Left shift approximation
  817.         subxl   d6,d6           | Do not overflow
  818.         orl     d6,d4           | 28+ bit 1/B approx in d4, B in d2:d3
  819.         swap    d2
  820. |
  821.         movel   d4,d0           | Save X0 in d0
  822.         bsr     DPD500          | d4 * d2:d3 -> d2:d3 (in place)
  823.         negl    d3
  824.         negxl   d2
  825.         movel   d0,d4
  826.         bsr     DPD500
  827. |
  828.         asll    #1,d3
  829.         roxll   #1,d2
  830.         jcc     DPD080          | J/ no shift out
  831.         moveq   #-1,d2          | Set d2:d3 to FFFFFFFF:FFFFFFFF
  832.         moveq   #-1,d3
  833. DPD080:
  834.         |dsw    0
  835. |
  836.         movel   sp@+,d4 | Fetch dividend
  837.         movel   sp@+,d5
  838.         jra     DPM050
  839. |
  840. |  DPD500:  Multiply D2:D3 by D4, top 64 bits of result in D2:D3
  841. |
  842. DPD500:
  843.         movew   d2,d1
  844.         mulu    d4,d1           | BY partial product
  845.         swap    d2
  846.         swap    d3
  847.         movew   d3,d7
  848.         movew   d2,d6
  849.         mulu    d4,d7
  850.         mulu    d4,d6           | AY:CY in d6:d7
  851.         movew   d6,d7
  852.         clrw    d6
  853.         swap    d6
  854.         swap    d7              | LSR #16,d6:d7
  855.         addl    d1,d7
  856.         clrl    d1
  857.         addxl   d1,d6           | 00:BY + 0A:YC
  858. |
  859.         swap    d4
  860.         movew   d3,d5
  861.         movew   d2,d1
  862.         mulu    d4,d5
  863.         mulu    d4,d1           | AX:CX in d1:d5
  864.         addl    d5,d7
  865.         addxl   d1,d6           | AX:CX + 00:BY + 0A:CY
  866. |
  867.         swap    d2
  868.         swap    d3
  869.         mulu    d4,d3
  870.         mulu    d4,d2           | BX:DX in d2:d3
  871.         movew   d2,d3
  872.         clrw    d2
  873.         swap    d2
  874.         swap    d3              | LSR #16,d2:d3
  875.         addl    d7,d3
  876.         addxl   d6,d2           | Result in d2:d3
  877. |
  878.         swap    d4              | Restore d4
  879.         rts
  880. #endif
  881. |       endc                    ;+++++
  883. /*
  884. |
  885. |       page
  886. |
  887. |  DPCMP
  888. |  =====
  889. |  Single Precision comparison routine.
  890. |
  891. |  Compare the two arguments provided and set the condition code
  892. |  register bits N, Z, and V as follows:
  893. |
  894. |      N  Z  V   Relation
  895. |      =  =  =   ====================================
  896. |      1  0  0   X > Y   (X is top argument on stack)
  897. |      0  1  0   X = Y   (within FFUZZ specification)
  898. |      0  0  0   X < Y
  899. |      0  0  1   X does not compare to Y
  900. |
  901. |
  902. |
  903. |
  904. */
  906. |       .set    DFUZZ,51                | Fifty-one bits of fuzz
  908. DPCMP:
  909.         bsr     GETDP2
  910.         cmpiw   #0x7FF,d0
  911.         jne     DPC020          | J/ X is not INF or NaN
  912. |
  913.         lsll    #1,d2           | Remove implicit bit
  914.         jeq     DPC005          | J/ X is INF
  915. |
  916. DPC001:
  917.         |dsw    0               | **  X does not compare to Y  **
  918.         moveq   #CCRV,d0        | CCR V bit
  919.         movew   d0,ccr
  920.         jmp     a0@             | Return
  921. |
  922. DPC005:
  923.         cmpiw   #0x7FF,d1
  924.         jne     DPC009          | J/ Y is not INF or NaN
  925. |
  926.         lsll    #1,d4
  927.         jne     DPC001          | J/ Y is NaN (does not compare)
  928. |
  929.         cmpaw   a2,a3
  930.         jeq     DPC001          | /* J/ INF's with same sign - no compare */
  931. |
  932. DPC009:
  933.         movew   a2,d0           | /* Result based on compl. of X's sign */
  934.         eoriw   #CCRN,d0
  935.         jra     DPC011
  936. |
  937. DPC010:
  938.         movew   a3,d0           | /* Set result based on Y's sign */
  939. DPC011:
  940.         andiw   #CCRN,d0
  941.         movew   d0,ccr
  942.         jmp     a0@
  943. |
  944. |
  945. DPC020:
  946.         cmpiw   #0x7FF,d1
  947.         jne     DPC030          | J/ Y is not NaN or INF
  948. |
  949.         lsll    #1,d4
  950.         jne     DPC001          | J/ Y is NaN - no comparison
  951.         jra     DPC010          | /* Result is based on Y's sign */
  952. |
  953. DPC030:
  954.         cmpaw   a2,a3
  955.         jne     DPC010          | /* J/ signs different - use Y's sign */
  956. |
  957.         movew   d0,d6
  958.         movew   d0,d7           | /* Assume X's exp is larger */
  959.         subw    d1,d6           | Calc difference in exponents
  960.         jpl     DPC031          | J/ positive
  961.         movew   d1,d7           | /* Y's exp is larger */
  962.         negw    d6
  963. DPC031:
  964.         |dsw    0
  965. |
  966.         lsrw    #1,d6
  967.         jeq     DPC040          | Must subtract to obtain result
  968. |
  969.         subw    d0,d1
  970.         subxw   d0,d0           | Set d0 to sign of Y[exp]-X[exp]
  971.         movew   a2,d1
  972.         eorw    d1,d0           | Flip if negative values
  973.         jra     DPC011          | Result based on value in d0
  974. |
  975. DPC040:
  976.         movew   d7,sp@- | Save max exp value, return address
  977.         movel   a0,sp@-
  978. |
  979.         movew   a2,d7
  980.         notw    d7              | Flip sign of opnd (force subtract)
  981.         moveaw  d7,a2
  982. |
  983.         pea     DPC041
  984.         movel   sp@+,a0 | Return address in a0
  985. |
  986.         jra     DPXSUB
  987. |
  988. DPC041:
  989.         movel   sp@+,d0
  990.         movel   sp@+,d1
  991.         moveal  sp@,a0
  992.         movel   d1,sp@
  993.         movel   d0,sp@-
  994.         movel   a0,sp@-
  995.         bsr     GETDP1          | Fetch and unpack result
  996. |
  997.         movew   sp@+,d5 | Recall max exp value
  998. |
  999.         andw    d0,d0
  1000.         jeq     DPC050          | J/ zero result
  1001. |
  1002.         subw    d0,d5
  1003.         cmpiw   #DFUZZ,d5
  1004.         jge     DPC050          | J/ within FFUZZ specification - zero
  1005. |
  1006.         movew   a2,d0           | Sign of result into d0
  1007.         jra     DPC011          | Comparison result from sign of sub
  1008. |
  1009. DPC050:
  1010.         subw    d0,d0           | Force CCR to say "Z"
  1011.         jmp     a0@             | Return
  1012. /*
  1013. |
  1014. |       page
  1015. |
  1016. |  GETDP2
  1017. |  ======
  1018. |  Routine called to extract two double precision arguments from
  1019. |  the system stack and place them in the 68000`s registers.
  1020. |
  1021. */
  1023. GETDP2:
  1024.         moveal  sp@+,a1 | /* GETDP2's return address */
  1025.         moveal  sp@+,a0 | Calling routines return address
  1026. |
  1027.         movel   sp@+,d0 | Get TOS (source) operand
  1028.         movel   sp@+,d3 | Get low long word
  1029.         subw    d2,d2           | Clear carry
  1030.         roxll   #1,d0           | Sign bit to bit 0
  1031.         subxw   d2,d2           | Fill d2 with sign bit
  1032.         moveaw  d2,a2           | Sign bit info to a2
  1033.         roll    #8,d0           | Left justify mantissa, position exp
  1034.         roll    #3,d0
  1035.         movel   d0,d2           | Copy into mantissa register
  1036.         andiw   #0x7FF,d0       | Mask to exponent field
  1037.         jeq     GETD21          | J/ zero value
  1038. |
  1039.         eorw    d0,d2           | Zero exponent bits in d2
  1040.         lsrl    #1,d2           | Position mantissa
  1041.         bset    #31,d2          | Set implicit bit in d2
  1042.         roll    #8,d3           | Position lo long word of mantissa
  1043.         roll    #3,d3
  1044.         eorw    d3,d2           | Clever use of EOR to move bits
  1045.         andiw   #0xF800,d3      | Trim off bits moved into d2
  1046.         eorw    d3,d2           | Remove noise in d2
  1047. |
  1048. GETD21:
  1049.         |dsw    0
  1050. |
  1051.         movel   sp@+,d1 | Get NOS (source) operand
  1052.         movel   sp@+,d5
  1053.         subw    d4,d4           | Clear carry
  1054.         roxll   #1,d1           | Sign bit carry
  1055.         subxw   d4,d4           | Replicate sign bit throughout d4
  1056.         moveaw  d4,a3           | Sign bit info into a3
  1057.         roll    #8,d1           | Left justify mantissa, position exp
  1058.         roll    #3,d1
  1059.         movel   d1,d4           | Copy into mantissa register
  1060.         andiw   #0x7FF,d1       | Mask to exponent field
  1061.         jeq     GETD22          | J/ zero value
  1062. |
  1063.         eorw    d1,d4           | Zero exponent bits in d4
  1064.         lsrl    #1,d4           | Position mantissa
  1065.         bset    #31,d4          | Set implicit bit in d4
  1066.         roll    #8,d5           | Position low long word of mantissa
  1067.         roll    #3,d5
  1068.         eorw    d5,d4           | Clever use of EOR to move bits
  1069.         andiw   #0xF800,d5      | Trim off bits moved into d4
  1070.         eorw    d5,d4           | Remove noise in d4
  1071. |
  1072. GETD22:
  1073.         jmp     a1@             | Return to caller, its ret addr in a0
  1074. /*
  1075. |
  1076. |
  1077. |       page
  1078. |
  1079. |  GETDP1
  1080. |  ======
  1081. |  Routine called to extract a double precision argument from the
  1082. |  system stack and place it (unpacked) into the 68000's registers.
  1083. |
  1084. */
  1086. GETDP1:
  1087.         moveal  sp@+,a1 | /* Get GETDP1's return address */
  1088.         moveal  sp@+,a0 | Get calling routines return address
  1089. |
  1090.         movel   sp@+,d0 | Get argument
  1091.         movel   sp@+,d3
  1092.         subw    d2,d2           | Clear carry
  1093.         roxll   #1,d0           | Sign bit into carry
  1094.         subxw   d2,d2           | Replicate sign bit throughout d2
  1095.         moveaw  d2,a2           | Sign bit info into a2
  1096.         roll    #8,d0           | Left justify mantissa, position exp
  1097.         roll    #3,d0
  1098.         movel   d0,d2
  1099.         andiw   #0x7FF,d0       | Mask to exponent field
  1100.         jeq     GETD11          | J/ zero value
  1101. |
  1102.         eorw    d0,d2           | Zero exponent bits in d2
  1103.         lsrl    #1,d2           | Position mantissa
  1104.         bset    #31,d2          | Set implicit bit
  1105.         roll    #8,d3           | Position lo long word of mantissa
  1106.         roll    #3,d3
  1107.         eorw    d3,d2           | Clever use of EOR to move bits
  1108.         andiw   #0xF800,d3      | Trim off bits moved to d3
  1109.         eorw    d3,d2           | Remove noise in d2
  1110. |
  1111. GETD11:
  1112.         jmp     a1@             | Return to caller, its ret addr in a0
  1113. /*
  1114. |
  1115. |
  1116. |       page
  1117. |
  1118. |  DOPRSL
  1119. |  ======
  1120. |  Double precision floating point result (main entry w/ round).
  1121. |  Mantissa in D2:D3, exponent in D0, sign in A2, and return address
  1122. |  in A0.  Place a formatted value on the stack.
  1123. |
  1124. */
  1126. DOPRSL:
  1127.         addl    #0x400,d3       | Round the value
  1128.         jcc     DOPR01          | J/ no carry out
  1129.         addql   #1,d2
  1130.         jcc     DOPR01          | J/ no carry out
  1131. |
  1132.         roxrl   #1,d2           | Adjust mantissa and exponent
  1133.         roxrl   #1,d3
  1134.         addqw   #1,d0
  1135. |
  1136. DOPR01:
  1137.         andw    d0,d0
  1138.         jle     DUNFRS          | J/ underflow
  1139. |
  1140.         cmpiw   #0x7FF,d0       | Check for overflow
  1141.         jge     DINFRS          | J/ overflow
  1142. |
  1143.         andiw   #0xF800,d3      | Trim mantissa
  1144.         eorw    d2,d3           | EOR to move over 11 bits
  1145.         andiw   #0xF800,d2      | Remove bits moved
  1146.         eorw    d2,d3           | Remove noise in d3
  1147.         subw    d1,d1           | Clear carry
  1148.         roxll   #1,d2           | Implicit bit into carry
  1149.         addw    d0,d2           | Exponent into d2
  1150.         rorl    #8,d2           | Reposition high word
  1151.         rorl    #3,d2
  1152.         movew   a2,d0           | Sign bit into carry
  1153.         aslw    #1,d0
  1154.         roxrl   #1,d2
  1155.         rorl    #8,d3
  1156.         rorl    #3,d3
  1157.         movel   d3,sp@- | Place value on stack
  1158.         movel   d2,sp@-
  1159. |
  1160.         moveb   #0,FPERR        | No floating point error
  1161.         jmp     a0@             | Return
  1162. |
  1163. |
  1164. |
  1165. DNANRS:
  1166.         moveq   #-1,d0          | Set d0 to 0xFFFFFFFF
  1167.         movel   d0,sp@- | NaN value
  1168.         movel   d0,sp@-
  1169. |
  1170.         moveb   #ERNAN,FPERR
  1171.         moveb   #-1,NANFLG
  1172.         jmp     a0@
  1173. |
  1174. |
  1175. DINFRS:
  1176.         movel   a2,d0           | Get sign information
  1177.         movel   #0xFFE00000,d1
  1178.         aslw    #1,d0           | Sign bit into carry
  1179.         roxrl   #1,d1
  1180.         clrl    sp@-            | Low long word = 00000000
  1181.         movel   d1,sp@-
  1182. |
  1183.         moveb   #EROVF,FPERR
  1184.         moveb   #-1,INFFLG
  1185.         jmp     a0@
  1186. |
  1187. |
  1188. DUNFRS:
  1189.         moveb   #ERUNF,FPERR
  1190.         moveb   #-1,UNFFLG
  1191.         jra     DZER01
  1192. |
  1193. |
  1194. DZERRS:
  1195.         moveb   #0,FPERR
  1196. |
  1197. |
  1198. DZER01:
  1199.         clrl    sp@-
  1200.         clrl    sp@-
  1201.         jmp     a0@
  1202. |
  1203. |       end