Detalhes

Categoria: Sistemas Operacionais

Atualização: Domingo, 12 Abril 2009 12:27

Autor: vovó Vicki

Acessos: 51060

MÓDULO 3 do SO Numaboa

Um dos requisitos para poder começar a pensar em criar um sistema operacional é conhecer a linguagem de programação Assembly (não é programação assembler, é Assembly mesmo ).

Isto você já sabe (se leu o tutorial anterior), pois o Assembly é a melhor forma que temos para nos comunicarmos com o processador. Se você não tiver a mínima noção do que se trata, sugiro que se dedique um pouco ao assunto. Na Aldeia NumaBoa você encontra alguma coisinha. Para aqueles que não querem se aprofundar no Assembly, para os que já têm algum conhecimento da linguagem ou para os mais preguiçosos, basta seguir este Curso Relâmpago.

Se você conseguir acompanhar e entender o texto - tudo bem, vá em frente. Se não for este o caso, sugiro que desista deste tutorial, pelo menos por enquanto

Ferramentas

• NASM - o compilador Assembly. As versões mais atualizadas e a documentação estão disponíveis para download no site oficial do NASM. A versão 0.98.39 para Windows está disponível aqui na Aldeia na seção de downloads (Informática / Compiladores).
• helpPC - Onde você encontra todas as referências imagináveis. Faça o download do helppc versão 2.1 aqui na Aldeia (downloads Informática / Referências e Manuais) ou procure-o pela Internet.

A linguagem Assembly

Todo processador possui um conjunto de instruções próprio. É como se fosse uma "linguagem" embutida dentro da CPU. Cada instrução possui um código operacional e realiza determinada tarefa dentro do processador utilizando seus registradores. Estes códigos são identificados por números. Na linguagem Assembly estes números são transformados nos chamados mnemônicos para facilitar a programação. Assim, por exemplo, o número hexadecimal B2 (178 decimal) corresponde a MOV DL em Assembly. MOV é o mnemônico de MOVer e DL é o byte menos significativo do registrador DX.

Os registradores

Registradores são áreas de trabalho especiais dentro do microprocessador projetadas para trabalharem com códigos operacionais. São uma espécie de "memória" da CPU e servem para armazenar informações temporariamente.

Os registradores mais utilizados são 8, chamados de uso geral. Destes, usaremos com frequência apenas 4: AX, BX, CX e DX. Estes registradores podem armazenar 16 bits, ou seja, 2 bytes (nas máquinas de 32 bits, assim chamadas porque os registradores da sua CPU podem armazenar 32 bits, estes mesmos registradores recebem os nomes de EAX, EBX, ECX e EDX).

Não é à toa que os registradores receberam estes nomes: AX é também o Acumulador, BX é a Base, CX é o Contador e DX vem de Dados. Os nomes derivam do uso mais frequente destes registradores.

Com Assembly podemos acessar diretamente os dois bytes (2 bytes = word) dos registradores de 16 bits ou podemos acessar diretamente o byte mais significativo ou superior (high) ou menos significativo ou inferior (low). Assim, por exemplo, podemos usar instruções com AX (word), AH (byte superior de AX) ou AL (byte inferior de AX), com BX, BH ou BL, etc.

É claro que existem mais registradores, mas não precisaremos deles por enquanto.

A instrução MOV

Esta instrução, uma das mais usadas, copia dados de um local para outro e o mnemônico deriva de MOVer. Veja alguns exemplos de uso:

A instrução INT

A instrução INT gera uma interrupção de software. O DOS e a BIOS fornecem muitas funções úteis que podem ser acessadas através desta instrução:

Um pequeno programa

Este é um programa extremamente simples:

Este programa nada mais faz do que... terminar. Está na hora de usar o helpPC para esclarecer este assunto:

1. Inicie o helpPC - uma tela chamada "Main Topic Menu" será mostrada.
2. Destaque o item de menu "Interrupt Services DOS-BIOS-EMS-Mouse" e tecle Enter.
3. Destaque o item "DOS Functions" e tecle Enter.
4. Escolha INT 21,4C

O helpPC nos informa que a INT 21,4C corresponde a Terminate Process With Return Code, ou seja, Termine o Processo com Código de Retorno. Também informa que AH precisa conter o valor 4C e que AL precisa conter o código de retorno (do arquivo de lote). Além disto, a instrução não tem valor de retorno.

Portanto, para usar esta instrução, basta preparar AH e AL com os parâmetros exigidos e chamar a interrupção. Com isto terminamos o programa... e com o método aprovado! Se quiser testar este programa, salve o código fonte como teste1.asm, compile-o com o NASM com nasm -o teste1.com teste1.asm para obter teste1.com

Escrevendo um caracter na tela

Do mesmo modo indicado no exemplo anterior, procure no helpPC por uma função que dê saída para a tela. Em "DOS Functions", a primeira encontrada é a INT 21,2 que revela: precisamos de AH=02 e DL com o caracter que deve ser mostrado. Daí, são dois palitos:

Para compilar e testar o programa, proceda como indicado no exemplo anterior.

Variáveis

As variáveis no Assembly são um pouco diferentes quando comparadas com as de outras linguagens de programação. No Assembly podemos inserir dados diretamente no programa com DB, DW e DD (onde B=byte=8bits, W=word=16 bits e D=duplo word=32 bits). Além disto, podemos atribuir marcadores para os dados para identificá-los por nomes - estão aí as nossas variáveis!

Veja alguns exemplos de como manipular os valores das variáveis acima definidas:

Para obter o endereço de variáveis, basta omitir os colchetes:

Escrevendo uma string na tela

Procure novamente no helpPC uma função do DOS que imprima texto na tela. Se você encontrou a INT 21,9 - parabéns! O serviço 9 da interrupção 21 pede que DS:DX apontem para uma string terminada em $. Por enquanto ignore a novidade do DS:DX, a única coisa importante no momento é saber que DX precisa conter o endereço da string:

Entrada de teclado

Ponha novamente o helpPC em ação e procure pela interrupção do DOS INT 21,A. A explicação parece um pouco complicada, mas não se preocupe. DS:DX deve conter um ponteiro para um buffer. Este buffer contém 3 áreas: max - o número máximo de caracteres que devem ser lidos, count - o número de caracteres retornados e buffer - a área de entrada. O código comentado vai facilitar as coisas:

Como atribuímos 20 zeros à área data do buffer e indicamos 20 na área max, o buffer poderá conter no máximo 20 caracteres, ou seja, após 20 "tecladas" nenhuma mais é aceita. Para encerrar o programa, basta digitar Enter.

Saltos

Saltos, os famosos jump, desviam a linha de execução. Geralmente são condicionais, do tipo "se alguma coisa, então salte para...", mas existe também uma instrução de salto incondicional. Os mais comuns são:

Como a maioria dos saltos são condicionais, é claro que precisamos de uma instrução que faça comparações. É a CMP, mnemônico de CoMParar (ou CoMPare). Observe no código abaixo como criar um loop com uma instrução de salto. Este programa imprime NumaBoa cinco vezes e termina:

Funções

As funções em Assembly são como os marcadores só que, ao invés de serem acessadas através de saltos, são chamadas e precisam ter uma instrução de retorno. Também é possível enviar parâmetros para as funções através de registradores ou da pilha. As funções são úteis quando há tarefas repetitivas. Observe um esqueleto de uma função:

Melhorando o "Escreva alguma coisa"

Fazendo uso de saltos, o programa "Escreva alguma coisa" pode ficar muito mais amigável. A tecla Enter interrompe a entrada de caracteres e pede nova entrada. A tecla Esc encerra o programa. Imagino que os comentários do código sejam suficientes:

A Pilha

A pilha é uma área especial de memória dentro do processador. Informações guardadas na pilha com PUSH são colocadas no topo. Quando informações são tiradas da pilha com POP, estas também são tiradas do topo. Isto resulta numa regra simples: os últimos dados que entram na pilha são os primeiros a sair. A pilha é muito utilizada pelas rotinas dos códigos operacionais do computador. Por exemplo, toda instrução CALL põe o endereço da instrução de chamada na pilha para que a instrução de retorno RETN saiba para onde saltar para voltar ao ponto de chamada.

Veja um pouco de código usando PUSH e POP e observe como os valores dos registradores AX e BX foram trocados com o auxílio da pilha:

Segmentos e Deslocamentos

Este é o tipo de assunto que no início dá nó na cabeça de qualquer um, mas, uma vez entendido, facilita muito a programação Assembly.

Segmentos

Quando as máquinas foram melhoradas, a memória do computador (aquelas "tripinhas" de chips que a gente espeta na placa-mãe) passou a armazenar vários megabytes - muitas vezes o maior número que conseguimos obter com 16 bits. Num sistema de 16 bits, o maior número que conseguimos obter é 1111 1111 1111 1111 em binário ou 65535 em decimal. Este número corresponde a 64 Kb, muito longe dos megabytes. A questão era: o que fazer para acessar posições de memória acima de 65535?

Foi daí que o pessoal resolveu "lotear" a memória em segmentos e, adivinhe, cada segmento com 65536 bytes (de 0 a 65535). Para acessar qualquer ponto da memória, passou-se a usar um duplo endereço: o número do segmento e a posição dentro deste segmento. Com os segmentos colocados um após o outro, as posições de memória ficariam da seguinte forma:

• Segmento 0 começa na posição 0 e vai até 65535
• Segmento 1 começa na posição 65536 e vai até 131071
• ...

Acontece que nem sempre os dados colocados na memória, como programas, dados e a pilha, ocupavam segmentos inteiros. Como resultado, a memória - chipzinhos caros pra caramba - pareciam um queijo suiço cheio de buracos. Resolveu-se então sobrepor os segmentos usando uma distância entre eles de 16 bytes. Desta forma, as posições de memória foram loteadas assim:

   Segmento 0 começa na posição 0 e vai até 65535
   Segmento 1 começa na posição 16 e vai até 65551
   ...
   Segmento 100 começa na posição 1600 e vai até 67135
   ...
   Segmento X começa na posição X*16 e vai até X*16 + 65535

Deslocamento

O deslocamento (offset) é um endereço relativo porque depende do segmento. Nada mais é do que a posição de determinado byte dentro das 65536 posições possíveis. Lembre-se de que as posições são numeradas de 0 a 65535, o que dá o total de 65536 posições. Lembre-se também que o deslocamento nunca pode ser maior do que 65535 porque... não conseguimos um número maior do que este com 16 bits.

O deslocamento é a segunda porção do duplo endereço de uma posição de memória, geralmente indicada por Segmento:Deslocamento. Para facilitar, vamos a um exemplo prático:

   Endereço 1234:5678 => Segmento 1234 e Deslocamento 5678
   
   Início do segmento => 1234 * 16 = 19744
   Deslocamento dentro do segmento =  5678
                                     ------
   Endereço da memória               25422

O processador possui registradores especiais para gerenciar os segmentos. Os principais são o CS (Code Segment), o DS (Data Segment) e o ES (Extra Segment). O CS gerencia os segmentos onde se encontra o código do programa, o DS gerencia os segmentos que contêm os dados do programa e o ES é um gerenciador adicional. Para o deslocamento também existe um registrador especial, o SI (Segment Index). Quando queremos acessar algum dado, é a dupla DS:SI que contém o endereço deste dado.

Se bagunçarmos estes registradores, os resultados podem ser catastróficos (nem preciso explicar porque Para evitar que inadvertidamente se mude os valores destes registradores, não existem instruções que façam alterações diretas - os valores só podem ser alterados indiretamente, forçando a atenção dos programadores. Veja um exemplo:

Considerações finais

Este foi o curso de Assembly mais rápido que consegui dar na minha vida. Contém o mínimo necessário para poder se aventurar nesta linguagem de baixo nível. Se você conseguiu acompanhá-lo (espero que sim), então o caminho para criar seu próprio sistema operacional (além de milhões de outras coisas) está aberto. A linguagem Assembly é rápida, eficiente e direta. O código pode parecer longo, mas os programas resultantes são espantosamente pequenos porque o código compilado é extremamente enxuto. E nada supera a deliciosa sensação de ter a CPU na mão

Este módulo abordou apenas a programação para sistemas de 16 bits, aliás, uma boa maneira de começar. Interessante é que sistemas de 32, ou até de 64 bits, aceitam sem problemas as instruções e os programas de 16 bits. A característica dos exemplos foi usar interrupções do DOS. Não que seja obrigatório, mesmo porque o DOS não é o único sistema operacional existente. A idéia foi apenas a de facilitar o aprendizado.

Quero agradecer o jovem Daniel Marjamäki pelo seu texto Assembly Programming, que serviu de base para este tutorial. Suas idéias claras e bem colocadas me chamaram a atenção. O texto original está em Inglês.