Assembler Programming. Lecture 9

Transcription

1 Assembler Programming Lecture 9

2 Lecture 9 Floating point coprocessor instructions. MMX instructions.

3 Math coprocessor 8087, 80287, separate chips. i486dx and above built in. Clculate many times faster then 8086-based processor: real numbers, packed BCD numbers, long integers. Has its own set of registers.

4 Math coprocessor registers R7 R6 R5 R4 R3 R2 R1 R ST(1) ST Sign Exponent Significand

5 Groups of the instructions Classical stack format. Memory. Register. Register pop.

6 Classical stack format Instructions treat registers like a stack. Only a top item can be accessed. First and sometimes second registers are assumed. ST is the source operand. ST(1) is the destination operand. Source is popped off the stack. Result is at the top of the stack.

7 Memory format Instructions treat registers like a stack. Item are pushed from memory or popped to the memory. Memory operand is always the source operand. ST is the destination operand. Result is at the top of the stack without popping the destination operand.

8 Register format Instructions treat registers like a registers. One operand is always the stack top ST. First operand is the destination. Second operand is the source. Stack position does not change.

9 Register pop format Instructions treat registers as modified stack. Source must be the ST (stack top). Destination is the other register. Result is placed into te destination register. Source (top) is popped off the stack.

10 Coprocessor instructions Loading and storing data. Doing arithmetic calculations. Controlling program flow.

11 Loading and Storing Data Copy data between memory and registers. Copy data between registers. Data in memory can be: integer, BCD number, real number. Data transferred to coprocessor is always 10- byte real number.

12 Loading and Storing Data Load commands push data onto the stack. Store commands pop data off the stack or copy the data to other register. Constants can not be operands. You can load constants like 0, 1, pi with special instructions. You can save the coprocessor status to the memory and later load the status back into registers.

13 Loading and storing data FLD, FST, FSTP - Loads and stores real numbers. FILD, FIST, FISTP - Loads and stores binary integers. FBLD - Loads BCD. FBSTP - Stores BCD. FXCH - Exchanges register values. In all istructions P means popping the ST.

14 Loading constants FLDZ - Pushes 0 into ST. FLD1 - Pushes 1 into ST. FLDPI - Pushes the value of pi into ST. FLDL2E - Pushes the value of log2e into ST. FLDL2T - Pushes log210 into ST. FLDLG2 - Pushes log102 into ST. FLDLN2 - Pushes loge2 into ST.

15 Loading and storing status FLDCW mem2byte - Loads the control word into the coprocessor F[[N]]STCW mem2byte - Stores the control word in memory FLDENV mem14byte - Loads environment from memory F[[N]]STENV mem14byte - Stores environment in memory FRSTOR mem94byte - Restores state from memory F[[N]]SAVE mem94byte - Saves state in memory

16 Loading and storing example.data m1 m1 REAL4 1.0 m2 m2 REAL4 2.0.CODE fld m1 m1 ; Push m1 m1 into first item fld st(2) ; Push third item into first fst m2 m2 ; Copy first item to to m2 m2 fxch st(2) ; Exchange first and third items fstp m1 m1 ; Pop first item into m1 m1

17 Arithmetic calculations FADD - Adds the source and destination. FSUB - Subtracts the source from the destination. FSUBR - Subtracts the destination from the source. FMUL - Multiplies the source and the destination. FDIV - Divides the destination by the source. FDIVR - Divides the source by the destination. FABS - Sets the sign of ST to positive. FCHS - Reverses the sign of ST.

18 Arithmetic calculations FRNDINT - Rounds ST to an integer. FSQRT - Replaces the contents of ST with its square root. FSCALE - Multiplies the stack-top value by 2 to the power contained in ST(1). FPREM - Calculates the remainder of ST divided by ST(1).

19 Arithmetic calculations 387 FSIN - Calculates the sine of the value in ST FCOS - Calculates the cosine of the value in ST FSINCOS - Calculates the sine and cosine of the value in ST FPTAN - Calculates the tangent of the value in ST FPATAN - Calculates the arctangent of the ratio Y/X

20 Arithmetic calculations 387 FPREM1 - Calculates the partial remainder by performing modulo division on the top two stack registers FXTRACT - Breaks a number down into its exponent and mantissa and pushes the mantissa onto the register stack F2XM1 - Calculates 2 x 1 FYL2X - Calculates Y * log 2 X FYL2XP1 - Calculates Y * log 2 (X+1)

21 Arithmetic calculations 387 F[[N]]INIT - Resets the coprocessor and restores all the default conditions in the control and status words F[[N]]CLEX - Clears all exception flags and the busy flag of the status word FINCSTP - Adds 1 to the stack pointer in the status word FDECSTP - Subtracts 1 from the stack pointer in the status word FFREE - Marks the specified register as empty

22 Arithmetic calculations - Example.DATA a REAL b REAL cc cc REAL posx REAL negx REAL CODE. ; Solve quadratic equation - no no error checking ; The The formula is: is: -b -b +/- +/- squareroot(b2-4ac) / (2a) fld1 ; Get Get constants 2 and and 4 fadd st,st ; 2 at at bottom fld fld st st ; Copy it it fmul a ; = 2a 2a fmul st(1),st ; = 4a 4a fxch ; Exchange st st and and st(1) fmul cc cc ; = 4ac 4ac

23 fld fld b ; Load b fmul st,st ; = b2 b2 fsubr ; = b2 b2-4ac 4ac ; Negative value here produces error fsqrt ; = square root(b2-4ac) fld fld b ; Load b fchs ; Make it it negative fxch ; Exchange fld fld st st ; Copy square root fadd st,st(2) ; Plus version = -b -b + root(b2-4ac) fxch ; Exchange fsubp st(2),st ; Minus version = -b -b - root(b2-4ac) fdiv st,st(2) ; Divide plus version fstp posx ; Store it it fdivr ; Divide minus version fstp negx ; Store it it

24 Invalid operation Denormalized Zero divide Overflow Underflow Precision Stack fault Exception flag Condition codes Top of stack Reserved Status Word register SW C3 C2 C1 C0 Exception flags

25 Controlling program flow Status word can be stored: intothememory, into the AX register (80287 and above). Coprocessor have instructions for: comparing operands, testing control flags. These instructions compare the ST to: specified source operand, ST(1) if not specified.

26 Controlling program flow FCOM - Compares the stack top to the source. The source and destination are unaffected by the comparison. FTST - Compares ST to 0. FCOMP - Compares the stack top to the source and then pops the stack. FUCOM, FUCOMP, FUCOMPP - Compares the source to ST and sets the condition codes of the status word according to the result (80386/486 only). F[[N]]STSW mem2byte - Stores the status word in memory. FXAM - Sets the value of the control flags based on the type of the number in ST.

27 Controlling program flow FPREM - Finds a correct remainder for large operands. It uses the C2 flag to indicate whether the remainder returned is partial (C2 is set) or complete (C2 is clear). FNOP - Copies the stack top onto itself without having any effect on registers or memory. FDISI, FNDISI, FENI, FNENI - Enables or disables interrupts (8087 only). FSETPM - Sets protected mode. Requires a.286p or.386p directive (80287, 80387, and only).

28 Controlling the flow - Example.DATA down REAL ; Sides of of a rectangle across REAL diamtr REAL ; Diameter of of a circle status WORD? P287 EQU EQU (@Cpu AND AND 00111y).CODE ; Get Get area of of rectangle fld fld across ; Load one one side fmul down ; Multiply by by the the other ; Get Get area of of circle: Area = PI PI * (D/2)2 fld1 ; Load one one and and fadd st, st, st st ; double it it to to get get constant 2 fdivr diamtr ; Divide diameter to to get get radius fmul st, st, st st ; Square radius fldpi ; Load pi pi fmul ; Multiply it it

29 ; Compare area of of circle and and rectangle fcompp ; Compare and and throw both away IF IF p287 fstsw ax ax ; (For 287+, skip memory) ELSE fnstsw status ; Load from coprocessor to to memory mov mov ax, ax, status ; Transfer memory to to register ENDIF sahf ; Transfer AH AH to to flags register jp jp nocomp ; If If parity set, can't compare jz jz same ; If If zero set, they're the the same jc jc rectangle ; If If carry set, rect. is is bigger jmp jmp circle ; else circle is is bigger nocomp: same: rectangle: circle: ; Error handler ; Both equal ; Rectangle bigger ; Circle bigger

30 Program flow new mechanism Available beginning with the P6 family processors. New instructions: FCOMI, FCOMIP, FUCOMI, FUCOMIP, compare and set ZF, PF, and CF flags in the EFLAGS register directly. New conditional transfer instructions: FCMOVcc, conditionally moves floating point values eliminates branches.

31 Memory access When using the coprocessor, follow these three steps: Load data from memory to coprocessor registers. Process the data. Store the data from coprocessor registers back to memory. Processing the data, can occur while the main processor is handling other tasks. Loading and storing data must be coordinated

32 Memory access Coprocessor instruction follows a processor instruction: assembler coordinates this conflict automatically for 8086, processor coordnates it automatically on and above processors. ; Processor instruction first - No No wait needed mov mov WORD PTR PTR mem32[0], ax ax ; Load memory mov mov WORD PTR PTR mem32[2], dx dx fild mem32 ; Load to to register

33 Memory access Processor instruction follows a coprocessor instruction: synchronization is not automatic, You must include WAIT or FWAIT instruction. ; Coprocessor instruction first - Wait needed fist mem32 ; Store to to memory fwait ; Wait until ; coprocessor is is done mov mov ax, ax, WORD PTR PTR mem32[0] ; Move to to register mov mov dx, dx, WORD PTR PTR mem32[2]

34 Coprocessor example ; counting average of of table elements count DW DW average REAL mov mov cx,count mov mov si,table fld fld qword ptr ptr [si] ; load first element to to the the ST ST dec dec cx cx sum: add add si,8 ; index of of next element fld fld qword ptr ptr [si] ; load next element to to the the ST ST fadd ; add add ST(1) to to ST ST loop sum sum fidiv count ; divide sum sum in in ST ST / count fstp average ; store the the result

35 MMX Introduced in the Pentium MMX. SIMD Single Instruction Multiple Data. Handles 64-bit packed integer data. Works on 8 new 64-bit registers. Three new packed data types: 64-bit packed byte integers (signed and unsigned). 64-bit packed word integers (signed and unsigned). 64-bit packed doubleword integers (signed and unsigned). 47 new instructions.

36 MMX registers 80-bit math coprocessor registers R MM7 R6 R5 R4 R3 R2 R1 MM6 MM5 MM4 MM3 MM2 MM1 R0 MM0 64-bit MMX registers

37 MMX data types Packed byte Byte Byte Byte Byte Byte Byte Byte Byte Packed word Word Word Word Word Packed doubleword Doubleword Doubleword 63 0

38 SIMD instructions Source operand Word Word Word Word Packed word PADDSW Source operand Word Word Word Word Packed word = = = = Destination Word Word Word Word Packed word

39 Wraparound Source operand 0000 FFFF 8000 FFFF Packed word PADDW Source operand FFFF Packed word = = = = Destination FFFE Packed word

40 Signed saturation Source operand 0000 FFFF 8000 FFFF Packed word PADDSW Source operand FFFF Packed word = = = = Destination FFFE Packed word

41 Unsigned saturation Source operand 0000 FFFF 8000 FFFF Packed word PADDUSW Source operand FFFF Packed word = = = = Destination 0001 FFFF FFFF FFFF Packed word

42 MMX instructions Data transfer Arithmetic Comparison Conversion Unpacking Logical Shift Empty MMX state instruction (EMMS)

43 Data transfer MOVD moves 32 bits between MMX register and memory, or general purpose register. MOVQ - moves 64 bits between MMX register and memory, or between MMX registers.

44 Arithmetic instructions PADDB, PADDW, PADDD add packed integers with wraparound. PSUBB, PSUBW, PSUBD subtract packed integers with wraparound. PADDSB, PADDSW add packed signed integers with signed saturation. PSUBSB, PSUBSW subtract packed signed integers with signed saturation PADDUSB, PADDUSW add packed unsigned integers with unsigned saturation PSUBUSB, PSUBUSW subtract packed unsigned integers with unsigned saturation

45 Arithmetic instructions PMULHW multiply packed signed integers and store high result. PMULLW multiply packed signed integers and store low result. PMADDWD multiply and add packed integers.

46 Comparison instructions PCMPEQB, PCMPEQW, PCMPEQD compare packed data for equal. PCMPGTB, PCMPGTW, PCMPGTD compare packet signed data for greater than.

47 Conversion instructions PACKSSWB pack words into bytes with signed saturation. PACKSSDW pack doublewords into words with signed saturation. PACKUSWB pack words into bytes with unsigned saturation.

48 Unpack instructions PUNPCKHBW, PUNPCKHWD, PUNPCKHDQ unpack high-order data elements. PUNPCKLBW, PUNPCKLWD, PUNPCKLDQ unpack low-order data elements.

49 Logical instructions PAND bitwise logical AND. PANDN bitwise logical AND NOT. POR bitwise logical OR. PXOR bitwise logical exclusive OR.

50 Shift instructions PSLLW, PSLLD, PSLLQ shift packed data left logical. PSRLW, PSRLD, PSRLQ shift packed data right logical. PSRAW, PSRAD shift packed data right arithmetic.

51 EMMS instruction Indicates math coprocessor registers as empty. Must be executed at the end of MMX routine.