home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 February / PCWorld_2000-02_cd.bin / Software / TemaCD / Hackman / _SETUP.1 / modulef.dat < prev    next >
Text File  |  1998-10-04  |  122KB  |  2,491 lines
  1. <F2XM1>
  2. [1]
  3. "F2XM1: Compute 2^x û1"
  4. ""
  5. "Calculates the exponential value of 2 to the power of the source operand minus 1. The source operand is located in register ST(0) and the result is also stored in ST(0). The value of the source operand must lie in the range û1.0 to +1.0. If the source value is outside this range, the result is undefined."
  6. [2]
  7. "ST(0) ¼ (2 ST(0) - 1);"
  8. [3]
  9. "FPU Flags Affected"
  10. ""
  11. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  12. [4]
  13. "Floating-Point Exceptions"
  14. ""
  15. "#IS Stack underflow occurred."
  16. "#IA Source operand is an SNaN value or unsupported format."
  17. "#D Result is a denormal value."
  18. "#U Result is too small for destination format."
  19. "#P Value cannot be represented exactly in destination format."
  20. ""
  21. "Protected Mode Exceptions"
  22. ""
  23. "#NM EM or TS in CR0 is set."
  24. ""
  25. "Real-Address Mode Exceptions"
  26. ""
  27. "#NM EM or TS in CR0 is set."
  28. ""
  29. "Virtual-8086 Mode Exceptions"
  30. ""
  31. "#NM EM or TS in CR0 is set."
  32. [5]
  33. "D9 F0 F2XM1 Replace ST(0) with (2^ST(0) û 1)"
  34. [6]
  35. </F2XM1>
  36. <FABS>
  37. [1]
  38. "FABS: Absolute Value"
  39. ""
  40. "Clears the sign bit of ST(0) to create the absolute value of the operand."
  41. [2]
  42. "ST(0) ¼ |ST(0)|"
  43. [3]
  44. "C1 Set to 0 if stack underflow occurred; otherwise, cleared to 0. C0, C2, C3 Undefined."
  45. [4]
  46. "Floating-Point Exceptions"
  47. ""
  48. "#IS Stack underflow occurred."
  49. ""
  50. "Protected Mode Exceptions"
  51. ""
  52. "#NM EM or TS in CR0 is set."
  53. ""
  54. "Real-Address Mode Exceptions"
  55. ""
  56. "#NM EM or TS in CR0 is set."
  57. ""
  58. "Virtual-8086 Mode Exceptions"
  59. ""
  60. "#NM EM or TS in CR0 is set."
  61. [5]
  62. "D9 E1 FABS Replace ST with its absolute value."
  63. [6]
  64. </FABS>
  65. <FADD>
  66. <FADDP>
  67. <FIADD>
  68. [1]
  69. "FADD/FADDP/FIADD: Add"
  70. ""
  71. "Adds the destination and source operands and stores the sum in the destination location. The destination operand is always an FPU register; the source operand can be a register or a memory location. Source operands in memory can be in single-real, double-real, word-integer, or short-integer formats."
  72. "The no-operand version of the instruction adds the contents of the ST(0) register to the ST(1) register. The one-operand version adds the contents of a memory location (either a real or an integer value) to the contents of the ST(0) register. The two-operand version, adds the contents of the ST(0) register to the ST(i) register or vice versa. The value in ST(0) can be doubled by coding: FADD ST(0), ST(0);"
  73. "The FADDP instructions perform the additional operation of popping the FPU register stack after storing the result. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. (The no-operand version of the floating-point add instructions always results in the register stack being popped. In some assemblers, the mnemonic for this instruction is FADD rather than FADDP.)"
  74. "The FIADD instructions convert an integer source operand to extended-real format before performing the addition."
  75. "When the sum of two operands with opposite signs is 0, the result is +0, except for the round toward -Ñ mode, in which case the result is -0. When the source operand is an integer 0, it is treated as a +0. When both operand are infinities of the same sign, the result is Ñ of the expected sign. If both operands are infinities of opposite signs, an invalid-operation exception is generated."
  76. [2]
  77. "IF instruction is FIADD"
  78. "THEN"
  79. "DEST ¼ DEST + ConvertExtendedReal(SRC);"
  80. "ELSE (* source operand is real number *)"
  81. "DEST ¼ DEST + SRC;"
  82. "FI;"
  83. "IF instruction = FADDP"
  84. "THEN"
  85. "PopRegisterStack;"
  86. "FI;"
  87. [3]
  88. "FPU Flags Affected"
  89. ""
  90. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  91. [4]
  92. "Floating-Point Exceptions"
  93. ""
  94. "#IS Stack underflow occurred."
  95. "#IA Operand is an SNaN value or unsupported format. Operands are infinities of unlike sign."
  96. "#D Result is a denormal value."
  97. "#U Result is too small for destination format."
  98. "#O Result is too large for destination format."
  99. "#P Value cannot be represented exactly in destination format."
  100. ""
  101. "Protected Mode Exceptions"
  102. ""
  103. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  104. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  105. "#NM EM or TS in CR0 is set."
  106. "#PF(fault-code) If a page fault occurs."
  107. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  108. ""
  109. "Real-Address Mode Exceptions"
  110. ""
  111. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  112. "#SS If a memory operand effective address is outside the SS segment limit."
  113. "#NM EM or TS in CR0 is set."
  114. ""
  115. "Virtual-8086 Mode Exceptions"
  116. ""
  117. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  118. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  119. "#NM EM or TS in CR0 is set."
  120. "#PF(fault-code) If a page fault occurs."
  121. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  122. [5]
  123. "D8 /0 FADD m32 real Add m32real to ST(0) and store result in ST(0)"
  124. "DC /0 FADD m64real Add m64real to ST(0) and store result in ST(0)"
  125. "D8 C0+i FADD ST(0), ST(i) Add ST(0) to ST(i) and store result in ST(0)"
  126. "DC C0+i FADD ST(i), ST(0) Add ST(i) to ST(0) and store result in ST(i)"
  127. "DE C0+i FADDP ST(i), ST(0) Add ST(0) to ST(i), store result in ST(i), and pop the register stack"
  128. "DE C1 FADDP Add ST(0) to ST(1), store result in ST(1), and pop the register stack"
  129. "DA /0 FIADD m32int Add m32int to ST(0) and store result in ST(0)"
  130. "DE /0 FIADD m16int Add m16int to ST(0) and store result in ST(0)"
  131. [6]
  132. </FADD>
  133. </FADDP>
  134. </FIADD>
  135. <FBLD>
  136. [1]
  137. "FBLD: Load Binary Coded Decimal"
  138. ""
  139. "Converts the BCD source operand into extended-real format and pushes the value onto the FPU stack. The source operand is loaded without rounding errors. The sign of the source operand is preserved, including that of -0. The packed BCD digits are assumed to be in the range 0 through 9; the instruction does not check for invalid digits (AH through FH). Attempting to load an invalid encoding produces an undefined result."
  140. [2]
  141. "TOP ¼ TOP - 1;"
  142. "ST(0) ¼ ExtendedReal(SRC);"
  143. [3]
  144. "FPU Flags Affected"
  145. ""
  146. "C1 Set to 1 if stack overflow occurred; otherwise, cleared to 0. C0, C2, C3 Undefined."
  147. [4]
  148. "Floating-Point Exceptions"
  149. ""
  150. "#IS Stack overflow occurred."
  151. ""
  152. "Protected Mode Exceptions"
  153. ""
  154. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  155. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  156. "#NM EM or TS in CR0 is set."
  157. "#PF(fault-code) If a page fault occurs."
  158. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  159. ""
  160. "Real-Address Mode Exceptions"
  161. ""
  162. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  163. "#SS If a memory operand effective address is outside the SS segment limit."
  164. "#NM EM or TS in CR0 is set."
  165. ""
  166. "Virtual-8086 Mode Exceptions"
  167. ""
  168. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  169. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  170. "#NM EM or TS in CR0 is set."
  171. "#PF(fault-code) If a page fault occurs."
  172. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  173. [5]
  174. "DF /4 FBLD m80 dec Convert BCD value to real and push onto the FPU stack."
  175. [6]
  176. </FBLD>
  177. <FBSTP>
  178. [1]
  179. "FBSTP: Store BCD Integer and Pop"
  180. ""
  181. "Converts the value in the ST(0) register to an 18-digit packed BCD integer, stores the result in the destination operand, and pops the register stack. If the source value is a non-integral value, it is rounded to an integer value, according to rounding mode specified by the RC field of the FPU control word. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1."
  182. "The destination operand specifies the address where the first byte destination value is to be stored. The BCD value (including its sign bit) requires 10 bytes of space in memory. If the source value is too large for the destination format and the invalid-operation exception is not masked, an invalid-operation exception is generated and no value is stored in the destination operand. If the invalid-operation exception is masked, the packed BCD indefinite value is stored in memory. If the source value is a quiet NaN, an invalid-operation exception is generated. Quiet NaNs do not normally cause this exception to be generated."
  183. [2]
  184. "DEST ¼ BCD(ST(0));"
  185. "PopRegisterStack;"
  186. [3]
  187. "FPU Flags Affected"
  188. ""
  189. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  190. [4]
  191. "Floating-Point Exceptions"
  192. ""
  193. "#IS Stack underflow occurred."
  194. "#IA Source operand is empty; contains a NaN, ▒Ñ, or unsupported format; or contains value that exceeds 18 BCD digits in length."
  195. "#P Value cannot be represented exactly in destination format."
  196. ""
  197. "Protected Mode Exceptions"
  198. ""
  199. "#GP(0) If a segment register is being loaded with a segment selector that points to a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  200. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  201. "#NM EM or TS in CR0 is set."
  202. "#PF(fault-code) If a page fault occurs."
  203. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  204. ""
  205. "Real-Address Mode Exceptions"
  206. ""
  207. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  208. "#SS If a memory operand effective address is outside the SS segment limit."
  209. "#NM EM or TS in CR0 is set."
  210. ""
  211. "Virtual-8086 Mode Exceptions"
  212. ""
  213. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  214. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  215. "#NM EM or TS in CR0 is set."
  216. "#PF(fault-code) If a page fault occurs."
  217. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  218. [5]
  219. "DF /6 FBSTP m80bcd Store ST(0) in m80bcd and pop ST(0)."
  220. [6]
  221. </FBSTP>
  222. <FCHS>
  223. [1]
  224. "FCHS: Change Sign"
  225. ""
  226. "Complements the sign bit of ST(0). This operation changes a positive value into a negative value of equal magnitude or vice versa."
  227. [2]
  228. "SignBit(ST(0)) ¼ NOT (SignBit(ST(0)))"
  229. [3]
  230. "FPU Flags Affected"
  231. ""
  232. "C1 Set to 0 if stack underflow occurred; otherwise, cleared to 0. C0, C2, C3 Undefined."
  233. [4]
  234. "Floating-Point Exceptions"
  235. ""
  236. "#IS Stack underflow occurred."
  237. ""
  238. "Protected Mode Exceptions"
  239. ""
  240. "#NM EM or TS in CR0 is set."
  241. ""
  242. "Real-Address Mode Exceptions"
  243. ""
  244. "#NM EM or TS in CR0 is set."
  245. ""
  246. "Virtual-8086 Mode Exceptions"
  247. ""
  248. "#NM EM or TS in CR0 is set."
  249. [5]
  250. "D9 E0 FCHS Complements sign of ST(0)"
  251. [6]
  252. </FCHS>
  253. <FCLEX>
  254. <FNCLEX>
  255. [1]
  256. "FCLEX/FNCLEX: Clear Exceptions"
  257. ""
  258. "Clears the floating-point exception flags (PE, UE, OE, ZE, DE, and IE), the exception summary status flag (ES), the stack fault flag (SF), and the busy flag (B) in the FPU status word. The FCLEX instruction checks for and handles any pending unmasked floating-point exceptions before clearing the exception flags; the FNCLEX instruction does not."
  259. ""
  260. "Intel Architecture Compatibility"
  261. ""
  262. "When operating a Pentium or Intel486 processor in MS-DOS compatibility mode, it is possible (under unusual circumstances) for an FNCLEX instruction to be interrupted prior to being executed to handle a pending FPU exception. An FNCLEX instruction cannot be interrupted in this way on a Pentium Pro processor."
  263. [2]
  264. "FPUStatusWord[0..7] ¼ 0;"
  265. "FPUStatusWord[15] ¼ 0;"
  266. [3]
  267. "FPU Flags Affected"
  268. ""
  269. "The PE, UE, OE, ZE, DE, IE, ES, SF, and B flags in the FPU status word are cleared. The C0, C1, C2, and C3 flags are undefined."
  270. [4]
  271. "Floating-Point Exceptions"
  272. ""
  273. "None."
  274. ""
  275. "Protected Mode Exceptions"
  276. ""
  277. "#NM EM or TS in CR0 is set."
  278. ""
  279. "Real-Address Mode Exceptions"
  280. ""
  281. "#NM EM or TS in CR0 is set."
  282. ""
  283. "Virtual-8086 Mode Exceptions"
  284. ""
  285. "#NM EM or TS in CR0 is set."
  286. [5]
  287. "9B DB E2 FCLEX Clear floating-point exception flags after checking for pending unmasked floating-point exceptions."
  288. "DB E2 FNCLEX Clear floating-point exception flags without checking for pending unmasked floating-point exceptions."
  289. [6]
  290. </FCLEX>
  291. </FNCLEX>
  292. <FCMOVB>
  293. <FCMOVE>
  294. <FCMOVBE>
  295. <FCMOVU>
  296. <FCMOVNB>
  297. <FCMOVNE>
  298. <FCMOVNBE>
  299. <FCMOVNU>
  300. [1]
  301. "FCMOV cc: Floating-Point Conditional Move"
  302. ""
  303. "Tests the status flags in the EFLAGS register and moves the source operand (second operand) to the destination operand (first operand) if the given test condition is true. The source operand is always in the ST(i) register and the destination operand is always ST(0). The FCMOVcc instructions are useful for optimizing small IF constructions. They also help eliminate branching overhead for IF operations and the possibility of branch mispredictions by the processor. A processor may not support the FCMOVcc instructions. Software can check if the FCMOVcc instructions are supported by checking the processorÆs feature information with the CPUID instruction. If both the CMOV and FPU feature bits are set, the FCMOVcc instructions are supported."
  304. ""
  305. "Intel Architecture Compatibility"
  306. ""
  307. "The FCMOVcc instructions were introduced to the Intel Architecture in the Pentium Pro processor family and is not available in earlier Intel Architecture processors."
  308. [2]
  309. "IF condition TRUE"
  310. "ST(0) ¼ ST(i)"
  311. "FI;"
  312. [3]
  313. "FPU Flags Affected"
  314. ""
  315. "C1 Set to 0 if stack underflow occurred. C0, C2, C3 Undefined."
  316. [4]
  317. "Floating-Point Exceptions"
  318. ""
  319. "#IS Stack underflow occurred."
  320. ""
  321. "Integer Flags Affected"
  322. ""
  323. "None."
  324. ""
  325. "Protected Mode Exceptions"
  326. ""
  327. "#NM EM or TS in CR0 is set."
  328. ""
  329. "Real-Address Mode Exceptions"
  330. ""
  331. "#NM EM or TS in CR0 is set."
  332. ""
  333. "Virtual-8086 Mode Exceptions"
  334. ""
  335. "#NM EM or TS in CR0 is set."
  336. [5]
  337. "DA C0+i FCMOVB ST(0), ST(i) Move if below (CF=1)"
  338. "DA C8+i FCMOVE ST(0), ST(i) Move if equal (ZF=1)"
  339. "DA D0+i FCMOVBE ST(0), ST(i) Move if below or equal (CF=1 or ZF=1)"
  340. "DA D8+i FCMOVU ST(0), ST(i) Move if unordered (PF=1)"
  341. "DB C0+i FCMOVNB ST(0), ST(i) Move if not below (CF=0)"
  342. "DB C8+i FCMOVNE ST(0), ST(i) Move if not equal (ZF=0)"
  343. "DB D0+i FCMOVNBE ST(0), ST(i) Move if not below or equal (CF=0 and ZF=0)"
  344. "DB D8+i FCMOVNU ST(0), ST(i) Move if not unordered (PF=0)"
  345. [6]
  346. </FCMOVB>
  347. </FCMOVE>
  348. </FCMOVBE>
  349. </FCMOVU>
  350. </FCMOVNB>
  351. </FCMOVNE>
  352. </FCMOVNBE>
  353. </FCMOVNU>
  354. <FCOM>
  355. <FCOMP>
  356. <FCOMPP>
  357. [1]
  358. "FCOM/FCOMP/FCOMPP: Compare Real"
  359. ""
  360. "Compares the contents of register ST(0) and source value and sets condition code flags C0, C2, and C3 in the FPU status word according to the results. The source operand can be a data register or a memory location. If no source operand is given, the value in ST(0) is compared with the value in ST(1). The sign of zero is ignored, so that û0.0 = +0.0."
  361. ""
  362. "NOTE:"
  363. "* Flags not set if unmasked invalid-arithmetic-operand (#IA) exception is generated. This instruction checks the class of the numbers being compared. If either operand is a NaN or is in an unsupported format, an invalid-arithmetic-operand exception (#IA) is raised and, if the exception is masked, the condition flags are set to ôunordered.ö If the invalid-arithmetic-operand exception is unmasked, the condition code flags are not set."
  364. ""
  365. "The FCOMP instruction pops the register stack following the comparison operation and the FCOMPP instruction pops the register stack twice following the comparison operation. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1."
  366. "The FCOM instructions perform the same operation as the FUCOM instructions. The only difference is how they handle QNaN operands. The FCOM instructions raise an invalid-arithmetic-operand exception (#IA) when either or both of the operands is a NaN value or is in an unsupported format. The FUCOM instructions perform the same operation as the FCOM instructions, except that they do not generate an invalid-arithmetic-operand exception for QNaNs."
  367. [2]
  368. "CASE (relation of operands) OF"
  369. "ST > SRC: C3, C2, C0 ¼ 000;"
  370. "ST < SRC: C3, C2, C0 ¼ 001;"
  371. "ST = SRC: C3, C2, C0 ¼ 100;"
  372. "ESAC;"
  373. "IF ST(0) or SRC = NaN or unsupported format"
  374. "THEN"
  375. "#IA"
  376. "IF FPUControlWord.IM = 1"
  377. "THEN"
  378. "C3, C2, C0 ¼ 111;"
  379. "FI;"
  380. "FI;"
  381. "IF instruction = FCOMP"
  382. "THEN"
  383. "PopRegisterStack;"
  384. "FI;"
  385. "IF instruction = FCOMPP"
  386. "THEN"
  387. "PopRegisterStack;"
  388. "PopRegisterStack;"
  389. "FI;"
  390. [3]
  391. "FPU Flags Affected"
  392. ""
  393. "C1 Set to 0 if stack underflow occurred; otherwise, cleared to 0."
  394. [4]
  395. "Floating-Point Exceptions"
  396. ""
  397. "#IS Stack underflow occurred."
  398. "#IA One or both operands are NaN values or have unsupported formats. Register is marked empty."
  399. "#D One or both operands are denormal values."
  400. ""
  401. "Protected Mode Exceptions"
  402. ""
  403. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  404. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  405. "#NM EM or TS in CR0 is set."
  406. "#PF(fault-code) If a page fault occurs."
  407. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  408. ""
  409. "Real-Address Mode Exceptions"
  410. ""
  411. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  412. "#SS If a memory operand effective address is outside the SS segment limit."
  413. "#NM EM or TS in CR0 is set."
  414. ""
  415. "Virtual-8086 Mode Exceptions"
  416. ""
  417. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  418. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  419. "#NM EM or TS in CR0 is set."
  420. "#PF(fault-code) If a page fault occurs."
  421. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  422. [5]
  423. "D8 /2 FCOM m32real Compare ST(0) with m32real."
  424. "DC /2 FCOM m64real Compare ST(0) with m64real."
  425. "D8 D0+i FCOM ST(i) Compare ST(0) with ST(i)."
  426. "D8 D1 FCOM Compare ST(0) with ST(1)."
  427. "D8 /3 FCOMP m32real Compare ST(0) with m32real and pop register stack."
  428. "DC /3 FCOMP m64real Compare ST(0) with m64real and pop register stack."
  429. "D8 D8+i FCOMP ST(i) Compare ST(0) with ST(i) and pop register stack."
  430. "D8 D9 FCOMP Compare ST(0) with ST(1) and pop register stack."
  431. "DE D9 FCOMPP Compare ST(0) with ST(1) and pop register stack twice."
  432. [6]
  433. </FCOM>
  434. </FCOMP>
  435. </FCOMPP>
  436. <FCOMI>
  437. <FCOMIP>
  438. <FUCOMI>
  439. <FUCOMIP>
  440. [1]
  441. "FCOMI/FCOMIP/FUCOMI/FUCOMIP: Compare Real and Set EFLAGS"
  442. ""
  443. "Compares the contents of register ST(0) and ST(i) and sets the status flags ZF, PF, and CF in the EFLAGS register according to the results. The sign of zero is ignored for comparisons, so that û0.0 = +0.0."
  444. "The FCOMI/FCOMIP instructions perform the same operation as the FUCOMI/FUCOMIP instructions. The only difference is how they handle QNaN operands. The FCOMI/FCOMIP instructions set the status flags to ôunorderedö and generate an invalid-arithmetic-operand exception (#IA) when either or both of the operands is a NaN value (SNaN or QNaN) or is in an unsupported format."
  445. "The FUCOMI/FUCOMIP instructions perform the same operation as the FCOMI/FCOMIP instructions, except that they do not generate an invalid-arithmetic-operand exception for QNaNs."
  446. "If invalid-operation exception is unmasked, the status flags are not set if the invalid-arithmetic-operand exception is generated. The FCOMIP and FUCOMIP instructions also pop the register stack following the comparison operation. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1."
  447. ""
  448. "Intel Architecture Compatibility"
  449. ""
  450. "The FCOMI/FCOMIP/FUCOMI/FUCOMIP instructions were introduced to the Intel Architecture in the Pentium Pro processor family and are not available in earlier Intel Architecture processors."
  451. [2]
  452. "CASE (relation of operands) OF"
  453. "ST(0) > ST(i): ZF, PF, CF ¼ 000;"
  454. "ST(0) < ST(i): ZF, PF, CF ¼ 001;"
  455. "ST(0) = ST(i): ZF, PF, CF ¼ 100;"
  456. "ESAC;"
  457. "IF instruction is FCOMI or FCOMIP"
  458. "THEN"
  459. "IF ST(0) or ST(i) = NaN or unsupported format"
  460. "THEN"
  461. "#IA"
  462. "IF FPUControlWord.IM = 1"
  463. "THEN"
  464. "ZF, PF, CF ¼ 111;"
  465. "FI;"
  466. "FI;"
  467. "FI;"
  468. "IF instruction is FUCOMI or FUCOMIP"
  469. "THEN"
  470. "IF ST(0) or ST(i) = QNaN, but not SNaN or unsupported format"
  471. "THEN"
  472. "ZF, PF, CF ¼ 111;"
  473. "ELSE (* ST(0) or ST(i) is SNaN or unsupported format *)"
  474. "#IA;"
  475. "IF FPUControlWord.IM = 1"
  476. "THEN"
  477. "ZF, PF, CF ¼ 111;"
  478. "FI;"
  479. "FI;"
  480. "FI;"
  481. "IF instruction is FCOMIP or FUCOMIP"
  482. "THEN"
  483. "PopRegisterStack;"
  484. "FI;"
  485. [3]
  486. "FPU Flags Affected"
  487. ""
  488. "C1 Set to 0 if stack underflow occurred; otherwise, cleared to 0. C0, C2, C3 Not affected."
  489. [4]
  490. "Floating-Point Exceptions"
  491. ""
  492. "#IS Stack underflow occurred."
  493. "#IA (FCOMI or FCOMIP instruction) One or both operands are NaN values or have unsupported formats. (FUCOMI or FUCOMIP instruction) One or both operands are SNaN values (but not QNaNs) or have undefined formats. Detection of a QNaN value does not raise an invalid-operand exception."
  494. ""
  495. "Protected Mode Exceptions"
  496. ""
  497. "#NM EM or TS in CR0 is set."
  498. ""
  499. "Real-Address Mode Exceptions"
  500. ""
  501. "#NM EM or TS in CR0 is set."
  502. ""
  503. "Virtual-8086 Mode Exceptions"
  504. ""
  505. "#NM EM or TS in CR0 is set."
  506. [5]
  507. "DB F0+i FCOMI ST, ST(i) Compare ST(0) with ST(i) and set status flags accordingly"
  508. "DF F0+i FCOMIP ST, ST(i) Compare ST(0) with ST(i), set status flags accordingly, and pop register stack"
  509. "DB E8+i FUCOMI ST, ST(i) Compare ST(0) with ST(i), check for ordered values, and set status flags accordingly"
  510. "DF E8+i FUCOMIP ST, ST(i) Compare ST(0) with ST(i), check for ordered values, set status flags accordingly, and pop register stack"
  511. [6]
  512. </FCOMI>
  513. </FCOMIP>
  514. </FUCOMI>
  515. </FUCOMIP>
  516. <FCOS>
  517. [1]
  518. "FCOS: Cosine"
  519. ""
  520. "Calculates the cosine of the source operand in register ST(0) and stores the result in ST(0). The source operand must be given in radians and must be within the range -2^63 to +2^63. If the source operand is outside the acceptable range, the C2 flag in the FPU status word is set, and the value in register ST(0) remains unchanged. The instruction does not raise an exception when the source operand is out of range. It is up to the program to check the C2 flag for out-of-range conditions. Source values outside the range -2^63 to +2^63 can be reduced to the range of the instruction by subtracting an appropriate integer multiple of 2p or by using the FPREM instruction with a divisor of 2p."
  521. [2]
  522. "IF |ST(0)| < 2 63"
  523. "THEN"
  524. "C2 ¼ 0;"
  525. "ST(0) ¼ cosine(ST(0));"
  526. "ELSE (*source operand is out-of-range *)"
  527. "C2 ¼ 1;"
  528. "FI;"
  529. [3]
  530. "FPU Flags Affected"
  531. ""
  532. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. Undefined if C2 is 1. C2 Set to 1 if source operand is outside the range -2^63 to +2^63 ; otherwise, cleared to 0. C0, C3 Undefined."
  533. [4]
  534. "Floating-Point Exceptions"
  535. ""
  536. "#IS Stack underflow occurred."
  537. "#IA Source operand is an SNaN value, Ñ, or unsupported format."
  538. "#D Result is a denormal value."
  539. "#U Result is too small for destination format."
  540. "#P Value cannot be represented exactly in destination format."
  541. ""
  542. "Protected Mode Exceptions"
  543. ""
  544. "#NM EM or TS in CR0 is set."
  545. ""
  546. "Real-Address Mode Exceptions"
  547. ""
  548. "#NM EM or TS in CR0 is set."
  549. ""
  550. "Virtual-8086 Mode Exceptions"
  551. ""
  552. "#NM EM or TS in CR0 is set."
  553. [5]
  554. "D9 FF FCOS Replace ST(0) with its cosine"
  555. [6]
  556. </FCOS>
  557. <FDECSTP>
  558. [1]
  559. "FDECSTP: Decrement Stack-Top Pointer"
  560. ""
  561. "Subtracts one from the TOP field of the FPU status word (decrements the top-of-stack pointer). If the TOP field contains a 0, it is set to 7. The effect of this instruction is to rotate the stack by one position. The contents of the FPU data registers and tag register are not affected."
  562. [2]
  563. "IF TOP = 0"
  564. "THEN TOP ¼ 7;"
  565. "ELSE TOP ¼ TOP û 1;"
  566. "FI;"
  567. [3]
  568. "FPU Flags Affected"
  569. ""
  570. "The C1 flag is set to 0; otherwise, cleared to 0. The C0, C2, and C3 flags are undefined."
  571. [4]
  572. "Floating-Point Exceptions"
  573. ""
  574. "None."
  575. ""
  576. "Protected Mode Exceptions"
  577. ""
  578. "#NM EM or TS in CR0 is set."
  579. ""
  580. "Real-Address Mode Exceptions"
  581. ""
  582. "#NM EM or TS in CR0 is set."
  583. ""
  584. "Virtual-8086 Mode Exceptions"
  585. ""
  586. "#NM EM or TS in CR0 is set."
  587. [5]
  588. "D9 F6 FDECSTP Decrement TOP field in FPU status word."
  589. [6]
  590. </FDECSTP>
  591. <FDIV>
  592. <FDIVP>
  593. <FIDIV>
  594. [1]
  595. "FDIV/FDIVP/FIDIV: Divide"
  596. ""
  597. "Divides the destination operand by the source operand and stores the result in the destination location. The destination operand (dividend) is always in an FPU register; the source operand (divisor) can be a register or a memory location. Source operands in memory can be in single-real, double-real, word-integer, or short-integer formats."
  598. "The no-operand version of the instruction divides the contents of the ST(1) register by the contents of the ST(0) register. The one-operand version divides the contents of the ST(0) register by the contents of a memory location (either a real or an integer value). The two-operand version, divides the contents of the ST(0) register by the contents of the ST(i) register or vice versa."
  599. "The FDIVP instructions perform the additional operation of popping the FPU register stack after storing the result. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. The no-operand version of the floating-point divide instructions always results in the register stack being popped. In some assemblers, the mnemonic for this instruction is FDIV rather than FDIVP."
  600. "The FIDIV instructions convert an integer source operand to extended-real format before performing the division. When the source operand is an integer 0, it is treated as a +0. If an unmasked divide by zero exception (#Z) is generated, no result is stored; if the exception is masked, an Ñ of the appropriate sign is stored in the destination operand."
  601. [2]
  602. "IF SRC = 0"
  603. "THEN"
  604. "#Z"
  605. "ELSE"
  606. "IF instruction is FIDIV"
  607. "THEN"
  608. "DEST ¼ DEST / ConvertExtendedReal(SRC);"
  609. "ELSE (* source operand is real number *)"
  610. "DEST ¼ DEST / SRC;"
  611. "FI;"
  612. "FI;"
  613. "IF instruction = FDIVP"
  614. "THEN"
  615. "PopRegisterStack"
  616. "FI;"
  617. [3]
  618. "FPU Flags Affected"
  619. ""
  620. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  621. [4]
  622. "Floating-Point Exceptions"
  623. ""
  624. "#IS Stack underflow occurred."
  625. "#IA Operand is an SNaN value or unsupported format. ▒Ñ / ▒Ñ; ▒0 / ▒0"
  626. "#D Result is a denormal value."
  627. "#Z DEST / ▒0, where DEST is not equal to ▒0."
  628. "#U Result is too small for destination format."
  629. "#O Result is too large for destination format."
  630. "#P Value cannot be represented exactly in destination format."
  631. ""
  632. "Protected Mode Exceptions"
  633. ""
  634. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  635. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  636. "#NM EM or TS in CR0 is set."
  637. "#PF(fault-code) If a page fault occurs."
  638. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  639. ""
  640. "Real-Address Mode Exceptions"
  641. ""
  642. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  643. "#SS If a memory operand effective address is outside the SS segment limit."
  644. "#NM EM or TS in CR0 is set."
  645. ""
  646. "Virtual-8086 Mode Exceptions"
  647. ""
  648. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  649. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  650. "#NM EM or TS in CR0 is set."
  651. "#PF(fault-code) If a page fault occurs."
  652. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  653. [5]
  654. "D8 /6 FDIV m32real Divide ST(0) by m32real and store result in ST(0)"
  655. "DC /6 FDIV m64real Divide ST(0) by m64real and store result in ST(0)"
  656. "D8 F0+i FDIV ST(0), ST(i) Divide ST(0) by ST(i) and store result in ST(0)"
  657. "DC F8+i FDIV ST(i), ST(0) Divide ST(i) by ST(0) and store result in ST(i)"
  658. "DE F8+i FDIVP ST(i), ST(0) Divide ST(i) by ST(0), store result in ST(i), and pop the register stack"
  659. "DE F9 FDIVP Divide ST(1) by ST(0), store result in ST(1), and pop the register stack"
  660. "DA /6 FIDIV m32int Divide ST(0) by m32int and store result in ST(0)"
  661. "DE /6 FIDIV m16int Divide ST(0) by m64int and store result in ST(0)"
  662. [6]
  663. </FDIV>
  664. </FDIVP>
  665. </FIDIV>
  666. <FDIVR>
  667. <FDIVRP>
  668. <FIDIVR>
  669. [1]
  670. "FDIVR/FDIVRP/FIDIVR: Reverse Divide"
  671. ""
  672. "Divides the source operand by the destination operand and stores the result in the destination location. The destination operand (divisor) is always in an FPU register; the source operand (dividend) can be a register or a memory location. Source operands in memory can be in single-real, double-real, word-integer, or short-integer formats. These instructions perform the reverse operations of the FDIV, FDIVP, and FIDIV instructions. They are provided to support more efficient coding. The no-operand version of the instruction divides the contents of the ST(0) register by the contents of the ST(1) register. The one-operand version divides the contents of a memory location (either a real or an integer value) by the contents of the ST(0) register. The two-operand version, divides the contents of the ST(i) register by the contents of the ST(0) register or vice versa."
  673. "The FDIVRP instructions perform the additional operation of popping the FPU register stack after storing the result. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. The no-operand version of the floating-point divide instructions always results in the register stack being popped. In some assemblers, the mnemonic for this instruction is FDIVR rather than FDIVRP."
  674. "The FIDIVR instructions convert an integer source operand to extended-real format before performing the division. If an unmasked divide by zero exception (#Z) is generated, no result is stored; if the exception is masked, an Ñ of the appropriate sign is stored in the destination operand."
  675. [2]
  676. "IF DEST = 0"
  677. "THEN"
  678. "#Z"
  679. "ELSE"
  680. "IF instruction is FIDIVR"
  681. "THEN"
  682. "DEST ¼ ConvertExtendedReal(SRC) / DEST;"
  683. "ELSE (* source operand is real number *)"
  684. "DEST ¼ SRC / DEST;"
  685. "FI;"
  686. "FI;"
  687. "IF instruction = FDIVRP"
  688. "THEN"
  689. "PopRegisterStack"
  690. "FI;"
  691. [3]
  692. "FPU Flags Affected"
  693. ""
  694. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  695. [4]
  696. "Floating-Point Exceptions"
  697. ""
  698. "#IS Stack underflow occurred."
  699. "#IA Operand is an SNaN value or unsupported format. ▒Ñ / ▒Ñ; ▒0 / ▒0"
  700. "#D Result is a denormal value."
  701. "#Z SRC / ▒0, where SRC is not equal to ▒0."
  702. "#U Result is too small for destination format."
  703. "#O Result is too large for destination format."
  704. "#P Value cannot be represented exactly in destination format."
  705. ""
  706. "Protected Mode Exceptions"
  707. ""
  708. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  709. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  710. "#NM EM or TS in CR0 is set."
  711. "#PF(fault-code) If a page fault occurs."
  712. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  713. ""
  714. "Real-Address Mode Exceptions"
  715. ""
  716. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  717. "#SS If a memory operand effective address is outside the SS segment limit."
  718. "#NM EM or TS in CR0 is set."
  719. ""
  720. "Virtual-8086 Mode Exceptions"
  721. ""
  722. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  723. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  724. "#NM EM or TS in CR0 is set."
  725. "#PF(fault-code) If a page fault occurs."
  726. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  727. [5]
  728. "D8 /7 FDIVR m32real Divide m32real by ST(0) and store result in ST(0)"
  729. "DC /7 FDIVR m64real Divide m64real by ST(0) and store result in ST(0)"
  730. "D8 F8+i FDIVR ST(0), ST(i) Divide ST(i) by ST(0) and store result in ST(0)"
  731. "DC F0+i FDIVR ST(i), ST(0) Divide ST(0) by ST(i) and store result in ST(i)"
  732. "DE F0+i FDIVRP ST(i), ST(0) Divide ST(0) by ST(i), store result in ST(i), and pop the register stack"
  733. "DE F1 FDIVRP Divide ST(0) by ST(1), store result in ST(1), and pop the register stack"
  734. "DA /7 FIDIVR m32int Divide m32int by ST(0) and store result in ST(0)"
  735. "DE /7 FIDIVR m16int Divide m64int by ST(0) and store result in ST(0)"
  736. [6]
  737. </FDIVR>
  738. </FDIVRP>
  739. </FIDIVR>
  740. <FFREE>
  741. [1]
  742. "FFREE: Free Floating-Point Register"
  743. ""
  744. "Sets the tag in the FPU tag register associated with register ST(i) to empty (11B). The contents of ST(i) and the FPU stack-top pointer (TOP) are not affected."
  745. [2]
  746. "TAG(i) ¼ 11B;"
  747. [3]
  748. "FPU Flags Affected"
  749. ""
  750. "C0, C1, C2, C3 undefined."
  751. [4]
  752. "Floating-Point Exceptions"
  753. ""
  754. "None."
  755. ""
  756. "Protected Mode Exceptions"
  757. ""
  758. "#NM EM or TS in CR0 is set."
  759. ""
  760. "Real-Address Mode Exceptions"
  761. ""
  762. "#NM EM or TS in CR0 is set."
  763. ""
  764. "Virtual-8086 Mode Exceptions"
  765. ""
  766. "#NM EM or TS in CR0 is set."
  767. [5]
  768. "DD C0+i FFREE ST(i) Sets tag for ST(i) to empty"
  769. [6]
  770. </FFREE>
  771. <FICOM>
  772. <FICOMP>
  773. [1]
  774. "FICOM/FICOMP: Compare Integer"
  775. ""
  776. "Compares the value in ST(0) with an integer source operand and sets the condition code flags C0, C2, and C3 in the FPU status word according to the results. The integer value is converted to extended-real format before the comparison is made. These instructions perform an ôunordered comparison.ö An unordered comparison also checks the class of the numbers being compared. If either operand is a NaN or is in an undefined format, the condition flags are set to ôunordered.ö The sign of zero is ignored, so that û0.0 = +0.0. The FICOMP instructions pop the register stack following the comparison. To pop the register stack, the processor marks the ST(0) register empty and increments the stack pointer (TOP) by 1."
  777. [2]
  778. "CASE (relation of operands) OF"
  779. "ST(0) > SRC: C3, C2, C0 ¼ 000;"
  780. "ST(0) < SRC: C3, C2, C0 ¼ 001;"
  781. "ST(0) = SRC: C3, C2, C0 ¼ 100;"
  782. "Unordered: C3, C2, C0 ¼ 111;"
  783. "ESAC;"
  784. "IF instruction = FICOMP"
  785. "THEN"
  786. "PopRegisterStack;"
  787. "FI;"
  788. [3]
  789. "FPU Flags Affected"
  790. ""
  791. "C1 Set to 0 if stack underflow occurred; otherwise, set to 0. C0, C2, C3 according to tables."
  792. [4]
  793. "Floating-Point Exceptions"
  794. ""
  795. "#IS Stack underflow occurred."
  796. "#IA One or both operands are NaN values or have unsupported formats."
  797. "#D One or both operands are denormal values."
  798. ""
  799. "Protected Mode Exceptions"
  800. ""
  801. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  802. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  803. "#NM EM or TS in CR0 is set."
  804. "#PF(fault-code) If a page fault occurs."
  805. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  806. ""
  807. "Real-Address Mode Exceptions"
  808. ""
  809. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  810. "#SS If a memory operand effective address is outside the SS segment limit."
  811. "#NM EM or TS in CR0 is set."
  812. ""
  813. "Virtual-8086 Mode Exceptions"
  814. ""
  815. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  816. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  817. "#NM EM or TS in CR0 is set."
  818. "#PF(fault-code) If a page fault occurs."
  819. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  820. [5]
  821. "DE /2 FICOM m16int Compare ST(0) with m16int"
  822. "DA /2 FICOM m32int Compare ST(0) with m32int"
  823. "DE /3 FICOMP m16int Compare ST(0) with m16int and pop stack register"
  824. "DA /3 FICOMP m32int Compare ST(0) with m32int and pop stack register"
  825. [6]
  826. </FICOM>
  827. </FICOMP>
  828. <FILD>
  829. [1]
  830. "FILD: Load Integer"
  831. ""
  832. "Converts the signed-integer source operand into extended-real format and pushes the value onto the FPU register stack. The source operand can be a word, short, or long integer value. It is loaded without rounding errors. The sign of the source operand is preserved."
  833. [2]
  834. "TOP ¼ TOP - 1;"
  835. "ST(0) ¼ ExtendedReal(SRC);"
  836. [3]
  837. "FPU Flags Affected"
  838. ""
  839. "C1 Set to 1 if stack overflow occurred; cleared to 0 otherwise. C0, C2, C3 Undefined."
  840. [4]
  841. "Floating-Point Exceptions"
  842. ""
  843. "#IS Stack overflow occurred."
  844. ""
  845. "Protected Mode Exceptions"
  846. ""
  847. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a null segment selector."
  848. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  849. "#NM EM or TS in CR0 is set."
  850. "#PF(fault-code) If a page fault occurs."
  851. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  852. ""
  853. "Real-Address Mode Exceptions"
  854. ""
  855. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  856. "#SS If a memory operand effective address is outside the SS segment limit."
  857. "#NM EM or TS in CR0 is set."
  858. ""
  859. "Virtual-8086 Mode Exceptions"
  860. ""
  861. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  862. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  863. "#NM EM or TS in CR0 is set."
  864. "#PF(fault-code) If a page fault occurs."
  865. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  866. [5]
  867. "DF /0 FILD m16int Push m16int onto the FPU register stack."
  868. "DB /0 FILD m32int Push m32int onto the FPU register stack."
  869. "DF /5 FILD m64int Push m64int onto the FPU register stack."
  870. [6]
  871. </FILD>
  872. <FINCSTP>
  873. [1]
  874. "FINCSTP: Increment Stack-Top Pointer"
  875. ""
  876. "Adds one to the TOP field of the FPU status word (increments the top-of-stack pointer). If the TOP field contains a 7, it is set to 0. The effect of this instruction is to rotate the stack by one position. The contents of the FPU data registers and tag register are not affected. This operation is not equivalent to popping the stack, because the tag for the previous top-of-stack register is not marked empty."
  877. [2]
  878. "IF TOP = 7"
  879. "THEN TOP ¼ 0;"
  880. "ELSE TOP ¼ TOP + 1;"
  881. "FI;"
  882. [3]
  883. "FPU Flags Affected"
  884. ""
  885. "The C1 flag is set to 0; otherwise, cleared to 0. The C0, C2, and C3 flags are undefined."
  886. [4]
  887. "Floating-Point Exceptions"
  888. ""
  889. "None."
  890. ""
  891. "Protected Mode Exceptions"
  892. ""
  893. "#NM EM or TS in CR0 is set."
  894. ""
  895. "Real-Address Mode Exceptions"
  896. ""
  897. "#NM EM or TS in CR0 is set."
  898. ""
  899. "Virtual-8086 Mode Exceptions"
  900. ""
  901. "#NM EM or TS in CR0 is set."
  902. [5]
  903. "D9 F7 FINCSTP Increment the TOP field in the FPU status register"
  904. [6]
  905. </FINCSTP>
  906. <FINIT>
  907. <FNINIT>
  908. [1]
  909. "FINIT/FNINIT: Initialize Floating-Point Unit"
  910. ""
  911. "Sets the FPU control, status, tag, instruction pointer, and data pointer registers to their default states. The FPU control word is set to 037FH (round to nearest, all exceptions masked, 64-bit precision). The status word is cleared (no exception flags set, TOP is set to 0). The data registers in the register stack are left unchanged, but they are all tagged as empty (11B). Both the instruction and data pointers are cleared. The FINIT instruction checks for and handles any pending unmasked floating-point exceptions before performing the initialization; the FNINIT instruction does not."
  912. ""
  913. "Intel Architecture Compatibility"
  914. ""
  915. "When operating a Pentium or Intel486 processor in MS-DOS compatibility mode, it is possible (under unusual circumstances) for an FNINIT instruction to be interrupted prior to being executed to handle a pending FPU exception. An FNINIT instruction cannot be interrupted in this way on a Pentium Pro processor. In the Intel387 math coprocessor, the FINIT/FNINIT instruction does not clear the instruction and data pointers."
  916. [2]
  917. "FPUControlWord ¼ 037FH;"
  918. "FPUStatusWord ¼ 0;"
  919. "FPUTagWord ¼ FFFFH;"
  920. "FPUDataPointer ¼ 0;"
  921. "FPUInstructionPointer ¼ 0;"
  922. "FPULastInstructionOpcode ¼ 0;"
  923. [3]
  924. "FPU Flags Affected"
  925. ""
  926. "C0, C1, C2, C3 cleared to 0."
  927. [4]
  928. "Floating-Point Exceptions"
  929. ""
  930. "None."
  931. ""
  932. "Protected Mode Exceptions"
  933. ""
  934. "#NM EM or TS in CR0 is set."
  935. ""
  936. "Real-Address Mode Exceptions"
  937. ""
  938. "#NM EM or TS in CR0 is set."
  939. ""
  940. "Virtual-8086 Mode Exceptions"
  941. ""
  942. "#NM EM or TS in CR0 is set."
  943. [5]
  944. "9B DB E3 FINIT Initialize FPU after checking for pending unmasked floating-point exceptions."
  945. "DB E3 FNINIT Initialize FPU without checking for pending unmasked floating-point exceptions."
  946. [6]
  947. </FINIT>
  948. </FNINIT>
  949. <FIST>
  950. <FISTP>
  951. [1]
  952. "FIST/FISTP: Store Integer"
  953. ""
  954. "The FIST instruction converts the value in the ST(0) register to a signed integer and stores the result in the destination operand. Values can be stored in word- or short-integer format. The destination operand specifies the address where the first byte of the destination value is to be stored. The FISTP instruction performs the same operation as the FIST instruction and then pops the register stack. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. The FISTP instruction can also stores values in long-integer format."
  955. "If the source value is a non-integral value, it is rounded to an integer value, according to the rounding mode specified by the RC field of the FPU control word. If the value being stored is too large for the destination format, is an Ñ, is a NaN, or is in an unsupported format and if the invalid-arithmetic-operand exception (#IA) is unmasked, an invalid-operation exception is generated and no value is stored in the destination operand. If the invalid-operation exception is masked, the integer indefinite value is stored in the destination operand."
  956. [2]
  957. "DEST ¼ Integer(ST(0));"
  958. "IF instruction = FISTP"
  959. "THEN"
  960. "PopRegisterStack;"
  961. "FI;"
  962. [3]
  963. "FPU Flags Affected"
  964. ""
  965. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction of if the inexact exception (#P) is generated: 0 = not roundup; 1 = roundup. Cleared to 0 otherwise. C0, C2, C3 Undefined."
  966. [4]
  967. "Floating-Point Exceptions"
  968. ""
  969. "#IS Stack underflow occurred."
  970. "#IA Source operand is too large for the destination format. Source operand is a NaN value or unsupported format."
  971. "#P Value cannot be represented exactly in destination format."
  972. ""
  973. "Protected Mode Exceptions"
  974. ""
  975. "#GP(0) If the destination is located in a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  976. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  977. "#NM EM or TS in CR0 is set."
  978. "#PF(fault-code) If a page fault occurs."
  979. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  980. ""
  981. "Real-Address Mode Exceptions"
  982. ""
  983. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  984. "#SS If a memory operand effective address is outside the SS segment limit."
  985. "#NM EM or TS in CR0 is set."
  986. ""
  987. "Virtual-8086 Mode Exceptions"
  988. ""
  989. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  990. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  991. "#NM EM or TS in CR0 is set."
  992. "#PF(fault-code) If a page fault occurs."
  993. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  994. [5]
  995. "DF /2 FIST m16int Store ST(0) in m16int"
  996. "DB /2 FIST m32int Store ST(0) in m32int"
  997. "DF /3 FISTP m16int Store ST(0) in m16int and pop register stack"
  998. "DB /3 FISTP m32int Store ST(0) in m32int and pop register stack"
  999. "DF /7 FISTP m64int Store ST(0) in m64int and pop register stack"
  1000. [6]
  1001. </FIST>
  1002. </FISTP>
  1003. <FLD>
  1004. [1]
  1005. "FLD: Load Real"
  1006. ""
  1007. "Pushes the source operand onto the FPU register stack. If the source operand is in single- or double-real format, it is automatically converted to the extended-real format before being pushed on the stack. The FLD instruction can also push the value in a selected FPU register [ST(i)] onto the stack. Here, pushing register ST(0) duplicates the stack top."
  1008. [2]
  1009. "IF SRC is ST(i)"
  1010. "THEN"
  1011. "temp ¼ ST(i)"
  1012. "TOP ¼ TOP - 1;"
  1013. "IF SRC is memory-operand"
  1014. "THEN"
  1015. "ST(0) ¼ ExtendedReal(SRC);"
  1016. "ELSE (* SRC is ST(i) *)"
  1017. "ST(0) ¼ temp;"
  1018. [3]
  1019. "FPU Flags Affected"
  1020. ""
  1021. "C1 Set to 1 if stack overflow occurred; otherwise, cleared to 0. C0, C2, C3 Undefined."
  1022. [4]
  1023. "Floating-Point Exceptions"
  1024. ""
  1025. "#IS Stack overflow occurred."
  1026. "#IA Source operand is an SNaN value or unsupported format."
  1027. "#D Source operand is a denormal value. Does not occur if the source operand is in extended-real format."
  1028. ""
  1029. "Protected Mode Exceptions"
  1030. ""
  1031. "#GP(0) If destination is located in a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1032. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1033. "#NM EM or TS in CR0 is set."
  1034. "#PF(fault-code) If a page fault occurs."
  1035. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1036. ""
  1037. "Real-Address Mode Exceptions"
  1038. ""
  1039. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1040. "#SS If a memory operand effective address is outside the SS segment limit."
  1041. "#NM EM or TS in CR0 is set."
  1042. ""
  1043. "Virtual-8086 Mode Exceptions"
  1044. ""
  1045. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1046. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1047. "#NM EM or TS in CR0 is set."
  1048. "#PF(fault-code) If a page fault occurs."
  1049. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1050. [5]
  1051. "D9 /0 FLD m32real Push m32real onto the FPU register stack."
  1052. "DD /0 FLD m64real Push m64real onto the FPU register stack."
  1053. "DB /5 FLD m80real Push m80real onto the FPU register stack."
  1054. "D9 C0+i FLD ST(i) Push ST(i) onto the FPU register stack."
  1055. [6]
  1056. </FLD>
  1057. <FLD1>
  1058. <FLDL2T>
  1059. <FLDL2E>
  1060. <FLDPI>
  1061. <FLDLG2>
  1062. <FLDLN2>
  1063. <FLDZ>
  1064. [1]
  1065. "FLD1/FLDL2T/FLDL2E/FLDPI/FLDLG2/FLDLN2/FLDZ: Load Constant"
  1066. ""
  1067. "Push one of seven commonly used constants (in extended-real format) onto the FPU register stack. The constants that can be loaded with these instructions include +1.0, +0.0, log 2 10, log 2 e, p, log 10 2, and log e 2. For each constant, an internal 66-bit constant is rounded (as specified by the RC field in the FPU control word) to external-real format. The inexact-result exception (#P) is not generated as a result of the rounding."
  1068. ""
  1069. "Intel Architecture Compatibility"
  1070. ""
  1071. "When the RC field is set to round-to-nearest, the FPU produces the same constants that is produced by the Intel 8087 and Intel287 math coprocessors."
  1072. [2]
  1073. "TOP ¼ TOP - 1;"
  1074. "ST(0) ¼ CONSTANT;"
  1075. [3]
  1076. "FPU Flags Affected"
  1077. ""
  1078. "C1 Set to 1 if stack overflow occurred; otherwise, cleared to 0. C0, C2, C3 Undefined."
  1079. [4]
  1080. "Floating-Point Exceptions"
  1081. ""
  1082. "#IS Stack overflow occurred."
  1083. ""
  1084. "Protected Mode Exceptions"
  1085. ""
  1086. "#NM EM or TS in CR0 is set."
  1087. ""
  1088. "Real-Address Mode Exceptions"
  1089. ""
  1090. "#NM EM or TS in CR0 is set."
  1091. ""
  1092. "Virtual-8086 Mode Exceptions"
  1093. ""
  1094. "#NM EM or TS in CR0 is set."
  1095. [5]
  1096. "D9 E8 FLD1 Push +1.0 onto the FPU register stack."
  1097. "D9 E9 FLDL2T Push log 2 10 onto the FPU register stack."
  1098. "D9 EA FLDL2E Push log 2 e onto the FPU register stack."
  1099. "D9 EB FLDPI Push p onto the FPU register stack."
  1100. "D9 EC FLDLG2 Push log 10 2 onto the FPU register stack."
  1101. "D9 ED FLDLN2 Push log e 2 onto the FPU register stack."
  1102. "D9 EE FLDZ Push +0.0 onto the FPU register stack."
  1103. [6]
  1104. </FLD1>
  1105. </FLDL2T>
  1106. </FLDL2E>
  1107. </FLDPI>
  1108. </FLDLG2>
  1109. </FLDLN2>
  1110. </FLDZ>
  1111. <FLDCW>
  1112. [1]
  1113. "FLDCW: Load Control Word"
  1114. ""
  1115. "Loads the 16-bit source operand into the FPU control word. The source operand is a memory location. This instruction is typically used to establish or change the FPUÆs mode of operation. If one or more exception flags are set in the FPU status word prior to loading a new FPU control word and the new control word unmasks one or more of those exceptions, a floating-point exception will be generated upon execution of the next floating-point instruction (except for the no-wait floating-point instructions). To avoid raising exceptions when changing FPU operating modes, clear any pending exceptions (using the FCLEX or FNCLEX instruction) before loading the new control word."
  1116. [2]
  1117. "FPUControlWord ¼ SRC;"
  1118. [3]
  1119. "FPU Flags Affected"
  1120. ""
  1121. "C0, C1, C2, C3 undefined."
  1122. [4]
  1123. "Floating-Point Exceptions"
  1124. ""
  1125. "None; however, this operation might unmask a pending exception in the FPU status word. That exception is then generated upon execution of the next ôwaitingö floating-point instruction."
  1126. ""
  1127. "Protected Mode Exceptions"
  1128. ""
  1129. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1130. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1131. "#NM EM or TS in CR0 is set."
  1132. "#PF(fault-code) If a page fault occurs."
  1133. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1134. ""
  1135. "Real-Address Mode Exceptions"
  1136. ""
  1137. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1138. "#SS If a memory operand effective address is outside the SS segment limit."
  1139. "#NM EM or TS in CR0 is set."
  1140. ""
  1141. "Virtual-8086 Mode Exceptions"
  1142. ""
  1143. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1144. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1145. "#NM EM or TS in CR0 is set."
  1146. "#PF(fault-code) If a page fault occurs."
  1147. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1148. [5]
  1149. "D9 /5 FLDCW m2byte Load FPU control word from m2byte."
  1150. [6]
  1151. </FLDCW>
  1152. <FLDENV>
  1153. [1]
  1154. "FLDENV: Load FPU Environment"
  1155. ""
  1156. "Loads the complete FPU operating environment from memory into the FPU registers. The source operand specifies the first byte of the operating-environment data in memory. This data is typically written to the specified memory location by a FSTENV or FNSTENV instruction. The FPU operating environment consists of the FPU control word, status word, tag word, instruction pointer, data pointer, and last opcode. In virtual-8086 mode, the real mode layouts are used. The FLDENV instruction should be executed in the same operating mode as the corresponding FSTENV/FNSTENV instruction. If one or more unmasked exception flags are set in the new FPU status word, a floating-point exception will be generated upon execution of the next floating-point instruction (except for the no-wait floating-point instructions). To avoid generating exceptions when loading a new environment, clear all the exception flags in the FPU status word that is being loaded."
  1157. [2]
  1158. "FPUControlWord ¼ SRC(FPUControlWord);"
  1159. "FPUStatusWord ¼ SRC(FPUStatusWord);"
  1160. "FPUTagWord ¼ SRC(FPUTagWord);"
  1161. "FPUDataPointer ¼ SRC(FPUDataPointer);"
  1162. "FPUInstructionPointer ¼ SRC(FPUInstructionPointer);"
  1163. "FPULastInstructionOpcode ¼ SRC(FPULastInstructionOpcode);"
  1164. [3]
  1165. "FPU Flags Affected"
  1166. ""
  1167. "The C0, C1, C2, C3 flags are loaded."
  1168. [4]
  1169. "Floating-Point Exceptions"
  1170. ""
  1171. "None; however, if an unmasked exception is loaded in the status word, it is generated upon execution of the next ôwaitingö floating-point instruction."
  1172. ""
  1173. "Protected Mode Exceptions"
  1174. ""
  1175. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1176. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1177. "#NM EM or TS in CR0 is set."
  1178. "#PF(fault-code) If a page fault occurs."
  1179. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1180. ""
  1181. "Real-Address Mode Exceptions"
  1182. ""
  1183. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1184. "#SS If a memory operand effective address is outside the SS segment limit."
  1185. "#NM EM or TS in CR0 is set."
  1186. ""
  1187. "Virtual-8086 Mode Exceptions"
  1188. ""
  1189. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1190. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1191. "#NM EM or TS in CR0 is set."
  1192. "#PF(fault-code) If a page fault occurs."
  1193. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1194. [5]
  1195. "D9 /4 FLDENV m14/28byte Load FPU environment from m14byte or m28byte."
  1196. [6]
  1197. </FLDENV>
  1198. <FMUL>
  1199. <FMULP>
  1200. <FIMUL>
  1201. [1]
  1202. "FMUL/FMULP/FIMUL: Multiply"
  1203. ""
  1204. "Multiplies the destination and source operands and stores the product in the destination location. The destination operand is always an FPU data register; the source operand can be an FPU data register or a memory location. Source operands in memory can be in single-real, double-real, word-integer, or short-integer formats."
  1205. "The no-operand version of the instruction multiplies the contents of the ST(1) register by the contents of the ST(0) register and stores the product in the ST(1) register. The one-operand version multiplies the contents of the ST(0) register by the contents of a memory location (either a real or an integer value) and stores the product in the ST(0) register. The two-operand version, multiplies the contents of the ST(0) register by the contents of the ST(i) register, or vice versa, with the result being stored in the register specified with the first operand (the destination operand)."
  1206. "The FMULP instructions perform the additional operation of popping the FPU register stack after storing the product. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. The no-operand version of the floating-point multiply instructions always results in the register stack being popped. In some assemblers, the mnemonic for this instruction is FMUL rather than FMULP. The FIMUL instructions convert an integer source operand to extended-real format before performing the multiplication. The sign of the result is always the exclusive-OR of the source signs, even if one or more of the values being multiplied is 0 or Ñ. When the source operand is an integer 0, it is treated as a +0."
  1207. [2]
  1208. "IF instruction is FIMUL"
  1209. "THEN"
  1210. "DEST ¼ DEST * ConvertExtendedReal(SRC);"
  1211. "ELSE (* source operand is real number *)"
  1212. "DEST ¼ DEST * SRC;"
  1213. "FI;"
  1214. "IF instruction = FMULP"
  1215. "THEN"
  1216. "PopRegisterStack"
  1217. "FI;"
  1218. [3]
  1219. "FPU Flags Affected"
  1220. ""
  1221. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) fault is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  1222. [4]
  1223. "Floating-Point Exceptions"
  1224. ""
  1225. "#IS Stack underflow occurred."
  1226. "#IA Operand is an SNaN value or unsupported format. One operand is ▒0 and the other is ▒Ñ."
  1227. "#D Source operand is a denormal value."
  1228. "#U Result is too small for destination format."
  1229. "#O Result is too large for destination format."
  1230. "#P Value cannot be represented exactly in destination format."
  1231. ""
  1232. "Protected Mode Exceptions"
  1233. ""
  1234. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1235. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1236. "#NM EM or TS in CR0 is set."
  1237. "#PF(fault-code) If a page fault occurs."
  1238. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1239. ""
  1240. "Real-Address Mode Exceptions"
  1241. ""
  1242. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1243. "#SS If a memory operand effective address is outside the SS segment limit."
  1244. "#NM EM or TS in CR0 is set."
  1245. ""
  1246. "Virtual-8086 Mode Exceptions"
  1247. ""
  1248. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1249. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1250. "#NM EM or TS in CR0 is set."
  1251. "#PF(fault-code) If a page fault occurs."
  1252. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1253. [5]
  1254. "D8 /1 FMUL m32real Multiply ST(0) by m32real and store result in ST(0)"
  1255. "DC /1 FMUL m64real Multiply ST(0) by m64real and store result in ST(0)"
  1256. "D8 C8+i FMUL ST(0), ST(i) Multiply ST(0) by ST(i) and store result in ST(0)"
  1257. "DC C8+i FMUL ST(i), ST(0) Multiply ST(i) by ST(0) and store result in ST(i)"
  1258. "DE C8+i FMULP ST(i), ST(0) Multiply ST(i) by ST(0), store result in ST(i), and pop the register stack"
  1259. "DE C9 FMULP Multiply ST(1) by ST(0), store result in ST(1), and pop the register stack"
  1260. "DA /1 FIMUL m32int Multiply ST(0) by m32int and store result in ST(0)"
  1261. "DE /1 FIMUL m16int Multiply ST(0) by m16int and store result in ST(0)"
  1262. [6]
  1263. </FMUL>
  1264. </FMULP>
  1265. </FIMUL>
  1266. <FNOP>
  1267. [1]
  1268. "FNOP: No Operation"
  1269. ""
  1270. "Performs no FPU operation. This instruction takes up space in the instruction stream but does not affect the FPU or machine context, except the EIP register."
  1271. [2]
  1272. "No Operation"
  1273. [3]
  1274. "FPU Flags Affected"
  1275. ""
  1276. "C0, C1, C2, C3 undefined."
  1277. [4]
  1278. "Floating-Point Exceptions"
  1279. ""
  1280. "None."
  1281. ""
  1282. "Protected Mode Exceptions"
  1283. ""
  1284. "#NM EM or TS in CR0 is set."
  1285. ""
  1286. "Real-Address Mode Exceptions"
  1287. ""
  1288. "#NM EM or TS in CR0 is set."
  1289. ""
  1290. "Virtual-8086 Mode Exceptions"
  1291. ""
  1292. "#NM EM or TS in CR0 is set."
  1293. [5]
  1294. "D9 D0 FNOP No operation is performed."
  1295. [6]
  1296. </FNOP>
  1297. <FPATAN>
  1298. [1]
  1299. "FPATAN: Partial Arctangent"
  1300. ""
  1301. "Computes the arctangent of the source operand in register ST(1) divided by the source operand in register ST(0), stores the result in ST(1), and pops the FPU register stack. The result in register ST(0) has the same sign as the source operand ST(1) and a magnitude less than +p. The FPATAN instruction returns the angle between the X axis and the line from the origin to the point (X,Y), where Y (the ordinate) is ST(1) and X (the abscissa) is ST(0). The angle depends on the sign of X and Y independently, not just on the sign of the ratio Y/X. This is because a point (-X,Y) is in the second quadrant, resulting in an angle between p/2 and p, while a point (X,-Y) is in the fourth quadrant, resulting in an angle between 0 and -p/2. A point (-X,-Y) is in the third quadrant, giving an angle between -p/2 and -p. There is no restriction on the range of source operands that FPATAN can accept."
  1302. ""
  1303. "Intel Architecture Compatibility"
  1304. ""
  1305. "The source operands for this instruction are restricted for the 80287 math coprocessor to the following range: 0 ú |ST(1)| < |ST(0)| < +Ñ"
  1306. [2]
  1307. "ST(1) ¼ arctan(ST(1) / ST(0));"
  1308. "PopRegisterStack;"
  1309. [3]
  1310. "FPU Flags Affected"
  1311. ""
  1312. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  1313. [4]
  1314. "Floating-Point Exceptions"
  1315. ""
  1316. "#IS Stack underflow occurred."
  1317. "#IA Source operand is an SNaN value or unsupported format."
  1318. "#D Source operand is a denormal value."
  1319. "#U Result is too small for destination format."
  1320. "#P Value cannot be represented exactly in destination format."
  1321. ""
  1322. "Protected Mode Exceptions"
  1323. ""
  1324. "#NM EM or TS in CR0 is set."
  1325. ""
  1326. "Real-Address Mode Exceptions"
  1327. ""
  1328. "#NM EM or TS in CR0 is set."
  1329. ""
  1330. "Virtual-8086 Mode Exceptions"
  1331. ""
  1332. "#NM EM or TS in CR0 is set."
  1333. [5]
  1334. "D9 F3 FPATAN Replace ST(1) with arctan(ST(1)/ST(0)) and pop the register stack"
  1335. [6]
  1336. </FPATAN>
  1337. <FPREM>
  1338. [1]
  1339. "FPREM - Partial Remainder"
  1340. ""
  1341. "Computes the remainder obtained from dividing the value in the ST(0) register (the dividend) by the value in the ST(1) register (the divisor or modulus), and stores the result in ST(0). The remainder represents the following value: Remainder = ST(0) - (Q * ST(1))"
  1342. "Here, Q is an integer value that is obtained by truncating the real-number quotient of [ST(0) / ST(1)] toward zero. The sign of the remainder is the same as the sign of the dividend. The magnitude of the remainder is less than that of the modulus, unless a partial remainder was computed (as described below). This instruction produces an exact result; the precision (inexact) exception does not occur and the rounding control has no effect. The FPREM instruction does not compute the remainder specified in IEEE Std 754. The IEEE specified remainder can be computed with the FPREM1 instruction. The FPREM instruction is provided for compatibility with the Intel 8087 and Intel287 math coprocessors."
  1343. "The FPREM instruction gets its name ôpartial remainderö because of the way it computes the remainder. This instructions arrives at a remainder through iterative subtraction. It can, however, reduce the exponent of ST(0) by no more than 63 in one execution of the instruction. If the instruction succeeds in producing a remainder that is less than the modulus, the operation is complete and the C2 flag in the FPU status word is cleared. Otherwise, C2 is set, and the result in ST(0) is called the partial remainder. The exponent of the partial remainder will be less than the exponent of the original dividend by at least 32. Software can re-execute the instruction (using the partial remainder in ST(0) as the dividend) until C2 is cleared. (Note that while executing such a remainder-computation loop, a higher-priority interrupting routine that needs the FPU can force a context switch in-between the instructions in the loop.)"
  1344. "An important use of the FPREM instruction is to reduce the arguments of periodic functions. When reduction is complete, the instruction stores the three least-significant bits of the quotient in the C3, C1, and C0 flags of the FPU status word. This information is important in argument reduction for the tangent function (using a modulus of p/4), because it locates the original angle in the correct one of eight sectors of the unit circle."
  1345. [2]
  1346. "D ¼ exponent(ST(0)) û exponent(ST(1));"
  1347. "IF D < 64"
  1348. "THEN"
  1349. "Q ¼ Integer(TruncateTowardZero(ST(0) / ST(1)));"
  1350. "ST(0) ¼ ST(0) û (ST(1) * Q);"
  1351. "C2 ¼ 0;"
  1352. "C0, C3, C1 ¼ LeastSignificantBits(Q); (* Q2, Q1, Q0 *)"
  1353. "ELSE"
  1354. "C2 ¼ 1;"
  1355. "N ¼ an implementation-dependent number between 32 and 63;"
  1356. "QQ ¼ Integer(TruncateTowardZero((ST(0) / ST(1)) / 2 (D - N) ));"
  1357. "ST(0) ¼ ST(0) û (ST(1) * QQ * 2 (D - N) );"
  1358. "FI;"
  1359. [3]
  1360. "FPU Flags Affected"
  1361. ""
  1362. "C0 Set to bit 2 (Q2) of the quotient."
  1363. "C1 Set to 0 if stack underflow occurred; otherwise, set to least significant bit of quotient (Q0)."
  1364. "C2 Set to 0 if reduction complete; set to 1 if incomplete."
  1365. "C3 Set to bit 1 (Q1) of the quotient."
  1366. [4]
  1367. "Floating-Point Exceptions"
  1368. ""
  1369. "#IS Stack underflow occurred."
  1370. "#IA Source operand is an SNaN value, modulus is 0, dividend is Ñ, or unsupported format."
  1371. "#D Source operand is a denormal value."
  1372. "#U Result is too small for destination format."
  1373. ""
  1374. "Protected Mode Exceptions"
  1375. ""
  1376. "#NM EM or TS in CR0 is set."
  1377. ""
  1378. "Real-Address Mode Exceptions"
  1379. ""
  1380. "#NM EM or TS in CR0 is set."
  1381. ""
  1382. "Virtual-8086 Mode Exceptions"
  1383. ""
  1384. "#NM EM or TS in CR0 is set."
  1385. [5]
  1386. "D9 F8 FPREM Replace ST(0) with the remainder obtained from"
  1387. [6]
  1388. </FPREM>
  1389. <FPREM1>
  1390. [1]
  1391. "FPREM1: Partial Remainder"
  1392. ""
  1393. "Computes the IEEE remainder obtained from dividing the value in the ST(0) register (the dividend) by the value in the ST(1) register (the divisor or modulus), and stores the result in ST(0). The remainder represents the following value: Remainder = ST(0) - (Q * ST(1))"
  1394. "Here, Q is an integer value that is obtained by rounding the real-number quotient of [ST(0) / ST(1)] toward the nearest integer value. The magnitude of the remainder is less than half the magnitude of the modulus, unless a partial remainder was computed (as described below). This instruction produces an exact result; the precision (inexact) exception does not occur and the rounding control has no effect. The following table shows the results obtained when computing the remainder of various classes of numbers, assuming that underflow does not occur. The FPREM1 instruction computes the remainder specified in IEEE Std 754. This instruction operates differently from the FPREM instruction in the way that it rounds the quotient of ST(0) divided by ST(1) to an integer (see the ôOperationö section)."
  1395. "Like the FPREM instruction, the FPREM1 computes the remainder through iterative subtraction, but can reduce the exponent of ST(0) by no more than 63 in one execution of the instruction. If the instruction succeeds in producing a remainder that is less than one half the modulus, the operation is complete and the C2 flag in the FPU status word is cleared. Otherwise, C2 is set, and the result in ST(0) is called the partial remainder. The exponent of the partial remainder will be less than the exponent of the original dividend by at least 32. Software can re-execute the instruction (using the partial remainder in ST(0) as the dividend) until C2 is cleared. (Note that while executing such a remainder-computation loop, a higher-priority interrupting routine that needs the FPU can force a context switch in-between the instructions in the loop.) An important use of the FPREM1 instruction is to reduce the arguments of periodic functions. When reduction is complete, the instruction stores the three least-significant bits of the quotient in the C3, C1, and C0 flags of the FPU status word. This information is important in argument reduction for the tangent function (using a modulus of p/4), because it locates the original angle in the correct one of eight sectors of the unit circle."
  1396. [2]
  1397. "D ¼ exponent(ST(0)) û exponent(ST(1));"
  1398. "IF D < 64"
  1399. "THEN"
  1400. "Q ¼ Integer(RoundTowardNearestInteger(ST(0) / ST(1)));"
  1401. "ST(0) ¼ ST(0) û (ST(1) * Q);"
  1402. "C2 ¼ 0;"
  1403. "C0, C3, C1 ¼ LeastSignificantBits(Q); (* Q2, Q1, Q0 *)"
  1404. "ELSE"
  1405. "C2 ¼ 1;"
  1406. "N ¼ an implementation-dependent number between 32 and 63;"
  1407. "QQ ¼ Integer(TruncateTowardZero((ST(0) / ST(1)) / 2 (D - N) ));"
  1408. "ST(0) ¼ ST(0) û (ST(1) * QQ * 2 (D - N) );"
  1409. "FI;"
  1410. [3]
  1411. "FPU Flags Affected"
  1412. ""
  1413. "C0 Set to bit 2 (Q2) of the quotient."
  1414. "C1 Set to 0 if stack underflow occurred; otherwise, set to least significant bit of quotient (Q0)."
  1415. "C2 Set to 0 if reduction complete; set to 1 if incomplete."
  1416. "C3 Set to bit 1 (Q1) of the quotient."
  1417. [4]
  1418. "Floating-Point Exceptions"
  1419. ""
  1420. "#IS Stack underflow occurred."
  1421. "#IA Source operand is an SNaN value, modulus (divisor) is 0, dividend is Ñ, or unsupported format."
  1422. "#D Source operand is a denormal value."
  1423. "#U Result is too small for destination format."
  1424. ""
  1425. "Protected Mode Exceptions"
  1426. ""
  1427. "#NM EM or TS in CR0 is set."
  1428. ""
  1429. "Real-Address Mode Exceptions"
  1430. ""
  1431. "#NM EM or TS in CR0 is set."
  1432. ""
  1433. "Virtual-8086 Mode Exceptions"
  1434. ""
  1435. "#NM EM or TS in CR0 is set."
  1436. [5]
  1437. "D9 F5 FPREM1 Replace ST(0) with the IEEE remainder obtained from dividing ST(0) by ST(1)"
  1438. [6]
  1439. </FPREM1>
  1440. <FPTAN>
  1441. [1]
  1442. "FPTAN: Partial Tangent"
  1443. ""
  1444. "Computes the tangent of the source operand in register ST(0), stores the result in ST(0), and pushes a 1.0 onto the FPU register stack. The source operand must be given in radians and must be less than ▒2^63 . If the source operand is outside the acceptable range, the C2 flag in the FPU status word is set, and the value in register ST(0) remains unchanged. The instruction does not raise an exception when the source operand is out of range. It is up to the program to check the C2 flag for out-of-range conditions. Source values outside the range -2^63 to +2^63 can be reduced to the range of the instruction by subtracting an appropriate integer multiple of 2p or by using the FPREM instruction with a divisor of 2p. The value 1.0 is pushed onto the register stack after the tangent has been computed to maintain compatibility with the Intel 8087 and Intel287 math coprocessors. This operation also simplifies the calculation of other trigonometric functions. For instance, the cotangent (which is the reciprocal of the tangent) can be computed by executing a FDIVR instruction after the FPTAN instruction."
  1445. [2]
  1446. "IF ST(0) < 2 63"
  1447. "THEN"
  1448. "C2 ¼ 0;"
  1449. "ST(0) ¼ tan(ST(0));"
  1450. "TOP ¼ TOP - 1;"
  1451. "ST(0) ¼ 1.0;"
  1452. "ELSE (*source operand is out-of-range *)"
  1453. "C2 ¼ 1;"
  1454. "FI;"
  1455. [3]
  1456. "FPU Flags Affected"
  1457. ""
  1458. "C1 Set to 0 if stack underflow occurred; set to 1 if stack overflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C2 Set to 1 if source operand is outside the range -2^63 to +2^63 ; otherwise, cleared to 0. C0, C3 Undefined."
  1459. [4]
  1460. "Floating-Point Exceptions"
  1461. ""
  1462. "#IS Stack underflow occurred."
  1463. "#IA Source operand is an SNaN value, Ñ, or unsupported format."
  1464. "#D Source operand is a denormal value."
  1465. "#U Result is too small for destination format."
  1466. "#P Value cannot be represented exactly in destination format."
  1467. ""
  1468. "Protected Mode Exceptions"
  1469. ""
  1470. "#NM EM or TS in CR0 is set."
  1471. ""
  1472. "Real-Address Mode Exceptions"
  1473. ""
  1474. "#NM EM or TS in CR0 is set."
  1475. ""
  1476. "Virtual-8086 Mode Exceptions"
  1477. ""
  1478. "#NM EM or TS in CR0 is set."
  1479. [5]
  1480. "D9 F2 FPTAN 17-173 Replace ST(0) with its tangent and push 1 onto the FPU stack."
  1481. [6]
  1482. </FPTAN>
  1483. <FRNDINT>
  1484. [1]
  1485. "FRNDINT: Round to Integer"
  1486. ""
  1487. "Rounds the source value in the ST(0) register to the nearest integral value, depending on the current rounding mode (setting of the RC field of the FPU control word), and stores the result in ST(0). If the source value is Ñ, the value is not changed. If the source value is not an integral value, the floating-point inexact-result exception (#P) is generated."
  1488. [2]
  1489. "ST(0) ¼ RoundToIntegralValue(ST(0));"
  1490. [3]
  1491. "FPU Flags Affected"
  1492. ""
  1493. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  1494. [4]
  1495. "Floating-Point Exceptions"
  1496. ""
  1497. "#IS Stack underflow occurred."
  1498. "#IA Source operand is an SNaN value or unsupported format."
  1499. "#D Source operand is a denormal value."
  1500. "#P Source operand is not an integral value."
  1501. ""
  1502. "Protected Mode Exceptions"
  1503. ""
  1504. "#NM EM or TS in CR0 is set."
  1505. ""
  1506. "Real-Address Mode Exceptions"
  1507. ""
  1508. "#NM EM or TS in CR0 is set."
  1509. ""
  1510. "Virtual-8086 Mode Exceptions"
  1511. ""
  1512. "#NM EM or TS in CR0 is set."
  1513. [5]
  1514. "D9 FC FRNDINT Round ST(0) to an integer."
  1515. [6]
  1516. </FRNDINT>
  1517. <FRSTOR>
  1518. [1]
  1519. "FRSTOR: Restore FPU State"
  1520. ""
  1521. "Loads the FPU state (operating environment and register stack) from the memory area specified with the source operand. This state data is typically written to the specified memory location by a previous FSAVE/FNSAVE instruction. The FPU operating environment consists of the FPU control word, status word, tag word, instruction pointer, data pointer, and last opcode. In virtual-8086 mode, the real mode layouts are used. The contents of the FPU register stack are stored in the 80 bytes immediately follow the operating environment image."
  1522. "The FRSTOR instruction should be executed in the same operating mode as the corresponding FSAVE/FNSAVE instruction. If one or more unmasked exception bits are set in the new FPU status word, a floating-point exception will be generated. To avoid raising exceptions when loading a new operating environment, clear all the exception flags in the FPU status word that is being loaded."
  1523. [2]
  1524. "FPUControlWord ¼ SRC(FPUControlWord);"
  1525. "FPUStatusWord ¼ SRC(FPUStatusWord);"
  1526. "FPUTagWord ¼ SRC(FPUTagWord);"
  1527. "FPUDataPointer ¼ SRC(FPUDataPointer);"
  1528. "FPUInstructionPointer ¼ SRC(FPUInstructionPointer);"
  1529. "FPULastInstructionOpcode ¼ SRC(FPULastInstructionOpcode);"
  1530. "ST(0) ¼ SRC(ST(0));"
  1531. "ST(1) ¼ SRC(ST(1));"
  1532. "ST(2) ¼ SRC(ST(2));"
  1533. "ST(3) ¼ SRC(ST(3));"
  1534. "ST(4) ¼ SRC(ST(4));"
  1535. "ST(5) ¼ SRC(ST(5));"
  1536. "ST(6) ¼ SRC(ST(6));"
  1537. "ST(7) ¼ SRC(ST(7));"
  1538. [3]
  1539. "FPU Flags Affected"
  1540. ""
  1541. "The C0, C1, C2, C3 flags are loaded."
  1542. [4]
  1543. "Floating-Point Exceptions"
  1544. ""
  1545. "None; however, this operation might unmask an existing exception that has been detected but not generated, because it was masked. Here, the exception is generated at the completion of the instruction."
  1546. ""
  1547. "Protected Mode Exceptions"
  1548. ""
  1549. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1550. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1551. "#NM EM or TS in CR0 is set."
  1552. "#PF(fault-code) If a page fault occurs."
  1553. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1554. ""
  1555. "Real-Address Mode Exceptions"
  1556. ""
  1557. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1558. "#SS If a memory operand effective address is outside the SS segment limit."
  1559. "#NM EM or TS in CR0 is set."
  1560. ""
  1561. "Virtual-8086 Mode Exceptions"
  1562. ""
  1563. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1564. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1565. "#NM EM or TS in CR0 is set."
  1566. "#PF(fault-code) If a page fault occurs."
  1567. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1568. [5]
  1569. "DD /4 FRSTOR m94/108byte Load FPU state from m94byte or m108byte."
  1570. [6]
  1571. </FRSTOR>
  1572. <FSAVE>
  1573. <FNSAVE>
  1574. [1]
  1575. "FSAVE/FNSAVE: Store FPU State"
  1576. ""
  1577. "Stores the current FPU state (operating environment and register stack) at the specified destination in memory, and then re-initializes the FPU. The FSAVE instruction checks for and handles pending unmasked floating-point exceptions before storing the FPU state; the FNSAVE instruction does not."
  1578. "The FPU operating environment consists of the FPU control word, status word, tag word, instruction pointer, data pointer, and last opcode. In virtual-8086 mode, the real mode layouts are used. The contents of the FPU register stack are stored in the 80 bytes immediately follow the operating environment image. The saved image reflects the state of the FPU after all floating-point instructions preceding the FSAVE/FNSAVE instruction in the instruction stream have been executed. After the FPU state has been saved, the FPU is reset to the same default values it is set to with the FINIT/FNINIT instructions. The FSAVE/FNSAVE instructions are typically used when the operating system needs to perform a context switch, an exception handler needs to use the FPU, or an application program needs to pass a ôcleanö FPU to a procedure."
  1579. ""
  1580. "Intel Architecture Compatibility"
  1581. ""
  1582. "For Intel math coprocessors and FPUs prior to the Intel Pentium processor, an FWAIT instruction should be executed before attempting to read from the memory image stored with a prior FSAVE/FNSAVE instruction. This FWAIT instruction helps insure that the storage operation has been completed."
  1583. "When operating a Pentium or Intel486 processor in MS-DOS compatibility mode, it is possible (under unusual circumstances) for an FNSAVE instruction to be interrupted prior to being executed to handle a pending FPU exception. An FNSAVE instruction cannot be interrupted in this way on a Pentium Pro processor."
  1584. [2]
  1585. "(* Save FPU State and Registers *)"
  1586. "DEST(FPUControlWord) ¼ FPUControlWord;"
  1587. "DEST(FPUStatusWord) ¼ FPUStatusWord;"
  1588. "DEST(FPUTagWord) ¼ FPUTagWord;"
  1589. "DEST(FPUDataPointer) ¼ FPUDataPointer;"
  1590. "DEST(FPUInstructionPointer) ¼ FPUInstructionPointer;"
  1591. "DEST(FPULastInstructionOpcode) ¼ FPULastInstructionOpcode;"
  1592. "DEST(ST(0)) ¼ ST(0);"
  1593. "DEST(ST(1)) ¼ ST(1);"
  1594. "DEST(ST(2)) ¼ ST(2);"
  1595. "DEST(ST(3)) ¼ ST(3);"
  1596. "DEST(ST(4)) ¼ ST(4);"
  1597. "DEST(ST(5)) ¼ ST(5);"
  1598. "DEST(ST(6)) ¼ ST(6);"
  1599. "DEST(ST(7)) ¼ ST(7);"
  1600. "(* Initialize FPU *)"
  1601. "FPUControlWord ¼ 037FH;"
  1602. "FPUStatusWord ¼ 0;"
  1603. "FPUTagWord ¼ FFFFH;"
  1604. "FPUDataPointer ¼ 0;"
  1605. "FPUInstructionPointer ¼ 0;"
  1606. "FPULastInstructionOpcode ¼ 0;"
  1607. [3]
  1608. "FPU Flags Affected"
  1609. ""
  1610. "The C0, C1, C2, and C3 flags are saved and then cleared."
  1611. [4]
  1612. "Floating-Point Exceptions"
  1613. ""
  1614. "None."
  1615. ""
  1616. "Protected Mode Exceptions"
  1617. ""
  1618. "#GP(0) If destination is located in a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1619. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1620. "#NM EM or TS in CR0 is set."
  1621. "#PF(fault-code) If a page fault occurs."
  1622. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1623. ""
  1624. "Real-Address Mode Exceptions"
  1625. ""
  1626. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1627. "#SS If a memory operand effective address is outside the SS segment limit."
  1628. "#NM EM or TS in CR0 is set."
  1629. ""
  1630. "Virtual-8086 Mode Exceptions"
  1631. ""
  1632. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1633. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1634. "#NM EM or TS in CR0 is set."
  1635. "#PF(fault-code) If a page fault occurs."
  1636. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1637. [5]
  1638. "9B DD /6 FSAVE m94/108byte Store FPU state to m94byte or m108byte after checking for pending unmasked floating-point exceptions. Then re-initialize the FPU."
  1639. "DD /6 FNSAVE* m94/108byte Store FPU environment to m94byte or m108byte without checking for pending unmasked floating-point exceptions. Then re-initialize the FPU."
  1640. [6]
  1641. </FSAVE>
  1642. </FNSAVE>
  1643. <FSCALE>
  1644. [1]
  1645. "FSCALE: Scale"
  1646. ""
  1647. "Multiplies the destination operand by 2 to the power of the source operand and stores the result in the destination operand. The destination operand is a real value that is located in register ST(0). The source operand is the nearest integer value that is smaller than the value in the ST(1) register (that is, the value in register ST(1) is truncated toward 0 to its nearest integer value to form the source operand). This instruction provides rapid multiplication or division by integral powers of 2 because it is implemented by simply adding an integer value (the source operand) to the exponent of the value in register ST(0)."
  1648. "In most cases, only the exponent is changed and the mantissa (significand) remains unchanged. However, when the value being scaled in ST(0) is a denormal value, the mantissa is also changed and the result may turn out to be a normalized number. Similarly, if overflow or underflow results from a scale operation, the resulting mantissa will differ from the sourceÆs mantissa. The FSCALE instruction can also be used to reverse the action of the FXTRACT instruction, as shown in the following example:"
  1649. "FXTRACT;"
  1650. "FSCALE;"
  1651. "FSTP ST(1);"
  1652. "In this example, the FXTRACT instruction extracts the significand and exponent from the value in ST(0) and stores them in ST(0) and ST(1) respectively. The FSCALE then scales the significand in ST(0) by the exponent in ST(1), recreating the original value before the FXTRACT operation was performed. The FSTP ST(1) instruction overwrites the exponent (extracted by the FXTRACT instruction) with the recreated value, which returns the stack to its original state with only one register [ST(0)] occupied."
  1653. [2]
  1654. "ST(0) ¼ ST(0) * 2 ST(1) ;"
  1655. [3]
  1656. "FPU Flags Affected"
  1657. ""
  1658. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  1659. [4]
  1660. "Floating-Point Exceptions"
  1661. ""
  1662. "#IS Stack underflow occurred."
  1663. "#IA Source operand is an SNaN value or unsupported format."
  1664. "#D Source operand is a denormal value."
  1665. "#U Result is too small for destination format."
  1666. "#O Result is too large for destination format."
  1667. "#P Value cannot be represented exactly in destination format."
  1668. ""
  1669. "Protected Mode Exceptions"
  1670. ""
  1671. "#NM EM or TS in CR0 is set."
  1672. ""
  1673. "Real-Address Mode Exceptions"
  1674. ""
  1675. "#NM EM or TS in CR0 is set."
  1676. ""
  1677. "Virtual-8086 Mode Exceptions"
  1678. ""
  1679. "#NM EM or TS in CR0 is set."
  1680. [5]
  1681. "D9 FD FSCALE Scale ST(0) by ST(1)."
  1682. [6]
  1683. </FSCALE>
  1684. <FSIN>
  1685. [1]
  1686. "FSIN: Sine"
  1687. ""
  1688. "Calculates the sine of the source operand in register ST(0) and stores the result in ST(0). The source operand must be given in radians and must be within the range -2^63 to +2^63. If the source operand is outside the acceptable range, the C2 flag in the FPU status word is set, and the value in register ST(0) remains unchanged. The instruction does not raise an exception when the source operand is out of range. It is up to the program to check the C2 flag for out-of-range conditions. Source values outside the range -2^63 to +2^63 can be reduced to the range of the instruction by subtracting an appropriate integer multiple of 2p or by using the FPREM instruction with a divisor of 2p."
  1689. [2]
  1690. "IF ST(0) < 2 63"
  1691. "THEN"
  1692. "C2 ¼ 0;"
  1693. "ST(0) ¼ sin(ST(0));"
  1694. "ELSE (* source operand out of range *)"
  1695. "C2 ¼ 1;"
  1696. "FI:"
  1697. [3]
  1698. "FPU Flags Affected"
  1699. ""
  1700. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C2 Set to 1 if source operand is outside the range -2^63 to +2^63; otherwise, cleared to 0. C0, C3 Undefined."
  1701. [4]
  1702. "Floating-Point Exceptions"
  1703. ""
  1704. "#IS Stack underflow occurred."
  1705. "#IA Source operand is an SNaN value, Ñ, or unsupported format."
  1706. "#D Source operand is a denormal value."
  1707. "#P Value cannot be represented exactly in destination format."
  1708. ""
  1709. "Protected Mode Exceptions"
  1710. ""
  1711. "#NM EM or TS in CR0 is set."
  1712. ""
  1713. "Real-Address Mode Exceptions"
  1714. ""
  1715. "#NM EM or TS in CR0 is set."
  1716. ""
  1717. "Virtual-8086 Mode Exceptions"
  1718. ""
  1719. "#NM EM or TS in CR0 is set."
  1720. [5]
  1721. "D9 FE FSIN Replace ST(0) with its sine."
  1722. [6]
  1723. </FSIN>
  1724. <FSINCOS>
  1725. [1]
  1726. "FSINCOS: Sine and Cosine"
  1727. ""
  1728. "Computes both the sine and the cosine of the source operand in register ST(0), stores the sine in ST(0), and pushes the cosine onto the top of the FPU register stack. (This instruction is faster than executing the FSIN and FCOS instructions in succession.) The source operand must be given in radians and must be within the range -2^63 to +2^63."
  1729. "If the source operand is outside the acceptable range, the C2 flag in the FPU status word is set, and the value in register ST(0) remains unchanged. The instruction does not raise an exception when the source operand is out of range. It is up to the program to check the C2 flag for out-of-range conditions. Source values outside the range -2^63 to +2^63 can be reduced to the range of the instruction by subtracting an appropriate integer multiple of 2p or by using the FPREM instruction with a divisor of 2p."
  1730. [2]
  1731. "IF ST(0) < 2 63"
  1732. "THEN"
  1733. "C2 ¼ 0;"
  1734. "TEMP ¼ cosine(ST(0));"
  1735. "ST(0) ¼ sine(ST(0));"
  1736. "TOP ¼ TOP - 1;"
  1737. "ST(0) ¼ TEMP;"
  1738. "ELSE (* source operand out of range *)"
  1739. "C2 ¼ 1;"
  1740. "FI:"
  1741. [3]
  1742. "FPU Flags Affected"
  1743. ""
  1744. "C1 Set to 0 if stack underflow occurred; set to 1 of stack overflow occurs. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C2 Set to 1 if source operand is outside the range -2^63 to +2^63; otherwise, cleared to 0. C0, C3 Undefined."
  1745. [4]
  1746. "Floating-Point Exceptions"
  1747. ""
  1748. "#IS Stack underflow occurred."
  1749. "#IA Source operand is an SNaN value, Ñ, or unsupported format."
  1750. "#D Source operand is a denormal value."
  1751. "#U Result is too small for destination format."
  1752. "#P Value cannot be represented exactly in destination format."
  1753. ""
  1754. "Protected Mode Exceptions"
  1755. ""
  1756. "#NM EM or TS in CR0 is set."
  1757. ""
  1758. "Real-Address Mode Exceptions"
  1759. ""
  1760. "#NM EM or TS in CR0 is set."
  1761. ""
  1762. "Virtual-8086 Mode Exceptions"
  1763. ""
  1764. "#NM EM or TS in CR0 is set."
  1765. [5]
  1766. "D9 FB FSINCOS Compute the sine and cosine of ST(0); replace ST(0) with the sine, and push the cosine onto the register stack."
  1767. [6]
  1768. </FSINCOS>
  1769. <FSQRT>
  1770. [1]
  1771. "FSQRT: Square Root"
  1772. ""
  1773. "Calculates the square root of the source value in the ST(0) register and stores the result in ST(0)."
  1774. [2]
  1775. "ST(0) ¼ SquareRoot(ST(0));"
  1776. [3]
  1777. "FPU Flags Affected"
  1778. ""
  1779. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  1780. [4]
  1781. "Floating-Point Exceptions"
  1782. ""
  1783. "#IS Stack underflow occurred."
  1784. "#IA Source operand is an SNaN value or unsupported format. Source operand is a negative value (except for -0)."
  1785. "#D Source operand is a denormal value."
  1786. "#P Value cannot be represented exactly in destination format."
  1787. ""
  1788. "Protected Mode Exceptions"
  1789. ""
  1790. "#NM EM or TS in CR0 is set."
  1791. ""
  1792. "Real-Address Mode Exceptions"
  1793. ""
  1794. "#NM EM or TS in CR0 is set."
  1795. ""
  1796. "Virtual-8086 Mode Exceptions"
  1797. ""
  1798. "#NM EM or TS in CR0 is set."
  1799. [5]
  1800. "D9 FA FSQRT Calculates square root of ST(0) and stores the result in ST(0)"
  1801. [6]
  1802. </FSQRT>
  1803. <FST>
  1804. <FSTP>
  1805. [1]
  1806. "FST/FSTP: Store Real"
  1807. ""
  1808. "The FST instruction copies the value in the ST(0) register to the destination operand, which can be a memory location or another register in the FPU register stack. When storing the value in memory, the value is converted to single- or double-real format. The FSTP instruction performs the same operation as the FST instruction and then pops the register stack. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. The FSTP instruction can also store values in memory in extended-real format."
  1809. "If the destination operand is a memory location, the operand specifies the address where the first byte of the destination value is to be stored. If the destination operand is a register, the operand specifies a register in the register stack relative to the top of the stack. If the destination size is single- or double-real, the significand of the value being stored is rounded to the width of the destination (according to rounding mode specified by the RC field of the FPU control word), and the exponent is converted to the width and bias of the destination format. If the value being stored is too large for the destination format, a numeric overflow exception (#O) is generated and, if the exception is unmasked, no value is stored  in the destination operand. If the value being stored is a denormal value, the denormal exception (#D) is not generated. This condition is simply signaled as a numeric underflow exception (#U) condition. If the value being stored is ▒0, ▒Ñ, or a NaN, the least-significant bits of the significand and the exponent are truncated to fit the destination format. This operation preserves the valueÆs identity as a 0, Ñ, or NaN. If the destination operand is a non-empty register, the invalid-operation exception is not generated."
  1810. [2]
  1811. "DEST ¼ ST(0);"
  1812. "IF instruction = FSTP"
  1813. "THEN"
  1814. "PopRegisterStack;"
  1815. "FI;"
  1816. [3]
  1817. "FPU Flags Affected"
  1818. ""
  1819. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction of if the floating-point inexact exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  1820. [4]
  1821. "Floating-Point Exceptions"
  1822. ""
  1823. "#IS Stack underflow occurred."
  1824. "#IA Source operand is an SNaN value or unsupported format."
  1825. "#U Result is too small for the destination format."
  1826. "#O Result is too large for the destination format."
  1827. "#P Value cannot be represented exactly in destination format."
  1828. ""
  1829. "Protected Mode Exceptions"
  1830. ""
  1831. "#GP(0) If the destination is located in a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1832. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1833. "#NM EM or TS in CR0 is set."
  1834. "#PF(fault-code) If a page fault occurs."
  1835. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1836. ""
  1837. "Real-Address Mode Exceptions"
  1838. ""
  1839. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1840. "#SS If a memory operand effective address is outside the SS segment limit."
  1841. "#NM EM or TS in CR0 is set."
  1842. ""
  1843. "Virtual-8086 Mode Exceptions"
  1844. ""
  1845. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1846. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1847. "#NM EM or TS in CR0 is set."
  1848. "#PF(fault-code) If a page fault occurs."
  1849. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1850. [5]
  1851. "D9 /2 FST m32real Copy ST(0) to m32real"
  1852. "DD /2 FST m64real Copy ST(0) to m64real"
  1853. "DD D0+i FST ST(i) Copy ST(0) to ST(i)"
  1854. "D9 /3 FSTP m32real Copy ST(0) to m32real and pop register stack"
  1855. "DD /3 FSTP m64real Copy ST(0) to m64real and pop register stack"
  1856. "DB /7 FSTP m80real Copy ST(0) to m80real and pop register stack"
  1857. "DD D8+i FSTP ST(i) Copy ST(0) to ST(i) and pop register stack"
  1858. [6]
  1859. </FST>
  1860. </FSTP>
  1861. <FSTCW>
  1862. <FNSTCW>
  1863. [1]
  1864. "FSTCW/FNSTCW: Store Control Word"
  1865. ""
  1866. "Stores the current value of the FPU control word at the specified destination in memory. The FSTCW instruction checks for and handles pending unmasked floating-point exceptions before storing the control word; the FNSTCW instruction does not."
  1867. ""
  1868. "Intel Architecture Compatibility"
  1869. ""
  1870. "When operating a Pentium or Intel486 processor in MS-DOS compatibility mode, it is possible (under unusual circumstances) for an FNSTCW instruction to be interrupted prior to being executed to handle a pending FPU exception. An FNSTCW instruction cannot be interrupted in this way on a Pentium Pro processor."
  1871. [2]
  1872. "DEST ¼ FPUControlWord;"
  1873. [3]
  1874. "FPU Flags Affected"
  1875. ""
  1876. "The C0, C1, C2, and C3 flags are undefined."
  1877. [4]
  1878. "Floating-Point Exceptions"
  1879. ""
  1880. "None."
  1881. ""
  1882. "Protected Mode Exceptions"
  1883. ""
  1884. "#GP(0) If the destination is located in a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1885. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1886. "#NM EM or TS in CR0 is set."
  1887. "#PF(fault-code) If a page fault occurs."
  1888. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1889. ""
  1890. "Real-Address Mode Exceptions"
  1891. ""
  1892. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1893. "#SS If a memory operand effective address is outside the SS segment limit."
  1894. "#NM EM or TS in CR0 is set."
  1895. ""
  1896. "Virtual-8086 Mode Exceptions"
  1897. ""
  1898. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1899. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1900. "#NM EM or TS in CR0 is set."
  1901. "#PF(fault-code) If a page fault occurs."
  1902. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1903. [5]
  1904. "9B D9 /7 FSTCW m2byte Store FPU control word to m2byte after checking for pending unmasked floating-point exceptions."
  1905. "D9 /7 FNSTCW m2byte Store FPU control word to m2byte without checking for pending unmasked floating-point exceptions."
  1906. [6]
  1907. </FSTCW>
  1908. </FNSTCW>
  1909. <FSTENV>
  1910. <FNSTENV>
  1911. [1]
  1912. "FSTENV/FNSTENV: Store FPU Environment"
  1913. ""
  1914. "Saves the current FPU operating environment at the memory location specified with the destination operand, and then masks all floating-point exceptions. The FPU operating environment consists of the FPU control word, status word, tag word, instruction pointer, data pointer, and last opcode. In virtual-8086 mode, the real mode layouts are used. The FSTENV instruction checks for and handles any pending unmasked floating-point exceptions before storing the FPU environment; the FNSTENV instruction does not.The saved image reflects the state of the FPU after all floating-point instructions preceding the FSTENV/FNSTENV instruction in the instruction stream have been executed."
  1915. "These instructions are often used by exception handlers because they provide access to the FPU instruction and data pointers. The environment is typically saved in the stack. Masking all exceptions after saving the environment prevents floating-point exceptions from interrupting the exception handler."
  1916. ""
  1917. "Intel Architecture Compatibility"
  1918. ""
  1919. "When operating a Pentium or Intel486 processor in MS-DOS compatibility mode, it is possible (under unusual circumstances) for an FNSTENV instruction to be interrupted prior to being executed to handle a pending FPU exception. An FNSTENV instruction cannot be interrupted in this way on a Pentium Pro processor."
  1920. [2]
  1921. "DEST(FPUControlWord) ¼ FPUControlWord;"
  1922. "DEST(FPUStatusWord) ¼ FPUStatusWord;"
  1923. "DEST(FPUTagWord) ¼ FPUTagWord;"
  1924. "DEST(FPUDataPointer) ¼ FPUDataPointer;"
  1925. "DEST(FPUInstructionPointer) ¼ FPUInstructionPointer;"
  1926. "DEST(FPULastInstructionOpcode) ¼ FPULastInstructionOpcode;"
  1927. [3]
  1928. "FPU Flags Affected"
  1929. ""
  1930. "The C0, C1, C2, and C3 are undefined."
  1931. [4]
  1932. "Floating-Point Exceptions"
  1933. ""
  1934. "None."
  1935. ""
  1936. "Protected Mode Exceptions"
  1937. ""
  1938. "#GP(0) If the destination is located in a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1939. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1940. "#NM EM or TS in CR0 is set."
  1941. "#PF(fault-code) If a page fault occurs."
  1942. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1943. ""
  1944. "Real-Address Mode Exceptions"
  1945. ""
  1946. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1947. "#SS If a memory operand effective address is outside the SS segment limit."
  1948. "#NM EM or TS in CR0 is set."
  1949. ""
  1950. "Virtual-8086 Mode Exceptions"
  1951. ""
  1952. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1953. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1954. "#NM EM or TS in CR0 is set."
  1955. "#PF(fault-code) If a page fault occurs."
  1956. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  1957. [5]
  1958. "9B D9 /6 FSTENV m14/28byte Store FPU environment to m14byte or m28byte after checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions."
  1959. "D9 /6 FNSTENV m14/28byte Store FPU environment to m14byte or m28byte without checking for pending unmasked floating-point exceptions. Then mask all floating-point exceptions."
  1960. [6]
  1961. </FSTENV>
  1962. </FNSTENV>
  1963. <FSTSW>
  1964. <FNSTSW>
  1965. [1]
  1966. "FSTSW/FNSTSW: Store Status Word"
  1967. ""
  1968. "Stores the current value of the FPU status word in the destination location. The destination operand can be either a two-byte memory location or the AX register. The FSTSW instruction checks for and handles pending unmasked floating-point exceptions before storing the status word; the FNSTSW instruction does not. The FNSTSW AX form of the instruction is used primarily in conditional branching (for instance, after an FPU comparison instruction or an FPREM, FPREM1, or FXAM instruction), where the direction of the branch depends on the state of the FPU condition code flags. This instruction can also be used to invoke exception handlers (by examining the exception flags) in environments that do not use interrupts. When the FNSTSW AX instruction is executed, the AX register is updated before the  processor executes any further instructions. The status stored in the AX register is thus guaranteed to be from the completion of the prior FPU instruction."
  1969. ""
  1970. "Intel Architecture Compatibility"
  1971. ""
  1972. "When operating a Pentium or Intel486 processor in MS-DOS compatibility mode, it is possible (under unusual circumstances) for an FNSTSW instruction to be interrupted prior to being executed to handle a pending FPU exception. An FNSTSW instruction cannot be interrupted in this way on a Pentium Pro processor."
  1973. [2]
  1974. "DEST ¼ FPUStatusWord;"
  1975. [3]
  1976. "FPU Flags Affected"
  1977. ""
  1978. "The C0, C1, C2, and C3 are undefined."
  1979. [4]
  1980. "Floating-Point Exceptions"
  1981. ""
  1982. "None."
  1983. ""
  1984. "Protected Mode Exceptions"
  1985. ""
  1986. "#GP(0) If the destination is located in a nonwritable segment. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  1987. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  1988. "#NM EM or TS in CR0 is set."
  1989. "#PF(fault-code) If a page fault occurs."
  1990. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  1991. ""
  1992. "Real-Address Mode Exceptions"
  1993. ""
  1994. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  1995. "#SS If a memory operand effective address is outside the SS segment limit."
  1996. "#NM EM or TS in CR0 is set."
  1997. ""
  1998. "Virtual-8086 Mode Exceptions"
  1999. ""
  2000. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  2001. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  2002. "#NM EM or TS in CR0 is set."
  2003. "#PF(fault-code) If a page fault occurs."
  2004. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  2005. [5]
  2006. "9B DD /7 FSTSW m2byte Store FPU status word at m2byte after checking for pending unmasked floating-point exceptions."
  2007. "9B DF E0 FSTSW AX Store FPU status word in AX register after checking for pending unmasked floating-point exceptions."
  2008. "DD /7 FNSTSW m2byte Store FPU status word at m2byte without checking for pending unmasked floating-point exceptions."
  2009. "DF E0 FNSTSW AX Store FPU status word in AX register without checking for pending unmasked floating-point exceptions."
  2010. [6]
  2011. </FSTSW>
  2012. </FNSTSW>
  2013. <FSUB>
  2014. <FSUBP>
  2015. <FISUB>
  2016. [1]
  2017. "FSUB/FSUBP/FISUB: Subtract"
  2018. ""
  2019. "Subtracts the source operand from the destination operand and stores the difference in the destination location. The destination operand is always an FPU data register; the source operand can be a register or a memory location. Source operands in memory can be in single-real, double-real, word-integer, or short-integer formats. The no-operand version of the instruction subtracts the contents of the ST(0) register from the ST(1) register and stores the result in ST(1). The one-operand version subtracts the contents of a memory location (either a real or an integer value) from the contents of the ST(0) register and stores the result in ST(0). The two-operand version, subtracts the contents of the ST(0) register from the ST(i) register or vice versa."
  2020. "The FSUBP instructions perform the additional operation of popping the FPU register stack following the subtraction. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. The no-operand version of the floating-point subtract instructions always results in the register stack being popped. In some assemblers, the mnemonic for this instruction is FSUB rather than FSUBP. The FISUB instructions convert an integer source operand to extended-real format before performing the subtraction."
  2021. "When the difference between two operands of like sign is 0, the result is +0, except for the round toward -Ñ mode, in which case the result is -0. This instruction also guarantees that +0 - (-0) = +0, and that -0 - (+0) = -0. When the source operand is an integer 0, it is treated as a +0. When one operand is Ñ, the result is Ñ of the expected sign. If both operands are Ñ of the same sign, an invalid-operation exception is generated."
  2022. [2]
  2023. "IF instruction is FISUB"
  2024. "THEN"
  2025. "DEST ¼ DEST - ConvertExtendedReal(SRC);"
  2026. "ELSE (* source operand is real number *)"
  2027. "DEST ¼ DEST - SRC;"
  2028. "FI;"
  2029. "IF instruction is FSUBP"
  2030. "THEN"
  2031. "PopRegisterStack"
  2032. "FI;"
  2033. [3]
  2034. "FPU Flags Affected"
  2035. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) fault is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  2036. [4]
  2037. "Floating-Point Exceptions"
  2038. ""
  2039. "#IS Stack underflow occurred."
  2040. "#IA Operand is an SNaN value or unsupported format. Operands are infinities of like sign."
  2041. "#D Source operand is a denormal value."
  2042. "#U Result is too small for destination format."
  2043. "#O Result is too large for destination format."
  2044. "#P Value cannot be represented exactly in destination format."
  2045. ""
  2046. "Protected Mode Exceptions"
  2047. ""
  2048. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  2049. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  2050. "#NM EM or TS in CR0 is set."
  2051. "#PF(fault-code) If a page fault occurs."
  2052. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  2053. ""
  2054. "Real-Address Mode Exceptions"
  2055. ""
  2056. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  2057. "#SS If a memory operand effective address is outside the SS segment limit."
  2058. "#NM EM or TS in CR0 is set."
  2059. ""
  2060. "Virtual-8086 Mode Exceptions"
  2061. ""
  2062. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  2063. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  2064. "#NM EM or TS in CR0 is set."
  2065. "#PF(fault-code) If a page fault occurs."
  2066. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  2067. [5]
  2068. "D8 /4 FSUB m32real Subtract m32real from ST(0) and store result in ST(0)"
  2069. "DC /4 FSUB m64real Subtract m64real from ST(0) and store result in ST(0)"
  2070. "D8 E0+i FSUB ST(0), ST(i) Subtract ST(i) from ST(0) and store result in ST(0)"
  2071. "DC E8+i FSUB ST(i), ST(0) Subtract ST(0) from ST(i) and store result in ST(i)"
  2072. "DE E8+i FSUBP ST(i), ST(0) Subtract ST(0) from ST(i), store result in ST(i), and pop register stack"
  2073. "DE E9 FSUBP Subtract ST(0) from ST(1), store result in ST(1), and pop register stack"
  2074. "DA /4 FISUB m32int Subtract m32int from ST(0) and store result in ST(0)"
  2075. "DE /4 FISUB m16int Subtract m16int from ST(0) and store result in ST(0)"
  2076. [6]
  2077. </FSUB>
  2078. </FSUBP>
  2079. </FISUB>
  2080. <FSUBR>
  2081. <FSUBRP>
  2082. <FISUBR>
  2083. [1]
  2084. "FSUBR/FSUBRP/FISUBR: Reverse Subtract"
  2085. ""
  2086. "Subtracts the destination operand from the source operand and stores the difference in the destination location. The destination operand is always an FPU register; the source operand can be a register or a memory location. Source operands in memory can be in single-real, double-real, word-integer, or short-integer formats. These instructions perform the reverse operations of the FSUB, FSUBP, and FISUB instructions. They are provided to support more efficient coding. The no-operand version of the instruction subtracts the contents of the ST(1) register from the ST(0) register and stores the result in ST(1). The one-operand version subtracts the contents of the ST(0) register from the contents of a memory location (either a real or an integer value) and stores the result in ST(0). The two-operand version, subtracts the contents of the ST(i) register from the ST(0) register or vice versa."
  2087. "The FSUBRP instructions perform the additional operation of popping the FPU register stack following the subtraction. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1. The no-operand version of the floating-point reverse subtract instructions always results in the register stack being popped. In some assemblers, the mnemonic for this instruction is FSUBR rather than FSUBRP. The FISUBR instructions convert an integer source operand to extended-real format before performing the subtraction."
  2088. "When the difference between two operands of like sign is 0, the result is +0, except for the round toward -Ñ mode, in which case the result is -0. This instruction also guarantees that +0 - (-0) = +0, and that -0 - (+0) = -0. When the source operand is an integer 0, it is treated as a +0. When one operand is Ñ, the result is Ñ of the expected sign. If both operands are Ñ of the same sign, an invalid-operation exception is generated."
  2089. [2]
  2090. "IF instruction is FISUBR"
  2091. "THEN"
  2092. "DEST ¼ ConvertExtendedReal(SRC) - DEST;"
  2093. "ELSE (* source operand is real number *)"
  2094. "DEST ¼ SRC - DEST;"
  2095. "FI;"
  2096. "IF instruction = FSUBRP"
  2097. "THEN"
  2098. "PopRegisterStack"
  2099. "FI;"
  2100. [3]
  2101. "FPU Flags Affected"
  2102. ""
  2103. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) fault is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  2104. [4]
  2105. "Floating-Point Exceptions"
  2106. ""
  2107. "#IS Stack underflow occurred."
  2108. "#IA Operand is an SNaN value or unsupported format. Operands are infinities of like sign."
  2109. "#D Source operand is a denormal value."
  2110. "#U Result is too small for destination format."
  2111. "#O Result is too large for destination format."
  2112. "#P Value cannot be represented exactly in destination format."
  2113. ""
  2114. "Protected Mode Exceptions"
  2115. ""
  2116. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a null segment selector."
  2117. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  2118. "#NM EM or TS in CR0 is set."
  2119. "#PF(fault-code) If a page fault occurs."
  2120. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3."
  2121. ""
  2122. "Real-Address Mode Exceptions"
  2123. ""
  2124. "#GP If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  2125. "#SS If a memory operand effective address is outside the SS segment limit."
  2126. "#NM EM or TS in CR0 is set."
  2127. ""
  2128. "Virtual-8086 Mode Exceptions"
  2129. ""
  2130. "#GP(0) If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit."
  2131. "#SS(0) If a memory operand effective address is outside the SS segment limit."
  2132. "#NM EM or TS in CR0 is set."
  2133. "#PF(fault-code) If a page fault occurs."
  2134. "#AC(0) If alignment checking is enabled and an unaligned memory reference is made."
  2135. [5]
  2136. "D8 /5 FSUBR m32real Subtract ST(0) from m32real and store result in ST(0)"
  2137. "DC /5 FSUBR m64real Subtract ST(0) from m64real and store result in ST(0)"
  2138. "D8 E8+i FSUBR ST(0), ST(i) Subtract ST(0) from ST(i) and store result in ST(0)"
  2139. "DC E0+i FSUBR ST(i), ST(0) Subtract ST(i) from ST(0) and store result in ST(i)"
  2140. "DE E0+i FSUBRP ST(i), ST(0) Subtract ST(i) from ST(0), store result in ST(i), and pop register stack"
  2141. "DE E1 FSUBRP Subtract ST(1) from ST(0), store result in ST(1), and pop register stack"
  2142. "DA /5 FISUBR m32int Subtract ST(0) from m32int and store result in ST(0)"
  2143. "DE /5 FISUBR m16int Subtract ST(0) from m16int and store result in ST(0)"
  2144. [6]
  2145. </FSUBR>
  2146. </FSUBRP>
  2147. </FISUBR>
  2148. <FTST>
  2149. [1]
  2150. "FTST: TEST"
  2151. ""
  2152. "Compares the value in the ST(0) register with 0.0 and sets the condition code flags C0, C2, and C3 in the FPU status word according to the results. This instruction performs an ôunordered comparison.ö An unordered comparison also checks the class of the numbers being compared. If the value in register ST(0) is a NaN or is in an undefined format, the condition flags are set to ôunorderedö and the invalid operation exception is generated. The sign of zero is ignored, so that û0.0 = +0.0."
  2153. [2]
  2154. "CASE (relation of operands) OF"
  2155. "Not comparable: C3, C2, C0 ¼ 111;"
  2156. "ST(0) > 0.0: C3, C2, C0 ¼ 000;"
  2157. "ST(0) < 0.0: C3, C2, C0 ¼ 001;"
  2158. "ST(0) = 0.0: C3, C2, C0 ¼ 100;"
  2159. "ESAC;"
  2160. [3]
  2161. "FPU Flags Affected"
  2162. ""
  2163. "C1 Set to 0 if stack underflow occurred; otherwise, cleared to 0. C0, C2, C3 according to tables."
  2164. [4]
  2165. "Floating-Point Exceptions"
  2166. ""
  2167. "#IS Stack underflow occurred."
  2168. "#IA The source operand is a NaN value or is in an unsupported format."
  2169. "#D The source operand is a denormal value."
  2170. ""
  2171. "Protected Mode Exceptions"
  2172. ""
  2173. "#NM EM or TS in CR0 is set."
  2174. ""
  2175. "Real-Address Mode Exceptions"
  2176. ""
  2177. "#NM EM or TS in CR0 is set."
  2178. ""
  2179. "Virtual-8086 Mode Exceptions"
  2180. ""
  2181. "#NM EM or TS in CR0 is set."
  2182. [5]
  2183. "D9 E4 FTST Compare ST(0) with 0.0."
  2184. [6]
  2185. </FTST>
  2186. <FUCOM>
  2187. <FUCOMP>
  2188. <FUCOMPP>
  2189. [1]
  2190. "FUCOM/FUCOMP/FUCOMPP: Unordered Compare Real"
  2191. ""
  2192. "Performs an unordered comparison of the contents of register ST(0) and ST(i) and sets condition code flags C0, C2, and C3 in the FPU status word according to the results. If no operand is specified, the contents of registers ST(0) and ST(1) are compared. The sign of zero is ignored, so that û0.0 = +0.0."
  2193. "An unordered comparison checks the class of the numbers being compared. The FUCOM instructions perform the same operations as the FCOM instructions. The only difference is that the FUCOM instructions raise the invalid-arithmetic-operand exception (#IA) only when either or both operands are an SNaN or are in an unsupported format; QNaNs cause the condition code flags to be set to unordered, but do not cause an exception to be generated. The FCOM instructions raise an invalid-operation exception when either or both of the operands are a NaN value of any kind or are in an unsupported format. As with the FCOM instructions, if the operation results in an invalid-arithmetic-operand exception being raised, the condition code flags are set only if the exception is masked. The FUCOMP instruction pops the register stack following the comparison operation and the FUCOMPP instruction pops the register stack twice following the comparison operation. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1."
  2194. [2]
  2195. "CASE (relation of operands) OF"
  2196. "ST > SRC: C3, C2, C0 ¼ 000;"
  2197. "ST < SRC: C3, C2, C0 ¼ 001;"
  2198. "ST = SRC: C3, C2, C0 ¼ 100;"
  2199. "ESAC;"
  2200. "IF ST(0) or SRC = QNaN, but not SNaN or unsupported format"
  2201. "THEN"
  2202. "C3, C2, C0 ¼ 111;"
  2203. "ELSE (* ST(0) or SRC is SNaN or unsupported format *)"
  2204. "#IA;"
  2205. "IF FPUControlWord.IM = 1"
  2206. "THEN"
  2207. "C3, C2, C0 ¼ 111;"
  2208. "FI;"
  2209. "FI;"
  2210. "IF instruction = FUCOMP"
  2211. "THEN"
  2212. "PopRegisterStack;"
  2213. "FI;"
  2214. "IF instruction = FUCOMPP"
  2215. "THEN"
  2216. "PopRegisterStack;"
  2217. "PopRegisterStack;"
  2218. "FI;"
  2219. [3]
  2220. "FPU Flags Affected"
  2221. ""
  2222. "C1 Set to 0 if stack underflow occurred. C0, C2, C3 according to table."
  2223. [4]
  2224. "Floating-Point Exceptions"
  2225. ""
  2226. "#IS Stack underflow occurred."
  2227. "#IA One or both operands are SNaN values or have unsupported formats. Detection of a QNaN value in and of itself does not raise an invalid-operand exception."
  2228. "#D One or both operands are denormal values."
  2229. ""
  2230. "Protected Mode Exceptions"
  2231. ""
  2232. "#NM EM or TS in CR0 is set."
  2233. ""
  2234. "Real-Address Mode Exceptions"
  2235. ""
  2236. "#NM EM or TS in CR0 is set."
  2237. ""
  2238. "Virtual-8086 Mode Exceptions"
  2239. ""
  2240. "#NM EM or TS in CR0 is set."
  2241. [5]
  2242. "DD E0+i FUCOM ST(i) Compare ST(0) with ST(i)"
  2243. "DD E1 FUCOM Compare ST(0) with ST(1)"
  2244. "DD E8+i FUCOMP ST(i) Compare ST(0) with ST(i) and pop register stack"
  2245. "DD E9 FUCOMP Compare ST(0) with ST(1) and pop register stack"
  2246. "DA E9 FUCOMPP Compare ST(0) with ST(1) and pop register stack twice"
  2247. [6]
  2248. </FUCOM>
  2249. </FUCOMP>
  2250. </FUCOMPP>
  2251. <FWAIT>
  2252. [1]
  2253. "FWAIT: Wait"
  2254. ""
  2255. "Causes the processor to check for and handle pending, unmasked, floating-point exceptions before proceeding. (FWAIT is an alternate mnemonic for the WAIT). This instruction is useful for synchronizing exceptions in critical sections of code. Coding a WAIT instruction after a floating-point instruction insures that any unmasked floating-point exceptions the instruction may raise are handled before the processor can modify the instruction's results."
  2256. [2]
  2257. "CheckForPendingUnmaskedFloatingPointExceptions;"
  2258. [3]
  2259. "The C0, C1, C2, and C3 flags are undefined."
  2260. [4]
  2261. "Floating-Point Exceptions"
  2262. ""
  2263. "None."
  2264. ""
  2265. "Protected Mode Exceptions"
  2266. ""
  2267. "#NM MP and TS in CR0 is set."
  2268. ""
  2269. "Real-Address Mode Exceptions"
  2270. ""
  2271. "#NM MP and TS in CR0 is set."
  2272. ""
  2273. "Virtual-8086 Mode Exceptions"
  2274. ""
  2275. "#NM MP and TS in CR0 is set."
  2276. [5]
  2277. "9B FWAIT Check pending unmasked floating-point exceptions."
  2278. [6]
  2279. </FWAIT>
  2280. </FXAM>
  2281. [1]
  2282. "FXAM: Examine"
  2283. ""
  2284. "Examines the contents of the ST(0) register and sets the condition code flags C0, C2, and C3 in the FPU status word to indicate the class of value or number in the register. The C1 flag is set to the sign of the value in ST(0), regardless of whether the register is empty or full."
  2285. [2]
  2286. "C1 ¼ sign bit of ST; (* 0 for positive, 1 for negative *)"
  2287. "CASE (class of value or number in ST(0)) OF"
  2288. "Unsupported:C3, C2, C0 ¼ 000;"
  2289. "NaN: C3, C2, C0 ¼ 001;"
  2290. "Normal: C3, C2, C0 ¼ 010;"
  2291. "Infinity: C3, C2, C0 ¼ 011;"
  2292. "Zero: C3, C2, C0 ¼ 100;"
  2293. "Empty: C3, C2, C0 ¼ 101;"
  2294. "Denormal: C3, C2, C0 ¼ 110;"
  2295. "ESAC;"
  2296. [3]
  2297. "FPU Flags Affected"
  2298. ""
  2299. "C1 Sign of value in ST(0). C0, C2, C3 according to table."
  2300. [4]
  2301. "Floating-Point Exceptions"
  2302. ""
  2303. "None."
  2304. ""
  2305. "Protected Mode Exceptions"
  2306. ""
  2307. "#NM EM or TS in CR0 is set."
  2308. ""
  2309. "Real-Address Mode Exceptions"
  2310. ""
  2311. "#NM EM or TS in CR0 is set."
  2312. ""
  2313. "Virtual-8086 Mode Exceptions"
  2314. ""
  2315. "#NM EM or TS in CR0 is set."
  2316. [5]
  2317. "D9 E5 FXAM Classify value or number in ST(0)"
  2318. [6]
  2319. </FXAM>
  2320. <FXCH>
  2321. [1]
  2322. "FXCH: Exchange Register Contents"
  2323. ""
  2324. "Exchanges the contents of registers ST(0) and ST(i). If no source operand is specified, the contents of ST(0) and ST(1) are exchanged. This instruction provides a simple means of moving values in the FPU register stack to the top of the stack [ST(0)], so that they can be operated on by those floating-point instructions that can only operate on values in ST(0). For example, the following instruction sequence takes the square root of the third register from the top of the register stack:"
  2325. "FXCH ST(3);"
  2326. "FSQRT;"
  2327. "FXCH ST(3);"
  2328. [2]
  2329. "IF number-of-operands is 1"
  2330. "THEN"
  2331. "temp ¼ ST(0);"
  2332. "ST(0) ¼ SRC;"
  2333. "SRC ¼ temp;"
  2334. "ELSE"
  2335. "temp ¼ ST(0);"
  2336. "ST(0) ¼ ST(1);"
  2337. "ST(1) ¼ temp;"
  2338. [3]
  2339. "FPU Flags Affected"
  2340. ""
  2341. "C1 Set to 0 if stack underflow occurred; otherwise, cleared to 0. C0, C2, C3 Undefined."
  2342. [4]
  2343. "Floating-Point Exceptions"
  2344. ""
  2345. "#IS Stack underflow occurred."
  2346. ""
  2347. "Protected Mode Exceptions"
  2348. ""
  2349. "#NM EM or TS in CR0 is set."
  2350. ""
  2351. "Real-Address Mode Exceptions"
  2352. ""
  2353. "#NM EM or TS in CR0 is set."
  2354. ""
  2355. "Virtual-8086 Mode Exceptions"
  2356. ""
  2357. "#NM EM or TS in CR0 is set."
  2358. [5]
  2359. "D9 C8+i FXCH ST(i) Exchange the contents of ST(0) and ST(i)"
  2360. "D9 C9 FXCH Exchange the contents of ST(0) and ST(1)"
  2361. [6]
  2362. </FXCH>
  2363. <FXTRACT>
  2364. [1]
  2365. "FXTRACT: Extract Exponent and Significand"
  2366. ""
  2367. "Separates the source value in the ST(0) register into its exponent and significand, stores the exponent in ST(0), and pushes the significand onto the register stack. Following this operation, the new top-of-stack register ST(0) contains the value of the original significand expressed as a real number. The sign and significand of this value are the same as those found in the source operand, and the exponent is 3FFFH (biased value for a true exponent of zero). The ST(1) register contains the value of the original operandÆs true (unbiased) exponent expressed as a real number. (The operation performed by this instruction is a superset of the IEEE-recommended logb(x) function.)"
  2368. "This instruction and the F2XM1 instruction are useful for performing power and range scaling operations. The FXTRACT instruction is also useful for converting numbers in extended-real format to decimal representations (e.g., for printing or displaying). If the floating-point zero-divide exception (#Z) is masked and the source operand is zero, an exponent value of ûÑ is stored in register ST(1) and 0 with the sign of the source operand is stored in register ST(0)."
  2369. [2]
  2370. "TEMP ¼ Significand(ST(0));"
  2371. "ST(0) ¼ Exponent(ST(0));"
  2372. "TOP¼ TOP - 1;"
  2373. "ST(0) ¼ TEMP;"
  2374. [3]
  2375. "FPU Flags Affected"
  2376. ""
  2377. "C1 Set to 0 if stack underflow occurred; set to 1 if stack overflow occurred. C0, C2, C3 Undefined."
  2378. [4]
  2379. "Floating-Point Exceptions"
  2380. ""
  2381. "#IS Stack underflow occurred. Stack overflow occurred."
  2382. "#IA Source operand is an SNaN value or unsupported format."
  2383. "#Z ST(0) operand is ▒0."
  2384. "#D Source operand is a denormal value."
  2385. ""
  2386. "Protected Mode Exceptions"
  2387. ""
  2388. "#NM EM or TS in CR0 is set."
  2389. ""
  2390. "Real-Address Mode Exceptions"
  2391. ""
  2392. "#NM EM or TS in CR0 is set."
  2393. ""
  2394. "Virtual-8086 Mode Exceptions"
  2395. ""
  2396. "#NM EM or TS in CR0 is set."
  2397. [5]
  2398. "D9 F4 FXTRACT Separate value in ST(0) into exponent and significand, store exponent in ST(0), and push the significand onto the register stack."
  2399. [6]
  2400. </FXTRACT>
  2401. <FYL2X>
  2402. [1]
  2403. "FYL2X: Compute y * log{2}x (Base of logarithm = 2)"
  2404. ""
  2405. "Calculates (ST(1) * log{2}(ST(0))), stores the result in resister ST(1), and pops the FPU register stack. The source operand in ST(0) must be a non-zero positive number. The FYL2X instruction is designed with a built-in multiplication to optimize the calculation of logarithms with an arbitrary positive base (b):"
  2406. "log{b}x = (log{2}b) û1 * log{2}x"
  2407. [2]
  2408. "ST(1) ¼ ST(1) * log{2}ST(0);"
  2409. "PopRegisterStack;"
  2410. [3]
  2411. "FPU Flags Affected"
  2412. ""
  2413. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  2414. [4]
  2415. "Floating-Point Exceptions"
  2416. ""
  2417. "#IS Stack underflow occurred."
  2418. "#IA Either operand is an SNaN or unsupported format. Source operand in register ST(0) is a negative finite value (not -0)."
  2419. "#Z Source operand in register ST(0) is ▒0."
  2420. "#D Source operand is a denormal value."
  2421. "#U Result is too small for destination format."
  2422. "#O Result is too large for destination format."
  2423. "#P Value cannot be represented exactly in destination format."
  2424. ""
  2425. "Protected Mode Exceptions"
  2426. ""
  2427. "#NM EM or TS in CR0 is set."
  2428. ""
  2429. "Real-Address Mode Exceptions"
  2430. ""
  2431. "#NM EM or TS in CR0 is set."
  2432. ""
  2433. "Virtual-8086 Mode Exceptions"
  2434. ""
  2435. "#NM EM or TS in CR0 is set."
  2436. [5]
  2437. "D9 F1 FYL2X Replace ST(1) with (ST(1) * log{2}ST(0)) and pop the register stack"
  2438. [6]
  2439. </FYL2X>
  2440. <FYL2XP1>
  2441. [1]
  2442. "FYL2XP1: Compute y * log{2}(x +1)"
  2443. ""
  2444. "Calculates the log epsilon (ST(1) * log{2}(ST(0) + 1.0)), stores the result in register ST(1), and pops the FPU register stack. The source operand in ST(0) must be in the range: The source operand in ST(1) can range from -Ñ to +Ñ. If the ST(0) operand is outside of its acceptable range, the result is undefined and software should not rely on an exception being generated. Under some circumstances exceptions may be generated when ST(0) is out of range, but this behavior is implementation specific and not guaranteed."
  2445. "This instruction provides optimal accuracy for values of epsilon [the value in register ST(0)] that are close to 0. When the epsilon value (e) is small, more significant digits can be retained by using the FYL2XP1 instruction than by using (e+1) as an argument to the FYL2X instruction. The (e+1) expression is commonly found in compound interest and annuity calculations. The result can be simply converted into a value in another logarithm base by including a scale factor in the ST(1) source operand. The following equation is used to calculate the scale factor for a particular logarithm base, where n is the logarithm base desired for the result of the FYL2XP1 instruction:"
  2446. "scale factor = log{n}2"
  2447. [2]
  2448. "ST(1) ¼ ST(1) * log{2}(ST(0) + 1.0);"
  2449. "PopRegisterStack;"
  2450. [3]
  2451. "FPU Flags Affected"
  2452. ""
  2453. "C1 Set to 0 if stack underflow occurred. Indicates rounding direction if the inexact-result exception (#P) is generated: 0 = not roundup; 1 = roundup. C0, C2, C3 Undefined."
  2454. [4]
  2455. "Floating-Point Exceptions"
  2456. ""
  2457. "#IS Stack underflow occurred."
  2458. "#IA Either operand is an SNaN value or unsupported format."
  2459. "#D Source operand is a denormal value."
  2460. "#U Result is too small for destination format."
  2461. "#O Result is too large for destination format."
  2462. "#P Value cannot be represented exactly in destination format."
  2463. ""
  2464. "Protected Mode Exceptions"
  2465. ""
  2466. "#NM EM or TS in CR0 is set."
  2467. ""
  2468. "Real-Address Mode Exceptions"
  2469. ""
  2470. "#NM EM or TS in CR0 is set."
  2471. ""
  2472. "Virtual-8086 Mode Exceptions"
  2473. ""
  2474. "#NM EM or TS in CR0 is set."
  2475. [5]
  2476. "D9 F9 FYL2XP1 Replace ST(1) with ST(1) * log{2}(ST(0) + 1.0) and pop the register stack"
  2477. [6]
  2478. </FYL2XP1>
  2479. <FS:>
  2480. [1]
  2481. "Internal disassembler's symbol which indicates that the next command is used with the FS: segment."
  2482. [2]
  2483. "═/┴"
  2484. [3]
  2485. "═/┴"
  2486. [4]
  2487. "═/┴"
  2488. [5]
  2489. "N/A"
  2490. [6]
  2491. </FS:>