Chapter 12. Selected Pentium Instructions

Transcription

1 Chapter 12 Selected Pentium Instructions 1

2 2 Chapter Carry flag indicates out-of-range error for unsigned operations.

3 Chapter Overflow flag indicates out-of-range error for signed operations.

4 4 Chapter Sign flag is a copy of the most significant bit of the result. We can detect this by several methods. Couple of them are given below: Use shift left (SHL) instruction to move the sign bit into the carry flag. Use and 80H and test the zero flag

5 Chapter Parity flag is set when the least significant byte of the result contains even number of 1 bits (i.e., even parity). This flag is useful in parity generation.

6 6 Chapter When executing sub dest,src if CF is set, it indicated that src is greater than dest operand when these two operand are treated as unsigned numbers.

7 Chapter If the overflow flag is set, src is greater than dest operand when these two operands are treated as signed numbers.

8 8 Chapter No. The carry flag is set when src is greater than dest whereas ZF is set when they are equal.

9 Chapter No. The overflow flag is set when src is greater than dest whereas ZF is set when they are equal.

10 10 Chapter When the result contains even number of 1s (except the zero result), the parity flag is set but not the zero flag.

11 Chapter The following code implements a count-down loop using the zero flag: mov CX,count repeat1: <<loop body>> dec CX jnz repeat1 The above code is better than the count-up loop implementation shown below: mov CX,0 repeat1: <<loop body>> inc CX cmp CX,count jne repeat1

12 12 Chapter AL CF ZF SF OF PF mov AL,127 add AL,-128 FF mov AL,127 sub AL,-128 FF mov AL,-1 add AL, mov AL,127 inc AL mov AL,127 neg AL mov AL,0 neg AL

13 Chapter Before execution After execution Instruction AL BL AL ZF SF PF and AL,BL 79H 86H or AL,BL 79H 86H FFH xor AL,BL 79H 86H FFH test AL,BL 79H 86H 79H and AL,BL 36H 24H 24H or AL,BL 36H 24H 36H xor AL,BL 36H 24H 12H test AL,BL 36H 24H 36H 0 0 1

14 14 Chapter Before execution After execution Instruction AL CF AL CF shl AL,1 1? FFH 1 rol AL,1 1? FFH 1 shr AL,1 50? 19H 0 ror AL,1 50? 19H 0 sal AL,1 20? D8H 1 sar AL,1 20? F6H 0 rcl AL, D9H 1 rcr AL, F6H 0

15 Chapter Before execution After execution Instruction AL CF AL CF shl AL,CL 76H? B0H 1 sal AL,CL 76H? B0H 1 rcl AL,CL 76H 1 B5H 1 rcr AL,CL 76H 1 AEH 1 ror AL,CL 76H? CEH 1 rol AL,CL 76H? B3H 1

16 16 Chapter The reason is that in unsigned numbers, there is no sign bit; even the most significant bit represents magnitude. In the signed numbers, the most significant bit represents sign, not magnitude.

17 Chapter We will show that the statement is true for the 8-bit numbers. The other two are similar. The maximum (unsigned) number we can represent using four bits is 255D. So multiplying 255D by 255D is the maximum number we can expect from the multiplication of two 8-bit numbers. Since this number (65025D) is less than , there will not be any overflow. A more general proof that looks at x-bit inputs: Multiplying two x-bit numbers results in (2 x 1) 2 =(2 2x +1 2 x+1 ), which is less than 2 2x 1.

18 18 Chapter jg condition: The logical expression ((SF xor OF) or ZF) = 0 is true when ZF = 0 and SF = OF (because of the xor operation). This is the condition given in Table jge condition: The logical expression (SF xor OF) = 1 is true only SF = OF (because of the xor operation). This is the condition given in Table jl condition: The logical expression (SF xor OF) = 0 is true only SF 6= OF (because of the xor operation). This is the condition given in Table jle condition: The logical expression ((SF xor OF) or ZF) = 1 is true when either ZF = 1 or SF 6= OF (because of the xor operation). This is the condition given in Table 12.6.

19 Chapter In the fixed-length representation, each string occupies exactly the same number of character positions. In such a representation, if a string has fewer characters, it is extended by padding, for example, with blank characters. On the other hand, if a string has more characters, it is usually truncated to fit the storage space available. Clearly, if we want to avoid truncation of larger strings, we need to fix the string length carefully so that it can accommodate the largest string. In practice, it may be difficult to guess this value. A further disadvantage is that memory space is wasted if the majority of strings are shorter than the fixed length used.

20 20 Chapter The main advantages are: We don t have to decide on the string length. We don t waste memory space if the actual string is shorter than the fixed length used. We don t truncate longer strings if they exceed the fixed length used. The main disadvantage is the overhead associated with processing variable-length strings (for example, testing for the sentinel character). In addition, in sentinel-terminated variable strings, the sentinel character must be avoided in the string.

21 Chapter Explicitly storing string length: In this method, the string length attribute is explicitly stored along with the string. Thus, it is efficient to find the string length. An additional advantage is that we can use any character in the string (in contrast to the other method that reserves a special character as the sentinel). However, the disadvantage is that, if we modify the contents of the string, we have to update the string length value as well. Using a sentinel character: In this method, strings are stored with a trailing sentinel character. The main advantage is that there is no need to store string length explicitly. The disadvantage is that the sentinel character is a special character that cannot appear within a string. Furthermore, finding string length involves scanning the string until we find the sentinel character.

22 22 Chapter The main advantage of the string instructions is that, as part of execution, they automatically update (i.e., increment or decrement) the index registers used by these instructions. Another advantage is that they allow memory-to-memory copying of data. (Note that normal instructions do not allow memory-to-memory copying.) In addition, string instructions can accept a repetition prefix to repeatedly execute the operation. These features result in an efficient code for block movement of data (strings and other types of data).

23 Chapter The load string (lods) instruction copies the value at DS:SI from the source string to AL, AX, or EAX. Use of the rep prefix does not make sense, as it will leave only the last value in AL, AX, or EAX. This instruction, along with the stos instruction, is often used when processing is required while copying a string.

24 24 Chapter This is because these string instructions do not compare values like the cmps instruction.

25 Chapter The repeat prefixes first check the CX register to see if it is not 0, only then is the string instruction executed. Thus, if CX is 0 to start with, the string instruction is not executed at all. This is in contrast to the loop instruction, which first decrements and then tests if CX is 0. Thus, with loop, CX = 0 results in a maximum number of iterations, and usually a jcxz check is needed.

26 26 Chapter Usually it does not matter whether the string processing direction is forward or backward. However, for sentinel character-terminated strings, the forward direction is preferred as it improves efficiency (copy the character until the sentinel character is read).

27 Chapter There are situations where one particular direction is mandatory. For example, if we want to shift a string right by one position, we have to start with the tail and proceed toward the head (i.e., in the backward direction) as in the following example: Initial string! a b c 0? After one shift! a b c 0 0 After two shifts! a b c c 0 After three shifts! a b b c 0 Final string! a a b c 0 If we proceed in the forward direction, only the first character is copied through the string, as shown below: Initial string! a b c 0? After one shift! a a c 0? After two shifts! a a a 0? After three shifts! a a a a? Final string! a a a a a

28 28 Chapter The code for lds SI,string can be implemented as shown below: mov mov mov SI,[string+2] DS,SI SI,[string]

29 Chapter From the Pentium data book, we get the following timing information: The code above takes 4 cycles as indicated below: mov SI,[string+2] ; 1 cycle mov DS,SI ; 2 cycles mov SI,[string] ; 1 cycle The lds instruction also takes 4 clock cycles.

30 30 Chapter In direct procedure calls, the offset of the target procedure is provided directly. In indirect procedure calls, this offset is given with one level of indirection as in the indirect jump. That is, the call instruction itself will contain either a memory address (through a label), or a 16-bit generalpurpose register. The actual offset of the target procedure is obtained either from the memory or register. For example, we could use call BX if BX contains the offset of the target procedure. When this call instruction is executed, the BX register contents are used to load IP in order to transfer control to the target procedure. Similarly, we can use call target_proc_ptr if the word in memory at target_proc_ptr contains the offset of the target procedure.