Selected Pentium Instructions

1
Selected Pentium Instructions

• Chapter 12
• S. Dandamudi

2
Outline

• Status flags
• Zero flag
• Carry flag
• Overflow flag
• Sign flag
• Auxiliary flag
• Parity flag
• Arithmetic instructions
• Multiplication instructions
• Division instructions
• Application examples
• PutInt8
• GetInt8

• Conditional execution
• Indirect jumps
• Conditional jumps
• Single flags
• Unsigned comparisons
• Signed comparisons
• Implementing high-level language decision
  structures
• Selection structures
• Iteration structures

3
Outline (contd)

• Logical expressions in high-level languages
• Representation of Boolean data
• Logical expressions
• Logical expression evaluation
• Full evaluation
• Partial evaluation
• Bit instructions
• Bit test and modify
• Bit scan
• Illustrative examples

• String representation
• String instructions
• Repetition prefixes
• Direction flag
• String move instructions
• String compare instructions
• String scan instructions
• Illustrative examples
• str_len
• str_mov
• Indirect procedure call

4
Status Flags
5
Status Flags (contd)

• Status flags are updated to indicate certain
  properties of the result
• Example If the result is zero, zero flag is set
• Once a flag is set, it remains in that state
  until another instruction that affects the flags
  is executed
• Not all instructions affect all status flags
• add and sub affect all six flags
• inc and dec affect all but the carry flag
• mov, push, and pop do not affect any flags

6
Status Flags (contd)

• Example
• initially, assume ZF 0
• mov AL,55H ZF is still zero
• sub AL,55H result is 0
• ZF is set (ZF 1)
• push BX ZF remains 1
• mov BX,AX ZF remains 1
• pop DX ZF remains 1
• mov CX,0 ZF remains 1
• inc CX result is 1
• ZF is cleared (ZF 0)

7
Status Flags (contd)

• Zero Flag
• Indicates zero result
• If the result is zero, ZF 1
• Otherwise, ZF 0
• Zero can result in several ways (e.g. overflow)
• mov AL,0FH mov AX,0FFFFH mov AX,1
• add AL,0F1H inc AX dec AX
• All three examples result in zero result and set
  ZF
• Related instructions
• jz jump if zero (jump if ZF 1)
• jnz jump if not zero (jump if ZF 0)

8
Status Flags (contd)

• Uses of zero flag
• Two main uses of zero flag
• Testing equality
• Often used with cmp instruction
• cmp char, ZF 1 if char is
• cmp AX,BX
• Counting to a preset value
• Initialize a register with the count value
• Decrement it using dec instruction
• Use jz/jnz to transfer control

9
Status Flags (contd)

• Consider the following code
• sum 0
• for (i 1 to M)
• for (j 1 to N)
• sum sum 1
• end for
• end for

• Assembly code
• sub AX,AX AX 0
• mov DX,M
• outer_loop
• mov CX,N
• inner_loop
• inc AX
• loop inner_loop
• dec DX
• jnz outer_loop
• exit_loops
• mov sum,AX

10
Status Flags (contd)

• Two observations
• loop instruction is equivalent to
• dec DX
• jnz outer_loop
• This two instruction sequence is more efficient
  than the loop instruction (takes less time to
  execute)
• loop instruction does not affect any flags!
• This two instruction sequence is better than
  initializing DX 1 and executing
• inc DX
• cmp DX,M
• jle inner_loop

11
Status Flags (contd)

• Carry Flag
• Records the fact that the result of an arithmetic
  operation on unsigned numbers is out of range
• The carry flag is set in the following examples
• mov AL,0FH mov AX,12AEH
• add AL,0F1H sub AX,12AFH
• Range of 8-, 16-, and 32-bit unsigned numbers
• size range
• 8 bits 0 to 255 (28 - 1)
• 16 bits 0 to 65,535 (216 - 1)
• 32 bits 0 to 4,294,967,295 (232-1)

12
Status Flags (contd)

• Carry flag is not set by inc and dec instructions
• The carry flag is not set in the following
  examples
• mov AL,0FFH mov AX,0
• inc AL dec AX
• Related instructions
• jc jump if carry (jump if CF 1)
• jnc jump if no carry (jump if CF 0)
• Carry flag can be manipulated directly using
• stc set carry flag (set CF to 1)
• clc clear carry flag (clears CF to 0)
• cmc complement carry flag (inverts CF value)

13
Status Flags (contd)

• Uses of carry flag
• To propagate carry/borrow in multiword
  addition/subtraction
• 1 ? carry from lower 32 bits
• x 3710 26A8 1257 9AE7H
• y 489B A321 FE60 4213H
• 7FAB C9CA 10B7 DCFAH
• To detect overflow/underflow condition
• In the last example, carry out of leftmost bit
  indicates overflow
• To test a bit using the shift/rotate instructions
• Bit shifted/rotated out is captured in the carry
  flag
• We can use jc/jnc to test whether this bit is 1
  or 0

14
Status Flags (contd)

• Overflow flag
• Indicates out-of-range result on signed numbers
• Signed number counterpart of the carry flag
• The following code sets the overflow flag but not
  the carry flag
• mov AL,72H 72H 114D
• add AL,0EH 0EH 14D
• Range of 8-, 16-, and 32-bit signed numbers
• size range
• 8 bits - 128 to 127 27 to (27 - 1)
• 16 bits - 32,768 to 32,767 215 to (215 -
  1)
• 32 bits -2,147,483,648 to 2,147,483,647 231
  to (231 - 1)

15
Status Flags (contd)

• Signed or unsigned How does the system know?
• The processor does not know the interpretation
• It sets carry and overflow under each
  interpretation

• Unsigned interpretation
• mov AL,72H
• add AL,0EH
• jc overflow
• no_overflow
• (no overflow code here)
• . . . .
• overflow
• (overflow code here)
• . . . .

• Signed interpretation
• mov AL,72H
• add AL,0EH
• jo overflow
• no_overflow
• (no overflow code here)
• . . . .
• overflow
• (overflow code here)
• . . . .

16
Status Flags (contd)

• Related instructions
• jo jump if overflow (jump if OF 1)
• jno jump if no overflow (jump if OF 0)
• There is a special software interrupt
  instruction
• into interrupt on overflow
• Details on this instruction in Chapter 20
• Uses of overflow flag
• Main use
• To detect out-of-range result on signed numbers

17
Status Flags (contd)

• Sign flag
• Indicates the sign of the result
• Useful only when dealing with signed numbers
• Simply a copy of the most significant bit of the
  result
• Examples
• mov AL,15 mov AL,15
• add AL,97 sub AL,97
• clears the sign flag as sets the sign flag as
• the result is 112 the result is -82
• (or 0111000 in binary) (or 10101110 in binary)
• Related instructions
• js jump if sign (jump if SF 1)
• jns jump if no sign (jump if SF 0)

18
Status Flags (contd)

• Usage of sign flag
• To test the sign of the result
• Also useful to efficiently implement countdown
  loops

• Consider the count down loop
• for (i M downto 0)
• ltloop bodygt
• end for
• If we dont use the jns, we need cmp as shown
  below
• cmp CX,0
• jl for_loop

• The count down loop can be implemented as
• mov CX,M
• for_loop
• ltloop bodygt
• dec CX
• jns for_loop

19
Status Flags (contd)

• Auxiliary flag
• Indicates whether an operation produced a carry
  or borrow in the low-order 4 bits (nibble) of 8-,
  16-, or 32-bit operands (i.e. operand size
  doesnt matter)
• Example
• 1 ? carry from lower 4
  bits
• mov AL,43 43D 0010 1011B
• add AL,94 94D 0101 1110B
• 137D 1000 1001B
• As there is a carry from the lower nibble,
  auxiliary flag is set

20
Status Flags (contd)

• Related instructions
• No conditional jump instructions with this flag
• Arithmetic operations on BCD numbers use this
  flag
• aaa ASCII adjust for addition
• aas ASCII adjust for subtraction
• aam ASCII adjust for multiplication
• aad ASCII adjust for division
• daa Decimal adjust for addition
• das Decimal adjust for subtraction
• Appendices I has more details on these
  instructions
• Usage
• Main use is in performing arithmetic operations
  on BCD numbers

21
Status Flags (contd)

• Parity flag
• Indicates even parity of the low 8 bits of the
  result
• PF is set if the lower 8 bits contain even number
  1 bits
• For 16- and 32-bit values, only the least
  significant 8 bits are considered for computing
  parity value
• Example
• mov AL,53 53D 0011 0101B
• add AL,89 89D 0101 1001B
• 142D 1000 1110B
• As the result has even number of 1 bits, parity
  flag is set
• Related instructions
• jp jump on even parity (jump if PF 1)
• jnp jump on odd parity (jump if PF 0)

22
Status Flags (contd)

• Usage of parity flag
• Useful in writing data encoding programs
• Example Encodes the byte in AL (MSB is the
  parity bit)
• parity_encode PROC
• shl AL
• jp parity_zero
• stc CF 1
• jmp move_parity_bit
• parity_zero
• clc CF 0
• move_parity_bit
• rcr AL
• parity_encode ENDP

23
Arithmetic Instructions

• Pentium provides several arithmetic instructions
  that operate on 8-, 16- and 32-bit operands
• Addition add, adc, inc
• Subtraction sub, sbb, dec, neg, cmp
• Multiplication mul, imul
• Division div, idiv
• Related instructions cbw, cwd, cdq, cwde, movsx,
  movzx
• There are few other instructions such as aaa,
  aas, etc. that operate on decimal numbers
• See Appendix I for details

Discussed in Chapter 9
24
Arithmetic Instructions (contd)

• Multiplication
• More complicated than add/sub
• Produces double-length results
• E.g. Multiplying two 8 bit numbers produces a
  16-bit result
• Cannot use a single multiply instruction for
  signed and unsigned numbers
• add and sub instructions work both on signed and
  unsigned numbers
• For multiplication, we need separate instructions
• mul for unsigned numbers
• imul for signed numbers

25
Arithmetic Instructions (contd)

• Unsigned multiplication
• mul source
• Depending on the source operand size, the
  location of the other source operand and
  destination are selected

26
Arithmetic Instructions (contd)

• Example
• mov AL,10
• mov DL,25
• mul DL
• produces 250D in AX register (result fits in AL)
• The imul instruction can use the same syntax
• Also supports other formats
• Example
• mov DL,0FFH DL -1
• mov AL,0BEH AL -66
• imul DL
• produces 66D in AX register (again, result fits
  in AL)

27
Arithmetic Instructions (contd)

• Division instruction
• Even more complicated than multiplication
• Produces two results
• Quotient
• Remainder
• In multiplication, using a double-length
  register, there will not be any overflow
• In division, divide overflow is possible
• Pentium provides a special software interrupt
  when a divide overflow occurs
• Two instructions as in multiplication
• div source for unsigned numbers
• idiv source for signed numbers

28
Arithmetic Instructions (contd)

• Dividend is twice the size of the divisor
• Dividend is assumed to be in
• AX (8-bit divisor)
• DXAX (16-bit divisor)
• EDXEAX (32-bit divisor)

29
Arithmetic Instructions (contd)
30
Arithmetic Instructions (contd)

• Example
• mov AX,251
• mov CL,12
• div CL
• produces 20D in AL and 11D as remainder in AH
• Example
• sub DX,DX clear DX
• mov AX,141BH AX 5147D
• mov CX,012CH CX 300D
• div CX
• produces 17D in AX and 47D as remainder in DX

31
Arithmetic Instructions (contd)

• Signed division requires some help
• We extended an unsigned 16 bit number to 32 bits
  by placing zeros in the upper 16 bits
• This will not work for signed numbers
• To extend signed numbers, you have to copy the
  sign bit into those upper bit positions
• Pentium provides three instructions in aiding
  sign extension
• All three take no operands
• cbw converts byte to word (extends AL into AH)
• cwd converts word to doubleword (extends AX
  into DX)
• cdq converts doubleword to quadword
• (extends EAX into EDX)

32
Arithmetic Instructions (contd)

• Some additional related instructions
• Sign extension
• cwde converts word to doubleword
• (extends AX into EAX)
• Two move instructions
• movsx dest,src (move sign-extended src to
  dest)
• movzx dest,src (move zero-extended src to
  dest)
• For both move instructions, dest has to be a
  register
• The src operand can be in a register or memory
• If src is 8-bits, dest must be either a 16- or
  32-bit register
• If src is 16-bits, dest must be a 32-bit register

33
Arithmetic Instructions (contd)

• Example
• mov AL,-95
• cbw AH FFH
• mov CL,12
• idiv CL
• produces -7D in AL and -11D as remainder in AH
• Example
• mov AX,-5147
• cwd DX FFFFH
• mov CX,300
• idiv CX
• produces -17D in AX and -47D as remainder in DX

34
Arithmetic Instructions (contd)

• Use of Shifts for Multiplication and Division
• Shifts are more efficient
• Example Multiply AX by 32
• mov CX,32
• imul CX
• takes 12 clock cycles
• Using
• sal AX,5
• takes just one clock cycle

35
Application Examples

• PutInt8 procedure
• To display a number, repeatedly divide it by 10
  and display the remainders obtained
• quotient remainder
• 108/10 10 8
• 10/10 1 0
• 1/10 0 1
• To display digits, they must be converted to
  their character form
• This means simply adding the ASCII code for zero
• line 24 add AH,0

36
Application Examples (contd)

• GetInt8 procedure
• To read a number, read each digit character
• Convert to its numeric equivalent
• Multiply the running total by 10 and add this
  digit

37
Indirect Jumps

• Direct jump
• Target address is encoded in the instruction
  itself
• Indirect jump
• Introduces a level of indirection
• Address is specified either through memory of a
  general-purpose register
• Example
• jmp CX
• jumps to the address in CX
• Address is absolute
• Not relative as in direct jumps

38
Indirect Jumps (contd)

• Switch (ch)
• Case 0
• count0 break
• Case 1
• count1 break
• Case 2
• count2 break
• Case 3
• count3 break
• Default
• count3

39
Indirect Jumps (contd)

• Turbo C assembly code for the switch statement
• _main PROC NEAR
• . . .
• mov AL,ch
• cbw
• sub AX,48 48 ASCII for 0
• mov BX,AX
• cmp BX,3
• ja default
• shl BX,1 BX BX 2
• jmp WORD PTR CSjump_tableBX

Indirect jump
40
Indirect Jumps (contd)

• case_0 inc WORD PTR BP-10
• jmp SHORT end_switch
• case_1 inc WORD PTR BP-8
• jmp SHORT end_switch
• case_2 inc WORD PTR BP-6
• jmp SHORT end_switch
• case_3 inc WORD PTR BP-4
• jmp SHORT end_switch
• default inc WORD PTR BP-2
• end_switch
• . . .
• _main ENDP

41
Indirect Jumps (contd)

• jump_table LABEL WORD
• DW case_0
• DW case_1
• DW case_2
• DW case_3
• . . .
• Indirect jump uses this table to jump to the
  appropriate case routine
• The indirect jump instruction uses segment
  override prefix to refer to the jump_table in the
  CODE segment

Jump table for the indirect jump
42
Conditional Jumps

• Three types of conditional jumps
• Jumps based on the value of a single flag
• Arithmetic flags such as zero, carry can be
  tested using these instructions
• Jumps based on unsigned comparisons
• Operands of cmp instruction are treated as
  unsigned numbers
• Jumps based on signed comparisons
• Operands of cmp instruction are treated as signed
  numbers

43
Jumps Based on Single Flags

• Testing for zero
• jz jump if zero jumps if ZF 1
• je jump if equal jumps if ZF 1
• jnz jump if not zero jumps if ZF 0
• jne jump if not equal jumps if ZF 0
• jcxz jump if CX 0 jumps if CX 0
• (Flags are not tested)

44
Jumps Based on Single Flags (contd)

• Testing for carry
• jc jump if carry jumps if CF 1
• jnc jump if no carry jumps if CF 0
• Testing for overflow
• jo jump if overflow jumps if OF 1
• jno jump if no overflow jumps if OF 0
• Testing for sign
• js jump if negative jumps if SF 1
• jns jump if not negative jumps if SF 0

45
Jumps Based on Single Flags (contd)

• Testing for parity
• jp jump if parity jumps if PF 1
• jpe jump if parity jumps if PF 1
• is even
• jnp jump if not parity jumps if PF 0
• jpo jump if parity jumps if PF 0
• is odd

46
Jumps Based on Unsigned Comparisons

• Mnemonic Meaning Condition
• je jump if equal ZF 1
• jz jump if zero ZF 1
• jne jump if not equal ZF 0
• jnz jump if not zero ZF 0
• ja jump if above CF ZF 0
• jnbe jump if not below CF ZF 0
• or equal

47
Jumps Based on Unsigned Comparisons

• Mnemonic Meaning Condition
• jae jump if above CF 0
• or equal
• jnb jump if not below CF 0
• jb jump if below CF 1
• jnae jump if not above CF 1
• or equal
• jbe jump if below CF1 or ZF1
• or equal
• jna jump if not above CF1 or ZF1

48
Jumps Based on Signed Comparisons

• Mnemonic Meaning Condition
• je jump if equal ZF 1
• jz jump if zero ZF 1
• jne jump if not equal ZF 0
• jnz jump if not zero ZF 0
• jg jump if greater ZF0 SFOF
• jnle jump if not less ZF0 SFOF
• or equal

49
Jumps Based on Signed Comparisons (contd)

• Mnemonic Meaning Condition
• jge jump if greater SF OF
• or equal
• jnl jump if not less SF OF
• jl jump if less SF ? OF
• jnge jump if not greater SF ? OF
• or equal
• jle jump if less ZF1 or SF ? OF
• or equal
• jng jump if not greater ZF1 or SF ? OF

50
Implementing HLL Decision Structures

• High-level language decision structures can be
  implemented in a straightforward way
• See Section 12.4 for examples that implement
• if-then-else
• if-then-else with a relational operator
• if-then-else with logical operator AND
• if-then-else with logical operator OR
• while loop
• repeat-until loop
• for loops

51
Logical Expressions in HLLs

• Representation of Boolean data
• Only a single bit is needed to represent Boolean
  data
• Usually a single byte is used
• For example, in C
• All zero bits represents false
• A non-zero value represents true
• Logical expressions
• Logical instructions AND, OR, etc. are used
• Bit manipulation
• Logical, shift, and rotate instructions are used

52
Evaluation of Logical Expressions

• Two basic ways
• Full evaluation
• Entire expression is evaluated before assigning a
  value
• PASCAL uses full evaluation
• Partial evaluation
• Assigns as soon as the final outcome is known
  without blindly evaluating the entire logical
  expression
• Two rules help
• cond1 AND cond2
• If cond1 is false, no need to evaluate cond2
• cond1 OR cond2
• If cond1 is true, no need to evaluate cond2

53
Evaluation of Logical Expressions (contd)

• Partial evaluation
• Used by C
• Useful in certain cases to avoid run-time errors
• Example
• if ((X gt 0) AND (Y/X gt 100))
• If x is 0, full evaluation results in divide
  error
• Partial evaluation will not evaluate (Y/X gt 100)
  if X 0
• Partial evaluation is used to test if a pointer
  value is NULL before accessing the data it points
  to

54
Bit Instructions

• Bit Test and Modify Instructions
• Four bit test instructions
• Each takes the position of the bit to be tested
• Instruction Effect on the selected bit
• bt (Bit Test) No effect
• bts (Bit Test and Set) selected bit ? 1
• btr (Bit Test and Reset) selected bit ? 0
• btc selected bit ? NOT(selected bit)
• (Bit Test and Complement)

55
Bit Instructions (contd)

• All four instructions have the same format
• We use bt to illustrate the format
• bt operand,bit_pos
• operand is word or doubleword
• Can be in a register or memory
• bit_pos indicates the position of the bit to be
  tested
• Can be an immediate value or in a 16/32-bit
  register
• Instructions in this group affect only the carry
  flag
• Other five flags are undefined

56
Bit Scan Instructions

• These instructions scan the operand for a 1 bit
• return the bit position in a register
• Two instructions
• bsf dest_reg,operand bit scan forward
• bsr dest_reg,operand bit scan reverse
• operand can be a word or doubleword in a register
  or memory
• dest_reg receives the bit position
• Must be a 16- or 32-bit register
• Only ZF is updated (other five flags undefined)
• ZF 1 if all bits of operand are 0
• ZF 0 otherwise (position of first 1 bit in
  dest_reg)

57
Illustrative Examples

• Example 1
• Linear search of an integer array
• Example 2
• Selection sort on an integer array
• Example 3
• Multiplication using shift and add operations
• Multiplies two unsigned 8-bit numbers
• Uses a loop that iterates 8 times
• Example 4
• Multiplication using bit instructions

58
String Representation

• Two types
• Fixed-length
• Variable-length
• Fixed length strings
• Each string uses the same length
• Shorter strings are padded (e.g. by blank
  characters)
• Longer strings are truncated
• Selection of string length is critical
• Too large gt inefficient
• Too small gt truncation of larger strings

59
String Representation (contd)

• Variable-length strings
• Avoids the pitfalls associated with fixed-length
  strings
• Two ways of representation
• Explicitly storing string length (used in PASCAL)
• string DB Error message
• str_len DW -string
• represents the current value of the location
  counter
• points to the byte after the last character of
  string
• Using a sentinel character (used in C)
• Uses NULL character
• Such NULL-terminated strings are called ASCIIZ
  strings

60
String Instructions

• Five string instructions
• LODS LOaD String source
• STOS STOre String destination
• MOVS MOVe String source destination
• CMPS CoMPare String source destination
• SCAS SCAn String destination
• Specifying operands
• 32-bit segments
• DSESI source operand ESEDI destination
  operand
• 16-bit segments
• DSSI source operand ESDI destination
  operand

61
String Instructions (contd)

• Each string instruction
• Can operate on 8-, 16-, or 32-bit operands
• Updates index register(s) automatically
• Byte operands increment/decrement by 1
• Word operands increment/decrement by 2
• Doubleword operands increment/decrement by 4
• Direction flag
• DF 0 Forward direction (increments index
  registers)
• DF 1 Backward direction (decrements index
  registers)
• Two instructions to manipulate DF
• std set direction flag (DF 1)
• cld clear direction flag (DF 0)

62
Repetition Prefixes

• String instructions can be repeated by using a
  repetition prefix
• Two types
• Unconditional repetition
• rep REPeat
• Conditional repetition
• repe/repz REPeat while Equal
• REPeat while Zero
• repne/repnz REPeat while Not Equal
• REPeat while Not Zero

63
Repetition Prefixes (contd)

• rep
• while (CX ? 0)
• execute the string instruction
• CX CX-1
• end while
• CX register is first checked
• If zero, string instruction is not executed at
  all
• More like the JCXZ instruction

64
Repetition Prefixes (contd)

• repe/repz
• while (CX ? 0)
• execute the string instruction
• CX CX-1
• if (ZF 0)
• then
• exit loop
• end if
• end while
• Useful with cmps and scas string instructions

65
Repetition Prefixes (contd)

• repne/repnz
• while (CX ? 0)
• execute the string instruction
• CX CX-1
• if (ZF 1)
• then
• exit loop
• end if
• end while

66
String Move Instructions

• Three basic instructions
• movs, lods, and stos
• Move a string (movs)
• Format
• movs dest_string,source_string
• movsb operands are bytes
• movsw operands are words
• movsd operands are doublewords
• First form is not used frequently
• Source and destination pointed by DS(E)SI and
  ES(E)DI, respectively

67
String Move Instructions (contd)

• movsb --- move a byte string
• ESDI (DSSI) copy a byte
• if (DF0) forward direction
• then
• SI SI1
• DI DI1
• else backward direction
• SI SI-1
• DI DI-1
• end if
• Flags affected none

68
String Move Instructions (contd)

• Example
• .DATA
• string1 DB 'The original string',0
• strLen EQU - string1
• string2 DB 80 DUP (?)
• .CODE
• .STARTUP
• mov AX,DS set up ES
• mov ES,AX to the data segment
• mov CX,strLen strLen includes NULL
• mov SI,OFFSET string1
• mov DI,OFFSET string2
• cld forward direction
• rep movsb

69
String Move Instructions (contd)

• Load a String (LODS)
• Copies the value from the source string at
  DS(E)SI to
• AL (lodsb)
• AX (lodsw)
• EAX (lodsd)
• Repetition prefix does not make sense
• It leaves only the last value in AL, AX, or EAX
  register

70
String Move Instructions (contd)

• lodsb --- load a byte string
• AL (DSSI) copy a byte
• if (DF0) forward direction
• then
• SI SI1
• else backward direction
• SI SI-1
• end if
• Flags affected none

71
String Move Instructions (contd)

• Store a String (STOS)
• Performs the complementary operation
• Copies the value in
• AL (lodsb)
• AX (lodsw)
• EAX (lodsd)
• to the destination string at ES(E)DI
• Repetition prefix can be used to initialize a
  block of memory

72
String Move Instructions (contd)

• stosb --- store a byte string
• ESDI AL copy a byte
• if (DF0) forward direction
• then
• DI DI1
• else backward direction
• DI DI-1
• end if
• Flags affected none

73
String Move Instructions (contd)

• Example Initializes array1 with -1
• .DATA
• array1 DW 100 DUP (?)
• .CODE
• .STARTUP
• mov AX,DS set up ES
• mov ES,AX to the data segment
• mov CX,100
• mov DI,OFFSET array1
• mov AX,-1
• cld forward direction
• rep stosw

74
String Move Instructions (contd)

• In general, repeat prefixes are not useful with
  lods and stos
• Used in a loop to do conversions while copying
• mov CX,strLen
• mov SI,OFFSET string1
• mov DI,OFFSET string2
• cld forward direction
• loop1
• lodsb
• or AL,20H
• stosb
• loop loop1
• done

75
String Compare Instruction

• cmpsb --- compare two byte strings
• Compare two bytes at DSSI and ESDI and set
  flags
• if (DF0) forward direction
• then
• SI SI1
• DI DI1
• else backward direction
• SI SI-1
• DI DI-1
• end if
• Flags affected As per cmp instruction
  (DSSI)-(ESDI)

76
String Compare Instruction (contd)

• .DATA
• string1 DB 'abcdfghi',0
• strLen EQU - string1
• string2 DB 'abcdefgh',0
• .CODE
• .STARTUP
• mov AX,DS set up ES
• mov ES,AX to the data segment
• mov CX,strLen
• mov SI,OFFSET string1
• mov DI,OFFSET string2
• cld forward direction
• repe cmpsb
• dec SI
• dec DI leaves SI DI pointing to the
  last character that differs

77
String Compare Instruction (contd)

• .DATA
• string1 DB 'abcdfghi',0
• strLen EQU - string1 - 1
• string2 DB 'abcdefgh',0
• .CODE
• .STARTUP
• mov AX,DS set up ES
• mov ES,AX to the data segment
• mov CX,strLen
• mov SI,OFFSET string1 strLen - 1
• mov DI,OFFSET string2 strLen - 1
• std backward direction
• repne cmpsb
• inc SI Leaves SI DI pointing to the
  first character that matches
• inc DI in the backward direction

78
String Scan Instruction

• scasb --- Scan a byte string
• Compare AL to the byte at ESDI and set flags
• if (DF0) forward direction
• then
• DI DI1
• else backward direction
• DI DI-1
• end if
• Flags affected As per cmp instruction
  (DSSI)-(ESDI)
• scasw uses AX and scasd uses EAX registers
  instead of AL

79
String Scan Instruction (contd)

• .DATA
• string1 DB 'abcdefgh',0
• strLen EQU - string1
• .CODE
• .STARTUP
• mov AX,DS set up ES
• mov ES,AX to the data segment
• mov CX,strLen
• mov DI,OFFSET string1
• mov AL,'e' character to be searched
• cld forward direction
• repne scasb
• dec DI leaves DI pointing to e in
  string1

Example 1
80
String Scan Instruction (contd)

• .DATA
• string1 DB ' abc',0
• strLen EQU - string1
• .CODE
• .STARTUP
• mov AX,DS set up ES
• mov ES,AX to the data segment
• mov CX,strLen
• mov DI,OFFSET string1
• mov AL,' ' character to be
  searched
• cld forward direction
• repe scasb
• dec DI leaves DI pointing to the first
  non-blank character a

Example 2
81
Illustrative Examples

• LDS and LES instructions
• String pointer can be loaded into DS/SI or ES/DI
  register pair by using lds or les instructions
• Syntax
• lds register,source
• les register,source
• register should be a 16-bit register
• source is a pointer to a 32-bit memory operand
• register is typically SI in lds and DI in les

82
Illustrative Examples (contd)

• Actions of lds and les
• lds
• register (source)
• DS (source2)
• les
• register (source)
• ES (source2)
• Pentium also supports lfs, lgs, and lss to load
  the other segment registers

83
Illustrative Examples (contd)

• Seven popular string processing routines are
  given as examples in string.asm
• str_len
• str_mov
• str-cpy
• str_cat
• str_cmp
• str_chr
• str_cnv

Given in the text
84
Indirect Procedure Call

• Direct procedure calls specify the offset of the
  first instruction of the called procedure
• In indirect procedure call, the offset is
  specified through memory or a register
• If BX contains pointer to the procedure, we can
  use
• call BX
• If the word in memory at target_proc_ptr contains
  the offset of the called procedure, we can use
• call target_proc_ptr
• These are similar to direct and indirect jumps

Last slide