home *** CD-ROM | disk | FTP | other *** search
/ The Unsorted BBS Collection / thegreatunsorted.tar / thegreatunsorted / programming / asm_programming / a07.doc < prev    next >
Text File  |  1994-01-23  |  21KB  |  478 lines
  1. CHAPTER 7   THE FLOATING-POINT PROCESSOR
  2.  
  3.  
  4. In this chapter, we'll refer to the various Central Processing
  5. Units (CPUs) as the "86".  Thus "86" refers to either the 8088,
  6. 8086, 80186, 80286, etc.  We'll refer to the various coprocessors
  7. as the "87".  Thus "87" refers to either the 8087, the 287, the
  8. 387, or the special IIT-2C87 processor.
  9.  
  10.  
  11. The 8087 and 287 Coprocessors
  12.  
  13. All IBM-PC's, and most clones, contain a socket for a floating
  14. point coprocessor.  If you shell out between $70 and $200, and
  15. plug the appropriate chip into that socket, then a host of
  16. floating point instructions is added to the assembly language
  17. instruction set.  The 486 DX series has the floating-point
  18. processor built into the main CPU chip.
  19.  
  20. The original IBM-PC, and the XT, accept the original floating
  21. point chip, the 8087.  Later processors accept corresponding
  22. chips: the 287 for the 286, the 387 for the 386, etc.  From a
  23. programming standpoint, the 8087 and 287 are nearly identical:
  24. the 287 adds the instructions FSETPM and FSTSW AX, and ignores
  25. the instructions FENI and FDISI.  There is, however, a rather
  26. nasty design flaw in the 8087, that was corrected in the 287.
  27.  
  28. To understand the flaw, you must understand how the 86 and 87
  29. work as coprocessors. Whenever the 86 sees a floating point
  30. instruction, it communicates the instruction, and any associated
  31. memory operands, to the 87.  Then the 86 goes on to its next
  32. instruction, operating in parallel with the 87.  That's OK, so
  33. long as the following instructions don't do one of the following:
  34.  
  35.   1. Execute another floating point instruction; or
  36.  
  37.   2. Try to read the results of the still-executing floating
  38.      point instruction.
  39.  
  40. If they do, then you must provide an instruction called WAIT (or
  41. synonymously FWAIT), which halts the 86 until the 87 is finished.
  42. For almost all floating point instructions, it should not be
  43. necessary to provide an explicit FWAIT; the 86 ought to know that
  44. it should wait.  For the 8087, it IS necessary to give an
  45. explicit FWAIT before each floating point instruction: that is
  46. the flaw.
  47.  
  48. Because of the flaw, all assemblers supporting the 8087 will
  49. silently insert an FWAIT code (hex 9B) before all 87
  50. instructions, except those few (the FN instructions other than
  51. FNOP) not requiring the FWAIT.  A86 will insert the opcode as
  52. well, when it is assembling for the original 8087.
  53.                                                               7-2
  54.  
  55. The are three ways to tell A86 whether it is assembling for an
  56. 8087 or a 287-or-later processor.  First, A86 will use a default
  57. for the processor on which it is currently assembling: no .287
  58. for an 8086, 8088, 186, or NEC; .287 for a 286 or later.  Second,
  59. this can be overridden by the switch +F (the F must be
  60. capitalized), to signal that the 287 is the target processor, or
  61. -F to specify the 8087.  Third, an 8087 setting can be further
  62. overridden in the source code, with the directive ".287",
  63. compatible with Microsoft's assembler.
  64.  
  65. When A86 is assembling for the 287 or later, it ceases outputting
  66. FWAIT directives that are unnecessary for the 287, ignores the
  67. instructions FENI, FDISI, FNENI, and FNDISI, and honors the
  68. instructions FSETPM and FSTSW AX.
  69.  
  70. WARNING: The most common mistake 87 programmers make is to try to
  71. read the results of an 87 operation in 86 memory, before the
  72. results are ready.  At least on my computer, the system often
  73. crashes when you do this!  If your program runs correctly when
  74. single stepped, but crashes when set loose, then chances are you
  75. need an extra explicit FWAIT somewhere.
  76.  
  77.  
  78. Extra Coprocessor Support
  79.  
  80. A86 now supports two additional coprocessors available for
  81. PC-compatibles: the 80387, available for 386-based machines, and
  82. the IIT-2C87, a 287-plug-compatible chip that adds a couple of
  83. unique instructions. The IIT-2C87 has two extra banks of on-chip
  84. 8-number stacks, that can be switched in with the FBANK
  85. instruction, and a matrix multiply instrction that uses all three
  86. banks as input.  (For details contact Specialty Software
  87. Development Corp., 110 Wild Basin Road, Austin TX 78746.) Both
  88. chips incorporate the correction to the 8087's FWAIT design flaw,
  89. so you can assemble with the .287 directive.  The extra
  90. instructions for these chips are marked by "387 only:" and "IIT
  91. only:" in the chart at the end of this chapter.
  92.  
  93.  
  94. Emulating the 8087 by Software
  95.  
  96. There is a software package provided with many compilers
  97. (Borland's Turbo C and most Microsoft compilers, for example)
  98. that emulates the 8087 instruction set.  The emulator is very
  99. cleverly implemented so that the programmer need not know whether
  100. a floating point chip will be available, or whether emulation
  101. will be necessary.  This is done by having the linker replace all
  102. floating point machine instructions with INT calls to certain
  103. interrupts, dedicated to emulation.  The interrupt handlers
  104. interpret the operands to the instructions, and emulate the 8087.
  105.                                                               7-3
  106.  
  107. You can tell A86 that the emulator might be used, by providing a
  108. +f switch in the invocation line, or in the A86 environment
  109. variable (make sure the f is lower case).  Since your program
  110. will be linked to the emulator, you must be producing an OBJ
  111. file, not a COM file, for emulation support to take effect.
  112. Whenever a floating point instruction is assembled, A86 will
  113. generate an external reference at the opcode for the instruction.
  114. Then, if the emulation package is linked with your program, the
  115. opcodes will be replaced by the INT calls. If a special
  116. non-emulation module is linked, the opcodes will be left alone,
  117. and the floating point instructions will be executed directly.
  118.  
  119. For the later processors (286 and beyond), emulation can be
  120. provided that executes when the floating-point instructions
  121. themselves are seen, so the +f games are not necessary.
  122.  
  123.  
  124. The Floating Point Stack
  125.  
  126. The 87 has its own register set, of 8 floating point numbers
  127. occupying 10 bytes each, plus 14 bytes of status and control
  128. information.  Many of the 87's instructions cause the numbers to
  129. act like a stack, much like a Hewlett-Packard calculator.  For
  130. this reason, the numbers are called the floating point stack.
  131.  
  132. The standard name for the top element of the floating point stack
  133. is either ST or ST(0); the others are named ST(1) through ST(7).
  134. Thus, for example, the instruction to add stack element number 3
  135. into the top stack element is usually coded FADD ST,ST(3).
  136.  
  137. I find this notation painfully verbose.  Especially bad are the
  138. parentheses, which are hard to type, and which add visual clutter
  139. to the program.  To alleviate this problem while retaining
  140. language compatibility, I name my stack elements simply 0 through
  141. 7.  I recognize ST as a synonym for 0.  I allow expression
  142. elements to be concatenated; concatenation is the same as
  143. addition.  Thus, when A86 sees ST(3), it computes 0+3 = 3.  So
  144. you can code the old way, FADD ST,ST(3), or you can code the
  145. concise way, FADD 0,3 or simply FADD 3.
  146.  
  147.  
  148. Floating Point Initializations
  149.  
  150. In general, you use the 87 by loading numbers from 86 memory to
  151. the 87 stack (using FLD instructions), calculating on the 87
  152. stack, and storing the results back to 86 memory (using FST and
  153. FSTP instructions).  There are seven constant numbers built into
  154. the 87 instruction set: zero, one, Pi, and four logarithmic
  155. conversion constants.  These can be loaded using the FLD0, FLD1,
  156. FLDPI, FLDL2T, FLDL2E, FLDLG2, and FLDLN2 instructions.  All
  157. other constants must be declared in, then loaded from, 86 memory.
  158. Integer constant words and doublewords can be loaded via FILD.
  159. Non-integer constant doubleword, quadwords, and ten-byte numbers
  160. can be loaded via FLD.
  161.                                                               7-4
  162.  
  163. A86 allows you to declare constants loaded via FLD as floating
  164. point numbers, using scientific notation if you like.  As an
  165. exclusive feature, A86 allows you to use any of the 4 arithmetic
  166. functions +, -, *, / in expressions involving floating point
  167. numbers.  A86 will even do type conversion if one of the two
  168. operands is given as an integer; though for clarity I recommend
  169. that you always give floating point constants with their decimal
  170. point.
  171.  
  172.  
  173. Built-In Constant Names
  174.  
  175. A86 offers another exclusive feature: the built-in symbols
  176.  
  177.     PI   ratio of circumference to diameter of a circle
  178.  
  179.     L2T  log base 2 of 10
  180.  
  181.     L2E  log base 2 of the calculus constant e = 2.71828...
  182.  
  183.     LG2  log base 10 of 2
  184.  
  185.     LN2  natural log (base e) of 2
  186.  
  187. You can use these symbols in expressions, to declare useful
  188. constants.  For example, you can declare the degrees-to-radians
  189. conversion constant:
  190.  
  191.     DEG_TO_RAD  DT  PI/180.
  192.  
  193.  
  194.  
  195. Special Immediate FLD Form
  196.  
  197. Yet another exclusive A86 feature is the instruction form FLD
  198. constant.  This form is intended primarily to facilitate "fooling
  199. around" with the 87 when using D86; but it is also useful for
  200. quick-and-dirty programs.  For example, the instruction FLD 12.3
  201. generates the following sequence of code bytes (without
  202. explicitly using the local labels given):
  203.  
  204.     CS FLD T[M1]
  205.     JMP >M2
  206.   M1  DT 12.3
  207.   M2:
  208.  
  209. Obviously, this form is not terrifically efficient: you can
  210. always save the JMP by placing the constant outside of the
  211. instruction stream; and the CS override might not be needed.  But
  212. the form is very, very convenient!
  213.  
  214. NOTE that the preceding 2 sections imply that you can get
  215. careless and code, for example, FLD PI when you intended FLDPI.
  216. Though the two are functionally equivalent, the first form takes
  217. a whopping 17 bytes; and second, only 2 bytes.  Be careful!
  218.                                                               7-5
  219.  
  220. Floating Point Operand Types
  221.  
  222. The list of floating point instructions contains a variety of
  223. operand types.  Here is a brief explanation of those types:
  224.  
  225. 0        stands for the top element of the floating point stack.
  226.          A synonym for 0 is ST or ST(0).
  227.  
  228. i        stands for element number i of the floating point stack.
  229.          i can range from 0 through 7.  A synonym for i is ST(i).
  230.  
  231. mem10r   is a 10-byte memory quantity (typically declared with a
  232.          DT directive) containing a full precision floating point
  233.          number. Intel recommends that you NOT store your numbers
  234.          in full precision; that you use the following double
  235.          precision format instead.  Full precision numbers are
  236.          intended for storage of intermediate results (on the
  237.          stack); they exist to insure maximum accuracy for
  238.          calculations on double precision numbers, which is the
  239.          official external format of 87 numbers.
  240.  
  241. mem8r    is an 8-byte memory quantity (typically declared with a
  242.          DQ directive) containing a double precision floating
  243.          point number.  This is the best format for floating
  244.          point numbers on the 87.  The 87 takes the same amount
  245.          of time on double precision calculations as it does on
  246.          single precision.  The only extra time is the memory
  247.          access of 4 more bytes; negligible in comparison to the
  248.          calculation time.
  249.  
  250. mem4r    is a 4-byte quantity (typically defined with a DD
  251.          directive) containing a single precision floating point
  252.          number.
  253.  
  254. mem10d   is a 10-byte quantity (also defined via DT) containing a
  255.          special Binary Coded Decimal format recognized by the
  256.          FBLD and FBSTP instructions.  This format is useful for
  257.          input and output of floating point numbers.
  258.  
  259. mem4i    is a 4-byte quantity representing a signed integer in
  260.          two's-complement notation.
  261.  
  262. mem2i    is a 2-byte quantity representing a signed integer in
  263.          two's-complement notation.
  264.  
  265. mem14    and mem94 are 14- and 94-byte buffers containing the 87
  266.          machine state.
  267.                                                               7-6
  268.  
  269. Operand Choices in A86
  270.  
  271. In the "standard" assembly language, the choice of operands for
  272. floating point instructions seems inconsistent to me.  For
  273. example, to subtract stack i from 0, you must provide two
  274. operands; to do the equivalent comparison, you must provide only
  275. one operand.  A86 smooths out these inconsistencies by allowing
  276. more choices for operands: FADD i is equivalent to FADD 0,i. FCOM
  277. 0,i is equivalent to FCOM i.  The same holds for the other main
  278. arithmetic instructions.  FXCH 0,i and FXCH i,0 are allowed. So
  279. if you wish to retain compatibility with other assemblers, you
  280. should use their more restrictive instruction list, not the
  281. following one.
  282.  
  283.  
  284. The 87 Instruction Set
  285.  
  286. Following is the 87 instruction set.  The "w" in the opcode field
  287. is the FWAIT opcode, hex 9B, which is suppressed if .287 is
  288. selected.  Again, "0", "1", and "i" stand for the associated
  289. floating point stack registers, not constant numbers!  Constant
  290. numbers in the descriptions are given with decimal points: 0.0,
  291. 1.0, 2.0, 10.0.
  292.  
  293.  
  294.  
  295.     Opcode    Instruction     Description
  296.  
  297.  w  D9 F0     F2XM1           0 := (2.0 ** 0) - 1.0
  298.  w  DB F1     F4X4            IIT only: 4 by 4 matrix multiply
  299.  w  D9 E1     FABS            0 := |0|
  300.  w  DE C1     FADD            1 := 1 + 0, pop
  301.  w  D8 C0+i   FADD i          0 := i + 0
  302.  w  DC C0+i   FADD i,0        i := i + 0
  303.  w  D8 C0+i   FADD 0,i        0 := i + 0
  304.  w  D8 /0     FADD mem4r      0 := 0 + mem4r
  305.  w  DC /0     FADD mem8r      0 := 0 + mem8r
  306.  w  DE C0+i   FADDP i,0       i := i + 0, pop
  307.  w  DB E8     FBANK 0         IIT only: set bank pointer to default
  308.  w  DB EB     FBANK 1         IIT only: set bank pointer to bank 1
  309.  w  DB EA     FBANK 2         IIT only: set bank pointer to bank 2
  310.  w  DF /4     FBLD mem10d     push, 0 := mem10d
  311.  w  DF /6     FBSTP mem10d    mem10d := 0, pop
  312.  
  313.  w  D9 E0     FCHS            0 := -0
  314. 9B  DB E2     FCLEX           clear exceptions
  315.  w  D8 D1     FCOM            compare 0 - 1
  316.  w  D8 D0+i   FCOM 0,i        compare 0 - i
  317.  w  D8 D0+i   FCOM i          compare 0 - i
  318.  w  D8 /2     FCOM mem4r      compare 0 - mem4r
  319.  w  DC /2     FCOM mem8r      compare 0 - mem8r
  320.                                                               7-7
  321.  
  322.  w  D8 D9     FCOMP           compare 0 - 1, pop
  323.  w  D8 D8+i   FCOMP 0,i       compare 0 - i, pop
  324.  w  D8 D8+i   FCOMP i         compare 0 - i, pop
  325.  w  D8 /3     FCOMP mem4r     compare 0 - mem4r, pop
  326.  w  DC /3     FCOMP mem8r     compare 0 - mem8r, pop
  327.  w  DE D9     FCOMPP          compare 0 - 1, pop both
  328.  w  D9 FF     FCOS            387 only: 0 := cosine(0)
  329.  
  330.  w  D9 F6     FDECSTP         decrement stack pointer
  331.  w  DB E1     FDISI           disable interrupts (.287 ignore)
  332.  
  333.  w  DE F9     FDIV            1 := 1 / 0, pop
  334.  w  D8 F0+i   FDIV i          0 := 0 / i
  335.  w  DC F8+i   FDIV i,0        i := i / 0
  336.  w  D8 F0+i   FDIV 0,i        0 := 0 / i
  337.  w  D8 /6     FDIV mem4r      0 := 0 / mem4r
  338.  w  DC /6     FDIV mem8r      0 := 0 / mem8r
  339.  
  340.  w  DE F8+i   FDIVP i,0       i := i / 0, pop
  341.  w  DE F1     FDIVR           1 := 0 / 1, pop
  342.  w  D8 F8+i   FDIVR i         0 := i / 0
  343.  w  DC F0+i   FDIVR i,0       i := 0 / i
  344.  w  D8 F8+i   FDIVR 0,i       0 := i / 0
  345.  w  D8 /7     FDIVR mem4r     0 := mem4r / 0
  346.  w  DC /7     FDIVR mem8r     0 := mem8r / 0
  347.  w  DE F0+i   FDIVRP i,0      i := 0 / i, pop
  348.  
  349.  w  DB E0     FENI            enable interrupts (.287 ignore)
  350.  w  DD C0+i   FFREE i         empty i
  351.  
  352.  w  DE /0     FIADD mem2i     0 := 0 + mem4i
  353.  w  DA /0     FIADD mem4i     0 := 0 + mem2i
  354.  w  DE /2     FICOM mem2i     compare 0 - mem2i
  355.  w  DA /2     FICOM mem4i     compare 0 - mem4i
  356.  w  DE /3     FICOMP mem2i    compare 0 - mem2i, pop
  357.  w  DA /3     FICOMP mem4i    compare 0 - mem4i, pop
  358.  
  359.  w  DE /6     FIDIV mem2i     0 := 0 / mem2i
  360.  w  DA /6     FIDIV mem4i     0 := 0 / mem4i
  361.  w  DE /7     FIDIVR mem2i    0 := mem2i / 0
  362.  w  DA /7     FIDIVR mem4i    0 := mem4i / 0
  363.  w  DF /0     FILD mem2i      push, 0 := mem2i
  364.  w  DB /0     FILD mem4i      push, 0 := mem4i
  365.  w  DF /5     FILD mem8i      push, 0 := mem8i
  366.  
  367.  w  DE /1     FIMUL mem2i     0 := 0 * mem2i
  368.  w  DA /1     FIMUL mem4i     0 := 0 * mem4i
  369.  
  370.  w  D9 F7     FINCSTP         increment stack pointer
  371.  
  372. 9B  DB E3     FINIT           initialize 87
  373.  w  DF /2     FIST mem2i      mem2i := 0
  374.  w  DB /2     FIST mem4i      mem4i := 0
  375.  w  DF /3     FISTP mem2i     mem2i := 0, pop
  376.  w  DB /3     FISTP mem4i     mem4i := 0, pop
  377.  w  DF /7     FISTP mem8i     mem8i := 0, pop
  378.                                                               7-8
  379.  
  380.  w  DE /4     FISUB mem2i     0 := 0 - mem2i
  381.  w  DA /4     FISUB mem4i     0 := 0 - mem4i
  382.  w  DE /5     FISUBR mem2i    0 := mem2i - 0
  383.  w  DA /5     FISUBR mem4i    0 := mem4i - 0
  384.  
  385.  w  D9 C0+i   FLD i           push, 0 := old i
  386.  w  DB /5     FLD mem10r      push, 0 := mem10r
  387.  w  D9 /0     FLD mem4r       push, 0 := mem4r
  388.  w  DD /0     FLD mem8r       push, 0 := mem8r
  389.  w  D9 E8     FLD1            push, 0 := 1.0
  390.  w  D9 /5     FLDCW mem2i     control word := mem2i
  391.  w  D9 /4     FLDENV mem14    environment := mem14
  392.  w  D9 EA     FLDL2E          push, 0 := log base 2.0 of e
  393.  w  D9 E9     FLDL2T          push, 0 := log base 2.0 of 10.0
  394.  w  D9 EC     FLDLG2          push, 0 := log base 10.0 of 2.0
  395.  w  D9 ED     FLDLN2          push, 0 := log base e of 2.0
  396.  w  D9 EB     FLDPI           push, 0 := Pi
  397.  w  D9 EE     FLDZ            push, 0 := +0.0
  398.  
  399.  w  DE C9     FMUL            1 := 1 * 0, pop
  400.  w  D8 C8+i   FMUL i          0 := 0 * i
  401.  w  DC C8+i   FMUL i,0        i := i * 0
  402.  w  D8 C8+i   FMUL 0,i        0 := 0 * i
  403.  w  D8 /1     FMUL mem4r      0 := 0 * mem4r
  404.  w  DC /1     FMUL mem8r      0 := 0 * mem8r
  405.  w  DE C8+i   FMULP i,0       i := i * 0, pop
  406.  
  407.     DB E2     FNCLEX          nowait clear exceptions
  408.     DB E1     FNDISI          disable interrupts (.287 ignore)
  409.     DB E0     FNENI           enable interrupts (.287 ignore)
  410.     DB E3     FNINIT          nowait initialize 87
  411.  w  D9 D0     FNOP            no operation
  412.  
  413.     DD /6     FNSAVE mem94    mem94 := 87 state
  414.     D9 /7     FNSTCW mem2i    mem2i := control word
  415.     D9 /6     FNSTENV mem14   mem14 := environment
  416.     DF E0     FNSTSW AX       AX := status word
  417.     DD /7     FNSTSW mem2i    mem2i := status word
  418.  
  419.  w  D9 F3     FPATAN          0 := arctan(1/0), pop
  420.  w  D9 F8     FPREM           0 := REPEAT(0 - 1)
  421.  w  D9 F5     FPREM1          387 only: 0 := REPEAT(0 - 1) IEEE compat.
  422.  w  D9 F2     FPTAN           push, 1/0 := tan(old 0)
  423.  
  424.  w  D9 FC     FRNDINT         0 := round(0)
  425.  w  DD /4     FRSTOR mem94    87 state := mem94
  426.  w  DD /6     FSAVE mem94     mem94 := 87 state
  427.  w  D9 FD     FSCALE          0 := 0 * 2.0 ** 1
  428. 9B  DB E4     FSETPM          set protection mode
  429.  w  D9 FE     FSIN            387 only: 0 := sine(0)
  430.  w  D9 FB     FSINCOS         387 only: push, 1 := sine, 0 := cos(old 0)
  431.  w  D9 FA     FSQRT           0 := square root of 0
  432.                                                               7-9
  433.  
  434.  w  DD D0+i   FST i           i := 0
  435.  w  D9 /2     FST mem4r       mem4r := 0
  436.  w  DD /2     FST mem8r       mem8r := 0
  437.  w  D9 /7     FSTCW mem2i     mem2i := control word
  438.  w  D9 /6     FSTENV mem14    mem14 := environment
  439.  w  DD D8+i   FSTP i          i := 0, pop
  440.  w  DB /7     FSTP mem10r     mem10r := 0, pop
  441.  w  D9 /3     FSTP mem4r      mem4r := 0, pop
  442.  w  DD /3     FSTP mem8r      mem8r := 0, pop
  443.  w  DF E0     FSTSW AX        AX := status word
  444.  w  DD /7     FSTSW mem2i     mem2i := status word
  445.  
  446.  w  DE E9     FSUB            1 := 1 - 0, pop
  447.  w  D8 E0+i   FSUB i          0 := 0 - i
  448.  w  DC E8+i   FSUB i,0        i := i - 0
  449.  w  D8 E0+i   FSUB 0,i        0 := 0 - i
  450.  w  D8 /4     FSUB mem4r      0 := 0 - mem4r
  451.  w  DC /4     FSUB mem8r      0 := 0 - mem8r
  452.  w  DE E8+i   FSUBP i,0       i := i - 0, pop
  453.  w  DE E1     FSUBR           1 := 0 - 1, pop
  454.  w  D8 E8+i   FSUBR i         0 := i - 0
  455.  w  DC E0+i   FSUBR i,0       i := 0 - i
  456.  w  D8 E8+i   FSUBR 0,i       0 := i - 0
  457.  w  D8 /5     FSUBR mem4r     0 := mem4r - 0
  458.  w  DC /5     FSUBR mem8r     0 := mem8r - 0
  459.  w  DE E0+i   FSUBRP i,0      i := 0 - i, pop
  460.  
  461.  w  D9 E4     FTST            compare 0 - 0.0
  462.  w  DD E0+i   FUCOM i         387 only: unordered compare 0 - i
  463.  w  DD E1     FUCOM           387 only: unordered compare 0 - 1
  464.  w  DD E8+i   FUCOMP i        387 only: unordered compare 0 - i, pop
  465.  w  DD E9     FUCOMP          387 only: unordered compare 0 - 1, pop
  466.  w  DA E9     FUCOMPP         387 only: unordered compare 0 - 1, pop both
  467.  
  468. 9B            FWAIT           wait for 87 ready
  469.  w  D9 E5     FXAM            C3 -- C0 := type of 0
  470.  w  D9 C9     FXCH            exchange 0 and 1
  471.  w  D9 C8+i   FXCH 0,i        exchange 0 and i
  472.  w  D9 C8+i   FXCH i          exchange 0 and i
  473.  w  D9 C8+i   FXCH i,0        exchange 0 and i
  474.  w  D9 F4     FXTRACT         push, 1 := expo, 0 := sig
  475.  w  D9 F1     FYL2X           0 := 1 * log base 2.0 of 0, pop
  476.  w  D9 F9     FYL2XP1         0 := 1 * log base 2.0 of (0+1.0), pop
  477.  
  478.