ASSEMBLY I

A linguagem ASSEMBLY (e näo assemblER!) dá medo em muita gente!
Só näo sei porque! As liguagens ditas de "alto nível" säo MUITO
mais complexas que o assembly! O programador assembly tem que
saber, antes de mais nada, como está organizada a memória da máquina
em que trabalha, a disponibilidade de rotinas pré-definidas na ROM
do micro (que facilita muito a vida de vez em quando!) e os demais
recursos que a máquina oferece.

Uma grande desvantagem do assembly com relaçäo as outras
linguagens é que näo existe tipagem de dados como, por exemplo,
ponto-flutuante... O programador terá que desenvolver as suas
próprias rotinas ou lançar mao do co-processador matemático (o TURBO
ASSEMBLER, da Borland, fornece uma maneira de emular o
co-processador). Näo existem funçöes de entrada-saída como PRINT do
BASIC ou o Write() do PASCAL... Näo existem rotinas que imprimam
dados numéricos ou strings na tela... Enfim... näo existe nada de
útil! (Será?! hehehe)

Pra que serve o assembly entäo? A resposta é: Para que você
possa desenvolver as suas próprias rotinas, sem ter que topar com
bugs ou limitaçöes de rotinas já existentes na ROM-BIOS ou no seu
compilador "C", "PASCAL" ou qualquer outro... Cabe aqui uma
consideraçäo interessante: É muito mais produtivo usarmos uma
liguagem de alto nível juntamente com nossas rotinas em assembly...
Evita-se a "reinvençäo da roda" e näo temos que desenvolver TODAS as
rotinas necessárias para os nossos programas. Em particular, o
assembly é muito útil quando queremos criar rotinas que näo existem
na liguagem de alto-nível nativa! Uma rotina ASM bem desenvolvida
pode nos dar a vantagem da velocidade ou do tamanho mais reduzido em
nossos programas.

O primeiro passo para começar a entender alguma coisa de
assembly é entender como a CPU organiza a memória. Como no nosso
caso a idéia é entender os microprocessadores da família 80x86 da
Intel (presentes em qualquer PC-Compatível), vamos dar uma olhadela
no modelamento de memória usado pelos PCs, funcionando sob o MS-DOS
(Windows, OS/2, UNIX, etc... usam outro tipo de modelamento...
MUITO MAIS COMPLICADO!).

i---------------------------------------------©
¦ Modelamento REAL da memória - A segmentaçäo ¦
È---------------------------------------------¥

A memória de qualquer PC é dividida em segmentos. Cada segmento
tem 64k bytes de tamanho (65536 bytes) e por mais estranho que
pareça os segmentos näo säo organizados de forma sequencial
(o segmento seguinte näo começa logo após o anterior!). Existe uma
sobreposiçao. De uma olhada:

64k
+-----------------------------------------------------+
+------------------------------------------------------------+
¦ ¦
¦ ¦ ¦ ¦ ¦
¦ ¦
+------------------------------------------------------------+
0 1 2 <- Numero do segmento
+-------------+
16 16
bytes bytes

O segundo segmento começa exatamente 16 bytes depois do
primeiro. Deu pra perceber que o inicio do segundo segmento está
DENTRO do primeiro, já que os segmentos tem 64k de tamanho!

Este esquema biruta confunde bastante os programadores menos
experientes e, até hoje, ninguem sabe porque a Intel resolveu
utilizar essa coisa esquisita. Mas, paciência, é assim que a coisa
funciona!

Para encontrarmos um determinado byte dentro de um segmento
precisamos fornecer o OFFSET (deslocamento, em inglês) deste byte
relativo ao inicio do segmento. Assim, se queremos localizar o
décimo-quinto byte do segmento 0, basta especificar 0:15, ou seja,
segmento 0 e offset 15. Esta notaçäo é usada no restante deste e de
outros artigos.

Na realidade a CPU faz o seguinte cálculo para encontrar o
"endereço físico" ou "endereço efetivo" na memória:

+-----------------------------------------------------------------+
¦ ENDEREÇO-EFETIVO = (SEGMENTO * 16) + OFFSET ¦
+-----------------------------------------------------------------+

Ilustrando a complexidade deste esquema de endereçamento,
podemos provar que existem diversas formas de especificarmos um
único "endereço efetivo" da memória... Por exemplo, o endereço
0:13Ah pode ser também escrito como:

0001h:012Ah 0002h:011Ah 0003h:010Ah 0004h:00FAh
0005h:00EAh 0006h:00DAh 0007h:00CAh 0008h:00BAh
0009h:00AAh 000Ah:009Ah 000Bh:008Ah 000Ch:007Ah
000Dh:006Ah 000Eh:005Ah 000Fh:004Ah 0010h:003Ah
0011h:002Ah 0012h:001Ah 0013h:000Ah

Basta fazer as contas que você verá que todas estas formas daräo
o mesmo resultado: o endereço-efetivo 0013Ah. Generalizando,
existem, no máximo, 16 formas de especificarmos o mesmo endereço
físico! As únicas faixas de endereços que näo tem equivalentes e só
podem ser especificados de uma única forma säo os desesseis
primeiros bytes do segmento 0 e os últimos desesseis bytes do
segmento 0FFFFh.

Normalmente o programador näo tem que se preocupar com esse tipo
de coisa. O compilador toma conta da melhor forma de endereçamento.
Mas, como a toda regra existe uma excessäo, a informaçäo acima pode
ser útil algum dia.

+-------------------------------------------------------------------+
¦ A BASE NUMÉRICA HEXADECIMAL E BINARIA (para os novatos...) ¦
+-------------------------------------------------------------------+

Alguns talvez näo tenham conhecimento sobre as demais bases
numéricas usadas na área informata. É muito comum dizermos "código
hexadecimal", mas o que significa?

É bastante lógico que usemos o sistema decimal como base para
todos os cálculos matemáticos do dia-a-dia pelo simples fato de
temos DEZ dedos nas mäos... fica facil contar nos dedos quando
precisamos (hehe).

Computadores usam o sistema binário por um outro motimo simples:
Existem apenas dois níveis de tensäo presentes em todos os circuitos
lógicos: níveis baixo e alto (que säo chamados de 0 e 1 por
conveniência... para podermos medi-los sem ter que recorrer a um
multímetro!). O sistema hexadecimal também tem o seu lugar: é a
forma mais abreviada de escrever um conjunto de bits.

Em decimal, o número 1994, por exemplo, pode ser escrito como:

1994 = (1 * 10^3) + (9 * 10^2) + (9 * 10^1) + (4 * 10^0)

Note a base 10 nas potências. Faço agora uma pergunta: Como
representariamos o mesmo númer se tivessemos 16 dedos nas mäos?

¦ Primeiro teriamos que obter mais digitos... 0 até 9 näo säo
suficientes. Pegaremos mais 6 letras do alfabeto para suprir
esta deficiencia.

¦ Segundo, Tomemos como inspiraçäo um odômetro (equipamento
disponível em qualquer automóvel - é o medidor de
quilometragem!): Quando o algarismo mais a direita (o menos
significativo) chega a 9 e é incrementado, o que ocorre?...
Retorna a 0 e o próximo é incrementado, formando o 10. No
caso do sistema hexadecimal, isto só acontece quando o último
algarismo alcança F e é incrementado! Depois do 9 vem o A,
depois o B, depois o C, e assim por diante... até chegar a
vez do F e saltar para 0, incrementando o próximo algarismo,
certo?

Como contar em base diferente de dez é uma situaçäo näo muito
intuitiva, vejamos a regra de conversäo de bases. Começaremos pela
base decimal para a hexadecimal. Tomemos o número 1994 como
exemplo. A regra é simples: Divide-se 1994 por 16 (base
hexadecimal) até que o quoeficiente seja zero... toma-se os restos
e tem-se o númer convertido para hexadecimal:

+---------------------------------------------------------------+
¦ 1994 / 16 -> Q=124, R=10 -> 10=A ¦
¦ 124 / 16 -> Q=7, R=12 -> 12=C ¦
¦ 7 / 16 -> Q=0, R=7 -> 7=7 ¦
+---------------------------------------------------------------+

Toma-se entäo os restos de baixo para cima, formando o número em
hexadecimal. Neste caso, 1994=7CAh

Acrescente um 'h' no fim do número para sabermos que se trata da
base 16, do contrário, se olharmos um número "7CA" poderiamos
associa-lo a qualquer outra base numérica (base octadecimal por
exemplo!)...

O processo inverso, hexa->decimal, é mais simples... basta
escrever o númer, multiplicando cada digito pela potência correta,
levando-se em conta a equivalencia das letras com a base decimal:

+-----------------------------------------------------------------+
¦ 7CAh = (7 * 16^2) + (C * 16^1) + (A * 16^0) = ¦
¦ (7 * 16^2) + (12 * 16^1) + (10 * 16^0) = ¦
¦ 1792 + 192 + 10 = 1994 ¦
+-----------------------------------------------------------------+

As mesmas regras podem ser aplicadas para a base binária (que
tem apenas dois digitos: 0 e 1). Por exemplo, o número 12 em
binário fica:

+-----------------------------------------------------------------+
¦ 12 / 2 -> Q=6, R=0 ¦
¦ 6 / 2 -> Q=3, R=0 ¦
¦ 3 / 2 -> Q=1, R=1 ¦
¦ 1 / 2 -> Q=0, R=1 ¦
¦ ¦
¦ 12 = 1100b ¦
+-----------------------------------------------------------------+

Cada digito na base binária é conhecido como BIT (Binary digIT -
ou digito binário, em inglês)! Note o 'b' no fim do número
convertido...

Faça o processo inverso... Converta 10100110b para decimal.

A vantagem de usarmos um número em base hexadecimal é que cada
digito hexadecimal equivale a exatamente quatro digitos binários!
Faça as contas: Quatro bits podem conter apenas 16 números (de 0 a
15), que é exatamente a quantidade de digitos na base hexadecimal.