Assembly Language floating point Instruction Set

; //////////////////////////////////////// ////////////////////////////////////////

; /// Floating point number loading command

; //////////////////////////////////////// ///////////////////////////////////////

; Mnemonic operand Function

Memory (real); press the real type in the memory into the human Stack

Fild memory (integer); converts the integer value of the memory to a floating point and presses the stack

Fbld memory (BCD); convert the BCD code of the memory to a floating point number and press the stack

Into ST (Num); press the value in the floating point register into the stack

Fld1 (none); 1.0 press the stack

Fldz (none); 0.0 runner stack

Fldpi (none); compaction (PI) Human Stack

Fldl2e (none); log2 (e) Press the stack

Fldl2t (none); log2 (10) press the stack

Fldlg2 (none); log10 (2) press the stack

Fldln2 (none); LogE (2) press the stack

Finit (none); initialize the floating point unit and clear the content of 8 registers

 

; //////////////////////////////////////// ////////////////////////////////////////

; /// Floating point data storage instruction

; //////////////////////////////////////// ///////////////////////////////////////

; Mnemonic operand Function

Fst st (Num); copy the value of St to replace the content of ST (Num); only ST (Num) is affected

Fstp ST (Num); copy the value of St to replace the content of ST (Num); ST to exit the stack

FST memory (real); the copy st value is a real number, stored in the memory; the stack is not affected

Fstp memory (real); copy the value of St to the real number and store it in the memory; ST to the output stack.

Fist memory (integer); copies the value of ST and converts it to an integer and stores it in the memory.

Fistp memory (integer); copies the value of the St and converts it to an integer and stores it in the memory; the st outputs the stack.

Fbstp memory (BCD); copies the value of ST and converts it to BCD code and stores it in the memory; ST outputs the stack.

Fxch (none); interchange st and ST (1)

Fxch ST (Num); SWAps st and ST (Num)

 

; //////////////////////////////////////// ///////////////////////////////////////

; // Floating-point addition command

; //////////////////////////////////////// //////////////////////////////////////

; Mnemonic operand Function

FADD (none); remove st and ST (1) from the stack; add two values, and combine them with

Fadd st (Num), ST; add ST (Num) and ST; use and replace ST (Num)

FADD St, ST (Num); add st and ST (Num); use and replace ST

FADD memory (real); add the number of real types in the ST and the memory; use and replace the St

Fiadd memory (integer); Add the integer in the ST and the memory, and replace the St

Faddp ST (Num), ST; add ST (Num) and ST, use and replace ST (Num), and remove st from Stack

 

; //////////////////////////////////////// //////////////////////////////////////

; // Floating-point multiplication command

; //////////////////////////////////////// //////////////////////////////////////

; Mnemonic operand Function

Fmul (none); the st and ST (1) are output from the stack, and their values are multiplied; the product stack

Fmul ST (Num), ST; multiply ST (Num) and ST; replace ST (Num) with the product)

Fmul St, ST (Num); multiply st and ST (Num); replace ST with the product

Fmul memory (real); multiply the real number in the ST and the number in the memory; replace the st with the product

Fimul memory (integer); multiply the st and the integer in the memory, and replace the st with the product

Fmulp ST (Num), ST; multiply ST (Num) and ST; replace ST (Num) with the product; and remove st from Stack

 

; Mnemonic operand Function

Fsub (none); returns st and ST (1) from the stack and calculates the ST (1) minus st value.

Fsub ST (Num), ST; Calculate the ST (Num) minus st value; replace ST (Num) with the difference value)

Fsub St, ST (Num); Calculate the st minus ST (Num) value; replace ST with the difference value

Fsub memory (real); Calculate the value of the real number in the St reduction memory; replace ST with the difference value

Fisub memory (integer); Calculate the value of the integer in the St minus memory; replace ST with the difference value

Fsubp ST (Num), ST; Calculate the ST (Num) minus st value; replace ST (Num) with the difference value; remove st from Stack

Fsubr (none); releases st and ST (1) from the stack; calculates st minus ST (1); adds the difference to the stack

Fsubr ST (Num), ST; calculates the value of St minus ST (Num) and replaces ST (Num) with the difference value)

Fsubr St, ST (Num); calculates the ST (Num) minus st value, and replaces ST with the difference value.

Fsubr memory (real); Calculate the value of the real-type value in the memory minus the value of the St, and replace the st with the difference value

Fisubr memory (integer); Calculate the value of the integer in the memory minus the value of the St; replace the st with the difference

Fsubrp ST (Num), ST; Calculate the value of St minus ST (Num), replace ST (Num) with the difference value; remove st from Stack

 

; //////////////////////////////////////// //////////////////////////////////////

; // Floating-point division command

; //////////////////////////////////////// //////////////////////////////////////

; Mnemonic operand Function

Fdiv (none); extract st and ST (1) from the stack; Calculate ST (1)/ST values; and import the vendors to the stack

Fdiv ST (Num), ST; Calculate the value of ST (Num)/ST; replace ST (Num) with the operator)

Fdiv St, ST (Num); Calculate the value of ST/ST (Num); replace ST with the operator

Fdiv memory (real); Calculate the real number in the ST/memory; replace ST with the vendor

Fidiv memory (integer); Calculate the integer number in the ST/memory; replace ST with the vendor

Fdivp ST (Num), ST; Calculate the value of ST (Num)/ST; replace ST (Num) with suppliers; and release st to stack

Fdivr (none); extract st and ST (1) from the stack; Calculate the value of ST/ST (1); and import the vendors into the stack

Fdivr ST (Num), ST; Calculate the value of ST/ST (Num); replace ST (Num) with the operator)

Fdivr St, ST (Num); Calculate the value of ST (Num)/ST; replace ST with the operator

Fdivr memory (real); calculate the number of instances in the memory/ST; replace ST with the vendor

Fidivr memory (integer); Calculate the integer number/ST in the memory; replace ST with the vendor

Fdivrp ST (Num), ST; Calculate the value of ST/ST (Num), replace ST (Num) with the supplier, and release st to the stack.

; //////////////////////////////////////// //////////////////////////////////////

; // Included floating point commands

; //////////////////////////////////////// /////////////////////////////////////

; Mnemonic operand Function

FABS (none); ST: = | st | (absolute value)

Fchs (none); ST: =-ST (reverse number)

Frndint (none); round the St

Fsqrt (none); replace ST with the square root of St

 

; //////////////////////////////////////// /////////////////////////////////////

; // Floating point comparison command

; //////////////////////////////////////// ////////////////////////////////////

; Mnemonic operand Function

Fcom (none); compare st and ST (1)

Fcom ST (Num); compare st and ST (Num)

Fcom memory (real); compares the number of real instances in the ST and memory.

Ficom memory (integer); compares the integer numbers in the ST and the memory.

Ftst (none); compare st and 0.0

Fcomp (none); compare st and ST (1); then exit the stack

Fcomp ST (Num); compare st and ST (Num); then output the stack

Fcomp memory (real); compares the real number of data types in the ST and memory, and then outputs the stack

Fcomp memory (integer); compares the integer values in the ST and the memory, and then outputs the stack

Fcompp (none); compare st and ST (1); then two times out of the stack

 

; //////////////////////////////////////// ////////////////////////////////////

; // Mixed floating point commands

; //////////////////////////////////////// ////////////////////////////////////

; Mnemonic operand Function

Fstsw memoryword; copy Status Register to memory word

Fstsw ax; copy the Status Register to the ax register

Fstcw memoryword; copy control word register to memory

Fldcw memoryword; copy the memory word to the control word register