Quando apareceram os primeiros processadores de 16 bits, eles podiam manipular diretamente 65536 posições de memória, isto é, 64 kilobytes, sendo esse o limite máximo de endereçamento.

No início isso era uma incrível quantidade de memória, mas a família fez tanto sucesso que começaram a fazer programas cada vez mais "pesados" e esses 64k já não conseguiam dar conta de tanto trabalho.

Os projetistas desses primeiros PC’s viram que precisavam fazer com que os processadores conseguissem acessar uma posição de memória maior que 64k e a solução foi dividi-la em segmentos de 64k cada.

Assim, os programadores conseguiram fazer programas maiores com mais facilidade.

Os programas eram organizados em vários tipos de segmentos, como o de dados, o de código, o de pilha.

O segmento pode ser imaginado como uma linha de nossa "memória" acima.

O byte desejado, seguindo o mesmo raciocínio, está numa coluna qualquer, a qual se chama deslocamento ou offset, em inglês.

Podemos representar um endereço de memória com esta sintaxe:

O Byte do endereço 0x83 está no segmento 80 e no offset 3, logo 80:3, de modo simplista.

Isso será matéria para um outro artigo.

Com o advento dos processadores de 32 bits, que conseguem ler quatro bytes de uma só vez, podendo endereçar diretamente 4.294.967.295 bytes, isto é, 4 gigabites!

Isso permite que nós deixemos de imaginar a memória como um "montão" de segmentos, o que simplifica muito nosso trabalho.

Mas em breve essa memória será pouca para programas tão poderosos que manipulam cada vez mais dados, como diversos jogos que exigem um gigabyte de memória para funcionarem corretamente.

Isso exigiria novamente que usássemos a memória segmentada, mas já temos uma nova família de processadores, os de 64 bits que nos permitem acessar 18.446.744.065.119.617.025 bytes ou vários milhares de petabytes ou milhões de gigabites – praticamente infinito!(Por enquanto)

Os dados, dependendo da arquitetura do processador para o qual fazemos um programa – um 16 bits, 32 bits ou 64 bits, podem ser organizados em pelo menos quatro maneiras básicas:

De um em um byte, de dois em dois bytes, de quatro em quatro bytes ou de oito em oito bytes.

Assim, temos quatro tipos básicos de dados para usarmos em Assembly:

• o byte, que é um grupo de oito bits;
• o word, que é um grupo de dois bytes;
• o dword, que é um grupo de dois words(um double word), ou quatro bytes e,
• o qword, que é o grupo de dois dwords ou quatro words ou oito bytes.

Suponha que a frase "Esta é a memória do Computador...", que começa no endereço hexadecimal 0x0010 seja o conteúdo da variável CompuMemo, ou mais tecnicamente, que o endereço inicial da frase se chame CompuMemo.

Podemos ler essa variável de quatro maneiras, dependendo do tamanho dos dados que estamos processando, conforme os tipos de dados acima.

Podemos ler a variável byte a byte, word a word, dword a dword e assim por diante.

Quando precisarmos ler o quinto byte da variável, por exemplo, tomamos a sua posição inicial, que é 0x0010 e somamos 4, pois o primeiro byte já está em 0x0010.

Vamos pôr esse byte em AL, por exemplo:

MOV AL, byte ptr[CompuMemo+4]

Não se assuste com a instrução, pois você ainda vai aprendê-la mais adiante, mas veja a maneira que usamos para acessar o quinto byte, de modo direto.

Em VisualBasic seria algo como AL = CompuMemo(4), sendo a variável considerada uma matriz unidimensional declarada como dim AL(30) as string * 1.

Da mesma maneira, se quisermos ler o terceiro dword da variável, usamos a seguinte instrução:

MOV EAX, dword ptr[CompuMemo + 2]

Depois de executada essa instrução, EAX terá a string "mem".

Para acessarmos a memória dessa maneira, chamada de indexada, usamos a seguinte sintaxe:

Onde byte, word, dword, qword são o tamanho do bloco de dados que estamos manipulando, variável é o nome da posição inicial da memória onde nossos dados estão e índice é a posição de memória em que estamos interessados.

Fique atento, pois não poderá usar indiscriminadamente duas formas de indexação juntas sem que se façam ajustes, causando erro na leitura/escrita da memória.

Nisso o Assembly é semelhante às linguagens de alto nível, onde não podemos armazenar uma string numa variável declarada como sendo do tipo ponto flutuante, ou valor como, por exemplo 3000 numa variável do tipo byte, que não agüenta um valor superior a 255.

Você entenderá tudo isso nos próximos artigos.

No próximo artigo você conhecerá os registradores, componentes importantíssimos do Assembly, sem os quais a programação se tornaria muito complicada.

Espero que tenha gostado de tanta teoria e até a próxima!