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

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

VxWorks

开发平台：

C/C++

emuFncALib.s：源码内容
  1. /* Copyright 1991-2001 Wind River Systems, Inc. */
  3. /*
  4. modification history
  5. --------------------
  6. 01e,28aug01,hdn  added FUNC/FUNC_LABEL, replaced .align with .balign
  7. 01d,16apr98,hdn  fixed comments which cause assembler error.
  8. 01c,03feb98,hdn  fixed sin/cos problem (SPR7764) w USSW v.311
  9. 01b,24oct96,yp   stuck in a # in USSC mailing addr so cpp will work
  10. 01a,24jan95,hdn  original US Software version.
  11. */
  13. #
  14. #       Filename:   EMUFNC.ASM
  15. #
  16. #       Copyright (C) 1990,1991 By
  17. #       # United States Software Corporation
  18. #       # 14215 N.W. Science Park Drive
  19. #       # Portland, Oregon 97229
  20. #
  21. #       This software is furnished under a license and may be used
  22. #       and copied only in accordance with the terms of such license
  23. #       and with the inclusion of the above copyright notice.
  24. #       This software or any other copies thereof may not be provided
  25. #       or otherwise made available to any other person.  No title to
  26. #       and ownership of the software is hereby transferred.
  27. #
  28. #       The information in this software is subject to change without
  29. #       notice and should not be construed as a commitment by United
  30. #       States Software Corporation.
  31. #
  32. #       Version:        V3.09  01/19/95 GOFAST  WRS GNU version of GF-PROT
  33. #       Released:       1 March 1991
  34. #
  35. #
  37. #define _ASMLANGUAGE
  38. #include "vxWorks.h"
  39. #include "asm.h"
  41. .data
  42. .globl FUNC(copyright_wind_river)
  43. .long FUNC(copyright_wind_river)
  45. .include "emuIncALib.s"
  46. .text
  48. #        extrn   wiep:near
  49. #        extrn   tnormal:near,shiftr:near,exproc:near,exprop:near
  50. #        extrn   epmul:near
  51. #        extrn   epadd1:near,epmul1:near,epdiv1:near
  52. #        extrn   retnan:near,getqn:near,chkarg:near,exret:near
  54. #DGROUP  GROUP   hwseg
  55. #CGROUP  GROUP   emuseg
  57. #hwseg   segment RW para public 'DATA'
  58. #        assume  ds:DGROUP, es:DGROUP, ss:DGROUP
  59. #        extrn   h_ctrl:word,h_stat:word
  60. #hwseg   ends
  62. #emuseg  segment public USE32 'CODE'
  63. #        assume  cs:CGROUP
  65. __lib:
  67. #        subttl  (2 to power x) - 1
  68. #        page
  70. # raise 2 to power x and subtract 1 (x between -1 and 1)
  71. # input:        EP in cx:edx:eax
  72. # output:       result in cx:edx:eax
  74. .globl epf2xm1
  76. .balign 16
  77. expcon: .word 0,0xf717,0x0001,0x0000,0x0000,0x0000 # ln2^18/18!
  78. .word 0,0x0889,0x0033,0x0000,0x0000,0x0000 # ln2^17/17!
  79. .word 0,0xa26b,0x04e3,0x0000,0x0000,0x0000 # ln2^16/16!
  80. .word 0,0xa10e,0x70db,0x0000,0x0000,0x0000 # ln2^15/15!
  81. .word 0,0x26ac,0x8a4b,0x0009,0x0000,0x0000 # ln2^14/14!
  82. .word 0,0x8b36,0xb0c9,0x00c0,0x0000,0x0000 # ln2^13/13!
  83. .word 0,0x7e14,0xeb28,0x0e1d,0x0000,0x0000 # ln2^12/12!
  84. .word 0,0x8dd9,0x639a,0xf465,0x0000,0x0000 # ln2^11/11!
  85. .word 0,0xc764,0x8ac5,0x267a,0x000f,0x0000 # ln2^10/10!
  86. .word 0,0x3e1e,0x9caf,0x929e,0x00da,0x0000 # ln2^9/9!
  87. .word 0,0x11fe,0xd2e4,0x0111,0x0b16,0x0000 # ln2^8/8!
  88. .word 0,0x1a1b,0x22c3,0xff16,0x7ff2,0x0000 # ln2^7/7!
  89. .word 0,0xdbd2,0xb1e1,0x4be1,0x0c24,0x0005 # ln2^6/6!
  90. .word 0,0x20e2,0xce62,0xcf14,0xb0ff,0x002b # ln2^5/5!
  91. .word 0,0x9ccb,0xe772,0xfba4,0x2ab6,0x013b # ln2^4/4!
  92. .word 0,0xcce9,0x2fe2,0xc128,0xc235,0x071a # ln2^3/3!
  93. .word 0,0x6f16,0x8ea8,0x82c5,0xbdff,0x1ebf # ln2^2/2!
  94. .word 0,0xe4f1,0xbcd5,0xe8e7,0x0bfb,0x58b9 # ln2^1/1!
  95. .word -1
  97. exp87: orl %ecx,%ecx #argument + or - 1
  98. jns exp89 #   +1 returns +1
  99. decl %ecx #   -1 returns -1/2
  100. exp89: ret
  102. expw: btl $16,%ecx #zero returns as such
  103. jc exp89
  105. call chkarg #weed out illegals
  106. jc exp89
  108. cmpw $0x7fff,%cx #-INF returns -1, +INF as such
  109. jnz exp2
  110. orl %ecx,%ecx
  111. jns exp89
  112. movl $0x80003fff,%ecx
  113. ret
  115. epf2xm1:
  116. testl $0x00030000,%ecx #jump if special value
  117. jnz expw
  119. exp2: #PREEXS  precis          #set precision exception
  120. orb $precis,h_stat
  121. testb $precis,h_ctrl
  122. jnz LL1
  123. orw $0x8080,h_stat
  124. movl $exret,-4(%ebp)
  125. LL1:
  127. cmpw $0x3fff,%cx #handle limit cases +1 and -1
  128. jz exp87
  130. movl $expcon,%ebx #call the polynomial routine
  131. call sigmax
  132. addw $0x3ffe,%cx
  134. call epmul #then multiply with x
  135. ret
  137. # sin: trigonometric sine of x
  138. # cos: trigonometric cosine of x
  139. # tan: trigonometric tangent of x
  140. # input:        x in ecx:edx:eax and ST
  141. # return:       answer in ecx:edx:eax
  143. .globl epsin,epcos,eptan
  145. .balign 16
  146. sincon: #coefficients for sin(x)
  147. .word 0,0x1dc0,0x654b,0x0000,0x0000,0x0000
  148. .word 0,0x6332,0x6030,0xff94,0xffff,0xffff
  149. .word 0,0xa1b4,0x184e,0x5849,0x0000,0x0000
  150. .word 0,0x763a,0x3015,0x3375,0xffca,0xffff
  151. .word 0,0x338e,0x56c7,0xe3a5,0x171d,0x0000
  152. .word 0,0x7f98,0x97f9,0xf97f,0x7f97,0xfff9
  153. .word 0,0x1111,0x1111,0x1111,0x1111,0x0111
  154. .word 0,0xaaab,0xaaaa,0xaaaa,0xaaaa,0xeaaa
  155. .word 0,0x0000,0x0000,0x0000,0x0000,0x8000
  156. .word -1
  158. .balign 16
  159. coscon: #coefficients for cos(x)
  160. .word 0,0x61b8,0xfa5f,0xffff,0xffff,0xffff
  161. .word 0,0xf9cc,0xb9fc,0x0006,0x0000,0x0000
  162. .word 0,0xcfe2,0xa2d5,0xf9b1,0xffff,0xffff
  163. .word 0,0x3624,0x3bfe,0x7bb6,0x0004,0x0000
  164. .word 0,0x1472,0x10ec,0x3609,0xfdb0,0xffff
  165. .word 0,0xd00d,0x0d00,0x00d0,0xd00d,0x0000
  166. .word 0,0x7d28,0x27d2,0xd27d,0x7d27,0xffd2
  167. .word 0,0x5555,0x5555,0x5555,0x5555,0x0555
  168. .word 0,0x0000,0x0000,0x0000,0x0000,0xc000
  169. .word 0,0x0000,0x0000,0x0000,0x0000,0x8000
  170. .word -1
  172. .balign 16
  173. tancon: #coefficients for tan(x)
  174. .word 0,0x49fa,0xa843,0xffff,0xffff,0xffff
  175. .word 0,0xd55c,0x9e11,0xfffc,0xffff,0xffff
  176. .word 0,0x5074,0x9d9a,0xffde,0xffff,0xffff
  177. .word 0,0xcc5e,0x827f,0xfeb6,0xffff,0xffff
  178. .word 0,0xb1e6,0x0f07,0xf34c,0xffff,0xffff
  179. .word 0,0xd54e,0x9a5c,0x82a0,0xffff,0xffff
  180. .word 0,0xb45a,0x38a6,0x2a9e,0xfffb,0xffff
  181. .word 0,0xd548,0xc10c,0x4b63,0xffd0,0xffff
  182. .word 0,0xe9e2,0xb1f6,0x24d3,0xfe29,0xffff
  183. .word 0,0x810a,0xbbda,0xfa29,0xedd7,0xffff
  184. .word 0,0x12ec,0x478a,0x86a0,0x4cab,0xffff
  185. .word 0,0x54e8,0xc43d,0x1b32,0x10a2,0xfff9
  186. .word 0,0x5100,0xaa65,0x0ffb,0xa655,0xffba
  187. .word 0,0xd27d,0x7d27,0x27d2,0xd27d,0xfd27
  188. .word 0,0x5555,0x5555,0x5555,0x5555,0xd555
  189. .word 0,0x0000,0x0000,0x0000,0x0000,0x8000
  190. .word -1
  192. epsin:
  193. #PREEXS  precis          #not precise
  194. orb $precis,h_stat
  195. testb $precis,h_ctrl
  196. jnz LL2
  197. orw $0x8080,h_stat
  198. movl $exret,-4(%ebp)
  199. LL2:
  201. cmpb $4,%bl #sin(x+pi) = -sinx
  202. jc sin2 #   so if octant > 3 we flip the sign
  203. xorb $0x80,11(%edi) #   and subtract 4 from octant number
  204. andb $-5,%bl
  206. sin2: jpo cos3 #if octant is 1 or 2 we take cosx
  208. sin3: movl %eax,(%edi) #store reduced value, leave sign
  209. movl %edx,4(%edi)
  210. movw %cx,8(%edi)
  212. call square #we use x^2 in the polynomial
  214. lea sincon,%ebx #do the polynomial
  215. call sigmax
  216. addw $0x3ffe,%cx
  218. call epmul1 #multiply with x
  219. ret
  221. epcos:
  222. #PREEXS  precis          #not precise
  223. orb $precis,h_stat
  224. testb $precis,h_ctrl
  225. jnz LL3
  226. orw $0x8080,h_stat
  227. movl $exret,-4(%ebp)
  228. LL3:
  230. andl $0xffff,%ecx #store for possible use, sign cleared
  231. movl %ecx,8(%edi)
  233. testb $2,%bl #we flip the sign in octants 2 and 3
  234. jz cos2
  235. xorb $0x80,11(%edi)
  237. cos2: cmpb $4,%bl #cos(x+pi) = -cosx
  238. jc cos2b #   so if octant > 3 we flip the sign
  239. xorb $0x80,11(%edi) #   and subtract 4 from octant number
  240. andb $-5,%bl
  242. cos2b: jpo sin3 #if octant is 1 or 2 we take sinx
  244. cos3: call square #we use x^2 in the polynomial
  246. lea coscon,%ebx #do the polynomial
  247. call sigmax
  248. addw $0x3ffe,%cx
  250. movw $0,8(%edi) #put in the sign
  251. orl 8(%edi),%ecx
  252. ret
  254. eptan:
  255. #PREEXS  precis          #not precise
  256. orb $precis,h_stat
  257. testb $precis,h_ctrl
  258. jnz LL4
  259. orw $0x8080,h_stat
  260. movl $exret,-4(%ebp)
  261. LL4:
  262. movl %eax,(%edi)
  263. movl %edx,4(%edi)
  264. movw %cx,8(%edi)
  266. andb $-5,%bl #tan(x+pi) = tan(x) 
  268. testb $2,%bl #if octant is 2 or 3 flip sign
  269. jz tan3
  270. xorb $0x80,11(%edi)
  272. tan3: call square #we use x^2 in the polynomial
  274. pushl %ebx #save the octant
  276. lea tancon,%ebx #do the polynomial
  277. call sigmax
  278. addw $0x3ffe,%cx
  280. popl %ebx #tan(x) = x/SUM
  281. orb %bl,%bl #   if octant is 1 or 2 we take 1/tan(x)
  282. jpo tan7
  283. xchgw 8(%edi),%cx
  284. xchgl 4(%edi),%edx
  285. xchgl 0(%edi),%eax
  286. tan7: call epdiv1
  288. ret #return
  290. #        subttl   base 2 logarithm of x
  291. #        page
  293. # take base 2 logarithm of x
  294. # input:        x in cx:edx:eax and ST
  295. # output:       log2(x) in cx:edx:eax
  297. .globl eplog,eplog1
  299. .balign 16
  300. logcon: .word 0,0x26b2,0xff99,0xd343,0x0f07,0x04dc #log2(e)/19
  301. .word 0,0xd0e5,0xc350,0xdd0f,0x6b26,0x056e #log2(e)/17
  302. .word 0,0xb98d,0xff7d,0xa533,0xcec5,0x0627 #log2(e)/15
  303. .word 0,0x388f,0xd807,0x34c5,0x3d5a,0x071a #log2(e)/13
  304. .word 0,0x2b91,0x1694,0xca01,0xd424,0x0864 #log2(e)/11
  305. .word 0,0x3540,0x54c7,0xbe01,0x589e,0x0a42 #log2(e)/9
  306. .word 0,0xb22e,0x6c9f,0x3d6f,0xbb15,0x0d30 #log2(e)/7
  307. .word 0,0x2ca7,0xfe79,0xef9b,0x6c50,0x1277 #log2(e)/5
  308. .word 0,0x9fc1,0xfd74,0x3a03,0x09dc,0x1ec7 #log2(e)/3
  309. .word 0,0xdf44,0xf85d,0xae0b,0x1d94,0x5c55 #log2(e)
  310. .word -1
  312. .balign 16
  313. flnlog: .word 0x0000,0x0000,0x0000,0x8000,0x3fff,0x8000 #log2(0.5) 
  314. .word 0xf0c1,0x0852,0xcb8c,0xd47f,0x3ffe,0x8000 #log2(0.5625)
  315. .word 0xd407,0xcb91,0x1ed0,0xad96,0x3ffe,0x8000 #log2(0.625)
  316. .word 0xc407,0x3457,0xb07f,0x8a62,0x3ffe,0x8000 #log2(0.6875)
  317. .word 0xf0c1,0x0852,0xcb8c,0xd47f,0x3ffd,0x8000 #log2(0.75)
  318. .word 0x432d,0x8773,0xf71b,0x995f,0x3ffd,0x8000 #log2(0.8125)
  319. .word 0x9333,0xfde9,0xc055,0xc544,0x3ffc,0x8000 #log2(0.875)
  320. .word 0x633a,0x7dda,0x24b6,0xbeb0,0x3ffb,0x8000 #log2(0.9375)
  321. .word 0x0000,0x0000,0x0000,0x0000,0x0000,1 #log2(1)
  322. .word 0x3cfd,0xdeb4,0xd1cf,0xae00,0x3ffc,0 #log2(1.125)
  323. .word 0x57f2,0x68dc,0xc25e,0xa4d3,0x3ffd,0 #log2(1.25)
  324. .word 0x77f2,0x9750,0x9f01,0xeb3a,0x3ffd,0 #log2(1.375)
  325. .word 0x87a0,0xfbd6,0x1a39,0x95c0,0x3ffe,0 #log2(1.5)
  326. .word 0x5e69,0x3c46,0x0472,0xb350,0x3ffe,0 #log2(1.625)
  327. .word 0x9b33,0x8085,0xcfea,0xceae,0x3ffe,0 #log2(1.75)
  328. .word 0xb399,0x3044,0xfb69,0xe829,0x3ffe,0 #log2(1.875)
  330. logzer: orb $zerod,h_stat #return -INF
  331. call exproc
  332. btsl $31,%edx
  333. jmp log88
  335. lognan: orb $invop,h_stat #return NaN
  336. call exproc
  337. movl $0xc0000000,%edx
  338. log88: movl $0x80027fff,%ecx
  339. xorl %eax,%eax
  340. log89: ret
  342. logw: btl $16,%ecx #zero returns -INF
  343. jc logzer
  345. call chkarg #weed out illegals
  346. jc log89
  348. orl %ecx,%ecx #negative illegal
  349. js lognan
  351. cmpw $0x7fff,%cx #+INF returns as such
  352. jz log89
  354. call tnormal #handle denormal
  355. #PUTEP   
  356. movl %eax,(%edi)
  357. movl %edx,4(%edi)
  358. movl %ecx,8(%edi)
  360. eplog:
  361. testl $0x80030000,%ecx #jump if special value
  362. jnz logw
  364. log2: movl %edx,%ebx #precision exception unless power of 2
  365. addl %ebx,%ebx
  366. orl %eax,%ebx
  367. jz log3
  368. #PREEXS  precis
  369. orb $precis,h_stat
  370. testb $precis,h_ctrl
  371. jnz LL5
  372. orw $0x8080,h_stat
  373. movl $exret,-4(%ebp)
  374. LL5:
  376. log3: movl %ecx,%ebx #we make the exponent 0 or -1
  377. cmpw $0x3fff,%cx #   depending on if x > 1 or < 1
  378. movw $0x3fff,%cx #   push the needed adjustment
  379. jge log31
  380. decl %ecx
  381. log31: movw %cx,8(%edi)
  382. subl %ecx,%ebx
  383. movswl %bx,%ebx
  384. pushl %ebx
  386. xorl %ebx,%ebx #calculate area number (0-15) 
  387. shldl $4,%edx,%ebx
  388. testb $1,%cl
  389. jnz log5
  390. andb $7,%bl
  392. log5: cmpb $7,%bl #handle 0.9375 < x < specially
  393. jnz log21
  394. incl %ebx
  395. pushl %ebx
  396. stc
  397. rcrl $1,%edx
  398. rcrl $1,%eax
  399. incw %cx
  400. xchgl (%edi),%eax
  401. xchgl 4(%edi),%edx
  402. xchgw 8(%edi),%cx
  403. notl %edx
  404. negl %eax
  405. sbbl $-1,%edx
  406. xorl $0x80000000,%ecx
  407. jmp log51
  409. log21: pushl %ebx #interpolation area number
  411. movl %edx,%ebx #registers = x+C
  412. andl $0xf0000000,%ebx
  413. addl %ebx,%edx
  414. rcrl $1,%edx
  415. rcrl $1,%eax
  416. incw %cx
  418. xchgl (%edi),%eax #swap arguments
  419. xchgl 4(%edi),%edx
  420. xchgw 8(%edi),%cx
  422. andl $0x0fffffff,%edx #registers = x-C
  423. log54: jnz log51
  424. orl %eax,%eax
  425. jnz log51
  426. xorl %ecx,%ecx
  427. jmp log57
  428. log51: decw %cx
  429. addl %eax,%eax
  430. adcl %edx,%edx
  431. jns log51
  433. log52: call epdiv1 #calculate d = (M-C)/(M+C)
  434. addb %bl,%bl
  435. adcl $0,%eax
  436. adcl $0,%edx
  437. #PUTEP   
  438. movl %eax,(%edi)
  439. movl %edx,4(%edi)
  440. movl %ecx,8(%edi)
  442. call square #square that
  444. lea logcon,%ebx #calculate polynomial for d^2
  445. call sigmax
  446. addb $0x40,%ch
  448. call epmul1 #then multiply by d
  449. addb %bl,%bl
  450. adcl $0,%eax
  451. adcl $0,%edx
  453. log57: popl %ebx #add base log2(C)
  454. shll $2,%ebx
  455. lea flnlog(%ebx,%ebx,2),%ebx
  456. movl %cs:(%ebx),%esi
  457. movl %esi,(%edi)
  458. movl %cs:4(%ebx),%esi
  459. movl %esi,4(%edi)
  460. movl %cs:8(%ebx),%esi
  461. movl %esi,8(%edi)
  462. call epadd1
  463. addb %bl,%bl
  464. adcl $0,%eax
  465. adcl $0,%edx
  466. #PUTEP   
  467. movl %eax,(%edi)
  468. movl %edx,4(%edi)
  469. movl %ecx,8(%edi)
  471. popl %edx #get exponent adjustment
  472. call wiep #   convert to EP, add to log2(d)
  473. call epadd1
  474. addb %bl,%bl
  475. adcl $0,%eax
  476. adcl $0,%edx
  477. log9: ret
  479. lgpw61: orl %ecx,%ecx #-INF returns NaN
  480. js lognan
  481. ret
  483. lgpw: btl $16,%ecx #zero returns 0
  484. jc log9
  486. call chkarg #weed out illegals
  487. jc log9
  489. cmpw $0x7fff,%cx #INF jumps
  490. jz lgpw61
  492. lgpw8: #PREEXS  precis          #very small multiplied by log2(e)
  493. orb $precis,h_stat
  494. testb $precis,h_ctrl
  495. jnz LL6
  496. orw $0x8080,h_stat
  497. movl $exret,-4(%ebp)
  498. LL6:
  499. movl $0x5C17F0BC,0(%edi)
  500. movl $0xB8AA3B29,4(%edi)
  501. movl $0x3fff,8(%edi)
  502. call epmul
  503. ret
  505. eplog1:
  506. testl $0x00030000,%ecx #jump if special value
  507. jnz lgpw
  509. cmpb $0x10,%ch #very small skip some code
  510. jc lgpw8
  512. #PREEXS  precis
  513. orb $precis,h_stat
  514. testb $precis,h_ctrl
  515. jnz LL7
  516. orw $0x8080,h_stat
  517. movl $exret,-4(%ebp)
  518. LL7:
  520. xorl %ebx,%ebx #push zero exponent adjustment
  521. pushl %ebx
  523. orl %ecx,%ecx #go handle x < 0 separately
  524. js lgp30
  526. subw $tBIAS-4,%cx #calculate area number (8-15) 
  527. cmpw $9,%cx
  528. jnc lgp3
  529. shldl %cl,%edx,%ebx
  530. lgp3: addb $8,%bl
  531. pushl %ebx
  533. movw $0x4000,%cx #calculate x+1+C
  534. subw 8(%edi),%cx
  535. call shiftr
  536. btsl $30,%edx
  537. movl %edx,%ebx
  538. andl $0x78000000,%ebx
  539. addl %ebx,%edx
  540. movl $0x4000,%ecx
  542. xchgl (%edi),%eax #swap arguments
  543. xchgl 4(%edi),%edx
  544. xchgl 8(%edi),%ecx
  546. movl %ecx,%ebx #registers = x-C
  547. addw $4-tBIAS,%bx
  548. jle log52
  549. xchgl %ecx,%ebx
  550. shll %cl,%edx
  551. shrl %cl,%edx
  552. xchgl %ecx,%ebx
  553. jmp log54
  555. lgp30: subw $tBIAS-5,%cx #calculate area number (0-7) 
  556. cmpw $9,%cx
  557. jnc lgp33
  558. shldl %cl,%edx,%ebx
  559. negl %ebx
  560. lgp33: addl $8,%ebx
  561. pushl %ebx
  563. movw $0x3fff,%cx #calculate x+1+C
  564. subw 8(%edi),%cx
  565. call shiftr
  566. movl %edx,%esi
  567. andl $0x38000000,%esi
  568. addl %esi,%edx
  569. addb %bl,%bl
  570. cmc
  571. notl %eax
  572. adcl $0,%eax
  573. notl %edx
  574. adcl $0,%edx
  575. movl $0x3fff,%ecx
  576. adcl $0,%ecx
  577. orl $0x80000000,%edx
  579. xchgl (%edi),%eax #swap arguments
  580. xchgl 4(%edi),%edx
  581. xchgl 8(%edi),%ecx
  583. movl %ecx,%ebx #registers = x-C
  584. addw $0xc006,%bx
  585. jle log52
  586. xchgl %ecx,%ebx
  587. shll %cl,%edx
  588. shrl %cl,%edx
  589. xchgl %ecx,%ebx
  590. jmp log54
  592. #        subttl   arctangent of x
  593. #        page
  595. # take arctangent of x
  596. # input:        x in cx:edx:eax and ST
  597. # output:       atan(x) in cx:edx:eax
  599. .globl epatan
  601. .balign 16
  602. atncon: #coefficients for polynomial
  603. .word 0,0x45d1,0x5d17,0xd174,0x1745,0xf45d
  604. .word 0,0xe38e,0x8e38,0x38e3,0xe38e,0x0e38
  605. .word 0,0xdb6e,0x6db6,0xb6db,0xdb6d,0xedb6
  606. .word 0,0x999a,0x9999,0x9999,0x9999,0x1999
  607. .word 0,0x5555,0x5555,0x5555,0x5555,0xd555
  608. .word 0,0x0000,0x0000,0x0000,0x0000,0x8000
  609. .word -1
  611. .balign 16
  612. attab: #interpolation table for n/32
  613. .word 0x0000,0x0000,0x0000,0x0000,0x0000,1 # atan(0.000000)
  614. .word 0x2542,0x4bb1,0xaddd,0xffea,0x3ff9,0 # atan(0.031250)
  615. .word 0x4e37,0x67ef,0xddb9,0xffaa,0x3ffa,0 # atan(0.062500)
  616. .word 0x7460,0x1788,0xc130,0xbf70,0x3ffb,0 # atan(0.093750)
  617. .word 0x6e33,0x617b,0xd4d5,0xfead,0x3ffb,0 # atan(0.125000)
  618. .word 0x62c4,0x3313,0x7746,0x9eb7,0x3ffc,0 # atan(0.156250)
  619. .word 0x1135,0x72d8,0xda5e,0xbdcb,0x3ffc,0 # atan(0.187500)
  620. .word 0x1023,0x9305,0xba94,0xdc86,0x3ffc,0 # atan(0.218750)
  621. .word 0xeb16,0x6406,0xafc9,0xfadb,0x3ffc,0 # atan(0.250000)
  622. .word 0xc130,0x5f8b,0xad18,0x8c5f,0x3ffd,0 # atan(0.281250)
  623. .word 0x5e6a,0x3f5e,0xb9b8,0x9b13,0x3ffd,0 # atan(0.312500)
  624. .word 0x4eda,0x8e6a,0x6cca,0xa985,0x3ffd,0 # atan(0.343750)
  625. .word 0x8473,0x26f7,0xca0f,0xb7b0,0x3ffd,0 # atan(0.375000)
  626. .word 0x2b6d,0x50d9,0x69ca,0xc592,0x3ffd,0 # atan(0.406250)
  627. .word 0xe5b6,0x611f,0x761e,0xd327,0x3ffd,0 # atan(0.437500)
  628. .word 0x7c68,0x764f,0xa64a,0xe06d,0x3ffd,0 # atan(0.468750)
  629. .word 0x7b46,0x0dda,0x382b,0xed63,0x3ffd,0 # atan(0.500000)
  630. .word 0xbe5c,0xa0a0,0xe85a,0xfa06,0x3ffd,0 # atan(0.531250)
  631. .word 0x7e2a,0xd986,0xf4a6,0x832b,0x3ffe,0 # atan(0.562500)
  632. .word 0x47b5,0xde95,0xecdf,0x892a,0x3ffe,0 # atan(0.593750)
  633. .word 0x9f9c,0xf7f5,0x5d5e,0x8f00,0x3ffe,0 # atan(0.625000)
  634. .word 0x86f6,0x8471,0x72c9,0x94ac,0x3ffe,0 # atan(0.656250)
  635. .word 0xda20,0x71bd,0x80e6,0x9a2f,0x3ffe,0 # atan(0.687500)
  636. .word 0xa1ed,0xf4b7,0xfdc4,0x9f89,0x3ffe,0 # atan(0.718750)
  637. .word 0x0924,0x34f7,0x7d19,0xa4bc,0x3ffe,0 # atan(0.750000)
  638. .word 0xf5c8,0x4830,0xabdc,0xa9c7,0x3ffe,0 # atan(0.781250)
  639. .word 0xc080,0xb4d8,0x4c38,0xaeac,0x3ffe,0 # atan(0.812500)
  640. .word 0x3691,0x1f04,0x31c9,0xb36b,0x3ffe,0 # atan(0.843750)
  641. .word 0x9e74,0xc231,0x3e2b,0xb805,0x3ffe,0 # atan(0.875000)
  642. .word 0xf281,0xe98a,0x5dea,0xbc7b,0x3ffe,0 # atan(0.906250)
  643. .word 0x6640,0xac52,0x85b8,0xc0ce,0x3ffe,0 # atan(0.937500)
  644. .word 0xbd54,0xbf8f,0xaffa,0xc4ff,0x3ffe,0 # atan(0.968750)
  646. atnw8: movl 8(%edi),%ecx #return 3pi/4
  647. andl $0x80000000,%ecx
  648. movw $0x4000,%cx
  649. movl $0x96cbe3f9,%edx
  650. movl $0x990e91a7,%eax
  651. orb $precis,h_stat
  652. call exprop
  653. ret
  655. atnzer: movb 11(%edi),%ch #return signed zero
  656. movb $1,%cl
  657. shll $16,%ecx
  658. xorl %edx,%edx
  659. xorl %eax,%eax
  660. ret
  662. atnw11: orl %ecx,%ecx # INF / INF
  663. js atnw8
  664. orb $precis,h_stat
  665. call exprop
  666. jmp atn90
  668. atnw3: cmpw $0x7fff,%cx # INF / y
  669. jz atnw11
  670. atnw9: orb $precis,h_stat
  671. call exprop
  672. atn82: movl $0x3fff,%ecx #INF returns +- pi/2
  673. jmp atn91
  675. atnw5: orl %ecx,%ecx # y / INF or 0 / x
  676. jns atnzer
  677. orb $precis,h_stat
  678. call exprop
  679. atn84: movl $0x4000,%ecx #here return +-pi
  680. jmp atn91
  682. atnw:
  683. call retnan #proper return for illegal arguments
  685. testb $1,10(%edi) #weed out x = 0
  686. jnz atnw5
  688. btl $16,%ecx #weed out y = 0
  689. jc atnw9
  691. cmpw $0x7fff,8(%edi) #weed out x = INF
  692. jz atnw3
  694. cmpw $0x7fff,%cx #weed out y = INF
  695. jz atnw5
  697. call tnormal #normalize arguments
  698. xchgl (%edi),%eax
  699. xchgl 4(%edi),%edx
  700. xchgl 8(%edi),%ecx
  701. call tnormal
  702. xchgl (%edi),%eax
  703. xchgl 4(%edi),%edx
  704. xchgl 8(%edi),%ecx
  705. jmp atn2
  707. atn90: orl %ecx,%ecx
  708. js atnw8
  709. movl $0x3ffe,%ecx #atan(1) return +-pi/4
  710. atn91: movl $0xc90fdaa2,%edx
  711. movl $0x2168c235,%eax
  712. jmp atn23
  714. atn89: movb s_X+5(%ebp),%bl
  715. testb $1,%bl
  716. jz atn82
  717. orb %bl,%bl
  718. js atn84
  719. call epdiv1
  720. jmp atn23
  722. epatan:
  723. shldl $16,%ecx,%ebx #save sign bits
  724. movb 11(%edi),%bl
  725. movw %bx,s_X+4(%ebp)
  727. shldl $16,%ecx,%ebx #weed out special arguments
  728. orb 10(%edi),%bl
  729. jnz atnw
  731. atn2: #PREEXS  precis          #set precision exception
  732. orb $precis,h_stat
  733. testb $precis,h_ctrl
  734. jnz LL8
  735. orw $0x8080,h_stat
  736. movl $exret,-4(%ebp)
  737. LL8:
  739. cmpw 8(%edi),%cx #compare x and y
  740. jl atn5
  741. jnz atn7
  742. cmpl 4(%edi),%edx
  743. jc atn5
  744. jnz atn7
  745. cmpl (%edi),%eax
  746. jz atn90
  747. jc atn5
  749. atn7: xchgl (%edi),%eax #switch arguments, set flag
  750. xchgl 4(%edi),%edx
  751. xchgl 8(%edi),%ecx
  752. incb s_X+5(%ebp)
  754. atn5: movl %ecx,%ebx #underflow here means either
  755. addw $tBIAS,%bx #   atn(INF) = +-pi/2 or
  756. subw 8(%edi),%bx #   atn(0) = 0 or pi
  757. cmpw $0x3f40,%bx
  758. jl atn89
  760. atn6: call epdiv1 #divide x / y
  761. andl $0x7fffffff,%ecx
  762. #PUTEP   
  763. movl %eax,(%edi)
  764. movl %edx,4(%edi)
  765. movl %ecx,8(%edi)
  767. xorl %ebx,%ebx #get interpolation interval, 0-31
  768. subw $tBIAS-6,%cx
  769. cmpw $9,%cx
  770. jc atn4
  771. movw $0,%cx
  772. atn4: shldl %cl,%edx,%ebx
  773. pushl %ebx
  775. shll %cl,%edx #calculate x - C = d
  776. shrl %cl,%edx
  777. movw 8(%edi),%cx
  778. js atn55
  779. jnz atn51
  780. orl %eax,%eax
  781. jnz atn51
  782. xorl %ecx,%ecx
  783. jmp atn54
  784. atn51: decw %cx
  785. addl %eax,%eax
  786. adcl %edx,%edx
  787. jns atn51
  789. atn55: pushl %eax #push d
  790. pushl %edx
  791. pushl %ecx
  793. rorl $5,%ebx #calculate x * C
  794. movl 4(%edi),%eax
  795. mull %ebx
  796. movl %eax,%ecx
  797. xchgl %ebx,%edx
  798. movl (%edi),%eax
  799. mull %edx
  800. addl %edx,%ecx
  801. adcl $0,%ebx
  803. movl %ebx,%edx #get x * C into right registers
  804. xchgl %ecx,%eax
  805. xorl %ebx,%ebx
  806. movl $0x3fff,%ecx
  807. subw 8(%edi),%cx
  809. atn11: shrl $1,%edx #normalize x * C to exponent 3fff
  810. rcrl $1,%eax
  811. loop atn11
  813. orl $0x80000000,%edx #calculate 1 + x*C
  814. movw $0x3fff,%cx
  815. #PUTEP   
  816. movl %eax,(%edi)
  817. movl %edx,4(%edi)
  818. movl %ecx,8(%edi)
  820. popl %ecx #calculate d/(1 + x*C)
  821. popl %edx
  822. popl %eax
  823. call epdiv1
  824. addb %bl,%bl
  825. adcl $0,%eax
  826. adcl $0,%edx
  827. #PUTEP   
  828. movl %eax,(%edi)
  829. movl %edx,4(%edi)
  830. movl %ecx,8(%edi)
  832. call square #polynomial uses x^2
  834. movl $atncon,%ebx #do the polynomial
  835. call sigmax
  836. addw $0x3ffe,%cx
  838. call epmul1 #multiply with x
  840. atn54: popl %ebx #then add atan(C)       
  841. shll $2,%ebx
  842. lea attab(%ebx,%ebx,2),%ebx
  843. movl %cs:(%ebx),%esi
  844. movl %esi,(%edi)
  845. movl %cs:4(%ebx),%esi
  846. movl %esi,4(%edi)
  847. movl %cs:8(%ebx),%esi
  848. movl %esi,8(%edi)
  849. call epadd1
  851. movb s_X+5(%ebp),%bl #adjust for actual quadrant
  852. cmpb $0x01,%bl
  853. jz atn23
  854. cmpb $0x80,%bl
  855. jz atn25
  856. orl $0x80000000,%ecx
  857. atn25: movw $0x4000,8(%edi)
  858. cmpb $0x81,%bl
  859. jz atn26
  860. movw $0x3fff,8(%edi)
  861. atn26: movl $0xc90fdaa2,4(%edi)
  862. movl $0x2168c235,0(%edi)
  863. call epadd1
  865. atn23: roll $8,%ecx #put in sign
  866. movb s_X+4(%ebp),%cl
  867. rorl $8,%ecx
  868. ret
  870. # routine to compute a Taylor polynomial
  871. # for speed and accuracy, we perform fixed-point scaled calculations
  872. # in    ebx = pointer to coefficient table
  873. #       ecx:edx:eax = EP argument
  874. # out   ecx:edx:eax = EP result
  876. shf22: movl %edx,%eax #big shift here
  877. xorl %edx,%edx
  878. subw $32,%cx
  879. cmpw $32,%cx
  880. jc shf9
  881. xorl %eax,%eax
  882. jmp shf19
  884. sigmax:
  885. pushl %edi #save registers
  886. movl %ecx,%esi
  888. subw $0x3ffe,%cx #get the scaling factor
  889. negl %ecx
  890. cmpw $32,%cx
  891. jnc shf22
  893. shf9: shrdl %cl,%edx,%eax #shift x right to scale
  894. shrl %cl,%edx
  896. shf19: movl %eax,s_A(%ebp) #store x 
  897. movl %edx,s_A+4(%ebp)
  899. movw %cs:2(%ebx),%ax #initial value of sum = first coefficient
  900. movl %cs:4(%ebx),%ecx
  901. movl %cs:8(%ebx),%edx
  902. addl $12,%ebx
  904. sig5: pushl %ebx #keep constant pointer on the stack
  905. movl %edx,%edi
  907. mulw s_A+6(%ebp) #multiply with x01
  908. movw %dx,%si #   put result in ebx:ecx:si
  909. movl %edi,%eax
  910. mull s_A+4(%ebp)
  911. movl %edx,%ebx
  912. xchgl %ecx,%eax
  913. orl %edi,%edi
  914. jns sig42
  915. subl s_A(%ebp),%ecx
  916. sbbl s_A+4(%ebp),%ebx
  917. sig42: pushl %eax
  918. mull s_A+4(%ebp)
  919. shrl $16,%eax
  920. addw %ax,%si
  921. adcl %edx,%ecx
  922. adcl $0,%ebx
  924. popl %eax #multiply with x23
  925. shrl $16,%eax
  926. mulw s_A+2(%ebp)
  927. addw %dx,%si
  928. adcl $0,%ecx
  929. adcl $0,%ebx
  930. movl %edi,%eax
  931. mull s_A(%ebp)
  932. shrl $16,%eax
  933. addw %si,%ax
  934. adcl %edx,%ecx
  935. adcl $0,%ebx
  937. movl %ebx,%edx #sum now in edx:ecx:ax
  939. popl %ebx #address of constant table in bx
  941. orl %esi,%esi #we may have to complement the sum
  942. jns sig31
  943. notl %edx
  944. notl %ecx
  945. negw %ax
  946. sbbl $-1,%ecx
  947. sbbl $-1,%edx
  949. sig31: addw %cs:2(%ebx),%ax #add next coefficient to sum
  950. adcl %cs:4(%ebx),%ecx
  951. adcl %cs:8(%ebx),%edx
  953. addl $12,%ebx #proceed to next element
  954. cmpb $-1,(%ebx)
  955. jnz sig5
  957. movb %ah,%bl #restore registers
  958. movl %ecx,%eax
  959. popl %edi
  961. movl $1,%ecx #normalize number
  962. orl %edx,%edx
  963. js sig18
  964. decl %ecx
  965. addb %bl,%bl
  966. adcl %eax,%eax
  967. adcl %edx,%edx
  968. sig18: ret
  970. #routine to raise number to second power
  971. # in    x in ecx:edx:eax
  972. # out   x^2 in same
  974. squ80: ret #return unchanged
  976. square:
  977. orw %cx,%cx #may be called with zero
  978. jz squ80
  980. pushl %edi #preserve registers
  981. pushl %ebx
  982. pushl %ebp
  983. pushl %ecx
  985. movl %edx,%esi #move mantissa
  986. movl %eax,%edi
  988. shrl $16,%eax #x23 * x23
  989. mulw %ax
  990. movb %dh,%bl
  992. movl %esi,%eax #x01 * x01 -> bp:cx:bl
  993. mull %eax
  994. movl %eax,%ecx
  995. movl %edx,%ebp
  997. movl %esi,%eax #double x01 * x23
  998. mull %edi
  999. shrl $16,%eax
  1000. addb %al,%bl
  1001. adcl %edx,%ecx
  1002. adcl $0,%ebp
  1003. addb %al,%bl
  1004. adcl %edx,%ecx
  1005. adcl $0,%ebp
  1007. movl %ecx,%eax #move mantissa to proper place
  1008. movl %ebp,%edx
  1010. popl %ecx #double exponent
  1011. addl %ecx,%ecx
  1012. subw $tBIAS-1,%cx
  1014. addb %bl,%bl #round
  1015. adcl $0,%eax
  1016. adcl $0,%edx
  1018. popl %ebp #restore registers
  1019. popl %ebx
  1020. popl %edi
  1021. ret
  1023. # routine to reduce the trigonometric argument to between 0 and pi/4
  1024. # returns octant number (0-7) in cl
  1026. .globl reduct
  1028. red80: orb $4,h_stat+1 #argument too big
  1029. addl $4,%esp
  1030. ret
  1032. red85: call getqn #here INF
  1033. orb $invop,h_stat
  1034. call exproc
  1035. red99: xorb %bl,%bl
  1036. ret
  1037. red96: andl $0x8000ffff,%ecx
  1038. jmp red99
  1040. redw: call chkarg #weed out illegals
  1041. jc red99
  1043. btl $16,%ecx #weed out INF, zero
  1044. jc red99
  1045. cmpw $1,%cx
  1046. jz red96
  1047. orw %cx,%cx
  1048. jnz red85
  1049. btsl $18,%ecx
  1050. cmpb $7,rmcode(%ebp)
  1051. jz red99
  1052. orb $underf,h_stat
  1053. call exproc
  1054. jmp red99
  1056. reduct:
  1057. andb $0x0fb,h_stat+1 #clear reduction bit
  1059. testl $0x00030000,%ecx #jump if special value
  1060. jnz redw
  1062. cmpw $tBIAS-1,%cx #small x, do nothing
  1063. jc red99
  1065. subw $tBIAS-2,%cx #get shift count -> cx
  1066. cmpw $64,%cx #   reduce only up to 63
  1067. jg red80
  1069. pushl %edi #preserve register
  1071. movl $0x2168c234,%edi
  1072. movl $0xc90fdaa2,%esi
  1074. xorl %ebx,%ebx #divide by subtraction
  1075. red61: subb $0x0c0,%bh #   remainder -> edx:eax:bh
  1076. sbbl %edi,%eax
  1077. sbbl %esi,%edx
  1078. sbbb $0,%ch
  1079. jnc red63
  1080. xorb %ch,%ch
  1081. addb $0x0c0,%bh
  1082. adcl %edi,%eax
  1083. adcl %esi,%edx
  1084. red63: cmc
  1085. adcb %bl,%bl
  1086. decb %cl
  1087. jle red65
  1088. addb %bh,%bh
  1089. adcl %eax,%eax
  1090. adcl %edx,%edx
  1091. adcb $0,%ch
  1092. jmp red61
  1094. red65: andb $7,%bl #octant number -> bh
  1096. testb $1,%bl #if octant 1 or 3 return pi/4 - x
  1097. jz red41
  1098. negb %bh
  1099. addb $0x0c0,%bh
  1100. notl %eax
  1101. adcl %edi,%eax
  1102. notl %edx
  1103. adcl %esi,%edx
  1105. red41: movl $0x3ffe,%ecx #exponent of pi/4
  1106. popl %edi
  1108. red37: orl %edx,%edx #normalize so bit 31 = 1
  1109. js red19
  1110. jnz red25
  1111. xchgl %eax,%edx
  1112. xchgb %bh,%al
  1113. shll $16,%eax #fix 10/28/97
  1114. # shll $16,%ebx
  1115. subl $32,%ecx
  1116. jmp red37
  1117. red25: decl %ecx
  1118. addb %bh,%bh
  1119. adcl %eax,%eax
  1120. adcl %edx,%edx
  1121. jns red25
  1123. red19: ret
  1125. #__lib   endp
  1127. #emuseg  ends
  1129. #        end