Presentation Outline

Basic Instructions
Addressing Modes
Operand Types

Data Transfer Instructions
Computer Organization
Addition and Subtraction
&
Addressing Modes
Assembly Language Programming
Jump and Loop Instructions

Copying a String

Summing an Array of Integers
Dr Adnan Gutub
aagutub at uqu.edu.sa
[Adapted from slides of Dr. Kip Irvine: Assembly Language for Intel-Based Computers]
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55
Most Slides contents have been arranged by Dr Muhamed Mudawar & Dr Aiman El-Maleh from Computer Engineering Dept. at KFUPM

Three Basic Types of Operands Instruction Operand Notation

Immediate Operand Description
r8 8-bit general-purpose register: AH, AL, BH, BL, CH, CL, DH, DL

Constant integer (8, 16, or 32 bits)
r16 16-bit general-purpose register: AX, BX, CX, DX, SI, DI, SP, BP

Constant value is stored within the instruction r32 32-bit general-purpose register: EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP

Register reg Any general-purpose register

sreg 16-bit segment register: CS, DS, SS, ES, FS, GS

Name of a register is specified
imm 8-, 16-, or 32-bit immediate value

Register number is encoded within the instruction imm8 8-bit immediate byte value

Memory imm16 16-bit immediate word value

imm32 32-bit immediate doubleword value

Reference to a location in memory
r/m8 8-bit operand which can be an 8-bit general-purpose register or memory byte

Memory address is encoded within the instruction, or r/m16 16-bit operand which can be a 16-bit general-purpose register or memory word

Register holds the address of a memory location r/m32 32-bit operand which can be a 32-bit general register or memory doubleword
mem 8-, 16-, or 32-bit memory operand
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Next . . . MOV Instruction

Move source operand to destination

Operand Types mov destination, source

Data Transfer Instructions
Source and destination operands can vary

Addition and Subtraction mov reg, reg
Rules
mov mem, reg

Addressing Modes Both operands must be of same size
mov reg, mem

Jump and Loop Instructions mov mem, imm No memory to memory moves

mov reg, imm No immediate to segment moves

Copying a String
mov r/m16, sreg No segment to segment moves

Summing an Array of Integers
mov sreg, r/m16 Destination cannot be CS

Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

1
 MOV Examples Zero Extension
.DATA
MOVZX Instruction
count BYTE 100
bVal BYTE 20
Fills (extends) the upper part of the destination with zeros
wVal WORD 2

Used to copy a small source into a larger destination
dVal DWORD 5
.CODE
Destination must be a register
mov bl, count ; bl = count = 100 movzx r32, r/m8
mov ax, wVal ; ax = wVal = 2
mov count,al ; count = al = 2 movzx r32, r/m16
mov eax, dval ; eax = dval = 5 movzx r16, r/m8
; Assembler will not accept the following moves why?
0 10001111 Source
mov ds, 45 ; immediate move to DS not permitted
mov esi, wVal ; size mismatch
mov eip, dVal ; EIP cannot be the destination
mov bl, 8Fh
mov 25, bVal ; immediate value cannot be destination
mov bVal,count ; memory-to-memory move not permitted
00000000 10001111 Destination movzx ax, bl
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Sign Extension XCHG Instruction

MOVSX Instruction
XCHG exchanges the values of two operands

Fills (extends) the upper part of the destination register with a xchg reg, reg
copy of the source operand's sign bit Rules
xchg reg, mem

Used to copy a small source into a larger destination Operands must be of the same size
xchg mem, reg
movsx r32, r/m8 At least one operand must be a register
.DATA No immediate operands are permitted
movsx r32, r/m16
var1 DWORD 10000000h
movsx r16, r/m8 var2 DWORD 20000000h
.CODE
10001111 Source
xchg ah, al ; exchange 8-bit regs
xchg ax, bx ; exchange 16-bit regs
xchg eax, ebx ; exchange 32-bit regs
mov bl, 8Fh xchg var1,ebx ; exchange mem, reg
11111111 10001111 Destination movsx ax, bl xchg var1,var2 ; error: two memory operands

Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Direct Memory Operands Direct-Offset Operands

Variable names are references to locations in memory
Direct-Offset Operand: Constant offset is added to a

Direct Memory Operand: named memory location to produce an effective address

Assembler computes the effective address
Named reference to a memory location

Lets you access memory locations that have no name

Assembler computes address (offset) of named variable
.DATA
.DATA arrayB BYTE 10h,20h,30h,40h
var1 BYTE 10h .CODE
Direct Memory Operand mov al, arrayB+1 ; AL = 20h
.CODE
mov al,[arrayB+1] ; alternative notation
mov al, var1 ; AL = var1 = 10h
mov al, arrayB[1] ; yet another notation
mov al,[var1] ; AL = var1 = 10h

Q: Why doesn't arrayB+1 produce 11h?

Alternate Format

Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

2
 Direct-Offset Operands - Examples Your Turn . . .
.DATA Given the following definition of arrayD
arrayW WORD 1020h, 3040h, 5060h
.DATA
arrayD DWORD 1, 2, 3, 4
arrayD DWORD 1,2,3
.CODE
mov ax, arrayW+2 ; AX = 3040h Rearrange the three values in the array as: 3, 1, 2
mov ax, arrayW[4] ; AX = 5060h
mov eax,[arrayD+4] ; EAX = 00000002h Solution:
mov eax,[arrayD-3] ; EAX = 01506030h ; Copy first array value into EAX
mov ax, [arrayW+9] ; AX = 0200h
mov eax, arrayD ; EAX = 1
mov ax, [arrayD+3] ; Error: Operands are not same size
mov ax, [arrayW-2]
; Exchange EAX with second array element
; AX = ? Out-of-range address
mov eax,[arrayD+16] ; EAX = ? MASM does not detect error xchg eax, arrayD[4] ; EAX = 2, arrayD = 1,1,3
; Exchange EAX with third array element
1020 3040 5060 1 2 3 4 xchg eax, arrayD[8] ; EAX = 3, arrayD = 1,1,2
20 10 40 30 60 50 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 ; Copy value in EAX to first array element
+1 +2 +3 +4 +5 +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 mov arrayD, eax ; arrayD = 3,1,2
arrayW arrayD
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Next . . . ADD and SUB Instructions

ADD destination, source

Operand Types destination = destination + source

Data Transfer Instructions

SUB destination, source

Addition and Subtraction
destination = destination source

Addressing Modes

Jump and Loop Instructions
Destination can be a register or a memory location

Copying a String
Source can be a register, memory location, or a constant

Summing an Array of Integers

Destination and source must be of the same size

Memory-to-memory arithmetic is not allowed

Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Evaluate this . . . Flags Affected

Write a program that adds the following three words:
.DATA
array WORD 890Fh,1276h,0AF5Bh

Solution: Accumulate the sum in the AX register ADD and SUB affect all the six status flags:
mov ax, array
add ax,[array+2] 1. Carry Flag: Set when unsigned arithmetic result is out of range
add ax,[array+4] ; what if sum cannot fit in AX? 2. Overflow Flag: Set when signed arithmetic result is out of range
Solution 2: Accumulate the sum in the EAX register 3. Sign Flag: Copy of sign bit, set when result is negative
movzx eax, array ; error to say: mov eax,array
4. Zero Flag: Set when result is zero
movzx ebx, array[2] ; use movsx for signed integers
add eax, ebx ; error to say: add eax,array[2] 5. Auxiliary Carry Flag: Set when there is a carry from bit 3 to bit 4
movzx ebx, array[4]
add eax, ebx 6. Parity Flag: Set when parity in least-significant byte is even
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

3
 More on Carry and Overflow Hardware Viewpoint

Addition: A + B
CPU cannot distinguish signed from unsigned integers

The Carry flag is the carry out of the most significant bit
YOU, the programmer, give a meaning to binary numbers

The Overflow flag is only set when . . .
How the ADD instruction modifies OF and CF:

Two positive operands are added and their sum is negative
CF = (carry out of the MSB) MSB = Most Significant Bit

Two negative operands are added and their sum is positive

OF = (carry out of the MSB) XOR (carry into the MSB)

Overflow cannot occur when adding operands of opposite signs

Hardware does SUB by XOR = eXclusive-OR operation

Subtraction: A B

ADDing destination to the 2's complement of the source operand

For Subtraction, the carry flag becomes the borrow flag

How the SUB instruction modifies OF and CF:

Carry flag is set when A has a smaller unsigned value than B

Negate (2's complement) the source and ADD it to destination

The Overflow flag is only set when . . .

A and B have different signs and sign of result sign of A
OF = (carry out of the MSB) XOR (carry into the MSB)

Overflow cannot occur when subtracting operands of the same sign
CF = INVERT (carry out of the MSB)
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

ADD and SUB Examples INC, DEC, and NEG Instructions

For each of the following marked entries, show the values
INC destination
of the destination operand and the six status flags:
destination = destination + 1

More compact (uses less space) than: ADD destination, 1
mov al,0FFh ; AL=-1
add al,1 ; AL=00h CF= 1 OF= 0 SF= 0 ZF=1 AF= 1 PF=1
DEC destination
sub al,1 ; AL=FFh CF= 1 OF= 0 SF= 1 ZF=0 AF= 1 PF=1
mov al,+127 ; AL=7Fh
destination = destination 1
add al,1 ; AL=80h CF= 0 OF= 1 SF= 1 ZF=0 AF= 1 PF=0
More compact (uses less space) than: SUB destination, 1
mov al,26h
sub al,95h ; AL=91h CF= 1 OF= 1 SF= 1 ZF=0 AF= 0 PF=0

NEG destination

destination = 2's complement of destination
1 0 0 1 0 0 0 1 0 1 1 0 1 1 1 0

0 0 1 0 0 1 1 0 26h (38) 0 0 1 0 0 1 1 0 26h (38)
Destination can be 8-, 16-, or 32-bit operand
+
1 0 0 1 0 1 0 1 95h (-107) 0 1 1 0 1 0 1 1 6Bh (107)
In memory or a register
1 0 0 1 0 0 0 1 91h (-111) 1 0 0 1 0 0 0 1 91h (-111)
NO immediate operand
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Affected Flags ADC and SBB Instruction

INC and DEC affect five status flags
ADC Instruction: Addition with Carry

Overflow, Sign, Zero, Auxiliary Carry, and Parity ADC destination, source

Carry flag is NOT modified
destination = destination + source + CF

NEG affects all the six status flags

SBB Instruction: Subtract with Borrow

Any nonzero operand causes the carry flag to be set
SBB destination, source
.DATA
B SBYTE -1 ; 0FFh destination = destination - source CF
C SBYTE 127 ; 7Fh

Destination can be a register or a memory location
.CODE
inc B ; B=0 OF=0 SF=0 ZF=1 AF=1 PF=1
Source can be a register, memory location, or a constant
dec B ; B=-1=FFh OF=0 SF=1 ZF=0 AF=1 PF=1
inc C ; C=-128=80h OF=1 SF=1 ZF=0 AF=1 PF=0
Destination and source must be of the same size
neg C ; C=-128 CF=1 OF=1 SF=1 ZF=0 AF=0 PF=0

Memory-to-memory arithmetic is not allowed
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

4
 Extended Arithmetic Next . . .

ADC and SBB are useful for extended arithmetic

Example: 64-bit addition
Operand Types

Assume first 64-bit integer operand is stored in EBX:EAX
Data Transfer Instructions

Second 64-bit integer operand is stored in EDX:ECX
Addition and Subtraction

Solution:
Addressing Modes
add eax, ecx ;add lower 32 bits
Jump and Loop Instructions
adc ebx, edx ;add upper 32 bits + carry
Copying a String
64-bit result is in EBX:EAX
Summing an Array of Integers

STC and CLC Instructions

Used to Set and Clear the Carry Flag
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Addressing Modes Register and Immediate Addressing

Two Basic Questions
Register Addressing

Where are the operands?
Most efficient way of specifying an operand: no memory access

How memory addresses are computed?
Shorter Instructions: fewer bits are needed to specify register

Intel IA-32 supports 3 fundamental addressing modes
Compilers use registers to optimize code

Register addressing: operand is in a register
Immediate Addressing

Immediate addressing: operand is stored in the instruction itself
Used to specify a constant

Memory addressing: operand is in memory
Immediate constant is part of the instruction

Memory Addressing
Efficient: no separate operand fetch is needed

Variety of addressing modes
Examples

Direct and indirect addressing mov eax, ebx ; register-to-register move

Support high-level language constructs and data structures add eax, 5 ; 5 is an immediate constant
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Direct Memory Addressing Register Indirect Addressing

Used to address simple variables in memory
Problem with Direct Memory Addressing

Variables are defined in the data section of the program
Causes problems in addressing arrays and data structures

We use the variable name (label) to address memory directly
Does not facilitate using a loop to traverse an array

Assembler computes the offset of a variable
Indirect memory addressing solves this problem

The variable offset is specified directly as part of the instruction
Register Indirect Addressing

Example
The memory address is stored in a register
.data
Brackets [ ] used to surround the register holding the address
var1 DWORD 100
For 32-bit addressing, any 32-bit register can be used
var2 DWORD 200
sum DWORD ?
Example
.code mov ebx, OFFSET array ; ebx contains the address
mov eax, var1 mov eax, [ebx] ; [ebx] used to access memory
add eax, var2 var1, var2, and sum are
mov sum, eax direct memory operands EBX contains the address of the operand, not the operand itself
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

5
 Array Sum Example Ambiguous Indirect Operands

Indirect addressing is ideal for traversing an array
Consider the following instructions:
.data mov [EBX], 100
array DWORD 10000h,20000h,30000h add [ESI], 20
.code
inc [EDI]
mov esi, OFFSET array ; esi = array address
mov eax,[esi] ; eax = [array] = 10000h
Where EBX, ESI, and EDI contain memory addresses
add esi,4 ; why 4?
The size of the memory operand is not clear to the assembler
add eax,[esi] ; eax = eax + [array+4]

EBX, ESI, and EDI can be pointers to BYTE, WORD, or DWORD
add esi,4 ; why 4?
add eax,[esi] ; eax = eax + [array+8]
Solution: use PTR operator to clarify the operand size
mov BYTE PTR [EBX], 100 ; BYTE operand in memory

Note that ESI register is used as a pointer to array

ESI must be incremented by 4 to access the next array element add WORD PTR [ESI], 20 ; WORD operand in memory

Because each array element is 4 bytes (DWORD) in memory inc DWORD PTR [EDI] ; DWORD operand in memory
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Indexed Addressing Index Scaling

Combines a displacement (nameconstant) with an
Useful to index array elements of size 2, 4, and 8 bytes
index register
Syntax: [disp + index * scale] or disp [index * scale]

Assembler converts displacement into a constant offset

Effective address is computed as follows:

Constant offset is added to register to form an effective address

Disp.'s offset + Index register * Scale factor

Syntax: [disp + index] or disp [index]
.DATA
.data arrayB BYTE 10h,20h,30h,40h
array DWORD 10000h,20000h,30000h arrayW WORD 100h,200h,300h,400h
.code arrayD DWORD 10000h,20000h,30000h,40000h
mov esi, 0 ; esi = array index .CODE
mov eax,array[esi] ; eax = array[0] = 10000h mov esi, 2
add esi,4 mov al, arrayB[esi] ; AL = 30h
add eax,array[esi] ; eax = eax + array[4] mov ax, arrayW[esi*2] ; AX = 300h
add esi,4 mov eax, arrayD[esi*4] ; EAX = 30000h
add eax,[array+esi]
Basic Instructions & Addressing Modes
; eax = eax + array[8]slide /55
Computer Organization & Assembly Language Programming Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Based Addressing Based-Indexed Addressing

Syntax: [Base + disp.]
Syntax: [Base + (Index * Scale) + disp.]

Effective Address = Base register + Constant Offset
Scale factor is optional and can be 1, 2, 4, or 8

Useful to access fields of a structure or an object
Useful in accessing two-dimensional arrays

Base Register points to the base address of the structure
Offset: array address => we can refer to the array by name

Constant Offset relative offset within the structure
Base register: holds row address => relative to start of array

Index register: selects an element of the row => column index
.DATA mystruct is a structure
mystruct WORD 12 consisting of 3 fields:
Scaling factor: when array element size is 2, 4, or 8 bytes
DWORD 1985 a word, a double
BYTE 'M' word, and a byte

Useful in accessing arrays of structures (or objects)
.CODE
Base register: holds the address of the array
mov ebx, OFFSET mystruct
mov eax, [ebx+2] ; EAX = 1985
Index register: holds the element address relative to the base
mov al, [ebx+6] ; AL = 'M'

Offset: represents the offset of a field within a structure
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

6
 Based-Indexed Examples LEA Instruction
.data
LEA = Load Effective Address
matrix DWORD 0, 1, 2, 3, 4 ; 4 rows, 5 cols
DWORD 10,11,12,13,14 LEA r32, mem (Flat-Memory)
DWORD 20,21,22,23,24 LEA r16, mem (Real-Address Mode)
DWORD 30,31,32,33,34

Calculate and load the effective address of a memory operand
ROWSIZE EQU SIZEOF matrix ; 20 bytes per row
Flat memory uses 32-bit effective addresses
.code
Real-address mode uses 16-bit effective addresses
mov ebx, 2*ROWSIZE ; row index = 2
LEA is similar to MOV OFFSET, except that:
mov esi, 3 ; col index = 3
mov eax, matrix[ebx+esi*4] ; EAX = matrix[2][3]
OFFSET operator is executed by the assembler

Used with named variables: address is known to the assembler
mov ebx, 3*ROWSIZE ; row index = 3

LEA instruction computes effective address at runtime
mov esi, 1 ; col index = 1
mov eax, matrix[ebx+esi*4] ; EAX = matrix[3][1]
Used with indirect operands: effective address is known at runtime

Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

LEA Examples Summary of Addressing Modes

.data Assembler converts a variable name into a
array WORD 1000 DUP(?) constant offset (called also a displacement)

.code ; Equivalent to . . . For indirect addressing, a base/index

lea eax, array ; mov eax, OFFSET array register contains an address/index

lea eax, array[esi] ; mov eax, esi CPU computes the effective
; add eax, OFFSET array address of a memory operand

lea eax, array[esi*2] ; mov eax, esi

; add eax, eax
; add eax, OFFSET array

lea eax, [ebx+esi*2] ; mov eax, esi

; add eax, eax
; add eax, ebx
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Registers Used in 32-Bit Addressing 16-bit Memory Addressing

32-bit addressing modes use the following 32-bit registers Old 16-bit Used with real-address mode
addressing
Base + ( Index * Scale ) + displacement Only 16-bit registers are used
mode
EAX EAX 1 no displacement No Scale Factor
EBX EBX 2 8-bit displacement
ECX ECX 4 32-bit displacement
EDX EDX 8
ESI ESI Only the index register can
have a scale factor
EDI EDI Only BX or BP can be the base register
ESP can be used as a base
EBP EBP Only SI or DI can be the index register
register, but not as an index
ESP Displacement can be 0, 8, or 16 bits
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

7
 Default Segments Next . . .

When 32-bit register indirect addressing is used

Address in EAX, EBX, ECX, EDX, ESI, and EDI is relative to DS
Operand Types

Address in EBP and ESP is relative to SS

Data Transfer Instructions

In flat-memory model, DS and SS are the same segment

Therefore, no need to worry about the default segment
Addition and Subtraction

When 16-bit register indirect addressing is used
Addressing Modes

Address in BX, SI, or DI is relative to the data segment DS
Jump and Loop Instructions

Address in BP is relative to the stack segment SS

Copying a String

In real-address mode, DS and SS can be different segments

Summing an Array of Integers

We can override the default segment using segment
prefix

mov ax, ss:[bx] ; address in bx is relative to stack segment

mov ax, ds:[bp]
Basic Instructions & Addressing Modes ; address in bp is relative to data segment
slide /55
Computer Organization & Assembly Language Programming Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

JMP Instruction LOOP Instruction

JMP is an unconditional jump to a destination instruction
The LOOP instruction creates a counting loop

Syntax: JMP destination
Syntax: LOOP destination

JMP causes the modification of the EIP register
Logic: ECX ECX 1
EIP destination address if ECX != 0, jump to destination label

A label is used to identify the destination address
ECX register is used as a counter to count the iterations

Example: top:
Example: calculate the sum of integers from 1 to 100
. . . mov eax, 0 ; sum = eax
jmp top mov ecx, 100 ; count = ecx
L1:

JMP provides an easy way to create a loop add eax, ecx ; accumulate sum in eax
loop L1 ; decrement ecx until 0

Loop will continue endlessly unless we find a way to terminate it
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Your turn . . . Nested Loop

If you need to code a loop within a loop, you must
mov eax,6
What will be the final value of EAX? mov ecx,4 save the outer loop counter's ECX value
Solution: 10 L1:
inc eax .DATA
count DWORD ?
loop L1
.CODE
mov ecx, 100 ; set outer loop count to 100
L1:
How many times will the loop execute? mov count, ecx ; save outer loop count
mov eax,1 mov ecx, 20 ; set inner loop count to 20
Solution: 232 = 4,294,967,296 mov ecx,0 L2: .
L2: .
What will be the final value of EAX? dec eax loop L2 ; repeat the inner loop
mov ecx, count ; restore outer loop count
Solution: same value 1 loop L2
loop L1 ; repeat the outer loop
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

8
 Next . . . Copying a String
The following code copies a string from source to target

Operand Types
.DATA

Data Transfer Instructions source BYTE "This is the source string",0
target BYTE SIZEOF source DUP(0)

Addition and Subtraction .CODE
main PROC Good use of SIZEOF

Addressing Modes mov esi,0 ; index register
mov ecx, SIZEOF source ; loop counter

Jump and Loop Instructions L1:
mov al,source[esi] ; get char from source

Copying a String mov target[esi],al ; store it in the target

Summing an Array of Integers inc esi ; increment index
loop L1 ESI is used to ; loop for entire string
exit index source &
main ENDP target strings
END main
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

Summing an Integer Array Summing an Integer Array cont'd

This program calculates the sum of an array of 16-bit integers This program calculates the sum of an array of 32-bit integers

.DATA .DATA
intarray WORD 100h,200h,300h,400h,500h,600h intarray DWORD 10000h,20000h,30000h,40000h,50000h,60000h
.CODE .CODE
main PROC main PROC
mov esi, OFFSET intarray ; address of intarray mov esi, 0 ; index of intarray
mov ecx, LENGTHOF intarray ; loop counter mov ecx, LENGTHOF intarray ; loop counter
mov ax, 0 ; zero the accumulator mov eax, 0 ; zero the accumulator
L1: L1:
add ax, [esi] ; accumulate sum in ax add eax, intarray[esi*4] ; accumulate sum in eax
add esi, 2 ; point to next integer inc esi ; increment index
loop L1 ; repeat until ecx = 0 loop L1 ; repeat until ecx = 0
exit exit
main ENDP esi is used as a pointer main ENDP esi is used as a scaled index
END main contains the address of an array element END main
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

PC-Relative Addressing PC-Relative Addressing cont'd

The following loop calculates the sum: 1 to 1000 Assembler:
Calculates the difference (in bytes), called PC-relative offset, between
Offset Machine Code Source Code
the offset of the target label and the offset of the following instruction
00000000 B8 00000000 mov eax, 0
00000005 B9 000003E8 mov ecx, 1000 Processor:
0000000A L1: Adds the PC-relative offset to EIP when executing LOOP instruction
0000000A 03 C1 add eax, ecx
0000000C E2 FC loop L1
0000000E . . . . . . If the PC-relative offset is encoded in a single signed byte,
(a) what is the largest possible backward jump?
When LOOP is assembled, the label L1 in LOOP is translated as FC
which is equal to 4 (decimal). This causes the loop instruction to (b) what is the largest possible forward jump?
jump 4 bytes backwards from the offset of the next instruction. Since
the offset of the next instruction = 0000000E, adding 4 (FCh) causes
a jump to location 0000000A. This jump is called PC-relative. Answers: (a) 128 bytes and (b) +127 bytes
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55 Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

9
 Summary

Data Transfer

MOV, MOVSX, MOVZX, and XCHG instructions

Arithmetic

ADD, SUB, INC, DEC, NEG, ADC, SBB, STC, and CLC

Carry, Overflow, Sign, Zero, Auxiliary and Parity flags

Addressing Modes

Register, immediate, direct, indirect, indexed, based-indexed

Load Effective Address (LEA) instruction

32-bit and 16-bit addressing

JMP and LOOP Instructions

Traversing and summing arrays, copying strings

PC-relative addressing
Basic Instructions & Addressing Modes Computer Organization & Assembly Language Programming slide /55

10