Linguagem de montagem

Origem: Wikipédia, a enciclopédia livre.

Uma linguagem de montagem ou assembly é uma notação legível por humanos para o código de máquina que uma arquitectura de computador específica usa. A linguagem de máquina, que é um mero padrão de bits, torna-se legível pela substituição dos valores em bruto por símbolos chamados mnemônicos.

Por exemplo, enquanto um computador sabe o que a instrução-máquina IA-21 (10110000 01100001) faz, para os programadores é mais fácil recordar a representação equivalente em intruções mneumônicas MOV AL, 61h. Tal instrução ordena que o valor hexadecimal 61 (97, em decimal) seja movido para o registrador 'AL'.

[editar] Arquitetura

Ao contrário do que acontece nas linguagens de alto nível, existe (até certo ponto) uma correspondência de 1 para 1 entre a linguagem de montagem simples e a linguagem de máquina. Por isso a tradução do código de montagem em código de máquina não é chamada compilação, mas montagem. Consegue-se transformar a linguagem de montagem em linguagem de máquina recorrendo a um montador (também chamado assembler, originado do termo em inglês), e a transformação inversa faz-se recorrendo a um desmontador (também chamado disassembler, originado do termo em inglês).

Cada arquitectura de computador tem a sua própria linguagem de máquina e, portanto, sua própria linguagem de montagem. Essas linguagens de montagem diferem no número e tipo de operações que suportam. Também têm diferentes tamanhos e números de registos, e diferentes representações dos tipos de dados armazenados. Enquanto todos os computadores de utilização genérica são capazes de desempenhar essencialmente as mesmas funções, o modo como o fazem é diferente.

Além disso, podem existir conjuntos múltiplos de mnemónicas, ou sintaxes de linguagem de montagem, para um único conjunto de instruções. Nestes casos, o conjunto mais popular é aquele que é utilizado pelo fabricante na sua documentação.

A maioria dos processadores só consegue manipular os dados que estão em registradores e a linguagem de montagem facilita o trabalho direto com os registradores.

Os registradores de uso geral da arquitetura i386 são:

EAX - registrador acumulador
EBX - registrador base
ECX - registrador contador
EDX - registrador de dados
ESI - registrador de índice da fonte dos dados
EDI - registrador de índice do destino dos dados
EBP - registrador ponteiro para a moldura de chamada de função
ESP - registrador ponteiro para a pilha de execução

Esses nomes derivam da forma como eram utilizados nas arquiteturas anteriores ao i386 (8086, [80286]]...), em que cada registrador desempenhava um papel específico. Na arquitetura i386, todos eles são de uso geral, embora eles continuem a poder ser utilizados em seus papéis tradicionais.

A arquitetura i386 ainda apresenta os registradores de segmento CS, DS, ES, SS, FS e GS, um contador de programa EIP, um registro de sinalizadores EFLAGS, 8 registradores de ponto flutuante e seus sinalizadores associados. Existem também registradores utilizados pelo sistema operacional para controle da execução em modo protegido, bem como outros registradores de uso específico (depuração, controle de desempenho, etc.).

[editar] Exemplos de código de montagem

[editar] Arquitetura Intel

Endereço   OPcode      Operandos
7C90EBAF   pushfd
7C90EBB0   sub         esp,2D0h
7C90EBB6   mov         dword ptr [ebp+FFFFFDDCh],eax
7C90EBBC   mov         dword ptr [ebp+FFFFFDD8h],ecx
7C90EBC2   mov         eax,dword ptr [ebp+8]
7C90EBC5   mov         ecx,dword ptr [ebp+4]
7C90EBC8   mov         dword ptr [eax+0Ch],ecx
7C90EBCB   lea         eax,[ebp+FFFFFD2Ch]
7C90EBD1   mov         dword ptr [eax+000000B8h],ecx
7C90EBD7   mov         dword ptr [eax+000000A4h],ebx
7C90EBDD   mov         dword ptr [eax+000000A8h],edx
7C90EBE3   mov         dword ptr [eax+000000A0h],esi
7C90EBE9   mov         dword ptr [eax+0000009Ch],edi
7C90EBEF   lea         ecx,[ebp+0Ch]
7C90EBF2   mov         dword ptr [eax+000000C4h],ecx
7C90EBF8   mov         ecx,dword ptr [ebp]
7C90EBFB   mov         dword ptr [eax+000000B4h],ecx
7C90EC01   mov         ecx,dword ptr [ebp-4]
7C90EC04   mov         dword ptr [eax+000000C0h],ecx
7C90EC0A   mov         word ptr [eax+000000BCh],cs
7C90EC10   mov         word ptr [eax+00000098h],ds
7C90EC16   mov         word ptr [eax+00000094h],es
7C90EC1C   mov         word ptr [eax+00000090h],fs
7C90EC22   mov         word ptr [eax+0000008Ch],gs
7C90EC28   mov         word ptr [eax+000000C8h],ss
7C90EC2E   mov         dword ptr [eax],10007h
7C90EC34   push        1
7C90EC36   push        eax
7C90EC37   push        dword ptr [ebp+8]
7C90EC3A   call        7C90E252
7C90EC3F   sub         esp,20h
7C90EC42   mov         dword ptr [esp],eax
7C90EC45   mov         dword ptr [esp+4],1
7C90EC4D   mov         dword ptr [esp+10h],0
7C90EC55   mov         eax,dword ptr [ebp+8]
7C90EC58   mov         dword ptr [esp+8],eax
7C90EC5C   mov         eax,esp
7C90EC5E   push        eax
7C90EC5F   call        7C90EBAC

[editar] Microprocessador Texas Instruments TMS320C2x

LOOP:
        LARP    AR1
        LRLK    AR1,apontador
        ADRK    TAMANHO_CONSTANTE
        ADRK    fimcon_rx
        LAC     *       
        BZ      NAOPASSARAM10MS    ;
        ZAC
        SACL    *
        LARP    AR1
        LRLK    AR1,apontador+CONSTANTE_A
        ADRK    controle
        LAC     *       
        BZ      LOOP            ;NAO DECORRIDO TEMPO: FICA NO LOOP
NAOPASSARAM10MS:
        SACL    *
        LARP    AR1
        B       LOOP

[editar] Microprocessador Texas Instruments TMS320C5x

LOOP:
        mvmm    ar1,ar3         ;move conteúdo de ar1 para ar3
        rpt     #10             ;repete
        mvdd    *ar3+,*ar5+     ;move word endereçada por ar1 para pos. end. por ar6
;Instruçoes com acumulador:
       STM     #1000h,AR1      ;load ar1 with konstant 1000h 
       LD      #0,A            ;zera o acumulador 
       STL     A,*AR1          ;store accumulator low 
       LD      #1,A            ;load accumulator with short konstant "1" 
       STL     A,*AR1          ;store accumulator low at (addresses by ar1) 
       LD      #65535,A        ;load accumulator with long konstant "65535" 
       STL     A,10            ;store accumulator low at address 10 
       STH     A,10            ;store accumulator high at address 10 
       STL     A,*AR1          ;store accumulator low at (addresses by ar1) 
       STH     A,*AR1          ;store accumulator high at (addresses by ar1) 
;Instruções com registradores auxiliares:
       STM     #1,AR1          ;load ar1 with konstant "1" 
       STM     #2,AR0          ;load ar0 with konstant "2" 
       MAR     *AR1+0          ;add content of ar0 to ar appointed by arp (1) 
       MVDK    256,*(AR2)      ;load ar2 with content of address 256 
       MAR     *AR1+           ;increase ar appointed by arp (1) 
       MVKD    *(AR2),256      ;store content of ar2 at address 256 
       MAR     *AR1-           ;decrease ar appointed by arp (1) 
;Instruções de teste de bit:
       BITF    *AR1,#128       ;TESTA BIT D7 
       BC      caca,NTC        ;branch to caca if bit==0 
       MAR     *AR1+           ;increase ar appointed by arp (1) 
caca:
        MAR     *+AR4(-128)     ;sbrk      80h
*Instruções de manipulação de ponteiros: 
* mvdm transforma arn no ponteiro(VETOR_AL):
        mvdm    *(VETORAL),ar1  ;move conteúdo da memória apontada para o ar
* mvmd restaura ponteiro(VETORAL) de acordo com arn:
        mvmd    ar1,*(VETORAL)  
        b       LOOP