Transcript Chapter 4
Assembly Language for Intel-Based Computers, 5
th
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 (Direct Offset) 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 4 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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 ; error ; error ; error
Web site Examples Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
7
Sua vez . . .
Explicar por que as instruções MOV seguintes são inválidas:
.data
bVal BYTE 100 bVal2 BYTE ?
wVal WORD 2 dVal DWORD 5 .code
mov ds,45 mov esi,wVal Move imediato para DS não permitido 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
8 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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 1 0 0 0 1 1 1 1
Source
0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1
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.
1 0 0 0 1 1 1 1
Source
1 1 1 1 1 1 1 1 1 0 0 0 1 1 1 1
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 ; exchange 16-bit regs ; exchange 8-bit regs ; exchange mem, reg ; exchange 32-bit regs ; error: two memory operands
11 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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
14 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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?
15 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
Avaliar . . .
(cont)
.data
myBytes BYTE 80h,66h,0A5h
• Falta algo no código seguinte?
movzx ax,myBytes mov bl,[myBytes+1] add ax,bx mov bl,[myBytes+2] add 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 ax,00FFh inc ax mov ax,00FFh inc al ; 1001h ; 1000h ; 10000001h ; AX = 0100h ; AX = 0000h
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples 20
Sua vez...
Mostrar o valor do operando destino depois que cada instrução é executada:
.data
myByte BYTE 0FFh, 0 .code
mov al,myByte mov ah,[myByte+1] dec ah inc al dec ax ; AL = ; AH = ; AH = ; AL = ; AX = FFh 00h FFh 00h FEFFh
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 ; ---EAX-- ; 00010000h ; 00030000h ; 0003FFFFh ; 00040000h ; 0004FFFFh
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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?
Web site Examples Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 ; CF = 1, OF = 0 ; CF = 0, OF = 0 ; CF = 1, OF = 1
25 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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 ; EAX = -26 ; EBX = -10 ; -36
26 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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 ebx,Yval neg ebx add ebx,Zval mov eax,Xval sub eax,ebx mov 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.
28 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
Diagrama ilustrativo
CPU part of executes executes ALU arithmetic & bitwise operations affect attached to status flags used by conditional jumps provide 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 cx,1 sub cx,1 mov ax,0FFFFh inc ax inc 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 ; AL = 11111111b, SF = 1 add al,2 ; 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) Added Slide. Gerald Cahill, Antelope Valley College Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
MSB = Most Significant Bit (high-order bit) XOR = eXclusive-OR operation NEG = Negate (same as SUB 0,operand ) 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 ; Try to go below zero: mov al,0 sub al,1 ; CF = 1, AL = 00 ; CF = 1, AL = FF
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 ax,00FFh add ax,1 sub ax,1 add al,1 mov bh,6Ch add bh,95h ; AX= SF= ZF= CF= ; AX= SF= ZF= CF= ; AL= SF= ZF= CF= mov al,2 sub al,3
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 ; OF = 1, AL = ??
; Example 2 mov al,7Fh add al,1 ; 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.
36 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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 ; OF = 0
37 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
Sua vez. . .
Quais seriam os valores dos flags para cada operação?
mov al,-128 neg al mov ax,8000h add ax,2 mov ax,0 sub ax,2 mov al,-5 sub al,+125 ; CF = ; CF = ; 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 início do segmento bytes, de um label, do • 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).
Web site Examples Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 bVal mov esi,OFFSET wVal mov esi,OFFSET dVal mov esi,OFFSET dVal2 ; ESI = 00404000h ; ESI = 00404001h ; ESI = 00404003h ; ESI = 00404007h
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site 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 ; ESI is p
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 mov ax,WORD PTR myDouble mov WORD PTR myDouble,4321h ; error – why?
; loads 5678h ; 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
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: doubleword 12345678 word 5678 byte 78 56 1234 34 12 offset 0000 0001 0002 0003 myDouble Quando os inteiros são carregados da memória para registradores, os bytes são myDouble + 2 automaticamente reordenados nas posições corretas.
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 12345678 word 5678 byte 78 56 1234 34 12 offset 0000 myDouble 0001 myDouble + 1 0002 myDouble + 2 0003 myDouble + 3
mov al,BYTE PTR myDouble mov al,BYTE PTR [myDouble+1] mov al,BYTE PTR [myDouble+2] mov ax,WORD PTR myDouble mov ax,WORD PTR [myDouble+2] ; AL = 78h ; AL = 56h ; AL = 34h ; AX = 5678h ; AX = 1234h
Web site Examples Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 ; AX = 3412h ; AX = 7856h ; EAX = 78563412h
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 ; a.
; b.
; c.
; d.
; e.
0502h 78h 02h 1234h 12026543h
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 var1 mov eax,TYPE var2 mov eax,TYPE var3 mov eax,TYPE var4 ; 1 ; 2 ; 4 ; 8
49 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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 .code
mov ecx,LENGTHOF array1
LENGTHOF
; 3 ; 32 ; 15 ; 4 ; 9 ; 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 .code
mov ecx,SIZEOF array1
SIZEOF
; 3 ; 64 ; 30 ; 16 ; 9 ; 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 ; 6 ; 12
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 ; 2 ; 4
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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] inc esi mov al,[esi] inc esi mov al,[esi] ; dereference ESI (AL = 10h) ; AL = 20h ; AL = 30h
57 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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] ; error: ambiguous ; ok
PTR seria usado aqui?
add [esi],20
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 WORD 1000h,2000h,3000h .code
mov esi,OFFSET arrayW mov ax,[esi] add esi,2 ; or: add esi,TYPE arrayW add ax,[esi] add esi,2 add ax,[esi] ; AX = sum of the array
Modificar este exemplo para um vetor de doublewords.
59 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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] [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.
; AX = 1000h ; alternate format
Modificar o exemplo para um vetor de doublewords.
60 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
Í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] ; 04 ; 0004 ; 00000004
61 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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
62 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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.
66 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
Exemplo de LOOP
O loop seguinte calcula a soma dos inteiros 5 + 4 + 3 +2 + 1: offset machine code
00000000 66 B8 0000 00000004 B9 00000005 00000009 66 03 C1 0000000C E2 FB 0000000E
source code
mov ax,0 mov 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) (b) 128 +127 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples 68
Qual o valor final de AX?
10
Sua vez . . .
L1: mov ax,6 mov ecx,4 inc ax loop L1
Quantas vezes o loop executa?
4,294,967,296
X2: mov ecx,0 inc ax loop X2
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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
70 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
Web site Examples
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 ; address of intarray ; loop counter ; zero the accumulator ; add an integer ; point to next integer ; repeat until ECX = 0
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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 BYTE "This is the source string",0 target BYTE SIZEOF source DUP(0) .code
mov esi,0 mov ecx,SIZEOF source L1: mov al,source[esi] mov target[esi],al inc esi loop L1 ; index register ; loop counter good use of SIZEOF ; get char from source ; store it in the target ; move to next character ; repeat for entire string
Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.
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