Assembly Language for Intel-Based Computers, 5 th Edition Capítulo 4: Transferência de Dados,...

Assembly Language for Intel-Based Assembly Language for Intel-Based Computers, 5Computers, 5thth Edition Edition

Capítulo 4: Transferência de Dados, Endereçamento, e

Aritmética

(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.

Slides prepared by the author

Revision date: June 4, 2006

Kip Irvine

Web site ExamplesIrvine, Kip R. Assembly Language for Intel-Based Computers 5/e, 2007. 2

ÍndiceÍ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


Instrução de Transferência de DadosInstruçã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)


Tipos de OperandosTipos 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


Notação de Operandos de InstruçãoNotação de Operandos de Instrução


Operandos de Memória por Operandos de Memória por endereçamento diretoendereç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.


Instrução MOVInstrução MOV

.datacount BYTE 100wVal WORD 2.code

mov bl,countmov ax,wValmov count,al

mov al,wVal ; errormov ax,count ; errormov eax,count ; error

• 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


Sua vez . . .Sua vez . . .

.databVal BYTE 100bVal2 BYTE ?wVal WORD 2dVal DWORD 5.code

mov ds,45

mov esi,wVal

mov eip,dVal

mov 25,bVal

mov bVal2,bVal

Explicar por que as instruções MOV seguintes são inválidas:

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


Extensão com ZerosExtensão com Zeros

mov bl,10001111b

movzx ax,bl ; zero-extension

Quando se copia um valor menor para um destino maior, a instrução MOVZX estende a parte mais significativa do destino com zeros.

O destino deve ser um registrador.


Extensão com SinalExtensão com Sinal

mov bl,10001111b

movsx ax,bl ; sign extension

A instrução MOVSX preenche a parte mais significativa do destino com uma cópia do bit de sinal do operando fonte.

O destino deve ser um registrador.


Instrução XCHGInstrução XCHG

.datavar1 WORD 1000hvar2 WORD 2000h.codexchg ax,bx ; exchange 16-bit regsxchg ah,al ; exchange 8-bit regsxchg var1,bx ; exchange mem, regxchg eax,ebx ; exchange 32-bit regs

xchg var1,var2 ; error: two memory operands

XCHG troca os valores de dois operandos. Pelo menos um operando deve ser um registrador. Nenhum operando imediato é permitido.


Operandos com deslocamento diretoOperandos com deslocamento direto(Direct-Offset)(Direct-Offset)

.dataarrayB BYTE 10h,20h,30h,40h.codemov al,arrayB+1 ; AL = 20hmov al,[arrayB+1] ; alternative notation

Um deslocamento é adicionado a um label para produzir um endereço efetivo (EA). O endereço é calculado pelo Assembler.

Por que arrayB+1 não resulta em 11h?


Operandos com deslocamento diretoOperandos com deslocamento direto(Direct-Offset)(Direct-Offset)(cont)(cont)

.dataarrayW WORD 1000h,2000h,3000harrayD DWORD 1,2,3,4.codemov ax,[arrayW+2] ; AX = 2000hmov ax,[arrayW+4] ; AX = 3000hmov 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?


Sua vez. . .Sua vez. . .

Escrever um programa que rearranja os valores de 3 doublewords no seguinte vetor: 3, 1, 2.

.dataarrayD DWORD 1,2,3

• passo 2: trocar EAX com o terceiro valor e copiar o valor em EAX para a primeira posição.

• passo1: copiar o primeiro valor em EAX e trocar com o valor na segunda posição.

mov eax,arrayDxchg eax,[arrayD+4]

xchg eax,[arrayD+8]mov arrayD,eax


Avaliar . . .Avaliar . . .

• Queremos escrever um programa que soma os 3 bytes seguintes:.datamyBytes 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?


Avaliar . . . Avaliar . . . (cont)(cont)

.datamyBytes BYTE 80h,66h,0A5h

• Falta algo no código seguinte?

movzx ax,myBytesmov bl,[myBytes+1]add ax,bxmov bl,[myBytes+2]add ax,bx ; AX = sum

Sim: Mover zero a BX antes da instrução MOVZX.


Próxima seçãoPróxima seção




Adição e SubtraçãoAdiçã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


Instruções INC e DECInstruçõ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


Exemplos de INC e DECExemplos de INC e DEC

.datamyWord WORD 1000hmyDword DWORD 10000000h.code

inc myWord ; 1001hdec myWord ; 1000hinc myDword ; 10000001h

mov ax,00FFhinc ax ; AX = 0100hmov ax,00FFhinc al ; AX = 0000h


Sua vez...Sua vez...

Mostrar o valor do operando destino depois que cada instrução é executada:

.datamyByte BYTE 0FFh, 0.code

mov al,myByte ; AL =mov ah,[myByte+1] ; AH =dec ah ; AH =inc al ; AL =dec ax ; AX =

FFh00hFFh00hFEFFh


Instruções ADD e SUBInstruçõ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


Exemplos de ADD e SUBExemplos de ADD e SUB

.datavar1 DWORD 10000hvar2 DWORD 20000h.code ; ---EAX---

mov eax,var1 ; 00010000hadd eax,var2 ; 00030000hadd ax,0FFFFh ; 0003FFFFhadd eax,1 ; 00040000hsub ax,1 ; 0004FFFFh


Instrução NEG (negar)Instrução NEG (negar)

.datavalB BYTE -1valW WORD +32767.code

mov al,valB ; AL = -1neg al ; AL = +1neg valW ; valW = -32767

Nega um operando. O operando pode ser de registrador ou memória.

Supondo que AX contenha –32,768, aplicar NEG.

O resultado é válido?


Instrução NEG e Flags Instrução NEG e Flags

.datavalB BYTE 1,0valC SBYTE -128.code

neg valB ; CF = 1, OF = 0neg [valB + 1] ; CF = 0, OF = 0neg valC ; CF = 1, OF = 1

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.


Implementando Expressões AritméticasImplementando Expressões Aritméticas

Rval DWORD ?Xval DWORD 26Yval DWORD 30Zval DWORD 40.code

mov eax,Xvalneg eax ; EAX = -26mov ebx,Yvalsub ebx,Zval ; EBX = -10add eax,ebxmov Rval,eax ; -36

Compiladores traduzem expressões matemáticas em linguagem Assembly. Fazer isso manualmente. Por exemplo:

Rval = -Xval + (Yval – Zval)


Sua vez...Sua vez...

mov ebx,Yvalneg ebxadd ebx,Zvalmov eax,Xvalsub eax,ebxmov Rval,eax

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.


Flags afetados pela aritméticaFlags 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.


Diagrama ilustrativoDiagrama ilustrativo

status flags

ALUconditional jumps

branching logic

arithmetic & bitwise operations

part of

used by provideattached to

affect

CPU

Pode-se usar diagramas como esse para expressar as relações entre os conceitos da linguagem assembly.

executes

executes


Flag Zero (ZF)Flag Zero (ZF)

mov cx,1sub cx,1 ; CX = 0, ZF = 1mov ax,0FFFFhinc ax ; AX = 0, ZF = 1inc ax ; AX = 1, ZF = 0

O flag Zero é acionado quando o resultado de uma operação produz zero no operando destino.

Lembrar ...• Acionar flag é torná-lo igual a 1. • Zerar flag é torná-lo igual a 0.


Flag Sign (SF)Flag Sign (SF)

mov cx,0sub cx,1 ; CX = -1, SF = 1add cx,2 ; CX = 1, SF = 0

O flag Sign é acionado quando o operando destino é negativo. O flag é zerado quando o operando destino é positivo.

O sign flag é uma cópia do bit de sinal do operando destino

mov al,0sub al,1 ; AL = 11111111b, SF = 1add al,2 ; AL = 00000001b, SF = 0


Inteiros com sinal e sem sinal Inteiros com sinal e sem sinal Ponto de vista do HardwarePonto 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


Flags de Overflow e CarryFlags de Overflow e CarryPonto de vista do HardwarePonto 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

MSB = Most Significant Bit (high-order bit)

XOR = eXclusive-OR operation

NEG = Negate (same as SUB 0,operand )


Flag Carry (CF)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,0FFhadd al,1 ; CF = 1, AL = 00

; Try to go below zero:

mov al,0sub al,1 ; CF = 1, AL = FF


Sua vez …Sua vez …

mov ax,00FFhadd ax,1 ; AX= SF= ZF= CF=sub ax,1 ; AX= SF= ZF= CF=add al,1 ; AL= SF= ZF= CF=mov bh,6Chadd bh,95h ; BH= SF= ZF= CF=

mov al,2sub al,3 ; AL= SF= ZF= CF=

Para cada uma das instruções aritméticas seguintes, mostrar os valores do operando destino e os flags de Sign, Zero e Carry :

0100h 0 0 000FFh 0 0 000h 0 1 1

01h 0 0 1

FFh 1 0 1


Flag Overflow (OF)Flag Overflow (OF)

O flag Overflow é acionado quando o resultado com sinal de uma operação é inválido ou fora do intervalo.

; Example 1mov al,+127add al,1 ; OF = 1, AL = ??

; Example 2mov al,7Fh ; OF = 1, AL = 80hadd 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.


Uma regra simples (Rule of Thumb)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,80hadd al,92h ; OF =

mov al,-2add al,+127 ; OF =

1

0


Sua vez. . .Sua vez. . .

mov al,-128neg al ; CF = OF =

mov ax,8000hadd ax,2 ; CF = OF =

mov ax,0sub ax,2 ; CF = OF =

mov al,-5sub al,+125 ; OF =

Quais seriam os valores dos flags para cada operação?

1 1

0 0

1 0

1






Operadores e diretivas relacionados a dadosOperadores e diretivas relacionados a dados

• Operador OFFSET • Operador PTR • Operador TYPE• Operador LENGTHOF• Operador SIZEOF • Diretiva LABEL


Operador OFFSET 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

Os programas em modo protegido tem apenas um segmento ( usando o modelo de memória flat).


Exemplos de OFFSETExemplos de OFFSET

.databVal BYTE ?wVal WORD ?dVal DWORD ?dVal2 DWORD ?

.codemov esi,OFFSET bVal ; ESI = 00404000hmov esi,OFFSET wVal ; ESI = 00404001hmov esi,OFFSET dVal ; ESI = 00404003hmov esi,OFFSET dVal2 ; ESI = 00404007h

Assumindo que o segmento de dados começa em 00404000h:


Relacionando a C/C++Relacionando a C/C++

; C++ version:char array[1000];char * p = array;

O valor retornado pelo OFFSET é um ponteiro. Comparar o seguinte código escrito em C++ e linguagem assembly:

.dataarray BYTE 1000 DUP(?).codemov esi,OFFSET array ; ESI is p


Operador PTR Operador PTR

.datamyDouble DWORD 12345678h.codemov ax,myDouble ; error – why?

mov ax,WORD PTR myDouble ; loads 5678h

mov WORD PTR myDouble,4321h ; saves 4321h

Sobrepõe o tipo default de um label (variável).

Provê a flexibilidade de acesso à parte de uma variável.

Lembrar a ordem de armazenamento little endian.


Ordenamento Little Endian 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.


Exemplo de operador PTRExemplo de operador PTR

.datamyDouble DWORD 12345678h

mov al,BYTE PTR myDouble ; AL = 78hmov al,BYTE PTR [myDouble+1] ; AL = 56hmov al,BYTE PTR [myDouble+2] ; AL = 34hmov ax,WORD PTR myDouble ; AX = 5678hmov ax,WORD PTR [myDouble+2] ; AX = 1234h


Operador PTR Operador PTR (cont)(cont)

.datamyBytes BYTE 12h,34h,56h,78h

.codemov ax,WORD PTR [myBytes] ; AX = 3412hmov ax,WORD PTR [myBytes+2] ; AX = 7856hmov eax,DWORD PTR myBytes ; EAX = 78563412h

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.



.datavarB BYTE 65h,31h,02h,05hvarW WORD 6543h,1202hvarD DWORD 12345678h

.codemov 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.

Escrever o valor de cada operando destino:

0502h78h02h1234h12026543h


Operador TYPEOperador TYPE

O operador TYPE retorna o tamanho em bytes de um único elemento de uma declaração de dados.

.datavar1 BYTE ?var2 WORD ?var3 DWORD ?var4 QWORD ?

.codemov eax,TYPE var1 ; 1mov eax,TYPE var2 ; 2mov eax,TYPE var3 ; 4mov eax,TYPE var4 ; 8


Operador LENGTHOFOperador LENGTHOF

.data LENGTHOFbyte1 BYTE 10,20,30 ; 3array1 WORD 30 DUP(?),0,0 ; 32array2 WORD 5 DUP(3 DUP(?)) ; 15array3 DWORD 1,2,3,4 ; 4digitStr BYTE "12345678",0 ; 9

.codemov ecx,LENGTHOF array1 ; 32

O operador LENGTHOF conta o número de elementos numa declaração única de dado.


Operador SIZEOFOperador SIZEOF

.data SIZEOFbyte1 BYTE 10,20,30 ; 3array1 WORD 30 DUP(?),0,0 ; 64array2 WORD 5 DUP(3 DUP(?)) ; 30array3 DWORD 1,2,3,4 ; 16digitStr BYTE "12345678",0 ; 9

.codemov ecx,SIZEOF array1 ; 64

O operador SIZEOF retorna um valor que é equivalente a multiplicar LENGTHOF por TYPE.


Usando Múltiplas Linhas Usando Múltiplas Linhas (1 de 2)(1 de 2)

.dataarray WORD 10,20,

30,40,50,60

.codemov eax,LENGTHOF array ; 6mov ebx,SIZEOF array ; 12

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:


Usando Múltiplas Linhas Usando Múltiplas Linhas (2 de 2)(2 de 2)

.dataarray WORD 10,20

WORD 30,40WORD 50,60

.codemov eax,LENGTHOF array ; 2mov ebx,SIZEOF array ; 4

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:


Diretiva LABELDiretiva 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

.datadwList LABEL DWORDwordList LABEL WORDintList BYTE 00h,10h,00h,20h.codemov eax,dwList ; 20001000hmov cx,wordList ; 1000hmov dl,intList ; 00h






Endereçamento IndiretoEndereçamento Indireto

• Operandos Indiretos• Exemplo de soma de vetor• Operandos Indexados• Ponteiros


Operandos indiretos Operandos indiretos (1 de 2)(1 de 2)

.dataval1 BYTE 10h,20h,30h.codemov esi,OFFSET val1mov al,[esi] ; dereference ESI (AL = 10h)

inc esimov al,[esi] ; AL = 20h

inc esimov al,[esi] ; AL = 30h

Um operando indireto refere-se ao endereço, geralmente, de um vetor ou cadeia. Funciona com um ponteiro.


Operandos indiretos Operandos indiretos (2 de 2)(2 de 2)

.datamyCount WORD 0

.codemov esi,OFFSET myCountinc [esi] ; error: ambiguousinc WORD PTR [esi] ; ok

Usar PTR para determinar o tamanho de um operando de memória.

PTR seria usado aqui?

add [esi],20

Sim, porque [esi] pode apontar para um byte, word, ou doubleword


Exemplo de soma de vetorExemplo de soma de vetor

.dataarrayW WORD 1000h,2000h,3000h.code

mov esi,OFFSET arrayWmov ax,[esi]add esi,2 ; or: add esi,TYPE arrayWadd ax,[esi]add esi,2add ax,[esi] ; AX = sum of the array

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.

Modificar este exemplo para um vetor de doublewords.


Operandos indexadosOperandos indexados

.dataarrayW WORD 1000h,2000h,3000h.code

mov esi,0mov ax,[arrayW + esi] ; AX = 1000hmov ax,arrayW[esi] ; alternate formatadd esi,2add ax,[arrayW + esi]etc.

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]

Modificar o exemplo para um vetor de doublewords.


Índice com escalaÍndice com escala

.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

Pode-se usar um fator de escala (tipo do vetor) ao endereço de um operando indireto ou indexado.


ponteirosponteiros

.dataarrayW WORD 1000h,2000h,3000hptrW DWORD arrayW.code

mov esi,ptrWmov ax,[esi] ; AX = 1000h

Pode-se declarar uma variável ponteiro que contem o offset de uma outra variável.

Formato alternativo:

ptrW DWORD OFFSET arrayW






Instruções JMP e LOOPInstruções JMP e LOOP

• Instrução JMP• Instrução LOOP• Exemplo de LOOP• Somando um vetor de inteiros• Copiando uma cadeia (String)


Instrução JMPInstrução JMP

top:..jmp top

• JMP é um saldo incondicional a um label que é usualmente dentro de um mesmo procedimento.

• Sintaxe: JMP target

• Lógica: EIP target

• Exemplo:

Um jump para fora do procedimento deve ser um tipo especial de label chamado de label global.


Instrução LOOPInstruçã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.


Exemplo de LOOPExemplo de LOOP

00000000 66 B8 0000 mov ax,0 00000004 B9 00000005 mov ecx,5

00000009 66 03 C1 L1: add ax,cx0000000C E2 FB loop L10000000E

O loop seguinte calcula a soma dos inteiros 5 + 4 + 3 +2 + 1:

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

offset machine code source code



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



Qual o valor final de AX?

mov ax,6mov ecx,4

L1:inc axloop L1

Quantas vezes o loop executa?mov ecx,0

X2:inc axloop X2

10

4,294,967,296


Loop aninhadoLoop aninhadoSe 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.

.datacount DWORD ?.code

mov ecx,100 ; set outer loop countL1:

mov count,ecx ; save outer loop countmov ecx,20 ; set inner loop count

L2: ..loop L2 ; repeat the inner loopmov ecx,count ; restore outer loop countloop L1 ; repeat the outer loop


Somando um vetor de inteirosSomando um vetor de inteiros

.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

O seguinte código calcula a soma de um vetor de inteiros de 16 bits



Que mudança voce faria ao programa

anterior se fosse somar um vetor de

doublewords?


Copiando uma cadeiaCopiando uma cadeia

.datasource BYTE "This is the source string",0target BYTE SIZEOF source DUP(0)

.codemov esi,0 ; index registermov ecx,SIZEOF source ; loop counter

L1:mov al,source[esi] ; get char from sourcemov target[esi],al ; store it in the targetinc esi ; move to next characterloop L1 ; repeat for entire string

good use of SIZEOF

O seguinte código copia uma cadeia de fonte para destino:



Reescrever o programa anterior usando endereçamento indireto ao invés de endereçamento indexado.


SumárioSumá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


The EndThe End

Date post:	17-Apr-2015
Category:	Documents
Upload:	internet
View:	103 times
Download:	0 times

Assembly Language for Intel-Based Computers, 5 th Edition Capítulo 4: Transferência de Dados,...

Documents