PageRenderTime 38350ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 2ms

/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
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0 
    

  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 DENORM
    2200. 

  2200. _L9_6s:
    2201. 

  2201. 

  2202. #
    2203. 

  2203. #	Result is now in FP0
    2204. 

  2204. #
    2205. 

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

  2206. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2207. 

  2207. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2208. 

  2208. 	unlk		%a6
    2209. 

  2209. 	rts
    2210. 

  2210. 

  2211. 	global		_ftand_
    2212. 

  2212. _ftand_:
    2213. 

  2213. 	link		%a6,&-LOCAL_SIZE
    2214. 

  2214. 

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

  2216. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2217. 

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

  2218. 

  2219. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2220. 

  2220. 

  2221. #
    2222. 

  2222. #	copy, convert, and tag input argument
    2223. 

  2223. #
    2224. 

  2224. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    2225. 

  2225. 	fmov.x		%fp0,FP_SRC(%a6)
    2226. 

  2226. 	lea		FP_SRC(%a6),%a0
    2227. 

  2227. 	bsr.l		tag			# fetch operand type
    2228. 

  2228. 	mov.b		%d0,STAG(%a6)
    2229. 

  2229. 	mov.b		%d0,%d1
    2230. 

  2230. 

  2231. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2232. 

  2232. 

  2233. 	clr.l		%d0
    2234. 

  2234. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2235. 

  2235. 

  2236. 	mov.b		%d1,STAG(%a6)
    2237. 

  2237. 	tst.b		%d1
    2238. 

  2238. 	bne.b		_L9_2d
    2239. 

  2239. 	bsr.l		stan			# operand is a NORM
    2240. 

  2240. 	bra.b		_L9_6d
    2241. 

  2241. _L9_2d:
    2242. 

  2242. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2243. 

  2243. 	bne.b		_L9_3d			# no
    2244. 

  2244. 	bsr.l		src_zero			# yes
    2245. 

  2245. 	bra.b		_L9_6d
    2246. 

  2246. _L9_3d:
    2247. 

  2247. 	cmpi.b		%d1,&INF		# is operand an INF?
    2248. 

  2248. 	bne.b		_L9_4d			# no
    2249. 

  2249. 	bsr.l		t_operr			# yes
    2250. 

  2250. 	bra.b		_L9_6d
    2251. 

  2251. _L9_4d:
    2252. 

  2252. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2253. 

  2253. 	bne.b		_L9_5d			# no
    2254. 

  2254. 	bsr.l		src_qnan			# yes
    2255. 

  2255. 	bra.b		_L9_6d
    2256. 

  2256. _L9_5d:
    2257. 

  2257. 	bsr.l		stand			# operand is a DENORM
    2258. 

  2258. _L9_6d:
    2259. 

  2259. 

  2260. #
    2261. 

  2261. #	Result is now in FP0
    2262. 

  2262. #
    2263. 

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

  2264. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2265. 

  2265. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2266. 

  2266. 	unlk		%a6
    2267. 

  2267. 	rts
    2268. 

  2268. 

  2269. 	global		_ftanx_
    2270. 

  2270. _ftanx_:
    2271. 

  2271. 	link		%a6,&-LOCAL_SIZE
    2272. 

  2272. 

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

  2274. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2275. 

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

  2276. 

  2277. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2278. 

  2278. 

  2279. #
    2280. 

  2280. #	copy, convert, and tag input argument
    2281. 

  2281. #
    2282. 

  2282. 	lea		FP_SRC(%a6),%a0
    2283. 

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

  2284. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    2285. 

  2285. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    2286. 

  2286. 	bsr.l		tag			# fetch operand type
    2287. 

  2287. 	mov.b		%d0,STAG(%a6)
    2288. 

  2288. 	mov.b		%d0,%d1
    2289. 

  2289. 

  2290. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2291. 

  2291. 

  2292. 	clr.l		%d0
    2293. 

  2293. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2294. 

  2294. 

  2295. 	tst.b		%d1
    2296. 

  2296. 	bne.b		_L9_2x
    2297. 

  2297. 	bsr.l		stan			# operand is a NORM
    2298. 

  2298. 	bra.b		_L9_6x
    2299. 

  2299. _L9_2x:
    2300. 

  2300. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2301. 

  2301. 	bne.b		_L9_3x			# no
    2302. 

  2302. 	bsr.l		src_zero			# yes
    2303. 

  2303. 	bra.b		_L9_6x
    2304. 

  2304. _L9_3x:
    2305. 

  2305. 	cmpi.b		%d1,&INF		# is operand an INF?
    2306. 

  2306. 	bne.b		_L9_4x			# no
    2307. 

  2307. 	bsr.l		t_operr			# yes
    2308. 

  2308. 	bra.b		_L9_6x
    2309. 

  2309. _L9_4x:
    2310. 

  2310. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2311. 

  2311. 	bne.b		_L9_5x			# no
    2312. 

  2312. 	bsr.l		src_qnan			# yes
    2313. 

  2313. 	bra.b		_L9_6x
    2314. 

  2314. _L9_5x:
    2315. 

  2315. 	bsr.l		stand			# operand is a DENORM
    2316. 

  2316. _L9_6x:
    2317. 

  2317. 

  2318. #
    2319. 

  2319. #	Result is now in FP0
    2320. 

  2320. #
    2321. 

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

  2322. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2323. 

  2323. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2324. 

  2324. 	unlk		%a6
    2325. 

  2325. 	rts
    2326. 

  2326. 

  2327. 

  2328. #########################################################################
    2329. 

  2329. # MONADIC TEMPLATE							#
    2330. 

  2330. #########################################################################
    2331. 

  2331. 	global		_fetoxs_
    2332. 

  2332. _fetoxs_:
    2333. 

  2333. 	link		%a6,&-LOCAL_SIZE
    2334. 

  2334. 

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

  2336. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2337. 

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

  2338. 

  2339. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2340. 

  2340. 

  2341. #
    2342. 

  2342. #	copy, convert, and tag input argument
    2343. 

  2343. #
    2344. 

  2344. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    2345. 

  2345. 	fmov.x		%fp0,FP_SRC(%a6)
    2346. 

  2346. 	lea		FP_SRC(%a6),%a0
    2347. 

  2347. 	bsr.l		tag			# fetch operand type
    2348. 

  2348. 	mov.b		%d0,STAG(%a6)
    2349. 

  2349. 	mov.b		%d0,%d1
    2350. 

  2350. 

  2351. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2352. 

  2352. 

  2353. 	clr.l		%d0
    2354. 

  2354. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2355. 

  2355. 

  2356. 	tst.b		%d1
    2357. 

  2357. 	bne.b		_L10_2s
    2358. 

  2358. 	bsr.l		setox			# operand is a NORM
    2359. 

  2359. 	bra.b		_L10_6s
    2360. 

  2360. _L10_2s:
    2361. 

  2361. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2362. 

  2362. 	bne.b		_L10_3s			# no
    2363. 

  2363. 	bsr.l		ld_pone			# yes
    2364. 

  2364. 	bra.b		_L10_6s
    2365. 

  2365. _L10_3s:
    2366. 

  2366. 	cmpi.b		%d1,&INF		# is operand an INF?
    2367. 

  2367. 	bne.b		_L10_4s			# no
    2368. 

  2368. 	bsr.l		szr_inf			# yes
    2369. 

  2369. 	bra.b		_L10_6s
    2370. 

  2370. _L10_4s:
    2371. 

  2371. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2372. 

  2372. 	bne.b		_L10_5s			# no
    2373. 

  2373. 	bsr.l		src_qnan			# yes
    2374. 

  2374. 	bra.b		_L10_6s
    2375. 

  2375. _L10_5s:
    2376. 

  2376. 	bsr.l		setoxd			# operand is a DENORM
    2377. 

  2377. _L10_6s:
    2378. 

  2378. 

  2379. #
    2380. 

  2380. #	Result is now in FP0
    2381. 

  2381. #
    2382. 

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

  2383. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2384. 

  2384. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2385. 

  2385. 	unlk		%a6
    2386. 

  2386. 	rts
    2387. 

  2387. 

  2388. 	global		_fetoxd_
    2389. 

  2389. _fetoxd_:
    2390. 

  2390. 	link		%a6,&-LOCAL_SIZE
    2391. 

  2391. 

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

  2393. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2394. 

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

  2395. 

  2396. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2397. 

  2397. 

  2398. #
    2399. 

  2399. #	copy, convert, and tag input argument
    2400. 

  2400. #
    2401. 

  2401. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    2402. 

  2402. 	fmov.x		%fp0,FP_SRC(%a6)
    2403. 

  2403. 	lea		FP_SRC(%a6),%a0
    2404. 

  2404. 	bsr.l		tag			# fetch operand type
    2405. 

  2405. 	mov.b		%d0,STAG(%a6)
    2406. 

  2406. 	mov.b		%d0,%d1
    2407. 

  2407. 

  2408. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2409. 

  2409. 

  2410. 	clr.l		%d0
    2411. 

  2411. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2412. 

  2412. 

  2413. 	mov.b		%d1,STAG(%a6)
    2414. 

  2414. 	tst.b		%d1
    2415. 

  2415. 	bne.b		_L10_2d
    2416. 

  2416. 	bsr.l		setox			# operand is a NORM
    2417. 

  2417. 	bra.b		_L10_6d
    2418. 

  2418. _L10_2d:
    2419. 

  2419. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2420. 

  2420. 	bne.b		_L10_3d			# no
    2421. 

  2421. 	bsr.l		ld_pone			# yes
    2422. 

  2422. 	bra.b		_L10_6d
    2423. 

  2423. _L10_3d:
    2424. 

  2424. 	cmpi.b		%d1,&INF		# is operand an INF?
    2425. 

  2425. 	bne.b		_L10_4d			# no
    2426. 

  2426. 	bsr.l		szr_inf			# yes
    2427. 

  2427. 	bra.b		_L10_6d
    2428. 

  2428. _L10_4d:
    2429. 

  2429. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2430. 

  2430. 	bne.b		_L10_5d			# no
    2431. 

  2431. 	bsr.l		src_qnan			# yes
    2432. 

  2432. 	bra.b		_L10_6d
    2433. 

  2433. _L10_5d:
    2434. 

  2434. 	bsr.l		setoxd			# operand is a DENORM
    2435. 

  2435. _L10_6d:
    2436. 

  2436. 

  2437. #
    2438. 

  2438. #	Result is now in FP0
    2439. 

  2439. #
    2440. 

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

  2441. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2442. 

  2442. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2443. 

  2443. 	unlk		%a6
    2444. 

  2444. 	rts
    2445. 

  2445. 

  2446. 	global		_fetoxx_
    2447. 

  2447. _fetoxx_:
    2448. 

  2448. 	link		%a6,&-LOCAL_SIZE
    2449. 

  2449. 

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

  2451. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2452. 

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

  2453. 

  2454. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2455. 

  2455. 

  2456. #
    2457. 

  2457. #	copy, convert, and tag input argument
    2458. 

  2458. #
    2459. 

  2459. 	lea		FP_SRC(%a6),%a0
    2460. 

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

  2461. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    2462. 

  2462. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    2463. 

  2463. 	bsr.l		tag			# fetch operand type
    2464. 

  2464. 	mov.b		%d0,STAG(%a6)
    2465. 

  2465. 	mov.b		%d0,%d1
    2466. 

  2466. 

  2467. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2468. 

  2468. 

  2469. 	clr.l		%d0
    2470. 

  2470. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2471. 

  2471. 

  2472. 	tst.b		%d1
    2473. 

  2473. 	bne.b		_L10_2x
    2474. 

  2474. 	bsr.l		setox			# operand is a NORM
    2475. 

  2475. 	bra.b		_L10_6x
    2476. 

  2476. _L10_2x:
    2477. 

  2477. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2478. 

  2478. 	bne.b		_L10_3x			# no
    2479. 

  2479. 	bsr.l		ld_pone			# yes
    2480. 

  2480. 	bra.b		_L10_6x
    2481. 

  2481. _L10_3x:
    2482. 

  2482. 	cmpi.b		%d1,&INF		# is operand an INF?
    2483. 

  2483. 	bne.b		_L10_4x			# no
    2484. 

  2484. 	bsr.l		szr_inf			# yes
    2485. 

  2485. 	bra.b		_L10_6x
    2486. 

  2486. _L10_4x:
    2487. 

  2487. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2488. 

  2488. 	bne.b		_L10_5x			# no
    2489. 

  2489. 	bsr.l		src_qnan			# yes
    2490. 

  2490. 	bra.b		_L10_6x
    2491. 

  2491. _L10_5x:
    2492. 

  2492. 	bsr.l		setoxd			# operand is a DENORM
    2493. 

  2493. _L10_6x:
    2494. 

  2494. 

  2495. #
    2496. 

  2496. #	Result is now in FP0
    2497. 

  2497. #
    2498. 

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

  2499. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2500. 

  2500. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2501. 

  2501. 	unlk		%a6
    2502. 

  2502. 	rts
    2503. 

  2503. 

  2504. 

  2505. #########################################################################
    2506. 

  2506. # MONADIC TEMPLATE							#
    2507. 

  2507. #########################################################################
    2508. 

  2508. 	global		_ftwotoxs_
    2509. 

  2509. _ftwotoxs_:
    2510. 

  2510. 	link		%a6,&-LOCAL_SIZE
    2511. 

  2511. 

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

  2513. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2514. 

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

  2515. 

  2516. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2517. 

  2517. 

  2518. #
    2519. 

  2519. #	copy, convert, and tag input argument
    2520. 

  2520. #
    2521. 

  2521. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    2522. 

  2522. 	fmov.x		%fp0,FP_SRC(%a6)
    2523. 

  2523. 	lea		FP_SRC(%a6),%a0
    2524. 

  2524. 	bsr.l		tag			# fetch operand type
    2525. 

  2525. 	mov.b		%d0,STAG(%a6)
    2526. 

  2526. 	mov.b		%d0,%d1
    2527. 

  2527. 

  2528. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2529. 

  2529. 

  2530. 	clr.l		%d0
    2531. 

  2531. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2532. 

  2532. 

  2533. 	tst.b		%d1
    2534. 

  2534. 	bne.b		_L11_2s
    2535. 

  2535. 	bsr.l		stwotox			# operand is a NORM
    2536. 

  2536. 	bra.b		_L11_6s
    2537. 

  2537. _L11_2s:
    2538. 

  2538. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2539. 

  2539. 	bne.b		_L11_3s			# no
    2540. 

  2540. 	bsr.l		ld_pone			# yes
    2541. 

  2541. 	bra.b		_L11_6s
    2542. 

  2542. _L11_3s:
    2543. 

  2543. 	cmpi.b		%d1,&INF		# is operand an INF?
    2544. 

  2544. 	bne.b		_L11_4s			# no
    2545. 

  2545. 	bsr.l		szr_inf			# yes
    2546. 

  2546. 	bra.b		_L11_6s
    2547. 

  2547. _L11_4s:
    2548. 

  2548. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2549. 

  2549. 	bne.b		_L11_5s			# no
    2550. 

  2550. 	bsr.l		src_qnan			# yes
    2551. 

  2551. 	bra.b		_L11_6s
    2552. 

  2552. _L11_5s:
    2553. 

  2553. 	bsr.l		stwotoxd			# operand is a DENORM
    2554. 

  2554. _L11_6s:
    2555. 

  2555. 

  2556. #
    2557. 

  2557. #	Result is now in FP0
    2558. 

  2558. #
    2559. 

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

  2560. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2561. 

  2561. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2562. 

  2562. 	unlk		%a6
    2563. 

  2563. 	rts
    2564. 

  2564. 

  2565. 	global		_ftwotoxd_
    2566. 

  2566. _ftwotoxd_:
    2567. 

  2567. 	link		%a6,&-LOCAL_SIZE
    2568. 

  2568. 

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

  2570. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2571. 

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

  2572. 

  2573. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2574. 

  2574. 

  2575. #
    2576. 

  2576. #	copy, convert, and tag input argument
    2577. 

  2577. #
    2578. 

  2578. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    2579. 

  2579. 	fmov.x		%fp0,FP_SRC(%a6)
    2580. 

  2580. 	lea		FP_SRC(%a6),%a0
    2581. 

  2581. 	bsr.l		tag			# fetch operand type
    2582. 

  2582. 	mov.b		%d0,STAG(%a6)
    2583. 

  2583. 	mov.b		%d0,%d1
    2584. 

  2584. 

  2585. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2586. 

  2586. 

  2587. 	clr.l		%d0
    2588. 

  2588. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2589. 

  2589. 

  2590. 	mov.b		%d1,STAG(%a6)
    2591. 

  2591. 	tst.b		%d1
    2592. 

  2592. 	bne.b		_L11_2d
    2593. 

  2593. 	bsr.l		stwotox			# operand is a NORM
    2594. 

  2594. 	bra.b		_L11_6d
    2595. 

  2595. _L11_2d:
    2596. 

  2596. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2597. 

  2597. 	bne.b		_L11_3d			# no
    2598. 

  2598. 	bsr.l		ld_pone			# yes
    2599. 

  2599. 	bra.b		_L11_6d
    2600. 

  2600. _L11_3d:
    2601. 

  2601. 	cmpi.b		%d1,&INF		# is operand an INF?
    2602. 

  2602. 	bne.b		_L11_4d			# no
    2603. 

  2603. 	bsr.l		szr_inf			# yes
    2604. 

  2604. 	bra.b		_L11_6d
    2605. 

  2605. _L11_4d:
    2606. 

  2606. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2607. 

  2607. 	bne.b		_L11_5d			# no
    2608. 

  2608. 	bsr.l		src_qnan			# yes
    2609. 

  2609. 	bra.b		_L11_6d
    2610. 

  2610. _L11_5d:
    2611. 

  2611. 	bsr.l		stwotoxd			# operand is a DENORM
    2612. 

  2612. _L11_6d:
    2613. 

  2613. 

  2614. #
    2615. 

  2615. #	Result is now in FP0
    2616. 

  2616. #
    2617. 

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

  2618. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2619. 

  2619. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2620. 

  2620. 	unlk		%a6
    2621. 

  2621. 	rts
    2622. 

  2622. 

  2623. 	global		_ftwotoxx_
    2624. 

  2624. _ftwotoxx_:
    2625. 

  2625. 	link		%a6,&-LOCAL_SIZE
    2626. 

  2626. 

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

  2628. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2629. 

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

  2630. 

  2631. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2632. 

  2632. 

  2633. #
    2634. 

  2634. #	copy, convert, and tag input argument
    2635. 

  2635. #
    2636. 

  2636. 	lea		FP_SRC(%a6),%a0
    2637. 

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

  2638. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    2639. 

  2639. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    2640. 

  2640. 	bsr.l		tag			# fetch operand type
    2641. 

  2641. 	mov.b		%d0,STAG(%a6)
    2642. 

  2642. 	mov.b		%d0,%d1
    2643. 

  2643. 

  2644. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2645. 

  2645. 

  2646. 	clr.l		%d0
    2647. 

  2647. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2648. 

  2648. 

  2649. 	tst.b		%d1
    2650. 

  2650. 	bne.b		_L11_2x
    2651. 

  2651. 	bsr.l		stwotox			# operand is a NORM
    2652. 

  2652. 	bra.b		_L11_6x
    2653. 

  2653. _L11_2x:
    2654. 

  2654. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2655. 

  2655. 	bne.b		_L11_3x			# no
    2656. 

  2656. 	bsr.l		ld_pone			# yes
    2657. 

  2657. 	bra.b		_L11_6x
    2658. 

  2658. _L11_3x:
    2659. 

  2659. 	cmpi.b		%d1,&INF		# is operand an INF?
    2660. 

  2660. 	bne.b		_L11_4x			# no
    2661. 

  2661. 	bsr.l		szr_inf			# yes
    2662. 

  2662. 	bra.b		_L11_6x
    2663. 

  2663. _L11_4x:
    2664. 

  2664. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2665. 

  2665. 	bne.b		_L11_5x			# no
    2666. 

  2666. 	bsr.l		src_qnan			# yes
    2667. 

  2667. 	bra.b		_L11_6x
    2668. 

  2668. _L11_5x:
    2669. 

  2669. 	bsr.l		stwotoxd			# operand is a DENORM
    2670. 

  2670. _L11_6x:
    2671. 

  2671. 

  2672. #
    2673. 

  2673. #	Result is now in FP0
    2674. 

  2674. #
    2675. 

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

  2676. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2677. 

  2677. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2678. 

  2678. 	unlk		%a6
    2679. 

  2679. 	rts
    2680. 

  2680. 

  2681. 

  2682. #########################################################################
    2683. 

  2683. # MONADIC TEMPLATE							#
    2684. 

  2684. #########################################################################
    2685. 

  2685. 	global		_ftentoxs_
    2686. 

  2686. _ftentoxs_:
    2687. 

  2687. 	link		%a6,&-LOCAL_SIZE
    2688. 

  2688. 

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

  2690. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2691. 

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

  2692. 

  2693. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2694. 

  2694. 

  2695. #
    2696. 

  2696. #	copy, convert, and tag input argument
    2697. 

  2697. #
    2698. 

  2698. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    2699. 

  2699. 	fmov.x		%fp0,FP_SRC(%a6)
    2700. 

  2700. 	lea		FP_SRC(%a6),%a0
    2701. 

  2701. 	bsr.l		tag			# fetch operand type
    2702. 

  2702. 	mov.b		%d0,STAG(%a6)
    2703. 

  2703. 	mov.b		%d0,%d1
    2704. 

  2704. 

  2705. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2706. 

  2706. 

  2707. 	clr.l		%d0
    2708. 

  2708. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2709. 

  2709. 

  2710. 	tst.b		%d1
    2711. 

  2711. 	bne.b		_L12_2s
    2712. 

  2712. 	bsr.l		stentox			# operand is a NORM
    2713. 

  2713. 	bra.b		_L12_6s
    2714. 

  2714. _L12_2s:
    2715. 

  2715. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2716. 

  2716. 	bne.b		_L12_3s			# no
    2717. 

  2717. 	bsr.l		ld_pone			# yes
    2718. 

  2718. 	bra.b		_L12_6s
    2719. 

  2719. _L12_3s:
    2720. 

  2720. 	cmpi.b		%d1,&INF		# is operand an INF?
    2721. 

  2721. 	bne.b		_L12_4s			# no
    2722. 

  2722. 	bsr.l		szr_inf			# yes
    2723. 

  2723. 	bra.b		_L12_6s
    2724. 

  2724. _L12_4s:
    2725. 

  2725. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2726. 

  2726. 	bne.b		_L12_5s			# no
    2727. 

  2727. 	bsr.l		src_qnan			# yes
    2728. 

  2728. 	bra.b		_L12_6s
    2729. 

  2729. _L12_5s:
    2730. 

  2730. 	bsr.l		stentoxd			# operand is a DENORM
    2731. 

  2731. _L12_6s:
    2732. 

  2732. 

  2733. #
    2734. 

  2734. #	Result is now in FP0
    2735. 

  2735. #
    2736. 

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

  2737. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2738. 

  2738. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2739. 

  2739. 	unlk		%a6
    2740. 

  2740. 	rts
    2741. 

  2741. 

  2742. 	global		_ftentoxd_
    2743. 

  2743. _ftentoxd_:
    2744. 

  2744. 	link		%a6,&-LOCAL_SIZE
    2745. 

  2745. 

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

  2747. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2748. 

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

  2749. 

  2750. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2751. 

  2751. 

  2752. #
    2753. 

  2753. #	copy, convert, and tag input argument
    2754. 

  2754. #
    2755. 

  2755. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    2756. 

  2756. 	fmov.x		%fp0,FP_SRC(%a6)
    2757. 

  2757. 	lea		FP_SRC(%a6),%a0
    2758. 

  2758. 	bsr.l		tag			# fetch operand type
    2759. 

  2759. 	mov.b		%d0,STAG(%a6)
    2760. 

  2760. 	mov.b		%d0,%d1
    2761. 

  2761. 

  2762. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2763. 

  2763. 

  2764. 	clr.l		%d0
    2765. 

  2765. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2766. 

  2766. 

  2767. 	mov.b		%d1,STAG(%a6)
    2768. 

  2768. 	tst.b		%d1
    2769. 

  2769. 	bne.b		_L12_2d
    2770. 

  2770. 	bsr.l		stentox			# operand is a NORM
    2771. 

  2771. 	bra.b		_L12_6d
    2772. 

  2772. _L12_2d:
    2773. 

  2773. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2774. 

  2774. 	bne.b		_L12_3d			# no
    2775. 

  2775. 	bsr.l		ld_pone			# yes
    2776. 

  2776. 	bra.b		_L12_6d
    2777. 

  2777. _L12_3d:
    2778. 

  2778. 	cmpi.b		%d1,&INF		# is operand an INF?
    2779. 

  2779. 	bne.b		_L12_4d			# no
    2780. 

  2780. 	bsr.l		szr_inf			# yes
    2781. 

  2781. 	bra.b		_L12_6d
    2782. 

  2782. _L12_4d:
    2783. 

  2783. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2784. 

  2784. 	bne.b		_L12_5d			# no
    2785. 

  2785. 	bsr.l		src_qnan			# yes
    2786. 

  2786. 	bra.b		_L12_6d
    2787. 

  2787. _L12_5d:
    2788. 

  2788. 	bsr.l		stentoxd			# operand is a DENORM
    2789. 

  2789. _L12_6d:
    2790. 

  2790. 

  2791. #
    2792. 

  2792. #	Result is now in FP0
    2793. 

  2793. #
    2794. 

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

  2795. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2796. 

  2796. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2797. 

  2797. 	unlk		%a6
    2798. 

  2798. 	rts
    2799. 

  2799. 

  2800. 	global		_ftentoxx_
    2801. 

  2801. _ftentoxx_:
    2802. 

  2802. 	link		%a6,&-LOCAL_SIZE
    2803. 

  2803. 

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

  2805. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2806. 

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

  2807. 

  2808. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2809. 

  2809. 

  2810. #
    2811. 

  2811. #	copy, convert, and tag input argument
    2812. 

  2812. #
    2813. 

  2813. 	lea		FP_SRC(%a6),%a0
    2814. 

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

  2815. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    2816. 

  2816. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    2817. 

  2817. 	bsr.l		tag			# fetch operand type
    2818. 

  2818. 	mov.b		%d0,STAG(%a6)
    2819. 

  2819. 	mov.b		%d0,%d1
    2820. 

  2820. 

  2821. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2822. 

  2822. 

  2823. 	clr.l		%d0
    2824. 

  2824. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2825. 

  2825. 

  2826. 	tst.b		%d1
    2827. 

  2827. 	bne.b		_L12_2x
    2828. 

  2828. 	bsr.l		stentox			# operand is a NORM
    2829. 

  2829. 	bra.b		_L12_6x
    2830. 

  2830. _L12_2x:
    2831. 

  2831. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2832. 

  2832. 	bne.b		_L12_3x			# no
    2833. 

  2833. 	bsr.l		ld_pone			# yes
    2834. 

  2834. 	bra.b		_L12_6x
    2835. 

  2835. _L12_3x:
    2836. 

  2836. 	cmpi.b		%d1,&INF		# is operand an INF?
    2837. 

  2837. 	bne.b		_L12_4x			# no
    2838. 

  2838. 	bsr.l		szr_inf			# yes
    2839. 

  2839. 	bra.b		_L12_6x
    2840. 

  2840. _L12_4x:
    2841. 

  2841. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2842. 

  2842. 	bne.b		_L12_5x			# no
    2843. 

  2843. 	bsr.l		src_qnan			# yes
    2844. 

  2844. 	bra.b		_L12_6x
    2845. 

  2845. _L12_5x:
    2846. 

  2846. 	bsr.l		stentoxd			# operand is a DENORM
    2847. 

  2847. _L12_6x:
    2848. 

  2848. 

  2849. #
    2850. 

  2850. #	Result is now in FP0
    2851. 

  2851. #
    2852. 

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

  2853. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2854. 

  2854. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2855. 

  2855. 	unlk		%a6
    2856. 

  2856. 	rts
    2857. 

  2857. 

  2858. 

  2859. #########################################################################
    2860. 

  2860. # MONADIC TEMPLATE							#
    2861. 

  2861. #########################################################################
    2862. 

  2862. 	global		_flogns_
    2863. 

  2863. _flogns_:
    2864. 

  2864. 	link		%a6,&-LOCAL_SIZE
    2865. 

  2865. 

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

  2867. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2868. 

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

  2869. 

  2870. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2871. 

  2871. 

  2872. #
    2873. 

  2873. #	copy, convert, and tag input argument
    2874. 

  2874. #
    2875. 

  2875. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    2876. 

  2876. 	fmov.x		%fp0,FP_SRC(%a6)
    2877. 

  2877. 	lea		FP_SRC(%a6),%a0
    2878. 

  2878. 	bsr.l		tag			# fetch operand type
    2879. 

  2879. 	mov.b		%d0,STAG(%a6)
    2880. 

  2880. 	mov.b		%d0,%d1
    2881. 

  2881. 

  2882. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2883. 

  2883. 

  2884. 	clr.l		%d0
    2885. 

  2885. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2886. 

  2886. 

  2887. 	tst.b		%d1
    2888. 

  2888. 	bne.b		_L13_2s
    2889. 

  2889. 	bsr.l		slogn			# operand is a NORM
    2890. 

  2890. 	bra.b		_L13_6s
    2891. 

  2891. _L13_2s:
    2892. 

  2892. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2893. 

  2893. 	bne.b		_L13_3s			# no
    2894. 

  2894. 	bsr.l		t_dz2			# yes
    2895. 

  2895. 	bra.b		_L13_6s
    2896. 

  2896. _L13_3s:
    2897. 

  2897. 	cmpi.b		%d1,&INF		# is operand an INF?
    2898. 

  2898. 	bne.b		_L13_4s			# no
    2899. 

  2899. 	bsr.l		sopr_inf			# yes
    2900. 

  2900. 	bra.b		_L13_6s
    2901. 

  2901. _L13_4s:
    2902. 

  2902. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2903. 

  2903. 	bne.b		_L13_5s			# no
    2904. 

  2904. 	bsr.l		src_qnan			# yes
    2905. 

  2905. 	bra.b		_L13_6s
    2906. 

  2906. _L13_5s:
    2907. 

  2907. 	bsr.l		slognd			# operand is a DENORM
    2908. 

  2908. _L13_6s:
    2909. 

  2909. 

  2910. #
    2911. 

  2911. #	Result is now in FP0
    2912. 

  2912. #
    2913. 

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

  2914. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2915. 

  2915. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2916. 

  2916. 	unlk		%a6
    2917. 

  2917. 	rts
    2918. 

  2918. 

  2919. 	global		_flognd_
    2920. 

  2920. _flognd_:
    2921. 

  2921. 	link		%a6,&-LOCAL_SIZE
    2922. 

  2922. 

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

  2924. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2925. 

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

  2926. 

  2927. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2928. 

  2928. 

  2929. #
    2930. 

  2930. #	copy, convert, and tag input argument
    2931. 

  2931. #
    2932. 

  2932. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    2933. 

  2933. 	fmov.x		%fp0,FP_SRC(%a6)
    2934. 

  2934. 	lea		FP_SRC(%a6),%a0
    2935. 

  2935. 	bsr.l		tag			# fetch operand type
    2936. 

  2936. 	mov.b		%d0,STAG(%a6)
    2937. 

  2937. 	mov.b		%d0,%d1
    2938. 

  2938. 

  2939. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2940. 

  2940. 

  2941. 	clr.l		%d0
    2942. 

  2942. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    2943. 

  2943. 

  2944. 	mov.b		%d1,STAG(%a6)
    2945. 

  2945. 	tst.b		%d1
    2946. 

  2946. 	bne.b		_L13_2d
    2947. 

  2947. 	bsr.l		slogn			# operand is a NORM
    2948. 

  2948. 	bra.b		_L13_6d
    2949. 

  2949. _L13_2d:
    2950. 

  2950. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    2951. 

  2951. 	bne.b		_L13_3d			# no
    2952. 

  2952. 	bsr.l		t_dz2			# yes
    2953. 

  2953. 	bra.b		_L13_6d
    2954. 

  2954. _L13_3d:
    2955. 

  2955. 	cmpi.b		%d1,&INF		# is operand an INF?
    2956. 

  2956. 	bne.b		_L13_4d			# no
    2957. 

  2957. 	bsr.l		sopr_inf			# yes
    2958. 

  2958. 	bra.b		_L13_6d
    2959. 

  2959. _L13_4d:
    2960. 

  2960. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    2961. 

  2961. 	bne.b		_L13_5d			# no
    2962. 

  2962. 	bsr.l		src_qnan			# yes
    2963. 

  2963. 	bra.b		_L13_6d
    2964. 

  2964. _L13_5d:
    2965. 

  2965. 	bsr.l		slognd			# operand is a DENORM
    2966. 

  2966. _L13_6d:
    2967. 

  2967. 

  2968. #
    2969. 

  2969. #	Result is now in FP0
    2970. 

  2970. #
    2971. 

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

  2972. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    2973. 

  2973. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    2974. 

  2974. 	unlk		%a6
    2975. 

  2975. 	rts
    2976. 

  2976. 

  2977. 	global		_flognx_
    2978. 

  2978. _flognx_:
    2979. 

  2979. 	link		%a6,&-LOCAL_SIZE
    2980. 

  2980. 

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

  2982. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    2983. 

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

  2984. 

  2985. 	fmov.l		&0x0,%fpcr		# zero FPCR
    2986. 

  2986. 

  2987. #
    2988. 

  2988. #	copy, convert, and tag input argument
    2989. 

  2989. #
    2990. 

  2990. 	lea		FP_SRC(%a6),%a0
    2991. 

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

  2992. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    2993. 

  2993. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    2994. 

  2994. 	bsr.l		tag			# fetch operand type
    2995. 

  2995. 	mov.b		%d0,STAG(%a6)
    2996. 

  2996. 	mov.b		%d0,%d1
    2997. 

  2997. 

  2998. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    2999. 

  2999. 

  3000. 	clr.l		%d0
    3001. 

  3001. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3002. 

  3002. 

  3003. 	tst.b		%d1
    3004. 

  3004. 	bne.b		_L13_2x
    3005. 

  3005. 	bsr.l		slogn			# operand is a NORM
    3006. 

  3006. 	bra.b		_L13_6x
    3007. 

  3007. _L13_2x:
    3008. 

  3008. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3009. 

  3009. 	bne.b		_L13_3x			# no
    3010. 

  3010. 	bsr.l		t_dz2			# yes
    3011. 

  3011. 	bra.b		_L13_6x
    3012. 

  3012. _L13_3x:
    3013. 

  3013. 	cmpi.b		%d1,&INF		# is operand an INF?
    3014. 

  3014. 	bne.b		_L13_4x			# no
    3015. 

  3015. 	bsr.l		sopr_inf			# yes
    3016. 

  3016. 	bra.b		_L13_6x
    3017. 

  3017. _L13_4x:
    3018. 

  3018. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3019. 

  3019. 	bne.b		_L13_5x			# no
    3020. 

  3020. 	bsr.l		src_qnan			# yes
    3021. 

  3021. 	bra.b		_L13_6x
    3022. 

  3022. _L13_5x:
    3023. 

  3023. 	bsr.l		slognd			# operand is a DENORM
    3024. 

  3024. _L13_6x:
    3025. 

  3025. 

  3026. #
    3027. 

  3027. #	Result is now in FP0
    3028. 

  3028. #
    3029. 

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

  3030. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3031. 

  3031. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3032. 

  3032. 	unlk		%a6
    3033. 

  3033. 	rts
    3034. 

  3034. 

  3035. 

  3036. #########################################################################
    3037. 

  3037. # MONADIC TEMPLATE							#
    3038. 

  3038. #########################################################################
    3039. 

  3039. 	global		_flog10s_
    3040. 

  3040. _flog10s_:
    3041. 

  3041. 	link		%a6,&-LOCAL_SIZE
    3042. 

  3042. 

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

  3044. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3045. 

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

  3046. 

  3047. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3048. 

  3048. 

  3049. #
    3050. 

  3050. #	copy, convert, and tag input argument
    3051. 

  3051. #
    3052. 

  3052. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    3053. 

  3053. 	fmov.x		%fp0,FP_SRC(%a6)
    3054. 

  3054. 	lea		FP_SRC(%a6),%a0
    3055. 

  3055. 	bsr.l		tag			# fetch operand type
    3056. 

  3056. 	mov.b		%d0,STAG(%a6)
    3057. 

  3057. 	mov.b		%d0,%d1
    3058. 

  3058. 

  3059. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3060. 

  3060. 

  3061. 	clr.l		%d0
    3062. 

  3062. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3063. 

  3063. 

  3064. 	tst.b		%d1
    3065. 

  3065. 	bne.b		_L14_2s
    3066. 

  3066. 	bsr.l		slog10			# operand is a NORM
    3067. 

  3067. 	bra.b		_L14_6s
    3068. 

  3068. _L14_2s:
    3069. 

  3069. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3070. 

  3070. 	bne.b		_L14_3s			# no
    3071. 

  3071. 	bsr.l		t_dz2			# yes
    3072. 

  3072. 	bra.b		_L14_6s
    3073. 

  3073. _L14_3s:
    3074. 

  3074. 	cmpi.b		%d1,&INF		# is operand an INF?
    3075. 

  3075. 	bne.b		_L14_4s			# no
    3076. 

  3076. 	bsr.l		sopr_inf			# yes
    3077. 

  3077. 	bra.b		_L14_6s
    3078. 

  3078. _L14_4s:
    3079. 

  3079. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3080. 

  3080. 	bne.b		_L14_5s			# no
    3081. 

  3081. 	bsr.l		src_qnan			# yes
    3082. 

  3082. 	bra.b		_L14_6s
    3083. 

  3083. _L14_5s:
    3084. 

  3084. 	bsr.l		slog10d			# operand is a DENORM
    3085. 

  3085. _L14_6s:
    3086. 

  3086. 

  3087. #
    3088. 

  3088. #	Result is now in FP0
    3089. 

  3089. #
    3090. 

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

  3091. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3092. 

  3092. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3093. 

  3093. 	unlk		%a6
    3094. 

  3094. 	rts
    3095. 

  3095. 

  3096. 	global		_flog10d_
    3097. 

  3097. _flog10d_:
    3098. 

  3098. 	link		%a6,&-LOCAL_SIZE
    3099. 

  3099. 

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

  3101. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3102. 

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

  3103. 

  3104. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3105. 

  3105. 

  3106. #
    3107. 

  3107. #	copy, convert, and tag input argument
    3108. 

  3108. #
    3109. 

  3109. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    3110. 

  3110. 	fmov.x		%fp0,FP_SRC(%a6)
    3111. 

  3111. 	lea		FP_SRC(%a6),%a0
    3112. 

  3112. 	bsr.l		tag			# fetch operand type
    3113. 

  3113. 	mov.b		%d0,STAG(%a6)
    3114. 

  3114. 	mov.b		%d0,%d1
    3115. 

  3115. 

  3116. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3117. 

  3117. 

  3118. 	clr.l		%d0
    3119. 

  3119. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3120. 

  3120. 

  3121. 	mov.b		%d1,STAG(%a6)
    3122. 

  3122. 	tst.b		%d1
    3123. 

  3123. 	bne.b		_L14_2d
    3124. 

  3124. 	bsr.l		slog10			# operand is a NORM
    3125. 

  3125. 	bra.b		_L14_6d
    3126. 

  3126. _L14_2d:
    3127. 

  3127. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3128. 

  3128. 	bne.b		_L14_3d			# no
    3129. 

  3129. 	bsr.l		t_dz2			# yes
    3130. 

  3130. 	bra.b		_L14_6d
    3131. 

  3131. _L14_3d:
    3132. 

  3132. 	cmpi.b		%d1,&INF		# is operand an INF?
    3133. 

  3133. 	bne.b		_L14_4d			# no
    3134. 

  3134. 	bsr.l		sopr_inf			# yes
    3135. 

  3135. 	bra.b		_L14_6d
    3136. 

  3136. _L14_4d:
    3137. 

  3137. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3138. 

  3138. 	bne.b		_L14_5d			# no
    3139. 

  3139. 	bsr.l		src_qnan			# yes
    3140. 

  3140. 	bra.b		_L14_6d
    3141. 

  3141. _L14_5d:
    3142. 

  3142. 	bsr.l		slog10d			# operand is a DENORM
    3143. 

  3143. _L14_6d:
    3144. 

  3144. 

  3145. #
    3146. 

  3146. #	Result is now in FP0
    3147. 

  3147. #
    3148. 

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

  3149. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3150. 

  3150. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3151. 

  3151. 	unlk		%a6
    3152. 

  3152. 	rts
    3153. 

  3153. 

  3154. 	global		_flog10x_
    3155. 

  3155. _flog10x_:
    3156. 

  3156. 	link		%a6,&-LOCAL_SIZE
    3157. 

  3157. 

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

  3159. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3160. 

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

  3161. 

  3162. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3163. 

  3163. 

  3164. #
    3165. 

  3165. #	copy, convert, and tag input argument
    3166. 

  3166. #
    3167. 

  3167. 	lea		FP_SRC(%a6),%a0
    3168. 

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

  3169. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    3170. 

  3170. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    3171. 

  3171. 	bsr.l		tag			# fetch operand type
    3172. 

  3172. 	mov.b		%d0,STAG(%a6)
    3173. 

  3173. 	mov.b		%d0,%d1
    3174. 

  3174. 

  3175. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3176. 

  3176. 

  3177. 	clr.l		%d0
    3178. 

  3178. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3179. 

  3179. 

  3180. 	tst.b		%d1
    3181. 

  3181. 	bne.b		_L14_2x
    3182. 

  3182. 	bsr.l		slog10			# operand is a NORM
    3183. 

  3183. 	bra.b		_L14_6x
    3184. 

  3184. _L14_2x:
    3185. 

  3185. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3186. 

  3186. 	bne.b		_L14_3x			# no
    3187. 

  3187. 	bsr.l		t_dz2			# yes
    3188. 

  3188. 	bra.b		_L14_6x
    3189. 

  3189. _L14_3x:
    3190. 

  3190. 	cmpi.b		%d1,&INF		# is operand an INF?
    3191. 

  3191. 	bne.b		_L14_4x			# no
    3192. 

  3192. 	bsr.l		sopr_inf			# yes
    3193. 

  3193. 	bra.b		_L14_6x
    3194. 

  3194. _L14_4x:
    3195. 

  3195. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3196. 

  3196. 	bne.b		_L14_5x			# no
    3197. 

  3197. 	bsr.l		src_qnan			# yes
    3198. 

  3198. 	bra.b		_L14_6x
    3199. 

  3199. _L14_5x:
    3200. 

  3200. 	bsr.l		slog10d			# operand is a DENORM
    3201. 

  3201. _L14_6x:
    3202. 

  3202. 

  3203. #
    3204. 

  3204. #	Result is now in FP0
    3205. 

  3205. #
    3206. 

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

  3207. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3208. 

  3208. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3209. 

  3209. 	unlk		%a6
    3210. 

  3210. 	rts
    3211. 

  3211. 

  3212. 

  3213. #########################################################################
    3214. 

  3214. # MONADIC TEMPLATE							#
    3215. 

  3215. #########################################################################
    3216. 

  3216. 	global		_flog2s_
    3217. 

  3217. _flog2s_:
    3218. 

  3218. 	link		%a6,&-LOCAL_SIZE
    3219. 

  3219. 

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

  3221. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3222. 

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

  3223. 

  3224. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3225. 

  3225. 

  3226. #
    3227. 

  3227. #	copy, convert, and tag input argument
    3228. 

  3228. #
    3229. 

  3229. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    3230. 

  3230. 	fmov.x		%fp0,FP_SRC(%a6)
    3231. 

  3231. 	lea		FP_SRC(%a6),%a0
    3232. 

  3232. 	bsr.l		tag			# fetch operand type
    3233. 

  3233. 	mov.b		%d0,STAG(%a6)
    3234. 

  3234. 	mov.b		%d0,%d1
    3235. 

  3235. 

  3236. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3237. 

  3237. 

  3238. 	clr.l		%d0
    3239. 

  3239. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3240. 

  3240. 

  3241. 	tst.b		%d1
    3242. 

  3242. 	bne.b		_L15_2s
    3243. 

  3243. 	bsr.l		slog2			# operand is a NORM
    3244. 

  3244. 	bra.b		_L15_6s
    3245. 

  3245. _L15_2s:
    3246. 

  3246. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3247. 

  3247. 	bne.b		_L15_3s			# no
    3248. 

  3248. 	bsr.l		t_dz2			# yes
    3249. 

  3249. 	bra.b		_L15_6s
    3250. 

  3250. _L15_3s:
    3251. 

  3251. 	cmpi.b		%d1,&INF		# is operand an INF?
    3252. 

  3252. 	bne.b		_L15_4s			# no
    3253. 

  3253. 	bsr.l		sopr_inf			# yes
    3254. 

  3254. 	bra.b		_L15_6s
    3255. 

  3255. _L15_4s:
    3256. 

  3256. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3257. 

  3257. 	bne.b		_L15_5s			# no
    3258. 

  3258. 	bsr.l		src_qnan			# yes
    3259. 

  3259. 	bra.b		_L15_6s
    3260. 

  3260. _L15_5s:
    3261. 

  3261. 	bsr.l		slog2d			# operand is a DENORM
    3262. 

  3262. _L15_6s:
    3263. 

  3263. 

  3264. #
    3265. 

  3265. #	Result is now in FP0
    3266. 

  3266. #
    3267. 

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

  3268. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3269. 

  3269. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3270. 

  3270. 	unlk		%a6
    3271. 

  3271. 	rts
    3272. 

  3272. 

  3273. 	global		_flog2d_
    3274. 

  3274. _flog2d_:
    3275. 

  3275. 	link		%a6,&-LOCAL_SIZE
    3276. 

  3276. 

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

  3278. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3279. 

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

  3280. 

  3281. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3282. 

  3282. 

  3283. #
    3284. 

  3284. #	copy, convert, and tag input argument
    3285. 

  3285. #
    3286. 

  3286. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    3287. 

  3287. 	fmov.x		%fp0,FP_SRC(%a6)
    3288. 

  3288. 	lea		FP_SRC(%a6),%a0
    3289. 

  3289. 	bsr.l		tag			# fetch operand type
    3290. 

  3290. 	mov.b		%d0,STAG(%a6)
    3291. 

  3291. 	mov.b		%d0,%d1
    3292. 

  3292. 

  3293. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3294. 

  3294. 

  3295. 	clr.l		%d0
    3296. 

  3296. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3297. 

  3297. 

  3298. 	mov.b		%d1,STAG(%a6)
    3299. 

  3299. 	tst.b		%d1
    3300. 

  3300. 	bne.b		_L15_2d
    3301. 

  3301. 	bsr.l		slog2			# operand is a NORM
    3302. 

  3302. 	bra.b		_L15_6d
    3303. 

  3303. _L15_2d:
    3304. 

  3304. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3305. 

  3305. 	bne.b		_L15_3d			# no
    3306. 

  3306. 	bsr.l		t_dz2			# yes
    3307. 

  3307. 	bra.b		_L15_6d
    3308. 

  3308. _L15_3d:
    3309. 

  3309. 	cmpi.b		%d1,&INF		# is operand an INF?
    3310. 

  3310. 	bne.b		_L15_4d			# no
    3311. 

  3311. 	bsr.l		sopr_inf			# yes
    3312. 

  3312. 	bra.b		_L15_6d
    3313. 

  3313. _L15_4d:
    3314. 

  3314. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3315. 

  3315. 	bne.b		_L15_5d			# no
    3316. 

  3316. 	bsr.l		src_qnan			# yes
    3317. 

  3317. 	bra.b		_L15_6d
    3318. 

  3318. _L15_5d:
    3319. 

  3319. 	bsr.l		slog2d			# operand is a DENORM
    3320. 

  3320. _L15_6d:
    3321. 

  3321. 

  3322. #
    3323. 

  3323. #	Result is now in FP0
    3324. 

  3324. #
    3325. 

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

  3326. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3327. 

  3327. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3328. 

  3328. 	unlk		%a6
    3329. 

  3329. 	rts
    3330. 

  3330. 

  3331. 	global		_flog2x_
    3332. 

  3332. _flog2x_:
    3333. 

  3333. 	link		%a6,&-LOCAL_SIZE
    3334. 

  3334. 

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

  3336. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3337. 

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

  3338. 

  3339. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3340. 

  3340. 

  3341. #
    3342. 

  3342. #	copy, convert, and tag input argument
    3343. 

  3343. #
    3344. 

  3344. 	lea		FP_SRC(%a6),%a0
    3345. 

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

  3346. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    3347. 

  3347. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    3348. 

  3348. 	bsr.l		tag			# fetch operand type
    3349. 

  3349. 	mov.b		%d0,STAG(%a6)
    3350. 

  3350. 	mov.b		%d0,%d1
    3351. 

  3351. 

  3352. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3353. 

  3353. 

  3354. 	clr.l		%d0
    3355. 

  3355. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3356. 

  3356. 

  3357. 	tst.b		%d1
    3358. 

  3358. 	bne.b		_L15_2x
    3359. 

  3359. 	bsr.l		slog2			# operand is a NORM
    3360. 

  3360. 	bra.b		_L15_6x
    3361. 

  3361. _L15_2x:
    3362. 

  3362. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3363. 

  3363. 	bne.b		_L15_3x			# no
    3364. 

  3364. 	bsr.l		t_dz2			# yes
    3365. 

  3365. 	bra.b		_L15_6x
    3366. 

  3366. _L15_3x:
    3367. 

  3367. 	cmpi.b		%d1,&INF		# is operand an INF?
    3368. 

  3368. 	bne.b		_L15_4x			# no
    3369. 

  3369. 	bsr.l		sopr_inf			# yes
    3370. 

  3370. 	bra.b		_L15_6x
    3371. 

  3371. _L15_4x:
    3372. 

  3372. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3373. 

  3373. 	bne.b		_L15_5x			# no
    3374. 

  3374. 	bsr.l		src_qnan			# yes
    3375. 

  3375. 	bra.b		_L15_6x
    3376. 

  3376. _L15_5x:
    3377. 

  3377. 	bsr.l		slog2d			# operand is a DENORM
    3378. 

  3378. _L15_6x:
    3379. 

  3379. 

  3380. #
    3381. 

  3381. #	Result is now in FP0
    3382. 

  3382. #
    3383. 

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

  3384. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3385. 

  3385. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3386. 

  3386. 	unlk		%a6
    3387. 

  3387. 	rts
    3388. 

  3388. 

  3389. 

  3390. #########################################################################
    3391. 

  3391. # MONADIC TEMPLATE							#
    3392. 

  3392. #########################################################################
    3393. 

  3393. 	global		_fcoshs_
    3394. 

  3394. _fcoshs_:
    3395. 

  3395. 	link		%a6,&-LOCAL_SIZE
    3396. 

  3396. 

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

  3398. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3399. 

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

  3400. 

  3401. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3402. 

  3402. 

  3403. #
    3404. 

  3404. #	copy, convert, and tag input argument
    3405. 

  3405. #
    3406. 

  3406. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    3407. 

  3407. 	fmov.x		%fp0,FP_SRC(%a6)
    3408. 

  3408. 	lea		FP_SRC(%a6),%a0
    3409. 

  3409. 	bsr.l		tag			# fetch operand type
    3410. 

  3410. 	mov.b		%d0,STAG(%a6)
    3411. 

  3411. 	mov.b		%d0,%d1
    3412. 

  3412. 

  3413. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3414. 

  3414. 

  3415. 	clr.l		%d0
    3416. 

  3416. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3417. 

  3417. 

  3418. 	tst.b		%d1
    3419. 

  3419. 	bne.b		_L16_2s
    3420. 

  3420. 	bsr.l		scosh			# operand is a NORM
    3421. 

  3421. 	bra.b		_L16_6s
    3422. 

  3422. _L16_2s:
    3423. 

  3423. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3424. 

  3424. 	bne.b		_L16_3s			# no
    3425. 

  3425. 	bsr.l		ld_pone			# yes
    3426. 

  3426. 	bra.b		_L16_6s
    3427. 

  3427. _L16_3s:
    3428. 

  3428. 	cmpi.b		%d1,&INF		# is operand an INF?
    3429. 

  3429. 	bne.b		_L16_4s			# no
    3430. 

  3430. 	bsr.l		ld_pinf			# yes
    3431. 

  3431. 	bra.b		_L16_6s
    3432. 

  3432. _L16_4s:
    3433. 

  3433. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3434. 

  3434. 	bne.b		_L16_5s			# no
    3435. 

  3435. 	bsr.l		src_qnan			# yes
    3436. 

  3436. 	bra.b		_L16_6s
    3437. 

  3437. _L16_5s:
    3438. 

  3438. 	bsr.l		scoshd			# operand is a DENORM
    3439. 

  3439. _L16_6s:
    3440. 

  3440. 

  3441. #
    3442. 

  3442. #	Result is now in FP0
    3443. 

  3443. #
    3444. 

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

  3445. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3446. 

  3446. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3447. 

  3447. 	unlk		%a6
    3448. 

  3448. 	rts
    3449. 

  3449. 

  3450. 	global		_fcoshd_
    3451. 

  3451. _fcoshd_:
    3452. 

  3452. 	link		%a6,&-LOCAL_SIZE
    3453. 

  3453. 

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

  3455. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3456. 

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

  3457. 

  3458. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3459. 

  3459. 

  3460. #
    3461. 

  3461. #	copy, convert, and tag input argument
    3462. 

  3462. #
    3463. 

  3463. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    3464. 

  3464. 	fmov.x		%fp0,FP_SRC(%a6)
    3465. 

  3465. 	lea		FP_SRC(%a6),%a0
    3466. 

  3466. 	bsr.l		tag			# fetch operand type
    3467. 

  3467. 	mov.b		%d0,STAG(%a6)
    3468. 

  3468. 	mov.b		%d0,%d1
    3469. 

  3469. 

  3470. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3471. 

  3471. 

  3472. 	clr.l		%d0
    3473. 

  3473. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3474. 

  3474. 

  3475. 	mov.b		%d1,STAG(%a6)
    3476. 

  3476. 	tst.b		%d1
    3477. 

  3477. 	bne.b		_L16_2d
    3478. 

  3478. 	bsr.l		scosh			# operand is a NORM
    3479. 

  3479. 	bra.b		_L16_6d
    3480. 

  3480. _L16_2d:
    3481. 

  3481. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3482. 

  3482. 	bne.b		_L16_3d			# no
    3483. 

  3483. 	bsr.l		ld_pone			# yes
    3484. 

  3484. 	bra.b		_L16_6d
    3485. 

  3485. _L16_3d:
    3486. 

  3486. 	cmpi.b		%d1,&INF		# is operand an INF?
    3487. 

  3487. 	bne.b		_L16_4d			# no
    3488. 

  3488. 	bsr.l		ld_pinf			# yes
    3489. 

  3489. 	bra.b		_L16_6d
    3490. 

  3490. _L16_4d:
    3491. 

  3491. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3492. 

  3492. 	bne.b		_L16_5d			# no
    3493. 

  3493. 	bsr.l		src_qnan			# yes
    3494. 

  3494. 	bra.b		_L16_6d
    3495. 

  3495. _L16_5d:
    3496. 

  3496. 	bsr.l		scoshd			# operand is a DENORM
    3497. 

  3497. _L16_6d:
    3498. 

  3498. 

  3499. #
    3500. 

  3500. #	Result is now in FP0
    3501. 

  3501. #
    3502. 

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

  3503. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3504. 

  3504. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3505. 

  3505. 	unlk		%a6
    3506. 

  3506. 	rts
    3507. 

  3507. 

  3508. 	global		_fcoshx_
    3509. 

  3509. _fcoshx_:
    3510. 

  3510. 	link		%a6,&-LOCAL_SIZE
    3511. 

  3511. 

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

  3513. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3514. 

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

  3515. 

  3516. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3517. 

  3517. 

  3518. #
    3519. 

  3519. #	copy, convert, and tag input argument
    3520. 

  3520. #
    3521. 

  3521. 	lea		FP_SRC(%a6),%a0
    3522. 

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

  3523. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    3524. 

  3524. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    3525. 

  3525. 	bsr.l		tag			# fetch operand type
    3526. 

  3526. 	mov.b		%d0,STAG(%a6)
    3527. 

  3527. 	mov.b		%d0,%d1
    3528. 

  3528. 

  3529. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3530. 

  3530. 

  3531. 	clr.l		%d0
    3532. 

  3532. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3533. 

  3533. 

  3534. 	tst.b		%d1
    3535. 

  3535. 	bne.b		_L16_2x
    3536. 

  3536. 	bsr.l		scosh			# operand is a NORM
    3537. 

  3537. 	bra.b		_L16_6x
    3538. 

  3538. _L16_2x:
    3539. 

  3539. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3540. 

  3540. 	bne.b		_L16_3x			# no
    3541. 

  3541. 	bsr.l		ld_pone			# yes
    3542. 

  3542. 	bra.b		_L16_6x
    3543. 

  3543. _L16_3x:
    3544. 

  3544. 	cmpi.b		%d1,&INF		# is operand an INF?
    3545. 

  3545. 	bne.b		_L16_4x			# no
    3546. 

  3546. 	bsr.l		ld_pinf			# yes
    3547. 

  3547. 	bra.b		_L16_6x
    3548. 

  3548. _L16_4x:
    3549. 

  3549. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3550. 

  3550. 	bne.b		_L16_5x			# no
    3551. 

  3551. 	bsr.l		src_qnan			# yes
    3552. 

  3552. 	bra.b		_L16_6x
    3553. 

  3553. _L16_5x:
    3554. 

  3554. 	bsr.l		scoshd			# operand is a DENORM
    3555. 

  3555. _L16_6x:
    3556. 

  3556. 

  3557. #
    3558. 

  3558. #	Result is now in FP0
    3559. 

  3559. #
    3560. 

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

  3561. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3562. 

  3562. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3563. 

  3563. 	unlk		%a6
    3564. 

  3564. 	rts
    3565. 

  3565. 

  3566. 

  3567. #########################################################################
    3568. 

  3568. # MONADIC TEMPLATE							#
    3569. 

  3569. #########################################################################
    3570. 

  3570. 	global		_facoss_
    3571. 

  3571. _facoss_:
    3572. 

  3572. 	link		%a6,&-LOCAL_SIZE
    3573. 

  3573. 

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

  3575. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3576. 

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

  3577. 

  3578. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3579. 

  3579. 

  3580. #
    3581. 

  3581. #	copy, convert, and tag input argument
    3582. 

  3582. #
    3583. 

  3583. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    3584. 

  3584. 	fmov.x		%fp0,FP_SRC(%a6)
    3585. 

  3585. 	lea		FP_SRC(%a6),%a0
    3586. 

  3586. 	bsr.l		tag			# fetch operand type
    3587. 

  3587. 	mov.b		%d0,STAG(%a6)
    3588. 

  3588. 	mov.b		%d0,%d1
    3589. 

  3589. 

  3590. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3591. 

  3591. 

  3592. 	clr.l		%d0
    3593. 

  3593. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3594. 

  3594. 

  3595. 	tst.b		%d1
    3596. 

  3596. 	bne.b		_L17_2s
    3597. 

  3597. 	bsr.l		sacos			# operand is a NORM
    3598. 

  3598. 	bra.b		_L17_6s
    3599. 

  3599. _L17_2s:
    3600. 

  3600. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3601. 

  3601. 	bne.b		_L17_3s			# no
    3602. 

  3602. 	bsr.l		ld_ppi2			# yes
    3603. 

  3603. 	bra.b		_L17_6s
    3604. 

  3604. _L17_3s:
    3605. 

  3605. 	cmpi.b		%d1,&INF		# is operand an INF?
    3606. 

  3606. 	bne.b		_L17_4s			# no
    3607. 

  3607. 	bsr.l		t_operr			# yes
    3608. 

  3608. 	bra.b		_L17_6s
    3609. 

  3609. _L17_4s:
    3610. 

  3610. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3611. 

  3611. 	bne.b		_L17_5s			# no
    3612. 

  3612. 	bsr.l		src_qnan			# yes
    3613. 

  3613. 	bra.b		_L17_6s
    3614. 

  3614. _L17_5s:
    3615. 

  3615. 	bsr.l		sacosd			# operand is a DENORM
    3616. 

  3616. _L17_6s:
    3617. 

  3617. 

  3618. #
    3619. 

  3619. #	Result is now in FP0
    3620. 

  3620. #
    3621. 

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

  3622. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3623. 

  3623. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3624. 

  3624. 	unlk		%a6
    3625. 

  3625. 	rts
    3626. 

  3626. 

  3627. 	global		_facosd_
    3628. 

  3628. _facosd_:
    3629. 

  3629. 	link		%a6,&-LOCAL_SIZE
    3630. 

  3630. 

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

  3632. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3633. 

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

  3634. 

  3635. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3636. 

  3636. 

  3637. #
    3638. 

  3638. #	copy, convert, and tag input argument
    3639. 

  3639. #
    3640. 

  3640. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    3641. 

  3641. 	fmov.x		%fp0,FP_SRC(%a6)
    3642. 

  3642. 	lea		FP_SRC(%a6),%a0
    3643. 

  3643. 	bsr.l		tag			# fetch operand type
    3644. 

  3644. 	mov.b		%d0,STAG(%a6)
    3645. 

  3645. 	mov.b		%d0,%d1
    3646. 

  3646. 

  3647. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3648. 

  3648. 

  3649. 	clr.l		%d0
    3650. 

  3650. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3651. 

  3651. 

  3652. 	mov.b		%d1,STAG(%a6)
    3653. 

  3653. 	tst.b		%d1
    3654. 

  3654. 	bne.b		_L17_2d
    3655. 

  3655. 	bsr.l		sacos			# operand is a NORM
    3656. 

  3656. 	bra.b		_L17_6d
    3657. 

  3657. _L17_2d:
    3658. 

  3658. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3659. 

  3659. 	bne.b		_L17_3d			# no
    3660. 

  3660. 	bsr.l		ld_ppi2			# yes
    3661. 

  3661. 	bra.b		_L17_6d
    3662. 

  3662. _L17_3d:
    3663. 

  3663. 	cmpi.b		%d1,&INF		# is operand an INF?
    3664. 

  3664. 	bne.b		_L17_4d			# no
    3665. 

  3665. 	bsr.l		t_operr			# yes
    3666. 

  3666. 	bra.b		_L17_6d
    3667. 

  3667. _L17_4d:
    3668. 

  3668. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3669. 

  3669. 	bne.b		_L17_5d			# no
    3670. 

  3670. 	bsr.l		src_qnan			# yes
    3671. 

  3671. 	bra.b		_L17_6d
    3672. 

  3672. _L17_5d:
    3673. 

  3673. 	bsr.l		sacosd			# operand is a DENORM
    3674. 

  3674. _L17_6d:
    3675. 

  3675. 

  3676. #
    3677. 

  3677. #	Result is now in FP0
    3678. 

  3678. #
    3679. 

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

  3680. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3681. 

  3681. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3682. 

  3682. 	unlk		%a6
    3683. 

  3683. 	rts
    3684. 

  3684. 

  3685. 	global		_facosx_
    3686. 

  3686. _facosx_:
    3687. 

  3687. 	link		%a6,&-LOCAL_SIZE
    3688. 

  3688. 

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

  3690. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3691. 

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

  3692. 

  3693. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3694. 

  3694. 

  3695. #
    3696. 

  3696. #	copy, convert, and tag input argument
    3697. 

  3697. #
    3698. 

  3698. 	lea		FP_SRC(%a6),%a0
    3699. 

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

  3700. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    3701. 

  3701. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    3702. 

  3702. 	bsr.l		tag			# fetch operand type
    3703. 

  3703. 	mov.b		%d0,STAG(%a6)
    3704. 

  3704. 	mov.b		%d0,%d1
    3705. 

  3705. 

  3706. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3707. 

  3707. 

  3708. 	clr.l		%d0
    3709. 

  3709. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3710. 

  3710. 

  3711. 	tst.b		%d1
    3712. 

  3712. 	bne.b		_L17_2x
    3713. 

  3713. 	bsr.l		sacos			# operand is a NORM
    3714. 

  3714. 	bra.b		_L17_6x
    3715. 

  3715. _L17_2x:
    3716. 

  3716. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3717. 

  3717. 	bne.b		_L17_3x			# no
    3718. 

  3718. 	bsr.l		ld_ppi2			# yes
    3719. 

  3719. 	bra.b		_L17_6x
    3720. 

  3720. _L17_3x:
    3721. 

  3721. 	cmpi.b		%d1,&INF		# is operand an INF?
    3722. 

  3722. 	bne.b		_L17_4x			# no
    3723. 

  3723. 	bsr.l		t_operr			# yes
    3724. 

  3724. 	bra.b		_L17_6x
    3725. 

  3725. _L17_4x:
    3726. 

  3726. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3727. 

  3727. 	bne.b		_L17_5x			# no
    3728. 

  3728. 	bsr.l		src_qnan			# yes
    3729. 

  3729. 	bra.b		_L17_6x
    3730. 

  3730. _L17_5x:
    3731. 

  3731. 	bsr.l		sacosd			# operand is a DENORM
    3732. 

  3732. _L17_6x:
    3733. 

  3733. 

  3734. #
    3735. 

  3735. #	Result is now in FP0
    3736. 

  3736. #
    3737. 

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

  3738. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3739. 

  3739. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3740. 

  3740. 	unlk		%a6
    3741. 

  3741. 	rts
    3742. 

  3742. 

  3743. 

  3744. #########################################################################
    3745. 

  3745. # MONADIC TEMPLATE							#
    3746. 

  3746. #########################################################################
    3747. 

  3747. 	global		_fgetexps_
    3748. 

  3748. _fgetexps_:
    3749. 

  3749. 	link		%a6,&-LOCAL_SIZE
    3750. 

  3750. 

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

  3752. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3753. 

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

  3754. 

  3755. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3756. 

  3756. 

  3757. #
    3758. 

  3758. #	copy, convert, and tag input argument
    3759. 

  3759. #
    3760. 

  3760. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    3761. 

  3761. 	fmov.x		%fp0,FP_SRC(%a6)
    3762. 

  3762. 	lea		FP_SRC(%a6),%a0
    3763. 

  3763. 	bsr.l		tag			# fetch operand type
    3764. 

  3764. 	mov.b		%d0,STAG(%a6)
    3765. 

  3765. 	mov.b		%d0,%d1
    3766. 

  3766. 

  3767. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3768. 

  3768. 

  3769. 	clr.l		%d0
    3770. 

  3770. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3771. 

  3771. 

  3772. 	tst.b		%d1
    3773. 

  3773. 	bne.b		_L18_2s
    3774. 

  3774. 	bsr.l		sgetexp			# operand is a NORM
    3775. 

  3775. 	bra.b		_L18_6s
    3776. 

  3776. _L18_2s:
    3777. 

  3777. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3778. 

  3778. 	bne.b		_L18_3s			# no
    3779. 

  3779. 	bsr.l		src_zero			# yes
    3780. 

  3780. 	bra.b		_L18_6s
    3781. 

  3781. _L18_3s:
    3782. 

  3782. 	cmpi.b		%d1,&INF		# is operand an INF?
    3783. 

  3783. 	bne.b		_L18_4s			# no
    3784. 

  3784. 	bsr.l		t_operr			# yes
    3785. 

  3785. 	bra.b		_L18_6s
    3786. 

  3786. _L18_4s:
    3787. 

  3787. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3788. 

  3788. 	bne.b		_L18_5s			# no
    3789. 

  3789. 	bsr.l		src_qnan			# yes
    3790. 

  3790. 	bra.b		_L18_6s
    3791. 

  3791. _L18_5s:
    3792. 

  3792. 	bsr.l		sgetexpd			# operand is a DENORM
    3793. 

  3793. _L18_6s:
    3794. 

  3794. 

  3795. #
    3796. 

  3796. #	Result is now in FP0
    3797. 

  3797. #
    3798. 

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

  3799. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3800. 

  3800. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3801. 

  3801. 	unlk		%a6
    3802. 

  3802. 	rts
    3803. 

  3803. 

  3804. 	global		_fgetexpd_
    3805. 

  3805. _fgetexpd_:
    3806. 

  3806. 	link		%a6,&-LOCAL_SIZE
    3807. 

  3807. 

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

  3809. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3810. 

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

  3811. 

  3812. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3813. 

  3813. 

  3814. #
    3815. 

  3815. #	copy, convert, and tag input argument
    3816. 

  3816. #
    3817. 

  3817. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    3818. 

  3818. 	fmov.x		%fp0,FP_SRC(%a6)
    3819. 

  3819. 	lea		FP_SRC(%a6),%a0
    3820. 

  3820. 	bsr.l		tag			# fetch operand type
    3821. 

  3821. 	mov.b		%d0,STAG(%a6)
    3822. 

  3822. 	mov.b		%d0,%d1
    3823. 

  3823. 

  3824. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3825. 

  3825. 

  3826. 	clr.l		%d0
    3827. 

  3827. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3828. 

  3828. 

  3829. 	mov.b		%d1,STAG(%a6)
    3830. 

  3830. 	tst.b		%d1
    3831. 

  3831. 	bne.b		_L18_2d
    3832. 

  3832. 	bsr.l		sgetexp			# operand is a NORM
    3833. 

  3833. 	bra.b		_L18_6d
    3834. 

  3834. _L18_2d:
    3835. 

  3835. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3836. 

  3836. 	bne.b		_L18_3d			# no
    3837. 

  3837. 	bsr.l		src_zero			# yes
    3838. 

  3838. 	bra.b		_L18_6d
    3839. 

  3839. _L18_3d:
    3840. 

  3840. 	cmpi.b		%d1,&INF		# is operand an INF?
    3841. 

  3841. 	bne.b		_L18_4d			# no
    3842. 

  3842. 	bsr.l		t_operr			# yes
    3843. 

  3843. 	bra.b		_L18_6d
    3844. 

  3844. _L18_4d:
    3845. 

  3845. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3846. 

  3846. 	bne.b		_L18_5d			# no
    3847. 

  3847. 	bsr.l		src_qnan			# yes
    3848. 

  3848. 	bra.b		_L18_6d
    3849. 

  3849. _L18_5d:
    3850. 

  3850. 	bsr.l		sgetexpd			# operand is a DENORM
    3851. 

  3851. _L18_6d:
    3852. 

  3852. 

  3853. #
    3854. 

  3854. #	Result is now in FP0
    3855. 

  3855. #
    3856. 

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

  3857. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3858. 

  3858. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3859. 

  3859. 	unlk		%a6
    3860. 

  3860. 	rts
    3861. 

  3861. 

  3862. 	global		_fgetexpx_
    3863. 

  3863. _fgetexpx_:
    3864. 

  3864. 	link		%a6,&-LOCAL_SIZE
    3865. 

  3865. 

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

  3867. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3868. 

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

  3869. 

  3870. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3871. 

  3871. 

  3872. #
    3873. 

  3873. #	copy, convert, and tag input argument
    3874. 

  3874. #
    3875. 

  3875. 	lea		FP_SRC(%a6),%a0
    3876. 

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

  3877. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    3878. 

  3878. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    3879. 

  3879. 	bsr.l		tag			# fetch operand type
    3880. 

  3880. 	mov.b		%d0,STAG(%a6)
    3881. 

  3881. 	mov.b		%d0,%d1
    3882. 

  3882. 

  3883. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3884. 

  3884. 

  3885. 	clr.l		%d0
    3886. 

  3886. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3887. 

  3887. 

  3888. 	tst.b		%d1
    3889. 

  3889. 	bne.b		_L18_2x
    3890. 

  3890. 	bsr.l		sgetexp			# operand is a NORM
    3891. 

  3891. 	bra.b		_L18_6x
    3892. 

  3892. _L18_2x:
    3893. 

  3893. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3894. 

  3894. 	bne.b		_L18_3x			# no
    3895. 

  3895. 	bsr.l		src_zero			# yes
    3896. 

  3896. 	bra.b		_L18_6x
    3897. 

  3897. _L18_3x:
    3898. 

  3898. 	cmpi.b		%d1,&INF		# is operand an INF?
    3899. 

  3899. 	bne.b		_L18_4x			# no
    3900. 

  3900. 	bsr.l		t_operr			# yes
    3901. 

  3901. 	bra.b		_L18_6x
    3902. 

  3902. _L18_4x:
    3903. 

  3903. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3904. 

  3904. 	bne.b		_L18_5x			# no
    3905. 

  3905. 	bsr.l		src_qnan			# yes
    3906. 

  3906. 	bra.b		_L18_6x
    3907. 

  3907. _L18_5x:
    3908. 

  3908. 	bsr.l		sgetexpd			# operand is a DENORM
    3909. 

  3909. _L18_6x:
    3910. 

  3910. 

  3911. #
    3912. 

  3912. #	Result is now in FP0
    3913. 

  3913. #
    3914. 

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

  3915. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3916. 

  3916. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3917. 

  3917. 	unlk		%a6
    3918. 

  3918. 	rts
    3919. 

  3919. 

  3920. 

  3921. #########################################################################
    3922. 

  3922. # MONADIC TEMPLATE							#
    3923. 

  3923. #########################################################################
    3924. 

  3924. 	global		_fgetmans_
    3925. 

  3925. _fgetmans_:
    3926. 

  3926. 	link		%a6,&-LOCAL_SIZE
    3927. 

  3927. 

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

  3929. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3930. 

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

  3931. 

  3932. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3933. 

  3933. 

  3934. #
    3935. 

  3935. #	copy, convert, and tag input argument
    3936. 

  3936. #
    3937. 

  3937. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    3938. 

  3938. 	fmov.x		%fp0,FP_SRC(%a6)
    3939. 

  3939. 	lea		FP_SRC(%a6),%a0
    3940. 

  3940. 	bsr.l		tag			# fetch operand type
    3941. 

  3941. 	mov.b		%d0,STAG(%a6)
    3942. 

  3942. 	mov.b		%d0,%d1
    3943. 

  3943. 

  3944. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    3945. 

  3945. 

  3946. 	clr.l		%d0
    3947. 

  3947. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    3948. 

  3948. 

  3949. 	tst.b		%d1
    3950. 

  3950. 	bne.b		_L19_2s
    3951. 

  3951. 	bsr.l		sgetman			# operand is a NORM
    3952. 

  3952. 	bra.b		_L19_6s
    3953. 

  3953. _L19_2s:
    3954. 

  3954. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    3955. 

  3955. 	bne.b		_L19_3s			# no
    3956. 

  3956. 	bsr.l		src_zero			# yes
    3957. 

  3957. 	bra.b		_L19_6s
    3958. 

  3958. _L19_3s:
    3959. 

  3959. 	cmpi.b		%d1,&INF		# is operand an INF?
    3960. 

  3960. 	bne.b		_L19_4s			# no
    3961. 

  3961. 	bsr.l		t_operr			# yes
    3962. 

  3962. 	bra.b		_L19_6s
    3963. 

  3963. _L19_4s:
    3964. 

  3964. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    3965. 

  3965. 	bne.b		_L19_5s			# no
    3966. 

  3966. 	bsr.l		src_qnan			# yes
    3967. 

  3967. 	bra.b		_L19_6s
    3968. 

  3968. _L19_5s:
    3969. 

  3969. 	bsr.l		sgetmand			# operand is a DENORM
    3970. 

  3970. _L19_6s:
    3971. 

  3971. 

  3972. #
    3973. 

  3973. #	Result is now in FP0
    3974. 

  3974. #
    3975. 

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

  3976. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    3977. 

  3977. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    3978. 

  3978. 	unlk		%a6
    3979. 

  3979. 	rts
    3980. 

  3980. 

  3981. 	global		_fgetmand_
    3982. 

  3982. _fgetmand_:
    3983. 

  3983. 	link		%a6,&-LOCAL_SIZE
    3984. 

  3984. 

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

  3986. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    3987. 

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

  3988. 

  3989. 	fmov.l		&0x0,%fpcr		# zero FPCR
    3990. 

  3990. 

  3991. #
    3992. 

  3992. #	copy, convert, and tag input argument
    3993. 

  3993. #
    3994. 

  3994. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    3995. 

  3995. 	fmov.x		%fp0,FP_SRC(%a6)
    3996. 

  3996. 	lea		FP_SRC(%a6),%a0
    3997. 

  3997. 	bsr.l		tag			# fetch operand type
    3998. 

  3998. 	mov.b		%d0,STAG(%a6)
    3999. 

  3999. 	mov.b		%d0,%d1
    4000. 

  4000. 

  4001. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4002. 

  4002. 

  4003. 	clr.l		%d0
    4004. 

  4004. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4005. 

  4005. 

  4006. 	mov.b		%d1,STAG(%a6)
    4007. 

  4007. 	tst.b		%d1
    4008. 

  4008. 	bne.b		_L19_2d
    4009. 

  4009. 	bsr.l		sgetman			# operand is a NORM
    4010. 

  4010. 	bra.b		_L19_6d
    4011. 

  4011. _L19_2d:
    4012. 

  4012. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4013. 

  4013. 	bne.b		_L19_3d			# no
    4014. 

  4014. 	bsr.l		src_zero			# yes
    4015. 

  4015. 	bra.b		_L19_6d
    4016. 

  4016. _L19_3d:
    4017. 

  4017. 	cmpi.b		%d1,&INF		# is operand an INF?
    4018. 

  4018. 	bne.b		_L19_4d			# no
    4019. 

  4019. 	bsr.l		t_operr			# yes
    4020. 

  4020. 	bra.b		_L19_6d
    4021. 

  4021. _L19_4d:
    4022. 

  4022. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4023. 

  4023. 	bne.b		_L19_5d			# no
    4024. 

  4024. 	bsr.l		src_qnan			# yes
    4025. 

  4025. 	bra.b		_L19_6d
    4026. 

  4026. _L19_5d:
    4027. 

  4027. 	bsr.l		sgetmand			# operand is a DENORM
    4028. 

  4028. _L19_6d:
    4029. 

  4029. 

  4030. #
    4031. 

  4031. #	Result is now in FP0
    4032. 

  4032. #
    4033. 

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

  4034. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4035. 

  4035. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4036. 

  4036. 	unlk		%a6
    4037. 

  4037. 	rts
    4038. 

  4038. 

  4039. 	global		_fgetmanx_
    4040. 

  4040. _fgetmanx_:
    4041. 

  4041. 	link		%a6,&-LOCAL_SIZE
    4042. 

  4042. 

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

  4044. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4045. 

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

  4046. 

  4047. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4048. 

  4048. 

  4049. #
    4050. 

  4050. #	copy, convert, and tag input argument
    4051. 

  4051. #
    4052. 

  4052. 	lea		FP_SRC(%a6),%a0
    4053. 

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

  4054. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    4055. 

  4055. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    4056. 

  4056. 	bsr.l		tag			# fetch operand type
    4057. 

  4057. 	mov.b		%d0,STAG(%a6)
    4058. 

  4058. 	mov.b		%d0,%d1
    4059. 

  4059. 

  4060. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4061. 

  4061. 

  4062. 	clr.l		%d0
    4063. 

  4063. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4064. 

  4064. 

  4065. 	tst.b		%d1
    4066. 

  4066. 	bne.b		_L19_2x
    4067. 

  4067. 	bsr.l		sgetman			# operand is a NORM
    4068. 

  4068. 	bra.b		_L19_6x
    4069. 

  4069. _L19_2x:
    4070. 

  4070. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4071. 

  4071. 	bne.b		_L19_3x			# no
    4072. 

  4072. 	bsr.l		src_zero			# yes
    4073. 

  4073. 	bra.b		_L19_6x
    4074. 

  4074. _L19_3x:
    4075. 

  4075. 	cmpi.b		%d1,&INF		# is operand an INF?
    4076. 

  4076. 	bne.b		_L19_4x			# no
    4077. 

  4077. 	bsr.l		t_operr			# yes
    4078. 

  4078. 	bra.b		_L19_6x
    4079. 

  4079. _L19_4x:
    4080. 

  4080. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4081. 

  4081. 	bne.b		_L19_5x			# no
    4082. 

  4082. 	bsr.l		src_qnan			# yes
    4083. 

  4083. 	bra.b		_L19_6x
    4084. 

  4084. _L19_5x:
    4085. 

  4085. 	bsr.l		sgetmand			# operand is a DENORM
    4086. 

  4086. _L19_6x:
    4087. 

  4087. 

  4088. #
    4089. 

  4089. #	Result is now in FP0
    4090. 

  4090. #
    4091. 

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

  4092. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4093. 

  4093. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4094. 

  4094. 	unlk		%a6
    4095. 

  4095. 	rts
    4096. 

  4096. 

  4097. 

  4098. #########################################################################
    4099. 

  4099. # MONADIC TEMPLATE							#
    4100. 

  4100. #########################################################################
    4101. 

  4101. 	global		_fsincoss_
    4102. 

  4102. _fsincoss_:
    4103. 

  4103. 	link		%a6,&-LOCAL_SIZE
    4104. 

  4104. 

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

  4106. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4107. 

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

  4108. 

  4109. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4110. 

  4110. 

  4111. #
    4112. 

  4112. #	copy, convert, and tag input argument
    4113. 

  4113. #
    4114. 

  4114. 	fmov.s		0x8(%a6),%fp0		# load sgl input
    4115. 

  4115. 	fmov.x		%fp0,FP_SRC(%a6)
    4116. 

  4116. 	lea		FP_SRC(%a6),%a0
    4117. 

  4117. 	bsr.l		tag			# fetch operand type
    4118. 

  4118. 	mov.b		%d0,STAG(%a6)
    4119. 

  4119. 	mov.b		%d0,%d1
    4120. 

  4120. 

  4121. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4122. 

  4122. 

  4123. 	clr.l		%d0
    4124. 

  4124. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4125. 

  4125. 

  4126. 	tst.b		%d1
    4127. 

  4127. 	bne.b		_L20_2s
    4128. 

  4128. 	bsr.l		ssincos			# operand is a NORM
    4129. 

  4129. 	bra.b		_L20_6s
    4130. 

  4130. _L20_2s:
    4131. 

  4131. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4132. 

  4132. 	bne.b		_L20_3s			# no
    4133. 

  4133. 	bsr.l		ssincosz			# yes
    4134. 

  4134. 	bra.b		_L20_6s
    4135. 

  4135. _L20_3s:
    4136. 

  4136. 	cmpi.b		%d1,&INF		# is operand an INF?
    4137. 

  4137. 	bne.b		_L20_4s			# no
    4138. 

  4138. 	bsr.l		ssincosi			# yes
    4139. 

  4139. 	bra.b		_L20_6s
    4140. 

  4140. _L20_4s:
    4141. 

  4141. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4142. 

  4142. 	bne.b		_L20_5s			# no
    4143. 

  4143. 	bsr.l		ssincosqnan			# yes
    4144. 

  4144. 	bra.b		_L20_6s
    4145. 

  4145. _L20_5s:
    4146. 

  4146. 	bsr.l		ssincosd			# operand is a DENORM
    4147. 

  4147. _L20_6s:
    4148. 

  4148. 

  4149. #
    4150. 

  4150. #	Result is now in FP0
    4151. 

  4151. #
    4152. 

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

  4153. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4154. 

  4154. 	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
    4155. 

  4155. 	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
    4156. 

  4156. 	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
    4157. 

  4157. 	unlk		%a6
    4158. 

  4158. 	rts
    4159. 

  4159. 

  4160. 	global		_fsincosd_
    4161. 

  4161. _fsincosd_:
    4162. 

  4162. 	link		%a6,&-LOCAL_SIZE
    4163. 

  4163. 

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

  4165. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4166. 

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

  4167. 

  4168. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4169. 

  4169. 

  4170. #
    4171. 

  4171. #	copy, convert, and tag input argument
    4172. 

  4172. #
    4173. 

  4173. 	fmov.d		0x8(%a6),%fp0		# load dbl input
    4174. 

  4174. 	fmov.x		%fp0,FP_SRC(%a6)
    4175. 

  4175. 	lea		FP_SRC(%a6),%a0
    4176. 

  4176. 	bsr.l		tag			# fetch operand type
    4177. 

  4177. 	mov.b		%d0,STAG(%a6)
    4178. 

  4178. 	mov.b		%d0,%d1
    4179. 

  4179. 

  4180. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4181. 

  4181. 

  4182. 	clr.l		%d0
    4183. 

  4183. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4184. 

  4184. 

  4185. 	mov.b		%d1,STAG(%a6)
    4186. 

  4186. 	tst.b		%d1
    4187. 

  4187. 	bne.b		_L20_2d
    4188. 

  4188. 	bsr.l		ssincos			# operand is a NORM
    4189. 

  4189. 	bra.b		_L20_6d
    4190. 

  4190. _L20_2d:
    4191. 

  4191. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4192. 

  4192. 	bne.b		_L20_3d			# no
    4193. 

  4193. 	bsr.l		ssincosz			# yes
    4194. 

  4194. 	bra.b		_L20_6d
    4195. 

  4195. _L20_3d:
    4196. 

  4196. 	cmpi.b		%d1,&INF		# is operand an INF?
    4197. 

  4197. 	bne.b		_L20_4d			# no
    4198. 

  4198. 	bsr.l		ssincosi			# yes
    4199. 

  4199. 	bra.b		_L20_6d
    4200. 

  4200. _L20_4d:
    4201. 

  4201. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4202. 

  4202. 	bne.b		_L20_5d			# no
    4203. 

  4203. 	bsr.l		ssincosqnan			# yes
    4204. 

  4204. 	bra.b		_L20_6d
    4205. 

  4205. _L20_5d:
    4206. 

  4206. 	bsr.l		ssincosd			# operand is a DENORM
    4207. 

  4207. _L20_6d:
    4208. 

  4208. 

  4209. #
    4210. 

  4210. #	Result is now in FP0
    4211. 

  4211. #
    4212. 

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

  4213. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4214. 

  4214. 	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
    4215. 

  4215. 	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
    4216. 

  4216. 	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
    4217. 

  4217. 	unlk		%a6
    4218. 

  4218. 	rts
    4219. 

  4219. 

  4220. 	global		_fsincosx_
    4221. 

  4221. _fsincosx_:
    4222. 

  4222. 	link		%a6,&-LOCAL_SIZE
    4223. 

  4223. 

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

  4225. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4226. 

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

  4227. 

  4228. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4229. 

  4229. 

  4230. #
    4231. 

  4231. #	copy, convert, and tag input argument
    4232. 

  4232. #
    4233. 

  4233. 	lea		FP_SRC(%a6),%a0
    4234. 

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

  4235. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    4236. 

  4236. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    4237. 

  4237. 	bsr.l		tag			# fetch operand type
    4238. 

  4238. 	mov.b		%d0,STAG(%a6)
    4239. 

  4239. 	mov.b		%d0,%d1
    4240. 

  4240. 

  4241. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4242. 

  4242. 

  4243. 	clr.l		%d0
    4244. 

  4244. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4245. 

  4245. 

  4246. 	tst.b		%d1
    4247. 

  4247. 	bne.b		_L20_2x
    4248. 

  4248. 	bsr.l		ssincos			# operand is a NORM
    4249. 

  4249. 	bra.b		_L20_6x
    4250. 

  4250. _L20_2x:
    4251. 

  4251. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4252. 

  4252. 	bne.b		_L20_3x			# no
    4253. 

  4253. 	bsr.l		ssincosz			# yes
    4254. 

  4254. 	bra.b		_L20_6x
    4255. 

  4255. _L20_3x:
    4256. 

  4256. 	cmpi.b		%d1,&INF		# is operand an INF?
    4257. 

  4257. 	bne.b		_L20_4x			# no
    4258. 

  4258. 	bsr.l		ssincosi			# yes
    4259. 

  4259. 	bra.b		_L20_6x
    4260. 

  4260. _L20_4x:
    4261. 

  4261. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4262. 

  4262. 	bne.b		_L20_5x			# no
    4263. 

  4263. 	bsr.l		ssincosqnan			# yes
    4264. 

  4264. 	bra.b		_L20_6x
    4265. 

  4265. _L20_5x:
    4266. 

  4266. 	bsr.l		ssincosd			# operand is a DENORM
    4267. 

  4267. _L20_6x:
    4268. 

  4268. 

  4269. #
    4270. 

  4270. #	Result is now in FP0
    4271. 

  4271. #
    4272. 

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

  4273. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4274. 

  4274. 	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
    4275. 

  4275. 	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
    4276. 

  4276. 	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
    4277. 

  4277. 	unlk		%a6
    4278. 

  4278. 	rts
    4279. 

  4279. 

  4280. 

  4281. #########################################################################
    4282. 

  4282. # DYADIC TEMPLATE							#
    4283. 

  4283. #########################################################################
    4284. 

  4284. 	global		_frems_
    4285. 

  4285. _frems_:
    4286. 

  4286. 	link		%a6,&-LOCAL_SIZE
    4287. 

  4287. 

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

  4289. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4290. 

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

  4291. 

  4292. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4293. 

  4293. 

  4294. #
    4295. 

  4295. #	copy, convert, and tag input argument
    4296. 

  4296. #
    4297. 

  4297. 	fmov.s		0x8(%a6),%fp0		# load sgl dst
    4298. 

  4298. 	fmov.x		%fp0,FP_DST(%a6)
    4299. 

  4299. 	lea		FP_DST(%a6),%a0
    4300. 

  4300. 	bsr.l		tag			# fetch operand type
    4301. 

  4301. 	mov.b		%d0,DTAG(%a6)
    4302. 

  4302. 

  4303. 	fmov.s		0xc(%a6),%fp0		# load sgl src
    4304. 

  4304. 	fmov.x		%fp0,FP_SRC(%a6)
    4305. 

  4305. 	lea		FP_SRC(%a6),%a0
    4306. 

  4306. 	bsr.l		tag			# fetch operand type
    4307. 

  4307. 	mov.b		%d0,STAG(%a6)
    4308. 

  4308. 	mov.l		%d0,%d1
    4309. 

  4309. 

  4310. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4311. 

  4311. 

  4312. 	clr.l		%d0
    4313. 

  4313. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4314. 

  4314. 

  4315. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4316. 

  4316. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4317. 

  4317. 

  4318. 	tst.b		%d1
    4319. 

  4319. 	bne.b		_L21_2s
    4320. 

  4320. 	bsr.l		srem_snorm			# operand is a NORM
    4321. 

  4321. 	bra.b		_L21_6s
    4322. 

  4322. _L21_2s:
    4323. 

  4323. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4324. 

  4324. 	bne.b		_L21_3s			# no
    4325. 

  4325. 	bsr.l		srem_szero			# yes
    4326. 

  4326. 	bra.b		_L21_6s
    4327. 

  4327. _L21_3s:
    4328. 

  4328. 	cmpi.b		%d1,&INF		# is operand an INF?
    4329. 

  4329. 	bne.b		_L21_4s			# no
    4330. 

  4330. 	bsr.l		srem_sinf			# yes
    4331. 

  4331. 	bra.b		_L21_6s
    4332. 

  4332. _L21_4s:
    4333. 

  4333. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4334. 

  4334. 	bne.b		_L21_5s			# no
    4335. 

  4335. 	bsr.l		sop_sqnan			# yes
    4336. 

  4336. 	bra.b		_L21_6s
    4337. 

  4337. _L21_5s:
    4338. 

  4338. 	bsr.l		srem_sdnrm			# operand is a DENORM
    4339. 

  4339. _L21_6s:
    4340. 

  4340. 

  4341. #
    4342. 

  4342. #	Result is now in FP0
    4343. 

  4343. #
    4344. 

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

  4345. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4346. 

  4346. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4347. 

  4347. 	unlk		%a6
    4348. 

  4348. 	rts
    4349. 

  4349. 

  4350. 	global		_fremd_
    4351. 

  4351. _fremd_:
    4352. 

  4352. 	link		%a6,&-LOCAL_SIZE
    4353. 

  4353. 

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

  4355. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4356. 

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

  4357. 

  4358. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4359. 

  4359. 

  4360. #
    4361. 

  4361. #	copy, convert, and tag input argument
    4362. 

  4362. #
    4363. 

  4363. 	fmov.d		0x8(%a6),%fp0		# load dbl dst
    4364. 

  4364. 	fmov.x		%fp0,FP_DST(%a6)
    4365. 

  4365. 	lea		FP_DST(%a6),%a0
    4366. 

  4366. 	bsr.l		tag			# fetch operand type
    4367. 

  4367. 	mov.b		%d0,DTAG(%a6)
    4368. 

  4368. 

  4369. 	fmov.d		0x10(%a6),%fp0		# load dbl src
    4370. 

  4370. 	fmov.x		%fp0,FP_SRC(%a6)
    4371. 

  4371. 	lea		FP_SRC(%a6),%a0
    4372. 

  4372. 	bsr.l		tag			# fetch operand type
    4373. 

  4373. 	mov.b		%d0,STAG(%a6)
    4374. 

  4374. 	mov.l		%d0,%d1
    4375. 

  4375. 

  4376. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4377. 

  4377. 

  4378. 	clr.l		%d0
    4379. 

  4379. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4380. 

  4380. 

  4381. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4382. 

  4382. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4383. 

  4383. 

  4384. 	tst.b		%d1
    4385. 

  4385. 	bne.b		_L21_2d
    4386. 

  4386. 	bsr.l		srem_snorm			# operand is a NORM
    4387. 

  4387. 	bra.b		_L21_6d
    4388. 

  4388. _L21_2d:
    4389. 

  4389. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4390. 

  4390. 	bne.b		_L21_3d			# no
    4391. 

  4391. 	bsr.l		srem_szero			# yes
    4392. 

  4392. 	bra.b		_L21_6d
    4393. 

  4393. _L21_3d:
    4394. 

  4394. 	cmpi.b		%d1,&INF		# is operand an INF?
    4395. 

  4395. 	bne.b		_L21_4d			# no
    4396. 

  4396. 	bsr.l		srem_sinf			# yes
    4397. 

  4397. 	bra.b		_L21_6d
    4398. 

  4398. _L21_4d:
    4399. 

  4399. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4400. 

  4400. 	bne.b		_L21_5d			# no
    4401. 

  4401. 	bsr.l		sop_sqnan			# yes
    4402. 

  4402. 	bra.b		_L21_6d
    4403. 

  4403. _L21_5d:
    4404. 

  4404. 	bsr.l		srem_sdnrm			# operand is a DENORM
    4405. 

  4405. _L21_6d:
    4406. 

  4406. 

  4407. #
    4408. 

  4408. #	Result is now in FP0
    4409. 

  4409. #
    4410. 

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

  4411. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4412. 

  4412. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4413. 

  4413. 	unlk		%a6
    4414. 

  4414. 	rts
    4415. 

  4415. 

  4416. 	global		_fremx_
    4417. 

  4417. _fremx_:
    4418. 

  4418. 	link		%a6,&-LOCAL_SIZE
    4419. 

  4419. 

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

  4421. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4422. 

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

  4423. 

  4424. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4425. 

  4425. 

  4426. #
    4427. 

  4427. #	copy, convert, and tag input argument
    4428. 

  4428. #
    4429. 

  4429. 	lea		FP_DST(%a6),%a0
    4430. 

  4430. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
    4431. 

  4431. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    4432. 

  4432. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    4433. 

  4433. 	bsr.l		tag			# fetch operand type
    4434. 

  4434. 	mov.b		%d0,DTAG(%a6)
    4435. 

  4435. 

  4436. 	lea		FP_SRC(%a6),%a0
    4437. 

  4437. 	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
    4438. 

  4438. 	mov.l		0x14+0x4(%a6),0x4(%a0)
    4439. 

  4439. 	mov.l		0x14+0x8(%a6),0x8(%a0)
    4440. 

  4440. 	bsr.l		tag			# fetch operand type
    4441. 

  4441. 	mov.b		%d0,STAG(%a6)
    4442. 

  4442. 	mov.l		%d0,%d1
    4443. 

  4443. 

  4444. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4445. 

  4445. 

  4446. 	clr.l		%d0
    4447. 

  4447. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4448. 

  4448. 

  4449. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4450. 

  4450. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4451. 

  4451. 

  4452. 	tst.b		%d1
    4453. 

  4453. 	bne.b		_L21_2x
    4454. 

  4454. 	bsr.l		srem_snorm			# operand is a NORM
    4455. 

  4455. 	bra.b		_L21_6x
    4456. 

  4456. _L21_2x:
    4457. 

  4457. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4458. 

  4458. 	bne.b		_L21_3x			# no
    4459. 

  4459. 	bsr.l		srem_szero			# yes
    4460. 

  4460. 	bra.b		_L21_6x
    4461. 

  4461. _L21_3x:
    4462. 

  4462. 	cmpi.b		%d1,&INF		# is operand an INF?
    4463. 

  4463. 	bne.b		_L21_4x			# no
    4464. 

  4464. 	bsr.l		srem_sinf			# yes
    4465. 

  4465. 	bra.b		_L21_6x
    4466. 

  4466. _L21_4x:
    4467. 

  4467. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4468. 

  4468. 	bne.b		_L21_5x			# no
    4469. 

  4469. 	bsr.l		sop_sqnan			# yes
    4470. 

  4470. 	bra.b		_L21_6x
    4471. 

  4471. _L21_5x:
    4472. 

  4472. 	bsr.l		srem_sdnrm			# operand is a DENORM
    4473. 

  4473. _L21_6x:
    4474. 

  4474. 

  4475. #
    4476. 

  4476. #	Result is now in FP0
    4477. 

  4477. #
    4478. 

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

  4479. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4480. 

  4480. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4481. 

  4481. 	unlk		%a6
    4482. 

  4482. 	rts
    4483. 

  4483. 

  4484. 

  4485. #########################################################################
    4486. 

  4486. # DYADIC TEMPLATE							#
    4487. 

  4487. #########################################################################
    4488. 

  4488. 	global		_fmods_
    4489. 

  4489. _fmods_:
    4490. 

  4490. 	link		%a6,&-LOCAL_SIZE
    4491. 

  4491. 

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

  4493. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4494. 

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

  4495. 

  4496. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4497. 

  4497. 

  4498. #
    4499. 

  4499. #	copy, convert, and tag input argument
    4500. 

  4500. #
    4501. 

  4501. 	fmov.s		0x8(%a6),%fp0		# load sgl dst
    4502. 

  4502. 	fmov.x		%fp0,FP_DST(%a6)
    4503. 

  4503. 	lea		FP_DST(%a6),%a0
    4504. 

  4504. 	bsr.l		tag			# fetch operand type
    4505. 

  4505. 	mov.b		%d0,DTAG(%a6)
    4506. 

  4506. 

  4507. 	fmov.s		0xc(%a6),%fp0		# load sgl src
    4508. 

  4508. 	fmov.x		%fp0,FP_SRC(%a6)
    4509. 

  4509. 	lea		FP_SRC(%a6),%a0
    4510. 

  4510. 	bsr.l		tag			# fetch operand type
    4511. 

  4511. 	mov.b		%d0,STAG(%a6)
    4512. 

  4512. 	mov.l		%d0,%d1
    4513. 

  4513. 

  4514. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4515. 

  4515. 

  4516. 	clr.l		%d0
    4517. 

  4517. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4518. 

  4518. 

  4519. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4520. 

  4520. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4521. 

  4521. 

  4522. 	tst.b		%d1
    4523. 

  4523. 	bne.b		_L22_2s
    4524. 

  4524. 	bsr.l		smod_snorm			# operand is a NORM
    4525. 

  4525. 	bra.b		_L22_6s
    4526. 

  4526. _L22_2s:
    4527. 

  4527. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4528. 

  4528. 	bne.b		_L22_3s			# no
    4529. 

  4529. 	bsr.l		smod_szero			# yes
    4530. 

  4530. 	bra.b		_L22_6s
    4531. 

  4531. _L22_3s:
    4532. 

  4532. 	cmpi.b		%d1,&INF		# is operand an INF?
    4533. 

  4533. 	bne.b		_L22_4s			# no
    4534. 

  4534. 	bsr.l		smod_sinf			# yes
    4535. 

  4535. 	bra.b		_L22_6s
    4536. 

  4536. _L22_4s:
    4537. 

  4537. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4538. 

  4538. 	bne.b		_L22_5s			# no
    4539. 

  4539. 	bsr.l		sop_sqnan			# yes
    4540. 

  4540. 	bra.b		_L22_6s
    4541. 

  4541. _L22_5s:
    4542. 

  4542. 	bsr.l		smod_sdnrm			# operand is a DENORM
    4543. 

  4543. _L22_6s:
    4544. 

  4544. 

  4545. #
    4546. 

  4546. #	Result is now in FP0
    4547. 

  4547. #
    4548. 

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

  4549. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4550. 

  4550. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4551. 

  4551. 	unlk		%a6
    4552. 

  4552. 	rts
    4553. 

  4553. 

  4554. 	global		_fmodd_
    4555. 

  4555. _fmodd_:
    4556. 

  4556. 	link		%a6,&-LOCAL_SIZE
    4557. 

  4557. 

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

  4559. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4560. 

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

  4561. 

  4562. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4563. 

  4563. 

  4564. #
    4565. 

  4565. #	copy, convert, and tag input argument
    4566. 

  4566. #
    4567. 

  4567. 	fmov.d		0x8(%a6),%fp0		# load dbl dst
    4568. 

  4568. 	fmov.x		%fp0,FP_DST(%a6)
    4569. 

  4569. 	lea		FP_DST(%a6),%a0
    4570. 

  4570. 	bsr.l		tag			# fetch operand type
    4571. 

  4571. 	mov.b		%d0,DTAG(%a6)
    4572. 

  4572. 

  4573. 	fmov.d		0x10(%a6),%fp0		# load dbl src
    4574. 

  4574. 	fmov.x		%fp0,FP_SRC(%a6)
    4575. 

  4575. 	lea		FP_SRC(%a6),%a0
    4576. 

  4576. 	bsr.l		tag			# fetch operand type
    4577. 

  4577. 	mov.b		%d0,STAG(%a6)
    4578. 

  4578. 	mov.l		%d0,%d1
    4579. 

  4579. 

  4580. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4581. 

  4581. 

  4582. 	clr.l		%d0
    4583. 

  4583. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4584. 

  4584. 

  4585. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4586. 

  4586. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4587. 

  4587. 

  4588. 	tst.b		%d1
    4589. 

  4589. 	bne.b		_L22_2d
    4590. 

  4590. 	bsr.l		smod_snorm			# operand is a NORM
    4591. 

  4591. 	bra.b		_L22_6d
    4592. 

  4592. _L22_2d:
    4593. 

  4593. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4594. 

  4594. 	bne.b		_L22_3d			# no
    4595. 

  4595. 	bsr.l		smod_szero			# yes
    4596. 

  4596. 	bra.b		_L22_6d
    4597. 

  4597. _L22_3d:
    4598. 

  4598. 	cmpi.b		%d1,&INF		# is operand an INF?
    4599. 

  4599. 	bne.b		_L22_4d			# no
    4600. 

  4600. 	bsr.l		smod_sinf			# yes
    4601. 

  4601. 	bra.b		_L22_6d
    4602. 

  4602. _L22_4d:
    4603. 

  4603. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4604. 

  4604. 	bne.b		_L22_5d			# no
    4605. 

  4605. 	bsr.l		sop_sqnan			# yes
    4606. 

  4606. 	bra.b		_L22_6d
    4607. 

  4607. _L22_5d:
    4608. 

  4608. 	bsr.l		smod_sdnrm			# operand is a DENORM
    4609. 

  4609. _L22_6d:
    4610. 

  4610. 

  4611. #
    4612. 

  4612. #	Result is now in FP0
    4613. 

  4613. #
    4614. 

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

  4615. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4616. 

  4616. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4617. 

  4617. 	unlk		%a6
    4618. 

  4618. 	rts
    4619. 

  4619. 

  4620. 	global		_fmodx_
    4621. 

  4621. _fmodx_:
    4622. 

  4622. 	link		%a6,&-LOCAL_SIZE
    4623. 

  4623. 

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

  4625. 	fmovm.l