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):

E0 E1 E2 E3

LG E15 LG E14 SE E15 = E12 E6 SOM E14 E13 E13

E4 E5 E6 E7

SOM E11 E12 E12 VÁ E2 IMP E13 PARE

E8 E9 E10 E11

? ? ? 1

E12 E13 E14 E15

0 0 ? ?
         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 No 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 20, depois 21, depois 22, depois 23, 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*20 + 0*21 + 0*22 + 1*23 + 0*24 + 0*25 + 1*26 + 1*27 + 
1*28
  = 1   + 0    + 0    + 8    + 0   + 0    + 64   +
128  + 256
  = 457

Exercícios:

1. Converta 179 e 65 para a base binária

2. Converta 1110 e 10110 para a base decimal
3. Converta os seguintes números para a base binária: 1, 3, 7, 15 e 31
4. Converta os seguintes números para a base binária: 2, 4, 8, 16 e 32
5. Monte uma tabela com todos os números binários de 2 bits possíveis
6. 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 4 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:

1. Faça uma análise passo-a-passo da execução do programa quando o

valor do 1o e do 2o cartão forem 1, e descubra o valor impresso no final.
2. Faça o mesmo passo-a-passo do exercício anterior, porém com o valor
do 1o cartão sendo 3, e do 2o cartão, 1. Descubra o valor que será
impresso.
3. Explique como é armazenado os valores (dados) do programa.
4. Qual o valor máximo que pode ser armazenado como dado do
programa?
5. 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).
6. Quantas instruções especificando dois operandos podemos criar sem
problemas de ambigüidade?
7. Quantas instruções de um operando podemos criar sem problemas de
ambigüidade?
8. Quantas instruções sem operandos (do tipo da instrução PARE)
podemos criar?
9. Como a CPU poderia diferenciar uma instrução sem operandos de uma
constante armazenada?
 10.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 1o 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 3o 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 4o exercício:

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