/arch/m68k/ifpsp060/src/fplsp.S

https://bitbucket.org/cresqo/cm7-p500-kernel · Assembly · 10980 lines · 9796 code · 1184 blank · 0 comment · 71 complexity · c8c88f2e1c605f8e83e2ae51cdf83207 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    2. 

  2. MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
    3. 

  3. M68000 Hi-Performance Microprocessor Division
    4. 

  4. M68060 Software Package
    5. 

  5. Production Release P1.00 -- October 10, 1994
    6. 

  6. 

  7. M68060 Software Package Copyright © 1993, 1994 Motorola Inc.  All rights reserved.
    8. 

  8. 

  9. THE SOFTWARE is provided on an "AS IS" basis and without warranty.
    10. 

  10. To the maximum extent permitted by applicable law,
    11. 

  11. MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
    12. 

  12. INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
    13. 

  13. and any warranty against infringement with regard to the SOFTWARE
    14. 

  14. (INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials.
    15. 

  15. 

  16. To the maximum extent permitted by applicable law,
    17. 

  17. IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
    18. 

  18. (INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
    19. 

  19. BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
    20. 

  20. ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
    21. 

  21. Motorola assumes no responsibility for the maintenance and support of the SOFTWARE.
    22. 

  22. 

  23. You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE
    24. 

  24. so long as this entire notice is retained without alteration in any modified and/or
    25. 

  25. redistributed versions, and that such modified versions are clearly identified as such.
    26. 

  26. No licenses are granted by implication, estoppel or otherwise under any patents
    27. 

  27. or trademarks of Motorola, Inc.
    28. 

  28. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    29. 

  29. #
    30. 

  30. # lfptop.s:
    31. 

  31. #	This file is appended to the top of the 060ILSP package
    32. 

  32. # and contains the entry points into the package. The user, in
    33. 

  33. # effect, branches to one of the branch table entries located here.
    34. 

  34. #
    35. 

  35. 

  36. 	bra.l	_facoss_
    37. 

  37. 	short	0x0000
    38. 

  38. 	bra.l	_facosd_
    39. 

  39. 	short	0x0000
    40. 

  40. 	bra.l	_facosx_
    41. 

  41. 	short	0x0000
    42. 

  42. 

  43. 	bra.l	_fasins_
    44. 

  44. 	short	0x0000
    45. 

  45. 	bra.l	_fasind_
    46. 

  46. 	short	0x0000
    47. 

  47. 	bra.l	_fasinx_
    48. 

  48. 	short	0x0000
    49. 

  49. 

  50. 	bra.l	_fatans_
    51. 

  51. 	short	0x0000
    52. 

  52. 	bra.l	_fatand_
    53. 

  53. 	short	0x0000
    54. 

  54. 	bra.l	_fatanx_
    55. 

  55. 	short	0x0000
    56. 

  56. 

  57. 	bra.l	_fatanhs_
    58. 

  58. 	short	0x0000
    59. 

  59. 	bra.l	_fatanhd_
    60. 

  60. 	short	0x0000
    61. 

  61. 	bra.l	_fatanhx_
    62. 

  62. 	short	0x0000
    63. 

  63. 

  64. 	bra.l	_fcoss_
    65. 

  65. 	short	0x0000
    66. 

  66. 	bra.l	_fcosd_
    67. 

  67. 	short	0x0000
    68. 

  68. 	bra.l	_fcosx_
    69. 

  69. 	short	0x0000
    70. 

  70. 

  71. 	bra.l	_fcoshs_
    72. 

  72. 	short	0x0000
    73. 

  73. 	bra.l	_fcoshd_
    74. 

  74. 	short	0x0000
    75. 

  75. 	bra.l	_fcoshx_
    76. 

  76. 	short	0x0000
    77. 

  77. 

  78. 	bra.l	_fetoxs_
    79. 

  79. 	short	0x0000
    80. 

  80. 	bra.l	_fetoxd_
    81. 

  81. 	short	0x0000
    82. 

  82. 	bra.l	_fetoxx_
    83. 

  83. 	short	0x0000
    84. 

  84. 

  85. 	bra.l	_fetoxm1s_
    86. 

  86. 	short	0x0000
    87. 

  87. 	bra.l	_fetoxm1d_
    88. 

  88. 	short	0x0000
    89. 

  89. 	bra.l	_fetoxm1x_
    90. 

  90. 	short	0x0000
    91. 

  91. 

  92. 	bra.l	_fgetexps_
    93. 

  93. 	short	0x0000
    94. 

  94. 	bra.l	_fgetexpd_
    95. 

  95. 	short	0x0000
    96. 

  96. 	bra.l	_fgetexpx_
    97. 

  97. 	short	0x0000
    98. 

  98. 

  99. 	bra.l	_fgetmans_
    100. 

  100. 	short	0x0000
    101. 

  101. 	bra.l	_fgetmand_
    102. 

  102. 	short	0x0000
    103. 

  103. 	bra.l	_fgetmanx_
    104. 

  104. 	short	0x0000
    105. 

  105. 

  106. 	bra.l	_flog10s_
    107. 

  107. 	short	0x0000
    108. 

  108. 	bra.l	_flog10d_
    109. 

  109. 	short	0x0000
    110. 

  110. 	bra.l	_flog10x_
    111. 

  111. 	short	0x0000
    112. 

  112. 

  113. 	bra.l	_flog2s_
    114. 

  114. 	short	0x0000
    115. 

  115. 	bra.l	_flog2d_
    116. 

  116. 	short	0x0000
    117. 

  117. 	bra.l	_flog2x_
    118. 

  118. 	short	0x0000
    119. 

  119. 

  120. 	bra.l	_flogns_
    121. 

  121. 	short	0x0000
    122. 

  122. 	bra.l	_flognd_
    123. 

  123. 	short	0x0000
    124. 

  124. 	bra.l	_flognx_
    125. 

  125. 	short	0x0000
    126. 

  126. 

  127. 	bra.l	_flognp1s_
    128. 

  128. 	short	0x0000
    129. 

  129. 	bra.l	_flognp1d_
    130. 

  130. 	short	0x0000
    131. 

  131. 	bra.l	_flognp1x_
    132. 

  132. 	short	0x0000
    133. 

  133. 

  134. 	bra.l	_fmods_
    135. 

  135. 	short	0x0000
    136. 

  136. 	bra.l	_fmodd_
    137. 

  137. 	short	0x0000
    138. 

  138. 	bra.l	_fmodx_
    139. 

  139. 	short	0x0000
    140. 

  140. 

  141. 	bra.l	_frems_
    142. 

  142. 	short	0x0000
    143. 

  143. 	bra.l	_fremd_
    144. 

  144. 	short	0x0000
    145. 

  145. 	bra.l	_fremx_
    146. 

  146. 	short	0x0000
    147. 

  147. 

  148. 	bra.l	_fscales_
    149. 

  149. 	short	0x0000
    150. 

  150. 	bra.l	_fscaled_
    151. 

  151. 	short	0x0000
    152. 

  152. 	bra.l	_fscalex_
    153. 

  153. 	short	0x0000
    154. 

  154. 

  155. 	bra.l	_fsins_
    156. 

  156. 	short	0x0000
    157. 

  157. 	bra.l	_fsind_
    158. 

  158. 	short	0x0000
    159. 

  159. 	bra.l	_fsinx_
    160. 

  160. 	short	0x0000
    161. 

  161. 

  162. 	bra.l	_fsincoss_
    163. 

  163. 	short	0x0000
    164. 

  164. 	bra.l	_fsincosd_
    165. 

  165. 	short	0x0000
    166. 

  166. 	bra.l	_fsincosx_
    167. 

  167. 	short	0x0000
    168. 

  168. 

  169. 	bra.l	_fsinhs_
    170. 

  170. 	short	0x0000
    171. 

  171. 	bra.l	_fsinhd_
    172. 

  172. 	short	0x0000
    173. 

  173. 	bra.l	_fsinhx_
    174. 

  174. 	short	0x0000
    175. 

  175. 

  176. 	bra.l	_ftans_
    177. 

  177. 	short	0x0000
    178. 

  178. 	bra.l	_ftand_
    179. 

  179. 	short	0x0000
    180. 

  180. 	bra.l	_ftanx_
    181. 

  181. 	short	0x0000
    182. 

  182. 

  183. 	bra.l	_ftanhs_
    184. 

  184. 	short	0x0000
    185. 

  185. 	bra.l	_ftanhd_
    186. 

  186. 	short	0x0000
    187. 

  187. 	bra.l	_ftanhx_
    188. 

  188. 	short	0x0000
    189. 

  189. 

  190. 	bra.l	_ftentoxs_
    191. 

  191. 	short	0x0000
    192. 

  192. 	bra.l	_ftentoxd_
    193. 

  193. 	short	0x0000
    194. 

  194. 	bra.l	_ftentoxx_
    195. 

  195. 	short	0x0000
    196. 

  196. 

  197. 	bra.l	_ftwotoxs_
    198. 

  198. 	short	0x0000
    199. 

  199. 	bra.l	_ftwotoxd_
    200. 

  200. 	short	0x0000
    201. 

  201. 	bra.l	_ftwotoxx_
    202. 

  202. 	short	0x0000
    203. 

  203. 

  204. 	bra.l	_fabss_
    205. 

  205. 	short	0x0000
    206. 

  206. 	bra.l	_fabsd_
    207. 

  207. 	short	0x0000
    208. 

  208. 	bra.l	_fabsx_
    209. 

  209. 	short	0x0000
    210. 

  210. 

  211. 	bra.l	_fadds_
    212. 

  212. 	short	0x0000
    213. 

  213. 	bra.l	_faddd_
    214. 

  214. 	short	0x0000
    215. 

  215. 	bra.l	_faddx_
    216. 

  216. 	short	0x0000
    217. 

  217. 

  218. 	bra.l	_fdivs_
    219. 

  219. 	short	0x0000
    220. 

  220. 	bra.l	_fdivd_
    221. 

  221. 	short	0x0000
    222. 

  222. 	bra.l	_fdivx_
    223. 

  223. 	short	0x0000
    224. 

  224. 

  225. 	bra.l	_fints_
    226. 

  226. 	short	0x0000
    227. 

  227. 	bra.l	_fintd_
    228. 

  228. 	short	0x0000
    229. 

  229. 	bra.l	_fintx_
    230. 

  230. 	short	0x0000
    231. 

  231. 

  232. 	bra.l	_fintrzs_
    233. 

  233. 	short	0x0000
    234. 

  234. 	bra.l	_fintrzd_
    235. 

  235. 	short	0x0000
    236. 

  236. 	bra.l	_fintrzx_
    237. 

  237. 	short	0x0000
    238. 

  238. 

  239. 	bra.l	_fmuls_
    240. 

  240. 	short	0x0000
    241. 

  241. 	bra.l	_fmuld_
    242. 

  242. 	short	0x0000
    243. 

  243. 	bra.l	_fmulx_
    244. 

  244. 	short	0x0000
    245. 

  245. 

  246. 	bra.l	_fnegs_
    247. 

  247. 	short	0x0000
    248. 

  248. 	bra.l	_fnegd_
    249. 

  249. 	short	0x0000
    250. 

  250. 	bra.l	_fnegx_
    251. 

  251. 	short	0x0000
    252. 

  252. 

  253. 	bra.l	_fsqrts_
    254. 

  254. 	short	0x0000
    255. 

  255. 	bra.l	_fsqrtd_
    256. 

  256. 	short	0x0000
    257. 

  257. 	bra.l	_fsqrtx_
    258. 

  258. 	short	0x0000
    259. 

  259. 

  260. 	bra.l	_fsubs_
    261. 

  261. 	short	0x0000
    262. 

  262. 	bra.l	_fsubd_
    263. 

  263. 	short	0x0000
    264. 

  264. 	bra.l	_fsubx_
    265. 

  265. 	short	0x0000
    266. 

  266. 

  267. # leave room for future possible additions
    268. 

  268. 	align	0x400
    269. 

  269. 

  270. #
    271. 

  271. # This file contains a set of define statements for constants
    272. 

  272. # in order to promote readability within the corecode itself.
    273. 

  273. #
    274. 

  274. 

  275. set LOCAL_SIZE,		192			# stack frame size(bytes)
    276. 

  276. set LV,			-LOCAL_SIZE		# stack offset
    277. 

  277. 

  278. set EXC_SR,		0x4			# stack status register
    279. 

  279. set EXC_PC,		0x6			# stack pc
    280. 

  280. set EXC_VOFF,		0xa			# stacked vector offset
    281. 

  281. set EXC_EA,		0xc			# stacked <ea>
    282. 

  282. 

  283. set EXC_FP,		0x0			# frame pointer
    284. 

  284. 

  285. set EXC_AREGS,		-68			# offset of all address regs
    286. 

  286. set EXC_DREGS,		-100			# offset of all data regs
    287. 

  287. set EXC_FPREGS,		-36			# offset of all fp regs
    288. 

  288. 

  289. set EXC_A7,		EXC_AREGS+(7*4)		# offset of saved a7
    290. 

  290. set OLD_A7,		EXC_AREGS+(6*4)		# extra copy of saved a7
    291. 

  291. set EXC_A6,		EXC_AREGS+(6*4)		# offset of saved a6
    292. 

  292. set EXC_A5,		EXC_AREGS+(5*4)
    293. 

  293. set EXC_A4,		EXC_AREGS+(4*4)
    294. 

  294. set EXC_A3,		EXC_AREGS+(3*4)
    295. 

  295. set EXC_A2,		EXC_AREGS+(2*4)
    296. 

  296. set EXC_A1,		EXC_AREGS+(1*4)
    297. 

  297. set EXC_A0,		EXC_AREGS+(0*4)
    298. 

  298. set EXC_D7,		EXC_DREGS+(7*4)
    299. 

  299. set EXC_D6,		EXC_DREGS+(6*4)
    300. 

  300. set EXC_D5,		EXC_DREGS+(5*4)
    301. 

  301. set EXC_D4,		EXC_DREGS+(4*4)
    302. 

  302. set EXC_D3,		EXC_DREGS+(3*4)
    303. 

  303. set EXC_D2,		EXC_DREGS+(2*4)
    304. 

  304. set EXC_D1,		EXC_DREGS+(1*4)
    305. 

  305. set EXC_D0,		EXC_DREGS+(0*4)
    306. 

  306. 

  307. set EXC_FP0,		EXC_FPREGS+(0*12)	# offset of saved fp0
    308. 

  308. set EXC_FP1,		EXC_FPREGS+(1*12)	# offset of saved fp1
    309. 

  309. set EXC_FP2,		EXC_FPREGS+(2*12)	# offset of saved fp2 (not used)
    310. 

  310. 

  311. set FP_SCR1,		LV+80			# fp scratch 1
    312. 

  312. set FP_SCR1_EX,		FP_SCR1+0
    313. 

  313. set FP_SCR1_SGN,	FP_SCR1+2
    314. 

  314. set FP_SCR1_HI,		FP_SCR1+4
    315. 

  315. set FP_SCR1_LO,		FP_SCR1+8
    316. 

  316. 

  317. set FP_SCR0,		LV+68			# fp scratch 0
    318. 

  318. set FP_SCR0_EX,		FP_SCR0+0
    319. 

  319. set FP_SCR0_SGN,	FP_SCR0+2
    320. 

  320. set FP_SCR0_HI,		FP_SCR0+4
    321. 

  321. set FP_SCR0_LO,		FP_SCR0+8
    322. 

  322. 

  323. set FP_DST,		LV+56			# fp destination operand
    324. 

  324. set FP_DST_EX,		FP_DST+0
    325. 

  325. set FP_DST_SGN,		FP_DST+2
    326. 

  326. set FP_DST_HI,		FP_DST+4
    327. 

  327. set FP_DST_LO,		FP_DST+8
    328. 

  328. 

  329. set FP_SRC,		LV+44			# fp source operand
    330. 

  330. set FP_SRC_EX,		FP_SRC+0
    331. 

  331. set FP_SRC_SGN,		FP_SRC+2
    332. 

  332. set FP_SRC_HI,		FP_SRC+4
    333. 

  333. set FP_SRC_LO,		FP_SRC+8
    334. 

  334. 

  335. set USER_FPIAR,		LV+40			# FP instr address register
    336. 

  336. 

  337. set USER_FPSR,		LV+36			# FP status register
    338. 

  338. set FPSR_CC,		USER_FPSR+0		# FPSR condition codes
    339. 

  339. set FPSR_QBYTE,		USER_FPSR+1		# FPSR qoutient byte
    340. 

  340. set FPSR_EXCEPT,	USER_FPSR+2		# FPSR exception status byte
    341. 

  341. set FPSR_AEXCEPT,	USER_FPSR+3		# FPSR accrued exception byte
    342. 

  342. 

  343. set USER_FPCR,		LV+32			# FP control register
    344. 

  344. set FPCR_ENABLE,	USER_FPCR+2		# FPCR exception enable
    345. 

  345. set FPCR_MODE,		USER_FPCR+3		# FPCR rounding mode control
    346. 

  346. 

  347. set L_SCR3,		LV+28			# integer scratch 3
    348. 

  348. set L_SCR2,		LV+24			# integer scratch 2
    349. 

  349. set L_SCR1,		LV+20			# integer scratch 1
    350. 

  350. 

  351. set STORE_FLG,		LV+19			# flag: operand store (ie. not fcmp/ftst)
    352. 

  352. 

  353. set EXC_TEMP2,		LV+24			# temporary space
    354. 

  354. set EXC_TEMP,		LV+16			# temporary space
    355. 

  355. 

  356. set DTAG,		LV+15			# destination operand type
    357. 

  357. set STAG,		LV+14			# source operand type
    358. 

  358. 

  359. set SPCOND_FLG,		LV+10			# flag: special case (see below)
    360. 

  360. 

  361. set EXC_CC,		LV+8			# saved condition codes
    362. 

  362. set EXC_EXTWPTR,	LV+4			# saved current PC (active)
    363. 

  363. set EXC_EXTWORD,	LV+2			# saved extension word
    364. 

  364. set EXC_CMDREG,		LV+2			# saved extension word
    365. 

  365. set EXC_OPWORD,		LV+0			# saved operation word
    366. 

  366. 

  367. ################################
    368. 

  368. 

  369. # Helpful macros
    370. 

  370. 

  371. set FTEMP,		0			# offsets within an
    372. 

  372. set FTEMP_EX,		0			# extended precision
    373. 

  373. set FTEMP_SGN,		2			# value saved in memory.
    374. 

  374. set FTEMP_HI,		4
    375. 

  375. set FTEMP_LO,		8
    376. 

  376. set FTEMP_GRS,		12
    377. 

  377. 

  378. set LOCAL,		0			# offsets within an
    379. 

  379. set LOCAL_EX,		0			# extended precision
    380. 

  380. set LOCAL_SGN,		2			# value saved in memory.
    381. 

  381. set LOCAL_HI,		4
    382. 

  382. set LOCAL_LO,		8
    383. 

  383. set LOCAL_GRS,		12
    384. 

  384. 

  385. set DST,		0			# offsets within an
    386. 

  386. set DST_EX,		0			# extended precision
    387. 

  387. set DST_HI,		4			# value saved in memory.
    388. 

  388. set DST_LO,		8
    389. 

  389. 

  390. set SRC,		0			# offsets within an
    391. 

  391. set SRC_EX,		0			# extended precision
    392. 

  392. set SRC_HI,		4			# value saved in memory.
    393. 

  393. set SRC_LO,		8
    394. 

  394. 

  395. set SGL_LO,		0x3f81			# min sgl prec exponent
    396. 

  396. set SGL_HI,		0x407e			# max sgl prec exponent
    397. 

  397. set DBL_LO,		0x3c01			# min dbl prec exponent
    398. 

  398. set DBL_HI,		0x43fe			# max dbl prec exponent
    399. 

  399. set EXT_LO,		0x0			# min ext prec exponent
    400. 

  400. set EXT_HI,		0x7ffe			# max ext prec exponent
    401. 

  401. 

  402. set EXT_BIAS,		0x3fff			# extended precision bias
    403. 

  403. set SGL_BIAS,		0x007f			# single precision bias
    404. 

  404. set DBL_BIAS,		0x03ff			# double precision bias
    405. 

  405. 

  406. set NORM,		0x00			# operand type for STAG/DTAG
    407. 

  407. set ZERO,		0x01			# operand type for STAG/DTAG
    408. 

  408. set INF,		0x02			# operand type for STAG/DTAG
    409. 

  409. set QNAN,		0x03			# operand type for STAG/DTAG
    410. 

  410. set DENORM,		0x04			# operand type for STAG/DTAG
    411. 

  411. set SNAN,		0x05			# operand type for STAG/DTAG
    412. 

  412. set UNNORM,		0x06			# operand type for STAG/DTAG
    413. 

  413. 

  414. ##################
    415. 

  415. # FPSR/FPCR bits #
    416. 

  416. ##################
    417. 

  417. set neg_bit,		0x3			# negative result
    418. 

  418. set z_bit,		0x2			# zero result
    419. 

  419. set inf_bit,		0x1			# infinite result
    420. 

  420. set nan_bit,		0x0			# NAN result
    421. 

  421. 

  422. set q_sn_bit,		0x7			# sign bit of quotient byte
    423. 

  423. 

  424. set bsun_bit,		7			# branch on unordered
    425. 

  425. set snan_bit,		6			# signalling NAN
    426. 

  426. set operr_bit,		5			# operand error
    427. 

  427. set ovfl_bit,		4			# overflow
    428. 

  428. set unfl_bit,		3			# underflow
    429. 

  429. set dz_bit,		2			# divide by zero
    430. 

  430. set inex2_bit,		1			# inexact result 2
    431. 

  431. set inex1_bit,		0			# inexact result 1
    432. 

  432. 

  433. set aiop_bit,		7			# accrued inexact operation bit
    434. 

  434. set aovfl_bit,		6			# accrued overflow bit
    435. 

  435. set aunfl_bit,		5			# accrued underflow bit
    436. 

  436. set adz_bit,		4			# accrued dz bit
    437. 

  437. set ainex_bit,		3			# accrued inexact bit
    438. 

  438. 

  439. #############################
    440. 

  440. # FPSR individual bit masks #
    441. 

  441. #############################
    442. 

  442. set neg_mask,		0x08000000		# negative bit mask (lw)
    443. 

  443. set inf_mask,		0x02000000		# infinity bit mask (lw)
    444. 

  444. set z_mask,		0x04000000		# zero bit mask (lw)
    445. 

  445. set nan_mask,		0x01000000		# nan bit mask (lw)
    446. 

  446. 

  447. set neg_bmask,		0x08			# negative bit mask (byte)
    448. 

  448. set inf_bmask,		0x02			# infinity bit mask (byte)
    449. 

  449. set z_bmask,		0x04			# zero bit mask (byte)
    450. 

  450. set nan_bmask,		0x01			# nan bit mask (byte)
    451. 

  451. 

  452. set bsun_mask,		0x00008000		# bsun exception mask
    453. 

  453. set snan_mask,		0x00004000		# snan exception mask
    454. 

  454. set operr_mask,		0x00002000		# operr exception mask
    455. 

  455. set ovfl_mask,		0x00001000		# overflow exception mask
    456. 

  456. set unfl_mask,		0x00000800		# underflow exception mask
    457. 

  457. set dz_mask,		0x00000400		# dz exception mask
    458. 

  458. set inex2_mask,		0x00000200		# inex2 exception mask
    459. 

  459. set inex1_mask,		0x00000100		# inex1 exception mask
    460. 

  460. 

  461. set aiop_mask,		0x00000080		# accrued illegal operation
    462. 

  462. set aovfl_mask,		0x00000040		# accrued overflow
    463. 

  463. set aunfl_mask,		0x00000020		# accrued underflow
    464. 

  464. set adz_mask,		0x00000010		# accrued divide by zero
    465. 

  465. set ainex_mask,		0x00000008		# accrued inexact
    466. 

  466. 

  467. ######################################
    468. 

  468. # FPSR combinations used in the FPSP #
    469. 

  469. ######################################
    470. 

  470. set dzinf_mask,		inf_mask+dz_mask+adz_mask
    471. 

  471. set opnan_mask,		nan_mask+operr_mask+aiop_mask
    472. 

  472. set nzi_mask,		0x01ffffff		#clears N, Z, and I
    473. 

  473. set unfinx_mask,	unfl_mask+inex2_mask+aunfl_mask+ainex_mask
    474. 

  474. set unf2inx_mask,	unfl_mask+inex2_mask+ainex_mask
    475. 

  475. set ovfinx_mask,	ovfl_mask+inex2_mask+aovfl_mask+ainex_mask
    476. 

  476. set inx1a_mask,		inex1_mask+ainex_mask
    477. 

  477. set inx2a_mask,		inex2_mask+ainex_mask
    478. 

  478. set snaniop_mask,	nan_mask+snan_mask+aiop_mask
    479. 

  479. set snaniop2_mask,	snan_mask+aiop_mask
    480. 

  480. set naniop_mask,	nan_mask+aiop_mask
    481. 

  481. set neginf_mask,	neg_mask+inf_mask
    482. 

  482. set infaiop_mask,	inf_mask+aiop_mask
    483. 

  483. set negz_mask,		neg_mask+z_mask
    484. 

  484. set opaop_mask,		operr_mask+aiop_mask
    485. 

  485. set unfl_inx_mask,	unfl_mask+aunfl_mask+ainex_mask
    486. 

  486. set ovfl_inx_mask,	ovfl_mask+aovfl_mask+ainex_mask
    487. 

  487. 

  488. #########
    489. 

  489. # misc. #
    490. 

  490. #########
    491. 

  491. set rnd_stky_bit,	29			# stky bit pos in longword
    492. 

  492. 

  493. set sign_bit,		0x7			# sign bit
    494. 

  494. set signan_bit,		0x6			# signalling nan bit
    495. 

  495. 

  496. set sgl_thresh,		0x3f81			# minimum sgl exponent
    497. 

  497. set dbl_thresh,		0x3c01			# minimum dbl exponent
    498. 

  498. 

  499. set x_mode,		0x0			# extended precision
    500. 

  500. set s_mode,		0x4			# single precision
    501. 

  501. set d_mode,		0x8			# double precision
    502. 

  502. 

  503. set rn_mode,		0x0			# round-to-nearest
    504. 

  504. set rz_mode,		0x1			# round-to-zero
    505. 

  505. set rm_mode,		0x2			# round-tp-minus-infinity
    506. 

  506. set rp_mode,		0x3			# round-to-plus-infinity
    507. 

  507. 

  508. set mantissalen,	64			# length of mantissa in bits
    509. 

  509. 

  510. set BYTE,		1			# len(byte) == 1 byte
    511. 

  511. set WORD,		2			# len(word) == 2 bytes
    512. 

  512. set LONG,		4			# len(longword) == 2 bytes
    513. 

  513. 

  514. set BSUN_VEC,		0xc0			# bsun    vector offset
    515. 

  515. set INEX_VEC,		0xc4			# inexact vector offset
    516. 

  516. set DZ_VEC,		0xc8			# dz      vector offset
    517. 

  517. set UNFL_VEC,		0xcc			# unfl    vector offset
    518. 

  518. set OPERR_VEC,		0xd0			# operr   vector offset
    519. 

  519. set OVFL_VEC,		0xd4			# ovfl    vector offset
    520. 

  520. set SNAN_VEC,		0xd8			# snan    vector offset
    521. 

  521. 

  522. ###########################
    523. 

  523. # SPecial CONDition FLaGs #
    524. 

  524. ###########################
    525. 

  525. set ftrapcc_flg,	0x01			# flag bit: ftrapcc exception
    526. 

  526. set fbsun_flg,		0x02			# flag bit: bsun exception
    527. 

  527. set mia7_flg,		0x04			# flag bit: (a7)+ <ea>
    528. 

  528. set mda7_flg,		0x08			# flag bit: -(a7) <ea>
    529. 

  529. set fmovm_flg,		0x40			# flag bit: fmovm instruction
    530. 

  530. set immed_flg,		0x80			# flag bit: &<data> <ea>
    531. 

  531. 

  532. set ftrapcc_bit,	0x0
    533. 

  533. set fbsun_bit,		0x1
    534. 

  534. set mia7_bit,		0x2
    535. 

  535. set mda7_bit,		0x3
    536. 

  536. set immed_bit,		0x7
    537. 

  537. 

  538. ##################################
    539. 

  539. # TRANSCENDENTAL "LAST-OP" FLAGS #
    540. 

  540. ##################################
    541. 

  541. set FMUL_OP,		0x0			# fmul instr performed last
    542. 

  542. set FDIV_OP,		0x1			# fdiv performed last
    543. 

  543. set FADD_OP,		0x2			# fadd performed last
    544. 

  544. set FMOV_OP,		0x3			# fmov performed last
    545. 

  545. 

  546. #############
    547. 

  547. # CONSTANTS #
    548. 

  548. #############
    549. 

  549. T1:	long		0x40C62D38,0xD3D64634	# 16381 LOG2 LEAD
    550. 

  550. T2:	long		0x3D6F90AE,0xB1E75CC7	# 16381 LOG2 TRAIL
    551. 

  551. 

  552. PI:	long		0x40000000,0xC90FDAA2,0x2168C235,0x00000000
    553. 

  553. PIBY2:	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
    554. 

  554. 

  555. TWOBYPI:
    556. 

  556. 	long		0x3FE45F30,0x6DC9C883
    557. 

  557. 

  558. #########################################################################
    559. 

  559. # MONADIC TEMPLATE							#
    560. 

  560. #########################################################################
    561. 

  561. 	global		_fsins_
    562. 

  562. _fsins_:
    563. 

  563. 	link		%a6,&-LOCAL_SIZE
    564. 

  564. 

  565. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    566. 

  566. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    567. 

  567. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    568. 

  568. 

  569. 	fmov.l		&0x0,%fpcr		# zero FPCR
    570. 

  570. 

  571. #
    572. 

  572. #	copy, convert, and tag input argument
    573. 

  573. #
    574. 

  574. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    575. 

  575. 	fmov.x		%fp0,FP_SRC(%a6)
    576. 

  576. 	lea		FP_SRC(%a6),%a0
    577. 

  577. 	bsr.l		tag			# fetch operand type
    578. 

  578. 	mov.b		%d0,STAG(%a6)
    579. 

  579. 	mov.b		%d0,%d1
    580. 

  580. 

  581. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    582. 

  582. 

  583. 	clr.l		%d0
    584. 

  584. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    585. 

  585. 

  586. 	tst.b		%d1
    587. 

  587. 	bne.b		_L0_2s
    588. 

  588. 	bsr.l		ssin			# operand is a NORM
    589. 

  589. 	bra.b		_L0_6s
    590. 

  590. _L0_2s:
    591. 

  591. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    592. 

  592. 	bne.b		_L0_3s			# no
    593. 

  593. 	bsr.l		src_zero			# yes
    594. 

  594. 	bra.b		_L0_6s
    595. 

  595. _L0_3s:
    596. 

  596. 	cmpi.b		%d1,&INF		# is operand an INF?
    597. 

  597. 	bne.b		_L0_4s			# no
    598. 

  598. 	bsr.l		t_operr			# yes
    599. 

  599. 	bra.b		_L0_6s
    600. 

  600. _L0_4s:
    601. 

  601. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    602. 

  602. 	bne.b		_L0_5s			# no
    603. 

  603. 	bsr.l		src_qnan			# yes
    604. 

  604. 	bra.b		_L0_6s
    605. 

  605. _L0_5s:
    606. 

  606. 	bsr.l		ssind			# operand is a DENORM
    607. 

  607. _L0_6s:
    608. 

  608. 

  609. #
    610. 

  610. #	Result is now in FP0
    611. 

  611. #
    612. 

  612. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    613. 

  613. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    614. 

  614. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    615. 

  615. 	unlk		%a6
    616. 

  616. 	rts
    617. 

  617. 

  618. 	global		_fsind_
    619. 

  619. _fsind_:
    620. 

  620. 	link		%a6,&-LOCAL_SIZE
    621. 

  621. 

  622. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    623. 

  623. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    624. 

  624. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    625. 

  625. 

  626. 	fmov.l		&0x0,%fpcr		# zero FPCR
    627. 

  627. 

  628. #
    629. 

  629. #	copy, convert, and tag input argument
    630. 

  630. #
    631. 

  631. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    632. 

  632. 	fmov.x		%fp0,FP_SRC(%a6)
    633. 

  633. 	lea		FP_SRC(%a6),%a0
    634. 

  634. 	bsr.l		tag			# fetch operand type
    635. 

  635. 	mov.b		%d0,STAG(%a6)
    636. 

  636. 	mov.b		%d0,%d1
    637. 

  637. 

  638. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    639. 

  639. 

  640. 	clr.l		%d0
    641. 

  641. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    642. 

  642. 

  643. 	mov.b		%d1,STAG(%a6)
    644. 

  644. 	tst.b		%d1
    645. 

  645. 	bne.b		_L0_2d
    646. 

  646. 	bsr.l		ssin			# operand is a NORM
    647. 

  647. 	bra.b		_L0_6d
    648. 

  648. _L0_2d:
    649. 

  649. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    650. 

  650. 	bne.b		_L0_3d			# no
    651. 

  651. 	bsr.l		src_zero			# yes
    652. 

  652. 	bra.b		_L0_6d
    653. 

  653. _L0_3d:
    654. 

  654. 	cmpi.b		%d1,&INF		# is operand an INF?
    655. 

  655. 	bne.b		_L0_4d			# no
    656. 

  656. 	bsr.l		t_operr			# yes
    657. 

  657. 	bra.b		_L0_6d
    658. 

  658. _L0_4d:
    659. 

  659. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    660. 

  660. 	bne.b		_L0_5d			# no
    661. 

  661. 	bsr.l		src_qnan			# yes
    662. 

  662. 	bra.b		_L0_6d
    663. 

  663. _L0_5d:
    664. 

  664. 	bsr.l		ssind			# operand is a DENORM
    665. 

  665. _L0_6d:
    666. 

  666. 

  667. #
    668. 

  668. #	Result is now in FP0
    669. 

  669. #
    670. 

  670. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    671. 

  671. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    672. 

  672. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    673. 

  673. 	unlk		%a6
    674. 

  674. 	rts
    675. 

  675. 

  676. 	global		_fsinx_
    677. 

  677. _fsinx_:
    678. 

  678. 	link		%a6,&-LOCAL_SIZE
    679. 

  679. 

  680. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    681. 

  681. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    682. 

  682. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    683. 

  683. 

  684. 	fmov.l		&0x0,%fpcr		# zero FPCR
    685. 

  685. 

  686. #
    687. 

  687. #	copy, convert, and tag input argument
    688. 

  688. #
    689. 

  689. 	lea		FP_SRC(%a6),%a0
    690. 

  690. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    691. 

  691. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    692. 

  692. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    693. 

  693. 	bsr.l		tag			# fetch operand type
    694. 

  694. 	mov.b		%d0,STAG(%a6)
    695. 

  695. 	mov.b		%d0,%d1
    696. 

  696. 

  697. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    698. 

  698. 

  699. 	clr.l		%d0
    700. 

  700. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    701. 

  701. 

  702. 	tst.b		%d1
    703. 

  703. 	bne.b		_L0_2x
    704. 

  704. 	bsr.l		ssin			# operand is a NORM
    705. 

  705. 	bra.b		_L0_6x
    706. 

  706. _L0_2x:
    707. 

  707. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    708. 

  708. 	bne.b		_L0_3x			# no
    709. 

  709. 	bsr.l		src_zero			# yes
    710. 

  710. 	bra.b		_L0_6x
    711. 

  711. _L0_3x:
    712. 

  712. 	cmpi.b		%d1,&INF		# is operand an INF?
    713. 

  713. 	bne.b		_L0_4x			# no
    714. 

  714. 	bsr.l		t_operr			# yes
    715. 

  715. 	bra.b		_L0_6x
    716. 

  716. _L0_4x:
    717. 

  717. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    718. 

  718. 	bne.b		_L0_5x			# no
    719. 

  719. 	bsr.l		src_qnan			# yes
    720. 

  720. 	bra.b		_L0_6x
    721. 

  721. _L0_5x:
    722. 

  722. 	bsr.l		ssind			# operand is a DENORM
    723. 

  723. _L0_6x:
    724. 

  724. 

  725. #
    726. 

  726. #	Result is now in FP0
    727. 

  727. #
    728. 

  728. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    729. 

  729. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    730. 

  730. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    731. 

  731. 	unlk		%a6
    732. 

  732. 	rts
    733. 

  733. 

  734. 

  735. #########################################################################
    736. 

  736. # MONADIC TEMPLATE							#
    737. 

  737. #########################################################################
    738. 

  738. 	global		_fcoss_
    739. 

  739. _fcoss_:
    740. 

  740. 	link		%a6,&-LOCAL_SIZE
    741. 

  741. 

  742. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    743. 

  743. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    744. 

  744. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    745. 

  745. 

  746. 	fmov.l		&0x0,%fpcr		# zero FPCR
    747. 

  747. 

  748. #
    749. 

  749. #	copy, convert, and tag input argument
    750. 

  750. #
    751. 

  751. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    752. 

  752. 	fmov.x		%fp0,FP_SRC(%a6)
    753. 

  753. 	lea		FP_SRC(%a6),%a0
    754. 

  754. 	bsr.l		tag			# fetch operand type
    755. 

  755. 	mov.b		%d0,STAG(%a6)
    756. 

  756. 	mov.b		%d0,%d1
    757. 

  757. 

  758. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    759. 

  759. 

  760. 	clr.l		%d0
    761. 

  761. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    762. 

  762. 

  763. 	tst.b		%d1
    764. 

  764. 	bne.b		_L1_2s
    765. 

  765. 	bsr.l		scos			# operand is a NORM
    766. 

  766. 	bra.b		_L1_6s
    767. 

  767. _L1_2s:
    768. 

  768. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    769. 

  769. 	bne.b		_L1_3s			# no
    770. 

  770. 	bsr.l		ld_pone			# yes
    771. 

  771. 	bra.b		_L1_6s
    772. 

  772. _L1_3s:
    773. 

  773. 	cmpi.b		%d1,&INF		# is operand an INF?
    774. 

  774. 	bne.b		_L1_4s			# no
    775. 

  775. 	bsr.l		t_operr			# yes
    776. 

  776. 	bra.b		_L1_6s
    777. 

  777. _L1_4s:
    778. 

  778. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    779. 

  779. 	bne.b		_L1_5s			# no
    780. 

  780. 	bsr.l		src_qnan			# yes
    781. 

  781. 	bra.b		_L1_6s
    782. 

  782. _L1_5s:
    783. 

  783. 	bsr.l		scosd			# operand is a DENORM
    784. 

  784. _L1_6s:
    785. 

  785. 

  786. #
    787. 

  787. #	Result is now in FP0
    788. 

  788. #
    789. 

  789. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    790. 

  790. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    791. 

  791. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    792. 

  792. 	unlk		%a6
    793. 

  793. 	rts
    794. 

  794. 

  795. 	global		_fcosd_
    796. 

  796. _fcosd_:
    797. 

  797. 	link		%a6,&-LOCAL_SIZE
    798. 

  798. 

  799. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    800. 

  800. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    801. 

  801. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    802. 

  802. 

  803. 	fmov.l		&0x0,%fpcr		# zero FPCR
    804. 

  804. 

  805. #
    806. 

  806. #	copy, convert, and tag input argument
    807. 

  807. #
    808. 

  808. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    809. 

  809. 	fmov.x		%fp0,FP_SRC(%a6)
    810. 

  810. 	lea		FP_SRC(%a6),%a0
    811. 

  811. 	bsr.l		tag			# fetch operand type
    812. 

  812. 	mov.b		%d0,STAG(%a6)
    813. 

  813. 	mov.b		%d0,%d1
    814. 

  814. 

  815. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    816. 

  816. 

  817. 	clr.l		%d0
    818. 

  818. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    819. 

  819. 

  820. 	mov.b		%d1,STAG(%a6)
    821. 

  821. 	tst.b		%d1
    822. 

  822. 	bne.b		_L1_2d
    823. 

  823. 	bsr.l		scos			# operand is a NORM
    824. 

  824. 	bra.b		_L1_6d
    825. 

  825. _L1_2d:
    826. 

  826. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    827. 

  827. 	bne.b		_L1_3d			# no
    828. 

  828. 	bsr.l		ld_pone			# yes
    829. 

  829. 	bra.b		_L1_6d
    830. 

  830. _L1_3d:
    831. 

  831. 	cmpi.b		%d1,&INF		# is operand an INF?
    832. 

  832. 	bne.b		_L1_4d			# no
    833. 

  833. 	bsr.l		t_operr			# yes
    834. 

  834. 	bra.b		_L1_6d
    835. 

  835. _L1_4d:
    836. 

  836. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    837. 

  837. 	bne.b		_L1_5d			# no
    838. 

  838. 	bsr.l		src_qnan			# yes
    839. 

  839. 	bra.b		_L1_6d
    840. 

  840. _L1_5d:
    841. 

  841. 	bsr.l		scosd			# operand is a DENORM
    842. 

  842. _L1_6d:
    843. 

  843. 

  844. #
    845. 

  845. #	Result is now in FP0
    846. 

  846. #
    847. 

  847. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    848. 

  848. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    849. 

  849. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    850. 

  850. 	unlk		%a6
    851. 

  851. 	rts
    852. 

  852. 

  853. 	global		_fcosx_
    854. 

  854. _fcosx_:
    855. 

  855. 	link		%a6,&-LOCAL_SIZE
    856. 

  856. 

  857. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    858. 

  858. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    859. 

  859. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    860. 

  860. 

  861. 	fmov.l		&0x0,%fpcr		# zero FPCR
    862. 

  862. 

  863. #
    864. 

  864. #	copy, convert, and tag input argument
    865. 

  865. #
    866. 

  866. 	lea		FP_SRC(%a6),%a0
    867. 

  867. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    868. 

  868. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    869. 

  869. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    870. 

  870. 	bsr.l		tag			# fetch operand type
    871. 

  871. 	mov.b		%d0,STAG(%a6)
    872. 

  872. 	mov.b		%d0,%d1
    873. 

  873. 

  874. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    875. 

  875. 

  876. 	clr.l		%d0
    877. 

  877. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    878. 

  878. 

  879. 	tst.b		%d1
    880. 

  880. 	bne.b		_L1_2x
    881. 

  881. 	bsr.l		scos			# operand is a NORM
    882. 

  882. 	bra.b		_L1_6x
    883. 

  883. _L1_2x:
    884. 

  884. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    885. 

  885. 	bne.b		_L1_3x			# no
    886. 

  886. 	bsr.l		ld_pone			# yes
    887. 

  887. 	bra.b		_L1_6x
    888. 

  888. _L1_3x:
    889. 

  889. 	cmpi.b		%d1,&INF		# is operand an INF?
    890. 

  890. 	bne.b		_L1_4x			# no
    891. 

  891. 	bsr.l		t_operr			# yes
    892. 

  892. 	bra.b		_L1_6x
    893. 

  893. _L1_4x:
    894. 

  894. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    895. 

  895. 	bne.b		_L1_5x			# no
    896. 

  896. 	bsr.l		src_qnan			# yes
    897. 

  897. 	bra.b		_L1_6x
    898. 

  898. _L1_5x:
    899. 

  899. 	bsr.l		scosd			# operand is a DENORM
    900. 

  900. _L1_6x:
    901. 

  901. 

  902. #
    903. 

  903. #	Result is now in FP0
    904. 

  904. #
    905. 

  905. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    906. 

  906. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    907. 

  907. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    908. 

  908. 	unlk		%a6
    909. 

  909. 	rts
    910. 

  910. 

  911. 

  912. #########################################################################
    913. 

  913. # MONADIC TEMPLATE							#
    914. 

  914. #########################################################################
    915. 

  915. 	global		_fsinhs_
    916. 

  916. _fsinhs_:
    917. 

  917. 	link		%a6,&-LOCAL_SIZE
    918. 

  918. 

  919. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    920. 

  920. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    921. 

  921. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    922. 

  922. 

  923. 	fmov.l		&0x0,%fpcr		# zero FPCR
    924. 

  924. 

  925. #
    926. 

  926. #	copy, convert, and tag input argument
    927. 

  927. #
    928. 

  928. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    929. 

  929. 	fmov.x		%fp0,FP_SRC(%a6)
    930. 

  930. 	lea		FP_SRC(%a6),%a0
    931. 

  931. 	bsr.l		tag			# fetch operand type
    932. 

  932. 	mov.b		%d0,STAG(%a6)
    933. 

  933. 	mov.b		%d0,%d1
    934. 

  934. 

  935. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    936. 

  936. 

  937. 	clr.l		%d0
    938. 

  938. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    939. 

  939. 

  940. 	tst.b		%d1
    941. 

  941. 	bne.b		_L2_2s
    942. 

  942. 	bsr.l		ssinh			# operand is a NORM
    943. 

  943. 	bra.b		_L2_6s
    944. 

  944. _L2_2s:
    945. 

  945. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    946. 

  946. 	bne.b		_L2_3s			# no
    947. 

  947. 	bsr.l		src_zero			# yes
    948. 

  948. 	bra.b		_L2_6s
    949. 

  949. _L2_3s:
    950. 

  950. 	cmpi.b		%d1,&INF		# is operand an INF?
    951. 

  951. 	bne.b		_L2_4s			# no
    952. 

  952. 	bsr.l		src_inf			# yes
    953. 

  953. 	bra.b		_L2_6s
    954. 

  954. _L2_4s:
    955. 

  955. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    956. 

  956. 	bne.b		_L2_5s			# no
    957. 

  957. 	bsr.l		src_qnan			# yes
    958. 

  958. 	bra.b		_L2_6s
    959. 

  959. _L2_5s:
    960. 

  960. 	bsr.l		ssinhd			# operand is a DENORM
    961. 

  961. _L2_6s:
    962. 

  962. 

  963. #
    964. 

  964. #	Result is now in FP0
    965. 

  965. #
    966. 

  966. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    967. 

  967. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    968. 

  968. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    969. 

  969. 	unlk		%a6
    970. 

  970. 	rts
    971. 

  971. 

  972. 	global		_fsinhd_
    973. 

  973. _fsinhd_:
    974. 

  974. 	link		%a6,&-LOCAL_SIZE
    975. 

  975. 

  976. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    977. 

  977. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    978. 

  978. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    979. 

  979. 

  980. 	fmov.l		&0x0,%fpcr		# zero FPCR
    981. 

  981. 

  982. #
    983. 

  983. #	copy, convert, and tag input argument
    984. 

  984. #
    985. 

  985. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    986. 

  986. 	fmov.x		%fp0,FP_SRC(%a6)
    987. 

  987. 	lea		FP_SRC(%a6),%a0
    988. 

  988. 	bsr.l		tag			# fetch operand type
    989. 

  989. 	mov.b		%d0,STAG(%a6)
    990. 

  990. 	mov.b		%d0,%d1
    991. 

  991. 

  992. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    993. 

  993. 

  994. 	clr.l		%d0
    995. 

  995. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    996. 

  996. 

  997. 	mov.b		%d1,STAG(%a6)
    998. 

  998. 	tst.b		%d1
    999. 

  999. 	bne.b		_L2_2d
    1000. 

  1000. 	bsr.l		ssinh			# operand is a NORM
    1001. 

  1001. 	bra.b		_L2_6d
    1002. 

  1002. _L2_2d:
    1003. 

  1003. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1004. 

  1004. 	bne.b		_L2_3d			# no
    1005. 

  1005. 	bsr.l		src_zero			# yes
    1006. 

  1006. 	bra.b		_L2_6d
    1007. 

  1007. _L2_3d:
    1008. 

  1008. 	cmpi.b		%d1,&INF		# is operand an INF?
    1009. 

  1009. 	bne.b		_L2_4d			# no
    1010. 

  1010. 	bsr.l		src_inf			# yes
    1011. 

  1011. 	bra.b		_L2_6d
    1012. 

  1012. _L2_4d:
    1013. 

  1013. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1014. 

  1014. 	bne.b		_L2_5d			# no
    1015. 

  1015. 	bsr.l		src_qnan			# yes
    1016. 

  1016. 	bra.b		_L2_6d
    1017. 

  1017. _L2_5d:
    1018. 

  1018. 	bsr.l		ssinhd			# operand is a DENORM
    1019. 

  1019. _L2_6d:
    1020. 

  1020. 

  1021. #
    1022. 

  1022. #	Result is now in FP0
    1023. 

  1023. #
    1024. 

  1024. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1025. 

  1025. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1026. 

  1026. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1027. 

  1027. 	unlk		%a6
    1028. 

  1028. 	rts
    1029. 

  1029. 

  1030. 	global		_fsinhx_
    1031. 

  1031. _fsinhx_:
    1032. 

  1032. 	link		%a6,&-LOCAL_SIZE
    1033. 

  1033. 

  1034. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1035. 

  1035. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1036. 

  1036. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1037. 

  1037. 

  1038. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1039. 

  1039. 

  1040. #
    1041. 

  1041. #	copy, convert, and tag input argument
    1042. 

  1042. #
    1043. 

  1043. 	lea		FP_SRC(%a6),%a0
    1044. 

  1044. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    1045. 

  1045. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    1046. 

  1046. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    1047. 

  1047. 	bsr.l		tag			# fetch operand type
    1048. 

  1048. 	mov.b		%d0,STAG(%a6)
    1049. 

  1049. 	mov.b		%d0,%d1
    1050. 

  1050. 

  1051. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1052. 

  1052. 

  1053. 	clr.l		%d0
    1054. 

  1054. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1055. 

  1055. 

  1056. 	tst.b		%d1
    1057. 

  1057. 	bne.b		_L2_2x
    1058. 

  1058. 	bsr.l		ssinh			# operand is a NORM
    1059. 

  1059. 	bra.b		_L2_6x
    1060. 

  1060. _L2_2x:
    1061. 

  1061. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1062. 

  1062. 	bne.b		_L2_3x			# no
    1063. 

  1063. 	bsr.l		src_zero			# yes
    1064. 

  1064. 	bra.b		_L2_6x
    1065. 

  1065. _L2_3x:
    1066. 

  1066. 	cmpi.b		%d1,&INF		# is operand an INF?
    1067. 

  1067. 	bne.b		_L2_4x			# no
    1068. 

  1068. 	bsr.l		src_inf			# yes
    1069. 

  1069. 	bra.b		_L2_6x
    1070. 

  1070. _L2_4x:
    1071. 

  1071. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1072. 

  1072. 	bne.b		_L2_5x			# no
    1073. 

  1073. 	bsr.l		src_qnan			# yes
    1074. 

  1074. 	bra.b		_L2_6x
    1075. 

  1075. _L2_5x:
    1076. 

  1076. 	bsr.l		ssinhd			# operand is a DENORM
    1077. 

  1077. _L2_6x:
    1078. 

  1078. 

  1079. #
    1080. 

  1080. #	Result is now in FP0
    1081. 

  1081. #
    1082. 

  1082. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1083. 

  1083. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1084. 

  1084. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1085. 

  1085. 	unlk		%a6
    1086. 

  1086. 	rts
    1087. 

  1087. 

  1088. 

  1089. #########################################################################
    1090. 

  1090. # MONADIC TEMPLATE							#
    1091. 

  1091. #########################################################################
    1092. 

  1092. 	global		_flognp1s_
    1093. 

  1093. _flognp1s_:
    1094. 

  1094. 	link		%a6,&-LOCAL_SIZE
    1095. 

  1095. 

  1096. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1097. 

  1097. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1098. 

  1098. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1099. 

  1099. 

  1100. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1101. 

  1101. 

  1102. #
    1103. 

  1103. #	copy, convert, and tag input argument
    1104. 

  1104. #
    1105. 

  1105. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    1106. 

  1106. 	fmov.x		%fp0,FP_SRC(%a6)
    1107. 

  1107. 	lea		FP_SRC(%a6),%a0
    1108. 

  1108. 	bsr.l		tag			# fetch operand type
    1109. 

  1109. 	mov.b		%d0,STAG(%a6)
    1110. 

  1110. 	mov.b		%d0,%d1
    1111. 

  1111. 

  1112. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1113. 

  1113. 

  1114. 	clr.l		%d0
    1115. 

  1115. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1116. 

  1116. 

  1117. 	tst.b		%d1
    1118. 

  1118. 	bne.b		_L3_2s
    1119. 

  1119. 	bsr.l		slognp1			# operand is a NORM
    1120. 

  1120. 	bra.b		_L3_6s
    1121. 

  1121. _L3_2s:
    1122. 

  1122. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1123. 

  1123. 	bne.b		_L3_3s			# no
    1124. 

  1124. 	bsr.l		src_zero			# yes
    1125. 

  1125. 	bra.b		_L3_6s
    1126. 

  1126. _L3_3s:
    1127. 

  1127. 	cmpi.b		%d1,&INF		# is operand an INF?
    1128. 

  1128. 	bne.b		_L3_4s			# no
    1129. 

  1129. 	bsr.l		sopr_inf			# yes
    1130. 

  1130. 	bra.b		_L3_6s
    1131. 

  1131. _L3_4s:
    1132. 

  1132. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1133. 

  1133. 	bne.b		_L3_5s			# no
    1134. 

  1134. 	bsr.l		src_qnan			# yes
    1135. 

  1135. 	bra.b		_L3_6s
    1136. 

  1136. _L3_5s:
    1137. 

  1137. 	bsr.l		slognp1d			# operand is a DENORM
    1138. 

  1138. _L3_6s:
    1139. 

  1139. 

  1140. #
    1141. 

  1141. #	Result is now in FP0
    1142. 

  1142. #
    1143. 

  1143. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1144. 

  1144. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1145. 

  1145. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1146. 

  1146. 	unlk		%a6
    1147. 

  1147. 	rts
    1148. 

  1148. 

  1149. 	global		_flognp1d_
    1150. 

  1150. _flognp1d_:
    1151. 

  1151. 	link		%a6,&-LOCAL_SIZE
    1152. 

  1152. 

  1153. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1154. 

  1154. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1155. 

  1155. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1156. 

  1156. 

  1157. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1158. 

  1158. 

  1159. #
    1160. 

  1160. #	copy, convert, and tag input argument
    1161. 

  1161. #
    1162. 

  1162. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    1163. 

  1163. 	fmov.x		%fp0,FP_SRC(%a6)
    1164. 

  1164. 	lea		FP_SRC(%a6),%a0
    1165. 

  1165. 	bsr.l		tag			# fetch operand type
    1166. 

  1166. 	mov.b		%d0,STAG(%a6)
    1167. 

  1167. 	mov.b		%d0,%d1
    1168. 

  1168. 

  1169. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1170. 

  1170. 

  1171. 	clr.l		%d0
    1172. 

  1172. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1173. 

  1173. 

  1174. 	mov.b		%d1,STAG(%a6)
    1175. 

  1175. 	tst.b		%d1
    1176. 

  1176. 	bne.b		_L3_2d
    1177. 

  1177. 	bsr.l		slognp1			# operand is a NORM
    1178. 

  1178. 	bra.b		_L3_6d
    1179. 

  1179. _L3_2d:
    1180. 

  1180. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1181. 

  1181. 	bne.b		_L3_3d			# no
    1182. 

  1182. 	bsr.l		src_zero			# yes
    1183. 

  1183. 	bra.b		_L3_6d
    1184. 

  1184. _L3_3d:
    1185. 

  1185. 	cmpi.b		%d1,&INF		# is operand an INF?
    1186. 

  1186. 	bne.b		_L3_4d			# no
    1187. 

  1187. 	bsr.l		sopr_inf			# yes
    1188. 

  1188. 	bra.b		_L3_6d
    1189. 

  1189. _L3_4d:
    1190. 

  1190. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1191. 

  1191. 	bne.b		_L3_5d			# no
    1192. 

  1192. 	bsr.l		src_qnan			# yes
    1193. 

  1193. 	bra.b		_L3_6d
    1194. 

  1194. _L3_5d:
    1195. 

  1195. 	bsr.l		slognp1d			# operand is a DENORM
    1196. 

  1196. _L3_6d:
    1197. 

  1197. 

  1198. #
    1199. 

  1199. #	Result is now in FP0
    1200. 

  1200. #
    1201. 

  1201. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1202. 

  1202. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1203. 

  1203. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1204. 

  1204. 	unlk		%a6
    1205. 

  1205. 	rts
    1206. 

  1206. 

  1207. 	global		_flognp1x_
    1208. 

  1208. _flognp1x_:
    1209. 

  1209. 	link		%a6,&-LOCAL_SIZE
    1210. 

  1210. 

  1211. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1212. 

  1212. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1213. 

  1213. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1214. 

  1214. 

  1215. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1216. 

  1216. 

  1217. #
    1218. 

  1218. #	copy, convert, and tag input argument
    1219. 

  1219. #
    1220. 

  1220. 	lea		FP_SRC(%a6),%a0
    1221. 

  1221. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    1222. 

  1222. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    1223. 

  1223. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    1224. 

  1224. 	bsr.l		tag			# fetch operand type
    1225. 

  1225. 	mov.b		%d0,STAG(%a6)
    1226. 

  1226. 	mov.b		%d0,%d1
    1227. 

  1227. 

  1228. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1229. 

  1229. 

  1230. 	clr.l		%d0
    1231. 

  1231. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1232. 

  1232. 

  1233. 	tst.b		%d1
    1234. 

  1234. 	bne.b		_L3_2x
    1235. 

  1235. 	bsr.l		slognp1			# operand is a NORM
    1236. 

  1236. 	bra.b		_L3_6x
    1237. 

  1237. _L3_2x:
    1238. 

  1238. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1239. 

  1239. 	bne.b		_L3_3x			# no
    1240. 

  1240. 	bsr.l		src_zero			# yes
    1241. 

  1241. 	bra.b		_L3_6x
    1242. 

  1242. _L3_3x:
    1243. 

  1243. 	cmpi.b		%d1,&INF		# is operand an INF?
    1244. 

  1244. 	bne.b		_L3_4x			# no
    1245. 

  1245. 	bsr.l		sopr_inf			# yes
    1246. 

  1246. 	bra.b		_L3_6x
    1247. 

  1247. _L3_4x:
    1248. 

  1248. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1249. 

  1249. 	bne.b		_L3_5x			# no
    1250. 

  1250. 	bsr.l		src_qnan			# yes
    1251. 

  1251. 	bra.b		_L3_6x
    1252. 

  1252. _L3_5x:
    1253. 

  1253. 	bsr.l		slognp1d			# operand is a DENORM
    1254. 

  1254. _L3_6x:
    1255. 

  1255. 

  1256. #
    1257. 

  1257. #	Result is now in FP0
    1258. 

  1258. #
    1259. 

  1259. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1260. 

  1260. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1261. 

  1261. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1262. 

  1262. 	unlk		%a6
    1263. 

  1263. 	rts
    1264. 

  1264. 

  1265. 

  1266. #########################################################################
    1267. 

  1267. # MONADIC TEMPLATE							#
    1268. 

  1268. #########################################################################
    1269. 

  1269. 	global		_fetoxm1s_
    1270. 

  1270. _fetoxm1s_:
    1271. 

  1271. 	link		%a6,&-LOCAL_SIZE
    1272. 

  1272. 

  1273. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1274. 

  1274. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1275. 

  1275. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1276. 

  1276. 

  1277. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1278. 

  1278. 

  1279. #
    1280. 

  1280. #	copy, convert, and tag input argument
    1281. 

  1281. #
    1282. 

  1282. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    1283. 

  1283. 	fmov.x		%fp0,FP_SRC(%a6)
    1284. 

  1284. 	lea		FP_SRC(%a6),%a0
    1285. 

  1285. 	bsr.l		tag			# fetch operand type
    1286. 

  1286. 	mov.b		%d0,STAG(%a6)
    1287. 

  1287. 	mov.b		%d0,%d1
    1288. 

  1288. 

  1289. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1290. 

  1290. 

  1291. 	clr.l		%d0
    1292. 

  1292. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1293. 

  1293. 

  1294. 	tst.b		%d1
    1295. 

  1295. 	bne.b		_L4_2s
    1296. 

  1296. 	bsr.l		setoxm1			# operand is a NORM
    1297. 

  1297. 	bra.b		_L4_6s
    1298. 

  1298. _L4_2s:
    1299. 

  1299. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1300. 

  1300. 	bne.b		_L4_3s			# no
    1301. 

  1301. 	bsr.l		src_zero			# yes
    1302. 

  1302. 	bra.b		_L4_6s
    1303. 

  1303. _L4_3s:
    1304. 

  1304. 	cmpi.b		%d1,&INF		# is operand an INF?
    1305. 

  1305. 	bne.b		_L4_4s			# no
    1306. 

  1306. 	bsr.l		setoxm1i			# yes
    1307. 

  1307. 	bra.b		_L4_6s
    1308. 

  1308. _L4_4s:
    1309. 

  1309. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1310. 

  1310. 	bne.b		_L4_5s			# no
    1311. 

  1311. 	bsr.l		src_qnan			# yes
    1312. 

  1312. 	bra.b		_L4_6s
    1313. 

  1313. _L4_5s:
    1314. 

  1314. 	bsr.l		setoxm1d			# operand is a DENORM
    1315. 

  1315. _L4_6s:
    1316. 

  1316. 

  1317. #
    1318. 

  1318. #	Result is now in FP0
    1319. 

  1319. #
    1320. 

  1320. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1321. 

  1321. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1322. 

  1322. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1323. 

  1323. 	unlk		%a6
    1324. 

  1324. 	rts
    1325. 

  1325. 

  1326. 	global		_fetoxm1d_
    1327. 

  1327. _fetoxm1d_:
    1328. 

  1328. 	link		%a6,&-LOCAL_SIZE
    1329. 

  1329. 

  1330. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1331. 

  1331. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1332. 

  1332. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1333. 

  1333. 

  1334. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1335. 

  1335. 

  1336. #
    1337. 

  1337. #	copy, convert, and tag input argument
    1338. 

  1338. #
    1339. 

  1339. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    1340. 

  1340. 	fmov.x		%fp0,FP_SRC(%a6)
    1341. 

  1341. 	lea		FP_SRC(%a6),%a0
    1342. 

  1342. 	bsr.l		tag			# fetch operand type
    1343. 

  1343. 	mov.b		%d0,STAG(%a6)
    1344. 

  1344. 	mov.b		%d0,%d1
    1345. 

  1345. 

  1346. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1347. 

  1347. 

  1348. 	clr.l		%d0
    1349. 

  1349. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1350. 

  1350. 

  1351. 	mov.b		%d1,STAG(%a6)
    1352. 

  1352. 	tst.b		%d1
    1353. 

  1353. 	bne.b		_L4_2d
    1354. 

  1354. 	bsr.l		setoxm1			# operand is a NORM
    1355. 

  1355. 	bra.b		_L4_6d
    1356. 

  1356. _L4_2d:
    1357. 

  1357. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1358. 

  1358. 	bne.b		_L4_3d			# no
    1359. 

  1359. 	bsr.l		src_zero			# yes
    1360. 

  1360. 	bra.b		_L4_6d
    1361. 

  1361. _L4_3d:
    1362. 

  1362. 	cmpi.b		%d1,&INF		# is operand an INF?
    1363. 

  1363. 	bne.b		_L4_4d			# no
    1364. 

  1364. 	bsr.l		setoxm1i			# yes
    1365. 

  1365. 	bra.b		_L4_6d
    1366. 

  1366. _L4_4d:
    1367. 

  1367. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1368. 

  1368. 	bne.b		_L4_5d			# no
    1369. 

  1369. 	bsr.l		src_qnan			# yes
    1370. 

  1370. 	bra.b		_L4_6d
    1371. 

  1371. _L4_5d:
    1372. 

  1372. 	bsr.l		setoxm1d			# operand is a DENORM
    1373. 

  1373. _L4_6d:
    1374. 

  1374. 

  1375. #
    1376. 

  1376. #	Result is now in FP0
    1377. 

  1377. #
    1378. 

  1378. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1379. 

  1379. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1380. 

  1380. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1381. 

  1381. 	unlk		%a6
    1382. 

  1382. 	rts
    1383. 

  1383. 

  1384. 	global		_fetoxm1x_
    1385. 

  1385. _fetoxm1x_:
    1386. 

  1386. 	link		%a6,&-LOCAL_SIZE
    1387. 

  1387. 

  1388. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1389. 

  1389. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1390. 

  1390. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1391. 

  1391. 

  1392. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1393. 

  1393. 

  1394. #
    1395. 

  1395. #	copy, convert, and tag input argument
    1396. 

  1396. #
    1397. 

  1397. 	lea		FP_SRC(%a6),%a0
    1398. 

  1398. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    1399. 

  1399. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    1400. 

  1400. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    1401. 

  1401. 	bsr.l		tag			# fetch operand type
    1402. 

  1402. 	mov.b		%d0,STAG(%a6)
    1403. 

  1403. 	mov.b		%d0,%d1
    1404. 

  1404. 

  1405. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1406. 

  1406. 

  1407. 	clr.l		%d0
    1408. 

  1408. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1409. 

  1409. 

  1410. 	tst.b		%d1
    1411. 

  1411. 	bne.b		_L4_2x
    1412. 

  1412. 	bsr.l		setoxm1			# operand is a NORM
    1413. 

  1413. 	bra.b		_L4_6x
    1414. 

  1414. _L4_2x:
    1415. 

  1415. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1416. 

  1416. 	bne.b		_L4_3x			# no
    1417. 

  1417. 	bsr.l		src_zero			# yes
    1418. 

  1418. 	bra.b		_L4_6x
    1419. 

  1419. _L4_3x:
    1420. 

  1420. 	cmpi.b		%d1,&INF		# is operand an INF?
    1421. 

  1421. 	bne.b		_L4_4x			# no
    1422. 

  1422. 	bsr.l		setoxm1i			# yes
    1423. 

  1423. 	bra.b		_L4_6x
    1424. 

  1424. _L4_4x:
    1425. 

  1425. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1426. 

  1426. 	bne.b		_L4_5x			# no
    1427. 

  1427. 	bsr.l		src_qnan			# yes
    1428. 

  1428. 	bra.b		_L4_6x
    1429. 

  1429. _L4_5x:
    1430. 

  1430. 	bsr.l		setoxm1d			# operand is a DENORM
    1431. 

  1431. _L4_6x:
    1432. 

  1432. 

  1433. #
    1434. 

  1434. #	Result is now in FP0
    1435. 

  1435. #
    1436. 

  1436. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1437. 

  1437. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1438. 

  1438. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1439. 

  1439. 	unlk		%a6
    1440. 

  1440. 	rts
    1441. 

  1441. 

  1442. 

  1443. #########################################################################
    1444. 

  1444. # MONADIC TEMPLATE							#
    1445. 

  1445. #########################################################################
    1446. 

  1446. 	global		_ftanhs_
    1447. 

  1447. _ftanhs_:
    1448. 

  1448. 	link		%a6,&-LOCAL_SIZE
    1449. 

  1449. 

  1450. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1451. 

  1451. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1452. 

  1452. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1453. 

  1453. 

  1454. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1455. 

  1455. 

  1456. #
    1457. 

  1457. #	copy, convert, and tag input argument
    1458. 

  1458. #
    1459. 

  1459. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    1460. 

  1460. 	fmov.x		%fp0,FP_SRC(%a6)
    1461. 

  1461. 	lea		FP_SRC(%a6),%a0
    1462. 

  1462. 	bsr.l		tag			# fetch operand type
    1463. 

  1463. 	mov.b		%d0,STAG(%a6)
    1464. 

  1464. 	mov.b		%d0,%d1
    1465. 

  1465. 

  1466. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1467. 

  1467. 

  1468. 	clr.l		%d0
    1469. 

  1469. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1470. 

  1470. 

  1471. 	tst.b		%d1
    1472. 

  1472. 	bne.b		_L5_2s
    1473. 

  1473. 	bsr.l		stanh			# operand is a NORM
    1474. 

  1474. 	bra.b		_L5_6s
    1475. 

  1475. _L5_2s:
    1476. 

  1476. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1477. 

  1477. 	bne.b		_L5_3s			# no
    1478. 

  1478. 	bsr.l		src_zero			# yes
    1479. 

  1479. 	bra.b		_L5_6s
    1480. 

  1480. _L5_3s:
    1481. 

  1481. 	cmpi.b		%d1,&INF		# is operand an INF?
    1482. 

  1482. 	bne.b		_L5_4s			# no
    1483. 

  1483. 	bsr.l		src_one			# yes
    1484. 

  1484. 	bra.b		_L5_6s
    1485. 

  1485. _L5_4s:
    1486. 

  1486. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1487. 

  1487. 	bne.b		_L5_5s			# no
    1488. 

  1488. 	bsr.l		src_qnan			# yes
    1489. 

  1489. 	bra.b		_L5_6s
    1490. 

  1490. _L5_5s:
    1491. 

  1491. 	bsr.l		stanhd			# operand is a DENORM
    1492. 

  1492. _L5_6s:
    1493. 

  1493. 

  1494. #
    1495. 

  1495. #	Result is now in FP0
    1496. 

  1496. #
    1497. 

  1497. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1498. 

  1498. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1499. 

  1499. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1500. 

  1500. 	unlk		%a6
    1501. 

  1501. 	rts
    1502. 

  1502. 

  1503. 	global		_ftanhd_
    1504. 

  1504. _ftanhd_:
    1505. 

  1505. 	link		%a6,&-LOCAL_SIZE
    1506. 

  1506. 

  1507. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1508. 

  1508. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1509. 

  1509. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1510. 

  1510. 

  1511. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1512. 

  1512. 

  1513. #
    1514. 

  1514. #	copy, convert, and tag input argument
    1515. 

  1515. #
    1516. 

  1516. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    1517. 

  1517. 	fmov.x		%fp0,FP_SRC(%a6)
    1518. 

  1518. 	lea		FP_SRC(%a6),%a0
    1519. 

  1519. 	bsr.l		tag			# fetch operand type
    1520. 

  1520. 	mov.b		%d0,STAG(%a6)
    1521. 

  1521. 	mov.b		%d0,%d1
    1522. 

  1522. 

  1523. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1524. 

  1524. 

  1525. 	clr.l		%d0
    1526. 

  1526. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1527. 

  1527. 

  1528. 	mov.b		%d1,STAG(%a6)
    1529. 

  1529. 	tst.b		%d1
    1530. 

  1530. 	bne.b		_L5_2d
    1531. 

  1531. 	bsr.l		stanh			# operand is a NORM
    1532. 

  1532. 	bra.b		_L5_6d
    1533. 

  1533. _L5_2d:
    1534. 

  1534. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1535. 

  1535. 	bne.b		_L5_3d			# no
    1536. 

  1536. 	bsr.l		src_zero			# yes
    1537. 

  1537. 	bra.b		_L5_6d
    1538. 

  1538. _L5_3d:
    1539. 

  1539. 	cmpi.b		%d1,&INF		# is operand an INF?
    1540. 

  1540. 	bne.b		_L5_4d			# no
    1541. 

  1541. 	bsr.l		src_one			# yes
    1542. 

  1542. 	bra.b		_L5_6d
    1543. 

  1543. _L5_4d:
    1544. 

  1544. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1545. 

  1545. 	bne.b		_L5_5d			# no
    1546. 

  1546. 	bsr.l		src_qnan			# yes
    1547. 

  1547. 	bra.b		_L5_6d
    1548. 

  1548. _L5_5d:
    1549. 

  1549. 	bsr.l		stanhd			# operand is a DENORM
    1550. 

  1550. _L5_6d:
    1551. 

  1551. 

  1552. #
    1553. 

  1553. #	Result is now in FP0
    1554. 

  1554. #
    1555. 

  1555. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1556. 

  1556. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1557. 

  1557. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1558. 

  1558. 	unlk		%a6
    1559. 

  1559. 	rts
    1560. 

  1560. 

  1561. 	global		_ftanhx_
    1562. 

  1562. _ftanhx_:
    1563. 

  1563. 	link		%a6,&-LOCAL_SIZE
    1564. 

  1564. 

  1565. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1566. 

  1566. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1567. 

  1567. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1568. 

  1568. 

  1569. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1570. 

  1570. 

  1571. #
    1572. 

  1572. #	copy, convert, and tag input argument
    1573. 

  1573. #
    1574. 

  1574. 	lea		FP_SRC(%a6),%a0
    1575. 

  1575. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    1576. 

  1576. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    1577. 

  1577. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    1578. 

  1578. 	bsr.l		tag			# fetch operand type
    1579. 

  1579. 	mov.b		%d0,STAG(%a6)
    1580. 

  1580. 	mov.b		%d0,%d1
    1581. 

  1581. 

  1582. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1583. 

  1583. 

  1584. 	clr.l		%d0
    1585. 

  1585. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1586. 

  1586. 

  1587. 	tst.b		%d1
    1588. 

  1588. 	bne.b		_L5_2x
    1589. 

  1589. 	bsr.l		stanh			# operand is a NORM
    1590. 

  1590. 	bra.b		_L5_6x
    1591. 

  1591. _L5_2x:
    1592. 

  1592. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1593. 

  1593. 	bne.b		_L5_3x			# no
    1594. 

  1594. 	bsr.l		src_zero			# yes
    1595. 

  1595. 	bra.b		_L5_6x
    1596. 

  1596. _L5_3x:
    1597. 

  1597. 	cmpi.b		%d1,&INF		# is operand an INF?
    1598. 

  1598. 	bne.b		_L5_4x			# no
    1599. 

  1599. 	bsr.l		src_one			# yes
    1600. 

  1600. 	bra.b		_L5_6x
    1601. 

  1601. _L5_4x:
    1602. 

  1602. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1603. 

  1603. 	bne.b		_L5_5x			# no
    1604. 

  1604. 	bsr.l		src_qnan			# yes
    1605. 

  1605. 	bra.b		_L5_6x
    1606. 

  1606. _L5_5x:
    1607. 

  1607. 	bsr.l		stanhd			# operand is a DENORM
    1608. 

  1608. _L5_6x:
    1609. 

  1609. 

  1610. #
    1611. 

  1611. #	Result is now in FP0
    1612. 

  1612. #
    1613. 

  1613. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1614. 

  1614. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1615. 

  1615. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1616. 

  1616. 	unlk		%a6
    1617. 

  1617. 	rts
    1618. 

  1618. 

  1619. 

  1620. #########################################################################
    1621. 

  1621. # MONADIC TEMPLATE							#
    1622. 

  1622. #########################################################################
    1623. 

  1623. 	global		_fatans_
    1624. 

  1624. _fatans_:
    1625. 

  1625. 	link		%a6,&-LOCAL_SIZE
    1626. 

  1626. 

  1627. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1628. 

  1628. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1629. 

  1629. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1630. 

  1630. 

  1631. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1632. 

  1632. 

  1633. #
    1634. 

  1634. #	copy, convert, and tag input argument
    1635. 

  1635. #
    1636. 

  1636. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    1637. 

  1637. 	fmov.x		%fp0,FP_SRC(%a6)
    1638. 

  1638. 	lea		FP_SRC(%a6),%a0
    1639. 

  1639. 	bsr.l		tag			# fetch operand type
    1640. 

  1640. 	mov.b		%d0,STAG(%a6)
    1641. 

  1641. 	mov.b		%d0,%d1
    1642. 

  1642. 

  1643. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1644. 

  1644. 

  1645. 	clr.l		%d0
    1646. 

  1646. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1647. 

  1647. 

  1648. 	tst.b		%d1
    1649. 

  1649. 	bne.b		_L6_2s
    1650. 

  1650. 	bsr.l		satan			# operand is a NORM
    1651. 

  1651. 	bra.b		_L6_6s
    1652. 

  1652. _L6_2s:
    1653. 

  1653. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1654. 

  1654. 	bne.b		_L6_3s			# no
    1655. 

  1655. 	bsr.l		src_zero			# yes
    1656. 

  1656. 	bra.b		_L6_6s
    1657. 

  1657. _L6_3s:
    1658. 

  1658. 	cmpi.b		%d1,&INF		# is operand an INF?
    1659. 

  1659. 	bne.b		_L6_4s			# no
    1660. 

  1660. 	bsr.l		spi_2			# yes
    1661. 

  1661. 	bra.b		_L6_6s
    1662. 

  1662. _L6_4s:
    1663. 

  1663. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1664. 

  1664. 	bne.b		_L6_5s			# no
    1665. 

  1665. 	bsr.l		src_qnan			# yes
    1666. 

  1666. 	bra.b		_L6_6s
    1667. 

  1667. _L6_5s:
    1668. 

  1668. 	bsr.l		satand			# operand is a DENORM
    1669. 

  1669. _L6_6s:
    1670. 

  1670. 

  1671. #
    1672. 

  1672. #	Result is now in FP0
    1673. 

  1673. #
    1674. 

  1674. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1675. 

  1675. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1676. 

  1676. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1677. 

  1677. 	unlk		%a6
    1678. 

  1678. 	rts
    1679. 

  1679. 

  1680. 	global		_fatand_
    1681. 

  1681. _fatand_:
    1682. 

  1682. 	link		%a6,&-LOCAL_SIZE
    1683. 

  1683. 

  1684. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1685. 

  1685. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1686. 

  1686. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1687. 

  1687. 

  1688. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1689. 

  1689. 

  1690. #
    1691. 

  1691. #	copy, convert, and tag input argument
    1692. 

  1692. #
    1693. 

  1693. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    1694. 

  1694. 	fmov.x		%fp0,FP_SRC(%a6)
    1695. 

  1695. 	lea		FP_SRC(%a6),%a0
    1696. 

  1696. 	bsr.l		tag			# fetch operand type
    1697. 

  1697. 	mov.b		%d0,STAG(%a6)
    1698. 

  1698. 	mov.b		%d0,%d1
    1699. 

  1699. 

  1700. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1701. 

  1701. 

  1702. 	clr.l		%d0
    1703. 

  1703. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1704. 

  1704. 

  1705. 	mov.b		%d1,STAG(%a6)
    1706. 

  1706. 	tst.b		%d1
    1707. 

  1707. 	bne.b		_L6_2d
    1708. 

  1708. 	bsr.l		satan			# operand is a NORM
    1709. 

  1709. 	bra.b		_L6_6d
    1710. 

  1710. _L6_2d:
    1711. 

  1711. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1712. 

  1712. 	bne.b		_L6_3d			# no
    1713. 

  1713. 	bsr.l		src_zero			# yes
    1714. 

  1714. 	bra.b		_L6_6d
    1715. 

  1715. _L6_3d:
    1716. 

  1716. 	cmpi.b		%d1,&INF		# is operand an INF?
    1717. 

  1717. 	bne.b		_L6_4d			# no
    1718. 

  1718. 	bsr.l		spi_2			# yes
    1719. 

  1719. 	bra.b		_L6_6d
    1720. 

  1720. _L6_4d:
    1721. 

  1721. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1722. 

  1722. 	bne.b		_L6_5d			# no
    1723. 

  1723. 	bsr.l		src_qnan			# yes
    1724. 

  1724. 	bra.b		_L6_6d
    1725. 

  1725. _L6_5d:
    1726. 

  1726. 	bsr.l		satand			# operand is a DENORM
    1727. 

  1727. _L6_6d:
    1728. 

  1728. 

  1729. #
    1730. 

  1730. #	Result is now in FP0
    1731. 

  1731. #
    1732. 

  1732. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1733. 

  1733. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1734. 

  1734. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1735. 

  1735. 	unlk		%a6
    1736. 

  1736. 	rts
    1737. 

  1737. 

  1738. 	global		_fatanx_
    1739. 

  1739. _fatanx_:
    1740. 

  1740. 	link		%a6,&-LOCAL_SIZE
    1741. 

  1741. 

  1742. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1743. 

  1743. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1744. 

  1744. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1745. 

  1745. 

  1746. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1747. 

  1747. 

  1748. #
    1749. 

  1749. #	copy, convert, and tag input argument
    1750. 

  1750. #
    1751. 

  1751. 	lea		FP_SRC(%a6),%a0
    1752. 

  1752. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    1753. 

  1753. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    1754. 

  1754. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    1755. 

  1755. 	bsr.l		tag			# fetch operand type
    1756. 

  1756. 	mov.b		%d0,STAG(%a6)
    1757. 

  1757. 	mov.b		%d0,%d1
    1758. 

  1758. 

  1759. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1760. 

  1760. 

  1761. 	clr.l		%d0
    1762. 

  1762. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1763. 

  1763. 

  1764. 	tst.b		%d1
    1765. 

  1765. 	bne.b		_L6_2x
    1766. 

  1766. 	bsr.l		satan			# operand is a NORM
    1767. 

  1767. 	bra.b		_L6_6x
    1768. 

  1768. _L6_2x:
    1769. 

  1769. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1770. 

  1770. 	bne.b		_L6_3x			# no
    1771. 

  1771. 	bsr.l		src_zero			# yes
    1772. 

  1772. 	bra.b		_L6_6x
    1773. 

  1773. _L6_3x:
    1774. 

  1774. 	cmpi.b		%d1,&INF		# is operand an INF?
    1775. 

  1775. 	bne.b		_L6_4x			# no
    1776. 

  1776. 	bsr.l		spi_2			# yes
    1777. 

  1777. 	bra.b		_L6_6x
    1778. 

  1778. _L6_4x:
    1779. 

  1779. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1780. 

  1780. 	bne.b		_L6_5x			# no
    1781. 

  1781. 	bsr.l		src_qnan			# yes
    1782. 

  1782. 	bra.b		_L6_6x
    1783. 

  1783. _L6_5x:
    1784. 

  1784. 	bsr.l		satand			# operand is a DENORM
    1785. 

  1785. _L6_6x:
    1786. 

  1786. 

  1787. #
    1788. 

  1788. #	Result is now in FP0
    1789. 

  1789. #
    1790. 

  1790. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1791. 

  1791. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1792. 

  1792. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1793. 

  1793. 	unlk		%a6
    1794. 

  1794. 	rts
    1795. 

  1795. 

  1796. 

  1797. #########################################################################
    1798. 

  1798. # MONADIC TEMPLATE							#
    1799. 

  1799. #########################################################################
    1800. 

  1800. 	global		_fasins_
    1801. 

  1801. _fasins_:
    1802. 

  1802. 	link		%a6,&-LOCAL_SIZE
    1803. 

  1803. 

  1804. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1805. 

  1805. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1806. 

  1806. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1807. 

  1807. 

  1808. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1809. 

  1809. 

  1810. #
    1811. 

  1811. #	copy, convert, and tag input argument
    1812. 

  1812. #
    1813. 

  1813. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    1814. 

  1814. 	fmov.x		%fp0,FP_SRC(%a6)
    1815. 

  1815. 	lea		FP_SRC(%a6),%a0
    1816. 

  1816. 	bsr.l		tag			# fetch operand type
    1817. 

  1817. 	mov.b		%d0,STAG(%a6)
    1818. 

  1818. 	mov.b		%d0,%d1
    1819. 

  1819. 

  1820. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1821. 

  1821. 

  1822. 	clr.l		%d0
    1823. 

  1823. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1824. 

  1824. 

  1825. 	tst.b		%d1
    1826. 

  1826. 	bne.b		_L7_2s
    1827. 

  1827. 	bsr.l		sasin			# operand is a NORM
    1828. 

  1828. 	bra.b		_L7_6s
    1829. 

  1829. _L7_2s:
    1830. 

  1830. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1831. 

  1831. 	bne.b		_L7_3s			# no
    1832. 

  1832. 	bsr.l		src_zero			# yes
    1833. 

  1833. 	bra.b		_L7_6s
    1834. 

  1834. _L7_3s:
    1835. 

  1835. 	cmpi.b		%d1,&INF		# is operand an INF?
    1836. 

  1836. 	bne.b		_L7_4s			# no
    1837. 

  1837. 	bsr.l		t_operr			# yes
    1838. 

  1838. 	bra.b		_L7_6s
    1839. 

  1839. _L7_4s:
    1840. 

  1840. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1841. 

  1841. 	bne.b		_L7_5s			# no
    1842. 

  1842. 	bsr.l		src_qnan			# yes
    1843. 

  1843. 	bra.b		_L7_6s
    1844. 

  1844. _L7_5s:
    1845. 

  1845. 	bsr.l		sasind			# operand is a DENORM
    1846. 

  1846. _L7_6s:
    1847. 

  1847. 

  1848. #
    1849. 

  1849. #	Result is now in FP0
    1850. 

  1850. #
    1851. 

  1851. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1852. 

  1852. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1853. 

  1853. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1854. 

  1854. 	unlk		%a6
    1855. 

  1855. 	rts
    1856. 

  1856. 

  1857. 	global		_fasind_
    1858. 

  1858. _fasind_:
    1859. 

  1859. 	link		%a6,&-LOCAL_SIZE
    1860. 

  1860. 

  1861. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1862. 

  1862. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1863. 

  1863. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1864. 

  1864. 

  1865. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1866. 

  1866. 

  1867. #
    1868. 

  1868. #	copy, convert, and tag input argument
    1869. 

  1869. #
    1870. 

  1870. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    1871. 

  1871. 	fmov.x		%fp0,FP_SRC(%a6)
    1872. 

  1872. 	lea		FP_SRC(%a6),%a0
    1873. 

  1873. 	bsr.l		tag			# fetch operand type
    1874. 

  1874. 	mov.b		%d0,STAG(%a6)
    1875. 

  1875. 	mov.b		%d0,%d1
    1876. 

  1876. 

  1877. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1878. 

  1878. 

  1879. 	clr.l		%d0
    1880. 

  1880. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1881. 

  1881. 

  1882. 	mov.b		%d1,STAG(%a6)
    1883. 

  1883. 	tst.b		%d1
    1884. 

  1884. 	bne.b		_L7_2d
    1885. 

  1885. 	bsr.l		sasin			# operand is a NORM
    1886. 

  1886. 	bra.b		_L7_6d
    1887. 

  1887. _L7_2d:
    1888. 

  1888. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1889. 

  1889. 	bne.b		_L7_3d			# no
    1890. 

  1890. 	bsr.l		src_zero			# yes
    1891. 

  1891. 	bra.b		_L7_6d
    1892. 

  1892. _L7_3d:
    1893. 

  1893. 	cmpi.b		%d1,&INF		# is operand an INF?
    1894. 

  1894. 	bne.b		_L7_4d			# no
    1895. 

  1895. 	bsr.l		t_operr			# yes
    1896. 

  1896. 	bra.b		_L7_6d
    1897. 

  1897. _L7_4d:
    1898. 

  1898. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1899. 

  1899. 	bne.b		_L7_5d			# no
    1900. 

  1900. 	bsr.l		src_qnan			# yes
    1901. 

  1901. 	bra.b		_L7_6d
    1902. 

  1902. _L7_5d:
    1903. 

  1903. 	bsr.l		sasind			# operand is a DENORM
    1904. 

  1904. _L7_6d:
    1905. 

  1905. 

  1906. #
    1907. 

  1907. #	Result is now in FP0
    1908. 

  1908. #
    1909. 

  1909. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1910. 

  1910. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1911. 

  1911. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1912. 

  1912. 	unlk		%a6
    1913. 

  1913. 	rts
    1914. 

  1914. 

  1915. 	global		_fasinx_
    1916. 

  1916. _fasinx_:
    1917. 

  1917. 	link		%a6,&-LOCAL_SIZE
    1918. 

  1918. 

  1919. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1920. 

  1920. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1921. 

  1921. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1922. 

  1922. 

  1923. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1924. 

  1924. 

  1925. #
    1926. 

  1926. #	copy, convert, and tag input argument
    1927. 

  1927. #
    1928. 

  1928. 	lea		FP_SRC(%a6),%a0
    1929. 

  1929. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    1930. 

  1930. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    1931. 

  1931. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    1932. 

  1932. 	bsr.l		tag			# fetch operand type
    1933. 

  1933. 	mov.b		%d0,STAG(%a6)
    1934. 

  1934. 	mov.b		%d0,%d1
    1935. 

  1935. 

  1936. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1937. 

  1937. 

  1938. 	clr.l		%d0
    1939. 

  1939. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    1940. 

  1940. 

  1941. 	tst.b		%d1
    1942. 

  1942. 	bne.b		_L7_2x
    1943. 

  1943. 	bsr.l		sasin			# operand is a NORM
    1944. 

  1944. 	bra.b		_L7_6x
    1945. 

  1945. _L7_2x:
    1946. 

  1946. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    1947. 

  1947. 	bne.b		_L7_3x			# no
    1948. 

  1948. 	bsr.l		src_zero			# yes
    1949. 

  1949. 	bra.b		_L7_6x
    1950. 

  1950. _L7_3x:
    1951. 

  1951. 	cmpi.b		%d1,&INF		# is operand an INF?
    1952. 

  1952. 	bne.b		_L7_4x			# no
    1953. 

  1953. 	bsr.l		t_operr			# yes
    1954. 

  1954. 	bra.b		_L7_6x
    1955. 

  1955. _L7_4x:
    1956. 

  1956. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    1957. 

  1957. 	bne.b		_L7_5x			# no
    1958. 

  1958. 	bsr.l		src_qnan			# yes
    1959. 

  1959. 	bra.b		_L7_6x
    1960. 

  1960. _L7_5x:
    1961. 

  1961. 	bsr.l		sasind			# operand is a DENORM
    1962. 

  1962. _L7_6x:
    1963. 

  1963. 

  1964. #
    1965. 

  1965. #	Result is now in FP0
    1966. 

  1966. #
    1967. 

  1967. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    1968. 

  1968. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    1969. 

  1969. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    1970. 

  1970. 	unlk		%a6
    1971. 

  1971. 	rts
    1972. 

  1972. 

  1973. 

  1974. #########################################################################
    1975. 

  1975. # MONADIC TEMPLATE							#
    1976. 

  1976. #########################################################################
    1977. 

  1977. 	global		_fatanhs_
    1978. 

  1978. _fatanhs_:
    1979. 

  1979. 	link		%a6,&-LOCAL_SIZE
    1980. 

  1980. 

  1981. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    1982. 

  1982. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    1983. 

  1983. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    1984. 

  1984. 

  1985. 	fmov.l		&0x0,%fpcr		# zero FPCR
    1986. 

  1986. 

  1987. #
    1988. 

  1988. #	copy, convert, and tag input argument
    1989. 

  1989. #
    1990. 

  1990. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    1991. 

  1991. 	fmov.x		%fp0,FP_SRC(%a6)
    1992. 

  1992. 	lea		FP_SRC(%a6),%a0
    1993. 

  1993. 	bsr.l		tag			# fetch operand type
    1994. 

  1994. 	mov.b		%d0,STAG(%a6)
    1995. 

  1995. 	mov.b		%d0,%d1
    1996. 

  1996. 

  1997. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    1998. 

  1998. 

  1999. 	clr.l		%d0
    2000. 

  2000. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2001. 

  2001. 

  2002. 	tst.b		%d1
    2003. 

  2003. 	bne.b		_L8_2s
    2004. 

  2004. 	bsr.l		satanh			# operand is a NORM
    2005. 

  2005. 	bra.b		_L8_6s
    2006. 

  2006. _L8_2s:
    2007. 

  2007. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2008. 

  2008. 	bne.b		_L8_3s			# no
    2009. 

  2009. 	bsr.l		src_zero			# yes
    2010. 

  2010. 	bra.b		_L8_6s
    2011. 

  2011. _L8_3s:
    2012. 

  2012. 	cmpi.b		%d1,&INF		# is operand an INF?
    2013. 

  2013. 	bne.b		_L8_4s			# no
    2014. 

  2014. 	bsr.l		t_operr			# yes
    2015. 

  2015. 	bra.b		_L8_6s
    2016. 

  2016. _L8_4s:
    2017. 

  2017. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2018. 

  2018. 	bne.b		_L8_5s			# no
    2019. 

  2019. 	bsr.l		src_qnan			# yes
    2020. 

  2020. 	bra.b		_L8_6s
    2021. 

  2021. _L8_5s:
    2022. 

  2022. 	bsr.l		satanhd			# operand is a DENORM
    2023. 

  2023. _L8_6s:
    2024. 

  2024. 

  2025. #
    2026. 

  2026. #	Result is now in FP0
    2027. 

  2027. #
    2028. 

  2028. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    2029. 

  2029. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2030. 

  2030. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2031. 

  2031. 	unlk		%a6
    2032. 

  2032. 	rts
    2033. 

  2033. 

  2034. 	global		_fatanhd_
    2035. 

  2035. _fatanhd_:
    2036. 

  2036. 	link		%a6,&-LOCAL_SIZE
    2037. 

  2037. 

  2038. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    2039. 

  2039. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2040. 

  2040. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    2041. 

  2041. 

  2042. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2043. 

  2043. 

  2044. #
    2045. 

  2045. #	copy, convert, and tag input argument
    2046. 

  2046. #
    2047. 

  2047. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    2048. 

  2048. 	fmov.x		%fp0,FP_SRC(%a6)
    2049. 

  2049. 	lea		FP_SRC(%a6),%a0
    2050. 

  2050. 	bsr.l		tag			# fetch operand type
    2051. 

  2051. 	mov.b		%d0,STAG(%a6)
    2052. 

  2052. 	mov.b		%d0,%d1
    2053. 

  2053. 

  2054. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2055. 

  2055. 

  2056. 	clr.l		%d0
    2057. 

  2057. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2058. 

  2058. 

  2059. 	mov.b		%d1,STAG(%a6)
    2060. 

  2060. 	tst.b		%d1
    2061. 

  2061. 	bne.b		_L8_2d
    2062. 

  2062. 	bsr.l		satanh			# operand is a NORM
    2063. 

  2063. 	bra.b		_L8_6d
    2064. 

  2064. _L8_2d:
    2065. 

  2065. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2066. 

  2066. 	bne.b		_L8_3d			# no
    2067. 

  2067. 	bsr.l		src_zero			# yes
    2068. 

  2068. 	bra.b		_L8_6d
    2069. 

  2069. _L8_3d:
    2070. 

  2070. 	cmpi.b		%d1,&INF		# is operand an INF?
    2071. 

  2071. 	bne.b		_L8_4d			# no
    2072. 

  2072. 	bsr.l		t_operr			# yes
    2073. 

  2073. 	bra.b		_L8_6d
    2074. 

  2074. _L8_4d:
    2075. 

  2075. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2076. 

  2076. 	bne.b		_L8_5d			# no
    2077. 

  2077. 	bsr.l		src_qnan			# yes
    2078. 

  2078. 	bra.b		_L8_6d
    2079. 

  2079. _L8_5d:
    2080. 

  2080. 	bsr.l		satanhd			# operand is a DENORM
    2081. 

  2081. _L8_6d:
    2082. 

  2082. 

  2083. #
    2084. 

  2084. #	Result is now in FP0
    2085. 

  2085. #
    2086. 

  2086. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    2087. 

  2087. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2088. 

  2088. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2089. 

  2089. 	unlk		%a6
    2090. 

  2090. 	rts
    2091. 

  2091. 

  2092. 	global		_fatanhx_
    2093. 

  2093. _fatanhx_:
    2094. 

  2094. 	link		%a6,&-LOCAL_SIZE
    2095. 

  2095. 

  2096. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    2097. 

  2097. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2098. 

  2098. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    2099. 

  2099. 

  2100. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2101. 

  2101. 

  2102. #
    2103. 

  2103. #	copy, convert, and tag input argument
    2104. 

  2104. #
    2105. 

  2105. 	lea		FP_SRC(%a6),%a0
    2106. 

  2106. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
    2107. 

  2107. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    2108. 

  2108. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    2109. 

  2109. 	bsr.l		tag			# fetch operand type
    2110. 

  2110. 	mov.b		%d0,STAG(%a6)
    2111. 

  2111. 	mov.b		%d0,%d1
    2112. 

  2112. 

  2113. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2114. 

  2114. 

  2115. 	clr.l		%d0
    2116. 

  2116. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2117. 

  2117. 

  2118. 	tst.b		%d1
    2119. 

  2119. 	bne.b		_L8_2x
    2120. 

  2120. 	bsr.l		satanh			# operand is a NORM
    2121. 

  2121. 	bra.b		_L8_6x
    2122. 

  2122. _L8_2x:
    2123. 

  2123. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2124. 

  2124. 	bne.b		_L8_3x			# no
    2125. 

  2125. 	bsr.l		src_zero			# yes
    2126. 

  2126. 	bra.b		_L8_6x
    2127. 

  2127. _L8_3x:
    2128. 

  2128. 	cmpi.b		%d1,&INF		# is operand an INF?
    2129. 

  2129. 	bne.b		_L8_4x			# no
    2130. 

  2130. 	bsr.l		t_operr			# yes
    2131. 

  2131. 	bra.b		_L8_6x
    2132. 

  2132. _L8_4x:
    2133. 

  2133. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2134. 

  2134. 	bne.b		_L8_5x			# no
    2135. 

  2135. 	bsr.l		src_qnan			# yes
    2136. 

  2136. 	bra.b		_L8_6x
    2137. 

  2137. _L8_5x:
    2138. 

  2138. 	bsr.l		satanhd			# operand is a DENORM
    2139. 

  2139. _L8_6x:
    2140. 

  2140. 

  2141. #
    2142. 

  2142. #	Result is now in FP0
    2143. 

  2143. #
    2144. 

  2144. 	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
    2145. 

  2145. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2146. 

  2146. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2147. 

  2147. 	unlk		%a6
    2148. 

  2148. 	rts
    2149. 

  2149. 

  2150. 

  2151. #########################################################################
    2152. 

  2152. # MONADIC TEMPLATE							#
    2153. 

  2153. #########################################################################
    2154. 

  2154. 	global		_ftans_
    2155. 

  2155. _ftans_:
    2156. 

  2156. 	link		%a6,&-LOCAL_SIZE
    2157. 

  2157. 

  2158. 	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
    2159. 

  2159. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2160. 

  2160. 	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
    2161. 

  2161. 

  2162. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2163. 

  2163. 

  2164. #
    2165. 

  2165. #	copy, convert, and tag input argument
    2166. 

  2166. #
    2167. 

  2167. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    2168. 

  2168. 	fmov.x		%fp0,FP_SRC(%a6)
    2169. 

  2169. 	lea		FP_SRC(%a6),%a0
    2170. 

  2170. 	bsr.l		tag			# fetch operand type
    2171. 

  2171. 	mov.b		%d0,STAG(%a6)
    2172. 

  2172. 	mov.b		%d0,%d1
    2173. 

  2173. 

  2174. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2175. 

  2175. 

  2176. 	clr.l		%d0
    2177. 

  2177. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2178. 

  2178. 

  2179. 	tst.b		%d1
    2180. 

  2180. 	bne.b		_L9_2s
    2181. 

  2181. 	bsr.l		stan			# operand is a NORM
    2182. 

  2182. 	bra.b		_L9_6s
    2183. 

  2183. _L9_2s:
    2184. 

  2184. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2185. 

  2185. 	bne.b		_L9_3s			# no
    2186. 

  2186. 	bsr.l		src_zero			# yes
    2187. 

  2187. 	bra.b		_L9_6s
    2188. 

  2188. _L9_3s:
    2189. 

  2189. 	cmpi.b		%d1,&INF		# is operand an INF?
    2190. 

  2190. 	bne.b		_L9_4s			# no
    2191. 

  2191. 	bsr.l		t_operr			# yes
    2192. 

  2192. 	bra.b		_L9_6s
    2193. 

  2193. _L9_4s:
    2194. 

  2194. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2195. 

  2195. 	bne.b		_L9_5s			# no
    2196. 

  2196. 	bsr.l		src_qnan			# yes
    2197. 

  2197. 	bra.b		_L9_6s
    2198. 

  2198. _L9_5s:
    2199. 

  2199. 	bsr.l		stand			# operand is a DENO…
    2200.