Sáb

25

Abr

2009

15:51

Assembly é uma linguagem de programação e uma linguagem de programação serve para fazer programas. Os programas são escritos em forma de texto. Usando um editor de texto criamos o chamado código fonte. Este código fonte é transformado pelo compilador e pelo linker num programa executável.

Muitas vezes ouvimos "linguagem assembler". É um erro muito difundido. Na realidade, Assembly é o nome da linguagem e assembler é um programa capaz de compilar código fonte em arquivos objeto.

A linguagem Assembly é considerada de baixo nível. Isto não significa que seja menos importante ou eficiente que uma linguagem chamada de alto nível - são apenas modos diferentes de se programar e níveis diferentes de atuação. O que posso dizer é que, com uma linguagem de baixo nível como a Assembly, você pilota diretamente a CPU do seu computador - nada de intermediários.

Uma das características da Assembly é que cada linha do código fonte possui apenas uma instrução para o processador (CPU). Por exemplo, MOV EAX,EDX irá MOVer o conteúdo do registrador EDX para o registrador EAX. Neste caso, a instrução "MOV" é chamada de mnemônico. Os mnemônicos são os "apelidos" das instruções, mais fáceis de guardar na memória do que seu valor hexadecimal ou seu valor binário exigido pelo processador. De mnemônico em mnemônico podemos escrever nosso código fonte e fazer com que o processador faça exatamente o que queremos, sem firulas ou perda de tempo. O resultado é um programa enxuto, rápido e altamente eficiente. Tome coragem! Experimente programar em Assembly!

Os componentes da linguagem Assembly

Os componentes da linguagem Assembly são basicamente as instruções para o processador. Ignorando as instruções que não podem ser utilizadas pelo sistema operacional Windows, assembly condicional, macros, ponto flutuante, MMX e instruções de 64 bits, os componentes da linguagem Assembly podem ser divididos nas seguintes categorias:

• Instruções de registradores
• Instruções de pilha
• Instruções de execução
• Instruções de memória
• Instruções de flag
• Declarações de memória
• Diretivas para o assembler
• Comentários
• Instruções para o sistema operacional (Windows)

Instruções de registradores

Estas instruções transferem dados ou realizam cálculos utilizando os registradores de 32 bits da CPU. Existem seis registradores de uso geral chamados de EAX, EBX, ECX, EDX, ESI e EDI. Exemplos deste tipo de instrução são:

MOV ESI,EBX     ;move o conteúdo do registrador EBX para o registrador ESI
ADD EAX,EDI     ;soma o conteúdo do registrador EDI com o do registrador EAX
BT ECX,0        ;testa o bit 0 do registrador ECX
CMP EDX,450     ;compara o conteúdo de EDX com 450
DIV ECX         ;divide EDX:EAX (inteiro longo) por ECX
MUL ECX         ;multiplica EAX por ECX e põe o resultado em EDX:EAX
SHL EDX,4       ;desloca os bits de EDX para a esquerda em 4 bits (multiplica por 16)
TEST EAX,8      ;testa o bit 3 do registrador EAX

Instruções de pilha

A pilha é uma área de memória reservada pelo sistema operacional como área de arquivamento temporário para cada programa que estiver rodando. São exemplos deste tipo de instrução:

PUSH EAX        ;põe o conteúdo do registrador EAX na pilha
POP EDX         ;retira o último valor colocado na pilha e põe em EDX
PUSH 1000h      ;põe o valor hexadecimal 1000 na pilha
MOV EBP,<a class="mosinfopop" style="cursor:help;border-bottom:1px dotted #000000;" href="javascript:void(0)" onmouseover="return overlib('<p>Extended Stack Pointer<br>&amp;nbsp;<br />Ponteiro de Pilha Estendido - um registrador que guarda o endereço do topo da pilha.</p>&amp;nbsp;<br />', CAPTION, 'ESP',BELOW,RIGHT, WIDTH, 300, FGCOLOR, '#CCCCFF', BGCOLOR, '#333399', TEXTCOLOR, '#000000', CAPCOLOR, '#FFFFFF', OFFSETX, 10, OFFSETY, 10);" onmouseout="return nd();" > ESP</a>     ;move o valor do ponteiro da pilha para o registrador EBP
SUB ESP,30h     ;move o ponteiro da pilha para abrir uma área de armazenamento para dados locais
MOV D[EBP-20h],500h  ;insere o valor 500 hexa na área de dados locais

Instruções de execução

Estas instruções desviam o processador para que execute código a partir de um ponto que não seja a próxima linha de execução. São exemplos:

CALL MAKEWINDOW ;executa o código do procedimento e depois retorna
CALL EAX        ;executa o código a partir do endereço presente em EAX e depois retorna
RET             ;termina este procedimento retornando ao chamador
JZ 4            ;se o resultado for zero, continua a execução a partir do marcador 4:
JC >.fim        ;se a flag estiver ativa, continua a execução a partir de .fim
JMP MAKEWINDOW  ;continua a execução a partir do procedimento nominado
LOOP 2          ;decrementa ECX e salta para o marcador 2: a não ser que ECX=0

Instruções de memória

Estas instruções lêem ou escrevem em áreas de memória que não sejam da pilha. Normalmente estas áreas estão na seção de dados do próprio executável ou podem ser alocadas pelo sistema operacional em tempo de execução. São exemplos:

ADD EAX,[ESI]       ;adiciona a EAX o conteúdo de memória cujo ponteiro de endereço está no registrador ESI
MOV EAX,[MEUSDADOS]       ;move para EAX o conteúdo de memória cujo marcador é MEUSDADOS
SUB D[MEUSDADOS+64],10h   ;subtrai 10h do dword em MEUSDADOS mais 64 bytes
CMP B[MEUSDADOS+EDX*4],2  ;compara um byte com 2 numa parte do array MEUSDADOS
LODSB                     ;carrega o byte na memória apontada por ESI em al
STOSD                     ;carrega o conteúdo de EAX na memória apontada por EDI

Instruções de flag

As principais flags usadas são a Z (flag zero), C (flag carry), S (flag de sinal) e D (flag de direção). A maioria das instruções alteram as flags automaticamente para mostrarem o resultado da instrução. Existem determinadas instruções que podem ser usadas para alterar o valor das flags manualmente:

STC              ;ativa a flag de carry
CLC              ;limpa a flag de carry
STD              ;ativa a flag de direção para LODS, STOS, CMPS, SCAS, MOVS
CLD              ;limpa a flag de direção

Declarações de memória

O sistema operacional reserva memória para o executável quando ele é executado. Declarações são feitas para reservar memória na seção de dados ou na seção de constantes se os dados devem ser inicializados, isto é, devem receber um valor. Se forem dados não inicializados, a área de dados pode ficar reservada na seção de dados não inicializados. Isto não toma espaço algum no arquivo executável, por que um espaço de memória é alocado para este tipo de dado quando o executável é iniciado pela primeira vez.

Seguem exemplos de como a memória é declarada, o que pode variar de acordo com o assembler utilizado:

DB 4    ;declara um byte e lhe atribui o valor inicial 4
MEUDADO DB 4  ;um byte de valor inicial 4 com o marcador MEUDADO
MYSTRUCT DD 16 DUP 0   ;16 dwords, todos com valor zero, chamados MYSTRUCT
BUFFER DB 1024 DUP ?   ;1024 bytes chamados BUFFER como dados não definidos

Diretivas para o assembler

São instruções que orientam onde o Assembler deve colocar o código fonte que as segue. O Assembler marca a seção de código como apenas para leitura e executável; as seções de dados definidos e indefinidos como leitura/escrita. Veja alguns exemplos (que podem variar de acordo com o assembler):

CODE SECTION     ;tudo o que se segue deve ser colocado numa seção
                 ;marcada para apenas leitura e executável (código)
DATA SECTION     ;tudo o que se segue deve ser colocado numa seção
                 ;com atributos de leitura e escrita mas não de código
CONST SECTION    ;tudo o que se segue deve ser colocado numa seção 
                 ;com atributo de apenas leitura

Comentários

Após ponto e vírgula, o texto é ignorado até a próxima quebra de linha. Desta forma é possível associar descrições e explicações ao código fonte, as quais serão ignoradas pelo assembler.

Instruções para o sistema operacional

Proporcionam ao programador o acesso a uma grande variedade de funções. No caso do sistema operacional Windows, proporcionam acesso à API. Veja os exemplos abaixo:

PUSH 12h             ;põe valor hexa 12 na pilha para a chamada à API
CALL GetKeyState     ;pede ao Windows para por o estado da tecla Alt em EAX
TEST EAX,80000000h   ;testa se a tecla Alt está sendo pressionada (bit 31 ligado)
JZ >L22              ;não, saltar para L22

PUSH 24h             ;valor hexa 24 = ponto de interrogação, botões yes e no
PUSH ESI,EDI         ;endereço do título, endereço da mensagem
PUSH [hWnd]          ;manipulador da janela proprietária
CALL MessageBoxA     ;mostra a caixa de mensagem Windows pedindo yes/no
CMP AL,7             ;checa se "no" foi clicado pelo usuário
JNZ >L40             ;não, saltar para L40

PUSH 0
PUSH ADDR FILE_DONE  ;dá endereço do arquivo FILE_DONE para receber o resultado
PUSH ECX,EDX         ;ECX = bytes que devem ser escritos, EDX=fonte de dados 
PUSH ESI             ;ESI = manipulador do arquivo
CALL WriteFile       ;escrever ECX bytes de EDX para ESI

PUSH 808h,5h         ;808 = em baixo e meio preenchido, 5 = elevado
PUSH EBX,EDX         ;ebx = RECT, EDX = contexto do dispositivo
CALL DrawEdge        ;desenhar retângulo especial com bordas na tela

PUSH 4h,3000h,ESI,0  ;4h = fazer memória leitura/escrita, 3000h = reservar
CALL VirtualAlloc    ;reservar e consignar ESI bytes de memória leitura/escrita

PUSH 0,[hInst],0,0   ;param, manipulador do módulo, menu e proprietário
PUSH 208,130,30,300  ;altura, largura, y, x
PUSH 80C80000h       ;estilo (POPUP+CAPTION+SYSMENU)
PUSH EAX             ;EAX = endereço da string terminada em zero com o título
PUSH 'LISTBOX'       ;por ponteiro para 'LISTBOX' na pilha
PUSH 0               ;estilo extended (nenhum)
CALL CreateWindowExA ;criar a janela listbox
 
...... ou, se preferir, usar INVOKE ..
INVOKE CreateWindowExA, 0,'LISTBOX',EAX,80C80000h,300,30,130,208,0,0,[hInst],0
 
.............
 
INVOKE ShowWindow, [hWnd], 1