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

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

VxWorks

开发平台：

C/C++

uss_fpopns.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. 01g,14mar95,tmk  inverted conditional assembly logic for 68000/10 to allow for
  10.  CPUs other than 68020.
  11. 01f,23aug92,jcf  changed bxxx to jxx.
  12. 01e,26may92,rrr  the tree shuffle
  13. 01d,30mar92,kdl  added include of "uss_fp.h"; commented-out ".set" directives
  14.  (SPR #1398).
  15. 01c,04oct91,rrr  passed through the ansification filter
  16.   -changed ASMLANGUAGE to _ASMLANGUAGE
  17.   -changed copyright notice
  18. 01b,29jan91,kdl  added include of vxWorks.h for conditional assembly.
  19. 01a,28jan91,kdl  modified original US Software version to use conditional
  20.  assembly for 68000/10 multiply and divide operations.
  21. */
  24. /*
  25. DESCRIPTION
  27. |       ttl     FPAC 68K/FPOPNS: IEEE Single Precision Operations
  28. |FPOPNS idnt    1,0             ; IEEE Single Precision Operations
  29. |                               ; FPOPNS.A68
  30. |
  31. | * * * * * * * * * *
  32. |
  33. |       Copyright (c) 1985,1989 by
  34. |       United States Software Corporation
  35. |       14215 N.W. Science Park Drive
  36. |       Portland, Oregon  97229
  37. |
  38. |       This software is furnished under a license and may be used
  39. |       and copied only in accordance with the terms of such license
  40. |       and with the inclusion of the above copyright notice.
  41. |       This software or any other copies thereof may not be provided
  42. |       or otherwise made available to any other person.  No title to
  43. |       and ownership of the software is hereby transferred.
  44. |
  45. |       The information in this software is subject to change without
  46. |       notice and should not be construed as a commitment by United
  47. |       States Software Corporation.
  48. |
  49. |       Released:       12 January 1989         V2.0
  50. |
  51. | * * * * * * * * * *
  52. |
  54. NOMANUAL
  55. */
  57. #define _ASMLANGUAGE
  58. #include "vxWorks.h"
  59. #include "uss_fp.h"
  62. |       .set    comp64,0                |the 64 bit multiply/divide flag
  64. |       opt     BRS             ; Default to forward branches SHORT
  65. |
  66.         .globl  FLOAT
  67.         .globl  FIX
  68.         .globl  INT
  69.         .globl  AINT
  70.         .globl  FPADD
  71.         .globl  FPMUL
  72.         .globl  FPDIV
  73.         .globl  FPRDIV
  74.         .globl  FPCMP
  75. |
  76.         .globl  GETFP1,FOPRSL
  77. |
  78.         .globl  FNANRS,FINFRS,FUNFRS,FZERRS
  79. |
  80. |
  81. |       xref    FPERR,NANFLG,INFFLG,UNFFLG
  82. |
  83. |
  84. |       .set    FBIAS,127               | Single precision format exponent bias
  85. |
  86. |
  87. |       .set    CCRC,0x01               | Carry bit in CCR
  88. |       .set    CCRV,0x02               | Overflow bit in CCR
  89. |       .set    CCRZ,0x04               | Zero bit in CCR
  90. |       .set    CCRN,0x08               | Negative bit in CCR
  91. |       .set    CCRX,0x10               | Extend bit in CCR
  92. |
  93. |
  94. |       .set    ERNAN,3
  95. |       .set    EROVF,2
  96. |       .set    ERUNF,1
  97. |
  98. |
  99.         .text           | General code section
  100. /*
  101. |
  102. |       page
  103. |
  104. |  FLOAT
  105. |  =====
  106. |  Float the integer value in D0 into a single precision floating
  107. |  point value on the stack.
  108. |
  109. */
  111. FLOAT:
  112.         moveal  sp@+,a0 | Return addr into a0
  113.         subal   a2,a2           | Set a2 = 0
  114.         andl    d0,d0
  115.         jne     FLT01           | J/ value <> 0
  116. |
  117.         movel   d0,sp@- | Place 0 value on stack
  118.         jmp     a0@             | Return
  119. |
  120. FLT01:
  121.         jge     FLT02           | J/ value > 0
  122.         subql   #1,a2           | Set a2 = -1
  123.         negl    d0
  124. |
  125. FLT02:
  126.         movel   #FBIAS+15,d2    | Default bias value
  127.         swap    d0
  128.         andw    d0,d0
  129.         jeq     FLT03           | J/ 16 bit shift required
  130. |
  131.         swap    d0              | Undo the shift
  132.         addw    #16,d2          | Reflect the larger number
  133. |
  134. FLT03:
  135.         andl    d0,d0
  136.         jmi     FLT06           | J/ value normalized
  137. |
  138. FLT04:
  139.         subqw   #1,d2           | Dec exponent, shift mantissa
  140.         asll    #1,d0
  141.         jpl     FLT04           | J/ more shifts to do
  142. |
  143. FLT06:
  144.         exg     d0,d2           | Position to standard d0/d2/a2 form
  145.         jra     FOPRSL          | J/ single precision result (w/ round)
  146. /*
  147. |
  148. |       page
  149. |
  150. |  FIX
  151. |  ===
  152. |  Routine to convert the single precision argument on the stack
  153. |  to an integer value (with a dropoff flag).
  154. |
  155. */
  157. FIX:
  158.         bsr     GETFP1          | Extract/unpack one single prec val
  159.         bsr     FIX00           | Use internal routine
  160.         jmp     a0@             | Return to caller
  161. |
  162. |
  163. FIX00:
  164.         andw    d0,d0
  165.         jne     FIX01           | J/ value <> 0.0
  166. |
  167.         subl    d0,d0           | Return a zero value, no drop off
  168.         rts
  169. |
  170. FIX01:
  171.         cmpiw   #FBIAS,d0
  172.         jcc     FIX02           | J/ abs() >= 1.0  [BCC == BHS]
  173. |
  174.         subl    d0,d0           | Return a zero value
  175.         orib    #CCRC+CCRX,ccr  | Set carry/extend bits
  176. | ###   ORI     #$11,CCR
  177.         rts
  178. |
  179. FIX02:
  180.         subiw   #FBIAS+31,d0
  181.         jcs     FIX03           | J/ abs() < 2^31
  182. |
  183.         moveq   #-1,d0          | Set d0 to the maximum integer value
  184.         lsrl    #1,d0           | d0 = 0x7FFFFFFF
  185.         subl    a2,d0           | Account for the sign of the arg.
  186.         rts
  187. |
  188. FIX03:
  189.         negw    d0              | Positive shift count
  190.         rorl    d0,d2           | Multibit shift
  191.         moveq   #-1,d1          | Mask for bit dropout check
  192.         lsrl    d0,d1
  193.         notl    d1
  194.         andl    d2,d1           | Bit(s) dropped left in d1
  195.         eorl    d1,d2           | Integer value in d2
  196.         movel   a2,d0
  197.         eorl    d2,d0           | Negate as required, move to d0
  198.         subl    a2,d0
  199.         moveq   #-1,d2
  200.         addl    d2,d1           | Set carry/extend if bits lost
  201.         rts
  202. /*
  203. |
  204. |       page
  205. |
  206. |  INT
  207. |  ===
  208. |  Return the largest integer smaller than the argument provided
  209. |
  210. */
  212. INT:
  213.         bsr     GETFP1
  214.         bsr     FIX00
  215. |
  216.         jcc     INT00           | J/ no bits lost
  217.         cmpaw   #0,a2
  218.         jeq     INT00           | J/ not negative
  219.         subql   #1,d0           | Decrement integer value
  220. INT00:
  221.         jmp     a0@
  222. /*
  223. |
  224. |       page
  225. |
  226. |  AINT
  227. |  ====
  228. |  Floating point corollary to the INT function
  229. |
  230. */
  232. AINT:
  233.         bsr     GETFP1
  234.         cmpiw   #FBIAS+23,d0    | Check for value too large
  235.         jcc     FOPRSL          | J/ return with same value
  236. |
  237.         movew   d0,d3
  238.         subiw   #FBIAS-1,d3
  239.         jgt     AINT02          | J/ abs() >= 1.0
  240. |
  241.         movew   a2,d2
  242.         jne     AINT01          | J/ 0.0 > value > -1.0
  243. |
  244.         movel   #0,sp@- | Return a zero value
  245.         jmp     a0@
  246. |
  247. AINT01:
  248.         movel   #0xBF800000,sp@-        | Return -1.0
  249.         jmp     a0@
  250. |
  251. AINT02:
  252.         moveq   #-1,d1          | Fill d1 with ones
  253.         lsrl    d3,d1           | Shift mask over
  254.         moveq   #1,d3
  255.         addl    d1,d3           | Create increment bit
  256.         andl    d2,d1           | Extract bits to drop
  257.         jeq     FOPRSL          | J/ no drop off, return as provided
  258. |
  259.         eorl    d1,d2           | Remove bits that must be dropped
  260.         cmpaw   #0,a2
  261.         jeq     FOPRSL          | Bits dropped from a positive number
  262. |
  263.         addl    d3,d2           | Bump the magnitude (negative number)
  264.         jcc     AINT03          | J/ no overflow
  265. |
  266.         roxll   #1,d2
  267.         addqw   #1,d0
  268. |
  269. AINT03:
  270.         jra     FOPRSL          | Return computed value
  271. /*
  272. |
  273. |       page
  274. |
  275. |  FPADD
  276. |  =====
  277. |  Single precision add routine
  278. |
  279. */
  281. FPADD:
  282.         bsr     GETFP2          | Fetch both operands
  283.         cmpiw   #0xFF,d0
  284. |
  285.         jne     FPA010          | J/ operand not NaN/INF
  286. |
  287.         lsll    #1,d2           | Remove implicit bit
  288.         jne     FNANRS          | J/  ?  + NaN -> NaN
  289. |
  290.         cmpiw   #0xFF,d1
  291.         jne     FINFRS          | J/  0,num + INF -> INF
  292. |
  293.         lsll    #1,d3           | Remove implicit bit
  294.         jne     FNANRS          | J/ INF + NaN -> NaN
  295. |
  296.         cmpal   a2,a3
  297.         jne     FNANRS          | J/ INF - INF -> NaN
  298.         jra     FINFRS          |    INF + INF -> INF
  299. |
  300. |
  301. FPA010:
  302.         cmpiw   #0xFF,d1
  303.         jne     FPA040          | J/ not NaN or INF
  304. |
  305.         lsll    #1,d3           | Remove implicit bit
  306.         jne     FNANRS          | J/ NaN + 0,num -> NaN
  307. |
  308.         moveal  a3,a2           | Move sign over
  309.         jra     FINFRS          | INF result
  310. |
  311. |
  312. FPXSUB:
  313.         |dsw    0               | Entry for FPCMP
  314. |
  315. FPA040:
  316.         andw    d1,d1
  317.         jeq     FPA041          | J/ 0,num + 0 -> 0,num
  318. |
  319.         andw    d0,d0
  320.         jne     FPA045          | J/ no zeroes involved
  321. |
  322.         movew   d1,d0           | Copy over data
  323.         movel   d3,d2
  324.         moveal  a3,a2
  325. FPA041:
  326.         jra     FOPR02          | Return w/o range check
  327. |
  328. |
  329. FPA045:
  330.         |dsw    0
  331. |
  332.         cmpw    d1,d0
  333.         jcc     FPA060          | J/ op1.exp >= op2.exp
  334. |
  335.         exg     d2,d3           | Flip mantissas
  336.         exg     d0,d1
  337.         exg     a2,a3
  338. |
  339. FPA060:
  340.         subw    d0,d1
  341.         negw    d1
  342.         cmpiw   #24,d1
  343.         jhi     FOPRSL          | J/ op2 too small to matter
  344. |
  345.         lsrl    d1,d3
  346.         cmpal   a2,a3
  347.         jne     FPS100          | J/ subtract operation
  348. |
  349.         addl    d3,d2
  350.         jcc     FOPRSL          | J/ no carry out
  351. |
  352.         roxrl   #1,d2           | Handle carry out
  353.         addqw   #1,d0           | Bump the exponent
  354.         jra     FOPRSL
  355. |
  356. |
  357. FPS100:
  358.         subl    d3,d2           | Do the subtract
  359.         jeq     FZERRS          | J/ zero result
  360.         jcc     FPS110
  361. |
  362.         negl    d2
  363. |
  364.         moveal  a3,a2           | Flip sign
  365. |
  366. FPS110:
  367.         andl    d2,d2           | Normalization section
  368.         jmi     FOPRSL          | J/ normalized
  369. |
  370.         subqw   #1,d0           | Decrease exponent value
  371. FPS120:
  372.         addl    d2,d2           | Left shift d2
  373.         dbmi    d0,FPS120       | J/ not normalized
  374. |
  375.         jra     FOPRSL
  376. /*
  377. |
  378. |       page
  379. |
  380. |  FPMUL
  381. |  =====
  382. |  Single precision multiply routine.
  383. |
  384. */
  386. FPMUL:
  387.         bsr     GETFP2          | Fetch both operands
  388.         movew   a2,d4
  389.         movew   a3,d5
  390.         eorw    d4,d5
  391.         moveaw  d5,a2           | /* Result's sign */
  392. |
  393.         andw    d0,d0
  394.         jne     FPM010          | J/ operand <> 0.0
  395. |
  396.         cmpiw   #0xFF,d1
  397.         jeq     FNANRS          | J/ 0.0 * NaN,INF -> NaN
  398.         jra     FZERRS          | J/ 0.0 * 0.0,num -> 0.0
  399. |
  400. FPM010:
  401.         cmpiw   #0xFF,d0
  402.         jne     FPM020          | J/ operand is a number
  403. |
  404.         lsll    #1,d2
  405.         jne     FNANRS          | J/ NaN *  ?  -> NaN
  406. |
  407.         andw    d1,d1
  408.         jeq     FNANRS          | J/ INF * 0.0 -> NaN
  409. |
  410.         cmpiw   #0xFF,d1
  411.         jne     FINFRS          | J/ INF * num -> INF
  412.         lsll    #1,d3
  413.         jeq     FINFRS          | J/ INF * INF -> INF
  414.         jra     FNANRS          | J/ INF * NaN -> NaN
  415. |
  416. FPM020:
  417.         andw    d1,d1
  418.         jeq     FZERRS          | J/ num * 0.0 -> 0.0
  419. |
  420.         cmpiw   #0xFF,d1
  421.         jne     FPM040          | J/ num * num
  422. |
  423.         lsll    #1,d3
  424.         jeq     FINFRS          | J/ num * INF -> INF
  425.         jra     FNANRS          | J/ num * NaN -> NaN
  426. |
  427. |
  428. FPM040:
  429.         addw    d1,d0           | Calculate result`s exponent
  430.         subw    #FBIAS-1,d0     | Remove double bias, assume shift
  431. |
  432. #if (CPU != MC68000 && CPU != MC68010)
  433.         mulul   d2,d2:d3
  434. #else
  435. |       ifne    comp64-1        ;+++++
  437.         movew   d2,d4           | Copy Lo byte to d4 (B)
  438.         movew   d3,d5           | Copy Lo byte to d5 (D)
  439.         swap    d2              | Position for high byte multiply (A)
  440.         mulu    d2,d5           | A mid multiplication result (AD)
  441.         swap    d3              | Position for high byte multiply (C)
  442.         mulu    d3,d4           | A mid multiplication result (CB)
  443.         mulu    d3,d2           | High order words multiplied (CA)
  444.         addl    d4,d5           | Combine mid multiply results (CB + AD)
  445.         subxw   d5,d5           | Preserve carry while...
  446.         negw    d5              | ...positioning the...
  447.         swap    d5              | ...result before...
  448.         addl    d5,d2           | ...combining partial products
  449. #endif
  450. |       endc                    ;+++++
  451.         jmi     FOPRSL          | Result normalized w/o shift
  452. |
  453.         subqw   #1,d0
  454.         addl    d2,d2           | Do a left shift
  455.         jra     FOPRSL
  456. /*
  457. |
  458. |       page
  459. |
  460. |  FPDIV
  461. |  =====
  462. |  Single precision division operation.
  463. |
  464. */
  466. FPRDIV:
  467.         bsr     GETFP2          | Get both operands
  468.         exg     a2,a3           | Flip the operands
  469.         exg     d0,d1
  470.         exg     d2,d3
  471.         jra     FPD001
  472. |
  473. FPDIV:
  474.         bsr     GETFP2
  475. |
  476. FPD001:
  477.         movew   a2,d4           | /* Compute result's sign */
  478.         movew   a3,d5
  479.         eorw    d4,d5
  480.         moveaw  d5,a2
  481. |
  482.         andw    d0,d0
  483.         jne     FPD010          | J/ divisor is not zero
  484. |
  485.         andw    d1,d1
  486.         jeq     FNANRS          | J/ 0.0 / 0.0 -> NaN
  487.         cmpiw   #0xFF,d1
  488.         jne     FINFRS          | J/ num / 0.0 -> INF
  489.         lsll    #1,d3
  490.         jeq     FINFRS          | J/ INF / 0.0 -> INF
  491.         jra     FNANRS          | J/ NaN / 0.0 -> NaN
  492. |
  493. FPD010:
  494.         cmpiw   #0xFF,d0
  495.         jne     FPD020          | J/ divisor is a normal number
  496. |
  497.         lsll    #1,d2
  498.         jne     FNANRS          | J/  ?  / NaN -> NaN
  499.         andw    d1,d1
  500.         jeq     FZERRS          | J/ 0.0 / INF -> 0.0
  501.         cmpiw   #0xFF,d1
  502.         jne     FUNFRS          | J/ num / INF -> 0.0 (w/ underflow)
  503.         jra     FNANRS          | J/ NaN,INF / INF -> NaN
  504. |
  505. FPD020:
  506.         andw    d1,d1
  507.         jeq     FZERRS          | J/ 0.0 / num -> 0.0
  508.         cmpiw   #0xFF,d1
  509.         jne     FPD040          | J/ num / num
  510. |
  511.         lsll    #1,d3
  512.         jeq     FINFRS          | J/ INF / num -> INF
  513.         jra     FNANRS          | J/ NaN / num -> NaN
  514. /*
  515. |
  516. |
  517. |  Division Algorithm:   A/(B+C) = A/B - A/B*C/B + A/B*(C/B)^2 - ...
  518. |                                = A/B * (1 - C/B + (C/B)^2)
  519. |
  520. |  Choose C to be the low order byte of the 24 bit mantissa.  The
  521. |  third and succeeding corrections terms (C squared and above)
  522. |  can be neglected because they are at least thirty bits down.
  523. |
  524. */
  526. FPD040:
  527.         subw    d1,d0
  528.         negw    d0
  529.         addw    #FBIAS,d0       | Restore bias
  530. #if (CPU != MC68000 && CPU != MC68010)
  531.         lsrl    #1,d3
  532.         clrl    d4
  533.         divul   d2,d3:d4
  534.         movel   d4,d2
  535. #else
  536. |       ifne    comp64-1        ;+++++
  537.         exg     d2,d3
  538. |
  539.         movel   d2,d4           | Copy A
  540.         lsrl    #1,d4           | Insure no overflow during divide
  541.         swap    d3
  542.         divu    d3,d4           | Top fifteen bits of A/B
  543.         movew   d4,d2           | A/B ultimately into d2
  544.         movew   d4,d5           | Copy for later opn (A/B * C)
  545.         swap    d2              | Position MS word
  546.         clrw    d4              | Zero low order bits in d4
  547.         divu    d3,d4           | Division of shifted remainder
  548.         movew   d4,d2           | Complete A/B operation
  549. |
  550.         movel   d3,d4
  551.         clrw    d4              | Create a shifted C in d4
  552.         lsrl    #1,d4           | Insure no division overflow
  553.         divu    d3,d4           | Division (complete since C is 8 bits)
  554. |
  555.         mulu    d5,d4           | A/B * C
  556.         lsrl    #8,d4           | Position A/B * C
  557.         lsrl    #7,d4
  558.         subl    d4,d2
  559. #endif
  560. |       endc                    ;+++++
  561.         jmi     FOPRSL          | J/ result normalized
  562. |
  563.         subqw   #1,d0
  564.         addl    d2,d2           | Normalize it
  565.         jra     FOPRSL
  566. /*
  567. |
  568. |       page
  569. |
  570. |  FPCMP
  571. |  =====
  572. |  Single Precision comparison routine.
  573. |
  574. |  Compare the two arguments provided and set the condition code
  575. |  register bits N, Z, and V as follows:
  576. |
  577. |      N  Z  V   Relation
  578. |      =  =  =   ====================================
  579. |      1  0  0   X > Y   (X is top argument on stack)
  580. |      0  1  0   X = Y   (within FFUZZ specification)
  581. |      0  0  0   X < Y
  582. |      0  0  1   X does not compare to Y
  583. |
  584. |
  585. */
  587. |       .set    FFUZZ,20                | Twenty bits of fuzz
  589. FPCMP:
  590.         bsr     GETFP2
  591.         cmpiw   #0xFF,d0
  592.         jne     FPC020          | J/ X is not INF or NaN
  593. |
  594.         lsll    #1,d2           | Remove implicit bit
  595.         jeq     FPC005          | J/ X is INF
  596. |
  597. FPC001:
  598.         |dsw    0               | **  X does not compare to Y  **
  599.         moveq   #CCRV,d0        | CCR V bit
  600.         movew   d0,ccr
  601.         jmp     a0@             | Return
  602. |
  603. FPC005:
  604.         cmpiw   #0xFF,d1
  605.         jne     FPC009          | J/ Y is not INF or NaN
  606. |
  607.         lsll    #1,d3
  608.         jne     FPC001          | J/ Y is NaN (does not compare)
  609. |
  610.         cmpaw   a2,a3
  611.         jeq     FPC001          | /* J/ INF's with same sign - no compare */
  612. |
  613. FPC009:
  614.         movew   a2,d0           | /* Result based on compl. of X's sign */
  615.         eoriw   #CCRN,d0
  616.         jra     FPC011
  617. |
  618. FPC010:
  619.         movew   a3,d0           | /* Set result based on Y's sign */
  620. FPC011:
  621.         andiw   #CCRN,d0
  622.         movew   d0,ccr
  623.         jmp     a0@
  624. |
  625. |
  626. FPC020:
  627.         cmpiw   #0xFF,d1
  628.         jne     FPC030          | J/ Y is not NaN or INF
  629. |
  630.         lsll    #1,d3
  631.         jne     FPC001          | J/ Y is NaN - no comparison
  632.         jra     FPC010          | /* Result is based on Y's sign */
  633. |
  634. FPC030:
  635.         cmpaw   a2,a3
  636.         jne     FPC010          | /* J/ signs different - use Y's sign */
  637. |
  638.         movew   d0,d4
  639.         movew   d0,d5           | /* Assume X's exp is larger */
  640.         subw    d1,d4           | Calc difference in exponents
  641.         jpl     FPC031          | J/ positive
  642.         movew   d1,d5           | /* Y's exp is larger */
  643.         negw    d4
  644. FPC031:
  645.         |dsw    0
  646. |
  647.         lsrw    #1,d4
  648.         jeq     FPC040          | Must subtract to obtain result
  649. |
  650.         subw    d0,d1
  651.         subxw   d0,d0           | Set d0 to sign of Y[exp]-X[exp]
  652.         movew   a2,d1
  653.         eorw    d1,d0           | Flip if negative values
  654.         jra     FPC011          | Result based on value in d0
  655. |
  656. FPC040:
  657.         movew   d5,sp@- | Save max exp value, return address
  658.         movel   a0,sp@-
  659. |
  660.         movew   a2,d5
  661.         notw    d5              | Flip sign of opnd (force subtract)
  662.         moveaw  d5,a2
  663. |
  664.         pea     FPC041
  665.         movel   sp@+,a0 | Return address in a0
  666. |
  667.         jra     FPXSUB
  668. |
  669. FPC041:
  670.         movel   sp@+,d0
  671.         movel   sp@,a0
  672.         movel   d0,sp@
  673.         movel   a0,sp@-
  674. |
  675.         bsr     GETFP1          | Fetch and unpack result
  676. |
  677.         movew   sp@+,d5 | Recall max exp value
  678. |
  679.         andw    d0,d0
  680.         jeq     FPC050          | J/ zero result
  681. |
  682.         subw    d0,d5
  683.         cmpiw   #FFUZZ,d5
  684.         jge     FPC050          | J/ within FFUZZ specification - zero
  685. |
  686.         movew   a2,d0           | Sign of result into d0
  687.         jra     FPC011          | Comparison result from sign of sub
  688. |
  689. FPC050:
  690.         subw    d0,d0           | Force CCR to say "Z"
  691.         jmp     a0@             | Return
  692. /*
  693. |
  694. |       page
  695. |
  696. |  GETFP2
  697. |  ======
  698. |  Routine called to extract two single precision arguments from
  699. |  the system stack and place them in the 68000`s registers.
  700. |
  701. */
  703. GETFP2:
  704.         moveal  sp@+,a1 | /* GETFP2's return address */
  705.         moveal  sp@+,a0 | Calling routines return address
  706. |
  707.         movel   sp@+,d0 | Get TOS (source) operand
  708.         asll    #1,d0           | Sign bit to carry
  709.         subxw   d2,d2           | Fill d2 with sign bit
  710.         movew   d2,a2           | Sign bit info to a2
  711.         roll    #8,d0           | Left justify mantissa, position exp
  712.         movel   d0,d2           | Copy into mantissa register
  713.         andiw   #0xFF,d0                | Mask to exponent field
  714.         jeq     GETF21          | J/ zero value
  715. |
  716.         andiw   #0xFE00,d2      | Zero sign bit and exponent bits in d2
  717.         lsrl    #1,d2           | Position mantissa
  718.         bset    #31,d2          | Set implicit bit in d2
  719. |
  720. GETF21:
  721.         |dsw    0
  722. |
  723.         movel   sp@+,d1 | Get NOS (source) operand
  724.         asll    #1,d1           | Sign bit to carry
  725.         subxw   d3,d3           | Replicate sign bit throughout d3
  726.         movew   d3,a3           | Sign bit info into a3
  727.         roll    #8,d1           | Left justify mantissa, position exp
  728.         movel   d1,d3           | Copy into mantissa register
  729.         andiw   #0xFF,d1                | Mask to exponent field
  730.         jeq     GETF22          | J/ zero value
  731. |
  732.         andiw   #0xFE00,d3      | Zero sign bit and exponent bits in d3
  733.         lsrl    #1,d3           | Position mantissa
  734.         bset    #31,d3          | Set implicit bit in d3
  735. |
  736. GETF22:
  737.         jmp     a1@             | Return to caller, its ret addr in a0
  738. /*
  739. |
  740. |
  741. |       page
  742. |
  743. |  GETFP1
  744. |  ======
  745. |  Routine called to extract a single precision argument from the
  746. |  system stack and place it (unpacked) into the 68000's registers.
  747. |
  748. */
  750. GETFP1:
  751.         moveal  sp@+,a1 | /* Get GETFP1's return address */
  752.         moveal  sp@+,a0 | Get calling routines return address
  753. |
  754.         movel   sp@+,d0 | Get argument
  755.         asll    #1,d0           | Sign bit into carry
  756.         subxw   d2,d2           | Replicate sign bit throughout d2
  757.         movew   d2,a2           | Sign bit info into a2
  758.         roll    #8,d0           | Left justify mantissa, position exp
  759.         movel   d0,d2
  760.         andiw   #0xFF,d0                | Mask to exponent field
  761.         jeq     GETF11          | J/ zero value
  762. |
  763.         andiw   #0xFE00,d2      | Zero sign bit and exponent bits in d2
  764.         lsrl    #1,d2           | Position mantissa
  765.         bset    #31,d2          | Set implicit bit
  766. |
  767. GETF11:
  768.         jmp     a1@             | Return to caller, its ret addr in a0
  769. /*
  770. |
  771. |
  772. |       page
  773. |
  774. |  FOPRSL
  775. |  ======
  776. |  Single precision floating point result (main entry w/ round).
  777. |  Mantissa in D2, exponent in D0, sign in A2, and return address
  778. |  in A0.  Place a format value on the stack.
  779. |
  780. */
  782. FOPRSL:
  783.         addl    #0x80,d2                | Round the value
  784.         jcc     FOPR01          | J/ no carry out
  785. |
  786.         roxrl   #1,d2           | Adjust mantissa and exponent
  787.         addqw   #1,d0
  788. |
  789. FOPR01:
  790.         andw    d0,d0
  791.         jle     FUNFRS          | J/ underflow
  792. |
  793.         cmpiw   #0xFF,d0                | Check for overflow
  794.         jge     FINFRS          | J/ overflow
  795. |
  796. FOPR02:
  797.         andiw   #0xFF00,d2      | Trim mantissa
  798.         asll    #1,d2           | Drop implicit bit
  799.         addw    d0,d2           | Blend in the exponent
  800.         rorl    #8,d2           | Reposition value
  801.         movew   a2,d0
  802.         aslw    #1,d0           | Sign bit into carry/extend
  803.         roxrl   #1,d2           | Finish construction of value
  804.         movel   d2,sp@-
  805. |
  806.         moveb   #0,FPERR        | No floating point error
  807.         jmp     a0@             | Return
  808. |
  809. |
  810. |
  811. FNANRS:
  812.         moveq   #-1,d0          | Set d0 to 0xFFFFFFFF
  813.         movel   d0,sp@- | NaN value
  814. |
  815.         moveb   #ERNAN,FPERR
  816.         moveb   #-1,NANFLG
  817.         jmp     a0@
  818. |
  819. |
  820. FINFRS:
  821.         movel   a2,d0           | Get sign information
  822.         movel   #0xFF000000,d1
  823.         aslw    #1,d0
  824.         roxrl   #1,d1
  825.         movel   d1,sp@-
  826. |
  827.         moveb   #EROVF,FPERR
  828.         moveb   #-1,INFFLG
  829.         jmp     a0@
  830. |
  831. |
  832. FUNFRS:
  833.         moveb   #ERUNF,FPERR
  834.         moveb   #-1,UNFFLG
  835.         jra     FZER01
  836. |
  837. |
  838. FZERRS:
  839.         moveb   #0,FPERR
  840. |
  841. |
  842. FZER01:
  843.         subl    d0,d0
  844.         movel   d0,sp@-
  845.         jmp     a0@
  846. |
  847. |
  848. |       end