reg_round.S 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709
  1. .file "reg_round.S"
  2. /*---------------------------------------------------------------------------+
  3. | reg_round.S |
  4. | |
  5. | Rounding/truncation/etc for FPU basic arithmetic functions. |
  6. | |
  7. | Copyright (C) 1993,1995,1997 |
  8. | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, |
  9. | Australia. E-mail billm@suburbia.net |
  10. | |
  11. | This code has four possible entry points. |
  12. | The following must be entered by a jmp instruction: |
  13. | fpu_reg_round, fpu_reg_round_sqrt, and fpu_Arith_exit. |
  14. | |
  15. | The FPU_round entry point is intended to be used by C code. |
  16. | From C, call as: |
  17. | int FPU_round(FPU_REG *arg, unsigned int extent, unsigned int control_w) |
  18. | |
  19. | Return value is the tag of the answer, or-ed with FPU_Exception if |
  20. | one was raised, or -1 on internal error. |
  21. | |
  22. | For correct "up" and "down" rounding, the argument must have the correct |
  23. | sign. |
  24. | |
  25. +---------------------------------------------------------------------------*/
  26. /*---------------------------------------------------------------------------+
  27. | Four entry points. |
  28. | |
  29. | Needed by both the fpu_reg_round and fpu_reg_round_sqrt entry points: |
  30. | %eax:%ebx 64 bit significand |
  31. | %edx 32 bit extension of the significand |
  32. | %edi pointer to an FPU_REG for the result to be stored |
  33. | stack calling function must have set up a C stack frame and |
  34. | pushed %esi, %edi, and %ebx |
  35. | |
  36. | Needed just for the fpu_reg_round_sqrt entry point: |
  37. | %cx A control word in the same format as the FPU control word. |
  38. | Otherwise, PARAM4 must give such a value. |
  39. | |
  40. | |
  41. | The significand and its extension are assumed to be exact in the |
  42. | following sense: |
  43. | If the significand by itself is the exact result then the significand |
  44. | extension (%edx) must contain 0, otherwise the significand extension |
  45. | must be non-zero. |
  46. | If the significand extension is non-zero then the significand is |
  47. | smaller than the magnitude of the correct exact result by an amount |
  48. | greater than zero and less than one ls bit of the significand. |
  49. | The significand extension is only required to have three possible |
  50. | non-zero values: |
  51. | less than 0x80000000 <=> the significand is less than 1/2 an ls |
  52. | bit smaller than the magnitude of the |
  53. | true exact result. |
  54. | exactly 0x80000000 <=> the significand is exactly 1/2 an ls bit |
  55. | smaller than the magnitude of the true |
  56. | exact result. |
  57. | greater than 0x80000000 <=> the significand is more than 1/2 an ls |
  58. | bit smaller than the magnitude of the |
  59. | true exact result. |
  60. | |
  61. +---------------------------------------------------------------------------*/
  62. /*---------------------------------------------------------------------------+
  63. | The code in this module has become quite complex, but it should handle |
  64. | all of the FPU flags which are set at this stage of the basic arithmetic |
  65. | computations. |
  66. | There are a few rare cases where the results are not set identically to |
  67. | a real FPU. These require a bit more thought because at this stage the |
  68. | results of the code here appear to be more consistent... |
  69. | This may be changed in a future version. |
  70. +---------------------------------------------------------------------------*/
  71. #include "fpu_emu.h"
  72. #include "exception.h"
  73. #include "control_w.h"
  74. /* Flags for FPU_bits_lost */
  75. #define LOST_DOWN $1
  76. #define LOST_UP $2
  77. /* Flags for FPU_denormal */
  78. #define DENORMAL $1
  79. #define UNMASKED_UNDERFLOW $2
  80. #ifndef NON_REENTRANT_FPU
  81. /* Make the code re-entrant by putting
  82. local storage on the stack: */
  83. #define FPU_bits_lost (%esp)
  84. #define FPU_denormal 1(%esp)
  85. #else
  86. /* Not re-entrant, so we can gain speed by putting
  87. local storage in a static area: */
  88. .data
  89. .align 4,0
  90. FPU_bits_lost:
  91. .byte 0
  92. FPU_denormal:
  93. .byte 0
  94. #endif /* NON_REENTRANT_FPU */
  95. .text
  96. .globl fpu_reg_round
  97. .globl fpu_Arith_exit
  98. /* Entry point when called from C */
  99. ENTRY(FPU_round)
  100. pushl %ebp
  101. movl %esp,%ebp
  102. pushl %esi
  103. pushl %edi
  104. pushl %ebx
  105. movl PARAM1,%edi
  106. movl SIGH(%edi),%eax
  107. movl SIGL(%edi),%ebx
  108. movl PARAM2,%edx
  109. fpu_reg_round: /* Normal entry point */
  110. movl PARAM4,%ecx
  111. #ifndef NON_REENTRANT_FPU
  112. pushl %ebx /* adjust the stack pointer */
  113. #endif /* NON_REENTRANT_FPU */
  114. #ifdef PARANOID
  115. /* Cannot use this here yet */
  116. /* orl %eax,%eax */
  117. /* jns L_entry_bugged */
  118. #endif /* PARANOID */
  119. cmpw EXP_UNDER,EXP(%edi)
  120. jle L_Make_denorm /* The number is a de-normal */
  121. movb $0,FPU_denormal /* 0 -> not a de-normal */
  122. Denorm_done:
  123. movb $0,FPU_bits_lost /* No bits yet lost in rounding */
  124. movl %ecx,%esi
  125. andl CW_PC,%ecx
  126. cmpl PR_64_BITS,%ecx
  127. je LRound_To_64
  128. cmpl PR_53_BITS,%ecx
  129. je LRound_To_53
  130. cmpl PR_24_BITS,%ecx
  131. je LRound_To_24
  132. #ifdef PECULIAR_486
  133. /* With the precision control bits set to 01 "(reserved)", a real 80486
  134. behaves as if the precision control bits were set to 11 "64 bits" */
  135. cmpl PR_RESERVED_BITS,%ecx
  136. je LRound_To_64
  137. #ifdef PARANOID
  138. jmp L_bugged_denorm_486
  139. #endif /* PARANOID */
  140. #else
  141. #ifdef PARANOID
  142. jmp L_bugged_denorm /* There is no bug, just a bad control word */
  143. #endif /* PARANOID */
  144. #endif /* PECULIAR_486 */
  145. /* Round etc to 24 bit precision */
  146. LRound_To_24:
  147. movl %esi,%ecx
  148. andl CW_RC,%ecx
  149. cmpl RC_RND,%ecx
  150. je LRound_nearest_24
  151. cmpl RC_CHOP,%ecx
  152. je LCheck_truncate_24
  153. cmpl RC_UP,%ecx /* Towards +infinity */
  154. je LUp_24
  155. cmpl RC_DOWN,%ecx /* Towards -infinity */
  156. je LDown_24
  157. #ifdef PARANOID
  158. jmp L_bugged_round24
  159. #endif /* PARANOID */
  160. LUp_24:
  161. cmpb SIGN_POS,PARAM5
  162. jne LCheck_truncate_24 /* If negative then up==truncate */
  163. jmp LCheck_24_round_up
  164. LDown_24:
  165. cmpb SIGN_POS,PARAM5
  166. je LCheck_truncate_24 /* If positive then down==truncate */
  167. LCheck_24_round_up:
  168. movl %eax,%ecx
  169. andl $0x000000ff,%ecx
  170. orl %ebx,%ecx
  171. orl %edx,%ecx
  172. jnz LDo_24_round_up
  173. jmp L_Re_normalise
  174. LRound_nearest_24:
  175. /* Do rounding of the 24th bit if needed (nearest or even) */
  176. movl %eax,%ecx
  177. andl $0x000000ff,%ecx
  178. cmpl $0x00000080,%ecx
  179. jc LCheck_truncate_24 /* less than half, no increment needed */
  180. jne LGreater_Half_24 /* greater than half, increment needed */
  181. /* Possibly half, we need to check the ls bits */
  182. orl %ebx,%ebx
  183. jnz LGreater_Half_24 /* greater than half, increment needed */
  184. orl %edx,%edx
  185. jnz LGreater_Half_24 /* greater than half, increment needed */
  186. /* Exactly half, increment only if 24th bit is 1 (round to even) */
  187. testl $0x00000100,%eax
  188. jz LDo_truncate_24
  189. LGreater_Half_24: /* Rounding: increment at the 24th bit */
  190. LDo_24_round_up:
  191. andl $0xffffff00,%eax /* Truncate to 24 bits */
  192. xorl %ebx,%ebx
  193. movb LOST_UP,FPU_bits_lost
  194. addl $0x00000100,%eax
  195. jmp LCheck_Round_Overflow
  196. LCheck_truncate_24:
  197. movl %eax,%ecx
  198. andl $0x000000ff,%ecx
  199. orl %ebx,%ecx
  200. orl %edx,%ecx
  201. jz L_Re_normalise /* No truncation needed */
  202. LDo_truncate_24:
  203. andl $0xffffff00,%eax /* Truncate to 24 bits */
  204. xorl %ebx,%ebx
  205. movb LOST_DOWN,FPU_bits_lost
  206. jmp L_Re_normalise
  207. /* Round etc to 53 bit precision */
  208. LRound_To_53:
  209. movl %esi,%ecx
  210. andl CW_RC,%ecx
  211. cmpl RC_RND,%ecx
  212. je LRound_nearest_53
  213. cmpl RC_CHOP,%ecx
  214. je LCheck_truncate_53
  215. cmpl RC_UP,%ecx /* Towards +infinity */
  216. je LUp_53
  217. cmpl RC_DOWN,%ecx /* Towards -infinity */
  218. je LDown_53
  219. #ifdef PARANOID
  220. jmp L_bugged_round53
  221. #endif /* PARANOID */
  222. LUp_53:
  223. cmpb SIGN_POS,PARAM5
  224. jne LCheck_truncate_53 /* If negative then up==truncate */
  225. jmp LCheck_53_round_up
  226. LDown_53:
  227. cmpb SIGN_POS,PARAM5
  228. je LCheck_truncate_53 /* If positive then down==truncate */
  229. LCheck_53_round_up:
  230. movl %ebx,%ecx
  231. andl $0x000007ff,%ecx
  232. orl %edx,%ecx
  233. jnz LDo_53_round_up
  234. jmp L_Re_normalise
  235. LRound_nearest_53:
  236. /* Do rounding of the 53rd bit if needed (nearest or even) */
  237. movl %ebx,%ecx
  238. andl $0x000007ff,%ecx
  239. cmpl $0x00000400,%ecx
  240. jc LCheck_truncate_53 /* less than half, no increment needed */
  241. jnz LGreater_Half_53 /* greater than half, increment needed */
  242. /* Possibly half, we need to check the ls bits */
  243. orl %edx,%edx
  244. jnz LGreater_Half_53 /* greater than half, increment needed */
  245. /* Exactly half, increment only if 53rd bit is 1 (round to even) */
  246. testl $0x00000800,%ebx
  247. jz LTruncate_53
  248. LGreater_Half_53: /* Rounding: increment at the 53rd bit */
  249. LDo_53_round_up:
  250. movb LOST_UP,FPU_bits_lost
  251. andl $0xfffff800,%ebx /* Truncate to 53 bits */
  252. addl $0x00000800,%ebx
  253. adcl $0,%eax
  254. jmp LCheck_Round_Overflow
  255. LCheck_truncate_53:
  256. movl %ebx,%ecx
  257. andl $0x000007ff,%ecx
  258. orl %edx,%ecx
  259. jz L_Re_normalise
  260. LTruncate_53:
  261. movb LOST_DOWN,FPU_bits_lost
  262. andl $0xfffff800,%ebx /* Truncate to 53 bits */
  263. jmp L_Re_normalise
  264. /* Round etc to 64 bit precision */
  265. LRound_To_64:
  266. movl %esi,%ecx
  267. andl CW_RC,%ecx
  268. cmpl RC_RND,%ecx
  269. je LRound_nearest_64
  270. cmpl RC_CHOP,%ecx
  271. je LCheck_truncate_64
  272. cmpl RC_UP,%ecx /* Towards +infinity */
  273. je LUp_64
  274. cmpl RC_DOWN,%ecx /* Towards -infinity */
  275. je LDown_64
  276. #ifdef PARANOID
  277. jmp L_bugged_round64
  278. #endif /* PARANOID */
  279. LUp_64:
  280. cmpb SIGN_POS,PARAM5
  281. jne LCheck_truncate_64 /* If negative then up==truncate */
  282. orl %edx,%edx
  283. jnz LDo_64_round_up
  284. jmp L_Re_normalise
  285. LDown_64:
  286. cmpb SIGN_POS,PARAM5
  287. je LCheck_truncate_64 /* If positive then down==truncate */
  288. orl %edx,%edx
  289. jnz LDo_64_round_up
  290. jmp L_Re_normalise
  291. LRound_nearest_64:
  292. cmpl $0x80000000,%edx
  293. jc LCheck_truncate_64
  294. jne LDo_64_round_up
  295. /* Now test for round-to-even */
  296. testb $1,%bl
  297. jz LCheck_truncate_64
  298. LDo_64_round_up:
  299. movb LOST_UP,FPU_bits_lost
  300. addl $1,%ebx
  301. adcl $0,%eax
  302. LCheck_Round_Overflow:
  303. jnc L_Re_normalise
  304. /* Overflow, adjust the result (significand to 1.0) */
  305. rcrl $1,%eax
  306. rcrl $1,%ebx
  307. incw EXP(%edi)
  308. jmp L_Re_normalise
  309. LCheck_truncate_64:
  310. orl %edx,%edx
  311. jz L_Re_normalise
  312. LTruncate_64:
  313. movb LOST_DOWN,FPU_bits_lost
  314. L_Re_normalise:
  315. testb $0xff,FPU_denormal
  316. jnz Normalise_result
  317. L_Normalised:
  318. movl TAG_Valid,%edx
  319. L_deNormalised:
  320. cmpb LOST_UP,FPU_bits_lost
  321. je L_precision_lost_up
  322. cmpb LOST_DOWN,FPU_bits_lost
  323. je L_precision_lost_down
  324. L_no_precision_loss:
  325. /* store the result */
  326. L_Store_significand:
  327. movl %eax,SIGH(%edi)
  328. movl %ebx,SIGL(%edi)
  329. cmpw EXP_OVER,EXP(%edi)
  330. jge L_overflow
  331. movl %edx,%eax
  332. /* Convert the exponent to 80x87 form. */
  333. addw EXTENDED_Ebias,EXP(%edi)
  334. andw $0x7fff,EXP(%edi)
  335. fpu_reg_round_signed_special_exit:
  336. cmpb SIGN_POS,PARAM5
  337. je fpu_reg_round_special_exit
  338. orw $0x8000,EXP(%edi) /* Negative sign for the result. */
  339. fpu_reg_round_special_exit:
  340. #ifndef NON_REENTRANT_FPU
  341. popl %ebx /* adjust the stack pointer */
  342. #endif /* NON_REENTRANT_FPU */
  343. fpu_Arith_exit:
  344. popl %ebx
  345. popl %edi
  346. popl %esi
  347. leave
  348. ret
  349. /*
  350. * Set the FPU status flags to represent precision loss due to
  351. * round-up.
  352. */
  353. L_precision_lost_up:
  354. push %edx
  355. push %eax
  356. call set_precision_flag_up
  357. popl %eax
  358. popl %edx
  359. jmp L_no_precision_loss
  360. /*
  361. * Set the FPU status flags to represent precision loss due to
  362. * truncation.
  363. */
  364. L_precision_lost_down:
  365. push %edx
  366. push %eax
  367. call set_precision_flag_down
  368. popl %eax
  369. popl %edx
  370. jmp L_no_precision_loss
  371. /*
  372. * The number is a denormal (which might get rounded up to a normal)
  373. * Shift the number right the required number of bits, which will
  374. * have to be undone later...
  375. */
  376. L_Make_denorm:
  377. /* The action to be taken depends upon whether the underflow
  378. exception is masked */
  379. testb CW_Underflow,%cl /* Underflow mask. */
  380. jz Unmasked_underflow /* Do not make a denormal. */
  381. movb DENORMAL,FPU_denormal
  382. pushl %ecx /* Save */
  383. movw EXP_UNDER+1,%cx
  384. subw EXP(%edi),%cx
  385. cmpw $64,%cx /* shrd only works for 0..31 bits */
  386. jnc Denorm_shift_more_than_63
  387. cmpw $32,%cx /* shrd only works for 0..31 bits */
  388. jnc Denorm_shift_more_than_32
  389. /*
  390. * We got here without jumps by assuming that the most common requirement
  391. * is for a small de-normalising shift.
  392. * Shift by [1..31] bits
  393. */
  394. addw %cx,EXP(%edi)
  395. orl %edx,%edx /* extension */
  396. setne %ch /* Save whether %edx is non-zero */
  397. xorl %edx,%edx
  398. shrd %cl,%ebx,%edx
  399. shrd %cl,%eax,%ebx
  400. shr %cl,%eax
  401. orb %ch,%dl
  402. popl %ecx
  403. jmp Denorm_done
  404. /* Shift by [32..63] bits */
  405. Denorm_shift_more_than_32:
  406. addw %cx,EXP(%edi)
  407. subb $32,%cl
  408. orl %edx,%edx
  409. setne %ch
  410. orb %ch,%bl
  411. xorl %edx,%edx
  412. shrd %cl,%ebx,%edx
  413. shrd %cl,%eax,%ebx
  414. shr %cl,%eax
  415. orl %edx,%edx /* test these 32 bits */
  416. setne %cl
  417. orb %ch,%bl
  418. orb %cl,%bl
  419. movl %ebx,%edx
  420. movl %eax,%ebx
  421. xorl %eax,%eax
  422. popl %ecx
  423. jmp Denorm_done
  424. /* Shift by [64..) bits */
  425. Denorm_shift_more_than_63:
  426. cmpw $64,%cx
  427. jne Denorm_shift_more_than_64
  428. /* Exactly 64 bit shift */
  429. addw %cx,EXP(%edi)
  430. xorl %ecx,%ecx
  431. orl %edx,%edx
  432. setne %cl
  433. orl %ebx,%ebx
  434. setne %ch
  435. orb %ch,%cl
  436. orb %cl,%al
  437. movl %eax,%edx
  438. xorl %eax,%eax
  439. xorl %ebx,%ebx
  440. popl %ecx
  441. jmp Denorm_done
  442. Denorm_shift_more_than_64:
  443. movw EXP_UNDER+1,EXP(%edi)
  444. /* This is easy, %eax must be non-zero, so.. */
  445. movl $1,%edx
  446. xorl %eax,%eax
  447. xorl %ebx,%ebx
  448. popl %ecx
  449. jmp Denorm_done
  450. Unmasked_underflow:
  451. movb UNMASKED_UNDERFLOW,FPU_denormal
  452. jmp Denorm_done
  453. /* Undo the de-normalisation. */
  454. Normalise_result:
  455. cmpb UNMASKED_UNDERFLOW,FPU_denormal
  456. je Signal_underflow
  457. /* The number must be a denormal if we got here. */
  458. #ifdef PARANOID
  459. /* But check it... just in case. */
  460. cmpw EXP_UNDER+1,EXP(%edi)
  461. jne L_norm_bugged
  462. #endif /* PARANOID */
  463. #ifdef PECULIAR_486
  464. /*
  465. * This implements a special feature of 80486 behaviour.
  466. * Underflow will be signalled even if the number is
  467. * not a denormal after rounding.
  468. * This difference occurs only for masked underflow, and not
  469. * in the unmasked case.
  470. * Actual 80486 behaviour differs from this in some circumstances.
  471. */
  472. orl %eax,%eax /* ms bits */
  473. js LPseudoDenormal /* Will be masked underflow */
  474. #else
  475. orl %eax,%eax /* ms bits */
  476. js L_Normalised /* No longer a denormal */
  477. #endif /* PECULIAR_486 */
  478. jnz LDenormal_adj_exponent
  479. orl %ebx,%ebx
  480. jz L_underflow_to_zero /* The contents are zero */
  481. LDenormal_adj_exponent:
  482. decw EXP(%edi)
  483. LPseudoDenormal:
  484. testb $0xff,FPU_bits_lost /* bits lost == underflow */
  485. movl TAG_Special,%edx
  486. jz L_deNormalised
  487. /* There must be a masked underflow */
  488. push %eax
  489. pushl EX_Underflow
  490. call EXCEPTION
  491. popl %eax
  492. popl %eax
  493. movl TAG_Special,%edx
  494. jmp L_deNormalised
  495. /*
  496. * The operations resulted in a number too small to represent.
  497. * Masked response.
  498. */
  499. L_underflow_to_zero:
  500. push %eax
  501. call set_precision_flag_down
  502. popl %eax
  503. push %eax
  504. pushl EX_Underflow
  505. call EXCEPTION
  506. popl %eax
  507. popl %eax
  508. /* Reduce the exponent to EXP_UNDER */
  509. movw EXP_UNDER,EXP(%edi)
  510. movl TAG_Zero,%edx
  511. jmp L_Store_significand
  512. /* The operations resulted in a number too large to represent. */
  513. L_overflow:
  514. addw EXTENDED_Ebias,EXP(%edi) /* Set for unmasked response. */
  515. push %edi
  516. call arith_overflow
  517. pop %edi
  518. jmp fpu_reg_round_signed_special_exit
  519. Signal_underflow:
  520. /* The number may have been changed to a non-denormal */
  521. /* by the rounding operations. */
  522. cmpw EXP_UNDER,EXP(%edi)
  523. jle Do_unmasked_underflow
  524. jmp L_Normalised
  525. Do_unmasked_underflow:
  526. /* Increase the exponent by the magic number */
  527. addw $(3*(1<<13)),EXP(%edi)
  528. push %eax
  529. pushl EX_Underflow
  530. call EXCEPTION
  531. popl %eax
  532. popl %eax
  533. jmp L_Normalised
  534. #ifdef PARANOID
  535. #ifdef PECULIAR_486
  536. L_bugged_denorm_486:
  537. pushl EX_INTERNAL|0x236
  538. call EXCEPTION
  539. popl %ebx
  540. jmp L_exception_exit
  541. #else
  542. L_bugged_denorm:
  543. pushl EX_INTERNAL|0x230
  544. call EXCEPTION
  545. popl %ebx
  546. jmp L_exception_exit
  547. #endif /* PECULIAR_486 */
  548. L_bugged_round24:
  549. pushl EX_INTERNAL|0x231
  550. call EXCEPTION
  551. popl %ebx
  552. jmp L_exception_exit
  553. L_bugged_round53:
  554. pushl EX_INTERNAL|0x232
  555. call EXCEPTION
  556. popl %ebx
  557. jmp L_exception_exit
  558. L_bugged_round64:
  559. pushl EX_INTERNAL|0x233
  560. call EXCEPTION
  561. popl %ebx
  562. jmp L_exception_exit
  563. L_norm_bugged:
  564. pushl EX_INTERNAL|0x234
  565. call EXCEPTION
  566. popl %ebx
  567. jmp L_exception_exit
  568. L_entry_bugged:
  569. pushl EX_INTERNAL|0x235
  570. call EXCEPTION
  571. popl %ebx
  572. L_exception_exit:
  573. mov $-1,%eax
  574. jmp fpu_reg_round_special_exit
  575. #endif /* PARANOID */