Assembly

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
NoFonti.svg
Este artigo ou se(c)ção cita fontes fiáveis e independentes, mas que não cobrem todo o conteúdo (desde janeiro de 2014). Por favor, adicione mais referências e insira-as corretamente no texto ou no rodapé. Material sem fontes poderá ser removido.
Encontre fontes: Google (notícias, livros e acadêmico)

Assembly ou linguagem de montagem é uma notação legível por humanos para o código de máquina que uma arquitetura de computador específica usa, utilizada para programar dispositivos computacionais, como microprocessadores e microcontroladores. 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[1] [2] .

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 instruções mnemónicas MOV AL, 61h. Tal instrução ordena que o valor hexadecimal 61 (97, em decimal) seja movido para o registrador 'AL'.

A conversão da linguagem de montagem para o código de máquina é feita pelo montador ou assembler, que é basicamente um tradutor de comandos, sendo mais simples que um compilador.

Arquitetura[editar | editar código-fonte]

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 assemblé em francês)[carece de fontes?], e a transformação inversa faz-se recorrendo a um desmontador (também chamado disassembler).

Cada arquitetura de computador tem a sua própria linguagem de máquina e, portanto, a 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 registradores, 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.

No mercado de PCs, dominado por processadores Intel e AMD, atualmente existem duas arquiteturas. Primeiro a IA32 (genericamente chamada de i386, x86 ou x86-32), criada pela Intel em 1985 e primeiramente utilizada pelo processadores i386 e segundo a IA32-EM64T (ou IA32-AMD64 ) criada em 2002 pela AMD (Mas também utilizada pela Intel hoje). O IA32 utiliza o grupo de instruções chamado x86, e o IA32-EM64T utiliza o grupo chamado x86-64. As duas arquiteturas usam números diferentes de registradores gerais e tamanho. Enquanto os registradores do x86 são 32 bits os da x86-64 são 64 bits.[carece de fontes?]

Os registradores de uso geral da arquitetura x86 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

Os registradores de uso geral da arquitetura x86-64 são:

  • %RAX - registrador valor de retorno
  • %RBX - registrador base
  • %RCX - registrador contador
  • %RDX - registrador de dados
  • %RSI - registrador de índice da fonte dos dados
  • %RDI - registrador de índice do destino dos dados
  • %RBP - registrador ponteiro para a moldura de chamada de função
  • %RSP - registrador ponteiro para a pilha de execução
  • %R8 - registrador de dados
  • %R9 - registrador de dados
  • %R10 - registrador ponteiro para a moldura de chamada de função
  • %R11 - registrador de linking
  • %R12 - registrador de base
  • %R13 - registrador de base
  • %R14 - registrador de base
  • %R15 - registrador de base

Esses nomes derivam da forma como eram utilizados nas arquiteturas anteriores a IA32 (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 IA32 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 vírgula 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.).

Instruções aritméticas
  • Adição: ADD, ADC, INC, XADD, AAA e DAA;
  • Subtracção: SUB, SBB, DEC, AAS e DAS;
  • Multiplicação: MUL, IMUL e AAM;
  • Divisão: DIV, IDIV e AAD.

Montador[editar | editar código-fonte]

O montador ou assembler (não confundir com assembly) é um programa que cria o código objeto traduzindo as instruções da linguagem de montagem (assembly) para código de máquina. Além dos comandos básicos, que são traduzidos diretamente para a linguagem de máquina, alguns montadores também aceitam diretivas, que são comandos específicos para o montador. Por exemplo, é possível definir constantes na memória utilizando diretivas.[3]

O montador possui tabelas, onde armazena informações importantes sobre o programa que está sendo montado. Tabelas de rótulos, de constantes e de comandos são as mais comuns.[3] :p.18

Exemplos de código de montagem[editar | editar código-fonte]

Arquitetura Intel[editar | editar código-fonte]

Código em assembly que usa a sintaxe intel.

Decimal		                        Endereço	OPcode		Operandos
 
2089872304                              7C90EBB0	sub		esp, 2D0h
2089872310                              7C90EBB6	mov		dword ptr [ebp+FFFFFDDCh], eax
2089872316                              7C90EBBC	mov		dword ptr [ebp+FFFFFDD8h], ecx
2089872322                              7C90EBC2	mov		eax, dword ptr [ebp+8]
2089872325                              7C90EBC5	mov		ecx, dword ptr [ebp+4]
2089872328                              7C90EBC8	mov		dword ptr [eax+0Ch], ecx
2089872331                              7C90EBCB	lea		eax, [ebp+FFFFFD2Ch]
2089872337                              7C90EBD1	mov		dword ptr [eax+000000B8h], ecx
2089872343                              7C90EBD7	mov		dword ptr [eax+000000A4h], ebx
2089872349                              7C90EBDD	mov		dword ptr [eax+000000A8h], edx
2089872355                              7C90EBE3	mov		dword ptr [eax+000000A0h], esi
2089872361                              7C90EBE9	mov		dword ptr [eax+0000009Ch], edi
2089872367                              7C90EBEF	lea		ecx, [ebp+0Ch]
2089872370                              7C90EBF2	mov		dword ptr [eax+000000C4h], ecx
2089872376                              7C90EBF8	mov		ecx, dword ptr [ebp]
2089872379                              7C90EBFB	mov		dword ptr [eax+000000B4h], ecx
2089872385                              7C90EC01	mov		ecx, dword ptr [ebp-4]
2089872388                              7C90EC04	mov		dword ptr [eax+000000C0h], ecx
2089872394                              7C90EC0A	mov		word ptr [eax+000000BCh], cs
2089872400                              7C90EC10	mov		word ptr [eax+00000098h], ds
2089872406                              7C90EC16	mov		word ptr [eax+00000094h], es
2089872412                              7C90EC1C	mov		word ptr [eax+00000090h], fs
2089872418                              7C90EC22	mov		word ptr [eax+0000008Ch], gs
2089872424                              7C90EC28	mov		word ptr [eax+000000C8h], ss
2089872430                              7C90EC2E	mov		dword ptr [eax], 10007h
2089872436                              7C90EC34	push		1
2089872438                              7C90EC36	push		eax
2089872439                              7C90EC37	push		dword ptr [ebp+8]
2089872442                              7C90EC3A	call		7C90E252
2089872447                              7C90EC3F	sub		esp, 20h
2089872450                              7C90EC42	mov		dword ptr [esp], eax
2089872453                              7C90EC45	mov		dword ptr [esp+4], 1
2089872461                              7C90EC4D	mov		dword ptr [esp+10h], 0
2089872469                              7C90EC55	mov		eax, dword ptr [ebp+8]
2089872472                              7C90EC58	mov		dword ptr [esp+8], eax
2089872476                              7C90EC5C	mov		eax, esp
2089872478                              7C90EC5E	push		eax
2089872479                              7C90EC5F	call		7C90EBAC

Microprocessador Texas Instruments TMS320C2x[editar | editar código-fonte]

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	;Não decorrido tempo: fica no loop
 
NAOPASSARAM10MS:
	SACL	*
	LARP	AR1
	B	LOOP

Microprocessador Texas Instruments TMS320C5x[editar | editar código-fonte]

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	;carrega ar1 com a constante 1000h
	LD	#0, A		;zera o acumulador
	STL	A, *AR1		;armazena no acumulador mínimo
	LD	#1, A		;carrega o acumulador com a constante mínima "1"
	STL	A, *AR1		;armazena o acumulador mínimo no endereço de ar1
	LD	#65535, A	;carrega acumulador com a constante "65535"
	STL	A, 10		;armazena o acumulador mínimo no endereço 10
	STH	A, 10		;armazena o acumulador máximo no endereço 10
	STL	A, *AR1		;armazena o acumulador mínimo no endereço de ar1
	STH	A, *AR1		;armazena o acumulador máximo no endereço de ar1
 
;Instruções com registradores auxiliares:
	STM	#1, AR1		;carrega ar1 com a constante "1"
	STM	#2, AR0		;carrega ar0 com a constante "2"
	MAR	*AR1+0		;adiciona o conteúdo de ar0 to ar appointed by arp (1)
	MVDK	256, *(AR2)     ;carrega ar2 with content of address 256
	MAR	*AR1+		;incrementa ar apontado por arp (1)
	MVKD	*(AR2), 256     ;aloja conteúdo de ar2 no endereço 256
	MAR	*AR1-		;decrementa ar appointed by arp (1)
 
;Instruções de teste de bit:
	BITF	*AR1, #128	;TESTA BIT D7
	BC	ptr, NTC	;vai para ptr se bit for igual a 0
	MAR	*AR1+		;incrementa ar apontado por arp (1)
 
ptr:
	MAR	*+AR4(-128)	;sbrk 80h
 
;Instruções de uso de ponteiros:
	mvdm	*(VETORAL), ar1	;move conteúdo da memória apontada para o ar (transforma arn em ponteiro)
	mvmd	ar1, *(VETORAL)	;mvmd restaura ponteiro(VETORAL) de acordo com arn
	b	LOOP

Ver também[editar | editar código-fonte]

Referências

  1. Assembly - Knol
  2. Linguagem de montagem - UFF
  3. a b Anido, Ricardo (25 de Fevereiro de 2011). [http://www.ic.unicamp.br/~ranido/mc404/faiska/cap2.pdf Introdução à Organização de Computadores e Linguagens de Montagem] (PDF) Universidade Estadual de Campinas. Visitado em 11 de março de 2012.

Ligações externas[editar | editar código-fonte]