A linguagem de máquina do computador simplificado

Detalhando o Computador Simplificado – A Linguagem de Máquina

1. Linguagem de Máquina Simplificada

Um "detalhe" importante foi esquecido: tanto a CPU como as várias memórias somente comprendem, ou melhor, armazenam dados e instruções em linguagem de máquina (linguagem de zeros e uns). Portanto, as 12 instruções do nosso computador simplificado, bem como os endereços de memória, devem ser todos escritos na linguagem que ele entende e opera, a binária. Vejamos como fazer isso.

Abaixo temos uma proposta de linguagem de máquina, simplificada, para o computador simplificado analisado em aula. Digamos que cada posição de memória do computador tenha 15 bits. Considere ainda a seguinte convenção para codificar as nossas 12 instruções da linguagem de montagem para a linguagem de máquina, exibida na Tabela 1:

LG Ei 111 00000000 IIII (Leia Cartão e guarde em Ei) COP Ei Ej 111 0001 IIII JJJJ (Copie Ei em Ej) VÁ Ei 111 00000001 IIII (Vá para Ei) IMP Ei 111 00000010 IIII (Imprima Ei) PARE 111 00000011 0000 (Interrompa execução) SOM Ei Ej Ek yyy IIII JJJJ KKKK (Some Ei e Ej e guarde em Ek) SUB Ei Ej Ek yyy IIII JJJJ KKKK (Subt Ei e Ej e guarde em Ek) MUL Ei Ej Ek yyy IIII JJJJ KKKK (Mult Ei e Ej e guarde em Ek) DIV Ei Ej Ek yyy IIII JJJJ KKKK (Div Ei e Ej e guarde em Ek) Onde: some yyy=000 subtraia yyy=001 multipl. yyy=010 divida yyy=011 SE Ei > Ej Ek yyy IIII JJJJ KKKK (Se Ei > Ej então vá para Ek) SE Ei < Ej Ek yyy IIII JJJJ KKKK (Se Ei < Ej então vá para Ek) SE Ei = Ej Ek yyy IIII JJJJ KKKK (Se Ei = Ej então vá para Ek) Onde: maior yyy=100 igual yyy=101 menor yyy=110

Tabela 1 – Códigos Binários das 12 Instruções do Computador Simplificado

Observe o detalhe de que todos as instruções têm 15 bits, os quais estão subdivididos numa parte para a instrução (os bits iniciais) e nas outras (se existem) para os endereços IIII, JJJJ e KKKK (com 4 bits), que são os operandos da instrução.

2. Codificando em Linguagem de Máquina – Resolvendo um Problema

Considere o seguinte problema: com a linguagem de máquina simplificada, proposta acima, tentemos codificar o programa abaixo (já previamente armazenado na "memória" dos escaninhos):

LG E15

LG E14

SE E15 = E12 E6

SOM E14 E13 E13

SOM E11 E12 E12

VÁ E2

IMP E13

PARE

E10

E11

E12

E13

E14

E15

O primeiro ponto importante a ser notado é que, para este computador simplificado, a posição 'i' do endereço de memória Ei tem 4 bits (o mesmo pode ser dito de Ej e Ek). Observe que os endereços (operandos da instrução) estão especificados como IIII, JJJJ ou KKKK, isto é, quatro posições, significando 4 bits. Como conseqüência, este computador consegue endereçar somente 16 posições de memória. Mas porque isso? Por causa da forma como os números são codificados no sistema binário.

2.1 Sistema Binário

O sistema binário ou sistema de base 2, é um sistema numérico em que todos os números são representados por apenas dois algarismos, o zero e o um, que correspondem aos dois estados possíveis de uma chave eletrônica, o '0' representando a posição desligada, e o '1' a posição ligada.

Exemplos:

00010001 da base binária corresponde ao 17 da base decimal

10001011 da base binária corresponde ao 139 da base decimal

A técnica para converter o código decimal para o binário é a seguinte: faz-se divisões sucessivas do número por 2, até quando não for mais possível dividir, anotando-se o resto de cada divisão. Quando as divisões terminam, escrevemos os restos (sempre 0 ou 1), de trás para diante.

Seja, por exemplo, o número 457 expresso na base decimal, qual o código binário correspondente ao 457?

457 |__2 1 228 |__2 0 114 |__2 0 57 |__2 1 28 |__2 0 14 |__2 0 7 |__2 1 3 |__2 1 1 |__2 1 0
Invertendo a ordem dos restos, temos o N^o 457 na base binária: 111001001

Para fazer a conversão de um número binário para decimal utilizamos uma outra técnica: multiplicamos cada bit, a partir da direita para esquerda, respectivamente com: primeiro 2⁰, depois 2¹, depois 2², depois 2³, e assim por diante até terminar os bits do número binário, e por fim soma-se todos os produtos, obtendo-se o resultado na notação decimal.

Seja, o número binário obtido acima, 111001001, como reconvertê-lo para a base decimal?

1*2⁰ + 0*2¹ + 0*2² + 1*2³ + 0*2⁴ + 0*2⁵ + 1*2⁶ + 1*2⁷ + 1*2⁸ = 1 + 0 + 0 + 8 + 0 + 0 + 64 + 128 + 256 = 457

Exercícios:

Converta 179 e 65 para a base binária
Converta 1110 e 10110 para a base decimal
Converta os seguintes números para a base binária: 1, 3, 7, 15 e 31
Converta os seguintes números para a base binária: 2, 4, 8, 16 e 32
Monte uma tabela com todos os números binários de 2 bits possíveis
Monte uma tabela com todos os números binários de 3 bits possíveis

2.2 Solucionando o Problema

Como havíamos dito, o endereço Ei do nosso problema tem apenas 4 bits, pois o endereço, na proposta de linguagem de máquina simplificada, está representado por 4 posições: IIII, JJJJ ou KKKK (ver início da Seção 2). Com 4 bits, podemos então endereçar até 2⁴ posições de memória, ou seja, até 16 endereços de memória.

O aluno deve notar que a memória do nosso computador simplificado (os escaninhos) já está com o número máximo possível de endereços, de E0 até E15. Portanto, o endereço E0 é codificado como 0000, E1 como 0001, E2 como 0010, assim por diante, até o último endereço, E15, codificado como 1111.

Identifiquemos então os códigos corretos das instruções:

    111 00000000      para LG
    111 00000001     para VÁ
    111 00000010     para IMP
    111 00000011 0000 para PARE

Enfim, o aluno deve observar que a instrução yyy (3 bits) das operações aritméticas são diferentes para cada uma delas (adição, subtração, etc). Como utilizamos a soma no programa acima, o código binário utilizado foi 000 (os outros bits são para os seus 3 operandos, Ei, Ej e Ek). Do mesmo modo, como utilizamos a operação condicional 'SE Ei = Ej Ek', o código binário usado foi 101. Confira estes códigos antes de ver a solução do problema.

O código binário do problema apresentado ficaria então assim:

        Endereço              Código da Instrução                                  Mnemônico da Instrução

    0000 : 111 00000000 1111 (LG E15)
    0001 : 111 00000000 1110 (LG E14)
    0010 : 101 1111 1100 0110 (SE E15 = E12 E6)
    0011 : 000 1110 1101 1101 (SOM E14 E13 E13)
    0100 : 000 1011 1100 1100 (SOM E11 E12 E12)
    0101 : 111 00000001 0010 (VÁ E2)
    0110 : 111 00000010 1101 (IMP E13)
    0111 : 111 00000011 0000 (PARE)
    1000 : ?
    1001 : ?
    1010 : ?
    1011 : 000 00000000 0001 (Valor 1)
    1100 : 000 00000000 0000 (Valor 0)
    1101 : 000 00000000 0000 (Valor 0)
    1110 : ?
    1111 : ?

Podemos agora já ter uma idéia bem clara do quão difícil foi programar no tempo dos primeiros computadores, que funcionavam apenas com linguagem de máquina. Os programadores mexiam diretamente nos bits, sem teclado e sem monitor de vídeo!

Exercícios:

Faça uma análise passo-a-passo da execução do programa quando o valor do 1^o e do 2^o cartão forem 1, e descubra o valor impresso no final.
Faça o mesmo passo-a-passo do exercício anterior, porém com o valor do 1^o cartão sendo 3, e do 2^o cartão, 1. Descubra o valor que será impresso.
Explique como é armazenado os valores (dados) do programa.
Qual o valor máximo que pode ser armazenado como dado do programa?
Explique por que a instrução 'SE Ei Ej Ek' só tem até três opções de comparação (maior, igual, menor) e não pode ter mais (por exemplo maior ou igual, menor ou igual, diferente).
Quantas instruções especificando dois operandos podemos criar sem problemas de ambigüidade?
Quantas instruções de um operando podemos criar sem problemas de ambigüidade?
Quantas instruções sem operandos (do tipo da instrução PARE) podemos criar?
Como a CPU poderia diferenciar uma instrução sem operandos de uma constante armazenada?
Considere um computador simplificado que possua um registrador "acumulador", e que tenha 32 células de memória. Considere também que cada célula tem 10 bits, e as instruções são assim codificadas:

Leia cartão (valor do cartão é guardado no acumulador) : 00000 00000

Carregue Ei (conteúdo de Ei é guardado no acumulador) : 00001 IIIII

Armazene Ei (conteúdo do acumulador é guardado em Ei) : 00010 IIIII

Some (subtraia, multiplique,...) Ei (conteúdo do acumulador é somado com o conteúdo de Ei e guardado no acumulador) : 110 yy IIIII

Onde: some yy=00; subtraia yy=01; multiplique yy=10; divida yy=11;

Vá para Ei : 00011 IIIII

Se acumulador maior(menor, igual,...) que 0 (zero) vá para Ej: 111 yy IIIII

Onde: maior yy=00; menor yy=01; igual yy=10;

Imprima (imprime o valor do acumulador) : 00000 00001

Pare : 00000 00010

Codifique então um programa em linguagem assembly e de máquina que implementa a seguinte especificação: o programa deve ler dois valores em cartão e imprimir o produto destes dois valores, a implementação não deve usar a instrução de multiplicação e sim somas sucessivas.

Resolução do 1^o exercício:

Lembrando sempre que o valor da posição E12 e E13 é 0 (ver o programa), podemos resumir a seqüência de execução numa tabela:

Passo	Instrução	Resultado
E0	LG E15	E15 = 1
E1	LG E14	E14 = 1
E2	SE E15 = E12 E6	Segue normalmente para E3
E3	SOM E14 E13 E13	E13 = 1
E4	SOM E11 E12 E12	E12 = 1
E5	VÁ E2	Retorna para E2
E2	SE E15 = E12 E6	Desvia para E6
E6	IMP E13	Imprime 1
E7	PARE	Encerra programa

Resolução do 3^o exercício:

Como não há instruções para serem divididas entre os 15 bits de cada célula da memória (o nosso escaninho), então todos os quinze bits podem ser usados para codificar a constante armazenada.

Resolução do 4^o exercício:

Como os 15 bits são usados para armazenar um valor numérico, eles podem representar 2¹⁵ valores diferentes. Porém, como um desses valores é o número 0, então o valor máximo seria 2¹⁵-1 = 32767.