Selected Pentium Instructions Chapter 12 S. Dandamudi

Selected Pentium Instructions

Chapter 12

S. Dandamudi

2003

To be used with S. Dandamudi, “Fundamentals of Computer Organization and Design,” Springer, 2003.

S. Dandamudi Chapter 12: Page 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

2003



Outline (cont’d)

• 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

2003



Status Flags

2003



Status Flags (cont’d)

• 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

2003




• 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)

2003




• 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 instructionsjz jump if zero (jump if ZF = 1)

jnz jump if not zero (jump if ZF = 0)

2003




• 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

2003




• 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,Mouter_loop: mov CX,Ninner_loop: inc AX loop inner_loop dec DX jnz outer_loopexit_loops: mov sum,AX

2003




• 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

2003




• 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 (2321)

2003




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)

2003




• Uses of carry flag To propagate carry/borrow in multiword

addition/subtraction 1 carry from lower 32 bitsx = 3710 26A8 1257 9AE7Hy = 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

2003




• 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

flagmov AL,72H ; 72H = 114Dadd 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)

2003




Unsigned interpretation

mov AL,72Hadd AL,0EHjc overflow

no_overflow:

(no overflow code here) . . . .

overflow:

(overflow code here) . . . .

Signed interpretation

mov AL,72Hadd AL,0EHjo overflow

no_overflow:

(no overflow code here) . . . .

overflow:

(overflow code here) . . . .

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

2003




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

2003




• 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

Examplesmov AL,15 mov AL,15add AL,97 sub AL,97clears the sign flag as sets the sign flag asthe result is 112 the result is 82(or 0111000 in binary) (or 10101110 in binary)

Related instructionsjs jump if sign (jump if SF = 1)jns jump if no sign (jump if SF = 0)

2003




• Consider the count down loop:

for (i = M downto 0)

<loop body>

end for

• If we don’t 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:

<loop body>

dec CX

jns for_loop

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

2003




• 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 doesn’t 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

2003




Related instructions» No conditional jump instructions with this flag» Arithmetic operations on BCD numbers use this flag

aaa ASCII adjust for additionaas ASCII adjust for subtractionaam ASCII adjust for multiplicationaad ASCII adjust for divisiondaa Decimal adjust for additiondas Decimal adjust for subtraction

– Appendices I has more details on these instructions Usage

» Main use is in performing arithmetic operations on BCD numbers

2003




• 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 0101Badd AL,89 89D = 0101 1001B 142D = 1000 1110B» As the result has even number of 1 bits, parity flag is set

Related instructionsjp jump on even parity (jump if PF = 1)jnp jump on odd parity (jump if PF = 0)

2003




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 ALparity_encode ENDP

2003



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

2003



Arithmetic Instructions (cont’d)

• 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

2003




• Unsigned multiplicationmul source» Depending on the source operand size, the location of the

other source operand and destination are selected

2003




Examplemov AL,10mov DL,25mul DL

produces 250D in AX register (result fits in AL)

• The imul instruction can use the same syntax» Also supports other formats

Examplemov DL,0FFH ; DL = -1mov AL,0BEH ; AL = -66imul DL

produces 66D in AX register (again, result fits in AL)

2003




• 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 possiblePentium provides a special software interrupt when a

divide overflow occurs

Two instructions as in multiplicationdiv source for unsigned numbers

idiv source for signed numbers

2003




• Dividend is twice the size of the divisor

• Dividend is assumed to be in AX (8-bit divisor) DX:AX (16-bit divisor) EDX:EAX (32-bit divisor)

2003




2003




• Examplemov AX,251mov CL,12div CL

produces 20D in AL and 11D as remainder in AH

• Examplesub DX,DX ; clear DX

mov AX,141BH ; AX = 5147Dmov CX,012CH ; CX = 300Ddiv CX

produces 17D in AX and 47D as remainder in DX

2003




• 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)

2003




Some additional related instructions

» Sign extensioncwde converts word to doubleword (extends AX into EAX)

» Two move instructionsmovsx 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

2003




• Examplemov AL,-95cbw ; AH = FFHmov CL,12idiv CL

produces 7D in AL and 11D as remainder in AH

• Examplemov AX,-5147cwd ; DX := FFFFHmov CX,300idiv CX

produces 17D in AX and 47D as remainder in DX

2003




• 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

2003



Application Examples

• PutInt8 procedure To display a number, repeatedly divide it by 10 and

display the remainders obtainedquotient 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’

2003



Application Examples (cont’d)

• 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

Input digit Numericvalue (N)

Number := Number*10 + N

Initial value -- 0‘1’ 1 0 * 10 + 1 = 1‘5’ 5 1 * 10 + 5 = 15‘8’ 8 15 * 10 + 8 = 158

2003



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 CXjumps to the address in CX

Address is absolute» Not relative as in direct jumps

2003



Indirect Jumps (cont’d)

Switch (ch) {

Case ’0’:

count[0]++; break;

Case ’1’:

count[1]++; break;

Case ’2’:

count[2]++; break;

Case ’3’:

count[3]++; break;

Default:

count[3]++;

}

2003




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 CS:jump_table[BX]

Indirect jump

2003




case_0: inc WORD PTR [BP-10]

jmp SHORT end_switch







default: inc WORD PTR [BP-2]

end_switch:

. . .

_main ENDP

2003




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

2003



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

2003



Jumps Based on Single Flags

Testing for zerojz 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)

2003



Jumps Based on Single Flags (cont’d)

Testing for carryjc jump if carry jumps if CF = 1

jnc jump if no carry jumps if CF = 0

Testing for overflowjo jump if overflow jumps if OF = 1

jno jump if no overflow jumps if OF = 0

Testing for signjs jump if negative jumps if SF = 1

jns jump if not negative jumps if SF = 0

2003



Jumps Based on Single Flags (cont’d)

Testing for parityjp jump if parity jumps if PF = 1

jpe jump if parity jumps if PF = 1is even

jnp jump if not parity jumps if PF = 0

jpo jump if parity jumps if PF = 0is odd

2003



Jumps Based on Unsigned Comparisons

Mnemonic Meaning Conditionje jump if equal ZF = 1jz jump if zero ZF = 1

jne jump if not equal ZF = 0jnz jump if not zero ZF = 0

ja jump if above CF = ZF = 0jnbe jump if not below CF = ZF = 0

or equal

2003



Jumps Based on Unsigned Comparisons

Mnemonic Meaning Conditionjae jump if above CF = 0

or equaljnb jump if not below CF = 0

jb jump if below CF = 1jnae jump if not above CF = 1

or equal

jbe jump if below CF=1 or ZF=1or equal

jna jump if not above CF=1 or ZF=1

2003



Jumps Based on Signed Comparisons

Mnemonic Meaning Conditionje jump if equal ZF = 1jz jump if zero ZF = 1

jne jump if not equal ZF = 0jnz jump if not zero ZF = 0

jg jump if greater ZF=0 & SF=OFjnle jump if not less ZF=0 & SF=OF

or equal

2003



Jumps Based on Signed Comparisons (cont’d)

Mnemonic Meaning Condition

jge jump if greater SF = OF or equal

jnl jump if not less SF = OF

jl jump if less SF OFjnge jump if not greater SF OF

or equal

jle jump if less ZF=1 or SF OF or equal

jng jump if not greater ZF=1 or SF OF

2003



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

2003



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

2003



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

2003



Evaluation of Logical Expressions (cont’d)

• Partial evaluation Used by C

• Useful in certain cases to avoid run-time errors• Example

if ((X > 0) AND (Y/X > 100))

If x is 0, full evaluation results in divide error Partial evaluation will not evaluate (Y/X > 100) if X = 0

• Partial evaluation is used to test if a pointer value is NULL before accessing the data it points to

2003



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)

2003



Bit Instructions (cont’d)

• 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

2003



Bit Scan Instructions

• These instructions scan the operand for a 1 bit return the bit position in a register

• Two instructionsbsf 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)

2003



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

2003



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 ==> inefficient

» Too small ==> truncation of larger strings

2003



String Representation (cont’d)

• 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

2003



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:

DS:ESI = source operand ES:EDI = destination operand

16-bit segments:DS:SI = source operand ES:DI = destination operand

2003



String Instructions (cont’d)

• 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 DFstd set direction flag (DF = 1)cld clear direction flag (DF = 0)

2003



Repetition Prefixes

• String instructions can be repeated by using a repetition prefix

• Two types Unconditional repetition

rep REPeat

Conditional repetitionrepe/repz REPeat while Equal

REPeat while Zero

repne/repnz REPeat while Not Equal

REPeat while Not Zero

2003



Repetition Prefixes (cont’d)

repwhile (CX 0)

execute the string instruction

CX := CX1end while

• CX register is first checked If zero, string instruction is not executed at all More like the JCXZ instruction

2003




repe/repzwhile (CX 0)


CX := CX1if (ZF = 0)

then

exit loop

end if

end while

• Useful with cmps and scas string instructions

2003




repne/repnz

while (CX 0)


CX := CX1if (ZF = 1)

then

exit loop

end if

end while

2003



String Move Instructions

• Three basic instructions movs, lods, and stos

Move a string (movs)• Format

movs dest_string,source_stringmovsb ; operands are bytesmovsw ; operands are wordsmovsd ; operands are doublewords

• First form is not used frequently

Source and destination pointed by DS:(E)SI and ES:(E)DI, respectively

2003



String Move Instructions (cont’d)

movsb --- move a byte stringES:DI := (DS:SI) ; copy a byteif (DF=0) ; forward direction then

SI := SI+1 DI := DI+1

else ; backward directionSI := SI1DI := DI1

end ifFlags affected: none

2003




Example.DATAstring1 DB 'The original string',0strLen EQU $ - string1string2 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

2003




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

2003




lodsb --- load a byte stringAL := (DS:SI) ; copy a byte

if (DF=0) ; forward direction

thenSI := SI+1

else ; backward directionSI := SI1

end if

Flags affected: none

2003




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

2003




stosb --- store a byte stringES:DI := AL ; copy a byteif (DF=0) ; forward direction then

DI := DI+1 else ; backward direction

DI := DI1end if

Flags affected: none

2003




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

2003




• 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 directionloop1: lodsb or AL,20H stosb loop loop1done:

2003



String Compare Instruction

cmpsb --- compare two byte stringsCompare two bytes at DS:SI and ES:DI and set flags

if (DF=0) ; forward direction then

SI := SI+1 DI := DI+1

else ; backward directionSI := SI1DI := DI1

end if

Flags affected: As per cmp instruction (DS:SI)(ES:DI)

2003



String Compare Instruction (cont’d)

.DATAstring1 DB 'abcdfghi',0strLen EQU $ - string1string2 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

2003



String Compare Instruction (cont’d)

.DATAstring1 DB 'abcdfghi',0strLen EQU $ - string1 - 1string2 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

2003



String Scan Instruction

scasb --- Scan a byte stringCompare AL to the byte at ES:DI and set

flagsif (DF=0) ; forward direction then

DI := DI+1 else ; backward direction

DI := DI1end if

Flags affected: As per cmp instruction (DS:SI)-(ES:DI)• scasw uses AX and scasd uses EAX registers instead of

AL

2003



String Scan Instruction (cont’d)

.DATAstring1 DB 'abcdefgh',0strLen 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

2003



String Scan Instruction (cont’d)

.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

2003



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,sourceles 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

2003



Illustrative Examples (cont’d)

• Actions of lds and les

ldsregister := (source)

DS := (source+2)

lesregister := (source)

ES := (source+2)

• Pentium also supports lfs, lgs, and lss to load the other segment registers

2003



Illustrative Examples (cont’d)

• 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

2003



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 jumpsLast slide

Documents

Selected Pentium Instructions Chapter 12 S. Dandamudi