Baixe Tutorial Linguagem Assembly e outras Notas de estudo em PDF para Informática, somente na Docsity!
T U T O R I A L D E L I N G U A G E M A S S E M B L Y
Conteúdo: 1.Introdução 2.Conceitos Básicos 3.Programação Assembly 4.Instruções Assembly 5.Interrupções e gerência de arquivos 6.Macros e procedimentos 7.Exemplos de programas 8.Bibliografia
CAPÍTULO 1: INTRODUÇÃO Conteúdo: 1.1.O que há de novo neste material 1.2.Apresentação 1.3.Por que aprender Assembly? 1.4.Nós precisamos da sua opinião --------------- // --------------- 1.1.O que há de novo neste material: Após um ano da realização da primeira versão do tutorial, e através das Opiniões recebidas por e-mail, resolvemos ter por disposição todos estes comentários e sugestões. Esperamos que através deste novo material Assembly, as pessoas que se mostrarem interessadas possam aprender mais sobre o seu IBM PC. Esta nova edição do tutorial inclui: Uma seção completa sobre como usar o programa debug. Mais exemplos de programas. Um motor de pesquisa, para qualquer tópico ou item relacionado a esta nova versão. Considerável reorganização e revisão do material Assembly. Em cada seção, há um link para o Dicionário On-line de Computação de Dennis Howe. 1.2.Apresentação: Este tutorial destina-se aquelas pessoas que nunca tiveram contato com a Linguagem Assembly. O tutorial está completamente focado em computadores com processadores 80x da família Intel, e considerando que a base da linguagem é o funcionamento dos recursos internos do processador, os exemplos descritos não são compatíveis com qualquer outra arquitetura.
As informações estão dispostas em unidades ordenadas para permitir fácil acesso a cada tópico, bem como uma melhor navegação pelo tutorial. Na seção introdutória são mencionados alguns conceitos elementares sobre computadores e a Linguagem Assembly em si. 1.3.Por que aprender Assembly? A primeira razão para se trabalhar com o assembly é a oportunidade de conhecer melhor o funcionamento do seu PC, o que permite o desenvolvimento de programas de forma mais consistente. A segunda razão é que você pode ter um controle total sobre o PC ao fazer uso do assembly. Uma outra razão é que programas assembly são mais rápidos, menores e mais poderosos do que os criados com outras linguagens. Ultimamente, o assembler (montador) permite uma otimização ideal nos programas, seja no seu tamanho ou execução. 1.4.Nós precisamos da sua opinião: Nosso intuito é oferecer um modo simples para que você consiga aprender Assembly por si mesmo. Por tanto, qualquer comentário ou sugestão ser bem-vinda.
CAPÍTULO 2: CONCEITOS BÁSICOS Conteúdo: 2.1.Descrição básica de um sistema computacional. 2.2.Conceitos básicos da Linguagem Assembly 2.3.Usando o programa debug --------------- // --------------- Esta seção tem o propósito de fazer um breve comentário a respeito dos principais componentes de um sistema computacional, o que ir permitir ao usuário uma melhor compreensão dos conceitos propostos no decorrer do tutorial. 2.1.DESCRIÇÃO DE UM SISTEMA COMPUTACIONAL 2.1.1.Processador Central
comunicações é possível introduzir informação a será processada e mais tarde visualizar os dados processados. Algumas das mais comuns unidades de entrada são o teclado e o mouse. As mais comuns unidades de saída são a tela do monitor e a impressora. 2.1.4.Unidades de Memória Auxiliar. Considerando o alto custo da memória principal e também o tamanho das aplicações atualmente, vemos que ela é muito limitada. Logo, surgiu a necessidade da criação de dispositivos de armazenamento práticos e econômicos. Estes e outros inconvenientes deram lugar às unidades de memória auxiliar, periféricos. As mais comuns são as fitas e os discos magnéticos. A informação ali armazenada pode ser dividida em arquivos. Um arquivo é feito de um número variável de registros, geralmente de tamanho fixo, podendo conter informação ou programas. --------------- // --------------- 2.2.CONCEITOS BÁSICOS 2.2.1.Informações nos computadores 2.2.2.Métodos de representação de dados 2.2.1.Informação no computador: 2.2.1.1 Unidades de informação 2.2.1.2.Sistemas numéricos 2.2.1.3.Convertendo números binários para decimais 2.2.1.4.Convertendo números decimais para binários 2.2.1.5.Sistema hexadecimal 2.2.1.1.Unidades de informação Para o PC processar a informação, é necessário que ela esteja em células especiais, chamadas á registradores. Os registradores são grupos de 8 ou 16 flip-flops. Um flip-flop é um dispositivo capaz de armazenar 2 níveis de voltagem, um baixo, geralmente 0.5 volts, e outro comumente de 5 volts. O nível baixo de energia no flip-flop é interpretado como desligado ou 0, e o nível alto, como ligado ou 1. Estes estados são geralmente conhecidos como bits, que são a menor unidade de informação num computador. Um grupo de 16 bits é conhecido como palavra; uma palavra pode ser dividida em grupos de 8 bits chamados bytes, e grupos de 4 bits chamados nibbles. 2.2.1.2.Sistemas numéricos O sistema numérico que nós usamos diariamente é o decimal, mas este sistema não é conveniente para máquinas, pois ali as informações tem que ser codificadas de modo a interpretar os estados da corrente (ligado-desligado); este modo de código faz com que tenhamos que conhecer o cálculo posicional que nos permitir expressar um número em qualquer base onde precisarmos dele. É possível representar um determinado número em qualquer base através da seguinte fórmula:
Onde n é a posição do dígito, iniciando da direita para a esquerda e numerando de 0. D é o dígito sobre o qual nós operamos e B é a base numérica usada. 2.2.1.3.Convertendo números binários para decimais Quando trabalhamos com a Linguagem Assembly encontramos por acaso a necessidade de converter números de um sistema binário, que é usado em computadores, para o sistema decimal usado pelas pessoas. O sistema binário é baseado em apenas duas condições ou estados, estar ligado(1), ou desligado(0), portanto sua base é dois. Para a conversão, podemos usar a fórmula de valor posicional: Por exemplo, se tivermos o número binário 10011, tomamos cada dígito da direita para a esquerda e o multiplicamos pela base, elevando ... potência correspondente ... sua posição relativa: Binary: 1 1 0 0 1 Decimal: 12^0 + 12^1 + 02^2 + 02^3 + 1*2^ = 1 + 2 + 0 + 0 + 16 = 19 decimal. O caracter ^ é usado em computação como símbolo para potência e * para a multiplicação. 2.2.1.4.Convertendo números decimais para binário Há vários métodos para se converter números decimais para binário; apenas um Vai ser analisado aqui. Naturalmente a conversão com uma calculadora científica é muito mais fácil, mas nem sempre podemos contar com isso, logo o mais conveniente é, ao menos, sabermos uma fórmula para fazê-la. O método resume-se na aplicação de divisões sucessivas por 2, mantendo o resto como o dígito binário e o resultado como o próximo número a ser dividido. Tomemos como exemplo o número decimal 43. 43/2=21 e o resto é 1; 21/2=10 e o resto é 1; 10/2=5 e o resto é 0; 5/2=2 e o resto é 1; 2/2=1 e o resto é 0; 1/2=0 e o resto é 1. Para construir o equivalente binário de 43, vamos pegar os restos obtidos de baixo para cima, assim temos 101011. 2.2.1.5.Sistema hexadecimal Na base hexadecimal temos 16 dígitos, que vão de 0 a 9 e da letra A até a F, estas letras representam os números de 10 a 15. Portanto contamos: 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E, e F.
2.2.2.2.Método BCD BCD significa Binary Coded Decimal. Neste método grupos de 4 bits são usados para representar cada dígito decimal de 0 a 9. Com este método podemos representar 2 dígitos por byte de informação. Vemos que este método vem a ser muito mais prático para representação numérica do que o código ASCII. Embora ainda menos prático do que o binário, com o método BCD podemos representar dígitos de 0 a 99. Com o binário, vemos que o alcance é maior, de 0 a 255. Este formato (BCD) é principalmente usado na representação de números grandes, aplicações comerciais, devido as suas facilidades de operação. 2.2.2.3.Representação de ponto flutuante Esta representação é baseada em notação científica, isto é, representar um número em 2 partes: sua base e seu expoente. Por exemplo o número decimal 1234000, é representado como 1.234*10^6, observamos que o expoente irá indicar o número de casas que o ponto decimal deve ser movido para a direita, a fim de obtermos o número original. O expoente negativo, por outro lado, indica o número de casas que o ponto decimal deve se locomover para a esquerda. --------------- // --------------- 2.3.PROGRAMA DEBUG 2.3.1.Processo de criação de programas 2.3.2.Registradores da CPU 2.3.3.Programa debug 2.3.4.Estrutura Assembly 2.3.5.Criando um programa assembly simples 2.3.6.Armazenando e carregando os programas 2.3.1.Processo de criação de programas. Para a criação de programas são necessários os seguintes passos:
- Desenvolvimento do algoritmo, estágio em que o problema a ser solucionado é estabelecido e a melhor solução é proposta, criação de diagramas esquemáticos relativos ... melhor solução proposta.
- Codificação do algoritmo, o que consiste em escrever o programa em alguma linguagem de programação; linguagem assembly neste caso específico, tomando como base a solução proposta no passo anterior.
- A transformação para a linguagem de máquina, ou seja, a criação do programa objeto, escrito como uma seqüência de zeros e uns que podem ser interpretados pelo processador.
- O último estágio é a eliminação de erros detectados no programa na fase de teste. A correção normalmente requer a repetição de todos os passos, com observação atenta.
2.3.2.Registradores da CPU. Para o propósito didático, vamos focar registradores de 16 bits. A CPU possui 4 registradores internos, cada um de 16 bits. São eles AX, BX, CX e DX. São registradores de uso geral e também podem ser usados como registradores de 8 bits. Para tanto devemos referenciá-los como, por exemplo, AH e AL, que são, respectivamente, o byte high e o low do registrador AX. Esta nomenclatura também se aplica para os registradores BX, CX e DX. Os registradores, segundo seus respectivos nomes: AX Registrador Acumulador BX Registrador Base CX Registrador Contador DX Registrador de Dados DS Registrador de Segmento de Dados ES Registrador de Segmento Extra SS Registrador de Segmento de Pilha CS Registrador de Segmento de Código BP Registrador Apontador da Base SI Registrador de Índice Fonte DI Registrador de Índice Destino SP Registrador Apontador de Pilha IP Registrador Apontador da Próxima Instrução F Registrador de Flag
2.3.3.Programa Debug.
Para a criação de um programa em assembly existem 2 opções: usar o
TASM -
Turbo Assembler da Borland, ou o DEBUGGER. Nesta primeira seção
vamos usar o
debug, uma vez que podemos encontrá-lo em qualquer PC com o MS-DOS.
Debug pode apenas criar arquivos com a extensão .COM, e por causa das
características deste tipo de programa, eles não podem exceder os 64 Kb,
e
também devem iniciar no endereço de memória 0100H dentro do segmento
específico. É importante observar isso, pois deste modo os programas
.COM
não são relocáveis.
Os principais comandos do programa debug são:
A Montar instruções simbólicas em código de máquina
D Mostrar o conteúdo de uma área da memória
E Entrar dados na memória, iniciando num endereço específico
G Rodar um programa executável na memória
N Dar nome a um programa
P Proceder, ou executar um conjunto de instruções relacionadas
comando. Por
exemplo:
add ah bh
Aqui "add" é o comando a ser executado, neste caso uma adição, e "ah"
bem
como "bh" são os parâmetros.
Por exemplo:
mov al, 25
No exemplo acima, estamos usando a instrução mov, que significa mover o
valor 25 para o registrador al.
O nome das instruções nesta linguagem é constituído de 2, 3 ou 4 letras.
Estas instruções são chamadas mnemônicos ou códigos de operação,
representando a função que o processador executará.
Às vezes instruções aparecem assim:
add al,[170] <- Ponteiro
Os colchetes no segundo parâmetro indica-nos que vamos trabalhar com o
conteúdo da célula de memória de número 170, ou seja, com o valor
contido no
endereço 170 da memória e não com o valor 170, isto é conhecido como
"endereçamento direto".
2.3.5.Criando um programa simples em assembly.
Não nos responsabilizaremos pela má execução ou possíveis danos
causados por
quaisquer exemplos que de agora em diante aparecerão, uma vez que os
mesmos,
apesar de testados, são de caráter didático. Vamos, então, criar um
programa
para ilustrar o que vimos até agora. Adicionaremos dois valores:
O primeiro passo é iniciar o Debug, o que já vimos como fazer
anteriormente.
Para montar um programa no Debug, é usado o comando "a" (assemble);
quando
usamos este comando, podemos especificar um endereço inicial para o
nosso
programa como o parâmetro, mas é opcional. No caso de omissão, o
endereço
inicial é o especificado pelos registradores CS:IP, geralmente 0100h, o
local em que programas com extensão .COM devem iniciar. E ser este o
local
que usaremos, uma vez que o Debug só pode criar este tipo de programa.
Embora neste momento não seja necessário darmos um parâmetro ao
comando "a",
isso é recomendável para evitar problemas, logo:
a 100[enter]
mov ax,0002[enter]
mov bx,0004[enter]
add ax,bx[enter]
nop[enter][enter]
O que o programa faz? Move o valor 0002 para o registrador ax, move o
valor
0004 para o registrador bx, adiciona o conteúdo dos registradores ax e bx,
guardando o resultado em ax e finalmente a instrução nop (nenhuma
operação)
finaliza o programa.
No programa debug, a tela se parecerá com:
C:>debug
-a 100
0D62:0100 mov ax,
0D62:0103 mov bx,
0D62:0106 add ax,bx
0D62:0108 nop
0D62:
Entramos com o comando "t" para executar passo a passo as instruções:
-t
AX=0002 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=
DI=
DS=0D62 ES=0D62 SS=0D62 CS=0D62 IP=0103 NV UP EI PL NZ NA
PO NC
0D62:0103 BB0400 MOV BX,
Vemos o valor 0002 no registrador AX. Teclamos "t" para executar a
segunda
instrução:
-t
AX=0002 BX=0004 CX=0000 DX=0000 SP=FFEE BP=0000 SI=
DI=
-n test.com O comando "rcx" permite-nos mudar o conteúdo do registrador CX para o valor obtido como tamanho do arquivo com o comando "h", neste caso 000a. -rcx CX 0000 :000a Finalmente, o comando "w" grava nosso programa no disco, indicando quantos bytes gravou. -w Writing 000A bytes Para já salvar um arquivo quando carregá-lo, 2 passos são necessários: Dar o nome do arquivo a ser carregado. Carregá-lo usando o comando "l" (load). Para obter o resultado correto destes passos, é necessário que o programa acima já esteja criado. Dentro do Debug, escrevemos o seguinte: -n test.com -l -u 100 109 0C3D:0100 B80200 MOV AX, 0C3D:0103 BB0400 MOV BX, 0C3D:0106 01D8 ADD AX,BX 0C3D:0108 CD20 INT 20 O último comando "u" é usado para verificar que o programa foi carregado na memória. O que ele faz é desmontar o código e mostrá-lo em assembly. Os parâmetros indicam ao Debug os endereços inicial e final a serem desmontados. O Debug sempre carrega os programas na memória no endereço 100h, conforme já comentamos.
CAPÍTULO 3: PROGRAMAÇÃO ASSEMBLY Conteúdo: 3.1.Construindo programas em Assembly 3.2.Processo Assembly 3.3.Pequenos programas em Assembly 3.4.Tipos de instruções --------------- // --------------- 3.1.Construindo programas em Assembly. 3.1.1.Software necessário 3.1.2.Programação Assembly
3.1.1.SOFTWARE NECESSÁRIO
Para que possamos criar um programa, precisamos de algumas ferramentas: Primeiro de um editor para criar o programa fonte. Segundo de um montador, um programa que irá transformar nosso fonte num programa objeto. E, terceiro, de um linker (ligador) que irá gerar o programa executável a partir do programa objeto. O editor pode ser qualquer um que dispusermos. O montador será o TASM macro assembler da Borland, e o linker será o TLINK, também da Borland. Nós devemos criar os programas fonte com a extensão .ASM para que o TASM reconheça e o transforme no programa objeto, um "formato intermediário" do programa, assim chamado porque ainda não é um programa executável e tão pouco um programa fonte. O linker gera a partir de um programa .OBJ, ou da combinação de vários deles, um programa executável, cuja extensão é normalmente .EXE, embora possa ser .COM dependendo da forma como for montado e ligado. 3.1.2.PROGRAMAÇÃO ASSEMBLY Para construirmos os programas com o TASM, devemos estruturar o fonte de forma diferenciada ao que fazíamos com o programa debug. É importante incluir as seguintes diretivas assembly: .MODEL SMALL Define o melo de memória a usar em nosso programa .CODE Define as instruções do programa, relacionado ao segmento de código .STACK Reserva espaço de memória para as instruções de programa na pilha END Finaliza um programa assembly Vamos programar Primeiro passo Use qualquer editor para criar o programa fonte. Entre com as seguintes linhas: Primeiro exemplo ; use ; para fazer comentários em programas assembly .MODEL SMALL ;modelo de memória .STACK ;espaço de memória para instruções do programa na pilha .CODE ;as linhas seguintes são instruções do programa mov ah,01h ;move o valor 01h para o registrador ah mov cx,07h ;move o valor 07h para o registrador cx int 10h ;interrupção 10h mov ah,4ch ;move o valor 4ch para o registrador ah int 21h ;interrupção 21h END ;finaliza o código do programa Este programa assembly muda o tamanho do cursor.
Desta forma, para que o montador seja capaz de gerenciar os dados, se faz necessário que cada informação ou instrução se encontre na área correspondente ao seu segmento. O endereço do segmento é fornecido ao montador pelos registradores DS, ES, SS e CS. Lembrando um programa no Debug, observe: 1CB0:0102 MOV AX,BX O primeiro número 1CB0, corresponde ao segmento de memória que está sendo usado, o segundo é uma referência ao endereço dentro do segmento , é um deslocamento dentro do segmento offset. O modo usado para indicar ao montador com quais segmentos vamos trabalhar é fazendo uso das diretivas .CODE, .DATA e .STACK. O montador ajusta o tamanho dos segmentos tomando como base o número de bytes que cada instrução assembly precisa, já que seria um desperdício de memória usar segmentos inteiros. Por exemplo, se um programa precisa de apenas 10Kb para armazenar dados, o segmento de dados seria apenas de 10Kb e não de 64Kb, como poderia acontecer se feito manualmente. 3.2.2.TABELAS DE EQUIVALÊNCIA Cada uma das partes numa linha de código assembly é conhecida como token, por exemplo: MOV AX,Var Aqui temos três tokens, a instrução MOV, o operador AX e o operador VAR. O que o montador faz para gerar o código OBJ é ler cada um dos tokens e procurar a equivalência em código de máquina em tabelas correspondentes, seja de palavras reservadas, tabela de códigos de operação, tabela de símbolos, tabela de literais, onde o significado dos mnemônicos e os endereços dos símbolos que usamos serão encontrados. A maioria dos montadores são de duas passagens. Em síntese na primeira passagem temos a definição dos símbolos, ou seja, são associados endereços a todas as instruções do programa. Seguindo este processo, o assembler lê MOV e procura-o na tabela de códigos de operação para encontrar seu equivalente na linguagem de máquina. Da mesma forma ele lê AX e encontra-o na tabela correspondente como sendo um registrador. O processo para Var é um pouco diferenciado, o montador verifica que ela não é uma palavra reservada, então procura na tabela de símbolos, lá encontrando-a ele designa o endereço correspondente, mas se não encontrou ele a insere na tabela para que ela possa receber um endereço na segunda passagem. Ainda na primeira passagem é executado parte do processamento das diretivas, é importante notar que as diretivas não criam código objeto. Na passagem dois são montadas as instruções, traduzindo os códigos de operação e procurando os endereços, e é gerado o código objeto. Há símbolos que o montador não consegue encontrar, uma vez que podem ser declarações externas. Neste caso o linker entra em ação para criar a estrutura necessária a fim de ligar as diversas possíveis partes de código, dizendo ao loader que o segmento e o token em questão são definidos quando o programa é carregado e antes de ser executado. --------------- // ---------------
3.3.Mais programas. Outro exemplo Primeiro passo Use qualquer editor e crie o seguinte: ;exemplo .model small .stack .code mov ah,2h ;move o valor 2h para o registrador ah mov dl,2ah ;move o valor 2ah para o registrador dl ;(é o valor ASCII do caractere *) int 21h ;interrupção 21h mov ah,4ch ;função 4ch, sai para o sistema operacional int 21h ;interrupção 21h end ;finaliza o programa Segundo passo Salvar o arquivo com o nome: exam2.asm Não esquecer de salvar em formato ASCII. Terceiro passo Usar o programa TASM para construir o programa objeto. C:>tasm exam2.asm Turbo Assembler Version 2.0 Copyright (c) 1988, 1990 Borland International Assembling file: exam2.asm Error messages: None Warning messages: None Passes: 1 Remaining memory: 471k Quarto passo Usar o programa TLINK para criar o programa executável. C:>tlink exam2.obj Turbo Link Version 3.0 Copyright (c) 1987, 1990 Borland International C:> Quinto passo Executar o programa: C:>exam2[enter]
C:> Este programa imprime o caracter * na tela. --------------- // --------------- 3.4.Tipos de instruções. 3.4.1.Movimento de dados 3.4.2.Operações lógicas e aritméticas 3.4.3.Saltos, laços e procedimentos
As instruções de operações lógicas são: and, not, or e xor. Elas trabalham a nível de bits em seus operadores. Para verificar o resultado das operações usamos as instruções cmp e test. As instruções usadas para operações algébricas são: para adição add, para subtração sub, para multiplicação mul e para divisão div. Quase todas as instruções de comparação são baseadas na informação contida no registrador de flag. Normalmente os flags do registrador que podem ser manuseados diretamente pelo programador são os da direção de dados DF, usado para definir as operações sobre cadeias. Uma outro que pode também ser manuseado é o flag IF através das instruções sti e cli, para ativar e desativar as interrupções. 3.4.3.SALTOS, LOOPS E PROCEDIMENTOS Saltos incondicionais na escrita de programas em linguagem assembly são dados pela instrução jmp; um salto é usado para modificar a seqüência da execução das instruções de um programa, enviando o controle ao endereço indicado, ou seja, o registrador contador de programa recebe este novo endereço. Um loop, também conhecido como interação, é a repetição de um processo um certo número de vezes até atingir a condição de parada.
CAPÍTULO 4: INSTRUÇÕES ASSEMBLY Conteúdo: 4.1.Instruções de operação de dados 4.2.Instruções lógicas e aritméticas 4.3.Instruções de controle de processos --------------- // --------------- 4.1. Instruções de operação de dados 4.1.1.Instruções de transferência 4.1.2.Instruções de carga 4.1.3.Instruções de pilha 4.1.1.Instruções de transferência. São usadas para mover o conteúdo dos operadores. Cada instrução pode ser usada com diferentes modos de endereçamento. MOV MOVS (MOVSB) (MOVSW) INSTRUÇÃO MOV Propósito: Transferência de dados entre células de memória, registradores e o acumulador. Sintaxe:
MOV Destino, Fonte Destino é o lugar para onde o dado ser movido e Fonte é o lugar onde o dado está. Os diferentes movimentos de dados permitidos para esta instrução são: *Destino: memória. Fonte: acumulador *Destino: acumulador. Fonte: memória *Destino: registrador de segmento. Fonte: memória/registrador *Destino: memória/registrador. Fonte: registrador de segmento *Destino: registrador. Fonte: registrador *Destino: registrador. Fonte: memória *Destino: memória. Fonte: registrador *Destino: registrador. Fonte: dado imediato *Destino: memória. Fonte: dado imediato Exemplo: MOV AX,0006h MOV BX,AX MOV AX,4C00h INT 21h Este pequeno programa move o valor 0006h para o registrador AX, então ele move o conteúdo de AX (0006h) para o registrador BX, e finalmente move o valor 4C00h para o registrador AX para terminar a execução com a opção 4C da interrupção 21h. INSTRUÇÕES MOVS (MOVSB) (MOVSW) Propósito: Mover byte ou cadeias de palavra da fonte, endereçada por SI, para o destino endereçado por DI. Sintaxe: MOVS Este comando não necessita de parâmetros uma vez que toma como endereço fonte o conteúdo do registrador SI e como destino o conteúdo de DI. A seguinte seqüência de instruções ilustra isso: MOV SI, OFFSET VAR MOV DI, OFFSET VAR MOVS Primeiro inicializamos os valores de SI e DI com os endereços das variáveis VAR1 e VAR2 respectivamente, então após a execução de MOVS o conteúdo de VAR1 é copiado para VAR2. As instruções MOVSB e MOVSW são usadas do mesmo modo que MOVS, a primeira move um byte e a segunda move uma palavra. 4.1.2.Instruções de carga. São instruções específicas para registradores, usadas para carregar bytes ou cadeias de bytes num registrador.
