8087 instruction set and examples

1
8087 instruction set and examples
2
About the 8087

• In the old days, you had to buy a -87 chip for
  numerical co-processing and hand install it.
  (Back in the 8086, 286,386 days).
• With the 486 processor and later, the -87
  coprocessor is integrated.

3
About the 8087

• The 8087 uses a stack or chain of 8 registers
  to use for internal storage and data
  manipulation, as well as status and control words
  to set rounding control and indicate the results
  of operations.
• It has its own instruction set, instructions are
  recognizable because of the F- in front. (Like
  FIADD, FCOM, etc)

4
About the 8087

• FWAIT checks a control line to see if the 87 is
  still active.
• programmers used to have to use an FWAIT before
  and after a set of instructions for the -87 to
  make sure -86 or -87 storage operations had been
  completed. (Basically, to handle
  synchronization).
• FWAIT should not be necessary.

5
About the 8087 data transfer

• Data transfer
• Instruction result
• FLD source load a real into st(0)
• FST dest store real at dest (86 mem)
• FSTP dest store/pop st(0)
• FXCH st(i) exchange two regs (St(0), St(1)) or
  St(0) and the operand

6
About the 8087 data transfer

• FILD source int load
• FIST dest int store
• FISTP dest int store/pop
• FBLD source bcd load (tbyte source)
• FBSTP dest bcd store tbyte dest

7
About the 8087 arithmetic

• FADD source add a real (mem) to st(0)
• FADD St(1),ST
• FADD st(i),st or FADD ST,ST(i)
• FADDP St(i),ST add st to st(i) and pop st(0)
• FIADD st, source int add to st

8
About the 8087 arithmetic

• FSUB for real subtract has same formats as FADD
• FISUB st, intmem for int sub
• ALSO
• FSUBR st(1),st
• FSUBR st, rmem
• FSUBRP st(i),st
• Etc and
• FISUBR st, intmem
• Reverse subtract subtract dest from source

9
About the 8087 arithmetic

• FMUL and FIMUL have same formats available
• FDIV and FIDIV have same formats
• Also available
• FDIVR, FDIVRP and FIDIVR

10
About the 8087 arithmetic

• Miscellaneous
• FSQRT st
• FABS st
• FCHS ST change sign
• FLDZ st load a zero

11
Control word

• The control word is a 16 bit word that works like
  a flag register on the 86 processor. It keeps
  information about zerodivide in bit 2 for
  example. Bits 3 and 4 are overflow and underflow
  respectively.
• Precision control is set in bits 8 and 9 and
  rounding is set in bits 10 and 11.
• Rounding control bit settings are
• 00 round to nearest/even
• O1 round down
• 10 round up
• 11 chop/truncate

12
Status word

• Status word is also a 16 bit word value.
• condition bits are named c3, c2,c1 and c0. Their
  position in the status word, though is
• C3 is bit 14
• C2,c1,c0 are bits 10,9,8 respectively.
• If you are curious, the eight possible bit
  settings in bits (11,12,13) indicate which
  register in the chain is currently st(0)

13
Temp real (80 bits)

• Temp real has an f-p format. Bits 0..63 are the
  significand in hidden bit format. Bits 64 to 78
  are the biased exponent, bit 79 is the sign.
• You shouldnt need to worry about these values on
  the stack.

14
Packed bcd (80 bits)

• A packed bcd is a tbyte.
• Bit 79 is the sign.
• Bits 72 through 78 are not used.
• Bits 0,1,2,3 store the 0 th (lsd) decimal digit.
• Bits 4,5,6,7 store the 1st.
• The 17th (msd) digit is in bits 68,69,70,71.
• Youll need to pad with zeros if there are fewer
  than 18 digits.

15
Int values

• 87 processor recognizes word, dword and qword
  signed int types, in the same manner as the 86
  processor.

16
The stack

• Pushing and popping on the stack change the
  register who is currently the top.
• Pushing more than 8 times will push the last
  piece of data out and put St(0) at the most
  recently pushed item.
• It is the programmers responsibility to count
  stack push/pop operations.
• Whoever is on top of the stack, is referenced by
  St or ST(0). St(1) is next. And so on to St(7).

17
Int transfer

• FILD load int. Type (word, dword, etc) is
  whatever the operand type is. St(0) is this new
  value. St(1) points to the previous value on
  top.
• FIST copy St(0) value to memory, converting to a
  signed int (following rounding control settings
  in the control word)
• FISTP same as above, but pop the stack as well.

18
BCD

• FBLD load a bcd (tbyte) onto the stack
• FBSTP store a tbyte bcd value into the memory
  operand, popping the stack as you go.
• Example
• FBLD myval
• FBSTP myval

19
Exchanging/swapping on the stack

• FXCHG dest
• Swap stack top with operand.
• Example
• FXCHG St(3)
• swaps St(0) value with St(3) value

20
Int arithmetic

• FIADD, FIADD add
• FISUB, FISUBR, sub, or sub reversed.
• FIMUL
• FIDIV, FIDIVR
• Other
• FPREM, FRNDINT partial remainder, round to int
• FLDZ push a zero onto the stack.
• FLD1 push a 1

21
FPREM

• Takes implicit operands st,st(1)
• Does repeated subtract leaves stgt0,(possibly
  stst(1)) or st0.
• May need to repeat it, because it only reduces st
  by exp(2,64)
• If stgtst(1) it needs to be repeated.
• FPREM sets bit C2 of the status word if it needs
  to be repeated, clears this bit if it completes
  operation.

22
operands

• Stack operands may be implicitly referenced.
• FIADD, FISUB, FIDIV, FIDIVR, FIMUL and FISUBR
  have only one form (example using add
  instruction)
• FIADD ST, intmem
• St(0) is implied dest for all of these.

23
comparison

• FCOM no operands compares st,st(1)
• FCOM St(i) one operand compares st with st(i)
• FCOMP (compare and pop) is the same.
• FCOMPP - only allows implicit operands St,st(1)
  (compare then pop twice)
• FTST compares St with 0.
• These all use condition codes described above and
  make the settings in the next slide.

24
Condition codes

• C3 c0
• 0 0 stgtsource
• 0 1 stltsource
• 1 0 stsource
• 1 1 not comparable

25
Getting status and control words

• FSTSW intmem copy status word to 16 bit mem
  location for examination.
• FLDCW intmem load control word (to set rounding,
  for example, from 16bit int mem)
• FSTCW intmem copy control word to int mem

26
Some -87 examples
27
16-bit vs 32-bit?

• Almost all the examples here were done in 32 bit.
  
• But the coprocessor works in 16 bit as well.

28
excerpt from a 16-bit program ouptut

• value word 1234
• .code
• main PROC
• mov ax,_at_data
• mov ds,ax
• mov ax, value
• call writedec
• fild value
• fiadd value
• fistp value
• mov ax,value
• call crlf
• call writedec

• C\MASM615gtcoprocessor
• 1234
• 2468
• C\MASM615gt

29
adding up an array (example from notes)

• include irvine16.inc
• .data
• array dword 12, 33, 44,55,77,88,99,101,202,9999,11
  1
• sum dword ?
• .code
• main proc
• mov ax,_at_data
• mov ds,ax
• xor bx,bx
• fldz
• fist sum
• mov eax,sum
• call writeintprint zero
• call crlf
• mov cx,10
• top
• mov eax,arraybxget value
• call writeintprint it
• call crlf

30
adding up an array (example from notes)
31
Getting sqrt

• call readint
• fstcw controlstore current control word
• or control,0800hset bit 11 clear bit 10 to round
  up
• fldcw controlload new control word
• mov num,eax
• fild num
• fsqrt
• fistp sqr
• fwait
• mov edx, offset prompt2
• call writestring
• mov eax,sqr
• call writeint

32
Rounding set to round up

• c\Masm615gtprimes
• enter an integer125
• sqrt of integer12

33
Add code to check for prime and print divisors
for composites

• mov eax,num
• call crlf
• mov ebx,2first divisor
• top
• xor edx,edx
• push eax
• div ebxdivide
• mov divi,ebx
• cmp edx,0
• je notprime
• inc ebx
• cmp ebx,sqr
• jg prime
• pop eax
• jmp top
• notprime
• call writedec
• call crlf
• mov eax,divi

34
Output from primes

• enter an integer1337711
• 18841
• 71
• not a prime
• c\Masm615gtprimes
• enter an integer17171731
• 746597
• 23
• not a prime
• c\Masm615gtprimes
• enter an integer313713
• 104571
• 3
• not a prime

35
factorials

• call readint
• mov num,eax
• call crlf
• fld1 load a 1 for subtacting and
  comparing..this will be st(2)
• fld1 prod value initialized in st(1)
• fild nummultiplier... need to count down and
  multiply st by st(1)
• theloop
• ftst is st0?
• fstsw status
• and status, 4100hcheck bits c3 and c0...c30
  c01 means stltsource
• cmp status,4000hstsource
• jz done
• fmul st(1),st leave prod in st(1)
• fsub st,st(2)
• jmp theloop
• done
• fistp dummy
• fistp answer
• mov edx,offset p2

36
factorials

• c\Masm615gtfactorials
• enter an integer6
• factorial is
• 720
• c\Masm615gtfactorials
• enter an integer7
• factorial is
• 5040
• c\Masm615gt

37
Fibonacci values

• mov edx, offset prompt
• call crlf
• call writestring
• call readint
• call crlf
• fld1 load a 1 for subtacting and
  comparing..this will be st(2)
• fld1 prod value initialized in st(1)
• top cmp eax,0
• je done
• fadd st(1),st
• fsubr st,st(1) cute huhn?stst(1)-st
• dec eax
• jmp top
• done
• fistp dummy
• fistp answer
• mov edx,offset p2
• call writestring
• call crlf

38
Fibonacci

• c\Masm615gtfibs
• enter an integer4
• fib is
• 8
• c\Masm615gtfibs
• enter an integer6
• fib is
• 21
• c\Masm615gtfibs
• enter an integer7
• fib is
• 34
• c\Masm615gt

39
Mimicking real io

• You can output reals by outputting first the
  integer part, subtracting this from the original
  value, then repeatedly multiplying the fraction
  by ten, (subtracting this off from the remainder)
  and outputting this sequence of fractional
  digits.
• This is NOT an IEEE f-p conversion routine!

40
Rounding control the int part

• fstcw control
• or control,0C00h chop or truncate
• fldcw control
• fild ten ten is in st(1)
• fild num num is in st(0)
• fsqrt sqrt in st
• fist intsqr store chopped result, dont pop
• call crlf
• mov edx,offset message
• call writestring
• fwait
• mov ax,intsqr write the int part
• call writedec

41
realio

• mov edx,offset dotdecimal point
• call writestring
• fisub intsqr subtract from sqrt the int part
  leaving fractional part
• now loop store 5 decimal places
• mov edi, offset decimals
• mov ecx, 5
• up
• fmul st,st(1) multiply by 10 to shift dec
  point
• fist digit store truncated int
• fisub digit subtract it off of the total
• fwait
• mov ax,digit
• add al,48
• mov byte ptr edi,al store this digit
• inc edi
• loop up

42
Run of realio

• c\Masm615gtrealio
• enter an integer
• 121
• sqrt of integer 11.00000
• c\Masm615gtrealio
• enter an integer
• 123
• sqrt of integer 11.09053
• c\Masm615gtrealio
• enter an integer
• 143
• sqrt of integer 11.95826
• c\Masm615gt