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

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

VxWorks

开发平台：

C/C++

mathHardALib.s：源码内容
  1. /* mathHardALib.s - C-callable math routines for the i80387 */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  5. /*
  6. modification history 
  7. --------------------
  8. 01g,28aug01,hdn  changed "fldl %st" to "fld %st" to shut off warning
  9.  added mathHardFmodIeee() for IEEE compliance
  10.  replaced .align with .balign
  11.  moved round-mode bit macros to fppI86Lib.h
  12.  added FUNC/FUNC_LABEL and GTEXT/GDATA macros
  13. 01f,09may00,pai  fixed _mathHardFmod to test for partial remainder (SPR
  14.                  #30548).
  15. 01e,29sep97,hdn  fixed a bug in _mathHardPow.
  16. 01d,17jun96,hdn  fixed a bug in _mathHardSincos.
  17. 01c,16jun93,hdn  updated to 5.1.
  18. 01b,14oct92,hdn  aligned all functions.
  19. 01a,16sep92,hdn  written by modifying Tron's mathHardALib.s.
  20. */
  22. /*
  23. DESCRIPTION
  24. This library provides a C interface to the high-level math functions
  25. on the i80387 floating-point coprocessor.  All angle-related
  26. parameters and return values are expressed in radians.  Functions
  27. capable errors, will set errno upon an error. All functions
  28. included in this library whos names correspond to the ANSI C specification
  29. are, indeed, ANSI-compatable. In the spirit of ANSI, HUGE_VAL is now
  30. supported.
  32. WARNING
  33. This library works only if an i80387 coprocessor is in the system! 
  34. Attempts to use these routines with no coprocessor present 
  35. will result in illegal instruction traps.
  37. SEE ALSO:
  38. fppLib (1), floatLib (1), The C Programming Language - Second Edition
  40. INCLUDE FILE: math.h
  42. INTERNAL
  43. Each routine has the following format:
  44.     o calculate floating-point function using double parameter 
  45.     o store result to %st0 register
  46. */
  48. #define _ASMLANGUAGE
  49. #include "vxWorks.h"
  50. #include "asm.h"
  51. #include "fppLib.h"
  52. #include "errno.h"
  55. .data
  56. .globl FUNC(copyright_wind_river)
  57. .long FUNC(copyright_wind_river)
  60. /* externals */
  63. /* internals */
  65.         .globl  GTEXT(mathHardLog2)
  66.         .globl  GTEXT(mathHardLog10)
  67.         .globl  GTEXT(mathHardLog)
  68.         .globl  GTEXT(mathHardExp)
  69. .globl  GTEXT(mathHardAsin)
  70. .globl  GTEXT(mathHardAcos)
  71. .globl  GTEXT(mathHardAtan)
  72. .globl  GTEXT(mathHardAtan2)
  73.         .globl  GTEXT(mathHardTan)
  74.         .globl  GTEXT(mathHardCos)
  75.         .globl  GTEXT(mathHardSin)
  76.         .globl  GTEXT(mathHardPow)
  77.         .globl  GTEXT(mathHardSqrt)
  78.         .globl  GTEXT(mathHardFabs)
  79. .globl  GTEXT(mathHardFmod)
  80. .globl  GTEXT(mathHardFmodIeee)
  82. .globl  GTEXT(mathHardSincos)
  83. .globl  GTEXT(mathHardFloor)
  84. .globl  GTEXT(mathHardCeil)
  85. .globl  GTEXT(mathHardTrunc)
  86. .globl  GTEXT(mathHardRound)
  87. .globl  GTEXT(mathHardIround)
  88. .globl  GTEXT(mathHardIrint)
  89. .globl  GTEXT(mathHardInfinity)
  92.         .text
  93. .balign 16
  96. /*******************************************************************************
  97. *
  98. * mathHardAcos - ANSI-compatable hardware floating-point arc-cosine
  99. *
  100. * RETURNS: The arc-cosine in the range -pi/2 to pi/2 radians.
  101. *
  102. * double mathHardAcos (dblParam)
  103. *     double dblParam; /* angle in radians *
  104. *
  105. */
  107. FUNC_LABEL(mathHardAcos) /* acos(x) = pi/2 - atan(x/sqrt(1-x**2)) */
  108. pushl %ebp
  109. movl %esp,%ebp
  111. fldl DARG1(%ebp)
  112. fldl DARG1(%ebp)
  113. fmul %st,%st(1)
  114. fxch %st(1)
  115. fld1
  116. fsubp %st,%st(1)
  117. fsqrt
  118. fpatan
  119. fld1
  120. fld1
  121. faddp %st,%st(1)
  122. fldpi
  123. fdivp %st,%st(1)
  124. fsubp %st,%st(1)
  126. leave
  127. ret
  129. /*******************************************************************************
  130. *
  131. * mathHardAsin - ANSI-compatable hardware floating-point arc-sine
  132. *
  133. * RETURNS: The arc-sine in the range 0.0 to pi radians.
  134. * 
  135. * SEE ALSO: 
  136. * floatLib (1), "The C Programming Language - Second Edition"
  137. *
  138. * double mathHardAsin (dblParam)
  139. *     double dblParam; /* angle in radians *
  140. *
  141. */
  143. .balign 16,0x90
  144. FUNC_LABEL(mathHardAsin) /* asin(x) = atan(x/sqrt(1-x**2)) */
  145. pushl %ebp
  146. movl %esp,%ebp
  148. fldl DARG1(%ebp)
  149. fldl DARG1(%ebp)
  150. fmul %st,%st(1)
  151. fxch %st(1)
  152. fld1
  153. fsubp %st,%st(1)
  154. fsqrt
  155. fpatan
  157. leave
  158. ret
  160. /*******************************************************************************
  161. *
  162. * mathHardAtan - ANSI-compatable hardware floating-point arc-tangent
  163. *
  164. * RETURNS: The arc-tangent of dblParam in the range -pi/2 to pi/2.
  165. *
  166. * SEE ALSO: floatLib (1), acos (2), asin (2)
  167. *
  168. * double mathHardAtan (dblParam)
  169. *     double dblParam; /* angle in radians *
  170. *
  171. */
  173. .balign 16,0x90
  174. FUNC_LABEL(mathHardAtan)
  175. pushl %ebp
  176. movl %esp,%ebp
  178. fldl DARG1(%ebp)
  179. fld1
  180. fpatan
  182. leave
  183. ret
  185. /*******************************************************************************
  186. *
  187. * mathHardAtan2 - hardware floating point function for arctangent of (dblY/dblX)
  188. *
  189. * RETURNS:
  190. *    The arc-tangent of (dblY/dblX) in the range -pi to pi.
  191. *
  192. * SEE ALSO: 
  193. * floatLib (1), "The C Programming Language - Second Edition"
  194. *
  195. * double mathHardAtan2 (dblY, dblX)
  196. *     double dblY; /* Y *
  197. *     double dblX; /* X *
  198. *
  199. */
  201. .balign 16,0x90
  202. FUNC_LABEL(mathHardAtan2)
  203. pushl %ebp
  204. movl %esp,%ebp
  206. fldl DARG1(%ebp)
  207. fldl DARG2(%ebp)
  208. fpatan
  210. leave
  211. ret
  212.     
  213. /*******************************************************************************
  214. *
  215. * mathHardCos - ANSI-compatable hardware floating-point cosine
  216. *
  217. * RETURNS: the cosine of the radian argument dblParam
  218. *
  219. * SEE ALSO: 
  220. * floatLib (1), sin (2), cos (2), tan(2),
  221. * "The C Programming Language - Second Edition"
  222. *
  223. * double mathHardCos (dblParam)
  224. *     double dblParam; /* angle in radians *
  225. *
  226. */
  228. .balign 16,0x90
  229. FUNC_LABEL(mathHardCos)
  230. pushl %ebp
  231. movl %esp,%ebp
  233. fldl DARG1(%ebp)
  234. fcos
  236. fstl DARG1(%ebp)
  237. fwait
  238. movl DARG1+4(%ebp),%eax
  239. movl DARG1(%ebp),%edx
  241. leave
  242. ret
  244. /*******************************************************************************
  245. *
  246. * mathHardExp - hardware floating-point exponential function
  247. *
  248. * RETURNS:
  249. *    Floating-point inverse natural logarithm (e ** (dblExponent)).
  250. *
  251. * SEE ALSO: 
  252. * floatLib (1), "The C Programming Language - Second Edition"
  253. *
  254. * double mathHardExp (dblExponent)
  255. *     double dblExponent; /* argument *
  256. *
  257. */
  259. .balign 16,0x90
  260. powerOftwo:
  261. /* 2**z. 
  262.  * z1 is integer of z. z2 is fractal of z.
  263.  * if z2 is greater than 0.5, z2 -= 0.5, then
  264.  *     2**z = 2**(z1 + z2 + 0.5) = 2**(z1) * 2**(z2) * 2**(0.5)
  265.  * if z2 is less than 0.5, then
  266.  *     2**z = 2**(z1 + z2) = 2**(z1) * 2**(z2)
  267.  */
  268. pushl %ebp
  269. movl %esp,%ebp
  271. /* change the Round Control bits */
  272. subl $8,%esp
  273. fstcw -4(%ebp)
  274. fwait
  275. movw -4(%ebp),%ax
  276. andw $ FPCR_RC_MASK,%ax
  277. orw $ FPCR_RC_DOWN,%ax
  278. movw %ax,-8(%ebp)
  279. fldcw -8(%ebp)
  281. /* get z1(integer part of z) and z2(fractal part of z) */
  282. fld %st
  283. frndint
  284. fldcw -4(%ebp)
  285. fsub %st,%st(1)
  286. fxch %st(1)
  287. fchs
  289. /* get a value 0.5 */
  290. fld1
  291. fchs
  292. fld1
  293. fscale
  294. fxch %st(1)
  295. fstp %st
  297. /* get z2 % 0.5 */
  298. fxch %st(1)
  299. fprem
  300. fstsw %ax
  301. fstp %st(1)
  303. /* get A = 2**(z2) */
  304. f2xm1
  305. fld1
  306. faddp %st,%st(1)
  307. test $0x0200,%ax
  308. jz powerOftwo0
  310. /* get A = 2**(z2) * 2**(0.5) */
  311. fld1
  312. fadd %st,%st(0)
  313. fsqrt
  314. fmulp %st,%st(1)
  316. powerOftwo0:
  317. /* get 2**z = A * 2**(z1) */
  318. fscale
  319. fstp %st(1)
  320. addl $8,%esp
  322. leave
  323. ret
  325. .balign 16,0x90
  326. FUNC_LABEL(mathHardExp) /* e**y = 2**(y * log2(e)) */
  327. pushl %ebp
  328. movl %esp,%ebp
  330. fldl DARG1(%ebp)
  331. fldl2e
  332. fmulp %st,%st(1)
  333. call powerOftwo
  335. leave
  336. ret
  338. /*******************************************************************************
  339. *
  340. * mathHardFabs - ANSI-compatable hardware floating-point absolute value
  341. *
  342. * RETURNS: The floating-point absolute value of dblParam.
  343. *
  344. * SEE ALSO: 
  345. * floatLib (1), "The C Programming Language - Second Edition"
  346. *
  347. * double mathHardFabs (dblParam)
  348. *     double dblParam; /* argument *
  349. *
  350. */
  352. .balign 16,0x90
  353. FUNC_LABEL(mathHardFabs) 
  354. pushl %ebp
  355. movl %esp,%ebp
  357. fldl DARG1(%ebp)
  358. fabs
  360. leave
  361. ret
  363. /*******************************************************************************
  364. *
  365. * mathHardLog - ANSI-compatable hardware floating-point natural logarithm 
  366. *
  367. * RETURNS: The natural logarithm of dblParam.
  368. *
  369. * SEE ALSO: 
  370. * floatLib (1), "The C Programming Language - Second Edition"
  371. *
  372. * double mathHardLog (dblParam)
  373. *     double dblParam; /* argument *
  374. *
  375. */
  377. .balign 16,0x90
  378. FUNC_LABEL(mathHardLog) /* loge(x) = loge(2) * log2(x) */
  379. pushl %ebp
  380. movl %esp,%ebp
  382. fldln2 /* st0 = loge(2) */
  383. fldl DARG1(%ebp) /* st0 = x, st1 = loge(2) */
  384. fyl2x /* st0 = loge(2) * log2(x) */
  386. leave
  387. ret
  389. /*******************************************************************************
  390. *
  391. * mathHardLog10 - ANSI-compatable hardware floating-point base 10 logarithm
  392. *
  393. * RETURNS: The logarithm (base 10) of dblParam.
  394. *
  395. * SEE ALSO: floatLib (1), log2 (2)
  396. *
  397. * double mathHardLog10 (dblParam)
  398. *     double dblParam; /* argument *
  399. *
  400. */
  402. .balign 16,0x90
  403. FUNC_LABEL(mathHardLog10) /* log10(x) = log10(2) * log2(x) */
  404. pushl %ebp
  405. movl %esp,%ebp
  407. fldlg2 /* st0 = log10(2) */
  408. fldl DARG1(%ebp) /* st0 = x, st1 = log10(2) */
  409. fyl2x /* st0 = log10(2) * log2(x) */
  411. leave
  412. ret
  414. /*******************************************************************************
  415. *
  416. * mathHardLog2 - ANSI-compatable hardware floating-point logarithm base 2 
  417. *
  418. * RETURNS: The logarithm (base 2) of dblParam.
  419. *
  420. * SEE ALSO: floatLib (1), log10 (2)
  421. *
  422. * double mathHardLog2 (dblParam)
  423. *     double dblParam; /* argument *
  424. *
  425. */
  427. .balign 16,0x90
  428. FUNC_LABEL(mathHardLog2)
  429. pushl %ebp
  430. movl %esp,%ebp
  432. fld1
  433. fldl DARG1(%ebp)
  434. fyl2x
  436. leave
  437. ret
  439. /*******************************************************************************
  440. *
  441. * mathHardPow - ANSI-compatable hardware floating-point power function
  442. *
  443. * RETURNS: The floating-point value of dblX to the power of dblY.
  444. *
  445. * SEE ALSO: floatLib (1), sqrt (2)
  446. *
  447. * double mathHardPow (dblX, dblY)
  448. *     double dblX; /* X *
  449. *     double dblY; /* Y *
  450. *
  451. */
  453. .balign 16,0x90
  454. FUNC_LABEL(mathHardPow)  /* x**y = 2**(y * log2(x)) */
  455. pushl %ebp
  456. movl %esp,%ebp
  458. fldz
  459. fldl DARG1(%ebp)
  460. fcompp
  461. fstsw %ax
  462. sahf
  463. je powZeroX /* if (x == 0) */
  464. jb powNegX /* if (x < 0) */
  466. fldl DARG2(%ebp) /* x > 0 */
  467. fldl DARG1(%ebp) /* x**y = 2**(y * log2(x)) */
  468. fyl2x
  469. call powerOftwo
  470. jmp powExit
  472. powZeroX: /* x == 0 */
  473. fldz
  474. fldl DARG2(%ebp)
  475. fcompp
  476. fstsw %ax
  477. sahf
  478. ja powNan /* if (y > 0),  (0**y = 0) */
  479. je powOne /* if (y == 0), (0**0 = 1) */
  481. fldl mathHardInfinity0 /* if (y < 0),  (0**y = HUGE_VALUE */
  482. fldl2t
  483. fmulp %st, %st(1)
  484. call powerOftwo
  485. jmp powErrExit
  487. powOne:
  488. fld1
  489. jmp powErrExit
  491. powNan:
  492. fldz
  493. jmp powErrExit
  495. powNegX: /* x < 0 */
  496. fldl DARG2(%ebp)
  497. frndint
  498. fcompl DARG2(%ebp)
  499. fstsw %ax
  500. sahf
  501. jne powNan /* if (y != int(y)), (x**y = 0) */
  503. fldl DARG2(%ebp) /* x**y = 2**(y * log2(|x|)) */
  504. fldl DARG1(%ebp)
  505. fabs
  506. fyl2x
  507. call powerOftwo
  509. fld1 /* if ((y % 2) != 0)              */
  510. fld1 /*   x**y = -(%st)                */
  511. faddp /* else                           */
  512. fldl DARG2(%ebp)             /*   x**y = %st                   */
  513. fprem
  514. fldz
  515. fcompp
  516. fstsw %ax
  517. sahf
  518. je powExit0
  520. fcomp %st /* pop, fincstp + ffree might work */
  521. fchs /* x**y = -(%st) */
  522. jmp powExit
  524. powExit0:
  525. fcomp %st /* pop, fincstp + ffree might work */
  526. jmp powExit
  528. powErrExit:
  529. powExit:
  530. leave
  531. ret
  533. /*******************************************************************************
  534. *
  535. * mathHardSin - ANSI-compatable hardware floating-point sine
  536. *
  537. * RETURNS: The floating-point sine of dblParam.
  538. *
  539. * SEE ALSO: 
  540. *   floatLib (1), cos (2), tan (2), 
  541. *   "The C Programming Language - Second Edition"
  542. *
  543. * double mathHardSin (dblParam)
  544. *     double dblParam; /* angle in radians *
  545. *
  546. */
  548. .balign 16,0x90
  549. FUNC_LABEL(mathHardSin)
  550. pushl %ebp
  551. movl %esp,%ebp
  553. fldl DARG1(%ebp)
  554. fsin
  556. leave
  557. ret
  559. /*******************************************************************************
  560. *
  561. * mathHardSqrt - ANSI-compatable hardware floating-point square root
  562. *
  563. * RETURNS: The floating-point square root of dblParam.
  564. *
  565. * SEE ALSO: floatLib(1), pow (2)
  566. *
  567. * double mathHardSqrt (dblParam)
  568. *     double dblParam; /* argument *
  569. *
  570. */
  572. .balign 16,0x90
  573. FUNC_LABEL(mathHardSqrt)
  574. pushl %ebp
  575. movl %esp,%ebp
  577. fldl DARG1(%ebp)
  578. fsqrt
  580. leave
  581. ret
  583. /*******************************************************************************
  584. *
  585. * mathHardTan - ANSI-compatable hardware floating-point tangent
  586. *
  587. * RETURNS: Floating-point tangent of dblParam.
  588. *
  589. * SEE ALSO: floatLib (1), cos (2), sin (2),
  590. * "The C Programming Language - Second Edition"
  591. *
  592. * double mathHardTan (dblParam)
  593. *     double dblParam; /* angle in radians *
  594. *
  595. */
  597. .balign 16,0x90
  598. FUNC_LABEL(mathHardTan)
  599. pushl %ebp
  600. movl %esp,%ebp
  602. fldl DARG1(%ebp)
  603. fptan
  604. fstp %st
  606. leave
  607. ret
  609. /*******************************************************************************
  610. *
  611. * mathHardSincos - simultaneous hardware floating-point sine and cosine
  612. *
  613. * RETURNS:
  614. * The simultaeous floating point results of sine and cosine of the 
  615. * radian argument  The dblParam must be in range of -1.0 to +1.0.
  616. *
  617. * CAVEAT:
  618. * Supported for the HD648132 only.
  619. *
  620. * SEE ALSO: floatLib (1), "HD648132 Floating-Point User's Manual"
  621. *
  622. * void mathHardSincos (dblParam, sinResult, cosResult)
  623. *     double dblParam; /* angle in radians *
  624. *     double *sinResult; /* sine result buffer *
  625. *     double *cosResult; /* cosine result buffer *
  626. *
  627. */
  629. .balign 16,0x90
  630. FUNC_LABEL(mathHardSincos)
  631. pushl %ebp
  632. movl %esp,%ebp
  634. fldl DARG1(%ebp)
  635. fsincos
  636. movl DARG2L(%ebp),%eax
  637. fstpl (%eax)
  638. movl DARG2(%ebp),%edx
  639. fstpl (%edx)
  641. leave
  642. ret
  644. /*******************************************************************************
  645. *
  646. * mathHardFmod - ANSI-compatable hardware floating-point modulus (fprem)
  647. *
  648. * RETURNS: 
  649. * Floating-point modulus of (dblParam / dblDivisor) with the sign of dblParam.  
  650. *
  651. * SEE ALSO: 
  652. * floatLib (1), "The C Programming Language - Second Edition"
  653. *
  654. * double mathHardFmod (dblParam, dblDivisor)
  655. *     double dblParam; /* argument *
  656. *     double dblDivisor; /* divisor *
  657. *
  658. */
  660. .balign 16,0x90
  661. FUNC_LABEL(mathHardFmod)
  662. pushl %ebp
  663. movl %esp,%ebp
  665. fldl DARG2(%ebp)
  666. fldl DARG1(%ebp)
  668. reducePartial:
  670. fprem /* fprem for non IEEE */
  671. fstsw %ax /* put the FPU status word in AX */
  672. test $0x0400,%ax /* is there a partial remainder at ST(0) ? */
  673. jnz reducePartial
  675. fstp %st(1)
  677. leave
  678. ret
  680. /*******************************************************************************
  681. *
  682. * mathHardFmodIeee - ANSI-compatable hardware floating-point modulus (fprem1)
  683. *
  684. * RETURNS: 
  685. * Floating-point modulus of (dblParam / dblDivisor) with the sign of dblParam.  
  686. *
  687. * SEE ALSO: 
  688. * floatLib (1), "The C Programming Language - Second Edition"
  689. *
  690. * double mathHardFmodIeee (dblParam, dblDivisor)
  691. *     double dblParam; /* argument *
  692. *     double dblDivisor; /* divisor *
  693. *
  694. */
  696. .balign 16,0x90
  697. FUNC_LABEL(mathHardFmodIeee)
  698. pushl %ebp
  699. movl %esp,%ebp
  701. fldl DARG2(%ebp)
  702. fldl DARG1(%ebp)
  704. reducePartialIeee:
  706. fprem1 /* fprem1 for IEEE */
  707. fstsw %ax /* put the FPU status word in AX */
  708. test $0x0400,%ax /* is there a partial remainder at ST(0) ? */
  709. jnz reducePartialIeee
  711. fstp %st(1)
  713. leave
  714. ret
  716. /*******************************************************************************
  717. *
  718. * mathHardFloor - ANSI-compatable hardware floating-point floor
  719. *
  720. * Performs a 'round-to-negative-infinity'.
  721. *
  722. * RETURNS: 
  723. * The largest integral value less than or equal to dblParam,
  724. * result is returned in double precision.
  725. *
  726. * SEE ALSO: 
  727. * floatLib (1), "The C Programming Language - Second Edition"
  728. *
  729. *
  730. * double mathHardFloor (dblParam)
  731. *     double dblParam; /* argument *
  732. *
  733. */
  735. .balign 16,0x90
  736. FUNC_LABEL(mathHardFloor)
  737. pushl %ebp
  738. movl %esp,%ebp
  740. subl $8,%esp
  741. fstcw -4(%ebp)
  742. fwait
  743. movw -4(%ebp),%ax
  744. andw $ FPCR_RC_MASK,%ax
  745. orw $ FPCR_RC_DOWN,%ax
  746. movw %ax,-8(%ebp)
  747. fldcw -8(%ebp)
  748. fldl DARG1(%ebp)
  749. frndint
  750. fldcw -4(%ebp)
  751. addl $8,%esp
  753. leave
  754. ret
  756. /*******************************************************************************
  757. *
  758. * mathHardCeil - ANSI-compatable hardware floating-point ceiling
  759. *
  760. * Performs a 'round-to-positive-infinity'
  761. *
  762. * RETURNS: 
  763. * The least integral value greater than or equal to dblParam,
  764. * result is returned in double precision.
  765. *
  766. * SEE ALSO: 
  767. * floatLib (1), "The C Programming Language - Second Edition"
  768. *
  769. * double mathHardCeil (dblParam)
  770. *     double dblParam; /* argument *
  771. *
  772. */
  774. .balign 16,0x90
  775. FUNC_LABEL(mathHardCeil)
  776. pushl %ebp
  777. movl %esp,%ebp
  779. subl $8,%esp
  780. fstcw -4(%ebp)
  781. fwait
  782. movw -4(%ebp),%ax
  783. andw $ FPCR_RC_MASK,%ax
  784. orw $ FPCR_RC_UP,%ax
  785. movw %ax,-8(%ebp)
  786. fldcw -8(%ebp)
  787. fldl DARG1(%ebp)
  788. frndint
  789. fldcw -4(%ebp)
  790. addl $8,%esp
  792. leave
  793. ret
  795. /*******************************************************************************
  796. *
  797. * mathHardTrunc - hardware floating-point truncation
  798. *
  799. * Performs FINTRZ.
  800. *
  801. * RETURNS:
  802. * The integer portion of a double-precision number,
  803. * result is in double-precision.
  804. *
  805. * SEE ALSO: floatLib (1)
  806. *
  807. * double mathHardTrunc (dblParam)
  808. *     double dblParam; /* argument *
  809. *
  810. */
  812. .balign 16,0x90
  813. FUNC_LABEL(mathHardTrunc)
  814. pushl %ebp
  815. movl %esp,%ebp
  817. subl $8,%esp
  818. fstcw -4(%ebp)
  819. fwait
  820. movw -4(%ebp),%ax
  821. andw $ FPCR_RC_MASK,%ax
  822. orw $ FPCR_RC_ZERO,%ax
  823. movw %ax,-8(%ebp)
  824. fldcw -8(%ebp)
  825. fldl DARG1(%ebp)
  826. frndint
  827. fldcw -4(%ebp)
  828. addl $8,%esp
  830. leave
  831. ret
  833. /*******************************************************************************
  834. *
  835. * mathHardRound - hardware floating-point rounding
  836. *
  837. * Performs a 'round-to-nearest'.
  838. *
  839. * SEE ALSO: floatLib (1)
  840. *
  841. * double mathHardRound (dblParam)
  842. *     double dblParam; /* argument *
  843. *
  844. */
  846. .balign 16,0x90
  847. FUNC_LABEL(mathHardRound)
  848. pushl %ebp
  849. movl %esp,%ebp
  851. subl $8,%esp
  852. fstcw -4(%ebp)
  853. fwait
  854. movw -4(%ebp),%ax
  855. andw $ FPCR_RC_MASK,%ax
  856. orw $ FPCR_RC_NEAREST,%ax
  857. movw %ax,-8(%ebp)
  858. fldcw -8(%ebp)
  859. fldl DARG1(%ebp)
  860. frndint
  861. fldcw -4(%ebp)
  862. addl $8,%esp
  864. leave
  865. ret
  867. /*******************************************************************************
  868. *
  869. * mathHardIround - hardware floating-point rounding to nearest integer
  870. *
  871. * Performs a 'round-to-nearest' function.
  872. *
  873. * NOTE:
  874. * If dblParam is spaced evenly between two integers,
  875. * then the  even integer will be returned.
  876. *
  877. * int mathHardIround (dblParam)
  878. *     double dblParam; /* argument *
  879. *
  880. */
  882. .balign 16,0x90
  883. FUNC_LABEL(mathHardIround)
  884. pushl %ebp
  885. movl %esp,%ebp
  887. subl $8,%esp
  888. fstcw -4(%ebp)
  889. fwait
  890. movw -4(%ebp),%ax
  891. andw $0xf3ff,%ax
  892. orw $0x0,%ax
  893. movw %ax,-8(%ebp)
  894. fldcw -8(%ebp)
  895. fldl DARG1(%ebp)
  896. frndint
  897. fistpl DARG1(%ebp)
  898. fwait
  899. movl DARG1(%ebp),%eax
  900. fldcw -4(%ebp)
  901. addl $8,%esp
  903. leave
  904. ret
  906. /********************************************************************************
  907. * mathHardIrint - hardware floating-point double to integer conversion
  908. *
  909. * Convert dblParam to an integer using the selected IEEE
  910. * rounding direction.
  911. *
  912. * CAVEAT:
  913. * The rounding direction is not pre-selectable
  914. * and is fixed for 'round-to-the-nearest'.
  915. *
  916. * SEE ALSO: floatLib (1)
  917. * 
  918. * int mathHardIrint (dblParam)
  919. *     double dblParam; /* argument *
  920. *
  921. */
  922.  
  923. .balign 16,0x90
  924. FUNC_LABEL(mathHardIrint)
  925. pushl %ebp
  926. movl %esp,%ebp
  928. fldl DARG1(%ebp)
  929. frndint
  930. fistpl DARG1(%ebp)
  931. fwait
  932. movl DARG1(%ebp),%eax
  934. leave
  935. ret
  937. /********************************************************************************
  938. * mathHardInfinity - hardware floating-point return of a very large double
  939. *
  940. * SEE ALSO: floatLib(1)
  941. * 
  942. * double mathHardInfinity ()
  943. *
  944. */
  945.  
  946. .balign 16
  947. mathHardInfinity0:
  948. .double 0d4.09600000000000000000e+03
  949. .balign 16
  951. FUNC_LABEL(mathHardInfinity) /* 10**4096 = 2**(4096 * log2(10)) */
  952. pushl %ebp
  953. movl %esp,%ebp
  955. fldl mathHardInfinity0
  956. fldl2t
  957. fmulp %st,%st(1)
  958. call powerOftwo
  960. leave
  961. ret