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.

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.

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.

Notação de Operandos de Instrução Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; AL = 10h mov al,[var1] ; AL = 10h alternativa Lembrar de mov al, (2000H) da aula-02. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; error mov ax,count ; error mov eax,count ; error Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 mov eip,dVal mov 25,bVal mov bVal2,bVal Move imediato para DS não permitido Tamanho incompatível EIP não pode ser destino Valor imediato não pode ser destino Move memória-a-memória não permitido Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

O destino deve ser um registrador. 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. 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.

O destino deve ser um registrador. 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. 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.

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 ; exchange 16-bit regs xchg ah,al ; exchange 8-bit regs xchg var1,bx ; exchange mem, reg xchg eax,ebx ; exchange 32-bit regs xchg var1,var2 ; error: two memory operands Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; AL = 20h mov al,[arrayB+1] ; alternative notation Por que arrayB+1 não resulta em 11h? Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

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.

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.

Avaliar . . . (cont) Sim: Mover zero a BX antes da instrução MOVZX. .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.

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.

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.

Instruções INC e DEC soma 1, subtrai 1 do operando destino INC 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.

Exemplos de INC e DEC .data myWord WORD 1000h myDword DWORD 10000000h .code inc myWord ; 1001h dec myWord ; 1000h inc myDword ; 10000001h mov ax,00FFh inc ax ; AX = 0100h inc al ; AX = 0000h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Sua vez... Mostrar o valor do operando destino depois que cada instrução é executada: .data myByte BYTE 0FFh, 0 .code mov al,myByte ; AL = mov ah,[myByte+1] ; AH = dec ah ; AH = inc al ; AL = dec ax ; AX = FFh 00h FEFFh Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Instruções ADD e SUB ADD destino, fonte SUB 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.

Exemplos de ADD e SUB .data var1 DWORD 10000h var2 DWORD 20000h .code ; ---EAX--- mov eax,var1 ; 00010000h add eax,var2 ; 00030000h add ax,0FFFFh ; 0003FFFFh add eax,1 ; 00040000h sub ax,1 ; 0004FFFFh Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; AL = -1 neg al ; AL = +1 neg valW ; 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.

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 ; CF = 1, OF = 0 neg [valB + 1] ; CF = 0, OF = 0 neg valC ; CF = 1, OF = 1 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; EAX = -26 mov ebx,Yval sub ebx,Zval ; EBX = -10 add eax,ebx mov Rval,eax ; -36 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

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.

arithmetic & bitwise operations Diagrama ilustrativo CPU part of executes executes ALU conditional jumps arithmetic & bitwise operations attached to used by provide affect 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.

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 ; CX = 0, ZF = 1 mov ax,0FFFFh inc ax ; AX = 0, ZF = 1 inc ax ; 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.

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 ; CX = -1, SF = 1 add cx,2 ; 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.

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.

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.

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 ; CF = 1, AL = FF Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; AX= SF= ZF= CF= sub ax,1 ; AX= SF= ZF= CF= add al,1 ; AL= SF= ZF= CF= mov bh,6Ch add bh,95h ; BH= SF= ZF= CF= mov al,2 sub al,3 ; AL= SF= ZF= CF= 0100h 0 0 0 00FFh 0 0 0 00h 0 1 1 01h 0 0 1 FFh 1 0 1 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; OF = 1, AL = 80h add al,1 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.

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 = mov al,-2 add al,+127 ; OF = 1 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Sua vez. . . Quais seriam os valores dos flags para cada operação? mov al,-128 neg al ; CF = OF = mov ax,8000h add ax,2 ; CF = OF = mov ax,0 sub ax,2 ; CF = OF = mov al,-5 sub al,+125 ; OF = 1 1 0 0 1 0 1 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

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.

Operador OFFSET Modo Protegido: 32 bits Modo Real: 16 bits OFFSET retorna a distância em bytes, de um label, do início do segmento Modo Protegido: 32 bits Modo Real: 16 bits 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.

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 ; ESI = 00404000h mov esi,OFFSET wVal ; ESI = 00404001h mov esi,OFFSET dVal ; ESI = 00404003h mov esi,OFFSET dVal2 ; ESI = 00404007h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

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.

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: Quando os inteiros são carregados da memória para registradores, os bytes são automaticamente reordenados nas posições corretas. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Exemplo de operador PTR .data myDouble DWORD 12345678h mov al,BYTE PTR myDouble ; AL = 78h mov al,BYTE PTR [myDouble+1] ; AL = 56h mov al,BYTE PTR [myDouble+2] ; AL = 34h mov ax,WORD PTR myDouble ; AX = 5678h mov ax,WORD PTR [myDouble+2] ; AX = 1234h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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] ; AX = 3412h mov ax,WORD PTR [myBytes+2] ; AX = 7856h mov eax,DWORD PTR myBytes ; EAX = 78563412h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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] ; a. mov bl,BYTE PTR varD ; b. mov bl,BYTE PTR [varW+2] ; c. mov ax,WORD PTR [varD+2] ; d. mov eax,DWORD PTR varW ; e. 0502h 78h 02h 1234h 12026543h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; 1 mov eax,TYPE var2 ; 2 mov eax,TYPE var3 ; 4 mov eax,TYPE var4 ; 8 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Operador LENGTHOF O operador LENGTHOF conta o número de elementos numa declaração única de dado. .data LENGTHOF byte1 BYTE 10,20,30 ; 3 array1 WORD 30 DUP(?),0,0 ; 32 array2 WORD 5 DUP(3 DUP(?)) ; 15 array3 DWORD 1,2,3,4 ; 4 digitStr BYTE "12345678",0 ; 9 .code mov ecx,LENGTHOF array1 ; 32 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Operador SIZEOF O operador SIZEOF retorna um valor que é equivalente a multiplicar LENGTHOF por TYPE. .data SIZEOF byte1 BYTE 10,20,30 ; 3 array1 WORD 30 DUP(?),0,0 ; 64 array2 WORD 5 DUP(3 DUP(?)) ; 30 array3 DWORD 1,2,3,4 ; 16 digitStr BYTE "12345678",0 ; 9 .code mov ecx,SIZEOF array1 ; 64 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; 6 mov ebx,SIZEOF array ; 12 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; 2 mov ebx,SIZEOF array ; 4 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

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.

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.

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 mov al,[esi] ; AL = 30h Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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] ; error: ambiguous inc WORD PTR [esi] ; ok PTR seria usado aqui? add [esi],20 Sim, porque [esi] pode apontar para um byte, word, ou doubleword Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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] ; AX = 1000h mov ax,arrayW[esi] ; alternate format add esi,2 add ax,[arrayW + esi] etc. Modificar o exemplo para um vetor de doublewords. Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Í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] ; 04 mov bx,arrayW[esi*TYPE arrayW] ; 0004 mov edx,arrayD[esi*TYPE arrayD] ; 00000004 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

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.

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.

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.

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.

Exemplo de LOOP O loop seguinte calcula a soma dos inteiros 5 + 4 + 3 +2 + 1: offset machine code source code 00000000 66 B8 0000 mov ax,0 00000004 B9 00000005 mov ecx,5 00000009 66 03 C1 L1: add ax,cx 0000000C E2 FB loop L1 0000000E 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.

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? -128 +127 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

Sua vez . . . Qual o valor final de AX? 10 mov ax,6 mov ecx,4 L1: inc ax loop L1 Qual o valor final de AX? 10 Quantas vezes o loop executa? mov ecx,0 X2: inc ax loop X2 4,294,967,296 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; set outer loop count L1: mov count,ecx ; save outer loop count mov ecx,20 ; set inner loop count L2: . . loop L2 ; repeat the inner loop mov ecx,count ; restore outer loop count loop L1 ; repeat the outer loop Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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 ; address of intarray mov ecx,LENGTHOF intarray ; loop counter mov ax,0 ; zero the accumulator L1: add ax,[edi] ; add an integer add edi,TYPE intarray ; point to next integer loop L1 ; repeat until ECX = 0 Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

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 ; index register mov ecx,SIZEOF source ; loop counter L1: mov al,source[esi] ; get char from source mov target[esi],al ; store it in the target inc esi ; move to next character loop L1 ; repeat for entire string good use of SIZEOF Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.

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.

Sumário Transferência de dados Tipos de operandos Aritmética 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.

The End Irvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007.