Download assembly3

Assembly Language
Data Transfers, Addressing, and
Arithmetic
Data Transfer Instructions

Operand Types



Immediate
Register
memory
Instruction Operand Notation
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples

Direct Memory Operands

For example
.data
 var1 BYTE 10h

.code
 mov al, var1
 mov al, [var1] ; alternative notation


MOV Instruction


Format: MOV destination, source
Rules
Both operands must be the same size
 Both operands cannot be memory
operands
 CS, EIP, and IP cannot be destination
operands


MOV Instruction

General variants
MOV
 MOV
 MOV
 MOV
 MOV

reg, reg
mem, reg
reg, mem
mem, imm
reg, imm

MOV Instruction

Segment registers in real mode
MOV r/m16, sreg
 MOV sreg, r/m16


MOVZX Instruction


Move with zero-extend
Variants
MOVZX r32, r/m8
 MOVZX r32, r/m16
 MOVZX r16, r/m8


MOVSX Instruction


Move with sign-extend
Variants
MOVSX r32, r/m8
 MOVSX r32, r/m16
 MOVSX r16, r/m8


LAHF



Load the low byte of the EFLAGS
register into AH
Includes Sign, Zero, Auxiliary Carry,
Parity, and Carry.
SAHF

Store AH into the low byte of the
EFLAGS register

XCHG Instruction

Rules
Both operands must be the same size
 Both operands cannot be memory
operands
 CS, EIP, and IP cannot be destination
operands


Variants
XCHG reg, reg
 XCHG reg, mem
 XCHG mem, reg


Direct-Offset Operands

For example
mov al, [arrayB+2]
 mov al, array+2 ; Alternative notation

Example: Data Transfer











TITLE Data Transfer Examples
(Moves.asm)
; Chapter 4 example. Demonstration of MOV and
; XCHG with direct and direct-offset operands.
; Last update: 06/01/2006. By K. R. Irvine.
INCLUDE Irvine32.inc
.data
val1 WORD 1000h
val2 WORD 2000h
arrayB BYTE 10h,20h,30h,40h,50h
arrayW WORD 100h,200h,300h
arrayD DWORD 10000h,20000h













.code
main PROC
; MOVZX
mov bx,0A69Bh
movzx eax,bx
movzx edx,bl
movzx cx,bl
; MOVSX
mov bx,0A69Bh
movsx eax,bx
movsx edx,bl
mov
bl,7Bh
movsx cx,bl
; EAX = 0000A69Bh
; EDX = 0000009Bh
; CX = 009Bh
; EAX = FFFFA69Bh
; EDX = FFFFFF9Bh
; CX = 007Bh








; Memory-to-memory exchange:
mov ax,val1
; AX = 1000h
xchg ax,val2
; AX = 2000h, val2 = 1000h
mov val1,ax
; val1 = 2000h
; Direct-Offset Addressing (byte array):
mov al,arrayB
; AL = 10h
mov al,[arrayB+1]
; AL = 20h
mov al,[arrayB+2]
; AL = 30h










; Direct-Offset Addressing (word array):
mov ax,arrayW
; AX = 100h
mov ax,[arrayW+2] ; AX = 200h
; Direct-Offset Addressing (doubleword array):
mov eax,arrayD
; EAX = 10000h
mov eax,[arrayD+4] ; EAX = 20000h
mov eax,[arrayD+TYPE arrayD]
; EAX = 20000h
exit
main ENDP
END main
Addition and Subtraction

INC Instruction


Increment by 1
Syntax


INC reg/mem
DEC Instruction


Decrement by 1
Syntax

DEC reg/mem

INC and DEC Instruction


Overflow, Sign, Zero, Auxiliary Carry,
and Parity flags are changed according
to the value of the destination operand
Do not affect the Carry flag

ADD Instruction

Syntax


ADD dest, source
General variants (like MOV)
MOV
 MOV
 MOV
 MOV
 MOV

reg, reg
mem, reg
reg, mem
mem, imm
reg, imm

SUB Instruction

Syntax


SUB dest, source
General variants (like MOV)
MOV
 MOV
 MOV
 MOV
 MOV

reg, reg
mem, reg
reg, mem
mem, imm
reg, imm

ADD and SUB Instructions

Overflow, Sign, Zero, Auxiliary Carry,
Parity, and Carry flags are changed
according to the value of the
destination operand

NEG Instruction


Convert the number to its two’s
complement
Syntax
NEG reg
 NEG mem


Overflow, Sign, Zero, Auxiliary Carry,
Parity, and Carry flags are changed
according to the value of the
destination operand
Flags Affected by Arithmetic
• The ALU has a number of status flags that reflect the
outcome of arithmetic (and bitwise) operations
• based on the contents of the destination operand
• Essential flags:
•
•
•
•
Zero flag – set when destination equals zero
Sign flag – set when destination is negative
Carry flag – set when unsigned value is out of range
Overflow flag – set when signed value is out of range
• The MOV instruction never affects the flags.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Zero Flag (ZF)
The Zero flag is set when the result of an operation produces
zero in the destination operand.
mov
sub
mov
inc
inc
cx,1
cx,1
ax,0FFFFh
ax
ax
; CX = 0, ZF = 1
; AX = 0, ZF = 1
; AX = 1, ZF = 0
Remember...
• A flag is set when it equals 1.
• A flag is clear when it equals 0.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Sign Flag (SF)
The Sign flag is set when the destination operand is negative.
The flag is clear when the destination is positive.
mov cx,0
sub cx,1
add cx,2
; CX = -1, SF = 1
; CX = 1, SF = 0
The sign flag is a copy of the destination's highest bit:
mov al,0
sub al,1
add al,2
; AL = 11111111b, SF = 1
; AL = 00000001b, SF = 0
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Signed and Unsigned Integers
A Hardware Viewpoint
• All CPU instructions operate exactly the same on
signed and unsigned integers
• The CPU cannot distinguish between signed and
unsigned integers
• YOU, the programmer, are solely responsible for
using the correct data type with each instruction
Added Slide. Gerald Cahill, Antelope Valley College
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Overflow and Carry Flags
A Hardware Viewpoint
• How the ADD instruction modifies OF and CF:
• OF = (carry out of the MSB) XOR (carry into the MSB)
• CF = (carry out of the MSB)
• How the SUB instruction modifies OF and CF:
• NEG the source and ADD it to the destination
• OF = (carry out of the MSB) XOR (carry into the MSB)
• CF = INVERT (carry out of the MSB)
MSB = Most Significant Bit (high-order bit)
XOR = eXclusive-OR operation
NEG = Negate (same as SUB 0,operand )
Added Slide. Gerald Cahill, Antelope Valley College
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Carry Flag (CF)
The Carry flag is set when the result of an operation generates an
unsigned value that is out of range (too big or too small for the
destination operand).
mov al,0FFh
add al,1
; CF = 1, AL = 00
; Try to go below zero:
mov al,0
sub al,1
; CF = 1, AL = FF
The INC and DEC instructions do not affect the Carry
flag. Applying NEG to a nonzero operand always
sets the Carry flag.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Your turn . . .
For each of the following marked entries, show the values of
the destination operand and the Sign, Zero, and Carry flags:
mov
add
sub
add
mov
add
ax,00FFh
ax,1
ax,1
al,1
bh,6Ch
bh,95h
mov al,2
sub al,3
; AX= 0100h
; AX= 00FFh
; AL= 00h
SF= 0 ZF= 0 CF= 0
SF= 0 ZF= 0 CF= 0
SF= 0 ZF= 1 CF= 1
; BH= 01h
SF= 0 ZF= 0 CF= 1
; AL= FFh
SF= 1 ZF= 0 CF= 1
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Overflow Flag (OF)
The Overflow flag is set when the signed result of an operation is
invalid or out of range.
; Example 1
mov al,+127
add al,1
; Example 2
mov al,7Fh
add al,1
; OF = 1,
AL = ??
; OF = 1,
AL = 80h
The two examples are identical at the binary level because 7Fh
equals +127. To determine the value of the destination operand,
it is often easier to calculate in hexadecimal.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
A Rule of Thumb
• When adding two integers, remember that the
Overflow flag is only set when . . .
• Two positive operands are added and their sum is
negative
• Two negative operands are added and their sum is
positive
What will be the values of the Overflow flag?
mov al,80h
add al,92h
; OF = 1
mov al,-2
add al,+127
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; OF = 0
Web site
Examples
Your turn . . .
What will be the values of the given flags after each operation?
mov al,-128
neg al
; CF = 1
OF = 1
mov ax,8000h
add ax,2
; CF = 0
OF = 0
mov ax,0
sub ax,2
; CF = 1
OF = 0
mov al,-5
sub al,+125
; OF = 1
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Example: Addition and Subtraction

TITLE Addition and Subtraction

;
;
;
;

INCLUDE Irvine32.inc








(AddSub3.asm)
Chapter 4 example. Demonstration of ADD, SUB,
INC, DEC, and NEG instructions, and how
they affect the CPU status flags.
Last update: 06/01/2006. By K. R. Irvine.
.data
Rval
Xval
Yval
Zval
SDWORD ?
SDWORD 26
SDWORD 30
SDWORD 40













.code
main PROC
; INC and DEC
mov
ax,1000h
inc
ax
dec
ax
; 1001h
; 1000h
; Expression: Rval = -Xval + (Yval - Zval)
mov
eax,Xval
neg
eax
; -26
mov
ebx,Yval
sub
ebx,Zval
; -10
add
eax,ebx
mov
Rval,eax
; -36










; Zero
mov
sub
mov
inc
flag example:
cx,1
cx,1
; ZF = 1
ax,0FFFFh
ax
; ZF = 1
; Sign
mov
sub
mov
add
flag example:
cx,0
cx,1
; SF = 1
ax,7FFFh
ax,2
; SF = 1











; Carry flag example:
mov
al,0FFh
add
al,1
; CF = 1, AL = 00
; Overflow flag example:
mov
al,+127
add
al,1
; OF = 1
mov
al,-128
sub
al,1
; OF = 1
exit
main ENDP
END main
Data-Related Operators and Directives

OFFSET


Returns the offset of a data label
For example
mov esi, OFFSET bVal
 mov esi, OFFSET myArray+4


ALIGN


Aligns a variable on a byte, word,
doubleword, or paragraph boundary
Syntax
ALIGN bound
 bound can be 1, 2, 4, or 16.


For example
bVal BYTE ?
 ALIGN 2


PTR


Override the declared size of an
operand
For example
mov ax, WORD PTR myDouble
 mov ax, WORD PTR [myDouble+2]
 mov bl, BYTE PTR myDouble


TYPE


LENGTHOF


Returns the size, in bytes, of a single
element of a variable.
Counts the number of elements in an
array, defined by the values appearing
on the same line as its label.
SIZEOF

Returns a value that is equavalent to
multiplying LENGTHOF by TYPE.

LABEL


Insert a label and give it a size
attribute without allocating any storage.
For example
.data
 val16 LABEL WORD
 val32 DWORD 12345678h

Example: TYPE, LENGTHOF

TITLE Operators
(Operator.asm)

; Demonstrates the TYPE, LENGTHOF, and SIZEOF
operators
; Last update: 06/01/2006. By K. R. Irvine.

INCLUDE Irvine32.inc









.data
byte1 BYTE 10,20,30
array1 WORD 30 DUP(?),0,0
array2 WORD 5 DUP(3 DUP(?))
array3 DWORD 1,2,3,4
digitStr BYTE '12345678',0
myArray BYTE 10,20,30,40,50,
60,70,80,90,100














; You can examine the following constant values
; by looking in the listing file (Operator.lst):
;--------------------------------------------X = LENGTHOF byte1
;3
X = LENGTHOF array1
; 30 + 2
X = LENGTHOF array2
;5*3
X = LENGTHOF array3
;4
X = LENGTHOF digitStr
;9
X = LENGTHOF myArray ; 10
X
X
X
X
X
=
=
=
=
=
SIZEOF
SIZEOF
SIZEOF
SIZEOF
SIZEOF
byte1
array1
array2
array3
digitStr
;
;
;
;
1
2
2
4
*
*
*
*
3
(30 + 2)
(5 * 3)
4
;1*9





.code
main PROC
exit
main ENDP
END main
Exercise

4.7, 4. Overflow Flag


Write a program that uses addition and
subtraction to set and clear the
Overflow flag. After each addition or
subtraction instruction, insert the call
DumpRegs statement to display the
registers and flags. Using comments,
explain how (and why) the Overflow
flag was affected by each instruction.
Optional: include an ADD instruction
that sets both the Carry and Overflow
flags.
Reference: Page 109.
Example











TITLE Chapter 4 Exercise 2
INCLUDE Irvine32.inc
.data
.code
main PROC
; INC does not affect the carry flag:
mov al,254
add al,1
; AL=255, CF=0
call DumpRegs
inc al ; AL=0, CF=0 (unchanged)
call DumpRegs









; DEC does not affect the carry flag:
mov al,1
sub al,1
; AL=0, CF=0
call DumpRegs
dec al ; AL=255, CF=0 (unchanged)
call DumpRegs
exit
main ENDP
END main
Indirect Addressing
•
•
•
•
Indirect Operands
Array Sum Example
Indexed Operands
Pointers
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Indirect Operands (1 of 2)
An indirect operand holds the address of a variable, usually an
array or string. It can be dereferenced (just like a pointer).
.data
val1 BYTE 10h,20h,30h
.code
mov esi,OFFSET val1
mov al,[esi]
; dereference ESI (AL = 10h)
inc esi
mov al,[esi]
; AL = 20h
inc esi
mov al,[esi]
; AL = 30h
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Indirect Operands (2 of 2)
Use PTR to clarify the size attribute of a memory operand.
.data
myCount WORD 0
.code
mov esi,OFFSET myCount
inc [esi]
inc WORD PTR [esi]
; error: ambiguous
; ok
Should PTR be used here?
add [esi],20
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
yes, because [esi] could
point to a byte, word, or
doubleword
Web site
Examples
Array Sum Example
Indirect operands are ideal for traversing an array. Note that the
register in brackets must be incremented by a value that
matches the array type.
.data
arrayW
.code
mov
mov
add
add
add
add
WORD 1000h,2000h,3000h
esi,OFFSET arrayW
ax,[esi]
esi,2
ax,[esi]
esi,2
ax,[esi]
; or: add esi,TYPE arrayW
; AX = sum of the array
ToDo: Modify this example for an array of doublewords.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Indexed Operands
An indexed operand adds a constant to a register to generate
an effective address. There are two notational forms:
[label + reg]
.data
arrayW WORD 1000h,2000h,3000h
.code
mov esi,0
mov ax,[arrayW + esi]
mov ax,arrayW[esi]
add esi,2
add ax,[arrayW + esi]
etc.
label[reg]
; AX = 1000h
; alternate format
ToDo: Modify this example for an array of doublewords.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Index Scaling*
You can scale an indirect or indexed operand to the offset of an
array element. This is done by multiplying the index by the
array's TYPE:
.data
arrayB BYTE 0,1,2,3,4,5
arrayW WORD 0,1,2,3,4,5
arrayD DWORD 0,1,2,3,4,5
.code
mov esi,4
mov al,arrayB[esi*TYPE arrayB]
mov bx,arrayW[esi*TYPE arrayW]
mov edx,arrayD[esi*TYPE arrayD]
; 04
; 0004
; 00000004
* Not in the book
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Pointers
You can declare a pointer variable that contains the offset of
another variable.
.data
arrayW WORD 1000h,2000h,3000h
ptrW DWORD arrayW
.code
mov esi,ptrW
mov ax,[esi]
; AX = 1000h
Alternate format:
ptrW DWORD OFFSET arrayW
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
JMP and LOOP Instructions
•
•
•
•
•
JMP Instruction
LOOP Instruction
LOOP Example
Summing an Integer Array
Copying a String
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
JMP Instruction
• JMP is an unconditional jump to a label that is usually within
the same procedure.
• Syntax: JMP target
• Logic: EIP  target
• Example:
top:
.
.
jmp top
A jump outside the current procedure must be to a special type of
label called a global label (see Section 5.5.2.3 for details).
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
LOOP Instruction
• The LOOP instruction creates a counting loop
• Syntax: LOOP target
• Logic:
• ECX  ECX – 1
• if ECX != 0, jump to target
• Implementation:
• The assembler calculates the distance, in bytes, between
the offset of the following instruction and the offset of the
target label. It is called the relative offset.
• The relative offset is added to EIP.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
LOOP Example
The following loop calculates the sum of the integers
5 + 4 + 3 +2 + 1:
offset
machine code
source code
00000000
00000004
66 B8 0000
B9 00000005
mov
mov
00000009
0000000C
0000000E
66 03 C1
E2 FB
ax,0
ecx,5
L1: add ax,cx
loop L1
When LOOP is assembled, the current location = 0000000E (offset of
the next instruction). –5 (FBh) is added to the the current location,
causing a jump to location 00000009:
00000009  0000000E + FB
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Your turn . . .
If the relative offset is encoded in a single signed byte,
(a) what is the largest possible backward jump?
(b) what is the largest possible forward jump?
(a) -128
(b) +127
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Your turn . . .
mov ax,6
mov ecx,4
What will be the final value of AX?
L1:
inc ax
loop L1
10
How many times will the loop
execute?
4,294,967,296
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
mov ecx,0
X2:
inc ax
loop X2
Web site
Examples
Nested Loop
If you need to code a loop within a loop, you must save the
outer loop counter's ECX value. In the following example, the
outer loop executes 100 times, and the inner loop 20 times.
.data
count DWORD ?
.code
mov ecx,100
L1:
mov count,ecx
mov ecx,20
L2: .
.
loop L2
mov ecx,count
loop L1
; set outer loop count
; save outer loop count
; set inner loop count
; repeat the inner loop
; restore outer loop count
; repeat the outer loop
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
Summing an Integer Array
The following code calculates the sum of an array of 16-bit
integers.
.data
intarray WORD 100h,200h,300h,400h
.code
mov edi,OFFSET intarray
mov ecx,LENGTHOF intarray
mov ax,0
L1:
add ax,[edi]
add edi,TYPE intarray
loop L1
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; address of intarray
; loop counter
; zero the accumulator
; add an integer
; point to next integer
; repeat until ECX = 0
Web site
Examples
Copying a String
The following code copies a string from source to target:
.data
source
target
.code
mov
mov
L1:
mov
mov
inc
loop
BYTE
BYTE
"This is the source string",0
SIZEOF source DUP(0)
good use of
SIZEOF
esi,0
ecx,SIZEOF source
; index register
; loop counter
al,source[esi]
target[esi],al
esi
L1
;
;
;
;
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
get char from source
store it in the target
move to next character
repeat for entire string
Web site
Examples