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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
emuMainALib.s
资源名称：vxWorks_src.rar　[点击查看]
上传用户：baixin
上传日期：2008-03-13
资源大小：4795k
文件大小：35k
源码类别：

嵌入式/单片机编程

开发平台：

MultiPlatform

emuMainALib.s：源码内容
  1. /* Copyright 1991-2001 Wind River Systems, Inc. */
  3. /*
  4. modification history
  5. --------------------
  6. 01f,28aug01,hdn  replaced .align with .balign
  7.  replaced FUNC with GTEXT/GDATA macros for global symbols.
  8.  added FUNC / FUNC_LABEL
  9.  assembly syntax has become more stringent for
  10.  indirect call instructions. '*' prefix now needed.
  11. 01e,12feb97,hdn  fixed a bug in fxchs. (SPR#7920)
  12. 01d,24oct96,yp   stuck in a # in USSC mailing addr so cpp will work 
  13. 01c,26sep95,hdn  implemented USSW's latest emumain.s.
  14. 01b,06sep95,hdn  changed .comm to .lcomm to make them contiguous.
  15. 01a,24jan95,hdn  original US Software version.
  16. */
  18. #* * * * * * * * * *
  19. #       Filename:   EMUMAIN.ASM
  20. #
  21. #       Copyright (C) 1990,1991 By
  22. #       # United States Software Corporation
  23. #       # 14215 N.W. Science Park Drive
  24. #       # Portland, Oregon 97229
  25. #
  26. #       This software is furnished under a license and may be used
  27. #       and copied only in accordance with the terms of such license
  28. #       and with the inclusion of the above copyright notice.
  29. #       This software or any other copies thereof may not be provided
  30. #       or otherwise made available to any other person.  No title to
  31. #       and ownership of the software is hereby transferred.
  32. #
  33. #       The information in this software is subject to change without
  34. #       notice and should not be construed as a commitment by United
  35. #       States Software Corporation.
  36. #
  37. #       Version:        See VSNLOG.TXT
  38. #       Released:       1 March 1991
  39. #
  40. #* * * * * * * * * *
  42. #define _ASMLANGUAGE
  43. #include "vxWorks.h"
  44. #include "asm.h"
  46. .data
  47. .globl FUNC(copyright_wind_river)
  48. .long FUNC(copyright_wind_river)
  51. .include "emuIncALib.s"
  52. .text
  54. .globl emuret,exret
  55. #        extrn   witoep:near,eptowi:near,sitoep:near,eptosi:near
  56. #        extrn   litoep:near,eptoli:near,pdtoep:near,eptopd:near
  57. #        extrn   fptoep:near,eptofp:near,dptoep:near,eptodp:near
  58. #        extrn   eptoep:near
  59. #        extrn   getqn:near
  60. #        extrn   epadd:near,epsub:near,epsubr:near,epmul:near
  61. #        extrn   epdiv:near,epdivr:near,eprem:near
  62. #        extrn   epcomp:near,epcomu:near,epexam:near,eptown:near,epsqrt:near
  63. #        extrn   rounde:near,roundx:near,exproc:near
  64. #        extrn   xtract:near,scale:near
  65. #        extrn   epf2xm1:near,epsin:near,epcos:near,eptan:near
  66. #        extrn   eplog:near,eplog1:near,epatan:near
  67. #        extrn   reduct:near
  68. #        extrn   exir_no:abs
  69. #        extrn   ENIRS:abs
  71. #DGROUP  GROUP   hwseg
  72. #CGROUP  GROUP   emuseg
  74. #hwseg   segment RW page public 'DATA'
  75. #        assume  ds:DGROUP, es:DGROUP, ss:DGROUP
  76. .globl h_ctrl,h_stat,s_iptr,s_memp
  77. .lcomm s_stk,256
  78. .lcomm s_fpsp,4
  79. .lcomm s_iptr,4
  80. .lcomm s_memp,4
  81. .lcomm h_ctrl,4
  82. .lcomm h_stat,4
  83. .lcomm h_tag,4
  84. #hwseg   ends
  86. #emuseg  segment public USE32 'CODE'
  87. #        assume  cs:CGROUP
  89. # address tables for floating-point instructions
  91. instab: .long faddfp,fmulfp,fcomfp,fcompfp,fsubfp,fsubrfp,fdivfp,fdivrfp
  92. .long fldfp,NONE_,fstf,fstpf,fldenv_,fldcwc,fstenv_,fstcwc
  93. .long faddsi,fmulsi,fcomsi,fcompsi,fsubsi,fsubrsi,fdivsi,fdivrsi
  94. .long fldsi,NONE_,fisti,fistpi,NONE_,flde,NONE_,fstpe
  95. .long fadddp,fmuldp,fcomdp,fcompdp,fsubdp,fsubrdp,fdivdp,fdivrdp
  96. .long flddp,NONE_,fstd,fstpd,frstor_,NONE_,fsave_,fstsw_
  97. .long faddwi,fmulwi,fcomwi,fcompwi,fsubwi,fsubrwi,fdivwi,fdivrwi
  98. .long fldwi,NONE_,fistw,fistpw,fbldp,fildl,fbstpp,fistpl
  100. instas: .long fadds,fmuls,fcoms,fcomps,fsubs,fsubrs,fdivs,fdivrs
  101. .long flds,fxchs,fnop_,fstps,is1,is8,is2,is3
  102. .long NONE_,NONE_,NONE_,NONE_,NONE_,fucompps,NONE_,NONE_
  103. .long NONE_,NONE_,NONE_,NONE_,is5,NONE_,NONE_,NONE_
  104. .long faddx,fmulx,NONE_,NONE_,fsubx,fsubrx,fdivx,fdivrx
  105. .long ffree_,NONE_,fsts,fstps,fucoms,fucomps,NONE_,NONE_
  106. .long faddpx,fmulpx,NONE_,fcompps,fsubpx,fsubrpx,fdivrpx,fdivpx
  107. .long NONE_,NONE_,NONE_,NONE_,fstswax_,NONE_,NONE_,NONE_
  109. .balign 16,0x90
  110. .globl GTEXT(emuInit)
  111. FUNC_LABEL(emuInit)
  112. fninit
  113. ret
  115. .balign 16,0x90
  116. .globl GTEXT(emu387)
  117. FUNC_LABEL(emu387)
  118. #       test    byte ptr [esp+9],2 ;enable interrupts, unless they were
  119. .word ENIRS
  120. .byte 0x24,0x09,0x02
  121. jz emu3 #   disabled initially
  122. sti
  124. emu3: pusha #save all general registers
  126. subl $s_len,%esp #reserve a frame on the stack
  127. movl %esp,%ebp
  128. cld
  130. addl $12,s_sp(%ebp)
  132. movl s_ip(%ebp),%esi #address of FP instruction -> esi
  134. emu86:
  135. .byte 0x2e #from cs: but assembler seems defective
  136. lodsw #pick up the instruction
  137. cmpb $0x0d8,%al
  138. jc emu84
  140. emu11: movl %eax,%edx #build 6-bit instruction index -> edx
  141. shlb $2,%dh
  142. rolw $3,%dx
  143. andl $0x3f,%edx
  145. movb %ah,%bl #build R/M code
  146. andl $7,%ebx #   and leave in bl for the following
  148. cmpb $0x0c0,%ah #MOD 3 uses no memory addressing
  149. jnc emu50
  151. xorl %edi,%edi #handle possible s-i-b
  152. cmpb $4,%bl
  153. jnz emu26
  154. .byte 0x2e #from cs: 
  155. lodsb
  156. movb %al,%bl
  157. andb $7,%bl
  158. shldl $31,%eax,%edi
  159. andl $7*4,%edi
  160. subl $4*4,%edi
  161. jz emu26
  162. movb %al,%cl #scaled index
  163. shrb $6,%cl
  164. negl %edi
  165. movl s_di+28-16(%ebp,%edi),%edi
  166. shll %cl,%edi
  168. emu26: addb %ah,%ah #take displacement -> ax
  169. js emu24 #   MOD 01 reg+d8
  170. jc emu25 #   MOD 10 reg+d32
  171. cmpb $5,%bl #   MOD 00 reg; reg5 = d32
  172. jnz emu27
  173. .byte 0x2e #from cs:
  174. lodsl
  175. jmp emu42
  176. emu27: xorl %eax,%eax
  177. jmp emu29
  178. emu25:
  179. .byte 0x2e #from cs:
  180. lodsl
  181. jmp emu29
  182. emu24:
  183. .byte 0x2e #from cs: 
  184. lodsb
  185. movsbl %al,%eax
  187. emu29: negl %ebx #add the base register
  188. addl s_di+28(%ebp,%ebx,4),%eax
  190. emu42: addl %edi,%eax #possible scaled index
  192. xchgl %esi,s_ip(%ebp) #update return address
  194. call *%cs:instab(,%edx,4) #call instruction handler
  196. emu51: movl s_ip(%ebp),%esi #if next instruction is ESC, repeat
  197. .byte 0x2e #from cs: but assembler seems defective
  198. lodsw
  199. xorb $0x0d8,%al
  200. cmpb $8,%al
  201. jc emu11
  203. addl $s_len,%esp #free the stack frame
  205. popa #restore registers
  206. emuret: iret
  208. emu50: xchgl %esi,s_ip(%ebp) #update return address
  209. call *%cs:instas(,%edx,4) #call instruction handler
  210. jmp emu51
  212. exret: addl $s_len,%esp #exception return
  214. popa
  215. .byte 0x0cd,EXIRNO #INT exception interrupt
  216. iret
  218. emu84: decl %esi #illegal prefix, skip
  219. jmp emu86
  221. #emu387  endp
  223. intrn:
  225. flddp: #push from memory
  226. andb $0x0fd,h_stat+1
  227. call dptoep
  228. #STPUSHP
  229. movl s_fpsp,%ebx
  230. subb $32,%bl
  231. cmpb $3,s_stk+10(%ebx)
  232. jnz stackof
  233. movl %ebx,s_fpsp
  234. addl $s_stk,%ebx
  235. movl %eax,(%ebx)
  236. movl %edx,4(%ebx)
  237. movl %ecx,8(%ebx)
  238. ret
  239. fstd: #fetch as double-precision
  240. #SAVEIX
  241. movl %eax,s_memp
  242. xchgl %esi,%eax
  243. movl %eax,s_iptr
  244. #STTOP   
  245. movl s_fpsp,%edi
  246. addl $s_stk,%edi
  247. #GETEP   
  248. movl (%edi),%eax
  249. movl 4(%edi),%edx
  250. movl 8(%edi),%ecx
  251. call eptodp
  252. movl %eax,(%esi)
  253. movl %edx,4(%esi)
  254. ret
  255. fstpd: #fetch as double-precision, pop
  256. #SAVEIX
  257. movl %eax,s_memp
  258. xchgl %esi,%eax
  259. movl %eax,s_iptr
  260. #STTOP   
  261. movl s_fpsp,%edi
  262. addl $s_stk,%edi
  263. #GETEP   
  264. movl (%edi),%eax
  265. movl 4(%edi),%edx
  266. movl 8(%edi),%ecx
  267. call eptodp
  268. movl %eax,(%esi)
  269. movl %edx,4(%esi)
  270. #STPOPq
  271. movb $3,10(%edi)
  272. addb $32,s_fpsp
  273. ret
  274. fadddp: #ST = ST + memory
  275. call dptoep
  276. #STTOP   
  277. movl s_fpsp,%edi
  278. addl $s_stk,%edi
  279. call epadd
  280. jmp rounde
  281. fsubdp: #ST = ST - memory
  282. call dptoep
  283. #STTOP   
  284. movl s_fpsp,%edi
  285. addl $s_stk,%edi
  286. call epsubr
  287. jmp rounde
  288. fmuldp: #ST = ST * memory
  289. call dptoep
  290. #STTOP   
  291. movl s_fpsp,%edi
  292. addl $s_stk,%edi
  293. call epmul
  294. jmp rounde
  295. fdivdp: #ST = ST / memory
  296. call dptoep
  297. #STTOP   
  298. movl s_fpsp,%edi
  299. addl $s_stk,%edi
  300. call epdivr
  301. jmp rounde
  302. fsubrdp: #ST = memory - ST
  303. call dptoep
  304. #STTOP   
  305. movl s_fpsp,%edi
  306. addl $s_stk,%edi
  307. call epsub
  308. jmp rounde
  309. fdivrdp: #ST = memory / ST
  310. call dptoep
  311. #STTOP   
  312. movl s_fpsp,%edi
  313. addl $s_stk,%edi
  314. call epdiv
  315. jmp rounde
  316. fsqrt_: #square-root of ST
  317. #STTOP   
  318. movl s_fpsp,%edi
  319. addl $s_stk,%edi
  320. #GETEP   
  321. movl (%edi),%eax
  322. movl 4(%edi),%edx
  323. movl 8(%edi),%ecx
  324. call epsqrt
  325. jmp rounde
  326. fcomdp: #ST - memory -> codes
  327. orb $0x45,h_stat+1
  328. call dptoep
  329. #STTOP   
  330. movl s_fpsp,%edi
  331. addl $s_stk,%edi
  332. jmp epcomp
  333. fcompdp: #ST - memory -> codes, pop
  334. orb $0x45,h_stat+1
  335. call dptoep
  336. #STTOP   
  337. movl s_fpsp,%edi
  338. addl $s_stk,%edi
  339. call epcomp
  340. #STPOPq
  341. movb $3,10(%edi)
  342. addb $32,s_fpsp
  343. ret
  344. faddfp: #ST = ST + memory
  345. call fptoep
  346. #STTOP   
  347. movl s_fpsp,%edi
  348. addl $s_stk,%edi
  349. call epadd
  350. jmp rounde
  351. faddwi: #ST = ST + memory
  352. call witoep
  353. jmp .+7
  354. faddsi: #ST = ST + memory
  355. call sitoep
  356. #STTOP   
  357. movl s_fpsp,%edi
  358. addl $s_stk,%edi
  359. call epadd
  360. jmp rounde
  361. fmulfp: #ST = ST * memory
  362. call fptoep
  363. #STTOP   
  364. movl s_fpsp,%edi
  365. addl $s_stk,%edi
  366. call epmul
  367. jmp rounde
  368. fmulwi: #ST = ST * memory
  369. call witoep
  370. jmp .+7
  371. fmulsi: #ST = ST * memory
  372. call sitoep
  373. #STTOP   
  374. movl s_fpsp,%edi
  375. addl $s_stk,%edi
  376. call epmul
  377. jmp rounde
  378. fcomfp: #ST - memory -> codes
  379. orb $0x45,h_stat+1
  380. call fptoep
  381. #STTOP   
  382. movl s_fpsp,%edi
  383. addl $s_stk,%edi
  384. jmp epcomp
  385. fcomsi: #ST - memory -> codes
  386. call sitoep
  387. #STTOP   
  388. movl s_fpsp,%edi
  389. addl $s_stk,%edi
  390. jmp epcomp
  391. fcomwi: #ST - memory -> codes
  392. call witoep
  393. #STTOP   
  394. movl s_fpsp,%edi
  395. addl $s_stk,%edi
  396. jmp epcomp
  397. fcompfp: #ST - memory -> codes, pop
  398. orb $0x45,h_stat+1
  399. call fptoep
  400. #STTOP   
  401. movl s_fpsp,%edi
  402. addl $s_stk,%edi
  403. call epcomp
  404. #STPOPq
  405. movb $3,10(%edi)
  406. addb $32,s_fpsp
  407. ret
  408. fcompwi: #ST - memory -> codes, pop
  409. call witoep
  410. jmp .+7
  411. fcompsi: #ST - memory -> codes, pop
  412. call sitoep
  413. #STTOP   
  414. movl s_fpsp,%edi
  415. addl $s_stk,%edi
  416. call epcomp
  417. #STPOPq
  418. movb $3,10(%edi)
  419. addb $32,s_fpsp
  420. ret
  421. fsubfp: #ST = ST - memory
  422. call fptoep
  423. #STTOP   
  424. movl s_fpsp,%edi
  425. addl $s_stk,%edi
  426. call epsubr
  427. jmp rounde
  428. fsubwi: #ST = ST - memory
  429. call witoep
  430. jmp .+7
  431. fsubsi: #ST = ST - memory
  432. call sitoep
  433. #STTOP   
  434. movl s_fpsp,%edi
  435. addl $s_stk,%edi
  436. call epsubr
  437. jmp rounde
  438. fsubrfp: #ST = memory - ST
  439. call fptoep
  440. #STTOP   
  441. movl s_fpsp,%edi
  442. addl $s_stk,%edi
  443. call epsub
  444. jmp rounde
  445. fsubrwi: #ST = memory - ST
  446. call witoep
  447. jmp .+7
  448. fsubrsi: #ST = memory - ST
  449. call sitoep
  450. #STTOP   
  451. movl s_fpsp,%edi
  452. addl $s_stk,%edi
  453. call epsub
  454. jmp rounde
  455. fdivfp: #ST = ST / memory
  456. call fptoep
  457. #STTOP   
  458. movl s_fpsp,%edi
  459. addl $s_stk,%edi
  460. call epdivr
  461. jmp rounde
  462. fdivwi: #ST = ST / memory
  463. call witoep
  464. jmp .+7
  465. fdivsi: #ST = ST / memory
  466. call sitoep
  467. #STTOP   
  468. movl s_fpsp,%edi
  469. addl $s_stk,%edi
  470. call epdivr
  471. jmp rounde
  472. fdivrfp: #ST = memory / ST
  473. call fptoep
  474. #STTOP   
  475. movl s_fpsp,%edi
  476. addl $s_stk,%edi
  477. call epdiv
  478. jmp rounde
  479. fdivrwi: #ST = memory / ST
  480. call witoep
  481. jmp .+7
  482. fdivrsi: #ST = memory / ST
  483. call sitoep
  484. #STTOP   
  485. movl s_fpsp,%edi
  486. addl $s_stk,%edi
  487. call epdiv
  488. jmp rounde
  489. fadds: #ST = ST + ST(i)
  490. #SAVEIN
  491. movl %esi,s_iptr
  492. #GETEPS  ebx
  493. movl s_fpsp,%eax
  494. movl %eax,%edi
  495. addl $s_stk,%edi
  496. shll $5,%ebx
  497. addb %bl,%al
  498. addl $s_stk,%eax
  499. movl 8(%eax),%ecx
  500. movl 4(%eax),%edx
  501. movl (%eax),%eax
  502. call epadd
  503. jmp rounde
  504. fmuls: #ST = ST * ST(i)
  505. #SAVEIN
  506. movl %esi,s_iptr
  507. #GETEPS  ebx
  508. movl s_fpsp,%eax
  509. movl %eax,%edi
  510. addl $s_stk,%edi
  511. shll $5,%ebx
  512. addb %bl,%al
  513. addl $s_stk,%eax
  514. movl 8(%eax),%ecx
  515. movl 4(%eax),%edx
  516. movl (%eax),%eax
  517. call epmul
  518. jmp rounde
  519. fcoms: #ST - ST(i) -> codes
  520. #SAVEIN
  521. movl %esi,s_iptr
  522. #GETEPS  ebx
  523. movl s_fpsp,%eax
  524. movl %eax,%edi
  525. addl $s_stk,%edi
  526. shll $5,%ebx
  527. addb %bl,%al
  528. addl $s_stk,%eax
  529. movl 8(%eax),%ecx
  530. movl 4(%eax),%edx
  531. movl (%eax),%eax
  532. jmp epcomp
  533. fcomps: #ST - ST(i) -> codes, pop
  534. #SAVEIN
  535. movl %esi,s_iptr
  536. #GETEPS  ebx
  537. movl s_fpsp,%eax
  538. movl %eax,%edi
  539. addl $s_stk,%edi
  540. shll $5,%ebx
  541. addb %bl,%al
  542. addl $s_stk,%eax
  543. movl 8(%eax),%ecx
  544. movl 4(%eax),%edx
  545. movl (%eax),%eax
  546. call epcomp
  547. #STPOPq
  548. movb $3,10(%edi)
  549. addb $32,s_fpsp
  550. ret
  551. fsubs: #ST = ST - ST(i)
  552. #SAVEIN
  553. movl %esi,s_iptr
  554. #GETEPS  ebx
  555. movl s_fpsp,%eax
  556. movl %eax,%edi
  557. addl $s_stk,%edi
  558. shll $5,%ebx
  559. addb %bl,%al
  560. addl $s_stk,%eax
  561. movl 8(%eax),%ecx
  562. movl 4(%eax),%edx
  563. movl (%eax),%eax
  564. call epsubr
  565. jmp rounde
  566. fsubrs: #ST = ST(i) - ST
  567. #SAVEIN
  568. movl %esi,s_iptr
  569. #GETEPS  ebx
  570. movl s_fpsp,%eax
  571. movl %eax,%edi
  572. addl $s_stk,%edi
  573. shll $5,%ebx
  574. addb %bl,%al
  575. addl $s_stk,%eax
  576. movl 8(%eax),%ecx
  577. movl 4(%eax),%edx
  578. movl (%eax),%eax
  579. call epsub
  580. jmp rounde
  581. fdivs: #ST = ST / ST(i)
  582. #SAVEIN
  583. movl %esi,s_iptr
  584. #GETEPS  ebx
  585. movl s_fpsp,%eax
  586. movl %eax,%edi
  587. addl $s_stk,%edi
  588. shll $5,%ebx
  589. addb %bl,%al
  590. addl $s_stk,%eax
  591. movl 8(%eax),%ecx
  592. movl 4(%eax),%edx
  593. movl (%eax),%eax
  594. call epdivr
  595. jmp rounde
  596. fdivrs: #ST = ST(i) / ST
  597. #SAVEIN
  598. movl %esi,s_iptr
  599. #GETEPS  ebx
  600. movl s_fpsp,%eax
  601. movl %eax,%edi
  602. addl $s_stk,%edi
  603. shll $5,%ebx
  604. addb %bl,%al
  605. addl $s_stk,%eax
  606. movl 8(%eax),%ecx
  607. movl 4(%eax),%edx
  608. movl (%eax),%eax
  609. call epdiv
  610. jmp rounde
  611. fldfp: #push from memory
  612. andb $0x0fd,h_stat+1
  613. call fptoep
  614. #STPUSHP
  615. movl s_fpsp,%ebx
  616. subb $32,%bl
  617. cmpb $3,s_stk+10(%ebx)
  618. jnz stackof
  619. movl %ebx,s_fpsp
  620. addl $s_stk,%ebx
  621. movl %eax,(%ebx)
  622. movl %edx,4(%ebx)
  623. movl %ecx,8(%ebx)
  624. ret
  625. fldsi: #push from memory
  626. andb $0x0fd,h_stat+1
  627. call sitoep
  628. #STPUSHP
  629. movl s_fpsp,%ebx
  630. subb $32,%bl
  631. cmpb $3,s_stk+10(%ebx)
  632. jnz stackof
  633. movl %ebx,s_fpsp
  634. addl $s_stk,%ebx
  635. movl %eax,(%ebx)
  636. movl %edx,4(%ebx)
  637. movl %ecx,8(%ebx)
  638. ret
  639. fldwi: #push from memory
  640. andb $0x0fd,h_stat+1
  641. call witoep
  642. #STPUSHP
  643. movl s_fpsp,%ebx
  644. subb $32,%bl
  645. cmpb $3,s_stk+10(%ebx)
  646. jnz stackof
  647. movl %ebx,s_fpsp
  648. addl $s_stk,%ebx
  649. movl %eax,(%ebx)
  650. movl %edx,4(%ebx)
  651. movl %ecx,8(%ebx)
  652. ret
  653. fstf: #fetch as single-precision
  654. #SAVEIX
  655. movl %eax,s_memp
  656. xchgl %esi,%eax
  657. movl %eax,s_iptr
  658. #STTOP   
  659. movl s_fpsp,%edi
  660. addl $s_stk,%edi
  661. #GETEP   
  662. movl (%edi),%eax
  663. movl 4(%edi),%edx
  664. movl 8(%edi),%ecx
  665. call eptofp
  666. movl %eax,(%esi)
  667. ret
  668. fstpf: #pop as single-precision 
  669. #SAVEIX
  670. movl %eax,s_memp
  671. xchgl %esi,%eax
  672. movl %eax,s_iptr
  673. #STTOP   
  674. movl s_fpsp,%edi
  675. addl $s_stk,%edi
  676. #GETEP   
  677. movl (%edi),%eax
  678. movl 4(%edi),%edx
  679. movl 8(%edi),%ecx
  680. call eptofp
  681. movl %eax,(%esi)
  682. #STPOPq
  683. movb $3,10(%edi)
  684. addb $32,s_fpsp
  685. ret
  686. fldcwc: #load control word
  687. movw (%eax),%ax
  688. andw $0x1f7f,%ax
  689. orb $0x40,%al
  690. movw %ax,h_ctrl
  691. ret
  692. fstcwc: #store control word
  693. movl %eax,%edi
  694. movw h_ctrl,%ax
  695. stosw
  696. ret
  697. flds: #ST = ST(i)
  698. #SAVEIN
  699. movl %esi,s_iptr
  700. andb $0x0fd,h_stat+1
  701. #STIX    ebx
  702. movl s_fpsp,%eax
  703. shll $5,%ebx
  704. addb %bl,%al
  705. addl $s_stk,%eax
  706. xchgl %edi,%eax
  707. #GETEP   
  708. movl (%edi),%eax
  709. movl 4(%edi),%edx
  710. movl 8(%edi),%ecx
  711. #STPUSHP
  712. movl s_fpsp,%ebx
  713. subb $32,%bl
  714. cmpb $3,s_stk+10(%ebx)
  715. jnz stackof
  716. movl %ebx,s_fpsp
  717. addl $s_stk,%ebx
  718. movl %eax,(%ebx)
  719. movl %edx,4(%ebx)
  720. movl %ecx,8(%ebx)
  721. ret
  722. fxchs: #exchange ST and ST(i)
  723. #SAVEIN
  724. movl %esi,s_iptr
  725. andb $0x0fd,h_stat+1
  726. movl s_fpsp,%eax
  727. addl $s_stk,%eax
  728. movl (%eax),%edi
  729. movl 4(%eax),%edx
  730. movl 8(%eax),%ecx
  731. subl $s_stk,%eax
  732. shll $5,%ebx
  733. addb %bl,%al
  734. addl $s_stk,%eax
  735. xchgl %edi,(%eax)
  736. xchgl %edx,4(%eax)
  737. xchgl %ecx,8(%eax)
  738. subl $s_stk,%eax
  739. subb %bl,%al
  740. addl $s_stk,%eax
  741. movl %edi,(%eax)
  742. movl %edx,4(%eax)
  743. movl %ecx,8(%eax)
  744. ret
  745. fnop_: #no operation
  746. #SAVEIN
  747. movl %esi,s_iptr
  748. ret
  749. fstps: #ST(i) = ST and pop
  750. #SAVEIN
  751. movl %esi,s_iptr
  752. andb $0x0fd,h_stat+1
  753. movl s_fpsp,%eax
  754. addl $s_stk,%eax
  755. movl %eax,%edi
  756. movl (%eax),%esi
  757. movl 4(%eax),%edx
  758. movl 8(%eax),%ecx
  759. shll $5,%ebx
  760. subl $s_stk,%eax
  761. addb %bl,%al
  762. addl $s_stk,%eax
  763. movl %esi,(%eax)
  764. movl %edx,4(%eax)
  765. movl %ecx,8(%eax)
  766. #STPOPq
  767. movb $3,10(%edi)
  768. addb $32,s_fpsp
  769. ret
  770. fucoms: #ST - ST(i) -> codes
  771. #SAVEIN
  772. movl %esi,s_iptr
  773. #GETEPS  ebx
  774. movl s_fpsp,%eax
  775. movl %eax,%edi
  776. addl $s_stk,%edi
  777. shll $5,%ebx
  778. addb %bl,%al
  779. addl $s_stk,%eax
  780. movl 8(%eax),%ecx
  781. movl 4(%eax),%edx
  782. movl (%eax),%eax
  783. jmp epcomu
  784. fucomps: #ST - ST(i) -> codes, pop
  785. #SAVEIN
  786. movl %esi,s_iptr
  787. #GETEPS  ebx
  788. movl s_fpsp,%eax
  789. movl %eax,%edi
  790. addl $s_stk,%edi
  791. shll $5,%ebx
  792. addb %bl,%al
  793. addl $s_stk,%eax
  794. movl 8(%eax),%ecx
  795. movl 4(%eax),%edx
  796. movl (%eax),%eax
  797. call epcomu
  798. #STPOPq
  799. movb $3,10(%edi)
  800. addb $32,s_fpsp
  801. ret
  802. is1t: .long fchs_,fabs_,NONE_,NONE_,ftst_,fxam_,NONE_,NONE_
  803. is1:
  804. #SAVEIN
  805. movl %esi,s_iptr
  806. jmp *%cs:is1t(,%ebx,4)
  807. fchs_: #ST = -ST
  808. andb $0x0fd,h_stat+1
  809. #STTOP   
  810. movl s_fpsp,%edi
  811. addl $s_stk,%edi
  812. xorb $0x80,11(%edi)
  813. ret
  814. fabs_: #ST = |ST|
  815. andb $0x0fd,h_stat+1
  816. #STTOP   
  817. movl s_fpsp,%edi
  818. addl $s_stk,%edi
  819. andb $0x7f,11(%edi)
  820. ret
  821. ftst_: #set codes according to ST
  822. #STTOP   
  823. movl s_fpsp,%edi
  824. addl $s_stk,%edi
  825. movl $0x00010000,%ecx
  826. xorl %eax,%eax
  827. xorl %edx,%edx
  828. jmp epcomp
  829. fxam_: #set codes according to ST
  830. andb $0x0b8,h_stat+1
  831. movl s_fpsp,%edi
  832. addl $s_stk,%edi
  833. cmpb $3,10(%edi)
  834. jz fxa9
  835. #GETEP   
  836. movl (%edi),%eax
  837. movl 4(%edi),%edx
  838. movl 8(%edi),%ecx
  839. call epexam
  840. orb %al,h_stat+1
  841. fxa9: ret
  842. is8t: .long ld1,ldl2t,ldl2e,ldpi,ldlg2,ldln2,ldz,NONE_ 
  843. is8:
  844. #SAVEIN
  845. movl %esi,s_iptr
  846. andb $0x0fd,h_stat+1
  847. call *%cs:is8t(,%ebx,4)
  848. #STPUSHP
  849. movl s_fpsp,%ebx
  850. subb $32,%bl
  851. cmpb $3,s_stk+10(%ebx)
  852. jnz stackof
  853. movl %ebx,s_fpsp
  854. addl $s_stk,%ebx
  855. movl %eax,(%ebx)
  856. movl %edx,4(%ebx)
  857. movl %ecx,8(%ebx)
  858. ret
  859. ld1: #load 1
  860. xorl %eax,%eax
  861. movl $0x80000000,%edx
  862. movl $0x00003fff,%ecx
  863. ret
  864. ldl2t: #load log2(10)
  865. movl $0xcd1b8afe,%eax
  866. movl $0xd49a784b,%edx
  867. movl $0x00004000,%ecx
  868. movb h_ctrl+1,%bh
  869. andb $0x0c,%bh
  870. cmpb $0x08,%bh
  871. jnz ldc3
  872. incl %eax
  873. ldc3: ret
  874. ldl2e: #load log2(e)
  875. movl $0x5c17f0bb,%eax
  876. movl $0xb8aa3b29,%edx
  877. movl $0x00003fff,%ecx
  878. testb $0x04,h_ctrl+1
  879. jnz ldc5
  880. incl %eax
  881. ldc5: ret
  882. ldpi: #load pi
  883. movl $0x2168c234,%eax
  884. movl $0xc90fdaa2,%edx
  885. movl $0x00004000,%ecx
  886. testb $0x04,h_ctrl+1
  887. jnz ldp5
  888. incl %eax
  889. ldp5: ret
  890. ldlg2: #load log10(2)
  891. movl $0xfbcff798,%eax
  892. movl $0x9a209a84,%edx
  893. movl $0x00003ffd,%ecx
  894. testb $0x04,h_ctrl+1
  895. jnz ldc9
  896. incl %eax
  897. ldc9: ret
  898. ldln2: #load ln(2)
  899. movl $0xd1cf79ab,%eax
  900. movl $0xb17217f7,%edx
  901. movl $0x00003ffe,%ecx
  902. testb $0x04,h_ctrl+1
  903. jnz ldc11
  904. incl %eax
  905. ldc11: ret
  906. ldz: #load 0
  907. xorl %eax,%eax
  908. xorl %edx,%edx
  909. movl $0x00010000,%ecx
  910. ret
  911. is2t: .long f2xm1_,fyl2x_,fptan_,fpatan_,fxtract_,fprem_,fdecstp_,fincstp_ 
  912. is2:
  913. #SAVEIN
  914. movl %esi,s_iptr
  915. jmp *%cs:is2t(,%ebx,4)
  916. f2xm1_: #ST = (2^ST) - 1
  917. #STTOP   
  918. movl s_fpsp,%edi
  919. addl $s_stk,%edi
  920. #GETEP   
  921. movl (%edi),%eax
  922. movl 4(%edi),%edx
  923. movl 8(%edi),%ecx
  924. call epf2xm1
  925. #PUTEP   
  926. movl %eax,(%edi)
  927. movl %edx,4(%edi)
  928. movl %ecx,8(%edi)
  929. ret
  930. fyl2x_: #calculate log2(ST) * ST(1), pop once
  931. #STTOP   
  932. movl s_fpsp,%edi
  933. addl $s_stk,%edi
  934. #GETEP   
  935. movl (%edi),%eax
  936. movl 4(%edi),%edx
  937. movl 8(%edi),%ecx
  938. call eplog
  939. #STPOPq
  940. movb $3,10(%edi)
  941. addb $32,s_fpsp
  942. #STTOP   
  943. movl s_fpsp,%edi
  944. addl $s_stk,%edi
  945. call epmul
  946. jmp rounde
  947. fptan_: #make ST into tan(ST)
  948. #STTOP   
  949. movl s_fpsp,%edi
  950. addl $s_stk,%edi
  951. #GETEP   
  952. movl (%edi),%eax
  953. movl 4(%edi),%edx
  954. movl 8(%edi),%ecx
  955. call reduct
  956. movl %edi,%esi
  957. #STPUSH
  958. xchgl %edi,%ebx
  959. movl s_fpsp,%ebx
  960. subb $32,%bl
  961. xchgl %edi,%ebx
  962. cmpb $3,s_stk+10(%edi)
  963. jz LL1
  964. call stackof
  965. LL1: movl %edi,s_fpsp
  966. addl $s_stk,%edi
  967. pushl %edi
  968. movl %esi,%edi
  969. testl $0x30000,%ecx
  970. jnz tan11
  971. call eptan
  972. tan5: #PUTEP   
  973. movl %eax,(%edi)
  974. movl %edx,4(%edi)
  975. movl %ecx,8(%edi)
  976. movl $tBIAS,%ecx
  977. movl $0x80000000,%edx
  978. xorl %eax,%eax
  979. tan6: popl %edi
  980. #PUTEP   
  981. movl %eax,(%edi)
  982. movl %edx,4(%edi)
  983. movl %ecx,8(%edi)
  984. ret
  985. tan11: testl $0x50000,%ecx
  986. jnz tan5
  987. #PUTEP   
  988. movl %eax,(%edi)
  989. movl %edx,4(%edi)
  990. movl %ecx,8(%edi)
  991. call getqn
  992. jmp tan6
  993. fpatan_: #arctangent of ST(1)/ST, pop stack
  994. #STTOP   
  995. movl s_fpsp,%edi
  996. addl $s_stk,%edi
  997. #GETEP   
  998. movl (%edi),%eax
  999. movl 4(%edi),%edx
  1000. movl 8(%edi),%ecx
  1001. #STIX1
  1002. movl s_fpsp,%ebx
  1003. addb $32,%bl
  1004. addl $s_stk,%ebx
  1005. xchgl %edi,%ebx
  1006. call epatan
  1007. #PUTEP   
  1008. movl %eax,(%edi)
  1009. movl %edx,4(%edi)
  1010. movl %ecx,8(%edi)
  1011. #STPOP
  1012. movl s_fpsp,%eax
  1013. addl $s_stk,%eax
  1014. movb $3,10(%eax)
  1015. addb $32,s_fpsp
  1016. ret
  1017. fxtract_: #extract exponent and mantissa
  1018. andb $0x0fd,h_stat+1
  1019. #STTOP   
  1020. movl s_fpsp,%edi
  1021. addl $s_stk,%edi
  1022. #GETEP   
  1023. movl (%edi),%eax
  1024. movl 4(%edi),%edx
  1025. movl 8(%edi),%ecx
  1026. call xtract
  1027. #STPUSHP
  1028. movl s_fpsp,%ebx
  1029. subb $32,%bl
  1030. cmpb $3,s_stk+10(%ebx)
  1031. jnz stackof
  1032. movl %ebx,s_fpsp
  1033. addl $s_stk,%ebx
  1034. movl %eax,(%ebx)
  1035. movl %edx,4(%ebx)
  1036. movl %ecx,8(%ebx)
  1037. ret
  1038. fdecstp_: #decrement stack pointer
  1039. subb $32,s_fpsp
  1040. ret
  1041. fincstp_: #increment stack pointer
  1042. addb $32,s_fpsp
  1043. ret
  1044. is3t: .long fprem_,fyl2xp1_,fsqrt_,fsincos_,frndint_,fscale_,fsin_,fcos_ 
  1045. is3:
  1046. #SAVEIN
  1047. movl %esi,s_iptr
  1048. jmp *%cs:is3t(,%ebx,4)
  1049. fprem_: # ST = ST / ST(1) Intel/IEEE remainder
  1050. #STIX1q
  1051. movl s_fpsp,%eax
  1052. addb $32,%al
  1053. addl $s_stk,%eax
  1054. xchgl %edi,%eax
  1055. #GETEP   
  1056. movl (%edi),%eax
  1057. movl 4(%edi),%edx
  1058. movl 8(%edi),%ecx
  1059. #STTOP   
  1060. movl s_fpsp,%edi
  1061. addl $s_stk,%edi
  1062. call eprem
  1063. #PUTEP   
  1064. movl %eax,(%edi)
  1065. movl %edx,4(%edi)
  1066. movl %ecx,8(%edi)
  1067. ret
  1068. fyl2xp1_: #calculate log2(ST+1) * ST(1), pop once
  1069. #STTOP   
  1070. movl s_fpsp,%edi
  1071. addl $s_stk,%edi
  1072. #GETEP   
  1073. movl (%edi),%eax
  1074. movl 4(%edi),%edx
  1075. movl 8(%edi),%ecx
  1076. call eplog1
  1077. #STPOPq
  1078. movb $3,10(%edi)
  1079. addb $32,s_fpsp
  1080. #STTOP   
  1081. movl s_fpsp,%edi
  1082. addl $s_stk,%edi
  1083. call epmul
  1084. jmp rounde
  1085. frndint_: #round ST to integer
  1086. #STTOP   
  1087. movl s_fpsp,%edi
  1088. addl $s_stk,%edi
  1089. #GETEP   
  1090. movl (%edi),%eax
  1091. movl 4(%edi),%edx
  1092. movl 8(%edi),%ecx
  1093. call eptown
  1094. #PUTEP   
  1095. movl %eax,(%edi)
  1096. movl %edx,4(%edi)
  1097. movl %ecx,8(%edi)
  1098. ret
  1099. fscale_: #add ST(1) to exponent of ST
  1100. movl s_fpsp,%eax
  1101. addl $s_stk,%eax
  1102. movl %eax,%edi
  1103. subl $s_stk,%eax
  1104. addb $32,%al
  1105. addl $s_stk,%eax
  1106. movl 8(%eax),%ecx
  1107. movl 4(%eax),%edx
  1108. movl (%eax),%eax
  1109. call scale
  1110. jmp roundx
  1111. fucompps: #ST - ST(1) -> codes, pop twice
  1112. #SAVEIN
  1113. movl %esi,s_iptr
  1114. #STIX1q
  1115. movl s_fpsp,%eax
  1116. addb $32,%al
  1117. addl $s_stk,%eax
  1118. xchgl %edi,%eax
  1119. #GETEP   
  1120. movl (%edi),%eax
  1121. movl 4(%edi),%edx
  1122. movl 8(%edi),%ecx
  1123. #STTOP   
  1124. movl s_fpsp,%edi
  1125. addl $s_stk,%edi
  1126. call epcomu
  1127. movl %edi,%eax
  1128. movb $3,10(%eax)
  1129. subl $s_stk,%eax
  1130. addb $32,%al
  1131. addl $s_stk,%eax
  1132. movb $3,10(%eax)
  1133. addb $64,s_fpsp
  1134. ret
  1135. fisti: #fetch into 32-bit integer
  1136. #SAVEIX
  1137. movl %eax,s_memp
  1138. xchgl %esi,%eax
  1139. movl %eax,s_iptr
  1140. #STTOP   
  1141. movl s_fpsp,%edi
  1142. addl $s_stk,%edi
  1143. #GETEP   
  1144. movl (%edi),%eax
  1145. movl 4(%edi),%edx
  1146. movl 8(%edi),%ecx
  1147. call eptosi
  1148. movl %eax,(%esi)
  1149. ret
  1150. fistpi: #pop into 32-bit integer
  1151. #SAVEIX
  1152. movl %eax,s_memp
  1153. xchgl %esi,%eax
  1154. movl %eax,s_iptr
  1155. #STTOP   
  1156. movl s_fpsp,%edi
  1157. addl $s_stk,%edi
  1158. #GETEP   
  1159. movl (%edi),%eax
  1160. movl 4(%edi),%edx
  1161. movl 8(%edi),%ecx
  1162. call eptosi
  1163. movl %eax,(%esi)
  1164. #STPOPq
  1165. movb $3,10(%edi)
  1166. addb $32,s_fpsp
  1167. ret
  1168. flde: #push EP from memory
  1169. #SAVEII
  1170. movl %esi,s_iptr
  1171. movl %eax,s_memp
  1172. andb $0x0fd,h_stat+1
  1173. call eptoep
  1174. #STPUSHP
  1175. movl s_fpsp,%ebx
  1176. subb $32,%bl
  1177. cmpb $3,s_stk+10(%ebx)
  1178. jnz stackof
  1179. movl %ebx,s_fpsp
  1180. addl $s_stk,%ebx
  1181. movl %eax,(%ebx)
  1182. movl %edx,4(%ebx)
  1183. movl %ecx,8(%ebx)
  1184. ret
  1185. fstpe: #fetch as extended-precision
  1186. #SAVEIX
  1187. movl %eax,s_memp
  1188. xchgl %esi,%eax
  1189. movl %eax,s_iptr
  1190. andb $0x0fd,h_stat+1
  1191. #STTOP   
  1192. movl s_fpsp,%edi
  1193. addl $s_stk,%edi
  1194. #GETEP   
  1195. movl (%edi),%eax
  1196. movl 4(%edi),%edx
  1197. movl 8(%edi),%ecx
  1198. shldl $16,%ecx,%ebx
  1199. cmpb $3,%bl
  1200. jnz stpe5
  1201. call getqn
  1202. stpe5: movl %eax,(%esi)
  1203. movl %edx,4(%esi)
  1204. addl %ecx,%ecx
  1205. rcrw $1,%cx
  1206. movw %cx,8(%esi)
  1207. #STPOPq
  1208. movb $3,10(%edi)
  1209. addb $32,s_fpsp
  1210. ret
  1211. is5t: .long NONE_,NONE_,fclex_,finit_,NONE_,NONE_,NONE_,NONE_ 
  1212. is5: jmp *%cs:is5t(,%ebx,4)
  1213. fclex_: #clear error status flags
  1214. andw $0x7f00,h_stat
  1215. ret
  1216. faddx: #ST(i) = ST + ST(i)
  1217. #SAVEIN
  1218. movl %esi,s_iptr
  1219. #GETEPX  ebx
  1220. movl s_fpsp,%eax
  1221. addl $s_stk,%eax
  1222. movl (%eax),%edi
  1223. movl 4(%eax),%edx
  1224. movl 8(%eax),%ecx
  1225. subl $s_stk,%eax
  1226. shll $5,%ebx
  1227. addb %bl,%al
  1228. addl $s_stk,%eax
  1229. xchgl %edi,%eax
  1230. call epadd
  1231. jmp rounde
  1232. fmulx: #ST(i) = ST * ST(i)
  1233. #SAVEIN
  1234. movl %esi,s_iptr
  1235. #GETEPX  ebx
  1236. movl s_fpsp,%eax
  1237. addl $s_stk,%eax
  1238. movl (%eax),%edi
  1239. movl 4(%eax),%edx
  1240. movl 8(%eax),%ecx
  1241. subl $s_stk,%eax
  1242. shll $5,%ebx
  1243. addb %bl,%al
  1244. addl $s_stk,%eax
  1245. xchgl %edi,%eax
  1246. call epmul
  1247. jmp rounde
  1248. fsubx: #ST(i) = ST - ST(i)
  1249. #SAVEIN
  1250. movl %esi,s_iptr
  1251. #GETEPX  ebx
  1252. movl s_fpsp,%eax
  1253. addl $s_stk,%eax
  1254. movl (%eax),%edi
  1255. movl 4(%eax),%edx
  1256. movl 8(%eax),%ecx
  1257. subl $s_stk,%eax
  1258. shll $5,%ebx
  1259. addb %bl,%al
  1260. addl $s_stk,%eax
  1261. xchgl %edi,%eax
  1262. call epsub
  1263. jmp rounde
  1264. fsubrx: #ST(i) = ST(i) - ST
  1265. #SAVEIN
  1266. movl %esi,s_iptr
  1267. #GETEPX  ebx
  1268. movl s_fpsp,%eax
  1269. addl $s_stk,%eax
  1270. movl (%eax),%edi
  1271. movl 4(%eax),%edx
  1272. movl 8(%eax),%ecx
  1273. subl $s_stk,%eax
  1274. shll $5,%ebx
  1275. addb %bl,%al
  1276. addl $s_stk,%eax
  1277. xchgl %edi,%eax
  1278. call epsubr
  1279. jmp rounde
  1280. fdivx: #ST(i) = ST / ST(i)
  1281. #SAVEIN
  1282. movl %esi,s_iptr
  1283. #GETEPX  ebx
  1284. movl s_fpsp,%eax
  1285. addl $s_stk,%eax
  1286. movl (%eax),%edi
  1287. movl 4(%eax),%edx
  1288. movl 8(%eax),%ecx
  1289. subl $s_stk,%eax
  1290. shll $5,%ebx
  1291. addb %bl,%al
  1292. addl $s_stk,%eax
  1293. xchgl %edi,%eax
  1294. call epdiv
  1295. jmp rounde
  1296. fdivrx: #ST(i) = ST(i) / ST
  1297. #SAVEIN
  1298. movl %esi,s_iptr
  1299. #GETEPX  ebx
  1300. movl s_fpsp,%eax
  1301. addl $s_stk,%eax
  1302. movl (%eax),%edi
  1303. movl 4(%eax),%edx
  1304. movl 8(%eax),%ecx
  1305. subl $s_stk,%eax
  1306. shll $5,%ebx
  1307. addb %bl,%al
  1308. addl $s_stk,%eax
  1309. xchgl %edi,%eax
  1310. call epdivr
  1311. jmp rounde
  1312. fldenv_: #load environment
  1313. frstor_: #restore the HW status
  1314. movl %eax,%esi
  1315. movl $h_ctrl,%edi
  1316. movl $3,%ecx
  1317. .byte 0x36 #from ss: 
  1318. repz
  1319. movsl
  1320. .byte 0x36 #from ss: 
  1321. lodsl #instruction pointer
  1322. movl %eax,s_iptr
  1323. addl $4,%esi
  1324. .byte 0x36 #from ss: 
  1325. lodsl #operand pointer
  1326. movl %eax,s_memp
  1327. addl $4,%esi
  1328. movb h_stat+1,%al
  1329. shlb $2,%al
  1330. andl $0x0e0,%eax
  1331. movl %eax,s_fpsp
  1332. cmpb $0x2c,%dl
  1333. jnz rst5
  1334. movl s_fpsp,%edi
  1335. addl $s_stk,%edi
  1336. movl $8,%ecx
  1337. lds2: movl %esi,%eax
  1338. pushl %ecx
  1339. call eptoep
  1340. #PUTEP
  1341. movl %eax,(%edi)
  1342. movl %edx,4(%edi)
  1343. movl %ecx,8(%edi)
  1344. popl %ecx
  1345. addl $10,%esi
  1346. movl %edi,%eax
  1347. subl $s_stk,%eax
  1348. addb $32,%al
  1349. addl $s_stk,%eax
  1350. movl %eax,%edi
  1351. loop lds2
  1352. rst5: movw h_ctrl,%ax
  1353. notl %eax
  1354. andw h_stat,%ax
  1355. testb $0x3f,%al
  1356. jz rst7
  1357. orw $0x8080,h_stat
  1358. rst7: movl $8,%ecx #prepare to loop over all 8 tags
  1359. movw h_tag,%ax
  1360. movl $s_stk+0x0e0,%edi
  1361. ltt3: rolw $2,%ax
  1362. movb %al,%dl
  1363. andb $3,%dl
  1364. movb %dl,10(%edi)
  1365. subl $32,%edi
  1366. loop ltt3
  1367. ret
  1368. fstenv_: #store environment
  1369. fsave_: #save HW block
  1370. pushl %es #flat model assumes target is stack
  1371. movw %ss,%cx
  1372. movw %cx,%es
  1373. pushl %eax
  1374. movl $8,%ecx #prepare to loop over all 8 tags
  1375. movl $s_stk,%edi
  1376. stt3: movb 10(%edi),%bl #concatenate tags       
  1377. shrdw $2,%bx,%ax
  1378. addl $32,%edi
  1379. loop stt3
  1380. movw %ax,h_tag #store new tags
  1381. popl %edi
  1382. call stfpsp
  1383. movl $h_ctrl,%esi
  1384. movsl
  1385. movsl
  1386. movsl
  1387. movl s_iptr,%eax #instruction pointer
  1388. stosl
  1389. orl %eax,%eax
  1390. jz stp5
  1391. movw %cs,%ax
  1392. stp5: stosl
  1393. movl s_memp,%eax #operand pointer
  1394. stosl
  1395. orl %eax,%eax
  1396. jz stp7
  1397. movw %es,%ax
  1398. stp7: stosl
  1399. popl %es
  1400. cmpb $0x2e,%dl
  1401. jnz sts9
  1402. movl $8,%ecx
  1403. movl s_fpsp,%eax
  1404. sts2: addl $s_stk,%eax
  1405. movl (%eax),%esi
  1406. movl 4(%eax),%edx
  1407. movl 8(%eax),%ebx
  1408. subl $s_stk,%eax
  1409. movl %esi,(%edi)
  1410. movl %edx,4(%edi)
  1411. addl %ebx,%ebx
  1412. rcrw $1,%bx
  1413. movw %bx,8(%edi)
  1414. addl $10,%edi
  1415. addb $32,%al
  1416. loop sts2
  1418. finit_: #initialize hardware block
  1419. xorl %eax,%eax
  1420. movl $0x037f,h_ctrl
  1421. movl %eax,h_stat
  1422. movl $0xffff,h_tag
  1423. movl %eax,s_iptr
  1424. movl %eax,s_memp
  1425. movl $s_stk,%eax
  1426. movl $0,s_fpsp
  1427. movl $8,%ecx
  1428. fin4: movb $3,10(%eax)
  1429. addl $32,%eax
  1430. loop fin4
  1431. sts9: ret
  1432. .globl fstsw_
  1433. fstsw_: #fetch HW status word
  1434. movl %eax,%edi
  1435. call stfpsp
  1436. movw h_stat,%ax
  1437. stosw
  1438. ret
  1439. ffree_: #change tag to empty
  1440. #SAVEIN
  1441. movl %esi,s_iptr
  1442. #STIX    ebx
  1443. movl s_fpsp,%eax
  1444. shll $5,%ebx
  1445. addb %bl,%al
  1446. addl $s_stk,%eax
  1447. xchgl %edi,%eax
  1448. movb $3,10(%edi)
  1449. ret
  1450. fsts: #ST(i) = ST 
  1451. #SAVEIN
  1452. movl %esi,s_iptr
  1453. #GETEPX  ebx
  1454. movl s_fpsp,%eax
  1455. addl $s_stk,%eax
  1456. movl (%eax),%edi
  1457. movl 4(%eax),%edx
  1458. movl 8(%eax),%ecx
  1459. subl $s_stk,%eax
  1460. shll $5,%ebx
  1461. addb %bl,%al
  1462. addl $s_stk,%eax
  1463. xchgl %edi,%eax
  1464. #PUTEP   
  1465. movl %eax,(%edi)
  1466. movl %edx,4(%edi)
  1467. movl %ecx,8(%edi)
  1468. ret
  1469. faddpx: #ST(i) = ST + ST(i) and pop
  1470. #SAVEIN
  1471. movl %esi,s_iptr
  1472. #GETEPX  ebx
  1473. movl s_fpsp,%eax
  1474. addl $s_stk,%eax
  1475. movl (%eax),%edi
  1476. movl 4(%eax),%edx
  1477. movl 8(%eax),%ecx
  1478. subl $s_stk,%eax
  1479. shll $5,%ebx
  1480. addb %bl,%al
  1481. addl $s_stk,%eax
  1482. xchgl %edi,%eax
  1483. call epadd
  1484. call rounde
  1485. #STPOP
  1486. movl s_fpsp,%eax
  1487. addl $s_stk,%eax
  1488. movb $3,10(%eax)
  1489. addb $32,s_fpsp
  1490. ret
  1491. fmulpx: #ST(i) = ST * ST(i) and pop
  1492. #SAVEIN
  1493. movl %esi,s_iptr
  1494. #GETEPX  ebx
  1495. movl s_fpsp,%eax
  1496. addl $s_stk,%eax
  1497. movl (%eax),%edi
  1498. movl 4(%eax),%edx
  1499. movl 8(%eax),%ecx
  1500. subl $s_stk,%eax
  1501. shll $5,%ebx
  1502. addb %bl,%al
  1503. addl $s_stk,%eax
  1504. xchgl %edi,%eax
  1505. call epmul
  1506. call rounde
  1507. #STPOP
  1508. movl s_fpsp,%eax
  1509. addl $s_stk,%eax
  1510. movb $3,10(%eax)
  1511. addb $32,s_fpsp
  1512. ret
  1513. fcompps: #ST - ST(1) -> codes, pop twice
  1514. #SAVEIN
  1515. movl %esi,s_iptr
  1516. #STIX1q
  1517. movl s_fpsp,%eax
  1518. addb $32,%al
  1519. addl $s_stk,%eax
  1520. xchgl %edi,%eax
  1521. #GETEP   
  1522. movl (%edi),%eax
  1523. movl 4(%edi),%edx
  1524. movl 8(%edi),%ecx
  1525. #STTOP   
  1526. movl s_fpsp,%edi
  1527. addl $s_stk,%edi
  1528. call epcomp
  1529. movl %edi,%eax
  1530. movb $3,10(%eax)
  1531. subl $s_stk,%eax
  1532. addb $32,%al
  1533. addl $s_stk,%eax
  1534. movb $3,10(%eax)
  1535. addb $64,s_fpsp
  1536. ret
  1537. fsubpx: #ST(i) = ST - ST(i) and pop
  1538. #SAVEIN
  1539. movl %esi,s_iptr
  1540. #GETEPX  ebx
  1541. movl s_fpsp,%eax
  1542. addl $s_stk,%eax
  1543. movl (%eax),%edi
  1544. movl 4(%eax),%edx
  1545. movl 8(%eax),%ecx
  1546. subl $s_stk,%eax
  1547. shll $5,%ebx
  1548. addb %bl,%al
  1549. addl $s_stk,%eax
  1550. xchgl %edi,%eax
  1551. call epsub
  1552. call rounde
  1553. #STPOP
  1554. movl s_fpsp,%eax
  1555. addl $s_stk,%eax
  1556. movb $3,10(%eax)
  1557. addb $32,s_fpsp
  1558. ret
  1559. fsubrpx: #ST(i) = ST(i) - ST and pop
  1560. #SAVEIN
  1561. movl %esi,s_iptr
  1562. #GETEPX  ebx
  1563. movl s_fpsp,%eax
  1564. addl $s_stk,%eax
  1565. movl (%eax),%edi
  1566. movl 4(%eax),%edx
  1567. movl 8(%eax),%ecx
  1568. subl $s_stk,%eax
  1569. shll $5,%ebx
  1570. addb %bl,%al
  1571. addl $s_stk,%eax
  1572. xchgl %edi,%eax
  1573. call epsubr
  1574. call rounde
  1575. #STPOP
  1576. movl s_fpsp,%eax
  1577. addl $s_stk,%eax
  1578. movb $3,10(%eax)
  1579. addb $32,s_fpsp
  1580. ret
  1581. fdivpx: #ST(i) = ST/ST(i) and pop
  1582. #SAVEIN
  1583. movl %esi,s_iptr
  1584. #GETEPX  ebx
  1585. movl s_fpsp,%eax
  1586. addl $s_stk,%eax
  1587. movl (%eax),%edi
  1588. movl 4(%eax),%edx
  1589. movl 8(%eax),%ecx
  1590. subl $s_stk,%eax
  1591. shll $5,%ebx
  1592. addb %bl,%al
  1593. addl $s_stk,%eax
  1594. xchgl %edi,%eax
  1595. call epdivr
  1596. call rounde
  1597. #STPOP
  1598. movl s_fpsp,%eax
  1599. addl $s_stk,%eax
  1600. movb $3,10(%eax)
  1601. addb $32,s_fpsp
  1602. ret
  1603. fdivrpx: #ST(i) = ST(i)/ST and pop
  1604. #SAVEIN
  1605. movl %esi,s_iptr
  1606. #GETEPX  ebx
  1607. movl s_fpsp,%eax
  1608. addl $s_stk,%eax
  1609. movl (%eax),%edi
  1610. movl 4(%eax),%edx
  1611. movl 8(%eax),%ecx
  1612. subl $s_stk,%eax
  1613. shll $5,%ebx
  1614. addb %bl,%al
  1615. addl $s_stk,%eax
  1616. xchgl %edi,%eax
  1617. call epdiv
  1618. call rounde
  1619. #STPOP
  1620. movl s_fpsp,%eax
  1621. addl $s_stk,%eax
  1622. movb $3,10(%eax)
  1623. addb $32,s_fpsp
  1624. ret
  1625. fistw: #fetch 16-bit integer
  1626. #SAVEIX
  1627. movl %eax,s_memp
  1628. xchgl %esi,%eax
  1629. movl %eax,s_iptr
  1630. #STTOP   
  1631. movl s_fpsp,%edi
  1632. addl $s_stk,%edi
  1633. #GETEP   
  1634. movl (%edi),%eax
  1635. movl 4(%edi),%edx
  1636. movl 8(%edi),%ecx
  1637. call eptowi
  1638. movw %ax,(%esi)
  1639. ret
  1640. fistpw: #fetch 16-bit integer, pop
  1641. #SAVEIX
  1642. movl %eax,s_memp
  1643. xchgl %esi,%eax
  1644. movl %eax,s_iptr
  1645. #STTOP   
  1646. movl s_fpsp,%edi
  1647. addl $s_stk,%edi
  1648. #GETEP   
  1649. movl (%edi),%eax
  1650. movl 4(%edi),%edx
  1651. movl 8(%edi),%ecx
  1652. call eptowi
  1653. movw %ax,(%esi)
  1654. #STPOPq
  1655. movb $3,10(%edi)
  1656. addb $32,s_fpsp
  1657. ret
  1658. fbldp: #push 10-byte packed-decimal integer
  1659. #SAVEII
  1660. movl %esi,s_iptr
  1661. movl %eax,s_memp
  1662. andb $0x0fd,h_stat+1
  1663. call pdtoep
  1664. #STPUSHP
  1665. movl s_fpsp,%ebx
  1666. subb $32,%bl
  1667. cmpb $3,s_stk+10(%ebx)
  1668. jnz stackof
  1669. movl %ebx,s_fpsp
  1670. addl $s_stk,%ebx
  1671. movl %eax,(%ebx)
  1672. movl %edx,4(%ebx)
  1673. movl %ecx,8(%ebx)
  1674. ret
  1675. fildl: #push 64-bit integer
  1676. andb $0x0fd,h_stat+1
  1677. call litoep
  1678. #STPUSHP
  1679. movl s_fpsp,%ebx
  1680. subb $32,%bl
  1681. cmpb $3,s_stk+10(%ebx)
  1682. jnz stackof
  1683. movl %ebx,s_fpsp
  1684. addl $s_stk,%ebx
  1685. movl %eax,(%ebx)
  1686. movl %edx,4(%ebx)
  1687. movl %ecx,8(%ebx)
  1688. ret
  1689. fbstpp: #pop into 10-byte packed-decimal integer
  1690. #SAVEII
  1691. movl %esi,s_iptr
  1692. movl %eax,s_memp
  1693. #STTOP   
  1694. movl s_fpsp,%edi
  1695. addl $s_stk,%edi
  1696. #GETEP   
  1697. movl (%edi),%eax
  1698. movl 4(%edi),%edx
  1699. movl 8(%edi),%ecx
  1700. movl s_memp,%edi
  1701. call eptopd
  1702. #STPOP
  1703. movl s_fpsp,%eax
  1704. addl $s_stk,%eax
  1705. movb $3,10(%eax)
  1706. addb $32,s_fpsp
  1707. ret
  1708. fistpl: #pop into 64-bit integer
  1709. #SAVEIX
  1710. movl %eax,s_memp
  1711. xchgl %esi,%eax
  1712. movl %eax,s_iptr
  1713. #STTOP   
  1714. movl s_fpsp,%edi
  1715. addl $s_stk,%edi
  1716. #GETEP   
  1717. movl (%edi),%eax
  1718. movl 4(%edi),%edx
  1719. movl 8(%edi),%ecx
  1720. call eptoli
  1721. movl %eax,(%esi)
  1722. movl %edx,4(%esi)
  1723. #STPOPq
  1724. movb $3,10(%edi)
  1725. addb $32,s_fpsp
  1726. ret
  1727. fstswax_: #status word -> ax
  1728. call stfpsp
  1729. movw h_stat,%ax
  1730. movw %ax,s_ax(%ebp)
  1731. ret
  1732. fsincos_: #make ST into sin(ST), push cos(ST)
  1733. #STTOP   
  1734. movl s_fpsp,%edi
  1735. addl $s_stk,%edi
  1736. #GETEP   
  1737. movl (%edi),%eax
  1738. movl 4(%edi),%edx
  1739. movl 8(%edi),%ecx
  1740. call reduct
  1741. pushl %edi
  1742. #STPUSH
  1743. xchgl %edi,%ebx
  1744. movl s_fpsp,%ebx
  1745. subb $32,%bl
  1746. xchgl %edi,%ebx
  1747. cmpb $3,s_stk+10(%edi)
  1748. jz LL2
  1749. call stackof
  1750. LL2: movl %edi,s_fpsp
  1751. addl $s_stk,%edi
  1752. #PUTEP   
  1753. movl %eax,(%edi)
  1754. movl %edx,4(%edi)
  1755. movl %ecx,8(%edi)
  1756. popl %edi
  1757. testl $0x30000,%ecx
  1758. jnz sco11
  1759. pushl %ebx
  1760. call epsin
  1761. popl %ebx
  1762. #PUTEP   
  1763. movl %eax,(%edi)
  1764. movl %edx,4(%edi)
  1765. movl %ecx,8(%edi)
  1766. #STTOP   
  1767. movl s_fpsp,%edi
  1768. addl $s_stk,%edi
  1769. #GETEP   
  1770. movl (%edi),%eax
  1771. movl 4(%edi),%edx
  1772. movl 8(%edi),%ecx
  1773. call epcos
  1774. sco9: #PUTEP   
  1775. movl %eax,(%edi)
  1776. movl %edx,4(%edi)
  1777. movl %ecx,8(%edi)
  1778. ret
  1779. sco11: testl $0x50000,%ecx
  1780. jz sco9
  1781. #PUTEP
  1782. movl %eax,(%edi)
  1783. movl %edx,4(%edi)
  1784. movl %ecx,8(%edi)
  1785. movl $0x3fff,%ecx
  1786. movl $0x80000000,%edx
  1787. xorl %eax,%eax
  1788. #STTOP
  1789. movl s_fpsp,%edi
  1790. addl $s_stk,%edi
  1791. jmp sco9
  1792. fsin_: #make ST into sin(ST)
  1793. #STTOP   
  1794. movl s_fpsp,%edi
  1795. addl $s_stk,%edi
  1796. #GETEP   
  1797. movl (%edi),%eax
  1798. movl 4(%edi),%edx
  1799. movl 8(%edi),%ecx
  1800. call reduct
  1801. testl $0x30000,%ecx
  1802. jnz sin9
  1803. call epsin
  1804. sin9: #PUTEP   
  1805. movl %eax,(%edi)
  1806. movl %edx,4(%edi)
  1807. movl %ecx,8(%edi)
  1808. ret
  1809. fcos_: #make ST into cos(ST)
  1810. #STTOP   
  1811. movl s_fpsp,%edi
  1812. addl $s_stk,%edi
  1813. #GETEP   
  1814. movl (%edi),%eax
  1815. movl 4(%edi),%edx
  1816. movl 8(%edi),%ecx
  1817. call reduct
  1818. testl $0x30000,%ecx
  1819. jnz cos11
  1820. call epcos
  1821. cos9: #PUTEP   
  1822. movl %eax,(%edi)
  1823. movl %edx,4(%edi)
  1824. movl %ecx,8(%edi)
  1825. ret
  1826. cos11: testl $0x50000,%ecx
  1827. jz cos9
  1828. movl $0x3fff,%ecx
  1829. movl $0x80000000,%edx
  1830. xorl %eax,%eax
  1831. jmp cos9
  1832. NONE_:
  1833. #SAVEIN
  1834. movl %esi,s_iptr
  1835. ret
  1837. # stack overflow handler
  1839. stackof:
  1840. orw $stacko,h_stat #stack overflow
  1841. call exproc
  1842. orb $2,h_stat+1
  1843. movl $0x80027fff,%ecx
  1844. movl $0xc0000000,%edx
  1845. xorl %eax,%eax
  1846. subb $32,s_fpsp
  1847. movl s_fpsp,%ebx
  1848. addl $s_stk,%ebx
  1849. movl %eax,(%ebx)
  1850. movl %edx,4(%ebx)
  1851. movl %ecx,8(%ebx)
  1852. ret
  1854. # store floating-point stack pointer into the status word
  1856. stfpsp:
  1857. movb s_fpsp,%al
  1858. shrb $2,%al
  1859. movb h_stat+1,%ah
  1860. andb $0x0c7,%ah
  1861. orb %ah,%al
  1862. movb %al,h_stat+1
  1863. ret
  1865. #intrn   endp
  1867. #emuseg  ends
  1869. #        END