PageRenderTime 135ms CodeModel.GetById 26ms 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		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4626. 

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

  4627. 

  4628. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4629. 

  4629. 

  4630. #
    4631. 

  4631. #	copy, convert, and tag input argument
    4632. 

  4632. #
    4633. 

  4633. 	lea		FP_DST(%a6),%a0
    4634. 

  4634. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
    4635. 

  4635. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    4636. 

  4636. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    4637. 

  4637. 	bsr.l		tag			# fetch operand type
    4638. 

  4638. 	mov.b		%d0,DTAG(%a6)
    4639. 

  4639. 

  4640. 	lea		FP_SRC(%a6),%a0
    4641. 

  4641. 	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
    4642. 

  4642. 	mov.l		0x14+0x4(%a6),0x4(%a0)
    4643. 

  4643. 	mov.l		0x14+0x8(%a6),0x8(%a0)
    4644. 

  4644. 	bsr.l		tag			# fetch operand type
    4645. 

  4645. 	mov.b		%d0,STAG(%a6)
    4646. 

  4646. 	mov.l		%d0,%d1
    4647. 

  4647. 

  4648. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4649. 

  4649. 

  4650. 	clr.l		%d0
    4651. 

  4651. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4652. 

  4652. 

  4653. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4654. 

  4654. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4655. 

  4655. 

  4656. 	tst.b		%d1
    4657. 

  4657. 	bne.b		_L22_2x
    4658. 

  4658. 	bsr.l		smod_snorm			# operand is a NORM
    4659. 

  4659. 	bra.b		_L22_6x
    4660. 

  4660. _L22_2x:
    4661. 

  4661. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4662. 

  4662. 	bne.b		_L22_3x			# no
    4663. 

  4663. 	bsr.l		smod_szero			# yes
    4664. 

  4664. 	bra.b		_L22_6x
    4665. 

  4665. _L22_3x:
    4666. 

  4666. 	cmpi.b		%d1,&INF		# is operand an INF?
    4667. 

  4667. 	bne.b		_L22_4x			# no
    4668. 

  4668. 	bsr.l		smod_sinf			# yes
    4669. 

  4669. 	bra.b		_L22_6x
    4670. 

  4670. _L22_4x:
    4671. 

  4671. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4672. 

  4672. 	bne.b		_L22_5x			# no
    4673. 

  4673. 	bsr.l		sop_sqnan			# yes
    4674. 

  4674. 	bra.b		_L22_6x
    4675. 

  4675. _L22_5x:
    4676. 

  4676. 	bsr.l		smod_sdnrm			# operand is a DENORM
    4677. 

  4677. _L22_6x:
    4678. 

  4678. 

  4679. #
    4680. 

  4680. #	Result is now in FP0
    4681. 

  4681. #
    4682. 

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

  4683. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4684. 

  4684. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4685. 

  4685. 	unlk		%a6
    4686. 

  4686. 	rts
    4687. 

  4687. 

  4688. 

  4689. #########################################################################
    4690. 

  4690. # DYADIC TEMPLATE							#
    4691. 

  4691. #########################################################################
    4692. 

  4692. 	global		_fscales_
    4693. 

  4693. _fscales_:
    4694. 

  4694. 	link		%a6,&-LOCAL_SIZE
    4695. 

  4695. 

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

  4697. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4698. 

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

  4699. 

  4700. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4701. 

  4701. 

  4702. #
    4703. 

  4703. #	copy, convert, and tag input argument
    4704. 

  4704. #
    4705. 

  4705. 	fmov.s		0x8(%a6),%fp0		# load sgl dst
    4706. 

  4706. 	fmov.x		%fp0,FP_DST(%a6)
    4707. 

  4707. 	lea		FP_DST(%a6),%a0
    4708. 

  4708. 	bsr.l		tag			# fetch operand type
    4709. 

  4709. 	mov.b		%d0,DTAG(%a6)
    4710. 

  4710. 

  4711. 	fmov.s		0xc(%a6),%fp0		# load sgl src
    4712. 

  4712. 	fmov.x		%fp0,FP_SRC(%a6)
    4713. 

  4713. 	lea		FP_SRC(%a6),%a0
    4714. 

  4714. 	bsr.l		tag			# fetch operand type
    4715. 

  4715. 	mov.b		%d0,STAG(%a6)
    4716. 

  4716. 	mov.l		%d0,%d1
    4717. 

  4717. 

  4718. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4719. 

  4719. 

  4720. 	clr.l		%d0
    4721. 

  4721. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4722. 

  4722. 

  4723. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4724. 

  4724. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4725. 

  4725. 

  4726. 	tst.b		%d1
    4727. 

  4727. 	bne.b		_L23_2s
    4728. 

  4728. 	bsr.l		sscale_snorm			# operand is a NORM
    4729. 

  4729. 	bra.b		_L23_6s
    4730. 

  4730. _L23_2s:
    4731. 

  4731. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4732. 

  4732. 	bne.b		_L23_3s			# no
    4733. 

  4733. 	bsr.l		sscale_szero			# yes
    4734. 

  4734. 	bra.b		_L23_6s
    4735. 

  4735. _L23_3s:
    4736. 

  4736. 	cmpi.b		%d1,&INF		# is operand an INF?
    4737. 

  4737. 	bne.b		_L23_4s			# no
    4738. 

  4738. 	bsr.l		sscale_sinf			# yes
    4739. 

  4739. 	bra.b		_L23_6s
    4740. 

  4740. _L23_4s:
    4741. 

  4741. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4742. 

  4742. 	bne.b		_L23_5s			# no
    4743. 

  4743. 	bsr.l		sop_sqnan			# yes
    4744. 

  4744. 	bra.b		_L23_6s
    4745. 

  4745. _L23_5s:
    4746. 

  4746. 	bsr.l		sscale_sdnrm			# operand is a DENORM
    4747. 

  4747. _L23_6s:
    4748. 

  4748. 

  4749. #
    4750. 

  4750. #	Result is now in FP0
    4751. 

  4751. #
    4752. 

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

  4753. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4754. 

  4754. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4755. 

  4755. 	unlk		%a6
    4756. 

  4756. 	rts
    4757. 

  4757. 

  4758. 	global		_fscaled_
    4759. 

  4759. _fscaled_:
    4760. 

  4760. 	link		%a6,&-LOCAL_SIZE
    4761. 

  4761. 

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

  4763. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4764. 

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

  4765. 

  4766. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4767. 

  4767. 

  4768. #
    4769. 

  4769. #	copy, convert, and tag input argument
    4770. 

  4770. #
    4771. 

  4771. 	fmov.d		0x8(%a6),%fp0		# load dbl dst
    4772. 

  4772. 	fmov.x		%fp0,FP_DST(%a6)
    4773. 

  4773. 	lea		FP_DST(%a6),%a0
    4774. 

  4774. 	bsr.l		tag			# fetch operand type
    4775. 

  4775. 	mov.b		%d0,DTAG(%a6)
    4776. 

  4776. 

  4777. 	fmov.d		0x10(%a6),%fp0		# load dbl src
    4778. 

  4778. 	fmov.x		%fp0,FP_SRC(%a6)
    4779. 

  4779. 	lea		FP_SRC(%a6),%a0
    4780. 

  4780. 	bsr.l		tag			# fetch operand type
    4781. 

  4781. 	mov.b		%d0,STAG(%a6)
    4782. 

  4782. 	mov.l		%d0,%d1
    4783. 

  4783. 

  4784. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4785. 

  4785. 

  4786. 	clr.l		%d0
    4787. 

  4787. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4788. 

  4788. 

  4789. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4790. 

  4790. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4791. 

  4791. 

  4792. 	tst.b		%d1
    4793. 

  4793. 	bne.b		_L23_2d
    4794. 

  4794. 	bsr.l		sscale_snorm			# operand is a NORM
    4795. 

  4795. 	bra.b		_L23_6d
    4796. 

  4796. _L23_2d:
    4797. 

  4797. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4798. 

  4798. 	bne.b		_L23_3d			# no
    4799. 

  4799. 	bsr.l		sscale_szero			# yes
    4800. 

  4800. 	bra.b		_L23_6d
    4801. 

  4801. _L23_3d:
    4802. 

  4802. 	cmpi.b		%d1,&INF		# is operand an INF?
    4803. 

  4803. 	bne.b		_L23_4d			# no
    4804. 

  4804. 	bsr.l		sscale_sinf			# yes
    4805. 

  4805. 	bra.b		_L23_6d
    4806. 

  4806. _L23_4d:
    4807. 

  4807. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4808. 

  4808. 	bne.b		_L23_5d			# no
    4809. 

  4809. 	bsr.l		sop_sqnan			# yes
    4810. 

  4810. 	bra.b		_L23_6d
    4811. 

  4811. _L23_5d:
    4812. 

  4812. 	bsr.l		sscale_sdnrm			# operand is a DENORM
    4813. 

  4813. _L23_6d:
    4814. 

  4814. 

  4815. #
    4816. 

  4816. #	Result is now in FP0
    4817. 

  4817. #
    4818. 

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

  4819. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4820. 

  4820. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4821. 

  4821. 	unlk		%a6
    4822. 

  4822. 	rts
    4823. 

  4823. 

  4824. 	global		_fscalex_
    4825. 

  4825. _fscalex_:
    4826. 

  4826. 	link		%a6,&-LOCAL_SIZE
    4827. 

  4827. 

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

  4829. 	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
    4830. 

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

  4831. 

  4832. 	fmov.l		&0x0,%fpcr		# zero FPCR
    4833. 

  4833. 

  4834. #
    4835. 

  4835. #	copy, convert, and tag input argument
    4836. 

  4836. #
    4837. 

  4837. 	lea		FP_DST(%a6),%a0
    4838. 

  4838. 	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
    4839. 

  4839. 	mov.l		0x8+0x4(%a6),0x4(%a0)
    4840. 

  4840. 	mov.l		0x8+0x8(%a6),0x8(%a0)
    4841. 

  4841. 	bsr.l		tag			# fetch operand type
    4842. 

  4842. 	mov.b		%d0,DTAG(%a6)
    4843. 

  4843. 

  4844. 	lea		FP_SRC(%a6),%a0
    4845. 

  4845. 	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
    4846. 

  4846. 	mov.l		0x14+0x4(%a6),0x4(%a0)
    4847. 

  4847. 	mov.l		0x14+0x8(%a6),0x8(%a0)
    4848. 

  4848. 	bsr.l		tag			# fetch operand type
    4849. 

  4849. 	mov.b		%d0,STAG(%a6)
    4850. 

  4850. 	mov.l		%d0,%d1
    4851. 

  4851. 

  4852. 	andi.l		&0x00ff00ff,USER_FPSR(%a6)
    4853. 

  4853. 

  4854. 	clr.l		%d0
    4855. 

  4855. 	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
    4856. 

  4856. 

  4857. 	lea		FP_SRC(%a6),%a0		# pass ptr to src
    4858. 

  4858. 	lea		FP_DST(%a6),%a1		# pass ptr to dst
    4859. 

  4859. 

  4860. 	tst.b		%d1
    4861. 

  4861. 	bne.b		_L23_2x
    4862. 

  4862. 	bsr.l		sscale_snorm			# operand is a NORM
    4863. 

  4863. 	bra.b		_L23_6x
    4864. 

  4864. _L23_2x:
    4865. 

  4865. 	cmpi.b		%d1,&ZERO		# is operand a ZERO?
    4866. 

  4866. 	bne.b		_L23_3x			# no
    4867. 

  4867. 	bsr.l		sscale_szero			# yes
    4868. 

  4868. 	bra.b		_L23_6x
    4869. 

  4869. _L23_3x:
    4870. 

  4870. 	cmpi.b		%d1,&INF		# is operand an INF?
    4871. 

  4871. 	bne.b		_L23_4x			# no
    4872. 

  4872. 	bsr.l		sscale_sinf			# yes
    4873. 

  4873. 	bra.b		_L23_6x
    4874. 

  4874. _L23_4x:
    4875. 

  4875. 	cmpi.b		%d1,&QNAN		# is operand a QNAN?
    4876. 

  4876. 	bne.b		_L23_5x			# no
    4877. 

  4877. 	bsr.l		sop_sqnan			# yes
    4878. 

  4878. 	bra.b		_L23_6x
    4879. 

  4879. _L23_5x:
    4880. 

  4880. 	bsr.l		sscale_sdnrm			# operand is a DENORM
    4881. 

  4881. _L23_6x:
    4882. 

  4882. 

  4883. #
    4884. 

  4884. #	Result is now in FP0
    4885. 

  4885. #
    4886. 

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

  4887. 	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
    4888. 

  4888. 	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
    4889. 

  4889. 	unlk		%a6
    4890. 

  4890. 	rts
    4891. 

  4891. 

  4892. 

  4893. #########################################################################
    4894. 

  4894. # ssin():     computes the sine of a normalized input			#
    4895. 

  4895. # ssind():    computes the sine of a denormalized input			#
    4896. 

  4896. # scos():     computes the cosine of a normalized input			#
    4897. 

  4897. # scosd():    computes the cosine of a denormalized input		#
    4898. 

  4898. # ssincos():  computes the sine and cosine of a normalized input	#
    4899. 

  4899. # ssincosd(): computes the sine and cosine of a denormalized input	#
    4900. 

  4900. #									#
    4901. 

  4901. # INPUT *************************************************************** #
    4902. 

  4902. #	a0 = pointer to extended precision input			#
    4903. 

  4903. #	d0 = round precision,mode					#
    4904. 

  4904. #									#
    4905. 

  4905. # OUTPUT ************************************************************** #
    4906. 

  4906. #	fp0 = sin(X) or cos(X)						#
    4907. 

  4907. #									#
    4908. 

  4908. #    For ssincos(X):							#
    4909. 

  4909. #	fp0 = sin(X)							#
    4910. 

  4910. #	fp1 = cos(X)							#
    4911. 

  4911. #									#
    4912. 

  4912. # ACCURACY and MONOTONICITY ******************************************* #
    4913. 

  4913. #	The returned result is within 1 ulp in 64 significant bit, i.e.	#
    4914. 

  4914. #	within 0.5001 ulp to 53 bits if the result is subsequently	#
    4915. 

  4915. #	rounded to double precision. The result is provably monotonic	#
    4916. 

  4916. #	in double precision.						#
    4917. 

  4917. #									#
    4918. 

  4918. # ALGORITHM ***********************************************************	#
    4919. 

  4919. #									#
    4920. 

  4920. #	SIN and COS:							#
    4921. 

  4921. #	1. If SIN is invoked, set AdjN := 0; otherwise, set AdjN := 1.	#
    4922. 

  4922. #									#
    4923. 

  4923. #	2. If |X| >= 15Pi or |X| < 2**(-40), go to 7.			#
    4924. 

  4924. #									#
    4925. 

  4925. #	3. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
    4926. 

  4926. #		k = N mod 4, so in particular, k = 0,1,2,or 3.		#
    4927. 

  4927. #		Overwrite k by k := k + AdjN.				#
    4928. 

  4928. #									#
    4929. 

  4929. #	4. If k is even, go to 6.					#
    4930. 

  4930. #									#
    4931. 

  4931. #	5. (k is odd) Set j := (k-1)/2, sgn := (-1)**j.			#
    4932. 

  4932. #		Return sgn*cos(r) where cos(r) is approximated by an	#
    4933. 

  4933. #		even polynomial in r, 1 + r*r*(B1+s*(B2+ ... + s*B8)),	#
    4934. 

  4934. #		s = r*r.						#
    4935. 

  4935. #		Exit.							#
    4936. 

  4936. #									#
    4937. 

  4937. #	6. (k is even) Set j := k/2, sgn := (-1)**j. Return sgn*sin(r)	#
    4938. 

  4938. #		where sin(r) is approximated by an odd polynomial in r	#
    4939. 

  4939. #		r + r*s*(A1+s*(A2+ ... + s*A7)),	s = r*r.	#
    4940. 

  4940. #		Exit.							#
    4941. 

  4941. #									#
    4942. 

  4942. #	7. If |X| > 1, go to 9.						#
    4943. 

  4943. #									#
    4944. 

  4944. #	8. (|X|<2**(-40)) If SIN is invoked, return X;			#
    4945. 

  4945. #		otherwise return 1.					#
    4946. 

  4946. #									#
    4947. 

  4947. #	9. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,		#
    4948. 

  4948. #		go back to 3.						#
    4949. 

  4949. #									#
    4950. 

  4950. #	SINCOS:								#
    4951. 

  4951. #	1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.			#
    4952. 

  4952. #									#
    4953. 

  4953. #	2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
    4954. 

  4954. #		k = N mod 4, so in particular, k = 0,1,2,or 3.		#
    4955. 

  4955. #									#
    4956. 

  4956. #	3. If k is even, go to 5.					#
    4957. 

  4957. #									#
    4958. 

  4958. #	4. (k is odd) Set j1 := (k-1)/2, j2 := j1 (EOR) (k mod 2), ie.	#
    4959. 

  4959. #		j1 exclusive or with the l.s.b. of k.			#
    4960. 

  4960. #		sgn1 := (-1)**j1, sgn2 := (-1)**j2.			#
    4961. 

  4961. #		SIN(X) = sgn1 * cos(r) and COS(X) = sgn2*sin(r) where	#
    4962. 

  4962. #		sin(r) and cos(r) are computed as odd and even		#
    4963. 

  4963. #		polynomials in r, respectively. Exit			#
    4964. 

  4964. #									#
    4965. 

  4965. #	5. (k is even) Set j1 := k/2, sgn1 := (-1)**j1.			#
    4966. 

  4966. #		SIN(X) = sgn1 * sin(r) and COS(X) = sgn1*cos(r) where	#
    4967. 

  4967. #		sin(r) and cos(r) are computed as odd and even		#
    4968. 

  4968. #		polynomials in r, respectively. Exit			#
    4969. 

  4969. #									#
    4970. 

  4970. #	6. If |X| > 1, go to 8.						#
    4971. 

  4971. #									#
    4972. 

  4972. #	7. (|X|<2**(-40)) SIN(X) = X and COS(X) = 1. Exit.		#
    4973. 

  4973. #									#
    4974. 

  4974. #	8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,		#
    4975. 

  4975. #		go back to 2.						#
    4976. 

  4976. #									#
    4977. 

  4977. #########################################################################
    4978. 

  4978. 

  4979. SINA7:	long		0xBD6AAA77,0xCCC994F5
    4980. 

  4980. SINA6:	long		0x3DE61209,0x7AAE8DA1
    4981. 

  4981. SINA5:	long		0xBE5AE645,0x2A118AE4
    4982. 

  4982. SINA4:	long		0x3EC71DE3,0xA5341531
    4983. 

  4983. SINA3:	long		0xBF2A01A0,0x1A018B59,0x00000000,0x00000000
    4984. 

  4984. SINA2:	long		0x3FF80000,0x88888888,0x888859AF,0x00000000
    4985. 

  4985. SINA1:	long		0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000
    4986. 

  4986. 

  4987. COSB8:	long		0x3D2AC4D0,0xD6011EE3
    4988. 

  4988. COSB7:	long		0xBDA9396F,0x9F45AC19
    4989. 

  4989. COSB6:	long		0x3E21EED9,0x0612C972
    4990. 

  4990. COSB5:	long		0xBE927E4F,0xB79D9FCF
    4991. 

  4991. COSB4:	long		0x3EFA01A0,0x1A01D423,0x00000000,0x00000000
    4992. 

  4992. COSB3:	long		0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000
    4993. 

  4993. COSB2:	long		0x3FFA0000,0xAAAAAAAA,0xAAAAAB5E
    4994. 

  4994. COSB1:	long		0xBF000000
    4995. 

  4995. 

  4996. 	set		INARG,FP_SCR0
    4997. 

  4997. 

  4998. 	set		X,FP_SCR0
    4999. 

  4999. #	set		XDCARE,X+2
    5000. 

  5000. 	set		XFRAC,X+4
    5001. 

  5001. 

  5002. 	set		RPRIME,FP_SCR0
    5003. 

  5003. 	set		SPRIME,FP_SCR1
    5004. 

  5004. 

  5005. 	set		POSNEG1,L_SCR1
    5006. 

  5006. 	set		TWOTO63,L_SCR1
    5007. 

  5007. 

  5008. 	set		ENDFLAG,L_SCR2
    5009. 

  5009. 	set		INT,L_SCR2
    5010. 

  5010. 

  5011. 	set		ADJN,L_SCR3
    5012. 

  5012. 

  5013. ############################################
    5014. 

  5014. 	global		ssin
    5015. 

  5015. ssin:
    5016. 

  5016. 	mov.l		&0,ADJN(%a6)		# yes; SET ADJN TO 0
    5017. 

  5017. 	bra.b		SINBGN
    5018. 

  5018. 

  5019. ############################################
    5020. 

  5020. 	global		scos
    5021. 

  5021. scos:
    5022. 

  5022. 	mov.l		&1,ADJN(%a6)		# yes; SET ADJN TO 1
    5023. 

  5023. 

  5024. ############################################
    5025. 

  5025. SINBGN:
    5026. 

  5026. #--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGE
    5027. 

  5027. 

  5028. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    5029. 

  5029. 	fmov.x		%fp0,X(%a6)		# save input at X
    5030. 

  5030. 

  5031. # "COMPACTIFY" X
    5032. 

  5032. 	mov.l		(%a0),%d1		# put exp in hi word
    5033. 

  5033. 	mov.w		4(%a0),%d1		# fetch hi(man)
    5034. 

  5034. 	and.l		&0x7FFFFFFF,%d1		# strip sign
    5035. 

  5035. 

  5036. 	cmpi.l		%d1,&0x3FD78000		# is |X| >= 2**(-40)?
    5037. 

  5037. 	bge.b		SOK1			# no
    5038. 

  5038. 	bra.w		SINSM			# yes; input is very small
    5039. 

  5039. 

  5040. SOK1:
    5041. 

  5041. 	cmp.l		%d1,&0x4004BC7E		# is |X| < 15 PI?
    5042. 

  5042. 	blt.b		SINMAIN			# no
    5043. 

  5043. 	bra.w		SREDUCEX		# yes; input is very large
    5044. 

  5044. 

  5045. #--THIS IS THE USUAL CASE, |X| <= 15 PI.
    5046. 

  5046. #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
    5047. 

  5047. SINMAIN:
    5048. 

  5048. 	fmov.x		%fp0,%fp1
    5049. 

  5049. 	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
    5050. 

  5050. 

  5051. 	lea		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
    5052. 

  5052. 

  5053. 	fmov.l		%fp1,INT(%a6)		# CONVERT TO INTEGER
    5054. 

  5054. 

  5055. 	mov.l		INT(%a6),%d1		# make a copy of N
    5056. 

  5056. 	asl.l		&4,%d1			# N *= 16
    5057. 

  5057. 	add.l		%d1,%a1			# tbl_addr = a1 + (N*16)
    5058. 

  5058. 

  5059. # A1 IS THE ADDRESS OF N*PIBY2
    5060. 

  5060. # ...WHICH IS IN TWO PIECES Y1 & Y2
    5061. 

  5061. 	fsub.x		(%a1)+,%fp0		# X-Y1
    5062. 

  5062. 	fsub.s		(%a1),%fp0		# fp0 = R = (X-Y1)-Y2
    5063. 

  5063. 

  5064. SINCONT:
    5065. 

  5065. #--continuation from REDUCEX
    5066. 

  5066. 

  5067. #--GET N+ADJN AND SEE IF SIN(R) OR COS(R) IS NEEDED
    5068. 

  5068. 	mov.l		INT(%a6),%d1
    5069. 

  5069. 	add.l		ADJN(%a6),%d1		# SEE IF D0 IS ODD OR EVEN
    5070. 

  5070. 	ror.l		&1,%d1			# D0 WAS ODD IFF D0 IS NEGATIVE
    5071. 

  5071. 	cmp.l		%d1,&0
    5072. 

  5072. 	blt.w		COSPOLY
    5073. 

  5073. 

  5074. #--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
    5075. 

  5075. #--THEN WE RETURN	SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY
    5076. 

  5076. #--R' + R'*S*(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE
    5077. 

  5077. #--R' = SGN*R, S=R*R. THIS CAN BE REWRITTEN AS
    5078. 

  5078. #--R' + R'*S*( [A1+T(A3+T(A5+TA7))] + [S(A2+T(A4+TA6))])
    5079. 

  5079. #--WHERE T=S*S.
    5080. 

  5080. #--NOTE THAT A3 THROUGH A7 ARE STORED IN DOUBLE PRECISION
    5081. 

  5081. #--WHILE A1 AND A2 ARE IN DOUBLE-EXTENDED FORMAT.
    5082. 

  5082. SINPOLY:
    5083. 

  5083. 	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
    5084. 

  5084. 

  5085. 	fmov.x		%fp0,X(%a6)		# X IS R
    5086. 

  5086. 	fmul.x		%fp0,%fp0		# FP0 IS S
    5087. 

  5087. 

  5088. 	fmov.d		SINA7(%pc),%fp3
    5089. 

  5089. 	fmov.d		SINA6(%pc),%fp2
    5090. 

  5090. 

  5091. 	fmov.x		%fp0,%fp1
    5092. 

  5092. 	fmul.x		%fp1,%fp1		# FP1 IS T
    5093. 

  5093. 

  5094. 	ror.l		&1,%d1
    5095. 

  5095. 	and.l		&0x80000000,%d1
    5096. 

  5096. # ...LEAST SIG. BIT OF D0 IN SIGN POSITION
    5097. 

  5097. 	eor.l		%d1,X(%a6)		# X IS NOW R'= SGN*R
    5098. 

    5099. 

  5099. 	fmul.x		%fp1,%fp3		# TA7
    5100. 

  5100. 	fmul.x		%fp1,%fp2		# TA6
    5101. 

  5101. 

  5102. 	fadd.d		SINA5(%pc),%fp3		# A5+TA7
    5103. 

  5103. 	fadd.d		SINA4(%pc),%fp2		# A4+TA6
    5104. 

  5104. 

  5105. 	fmul.x		%fp1,%fp3		# T(A5+TA7)
    5106. 

  5106. 	fmul.x		%fp1,%fp2		# T(A4+TA6)
    5107. 

  5107. 

  5108. 	fadd.d		SINA3(%pc),%fp3		# A3+T(A5+TA7)
    5109. 

  5109. 	fadd.x		SINA2(%pc),%fp2		# A2+T(A4+TA6)
    5110. 

  5110. 

  5111. 	fmul.x		%fp3,%fp1		# T(A3+T(A5+TA7))
    5112. 

  5112. 

  5113. 	fmul.x		%fp0,%fp2		# S(A2+T(A4+TA6))
    5114. 

  5114. 	fadd.x		SINA1(%pc),%fp1		# A1+T(A3+T(A5+TA7))
    5115. 

  5115. 	fmul.x		X(%a6),%fp0		# R'*S
    5116. 

    5117. 

  5117. 	fadd.x		%fp2,%fp1		# [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))]
    5118. 

  5118. 

  5119. 	fmul.x		%fp1,%fp0		# SIN(R')-R'
    5120. 

  5120. 

  5121. 	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
    5122. 

  5122. 

  5123. 	fmov.l		%d0,%fpcr		# restore users round mode,prec
    5124. 

  5124. 	fadd.x		X(%a6),%fp0		# last inst - possible exception set
    5125. 

  5125. 	bra		t_inx2
    5126. 

  5126. 

  5127. #--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
    5128. 

  5128. #--THEN WE RETURN	SGN*COS(R). SGN*COS(R) IS COMPUTED BY
    5129. 

  5129. #--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE
    5130. 

  5130. #--S=R*R AND S'=SGN*S. THIS CAN BE REWRITTEN AS
    5131. 

  5131. #--SGN + S'*([B1+T(B3+T(B5+TB7))] + [S(B2+T(B4+T(B6+TB8)))])
    5132. 

  5132. #--WHERE T=S*S.
    5133. 

  5133. #--NOTE THAT B4 THROUGH B8 ARE STORED IN DOUBLE PRECISION
    5134. 

  5134. #--WHILE B2 AND B3 ARE IN DOUBLE-EXTENDED FORMAT, B1 IS -1/2
    5135. 

  5135. #--AND IS THEREFORE STORED AS SINGLE PRECISION.
    5136. 

  5136. COSPOLY:
    5137. 

  5137. 	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
    5138. 

  5138. 

  5139. 	fmul.x		%fp0,%fp0		# FP0 IS S
    5140. 

  5140. 

  5141. 	fmov.d		COSB8(%pc),%fp2
    5142. 

  5142. 	fmov.d		COSB7(%pc),%fp3
    5143. 

  5143. 

  5144. 	fmov.x		%fp0,%fp1
    5145. 

  5145. 	fmul.x		%fp1,%fp1		# FP1 IS T
    5146. 

  5146. 

  5147. 	fmov.x		%fp0,X(%a6)		# X IS S
    5148. 

  5148. 	ror.l		&1,%d1
    5149. 

  5149. 	and.l		&0x80000000,%d1
    5150. 

  5150. # ...LEAST SIG. BIT OF D0 IN SIGN POSITION
    5151. 

  5151. 

  5152. 	fmul.x		%fp1,%fp2		# TB8
    5153. 

  5153. 

  5154. 	eor.l		%d1,X(%a6)		# X IS NOW S'= SGN*S
    5155. 

  5155. 	and.l		&0x80000000,%d1
    5156. 

  5156. 

  5157. 	fmul.x		%fp1,%fp3		# TB7
    5158. 

  5158. 

  5159. 	or.l		&0x3F800000,%d1		# D0 IS SGN IN SINGLE
    5160. 

  5160. 	mov.l		%d1,POSNEG1(%a6)
    5161. 

  5161. 

  5162. 	fadd.d		COSB6(%pc),%fp2		# B6+TB8
    5163. 

  5163. 	fadd.d		COSB5(%pc),%fp3		# B5+TB7
    5164. 

  5164. 

  5165. 	fmul.x		%fp1,%fp2		# T(B6+TB8)
    5166. 

  5166. 	fmul.x		%fp1,%fp3		# T(B5+TB7)
    5167. 

  5167. 

  5168. 	fadd.d		COSB4(%pc),%fp2		# B4+T(B6+TB8)
    5169. 

  5169. 	fadd.x		COSB3(%pc),%fp3		# B3+T(B5+TB7)
    5170. 

  5170. 

  5171. 	fmul.x		%fp1,%fp2		# T(B4+T(B6+TB8))
    5172. 

  5172. 	fmul.x		%fp3,%fp1		# T(B3+T(B5+TB7))
    5173. 

  5173. 

  5174. 	fadd.x		COSB2(%pc),%fp2		# B2+T(B4+T(B6+TB8))
    5175. 

  5175. 	fadd.s		COSB1(%pc),%fp1		# B1+T(B3+T(B5+TB7))
    5176. 

  5176. 

  5177. 	fmul.x		%fp2,%fp0		# S(B2+T(B4+T(B6+TB8)))
    5178. 

  5178. 

  5179. 	fadd.x		%fp1,%fp0
    5180. 

  5180. 

  5181. 	fmul.x		X(%a6),%fp0
    5182. 

  5182. 

  5183. 	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
    5184. 

  5184. 

  5185. 	fmov.l		%d0,%fpcr		# restore users round mode,prec
    5186. 

  5186. 	fadd.s		POSNEG1(%a6),%fp0	# last inst - possible exception set
    5187. 

  5187. 	bra		t_inx2
    5188. 

  5188. 

  5189. ##############################################
    5190. 

  5190. 

  5191. # SINe: Big OR Small?
    5192. 

  5192. #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
    5193. 

  5193. #--IF |X| < 2**(-40), RETURN X OR 1.
    5194. 

  5194. SINBORS:
    5195. 

  5195. 	cmp.l		%d1,&0x3FFF8000
    5196. 

  5196. 	bgt.l		SREDUCEX
    5197. 

  5197. 

  5198. SINSM:
    5199. 

  5199. 	mov.l		ADJN(%a6),%d1
    5200. 

  5200. 	cmp.l		%d1,&0
    5201. 

  5201. 	bgt.b		COSTINY
    5202. 

  5202. 

  5203. # here, the operation may underflow iff the precision is sgl or dbl.
    5204. 

  5204. # extended denorms are handled through another entry point.
    5205. 

  5205. SINTINY:
    5206. 

  5206. #	mov.w		&0x0000,XDCARE(%a6)	# JUST IN CASE
    5207. 

  5207. 

  5208. 	fmov.l		%d0,%fpcr		# restore users round mode,prec
    5209. 

  5209. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    5210. 

  5210. 	fmov.x		X(%a6),%fp0		# last inst - possible exception set
    5211. 

  5211. 	bra		t_catch
    5212. 

  5212. 

  5213. COSTINY:
    5214. 

  5214. 	fmov.s		&0x3F800000,%fp0	# fp0 = 1.0
    5215. 

  5215. 	fmov.l		%d0,%fpcr		# restore users round mode,prec
    5216. 

  5216. 	fadd.s		&0x80800000,%fp0	# last inst - possible exception set
    5217. 

  5217. 	bra		t_pinx2
    5218. 

  5218. 

  5219. ################################################
    5220. 

  5220. 	global		ssind
    5221. 

  5221. #--SIN(X) = X FOR DENORMALIZED X
    5222. 

  5222. ssind:
    5223. 

  5223. 	bra		t_extdnrm
    5224. 

  5224. 

  5225. ############################################
    5226. 

  5226. 	global		scosd
    5227. 

  5227. #--COS(X) = 1 FOR DENORMALIZED X
    5228. 

  5228. scosd:
    5229. 

  5229. 	fmov.s		&0x3F800000,%fp0	# fp0 = 1.0
    5230. 

  5230. 	bra		t_pinx2
    5231. 

  5231. 

  5232. ##################################################
    5233. 

  5233. 

  5234. 	global		ssincos
    5235. 

  5235. ssincos:
    5236. 

  5236. #--SET ADJN TO 4
    5237. 

  5237. 	mov.l		&4,ADJN(%a6)
    5238. 

  5238. 

  5239. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    5240. 

  5240. 	fmov.x		%fp0,X(%a6)
    5241. 

  5241. 

  5242. 	mov.l		(%a0),%d1
    5243. 

  5243. 	mov.w		4(%a0),%d1
    5244. 

  5244. 	and.l		&0x7FFFFFFF,%d1		# COMPACTIFY X
    5245. 

  5245. 

  5246. 	cmp.l		%d1,&0x3FD78000		# |X| >= 2**(-40)?
    5247. 

  5247. 	bge.b		SCOK1
    5248. 

  5248. 	bra.w		SCSM
    5249. 

  5249. 

  5250. SCOK1:
    5251. 

  5251. 	cmp.l		%d1,&0x4004BC7E		# |X| < 15 PI?
    5252. 

  5252. 	blt.b		SCMAIN
    5253. 

  5253. 	bra.w		SREDUCEX
    5254. 

  5254. 

  5255. 

  5256. #--THIS IS THE USUAL CASE, |X| <= 15 PI.
    5257. 

  5257. #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
    5258. 

  5258. SCMAIN:
    5259. 

  5259. 	fmov.x		%fp0,%fp1
    5260. 

  5260. 

  5261. 	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
    5262. 

  5262. 

  5263. 	lea		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
    5264. 

  5264. 

  5265. 	fmov.l		%fp1,INT(%a6)		# CONVERT TO INTEGER
    5266. 

  5266. 

  5267. 	mov.l		INT(%a6),%d1
    5268. 

  5268. 	asl.l		&4,%d1
    5269. 

  5269. 	add.l		%d1,%a1			# ADDRESS OF N*PIBY2, IN Y1, Y2
    5270. 

  5270. 

  5271. 	fsub.x		(%a1)+,%fp0		# X-Y1
    5272. 

  5272. 	fsub.s		(%a1),%fp0		# FP0 IS R = (X-Y1)-Y2
    5273. 

  5273. 

  5274. SCCONT:
    5275. 

  5275. #--continuation point from REDUCEX
    5276. 

  5276. 

  5277. 	mov.l		INT(%a6),%d1
    5278. 

  5278. 	ror.l		&1,%d1
    5279. 

  5279. 	cmp.l		%d1,&0			# D0 < 0 IFF N IS ODD
    5280. 

  5280. 	bge.w		NEVEN
    5281. 

  5281. 

  5282. SNODD:
    5283. 

  5283. #--REGISTERS SAVED SO FAR: D0, A0, FP2.
    5284. 

  5284. 	fmovm.x		&0x04,-(%sp)		# save fp2
    5285. 

  5285. 

  5286. 	fmov.x		%fp0,RPRIME(%a6)
    5287. 

  5287. 	fmul.x		%fp0,%fp0		# FP0 IS S = R*R
    5288. 

  5288. 	fmov.d		SINA7(%pc),%fp1		# A7
    5289. 

  5289. 	fmov.d		COSB8(%pc),%fp2		# B8
    5290. 

  5290. 	fmul.x		%fp0,%fp1		# SA7
    5291. 

  5291. 	fmul.x		%fp0,%fp2		# SB8
    5292. 

  5292. 

  5293. 	mov.l		%d2,-(%sp)
    5294. 

  5294. 	mov.l		%d1,%d2
    5295. 

  5295. 	ror.l		&1,%d2
    5296. 

  5296. 	and.l		&0x80000000,%d2
    5297. 

  5297. 	eor.l		%d1,%d2
    5298. 

  5298. 	and.l		&0x80000000,%d2
    5299. 

  5299. 

  5300. 	fadd.d		SINA6(%pc),%fp1		# A6+SA7
    5301. 

  5301. 	fadd.d		COSB7(%pc),%fp2		# B7+SB8
    5302. 

  5302. 

  5303. 	fmul.x		%fp0,%fp1		# S(A6+SA7)
    5304. 

  5304. 	eor.l		%d2,RPRIME(%a6)
    5305. 

  5305. 	mov.l		(%sp)+,%d2
    5306. 

  5306. 	fmul.x		%fp0,%fp2		# S(B7+SB8)
    5307. 

  5307. 	ror.l		&1,%d1
    5308. 

  5308. 	and.l		&0x80000000,%d1
    5309. 

  5309. 	mov.l		&0x3F800000,POSNEG1(%a6)
    5310. 

  5310. 	eor.l		%d1,POSNEG1(%a6)
    5311. 

  5311. 

  5312. 	fadd.d		SINA5(%pc),%fp1		# A5+S(A6+SA7)
    5313. 

  5313. 	fadd.d		COSB6(%pc),%fp2		# B6+S(B7+SB8)
    5314. 

  5314. 

  5315. 	fmul.x		%fp0,%fp1		# S(A5+S(A6+SA7))
    5316. 

  5316. 	fmul.x		%fp0,%fp2		# S(B6+S(B7+SB8))
    5317. 

  5317. 	fmov.x		%fp0,SPRIME(%a6)
    5318. 

  5318. 

  5319. 	fadd.d		SINA4(%pc),%fp1		# A4+S(A5+S(A6+SA7))
    5320. 

  5320. 	eor.l		%d1,SPRIME(%a6)
    5321. 

  5321. 	fadd.d		COSB5(%pc),%fp2		# B5+S(B6+S(B7+SB8))
    5322. 

  5322. 

  5323. 	fmul.x		%fp0,%fp1		# S(A4+...)
    5324. 

  5324. 	fmul.x		%fp0,%fp2		# S(B5+...)
    5325. 

  5325. 

  5326. 	fadd.d		SINA3(%pc),%fp1		# A3+S(A4+...)
    5327. 

  5327. 	fadd.d		COSB4(%pc),%fp2		# B4+S(B5+...)
    5328. 

  5328. 

  5329. 	fmul.x		%fp0,%fp1		# S(A3+...)
    5330. 

  5330. 	fmul.x		%fp0,%fp2		# S(B4+...)
    5331. 

  5331. 

  5332. 	fadd.x		SINA2(%pc),%fp1		# A2+S(A3+...)
    5333. 

  5333. 	fadd.x		COSB3(%pc),%fp2		# B3+S(B4+...)
    5334. 

  5334. 

  5335. 	fmul.x		%fp0,%fp1		# S(A2+...)
    5336. 

  5336. 	fmul.x		%fp0,%fp2		# S(B3+...)
    5337. 

  5337. 

  5338. 	fadd.x		SINA1(%pc),%fp1		# A1+S(A2+...)
    5339. 

  5339. 	fadd.x		COSB2(%pc),%fp2		# B2+S(B3+...)
    5340. 

  5340. 

  5341. 	fmul.x		%fp0,%fp1		# S(A1+...)
    5342. 

  5342. 	fmul.x		%fp2,%fp0		# S(B2+...)
    5343. 

  5343. 

  5344. 	fmul.x		RPRIME(%a6),%fp1	# R'S(A1+...)
    5345. 

  5345. 	fadd.s		COSB1(%pc),%fp0		# B1+S(B2...)
    5346. 

  5346. 	fmul.x		SPRIME(%a6),%fp0	# S'(B1+S(B2+...))
    5347. 

    5348. 

  5348. 	fmovm.x		(%sp)+,&0x20		# restore fp2
    5349. 

  5349. 

  5350. 	fmov.l		%d0,%fpcr
    5351. 

  5351. 	fadd.x		RPRIME(%a6),%fp1	# COS(X)
    5352. 

  5352. 	bsr		sto_cos			# store cosine result
    5353. 

  5353. 	fadd.s		POSNEG1(%a6),%fp0	# SIN(X)
    5354. 

  5354. 	bra		t_inx2
    5355. 

  5355. 

  5356. NEVEN:
    5357. 

  5357. #--REGISTERS SAVED SO FAR: FP2.
    5358. 

  5358. 	fmovm.x		&0x04,-(%sp)		# save fp2
    5359. 

  5359. 

  5360. 	fmov.x		%fp0,RPRIME(%a6)
    5361. 

  5361. 	fmul.x		%fp0,%fp0		# FP0 IS S = R*R
    5362. 

  5362. 

  5363. 	fmov.d		COSB8(%pc),%fp1		# B8
    5364. 

  5364. 	fmov.d		SINA7(%pc),%fp2		# A7
    5365. 

  5365. 

  5366. 	fmul.x		%fp0,%fp1		# SB8
    5367. 

  5367. 	fmov.x		%fp0,SPRIME(%a6)
    5368. 

  5368. 	fmul.x		%fp0,%fp2		# SA7
    5369. 

  5369. 

  5370. 	ror.l		&1,%d1
    5371. 

  5371. 	and.l		&0x80000000,%d1
    5372. 

  5372. 

  5373. 	fadd.d		COSB7(%pc),%fp1		# B7+SB8
    5374. 

  5374. 	fadd.d		SINA6(%pc),%fp2		# A6+SA7
    5375. 

  5375. 

  5376. 	eor.l		%d1,RPRIME(%a6)
    5377. 

  5377. 	eor.l		%d1,SPRIME(%a6)
    5378. 

  5378. 

  5379. 	fmul.x		%fp0,%fp1		# S(B7+SB8)
    5380. 

  5380. 

  5381. 	or.l		&0x3F800000,%d1
    5382. 

  5382. 	mov.l		%d1,POSNEG1(%a6)
    5383. 

  5383. 

  5384. 	fmul.x		%fp0,%fp2		# S(A6+SA7)
    5385. 

  5385. 

  5386. 	fadd.d		COSB6(%pc),%fp1		# B6+S(B7+SB8)
    5387. 

  5387. 	fadd.d		SINA5(%pc),%fp2		# A5+S(A6+SA7)
    5388. 

  5388. 

  5389. 	fmul.x		%fp0,%fp1		# S(B6+S(B7+SB8))
    5390. 

  5390. 	fmul.x		%fp0,%fp2		# S(A5+S(A6+SA7))
    5391. 

  5391. 

  5392. 	fadd.d		COSB5(%pc),%fp1		# B5+S(B6+S(B7+SB8))
    5393. 

  5393. 	fadd.d		SINA4(%pc),%fp2		# A4+S(A5+S(A6+SA7))
    5394. 

  5394. 

  5395. 	fmul.x		%fp0,%fp1		# S(B5+...)
    5396. 

  5396. 	fmul.x		%fp0,%fp2		# S(A4+...)
    5397. 

  5397. 

  5398. 	fadd.d		COSB4(%pc),%fp1		# B4+S(B5+...)
    5399. 

  5399. 	fadd.d		SINA3(%pc),%fp2		# A3+S(A4+...)
    5400. 

  5400. 

  5401. 	fmul.x		%fp0,%fp1		# S(B4+...)
    5402. 

  5402. 	fmul.x		%fp0,%fp2		# S(A3+...)
    5403. 

  5403. 

  5404. 	fadd.x		COSB3(%pc),%fp1		# B3+S(B4+...)
    5405. 

  5405. 	fadd.x		SINA2(%pc),%fp2		# A2+S(A3+...)
    5406. 

  5406. 

  5407. 	fmul.x		%fp0,%fp1		# S(B3+...)
    5408. 

  5408. 	fmul.x		%fp0,%fp2		# S(A2+...)
    5409. 

  5409. 

  5410. 	fadd.x		COSB2(%pc),%fp1		# B2+S(B3+...)
    5411. 

  5411. 	fadd.x		SINA1(%pc),%fp2		# A1+S(A2+...)
    5412. 

  5412. 

  5413. 	fmul.x		%fp0,%fp1		# S(B2+...)
    5414. 

  5414. 	fmul.x		%fp2,%fp0		# s(a1+...)
    5415. 

  5415. 

  5416. 

  5417. 	fadd.s		COSB1(%pc),%fp1		# B1+S(B2...)
    5418. 

  5418. 	fmul.x		RPRIME(%a6),%fp0	# R'S(A1+...)
    5419. 

  5419. 	fmul.x		SPRIME(%a6),%fp1	# S'(B1+S(B2+...))
    5420. 

    5421. 

  5421. 	fmovm.x		(%sp)+,&0x20		# restore fp2
    5422. 

  5422. 

  5423. 	fmov.l		%d0,%fpcr
    5424. 

  5424. 	fadd.s		POSNEG1(%a6),%fp1	# COS(X)
    5425. 

  5425. 	bsr		sto_cos			# store cosine result
    5426. 

  5426. 	fadd.x		RPRIME(%a6),%fp0	# SIN(X)
    5427. 

  5427. 	bra		t_inx2
    5428. 

  5428. 

  5429. ################################################
    5430. 

  5430. 

  5431. SCBORS:
    5432. 

  5432. 	cmp.l		%d1,&0x3FFF8000
    5433. 

  5433. 	bgt.w		SREDUCEX
    5434. 

  5434. 

  5435. ################################################
    5436. 

  5436. 

  5437. SCSM:
    5438. 

  5438. #	mov.w		&0x0000,XDCARE(%a6)
    5439. 

  5439. 	fmov.s		&0x3F800000,%fp1
    5440. 

  5440. 

  5441. 	fmov.l		%d0,%fpcr
    5442. 

  5442. 	fsub.s		&0x00800000,%fp1
    5443. 

  5443. 	bsr		sto_cos			# store cosine result
    5444. 

  5444. 	fmov.l		%fpcr,%d0		# d0 must have fpcr,too
    5445. 

  5445. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    5446. 

  5446. 	fmov.x		X(%a6),%fp0
    5447. 

  5447. 	bra		t_catch
    5448. 

  5448. 

  5449. ##############################################
    5450. 

  5450. 

  5451. 	global		ssincosd
    5452. 

  5452. #--SIN AND COS OF X FOR DENORMALIZED X
    5453. 

  5453. ssincosd:
    5454. 

  5454. 	mov.l		%d0,-(%sp)		# save d0
    5455. 

  5455. 	fmov.s		&0x3F800000,%fp1
    5456. 

  5456. 	bsr		sto_cos			# store cosine result
    5457. 

  5457. 	mov.l		(%sp)+,%d0		# restore d0
    5458. 

  5458. 	bra		t_extdnrm
    5459. 

  5459. 

  5460. ############################################
    5461. 

  5461. 

  5462. #--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
    5463. 

  5463. #--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
    5464. 

  5464. #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
    5465. 

  5465. SREDUCEX:
    5466. 

  5466. 	fmovm.x		&0x3c,-(%sp)		# save {fp2-fp5}
    5467. 

  5467. 	mov.l		%d2,-(%sp)		# save d2
    5468. 

  5468. 	fmov.s		&0x00000000,%fp1	# fp1 = 0
    5469. 

  5469. 

  5470. #--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
    5471. 

  5471. #--there is a danger of unwanted overflow in first LOOP iteration.  In this
    5472. 

  5472. #--case, reduce argument by one remainder step to make subsequent reduction
    5473. 

  5473. #--safe.
    5474. 

  5474. 	cmp.l		%d1,&0x7ffeffff		# is arg dangerously large?
    5475. 

  5475. 	bne.b		SLOOP			# no
    5476. 

  5476. 

  5477. # yes; create 2**16383*PI/2
    5478. 

  5478. 	mov.w		&0x7ffe,FP_SCR0_EX(%a6)
    5479. 

  5479. 	mov.l		&0xc90fdaa2,FP_SCR0_HI(%a6)
    5480. 

  5480. 	clr.l		FP_SCR0_LO(%a6)
    5481. 

  5481. 

  5482. # create low half of 2**16383*PI/2 at FP_SCR1
    5483. 

  5483. 	mov.w		&0x7fdc,FP_SCR1_EX(%a6)
    5484. 

  5484. 	mov.l		&0x85a308d3,FP_SCR1_HI(%a6)
    5485. 

  5485. 	clr.l		FP_SCR1_LO(%a6)
    5486. 

  5486. 

  5487. 	ftest.x		%fp0			# test sign of argument
    5488. 

  5488. 	fblt.w		sred_neg
    5489. 

  5489. 

  5490. 	or.b		&0x80,FP_SCR0_EX(%a6)	# positive arg
    5491. 

  5491. 	or.b		&0x80,FP_SCR1_EX(%a6)
    5492. 

  5492. sred_neg:
    5493. 

  5493. 	fadd.x		FP_SCR0(%a6),%fp0	# high part of reduction is exact
    5494. 

  5494. 	fmov.x		%fp0,%fp1		# save high result in fp1
    5495. 

  5495. 	fadd.x		FP_SCR1(%a6),%fp0	# low part of reduction
    5496. 

  5496. 	fsub.x		%fp0,%fp1		# determine low component of result
    5497. 

  5497. 	fadd.x		FP_SCR1(%a6),%fp1	# fp0/fp1 are reduced argument.
    5498. 

  5498. 

  5499. #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
    5500. 

  5500. #--integer quotient will be stored in N
    5501. 

  5501. #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
    5502. 

  5502. SLOOP:
    5503. 

  5503. 	fmov.x		%fp0,INARG(%a6)		# +-2**K * F, 1 <= F < 2
    5504. 

  5504. 	mov.w		INARG(%a6),%d1
    5505. 

  5505. 	mov.l		%d1,%a1			# save a copy of D0
    5506. 

  5506. 	and.l		&0x00007FFF,%d1
    5507. 

  5507. 	sub.l		&0x00003FFF,%d1		# d0 = K
    5508. 

  5508. 	cmp.l		%d1,&28
    5509. 

  5509. 	ble.b		SLASTLOOP
    5510. 

  5510. SCONTLOOP:
    5511. 

  5511. 	sub.l		&27,%d1			# d0 = L := K-27
    5512. 

  5512. 	mov.b		&0,ENDFLAG(%a6)
    5513. 

  5513. 	bra.b		SWORK
    5514. 

  5514. SLASTLOOP:
    5515. 

  5515. 	clr.l		%d1			# d0 = L := 0
    5516. 

  5516. 	mov.b		&1,ENDFLAG(%a6)
    5517. 

  5517. 

  5518. SWORK:
    5519. 

  5519. #--FIND THE REMAINDER OF (R,r) W.R.T.	2**L * (PI/2). L IS SO CHOSEN
    5520. 

  5520. #--THAT	INT( X * (2/PI) / 2**(L) ) < 2**29.
    5521. 

  5521. 

  5522. #--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
    5523. 

  5523. #--2**L * (PIby2_1), 2**L * (PIby2_2)
    5524. 

  5524. 

  5525. 	mov.l		&0x00003FFE,%d2		# BIASED EXP OF 2/PI
    5526. 

  5526. 	sub.l		%d1,%d2			# BIASED EXP OF 2**(-L)*(2/PI)
    5527. 

  5527. 

  5528. 	mov.l		&0xA2F9836E,FP_SCR0_HI(%a6)
    5529. 

  5529. 	mov.l		&0x4E44152A,FP_SCR0_LO(%a6)
    5530. 

  5530. 	mov.w		%d2,FP_SCR0_EX(%a6)	# FP_SCR0 = 2**(-L)*(2/PI)
    5531. 

  5531. 

  5532. 	fmov.x		%fp0,%fp2
    5533. 

  5533. 	fmul.x		FP_SCR0(%a6),%fp2	# fp2 = X * 2**(-L)*(2/PI)
    5534. 

  5534. 

  5535. #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
    5536. 

  5536. #--FLOATING POINT FORMAT, THE TWO FMOVE'S	FMOVE.L FP <--> N
    5537. 

  5537. #--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
    5538. 

  5538. #--(SIGN(INARG)*2**63	+	FP2) - SIGN(INARG)*2**63 WILL GIVE
    5539. 

  5539. #--US THE DESIRED VALUE IN FLOATING POINT.
    5540. 

  5540. 	mov.l		%a1,%d2
    5541. 

  5541. 	swap		%d2
    5542. 

  5542. 	and.l		&0x80000000,%d2
    5543. 

  5543. 	or.l		&0x5F000000,%d2		# d2 = SIGN(INARG)*2**63 IN SGL
    5544. 

  5544. 	mov.l		%d2,TWOTO63(%a6)
    5545. 

  5545. 	fadd.s		TWOTO63(%a6),%fp2	# THE FRACTIONAL PART OF FP1 IS ROUNDED
    5546. 

  5546. 	fsub.s		TWOTO63(%a6),%fp2	# fp2 = N
    5547. 

  5547. #	fint.x		%fp2
    5548. 

  5548. 

  5549. #--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
    5550. 

  5550. 	mov.l		%d1,%d2			# d2 = L
    5551. 

  5551. 

  5552. 	add.l		&0x00003FFF,%d2		# BIASED EXP OF 2**L * (PI/2)
    5553. 

  5553. 	mov.w		%d2,FP_SCR0_EX(%a6)
    5554. 

  5554. 	mov.l		&0xC90FDAA2,FP_SCR0_HI(%a6)
    5555. 

  5555. 	clr.l		FP_SCR0_LO(%a6)		# FP_SCR0 = 2**(L) * Piby2_1
    5556. 

  5556. 

  5557. 	add.l		&0x00003FDD,%d1
    5558. 

  5558. 	mov.w		%d1,FP_SCR1_EX(%a6)
    5559. 

  5559. 	mov.l		&0x85A308D3,FP_SCR1_HI(%a6)
    5560. 

  5560. 	clr.l		FP_SCR1_LO(%a6)		# FP_SCR1 = 2**(L) * Piby2_2
    5561. 

  5561. 

  5562. 	mov.b		ENDFLAG(%a6),%d1
    5563. 

  5563. 

  5564. #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
    5565. 

  5565. #--P2 = 2**(L) * Piby2_2
    5566. 

  5566. 	fmov.x		%fp2,%fp4		# fp4 = N
    5567. 

  5567. 	fmul.x		FP_SCR0(%a6),%fp4	# fp4 = W = N*P1
    5568. 

  5568. 	fmov.x		%fp2,%fp5		# fp5 = N
    5569. 

  5569. 	fmul.x		FP_SCR1(%a6),%fp5	# fp5 = w = N*P2
    5570. 

  5570. 	fmov.x		%fp4,%fp3		# fp3 = W = N*P1
    5571. 

  5571. 

  5572. #--we want P+p = W+w  but  |p| <= half ulp of P
    5573. 

  5573. #--Then, we need to compute  A := R-P   and  a := r-p
    5574. 

  5574. 	fadd.x		%fp5,%fp3		# fp3 = P
    5575. 

  5575. 	fsub.x		%fp3,%fp4		# fp4 = W-P
    5576. 

  5576. 

  5577. 	fsub.x		%fp3,%fp0		# fp0 = A := R - P
    5578. 

  5578. 	fadd.x		%fp5,%fp4		# fp4 = p = (W-P)+w
    5579. 

  5579. 

  5580. 	fmov.x		%fp0,%fp3		# fp3 = A
    5581. 

  5581. 	fsub.x		%fp4,%fp1		# fp1 = a := r - p
    5582. 

  5582. 

  5583. #--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
    5584. 

  5584. #--|r| <= half ulp of R.
    5585. 

  5585. 	fadd.x		%fp1,%fp0		# fp0 = R := A+a
    5586. 

  5586. #--No need to calculate r if this is the last loop
    5587. 

  5587. 	cmp.b		%d1,&0
    5588. 

  5588. 	bgt.w		SRESTORE
    5589. 

  5589. 

  5590. #--Need to calculate r
    5591. 

  5591. 	fsub.x		%fp0,%fp3		# fp3 = A-R
    5592. 

  5592. 	fadd.x		%fp3,%fp1		# fp1 = r := (A-R)+a
    5593. 

  5593. 	bra.w		SLOOP
    5594. 

  5594. 

  5595. SRESTORE:
    5596. 

  5596. 	fmov.l		%fp2,INT(%a6)
    5597. 

  5597. 	mov.l		(%sp)+,%d2		# restore d2
    5598. 

  5598. 	fmovm.x		(%sp)+,&0x3c		# restore {fp2-fp5}
    5599. 

  5599. 

  5600. 	mov.l		ADJN(%a6),%d1
    5601. 

  5601. 	cmp.l		%d1,&4
    5602. 

  5602. 

  5603. 	blt.w		SINCONT
    5604. 

  5604. 	bra.w		SCCONT
    5605. 

  5605. 

  5606. #########################################################################
    5607. 

  5607. # stan():  computes the tangent of a normalized input			#
    5608. 

  5608. # stand(): computes the tangent of a denormalized input			#
    5609. 

  5609. #									#
    5610. 

  5610. # INPUT *************************************************************** #
    5611. 

  5611. #	a0 = pointer to extended precision input			#
    5612. 

  5612. #	d0 = round precision,mode					#
    5613. 

  5613. #									#
    5614. 

  5614. # OUTPUT ************************************************************** #
    5615. 

  5615. #	fp0 = tan(X)							#
    5616. 

  5616. #									#
    5617. 

  5617. # ACCURACY and MONOTONICITY ******************************************* #
    5618. 

  5618. #	The returned result is within 3 ulp in 64 significant bit, i.e. #
    5619. 

  5619. #	within 0.5001 ulp to 53 bits if the result is subsequently	#
    5620. 

  5620. #	rounded to double precision. The result is provably monotonic	#
    5621. 

  5621. #	in double precision.						#
    5622. 

  5622. #									#
    5623. 

  5623. # ALGORITHM *********************************************************** #
    5624. 

  5624. #									#
    5625. 

  5625. #	1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.			#
    5626. 

  5626. #									#
    5627. 

  5627. #	2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
    5628. 

  5628. #		k = N mod 2, so in particular, k = 0 or 1.		#
    5629. 

  5629. #									#
    5630. 

  5630. #	3. If k is odd, go to 5.					#
    5631. 

  5631. #									#
    5632. 

  5632. #	4. (k is even) Tan(X) = tan(r) and tan(r) is approximated by a	#
    5633. 

  5633. #		rational function U/V where				#
    5634. 

  5634. #		U = r + r*s*(P1 + s*(P2 + s*P3)), and			#
    5635. 

  5635. #		V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))),  s = r*r.	#
    5636. 

  5636. #		Exit.							#
    5637. 

  5637. #									#
    5638. 

  5638. #	4. (k is odd) Tan(X) = -cot(r). Since tan(r) is approximated by #
    5639. 

  5639. #		a rational function U/V where				#
    5640. 

  5640. #		U = r + r*s*(P1 + s*(P2 + s*P3)), and			#
    5641. 

  5641. #		V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r,	#
    5642. 

  5642. #		-Cot(r) = -V/U. Exit.					#
    5643. 

  5643. #									#
    5644. 

  5644. #	6. If |X| > 1, go to 8.						#
    5645. 

  5645. #									#
    5646. 

  5646. #	7. (|X|<2**(-40)) Tan(X) = X. Exit.				#
    5647. 

  5647. #									#
    5648. 

  5648. #	8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, go back	#
    5649. 

  5649. #		to 2.							#
    5650. 

  5650. #									#
    5651. 

  5651. #########################################################################
    5652. 

  5652. 

  5653. TANQ4:
    5654. 

  5654. 	long		0x3EA0B759,0xF50F8688
    5655. 

  5655. TANP3:
    5656. 

  5656. 	long		0xBEF2BAA5,0xA8924F04
    5657. 

  5657. 

  5658. TANQ3:
    5659. 

  5659. 	long		0xBF346F59,0xB39BA65F,0x00000000,0x00000000
    5660. 

  5660. 

  5661. TANP2:
    5662. 

  5662. 	long		0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000
    5663. 

  5663. 

  5664. TANQ2:
    5665. 

  5665. 	long		0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000
    5666. 

  5666. 

  5667. TANP1:
    5668. 

  5668. 	long		0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000
    5669. 

  5669. 

  5670. TANQ1:
    5671. 

  5671. 	long		0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000
    5672. 

  5672. 

  5673. INVTWOPI:
    5674. 

  5674. 	long		0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000
    5675. 

  5675. 

  5676. TWOPI1:
    5677. 

  5677. 	long		0x40010000,0xC90FDAA2,0x00000000,0x00000000
    5678. 

  5678. TWOPI2:
    5679. 

  5679. 	long		0x3FDF0000,0x85A308D4,0x00000000,0x00000000
    5680. 

  5680. 

  5681. #--N*PI/2, -32 <= N <= 32, IN A LEADING TERM IN EXT. AND TRAILING
    5682. 

  5682. #--TERM IN SGL. NOTE THAT PI IS 64-BIT LONG, THUS N*PI/2 IS AT
    5683. 

  5683. #--MOST 69 BITS LONG.
    5684. 

  5684. #	global		PITBL
    5685. 

  5685. PITBL:
    5686. 

  5686. 	long		0xC0040000,0xC90FDAA2,0x2168C235,0x21800000
    5687. 

  5687. 	long		0xC0040000,0xC2C75BCD,0x105D7C23,0xA0D00000
    5688. 

  5688. 	long		0xC0040000,0xBC7EDCF7,0xFF523611,0xA1E80000
    5689. 

  5689. 	long		0xC0040000,0xB6365E22,0xEE46F000,0x21480000
    5690. 

  5690. 	long		0xC0040000,0xAFEDDF4D,0xDD3BA9EE,0xA1200000
    5691. 

  5691. 	long		0xC0040000,0xA9A56078,0xCC3063DD,0x21FC0000
    5692. 

  5692. 	long		0xC0040000,0xA35CE1A3,0xBB251DCB,0x21100000
    5693. 

  5693. 	long		0xC0040000,0x9D1462CE,0xAA19D7B9,0xA1580000
    5694. 

  5694. 	long		0xC0040000,0x96CBE3F9,0x990E91A8,0x21E00000
    5695. 

  5695. 	long		0xC0040000,0x90836524,0x88034B96,0x20B00000
    5696. 

  5696. 	long		0xC0040000,0x8A3AE64F,0x76F80584,0xA1880000
    5697. 

  5697. 	long		0xC0040000,0x83F2677A,0x65ECBF73,0x21C40000
    5698. 

  5698. 	long		0xC0030000,0xFB53D14A,0xA9C2F2C2,0x20000000
    5699. 

  5699. 	long		0xC0030000,0xEEC2D3A0,0x87AC669F,0x21380000
    5700. 

  5700. 	long		0xC0030000,0xE231D5F6,0x6595DA7B,0xA1300000
    5701. 

  5701. 	long		0xC0030000,0xD5A0D84C,0x437F4E58,0x9FC00000
    5702. 

  5702. 	long		0xC0030000,0xC90FDAA2,0x2168C235,0x21000000
    5703. 

  5703. 	long		0xC0030000,0xBC7EDCF7,0xFF523611,0xA1680000
    5704. 

  5704. 	long		0xC0030000,0xAFEDDF4D,0xDD3BA9EE,0xA0A00000
    5705. 

  5705. 	long		0xC0030000,0xA35CE1A3,0xBB251DCB,0x20900000
    5706. 

  5706. 	long		0xC0030000,0x96CBE3F9,0x990E91A8,0x21600000
    5707. 

  5707. 	long		0xC0030000,0x8A3AE64F,0x76F80584,0xA1080000
    5708. 

  5708. 	long		0xC0020000,0xFB53D14A,0xA9C2F2C2,0x1F800000
    5709. 

  5709. 	long		0xC0020000,0xE231D5F6,0x6595DA7B,0xA0B00000
    5710. 

  5710. 	long		0xC0020000,0xC90FDAA2,0x2168C235,0x20800000
    5711. 

  5711. 	long		0xC0020000,0xAFEDDF4D,0xDD3BA9EE,0xA0200000
    5712. 

  5712. 	long		0xC0020000,0x96CBE3F9,0x990E91A8,0x20E00000
    5713. 

  5713. 	long		0xC0010000,0xFB53D14A,0xA9C2F2C2,0x1F000000
    5714. 

  5714. 	long		0xC0010000,0xC90FDAA2,0x2168C235,0x20000000
    5715. 

  5715. 	long		0xC0010000,0x96CBE3F9,0x990E91A8,0x20600000
    5716. 

  5716. 	long		0xC0000000,0xC90FDAA2,0x2168C235,0x1F800000
    5717. 

  5717. 	long		0xBFFF0000,0xC90FDAA2,0x2168C235,0x1F000000
    5718. 

  5718. 	long		0x00000000,0x00000000,0x00000000,0x00000000
    5719. 

  5719. 	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x9F000000
    5720. 

  5720. 	long		0x40000000,0xC90FDAA2,0x2168C235,0x9F800000
    5721. 

  5721. 	long		0x40010000,0x96CBE3F9,0x990E91A8,0xA0600000
    5722. 

  5722. 	long		0x40010000,0xC90FDAA2,0x2168C235,0xA0000000
    5723. 

  5723. 	long		0x40010000,0xFB53D14A,0xA9C2F2C2,0x9F000000
    5724. 

  5724. 	long		0x40020000,0x96CBE3F9,0x990E91A8,0xA0E00000
    5725. 

  5725. 	long		0x40020000,0xAFEDDF4D,0xDD3BA9EE,0x20200000
    5726. 

  5726. 	long		0x40020000,0xC90FDAA2,0x2168C235,0xA0800000
    5727. 

  5727. 	long		0x40020000,0xE231D5F6,0x6595DA7B,0x20B00000
    5728. 

  5728. 	long		0x40020000,0xFB53D14A,0xA9C2F2C2,0x9F800000
    5729. 

  5729. 	long		0x40030000,0x8A3AE64F,0x76F80584,0x21080000
    5730. 

  5730. 	long		0x40030000,0x96CBE3F9,0x990E91A8,0xA1600000
    5731. 

  5731. 	long		0x40030000,0xA35CE1A3,0xBB251DCB,0xA0900000
    5732. 

  5732. 	long		0x40030000,0xAFEDDF4D,0xDD3BA9EE,0x20A00000
    5733. 

  5733. 	long		0x40030000,0xBC7EDCF7,0xFF523611,0x21680000
    5734. 

  5734. 	long		0x40030000,0xC90FDAA2,0x2168C235,0xA1000000
    5735. 

  5735. 	long		0x40030000,0xD5A0D84C,0x437F4E58,0x1FC00000
    5736. 

  5736. 	long		0x40030000,0xE231D5F6,0x6595DA7B,0x21300000
    5737. 

  5737. 	long		0x40030000,0xEEC2D3A0,0x87AC669F,0xA1380000
    5738. 

  5738. 	long		0x40030000,0xFB53D14A,0xA9C2F2C2,0xA0000000
    5739. 

  5739. 	long		0x40040000,0x83F2677A,0x65ECBF73,0xA1C40000
    5740. 

  5740. 	long		0x40040000,0x8A3AE64F,0x76F80584,0x21880000
    5741. 

  5741. 	long		0x40040000,0x90836524,0x88034B96,0xA0B00000
    5742. 

  5742. 	long		0x40040000,0x96CBE3F9,0x990E91A8,0xA1E00000
    5743. 

  5743. 	long		0x40040000,0x9D1462CE,0xAA19D7B9,0x21580000
    5744. 

  5744. 	long		0x40040000,0xA35CE1A3,0xBB251DCB,0xA1100000
    5745. 

  5745. 	long		0x40040000,0xA9A56078,0xCC3063DD,0xA1FC0000
    5746. 

  5746. 	long		0x40040000,0xAFEDDF4D,0xDD3BA9EE,0x21200000
    5747. 

  5747. 	long		0x40040000,0xB6365E22,0xEE46F000,0xA1480000
    5748. 

  5748. 	long		0x40040000,0xBC7EDCF7,0xFF523611,0x21E80000
    5749. 

  5749. 	long		0x40040000,0xC2C75BCD,0x105D7C23,0x20D00000
    5750. 

  5750. 	long		0x40040000,0xC90FDAA2,0x2168C235,0xA1800000
    5751. 

  5751. 

  5752. 	set		INARG,FP_SCR0
    5753. 

  5753. 

  5754. 	set		TWOTO63,L_SCR1
    5755. 

  5755. 	set		INT,L_SCR1
    5756. 

  5756. 	set		ENDFLAG,L_SCR2
    5757. 

  5757. 

  5758. 	global		stan
    5759. 

  5759. stan:
    5760. 

  5760. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    5761. 

  5761. 

  5762. 	mov.l		(%a0),%d1
    5763. 

  5763. 	mov.w		4(%a0),%d1
    5764. 

  5764. 	and.l		&0x7FFFFFFF,%d1
    5765. 

  5765. 

  5766. 	cmp.l		%d1,&0x3FD78000		# |X| >= 2**(-40)?
    5767. 

  5767. 	bge.b		TANOK1
    5768. 

  5768. 	bra.w		TANSM
    5769. 

  5769. TANOK1:
    5770. 

  5770. 	cmp.l		%d1,&0x4004BC7E		# |X| < 15 PI?
    5771. 

  5771. 	blt.b		TANMAIN
    5772. 

  5772. 	bra.w		REDUCEX
    5773. 

  5773. 

  5774. TANMAIN:
    5775. 

  5775. #--THIS IS THE USUAL CASE, |X| <= 15 PI.
    5776. 

  5776. #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
    5777. 

  5777. 	fmov.x		%fp0,%fp1
    5778. 

  5778. 	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
    5779. 

  5779. 

  5780. 	lea.l		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
    5781. 

  5781. 

  5782. 	fmov.l		%fp1,%d1		# CONVERT TO INTEGER
    5783. 

  5783. 

  5784. 	asl.l		&4,%d1
    5785. 

  5785. 	add.l		%d1,%a1			# ADDRESS N*PIBY2 IN Y1, Y2
    5786. 

  5786. 

  5787. 	fsub.x		(%a1)+,%fp0		# X-Y1
    5788. 

  5788. 

  5789. 	fsub.s		(%a1),%fp0		# FP0 IS R = (X-Y1)-Y2
    5790. 

  5790. 

  5791. 	ror.l		&5,%d1
    5792. 

  5792. 	and.l		&0x80000000,%d1		# D0 WAS ODD IFF D0 < 0
    5793. 

  5793. 

  5794. TANCONT:
    5795. 

  5795. 	fmovm.x		&0x0c,-(%sp)		# save fp2,fp3
    5796. 

  5796. 

  5797. 	cmp.l		%d1,&0
    5798. 

  5798. 	blt.w		NODD
    5799. 

  5799. 

  5800. 	fmov.x		%fp0,%fp1
    5801. 

  5801. 	fmul.x		%fp1,%fp1		# S = R*R
    5802. 

  5802. 

  5803. 	fmov.d		TANQ4(%pc),%fp3
    5804. 

  5804. 	fmov.d		TANP3(%pc),%fp2
    5805. 

  5805. 

  5806. 	fmul.x		%fp1,%fp3		# SQ4
    5807. 

  5807. 	fmul.x		%fp1,%fp2		# SP3
    5808. 

  5808. 

  5809. 	fadd.d		TANQ3(%pc),%fp3		# Q3+SQ4
    5810. 

  5810. 	fadd.x		TANP2(%pc),%fp2		# P2+SP3
    5811. 

  5811. 

  5812. 	fmul.x		%fp1,%fp3		# S(Q3+SQ4)
    5813. 

  5813. 	fmul.x		%fp1,%fp2		# S(P2+SP3)
    5814. 

  5814. 

  5815. 	fadd.x		TANQ2(%pc),%fp3		# Q2+S(Q3+SQ4)
    5816. 

  5816. 	fadd.x		TANP1(%pc),%fp2		# P1+S(P2+SP3)
    5817. 

  5817. 

  5818. 	fmul.x		%fp1,%fp3		# S(Q2+S(Q3+SQ4))
    5819. 

  5819. 	fmul.x		%fp1,%fp2		# S(P1+S(P2+SP3))
    5820. 

  5820. 

  5821. 	fadd.x		TANQ1(%pc),%fp3		# Q1+S(Q2+S(Q3+SQ4))
    5822. 

  5822. 	fmul.x		%fp0,%fp2		# RS(P1+S(P2+SP3))
    5823. 

  5823. 

  5824. 	fmul.x		%fp3,%fp1		# S(Q1+S(Q2+S(Q3+SQ4)))
    5825. 

  5825. 

  5826. 	fadd.x		%fp2,%fp0		# R+RS(P1+S(P2+SP3))
    5827. 

  5827. 

  5828. 	fadd.s		&0x3F800000,%fp1	# 1+S(Q1+...)
    5829. 

  5829. 

  5830. 	fmovm.x		(%sp)+,&0x30		# restore fp2,fp3
    5831. 

  5831. 

  5832. 	fmov.l		%d0,%fpcr		# restore users round mode,prec
    5833. 

  5833. 	fdiv.x		%fp1,%fp0		# last inst - possible exception set
    5834. 

  5834. 	bra		t_inx2
    5835. 

  5835. 

  5836. NODD:
    5837. 

  5837. 	fmov.x		%fp0,%fp1
    5838. 

  5838. 	fmul.x		%fp0,%fp0		# S = R*R
    5839. 

  5839. 

  5840. 	fmov.d		TANQ4(%pc),%fp3
    5841. 

  5841. 	fmov.d		TANP3(%pc),%fp2
    5842. 

  5842. 

  5843. 	fmul.x		%fp0,%fp3		# SQ4
    5844. 

  5844. 	fmul.x		%fp0,%fp2		# SP3
    5845. 

  5845. 

  5846. 	fadd.d		TANQ3(%pc),%fp3		# Q3+SQ4
    5847. 

  5847. 	fadd.x		TANP2(%pc),%fp2		# P2+SP3
    5848. 

  5848. 

  5849. 	fmul.x		%fp0,%fp3		# S(Q3+SQ4)
    5850. 

  5850. 	fmul.x		%fp0,%fp2		# S(P2+SP3)
    5851. 

  5851. 

  5852. 	fadd.x		TANQ2(%pc),%fp3		# Q2+S(Q3+SQ4)
    5853. 

  5853. 	fadd.x		TANP1(%pc),%fp2		# P1+S(P2+SP3)
    5854. 

  5854. 

  5855. 	fmul.x		%fp0,%fp3		# S(Q2+S(Q3+SQ4))
    5856. 

  5856. 	fmul.x		%fp0,%fp2		# S(P1+S(P2+SP3))
    5857. 

  5857. 

  5858. 	fadd.x		TANQ1(%pc),%fp3		# Q1+S(Q2+S(Q3+SQ4))
    5859. 

  5859. 	fmul.x		%fp1,%fp2		# RS(P1+S(P2+SP3))
    5860. 

  5860. 

  5861. 	fmul.x		%fp3,%fp0		# S(Q1+S(Q2+S(Q3+SQ4)))
    5862. 

  5862. 

  5863. 	fadd.x		%fp2,%fp1		# R+RS(P1+S(P2+SP3))
    5864. 

  5864. 	fadd.s		&0x3F800000,%fp0	# 1+S(Q1+...)
    5865. 

  5865. 

  5866. 	fmovm.x		(%sp)+,&0x30		# restore fp2,fp3
    5867. 

  5867. 

  5868. 	fmov.x		%fp1,-(%sp)
    5869. 

  5869. 	eor.l		&0x80000000,(%sp)
    5870. 

  5870. 

  5871. 	fmov.l		%d0,%fpcr		# restore users round mode,prec
    5872. 

  5872. 	fdiv.x		(%sp)+,%fp0		# last inst - possible exception set
    5873. 

  5873. 	bra		t_inx2
    5874. 

  5874. 

  5875. TANBORS:
    5876. 

  5876. #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
    5877. 

  5877. #--IF |X| < 2**(-40), RETURN X OR 1.
    5878. 

  5878. 	cmp.l		%d1,&0x3FFF8000
    5879. 

  5879. 	bgt.b		REDUCEX
    5880. 

  5880. 

  5881. TANSM:
    5882. 

  5882. 	fmov.x		%fp0,-(%sp)
    5883. 

  5883. 	fmov.l		%d0,%fpcr		# restore users round mode,prec
    5884. 

  5884. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    5885. 

  5885. 	fmov.x		(%sp)+,%fp0		# last inst - posibble exception set
    5886. 

  5886. 	bra		t_catch
    5887. 

  5887. 

  5888. 	global		stand
    5889. 

  5889. #--TAN(X) = X FOR DENORMALIZED X
    5890. 

  5890. stand:
    5891. 

  5891. 	bra		t_extdnrm
    5892. 

  5892. 

  5893. #--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
    5894. 

  5894. #--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
    5895. 

  5895. #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
    5896. 

  5896. REDUCEX:
    5897. 

  5897. 	fmovm.x		&0x3c,-(%sp)		# save {fp2-fp5}
    5898. 

  5898. 	mov.l		%d2,-(%sp)		# save d2
    5899. 

  5899. 	fmov.s		&0x00000000,%fp1	# fp1 = 0
    5900. 

  5900. 

  5901. #--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
    5902. 

  5902. #--there is a danger of unwanted overflow in first LOOP iteration.  In this
    5903. 

  5903. #--case, reduce argument by one remainder step to make subsequent reduction
    5904. 

  5904. #--safe.
    5905. 

  5905. 	cmp.l		%d1,&0x7ffeffff		# is arg dangerously large?
    5906. 

  5906. 	bne.b		LOOP			# no
    5907. 

  5907. 

  5908. # yes; create 2**16383*PI/2
    5909. 

  5909. 	mov.w		&0x7ffe,FP_SCR0_EX(%a6)
    5910. 

  5910. 	mov.l		&0xc90fdaa2,FP_SCR0_HI(%a6)
    5911. 

  5911. 	clr.l		FP_SCR0_LO(%a6)
    5912. 

  5912. 

  5913. # create low half of 2**16383*PI/2 at FP_SCR1
    5914. 

  5914. 	mov.w		&0x7fdc,FP_SCR1_EX(%a6)
    5915. 

  5915. 	mov.l		&0x85a308d3,FP_SCR1_HI(%a6)
    5916. 

  5916. 	clr.l		FP_SCR1_LO(%a6)
    5917. 

  5917. 

  5918. 	ftest.x		%fp0			# test sign of argument
    5919. 

  5919. 	fblt.w		red_neg
    5920. 

  5920. 

  5921. 	or.b		&0x80,FP_SCR0_EX(%a6)	# positive arg
    5922. 

  5922. 	or.b		&0x80,FP_SCR1_EX(%a6)
    5923. 

  5923. red_neg:
    5924. 

  5924. 	fadd.x		FP_SCR0(%a6),%fp0	# high part of reduction is exact
    5925. 

  5925. 	fmov.x		%fp0,%fp1		# save high result in fp1
    5926. 

  5926. 	fadd.x		FP_SCR1(%a6),%fp0	# low part of reduction
    5927. 

  5927. 	fsub.x		%fp0,%fp1		# determine low component of result
    5928. 

  5928. 	fadd.x		FP_SCR1(%a6),%fp1	# fp0/fp1 are reduced argument.
    5929. 

  5929. 

  5930. #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
    5931. 

  5931. #--integer quotient will be stored in N
    5932. 

  5932. #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
    5933. 

  5933. LOOP:
    5934. 

  5934. 	fmov.x		%fp0,INARG(%a6)		# +-2**K * F, 1 <= F < 2
    5935. 

  5935. 	mov.w		INARG(%a6),%d1
    5936. 

  5936. 	mov.l		%d1,%a1			# save a copy of D0
    5937. 

  5937. 	and.l		&0x00007FFF,%d1
    5938. 

  5938. 	sub.l		&0x00003FFF,%d1		# d0 = K
    5939. 

  5939. 	cmp.l		%d1,&28
    5940. 

  5940. 	ble.b		LASTLOOP
    5941. 

  5941. CONTLOOP:
    5942. 

  5942. 	sub.l		&27,%d1			# d0 = L := K-27
    5943. 

  5943. 	mov.b		&0,ENDFLAG(%a6)
    5944. 

  5944. 	bra.b		WORK
    5945. 

  5945. LASTLOOP:
    5946. 

  5946. 	clr.l		%d1			# d0 = L := 0
    5947. 

  5947. 	mov.b		&1,ENDFLAG(%a6)
    5948. 

  5948. 

  5949. WORK:
    5950. 

  5950. #--FIND THE REMAINDER OF (R,r) W.R.T.	2**L * (PI/2). L IS SO CHOSEN
    5951. 

  5951. #--THAT	INT( X * (2/PI) / 2**(L) ) < 2**29.
    5952. 

  5952. 

  5953. #--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
    5954. 

  5954. #--2**L * (PIby2_1), 2**L * (PIby2_2)
    5955. 

  5955. 

  5956. 	mov.l		&0x00003FFE,%d2		# BIASED EXP OF 2/PI
    5957. 

  5957. 	sub.l		%d1,%d2			# BIASED EXP OF 2**(-L)*(2/PI)
    5958. 

  5958. 

  5959. 	mov.l		&0xA2F9836E,FP_SCR0_HI(%a6)
    5960. 

  5960. 	mov.l		&0x4E44152A,FP_SCR0_LO(%a6)
    5961. 

  5961. 	mov.w		%d2,FP_SCR0_EX(%a6)	# FP_SCR0 = 2**(-L)*(2/PI)
    5962. 

  5962. 

  5963. 	fmov.x		%fp0,%fp2
    5964. 

  5964. 	fmul.x		FP_SCR0(%a6),%fp2	# fp2 = X * 2**(-L)*(2/PI)
    5965. 

  5965. 

  5966. #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
    5967. 

  5967. #--FLOATING POINT FORMAT, THE TWO FMOVE'S	FMOVE.L FP <--> N
    5968. 

  5968. #--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
    5969. 

  5969. #--(SIGN(INARG)*2**63	+	FP2) - SIGN(INARG)*2**63 WILL GIVE
    5970. 

  5970. #--US THE DESIRED VALUE IN FLOATING POINT.
    5971. 

  5971. 	mov.l		%a1,%d2
    5972. 

  5972. 	swap		%d2
    5973. 

  5973. 	and.l		&0x80000000,%d2
    5974. 

  5974. 	or.l		&0x5F000000,%d2		# d2 = SIGN(INARG)*2**63 IN SGL
    5975. 

  5975. 	mov.l		%d2,TWOTO63(%a6)
    5976. 

  5976. 	fadd.s		TWOTO63(%a6),%fp2	# THE FRACTIONAL PART OF FP1 IS ROUNDED
    5977. 

  5977. 	fsub.s		TWOTO63(%a6),%fp2	# fp2 = N
    5978. 

  5978. #	fintrz.x	%fp2,%fp2
    5979. 

  5979. 

  5980. #--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
    5981. 

  5981. 	mov.l		%d1,%d2			# d2 = L
    5982. 

  5982. 

  5983. 	add.l		&0x00003FFF,%d2		# BIASED EXP OF 2**L * (PI/2)
    5984. 

  5984. 	mov.w		%d2,FP_SCR0_EX(%a6)
    5985. 

  5985. 	mov.l		&0xC90FDAA2,FP_SCR0_HI(%a6)
    5986. 

  5986. 	clr.l		FP_SCR0_LO(%a6)		# FP_SCR0 = 2**(L) * Piby2_1
    5987. 

  5987. 

  5988. 	add.l		&0x00003FDD,%d1
    5989. 

  5989. 	mov.w		%d1,FP_SCR1_EX(%a6)
    5990. 

  5990. 	mov.l		&0x85A308D3,FP_SCR1_HI(%a6)
    5991. 

  5991. 	clr.l		FP_SCR1_LO(%a6)		# FP_SCR1 = 2**(L) * Piby2_2
    5992. 

  5992. 

  5993. 	mov.b		ENDFLAG(%a6),%d1
    5994. 

  5994. 

  5995. #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
    5996. 

  5996. #--P2 = 2**(L) * Piby2_2
    5997. 

  5997. 	fmov.x		%fp2,%fp4		# fp4 = N
    5998. 

  5998. 	fmul.x		FP_SCR0(%a6),%fp4	# fp4 = W = N*P1
    5999. 

  5999. 	fmov.x		%fp2,%fp5		# fp5 = N
    6000. 

  6000. 	fmul.x		FP_SCR1(%a6),%fp5	# fp5 = w = N*P2
    6001. 

  6001. 	fmov.x		%fp4,%fp3		# fp3 = W = N*P1
    6002. 

  6002. 

  6003. #--we want P+p = W+w  but  |p| <= half ulp of P
    6004. 

  6004. #--Then, we need to compute  A := R-P   and  a := r-p
    6005. 

  6005. 	fadd.x		%fp5,%fp3		# fp3 = P
    6006. 

  6006. 	fsub.x		%fp3,%fp4		# fp4 = W-P
    6007. 

  6007. 

  6008. 	fsub.x		%fp3,%fp0		# fp0 = A := R - P
    6009. 

  6009. 	fadd.x		%fp5,%fp4		# fp4 = p = (W-P)+w
    6010. 

  6010. 

  6011. 	fmov.x		%fp0,%fp3		# fp3 = A
    6012. 

  6012. 	fsub.x		%fp4,%fp1		# fp1 = a := r - p
    6013. 

  6013. 

  6014. #--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
    6015. 

  6015. #--|r| <= half ulp of R.
    6016. 

  6016. 	fadd.x		%fp1,%fp0		# fp0 = R := A+a
    6017. 

  6017. #--No need to calculate r if this is the last loop
    6018. 

  6018. 	cmp.b		%d1,&0
    6019. 

  6019. 	bgt.w		RESTORE
    6020. 

  6020. 

  6021. #--Need to calculate r
    6022. 

  6022. 	fsub.x		%fp0,%fp3		# fp3 = A-R
    6023. 

  6023. 	fadd.x		%fp3,%fp1		# fp1 = r := (A-R)+a
    6024. 

  6024. 	bra.w		LOOP
    6025. 

  6025. 

  6026. RESTORE:
    6027. 

  6027. 	fmov.l		%fp2,INT(%a6)
    6028. 

  6028. 	mov.l		(%sp)+,%d2		# restore d2
    6029. 

  6029. 	fmovm.x		(%sp)+,&0x3c		# restore {fp2-fp5}
    6030. 

  6030. 

  6031. 	mov.l		INT(%a6),%d1
    6032. 

  6032. 	ror.l		&1,%d1
    6033. 

  6033. 

  6034. 	bra.w		TANCONT
    6035. 

  6035. 

  6036. #########################################################################
    6037. 

  6037. # satan():  computes the arctangent of a normalized number		#
    6038. 

  6038. # satand(): computes the arctangent of a denormalized number		#
    6039. 

  6039. #									#
    6040. 

  6040. # INPUT	*************************************************************** #
    6041. 

  6041. #	a0 = pointer to extended precision input			#
    6042. 

  6042. #	d0 = round precision,mode					#
    6043. 

  6043. #									#
    6044. 

  6044. # OUTPUT ************************************************************** #
    6045. 

  6045. #	fp0 = arctan(X)							#
    6046. 

  6046. #									#
    6047. 

  6047. # ACCURACY and MONOTONICITY ******************************************* #
    6048. 

  6048. #	The returned result is within 2 ulps in	64 significant bit,	#
    6049. 

  6049. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
    6050. 

  6050. #	rounded to double precision. The result is provably monotonic	#
    6051. 

  6051. #	in double precision.						#
    6052. 

  6052. #									#
    6053. 

  6053. # ALGORITHM *********************************************************** #
    6054. 

  6054. #	Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5.		#
    6055. 

  6055. #									#
    6056. 

  6056. #	Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x.			#
    6057. 

  6057. #		Note that k = -4, -3,..., or 3.				#
    6058. 

  6058. #		Define F = sgn * 2**k * 1.xxxx1, i.e. the first 5	#
    6059. 

  6059. #		significant bits of X with a bit-1 attached at the 6-th	#
    6060. 

  6060. #		bit position. Define u to be u = (X-F) / (1 + X*F).	#
    6061. 

  6061. #									#
    6062. 

  6062. #	Step 3. Approximate arctan(u) by a polynomial poly.		#
    6063. 

  6063. #									#
    6064. 

  6064. #	Step 4. Return arctan(F) + poly, arctan(F) is fetched from a	#
    6065. 

  6065. #		table of values calculated beforehand. Exit.		#
    6066. 

  6066. #									#
    6067. 

  6067. #	Step 5. If |X| >= 16, go to Step 7.				#
    6068. 

  6068. #									#
    6069. 

  6069. #	Step 6. Approximate arctan(X) by an odd polynomial in X. Exit.	#
    6070. 

  6070. #									#
    6071. 

  6071. #	Step 7. Define X' = -1/X. Approximate arctan(X') by an odd	#
    6072. 

  6072. #		polynomial in X'.					#
    6073. 

  6073. #		Arctan(X) = sign(X)*Pi/2 + arctan(X'). Exit.		#
    6074. 

  6074. #									#
    6075. 

  6075. #########################################################################
    6076. 

  6076. 

  6077. ATANA3:	long		0xBFF6687E,0x314987D8
    6078. 

  6078. ATANA2:	long		0x4002AC69,0x34A26DB3
    6079. 

  6079. ATANA1:	long		0xBFC2476F,0x4E1DA28E
    6080. 

  6080. 

  6081. ATANB6:	long		0x3FB34444,0x7F876989
    6082. 

  6082. ATANB5:	long		0xBFB744EE,0x7FAF45DB
    6083. 

  6083. ATANB4:	long		0x3FBC71C6,0x46940220
    6084. 

  6084. ATANB3:	long		0xBFC24924,0x921872F9
    6085. 

  6085. ATANB2:	long		0x3FC99999,0x99998FA9
    6086. 

  6086. ATANB1:	long		0xBFD55555,0x55555555
    6087. 

  6087. 

  6088. ATANC5:	long		0xBFB70BF3,0x98539E6A
    6089. 

  6089. ATANC4:	long		0x3FBC7187,0x962D1D7D
    6090. 

  6090. ATANC3:	long		0xBFC24924,0x827107B8
    6091. 

  6091. ATANC2:	long		0x3FC99999,0x9996263E
    6092. 

  6092. ATANC1:	long		0xBFD55555,0x55555536
    6093. 

  6093. 

  6094. PPIBY2:	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
    6095. 

  6095. NPIBY2:	long		0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000
    6096. 

  6096. 

  6097. PTINY:	long		0x00010000,0x80000000,0x00000000,0x00000000
    6098. 

  6098. NTINY:	long		0x80010000,0x80000000,0x00000000,0x00000000
    6099. 

  6099. 

  6100. ATANTBL:
    6101. 

  6101. 	long		0x3FFB0000,0x83D152C5,0x060B7A51,0x00000000
    6102. 

  6102. 	long		0x3FFB0000,0x8BC85445,0x65498B8B,0x00000000
    6103. 

  6103. 	long		0x3FFB0000,0x93BE4060,0x17626B0D,0x00000000
    6104. 

  6104. 	long		0x3FFB0000,0x9BB3078D,0x35AEC202,0x00000000
    6105. 

  6105. 	long		0x3FFB0000,0xA3A69A52,0x5DDCE7DE,0x00000000
    6106. 

  6106. 	long		0x3FFB0000,0xAB98E943,0x62765619,0x00000000
    6107. 

  6107. 	long		0x3FFB0000,0xB389E502,0xF9C59862,0x00000000
    6108. 

  6108. 	long		0x3FFB0000,0xBB797E43,0x6B09E6FB,0x00000000
    6109. 

  6109. 	long		0x3FFB0000,0xC367A5C7,0x39E5F446,0x00000000
    6110. 

  6110. 	long		0x3FFB0000,0xCB544C61,0xCFF7D5C6,0x00000000
    6111. 

  6111. 	long		0x3FFB0000,0xD33F62F8,0x2488533E,0x00000000
    6112. 

  6112. 	long		0x3FFB0000,0xDB28DA81,0x62404C77,0x00000000
    6113. 

  6113. 	long		0x3FFB0000,0xE310A407,0x8AD34F18,0x00000000
    6114. 

  6114. 	long		0x3FFB0000,0xEAF6B0A8,0x188EE1EB,0x00000000
    6115. 

  6115. 	long		0x3FFB0000,0xF2DAF194,0x9DBE79D5,0x00000000
    6116. 

  6116. 	long		0x3FFB0000,0xFABD5813,0x61D47E3E,0x00000000
    6117. 

  6117. 	long		0x3FFC0000,0x8346AC21,0x0959ECC4,0x00000000
    6118. 

  6118. 	long		0x3FFC0000,0x8B232A08,0x304282D8,0x00000000
    6119. 

  6119. 	long		0x3FFC0000,0x92FB70B8,0xD29AE2F9,0x00000000
    6120. 

  6120. 	long		0x3FFC0000,0x9ACF476F,0x5CCD1CB4,0x00000000
    6121. 

  6121. 	long		0x3FFC0000,0xA29E7630,0x4954F23F,0x00000000
    6122. 

  6122. 	long		0x3FFC0000,0xAA68C5D0,0x8AB85230,0x00000000
    6123. 

  6123. 	long		0x3FFC0000,0xB22DFFFD,0x9D539F83,0x00000000
    6124. 

  6124. 	long		0x3FFC0000,0xB9EDEF45,0x3E900EA5,0x00000000
    6125. 

  6125. 	long		0x3FFC0000,0xC1A85F1C,0xC75E3EA5,0x00000000
    6126. 

  6126. 	long		0x3FFC0000,0xC95D1BE8,0x28138DE6,0x00000000
    6127. 

  6127. 	long		0x3FFC0000,0xD10BF300,0x840D2DE4,0x00000000
    6128. 

  6128. 	long		0x3FFC0000,0xD8B4B2BA,0x6BC05E7A,0x00000000
    6129. 

  6129. 	long		0x3FFC0000,0xE0572A6B,0xB42335F6,0x00000000
    6130. 

  6130. 	long		0x3FFC0000,0xE7F32A70,0xEA9CAA8F,0x00000000
    6131. 

  6131. 	long		0x3FFC0000,0xEF888432,0x64ECEFAA,0x00000000
    6132. 

  6132. 	long		0x3FFC0000,0xF7170A28,0xECC06666,0x00000000
    6133. 

  6133. 	long		0x3FFD0000,0x812FD288,0x332DAD32,0x00000000
    6134. 

  6134. 	long		0x3FFD0000,0x88A8D1B1,0x218E4D64,0x00000000
    6135. 

  6135. 	long		0x3FFD0000,0x9012AB3F,0x23E4AEE8,0x00000000
    6136. 

  6136. 	long		0x3FFD0000,0x976CC3D4,0x11E7F1B9,0x00000000
    6137. 

  6137. 	long		0x3FFD0000,0x9EB68949,0x3889A227,0x00000000
    6138. 

  6138. 	long		0x3FFD0000,0xA5EF72C3,0x4487361B,0x00000000
    6139. 

  6139. 	long		0x3FFD0000,0xAD1700BA,0xF07A7227,0x00000000
    6140. 

  6140. 	long		0x3FFD0000,0xB42CBCFA,0xFD37EFB7,0x00000000
    6141. 

  6141. 	long		0x3FFD0000,0xBB303A94,0x0BA80F89,0x00000000
    6142. 

  6142. 	long		0x3FFD0000,0xC22115C6,0xFCAEBBAF,0x00000000
    6143. 

  6143. 	long		0x3FFD0000,0xC8FEF3E6,0x86331221,0x00000000
    6144. 

  6144. 	long		0x3FFD0000,0xCFC98330,0xB4000C70,0x00000000
    6145. 

  6145. 	long		0x3FFD0000,0xD6807AA1,0x102C5BF9,0x00000000
    6146. 

  6146. 	long		0x3FFD0000,0xDD2399BC,0x31252AA3,0x00000000
    6147. 

  6147. 	long		0x3FFD0000,0xE3B2A855,0x6B8FC517,0x00000000
    6148. 

  6148. 	long		0x3FFD0000,0xEA2D764F,0x64315989,0x00000000
    6149. 

  6149. 	long		0x3FFD0000,0xF3BF5BF8,0xBAD1A21D,0x00000000
    6150. 

  6150. 	long		0x3FFE0000,0x801CE39E,0x0D205C9A,0x00000000
    6151. 

  6151. 	long		0x3FFE0000,0x8630A2DA,0xDA1ED066,0x00000000
    6152. 

  6152. 	long		0x3FFE0000,0x8C1AD445,0xF3E09B8C,0x00000000
    6153. 

  6153. 	long		0x3FFE0000,0x91DB8F16,0x64F350E2,0x00000000
    6154. 

  6154. 	long		0x3FFE0000,0x97731420,0x365E538C,0x00000000
    6155. 

  6155. 	long		0x3FFE0000,0x9CE1C8E6,0xA0B8CDBA,0x00000000
    6156. 

  6156. 	long		0x3FFE0000,0xA22832DB,0xCADAAE09,0x00000000
    6157. 

  6157. 	long		0x3FFE0000,0xA746F2DD,0xB7602294,0x00000000
    6158. 

  6158. 	long		0x3FFE0000,0xAC3EC0FB,0x997DD6A2,0x00000000
    6159. 

  6159. 	long		0x3FFE0000,0xB110688A,0xEBDC6F6A,0x00000000
    6160. 

  6160. 	long		0x3FFE0000,0xB5BCC490,0x59ECC4B0,0x00000000
    6161. 

  6161. 	long		0x3FFE0000,0xBA44BC7D,0xD470782F,0x00000000
    6162. 

  6162. 	long		0x3FFE0000,0xBEA94144,0xFD049AAC,0x00000000
    6163. 

  6163. 	long		0x3FFE0000,0xC2EB4ABB,0x661628B6,0x00000000
    6164. 

  6164. 	long		0x3FFE0000,0xC70BD54C,0xE602EE14,0x00000000
    6165. 

  6165. 	long		0x3FFE0000,0xCD000549,0xADEC7159,0x00000000
    6166. 

  6166. 	long		0x3FFE0000,0xD48457D2,0xD8EA4EA3,0x00000000
    6167. 

  6167. 	long		0x3FFE0000,0xDB948DA7,0x12DECE3B,0x00000000
    6168. 

  6168. 	long		0x3FFE0000,0xE23855F9,0x69E8096A,0x00000000
    6169. 

  6169. 	long		0x3FFE0000,0xE8771129,0xC4353259,0x00000000
    6170. 

  6170. 	long		0x3FFE0000,0xEE57C16E,0x0D379C0D,0x00000000
    6171. 

  6171. 	long		0x3FFE0000,0xF3E10211,0xA87C3779,0x00000000
    6172. 

  6172. 	long		0x3FFE0000,0xF919039D,0x758B8D41,0x00000000
    6173. 

  6173. 	long		0x3FFE0000,0xFE058B8F,0x64935FB3,0x00000000
    6174. 

  6174. 	long		0x3FFF0000,0x8155FB49,0x7B685D04,0x00000000
    6175. 

  6175. 	long		0x3FFF0000,0x83889E35,0x49D108E1,0x00000000
    6176. 

  6176. 	long		0x3FFF0000,0x859CFA76,0x511D724B,0x00000000
    6177. 

  6177. 	long		0x3FFF0000,0x87952ECF,0xFF8131E7,0x00000000
    6178. 

  6178. 	long		0x3FFF0000,0x89732FD1,0x9557641B,0x00000000
    6179. 

  6179. 	long		0x3FFF0000,0x8B38CAD1,0x01932A35,0x00000000
    6180. 

  6180. 	long		0x3FFF0000,0x8CE7A8D8,0x301EE6B5,0x00000000
    6181. 

  6181. 	long		0x3FFF0000,0x8F46A39E,0x2EAE5281,0x00000000
    6182. 

  6182. 	long		0x3FFF0000,0x922DA7D7,0x91888487,0x00000000
    6183. 

  6183. 	long		0x3FFF0000,0x94D19FCB,0xDEDF5241,0x00000000
    6184. 

  6184. 	long		0x3FFF0000,0x973AB944,0x19D2A08B,0x00000000
    6185. 

  6185. 	long		0x3FFF0000,0x996FF00E,0x08E10B96,0x00000000
    6186. 

  6186. 	long		0x3FFF0000,0x9B773F95,0x12321DA7,0x00000000
    6187. 

  6187. 	long		0x3FFF0000,0x9D55CC32,0x0F935624,0x00000000
    6188. 

  6188. 	long		0x3FFF0000,0x9F100575,0x006CC571,0x00000000
    6189. 

  6189. 	long		0x3FFF0000,0xA0A9C290,0xD97CC06C,0x00000000
    6190. 

  6190. 	long		0x3FFF0000,0xA22659EB,0xEBC0630A,0x00000000
    6191. 

  6191. 	long		0x3FFF0000,0xA388B4AF,0xF6EF0EC9,0x00000000
    6192. 

  6192. 	long		0x3FFF0000,0xA4D35F10,0x61D292C4,0x00000000
    6193. 

  6193. 	long		0x3FFF0000,0xA60895DC,0xFBE3187E,0x00000000
    6194. 

  6194. 	long		0x3FFF0000,0xA72A51DC,0x7367BEAC,0x00000000
    6195. 

  6195. 	long		0x3FFF0000,0xA83A5153,0x0956168F,0x00000000
    6196. 

  6196. 	long		0x3FFF0000,0xA93A2007,0x7539546E,0x00000000
    6197. 

  6197. 	long		0x3FFF0000,0xAA9E7245,0x023B2605,0x00000000
    6198. 

  6198. 	long		0x3FFF0000,0xAC4C84BA,0x6FE4D58F,0x00000000
    6199. 

  6199. 	long		0x3FFF0000,0xADCE4A4A,0x606B9712,0x00000000
    6200. 

  6200. 	long		0x3FFF0000,0xAF2A2DCD,0x8D263C9C,0x00000000
    6201. 

  6201. 	long		0x3FFF0000,0xB0656F81,0xF22265C7,0x00000000
    6202. 

  6202. 	long		0x3FFF0000,0xB1846515,0x0F71496A,0x00000000
    6203. 

  6203. 	long		0x3FFF0000,0xB28AAA15,0x6F9ADA35,0x00000000
    6204. 

  6204. 	long		0x3FFF0000,0xB37B44FF,0x3766B895,0x00000000
    6205. 

  6205. 	long		0x3FFF0000,0xB458C3DC,0xE9630433,0x00000000
    6206. 

  6206. 	long		0x3FFF0000,0xB525529D,0x562246BD,0x00000000
    6207. 

  6207. 	long		0x3FFF0000,0xB5E2CCA9,0x5F9D88CC,0x00000000
    6208. 

  6208. 	long		0x3FFF0000,0xB692CADA,0x7ACA1ADA,0x00000000
    6209. 

  6209. 	long		0x3FFF0000,0xB736AEA7,0xA6925838,0x00000000
    6210. 

  6210. 	long		0x3FFF0000,0xB7CFAB28,0x7E9F7B36,0x00000000
    6211. 

  6211. 	long		0x3FFF0000,0xB85ECC66,0xCB219835,0x00000000
    6212. 

  6212. 	long		0x3FFF0000,0xB8E4FD5A,0x20A593DA,0x00000000
    6213. 

  6213. 	long		0x3FFF0000,0xB99F41F6,0x4AFF9BB5,0x00000000
    6214. 

  6214. 	long		0x3FFF0000,0xBA7F1E17,0x842BBE7B,0x00000000
    6215. 

  6215. 	long		0x3FFF0000,0xBB471285,0x7637E17D,0x00000000
    6216. 

  6216. 	long		0x3FFF0000,0xBBFABE8A,0x4788DF6F,0x00000000
    6217. 

  6217. 	long		0x3FFF0000,0xBC9D0FAD,0x2B689D79,0x00000000
    6218. 

  6218. 	long		0x3FFF0000,0xBD306A39,0x471ECD86,0x00000000
    6219. 

  6219. 	long		0x3FFF0000,0xBDB6C731,0x856AF18A,0x00000000
    6220. 

  6220. 	long		0x3FFF0000,0xBE31CAC5,0x02E80D70,0x00000000
    6221. 

  6221. 	long		0x3FFF0000,0xBEA2D55C,0xE33194E2,0x00000000
    6222. 

  6222. 	long		0x3FFF0000,0xBF0B10B7,0xC03128F0,0x00000000
    6223. 

  6223. 	long		0x3FFF0000,0xBF6B7A18,0xDACB778D,0x00000000
    6224. 

  6224. 	long		0x3FFF0000,0xBFC4EA46,0x63FA18F6,0x00000000
    6225. 

  6225. 	long		0x3FFF0000,0xC0181BDE,0x8B89A454,0x00000000
    6226. 

  6226. 	long		0x3FFF0000,0xC065B066,0xCFBF6439,0x00000000
    6227. 

  6227. 	long		0x3FFF0000,0xC0AE345F,0x56340AE6,0x00000000
    6228. 

  6228. 	long		0x3FFF0000,0xC0F22291,0x9CB9E6A7,0x00000000
    6229. 

  6229. 

  6230. 	set		X,FP_SCR0
    6231. 

  6231. 	set		XDCARE,X+2
    6232. 

  6232. 	set		XFRAC,X+4
    6233. 

  6233. 	set		XFRACLO,X+8
    6234. 

  6234. 

  6235. 	set		ATANF,FP_SCR1
    6236. 

  6236. 	set		ATANFHI,ATANF+4
    6237. 

  6237. 	set		ATANFLO,ATANF+8
    6238. 

  6238. 

  6239. 	global		satan
    6240. 

  6240. #--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
    6241. 

  6241. satan:
    6242. 

  6242. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    6243. 

  6243. 

  6244. 	mov.l		(%a0),%d1
    6245. 

  6245. 	mov.w		4(%a0),%d1
    6246. 

  6246. 	fmov.x		%fp0,X(%a6)
    6247. 

  6247. 	and.l		&0x7FFFFFFF,%d1
    6248. 

  6248. 

  6249. 	cmp.l		%d1,&0x3FFB8000		# |X| >= 1/16?
    6250. 

  6250. 	bge.b		ATANOK1
    6251. 

  6251. 	bra.w		ATANSM
    6252. 

  6252. 

  6253. ATANOK1:
    6254. 

  6254. 	cmp.l		%d1,&0x4002FFFF		# |X| < 16 ?
    6255. 

  6255. 	ble.b		ATANMAIN
    6256. 

  6256. 	bra.w		ATANBIG
    6257. 

  6257. 

  6258. #--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE
    6259. 

  6259. #--THE IDEA IS ATAN(X) = ATAN(F) + ATAN( [X-F] / [1+XF] ).
    6260. 

  6260. #--SO IF F IS CHOSEN TO BE CLOSE TO X AND ATAN(F) IS STORED IN
    6261. 

  6261. #--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE
    6262. 

  6262. #--U = (X-F)/(1+XF) IS SMALL (REMEMBER F IS CLOSE TO X). IT IS
    6263. 

  6263. #--TRUE THAT A DIVIDE IS NOW NEEDED, BUT THE APPROXIMATION FOR
    6264. 

  6264. #--ATAN(U) IS A VERY SHORT POLYNOMIAL AND THE INDEXING TO
    6265. 

  6265. #--FETCH F AND SAVING OF REGISTERS CAN BE ALL HIDED UNDER THE
    6266. 

  6266. #--DIVIDE. IN THE END THIS METHOD IS MUCH FASTER THAN A TRADITIONAL
    6267. 

  6267. #--ONE. NOTE ALSO THAT THE TRADITIONAL SCHEME THAT APPROXIMATE
    6268. 

  6268. #--ATAN(X) DIRECTLY WILL NEED TO USE A RATIONAL APPROXIMATION
    6269. 

  6269. #--(DIVISION NEEDED) ANYWAY BECAUSE A POLYNOMIAL APPROXIMATION
    6270. 

  6270. #--WILL INVOLVE A VERY LONG POLYNOMIAL.
    6271. 

  6271. 

  6272. #--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS
    6273. 

  6273. #--WE CHOSE F TO BE +-2^K * 1.BBBB1
    6274. 

  6274. #--THAT IS IT MATCHES THE EXPONENT AND FIRST 5 BITS OF X, THE
    6275. 

  6275. #--SIXTH BITS IS SET TO BE 1. SINCE K = -4, -3, ..., 3, THERE
    6276. 

  6276. #--ARE ONLY 8 TIMES 16 = 2^7 = 128 |F|'S. SINCE ATAN(-|F|) IS
    6277. 

  6277. #-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|).
    6278. 

  6278. 

  6279. ATANMAIN:
    6280. 

  6280. 

  6281. 	and.l		&0xF8000000,XFRAC(%a6)	# FIRST 5 BITS
    6282. 

  6282. 	or.l		&0x04000000,XFRAC(%a6)	# SET 6-TH BIT TO 1
    6283. 

  6283. 	mov.l		&0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW F
    6284. 

  6284. 

  6285. 	fmov.x		%fp0,%fp1		# FP1 IS X
    6286. 

  6286. 	fmul.x		X(%a6),%fp1		# FP1 IS X*F, NOTE THAT X*F > 0
    6287. 

  6287. 	fsub.x		X(%a6),%fp0		# FP0 IS X-F
    6288. 

  6288. 	fadd.s		&0x3F800000,%fp1	# FP1 IS 1 + X*F
    6289. 

  6289. 	fdiv.x		%fp1,%fp0		# FP0 IS U = (X-F)/(1+X*F)
    6290. 

  6290. 

  6291. #--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|)
    6292. 

  6292. #--CREATE ATAN(F) AND STORE IT IN ATANF, AND
    6293. 

  6293. #--SAVE REGISTERS FP2.
    6294. 

  6294. 

  6295. 	mov.l		%d2,-(%sp)		# SAVE d2 TEMPORARILY
    6296. 

  6296. 	mov.l		%d1,%d2			# THE EXP AND 16 BITS OF X
    6297. 

  6297. 	and.l		&0x00007800,%d1		# 4 VARYING BITS OF F'S FRACTION
    6298. 

  6298. 	and.l		&0x7FFF0000,%d2		# EXPONENT OF F
    6299. 

  6299. 	sub.l		&0x3FFB0000,%d2		# K+4
    6300. 

  6300. 	asr.l		&1,%d2
    6301. 

  6301. 	add.l		%d2,%d1			# THE 7 BITS IDENTIFYING F
    6302. 

  6302. 	asr.l		&7,%d1			# INDEX INTO TBL OF ATAN(|F|)
    6303. 

  6303. 	lea		ATANTBL(%pc),%a1
    6304. 

  6304. 	add.l		%d1,%a1			# ADDRESS OF ATAN(|F|)
    6305. 

  6305. 	mov.l		(%a1)+,ATANF(%a6)
    6306. 

  6306. 	mov.l		(%a1)+,ATANFHI(%a6)
    6307. 

  6307. 	mov.l		(%a1)+,ATANFLO(%a6)	# ATANF IS NOW ATAN(|F|)
    6308. 

  6308. 	mov.l		X(%a6),%d1		# LOAD SIGN AND EXPO. AGAIN
    6309. 

  6309. 	and.l		&0x80000000,%d1		# SIGN(F)
    6310. 

  6310. 	or.l		%d1,ATANF(%a6)		# ATANF IS NOW SIGN(F)*ATAN(|F|)
    6311. 

  6311. 	mov.l		(%sp)+,%d2		# RESTORE d2
    6312. 

  6312. 

  6313. #--THAT'S ALL I HAVE TO DO FOR NOW,
    6314. 

  6314. #--BUT ALAS, THE DIVIDE IS STILL CRANKING!
    6315. 

  6315. 

  6316. #--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS
    6317. 

  6317. #--U + A1*U*V*(A2 + V*(A3 + V)), V = U*U
    6318. 

  6318. #--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT.
    6319. 

  6319. #--THE NATURAL FORM IS U + U*V*(A1 + V*(A2 + V*A3))
    6320. 

  6320. #--WHAT WE HAVE HERE IS MERELY	A1 = A3, A2 = A1/A3, A3 = A2/A3.
    6321. 

  6321. #--THE REASON FOR THIS REARRANGEMENT IS TO MAKE THE INDEPENDENT
    6322. 

  6322. #--PARTS A1*U*V AND (A2 + ... STUFF) MORE LOAD-BALANCED
    6323. 

  6323. 

  6324. 	fmovm.x		&0x04,-(%sp)		# save fp2
    6325. 

  6325. 

  6326. 	fmov.x		%fp0,%fp1
    6327. 

  6327. 	fmul.x		%fp1,%fp1
    6328. 

  6328. 	fmov.d		ATANA3(%pc),%fp2
    6329. 

  6329. 	fadd.x		%fp1,%fp2		# A3+V
    6330. 

  6330. 	fmul.x		%fp1,%fp2		# V*(A3+V)
    6331. 

  6331. 	fmul.x		%fp0,%fp1		# U*V
    6332. 

  6332. 	fadd.d		ATANA2(%pc),%fp2	# A2+V*(A3+V)
    6333. 

  6333. 	fmul.d		ATANA1(%pc),%fp1	# A1*U*V
    6334. 

  6334. 	fmul.x		%fp2,%fp1		# A1*U*V*(A2+V*(A3+V))
    6335. 

  6335. 	fadd.x		%fp1,%fp0		# ATAN(U), FP1 RELEASED
    6336. 

  6336. 

  6337. 	fmovm.x		(%sp)+,&0x20		# restore fp2
    6338. 

  6338. 

  6339. 	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
    6340. 

  6340. 	fadd.x		ATANF(%a6),%fp0		# ATAN(X)
    6341. 

  6341. 	bra		t_inx2
    6342. 

  6342. 

  6343. ATANBORS:
    6344. 

  6344. #--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.
    6345. 

  6345. #--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.
    6346. 

  6346. 	cmp.l		%d1,&0x3FFF8000
    6347. 

  6347. 	bgt.w		ATANBIG			# I.E. |X| >= 16
    6348. 

  6348. 

  6349. ATANSM:
    6350. 

  6350. #--|X| <= 1/16
    6351. 

  6351. #--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE
    6352. 

  6352. #--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6)))))
    6353. 

  6353. #--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] )
    6354. 

  6354. #--WHERE Y = X*X, AND Z = Y*Y.
    6355. 

  6355. 

  6356. 	cmp.l		%d1,&0x3FD78000
    6357. 

  6357. 	blt.w		ATANTINY
    6358. 

  6358. 

  6359. #--COMPUTE POLYNOMIAL
    6360. 

  6360. 	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
    6361. 

  6361. 

  6362. 	fmul.x		%fp0,%fp0		# FPO IS Y = X*X
    6363. 

  6363. 

  6364. 	fmov.x		%fp0,%fp1
    6365. 

  6365. 	fmul.x		%fp1,%fp1		# FP1 IS Z = Y*Y
    6366. 

  6366. 

  6367. 	fmov.d		ATANB6(%pc),%fp2
    6368. 

  6368. 	fmov.d		ATANB5(%pc),%fp3
    6369. 

  6369. 

  6370. 	fmul.x		%fp1,%fp2		# Z*B6
    6371. 

  6371. 	fmul.x		%fp1,%fp3		# Z*B5
    6372. 

  6372. 

  6373. 	fadd.d		ATANB4(%pc),%fp2	# B4+Z*B6
    6374. 

  6374. 	fadd.d		ATANB3(%pc),%fp3	# B3+Z*B5
    6375. 

  6375. 

  6376. 	fmul.x		%fp1,%fp2		# Z*(B4+Z*B6)
    6377. 

  6377. 	fmul.x		%fp3,%fp1		# Z*(B3+Z*B5)
    6378. 

  6378. 

  6379. 	fadd.d		ATANB2(%pc),%fp2	# B2+Z*(B4+Z*B6)
    6380. 

  6380. 	fadd.d		ATANB1(%pc),%fp1	# B1+Z*(B3+Z*B5)
    6381. 

  6381. 

  6382. 	fmul.x		%fp0,%fp2		# Y*(B2+Z*(B4+Z*B6))
    6383. 

  6383. 	fmul.x		X(%a6),%fp0		# X*Y
    6384. 

  6384. 

  6385. 	fadd.x		%fp2,%fp1		# [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]
    6386. 

  6386. 

  6387. 	fmul.x		%fp1,%fp0		# X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
    6388. 

  6388. 

  6389. 	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
    6390. 

  6390. 

  6391. 	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
    6392. 

  6392. 	fadd.x		X(%a6),%fp0
    6393. 

  6393. 	bra		t_inx2
    6394. 

  6394. 

  6395. ATANTINY:
    6396. 

  6396. #--|X| < 2^(-40), ATAN(X) = X
    6397. 

  6397. 

  6398. 	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
    6399. 

  6399. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    6400. 

  6400. 	fmov.x		X(%a6),%fp0		# last inst - possible exception set
    6401. 

  6401. 

  6402. 	bra		t_catch
    6403. 

  6403. 

  6404. ATANBIG:
    6405. 

  6405. #--IF |X| > 2^(100), RETURN	SIGN(X)*(PI/2 - TINY). OTHERWISE,
    6406. 

  6406. #--RETURN SIGN(X)*PI/2 + ATAN(-1/X).
    6407. 

  6407. 	cmp.l		%d1,&0x40638000
    6408. 

  6408. 	bgt.w		ATANHUGE
    6409. 

  6409. 

  6410. #--APPROXIMATE ATAN(-1/X) BY
    6411. 

  6411. #--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X'
    6412. 

  6412. #--THIS CAN BE RE-WRITTEN AS
    6413. 

  6413. #--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y.
    6414. 

  6414. 

  6415. 	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
    6416. 

  6416. 

  6417. 	fmov.s		&0xBF800000,%fp1	# LOAD -1
    6418. 

  6418. 	fdiv.x		%fp0,%fp1		# FP1 IS -1/X
    6419. 

  6419. 

  6420. #--DIVIDE IS STILL CRANKING
    6421. 

  6421. 

  6422. 	fmov.x		%fp1,%fp0		# FP0 IS X'
    6423. 

  6423. 	fmul.x		%fp0,%fp0		# FP0 IS Y = X'*X'
    6424. 

  6424. 	fmov.x		%fp1,X(%a6)		# X IS REALLY X'
    6425. 

    6426. 

  6426. 	fmov.x		%fp0,%fp1
    6427. 

  6427. 	fmul.x		%fp1,%fp1		# FP1 IS Z = Y*Y
    6428. 

  6428. 

  6429. 	fmov.d		ATANC5(%pc),%fp3
    6430. 

  6430. 	fmov.d		ATANC4(%pc),%fp2
    6431. 

  6431. 

  6432. 	fmul.x		%fp1,%fp3		# Z*C5
    6433. 

  6433. 	fmul.x		%fp1,%fp2		# Z*B4
    6434. 

  6434. 

  6435. 	fadd.d		ATANC3(%pc),%fp3	# C3+Z*C5
    6436. 

  6436. 	fadd.d		ATANC2(%pc),%fp2	# C2+Z*C4
    6437. 

  6437. 

  6438. 	fmul.x		%fp3,%fp1		# Z*(C3+Z*C5), FP3 RELEASED
    6439. 

  6439. 	fmul.x		%fp0,%fp2		# Y*(C2+Z*C4)
    6440. 

  6440. 

  6441. 	fadd.d		ATANC1(%pc),%fp1	# C1+Z*(C3+Z*C5)
    6442. 

  6442. 	fmul.x		X(%a6),%fp0		# X'*Y
    6443. 

    6444. 

  6444. 	fadd.x		%fp2,%fp1		# [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)]
    6445. 

  6445. 

  6446. 	fmul.x		%fp1,%fp0		# X'*Y*([B1+Z*(B3+Z*B5)]
    6447. 

  6447. #					...	+[Y*(B2+Z*(B4+Z*B6))])
    6448. 

  6448. 	fadd.x		X(%a6),%fp0
    6449. 

  6449. 

  6450. 	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
    6451. 

  6451. 

  6452. 	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
    6453. 

  6453. 	tst.b		(%a0)
    6454. 

  6454. 	bpl.b		pos_big
    6455. 

  6455. 

  6456. neg_big:
    6457. 

  6457. 	fadd.x		NPIBY2(%pc),%fp0
    6458. 

  6458. 	bra		t_minx2
    6459. 

  6459. 

  6460. pos_big:
    6461. 

  6461. 	fadd.x		PPIBY2(%pc),%fp0
    6462. 

  6462. 	bra		t_pinx2
    6463. 

  6463. 

  6464. ATANHUGE:
    6465. 

  6465. #--RETURN SIGN(X)*(PIBY2 - TINY) = SIGN(X)*PIBY2 - SIGN(X)*TINY
    6466. 

  6466. 	tst.b		(%a0)
    6467. 

  6467. 	bpl.b		pos_huge
    6468. 

  6468. 

  6469. neg_huge:
    6470. 

  6470. 	fmov.x		NPIBY2(%pc),%fp0
    6471. 

  6471. 	fmov.l		%d0,%fpcr
    6472. 

  6472. 	fadd.x		PTINY(%pc),%fp0
    6473. 

  6473. 	bra		t_minx2
    6474. 

  6474. 

  6475. pos_huge:
    6476. 

  6476. 	fmov.x		PPIBY2(%pc),%fp0
    6477. 

  6477. 	fmov.l		%d0,%fpcr
    6478. 

  6478. 	fadd.x		NTINY(%pc),%fp0
    6479. 

  6479. 	bra		t_pinx2
    6480. 

  6480. 

  6481. 	global		satand
    6482. 

  6482. #--ENTRY POINT FOR ATAN(X) FOR DENORMALIZED ARGUMENT
    6483. 

  6483. satand:
    6484. 

  6484. 	bra		t_extdnrm
    6485. 

  6485. 

  6486. #########################################################################
    6487. 

  6487. # sasin():  computes the inverse sine of a normalized input		#
    6488. 

  6488. # sasind(): computes the inverse sine of a denormalized input		#
    6489. 

  6489. #									#
    6490. 

  6490. # INPUT ***************************************************************	#
    6491. 

  6491. #	a0 = pointer to extended precision input			#
    6492. 

  6492. #	d0 = round precision,mode					#
    6493. 

  6493. #									#
    6494. 

  6494. # OUTPUT **************************************************************	#
    6495. 

  6495. #	fp0 = arcsin(X)							#
    6496. 

  6496. #									#
    6497. 

  6497. # ACCURACY and MONOTONICITY *******************************************	#
    6498. 

  6498. #	The returned result is within 3 ulps in	64 significant bit,	#
    6499. 

  6499. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
    6500. 

  6500. #	rounded to double precision. The result is provably monotonic	#
    6501. 

  6501. #	in double precision.						#
    6502. 

  6502. #									#
    6503. 

  6503. # ALGORITHM ***********************************************************	#
    6504. 

  6504. #									#
    6505. 

  6505. #	ASIN								#
    6506. 

  6506. #	1. If |X| >= 1, go to 3.					#
    6507. 

  6507. #									#
    6508. 

  6508. #	2. (|X| < 1) Calculate asin(X) by				#
    6509. 

  6509. #		z := sqrt( [1-X][1+X] )					#
    6510. 

  6510. #		asin(X) = atan( x / z ).				#
    6511. 

  6511. #		Exit.							#
    6512. 

  6512. #									#
    6513. 

  6513. #	3. If |X| > 1, go to 5.						#
    6514. 

  6514. #									#
    6515. 

  6515. #	4. (|X| = 1) sgn := sign(X), return asin(X) := sgn * Pi/2. Exit.#
    6516. 

  6516. #									#
    6517. 

  6517. #	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
    6518. 

  6518. #		Exit.							#
    6519. 

  6519. #									#
    6520. 

  6520. #########################################################################
    6521. 

  6521. 

  6522. 	global		sasin
    6523. 

  6523. sasin:
    6524. 

  6524. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    6525. 

  6525. 

  6526. 	mov.l		(%a0),%d1
    6527. 

  6527. 	mov.w		4(%a0),%d1
    6528. 

  6528. 	and.l		&0x7FFFFFFF,%d1
    6529. 

  6529. 	cmp.l		%d1,&0x3FFF8000
    6530. 

  6530. 	bge.b		ASINBIG
    6531. 

  6531. 

  6532. # This catch is added here for the '060 QSP. Originally, the call to
    6533. 

  6533. # satan() would handle this case by causing the exception which would
    6534. 

  6534. # not be caught until gen_except(). Now, with the exceptions being
    6535. 

  6535. # detected inside of satan(), the exception would have been handled there
    6536. 

  6536. # instead of inside sasin() as expected.
    6537. 

  6537. 	cmp.l		%d1,&0x3FD78000
    6538. 

  6538. 	blt.w		ASINTINY
    6539. 

  6539. 

  6540. #--THIS IS THE USUAL CASE, |X| < 1
    6541. 

  6541. #--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) )
    6542. 

  6542. 

  6543. ASINMAIN:
    6544. 

  6544. 	fmov.s		&0x3F800000,%fp1
    6545. 

  6545. 	fsub.x		%fp0,%fp1		# 1-X
    6546. 

  6546. 	fmovm.x		&0x4,-(%sp)		#  {fp2}
    6547. 

  6547. 	fmov.s		&0x3F800000,%fp2
    6548. 

  6548. 	fadd.x		%fp0,%fp2		# 1+X
    6549. 

  6549. 	fmul.x		%fp2,%fp1		# (1+X)(1-X)
    6550. 

  6550. 	fmovm.x		(%sp)+,&0x20		#  {fp2}
    6551. 

  6551. 	fsqrt.x		%fp1			# SQRT([1-X][1+X])
    6552. 

  6552. 	fdiv.x		%fp1,%fp0		# X/SQRT([1-X][1+X])
    6553. 

  6553. 	fmovm.x		&0x01,-(%sp)		# save X/SQRT(...)
    6554. 

  6554. 	lea		(%sp),%a0		# pass ptr to X/SQRT(...)
    6555. 

  6555. 	bsr		satan
    6556. 

  6556. 	add.l		&0xc,%sp		# clear X/SQRT(...) from stack
    6557. 

  6557. 	bra		t_inx2
    6558. 

  6558. 

  6559. ASINBIG:
    6560. 

  6560. 	fabs.x		%fp0			# |X|
    6561. 

  6561. 	fcmp.s		%fp0,&0x3F800000
    6562. 

  6562. 	fbgt		t_operr			# cause an operr exception
    6563. 

  6563. 

  6564. #--|X| = 1, ASIN(X) = +- PI/2.
    6565. 

  6565. ASINONE:
    6566. 

  6566. 	fmov.x		PIBY2(%pc),%fp0
    6567. 

  6567. 	mov.l		(%a0),%d1
    6568. 

  6568. 	and.l		&0x80000000,%d1		# SIGN BIT OF X
    6569. 

  6569. 	or.l		&0x3F800000,%d1		# +-1 IN SGL FORMAT
    6570. 

  6570. 	mov.l		%d1,-(%sp)		# push SIGN(X) IN SGL-FMT
    6571. 

  6571. 	fmov.l		%d0,%fpcr
    6572. 

  6572. 	fmul.s		(%sp)+,%fp0
    6573. 

  6573. 	bra		t_inx2
    6574. 

  6574. 

  6575. #--|X| < 2^(-40), ATAN(X) = X
    6576. 

  6576. ASINTINY:
    6577. 

  6577. 	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
    6578. 

  6578. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    6579. 

  6579. 	fmov.x		(%a0),%fp0		# last inst - possible exception
    6580. 

  6580. 	bra		t_catch
    6581. 

  6581. 

  6582. 	global		sasind
    6583. 

  6583. #--ASIN(X) = X FOR DENORMALIZED X
    6584. 

  6584. sasind:
    6585. 

  6585. 	bra		t_extdnrm
    6586. 

  6586. 

  6587. #########################################################################
    6588. 

  6588. # sacos():  computes the inverse cosine of a normalized input		#
    6589. 

  6589. # sacosd(): computes the inverse cosine of a denormalized input		#
    6590. 

  6590. #									#
    6591. 

  6591. # INPUT ***************************************************************	#
    6592. 

  6592. #	a0 = pointer to extended precision input			#
    6593. 

  6593. #	d0 = round precision,mode					#
    6594. 

  6594. #									#
    6595. 

  6595. # OUTPUT ************************************************************** #
    6596. 

  6596. #	fp0 = arccos(X)							#
    6597. 

  6597. #									#
    6598. 

  6598. # ACCURACY and MONOTONICITY *******************************************	#
    6599. 

  6599. #	The returned result is within 3 ulps in	64 significant bit,	#
    6600. 

  6600. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
    6601. 

  6601. #	rounded to double precision. The result is provably monotonic	#
    6602. 

  6602. #	in double precision.						#
    6603. 

  6603. #									#
    6604. 

  6604. # ALGORITHM *********************************************************** #
    6605. 

  6605. #									#
    6606. 

  6606. #	ACOS								#
    6607. 

  6607. #	1. If |X| >= 1, go to 3.					#
    6608. 

  6608. #									#
    6609. 

  6609. #	2. (|X| < 1) Calculate acos(X) by				#
    6610. 

  6610. #		z := (1-X) / (1+X)					#
    6611. 

  6611. #		acos(X) = 2 * atan( sqrt(z) ).				#
    6612. 

  6612. #		Exit.							#
    6613. 

  6613. #									#
    6614. 

  6614. #	3. If |X| > 1, go to 5.						#
    6615. 

  6615. #									#
    6616. 

  6616. #	4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit.	#
    6617. 

  6617. #									#
    6618. 

  6618. #	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
    6619. 

  6619. #		Exit.							#
    6620. 

  6620. #									#
    6621. 

  6621. #########################################################################
    6622. 

  6622. 

  6623. 	global		sacos
    6624. 

  6624. sacos:
    6625. 

  6625. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    6626. 

  6626. 

  6627. 	mov.l		(%a0),%d1		# pack exp w/ upper 16 fraction
    6628. 

  6628. 	mov.w		4(%a0),%d1
    6629. 

  6629. 	and.l		&0x7FFFFFFF,%d1
    6630. 

  6630. 	cmp.l		%d1,&0x3FFF8000
    6631. 

  6631. 	bge.b		ACOSBIG
    6632. 

  6632. 

  6633. #--THIS IS THE USUAL CASE, |X| < 1
    6634. 

  6634. #--ACOS(X) = 2 * ATAN(	SQRT( (1-X)/(1+X) ) )
    6635. 

  6635. 

  6636. ACOSMAIN:
    6637. 

  6637. 	fmov.s		&0x3F800000,%fp1
    6638. 

  6638. 	fadd.x		%fp0,%fp1		# 1+X
    6639. 

  6639. 	fneg.x		%fp0			# -X
    6640. 

  6640. 	fadd.s		&0x3F800000,%fp0	# 1-X
    6641. 

  6641. 	fdiv.x		%fp1,%fp0		# (1-X)/(1+X)
    6642. 

  6642. 	fsqrt.x		%fp0			# SQRT((1-X)/(1+X))
    6643. 

  6643. 	mov.l		%d0,-(%sp)		# save original users fpcr
    6644. 

  6644. 	clr.l		%d0
    6645. 

  6645. 	fmovm.x		&0x01,-(%sp)		# save SQRT(...) to stack
    6646. 

  6646. 	lea		(%sp),%a0		# pass ptr to sqrt
    6647. 

  6647. 	bsr		satan			# ATAN(SQRT([1-X]/[1+X]))
    6648. 

  6648. 	add.l		&0xc,%sp		# clear SQRT(...) from stack
    6649. 

  6649. 

  6650. 	fmov.l		(%sp)+,%fpcr		# restore users round prec,mode
    6651. 

  6651. 	fadd.x		%fp0,%fp0		# 2 * ATAN( STUFF )
    6652. 

  6652. 	bra		t_pinx2
    6653. 

  6653. 

  6654. ACOSBIG:
    6655. 

  6655. 	fabs.x		%fp0
    6656. 

  6656. 	fcmp.s		%fp0,&0x3F800000
    6657. 

  6657. 	fbgt		t_operr			# cause an operr exception
    6658. 

  6658. 

  6659. #--|X| = 1, ACOS(X) = 0 OR PI
    6660. 

  6660. 	tst.b		(%a0)			# is X positive or negative?
    6661. 

  6661. 	bpl.b		ACOSP1
    6662. 

  6662. 

  6663. #--X = -1
    6664. 

  6664. #Returns PI and inexact exception
    6665. 

  6665. ACOSM1:
    6666. 

  6666. 	fmov.x		PI(%pc),%fp0		# load PI
    6667. 

  6667. 	fmov.l		%d0,%fpcr		# load round mode,prec
    6668. 

  6668. 	fadd.s		&0x00800000,%fp0	# add a small value
    6669. 

  6669. 	bra		t_pinx2
    6670. 

  6670. 

  6671. ACOSP1:
    6672. 

  6672. 	bra		ld_pzero		# answer is positive zero
    6673. 

  6673. 

  6674. 	global		sacosd
    6675. 

  6675. #--ACOS(X) = PI/2 FOR DENORMALIZED X
    6676. 

  6676. sacosd:
    6677. 

  6677. 	fmov.l		%d0,%fpcr		# load user's rnd mode/prec
    6678. 

  6678. 	fmov.x		PIBY2(%pc),%fp0
    6679. 

  6679. 	bra		t_pinx2
    6680. 

  6680. 

  6681. #########################################################################
    6682. 

  6682. # setox():    computes the exponential for a normalized input		#
    6683. 

  6683. # setoxd():   computes the exponential for a denormalized input		#
    6684. 

  6684. # setoxm1():  computes the exponential minus 1 for a normalized input	#
    6685. 

  6685. # setoxm1d(): computes the exponential minus 1 for a denormalized input	#
    6686. 

  6686. #									#
    6687. 

  6687. # INPUT	*************************************************************** #
    6688. 

  6688. #	a0 = pointer to extended precision input			#
    6689. 

  6689. #	d0 = round precision,mode					#
    6690. 

  6690. #									#
    6691. 

  6691. # OUTPUT ************************************************************** #
    6692. 

  6692. #	fp0 = exp(X) or exp(X)-1					#
    6693. 

  6693. #									#
    6694. 

  6694. # ACCURACY and MONOTONICITY ******************************************* #
    6695. 

  6695. #	The returned result is within 0.85 ulps in 64 significant bit,	#
    6696. 

  6696. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
    6697. 

  6697. #	rounded to double precision. The result is provably monotonic	#
    6698. 

  6698. #	in double precision.						#
    6699. 

  6699. #									#
    6700. 

  6700. # ALGORITHM and IMPLEMENTATION **************************************** #
    6701. 

  6701. #									#
    6702. 

  6702. #	setoxd								#
    6703. 

  6703. #	------								#
    6704. 

  6704. #	Step 1.	Set ans := 1.0						#
    6705. 

  6705. #									#
    6706. 

  6706. #	Step 2.	Return	ans := ans + sign(X)*2^(-126). Exit.		#
    6707. 

  6707. #	Notes:	This will always generate one exception -- inexact.	#
    6708. 

  6708. #									#
    6709. 

  6709. #									#
    6710. 

  6710. #	setox								#
    6711. 

  6711. #	-----								#
    6712. 

  6712. #									#
    6713. 

  6713. #	Step 1.	Filter out extreme cases of input argument.		#
    6714. 

  6714. #		1.1	If |X| >= 2^(-65), go to Step 1.3.		#
    6715. 

  6715. #		1.2	Go to Step 7.					#
    6716. 

  6716. #		1.3	If |X| < 16380 log(2), go to Step 2.		#
    6717. 

  6717. #		1.4	Go to Step 8.					#
    6718. 

  6718. #	Notes:	The usual case should take the branches 1.1 -> 1.3 -> 2.#
    6719. 

  6719. #		To avoid the use of floating-point comparisons, a	#
    6720. 

  6720. #		compact representation of |X| is used. This format is a	#
    6721. 

  6721. #		32-bit integer, the upper (more significant) 16 bits	#
    6722. 

  6722. #		are the sign and biased exponent field of |X|; the	#
    6723. 

  6723. #		lower 16 bits are the 16 most significant fraction	#
    6724. 

  6724. #		(including the explicit bit) bits of |X|. Consequently,	#
    6725. 

  6725. #		the comparisons in Steps 1.1 and 1.3 can be performed	#
    6726. 

  6726. #		by integer comparison. Note also that the constant	#
    6727. 

  6727. #		16380 log(2) used in Step 1.3 is also in the compact	#
    6728. 

  6728. #		form. Thus taking the branch to Step 2 guarantees	#
    6729. 

  6729. #		|X| < 16380 log(2). There is no harm to have a small	#
    6730. 

  6730. #		number of cases where |X| is less than,	but close to,	#
    6731. 

  6731. #		16380 log(2) and the branch to Step 9 is taken.		#
    6732. 

  6732. #									#
    6733. 

  6733. #	Step 2.	Calculate N = round-to-nearest-int( X * 64/log2 ).	#
    6734. 

  6734. #		2.1	Set AdjFlag := 0 (indicates the branch 1.3 -> 2 #
    6735. 

  6735. #			was taken)					#
    6736. 

  6736. #		2.2	N := round-to-nearest-integer( X * 64/log2 ).	#
    6737. 

  6737. #		2.3	Calculate	J = N mod 64; so J = 0,1,2,..., #
    6738. 

  6738. #			or 63.						#
    6739. 

  6739. #		2.4	Calculate	M = (N - J)/64; so N = 64M + J.	#
    6740. 

  6740. #		2.5	Calculate the address of the stored value of	#
    6741. 

  6741. #			2^(J/64).					#
    6742. 

  6742. #		2.6	Create the value Scale = 2^M.			#
    6743. 

  6743. #	Notes:	The calculation in 2.2 is really performed by		#
    6744. 

  6744. #			Z := X * constant				#
    6745. 

  6745. #			N := round-to-nearest-integer(Z)		#
    6746. 

  6746. #		where							#
    6747. 

  6747. #			constant := single-precision( 64/log 2 ).	#
    6748. 

  6748. #									#
    6749. 

  6749. #		Using a single-precision constant avoids memory		#
    6750. 

  6750. #		access. Another effect of using a single-precision	#
    6751. 

  6751. #		"constant" is that the calculated value Z is		#
    6752. 

  6752. #									#
    6753. 

  6753. #			Z = X*(64/log2)*(1+eps), |eps| <= 2^(-24).	#
    6754. 

  6754. #									#
    6755. 

  6755. #		This error has to be considered later in Steps 3 and 4.	#
    6756. 

  6756. #									#
    6757. 

  6757. #	Step 3.	Calculate X - N*log2/64.				#
    6758. 

  6758. #		3.1	R := X + N*L1,					#
    6759. 

  6759. #				where L1 := single-precision(-log2/64).	#
    6760. 

  6760. #		3.2	R := R + N*L2,					#
    6761. 

  6761. #				L2 := extended-precision(-log2/64 - L1).#
    6762. 

  6762. #	Notes:	a) The way L1 and L2 are chosen ensures L1+L2		#
    6763. 

  6763. #		approximate the value -log2/64 to 88 bits of accuracy.	#
    6764. 

  6764. #		b) N*L1 is exact because N is no longer than 22 bits	#
    6765. 

  6765. #		and L1 is no longer than 24 bits.			#
    6766. 

  6766. #		c) The calculation X+N*L1 is also exact due to		#
    6767. 

  6767. #		cancellation. Thus, R is practically X+N(L1+L2) to full	#
    6768. 

  6768. #		64 bits.						#
    6769. 

  6769. #		d) It is important to estimate how large can |R| be	#
    6770. 

  6770. #		after Step 3.2.						#
    6771. 

  6771. #									#
    6772. 

  6772. #		N = rnd-to-int( X*64/log2 (1+eps) ), |eps|<=2^(-24)	#
    6773. 

  6773. #		X*64/log2 (1+eps)	=	N + f,	|f| <= 0.5	#
    6774. 

  6774. #		X*64/log2 - N	=	f - eps*X 64/log2		#
    6775. 

  6775. #		X - N*log2/64	=	f*log2/64 - eps*X		#
    6776. 

  6776. #									#
    6777. 

  6777. #									#
    6778. 

  6778. #		Now |X| <= 16446 log2, thus				#
    6779. 

  6779. #									#
    6780. 

  6780. #			|X - N*log2/64| <= (0.5 + 16446/2^(18))*log2/64	#
    6781. 

  6781. #					<= 0.57 log2/64.		#
    6782. 

  6782. #		 This bound will be used in Step 4.			#
    6783. 

  6783. #									#
    6784. 

  6784. #	Step 4.	Approximate exp(R)-1 by a polynomial			#
    6785. 

  6785. #		p = R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))	#
    6786. 

  6786. #	Notes:	a) In order to reduce memory access, the coefficients	#
    6787. 

  6787. #		are made as "short" as possible: A1 (which is 1/2), A4	#
    6788. 

  6788. #		and A5 are single precision; A2 and A3 are double	#
    6789. 

  6789. #		precision.						#
    6790. 

  6790. #		b) Even with the restrictions above,			#
    6791. 

  6791. #		   |p - (exp(R)-1)| < 2^(-68.8) for all |R| <= 0.0062.	#
    6792. 

  6792. #		Note that 0.0062 is slightly bigger than 0.57 log2/64.	#
    6793. 

  6793. #		c) To fully utilize the pipeline, p is separated into	#
    6794. 

  6794. #		two independent pieces of roughly equal complexities	#
    6795. 

  6795. #			p = [ R + R*S*(A2 + S*A4) ]	+		#
    6796. 

  6796. #				[ S*(A1 + S*(A3 + S*A5)) ]		#
    6797. 

  6797. #		where S = R*R.						#
    6798. 

  6798. #									#
    6799. 

  6799. #	Step 5.	Compute 2^(J/64)*exp(R) = 2^(J/64)*(1+p) by		#
    6800. 

  6800. #				ans := T + ( T*p + t)			#
    6801. 

  6801. #		where T and t are the stored values for 2^(J/64).	#
    6802. 

  6802. #	Notes:	2^(J/64) is stored as T and t where T+t approximates	#
    6803. 

  6803. #		2^(J/64) to roughly 85 bits; T is in extended precision	#
    6804. 

  6804. #		and t is in single precision. Note also that T is	#
    6805. 

  6805. #		rounded to 62 bits so that the last two bits of T are	#
    6806. 

  6806. #		zero. The reason for such a special form is that T-1,	#
    6807. 

  6807. #		T-2, and T-8 will all be exact --- a property that will	#
    6808. 

  6808. #		give much more accurate computation of the function	#
    6809. 

  6809. #		EXPM1.							#
    6810. 

  6810. #									#
    6811. 

  6811. #	Step 6.	Reconstruction of exp(X)				#
    6812. 

  6812. #			exp(X) = 2^M * 2^(J/64) * exp(R).		#
    6813. 

  6813. #		6.1	If AdjFlag = 0, go to 6.3			#
    6814. 

  6814. #		6.2	ans := ans * AdjScale				#
    6815. 

  6815. #		6.3	Restore the user FPCR				#
    6816. 

  6816. #		6.4	Return ans := ans * Scale. Exit.		#
    6817. 

  6817. #	Notes:	If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R,	#
    6818. 

  6818. #		|M| <= 16380, and Scale = 2^M. Moreover, exp(X) will	#
    6819. 

  6819. #		neither overflow nor underflow. If AdjFlag = 1, that	#
    6820. 

  6820. #		means that						#
    6821. 

  6821. #			X = (M1+M)log2 + Jlog2/64 + R, |M1+M| >= 16380.	#
    6822. 

  6822. #		Hence, exp(X) may overflow or underflow or neither.	#
    6823. 

  6823. #		When that is the case, AdjScale = 2^(M1) where M1 is	#
    6824. 

  6824. #		approximately M. Thus 6.2 will never cause		#
    6825. 

  6825. #		over/underflow. Possible exception in 6.4 is overflow	#
    6826. 

  6826. #		or underflow. The inexact exception is not generated in	#
    6827. 

  6827. #		6.4. Although one can argue that the inexact flag	#
    6828. 

  6828. #		should always be raised, to simulate that exception	#
    6829. 

  6829. #		cost to much than the flag is worth in practical uses.	#
    6830. 

  6830. #									#
    6831. 

  6831. #	Step 7.	Return 1 + X.						#
    6832. 

  6832. #		7.1	ans := X					#
    6833. 

  6833. #		7.2	Restore user FPCR.				#
    6834. 

  6834. #		7.3	Return ans := 1 + ans. Exit			#
    6835. 

  6835. #	Notes:	For non-zero X, the inexact exception will always be	#
    6836. 

  6836. #		raised by 7.3. That is the only exception raised by 7.3.#
    6837. 

  6837. #		Note also that we use the FMOVEM instruction to move X	#
    6838. 

  6838. #		in Step 7.1 to avoid unnecessary trapping. (Although	#
    6839. 

  6839. #		the FMOVEM may not seem relevant since X is normalized,	#
    6840. 

  6840. #		the precaution will be useful in the library version of	#
    6841. 

  6841. #		this code where the separate entry for denormalized	#
    6842. 

  6842. #		inputs will be done away with.)				#
    6843. 

  6843. #									#
    6844. 

  6844. #	Step 8.	Handle exp(X) where |X| >= 16380log2.			#
    6845. 

  6845. #		8.1	If |X| > 16480 log2, go to Step 9.		#
    6846. 

  6846. #		(mimic 2.2 - 2.6)					#
    6847. 

  6847. #		8.2	N := round-to-integer( X * 64/log2 )		#
    6848. 

  6848. #		8.3	Calculate J = N mod 64, J = 0,1,...,63		#
    6849. 

  6849. #		8.4	K := (N-J)/64, M1 := truncate(K/2), M = K-M1,	#
    6850. 

  6850. #			AdjFlag := 1.					#
    6851. 

  6851. #		8.5	Calculate the address of the stored value	#
    6852. 

  6852. #			2^(J/64).					#
    6853. 

  6853. #		8.6	Create the values Scale = 2^M, AdjScale = 2^M1.	#
    6854. 

  6854. #		8.7	Go to Step 3.					#
    6855. 

  6855. #	Notes:	Refer to notes for 2.2 - 2.6.				#
    6856. 

  6856. #									#
    6857. 

  6857. #	Step 9.	Handle exp(X), |X| > 16480 log2.			#
    6858. 

  6858. #		9.1	If X < 0, go to 9.3				#
    6859. 

  6859. #		9.2	ans := Huge, go to 9.4				#
    6860. 

  6860. #		9.3	ans := Tiny.					#
    6861. 

  6861. #		9.4	Restore user FPCR.				#
    6862. 

  6862. #		9.5	Return ans := ans * ans. Exit.			#
    6863. 

  6863. #	Notes:	Exp(X) will surely overflow or underflow, depending on	#
    6864. 

  6864. #		X's sign. "Huge" and "Tiny" are respectively large/tiny	#
    6865. 

  6865. #		extended-precision numbers whose square over/underflow	#
    6866. 

  6866. #		with an inexact result. Thus, 9.5 always raises the	#
    6867. 

  6867. #		inexact together with either overflow or underflow.	#
    6868. 

  6868. #									#
    6869. 

  6869. #	setoxm1d							#
    6870. 

  6870. #	--------							#
    6871. 

  6871. #									#
    6872. 

  6872. #	Step 1.	Set ans := 0						#
    6873. 

  6873. #									#
    6874. 

  6874. #	Step 2.	Return	ans := X + ans. Exit.				#
    6875. 

  6875. #	Notes:	This will return X with the appropriate rounding	#
    6876. 

  6876. #		 precision prescribed by the user FPCR.			#
    6877. 

  6877. #									#
    6878. 

  6878. #	setoxm1								#
    6879. 

  6879. #	-------								#
    6880. 

  6880. #									#
    6881. 

  6881. #	Step 1.	Check |X|						#
    6882. 

  6882. #		1.1	If |X| >= 1/4, go to Step 1.3.			#
    6883. 

  6883. #		1.2	Go to Step 7.					#
    6884. 

  6884. #		1.3	If |X| < 70 log(2), go to Step 2.		#
    6885. 

  6885. #		1.4	Go to Step 10.					#
    6886. 

  6886. #	Notes:	The usual case should take the branches 1.1 -> 1.3 -> 2.#
    6887. 

  6887. #		However, it is conceivable |X| can be small very often	#
    6888. 

  6888. #		because EXPM1 is intended to evaluate exp(X)-1		#
    6889. 

  6889. #		accurately when |X| is small. For further details on	#
    6890. 

  6890. #		the comparisons, see the notes on Step 1 of setox.	#
    6891. 

  6891. #									#
    6892. 

  6892. #	Step 2.	Calculate N = round-to-nearest-int( X * 64/log2 ).	#
    6893. 

  6893. #		2.1	N := round-to-nearest-integer( X * 64/log2 ).	#
    6894. 

  6894. #		2.2	Calculate	J = N mod 64; so J = 0,1,2,..., #
    6895. 

  6895. #			or 63.						#
    6896. 

  6896. #		2.3	Calculate	M = (N - J)/64; so N = 64M + J.	#
    6897. 

  6897. #		2.4	Calculate the address of the stored value of	#
    6898. 

  6898. #			2^(J/64).					#
    6899. 

  6899. #		2.5	Create the values Sc = 2^M and			#
    6900. 

  6900. #			OnebySc := -2^(-M).				#
    6901. 

  6901. #	Notes:	See the notes on Step 2 of setox.			#
    6902. 

  6902. #									#
    6903. 

  6903. #	Step 3.	Calculate X - N*log2/64.				#
    6904. 

  6904. #		3.1	R := X + N*L1,					#
    6905. 

  6905. #				where L1 := single-precision(-log2/64).	#
    6906. 

  6906. #		3.2	R := R + N*L2,					#
    6907. 

  6907. #				L2 := extended-precision(-log2/64 - L1).#
    6908. 

  6908. #	Notes:	Applying the analysis of Step 3 of setox in this case	#
    6909. 

  6909. #		shows that |R| <= 0.0055 (note that |X| <= 70 log2 in	#
    6910. 

  6910. #		this case).						#
    6911. 

  6911. #									#
    6912. 

  6912. #	Step 4.	Approximate exp(R)-1 by a polynomial			#
    6913. 

  6913. #			p = R+R*R*(A1+R*(A2+R*(A3+R*(A4+R*(A5+R*A6)))))	#
    6914. 

  6914. #	Notes:	a) In order to reduce memory access, the coefficients	#
    6915. 

  6915. #		are made as "short" as possible: A1 (which is 1/2), A5	#
    6916. 

  6916. #		and A6 are single precision; A2, A3 and A4 are double	#
    6917. 

  6917. #		precision.						#
    6918. 

  6918. #		b) Even with the restriction above,			#
    6919. 

  6919. #			|p - (exp(R)-1)| <	|R| * 2^(-72.7)		#
    6920. 

  6920. #		for all |R| <= 0.0055.					#
    6921. 

  6921. #		c) To fully utilize the pipeline, p is separated into	#
    6922. 

  6922. #		two independent pieces of roughly equal complexity	#
    6923. 

  6923. #			p = [ R*S*(A2 + S*(A4 + S*A6)) ]	+	#
    6924. 

  6924. #				[ R + S*(A1 + S*(A3 + S*A5)) ]		#
    6925. 

  6925. #		where S = R*R.						#
    6926. 

  6926. #									#
    6927. 

  6927. #	Step 5.	Compute 2^(J/64)*p by					#
    6928. 

  6928. #				p := T*p				#
    6929. 

  6929. #		where T and t are the stored values for 2^(J/64).	#
    6930. 

  6930. #	Notes:	2^(J/64) is stored as T and t where T+t approximates	#
    6931. 

  6931. #		2^(J/64) to roughly 85 bits; T is in extended precision	#
    6932. 

  6932. #		and t is in single precision. Note also that T is	#
    6933. 

  6933. #		rounded to 62 bits so that the last two bits of T are	#
    6934. 

  6934. #		zero. The reason for such a special form is that T-1,	#
    6935. 

  6935. #		T-2, and T-8 will all be exact --- a property that will	#
    6936. 

  6936. #		be exploited in Step 6 below. The total relative error	#
    6937. 

  6937. #		in p is no bigger than 2^(-67.7) compared to the final	#
    6938. 

  6938. #		result.							#
    6939. 

  6939. #									#
    6940. 

  6940. #	Step 6.	Reconstruction of exp(X)-1				#
    6941. 

  6941. #			exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ).	#
    6942. 

  6942. #		6.1	If M <= 63, go to Step 6.3.			#
    6943. 

  6943. #		6.2	ans := T + (p + (t + OnebySc)). Go to 6.6	#
    6944. 

  6944. #		6.3	If M >= -3, go to 6.5.				#
    6945. 

  6945. #		6.4	ans := (T + (p + t)) + OnebySc. Go to 6.6	#
    6946. 

  6946. #		6.5	ans := (T + OnebySc) + (p + t).			#
    6947. 

  6947. #		6.6	Restore user FPCR.				#
    6948. 

  6948. #		6.7	Return ans := Sc * ans. Exit.			#
    6949. 

  6949. #	Notes:	The various arrangements of the expressions give	#
    6950. 

  6950. #		accurate evaluations.					#
    6951. 

  6951. #									#
    6952. 

  6952. #	Step 7.	exp(X)-1 for |X| < 1/4.					#
    6953. 

  6953. #		7.1	If |X| >= 2^(-65), go to Step 9.		#
    6954. 

  6954. #		7.2	Go to Step 8.					#
    6955. 

  6955. #									#
    6956. 

  6956. #	Step 8.	Calculate exp(X)-1, |X| < 2^(-65).			#
    6957. 

  6957. #		8.1	If |X| < 2^(-16312), goto 8.3			#
    6958. 

  6958. #		8.2	Restore FPCR; return ans := X - 2^(-16382).	#
    6959. 

  6959. #			Exit.						#
    6960. 

  6960. #		8.3	X := X * 2^(140).				#
    6961. 

  6961. #		8.4	Restore FPCR; ans := ans - 2^(-16382).		#
    6962. 

  6962. #		 Return ans := ans*2^(140). Exit			#
    6963. 

  6963. #	Notes:	The idea is to return "X - tiny" under the user		#
    6964. 

  6964. #		precision and rounding modes. To avoid unnecessary	#
    6965. 

  6965. #		inefficiency, we stay away from denormalized numbers	#
    6966. 

  6966. #		the best we can. For |X| >= 2^(-16312), the		#
    6967. 

  6967. #		straightforward 8.2 generates the inexact exception as	#
    6968. 

  6968. #		the case warrants.					#
    6969. 

  6969. #									#
    6970. 

  6970. #	Step 9.	Calculate exp(X)-1, |X| < 1/4, by a polynomial		#
    6971. 

  6971. #			p = X + X*X*(B1 + X*(B2 + ... + X*B12))		#
    6972. 

  6972. #	Notes:	a) In order to reduce memory access, the coefficients	#
    6973. 

  6973. #		are made as "short" as possible: B1 (which is 1/2), B9	#
    6974. 

  6974. #		to B12 are single precision; B3 to B8 are double	#
    6975. 

  6975. #		precision; and B2 is double extended.			#
    6976. 

  6976. #		b) Even with the restriction above,			#
    6977. 

  6977. #			|p - (exp(X)-1)| < |X| 2^(-70.6)		#
    6978. 

  6978. #		for all |X| <= 0.251.					#
    6979. 

  6979. #		Note that 0.251 is slightly bigger than 1/4.		#
    6980. 

  6980. #		c) To fully preserve accuracy, the polynomial is	#
    6981. 

  6981. #		computed as						#
    6982. 

  6982. #			X + ( S*B1 +	Q ) where S = X*X and		#
    6983. 

  6983. #			Q	=	X*S*(B2 + X*(B3 + ... + X*B12))	#
    6984. 

  6984. #		d) To fully utilize the pipeline, Q is separated into	#
    6985. 

  6985. #		two independent pieces of roughly equal complexity	#
    6986. 

  6986. #			Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] +	#
    6987. 

  6987. #				[ S*S*(B3 + S*(B5 + ... + S*B11)) ]	#
    6988. 

  6988. #									#
    6989. 

  6989. #	Step 10. Calculate exp(X)-1 for |X| >= 70 log 2.		#
    6990. 

  6990. #		10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all	#
    6991. 

  6991. #		practical purposes. Therefore, go to Step 1 of setox.	#
    6992. 

  6992. #		10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical	#
    6993. 

  6993. #		purposes.						#
    6994. 

  6994. #		ans := -1						#
    6995. 

  6995. #		Restore user FPCR					#
    6996. 

  6996. #		Return ans := ans + 2^(-126). Exit.			#
    6997. 

  6997. #	Notes:	10.2 will always create an inexact and return -1 + tiny	#
    6998. 

  6998. #		in the user rounding precision and mode.		#
    6999. 

  6999. #									#
    7000. 

  7000. #########################################################################
    7001. 

  7001. 

  7002. L2:	long		0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000
    7003. 

  7003. 

  7004. EEXPA3:	long		0x3FA55555,0x55554CC1
    7005. 

  7005. EEXPA2:	long		0x3FC55555,0x55554A54
    7006. 

  7006. 

  7007. EM1A4:	long		0x3F811111,0x11174385
    7008. 

  7008. EM1A3:	long		0x3FA55555,0x55554F5A
    7009. 

  7009. 

  7010. EM1A2:	long		0x3FC55555,0x55555555,0x00000000,0x00000000
    7011. 

  7011. 

  7012. EM1B8:	long		0x3EC71DE3,0xA5774682
    7013. 

  7013. EM1B7:	long		0x3EFA01A0,0x19D7CB68
    7014. 

  7014. 

  7015. EM1B6:	long		0x3F2A01A0,0x1A019DF3
    7016. 

  7016. EM1B5:	long		0x3F56C16C,0x16C170E2
    7017. 

  7017. 

  7018. EM1B4:	long		0x3F811111,0x11111111
    7019. 

  7019. EM1B3:	long		0x3FA55555,0x55555555
    7020. 

  7020. 

  7021. EM1B2:	long		0x3FFC0000,0xAAAAAAAA,0xAAAAAAAB
    7022. 

  7022. 	long		0x00000000
    7023. 

  7023. 

  7024. TWO140:	long		0x48B00000,0x00000000
    7025. 

  7025. TWON140:
    7026. 

  7026. 	long		0x37300000,0x00000000
    7027. 

  7027. 

  7028. EEXPTBL:
    7029. 

  7029. 	long		0x3FFF0000,0x80000000,0x00000000,0x00000000
    7030. 

  7030. 	long		0x3FFF0000,0x8164D1F3,0xBC030774,0x9F841A9B
    7031. 

  7031. 	long		0x3FFF0000,0x82CD8698,0xAC2BA1D8,0x9FC1D5B9
    7032. 

  7032. 	long		0x3FFF0000,0x843A28C3,0xACDE4048,0xA0728369
    7033. 

  7033. 	long		0x3FFF0000,0x85AAC367,0xCC487B14,0x1FC5C95C
    7034. 

  7034. 	long		0x3FFF0000,0x871F6196,0x9E8D1010,0x1EE85C9F
    7035. 

  7035. 	long		0x3FFF0000,0x88980E80,0x92DA8528,0x9FA20729
    7036. 

  7036. 	long		0x3FFF0000,0x8A14D575,0x496EFD9C,0xA07BF9AF
    7037. 

  7037. 	long		0x3FFF0000,0x8B95C1E3,0xEA8BD6E8,0xA0020DCF
    7038. 

  7038. 	long		0x3FFF0000,0x8D1ADF5B,0x7E5BA9E4,0x205A63DA
    7039. 

  7039. 	long		0x3FFF0000,0x8EA4398B,0x45CD53C0,0x1EB70051
    7040. 

  7040. 	long		0x3FFF0000,0x9031DC43,0x1466B1DC,0x1F6EB029
    7041. 

  7041. 	long		0x3FFF0000,0x91C3D373,0xAB11C338,0xA0781494
    7042. 

  7042. 	long		0x3FFF0000,0x935A2B2F,0x13E6E92C,0x9EB319B0
    7043. 

  7043. 	long		0x3FFF0000,0x94F4EFA8,0xFEF70960,0x2017457D
    7044. 

  7044. 	long		0x3FFF0000,0x96942D37,0x20185A00,0x1F11D537
    7045. 

  7045. 	long		0x3FFF0000,0x9837F051,0x8DB8A970,0x9FB952DD
    7046. 

  7046. 	long		0x3FFF0000,0x99E04593,0x20B7FA64,0x1FE43087
    7047. 

  7047. 	long		0x3FFF0000,0x9B8D39B9,0xD54E5538,0x1FA2A818
    7048. 

  7048. 	long		0x3FFF0000,0x9D3ED9A7,0x2CFFB750,0x1FDE494D
    7049. 

  7049. 	long		0x3FFF0000,0x9EF53260,0x91A111AC,0x20504890
    7050. 

  7050. 	long		0x3FFF0000,0xA0B0510F,0xB9714FC4,0xA073691C
    7051. 

  7051. 	long		0x3FFF0000,0xA2704303,0x0C496818,0x1F9B7A05
    7052. 

  7052. 	long		0x3FFF0000,0xA43515AE,0x09E680A0,0xA0797126
    7053. 

  7053. 	long		0x3FFF0000,0xA5FED6A9,0xB15138EC,0xA071A140
    7054. 

  7054. 	long		0x3FFF0000,0xA7CD93B4,0xE9653568,0x204F62DA
    7055. 

  7055. 	long		0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x1F283C4A
    7056. 

  7056. 	long		0x3FFF0000,0xAB7A39B5,0xA93ED338,0x9F9A7FDC
    7057. 

  7057. 	long		0x3FFF0000,0xAD583EEA,0x42A14AC8,0xA05B3FAC
    7058. 

  7058. 	long		0x3FFF0000,0xAF3B78AD,0x690A4374,0x1FDF2610
    7059. 

  7059. 	long		0x3FFF0000,0xB123F581,0xD2AC2590,0x9F705F90
    7060. 

  7060. 	long		0x3FFF0000,0xB311C412,0xA9112488,0x201F678A
    7061. 

  7061. 	long		0x3FFF0000,0xB504F333,0xF9DE6484,0x1F32FB13
    7062. 

  7062. 	long		0x3FFF0000,0xB6FD91E3,0x28D17790,0x20038B30
    7063. 

  7063. 	long		0x3FFF0000,0xB8FBAF47,0x62FB9EE8,0x200DC3CC
    7064. 

  7064. 	long		0x3FFF0000,0xBAFF5AB2,0x133E45FC,0x9F8B2AE6
    7065. 

  7065. 	long		0x3FFF0000,0xBD08A39F,0x580C36C0,0xA02BBF70
    7066. 

  7066. 	long		0x3FFF0000,0xBF1799B6,0x7A731084,0xA00BF518
    7067. 

  7067. 	long		0x3FFF0000,0xC12C4CCA,0x66709458,0xA041DD41
    7068. 

  7068. 	long		0x3FFF0000,0xC346CCDA,0x24976408,0x9FDF137B
    7069. 

  7069. 	long		0x3FFF0000,0xC5672A11,0x5506DADC,0x201F1568
    7070. 

  7070. 	long		0x3FFF0000,0xC78D74C8,0xABB9B15C,0x1FC13A2E
    7071. 

  7071. 	long		0x3FFF0000,0xC9B9BD86,0x6E2F27A4,0xA03F8F03
    7072. 

  7072. 	long		0x3FFF0000,0xCBEC14FE,0xF2727C5C,0x1FF4907D
    7073. 

  7073. 	long		0x3FFF0000,0xCE248C15,0x1F8480E4,0x9E6E53E4
    7074. 

  7074. 	long		0x3FFF0000,0xD06333DA,0xEF2B2594,0x1FD6D45C
    7075. 

  7075. 	long		0x3FFF0000,0xD2A81D91,0xF12AE45C,0xA076EDB9
    7076. 

  7076. 	long		0x3FFF0000,0xD4F35AAB,0xCFEDFA20,0x9FA6DE21
    7077. 

  7077. 	long		0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x1EE69A2F
    7078. 

  7078. 	long		0x3FFF0000,0xD99D15C2,0x78AFD7B4,0x207F439F
    7079. 

  7079. 	long		0x3FFF0000,0xDBFBB797,0xDAF23754,0x201EC207
    7080. 

  7080. 	long		0x3FFF0000,0xDE60F482,0x5E0E9124,0x9E8BE175
    7081. 

  7081. 	long		0x3FFF0000,0xE0CCDEEC,0x2A94E110,0x20032C4B
    7082. 

  7082. 	long		0x3FFF0000,0xE33F8972,0xBE8A5A50,0x2004DFF5
    7083. 

  7083. 	long		0x3FFF0000,0xE5B906E7,0x7C8348A8,0x1E72F47A
    7084. 

  7084. 	long		0x3FFF0000,0xE8396A50,0x3C4BDC68,0x1F722F22
    7085. 

  7085. 	long		0x3FFF0000,0xEAC0C6E7,0xDD243930,0xA017E945
    7086. 

  7086. 	long		0x3FFF0000,0xED4F301E,0xD9942B84,0x1F401A5B
    7087. 

  7087. 	long		0x3FFF0000,0xEFE4B99B,0xDCDAF5CC,0x9FB9A9E3
    7088. 

  7088. 	long		0x3FFF0000,0xF281773C,0x59FFB138,0x20744C05
    7089. 

  7089. 	long		0x3FFF0000,0xF5257D15,0x2486CC2C,0x1F773A19
    7090. 

  7090. 	long		0x3FFF0000,0xF7D0DF73,0x0AD13BB8,0x1FFE90D5
    7091. 

  7091. 	long		0x3FFF0000,0xFA83B2DB,0x722A033C,0xA041ED22
    7092. 

  7092. 	long		0x3FFF0000,0xFD3E0C0C,0xF486C174,0x1F853F3A
    7093. 

  7093. 

  7094. 	set		ADJFLAG,L_SCR2
    7095. 

  7095. 	set		SCALE,FP_SCR0
    7096. 

  7096. 	set		ADJSCALE,FP_SCR1
    7097. 

  7097. 	set		SC,FP_SCR0
    7098. 

  7098. 	set		ONEBYSC,FP_SCR1
    7099. 

  7099. 

  7100. 	global		setox
    7101. 

  7101. setox:
    7102. 

  7102. #--entry point for EXP(X), here X is finite, non-zero, and not NaN's
    7103. 

    7104. 

  7104. #--Step 1.
    7105. 

  7105. 	mov.l		(%a0),%d1		# load part of input X
    7106. 

  7106. 	and.l		&0x7FFF0000,%d1		# biased expo. of X
    7107. 

  7107. 	cmp.l		%d1,&0x3FBE0000		# 2^(-65)
    7108. 

  7108. 	bge.b		EXPC1			# normal case
    7109. 

  7109. 	bra		EXPSM
    7110. 

  7110. 

  7111. EXPC1:
    7112. 

  7112. #--The case |X| >= 2^(-65)
    7113. 

  7113. 	mov.w		4(%a0),%d1		# expo. and partial sig. of |X|
    7114. 

  7114. 	cmp.l		%d1,&0x400CB167		# 16380 log2 trunc. 16 bits
    7115. 

  7115. 	blt.b		EXPMAIN			# normal case
    7116. 

  7116. 	bra		EEXPBIG
    7117. 

  7117. 

  7118. EXPMAIN:
    7119. 

  7119. #--Step 2.
    7120. 

  7120. #--This is the normal branch:	2^(-65) <= |X| < 16380 log2.
    7121. 

  7121. 	fmov.x		(%a0),%fp0		# load input from (a0)
    7122. 

  7122. 

  7123. 	fmov.x		%fp0,%fp1
    7124. 

  7124. 	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
    7125. 

  7125. 	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
    7126. 

  7126. 	mov.l		&0,ADJFLAG(%a6)
    7127. 

  7127. 	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
    7128. 

  7128. 	lea		EEXPTBL(%pc),%a1
    7129. 

  7129. 	fmov.l		%d1,%fp0		# convert to floating-format
    7130. 

  7130. 

  7131. 	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
    7132. 

  7132. 	and.l		&0x3F,%d1		# D0 is J = N mod 64
    7133. 

  7133. 	lsl.l		&4,%d1
    7134. 

  7134. 	add.l		%d1,%a1			# address of 2^(J/64)
    7135. 

  7135. 	mov.l		L_SCR1(%a6),%d1
    7136. 

  7136. 	asr.l		&6,%d1			# D0 is M
    7137. 

  7137. 	add.w		&0x3FFF,%d1		# biased expo. of 2^(M)
    7138. 

  7138. 	mov.w		L2(%pc),L_SCR1(%a6)	# prefetch L2, no need in CB
    7139. 

  7139. 

  7140. EXPCONT1:
    7141. 

  7141. #--Step 3.
    7142. 

  7142. #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
    7143. 

  7143. #--a0 points to 2^(J/64), D0 is biased expo. of 2^(M)
    7144. 

  7144. 	fmov.x		%fp0,%fp2
    7145. 

  7145. 	fmul.s		&0xBC317218,%fp0	# N * L1, L1 = lead(-log2/64)
    7146. 

  7146. 	fmul.x		L2(%pc),%fp2		# N * L2, L1+L2 = -log2/64
    7147. 

  7147. 	fadd.x		%fp1,%fp0		# X + N*L1
    7148. 

  7148. 	fadd.x		%fp2,%fp0		# fp0 is R, reduced arg.
    7149. 

  7149. 

  7150. #--Step 4.
    7151. 

  7151. #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
    7152. 

  7152. #-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))
    7153. 

  7153. #--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
    7154. 

  7154. #--[R+R*S*(A2+S*A4)] + [S*(A1+S*(A3+S*A5))]
    7155. 

  7155. 

  7156. 	fmov.x		%fp0,%fp1
    7157. 

  7157. 	fmul.x		%fp1,%fp1		# fp1 IS S = R*R
    7158. 

  7158. 

  7159. 	fmov.s		&0x3AB60B70,%fp2	# fp2 IS A5
    7160. 

  7160. 

  7161. 	fmul.x		%fp1,%fp2		# fp2 IS S*A5
    7162. 

  7162. 	fmov.x		%fp1,%fp3
    7163. 

  7163. 	fmul.s		&0x3C088895,%fp3	# fp3 IS S*A4
    7164. 

  7164. 

  7165. 	fadd.d		EEXPA3(%pc),%fp2	# fp2 IS A3+S*A5
    7166. 

  7166. 	fadd.d		EEXPA2(%pc),%fp3	# fp3 IS A2+S*A4
    7167. 

  7167. 

  7168. 	fmul.x		%fp1,%fp2		# fp2 IS S*(A3+S*A5)
    7169. 

  7169. 	mov.w		%d1,SCALE(%a6)		# SCALE is 2^(M) in extended
    7170. 

  7170. 	mov.l		&0x80000000,SCALE+4(%a6)
    7171. 

  7171. 	clr.l		SCALE+8(%a6)
    7172. 

  7172. 

  7173. 	fmul.x		%fp1,%fp3		# fp3 IS S*(A2+S*A4)
    7174. 

  7174. 

  7175. 	fadd.s		&0x3F000000,%fp2	# fp2 IS A1+S*(A3+S*A5)
    7176. 

  7176. 	fmul.x		%fp0,%fp3		# fp3 IS R*S*(A2+S*A4)
    7177. 

  7177. 

  7178. 	fmul.x		%fp1,%fp2		# fp2 IS S*(A1+S*(A3+S*A5))
    7179. 

  7179. 	fadd.x		%fp3,%fp0		# fp0 IS R+R*S*(A2+S*A4),
    7180. 

  7180. 

  7181. 	fmov.x		(%a1)+,%fp1		# fp1 is lead. pt. of 2^(J/64)
    7182. 

  7182. 	fadd.x		%fp2,%fp0		# fp0 is EXP(R) - 1
    7183. 

  7183. 

  7184. #--Step 5
    7185. 

  7185. #--final reconstruction process
    7186. 

  7186. #--EXP(X) = 2^M * ( 2^(J/64) + 2^(J/64)*(EXP(R)-1) )
    7187. 

  7187. 

  7188. 	fmul.x		%fp1,%fp0		# 2^(J/64)*(Exp(R)-1)
    7189. 

  7189. 	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
    7190. 

  7190. 	fadd.s		(%a1),%fp0		# accurate 2^(J/64)
    7191. 

  7191. 

  7192. 	fadd.x		%fp1,%fp0		# 2^(J/64) + 2^(J/64)*...
    7193. 

  7193. 	mov.l		ADJFLAG(%a6),%d1
    7194. 

  7194. 

  7195. #--Step 6
    7196. 

  7196. 	tst.l		%d1
    7197. 

  7197. 	beq.b		NORMAL
    7198. 

  7198. ADJUST:
    7199. 

  7199. 	fmul.x		ADJSCALE(%a6),%fp0
    7200. 

  7200. NORMAL:
    7201. 

  7201. 	fmov.l		%d0,%fpcr		# restore user FPCR
    7202. 

  7202. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    7203. 

  7203. 	fmul.x		SCALE(%a6),%fp0		# multiply 2^(M)
    7204. 

  7204. 	bra		t_catch
    7205. 

  7205. 

  7206. EXPSM:
    7207. 

  7207. #--Step 7
    7208. 

  7208. 	fmovm.x		(%a0),&0x80		# load X
    7209. 

  7209. 	fmov.l		%d0,%fpcr
    7210. 

  7210. 	fadd.s		&0x3F800000,%fp0	# 1+X in user mode
    7211. 

  7211. 	bra		t_pinx2
    7212. 

  7212. 

  7213. EEXPBIG:
    7214. 

  7214. #--Step 8
    7215. 

  7215. 	cmp.l		%d1,&0x400CB27C		# 16480 log2
    7216. 

  7216. 	bgt.b		EXP2BIG
    7217. 

  7217. #--Steps 8.2 -- 8.6
    7218. 

  7218. 	fmov.x		(%a0),%fp0		# load input from (a0)
    7219. 

  7219. 

  7220. 	fmov.x		%fp0,%fp1
    7221. 

  7221. 	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
    7222. 

  7222. 	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
    7223. 

  7223. 	mov.l		&1,ADJFLAG(%a6)
    7224. 

  7224. 	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
    7225. 

  7225. 	lea		EEXPTBL(%pc),%a1
    7226. 

  7226. 	fmov.l		%d1,%fp0		# convert to floating-format
    7227. 

  7227. 	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
    7228. 

  7228. 	and.l		&0x3F,%d1		# D0 is J = N mod 64
    7229. 

  7229. 	lsl.l		&4,%d1
    7230. 

  7230. 	add.l		%d1,%a1			# address of 2^(J/64)
    7231. 

  7231. 	mov.l		L_SCR1(%a6),%d1
    7232. 

  7232. 	asr.l		&6,%d1			# D0 is K
    7233. 

  7233. 	mov.l		%d1,L_SCR1(%a6)		# save K temporarily
    7234. 

  7234. 	asr.l		&1,%d1			# D0 is M1
    7235. 

  7235. 	sub.l		%d1,L_SCR1(%a6)		# a1 is M
    7236. 

  7236. 	add.w		&0x3FFF,%d1		# biased expo. of 2^(M1)
    7237. 

  7237. 	mov.w		%d1,ADJSCALE(%a6)	# ADJSCALE := 2^(M1)
    7238. 

  7238. 	mov.l		&0x80000000,ADJSCALE+4(%a6)
    7239. 

  7239. 	clr.l		ADJSCALE+8(%a6)
    7240. 

  7240. 	mov.l		L_SCR1(%a6),%d1		# D0 is M
    7241. 

  7241. 	add.w		&0x3FFF,%d1		# biased expo. of 2^(M)
    7242. 

  7242. 	bra.w		EXPCONT1		# go back to Step 3
    7243. 

  7243. 

  7244. EXP2BIG:
    7245. 

  7245. #--Step 9
    7246. 

  7246. 	tst.b		(%a0)			# is X positive or negative?
    7247. 

  7247. 	bmi		t_unfl2
    7248. 

  7248. 	bra		t_ovfl2
    7249. 

  7249. 

  7250. 	global		setoxd
    7251. 

  7251. setoxd:
    7252. 

  7252. #--entry point for EXP(X), X is denormalized
    7253. 

  7253. 	mov.l		(%a0),-(%sp)
    7254. 

  7254. 	andi.l		&0x80000000,(%sp)
    7255. 

  7255. 	ori.l		&0x00800000,(%sp)	# sign(X)*2^(-126)
    7256. 

  7256. 

  7257. 	fmov.s		&0x3F800000,%fp0
    7258. 

  7258. 

  7259. 	fmov.l		%d0,%fpcr
    7260. 

  7260. 	fadd.s		(%sp)+,%fp0
    7261. 

  7261. 	bra		t_pinx2
    7262. 

  7262. 

  7263. 	global		setoxm1
    7264. 

  7264. setoxm1:
    7265. 

  7265. #--entry point for EXPM1(X), here X is finite, non-zero, non-NaN
    7266. 

  7266. 

  7267. #--Step 1.
    7268. 

  7268. #--Step 1.1
    7269. 

  7269. 	mov.l		(%a0),%d1		# load part of input X
    7270. 

  7270. 	and.l		&0x7FFF0000,%d1		# biased expo. of X
    7271. 

  7271. 	cmp.l		%d1,&0x3FFD0000		# 1/4
    7272. 

  7272. 	bge.b		EM1CON1			# |X| >= 1/4
    7273. 

  7273. 	bra		EM1SM
    7274. 

  7274. 

  7275. EM1CON1:
    7276. 

  7276. #--Step 1.3
    7277. 

  7277. #--The case |X| >= 1/4
    7278. 

  7278. 	mov.w		4(%a0),%d1		# expo. and partial sig. of |X|
    7279. 

  7279. 	cmp.l		%d1,&0x4004C215		# 70log2 rounded up to 16 bits
    7280. 

  7280. 	ble.b		EM1MAIN			# 1/4 <= |X| <= 70log2
    7281. 

  7281. 	bra		EM1BIG
    7282. 

  7282. 

  7283. EM1MAIN:
    7284. 

  7284. #--Step 2.
    7285. 

  7285. #--This is the case:	1/4 <= |X| <= 70 log2.
    7286. 

  7286. 	fmov.x		(%a0),%fp0		# load input from (a0)
    7287. 

  7287. 

  7288. 	fmov.x		%fp0,%fp1
    7289. 

  7289. 	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
    7290. 

  7290. 	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
    7291. 

  7291. 	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
    7292. 

  7292. 	lea		EEXPTBL(%pc),%a1
    7293. 

  7293. 	fmov.l		%d1,%fp0		# convert to floating-format
    7294. 

  7294. 

  7295. 	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
    7296. 

  7296. 	and.l		&0x3F,%d1		# D0 is J = N mod 64
    7297. 

  7297. 	lsl.l		&4,%d1
    7298. 

  7298. 	add.l		%d1,%a1			# address of 2^(J/64)
    7299. 

  7299. 	mov.l		L_SCR1(%a6),%d1
    7300. 

  7300. 	asr.l		&6,%d1			# D0 is M
    7301. 

  7301. 	mov.l		%d1,L_SCR1(%a6)		# save a copy of M
    7302. 

  7302. 

  7303. #--Step 3.
    7304. 

  7304. #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
    7305. 

  7305. #--a0 points to 2^(J/64), D0 and a1 both contain M
    7306. 

  7306. 	fmov.x		%fp0,%fp2
    7307. 

  7307. 	fmul.s		&0xBC317218,%fp0	# N * L1, L1 = lead(-log2/64)
    7308. 

  7308. 	fmul.x		L2(%pc),%fp2		# N * L2, L1+L2 = -log2/64
    7309. 

  7309. 	fadd.x		%fp1,%fp0		# X + N*L1
    7310. 

  7310. 	fadd.x		%fp2,%fp0		# fp0 is R, reduced arg.
    7311. 

  7311. 	add.w		&0x3FFF,%d1		# D0 is biased expo. of 2^M
    7312. 

  7312. 

  7313. #--Step 4.
    7314. 

  7314. #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
    7315. 

  7315. #-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*(A5 + R*A6)))))
    7316. 

  7316. #--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
    7317. 

  7317. #--[R*S*(A2+S*(A4+S*A6))] + [R+S*(A1+S*(A3+S*A5))]
    7318. 

  7318. 

  7319. 	fmov.x		%fp0,%fp1
    7320. 

  7320. 	fmul.x		%fp1,%fp1		# fp1 IS S = R*R
    7321. 

  7321. 

  7322. 	fmov.s		&0x3950097B,%fp2	# fp2 IS a6
    7323. 

  7323. 

  7324. 	fmul.x		%fp1,%fp2		# fp2 IS S*A6
    7325. 

  7325. 	fmov.x		%fp1,%fp3
    7326. 

  7326. 	fmul.s		&0x3AB60B6A,%fp3	# fp3 IS S*A5
    7327. 

  7327. 

  7328. 	fadd.d		EM1A4(%pc),%fp2		# fp2 IS A4+S*A6
    7329. 

  7329. 	fadd.d		EM1A3(%pc),%fp3		# fp3 IS A3+S*A5
    7330. 

  7330. 	mov.w		%d1,SC(%a6)		# SC is 2^(M) in extended
    7331. 

  7331. 	mov.l		&0x80000000,SC+4(%a6)
    7332. 

  7332. 	clr.l		SC+8(%a6)
    7333. 

  7333. 

  7334. 	fmul.x		%fp1,%fp2		# fp2 IS S*(A4+S*A6)
    7335. 

  7335. 	mov.l		L_SCR1(%a6),%d1		# D0 is	M
    7336. 

  7336. 	neg.w		%d1			# D0 is -M
    7337. 

  7337. 	fmul.x		%fp1,%fp3		# fp3 IS S*(A3+S*A5)
    7338. 

  7338. 	add.w		&0x3FFF,%d1		# biased expo. of 2^(-M)
    7339. 

  7339. 	fadd.d		EM1A2(%pc),%fp2		# fp2 IS A2+S*(A4+S*A6)
    7340. 

  7340. 	fadd.s		&0x3F000000,%fp3	# fp3 IS A1+S*(A3+S*A5)
    7341. 

  7341. 

  7342. 	fmul.x		%fp1,%fp2		# fp2 IS S*(A2+S*(A4+S*A6))
    7343. 

  7343. 	or.w		&0x8000,%d1		# signed/expo. of -2^(-M)
    7344. 

  7344. 	mov.w		%d1,ONEBYSC(%a6)	# OnebySc is -2^(-M)
    7345. 

  7345. 	mov.l		&0x80000000,ONEBYSC+4(%a6)
    7346. 

  7346. 	clr.l		ONEBYSC+8(%a6)
    7347. 

  7347. 	fmul.x		%fp3,%fp1		# fp1 IS S*(A1+S*(A3+S*A5))
    7348. 

  7348. 

  7349. 	fmul.x		%fp0,%fp2		# fp2 IS R*S*(A2+S*(A4+S*A6))
    7350. 

  7350. 	fadd.x		%fp1,%fp0		# fp0 IS R+S*(A1+S*(A3+S*A5))
    7351. 

  7351. 

  7352. 	fadd.x		%fp2,%fp0		# fp0 IS EXP(R)-1
    7353. 

  7353. 

  7354. 	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
    7355. 

  7355. 

  7356. #--Step 5
    7357. 

  7357. #--Compute 2^(J/64)*p
    7358. 

  7358. 

  7359. 	fmul.x		(%a1),%fp0		# 2^(J/64)*(Exp(R)-1)
    7360. 

  7360. 

  7361. #--Step 6
    7362. 

  7362. #--Step 6.1
    7363. 

  7363. 	mov.l		L_SCR1(%a6),%d1		# retrieve M
    7364. 

  7364. 	cmp.l		%d1,&63
    7365. 

  7365. 	ble.b		MLE63
    7366. 

  7366. #--Step 6.2	M >= 64
    7367. 

  7367. 	fmov.s		12(%a1),%fp1		# fp1 is t
    7368. 

  7368. 	fadd.x		ONEBYSC(%a6),%fp1	# fp1 is t+OnebySc
    7369. 

  7369. 	fadd.x		%fp1,%fp0		# p+(t+OnebySc), fp1 released
    7370. 

  7370. 	fadd.x		(%a1),%fp0		# T+(p+(t+OnebySc))
    7371. 

  7371. 	bra		EM1SCALE
    7372. 

  7372. MLE63:
    7373. 

  7373. #--Step 6.3	M <= 63
    7374. 

  7374. 	cmp.l		%d1,&-3
    7375. 

  7375. 	bge.b		MGEN3
    7376. 

  7376. MLTN3:
    7377. 

  7377. #--Step 6.4	M <= -4
    7378. 

  7378. 	fadd.s		12(%a1),%fp0		# p+t
    7379. 

  7379. 	fadd.x		(%a1),%fp0		# T+(p+t)
    7380. 

  7380. 	fadd.x		ONEBYSC(%a6),%fp0	# OnebySc + (T+(p+t))
    7381. 

  7381. 	bra		EM1SCALE
    7382. 

  7382. MGEN3:
    7383. 

  7383. #--Step 6.5	-3 <= M <= 63
    7384. 

  7384. 	fmov.x		(%a1)+,%fp1		# fp1 is T
    7385. 

  7385. 	fadd.s		(%a1),%fp0		# fp0 is p+t
    7386. 

  7386. 	fadd.x		ONEBYSC(%a6),%fp1	# fp1 is T+OnebySc
    7387. 

  7387. 	fadd.x		%fp1,%fp0		# (T+OnebySc)+(p+t)
    7388. 

  7388. 

  7389. EM1SCALE:
    7390. 

  7390. #--Step 6.6
    7391. 

  7391. 	fmov.l		%d0,%fpcr
    7392. 

  7392. 	fmul.x		SC(%a6),%fp0
    7393. 

  7393. 	bra		t_inx2
    7394. 

  7394. 

  7395. EM1SM:
    7396. 

  7396. #--Step 7	|X| < 1/4.
    7397. 

  7397. 	cmp.l		%d1,&0x3FBE0000		# 2^(-65)
    7398. 

  7398. 	bge.b		EM1POLY
    7399. 

  7399. 

  7400. EM1TINY:
    7401. 

  7401. #--Step 8	|X| < 2^(-65)
    7402. 

  7402. 	cmp.l		%d1,&0x00330000		# 2^(-16312)
    7403. 

  7403. 	blt.b		EM12TINY
    7404. 

  7404. #--Step 8.2
    7405. 

  7405. 	mov.l		&0x80010000,SC(%a6)	# SC is -2^(-16382)
    7406. 

  7406. 	mov.l		&0x80000000,SC+4(%a6)
    7407. 

  7407. 	clr.l		SC+8(%a6)
    7408. 

  7408. 	fmov.x		(%a0),%fp0
    7409. 

  7409. 	fmov.l		%d0,%fpcr
    7410. 

  7410. 	mov.b		&FADD_OP,%d1		# last inst is ADD
    7411. 

  7411. 	fadd.x		SC(%a6),%fp0
    7412. 

  7412. 	bra		t_catch
    7413. 

  7413. 

  7414. EM12TINY:
    7415. 

  7415. #--Step 8.3
    7416. 

  7416. 	fmov.x		(%a0),%fp0
    7417. 

  7417. 	fmul.d		TWO140(%pc),%fp0
    7418. 

  7418. 	mov.l		&0x80010000,SC(%a6)
    7419. 

  7419. 	mov.l		&0x80000000,SC+4(%a6)
    7420. 

  7420. 	clr.l		SC+8(%a6)
    7421. 

  7421. 	fadd.x		SC(%a6),%fp0
    7422. 

  7422. 	fmov.l		%d0,%fpcr
    7423. 

  7423. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    7424. 

  7424. 	fmul.d		TWON140(%pc),%fp0
    7425. 

  7425. 	bra		t_catch
    7426. 

  7426. 

  7427. EM1POLY:
    7428. 

  7428. #--Step 9	exp(X)-1 by a simple polynomial
    7429. 

  7429. 	fmov.x		(%a0),%fp0		# fp0 is X
    7430. 

  7430. 	fmul.x		%fp0,%fp0		# fp0 is S := X*X
    7431. 

  7431. 	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
    7432. 

  7432. 	fmov.s		&0x2F30CAA8,%fp1	# fp1 is B12
    7433. 

  7433. 	fmul.x		%fp0,%fp1		# fp1 is S*B12
    7434. 

  7434. 	fmov.s		&0x310F8290,%fp2	# fp2 is B11
    7435. 

  7435. 	fadd.s		&0x32D73220,%fp1	# fp1 is B10+S*B12
    7436. 

  7436. 

  7437. 	fmul.x		%fp0,%fp2		# fp2 is S*B11
    7438. 

  7438. 	fmul.x		%fp0,%fp1		# fp1 is S*(B10 + ...
    7439. 

  7439. 

  7440. 	fadd.s		&0x3493F281,%fp2	# fp2 is B9+S*...
    7441. 

  7441. 	fadd.d		EM1B8(%pc),%fp1		# fp1 is B8+S*...
    7442. 

  7442. 

  7443. 	fmul.x		%fp0,%fp2		# fp2 is S*(B9+...
    7444. 

  7444. 	fmul.x		%fp0,%fp1		# fp1 is S*(B8+...
    7445. 

  7445. 

  7446. 	fadd.d		EM1B7(%pc),%fp2		# fp2 is B7+S*...
    7447. 

  7447. 	fadd.d		EM1B6(%pc),%fp1		# fp1 is B6+S*...
    7448. 

  7448. 

  7449. 	fmul.x		%fp0,%fp2		# fp2 is S*(B7+...
    7450. 

  7450. 	fmul.x		%fp0,%fp1		# fp1 is S*(B6+...
    7451. 

  7451. 

  7452. 	fadd.d		EM1B5(%pc),%fp2		# fp2 is B5+S*...
    7453. 

  7453. 	fadd.d		EM1B4(%pc),%fp1		# fp1 is B4+S*...
    7454. 

  7454. 

  7455. 	fmul.x		%fp0,%fp2		# fp2 is S*(B5+...
    7456. 

  7456. 	fmul.x		%fp0,%fp1		# fp1 is S*(B4+...
    7457. 

  7457. 

  7458. 	fadd.d		EM1B3(%pc),%fp2		# fp2 is B3+S*...
    7459. 

  7459. 	fadd.x		EM1B2(%pc),%fp1		# fp1 is B2+S*...
    7460. 

  7460. 

  7461. 	fmul.x		%fp0,%fp2		# fp2 is S*(B3+...
    7462. 

  7462. 	fmul.x		%fp0,%fp1		# fp1 is S*(B2+...
    7463. 

  7463. 

  7464. 	fmul.x		%fp0,%fp2		# fp2 is S*S*(B3+...)
    7465. 

  7465. 	fmul.x		(%a0),%fp1		# fp1 is X*S*(B2...
    7466. 

  7466. 

  7467. 	fmul.s		&0x3F000000,%fp0	# fp0 is S*B1
    7468. 

  7468. 	fadd.x		%fp2,%fp1		# fp1 is Q
    7469. 

  7469. 

  7470. 	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
    7471. 

  7471. 

  7472. 	fadd.x		%fp1,%fp0		# fp0 is S*B1+Q
    7473. 

  7473. 

  7474. 	fmov.l		%d0,%fpcr
    7475. 

  7475. 	fadd.x		(%a0),%fp0
    7476. 

  7476. 	bra		t_inx2
    7477. 

  7477. 

  7478. EM1BIG:
    7479. 

  7479. #--Step 10	|X| > 70 log2
    7480. 

  7480. 	mov.l		(%a0),%d1
    7481. 

  7481. 	cmp.l		%d1,&0
    7482. 

  7482. 	bgt.w		EXPC1
    7483. 

  7483. #--Step 10.2
    7484. 

  7484. 	fmov.s		&0xBF800000,%fp0	# fp0 is -1
    7485. 

  7485. 	fmov.l		%d0,%fpcr
    7486. 

  7486. 	fadd.s		&0x00800000,%fp0	# -1 + 2^(-126)
    7487. 

  7487. 	bra		t_minx2
    7488. 

  7488. 

  7489. 	global		setoxm1d
    7490. 

  7490. setoxm1d:
    7491. 

  7491. #--entry point for EXPM1(X), here X is denormalized
    7492. 

  7492. #--Step 0.
    7493. 

  7493. 	bra		t_extdnrm
    7494. 

  7494. 

  7495. #########################################################################
    7496. 

  7496. # sgetexp():  returns the exponent portion of the input argument.	#
    7497. 

  7497. #	      The exponent bias is removed and the exponent value is	#
    7498. 

  7498. #	      returned as an extended precision number in fp0.		#
    7499. 

  7499. # sgetexpd(): handles denormalized numbers.				#
    7500. 

  7500. #									#
    7501. 

  7501. # sgetman():  extracts the mantissa of the input argument. The		#
    7502. 

  7502. #	      mantissa is converted to an extended precision number w/	#
    7503. 

  7503. #	      an exponent of $3fff and is returned in fp0. The range of #
    7504. 

  7504. #	      the result is [1.0 - 2.0).				#
    7505. 

  7505. # sgetmand(): handles denormalized numbers.				#
    7506. 

  7506. #									#
    7507. 

  7507. # INPUT *************************************************************** #
    7508. 

  7508. #	a0  = pointer to extended precision input			#
    7509. 

  7509. #									#
    7510. 

  7510. # OUTPUT ************************************************************** #
    7511. 

  7511. #	fp0 = exponent(X) or mantissa(X)				#
    7512. 

  7512. #									#
    7513. 

  7513. #########################################################################
    7514. 

  7514. 

  7515. 	global		sgetexp
    7516. 

  7516. sgetexp:
    7517. 

  7517. 	mov.w		SRC_EX(%a0),%d0		# get the exponent
    7518. 

  7518. 	bclr		&0xf,%d0		# clear the sign bit
    7519. 

  7519. 	subi.w		&0x3fff,%d0		# subtract off the bias
    7520. 

  7520. 	fmov.w		%d0,%fp0		# return exp in fp0
    7521. 

  7521. 	blt.b		sgetexpn		# it's negative
    7522. 

  7522. 	rts
    7523. 

  7523. 

  7524. sgetexpn:
    7525. 

  7525. 	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
    7526. 

  7526. 	rts
    7527. 

  7527. 

  7528. 	global		sgetexpd
    7529. 

  7529. sgetexpd:
    7530. 

  7530. 	bsr.l		norm			# normalize
    7531. 

  7531. 	neg.w		%d0			# new exp = -(shft amt)
    7532. 

  7532. 	subi.w		&0x3fff,%d0		# subtract off the bias
    7533. 

  7533. 	fmov.w		%d0,%fp0		# return exp in fp0
    7534. 

  7534. 	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
    7535. 

  7535. 	rts
    7536. 

  7536. 

  7537. 	global		sgetman
    7538. 

  7538. sgetman:
    7539. 

  7539. 	mov.w		SRC_EX(%a0),%d0		# get the exp
    7540. 

  7540. 	ori.w		&0x7fff,%d0		# clear old exp
    7541. 

  7541. 	bclr		&0xe,%d0		# make it the new exp +-3fff
    7542. 

  7542. 

  7543. # here, we build the result in a tmp location so as not to disturb the input
    7544. 

  7544. 	mov.l		SRC_HI(%a0),FP_SCR0_HI(%a6) # copy to tmp loc
    7545. 

  7545. 	mov.l		SRC_LO(%a0),FP_SCR0_LO(%a6) # copy to tmp loc
    7546. 

  7546. 	mov.w		%d0,FP_SCR0_EX(%a6)	# insert new exponent
    7547. 

  7547. 	fmov.x		FP_SCR0(%a6),%fp0	# put new value back in fp0
    7548. 

  7548. 	bmi.b		sgetmann		# it's negative
    7549. 

  7549. 	rts
    7550. 

  7550. 

  7551. sgetmann:
    7552. 

  7552. 	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
    7553. 

  7553. 	rts
    7554. 

  7554. 

  7555. #
    7556. 

  7556. # For denormalized numbers, shift the mantissa until the j-bit = 1,
    7557. 

  7557. # then load the exponent with +/1 $3fff.
    7558. 

  7558. #
    7559. 

  7559. 	global		sgetmand
    7560. 

  7560. sgetmand:
    7561. 

  7561. 	bsr.l		norm			# normalize exponent
    7562. 

  7562. 	bra.b		sgetman
    7563. 

  7563. 

  7564. #########################################################################
    7565. 

  7565. # scosh():  computes the hyperbolic cosine of a normalized input	#
    7566. 

  7566. # scoshd(): computes the hyperbolic cosine of a denormalized input	#
    7567. 

  7567. #									#
    7568. 

  7568. # INPUT ***************************************************************	#
    7569. 

  7569. #	a0 = pointer to extended precision input			#
    7570. 

  7570. #	d0 = round precision,mode					#
    7571. 

  7571. #									#
    7572. 

  7572. # OUTPUT **************************************************************	#
    7573. 

  7573. #	fp0 = cosh(X)							#
    7574. 

  7574. #									#
    7575. 

  7575. # ACCURACY and MONOTONICITY *******************************************	#
    7576. 

  7576. #	The returned result is within 3 ulps in 64 significant bit,	#
    7577. 

  7577. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
    7578. 

  7578. #	rounded to double precision. The result is provably monotonic	#
    7579. 

  7579. #	in double precision.						#
    7580. 

  7580. #									#
    7581. 

  7581. # ALGORITHM ***********************************************************	#
    7582. 

  7582. #									#
    7583. 

  7583. #	COSH								#
    7584. 

  7584. #	1. If |X| > 16380 log2, go to 3.				#
    7585. 

  7585. #									#
    7586. 

  7586. #	2. (|X| <= 16380 log2) Cosh(X) is obtained by the formulae	#
    7587. 

  7587. #		y = |X|, z = exp(Y), and				#
    7588. 

  7588. #		cosh(X) = (1/2)*( z + 1/z ).				#
    7589. 

  7589. #		Exit.							#
    7590. 

  7590. #									#
    7591. 

  7591. #	3. (|X| > 16380 log2). If |X| > 16480 log2, go to 5.		#
    7592. 

  7592. #									#
    7593. 

  7593. #	4. (16380 log2 < |X| <= 16480 log2)				#
    7594. 

  7594. #		cosh(X) = sign(X) * exp(|X|)/2.				#
    7595. 

  7595. #		However, invoking exp(|X|) may cause premature		#
    7596. 

  7596. #		overflow. Thus, we calculate sinh(X) as follows:	#
    7597. 

  7597. #		Y	:= |X|						#
    7598. 

  7598. #		Fact	:=	2**(16380)				#
    7599. 

  7599. #		Y'	:= Y - 16381 log2				#
    7600. 

  7600. #		cosh(X) := Fact * exp(Y').				#
    7601. 

  7601. #		Exit.							#
    7602. 

  7602. #									#
    7603. 

  7603. #	5. (|X| > 16480 log2) sinh(X) must overflow. Return		#
    7604. 

  7604. #		Huge*Huge to generate overflow and an infinity with	#
    7605. 

  7605. #		the appropriate sign. Huge is the largest finite number	#
    7606. 

  7606. #		in extended format. Exit.				#
    7607. 

  7607. #									#
    7608. 

  7608. #########################################################################
    7609. 

  7609. 

  7610. TWO16380:
    7611. 

  7611. 	long		0x7FFB0000,0x80000000,0x00000000,0x00000000
    7612. 

  7612. 

  7613. 	global		scosh
    7614. 

  7614. scosh:
    7615. 

  7615. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    7616. 

  7616. 

  7617. 	mov.l		(%a0),%d1
    7618. 

  7618. 	mov.w		4(%a0),%d1
    7619. 

  7619. 	and.l		&0x7FFFFFFF,%d1
    7620. 

  7620. 	cmp.l		%d1,&0x400CB167
    7621. 

  7621. 	bgt.b		COSHBIG
    7622. 

  7622. 

  7623. #--THIS IS THE USUAL CASE, |X| < 16380 LOG2
    7624. 

  7624. #--COSH(X) = (1/2) * ( EXP(X) + 1/EXP(X) )
    7625. 

  7625. 

  7626. 	fabs.x		%fp0			# |X|
    7627. 

  7627. 

  7628. 	mov.l		%d0,-(%sp)
    7629. 

  7629. 	clr.l		%d0
    7630. 

  7630. 	fmovm.x		&0x01,-(%sp)		# save |X| to stack
    7631. 

  7631. 	lea		(%sp),%a0		# pass ptr to |X|
    7632. 

  7632. 	bsr		setox			# FP0 IS EXP(|X|)
    7633. 

  7633. 	add.l		&0xc,%sp		# erase |X| from stack
    7634. 

  7634. 	fmul.s		&0x3F000000,%fp0	# (1/2)EXP(|X|)
    7635. 

  7635. 	mov.l		(%sp)+,%d0
    7636. 

  7636. 

  7637. 	fmov.s		&0x3E800000,%fp1	# (1/4)
    7638. 

  7638. 	fdiv.x		%fp0,%fp1		# 1/(2 EXP(|X|))
    7639. 

  7639. 

  7640. 	fmov.l		%d0,%fpcr
    7641. 

  7641. 	mov.b		&FADD_OP,%d1		# last inst is ADD
    7642. 

  7642. 	fadd.x		%fp1,%fp0
    7643. 

  7643. 	bra		t_catch
    7644. 

  7644. 

  7645. COSHBIG:
    7646. 

  7646. 	cmp.l		%d1,&0x400CB2B3
    7647. 

  7647. 	bgt.b		COSHHUGE
    7648. 

  7648. 

  7649. 	fabs.x		%fp0
    7650. 

  7650. 	fsub.d		T1(%pc),%fp0		# (|X|-16381LOG2_LEAD)
    7651. 

  7651. 	fsub.d		T2(%pc),%fp0		# |X| - 16381 LOG2, ACCURATE
    7652. 

  7652. 

  7653. 	mov.l		%d0,-(%sp)
    7654. 

  7654. 	clr.l		%d0
    7655. 

  7655. 	fmovm.x		&0x01,-(%sp)		# save fp0 to stack
    7656. 

  7656. 	lea		(%sp),%a0		# pass ptr to fp0
    7657. 

  7657. 	bsr		setox
    7658. 

  7658. 	add.l		&0xc,%sp		# clear fp0 from stack
    7659. 

  7659. 	mov.l		(%sp)+,%d0
    7660. 

  7660. 

  7661. 	fmov.l		%d0,%fpcr
    7662. 

  7662. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    7663. 

  7663. 	fmul.x		TWO16380(%pc),%fp0
    7664. 

  7664. 	bra		t_catch
    7665. 

  7665. 

  7666. COSHHUGE:
    7667. 

  7667. 	bra		t_ovfl2
    7668. 

  7668. 

  7669. 	global		scoshd
    7670. 

  7670. #--COSH(X) = 1 FOR DENORMALIZED X
    7671. 

  7671. scoshd:
    7672. 

  7672. 	fmov.s		&0x3F800000,%fp0
    7673. 

  7673. 

  7674. 	fmov.l		%d0,%fpcr
    7675. 

  7675. 	fadd.s		&0x00800000,%fp0
    7676. 

  7676. 	bra		t_pinx2
    7677. 

  7677. 

  7678. #########################################################################
    7679. 

  7679. # ssinh():  computes the hyperbolic sine of a normalized input		#
    7680. 

  7680. # ssinhd(): computes the hyperbolic sine of a denormalized input	#
    7681. 

  7681. #									#
    7682. 

  7682. # INPUT *************************************************************** #
    7683. 

  7683. #	a0 = pointer to extended precision input			#
    7684. 

  7684. #	d0 = round precision,mode					#
    7685. 

  7685. #									#
    7686. 

  7686. # OUTPUT ************************************************************** #
    7687. 

  7687. #	fp0 = sinh(X)							#
    7688. 

  7688. #									#
    7689. 

  7689. # ACCURACY and MONOTONICITY *******************************************	#
    7690. 

  7690. #	The returned result is within 3 ulps in 64 significant bit,	#
    7691. 

  7691. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
    7692. 

  7692. #	rounded to double precision. The result is provably monotonic	#
    7693. 

  7693. #	in double precision.						#
    7694. 

  7694. #									#
    7695. 

  7695. # ALGORITHM *********************************************************** #
    7696. 

  7696. #									#
    7697. 

  7697. #       SINH								#
    7698. 

  7698. #       1. If |X| > 16380 log2, go to 3.				#
    7699. 

  7699. #									#
    7700. 

  7700. #       2. (|X| <= 16380 log2) Sinh(X) is obtained by the formula	#
    7701. 

  7701. #               y = |X|, sgn = sign(X), and z = expm1(Y),		#
    7702. 

  7702. #               sinh(X) = sgn*(1/2)*( z + z/(1+z) ).			#
    7703. 

  7703. #          Exit.							#
    7704. 

  7704. #									#
    7705. 

  7705. #       3. If |X| > 16480 log2, go to 5.				#
    7706. 

  7706. #									#
    7707. 

  7707. #       4. (16380 log2 < |X| <= 16480 log2)				#
    7708. 

  7708. #               sinh(X) = sign(X) * exp(|X|)/2.				#
    7709. 

  7709. #          However, invoking exp(|X|) may cause premature overflow.	#
    7710. 

  7710. #          Thus, we calculate sinh(X) as follows:			#
    7711. 

  7711. #             Y       := |X|						#
    7712. 

  7712. #             sgn     := sign(X)					#
    7713. 

  7713. #             sgnFact := sgn * 2**(16380)				#
    7714. 

  7714. #             Y'      := Y - 16381 log2					#
    7715. 

  7715. #             sinh(X) := sgnFact * exp(Y').				#
    7716. 

  7716. #          Exit.							#
    7717. 

  7717. #									#
    7718. 

  7718. #       5. (|X| > 16480 log2) sinh(X) must overflow. Return		#
    7719. 

  7719. #          sign(X)*Huge*Huge to generate overflow and an infinity with	#
    7720. 

  7720. #          the appropriate sign. Huge is the largest finite number in	#
    7721. 

  7721. #          extended format. Exit.					#
    7722. 

  7722. #									#
    7723. 

  7723. #########################################################################
    7724. 

  7724. 

  7725. 	global		ssinh
    7726. 

  7726. ssinh:
    7727. 

  7727. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    7728. 

  7728. 

  7729. 	mov.l		(%a0),%d1
    7730. 

  7730. 	mov.w		4(%a0),%d1
    7731. 

  7731. 	mov.l		%d1,%a1			# save (compacted) operand
    7732. 

  7732. 	and.l		&0x7FFFFFFF,%d1
    7733. 

  7733. 	cmp.l		%d1,&0x400CB167
    7734. 

  7734. 	bgt.b		SINHBIG
    7735. 

  7735. 

  7736. #--THIS IS THE USUAL CASE, |X| < 16380 LOG2
    7737. 

  7737. #--Y = |X|, Z = EXPM1(Y), SINH(X) = SIGN(X)*(1/2)*( Z + Z/(1+Z) )
    7738. 

  7738. 

  7739. 	fabs.x		%fp0			# Y = |X|
    7740. 

  7740. 

  7741. 	movm.l		&0x8040,-(%sp)		# {a1/d0}
    7742. 

  7742. 	fmovm.x		&0x01,-(%sp)		# save Y on stack
    7743. 

  7743. 	lea		(%sp),%a0		# pass ptr to Y
    7744. 

  7744. 	clr.l		%d0
    7745. 

  7745. 	bsr		setoxm1			# FP0 IS Z = EXPM1(Y)
    7746. 

  7746. 	add.l		&0xc,%sp		# clear Y from stack
    7747. 

  7747. 	fmov.l		&0,%fpcr
    7748. 

  7748. 	movm.l		(%sp)+,&0x0201		# {a1/d0}
    7749. 

  7749. 

  7750. 	fmov.x		%fp0,%fp1
    7751. 

  7751. 	fadd.s		&0x3F800000,%fp1	# 1+Z
    7752. 

  7752. 	fmov.x		%fp0,-(%sp)
    7753. 

  7753. 	fdiv.x		%fp1,%fp0		# Z/(1+Z)
    7754. 

  7754. 	mov.l		%a1,%d1
    7755. 

  7755. 	and.l		&0x80000000,%d1
    7756. 

  7756. 	or.l		&0x3F000000,%d1
    7757. 

  7757. 	fadd.x		(%sp)+,%fp0
    7758. 

  7758. 	mov.l		%d1,-(%sp)
    7759. 

  7759. 

  7760. 	fmov.l		%d0,%fpcr
    7761. 

  7761. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    7762. 

  7762. 	fmul.s		(%sp)+,%fp0		# last fp inst - possible exceptions set
    7763. 

  7763. 	bra		t_catch
    7764. 

  7764. 

  7765. SINHBIG:
    7766. 

  7766. 	cmp.l		%d1,&0x400CB2B3
    7767. 

  7767. 	bgt		t_ovfl
    7768. 

  7768. 	fabs.x		%fp0
    7769. 

  7769. 	fsub.d		T1(%pc),%fp0		# (|X|-16381LOG2_LEAD)
    7770. 

  7770. 	mov.l		&0,-(%sp)
    7771. 

  7771. 	mov.l		&0x80000000,-(%sp)
    7772. 

  7772. 	mov.l		%a1,%d1
    7773. 

  7773. 	and.l		&0x80000000,%d1
    7774. 

  7774. 	or.l		&0x7FFB0000,%d1
    7775. 

  7775. 	mov.l		%d1,-(%sp)		# EXTENDED FMT
    7776. 

  7776. 	fsub.d		T2(%pc),%fp0		# |X| - 16381 LOG2, ACCURATE
    7777. 

  7777. 

  7778. 	mov.l		%d0,-(%sp)
    7779. 

  7779. 	clr.l		%d0
    7780. 

  7780. 	fmovm.x		&0x01,-(%sp)		# save fp0 on stack
    7781. 

  7781. 	lea		(%sp),%a0		# pass ptr to fp0
    7782. 

  7782. 	bsr		setox
    7783. 

  7783. 	add.l		&0xc,%sp		# clear fp0 from stack
    7784. 

  7784. 

  7785. 	mov.l		(%sp)+,%d0
    7786. 

  7786. 	fmov.l		%d0,%fpcr
    7787. 

  7787. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    7788. 

  7788. 	fmul.x		(%sp)+,%fp0		# possible exception
    7789. 

  7789. 	bra		t_catch
    7790. 

  7790. 

  7791. 	global		ssinhd
    7792. 

  7792. #--SINH(X) = X FOR DENORMALIZED X
    7793. 

  7793. ssinhd:
    7794. 

  7794. 	bra		t_extdnrm
    7795. 

  7795. 

  7796. #########################################################################
    7797. 

  7797. # stanh():  computes the hyperbolic tangent of a normalized input	#
    7798. 

  7798. # stanhd(): computes the hyperbolic tangent of a denormalized input	#
    7799. 

  7799. #									#
    7800. 

  7800. # INPUT ***************************************************************	#
    7801. 

  7801. #	a0 = pointer to extended precision input			#
    7802. 

  7802. #	d0 = round precision,mode					#
    7803. 

  7803. #									#
    7804. 

  7804. # OUTPUT **************************************************************	#
    7805. 

  7805. #	fp0 = tanh(X)							#
    7806. 

  7806. #									#
    7807. 

  7807. # ACCURACY and MONOTONICITY *******************************************	#
    7808. 

  7808. #	The returned result is within 3 ulps in 64 significant bit,	#
    7809. 

  7809. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
    7810. 

  7810. #	rounded to double precision. The result is provably monotonic	#
    7811. 

  7811. #	in double precision.						#
    7812. 

  7812. #									#
    7813. 

  7813. # ALGORITHM ***********************************************************	#
    7814. 

  7814. #									#
    7815. 

  7815. #	TANH								#
    7816. 

  7816. #	1. If |X| >= (5/2) log2 or |X| <= 2**(-40), go to 3.		#
    7817. 

  7817. #									#
    7818. 

  7818. #	2. (2**(-40) < |X| < (5/2) log2) Calculate tanh(X) by		#
    7819. 

  7819. #		sgn := sign(X), y := 2|X|, z := expm1(Y), and		#
    7820. 

  7820. #		tanh(X) = sgn*( z/(2+z) ).				#
    7821. 

  7821. #		Exit.							#
    7822. 

  7822. #									#
    7823. 

  7823. #	3. (|X| <= 2**(-40) or |X| >= (5/2) log2). If |X| < 1,		#
    7824. 

  7824. #		go to 7.						#
    7825. 

  7825. #									#
    7826. 

  7826. #	4. (|X| >= (5/2) log2) If |X| >= 50 log2, go to 6.		#
    7827. 

  7827. #									#
    7828. 

  7828. #	5. ((5/2) log2 <= |X| < 50 log2) Calculate tanh(X) by		#
    7829. 

  7829. #		sgn := sign(X), y := 2|X|, z := exp(Y),			#
    7830. 

  7830. #		tanh(X) = sgn - [ sgn*2/(1+z) ].			#
    7831. 

  7831. #		Exit.							#
    7832. 

  7832. #									#
    7833. 

  7833. #	6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we	#
    7834. 

  7834. #		calculate Tanh(X) by					#
    7835. 

  7835. #		sgn := sign(X), Tiny := 2**(-126),			#
    7836. 

  7836. #		tanh(X) := sgn - sgn*Tiny.				#
    7837. 

  7837. #		Exit.							#
    7838. 

  7838. #									#
    7839. 

  7839. #	7. (|X| < 2**(-40)). Tanh(X) = X.	Exit.			#
    7840. 

  7840. #									#
    7841. 

  7841. #########################################################################
    7842. 

  7842. 

  7843. 	set		X,FP_SCR0
    7844. 

  7844. 	set		XFRAC,X+4
    7845. 

  7845. 

  7846. 	set		SGN,L_SCR3
    7847. 

  7847. 

  7848. 	set		V,FP_SCR0
    7849. 

  7849. 

  7850. 	global		stanh
    7851. 

  7851. stanh:
    7852. 

  7852. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    7853. 

  7853. 

  7854. 	fmov.x		%fp0,X(%a6)
    7855. 

  7855. 	mov.l		(%a0),%d1
    7856. 

  7856. 	mov.w		4(%a0),%d1
    7857. 

  7857. 	mov.l		%d1,X(%a6)
    7858. 

  7858. 	and.l		&0x7FFFFFFF,%d1
    7859. 

  7859. 	cmp.l		%d1, &0x3fd78000	# is |X| < 2^(-40)?
    7860. 

  7860. 	blt.w		TANHBORS		# yes
    7861. 

  7861. 	cmp.l		%d1, &0x3fffddce	# is |X| > (5/2)LOG2?
    7862. 

  7862. 	bgt.w		TANHBORS		# yes
    7863. 

  7863. 

  7864. #--THIS IS THE USUAL CASE
    7865. 

  7865. #--Y = 2|X|, Z = EXPM1(Y), TANH(X) = SIGN(X) * Z / (Z+2).
    7866. 

  7866. 

  7867. 	mov.l		X(%a6),%d1
    7868. 

  7868. 	mov.l		%d1,SGN(%a6)
    7869. 

  7869. 	and.l		&0x7FFF0000,%d1
    7870. 

  7870. 	add.l		&0x00010000,%d1		# EXPONENT OF 2|X|
    7871. 

  7871. 	mov.l		%d1,X(%a6)
    7872. 

  7872. 	and.l		&0x80000000,SGN(%a6)
    7873. 

  7873. 	fmov.x		X(%a6),%fp0		# FP0 IS Y = 2|X|
    7874. 

  7874. 

  7875. 	mov.l		%d0,-(%sp)
    7876. 

  7876. 	clr.l		%d0
    7877. 

  7877. 	fmovm.x		&0x1,-(%sp)		# save Y on stack
    7878. 

  7878. 	lea		(%sp),%a0		# pass ptr to Y
    7879. 

  7879. 	bsr		setoxm1			# FP0 IS Z = EXPM1(Y)
    7880. 

  7880. 	add.l		&0xc,%sp		# clear Y from stack
    7881. 

  7881. 	mov.l		(%sp)+,%d0
    7882. 

  7882. 

  7883. 	fmov.x		%fp0,%fp1
    7884. 

  7884. 	fadd.s		&0x40000000,%fp1	# Z+2
    7885. 

  7885. 	mov.l		SGN(%a6),%d1
    7886. 

  7886. 	fmov.x		%fp1,V(%a6)
    7887. 

  7887. 	eor.l		%d1,V(%a6)
    7888. 

  7888. 

  7889. 	fmov.l		%d0,%fpcr		# restore users round prec,mode
    7890. 

  7890. 	fdiv.x		V(%a6),%fp0
    7891. 

  7891. 	bra		t_inx2
    7892. 

  7892. 

  7893. TANHBORS:
    7894. 

  7894. 	cmp.l		%d1,&0x3FFF8000
    7895. 

  7895. 	blt.w		TANHSM
    7896. 

  7896. 

  7897. 	cmp.l		%d1,&0x40048AA1
    7898. 

  7898. 	bgt.w		TANHHUGE
    7899. 

  7899. 

  7900. #-- (5/2) LOG2 < |X| < 50 LOG2,
    7901. 

  7901. #--TANH(X) = 1 - (2/[EXP(2X)+1]). LET Y = 2|X|, SGN = SIGN(X),
    7902. 

  7902. #--TANH(X) = SGN -	SGN*2/[EXP(Y)+1].
    7903. 

  7903. 

  7904. 	mov.l		X(%a6),%d1
    7905. 

  7905. 	mov.l		%d1,SGN(%a6)
    7906. 

  7906. 	and.l		&0x7FFF0000,%d1
    7907. 

  7907. 	add.l		&0x00010000,%d1		# EXPO OF 2|X|
    7908. 

  7908. 	mov.l		%d1,X(%a6)		# Y = 2|X|
    7909. 

  7909. 	and.l		&0x80000000,SGN(%a6)
    7910. 

  7910. 	mov.l		SGN(%a6),%d1
    7911. 

  7911. 	fmov.x		X(%a6),%fp0		# Y = 2|X|
    7912. 

  7912. 

  7913. 	mov.l		%d0,-(%sp)
    7914. 

  7914. 	clr.l		%d0
    7915. 

  7915. 	fmovm.x		&0x01,-(%sp)		# save Y on stack
    7916. 

  7916. 	lea		(%sp),%a0		# pass ptr to Y
    7917. 

  7917. 	bsr		setox			# FP0 IS EXP(Y)
    7918. 

  7918. 	add.l		&0xc,%sp		# clear Y from stack
    7919. 

  7919. 	mov.l		(%sp)+,%d0
    7920. 

  7920. 	mov.l		SGN(%a6),%d1
    7921. 

  7921. 	fadd.s		&0x3F800000,%fp0	# EXP(Y)+1
    7922. 

  7922. 

  7923. 	eor.l		&0xC0000000,%d1		# -SIGN(X)*2
    7924. 

  7924. 	fmov.s		%d1,%fp1		# -SIGN(X)*2 IN SGL FMT
    7925. 

  7925. 	fdiv.x		%fp0,%fp1		# -SIGN(X)2 / [EXP(Y)+1 ]
    7926. 

  7926. 

  7927. 	mov.l		SGN(%a6),%d1
    7928. 

  7928. 	or.l		&0x3F800000,%d1		# SGN
    7929. 

  7929. 	fmov.s		%d1,%fp0		# SGN IN SGL FMT
    7930. 

  7930. 

  7931. 	fmov.l		%d0,%fpcr		# restore users round prec,mode
    7932. 

  7932. 	mov.b		&FADD_OP,%d1		# last inst is ADD
    7933. 

  7933. 	fadd.x		%fp1,%fp0
    7934. 

  7934. 	bra		t_inx2
    7935. 

  7935. 

  7936. TANHSM:
    7937. 

  7937. 	fmov.l		%d0,%fpcr		# restore users round prec,mode
    7938. 

  7938. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    7939. 

  7939. 	fmov.x		X(%a6),%fp0		# last inst - possible exception set
    7940. 

  7940. 	bra		t_catch
    7941. 

  7941. 

  7942. #---RETURN SGN(X) - SGN(X)EPS
    7943. 

  7943. TANHHUGE:
    7944. 

  7944. 	mov.l		X(%a6),%d1
    7945. 

  7945. 	and.l		&0x80000000,%d1
    7946. 

  7946. 	or.l		&0x3F800000,%d1
    7947. 

  7947. 	fmov.s		%d1,%fp0
    7948. 

  7948. 	and.l		&0x80000000,%d1
    7949. 

  7949. 	eor.l		&0x80800000,%d1		# -SIGN(X)*EPS
    7950. 

  7950. 

  7951. 	fmov.l		%d0,%fpcr		# restore users round prec,mode
    7952. 

  7952. 	fadd.s		%d1,%fp0
    7953. 

  7953. 	bra		t_inx2
    7954. 

  7954. 

  7955. 	global		stanhd
    7956. 

  7956. #--TANH(X) = X FOR DENORMALIZED X
    7957. 

  7957. stanhd:
    7958. 

  7958. 	bra		t_extdnrm
    7959. 

  7959. 

  7960. #########################################################################
    7961. 

  7961. # slogn():    computes the natural logarithm of a normalized input	#
    7962. 

  7962. # slognd():   computes the natural logarithm of a denormalized input	#
    7963. 

  7963. # slognp1():  computes the log(1+X) of a normalized input		#
    7964. 

  7964. # slognp1d(): computes the log(1+X) of a denormalized input		#
    7965. 

  7965. #									#
    7966. 

  7966. # INPUT ***************************************************************	#
    7967. 

  7967. #	a0 = pointer to extended precision input			#
    7968. 

  7968. #	d0 = round precision,mode					#
    7969. 

  7969. #									#
    7970. 

  7970. # OUTPUT **************************************************************	#
    7971. 

  7971. #	fp0 = log(X) or log(1+X)					#
    7972. 

  7972. #									#
    7973. 

  7973. # ACCURACY and MONOTONICITY *******************************************	#
    7974. 

  7974. #	The returned result is within 2 ulps in 64 significant bit,	#
    7975. 

  7975. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
    7976. 

  7976. #	rounded to double precision. The result is provably monotonic	#
    7977. 

  7977. #	in double precision.						#
    7978. 

  7978. #									#
    7979. 

  7979. # ALGORITHM ***********************************************************	#
    7980. 

  7980. #	LOGN:								#
    7981. 

  7981. #	Step 1. If |X-1| < 1/16, approximate log(X) by an odd		#
    7982. 

  7982. #		polynomial in u, where u = 2(X-1)/(X+1). Otherwise,	#
    7983. 

  7983. #		move on to Step 2.					#
    7984. 

  7984. #									#
    7985. 

  7985. #	Step 2. X = 2**k * Y where 1 <= Y < 2. Define F to be the first	#
    7986. 

  7986. #		seven significant bits of Y plus 2**(-7), i.e.		#
    7987. 

  7987. #		F = 1.xxxxxx1 in base 2 where the six "x" match those	#
    7988. 

  7988. #		of Y. Note that |Y-F| <= 2**(-7).			#
    7989. 

  7989. #									#
    7990. 

  7990. #	Step 3. Define u = (Y-F)/F. Approximate log(1+u) by a		#
    7991. 

  7991. #		polynomial in u, log(1+u) = poly.			#
    7992. 

  7992. #									#
    7993. 

  7993. #	Step 4. Reconstruct						#
    7994. 

  7994. #		log(X) = log( 2**k * Y ) = k*log(2) + log(F) + log(1+u)	#
    7995. 

  7995. #		by k*log(2) + (log(F) + poly). The values of log(F) are	#
    7996. 

  7996. #		calculated beforehand and stored in the program.	#
    7997. 

  7997. #									#
    7998. 

  7998. #	lognp1:								#
    7999. 

  7999. #	Step 1: If |X| < 1/16, approximate log(1+X) by an odd		#
    8000. 

  8000. #		polynomial in u where u = 2X/(2+X). Otherwise, move on	#
    8001. 

  8001. #		to Step 2.						#
    8002. 

  8002. #									#
    8003. 

  8003. #	Step 2: Let 1+X = 2**k * Y, where 1 <= Y < 2. Define F as done	#
    8004. 

  8004. #		in Step 2 of the algorithm for LOGN and compute		#
    8005. 

  8005. #		log(1+X) as k*log(2) + log(F) + poly where poly		#
    8006. 

  8006. #		approximates log(1+u), u = (Y-F)/F.			#
    8007. 

  8007. #									#
    8008. 

  8008. #	Implementation Notes:						#
    8009. 

  8009. #	Note 1. There are 64 different possible values for F, thus 64	#
    8010. 

  8010. #		log(F)'s need to be tabulated. Moreover, the values of	#
    8011. 

  8011. #		1/F are also tabulated so that the division in (Y-F)/F	#
    8012. 

  8012. #		can be performed by a multiplication.			#
    8013. 

  8013. #									#
    8014. 

  8014. #	Note 2. In Step 2 of lognp1, in order to preserved accuracy,	#
    8015. 

  8015. #		the value Y-F has to be calculated carefully when	#
    8016. 

  8016. #		1/2 <= X < 3/2.						#
    8017. 

  8017. #									#
    8018. 

  8018. #	Note 3. To fully exploit the pipeline, polynomials are usually	#
    8019. 

  8019. #		separated into two parts evaluated independently before	#
    8020. 

  8020. #		being added up.						#
    8021. 

  8021. #									#
    8022. 

  8022. #########################################################################
    8023. 

  8023. LOGOF2:
    8024. 

  8024. 	long		0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
    8025. 

  8025. 

  8026. one:
    8027. 

  8027. 	long		0x3F800000
    8028. 

  8028. zero:
    8029. 

  8029. 	long		0x00000000
    8030. 

  8030. infty:
    8031. 

  8031. 	long		0x7F800000
    8032. 

  8032. negone:
    8033. 

  8033. 	long		0xBF800000
    8034. 

  8034. 

  8035. LOGA6:
    8036. 

  8036. 	long		0x3FC2499A,0xB5E4040B
    8037. 

  8037. LOGA5:
    8038. 

  8038. 	long		0xBFC555B5,0x848CB7DB
    8039. 

  8039. 

  8040. LOGA4:
    8041. 

  8041. 	long		0x3FC99999,0x987D8730
    8042. 

  8042. LOGA3:
    8043. 

  8043. 	long		0xBFCFFFFF,0xFF6F7E97
    8044. 

  8044. 

  8045. LOGA2:
    8046. 

  8046. 	long		0x3FD55555,0x555555A4
    8047. 

  8047. LOGA1:
    8048. 

  8048. 	long		0xBFE00000,0x00000008
    8049. 

  8049. 

  8050. LOGB5:
    8051. 

  8051. 	long		0x3F175496,0xADD7DAD6
    8052. 

  8052. LOGB4:
    8053. 

  8053. 	long		0x3F3C71C2,0xFE80C7E0
    8054. 

  8054. 

  8055. LOGB3:
    8056. 

  8056. 	long		0x3F624924,0x928BCCFF
    8057. 

  8057. LOGB2:
    8058. 

  8058. 	long		0x3F899999,0x999995EC
    8059. 

  8059. 

  8060. LOGB1:
    8061. 

  8061. 	long		0x3FB55555,0x55555555
    8062. 

  8062. TWO:
    8063. 

  8063. 	long		0x40000000,0x00000000
    8064. 

  8064. 

  8065. LTHOLD:
    8066. 

  8066. 	long		0x3f990000,0x80000000,0x00000000,0x00000000
    8067. 

  8067. 

  8068. LOGTBL:
    8069. 

  8069. 	long		0x3FFE0000,0xFE03F80F,0xE03F80FE,0x00000000
    8070. 

  8070. 	long		0x3FF70000,0xFF015358,0x833C47E2,0x00000000
    8071. 

  8071. 	long		0x3FFE0000,0xFA232CF2,0x52138AC0,0x00000000
    8072. 

  8072. 	long		0x3FF90000,0xBDC8D83E,0xAD88D549,0x00000000
    8073. 

  8073. 	long		0x3FFE0000,0xF6603D98,0x0F6603DA,0x00000000
    8074. 

  8074. 	long		0x3FFA0000,0x9CF43DCF,0xF5EAFD48,0x00000000
    8075. 

  8075. 	long		0x3FFE0000,0xF2B9D648,0x0F2B9D65,0x00000000
    8076. 

  8076. 	long		0x3FFA0000,0xDA16EB88,0xCB8DF614,0x00000000
    8077. 

  8077. 	long		0x3FFE0000,0xEF2EB71F,0xC4345238,0x00000000
    8078. 

  8078. 	long		0x3FFB0000,0x8B29B775,0x1BD70743,0x00000000
    8079. 

  8079. 	long		0x3FFE0000,0xEBBDB2A5,0xC1619C8C,0x00000000
    8080. 

  8080. 	long		0x3FFB0000,0xA8D839F8,0x30C1FB49,0x00000000
    8081. 

  8081. 	long		0x3FFE0000,0xE865AC7B,0x7603A197,0x00000000
    8082. 

  8082. 	long		0x3FFB0000,0xC61A2EB1,0x8CD907AD,0x00000000
    8083. 

  8083. 	long		0x3FFE0000,0xE525982A,0xF70C880E,0x00000000
    8084. 

  8084. 	long		0x3FFB0000,0xE2F2A47A,0xDE3A18AF,0x00000000
    8085. 

  8085. 	long		0x3FFE0000,0xE1FC780E,0x1FC780E2,0x00000000
    8086. 

  8086. 	long		0x3FFB0000,0xFF64898E,0xDF55D551,0x00000000
    8087. 

  8087. 	long		0x3FFE0000,0xDEE95C4C,0xA037BA57,0x00000000
    8088. 

  8088. 	long		0x3FFC0000,0x8DB956A9,0x7B3D0148,0x00000000
    8089. 

  8089. 	long		0x3FFE0000,0xDBEB61EE,0xD19C5958,0x00000000
    8090. 

  8090. 	long		0x3FFC0000,0x9B8FE100,0xF47BA1DE,0x00000000
    8091. 

  8091. 	long		0x3FFE0000,0xD901B203,0x6406C80E,0x00000000
    8092. 

  8092. 	long		0x3FFC0000,0xA9372F1D,0x0DA1BD17,0x00000000
    8093. 

  8093. 	long		0x3FFE0000,0xD62B80D6,0x2B80D62C,0x00000000
    8094. 

  8094. 	long		0x3FFC0000,0xB6B07F38,0xCE90E46B,0x00000000
    8095. 

  8095. 	long		0x3FFE0000,0xD3680D36,0x80D3680D,0x00000000
    8096. 

  8096. 	long		0x3FFC0000,0xC3FD0329,0x06488481,0x00000000
    8097. 

  8097. 	long		0x3FFE0000,0xD0B69FCB,0xD2580D0B,0x00000000
    8098. 

  8098. 	long		0x3FFC0000,0xD11DE0FF,0x15AB18CA,0x00000000
    8099. 

  8099. 	long		0x3FFE0000,0xCE168A77,0x25080CE1,0x00000000
    8100. 

  8100. 	long		0x3FFC0000,0xDE1433A1,0x6C66B150,0x00000000
    8101. 

  8101. 	long		0x3FFE0000,0xCB8727C0,0x65C393E0,0x00000000
    8102. 

  8102. 	long		0x3FFC0000,0xEAE10B5A,0x7DDC8ADD,0x00000000
    8103. 

  8103. 	long		0x3FFE0000,0xC907DA4E,0x871146AD,0x00000000
    8104. 

  8104. 	long		0x3FFC0000,0xF7856E5E,0xE2C9B291,0x00000000
    8105. 

  8105. 	long		0x3FFE0000,0xC6980C69,0x80C6980C,0x00000000
    8106. 

  8106. 	long		0x3FFD0000,0x82012CA5,0xA68206D7,0x00000000
    8107. 

  8107. 	long		0x3FFE0000,0xC4372F85,0x5D824CA6,0x00000000
    8108. 

  8108. 	long		0x3FFD0000,0x882C5FCD,0x7256A8C5,0x00000000
    8109. 

  8109. 	long		0x3FFE0000,0xC1E4BBD5,0x95F6E947,0x00000000
    8110. 

  8110. 	long		0x3FFD0000,0x8E44C60B,0x4CCFD7DE,0x00000000
    8111. 

  8111. 	long		0x3FFE0000,0xBFA02FE8,0x0BFA02FF,0x00000000
    8112. 

  8112. 	long		0x3FFD0000,0x944AD09E,0xF4351AF6,0x00000000
    8113. 

  8113. 	long		0x3FFE0000,0xBD691047,0x07661AA3,0x00000000
    8114. 

  8114. 	long		0x3FFD0000,0x9A3EECD4,0xC3EAA6B2,0x00000000
    8115. 

  8115. 	long		0x3FFE0000,0xBB3EE721,0xA54D880C,0x00000000
    8116. 

  8116. 	long		0x3FFD0000,0xA0218434,0x353F1DE8,0x00000000
    8117. 

  8117. 	long		0x3FFE0000,0xB92143FA,0x36F5E02E,0x00000000
    8118. 

  8118. 	long		0x3FFD0000,0xA5F2FCAB,0xBBC506DA,0x00000000
    8119. 

  8119. 	long		0x3FFE0000,0xB70FBB5A,0x19BE3659,0x00000000
    8120. 

  8120. 	long		0x3FFD0000,0xABB3B8BA,0x2AD362A5,0x00000000
    8121. 

  8121. 	long		0x3FFE0000,0xB509E68A,0x9B94821F,0x00000000
    8122. 

  8122. 	long		0x3FFD0000,0xB1641795,0xCE3CA97B,0x00000000
    8123. 

  8123. 	long		0x3FFE0000,0xB30F6352,0x8917C80B,0x00000000
    8124. 

  8124. 	long		0x3FFD0000,0xB7047551,0x5D0F1C61,0x00000000
    8125. 

  8125. 	long		0x3FFE0000,0xB11FD3B8,0x0B11FD3C,0x00000000
    8126. 

  8126. 	long		0x3FFD0000,0xBC952AFE,0xEA3D13E1,0x00000000
    8127. 

  8127. 	long		0x3FFE0000,0xAF3ADDC6,0x80AF3ADE,0x00000000
    8128. 

  8128. 	long		0x3FFD0000,0xC2168ED0,0xF458BA4A,0x00000000
    8129. 

  8129. 	long		0x3FFE0000,0xAD602B58,0x0AD602B6,0x00000000
    8130. 

  8130. 	long		0x3FFD0000,0xC788F439,0xB3163BF1,0x00000000
    8131. 

  8131. 	long		0x3FFE0000,0xAB8F69E2,0x8359CD11,0x00000000
    8132. 

  8132. 	long		0x3FFD0000,0xCCECAC08,0xBF04565D,0x00000000
    8133. 

  8133. 	long		0x3FFE0000,0xA9C84A47,0xA07F5638,0x00000000
    8134. 

  8134. 	long		0x3FFD0000,0xD2420487,0x2DD85160,0x00000000
    8135. 

  8135. 	long		0x3FFE0000,0xA80A80A8,0x0A80A80B,0x00000000
    8136. 

  8136. 	long		0x3FFD0000,0xD7894992,0x3BC3588A,0x00000000
    8137. 

  8137. 	long		0x3FFE0000,0xA655C439,0x2D7B73A8,0x00000000
    8138. 

  8138. 	long		0x3FFD0000,0xDCC2C4B4,0x9887DACC,0x00000000
    8139. 

  8139. 	long		0x3FFE0000,0xA4A9CF1D,0x96833751,0x00000000
    8140. 

  8140. 	long		0x3FFD0000,0xE1EEBD3E,0x6D6A6B9E,0x00000000
    8141. 

  8141. 	long		0x3FFE0000,0xA3065E3F,0xAE7CD0E0,0x00000000
    8142. 

  8142. 	long		0x3FFD0000,0xE70D785C,0x2F9F5BDC,0x00000000
    8143. 

  8143. 	long		0x3FFE0000,0xA16B312E,0xA8FC377D,0x00000000
    8144. 

  8144. 	long		0x3FFD0000,0xEC1F392C,0x5179F283,0x00000000
    8145. 

  8145. 	long		0x3FFE0000,0x9FD809FD,0x809FD80A,0x00000000
    8146. 

  8146. 	long		0x3FFD0000,0xF12440D3,0xE36130E6,0x00000000
    8147. 

  8147. 	long		0x3FFE0000,0x9E4CAD23,0xDD5F3A20,0x00000000
    8148. 

  8148. 	long		0x3FFD0000,0xF61CCE92,0x346600BB,0x00000000
    8149. 

  8149. 	long		0x3FFE0000,0x9CC8E160,0xC3FB19B9,0x00000000
    8150. 

  8150. 	long		0x3FFD0000,0xFB091FD3,0x8145630A,0x00000000
    8151. 

  8151. 	long		0x3FFE0000,0x9B4C6F9E,0xF03A3CAA,0x00000000
    8152. 

  8152. 	long		0x3FFD0000,0xFFE97042,0xBFA4C2AD,0x00000000
    8153. 

  8153. 	long		0x3FFE0000,0x99D722DA,0xBDE58F06,0x00000000
    8154. 

  8154. 	long		0x3FFE0000,0x825EFCED,0x49369330,0x00000000
    8155. 

  8155. 	long		0x3FFE0000,0x9868C809,0x868C8098,0x00000000
    8156. 

  8156. 	long		0x3FFE0000,0x84C37A7A,0xB9A905C9,0x00000000
    8157. 

  8157. 	long		0x3FFE0000,0x97012E02,0x5C04B809,0x00000000
    8158. 

  8158. 	long		0x3FFE0000,0x87224C2E,0x8E645FB7,0x00000000
    8159. 

  8159. 	long		0x3FFE0000,0x95A02568,0x095A0257,0x00000000
    8160. 

  8160. 	long		0x3FFE0000,0x897B8CAC,0x9F7DE298,0x00000000
    8161. 

  8161. 	long		0x3FFE0000,0x94458094,0x45809446,0x00000000
    8162. 

  8162. 	long		0x3FFE0000,0x8BCF55DE,0xC4CD05FE,0x00000000
    8163. 

  8163. 	long		0x3FFE0000,0x92F11384,0x0497889C,0x00000000
    8164. 

  8164. 	long		0x3FFE0000,0x8E1DC0FB,0x89E125E5,0x00000000
    8165. 

  8165. 	long		0x3FFE0000,0x91A2B3C4,0xD5E6F809,0x00000000
    8166. 

  8166. 	long		0x3FFE0000,0x9066E68C,0x955B6C9B,0x00000000
    8167. 

  8167. 	long		0x3FFE0000,0x905A3863,0x3E06C43B,0x00000000
    8168. 

  8168. 	long		0x3FFE0000,0x92AADE74,0xC7BE59E0,0x00000000
    8169. 

  8169. 	long		0x3FFE0000,0x8F1779D9,0xFDC3A219,0x00000000
    8170. 

  8170. 	long		0x3FFE0000,0x94E9BFF6,0x15845643,0x00000000
    8171. 

  8171. 	long		0x3FFE0000,0x8DDA5202,0x37694809,0x00000000
    8172. 

  8172. 	long		0x3FFE0000,0x9723A1B7,0x20134203,0x00000000
    8173. 

  8173. 	long		0x3FFE0000,0x8CA29C04,0x6514E023,0x00000000
    8174. 

  8174. 	long		0x3FFE0000,0x995899C8,0x90EB8990,0x00000000
    8175. 

  8175. 	long		0x3FFE0000,0x8B70344A,0x139BC75A,0x00000000
    8176. 

  8176. 	long		0x3FFE0000,0x9B88BDAA,0x3A3DAE2F,0x00000000
    8177. 

  8177. 	long		0x3FFE0000,0x8A42F870,0x5669DB46,0x00000000
    8178. 

  8178. 	long		0x3FFE0000,0x9DB4224F,0xFFE1157C,0x00000000
    8179. 

  8179. 	long		0x3FFE0000,0x891AC73A,0xE9819B50,0x00000000
    8180. 

  8180. 	long		0x3FFE0000,0x9FDADC26,0x8B7A12DA,0x00000000
    8181. 

  8181. 	long		0x3FFE0000,0x87F78087,0xF78087F8,0x00000000
    8182. 

  8182. 	long		0x3FFE0000,0xA1FCFF17,0xCE733BD4,0x00000000
    8183. 

  8183. 	long		0x3FFE0000,0x86D90544,0x7A34ACC6,0x00000000
    8184. 

  8184. 	long		0x3FFE0000,0xA41A9E8F,0x5446FB9F,0x00000000
    8185. 

  8185. 	long		0x3FFE0000,0x85BF3761,0x2CEE3C9B,0x00000000
    8186. 

  8186. 	long		0x3FFE0000,0xA633CD7E,0x6771CD8B,0x00000000
    8187. 

  8187. 	long		0x3FFE0000,0x84A9F9C8,0x084A9F9D,0x00000000
    8188. 

  8188. 	long		0x3FFE0000,0xA8489E60,0x0B435A5E,0x00000000
    8189. 

  8189. 	long		0x3FFE0000,0x83993052,0x3FBE3368,0x00000000
    8190. 

  8190. 	long		0x3FFE0000,0xAA59233C,0xCCA4BD49,0x00000000
    8191. 

  8191. 	long		0x3FFE0000,0x828CBFBE,0xB9A020A3,0x00000000
    8192. 

  8192. 	long		0x3FFE0000,0xAC656DAE,0x6BCC4985,0x00000000
    8193. 

  8193. 	long		0x3FFE0000,0x81848DA8,0xFAF0D277,0x00000000
    8194. 

  8194. 	long		0x3FFE0000,0xAE6D8EE3,0x60BB2468,0x00000000
    8195. 

  8195. 	long		0x3FFE0000,0x80808080,0x80808081,0x00000000
    8196. 

  8196. 	long		0x3FFE0000,0xB07197A2,0x3C46C654,0x00000000
    8197. 

  8197. 

  8198. 	set		ADJK,L_SCR1
    8199. 

  8199. 

  8200. 	set		X,FP_SCR0
    8201. 

  8201. 	set		XDCARE,X+2
    8202. 

  8202. 	set		XFRAC,X+4
    8203. 

  8203. 

  8204. 	set		F,FP_SCR1
    8205. 

  8205. 	set		FFRAC,F+4
    8206. 

  8206. 

  8207. 	set		KLOG2,FP_SCR0
    8208. 

  8208. 

  8209. 	set		SAVEU,FP_SCR0
    8210. 

  8210. 

  8211. 	global		slogn
    8212. 

  8212. #--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'S
    8213. 

  8213. slogn:
    8214. 

  8214. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    8215. 

  8215. 	mov.l		&0x00000000,ADJK(%a6)
    8216. 

  8216. 

  8217. LOGBGN:
    8218. 

  8218. #--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS
    8219. 

  8219. #--A FINITE, NON-ZERO, NORMALIZED NUMBER.
    8220. 

  8220. 

  8221. 	mov.l		(%a0),%d1
    8222. 

  8222. 	mov.w		4(%a0),%d1
    8223. 

  8223. 

  8224. 	mov.l		(%a0),X(%a6)
    8225. 

  8225. 	mov.l		4(%a0),X+4(%a6)
    8226. 

  8226. 	mov.l		8(%a0),X+8(%a6)
    8227. 

  8227. 

  8228. 	cmp.l		%d1,&0			# CHECK IF X IS NEGATIVE
    8229. 

  8229. 	blt.w		LOGNEG			# LOG OF NEGATIVE ARGUMENT IS INVALID
    8230. 

  8230. # X IS POSITIVE, CHECK IF X IS NEAR 1
    8231. 

  8231. 	cmp.l		%d1,&0x3ffef07d		# IS X < 15/16?
    8232. 

  8232. 	blt.b		LOGMAIN			# YES
    8233. 

  8233. 	cmp.l		%d1,&0x3fff8841		# IS X > 17/16?
    8234. 

  8234. 	ble.w		LOGNEAR1		# NO
    8235. 

  8235. 

  8236. LOGMAIN:
    8237. 

  8237. #--THIS SHOULD BE THE USUAL CASE, X NOT VERY CLOSE TO 1
    8238. 

  8238. 

  8239. #--X = 2^(K) * Y, 1 <= Y < 2. THUS, Y = 1.XXXXXXXX....XX IN BINARY.
    8240. 

  8240. #--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1.
    8241. 

  8241. #--THE IDEA IS THAT LOG(X) = K*LOG2 + LOG(Y)
    8242. 

  8242. #--			 = K*LOG2 + LOG(F) + LOG(1 + (Y-F)/F).
    8243. 

  8243. #--NOTE THAT U = (Y-F)/F IS VERY SMALL AND THUS APPROXIMATING
    8244. 

  8244. #--LOG(1+U) CAN BE VERY EFFICIENT.
    8245. 

  8245. #--ALSO NOTE THAT THE VALUE 1/F IS STORED IN A TABLE SO THAT NO
    8246. 

  8246. #--DIVISION IS NEEDED TO CALCULATE (Y-F)/F.
    8247. 

  8247. 

  8248. #--GET K, Y, F, AND ADDRESS OF 1/F.
    8249. 

  8249. 	asr.l		&8,%d1
    8250. 

  8250. 	asr.l		&8,%d1			# SHIFTED 16 BITS, BIASED EXPO. OF X
    8251. 

  8251. 	sub.l		&0x3FFF,%d1		# THIS IS K
    8252. 

  8252. 	add.l		ADJK(%a6),%d1		# ADJUST K, ORIGINAL INPUT MAY BE  DENORM.
    8253. 

  8253. 	lea		LOGTBL(%pc),%a0		# BASE ADDRESS OF 1/F AND LOG(F)
    8254. 

  8254. 	fmov.l		%d1,%fp1		# CONVERT K TO FLOATING-POINT FORMAT
    8255. 

  8255. 

  8256. #--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/F
    8257. 

  8257. 	mov.l		&0x3FFF0000,X(%a6)	# X IS NOW Y, I.E. 2^(-K)*X
    8258. 

  8258. 	mov.l		XFRAC(%a6),FFRAC(%a6)
    8259. 

  8259. 	and.l		&0xFE000000,FFRAC(%a6)	# FIRST 7 BITS OF Y
    8260. 

  8260. 	or.l		&0x01000000,FFRAC(%a6)	# GET F: ATTACH A 1 AT THE EIGHTH BIT
    8261. 

  8261. 	mov.l		FFRAC(%a6),%d1	# READY TO GET ADDRESS OF 1/F
    8262. 

  8262. 	and.l		&0x7E000000,%d1
    8263. 

  8263. 	asr.l		&8,%d1
    8264. 

  8264. 	asr.l		&8,%d1
    8265. 

  8265. 	asr.l		&4,%d1			# SHIFTED 20, D0 IS THE DISPLACEMENT
    8266. 

  8266. 	add.l		%d1,%a0			# A0 IS THE ADDRESS FOR 1/F
    8267. 

  8267. 

  8268. 	fmov.x		X(%a6),%fp0
    8269. 

  8269. 	mov.l		&0x3fff0000,F(%a6)
    8270. 

  8270. 	clr.l		F+8(%a6)
    8271. 

  8271. 	fsub.x		F(%a6),%fp0		# Y-F
    8272. 

  8272. 	fmovm.x		&0xc,-(%sp)		# SAVE FP2-3 WHILE FP0 IS NOT READY
    8273. 

  8273. #--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K
    8274. 

  8274. #--REGISTERS SAVED: FPCR, FP1, FP2
    8275. 

  8275. 

  8276. LP1CONT1:
    8277. 

  8277. #--AN RE-ENTRY POINT FOR LOGNP1
    8278. 

  8278. 	fmul.x		(%a0),%fp0		# FP0 IS U = (Y-F)/F
    8279. 

  8279. 	fmul.x		LOGOF2(%pc),%fp1	# GET K*LOG2 WHILE FP0 IS NOT READY
    8280. 

  8280. 	fmov.x		%fp0,%fp2
    8281. 

  8281. 	fmul.x		%fp2,%fp2		# FP2 IS V=U*U
    8282. 

  8282. 	fmov.x		%fp1,KLOG2(%a6)		# PUT K*LOG2 IN MEMEORY, FREE FP1
    8283. 

  8283. 

  8284. #--LOG(1+U) IS APPROXIMATED BY
    8285. 

  8285. #--U + V*(A1+U*(A2+U*(A3+U*(A4+U*(A5+U*A6))))) WHICH IS
    8286. 

  8286. #--[U + V*(A1+V*(A3+V*A5))]  +  [U*V*(A2+V*(A4+V*A6))]
    8287. 

  8287. 

  8288. 	fmov.x		%fp2,%fp3
    8289. 

  8289. 	fmov.x		%fp2,%fp1
    8290. 

  8290. 

  8291. 	fmul.d		LOGA6(%pc),%fp1		# V*A6
    8292. 

  8292. 	fmul.d		LOGA5(%pc),%fp2		# V*A5
    8293. 

  8293. 

  8294. 	fadd.d		LOGA4(%pc),%fp1		# A4+V*A6
    8295. 

  8295. 	fadd.d		LOGA3(%pc),%fp2		# A3+V*A5
    8296. 

  8296. 

  8297. 	fmul.x		%fp3,%fp1		# V*(A4+V*A6)
    8298. 

  8298. 	fmul.x		%fp3,%fp2		# V*(A3+V*A5)
    8299. 

  8299. 

  8300. 	fadd.d		LOGA2(%pc),%fp1		# A2+V*(A4+V*A6)
    8301. 

  8301. 	fadd.d		LOGA1(%pc),%fp2		# A1+V*(A3+V*A5)
    8302. 

  8302. 

  8303. 	fmul.x		%fp3,%fp1		# V*(A2+V*(A4+V*A6))
    8304. 

  8304. 	add.l		&16,%a0			# ADDRESS OF LOG(F)
    8305. 

  8305. 	fmul.x		%fp3,%fp2		# V*(A1+V*(A3+V*A5))
    8306. 

  8306. 

  8307. 	fmul.x		%fp0,%fp1		# U*V*(A2+V*(A4+V*A6))
    8308. 

  8308. 	fadd.x		%fp2,%fp0		# U+V*(A1+V*(A3+V*A5))
    8309. 

  8309. 

  8310. 	fadd.x		(%a0),%fp1		# LOG(F)+U*V*(A2+V*(A4+V*A6))
    8311. 

  8311. 	fmovm.x		(%sp)+,&0x30		# RESTORE FP2-3
    8312. 

  8312. 	fadd.x		%fp1,%fp0		# FP0 IS LOG(F) + LOG(1+U)
    8313. 

  8313. 

  8314. 	fmov.l		%d0,%fpcr
    8315. 

  8315. 	fadd.x		KLOG2(%a6),%fp0		# FINAL ADD
    8316. 

  8316. 	bra		t_inx2
    8317. 

  8317. 

  8318. 

  8319. LOGNEAR1:
    8320. 

  8320. 

  8321. # if the input is exactly equal to one, then exit through ld_pzero.
    8322. 

  8322. # if these 2 lines weren't here, the correct answer would be returned
    8323. 

  8323. # but the INEX2 bit would be set.
    8324. 

  8324. 	fcmp.b		%fp0,&0x1		# is it equal to one?
    8325. 

  8325. 	fbeq.l		ld_pzero		# yes
    8326. 

  8326. 

  8327. #--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
    8328. 

  8328. 	fmov.x		%fp0,%fp1
    8329. 

  8329. 	fsub.s		one(%pc),%fp1		# FP1 IS X-1
    8330. 

  8330. 	fadd.s		one(%pc),%fp0		# FP0 IS X+1
    8331. 

  8331. 	fadd.x		%fp1,%fp1		# FP1 IS 2(X-1)
    8332. 

  8332. #--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL
    8333. 

  8333. #--IN U, U = 2(X-1)/(X+1) = FP1/FP0
    8334. 

  8334. 

  8335. LP1CONT2:
    8336. 

  8336. #--THIS IS AN RE-ENTRY POINT FOR LOGNP1
    8337. 

  8337. 	fdiv.x		%fp0,%fp1		# FP1 IS U
    8338. 

  8338. 	fmovm.x		&0xc,-(%sp)		# SAVE FP2-3
    8339. 

  8339. #--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3
    8340. 

  8340. #--LET V=U*U, W=V*V, CALCULATE
    8341. 

  8341. #--U + U*V*(B1 + V*(B2 + V*(B3 + V*(B4 + V*B5)))) BY
    8342. 

  8342. #--U + U*V*(  [B1 + W*(B3 + W*B5)]  +  [V*(B2 + W*B4)]  )
    8343. 

  8343. 	fmov.x		%fp1,%fp0
    8344. 

  8344. 	fmul.x		%fp0,%fp0		# FP0 IS V
    8345. 

  8345. 	fmov.x		%fp1,SAVEU(%a6)		# STORE U IN MEMORY, FREE FP1
    8346. 

  8346. 	fmov.x		%fp0,%fp1
    8347. 

  8347. 	fmul.x		%fp1,%fp1		# FP1 IS W
    8348. 

  8348. 

  8349. 	fmov.d		LOGB5(%pc),%fp3
    8350. 

  8350. 	fmov.d		LOGB4(%pc),%fp2
    8351. 

  8351. 

  8352. 	fmul.x		%fp1,%fp3		# W*B5
    8353. 

  8353. 	fmul.x		%fp1,%fp2		# W*B4
    8354. 

  8354. 

  8355. 	fadd.d		LOGB3(%pc),%fp3		# B3+W*B5
    8356. 

  8356. 	fadd.d		LOGB2(%pc),%fp2		# B2+W*B4
    8357. 

  8357. 

  8358. 	fmul.x		%fp3,%fp1		# W*(B3+W*B5), FP3 RELEASED
    8359. 

  8359. 

  8360. 	fmul.x		%fp0,%fp2		# V*(B2+W*B4)
    8361. 

  8361. 

  8362. 	fadd.d		LOGB1(%pc),%fp1		# B1+W*(B3+W*B5)
    8363. 

  8363. 	fmul.x		SAVEU(%a6),%fp0		# FP0 IS U*V
    8364. 

  8364. 

  8365. 	fadd.x		%fp2,%fp1		# B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASED
    8366. 

  8366. 	fmovm.x		(%sp)+,&0x30		# FP2-3 RESTORED
    8367. 

  8367. 

  8368. 	fmul.x		%fp1,%fp0		# U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )
    8369. 

  8369. 

  8370. 	fmov.l		%d0,%fpcr
    8371. 

  8371. 	fadd.x		SAVEU(%a6),%fp0
    8372. 

  8372. 	bra		t_inx2
    8373. 

  8373. 

  8374. #--REGISTERS SAVED FPCR. LOG(-VE) IS INVALID
    8375. 

  8375. LOGNEG:
    8376. 

  8376. 	bra		t_operr
    8377. 

  8377. 

  8378. 	global		slognd
    8379. 

  8379. slognd:
    8380. 

  8380. #--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT
    8381. 

  8381. 

  8382. 	mov.l		&-100,ADJK(%a6)		# INPUT = 2^(ADJK) * FP0
    8383. 

  8383. 

  8384. #----normalize the input value by left shifting k bits (k to be determined
    8385. 

  8385. #----below), adjusting exponent and storing -k to  ADJK
    8386. 

  8386. #----the value TWOTO100 is no longer needed.
    8387. 

  8387. #----Note that this code assumes the denormalized input is NON-ZERO.
    8388. 

  8388. 

  8389. 	movm.l		&0x3f00,-(%sp)		# save some registers  {d2-d7}
    8390. 

  8390. 	mov.l		(%a0),%d3		# D3 is exponent of smallest norm. #
    8391. 

  8391. 	mov.l		4(%a0),%d4
    8392. 

  8392. 	mov.l		8(%a0),%d5		# (D4,D5) is (Hi_X,Lo_X)
    8393. 

  8393. 	clr.l		%d2			# D2 used for holding K
    8394. 

  8394. 

  8395. 	tst.l		%d4
    8396. 

  8396. 	bne.b		Hi_not0
    8397. 

  8397. 

  8398. Hi_0:
    8399. 

  8399. 	mov.l		%d5,%d4
    8400. 

  8400. 	clr.l		%d5
    8401. 

  8401. 	mov.l		&32,%d2
    8402. 

  8402. 	clr.l		%d6
    8403. 

  8403. 	bfffo		%d4{&0:&32},%d6
    8404. 

  8404. 	lsl.l		%d6,%d4
    8405. 

  8405. 	add.l		%d6,%d2			# (D3,D4,D5) is normalized
    8406. 

  8406. 

  8407. 	mov.l		%d3,X(%a6)
    8408. 

  8408. 	mov.l		%d4,XFRAC(%a6)
    8409. 

  8409. 	mov.l		%d5,XFRAC+4(%a6)
    8410. 

  8410. 	neg.l		%d2
    8411. 

  8411. 	mov.l		%d2,ADJK(%a6)
    8412. 

  8412. 	fmov.x		X(%a6),%fp0
    8413. 

  8413. 	movm.l		(%sp)+,&0xfc		# restore registers {d2-d7}
    8414. 

  8414. 	lea		X(%a6),%a0
    8415. 

  8415. 	bra.w		LOGBGN			# begin regular log(X)
    8416. 

  8416. 

  8417. Hi_not0:
    8418. 

  8418. 	clr.l		%d6
    8419. 

  8419. 	bfffo		%d4{&0:&32},%d6		# find first 1
    8420. 

  8420. 	mov.l		%d6,%d2			# get k
    8421. 

  8421. 	lsl.l		%d6,%d4
    8422. 

  8422. 	mov.l		%d5,%d7			# a copy of D5
    8423. 

  8423. 	lsl.l		%d6,%d5
    8424. 

  8424. 	neg.l		%d6
    8425. 

  8425. 	add.l		&32,%d6
    8426. 

  8426. 	lsr.l		%d6,%d7
    8427. 

  8427. 	or.l		%d7,%d4			# (D3,D4,D5) normalized
    8428. 

  8428. 

  8429. 	mov.l		%d3,X(%a6)
    8430. 

  8430. 	mov.l		%d4,XFRAC(%a6)
    8431. 

  8431. 	mov.l		%d5,XFRAC+4(%a6)
    8432. 

  8432. 	neg.l		%d2
    8433. 

  8433. 	mov.l		%d2,ADJK(%a6)
    8434. 

  8434. 	fmov.x		X(%a6),%fp0
    8435. 

  8435. 	movm.l		(%sp)+,&0xfc		# restore registers {d2-d7}
    8436. 

  8436. 	lea		X(%a6),%a0
    8437. 

  8437. 	bra.w		LOGBGN			# begin regular log(X)
    8438. 

  8438. 

  8439. 	global		slognp1
    8440. 

  8440. #--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'S
    8441. 

  8441. slognp1:
    8442. 

  8442. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    8443. 

  8443. 	fabs.x		%fp0			# test magnitude
    8444. 

  8444. 	fcmp.x		%fp0,LTHOLD(%pc)	# compare with min threshold
    8445. 

  8445. 	fbgt.w		LP1REAL			# if greater, continue
    8446. 

  8446. 	fmov.l		%d0,%fpcr
    8447. 

  8447. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    8448. 

  8448. 	fmov.x		(%a0),%fp0		# return signed argument
    8449. 

  8449. 	bra		t_catch
    8450. 

  8450. 

  8451. LP1REAL:
    8452. 

  8452. 	fmov.x		(%a0),%fp0		# LOAD INPUT
    8453. 

  8453. 	mov.l		&0x00000000,ADJK(%a6)
    8454. 

  8454. 	fmov.x		%fp0,%fp1		# FP1 IS INPUT Z
    8455. 

  8455. 	fadd.s		one(%pc),%fp0		# X := ROUND(1+Z)
    8456. 

  8456. 	fmov.x		%fp0,X(%a6)
    8457. 

  8457. 	mov.w		XFRAC(%a6),XDCARE(%a6)
    8458. 

  8458. 	mov.l		X(%a6),%d1
    8459. 

  8459. 	cmp.l		%d1,&0
    8460. 

  8460. 	ble.w		LP1NEG0			# LOG OF ZERO OR -VE
    8461. 

  8461. 	cmp.l		%d1,&0x3ffe8000		# IS BOUNDS [1/2,3/2]?
    8462. 

  8462. 	blt.w		LOGMAIN
    8463. 

  8463. 	cmp.l		%d1,&0x3fffc000
    8464. 

  8464. 	bgt.w		LOGMAIN
    8465. 

  8465. #--IF 1+Z > 3/2 OR 1+Z < 1/2, THEN X, WHICH IS ROUNDING 1+Z,
    8466. 

  8466. #--CONTAINS AT LEAST 63 BITS OF INFORMATION OF Z. IN THAT CASE,
    8467. 

  8467. #--SIMPLY INVOKE LOG(X) FOR LOG(1+Z).
    8468. 

  8468. 

  8469. LP1NEAR1:
    8470. 

  8470. #--NEXT SEE IF EXP(-1/16) < X < EXP(1/16)
    8471. 

  8471. 	cmp.l		%d1,&0x3ffef07d
    8472. 

  8472. 	blt.w		LP1CARE
    8473. 

  8473. 	cmp.l		%d1,&0x3fff8841
    8474. 

  8474. 	bgt.w		LP1CARE
    8475. 

  8475. 

  8476. LP1ONE16:
    8477. 

  8477. #--EXP(-1/16) < X < EXP(1/16). LOG(1+Z) = LOG(1+U/2) - LOG(1-U/2)
    8478. 

  8478. #--WHERE U = 2Z/(2+Z) = 2Z/(1+X).
    8479. 

  8479. 	fadd.x		%fp1,%fp1		# FP1 IS 2Z
    8480. 

  8480. 	fadd.s		one(%pc),%fp0		# FP0 IS 1+X
    8481. 

  8481. #--U = FP1/FP0
    8482. 

  8482. 	bra.w		LP1CONT2
    8483. 

  8483. 

  8484. LP1CARE:
    8485. 

  8485. #--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE
    8486. 

  8486. #--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST
    8487. 

  8487. #--PRESERVE ALL THE INFORMATION. BECAUSE 1+Z IS IN [1/2,3/2],
    8488. 

  8488. #--THERE ARE ONLY TWO CASES.
    8489. 

  8489. #--CASE 1: 1+Z < 1, THEN K = -1 AND Y-F = (2-F) + 2Z
    8490. 

  8490. #--CASE 2: 1+Z > 1, THEN K = 0  AND Y-F = (1-F) + Z
    8491. 

  8491. #--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF
    8492. 

  8492. #--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED.
    8493. 

  8493. 

  8494. 	mov.l		XFRAC(%a6),FFRAC(%a6)
    8495. 

  8495. 	and.l		&0xFE000000,FFRAC(%a6)
    8496. 

  8496. 	or.l		&0x01000000,FFRAC(%a6)	# F OBTAINED
    8497. 

  8497. 	cmp.l		%d1,&0x3FFF8000		# SEE IF 1+Z > 1
    8498. 

  8498. 	bge.b		KISZERO
    8499. 

  8499. 

  8500. KISNEG1:
    8501. 

  8501. 	fmov.s		TWO(%pc),%fp0
    8502. 

  8502. 	mov.l		&0x3fff0000,F(%a6)
    8503. 

  8503. 	clr.l		F+8(%a6)
    8504. 

  8504. 	fsub.x		F(%a6),%fp0		# 2-F
    8505. 

  8505. 	mov.l		FFRAC(%a6),%d1
    8506. 

  8506. 	and.l		&0x7E000000,%d1
    8507. 

  8507. 	asr.l		&8,%d1
    8508. 

  8508. 	asr.l		&8,%d1
    8509. 

  8509. 	asr.l		&4,%d1			# D0 CONTAINS DISPLACEMENT FOR 1/F
    8510. 

  8510. 	fadd.x		%fp1,%fp1		# GET 2Z
    8511. 

  8511. 	fmovm.x		&0xc,-(%sp)		# SAVE FP2  {%fp2/%fp3}
    8512. 

  8512. 	fadd.x		%fp1,%fp0		# FP0 IS Y-F = (2-F)+2Z
    8513. 

  8513. 	lea		LOGTBL(%pc),%a0		# A0 IS ADDRESS OF 1/F
    8514. 

  8514. 	add.l		%d1,%a0
    8515. 

  8515. 	fmov.s		negone(%pc),%fp1	# FP1 IS K = -1
    8516. 

  8516. 	bra.w		LP1CONT1
    8517. 

  8517. 

  8518. KISZERO:
    8519. 

  8519. 	fmov.s		one(%pc),%fp0
    8520. 

  8520. 	mov.l		&0x3fff0000,F(%a6)
    8521. 

  8521. 	clr.l		F+8(%a6)
    8522. 

  8522. 	fsub.x		F(%a6),%fp0		# 1-F
    8523. 

  8523. 	mov.l		FFRAC(%a6),%d1
    8524. 

  8524. 	and.l		&0x7E000000,%d1
    8525. 

  8525. 	asr.l		&8,%d1
    8526. 

  8526. 	asr.l		&8,%d1
    8527. 

  8527. 	asr.l		&4,%d1
    8528. 

  8528. 	fadd.x		%fp1,%fp0		# FP0 IS Y-F
    8529. 

  8529. 	fmovm.x		&0xc,-(%sp)		# FP2 SAVED {%fp2/%fp3}
    8530. 

  8530. 	lea		LOGTBL(%pc),%a0
    8531. 

  8531. 	add.l		%d1,%a0			# A0 IS ADDRESS OF 1/F
    8532. 

  8532. 	fmov.s		zero(%pc),%fp1		# FP1 IS K = 0
    8533. 

  8533. 	bra.w		LP1CONT1
    8534. 

  8534. 

  8535. LP1NEG0:
    8536. 

  8536. #--FPCR SAVED. D0 IS X IN COMPACT FORM.
    8537. 

  8537. 	cmp.l		%d1,&0
    8538. 

  8538. 	blt.b		LP1NEG
    8539. 

  8539. LP1ZERO:
    8540. 

  8540. 	fmov.s		negone(%pc),%fp0
    8541. 

  8541. 

  8542. 	fmov.l		%d0,%fpcr
    8543. 

  8543. 	bra		t_dz
    8544. 

  8544. 

  8545. LP1NEG:
    8546. 

  8546. 	fmov.s		zero(%pc),%fp0
    8547. 

  8547. 

  8548. 	fmov.l		%d0,%fpcr
    8549. 

  8549. 	bra		t_operr
    8550. 

  8550. 

  8551. 	global		slognp1d
    8552. 

  8552. #--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT
    8553. 

  8553. # Simply return the denorm
    8554. 

  8554. slognp1d:
    8555. 

  8555. 	bra		t_extdnrm
    8556. 

  8556. 

  8557. #########################################################################
    8558. 

  8558. # satanh():  computes the inverse hyperbolic tangent of a norm input	#
    8559. 

  8559. # satanhd(): computes the inverse hyperbolic tangent of a denorm input	#
    8560. 

  8560. #									#
    8561. 

  8561. # INPUT ***************************************************************	#
    8562. 

  8562. #	a0 = pointer to extended precision input			#
    8563. 

  8563. #	d0 = round precision,mode					#
    8564. 

  8564. #									#
    8565. 

  8565. # OUTPUT **************************************************************	#
    8566. 

  8566. #	fp0 = arctanh(X)						#
    8567. 

  8567. #									#
    8568. 

  8568. # ACCURACY and MONOTONICITY *******************************************	#
    8569. 

  8569. #	The returned result is within 3 ulps in	64 significant bit,	#
    8570. 

  8570. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
    8571. 

  8571. #	rounded to double precision. The result is provably monotonic	#
    8572. 

  8572. #	in double precision.						#
    8573. 

  8573. #									#
    8574. 

  8574. # ALGORITHM ***********************************************************	#
    8575. 

  8575. #									#
    8576. 

  8576. #	ATANH								#
    8577. 

  8577. #	1. If |X| >= 1, go to 3.					#
    8578. 

  8578. #									#
    8579. 

  8579. #	2. (|X| < 1) Calculate atanh(X) by				#
    8580. 

  8580. #		sgn := sign(X)						#
    8581. 

  8581. #		y := |X|						#
    8582. 

  8582. #		z := 2y/(1-y)						#
    8583. 

  8583. #		atanh(X) := sgn * (1/2) * logp1(z)			#
    8584. 

  8584. #		Exit.							#
    8585. 

  8585. #									#
    8586. 

  8586. #	3. If |X| > 1, go to 5.						#
    8587. 

  8587. #									#
    8588. 

  8588. #	4. (|X| = 1) Generate infinity with an appropriate sign and	#
    8589. 

  8589. #		divide-by-zero by					#
    8590. 

  8590. #		sgn := sign(X)						#
    8591. 

  8591. #		atan(X) := sgn / (+0).					#
    8592. 

  8592. #		Exit.							#
    8593. 

  8593. #									#
    8594. 

  8594. #	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
    8595. 

  8595. #		Exit.							#
    8596. 

  8596. #									#
    8597. 

  8597. #########################################################################
    8598. 

  8598. 

  8599. 	global		satanh
    8600. 

  8600. satanh:
    8601. 

  8601. 	mov.l		(%a0),%d1
    8602. 

  8602. 	mov.w		4(%a0),%d1
    8603. 

  8603. 	and.l		&0x7FFFFFFF,%d1
    8604. 

  8604. 	cmp.l		%d1,&0x3FFF8000
    8605. 

  8605. 	bge.b		ATANHBIG
    8606. 

  8606. 

  8607. #--THIS IS THE USUAL CASE, |X| < 1
    8608. 

  8608. #--Y = |X|, Z = 2Y/(1-Y), ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z).
    8609. 

  8609. 

  8610. 	fabs.x		(%a0),%fp0		# Y = |X|
    8611. 

  8611. 	fmov.x		%fp0,%fp1
    8612. 

  8612. 	fneg.x		%fp1			# -Y
    8613. 

  8613. 	fadd.x		%fp0,%fp0		# 2Y
    8614. 

  8614. 	fadd.s		&0x3F800000,%fp1	# 1-Y
    8615. 

  8615. 	fdiv.x		%fp1,%fp0		# 2Y/(1-Y)
    8616. 

  8616. 	mov.l		(%a0),%d1
    8617. 

  8617. 	and.l		&0x80000000,%d1
    8618. 

  8618. 	or.l		&0x3F000000,%d1		# SIGN(X)*HALF
    8619. 

  8619. 	mov.l		%d1,-(%sp)
    8620. 

  8620. 

  8621. 	mov.l		%d0,-(%sp)		# save rnd prec,mode
    8622. 

  8622. 	clr.l		%d0			# pass ext prec,RN
    8623. 

  8623. 	fmovm.x		&0x01,-(%sp)		# save Z on stack
    8624. 

  8624. 	lea		(%sp),%a0		# pass ptr to Z
    8625. 

  8625. 	bsr		slognp1			# LOG1P(Z)
    8626. 

  8626. 	add.l		&0xc,%sp		# clear Z from stack
    8627. 

  8627. 

  8628. 	mov.l		(%sp)+,%d0		# fetch old prec,mode
    8629. 

  8629. 	fmov.l		%d0,%fpcr		# load it
    8630. 

  8630. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    8631. 

  8631. 	fmul.s		(%sp)+,%fp0
    8632. 

  8632. 	bra		t_catch
    8633. 

  8633. 

  8634. ATANHBIG:
    8635. 

  8635. 	fabs.x		(%a0),%fp0		# |X|
    8636. 

  8636. 	fcmp.s		%fp0,&0x3F800000
    8637. 

  8637. 	fbgt		t_operr
    8638. 

  8638. 	bra		t_dz
    8639. 

  8639. 

  8640. 	global		satanhd
    8641. 

  8641. #--ATANH(X) = X FOR DENORMALIZED X
    8642. 

  8642. satanhd:
    8643. 

  8643. 	bra		t_extdnrm
    8644. 

  8644. 

  8645. #########################################################################
    8646. 

  8646. # slog10():  computes the base-10 logarithm of a normalized input	#
    8647. 

  8647. # slog10d(): computes the base-10 logarithm of a denormalized input	#
    8648. 

  8648. # slog2():   computes the base-2 logarithm of a normalized input	#
    8649. 

  8649. # slog2d():  computes the base-2 logarithm of a denormalized input	#
    8650. 

  8650. #									#
    8651. 

  8651. # INPUT *************************************************************** #
    8652. 

  8652. #	a0 = pointer to extended precision input			#
    8653. 

  8653. #	d0 = round precision,mode					#
    8654. 

  8654. #									#
    8655. 

  8655. # OUTPUT **************************************************************	#
    8656. 

  8656. #	fp0 = log_10(X) or log_2(X)					#
    8657. 

  8657. #									#
    8658. 

  8658. # ACCURACY and MONOTONICITY *******************************************	#
    8659. 

  8659. #	The returned result is within 1.7 ulps in 64 significant bit,	#
    8660. 

  8660. #	i.e. within 0.5003 ulp to 53 bits if the result is subsequently	#
    8661. 

  8661. #	rounded to double precision. The result is provably monotonic	#
    8662. 

  8662. #	in double precision.						#
    8663. 

  8663. #									#
    8664. 

  8664. # ALGORITHM ***********************************************************	#
    8665. 

  8665. #									#
    8666. 

  8666. #       slog10d:							#
    8667. 

  8667. #									#
    8668. 

  8668. #       Step 0.	If X < 0, create a NaN and raise the invalid operation	#
    8669. 

  8669. #               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
    8670. 

  8670. #       Notes:  Default means round-to-nearest mode, no floating-point	#
    8671. 

  8671. #               traps, and precision control = double extended.		#
    8672. 

  8672. #									#
    8673. 

  8673. #       Step 1. Call slognd to obtain Y = log(X), the natural log of X.	#
    8674. 

  8674. #       Notes:  Even if X is denormalized, log(X) is always normalized.	#
    8675. 

  8675. #									#
    8676. 

  8676. #       Step 2.  Compute log_10(X) = log(X) * (1/log(10)).		#
    8677. 

  8677. #            2.1 Restore the user FPCR					#
    8678. 

  8678. #            2.2 Return ans := Y * INV_L10.				#
    8679. 

  8679. #									#
    8680. 

  8680. #       slog10:								#
    8681. 

  8681. #									#
    8682. 

  8682. #       Step 0. If X < 0, create a NaN and raise the invalid operation	#
    8683. 

  8683. #               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
    8684. 

  8684. #       Notes:  Default means round-to-nearest mode, no floating-point	#
    8685. 

  8685. #               traps, and precision control = double extended.		#
    8686. 

  8686. #									#
    8687. 

  8687. #       Step 1. Call sLogN to obtain Y = log(X), the natural log of X.	#
    8688. 

  8688. #									#
    8689. 

  8689. #       Step 2.   Compute log_10(X) = log(X) * (1/log(10)).		#
    8690. 

  8690. #            2.1  Restore the user FPCR					#
    8691. 

  8691. #            2.2  Return ans := Y * INV_L10.				#
    8692. 

  8692. #									#
    8693. 

  8693. #       sLog2d:								#
    8694. 

  8694. #									#
    8695. 

  8695. #       Step 0. If X < 0, create a NaN and raise the invalid operation	#
    8696. 

  8696. #               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
    8697. 

  8697. #       Notes:  Default means round-to-nearest mode, no floating-point	#
    8698. 

  8698. #               traps, and precision control = double extended.		#
    8699. 

  8699. #									#
    8700. 

  8700. #       Step 1. Call slognd to obtain Y = log(X), the natural log of X.	#
    8701. 

  8701. #       Notes:  Even if X is denormalized, log(X) is always normalized.	#
    8702. 

  8702. #									#
    8703. 

  8703. #       Step 2.   Compute log_10(X) = log(X) * (1/log(2)).		#
    8704. 

  8704. #            2.1  Restore the user FPCR					#
    8705. 

  8705. #            2.2  Return ans := Y * INV_L2.				#
    8706. 

  8706. #									#
    8707. 

  8707. #       sLog2:								#
    8708. 

  8708. #									#
    8709. 

  8709. #       Step 0. If X < 0, create a NaN and raise the invalid operation	#
    8710. 

  8710. #               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
    8711. 

  8711. #       Notes:  Default means round-to-nearest mode, no floating-point	#
    8712. 

  8712. #               traps, and precision control = double extended.		#
    8713. 

  8713. #									#
    8714. 

  8714. #       Step 1. If X is not an integer power of two, i.e., X != 2^k,	#
    8715. 

  8715. #               go to Step 3.						#
    8716. 

  8716. #									#
    8717. 

  8717. #       Step 2.   Return k.						#
    8718. 

  8718. #            2.1  Get integer k, X = 2^k.				#
    8719. 

  8719. #            2.2  Restore the user FPCR.				#
    8720. 

  8720. #            2.3  Return ans := convert-to-double-extended(k).		#
    8721. 

  8721. #									#
    8722. 

  8722. #       Step 3. Call sLogN to obtain Y = log(X), the natural log of X.	#
    8723. 

  8723. #									#
    8724. 

  8724. #       Step 4.   Compute log_2(X) = log(X) * (1/log(2)).		#
    8725. 

  8725. #            4.1  Restore the user FPCR					#
    8726. 

  8726. #            4.2  Return ans := Y * INV_L2.				#
    8727. 

  8727. #									#
    8728. 

  8728. #########################################################################
    8729. 

  8729. 

  8730. INV_L10:
    8731. 

  8731. 	long		0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000
    8732. 

  8732. 

  8733. INV_L2:
    8734. 

  8734. 	long		0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000
    8735. 

  8735. 

  8736. 	global		slog10
    8737. 

  8737. #--entry point for Log10(X), X is normalized
    8738. 

  8738. slog10:
    8739. 

  8739. 	fmov.b		&0x1,%fp0
    8740. 

  8740. 	fcmp.x		%fp0,(%a0)		# if operand == 1,
    8741. 

  8741. 	fbeq.l		ld_pzero		# return an EXACT zero
    8742. 

  8742. 

  8743. 	mov.l		(%a0),%d1
    8744. 

  8744. 	blt.w		invalid
    8745. 

  8745. 	mov.l		%d0,-(%sp)
    8746. 

  8746. 	clr.l		%d0
    8747. 

  8747. 	bsr		slogn			# log(X), X normal.
    8748. 

  8748. 	fmov.l		(%sp)+,%fpcr
    8749. 

  8749. 	fmul.x		INV_L10(%pc),%fp0
    8750. 

  8750. 	bra		t_inx2
    8751. 

  8751. 

  8752. 	global		slog10d
    8753. 

  8753. #--entry point for Log10(X), X is denormalized
    8754. 

  8754. slog10d:
    8755. 

  8755. 	mov.l		(%a0),%d1
    8756. 

  8756. 	blt.w		invalid
    8757. 

  8757. 	mov.l		%d0,-(%sp)
    8758. 

  8758. 	clr.l		%d0
    8759. 

  8759. 	bsr		slognd			# log(X), X denorm.
    8760. 

  8760. 	fmov.l		(%sp)+,%fpcr
    8761. 

  8761. 	fmul.x		INV_L10(%pc),%fp0
    8762. 

  8762. 	bra		t_minx2
    8763. 

  8763. 

  8764. 	global		slog2
    8765. 

  8765. #--entry point for Log2(X), X is normalized
    8766. 

  8766. slog2:
    8767. 

  8767. 	mov.l		(%a0),%d1
    8768. 

  8768. 	blt.w		invalid
    8769. 

  8769. 

  8770. 	mov.l		8(%a0),%d1
    8771. 

  8771. 	bne.b		continue		# X is not 2^k
    8772. 

  8772. 

  8773. 	mov.l		4(%a0),%d1
    8774. 

  8774. 	and.l		&0x7FFFFFFF,%d1
    8775. 

  8775. 	bne.b		continue
    8776. 

  8776. 

  8777. #--X = 2^k.
    8778. 

  8778. 	mov.w		(%a0),%d1
    8779. 

  8779. 	and.l		&0x00007FFF,%d1
    8780. 

  8780. 	sub.l		&0x3FFF,%d1
    8781. 

  8781. 	beq.l		ld_pzero
    8782. 

  8782. 	fmov.l		%d0,%fpcr
    8783. 

  8783. 	fmov.l		%d1,%fp0
    8784. 

  8784. 	bra		t_inx2
    8785. 

  8785. 

  8786. continue:
    8787. 

  8787. 	mov.l		%d0,-(%sp)
    8788. 

  8788. 	clr.l		%d0
    8789. 

  8789. 	bsr		slogn			# log(X), X normal.
    8790. 

  8790. 	fmov.l		(%sp)+,%fpcr
    8791. 

  8791. 	fmul.x		INV_L2(%pc),%fp0
    8792. 

  8792. 	bra		t_inx2
    8793. 

  8793. 

  8794. invalid:
    8795. 

  8795. 	bra		t_operr
    8796. 

  8796. 

  8797. 	global		slog2d
    8798. 

  8798. #--entry point for Log2(X), X is denormalized
    8799. 

  8799. slog2d:
    8800. 

  8800. 	mov.l		(%a0),%d1
    8801. 

  8801. 	blt.w		invalid
    8802. 

  8802. 	mov.l		%d0,-(%sp)
    8803. 

  8803. 	clr.l		%d0
    8804. 

  8804. 	bsr		slognd			# log(X), X denorm.
    8805. 

  8805. 	fmov.l		(%sp)+,%fpcr
    8806. 

  8806. 	fmul.x		INV_L2(%pc),%fp0
    8807. 

  8807. 	bra		t_minx2
    8808. 

  8808. 

  8809. #########################################################################
    8810. 

  8810. # stwotox():  computes 2**X for a normalized input			#
    8811. 

  8811. # stwotoxd(): computes 2**X for a denormalized input			#
    8812. 

  8812. # stentox():  computes 10**X for a normalized input			#
    8813. 

  8813. # stentoxd(): computes 10**X for a denormalized input			#
    8814. 

  8814. #									#
    8815. 

  8815. # INPUT ***************************************************************	#
    8816. 

  8816. #	a0 = pointer to extended precision input			#
    8817. 

  8817. #	d0 = round precision,mode					#
    8818. 

  8818. #									#
    8819. 

  8819. # OUTPUT **************************************************************	#
    8820. 

  8820. #	fp0 = 2**X or 10**X						#
    8821. 

  8821. #									#
    8822. 

  8822. # ACCURACY and MONOTONICITY *******************************************	#
    8823. 

  8823. #	The returned result is within 2 ulps in 64 significant bit,	#
    8824. 

  8824. #	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
    8825. 

  8825. #	rounded to double precision. The result is provably monotonic	#
    8826. 

  8826. #	in double precision.						#
    8827. 

  8827. #									#
    8828. 

  8828. # ALGORITHM ***********************************************************	#
    8829. 

  8829. #									#
    8830. 

  8830. #	twotox								#
    8831. 

  8831. #	1. If |X| > 16480, go to ExpBig.				#
    8832. 

  8832. #									#
    8833. 

  8833. #	2. If |X| < 2**(-70), go to ExpSm.				#
    8834. 

  8834. #									#
    8835. 

  8835. #	3. Decompose X as X = N/64 + r where |r| <= 1/128. Furthermore	#
    8836. 

  8836. #		decompose N as						#
    8837. 

  8837. #		 N = 64(M + M') + j,  j = 0,1,2,...,63.			#
    8838. 

  8838. #									#
    8839. 

  8839. #	4. Overwrite r := r * log2. Then				#
    8840. 

  8840. #		2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).		#
    8841. 

  8841. #		Go to expr to compute that expression.			#
    8842. 

  8842. #									#
    8843. 

  8843. #	tentox								#
    8844. 

  8844. #	1. If |X| > 16480*log_10(2) (base 10 log of 2), go to ExpBig.	#
    8845. 

  8845. #									#
    8846. 

  8846. #	2. If |X| < 2**(-70), go to ExpSm.				#
    8847. 

  8847. #									#
    8848. 

  8848. #	3. Set y := X*log_2(10)*64 (base 2 log of 10). Set		#
    8849. 

  8849. #		N := round-to-int(y). Decompose N as			#
    8850. 

  8850. #		 N = 64(M + M') + j,  j = 0,1,2,...,63.			#
    8851. 

  8851. #									#
    8852. 

  8852. #	4. Define r as							#
    8853. 

  8853. #		r := ((X - N*L1)-N*L2) * L10				#
    8854. 

  8854. #		where L1, L2 are the leading and trailing parts of	#
    8855. 

  8855. #		log_10(2)/64 and L10 is the natural log of 10. Then	#
    8856. 

  8856. #		10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).		#
    8857. 

  8857. #		Go to expr to compute that expression.			#
    8858. 

  8858. #									#
    8859. 

  8859. #	expr								#
    8860. 

  8860. #	1. Fetch 2**(j/64) from table as Fact1 and Fact2.		#
    8861. 

  8861. #									#
    8862. 

  8862. #	2. Overwrite Fact1 and Fact2 by					#
    8863. 

  8863. #		Fact1 := 2**(M) * Fact1					#
    8864. 

  8864. #		Fact2 := 2**(M) * Fact2					#
    8865. 

  8865. #		Thus Fact1 + Fact2 = 2**(M) * 2**(j/64).		#
    8866. 

  8866. #									#
    8867. 

  8867. #	3. Calculate P where 1 + P approximates exp(r):			#
    8868. 

  8868. #		P = r + r*r*(A1+r*(A2+...+r*A5)).			#
    8869. 

  8869. #									#
    8870. 

  8870. #	4. Let AdjFact := 2**(M'). Return				#
    8871. 

  8871. #		AdjFact * ( Fact1 + ((Fact1*P) + Fact2) ).		#
    8872. 

  8872. #		Exit.							#
    8873. 

  8873. #									#
    8874. 

  8874. #	ExpBig								#
    8875. 

  8875. #	1. Generate overflow by Huge * Huge if X > 0; otherwise,	#
    8876. 

  8876. #	        generate underflow by Tiny * Tiny.			#
    8877. 

  8877. #									#
    8878. 

  8878. #	ExpSm								#
    8879. 

  8879. #	1. Return 1 + X.						#
    8880. 

  8880. #									#
    8881. 

  8881. #########################################################################
    8882. 

  8882. 

  8883. L2TEN64:
    8884. 

  8884. 	long		0x406A934F,0x0979A371	# 64LOG10/LOG2
    8885. 

  8885. L10TWO1:
    8886. 

  8886. 	long		0x3F734413,0x509F8000	# LOG2/64LOG10
    8887. 

  8887. 

  8888. L10TWO2:
    8889. 

  8889. 	long		0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000
    8890. 

  8890. 

  8891. LOG10:	long		0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000
    8892. 

  8892. 

  8893. LOG2:	long		0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
    8894. 

  8894. 

  8895. EXPA5:	long		0x3F56C16D,0x6F7BD0B2
    8896. 

  8896. EXPA4:	long		0x3F811112,0x302C712C
    8897. 

  8897. EXPA3:	long		0x3FA55555,0x55554CC1
    8898. 

  8898. EXPA2:	long		0x3FC55555,0x55554A54
    8899. 

  8899. EXPA1:	long		0x3FE00000,0x00000000,0x00000000,0x00000000
    8900. 

  8900. 

  8901. TEXPTBL:
    8902. 

  8902. 	long		0x3FFF0000,0x80000000,0x00000000,0x3F738000
    8903. 

  8903. 	long		0x3FFF0000,0x8164D1F3,0xBC030773,0x3FBEF7CA
    8904. 

  8904. 	long		0x3FFF0000,0x82CD8698,0xAC2BA1D7,0x3FBDF8A9
    8905. 

  8905. 	long		0x3FFF0000,0x843A28C3,0xACDE4046,0x3FBCD7C9
    8906. 

  8906. 	long		0x3FFF0000,0x85AAC367,0xCC487B15,0xBFBDE8DA
    8907. 

  8907. 	long		0x3FFF0000,0x871F6196,0x9E8D1010,0x3FBDE85C
    8908. 

  8908. 	long		0x3FFF0000,0x88980E80,0x92DA8527,0x3FBEBBF1
    8909. 

  8909. 	long		0x3FFF0000,0x8A14D575,0x496EFD9A,0x3FBB80CA
    8910. 

  8910. 	long		0x3FFF0000,0x8B95C1E3,0xEA8BD6E7,0xBFBA8373
    8911. 

  8911. 	long		0x3FFF0000,0x8D1ADF5B,0x7E5BA9E6,0xBFBE9670
    8912. 

  8912. 	long		0x3FFF0000,0x8EA4398B,0x45CD53C0,0x3FBDB700
    8913. 

  8913. 	long		0x3FFF0000,0x9031DC43,0x1466B1DC,0x3FBEEEB0
    8914. 

  8914. 	long		0x3FFF0000,0x91C3D373,0xAB11C336,0x3FBBFD6D
    8915. 

  8915. 	long		0x3FFF0000,0x935A2B2F,0x13E6E92C,0xBFBDB319
    8916. 

  8916. 	long		0x3FFF0000,0x94F4EFA8,0xFEF70961,0x3FBDBA2B
    8917. 

  8917. 	long		0x3FFF0000,0x96942D37,0x20185A00,0x3FBE91D5
    8918. 

  8918. 	long		0x3FFF0000,0x9837F051,0x8DB8A96F,0x3FBE8D5A
    8919. 

  8919. 	long		0x3FFF0000,0x99E04593,0x20B7FA65,0xBFBCDE7B
    8920. 

  8920. 	long		0x3FFF0000,0x9B8D39B9,0xD54E5539,0xBFBEBAAF
    8921. 

  8921. 	long		0x3FFF0000,0x9D3ED9A7,0x2CFFB751,0xBFBD86DA
    8922. 

  8922. 	long		0x3FFF0000,0x9EF53260,0x91A111AE,0xBFBEBEDD
    8923. 

  8923. 	long		0x3FFF0000,0xA0B0510F,0xB9714FC2,0x3FBCC96E
    8924. 

  8924. 	long		0x3FFF0000,0xA2704303,0x0C496819,0xBFBEC90B
    8925. 

  8925. 	long		0x3FFF0000,0xA43515AE,0x09E6809E,0x3FBBD1DB
    8926. 

  8926. 	long		0x3FFF0000,0xA5FED6A9,0xB15138EA,0x3FBCE5EB
    8927. 

  8927. 	long		0x3FFF0000,0xA7CD93B4,0xE965356A,0xBFBEC274
    8928. 

  8928. 	long		0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x3FBEA83C
    8929. 

  8929. 	long		0x3FFF0000,0xAB7A39B5,0xA93ED337,0x3FBECB00
    8930. 

  8930. 	long		0x3FFF0000,0xAD583EEA,0x42A14AC6,0x3FBE9301
    8931. 

  8931. 	long		0x3FFF0000,0xAF3B78AD,0x690A4375,0xBFBD8367
    8932. 

  8932. 	long		0x3FFF0000,0xB123F581,0xD2AC2590,0xBFBEF05F
    8933. 

  8933. 	long		0x3FFF0000,0xB311C412,0xA9112489,0x3FBDFB3C
    8934. 

  8934. 	long		0x3FFF0000,0xB504F333,0xF9DE6484,0x3FBEB2FB
    8935. 

  8935. 	long		0x3FFF0000,0xB6FD91E3,0x28D17791,0x3FBAE2CB
    8936. 

  8936. 	long		0x3FFF0000,0xB8FBAF47,0x62FB9EE9,0x3FBCDC3C
    8937. 

  8937. 	long		0x3FFF0000,0xBAFF5AB2,0x133E45FB,0x3FBEE9AA
    8938. 

  8938. 	long		0x3FFF0000,0xBD08A39F,0x580C36BF,0xBFBEAEFD
    8939. 

  8939. 	long		0x3FFF0000,0xBF1799B6,0x7A731083,0xBFBCBF51
    8940. 

  8940. 	long		0x3FFF0000,0xC12C4CCA,0x66709456,0x3FBEF88A
    8941. 

  8941. 	long		0x3FFF0000,0xC346CCDA,0x24976407,0x3FBD83B2
    8942. 

  8942. 	long		0x3FFF0000,0xC5672A11,0x5506DADD,0x3FBDF8AB
    8943. 

  8943. 	long		0x3FFF0000,0xC78D74C8,0xABB9B15D,0xBFBDFB17
    8944. 

  8944. 	long		0x3FFF0000,0xC9B9BD86,0x6E2F27A3,0xBFBEFE3C
    8945. 

  8945. 	long		0x3FFF0000,0xCBEC14FE,0xF2727C5D,0xBFBBB6F8
    8946. 

  8946. 	long		0x3FFF0000,0xCE248C15,0x1F8480E4,0xBFBCEE53
    8947. 

  8947. 	long		0x3FFF0000,0xD06333DA,0xEF2B2595,0xBFBDA4AE
    8948. 

  8948. 	long		0x3FFF0000,0xD2A81D91,0xF12AE45A,0x3FBC9124
    8949. 

  8949. 	long		0x3FFF0000,0xD4F35AAB,0xCFEDFA1F,0x3FBEB243
    8950. 

  8950. 	long		0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x3FBDE69A
    8951. 

  8951. 	long		0x3FFF0000,0xD99D15C2,0x78AFD7B6,0xBFB8BC61
    8952. 

  8952. 	long		0x3FFF0000,0xDBFBB797,0xDAF23755,0x3FBDF610
    8953. 

  8953. 	long		0x3FFF0000,0xDE60F482,0x5E0E9124,0xBFBD8BE1
    8954. 

  8954. 	long		0x3FFF0000,0xE0CCDEEC,0x2A94E111,0x3FBACB12
    8955. 

  8955. 	long		0x3FFF0000,0xE33F8972,0xBE8A5A51,0x3FBB9BFE
    8956. 

  8956. 	long		0x3FFF0000,0xE5B906E7,0x7C8348A8,0x3FBCF2F4
    8957. 

  8957. 	long		0x3FFF0000,0xE8396A50,0x3C4BDC68,0x3FBEF22F
    8958. 

  8958. 	long		0x3FFF0000,0xEAC0C6E7,0xDD24392F,0xBFBDBF4A
    8959. 

  8959. 	long		0x3FFF0000,0xED4F301E,0xD9942B84,0x3FBEC01A
    8960. 

  8960. 	long		0x3FFF0000,0xEFE4B99B,0xDCDAF5CB,0x3FBE8CAC
    8961. 

  8961. 	long		0x3FFF0000,0xF281773C,0x59FFB13A,0xBFBCBB3F
    8962. 

  8962. 	long		0x3FFF0000,0xF5257D15,0x2486CC2C,0x3FBEF73A
    8963. 

  8963. 	long		0x3FFF0000,0xF7D0DF73,0x0AD13BB9,0xBFB8B795
    8964. 

  8964. 	long		0x3FFF0000,0xFA83B2DB,0x722A033A,0x3FBEF84B
    8965. 

  8965. 	long		0x3FFF0000,0xFD3E0C0C,0xF486C175,0xBFBEF581
    8966. 

  8966. 

  8967. 	set		INT,L_SCR1
    8968. 

  8968. 

  8969. 	set		X,FP_SCR0
    8970. 

  8970. 	set		XDCARE,X+2
    8971. 

  8971. 	set		XFRAC,X+4
    8972. 

  8972. 

  8973. 	set		ADJFACT,FP_SCR0
    8974. 

  8974. 

  8975. 	set		FACT1,FP_SCR0
    8976. 

  8976. 	set		FACT1HI,FACT1+4
    8977. 

  8977. 	set		FACT1LOW,FACT1+8
    8978. 

  8978. 

  8979. 	set		FACT2,FP_SCR1
    8980. 

  8980. 	set		FACT2HI,FACT2+4
    8981. 

  8981. 	set		FACT2LOW,FACT2+8
    8982. 

  8982. 

  8983. 	global		stwotox
    8984. 

  8984. #--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
    8985. 

  8985. stwotox:
    8986. 

  8986. 	fmovm.x		(%a0),&0x80		# LOAD INPUT
    8987. 

  8987. 

  8988. 	mov.l		(%a0),%d1
    8989. 

  8989. 	mov.w		4(%a0),%d1
    8990. 

  8990. 	fmov.x		%fp0,X(%a6)
    8991. 

  8991. 	and.l		&0x7FFFFFFF,%d1
    8992. 

  8992. 

  8993. 	cmp.l		%d1,&0x3FB98000		# |X| >= 2**(-70)?
    8994. 

  8994. 	bge.b		TWOOK1
    8995. 

  8995. 	bra.w		EXPBORS
    8996. 

  8996. 

  8997. TWOOK1:
    8998. 

  8998. 	cmp.l		%d1,&0x400D80C0		# |X| > 16480?
    8999. 

  8999. 	ble.b		TWOMAIN
    9000. 

  9000. 	bra.w		EXPBORS
    9001. 

  9001. 

  9002. TWOMAIN:
    9003. 

  9003. #--USUAL CASE, 2^(-70) <= |X| <= 16480
    9004. 

  9004. 

  9005. 	fmov.x		%fp0,%fp1
    9006. 

  9006. 	fmul.s		&0x42800000,%fp1	# 64 * X
    9007. 

  9007. 	fmov.l		%fp1,INT(%a6)		# N = ROUND-TO-INT(64 X)
    9008. 

  9008. 	mov.l		%d2,-(%sp)
    9009. 

  9009. 	lea		TEXPTBL(%pc),%a1	# LOAD ADDRESS OF TABLE OF 2^(J/64)
    9010. 

  9010. 	fmov.l		INT(%a6),%fp1		# N --> FLOATING FMT
    9011. 

  9011. 	mov.l		INT(%a6),%d1
    9012. 

  9012. 	mov.l		%d1,%d2
    9013. 

  9013. 	and.l		&0x3F,%d1		# D0 IS J
    9014. 

  9014. 	asl.l		&4,%d1			# DISPLACEMENT FOR 2^(J/64)
    9015. 

  9015. 	add.l		%d1,%a1			# ADDRESS FOR 2^(J/64)
    9016. 

  9016. 	asr.l		&6,%d2			# d2 IS L, N = 64L + J
    9017. 

  9017. 	mov.l		%d2,%d1
    9018. 

  9018. 	asr.l		&1,%d1			# D0 IS M
    9019. 

  9019. 	sub.l		%d1,%d2			# d2 IS M', N = 64(M+M') + J
    9020. 

  9020. 	add.l		&0x3FFF,%d2
    9021. 

  9021. 

  9022. #--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
    9023. 

  9023. #--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
    9024. 

  9024. #--ADJFACT = 2^(M').
    9025. 

  9025. #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
    9026. 

  9026. 

  9027. 	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
    9028. 

  9028. 

  9029. 	fmul.s		&0x3C800000,%fp1	# (1/64)*N
    9030. 

  9030. 	mov.l		(%a1)+,FACT1(%a6)
    9031. 

  9031. 	mov.l		(%a1)+,FACT1HI(%a6)
    9032. 

  9032. 	mov.l		(%a1)+,FACT1LOW(%a6)
    9033. 

  9033. 	mov.w		(%a1)+,FACT2(%a6)
    9034. 

  9034. 

  9035. 	fsub.x		%fp1,%fp0		# X - (1/64)*INT(64 X)
    9036. 

  9036. 

  9037. 	mov.w		(%a1)+,FACT2HI(%a6)
    9038. 

  9038. 	clr.w		FACT2HI+2(%a6)
    9039. 

  9039. 	clr.l		FACT2LOW(%a6)
    9040. 

  9040. 	add.w		%d1,FACT1(%a6)
    9041. 

  9041. 	fmul.x		LOG2(%pc),%fp0		# FP0 IS R
    9042. 

  9042. 	add.w		%d1,FACT2(%a6)
    9043. 

  9043. 

  9044. 	bra.w		expr
    9045. 

  9045. 

  9046. EXPBORS:
    9047. 

  9047. #--FPCR, D0 SAVED
    9048. 

  9048. 	cmp.l		%d1,&0x3FFF8000
    9049. 

  9049. 	bgt.b		TEXPBIG
    9050. 

  9050. 

  9051. #--|X| IS SMALL, RETURN 1 + X
    9052. 

  9052. 

  9053. 	fmov.l		%d0,%fpcr		# restore users round prec,mode
    9054. 

  9054. 	fadd.s		&0x3F800000,%fp0	# RETURN 1 + X
    9055. 

  9055. 	bra		t_pinx2
    9056. 

  9056. 

  9057. TEXPBIG:
    9058. 

  9058. #--|X| IS LARGE, GENERATE OVERFLOW IF X > 0; ELSE GENERATE UNDERFLOW
    9059. 

  9059. #--REGISTERS SAVE SO FAR ARE FPCR AND  D0
    9060. 

  9060. 	mov.l		X(%a6),%d1
    9061. 

  9061. 	cmp.l		%d1,&0
    9062. 

  9062. 	blt.b		EXPNEG
    9063. 

  9063. 

  9064. 	bra		t_ovfl2			# t_ovfl expects positive value
    9065. 

  9065. 

  9066. EXPNEG:
    9067. 

  9067. 	bra		t_unfl2			# t_unfl expects positive value
    9068. 

  9068. 

  9069. 	global		stwotoxd
    9070. 

  9070. stwotoxd:
    9071. 

  9071. #--ENTRY POINT FOR 2**(X) FOR DENORMALIZED ARGUMENT
    9072. 

  9072. 

  9073. 	fmov.l		%d0,%fpcr		# set user's rounding mode/precision
    9074. 

  9074. 	fmov.s		&0x3F800000,%fp0	# RETURN 1 + X
    9075. 

  9075. 	mov.l		(%a0),%d1
    9076. 

  9076. 	or.l		&0x00800001,%d1
    9077. 

  9077. 	fadd.s		%d1,%fp0
    9078. 

  9078. 	bra		t_pinx2
    9079. 

  9079. 

  9080. 	global		stentox
    9081. 

  9081. #--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
    9082. 

  9082. stentox:
    9083. 

  9083. 	fmovm.x		(%a0),&0x80		# LOAD INPUT
    9084. 

  9084. 

  9085. 	mov.l		(%a0),%d1
    9086. 

  9086. 	mov.w		4(%a0),%d1
    9087. 

  9087. 	fmov.x		%fp0,X(%a6)
    9088. 

  9088. 	and.l		&0x7FFFFFFF,%d1
    9089. 

  9089. 

  9090. 	cmp.l		%d1,&0x3FB98000		# |X| >= 2**(-70)?
    9091. 

  9091. 	bge.b		TENOK1
    9092. 

  9092. 	bra.w		EXPBORS
    9093. 

  9093. 

  9094. TENOK1:
    9095. 

  9095. 	cmp.l		%d1,&0x400B9B07		# |X| <= 16480*log2/log10 ?
    9096. 

  9096. 	ble.b		TENMAIN
    9097. 

  9097. 	bra.w		EXPBORS
    9098. 

  9098. 

  9099. TENMAIN:
    9100. 

  9100. #--USUAL CASE, 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10
    9101. 

  9101. 

  9102. 	fmov.x		%fp0,%fp1
    9103. 

  9103. 	fmul.d		L2TEN64(%pc),%fp1	# X*64*LOG10/LOG2
    9104. 

  9104. 	fmov.l		%fp1,INT(%a6)		# N=INT(X*64*LOG10/LOG2)
    9105. 

  9105. 	mov.l		%d2,-(%sp)
    9106. 

  9106. 	lea		TEXPTBL(%pc),%a1	# LOAD ADDRESS OF TABLE OF 2^(J/64)
    9107. 

  9107. 	fmov.l		INT(%a6),%fp1		# N --> FLOATING FMT
    9108. 

  9108. 	mov.l		INT(%a6),%d1
    9109. 

  9109. 	mov.l		%d1,%d2
    9110. 

  9110. 	and.l		&0x3F,%d1		# D0 IS J
    9111. 

  9111. 	asl.l		&4,%d1			# DISPLACEMENT FOR 2^(J/64)
    9112. 

  9112. 	add.l		%d1,%a1			# ADDRESS FOR 2^(J/64)
    9113. 

  9113. 	asr.l		&6,%d2			# d2 IS L, N = 64L + J
    9114. 

  9114. 	mov.l		%d2,%d1
    9115. 

  9115. 	asr.l		&1,%d1			# D0 IS M
    9116. 

  9116. 	sub.l		%d1,%d2			# d2 IS M', N = 64(M+M') + J
    9117. 

  9117. 	add.l		&0x3FFF,%d2
    9118. 

  9118. 

  9119. #--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
    9120. 

  9120. #--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
    9121. 

  9121. #--ADJFACT = 2^(M').
    9122. 

  9122. #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
    9123. 

  9123. 	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
    9124. 

  9124. 

  9125. 	fmov.x		%fp1,%fp2
    9126. 

  9126. 

  9127. 	fmul.d		L10TWO1(%pc),%fp1	# N*(LOG2/64LOG10)_LEAD
    9128. 

  9128. 	mov.l		(%a1)+,FACT1(%a6)
    9129. 

  9129. 

  9130. 	fmul.x		L10TWO2(%pc),%fp2	# N*(LOG2/64LOG10)_TRAIL
    9131. 

  9131. 

  9132. 	mov.l		(%a1)+,FACT1HI(%a6)
    9133. 

  9133. 	mov.l		(%a1)+,FACT1LOW(%a6)
    9134. 

  9134. 	fsub.x		%fp1,%fp0		# X - N L_LEAD
    9135. 

  9135. 	mov.w		(%a1)+,FACT2(%a6)
    9136. 

  9136. 

  9137. 	fsub.x		%fp2,%fp0		# X - N L_TRAIL
    9138. 

  9138. 

  9139. 	mov.w		(%a1)+,FACT2HI(%a6)
    9140. 

  9140. 	clr.w		FACT2HI+2(%a6)
    9141. 

  9141. 	clr.l		FACT2LOW(%a6)
    9142. 

  9142. 

  9143. 	fmul.x		LOG10(%pc),%fp0		# FP0 IS R
    9144. 

  9144. 	add.w		%d1,FACT1(%a6)
    9145. 

  9145. 	add.w		%d1,FACT2(%a6)
    9146. 

  9146. 

  9147. expr:
    9148. 

  9148. #--FPCR, FP2, FP3 ARE SAVED IN ORDER AS SHOWN.
    9149. 

  9149. #--ADJFACT CONTAINS 2**(M'), FACT1 + FACT2 = 2**(M) * 2**(J/64).
    9150. 

  9150. #--FP0 IS R. THE FOLLOWING CODE COMPUTES
    9151. 

  9151. #--	2**(M'+M) * 2**(J/64) * EXP(R)
    9152. 

    9153. 

  9153. 	fmov.x		%fp0,%fp1
    9154. 

  9154. 	fmul.x		%fp1,%fp1		# FP1 IS S = R*R
    9155. 

  9155. 

  9156. 	fmov.d		EXPA5(%pc),%fp2		# FP2 IS A5
    9157. 

  9157. 	fmov.d		EXPA4(%pc),%fp3		# FP3 IS A4
    9158. 

  9158. 

  9159. 	fmul.x		%fp1,%fp2		# FP2 IS S*A5
    9160. 

  9160. 	fmul.x		%fp1,%fp3		# FP3 IS S*A4
    9161. 

  9161. 

  9162. 	fadd.d		EXPA3(%pc),%fp2		# FP2 IS A3+S*A5
    9163. 

  9163. 	fadd.d		EXPA2(%pc),%fp3		# FP3 IS A2+S*A4
    9164. 

  9164. 

  9165. 	fmul.x		%fp1,%fp2		# FP2 IS S*(A3+S*A5)
    9166. 

  9166. 	fmul.x		%fp1,%fp3		# FP3 IS S*(A2+S*A4)
    9167. 

  9167. 

  9168. 	fadd.d		EXPA1(%pc),%fp2		# FP2 IS A1+S*(A3+S*A5)
    9169. 

  9169. 	fmul.x		%fp0,%fp3		# FP3 IS R*S*(A2+S*A4)
    9170. 

  9170. 

  9171. 	fmul.x		%fp1,%fp2		# FP2 IS S*(A1+S*(A3+S*A5))
    9172. 

  9172. 	fadd.x		%fp3,%fp0		# FP0 IS R+R*S*(A2+S*A4)
    9173. 

  9173. 	fadd.x		%fp2,%fp0		# FP0 IS EXP(R) - 1
    9174. 

  9174. 

  9175. 	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
    9176. 

  9176. 

  9177. #--FINAL RECONSTRUCTION PROCESS
    9178. 

  9178. #--EXP(X) = 2^M*2^(J/64) + 2^M*2^(J/64)*(EXP(R)-1)  -  (1 OR 0)
    9179. 

  9179. 

  9180. 	fmul.x		FACT1(%a6),%fp0
    9181. 

  9181. 	fadd.x		FACT2(%a6),%fp0
    9182. 

  9182. 	fadd.x		FACT1(%a6),%fp0
    9183. 

  9183. 

  9184. 	fmov.l		%d0,%fpcr		# restore users round prec,mode
    9185. 

  9185. 	mov.w		%d2,ADJFACT(%a6)	# INSERT EXPONENT
    9186. 

  9186. 	mov.l		(%sp)+,%d2
    9187. 

  9187. 	mov.l		&0x80000000,ADJFACT+4(%a6)
    9188. 

  9188. 	clr.l		ADJFACT+8(%a6)
    9189. 

  9189. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    9190. 

  9190. 	fmul.x		ADJFACT(%a6),%fp0	# FINAL ADJUSTMENT
    9191. 

  9191. 	bra		t_catch
    9192. 

  9192. 

  9193. 	global		stentoxd
    9194. 

  9194. stentoxd:
    9195. 

  9195. #--ENTRY POINT FOR 10**(X) FOR DENORMALIZED ARGUMENT
    9196. 

  9196. 

  9197. 	fmov.l		%d0,%fpcr		# set user's rounding mode/precision
    9198. 

  9198. 	fmov.s		&0x3F800000,%fp0	# RETURN 1 + X
    9199. 

  9199. 	mov.l		(%a0),%d1
    9200. 

  9200. 	or.l		&0x00800001,%d1
    9201. 

  9201. 	fadd.s		%d1,%fp0
    9202. 

  9202. 	bra		t_pinx2
    9203. 

  9203. 

  9204. #########################################################################
    9205. 

  9205. # sscale(): computes the destination operand scaled by the source	#
    9206. 

  9206. #	    operand. If the absoulute value of the source operand is	#
    9207. 

  9207. #	    >= 2^14, an overflow or underflow is returned.		#
    9208. 

  9208. #									#
    9209. 

  9209. # INPUT *************************************************************** #
    9210. 

  9210. #	a0  = pointer to double-extended source operand X		#
    9211. 

  9211. #	a1  = pointer to double-extended destination operand Y		#
    9212. 

  9212. #									#
    9213. 

  9213. # OUTPUT ************************************************************** #
    9214. 

  9214. #	fp0 =  scale(X,Y)						#
    9215. 

  9215. #									#
    9216. 

  9216. #########################################################################
    9217. 

  9217. 

  9218. set	SIGN,		L_SCR1
    9219. 

  9219. 

  9220. 	global		sscale
    9221. 

  9221. sscale:
    9222. 

  9222. 	mov.l		%d0,-(%sp)		# store off ctrl bits for now
    9223. 

  9223. 

  9224. 	mov.w		DST_EX(%a1),%d1		# get dst exponent
    9225. 

  9225. 	smi.b		SIGN(%a6)		# use SIGN to hold dst sign
    9226. 

  9226. 	andi.l		&0x00007fff,%d1		# strip sign from dst exp
    9227. 

  9227. 

  9228. 	mov.w		SRC_EX(%a0),%d0		# check src bounds
    9229. 

  9229. 	andi.w		&0x7fff,%d0		# clr src sign bit
    9230. 

  9230. 	cmpi.w		%d0,&0x3fff		# is src ~ ZERO?
    9231. 

  9231. 	blt.w		src_small		# yes
    9232. 

  9232. 	cmpi.w		%d0,&0x400c		# no; is src too big?
    9233. 

  9233. 	bgt.w		src_out			# yes
    9234. 

  9234. 

  9235. #
    9236. 

  9236. # Source is within 2^14 range.
    9237. 

  9237. #
    9238. 

  9238. src_ok:
    9239. 

  9239. 	fintrz.x	SRC(%a0),%fp0		# calc int of src
    9240. 

  9240. 	fmov.l		%fp0,%d0		# int src to d0
    9241. 

  9241. # don't want any accrued bits from the fintrz showing up later since
    9242. 

  9242. # we may need to read the fpsr for the last fp op in t_catch2().
    9243. 

  9243. 	fmov.l		&0x0,%fpsr
    9244. 

  9244. 

  9245. 	tst.b		DST_HI(%a1)		# is dst denormalized?
    9246. 

  9246. 	bmi.b		sok_norm
    9247. 

  9247. 

  9248. # the dst is a DENORM. normalize the DENORM and add the adjustment to
    9249. 

  9249. # the src value. then, jump to the norm part of the routine.
    9250. 

  9250. sok_dnrm:
    9251. 

  9251. 	mov.l		%d0,-(%sp)		# save src for now
    9252. 

  9252. 

  9253. 	mov.w		DST_EX(%a1),FP_SCR0_EX(%a6) # make a copy
    9254. 

  9254. 	mov.l		DST_HI(%a1),FP_SCR0_HI(%a6)
    9255. 

  9255. 	mov.l		DST_LO(%a1),FP_SCR0_LO(%a6)
    9256. 

  9256. 

  9257. 	lea		FP_SCR0(%a6),%a0	# pass ptr to DENORM
    9258. 

  9258. 	bsr.l		norm			# normalize the DENORM
    9259. 

  9259. 	neg.l		%d0
    9260. 

  9260. 	add.l		(%sp)+,%d0		# add adjustment to src
    9261. 

  9261. 

  9262. 	fmovm.x		FP_SCR0(%a6),&0x80	# load normalized DENORM
    9263. 

  9263. 

  9264. 	cmpi.w		%d0,&-0x3fff		# is the shft amt really low?
    9265. 

  9265. 	bge.b		sok_norm2		# thank goodness no
    9266. 

  9266. 

  9267. # the multiply factor that we're trying to create should be a denorm
    9268. 

  9268. # for the multiply to work. therefore, we're going to actually do a
    9269. 

  9269. # multiply with a denorm which will cause an unimplemented data type
    9270. 

  9270. # exception to be put into the machine which will be caught and corrected
    9271. 

  9271. # later. we don't do this with the DENORMs above because this method
    9272. 

  9272. # is slower. but, don't fret, I don't see it being used much either.
    9273. 

  9273. 	fmov.l		(%sp)+,%fpcr		# restore user fpcr
    9274. 

  9274. 	mov.l		&0x80000000,%d1		# load normalized mantissa
    9275. 

  9275. 	subi.l		&-0x3fff,%d0		# how many should we shift?
    9276. 

  9276. 	neg.l		%d0			# make it positive
    9277. 

  9277. 	cmpi.b		%d0,&0x20		# is it > 32?
    9278. 

  9278. 	bge.b		sok_dnrm_32		# yes
    9279. 

  9279. 	lsr.l		%d0,%d1			# no; bit stays in upper lw
    9280. 

  9280. 	clr.l		-(%sp)			# insert zero low mantissa
    9281. 

  9281. 	mov.l		%d1,-(%sp)		# insert new high mantissa
    9282. 

  9282. 	clr.l		-(%sp)			# make zero exponent
    9283. 

  9283. 	bra.b		sok_norm_cont
    9284. 

  9284. sok_dnrm_32:
    9285. 

  9285. 	subi.b		&0x20,%d0		# get shift count
    9286. 

  9286. 	lsr.l		%d0,%d1			# make low mantissa longword
    9287. 

  9287. 	mov.l		%d1,-(%sp)		# insert new low mantissa
    9288. 

  9288. 	clr.l		-(%sp)			# insert zero high mantissa
    9289. 

  9289. 	clr.l		-(%sp)			# make zero exponent
    9290. 

  9290. 	bra.b		sok_norm_cont
    9291. 

  9291. 

  9292. # the src will force the dst to a DENORM value or worse. so, let's
    9293. 

  9293. # create an fp multiply that will create the result.
    9294. 

  9294. sok_norm:
    9295. 

  9295. 	fmovm.x		DST(%a1),&0x80		# load fp0 with normalized src
    9296. 

  9296. sok_norm2:
    9297. 

  9297. 	fmov.l		(%sp)+,%fpcr		# restore user fpcr
    9298. 

  9298. 

  9299. 	addi.w		&0x3fff,%d0		# turn src amt into exp value
    9300. 

  9300. 	swap		%d0			# put exponent in high word
    9301. 

  9301. 	clr.l		-(%sp)			# insert new exponent
    9302. 

  9302. 	mov.l		&0x80000000,-(%sp)	# insert new high mantissa
    9303. 

  9303. 	mov.l		%d0,-(%sp)		# insert new lo mantissa
    9304. 

  9304. 

  9305. sok_norm_cont:
    9306. 

  9306. 	fmov.l		%fpcr,%d0		# d0 needs fpcr for t_catch2
    9307. 

  9307. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    9308. 

  9308. 	fmul.x		(%sp)+,%fp0		# do the multiply
    9309. 

  9309. 	bra		t_catch2		# catch any exceptions
    9310. 

  9310. 

  9311. #
    9312. 

  9312. # Source is outside of 2^14 range.  Test the sign and branch
    9313. 

  9313. # to the appropriate exception handler.
    9314. 

  9314. #
    9315. 

  9315. src_out:
    9316. 

  9316. 	mov.l		(%sp)+,%d0		# restore ctrl bits
    9317. 

  9317. 	exg		%a0,%a1			# swap src,dst ptrs
    9318. 

  9318. 	tst.b		SRC_EX(%a1)		# is src negative?
    9319. 

  9319. 	bmi		t_unfl			# yes; underflow
    9320. 

  9320. 	bra		t_ovfl_sc		# no; overflow
    9321. 

  9321. 

  9322. #
    9323. 

  9323. # The source input is below 1, so we check for denormalized numbers
    9324. 

  9324. # and set unfl.
    9325. 

  9325. #
    9326. 

  9326. src_small:
    9327. 

  9327. 	tst.b		DST_HI(%a1)		# is dst denormalized?
    9328. 

  9328. 	bpl.b		ssmall_done		# yes
    9329. 

  9329. 

  9330. 	mov.l		(%sp)+,%d0
    9331. 

  9331. 	fmov.l		%d0,%fpcr		# no; load control bits
    9332. 

  9332. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    9333. 

  9333. 	fmov.x		DST(%a1),%fp0		# simply return dest
    9334. 

  9334. 	bra		t_catch2
    9335. 

  9335. ssmall_done:
    9336. 

  9336. 	mov.l		(%sp)+,%d0		# load control bits into d1
    9337. 

  9337. 	mov.l		%a1,%a0			# pass ptr to dst
    9338. 

  9338. 	bra		t_resdnrm
    9339. 

  9339. 

  9340. #########################################################################
    9341. 

  9341. # smod(): computes the fp MOD of the input values X,Y.			#
    9342. 

  9342. # srem(): computes the fp (IEEE) REM of the input values X,Y.		#
    9343. 

  9343. #									#
    9344. 

  9344. # INPUT *************************************************************** #
    9345. 

  9345. #	a0 = pointer to extended precision input X			#
    9346. 

  9346. #	a1 = pointer to extended precision input Y			#
    9347. 

  9347. #	d0 = round precision,mode					#
    9348. 

  9348. #									#
    9349. 

  9349. #	The input operands X and Y can be either normalized or		#
    9350. 

  9350. #	denormalized.							#
    9351. 

  9351. #									#
    9352. 

  9352. # OUTPUT ************************************************************** #
    9353. 

  9353. #      fp0 = FREM(X,Y) or FMOD(X,Y)					#
    9354. 

  9354. #									#
    9355. 

  9355. # ALGORITHM *********************************************************** #
    9356. 

  9356. #									#
    9357. 

  9357. #       Step 1.  Save and strip signs of X and Y: signX := sign(X),	#
    9358. 

  9358. #                signY := sign(Y), X := |X|, Y := |Y|,			#
    9359. 

  9359. #                signQ := signX EOR signY. Record whether MOD or REM	#
    9360. 

  9360. #                is requested.						#
    9361. 

  9361. #									#
    9362. 

  9362. #       Step 2.  Set L := expo(X)-expo(Y), k := 0, Q := 0.		#
    9363. 

  9363. #                If (L < 0) then					#
    9364. 

  9364. #                   R := X, go to Step 4.				#
    9365. 

  9365. #                else							#
    9366. 

  9366. #                   R := 2^(-L)X, j := L.				#
    9367. 

  9367. #                endif							#
    9368. 

  9368. #									#
    9369. 

  9369. #       Step 3.  Perform MOD(X,Y)					#
    9370. 

  9370. #            3.1 If R = Y, go to Step 9.				#
    9371. 

  9371. #            3.2 If R > Y, then { R := R - Y, Q := Q + 1}		#
    9372. 

  9372. #            3.3 If j = 0, go to Step 4.				#
    9373. 

  9373. #            3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to	#
    9374. 

  9374. #                Step 3.1.						#
    9375. 

  9375. #									#
    9376. 

  9376. #       Step 4.  At this point, R = X - QY = MOD(X,Y). Set		#
    9377. 

  9377. #                Last_Subtract := false (used in Step 7 below). If	#
    9378. 

  9378. #                MOD is requested, go to Step 6.			#
    9379. 

  9379. #									#
    9380. 

  9380. #       Step 5.  R = MOD(X,Y), but REM(X,Y) is requested.		#
    9381. 

  9381. #            5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to	#
    9382. 

  9382. #                Step 6.						#
    9383. 

  9383. #            5.2 If R > Y/2, then { set Last_Subtract := true,		#
    9384. 

  9384. #                Q := Q + 1, Y := signY*Y }. Go to Step 6.		#
    9385. 

  9385. #            5.3 This is the tricky case of R = Y/2. If Q is odd,	#
    9386. 

  9386. #                then { Q := Q + 1, signX := -signX }.			#
    9387. 

  9387. #									#
    9388. 

  9388. #       Step 6.  R := signX*R.						#
    9389. 

  9389. #									#
    9390. 

  9390. #       Step 7.  If Last_Subtract = true, R := R - Y.			#
    9391. 

  9391. #									#
    9392. 

  9392. #       Step 8.  Return signQ, last 7 bits of Q, and R as required.	#
    9393. 

  9393. #									#
    9394. 

  9394. #       Step 9.  At this point, R = 2^(-j)*X - Q Y = Y. Thus,		#
    9395. 

  9395. #                X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1),		#
    9396. 

  9396. #                R := 0. Return signQ, last 7 bits of Q, and R.		#
    9397. 

  9397. #									#
    9398. 

  9398. #########################################################################
    9399. 

  9399. 

  9400. 	set		Mod_Flag,L_SCR3
    9401. 

  9401. 	set		Sc_Flag,L_SCR3+1
    9402. 

  9402. 

  9403. 	set		SignY,L_SCR2
    9404. 

  9404. 	set		SignX,L_SCR2+2
    9405. 

  9405. 	set		SignQ,L_SCR3+2
    9406. 

  9406. 

  9407. 	set		Y,FP_SCR0
    9408. 

  9408. 	set		Y_Hi,Y+4
    9409. 

  9409. 	set		Y_Lo,Y+8
    9410. 

  9410. 

  9411. 	set		R,FP_SCR1
    9412. 

  9412. 	set		R_Hi,R+4
    9413. 

  9413. 	set		R_Lo,R+8
    9414. 

  9414. 

  9415. Scale:
    9416. 

  9416. 	long		0x00010000,0x80000000,0x00000000,0x00000000
    9417. 

  9417. 

  9418. 	global		smod
    9419. 

  9419. smod:
    9420. 

  9420. 	clr.b		FPSR_QBYTE(%a6)
    9421. 

  9421. 	mov.l		%d0,-(%sp)		# save ctrl bits
    9422. 

  9422. 	clr.b		Mod_Flag(%a6)
    9423. 

  9423. 	bra.b		Mod_Rem
    9424. 

  9424. 

  9425. 	global		srem
    9426. 

  9426. srem:
    9427. 

  9427. 	clr.b		FPSR_QBYTE(%a6)
    9428. 

  9428. 	mov.l		%d0,-(%sp)		# save ctrl bits
    9429. 

  9429. 	mov.b		&0x1,Mod_Flag(%a6)
    9430. 

  9430. 

  9431. Mod_Rem:
    9432. 

  9432. #..Save sign of X and Y
    9433. 

  9433. 	movm.l		&0x3f00,-(%sp)		# save data registers
    9434. 

  9434. 	mov.w		SRC_EX(%a0),%d3
    9435. 

  9435. 	mov.w		%d3,SignY(%a6)
    9436. 

  9436. 	and.l		&0x00007FFF,%d3		# Y := |Y|
    9437. 

  9437. 

  9438. #
    9439. 

  9439. 	mov.l		SRC_HI(%a0),%d4
    9440. 

  9440. 	mov.l		SRC_LO(%a0),%d5		# (D3,D4,D5) is |Y|
    9441. 

  9441. 

  9442. 	tst.l		%d3
    9443. 

  9443. 	bne.b		Y_Normal
    9444. 

  9444. 

  9445. 	mov.l		&0x00003FFE,%d3		# $3FFD + 1
    9446. 

  9446. 	tst.l		%d4
    9447. 

  9447. 	bne.b		HiY_not0
    9448. 

  9448. 

  9449. HiY_0:
    9450. 

  9450. 	mov.l		%d5,%d4
    9451. 

  9451. 	clr.l		%d5
    9452. 

  9452. 	sub.l		&32,%d3
    9453. 

  9453. 	clr.l		%d6
    9454. 

  9454. 	bfffo		%d4{&0:&32},%d6
    9455. 

  9455. 	lsl.l		%d6,%d4
    9456. 

  9456. 	sub.l		%d6,%d3			# (D3,D4,D5) is normalized
    9457. 

  9457. #	                                        ...with bias $7FFD
    9458. 

  9458. 	bra.b		Chk_X
    9459. 

  9459. 

  9460. HiY_not0:
    9461. 

  9461. 	clr.l		%d6
    9462. 

  9462. 	bfffo		%d4{&0:&32},%d6
    9463. 

  9463. 	sub.l		%d6,%d3
    9464. 

  9464. 	lsl.l		%d6,%d4
    9465. 

  9465. 	mov.l		%d5,%d7			# a copy of D5
    9466. 

  9466. 	lsl.l		%d6,%d5
    9467. 

  9467. 	neg.l		%d6
    9468. 

  9468. 	add.l		&32,%d6
    9469. 

  9469. 	lsr.l		%d6,%d7
    9470. 

  9470. 	or.l		%d7,%d4			# (D3,D4,D5) normalized
    9471. 

  9471. #                                       ...with bias $7FFD
    9472. 

  9472. 	bra.b		Chk_X
    9473. 

  9473. 

  9474. Y_Normal:
    9475. 

  9475. 	add.l		&0x00003FFE,%d3		# (D3,D4,D5) normalized
    9476. 

  9476. #                                       ...with bias $7FFD
    9477. 

  9477. 

  9478. Chk_X:
    9479. 

  9479. 	mov.w		DST_EX(%a1),%d0
    9480. 

  9480. 	mov.w		%d0,SignX(%a6)
    9481. 

  9481. 	mov.w		SignY(%a6),%d1
    9482. 

  9482. 	eor.l		%d0,%d1
    9483. 

  9483. 	and.l		&0x00008000,%d1
    9484. 

  9484. 	mov.w		%d1,SignQ(%a6)		# sign(Q) obtained
    9485. 

  9485. 	and.l		&0x00007FFF,%d0
    9486. 

  9486. 	mov.l		DST_HI(%a1),%d1
    9487. 

  9487. 	mov.l		DST_LO(%a1),%d2		# (D0,D1,D2) is |X|
    9488. 

  9488. 	tst.l		%d0
    9489. 

  9489. 	bne.b		X_Normal
    9490. 

  9490. 	mov.l		&0x00003FFE,%d0
    9491. 

  9491. 	tst.l		%d1
    9492. 

  9492. 	bne.b		HiX_not0
    9493. 

  9493. 

  9494. HiX_0:
    9495. 

  9495. 	mov.l		%d2,%d1
    9496. 

  9496. 	clr.l		%d2
    9497. 

  9497. 	sub.l		&32,%d0
    9498. 

  9498. 	clr.l		%d6
    9499. 

  9499. 	bfffo		%d1{&0:&32},%d6
    9500. 

  9500. 	lsl.l		%d6,%d1
    9501. 

  9501. 	sub.l		%d6,%d0			# (D0,D1,D2) is normalized
    9502. 

  9502. #                                       ...with bias $7FFD
    9503. 

  9503. 	bra.b		Init
    9504. 

  9504. 

  9505. HiX_not0:
    9506. 

  9506. 	clr.l		%d6
    9507. 

  9507. 	bfffo		%d1{&0:&32},%d6
    9508. 

  9508. 	sub.l		%d6,%d0
    9509. 

  9509. 	lsl.l		%d6,%d1
    9510. 

  9510. 	mov.l		%d2,%d7			# a copy of D2
    9511. 

  9511. 	lsl.l		%d6,%d2
    9512. 

  9512. 	neg.l		%d6
    9513. 

  9513. 	add.l		&32,%d6
    9514. 

  9514. 	lsr.l		%d6,%d7
    9515. 

  9515. 	or.l		%d7,%d1			# (D0,D1,D2) normalized
    9516. 

  9516. #                                       ...with bias $7FFD
    9517. 

  9517. 	bra.b		Init
    9518. 

  9518. 

  9519. X_Normal:
    9520. 

  9520. 	add.l		&0x00003FFE,%d0		# (D0,D1,D2) normalized
    9521. 

  9521. #                                       ...with bias $7FFD
    9522. 

  9522. 

  9523. Init:
    9524. 

  9524. #
    9525. 

  9525. 	mov.l		%d3,L_SCR1(%a6)		# save biased exp(Y)
    9526. 

  9526. 	mov.l		%d0,-(%sp)		# save biased exp(X)
    9527. 

  9527. 	sub.l		%d3,%d0			# L := expo(X)-expo(Y)
    9528. 

  9528. 

  9529. 	clr.l		%d6			# D6 := carry <- 0
    9530. 

  9530. 	clr.l		%d3			# D3 is Q
    9531. 

  9531. 	mov.l		&0,%a1			# A1 is k; j+k=L, Q=0
    9532. 

  9532. 

  9533. #..(Carry,D1,D2) is R
    9534. 

  9534. 	tst.l		%d0
    9535. 

  9535. 	bge.b		Mod_Loop_pre
    9536. 

  9536. 

  9537. #..expo(X) < expo(Y). Thus X = mod(X,Y)
    9538. 

  9538. #
    9539. 

  9539. 	mov.l		(%sp)+,%d0		# restore d0
    9540. 

  9540. 	bra.w		Get_Mod
    9541. 

  9541. 

  9542. Mod_Loop_pre:
    9543. 

  9543. 	addq.l		&0x4,%sp		# erase exp(X)
    9544. 

  9544. #..At this point  R = 2^(-L)X; Q = 0; k = 0; and  k+j = L
    9545. 

  9545. Mod_Loop:
    9546. 

  9546. 	tst.l		%d6			# test carry bit
    9547. 

  9547. 	bgt.b		R_GT_Y
    9548. 

  9548. 

  9549. #..At this point carry = 0, R = (D1,D2), Y = (D4,D5)
    9550. 

  9550. 	cmp.l		%d1,%d4			# compare hi(R) and hi(Y)
    9551. 

  9551. 	bne.b		R_NE_Y
    9552. 

  9552. 	cmp.l		%d2,%d5			# compare lo(R) and lo(Y)
    9553. 

  9553. 	bne.b		R_NE_Y
    9554. 

  9554. 

  9555. #..At this point, R = Y
    9556. 

  9556. 	bra.w		Rem_is_0
    9557. 

  9557. 

  9558. R_NE_Y:
    9559. 

  9559. #..use the borrow of the previous compare
    9560. 

  9560. 	bcs.b		R_LT_Y			# borrow is set iff R < Y
    9561. 

  9561. 

  9562. R_GT_Y:
    9563. 

  9563. #..If Carry is set, then Y < (Carry,D1,D2) < 2Y. Otherwise, Carry = 0
    9564. 

  9564. #..and Y < (D1,D2) < 2Y. Either way, perform R - Y
    9565. 

  9565. 	sub.l		%d5,%d2			# lo(R) - lo(Y)
    9566. 

  9566. 	subx.l		%d4,%d1			# hi(R) - hi(Y)
    9567. 

  9567. 	clr.l		%d6			# clear carry
    9568. 

  9568. 	addq.l		&1,%d3			# Q := Q + 1
    9569. 

  9569. 

  9570. R_LT_Y:
    9571. 

  9571. #..At this point, Carry=0, R < Y. R = 2^(k-L)X - QY; k+j = L; j >= 0.
    9572. 

  9572. 	tst.l		%d0			# see if j = 0.
    9573. 

  9573. 	beq.b		PostLoop
    9574. 

  9574. 

  9575. 	add.l		%d3,%d3			# Q := 2Q
    9576. 

  9576. 	add.l		%d2,%d2			# lo(R) = 2lo(R)
    9577. 

  9577. 	roxl.l		&1,%d1			# hi(R) = 2hi(R) + carry
    9578. 

  9578. 	scs		%d6			# set Carry if 2(R) overflows
    9579. 

  9579. 	addq.l		&1,%a1			# k := k+1
    9580. 

  9580. 	subq.l		&1,%d0			# j := j - 1
    9581. 

  9581. #..At this point, R=(Carry,D1,D2) = 2^(k-L)X - QY, j+k=L, j >= 0, R < 2Y.
    9582. 

  9582. 

  9583. 	bra.b		Mod_Loop
    9584. 

  9584. 

  9585. PostLoop:
    9586. 

  9586. #..k = L, j = 0, Carry = 0, R = (D1,D2) = X - QY, R < Y.
    9587. 

  9587. 

  9588. #..normalize R.
    9589. 

  9589. 	mov.l		L_SCR1(%a6),%d0		# new biased expo of R
    9590. 

  9590. 	tst.l		%d1
    9591. 

  9591. 	bne.b		HiR_not0
    9592. 

  9592. 

  9593. HiR_0:
    9594. 

  9594. 	mov.l		%d2,%d1
    9595. 

  9595. 	clr.l		%d2
    9596. 

  9596. 	sub.l		&32,%d0
    9597. 

  9597. 	clr.l		%d6
    9598. 

  9598. 	bfffo		%d1{&0:&32},%d6
    9599. 

  9599. 	lsl.l		%d6,%d1
    9600. 

  9600. 	sub.l		%d6,%d0			# (D0,D1,D2) is normalized
    9601. 

  9601. #                                       ...with bias $7FFD
    9602. 

  9602. 	bra.b		Get_Mod
    9603. 

  9603. 

  9604. HiR_not0:
    9605. 

  9605. 	clr.l		%d6
    9606. 

  9606. 	bfffo		%d1{&0:&32},%d6
    9607. 

  9607. 	bmi.b		Get_Mod			# already normalized
    9608. 

  9608. 	sub.l		%d6,%d0
    9609. 

  9609. 	lsl.l		%d6,%d1
    9610. 

  9610. 	mov.l		%d2,%d7			# a copy of D2
    9611. 

  9611. 	lsl.l		%d6,%d2
    9612. 

  9612. 	neg.l		%d6
    9613. 

  9613. 	add.l		&32,%d6
    9614. 

  9614. 	lsr.l		%d6,%d7
    9615. 

  9615. 	or.l		%d7,%d1			# (D0,D1,D2) normalized
    9616. 

  9616. 

  9617. #
    9618. 

  9618. Get_Mod:
    9619. 

  9619. 	cmp.l		%d0,&0x000041FE
    9620. 

  9620. 	bge.b		No_Scale
    9621. 

  9621. Do_Scale:
    9622. 

  9622. 	mov.w		%d0,R(%a6)
    9623. 

  9623. 	mov.l		%d1,R_Hi(%a6)
    9624. 

  9624. 	mov.l		%d2,R_Lo(%a6)
    9625. 

  9625. 	mov.l		L_SCR1(%a6),%d6
    9626. 

  9626. 	mov.w		%d6,Y(%a6)
    9627. 

  9627. 	mov.l		%d4,Y_Hi(%a6)
    9628. 

  9628. 	mov.l		%d5,Y_Lo(%a6)
    9629. 

  9629. 	fmov.x		R(%a6),%fp0		# no exception
    9630. 

  9630. 	mov.b		&1,Sc_Flag(%a6)
    9631. 

  9631. 	bra.b		ModOrRem
    9632. 

  9632. No_Scale:
    9633. 

  9633. 	mov.l		%d1,R_Hi(%a6)
    9634. 

  9634. 	mov.l		%d2,R_Lo(%a6)
    9635. 

  9635. 	sub.l		&0x3FFE,%d0
    9636. 

  9636. 	mov.w		%d0,R(%a6)
    9637. 

  9637. 	mov.l		L_SCR1(%a6),%d6
    9638. 

  9638. 	sub.l		&0x3FFE,%d6
    9639. 

  9639. 	mov.l		%d6,L_SCR1(%a6)
    9640. 

  9640. 	fmov.x		R(%a6),%fp0
    9641. 

  9641. 	mov.w		%d6,Y(%a6)
    9642. 

  9642. 	mov.l		%d4,Y_Hi(%a6)
    9643. 

  9643. 	mov.l		%d5,Y_Lo(%a6)
    9644. 

  9644. 	clr.b		Sc_Flag(%a6)
    9645. 

  9645. 

  9646. #
    9647. 

  9647. ModOrRem:
    9648. 

  9648. 	tst.b		Mod_Flag(%a6)
    9649. 

  9649. 	beq.b		Fix_Sign
    9650. 

  9650. 

  9651. 	mov.l		L_SCR1(%a6),%d6		# new biased expo(Y)
    9652. 

  9652. 	subq.l		&1,%d6			# biased expo(Y/2)
    9653. 

  9653. 	cmp.l		%d0,%d6
    9654. 

  9654. 	blt.b		Fix_Sign
    9655. 

  9655. 	bgt.b		Last_Sub
    9656. 

  9656. 

  9657. 	cmp.l		%d1,%d4
    9658. 

  9658. 	bne.b		Not_EQ
    9659. 

  9659. 	cmp.l		%d2,%d5
    9660. 

  9660. 	bne.b		Not_EQ
    9661. 

  9661. 	bra.w		Tie_Case
    9662. 

  9662. 

  9663. Not_EQ:
    9664. 

  9664. 	bcs.b		Fix_Sign
    9665. 

  9665. 

  9666. Last_Sub:
    9667. 

  9667. #
    9668. 

  9668. 	fsub.x		Y(%a6),%fp0		# no exceptions
    9669. 

  9669. 	addq.l		&1,%d3			# Q := Q + 1
    9670. 

  9670. 

  9671. #
    9672. 

  9672. Fix_Sign:
    9673. 

  9673. #..Get sign of X
    9674. 

  9674. 	mov.w		SignX(%a6),%d6
    9675. 

  9675. 	bge.b		Get_Q
    9676. 

  9676. 	fneg.x		%fp0
    9677. 

  9677. 

  9678. #..Get Q
    9679. 

  9679. #
    9680. 

  9680. Get_Q:
    9681. 

  9681. 	clr.l		%d6
    9682. 

  9682. 	mov.w		SignQ(%a6),%d6		# D6 is sign(Q)
    9683. 

  9683. 	mov.l		&8,%d7
    9684. 

  9684. 	lsr.l		%d7,%d6
    9685. 

  9685. 	and.l		&0x0000007F,%d3		# 7 bits of Q
    9686. 

  9686. 	or.l		%d6,%d3			# sign and bits of Q
    9687. 

  9687. #	swap		%d3
    9688. 

  9688. #	fmov.l		%fpsr,%d6
    9689. 

  9689. #	and.l		&0xFF00FFFF,%d6
    9690. 

  9690. #	or.l		%d3,%d6
    9691. 

  9691. #	fmov.l		%d6,%fpsr		# put Q in fpsr
    9692. 

  9692. 	mov.b		%d3,FPSR_QBYTE(%a6)	# put Q in fpsr
    9693. 

  9693. 

  9694. #
    9695. 

  9695. Restore:
    9696. 

  9696. 	movm.l		(%sp)+,&0xfc		#  {%d2-%d7}
    9697. 

  9697. 	mov.l		(%sp)+,%d0
    9698. 

  9698. 	fmov.l		%d0,%fpcr
    9699. 

  9699. 	tst.b		Sc_Flag(%a6)
    9700. 

  9700. 	beq.b		Finish
    9701. 

  9701. 	mov.b		&FMUL_OP,%d1		# last inst is MUL
    9702. 

  9702. 	fmul.x		Scale(%pc),%fp0		# may cause underflow
    9703. 

  9703. 	bra		t_catch2
    9704. 

  9704. # the '040 package did this apparently to see if the dst operand for the
    9705. 

  9705. # preceding fmul was a denorm. but, it better not have been since the
    9706. 

  9706. # algorithm just got done playing with fp0 and expected no exceptions
    9707. 

  9707. # as a result. trust me...
    9708. 

  9708. #	bra		t_avoid_unsupp		# check for denorm as a
    9709. 

  9709. #						;result of the scaling
    9710. 

  9710. 

  9711. Finish:
    9712. 

  9712. 	mov.b		&FMOV_OP,%d1		# last inst is MOVE
    9713. 

  9713. 	fmov.x		%fp0,%fp0		# capture exceptions & round
    9714. 

  9714. 	bra		t_catch2
    9715. 

  9715. 

  9716. Rem_is_0:
    9717. 

  9717. #..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1)
    9718. 

  9718. 	addq.l		&1,%d3
    9719. 

  9719. 	cmp.l		%d0,&8			# D0 is j
    9720. 

  9720. 	bge.b		Q_Big
    9721. 

  9721. 

  9722. 	lsl.l		%d0,%d3
    9723. 

  9723. 	bra.b		Set_R_0
    9724. 

  9724. 

  9725. Q_Big:
    9726. 

  9726. 	clr.l		%d3
    9727. 

  9727. 

  9728. Set_R_0:
    9729. 

  9729. 	fmov.s		&0x00000000,%fp0
    9730. 

  9730. 	clr.b		Sc_Flag(%a6)
    9731. 

  9731. 	bra.w		Fix_Sign
    9732. 

  9732. 

  9733. Tie_Case:
    9734. 

  9734. #..Check parity of Q
    9735. 

  9735. 	mov.l		%d3,%d6
    9736. 

  9736. 	and.l		&0x00000001,%d6
    9737. 

  9737. 	tst.l		%d6
    9738. 

  9738. 	beq.w		Fix_Sign		# Q is even
    9739. 

  9739. 

  9740. #..Q is odd, Q := Q + 1, signX := -signX
    9741. 

  9741. 	addq.l		&1,%d3
    9742. 

  9742. 	mov.w		SignX(%a6),%d6
    9743. 

  9743. 	eor.l		&0x00008000,%d6
    9744. 

  9744. 	mov.w		%d6,SignX(%a6)
    9745. 

  9745. 	bra.w		Fix_Sign
    9746. 

  9746. 

  9747. #########################################################################
    9748. 

  9748. # XDEF ****************************************************************	#
    9749. 

  9749. #	tag(): return the optype of the input ext fp number		#
    9750. 

  9750. #									#
    9751. 

  9751. #	This routine is used by the 060FPLSP.				#
    9752. 

  9752. #									#
    9753. 

  9753. # XREF ****************************************************************	#
    9754. 

  9754. #	None								#
    9755. 

  9755. #									#
    9756. 

  9756. # INPUT ***************************************************************	#
    9757. 

  9757. #	a0 = pointer to extended precision operand			#
    9758. 

  9758. #									#
    9759. 

  9759. # OUTPUT **************************************************************	#
    9760. 

  9760. #	d0 = value of type tag						#
    9761. 

  9761. #		one of: NORM, INF, QNAN, SNAN, DENORM, ZERO		#
    9762. 

  9762. #									#
    9763. 

  9763. # ALGORITHM ***********************************************************	#
    9764. 

  9764. #	Simply test the exponent, j-bit, and mantissa values to		#
    9765. 

  9765. # determine the type of operand.					#
    9766. 

  9766. #	If it's an unnormalized zero, alter the operand and force it	#
    9767. 

  9767. # to be a normal zero.							#
    9768. 

  9768. #									#
    9769. 

  9769. #########################################################################
    9770. 

  9770. 

  9771. 	global		tag
    9772. 

  9772. tag:
    9773. 

  9773. 	mov.w		FTEMP_EX(%a0), %d0	# extract exponent
    9774. 

  9774. 	andi.w		&0x7fff, %d0		# strip off sign
    9775. 

  9775. 	cmpi.w		%d0, &0x7fff		# is (EXP == MAX)?
    9776. 

  9776. 	beq.b		inf_or_nan_x
    9777. 

  9777. not_inf_or_nan_x:
    9778. 

  9778. 	btst		&0x7,FTEMP_HI(%a0)
    9779. 

  9779. 	beq.b		not_norm_x
    9780. 

  9780. is_norm_x:
    9781. 

  9781. 	mov.b		&NORM, %d0
    9782. 

  9782. 	rts
    9783. 

  9783. not_norm_x:
    9784. 

  9784. 	tst.w		%d0			# is exponent = 0?
    9785. 

  9785. 	bne.b		is_unnorm_x
    9786. 

  9786. not_unnorm_x:
    9787. 

  9787. 	tst.l		FTEMP_HI(%a0)
    9788. 

  9788. 	bne.b		is_denorm_x
    9789. 

  9789. 	tst.l		FTEMP_LO(%a0)
    9790. 

  9790. 	bne.b		is_denorm_x
    9791. 

  9791. is_zero_x:
    9792. 

  9792. 	mov.b		&ZERO, %d0
    9793. 

  9793. 	rts
    9794. 

  9794. is_denorm_x:
    9795. 

  9795. 	mov.b		&DENORM, %d0
    9796. 

  9796. 	rts
    9797. 

  9797. is_unnorm_x:
    9798. 

  9798. 	bsr.l		unnorm_fix		# convert to norm,denorm,or zero
    9799. 

  9799. 	rts
    9800. 

  9800. is_unnorm_reg_x:
    9801. 

  9801. 	mov.b		&UNNORM, %d0
    9802. 

  9802. 	rts
    9803. 

  9803. inf_or_nan_x:
    9804. 

  9804. 	tst.l		FTEMP_LO(%a0)
    9805. 

  9805. 	bne.b		is_nan_x
    9806. 

  9806. 	mov.l		FTEMP_HI(%a0), %d0
    9807. 

  9807. 	and.l		&0x7fffffff, %d0	# msb is a don't care!
    9808. 

  9808. 	bne.b		is_nan_x
    9809. 

  9809. is_inf_x:
    9810. 

  9810. 	mov.b		&INF, %d0
    9811. 

  9811. 	rts
    9812. 

  9812. is_nan_x:
    9813. 

  9813. 	mov.b		&QNAN, %d0
    9814. 

  9814. 	rts
    9815. 

  9815. 

  9816. #############################################################
    9817. 

  9817. 

  9818. qnan:	long		0x7fff0000, 0xffffffff, 0xffffffff
    9819. 

  9819. 

  9820. #########################################################################
    9821. 

  9821. # XDEF ****************************************************************	#
    9822. 

  9822. #	t_dz(): Handle 060FPLSP dz exception for "flogn" emulation.	#
    9823. 

  9823. #	t_dz2(): Handle 060FPLSP dz exception for "fatanh" emulation.	#
    9824. 

  9824. #									#
    9825. 

  9825. #	These rouitnes are used by the 060FPLSP package.		#
    9826. 

  9826. #									#
    9827. 

  9827. # XREF ****************************************************************	#
    9828. 

  9828. #	None								#
    9829. 

  9829. #									#
    9830. 

  9830. # INPUT ***************************************************************	#
    9831. 

  9831. #	a0 = pointer to extended precision source operand.		#
    9832. 

  9832. #									#
    9833. 

  9833. # OUTPUT **************************************************************	#
    9834. 

  9834. #	fp0 = default DZ result.					#
    9835. 

  9835. #									#
    9836. 

  9836. # ALGORITHM ***********************************************************	#
    9837. 

  9837. #	Transcendental emulation for the 060FPLSP has detected that	#
    9838. 

  9838. # a DZ exception should occur for the instruction. If DZ is disabled,	#
    9839. 

  9839. # return the default result.						#
    9840. 

  9840. #	If DZ is enabled, the dst operand should be returned unscathed	#
    9841. 

  9841. # in fp0 while fp1 is used to create a DZ exception so that the		#
    9842. 

  9842. # operating system can log that such an event occurred.			#
    9843. 

  9843. #									#
    9844. 

  9844. #########################################################################
    9845. 

  9845. 

  9846. 	global		t_dz
    9847. 

  9847. t_dz:
    9848. 

  9848. 	tst.b		SRC_EX(%a0)		# check sign for neg or pos
    9849. 

  9849. 	bpl.b		dz_pinf			# branch if pos sign
    9850. 

  9850. 

  9851. 	global		t_dz2
    9852. 

  9852. t_dz2:
    9853. 

  9853. 	ori.l		&dzinf_mask+neg_mask,USER_FPSR(%a6) # set N/I/DZ/ADZ
    9854. 

  9854. 

  9855. 	btst		&dz_bit,FPCR_ENABLE(%a6)
    9856. 

  9856. 	bne.b		dz_minf_ena
    9857. 

  9857. 

  9858. # dz is disabled. return a -INF.
    9859. 

  9859. 	fmov.s		&0xff800000,%fp0	# return -INF
    9860. 

  9860. 	rts
    9861. 

  9861. 

  9862. # dz is enabled. create a dz exception so the user can record it
    9863. 

  9863. # but use fp1 instead. return the dst operand unscathed in fp0.
    9864. 

  9864. dz_minf_ena:
    9865. 

  9865. 	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
    9866. 

  9866. 	fmov.l		USER_FPCR(%a6),%fpcr
    9867. 

  9867. 	fmov.s		&0xbf800000,%fp1	# load -1
    9868. 

  9868. 	fdiv.s		&0x00000000,%fp1	# -1 / 0
    9869. 

  9869. 	rts
    9870. 

  9870. 

  9871. dz_pinf:
    9872. 

  9872. 	ori.l		&dzinf_mask,USER_FPSR(%a6) # set I/DZ/ADZ
    9873. 

  9873. 

  9874. 	btst		&dz_bit,FPCR_ENABLE(%a6)
    9875. 

  9875. 	bne.b		dz_pinf_ena
    9876. 

  9876. 

  9877. # dz is disabled. return a +INF.
    9878. 

  9878. 	fmov.s		&0x7f800000,%fp0	# return +INF
    9879. 

  9879. 	rts
    9880. 

  9880. 

  9881. # dz is enabled. create a dz exception so the user can record it
    9882. 

  9882. # but use fp1 instead. return the dst operand unscathed in fp0.
    9883. 

  9883. dz_pinf_ena:
    9884. 

  9884. 	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
    9885. 

  9885. 	fmov.l		USER_FPCR(%a6),%fpcr
    9886. 

  9886. 	fmov.s		&0x3f800000,%fp1	# load +1
    9887. 

  9887. 	fdiv.s		&0x00000000,%fp1	# +1 / 0
    9888. 

  9888. 	rts
    9889. 

  9889. 

  9890. #########################################################################
    9891. 

  9891. # XDEF ****************************************************************	#
    9892. 

  9892. #	t_operr(): Handle 060FPLSP OPERR exception during emulation.	#
    9893. 

  9893. #									#
    9894. 

  9894. #	This routine is used by the 060FPLSP package.			#
    9895. 

  9895. #									#
    9896. 

  9896. # XREF ****************************************************************	#
    9897. 

  9897. #	None.								#
    9898. 

  9898. #									#
    9899. 

  9899. # INPUT ***************************************************************	#
    9900. 

  9900. #	fp1 = source operand						#
    9901. 

  9901. #									#
    9902. 

  9902. # OUTPUT **************************************************************	#
    9903. 

  9903. #	fp0 = default result						#
    9904. 

  9904. #	fp1 = unchanged							#
    9905. 

  9905. #									#
    9906. 

  9906. # ALGORITHM ***********************************************************	#
    9907. 

  9907. #	An operand error should occur as the result of transcendental	#
    9908. 

  9908. # emulation in the 060FPLSP. If OPERR is disabled, just return a NAN	#
    9909. 

  9909. # in fp0. If OPERR is enabled, return the dst operand unscathed in fp0	#
    9910. 

  9910. # and the source operand in fp1. Use fp2 to create an OPERR exception	#
    9911. 

  9911. # so that the operating system can log the event.			#
    9912. 

  9912. #									#
    9913. 

  9913. #########################################################################
    9914. 

  9914. 

  9915. 	global		t_operr
    9916. 

  9916. t_operr:
    9917. 

  9917. 	ori.l		&opnan_mask,USER_FPSR(%a6) # set NAN/OPERR/AIOP
    9918. 

  9918. 

  9919. 	btst		&operr_bit,FPCR_ENABLE(%a6)
    9920. 

  9920. 	bne.b		operr_ena
    9921. 

  9921. 

  9922. # operr is disabled. return a QNAN in fp0
    9923. 

  9923. 	fmovm.x		qnan(%pc),&0x80		# return QNAN
    9924. 

  9924. 	rts
    9925. 

  9925. 

  9926. # operr is enabled. create an operr exception so the user can record it
    9927. 

  9927. # but use fp2 instead. return the dst operand unscathed in fp0.
    9928. 

  9928. operr_ena:
    9929. 

  9929. 	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
    9930. 

  9930. 	fmov.l		USER_FPCR(%a6),%fpcr
    9931. 

  9931. 	fmovm.x		&0x04,-(%sp)		# save fp2
    9932. 

  9932. 	fmov.s		&0x7f800000,%fp2	# load +INF
    9933. 

  9933. 	fmul.s		&0x00000000,%fp2	# +INF x 0
    9934. 

  9934. 	fmovm.x		(%sp)+,&0x20		# restore fp2
    9935. 

  9935. 	rts
    9936. 

  9936. 

  9937. pls_huge:
    9938. 

  9938. 	long		0x7ffe0000,0xffffffff,0xffffffff
    9939. 

  9939. mns_huge:
    9940. 

  9940. 	long		0xfffe0000,0xffffffff,0xffffffff
    9941. 

  9941. pls_tiny:
    9942. 

  9942. 	long		0x00000000,0x80000000,0x00000000
    9943. 

  9943. mns_tiny:
    9944. 

  9944. 	long		0x80000000,0x80000000,0x00000000
    9945. 

  9945. 

  9946. #########################################################################
    9947. 

  9947. # XDEF ****************************************************************	#
    9948. 

  9948. #	t_unfl(): Handle 060FPLSP underflow exception during emulation.	#
    9949. 

  9949. #	t_unfl2(): Handle 060FPLSP underflow exception during		#
    9950. 

  9950. #	           emulation. result always positive.			#
    9951. 

  9951. #									#
    9952. 

  9952. #	This routine is used by the 060FPLSP package.			#
    9953. 

  9953. #									#
    9954. 

  9954. # XREF ****************************************************************	#
    9955. 

  9955. #	None.								#
    9956. 

  9956. #									#
    9957. 

  9957. # INPUT ***************************************************************	#
    9958. 

  9958. #	a0 = pointer to extended precision source operand		#
    9959. 

  9959. #									#
    9960. 

  9960. # OUTPUT **************************************************************	#
    9961. 

  9961. #	fp0 = default underflow result					#
    9962. 

  9962. #									#
    9963. 

  9963. # ALGORITHM ***********************************************************	#
    9964. 

  9964. #	An underflow should occur as the result of transcendental	#
    9965. 

  9965. # emulation in the 060FPLSP. Create an underflow by using "fmul"	#
    9966. 

  9966. # and two very small numbers of appropriate sign so the operating	#
    9967. 

  9967. # system can log the event.						#
    9968. 

  9968. #									#
    9969. 

  9969. #########################################################################
    9970. 

  9970. 

  9971. 	global		t_unfl
    9972. 

  9972. t_unfl:
    9973. 

  9973. 	tst.b		SRC_EX(%a0)
    9974. 

  9974. 	bpl.b		unf_pos
    9975. 

  9975. 

  9976. 	global		t_unfl2
    9977. 

  9977. t_unfl2:
    9978. 

  9978. 	ori.l		&unfinx_mask+neg_mask,USER_FPSR(%a6) # set N/UNFL/INEX2/AUNFL/AINEX
    9979. 

  9979. 

  9980. 	fmov.l		USER_FPCR(%a6),%fpcr
    9981. 

  9981. 	fmovm.x		mns_tiny(%pc),&0x80
    9982. 

  9982. 	fmul.x		pls_tiny(%pc),%fp0
    9983. 

  9983. 

  9984. 	fmov.l		%fpsr,%d0
    9985. 

  9985. 	rol.l		&0x8,%d0
    9986. 

  9986. 	mov.b		%d0,FPSR_CC(%a6)
    9987. 

  9987. 	rts
    9988. 

  9988. unf_pos:
    9989. 

  9989. 	ori.w		&unfinx_mask,FPSR_EXCEPT(%a6) # set UNFL/INEX2/AUNFL/AINEX
    9990. 

  9990. 

  9991. 	fmov.l		USER_FPCR(%a6),%fpcr
    9992. 

  9992. 	fmovm.x		pls_tiny(%pc),&0x80
    9993. 

  9993. 	fmul.x		%fp0,%fp0
    9994. 

  9994. 

  9995. 	fmov.l		%fpsr,%d0
    9996. 

  9996. 	rol.l		&0x8,%d0
    9997. 

  9997. 	mov.b		%d0,FPSR_CC(%a6)
    9998. 

  9998. 	rts
    9999. 

  9999. 

  10000. #########################################################################
    10001. 

  10001. # XDEF ****************************************************************	#
    10002. 

  10002. #	t_ovfl(): Handle 060FPLSP overflow exception during emulation.	#
    10003. 

  10003. #		  (monadic)						#
    10004. 

  10004. #	t_ovfl2(): Handle 060FPLSP overflow exception during		#
    10005. 

  10005. #	           emulation. result always positive. (dyadic)		#
    10006. 

  10006. #	t_ovfl_sc(): Handle 060FPLSP overflow exception during		#
    10007. 

  10007. #	             emulation for "fscale".				#
    10008. 

  10008. #									#
    10009. 

  10009. #	This routine is used by the 060FPLSP package.			#
    10010. 

  10010. #									#
    10011. 

  10011. # XREF ****************************************************************	#
    10012. 

  10012. #	None.								#
    10013. 

  10013. #									#
    10014. 

  10014. # INPUT ***************************************************************	#
    10015. 

  10015. #	a0 = pointer to extended precision source operand		#
    10016. 

  10016. #									#
    10017. 

  10017. # OUTPUT **************************************************************	#
    10018. 

  10018. #	fp0 = default underflow result					#
    10019. 

  10019. #									#
    10020. 

  10020. # ALGORITHM ***********************************************************	#
    10021. 

  10021. #	An overflow should occur as the result of transcendental	#
    10022. 

  10022. # emulation in the 060FPLSP. Create an overflow by using "fmul"		#
    10023. 

  10023. # and two very lareg numbers of appropriate sign so the operating	#
    10024. 

  10024. # system can log the event.						#
    10025. 

  10025. #	For t_ovfl_sc() we take special care not to lose the INEX2 bit.	#
    10026. 

  10026. #									#
    10027. 

  10027. #########################################################################
    10028. 

  10028. 

  10029. 	global		t_ovfl_sc
    10030. 

  10030. t_ovfl_sc:
    10031. 

  10031. 	ori.l		&ovfl_inx_mask,USER_FPSR(%a6) # set OVFL/AOVFL/AINEX
    10032. 

  10032. 

  10033. 	mov.b		%d0,%d1			# fetch rnd prec,mode
    10034. 

  10034. 	andi.b		&0xc0,%d1		# extract prec
    10035. 

  10035. 	beq.w		ovfl_work
    10036. 

  10036. 

  10037. # dst op is a DENORM. we have to normalize the mantissa to see if the
    10038. 

  10038. # result would be inexact for the given precision. make a copy of the
    10039. 

  10039. # dst so we don't screw up the version passed to us.
    10040. 

  10040. 	mov.w		LOCAL_EX(%a0),FP_SCR0_EX(%a6)
    10041. 

  10041. 	mov.l		LOCAL_HI(%a0),FP_SCR0_HI(%a6)
    10042. 

  10042. 	mov.l		LOCAL_LO(%a0),FP_SCR0_LO(%a6)
    10043. 

  10043. 	lea		FP_SCR0(%a6),%a0	# pass ptr to FP_SCR0
    10044. 

  10044. 	movm.l		&0xc080,-(%sp)		# save d0-d1/a0
    10045. 

  10045. 	bsr.l		norm			# normalize mantissa
    10046. 

  10046. 	movm.l		(%sp)+,&0x0103		# restore d0-d1/a0
    10047. 

  10047. 

  10048. 	cmpi.b		%d1,&0x40		# is precision sgl?
    10049. 

  10049. 	bne.b		ovfl_sc_dbl		# no; dbl
    10050. 

  10050. ovfl_sc_sgl:
    10051. 

  10051. 	tst.l		LOCAL_LO(%a0)		# is lo lw of sgl set?
    10052. 

  10052. 	bne.b		ovfl_sc_inx		# yes
    10053. 

  10053. 	tst.b		3+LOCAL_HI(%a0)		# is lo byte of hi lw set?
    10054. 

  10054. 	bne.b		ovfl_sc_inx		# yes
    10055. 

  10055. 	bra.w		ovfl_work		# don't set INEX2
    10056. 

  10056. ovfl_sc_dbl:
    10057. 

  10057. 	mov.l		LOCAL_LO(%a0),%d1	# are any of lo 11 bits of
    10058. 

  10058. 	andi.l		&0x7ff,%d1		# dbl mantissa set?
    10059. 

  10059. 	beq.w		ovfl_work		# no; don't set INEX2
    10060. 

  10060. ovfl_sc_inx:
    10061. 

  10061. 	ori.l		&inex2_mask,USER_FPSR(%a6) # set INEX2
    10062. 

  10062. 	bra.b		ovfl_work		# continue
    10063. 

  10063. 

  10064. 	global		t_ovfl
    10065. 

  10065. t_ovfl:
    10066. 

  10066. 	ori.w		&ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
    10067. 

  10067. ovfl_work:
    10068. 

  10068. 	tst.b		SRC_EX(%a0)
    10069. 

  10069. 	bpl.b		ovfl_p
    10070. 

  10070. ovfl_m:
    10071. 

  10071. 	fmov.l		USER_FPCR(%a6),%fpcr
    10072. 

  10072. 	fmovm.x		mns_huge(%pc),&0x80
    10073. 

  10073. 	fmul.x		pls_huge(%pc),%fp0
    10074. 

  10074. 

  10075. 	fmov.l		%fpsr,%d0
    10076. 

  10076. 	rol.l		&0x8,%d0
    10077. 

  10077. 	ori.b		&neg_mask,%d0
    10078. 

  10078. 	mov.b		%d0,FPSR_CC(%a6)
    10079. 

  10079. 	rts
    10080. 

  10080. ovfl_p:
    10081. 

  10081. 	fmov.l		USER_FPCR(%a6),%fpcr
    10082. 

  10082. 	fmovm.x		pls_huge(%pc),&0x80
    10083. 

  10083. 	fmul.x		pls_huge(%pc),%fp0
    10084. 

  10084. 

  10085. 	fmov.l		%fpsr,%d0
    10086. 

  10086. 	rol.l		&0x8,%d0
    10087. 

  10087. 	mov.b		%d0,FPSR_CC(%a6)
    10088. 

  10088. 	rts
    10089. 

  10089. 

  10090. 	global		t_ovfl2
    10091. 

  10091. t_ovfl2:
    10092. 

  10092. 	ori.w		&ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
    10093. 

  10093. 	fmov.l		USER_FPCR(%a6),%fpcr
    10094. 

  10094. 	fmovm.x		pls_huge(%pc),&0x80
    10095. 

  10095. 	fmul.x		pls_huge(%pc),%fp0
    10096. 

  10096. 

  10097. 	fmov.l		%fpsr,%d0
    10098. 

  10098. 	rol.l		&0x8,%d0
    10099. 

  10099. 	mov.b		%d0,FPSR_CC(%a6)
    10100. 

  10100. 	rts
    10101. 

  10101. 

  10102. #########################################################################
    10103. 

  10103. # XDEF ****************************************************************	#
    10104. 

  10104. #	t_catch(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during	#
    10105. 

  10105. #		   emulation.						#
    10106. 

  10106. #	t_catch2(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during	#
    10107. 

  10107. #		    emulation.						#
    10108. 

  10108. #									#
    10109. 

  10109. #	These routines are used by the 060FPLSP package.		#
    10110. 

  10110. #									#
    10111. 

  10111. # XREF ****************************************************************	#
    10112. 

  10112. #	None.								#
    10113. 

  10113. #									#
    10114. 

  10114. # INPUT ***************************************************************	#
    10115. 

  10115. #	fp0 = default underflow or overflow result			#
    10116. 

  10116. #									#
    10117. 

  10117. # OUTPUT **************************************************************	#
    10118. 

  10118. #	fp0 = default result						#
    10119. 

  10119. #									#
    10120. 

  10120. # ALGORITHM ***********************************************************	#
    10121. 

  10121. #	If an overflow or underflow occurred during the last		#
    10122. 

  10122. # instruction of transcendental 060FPLSP emulation, then it has already	#
    10123. 

  10123. # occurred and has been logged. Now we need to see if an inexact	#
    10124. 

  10124. # exception should occur.						#
    10125. 

  10125. #									#
    10126. 

  10126. #########################################################################
    10127. 

  10127. 

  10128. 	global		t_catch2
    10129. 

  10129. t_catch2:
    10130. 

  10130. 	fmov.l		%fpsr,%d0
    10131. 

  10131. 	or.l		%d0,USER_FPSR(%a6)
    10132. 

  10132. 	bra.b		inx2_work
    10133. 

  10133. 

  10134. 	global		t_catch
    10135. 

  10135. t_catch:
    10136. 

  10136. 	fmov.l		%fpsr,%d0
    10137. 

  10137. 	or.l		%d0,USER_FPSR(%a6)
    10138. 

  10138. 

  10139. #########################################################################
    10140. 

  10140. # XDEF ****************************************************************	#
    10141. 

  10141. #	t_inx2(): Handle inexact 060FPLSP exception during emulation.	#
    10142. 

  10142. #	t_pinx2(): Handle inexact 060FPLSP exception for "+" results.	#
    10143. 

  10143. #	t_minx2(): Handle inexact 060FPLSP exception for "-" results.	#
    10144. 

  10144. #									#
    10145. 

  10145. # XREF ****************************************************************	#
    10146. 

  10146. #	None.								#
    10147. 

  10147. #									#
    10148. 

  10148. # INPUT ***************************************************************	#
    10149. 

  10149. #	fp0 = default result						#
    10150. 

  10150. #									#
    10151. 

  10151. # OUTPUT **************************************************************	#
    10152. 

  10152. #	fp0 = default result						#
    10153. 

  10153. #									#
    10154. 

  10154. # ALGORITHM ***********************************************************	#
    10155. 

  10155. #	The last instruction of transcendental emulation for the	#
    10156. 

  10156. # 060FPLSP should be inexact. So, if inexact is enabled, then we create	#
    10157. 

  10157. # the event here by adding a large and very small number together	#
    10158. 

  10158. # so that the operating system can log the event.			#
    10159. 

  10159. #	Must check, too, if the result was zero, in which case we just	#
    10160. 

  10160. # set the FPSR bits and return.						#
    10161. 

  10161. #									#
    10162. 

  10162. #########################################################################
    10163. 

  10163. 

  10164. 	global		t_inx2
    10165. 

  10165. t_inx2:
    10166. 

  10166. 	fblt.w		t_minx2
    10167. 

  10167. 	fbeq.w		inx2_zero
    10168. 

  10168. 

  10169. 	global		t_pinx2
    10170. 

  10170. t_pinx2:
    10171. 

  10171. 	ori.w		&inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEX
    10172. 

  10172. 	bra.b		inx2_work
    10173. 

  10173. 

  10174. 	global		t_minx2
    10175. 

  10175. t_minx2:
    10176. 

  10176. 	ori.l		&inx2a_mask+neg_mask,USER_FPSR(%a6)
    10177. 

  10177. 

  10178. inx2_work:
    10179. 

  10179. 	btst		&inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled?
    10180. 

  10180. 	bne.b		inx2_work_ena		# yes
    10181. 

  10181. 	rts
    10182. 

  10182. inx2_work_ena:
    10183. 

  10183. 	fmov.l		USER_FPCR(%a6),%fpcr	# insert user's exceptions
    10184. 

  10184. 	fmov.s		&0x3f800000,%fp1	# load +1
    10185. 

  10185. 	fadd.x		pls_tiny(%pc),%fp1	# cause exception
    10186. 

  10186. 	rts
    10187. 

  10187. 

  10188. inx2_zero:
    10189. 

  10189. 	mov.b		&z_bmask,FPSR_CC(%a6)
    10190. 

  10190. 	ori.w		&inx2a_mask,2+USER_FPSR(%a6) # set INEX/AINEX
    10191. 

  10191. 	rts
    10192. 

  10192. 

  10193. #########################################################################
    10194. 

  10194. # XDEF ****************************************************************	#
    10195. 

  10195. #	t_extdnrm(): Handle DENORM inputs in 060FPLSP.			#
    10196. 

  10196. #	t_resdnrm(): Handle DENORM inputs in 060FPLSP for "fscale".	#
    10197. 

  10197. #									#
    10198. 

  10198. #	This routine is used by the 060FPLSP package.			#
    10199. 

  10199. #									#
    10200. 

  10200. # XREF ****************************************************************	#
    10201. 

  10201. #	None.								#
    10202. 

  10202. #									#
    10203. 

  10203. # INPUT ***************************************************************	#
    10204. 

  10204. #	a0 = pointer to extended precision input operand		#
    10205. 

  10205. #									#
    10206. 

  10206. # OUTPUT **************************************************************	#
    10207. 

  10207. #	fp0 = default result						#
    10208. 

  10208. #									#
    10209. 

  10209. # ALGORITHM ***********************************************************	#
    10210. 

  10210. #	For all functions that have a denormalized input and that	#
    10211. 

  10211. # f(x)=x, this is the entry point.					#
    10212. 

  10212. #	DENORM value is moved using "fmove" which triggers an exception	#
    10213. 

  10213. # if enabled so the operating system can log the event.			#
    10214. 

  10214. #									#
    10215. 

  10215. #########################################################################
    10216. 

  10216. 

  10217. 	global		t_extdnrm
    10218. 

  10218. t_extdnrm:
    10219. 

  10219. 	fmov.l		USER_FPCR(%a6),%fpcr
    10220. 

  10220. 	fmov.x		SRC_EX(%a0),%fp0
    10221. 

  10221. 	fmov.l		%fpsr,%d0
    10222. 

  10222. 	ori.l		&unfinx_mask,%d0
    10223. 

  10223. 	or.l		%d0,USER_FPSR(%a6)
    10224. 

  10224. 	rts
    10225. 

  10225. 

  10226. 	global		t_resdnrm
    10227. 

  10227. t_resdnrm:
    10228. 

  10228. 	fmov.l		USER_FPCR(%a6),%fpcr
    10229. 

  10229. 	fmov.x		SRC_EX(%a0),%fp0
    10230. 

  10230. 	fmov.l		%fpsr,%d0
    10231. 

  10231. 	or.l		%d0,USER_FPSR(%a6)
    10232. 

  10232. 	rts
    10233. 

  10233. 

  10234. ##########################################
    10235. 

  10235. 

  10236. #
    10237. 

  10237. # sto_cos:
    10238. 

  10238. #	This is used by fsincos library emulation. The correct
    10239. 

  10239. # values are already in fp0 and fp1 so we do nothing here.
    10240. 

  10240. #
    10241. 

  10241. 	global		sto_cos
    10242. 

  10242. sto_cos:
    10243. 

  10243. 	rts
    10244. 

  10244. 

  10245. ##########################################
    10246. 

  10246. 

  10247. #
    10248. 

  10248. #	dst_qnan --- force result when destination is a NaN
    10249. 

  10249. #
    10250. 

  10250. 	global		dst_qnan
    10251. 

  10251. dst_qnan:
    10252. 

  10252. 	fmov.x		DST(%a1),%fp0
    10253. 

  10253. 	tst.b		DST_EX(%a1)
    10254. 

  10254. 	bmi.b		dst_qnan_m
    10255. 

  10255. dst_qnan_p:
    10256. 

  10256. 	mov.b		&nan_bmask,FPSR_CC(%a6)
    10257. 

  10257. 	rts
    10258. 

  10258. dst_qnan_m:
    10259. 

  10259. 	mov.b		&nan_bmask+neg_bmask,FPSR_CC(%a6)
    10260. 

  10260. 	rts
    10261. 

  10261. 

  10262. #
    10263. 

  10263. #	src_qnan --- force result when source is a NaN
    10264. 

  10264. #
    10265. 

  10265. 	global		src_qnan
    10266. 

  10266. src_qnan:
    10267. 

  10267. 	fmov.x		SRC(%a0),%fp0
    10268. 

  10268. 	tst.b		SRC_EX(%a0)
    10269. 

  10269. 	bmi.b		src_qnan_m
    10270. 

  10270. src_qnan_p:
    10271. 

  10271. 	mov.b		&nan_bmask,FPSR_CC(%a6)
    10272. 

  10272. 	rts
    10273. 

  10273. src_qnan_m:
    10274. 

  10274. 	mov.b		&nan_bmask+neg_bmask,FPSR_CC(%a6)
    10275. 

  10275. 	rts
    10276. 

  10276. 

  10277. ##########################################
    10278. 

  10278. 

  10279. #
    10280. 

  10280. #	Native instruction support
    10281. 

  10281. #
    10282. 

  10282. #	Some systems may need entry points even for 68060 native
    10283. 

  10283. #	instructions.  These routines are provided for
    10284. 

  10284. #	convenience.
    10285. 

  10285. #
    10286. 

  10286. 	global		_fadds_
    10287. 

  10287. _fadds_:
    10288. 

  10288. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10289. 

  10289. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10290. 

  10290. 	fmov.s		0x8(%sp),%fp0		# load sgl dst
    10291. 

  10291. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10292. 

  10292. 	fadd.s		0x8(%sp),%fp0		# fadd w/ sgl src
    10293. 

  10293. 	rts
    10294. 

  10294. 

  10295. 	global		_faddd_
    10296. 

  10296. _faddd_:
    10297. 

  10297. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10298. 

  10298. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10299. 

  10299. 	fmov.d		0x8(%sp),%fp0		# load dbl dst
    10300. 

  10300. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10301. 

  10301. 	fadd.d		0xc(%sp),%fp0		# fadd w/ dbl src
    10302. 

  10302. 	rts
    10303. 

  10303. 

  10304. 	global		_faddx_
    10305. 

  10305. _faddx_:
    10306. 

  10306. 	fmovm.x		0x4(%sp),&0x80		# load ext dst
    10307. 

  10307. 	fadd.x		0x10(%sp),%fp0		# fadd w/ ext src
    10308. 

  10308. 	rts
    10309. 

  10309. 

  10310. 	global		_fsubs_
    10311. 

  10311. _fsubs_:
    10312. 

  10312. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10313. 

  10313. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10314. 

  10314. 	fmov.s		0x8(%sp),%fp0		# load sgl dst
    10315. 

  10315. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10316. 

  10316. 	fsub.s		0x8(%sp),%fp0		# fsub w/ sgl src
    10317. 

  10317. 	rts
    10318. 

  10318. 

  10319. 	global		_fsubd_
    10320. 

  10320. _fsubd_:
    10321. 

  10321. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10322. 

  10322. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10323. 

  10323. 	fmov.d		0x8(%sp),%fp0		# load dbl dst
    10324. 

  10324. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10325. 

  10325. 	fsub.d		0xc(%sp),%fp0		# fsub w/ dbl src
    10326. 

  10326. 	rts
    10327. 

  10327. 

  10328. 	global		_fsubx_
    10329. 

  10329. _fsubx_:
    10330. 

  10330. 	fmovm.x		0x4(%sp),&0x80		# load ext dst
    10331. 

  10331. 	fsub.x		0x10(%sp),%fp0		# fsub w/ ext src
    10332. 

  10332. 	rts
    10333. 

  10333. 

  10334. 	global		_fmuls_
    10335. 

  10335. _fmuls_:
    10336. 

  10336. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10337. 

  10337. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10338. 

  10338. 	fmov.s		0x8(%sp),%fp0		# load sgl dst
    10339. 

  10339. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10340. 

  10340. 	fmul.s		0x8(%sp),%fp0		# fmul w/ sgl src
    10341. 

  10341. 	rts
    10342. 

  10342. 

  10343. 	global		_fmuld_
    10344. 

  10344. _fmuld_:
    10345. 

  10345. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10346. 

  10346. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10347. 

  10347. 	fmov.d		0x8(%sp),%fp0		# load dbl dst
    10348. 

  10348. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10349. 

  10349. 	fmul.d		0xc(%sp),%fp0		# fmul w/ dbl src
    10350. 

  10350. 	rts
    10351. 

  10351. 

  10352. 	global		_fmulx_
    10353. 

  10353. _fmulx_:
    10354. 

  10354. 	fmovm.x		0x4(%sp),&0x80		# load ext dst
    10355. 

  10355. 	fmul.x		0x10(%sp),%fp0		# fmul w/ ext src
    10356. 

  10356. 	rts
    10357. 

  10357. 

  10358. 	global		_fdivs_
    10359. 

  10359. _fdivs_:
    10360. 

  10360. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10361. 

  10361. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10362. 

  10362. 	fmov.s		0x8(%sp),%fp0		# load sgl dst
    10363. 

  10363. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10364. 

  10364. 	fdiv.s		0x8(%sp),%fp0		# fdiv w/ sgl src
    10365. 

  10365. 	rts
    10366. 

  10366. 

  10367. 	global		_fdivd_
    10368. 

  10368. _fdivd_:
    10369. 

  10369. 	fmov.l		%fpcr,-(%sp)		# save fpcr
    10370. 

  10370. 	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
    10371. 

  10371. 	fmov.d		0x8(%sp),%fp0		# load dbl dst
    10372. 

  10372. 	fmov.l		(%sp)+,%fpcr		# restore fpcr
    10373. 

  10373. 	fdiv.d		0xc(%sp),%fp0		# fdiv w/ dbl src
    10374. 

  10374. 	rts
    10375. 

  10375. 

  10376. 	global		_fdivx_
    10377. 

  10377. _fdivx_:
    10378. 

  10378. 	fmovm.x		0x4(%sp),&0x80		# load ext dst
    10379. 

  10379. 	fdiv.x		0x10(%sp),%fp0		# fdiv w/ ext src
    10380. 

  10380. 	rts
    10381. 

  10381. 

  10382. 	global		_fabss_
    10383. 

  10383. _fabss_:
    10384. 

  10384. 	fabs.s		0x4(%sp),%fp0		# fabs w/ sgl src
    10385. 

  10385. 	rts
    10386. 

  10386. 

  10387. 	global		_fabsd_
    10388. 

  10388. _fabsd_:
    10389. 

  10389. 	fabs.d		0x4(%sp),%fp0		# fabs w/ dbl src
    10390. 

  10390. 	rts
    10391. 

  10391. 

  10392. 	global		_fabsx_
    10393. 

  10393. _fabsx_:
    10394. 

  10394. 	fabs.x		0x4(%sp),%fp0		# fabs w/ ext src
    10395. 

  10395. 	rts
    10396. 

  10396. 

  10397. 	global		_fnegs_
    10398. 

  10398. _fnegs_:
    10399. 

  10399. 	fneg.s		0x4(%sp),%fp0		# fneg w/ sgl src
    10400. 

  10400. 	rts
    10401. 

  10401. 

  10402. 	global		_fnegd_
    10403. 

  10403. _fnegd_:
    10404. 

  10404. 	fneg.d		0x4(%sp),%fp0		# fneg w/ dbl src
    10405. 

  10405. 	rts
    10406. 

  10406. 

  10407. 	global		_fnegx_
    10408. 

  10408. _fnegx_:
    10409. 

  10409. 	fneg.x		0x4(%sp),%fp0		# fneg w/ ext src
    10410. 

  10410. 	rts
    10411. 

  10411. 

  10412. 	global		_fsqrts_
    10413. 

  10413. _fsqrts_:
    10414. 

  10414. 	fsqrt.s		0x4(%sp),%fp0		# fsqrt w/ sgl src
    10415. 

  10415. 	rts
    10416. 

  10416. 

  10417. 	global		_fsqrtd_
    10418. 

  10418. _fsqrtd_:
    10419. 

  10419. 	fsqrt.d		0x4(%sp),%fp0		# fsqrt w/ dbl src
    10420. 

  10420. 	rts
    10421. 

  10421. 

  10422. 	global		_fsqrtx_
    10423. 

  10423. _fsqrtx_:
    10424. 

  10424. 	fsqrt.x		0x4(%sp),%fp0		# fsqrt w/ ext src
    10425. 

  10425. 	rts
    10426. 

  10426. 

  10427. 	global		_fints_
    10428. 

  10428. _fints_:
    10429. 

  10429. 	fint.s		0x4(%sp),%fp0		# fint w/ sgl src
    10430. 

  10430. 	rts
    10431. 

  10431. 

  10432. 	global		_fintd_
    10433. 

  10433. _fintd_:
    10434. 

  10434. 	fint.d		0x4(%sp),%fp0		# fint w/ dbl src
    10435. 

  10435. 	rts
    10436. 

  10436. 

  10437. 	global		_fintx_
    10438. 

  10438. _fintx_:
    10439. 

  10439. 	fint.x		0x4(%sp),%fp0		# fint w/ ext src
    10440. 

  10440. 	rts
    10441. 

  10441. 

  10442. 	global		_fintrzs_
    10443. 

  10443. _fintrzs_:
    10444. 

  10444. 	fintrz.s	0x4(%sp),%fp0		# fintrz w/ sgl src
    10445. 

  10445. 	rts
    10446. 

  10446. 

  10447. 	global		_fintrzd_
    10448. 

  10448. _fintrzd_:
    10449. 

  10449. 	fintrz.d	0x4(%sp),%fp0		# fintrx w/ dbl src
    10450. 

  10450. 	rts
    10451. 

  10451. 

  10452. 	global		_fintrzx_
    10453. 

  10453. _fintrzx_:
    10454. 

  10454. 	fintrz.x	0x4(%sp),%fp0		# fintrz w/ ext src
    10455. 

  10455. 	rts
    10456. 

  10456. 

  10457. ########################################################################
    10458. 

  10458. 

  10459. #########################################################################
    10460. 

  10460. # src_zero(): Return signed zero according to sign of src operand.	#
    10461. 

  10461. #########################################################################
    10462. 

  10462. 	global		src_zero
    10463. 

  10463. src_zero:
    10464. 

  10464. 	tst.b		SRC_EX(%a0)		# get sign of src operand
    10465. 

  10465. 	bmi.b		ld_mzero		# if neg, load neg zero
    10466. 

  10466. 

  10467. #
    10468. 

  10468. # ld_pzero(): return a positive zero.
    10469. 

  10469. #
    10470. 

  10470. 	global		ld_pzero
    10471. 

  10471. ld_pzero:
    10472. 

  10472. 	fmov.s		&0x00000000,%fp0	# load +0
    10473. 

  10473. 	mov.b		&z_bmask,FPSR_CC(%a6)	# set 'Z' ccode bit
    10474. 

  10474. 	rts
    10475. 

  10475. 

  10476. # ld_mzero(): return a negative zero.
    10477. 

  10477. 	global		ld_mzero
    10478. 

  10478. ld_mzero:
    10479. 

  10479. 	fmov.s		&0x80000000,%fp0	# load -0
    10480. 

  10480. 	mov.b		&neg_bmask+z_bmask,FPSR_CC(%a6) # set 'N','Z' ccode bits
    10481. 

  10481. 	rts
    10482. 

  10482. 

  10483. #########################################################################
    10484. 

  10484. # dst_zero(): Return signed zero according to sign of dst operand.	#
    10485. 

  10485. #########################################################################
    10486. 

  10486. 	global		dst_zero
    10487. 

  10487. dst_zero:
    10488. 

  10488. 	tst.b		DST_EX(%a1)		# get sign of dst operand
    10489. 

  10489. 	bmi.b		ld_mzero		# if neg, load neg zero
    10490. 

  10490. 	bra.b		ld_pzero		# load positive zero
    10491. 

  10491. 

  10492. #########################################################################
    10493. 

  10493. # src_inf(): Return signed inf according to sign of src operand.	#
    10494. 

  10494. #########################################################################
    10495. 

  10495. 	global		src_inf
    10496. 

  10496. src_inf:
    10497. 

  10497. 	tst.b		SRC_EX(%a0)		# get sign of src operand
    10498. 

  10498. 	bmi.b		ld_minf			# if negative branch
    10499. 

  10499. 

  10500. #
    10501. 

  10501. # ld_pinf(): return a positive infinity.
    10502. 

  10502. #
    10503. 

  10503. 	global		ld_pinf
    10504. 

  10504. ld_pinf:
    10505. 

  10505. 	fmov.s		&0x7f800000,%fp0	# load +INF
    10506. 

  10506. 	mov.b		&inf_bmask,FPSR_CC(%a6)	# set 'INF' ccode bit
    10507. 

  10507. 	rts
    10508. 

  10508. 

  10509. #
    10510. 

  10510. # ld_minf():return a negative infinity.
    10511. 

  10511. #
    10512. 

  10512. 	global		ld_minf
    10513. 

  10513. ld_minf:
    10514. 

  10514. 	fmov.s		&0xff800000,%fp0	# load -INF
    10515. 

  10515. 	mov.b		&neg_bmask+inf_bmask,FPSR_CC(%a6) # set 'N','I' ccode bits
    10516. 

  10516. 	rts
    10517. 

  10517. 

  10518. #########################################################################
    10519. 

  10519. # dst_inf(): Return signed inf according to sign of dst operand.	#
    10520. 

  10520. #########################################################################
    10521. 

  10521. 	global		dst_inf
    10522. 

  10522. dst_inf:
    10523. 

  10523. 	tst.b		DST_EX(%a1)		# get sign of dst operand
    10524. 

  10524. 	bmi.b		ld_minf			# if negative branch
    10525. 

  10525. 	bra.b		ld_pinf
    10526. 

  10526. 

  10527. 	global		szr_inf
    10528. 

  10528. #################################################################
    10529. 

  10529. # szr_inf(): Return +ZERO for a negative src operand or		#
    10530. 

  10530. #	            +INF for a positive src operand.		#
    10531. 

  10531. #	     Routine used for fetox, ftwotox, and ftentox.	#
    10532. 

  10532. #################################################################
    10533. 

  10533. szr_inf:
    10534. 

  10534. 	tst.b		SRC_EX(%a0)		# check sign of source
    10535. 

  10535. 	bmi.b		ld_pzero
    10536. 

  10536. 	bra.b		ld_pinf
    10537. 

  10537. 

  10538. #########################################################################
    10539. 

  10539. # sopr_inf(): Return +INF for a positive src operand or			#
    10540. 

  10540. #	      jump to operand error routine for a negative src operand.	#
    10541. 

  10541. #	      Routine used for flogn, flognp1, flog10, and flog2.	#
    10542. 

  10542. #########################################################################
    10543. 

  10543. 	global		sopr_inf
    10544. 

  10544. sopr_inf:
    10545. 

  10545. 	tst.b		SRC_EX(%a0)		# check sign of source
    10546. 

  10546. 	bmi.w		t_operr
    10547. 

  10547. 	bra.b		ld_pinf
    10548. 

  10548. 

  10549. #################################################################
    10550. 

  10550. # setoxm1i(): Return minus one for a negative src operand or	#
    10551. 

  10551. #	      positive infinity for a positive src operand.	#
    10552. 

  10552. #	      Routine used for fetoxm1.				#
    10553. 

  10553. #################################################################
    10554. 

  10554. 	global		setoxm1i
    10555. 

  10555. setoxm1i:
    10556. 

  10556. 	tst.b		SRC_EX(%a0)		# check sign of source
    10557. 

  10557. 	bmi.b		ld_mone
    10558. 

  10558. 	bra.b		ld_pinf
    10559. 

  10559. 

  10560. #########################################################################
    10561. 

  10561. # src_one(): Return signed one according to sign of src operand.	#
    10562. 

  10562. #########################################################################
    10563. 

  10563. 	global		src_one
    10564. 

  10564. src_one:
    10565. 

  10565. 	tst.b		SRC_EX(%a0)		# check sign of source
    10566. 

  10566. 	bmi.b		ld_mone
    10567. 

  10567. 

  10568. #
    10569. 

  10569. # ld_pone(): return positive one.
    10570. 

  10570. #
    10571. 

  10571. 	global		ld_pone
    10572. 

  10572. ld_pone:
    10573. 

  10573. 	fmov.s		&0x3f800000,%fp0	# load +1
    10574. 

  10574. 	clr.b		FPSR_CC(%a6)
    10575. 

  10575. 	rts
    10576. 

  10576. 

  10577. #
    10578. 

  10578. # ld_mone(): return negative one.
    10579. 

  10579. #
    10580. 

  10580. 	global		ld_mone
    10581. 

  10581. ld_mone:
    10582. 

  10582. 	fmov.s		&0xbf800000,%fp0	# load -1
    10583. 

  10583. 	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
    10584. 

  10584. 	rts
    10585. 

  10585. 

  10586. ppiby2:	long		0x3fff0000, 0xc90fdaa2, 0x2168c235
    10587. 

  10587. mpiby2:	long		0xbfff0000, 0xc90fdaa2, 0x2168c235
    10588. 

  10588. 

  10589. #################################################################
    10590. 

  10590. # spi_2(): Return signed PI/2 according to sign of src operand.	#
    10591. 

  10591. #################################################################
    10592. 

  10592. 	global		spi_2
    10593. 

  10593. spi_2:
    10594. 

  10594. 	tst.b		SRC_EX(%a0)		# check sign of source
    10595. 

  10595. 	bmi.b		ld_mpi2
    10596. 

  10596. 

  10597. #
    10598. 

  10598. # ld_ppi2(): return positive PI/2.
    10599. 

  10599. #
    10600. 

  10600. 	global		ld_ppi2
    10601. 

  10601. ld_ppi2:
    10602. 

  10602. 	fmov.l		%d0,%fpcr
    10603. 

  10603. 	fmov.x		ppiby2(%pc),%fp0	# load +pi/2
    10604. 

  10604. 	bra.w		t_pinx2			# set INEX2
    10605. 

  10605. 

  10606. #
    10607. 

  10607. # ld_mpi2(): return negative PI/2.
    10608. 

  10608. #
    10609. 

  10609. 	global		ld_mpi2
    10610. 

  10610. ld_mpi2:
    10611. 

  10611. 	fmov.l		%d0,%fpcr
    10612. 

  10612. 	fmov.x		mpiby2(%pc),%fp0	# load -pi/2
    10613. 

  10613. 	bra.w		t_minx2			# set INEX2
    10614. 

  10614. 

  10615. ####################################################
    10616. 

  10616. # The following routines give support for fsincos. #
    10617. 

  10617. ####################################################
    10618. 

  10618. 

  10619. #
    10620. 

  10620. # ssincosz(): When the src operand is ZERO, store a one in the
    10621. 

  10621. #	      cosine register and return a ZERO in fp0 w/ the same sign
    10622. 

  10622. #	      as the src operand.
    10623. 

  10623. #
    10624. 

  10624. 	global		ssincosz
    10625. 

  10625. ssincosz:
    10626. 

  10626. 	fmov.s		&0x3f800000,%fp1
    10627. 

  10627. 	tst.b		SRC_EX(%a0)		# test sign
    10628. 

  10628. 	bpl.b		sincoszp
    10629. 

  10629. 	fmov.s		&0x80000000,%fp0	# return sin result in fp0
    10630. 

  10630. 	mov.b		&z_bmask+neg_bmask,FPSR_CC(%a6)
    10631. 

  10631. 	rts
    10632. 

  10632. sincoszp:
    10633. 

  10633. 	fmov.s		&0x00000000,%fp0	# return sin result in fp0
    10634. 

  10634. 	mov.b		&z_bmask,FPSR_CC(%a6)
    10635. 

  10635. 	rts
    10636. 

  10636. 

  10637. #
    10638. 

  10638. # ssincosi(): When the src operand is INF, store a QNAN in the cosine
    10639. 

  10639. #	      register and jump to the operand error routine for negative
    10640. 

  10640. #	      src operands.
    10641. 

  10641. #
    10642. 

  10642. 	global		ssincosi
    10643. 

  10643. ssincosi:
    10644. 

  10644. 	fmov.x		qnan(%pc),%fp1		# load NAN
    10645. 

  10645. 	bra.w		t_operr
    10646. 

  10646. 

  10647. #
    10648. 

  10648. # ssincosqnan(): When the src operand is a QNAN, store the QNAN in the cosine
    10649. 

  10649. #		 register and branch to the src QNAN routine.
    10650. 

  10650. #
    10651. 

  10651. 	global		ssincosqnan
    10652. 

  10652. ssincosqnan:
    10653. 

  10653. 	fmov.x		LOCAL_EX(%a0),%fp1
    10654. 

  10654. 	bra.w		src_qnan
    10655. 

  10655. 

  10656. ########################################################################
    10657. 

  10657. 

  10658. 	global		smod_sdnrm
    10659. 

  10659. 	global		smod_snorm
    10660. 

  10660. smod_sdnrm:
    10661. 

  10661. smod_snorm:
    10662. 

  10662. 	mov.b		DTAG(%a6),%d1
    10663. 

  10663. 	beq.l		smod
    10664. 

  10664. 	cmpi.b		%d1,&ZERO
    10665. 

  10665. 	beq.w		smod_zro
    10666. 

  10666. 	cmpi.b		%d1,&INF
    10667. 

  10667. 	beq.l		t_operr
    10668. 

  10668. 	cmpi.b		%d1,&DENORM
    10669. 

  10669. 	beq.l		smod
    10670. 

  10670. 	bra.l		dst_qnan
    10671. 

  10671. 

  10672. 	global		smod_szero
    10673. 

  10673. smod_szero:
    10674. 

  10674. 	mov.b		DTAG(%a6),%d1
    10675. 

  10675. 	beq.l		t_operr
    10676. 

  10676. 	cmpi.b		%d1,&ZERO
    10677. 

  10677. 	beq.l		t_operr
    10678. 

  10678. 	cmpi.b		%d1,&INF
    10679. 

  10679. 	beq.l		t_operr
    10680. 

  10680. 	cmpi.b		%d1,&DENORM
    10681. 

  10681. 	beq.l		t_operr
    10682. 

  10682. 	bra.l		dst_qnan
    10683. 

  10683. 

  10684. 	global		smod_sinf
    10685. 

  10685. smod_sinf:
    10686. 

  10686. 	mov.b		DTAG(%a6),%d1
    10687. 

  10687. 	beq.l		smod_fpn
    10688. 

  10688. 	cmpi.b		%d1,&ZERO
    10689. 

  10689. 	beq.l		smod_zro
    10690. 

  10690. 	cmpi.b		%d1,&INF
    10691. 

  10691. 	beq.l		t_operr
    10692. 

  10692. 	cmpi.b		%d1,&DENORM
    10693. 

  10693. 	beq.l		smod_fpn
    10694. 

  10694. 	bra.l		dst_qnan
    10695. 

  10695. 

  10696. smod_zro:
    10697. 

  10697. srem_zro:
    10698. 

  10698. 	mov.b		SRC_EX(%a0),%d1		# get src sign
    10699. 

  10699. 	mov.b		DST_EX(%a1),%d0		# get dst sign
    10700. 

  10700. 	eor.b		%d0,%d1			# get qbyte sign
    10701. 

  10701. 	andi.b		&0x80,%d1
    10702. 

  10702. 	mov.b		%d1,FPSR_QBYTE(%a6)
    10703. 

  10703. 	tst.b		%d0
    10704. 

  10704. 	bpl.w		ld_pzero
    10705. 

  10705. 	bra.w		ld_mzero
    10706. 

  10706. 

  10707. smod_fpn:
    10708. 

  10708. srem_fpn:
    10709. 

  10709. 	clr.b		FPSR_QBYTE(%a6)
    10710. 

  10710. 	mov.l		%d0,-(%sp)
    10711. 

  10711. 	mov.b		SRC_EX(%a0),%d1		# get src sign
    10712. 

  10712. 	mov.b		DST_EX(%a1),%d0		# get dst sign
    10713. 

  10713. 	eor.b		%d0,%d1			# get qbyte sign
    10714. 

  10714. 	andi.b		&0x80,%d1
    10715. 

  10715. 	mov.b		%d1,FPSR_QBYTE(%a6)
    10716. 

  10716. 	cmpi.b		DTAG(%a6),&DENORM
    10717. 

  10717. 	bne.b		smod_nrm
    10718. 

  10718. 	lea		DST(%a1),%a0
    10719. 

  10719. 	mov.l		(%sp)+,%d0
    10720. 

  10720. 	bra		t_resdnrm
    10721. 

  10721. smod_nrm:
    10722. 

  10722. 	fmov.l		(%sp)+,%fpcr
    10723. 

  10723. 	fmov.x		DST(%a1),%fp0
    10724. 

  10724. 	tst.b		DST_EX(%a1)
    10725. 

  10725. 	bmi.b		smod_nrm_neg
    10726. 

  10726. 	rts
    10727. 

  10727. 

  10728. smod_nrm_neg:
    10729. 

  10729. 	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' code
    10730. 

  10730. 	rts
    10731. 

  10731. 

  10732. #########################################################################
    10733. 

  10733. 	global		srem_snorm
    10734. 

  10734. 	global		srem_sdnrm
    10735. 

  10735. srem_sdnrm:
    10736. 

  10736. srem_snorm:
    10737. 

  10737. 	mov.b		DTAG(%a6),%d1
    10738. 

  10738. 	beq.l		srem
    10739. 

  10739. 	cmpi.b		%d1,&ZERO
    10740. 

  10740. 	beq.w		srem_zro
    10741. 

  10741. 	cmpi.b		%d1,&INF
    10742. 

  10742. 	beq.l		t_operr
    10743. 

  10743. 	cmpi.b		%d1,&DENORM
    10744. 

  10744. 	beq.l		srem
    10745. 

  10745. 	bra.l		dst_qnan
    10746. 

  10746. 

  10747. 	global		srem_szero
    10748. 

  10748. srem_szero:
    10749. 

  10749. 	mov.b		DTAG(%a6),%d1
    10750. 

  10750. 	beq.l		t_operr
    10751. 

  10751. 	cmpi.b		%d1,&ZERO
    10752. 

  10752. 	beq.l		t_operr
    10753. 

  10753. 	cmpi.b		%d1,&INF
    10754. 

  10754. 	beq.l		t_operr
    10755. 

  10755. 	cmpi.b		%d1,&DENORM
    10756. 

  10756. 	beq.l		t_operr
    10757. 

  10757. 	bra.l		dst_qnan
    10758. 

  10758. 

  10759. 	global		srem_sinf
    10760. 

  10760. srem_sinf:
    10761. 

  10761. 	mov.b		DTAG(%a6),%d1
    10762. 

  10762. 	beq.w		srem_fpn
    10763. 

  10763. 	cmpi.b		%d1,&ZERO
    10764. 

  10764. 	beq.w		srem_zro
    10765. 

  10765. 	cmpi.b		%d1,&INF
    10766. 

  10766. 	beq.l		t_operr
    10767. 

  10767. 	cmpi.b		%d1,&DENORM
    10768. 

  10768. 	beq.l		srem_fpn
    10769. 

  10769. 	bra.l		dst_qnan
    10770. 

  10770. 

  10771. #########################################################################
    10772. 

  10772. 

  10773. 	global		sscale_snorm
    10774. 

  10774. 	global		sscale_sdnrm
    10775. 

  10775. sscale_snorm:
    10776. 

  10776. sscale_sdnrm:
    10777. 

  10777. 	mov.b		DTAG(%a6),%d1
    10778. 

  10778. 	beq.l		sscale
    10779. 

  10779. 	cmpi.b		%d1,&ZERO
    10780. 

  10780. 	beq.l		dst_zero
    10781. 

  10781. 	cmpi.b		%d1,&INF
    10782. 

  10782. 	beq.l		dst_inf
    10783. 

  10783. 	cmpi.b		%d1,&DENORM
    10784. 

  10784. 	beq.l		sscale
    10785. 

  10785. 	bra.l		dst_qnan
    10786. 

  10786. 

  10787. 	global		sscale_szero
    10788. 

  10788. sscale_szero:
    10789. 

  10789. 	mov.b		DTAG(%a6),%d1
    10790. 

  10790. 	beq.l		sscale
    10791. 

  10791. 	cmpi.b		%d1,&ZERO
    10792. 

  10792. 	beq.l		dst_zero
    10793. 

  10793. 	cmpi.b		%d1,&INF
    10794. 

  10794. 	beq.l		dst_inf
    10795. 

  10795. 	cmpi.b		%d1,&DENORM
    10796. 

  10796. 	beq.l		sscale
    10797. 

  10797. 	bra.l		dst_qnan
    10798. 

  10798. 

  10799. 	global		sscale_sinf
    10800. 

  10800. sscale_sinf:
    10801. 

  10801. 	mov.b		DTAG(%a6),%d1
    10802. 

  10802. 	beq.l		t_operr
    10803. 

  10803. 	cmpi.b		%d1,&QNAN
    10804. 

  10804. 	beq.l		dst_qnan
    10805. 

  10805. 	bra.l		t_operr
    10806. 

  10806. 

  10807. ########################################################################
    10808. 

  10808. 

  10809. 	global		sop_sqnan
    10810. 

  10810. sop_sqnan:
    10811. 

  10811. 	mov.b		DTAG(%a6),%d1
    10812. 

  10812. 	cmpi.b		%d1,&QNAN
    10813. 

  10813. 	beq.l		dst_qnan
    10814. 

  10814. 	bra.l		src_qnan
    10815. 

  10815. 

  10816. #########################################################################
    10817. 

  10817. # norm(): normalize the mantissa of an extended precision input. the	#
    10818. 

  10818. #	  input operand should not be normalized already.		#
    10819. 

  10819. #									#
    10820. 

  10820. # XDEF ****************************************************************	#
    10821. 

  10821. #	norm()								#
    10822. 

  10822. #									#
    10823. 

  10823. # XREF **************************************************************** #
    10824. 

  10824. #	none								#
    10825. 

  10825. #									#
    10826. 

  10826. # INPUT *************************************************************** #
    10827. 

  10827. #	a0 = pointer fp extended precision operand to normalize		#
    10828. 

  10828. #									#
    10829. 

  10829. # OUTPUT ************************************************************** #
    10830. 

  10830. #	d0 = number of bit positions the mantissa was shifted		#
    10831. 

  10831. #	a0 = the input operand's mantissa is normalized; the exponent	#
    10832. 

  10832. #	     is unchanged.						#
    10833. 

  10833. #									#
    10834. 

  10834. #########################################################################
    10835. 

  10835. 	global		norm
    10836. 

  10836. norm:
    10837. 

  10837. 	mov.l		%d2, -(%sp)		# create some temp regs
    10838. 

  10838. 	mov.l		%d3, -(%sp)
    10839. 

  10839. 

  10840. 	mov.l		FTEMP_HI(%a0), %d0	# load hi(mantissa)
    10841. 

  10841. 	mov.l		FTEMP_LO(%a0), %d1	# load lo(mantissa)
    10842. 

  10842. 

  10843. 	bfffo		%d0{&0:&32}, %d2	# how many places to shift?
    10844. 

  10844. 	beq.b		norm_lo			# hi(man) is all zeroes!
    10845. 

  10845. 

  10846. norm_hi:
    10847. 

  10847. 	lsl.l		%d2, %d0		# left shift hi(man)
    10848. 

  10848. 	bfextu		%d1{&0:%d2}, %d3	# extract lo bits
    10849. 

  10849. 

  10850. 	or.l		%d3, %d0		# create hi(man)
    10851. 

  10851. 	lsl.l		%d2, %d1		# create lo(man)
    10852. 

  10852. 

  10853. 	mov.l		%d0, FTEMP_HI(%a0)	# store new hi(man)
    10854. 

  10854. 	mov.l		%d1, FTEMP_LO(%a0)	# store new lo(man)
    10855. 

  10855. 

  10856. 	mov.l		%d2, %d0		# return shift amount
    10857. 

  10857. 

  10858. 	mov.l		(%sp)+, %d3		# restore temp regs
    10859. 

  10859. 	mov.l		(%sp)+, %d2
    10860. 

  10860. 

  10861. 	rts
    10862. 

  10862. 

  10863. norm_lo:
    10864. 

  10864. 	bfffo		%d1{&0:&32}, %d2	# how many places to shift?
    10865. 

  10865. 	lsl.l		%d2, %d1		# shift lo(man)
    10866. 

  10866. 	add.l		&32, %d2		# add 32 to shft amount
    10867. 

  10867. 

  10868. 	mov.l		%d1, FTEMP_HI(%a0)	# store hi(man)
    10869. 

  10869. 	clr.l		FTEMP_LO(%a0)		# lo(man) is now zero
    10870. 

  10870. 

  10871. 	mov.l		%d2, %d0		# return shift amount
    10872. 

  10872. 

  10873. 	mov.l		(%sp)+, %d3		# restore temp regs
    10874. 

  10874. 	mov.l		(%sp)+, %d2
    10875. 

  10875. 

  10876. 	rts
    10877. 

  10877. 

  10878. #########################################################################
    10879. 

  10879. # unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO	#
    10880. 

  10880. #		- returns corresponding optype tag			#
    10881. 

  10881. #									#
    10882. 

  10882. # XDEF ****************************************************************	#
    10883. 

  10883. #	unnorm_fix()							#
    10884. 

  10884. #									#
    10885. 

  10885. # XREF **************************************************************** #
    10886. 

  10886. #	norm() - normalize the mantissa					#
    10887. 

  10887. #									#
    10888. 

  10888. # INPUT *************************************************************** #
    10889. 

  10889. #	a0 = pointer to unnormalized extended precision number		#
    10890. 

  10890. #									#
    10891. 

  10891. # OUTPUT ************************************************************** #
    10892. 

  10892. #	d0 = optype tag - is corrected to one of NORM, DENORM, or ZERO	#
    10893. 

  10893. #	a0 = input operand has been converted to a norm, denorm, or	#
    10894. 

  10894. #	     zero; both the exponent and mantissa are changed.		#
    10895. 

  10895. #									#
    10896. 

  10896. #########################################################################
    10897. 

  10897. 

  10898. 	global		unnorm_fix
    10899. 

  10899. unnorm_fix:
    10900. 

  10900. 	bfffo		FTEMP_HI(%a0){&0:&32}, %d0 # how many shifts are needed?
    10901. 

  10901. 	bne.b		unnorm_shift		# hi(man) is not all zeroes
    10902. 

  10902. 

  10903. #
    10904. 

  10904. # hi(man) is all zeroes so see if any bits in lo(man) are set
    10905. 

  10905. #
    10906. 

  10906. unnorm_chk_lo:
    10907. 

  10907. 	bfffo		FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero?
    10908. 

  10908. 	beq.w		unnorm_zero		# yes
    10909. 

  10909. 

  10910. 	add.w		&32, %d0		# no; fix shift distance
    10911. 

  10911. 

  10912. #
    10913. 

  10913. # d0 = # shifts needed for complete normalization
    10914. 

  10914. #
    10915. 

  10915. unnorm_shift:
    10916. 

  10916. 	clr.l		%d1			# clear top word
    10917. 

  10917. 	mov.w		FTEMP_EX(%a0), %d1	# extract exponent
    10918. 

  10918. 	and.w		&0x7fff, %d1		# strip off sgn
    10919. 

  10919. 

  10920. 	cmp.w		%d0, %d1		# will denorm push exp < 0?
    10921. 

  10921. 	bgt.b		unnorm_nrm_zero		# yes; denorm only until exp = 0
    10922. 

  10922. 

  10923. #
    10924. 

  10924. # exponent would not go < 0. therefore, number stays normalized
    10925. 

  10925. #
    10926. 

  10926. 	sub.w		%d0, %d1		# shift exponent value
    10927. 

  10927. 	mov.w		FTEMP_EX(%a0), %d0	# load old exponent
    10928. 

  10928. 	and.w		&0x8000, %d0		# save old sign
    10929. 

  10929. 	or.w		%d0, %d1		# {sgn,new exp}
    10930. 

  10930. 	mov.w		%d1, FTEMP_EX(%a0)	# insert new exponent
    10931. 

  10931. 

  10932. 	bsr.l		norm			# normalize UNNORM
    10933. 

  10933. 

  10934. 	mov.b		&NORM, %d0		# return new optype tag
    10935. 

  10935. 	rts
    10936. 

  10936. 

  10937. #
    10938. 

  10938. # exponent would go < 0, so only denormalize until exp = 0
    10939. 

  10939. #
    10940. 

  10940. unnorm_nrm_zero:
    10941. 

  10941. 	cmp.b		%d1, &32		# is exp <= 32?
    10942. 

  10942. 	bgt.b		unnorm_nrm_zero_lrg	# no; go handle large exponent
    10943. 

  10943. 

  10944. 	bfextu		FTEMP_HI(%a0){%d1:&32}, %d0 # extract new hi(man)
    10945. 

  10945. 	mov.l		%d0, FTEMP_HI(%a0)	# save new hi(man)
    10946. 

  10946. 

  10947. 	mov.l		FTEMP_LO(%a0), %d0	# fetch old lo(man)
    10948. 

  10948. 	lsl.l		%d1, %d0		# extract new lo(man)
    10949. 

  10949. 	mov.l		%d0, FTEMP_LO(%a0)	# save new lo(man)
    10950. 

  10950. 

  10951. 	and.w		&0x8000, FTEMP_EX(%a0)	# set exp = 0
    10952. 

  10952. 

  10953. 	mov.b		&DENORM, %d0		# return new optype tag
    10954. 

  10954. 	rts
    10955. 

  10955. 

  10956. #
    10957. 

  10957. # only mantissa bits set are in lo(man)
    10958. 

  10958. #
    10959. 

  10959. unnorm_nrm_zero_lrg:
    10960. 

  10960. 	sub.w		&32, %d1		# adjust shft amt by 32
    10961. 

  10961. 

  10962. 	mov.l		FTEMP_LO(%a0), %d0	# fetch old lo(man)
    10963. 

  10963. 	lsl.l		%d1, %d0		# left shift lo(man)
    10964. 

  10964. 

  10965. 	mov.l		%d0, FTEMP_HI(%a0)	# store new hi(man)
    10966. 

  10966. 	clr.l		FTEMP_LO(%a0)		# lo(man) = 0
    10967. 

  10967. 

  10968. 	and.w		&0x8000, FTEMP_EX(%a0)	# set exp = 0
    10969. 

  10969. 

  10970. 	mov.b		&DENORM, %d0		# return new optype tag
    10971. 

  10971. 	rts
    10972. 

  10972. 

  10973. #
    10974. 

  10974. # whole mantissa is zero so this UNNORM is actually a zero
    10975. 

  10975. #
    10976. 

  10976. unnorm_zero:
    10977. 

  10977. 	and.w		&0x8000, FTEMP_EX(%a0)	# force exponent to zero
    10978. 

  10978. 

  10979. 	mov.b		&ZERO, %d0		# fix optype tag
    10980. 

  10980. 	rts
    10981. 

  10981.