Assembly Language for Intel-Based
Computers, 5th Edition
Kip Irvine
Capítulo 4: Transferência de
Dados, Endereçamento, e
Aritmética
Slides prepared by the author
Revision date: June 4, 2006
(c) Pearson Education, 2006-2007. All rights reserved. You may modify and copy this slide show for your personal use,
or for use in the classroom, as long as this copyright statement, the author's name, and the title are not changed.
Índice
• Instrução de Transferência de Dados
• Adição e Subtração
• Operadores e Diretivas relacionados a
Dados
• Endereçamento Indireto
• Instruções JMP e LOOP
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
2
Instrução de Transferência de Dados
•
•
•
•
•
•
•
Tipos de Operandos
Notação de Operandos de Instrução
Operandos de Memória por endereçamento Direto
Instrução MOV
Extensão de Zero & Sign
Instrução XCHG
Operandos com Deslocamento Direto (DirectOffset)
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
3
Tipos de Operandos
• Três tipos básicos de operandos:
• Imediato – uma constante inteira (8, 16, ou 32 bits)
• Valor é codificado dentro da instrução
• Registrador – nome de um register
• O nome do registrador é codificado dentro da instrução
• Memória – referência a uma posição na memória
• O endereço da memória é codificado dentro da instrução, ou
um registrador contem o endereço de uma posição de memória
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
4
Notação de Operandos de Instrução
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
5
Operandos de Memória por
endereçamento direto
• Um operando de memória por endereçamento direto é
uma referência à memória por nome
• A referência (label) é automaticamente reconhecida
pelo assembler
.data
var1 BYTE 10h
.code
mov al,var1
mov al,[var1]
; AL = 10h
; AL = 10h
alternativa
Lembrar de mov al, (2000H) da aula-02.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
6
Instrução MOV
• Move da fonte para o destino. Sintaxe:
MOV destino, fonte
• É permitido apenas um operando de memória
• CS, EIP, e IP não podem ser destino
• Não existe mov imediato para registrador de segmento
.data
count BYTE 100
wVal WORD 2
.code
mov bl,count
mov ax,wVal
mov count,al
mov al,wVal
mov ax,count
mov eax,count
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; error
; error
; error
Web site
Examples
7
Sua vez . . .
Explicar por que as instruções MOV seguintes são inválidas:
.data
bVal BYTE
bVal2 BYTE
wVal WORD
dVal DWORD
.code
mov ds,45
100
?
2
5
Move imediato para DS não permitido
mov esi,wVal
Tamanho incompatível
mov eip,dVal
EIP não pode ser destino
mov 25,bVal
Valor imediato não pode ser destino
mov bVal2,bVal
Move memória-a-memória não permitido
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
8
Extensão com Zeros
Quando se copia um valor menor para um destino maior, a
instrução MOVZX estende a parte mais significativa do destino
com zeros.
0
10001111
Source
00000000
10001111
Destination
mov bl,10001111b
movzx ax,bl
; zero-extension
O destino deve ser um registrador.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
9
Extensão com Sinal
A instrução MOVSX preenche a parte mais significativa do
destino com uma cópia do bit de sinal do operando fonte.
11111111
10001111
Source
10001111
Destination
mov bl,10001111b
movsx ax,bl
; sign extension
O destino deve ser um registrador.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
10
Instrução XCHG
XCHG troca os valores de dois operandos. Pelo menos um
operando deve ser um registrador. Nenhum operando imediato
é permitido.
.data
var1 WORD 1000h
var2 WORD 2000h
.code
xchg ax,bx
xchg ah,al
xchg var1,bx
xchg eax,ebx
;
;
;
;
xchg var1,var2
; error: two memory operands
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
exchange
exchange
exchange
exchange
16-bit regs
8-bit regs
mem, reg
32-bit regs
Web site
Examples
11
Operandos com deslocamento direto
(Direct-Offset)
Um deslocamento é adicionado a um label para produzir um
endereço efetivo (EA). O endereço é calculado pelo Assembler.
.data
arrayB BYTE 10h,20h,30h,40h
.code
mov al,arrayB+1
mov al,[arrayB+1]
; AL = 20h
; alternative notation
Por que arrayB+1 não resulta em 11h?
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
12
Operandos com deslocamento direto
(Direct-Offset)(cont)
.data
arrayW WORD 1000h,2000h,3000h
arrayD DWORD 1,2,3,4
.code
mov ax,[arrayW+2]
; AX = 2000h
mov ax,[arrayW+4]
; AX = 3000h
mov eax,[arrayD+4]
; EAX = 00000002h
; As seguintes instruções são corretas?
mov ax,[arrayW-2]
; ??
mov eax,[arrayD+16]
; ??
O que acontece quando são executadas?
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
13
Sua vez. . .
Escrever um programa que rearranja os valores de 3 doublewords no
seguinte vetor: 3, 1, 2.
.data
arrayD DWORD 1,2,3
• passo1: copiar o primeiro valor em EAX e trocar com o valor na
segunda posição.
mov eax,arrayD
xchg eax,[arrayD+4]
• passo 2: trocar EAX com o terceiro valor e copiar o valor em EAX
para a primeira posição.
xchg eax,[arrayD+8]
mov arrayD,eax
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
14
Avaliar . . .
• Queremos escrever um programa que soma os 3 bytes seguintes:
.data
myBytes BYTE 80h,66h,0A5h
• Qual a avaliação para o seguinte código?
mov al,myBytes
add al,[myBytes+1]
add al,[myBytes+2]
• Qual a avaliação para o seguinte código?
mov ax,myBytes
add ax,[myBytes+1]
add ax,[myBytes+2]
• Alguma outra possibilidade?
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
15
Avaliar . . . (cont)
.data
myBytes BYTE 80h,66h,0A5h
• Falta algo no código seguinte?
movzx
mov
add
mov
add
ax,myBytes
bl,[myBytes+1]
ax,bx
bl,[myBytes+2]
ax,bx
; AX = sum
Sim: Mover zero a BX antes da instrução MOVZX.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
16
Próxima seção
• Instrução de Transferência de Dados
• Adição e Subtração
• Operadores e Diretivas relacionados a
Dados
• Endereçamento Indireto
• Instruções JMP e LOOP
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
17
Adição e Subtração
•
•
•
•
•
Instruções INC e DEC
Instruções ADD e SUB
Instrução NEG
Implementando Expressões Aritméticas
Flags afetados pela Aritmética
•
•
•
•
Zero
Sign
Carry
Overflow
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
18
Instruções INC e DEC
• soma 1, subtrai 1 do operando destino
• Operando pode ser registrador ou memória
• INC destino
• Lógica: destino  destino + 1
• DEC destino
• Lógica: destino  destino – 1
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
19
Exemplos de INC e DEC
.data
myWord WORD 1000h
myDword DWORD 10000000h
.code
inc myWord
dec myWord
inc myDword
mov
inc
mov
inc
ax,00FFh
ax
ax,00FFh
al
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; 1001h
; 1000h
; 10000001h
; AX = 0100h
; AX = 0000h
Web site
Examples
20
Sua vez...
Mostrar o valor do operando destino depois que cada instrução é
executada:
.data
myByte
.code
mov
mov
dec
inc
dec
BYTE 0FFh, 0
al,myByte
ah,[myByte+1]
ah
al
ax
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
;
;
;
;
;
AL
AH
AH
AL
AX
=
=
=
=
=
FFh
00h
FFh
00h
FEFFh
Web site
Examples
21
Instruções ADD e SUB
• ADD destino, fonte
• Lógica: destino  destino + fonte
• SUB destino, fonte
• Lógica: destino  destino – fonte
• Mesmas regras de operando que a instrução MOV
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
22
Exemplos de ADD e SUB
.data
var1 DWORD 10000h
var2 DWORD 20000h
.code
mov eax,var1
add eax,var2
add ax,0FFFFh
add eax,1
sub ax,1
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
;
;
;
;
;
;
---EAX--00010000h
00030000h
0003FFFFh
00040000h
0004FFFFh
Web site
Examples
23
Instrução NEG (negar)
Nega um operando. O operando pode ser de registrador ou
memória.
.data
valB BYTE -1
valW WORD +32767
.code
mov al,valB
neg al
neg valW
; AL = -1
; AL = +1
; valW = -32767
Supondo que AX contenha –32,768, aplicar NEG.
O resultado é válido?
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
24
Instrução NEG e Flags
O processador implementa NEG usando a seguinte operação
interna:
zero menos operando
(0 – operando)
Qualquer operando não zero faz com que o Carry flag seja
acionado.
.data
valB BYTE 1,0
valC SBYTE -128
.code
neg valB
neg [valB + 1]
neg valC
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; CF = 1, OF = 0
; CF = 0, OF = 0
; CF = 1, OF = 1
Web site
Examples
25
Implementando Expressões Aritméticas
Compiladores traduzem expressões matemáticas em
linguagem Assembly. Fazer isso manualmente. Por exemplo:
Rval = -Xval + (Yval – Zval)
Rval DWORD ?
Xval DWORD 26
Yval DWORD 30
Zval DWORD 40
.code
mov eax,Xval
neg eax
mov ebx,Yval
sub ebx,Zval
add eax,ebx
mov Rval,eax
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; EAX = -26
; EBX = -10
; -36
Web site
Examples
26
Sua vez...
Traduzir a seguinte expressão em linguagem Assembly. Não
modificar Xval, Yval, e Zval:
Rval = Xval - (-Yval + Zval)
Assumir que todos os valores são doublewords com sinal.
mov
neg
add
mov
sub
mov
ebx,Yval
ebx
ebx,Zval
eax,Xval
eax,ebx
Rval,eax
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
27
Flags afetados pela aritmética
• A ALU tem um número de flags que refletem o resultado da aritmética e
operações com bits
• Baseado no conteúdo do operando destino
• Flags essenciais:
• Zero flag – aciona quando o destino é zero
• Sign flag – aciona quando o destino é negativo
• Carry flag – aciona quando um valor sem sinal cair fora do intervalo
• Overflow flag – aciona quando um valor com sinal cair fora do intervalo
• A instrução MOV não afeta flags.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
28
Diagrama ilustrativo
CPU
part of
executes
executes
ALU
conditional jumps
arithmetic & bitwise
operations
attached to
affect
used by
provide
status flags
branching logic
Pode-se usar diagramas como esse para expressar as relações entre os conceitos
da linguagem assembly.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
29
Flag Zero (ZF)
O flag Zero é acionado quando o resultado de uma operação
produz zero no operando destino.
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
Lembrar ...
• Acionar flag é torná-lo igual a 1.
• Zerar flag é torná-lo igual a 0.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
30
Flag Sign (SF)
O flag Sign é acionado quando o operando destino é negativo.
O flag é zerado quando o operando destino é positivo.
mov cx,0
sub cx,1
add cx,2
; CX = -1, SF = 1
; CX = 1, SF = 0
O sign flag é uma cópia do bit de sinal do operando destino
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
31
Inteiros com sinal e sem sinal
Ponto de vista do Hardware
• Todas as instruções operam exatamente da mesma
forma em inteiros com sinal e sem sinal
• A CPU não faz distinção entre números inteiros com
sinal e sem sinal
• O programador é o único responsável pelo uso
correto dos tipos de dados para cada instrução
Added Slide. Gerald Cahill, Antelope Valley College
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
32
Flags de Overflow e Carry
Ponto de vista do Hardware
• Como a instrução ADD modifica OF e CF:
• OF = (carry out do MSB) xor (carry in para MSB)
• CF = (carry out of the MSB)
• Como a instrução SUB modifica OF e CF:
• Nega (NEG) o fonte e soma (ADD) ao destino
• OF = (carry out do MSB) xor (carry in para MSB)
• CF = INVERT (carry out do 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
33
Flag Carry (CF)
O flag Carry é acionado quando o resultado de uma operação
gera um valor valor sem sinal que é fora do intervalo (muito grande
ou muito pequeno para o operando destino).
mov al,0FFh
add al,1
; CF = 1, AL = 00
; Try to go below zero:
mov al,0
sub al,1
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; CF = 1, AL = FF
Web site
Examples
34
Sua vez …
Para cada uma das instruções aritméticas seguintes, mostrar
os valores do operando destino e os flags de Sign, Zero e
Carry :
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
35
Flag Overflow (OF)
O flag Overflow é acionado quando o resultado com sinal de uma
operação é inválido ou fora do intervalo.
; Example 1
mov al,+127
add al,1
; Example 2
mov al,7Fh
add al,1
; OF = 1,
AL = ??
; OF = 1,
AL = 80h
Os dois exemplos são idênticos no binário pois 7Fh é igual a +127.
Para determinar o valor do operando destino, é geralmente mais
fácil em hexadecimal.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
36
Uma regra simples (Rule of Thumb)
• Ao somar dois inteiros, lembrar que o flag Overflow
é apenas acionado quando . . .
• Dois operandos positivos são somados e a sua soma
é negativa
• Dois operandos negativos são somados e sua soma é
positiva
Qual é o valor do flag Overflow?
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
37
Sua vez. . .
Quais seriam os valores dos flags para cada operação?
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
38
Próxima seção
• Instrução de Transferência de Dados
• Adição e Subtração
• Operadores e Diretivas relacionados a
Dados
• Endereçamento Indireto
• Instruções JMP e LOOP
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
39
Operadores e diretivas relacionados a dados
•
•
•
•
•
•
Operador OFFSET
Operador PTR
Operador TYPE
Operador LENGTHOF
Operador SIZEOF
Diretiva LABEL
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
40
Operador OFFSET
• OFFSET retorna a distância em bytes, de um label, do
início do segmento
• Modo Protegido: 32 bits
• Modo Real: 16 bits
offset
data segment:
myByte
Os programas em modo protegido tem apenas um
segmento ( usando o modelo de memória flat).
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
41
Exemplos de OFFSET
Assumindo que o segmento de dados começa em 00404000h:
.data
bVal BYTE ?
wVal WORD ?
dVal DWORD ?
dVal2 DWORD ?
.code
mov esi,OFFSET
mov esi,OFFSET
mov esi,OFFSET
mov esi,OFFSET
bVal
wVal
dVal
dVal2
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
;
;
;
;
ESI
ESI
ESI
ESI
Web site
=
=
=
=
00404000h
00404001h
00404003h
00404007h
Examples
42
Relacionando a C/C++
O valor retornado pelo OFFSET é um ponteiro. Comparar o
seguinte código escrito em C++ e linguagem assembly:
; C++ version:
char array[1000];
char * p = array;
.data
array BYTE 1000 DUP(?)
.code
mov esi,OFFSET array
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; ESI is p
Web site
Examples
43
Operador PTR
Sobrepõe o tipo default de um label (variável).
Provê a flexibilidade de acesso à parte de uma variável.
.data
myDouble DWORD 12345678h
.code
mov ax,myDouble
; error – why?
mov ax,WORD PTR myDouble
; loads 5678h
mov WORD PTR myDouble,4321h
; saves 4321h
Lembrar a ordem de armazenamento little endian.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
44
ord
Ordenamento Little Endian
• O ordenamento Little endian refere-se a forma com
que IA-32 guarda dados na memória.
• Por exemplo, o doubleword 12345678h é guardado
na forma:
word
byte
offset
78 5678
78
0000
56
1234
34
12
myDouble
Quando os inteiros são
+1
0001 myDouble carregados
da memória para
registradores, os bytes são
0002 myDouble + 2
automaticamente reordenados
+ 3 posições corretas.
0003 myDouble nas
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
45
Exemplo de operador PTR
.data
myDouble DWORD 12345678h
doubleword
word
byte
offset
12345678 5678
78
0000
myDouble
56
0001
myDouble + 1
34
0002
myDouble + 2
12
0003
myDouble + 3
1234
mov
mov
mov
mov
mov
al,BYTE
al,BYTE
al,BYTE
ax,WORD
ax,WORD
PTR myDouble
PTR [myDouble+1]
PTR [myDouble+2]
PTR myDouble
PTR [myDouble+2]
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
;
;
;
;
;
Web site
AL
AL
AL
AX
AX
=
=
=
=
=
78h
56h
34h
5678h
1234h
Examples
46
Operador PTR (cont)
PTR pode também ser usado para combinar elementos de
um tipo de dados menor, movendo-o a um operando maior .
O CPU reverte automaticamente os bytes.
.data
myBytes BYTE 12h,34h,56h,78h
.code
mov ax,WORD PTR [myBytes]
mov ax,WORD PTR [myBytes+2]
mov eax,DWORD PTR myBytes
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; AX = 3412h
; AX = 7856h
; EAX = 78563412h
Web site
Examples
47
Sua vez . . .
Escrever o valor de cada operando destino:
.data
varB BYTE 65h,31h,02h,05h
varW WORD 6543h,1202h
varD DWORD 12345678h
.code
mov ax,WORD PTR [varB+2]
mov bl,BYTE PTR varD
mov bl,BYTE PTR [varW+2]
mov ax,WORD PTR [varD+2]
mov eax,DWORD PTR varW
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
;
;
;
;
;
a. 0502h
b. 78h
c. 02h
d. 1234h
e. 12026543h
Web site
Examples
48
Operador TYPE
O operador TYPE retorna o tamanho em bytes de um
único elemento de uma declaração de dados.
.data
var1 BYTE ?
var2 WORD ?
var3 DWORD ?
var4 QWORD ?
.code
mov eax,TYPE
mov eax,TYPE
mov eax,TYPE
mov eax,TYPE
var1
var2
var3
var4
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
;
;
;
;
Web site
1
2
4
8
Examples
49
Operador LENGTHOF
O operador LENGTHOF conta o número de
elementos numa declaração única de dado.
.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
LENGTHOF
; 3
; 32
; 15
; 4
; 9
.code
mov ecx,LENGTHOF array1
; 32
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
50
Operador SIZEOF
O operador SIZEOF retorna um valor que é equivalente a
multiplicar LENGTHOF por TYPE.
.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
SIZEOF
; 3
; 64
; 30
; 16
; 9
.code
mov ecx,SIZEOF array1
; 64
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
51
Usando Múltiplas Linhas (1 de 2)
Uma declaração de dados usa múltiplas linhas se cada linha
(exceto a última) termina com vírgula. Os operadores LENGTHOF
e SIZEOF incluem todas as linhas pertencentes à declaração:
.data
array WORD 10,20,
30,40,
50,60
.code
mov eax,LENGTHOF array
mov ebx,SIZEOF array
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; 6
; 12
Web site
Examples
52
Usando Múltiplas Linhas (2 de 2)
No exemplo seguinte, array identifica somente a primeira
declaração de WORD. Comparar os valores que retornam
pelo LENGTHOF e SIZEOF com o slide anterior:
.data
array
WORD 10,20
WORD 30,40
WORD 50,60
.code
mov eax,LENGTHOF array
mov ebx,SIZEOF array
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; 2
; 4
Web site
Examples
53
Diretiva LABEL
• Atribui um nome e tipo de label alternativo a uma
posição existente
• LABEL não aloca nenhum dado a si próprio
• Remove a necessidade do operador PTR
.data
dwList
LABEL DWORD
wordList LABEL WORD
intList BYTE 00h,10h,00h,20h
.code
mov eax,dwList
; 20001000h
mov cx,wordList
; 1000h
mov dl,intList
; 00h
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
54
Próxima seção
• Instrução de Transferência de Dados
• Adição e Subtração
• Operadores e Diretivas relacionados a
Dados
• Endereçamento Indireto
• Instruções JMP e LOOP
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
55
Endereçamento Indireto
•
•
•
•
Operandos Indiretos
Exemplo de soma de vetor
Operandos Indexados
Ponteiros
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
56
Operandos indiretos (1 de 2)
Um operando indireto refere-se ao endereço, geralmente, de
um vetor ou cadeia. Funciona com um ponteiro.
.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
57
Operandos indiretos (2 de 2)
Usar PTR para determinar o tamanho de um operando de
memória.
.data
myCount WORD 0
.code
mov esi,OFFSET myCount
inc [esi]
inc WORD PTR [esi]
PTR seria usado aqui?
add [esi],20
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
; error: ambiguous
; ok
Sim, porque [esi] pode
apontar para um byte, word,
ou doubleword
Web site
Examples
58
Exemplo de soma de vetor
Operandos indiretos são ideais para vetores. Note que o
registrador entre colchetes deve ser incrementado por um valor
que coincide com o tipo do vetor.
.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
Modificar este exemplo para um vetor de doublewords.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
59
Operandos indexados
Um operando indexado soma uma constante a um registrador
para gerar um endereço efetivo. Existem duas formas de
notação:
[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
Modificar o exemplo para um vetor de doublewords.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
60
Índice com escala
Pode-se usar um fator de escala (tipo do vetor) ao endereço
de um operando indireto ou indexado.
.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]
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
; 04
; 0004
; 00000004
Examples
61
ponteiros
Pode-se declarar uma variável ponteiro que contem o offset de
uma outra variável.
.data
arrayW WORD 1000h,2000h,3000h
ptrW DWORD arrayW
.code
mov esi,ptrW
mov ax,[esi]
; AX = 1000h
Formato alternativo:
ptrW DWORD OFFSET arrayW
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
62
Próxima seção
• Instrução de Transferência de Dados
• Adição e Subtração
• Operadores e Diretivas relacionados a
Dados
• Endereçamento Indireto
• Instruções JMP e LOOP
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
63
Instruções JMP e LOOP
•
•
•
•
•
Instrução JMP
Instrução LOOP
Exemplo de LOOP
Somando um vetor de inteiros
Copiando uma cadeia (String)
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
64
Instrução JMP
• JMP é um saldo incondicional a um label que é usualmente
dentro de um mesmo procedimento.
• Sintaxe: JMP target
• Lógica: EIP  target
• Exemplo:
top:
.
.
jmp top
Um jump para fora do procedimento deve ser um tipo especial de
label chamado de label global.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
65
Instrução LOOP
• A instrução LOOP cria um loop com contador
• Sintaxe: LOOP target
• Lógica:
• ECX  ECX – 1
• se ECX != 0, salta para target
• Implementação:
• O assembler calcula a distância, em bytes, entre o offset
da instrução seguinte e o offset do target, chamada offset
relativo.
• O offset relativo é somado ao EIP.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
66
Exemplo de LOOP
O loop seguinte calcula a soma dos inteiros 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
Quando LOOP é executado, a posição corrente = 0000000E (offset da
instrução seguinte) é somado com –5 (FBh) causando um salto para a
posição 00000009:
00000009  0000000E + FB
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
67
Sua vez . . .
Se o offset relativo é codificado num byte com sinal,
(a) qual é o maior jump retroativo possível?
(b) qual é o maior jump progressivo possível?
(a) -128
(b) +127
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
68
Sua vez . . .
mov ax,6
mov ecx,4
Qual o valor final de AX?
L1:
inc ax
loop L1
10
Quantas vezes o loop executa?
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
69
Loop aninhado
Se necessitamos codificar um loop dentro de um loop, deve-se
salvar o valor do contador do loop externo ECX.
No exemplo seguinte, o loop externo executa 100 vezes e o
loop interno 20 vezes.
.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
70
Somando um vetor de inteiros
O seguinte código calcula a soma de um vetor de inteiros de 16 bits
.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
71
Sua vez . . .
Que mudança voce faria ao programa
anterior se fosse somar um vetor de
doublewords?
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
72
Copiando uma cadeia
O seguinte código copia uma cadeia de fonte para destino:
.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
73
Sua vez . . .
Reescrever o programa anterior usando
endereçamento indireto ao invés de
endereçamento indexado.
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
74
Sumário
• Transferência de dados
• MOV – data transfer from source to destination
• MOVSX, MOVZX, XCHG
• Tipos de operandos
• direct, direct-offset, indirect, indexed
• Aritmética
• INC, DEC, ADD, SUB, NEG
• Sign, Carry, Zero, Overflow flags
• Operadores
• OFFSET, PTR, TYPE, LENGTHOF, SIZEOF, TYPEDEF
• JMP e LOOP – branching instructions
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
75
The End
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site
Examples
76