1. Registros
2. Os vários tipos de MOV

Retornar  xandre@convex.com.br

Registradores

    Em assembler como em qualquer outra linguagem de programação temos a nescessidade de variáveis, os registros de processador podem ser interpretados como uma espécie de variável, no caso de micros com processadores até o 80286, possuímos somente registros de 16 bits, ou seja podem armazenar valores que vão de 0 até FFFF (Hexadecimal), esses registros são AX(Acumulador), BX(Endereçamento), CX(Contador), DX(Dados) esses registros são formados por dois outros de 8 bits, veja o exemplo se ah=11h e al=22h então ax=1122h, assim como ax é formado por ah e al, bx é formado por bh e bl e assim por diante, mas preste atenção somento os registros AX,BX,CX e DX são divididos os outros registros do processador não podem ser divididos em dois. Logo abaixo temos uma pequena tabela com os outros registros do processador assim como sua descrição.

 

 

Registro	Descrição
AX / AH e AL	Acumulador - Este registro pode ser usado para qualquer finalidade, mas nele podem ser armazenados alguns resultados de intruções como por exemplo DIV que faz uma divisão.
BX / BH e BL	Índice - Também pode ser usado para qualquer finalidade, mas ele é usado para endereçamento de memória, se por exemplo quiservos colocar o byte que se localiza no endereço de memória 1234h, no registro ah, temos que usar o registro bx veja o exemplo. mov  bx,1234h - coloca o valor 1234h no registro bx mov ah,[bx]   - lê o valor da memória e coloca em ah
CX / CH e CL	Contador - Usado em loops para contar o número de vezes, também pode ser usado em instruções que movem blocos de memória, indicando o número de blocos a serem movidos
DX / DH e DL	Dados - Semelhante ao bx só que ao contrário dele ele endereça as portas de hardware
SI	Índice da Origem - Em intruções que movem blocos de memória ele é o endereço inicial do bloco
DI	Índice do Destino - Em intruções que movem blocos de memória ele indica o endereço destino do bloco de memória.
BP	Ponteiro de Base - Tem função semelhante ao BX
DS	Segmento de Dados - Este endereço contém o valor de um segmento, todas as intruções de acesso à memória vão ultilizar deste valor para acessar a memória
ES	Segmento de Dados Extra - Somente um segmento de dados não é o suficiente, podemos ver que em processadores 386 ou superiores temos outros dois segmentos, mas para acessamos o es temos que dizer ao processador, veja o exemplo abaixo mov ax,es:[bx]
SS	Segemento de Pilha - Semelhante ao ds e ao es, mas ele é usado pelo processador para indicar o segmento em que o processador irá usar para armazenar os dados da pilha.
SP	Ponteiro da Pilha - Também usado pelo processador, para ver o endereço onde serão armazendado os dados da pilha
CS	Segmento de Código - O processador usa esse registro para saber em qual segmento está o programa que está sendo executado no momento
IP	Ponteiro de Intrução - Assim como o SP o processador usa este registro para saber em qual endereço da memória está a intrução executada no momento

  Os registros Ax,Bx,Cx,Dx,Si,Di,Bp podem ser alterados livrimente, eles dever ter valores específicos em algumas instruções, mas geralmente podem ter qualquer valor.

 Registradores Extendidos de 32 Bits (386 e superiores)

    Nos processadore 386 e superiores encontramos os registradores de 32 bits, todos os registros do processador com execessão dos registros de segmento, receberam o prefixo E, esse prefixo identifica que o registro é um registro extendido, vejamos o exemplo do ax, que é de 16bits, mas se nos referirmos à ele como eax, o compilador endererá que estamos nos referindo a um registro de 32bits, assim como o eax temos o ebx, ecx, edx, esi, edi, ebp, esp, eip, mas ao contrário dos registros de 16bits que são divididos em dois de 8bits, nos registros de 32bits isso não acontece. Veja o grafico abaixo. E além desses regisros temos dois novos registros de segmentos o fs e o gs, se servem para complementar o ds e o es.

EAX ------------------------------------------------------- |        AH        |        AL        |           Extendido          | ------------------------------------------------------- |                    AX                  |               E                   | ------------------------------------------------------

Registros MMX de 64bits (Processadores com tecnologia MMX)

    Os processadores com a tecnologia MMX permitem a manipulação de dados em 64Bits, isso nos dá uma grande velocidado ao acesso à memória, vejamos por exemplo se um 386 consegue transferir 4 caracteres por vez em um MMX conseguimos 8, ou seja o dobro dos dados com o mesmo tanto de ciclos do processador, ao contrário do 386 os registros MMX não tem nada a ver com os registros do processador antes existentes, foram criados 8 novos registros de 64Bits são eles mm0, mm1, mm2, mm3, mm4, mm5, mm6 e mm7, eles podem ser acessados de forma comum, veja o exemplo -> movq mm0,[ebx] veja que ele pode armazenar um valor bem alto.
 

---

Os Vários tipos de MOV

MOV COM VALORES DIRETOS

        Bem, como vimos anteriormente, existem vários tamanho de dados no processador, então lógicamente também temos vários tipos de mov, essa instrução pega uma informação e a "move", se quisermos fazer o eax valer 123 é só colocar mov eax,1234, logo abaixo coloquei alguns exemplos.
 

MOV  EAX,1234
MOV    AX,1234
MOV    AH,128
MOV  EAX,EBX
MOV    AX,DX
 
        Mas devemos prestar atenção no valor máximo que cada variável pode conter as variáveis de 8 Bits por exemplo, possuem valores até 255 (0ffh), sem sinal, ou -128 a +128 com sinal, o sinal é dado no último bit do byte, mas veremos isso mais adiante. Abaixo temos uma tabela com os valores.
 
 

Tamanho	Sinal	Valor Mínimo	Valor Máximo	Processador
8 Bits	Não	0	FFh	8086+
8 Bits	Sim	-80h	+80h	8086+
16 Bits	Não	0	FFFFh	8086+
16 Bits	Sim	-8000h	+8000h	8086+
32 Bits	Não	0	FFFFFFFFh	80386+
32 Bits	Sim	-80000000h	+80000000 h	80386+
64 Bits	Não	0	FFFFFFFFFFFFFFFFh	MMX
64 Bits	Sim	-8000000000000000h	+8000000000000000h	MMX

 
        Para deixar mais claro logo abaixo temos alguns exemplos que são inválidos, ou seja estão errados:
 
 
MOV  EAX,AX        (Registro de 32Bits com 16Bits)
MOV    AX,AH        (Registro de 16Bits com   8Bits)
MOV    AH,65323    (Tentando atribuir um valor maior que FFh em um registro de 8 Bits)
MOV  mm1,12321    (Será exmplicado mais abaixo)
 
MOV COM VALORES DE MEMÓRIA

        Este sem dúvida é um dos recursos mais importantes, pois é atravéz dele que tranferimos os dados da memória do micro para os registradores, para poderem ser manipulados, para dizermos ao processador que queremos trabalhar com um endereço de memória, simplismente colocamos o endereço entre parenteses veja o exemplo mov ax,[1234h], isto colocará o valor do endereço de memória, ds:1234, preste atenção, pois temos vários registros de segmentos e quanto não especificamos nenhum o default é o DS, uma dica interessante é sempre usarmos o eax e o ds pois esses registros são mais rápidos, economizando espaço e ciclos do processador, abaixo temos o exemplo de um programinha, que compilará com o MASM 6.0(Depois de se usar o patch para MMX, quem quiser me peça via e-mail).

.586p
.MMX
.mode Huge
.Stack
.Data
Dado1    DB  0AAh
Dado2    DB  00
Dado3    DW 0AABBh
Dado4    DW 0000
Dado5    DD  0AABBCCDDh
Dado6    DD  00000000
Dado7    DQ  01122334455667788h
Dado8    DQ  0000000000000000

Texto      DB 'A',07,'l',07,'e',07,'l',07,'u',07,'i',07,'a',07,'!',07
.Code
        mov eax,@data                    ;->Coloca em eax o valor do segmento de dados
        mov ds,eax                           ;->DS não pode ser atribuido diretamente então usamos este artifício, apesar do
        mov  fs,eax                           ; ax ser de 32 bits e o ds de 16Bits, o processador pega somente a parte  ax
                                                    ; de eax não causando problemas.
        mov eax,0b800h                   ;->Segmento de vídeo (Veremos mais adiante)
        mov   es,eax

        mov  eax,3
        int     10h                               ;->Inicializa o modo de vídeo 80x25

        mov  ah,[Dado1]                    ;->Faz Dado2 valer a mesma coisa de Dado1
        mov  [Dado2],ah
        mov  ax,fs:[Dado3]
        mov  fs:[Dado4],ax                 ;->Faz Dado4 valer a mesma coisa de Dado3 só que usando o registro fs
        mov eax,gs:[Dado5]
        mov gs:[Dado6],eax                ;->Faz Dado6 valer a mesma coisa de Dado5 só que usando o registro gs
        movq mm0,qword ptr [Dado7]
        movq mm1,mm0
        movq fs:[Dado8],mm1            ;->Podeia ser feito como os anteriores, mas eu quis demonstrar várias combinações

        movq mm0,qword ptr [Texto]                      ;->Imprime um texto usando MMX
        movq mm1,qword ptr [Texto+8]                  ;->O movq indica que estamos trabalhando com registro de 64bits
        movq es:[0],mm0                                         ;    ou qwords
        movq es:[8],mm1

        mov eax,dword ptr [Texto]                          ;->Imprime o Texto usando os registros de 32 bits
        mov ebx,dword ptr [Texto+4]
        mov  ecx,dword ptr [Texto+8]
        mov  edx,dword ptr [Texto+12]
        mov es:[160],eax
        mov es:[164],ebx
        mov es:[168],ecx
        mov es:[172],edx

        xor eax,eax                                                ;->Espere por uma tecla
        int  16h
        mov eax,4c00h                                          ;->Retorna ao DOS
        int 21h
End

        Como podemos ver o MMX dá uma grande economia de intruções, pois o mesmo é capaz de manipular uma grande quantidade de informações de uma só vez
 

  Página em Construção

  xandre@convex.com.br