4) COMPUTADORES

Considerar a arquitetura a seguir:

1
 A memória agora trabalha com palavras de 12 bits e os 2 terminais E (Habilita) e R/W
foram substituídos pelos terminais R (ler) e W (escrever), que são ativados em nível 1 (não é
permitido R = W = 1).
O Registrador de Instrução (RI) foi substituído por dois registradores: um Registrador de
Propósito Geral (RPG), de 12 bits, e um Registrador de Operação (ROP), de 4 bits. Assim, com 4
bits, pode-se ter agora 16 instruções. Quando uma instrução é lida da memória, uma palavra de
12 bits é transferida para RPG: 4 bits serão transferidos para ROP e, quando necessário, 8 bits,
possivelmente, para REM (p.ex., como endereço do operando). Dessa forma, pode-se trabalhar
com operação e endereço separadamente. RPG pode armazenar também um operando de 12 bits.
Notar que há conexões diretas RPG-Memória, RPG-ROP, RPG-REM e RPG-ULA (com
duas ligações separadas). Ainda, há dois caminhos separados RPG  PC e PC  RPG,
permitindo, inclusive, trocas simultâneas entre RPG e PC num único ciclo de relógio (por
exemplo, usando FFs mestre-escravo). (observar que RPG atende 4 microoperações; observar tb a ligação R
com MRPG)
Observar que a ULA tem um registrador F de um bit (um FF) e que ela pode executar 8
microoperações, incluindo as de rotacionar RAC em 1 bit à direita (ROR) e à esquerda (ROL)
através de F. Ainda, há duas entradas F e Z (de um bit cada) que chegam ao Controlador: F
(“flag”) que vem do registrador F e Z que vem de RPG (Z estará em 1 quando todos os 12 bits de
RPG estiverem em zero).
Se as instruções são simples e poucas, o controlador será mantido simples; neste caso, os
programas de instruções deverão ser mais longos. Para a escrita de programas mais simples e
curtos, torna-se necessária a definição de instruções mais complexas e numerosas; com isso, o
controlador torna-se correspondentemente mais elaborado. (Qual a ligação disso com arquiteturas CISC e
RISC?)

Instruções
A sequência de microoperações para buscar (“fetch”) uma instrução é:
Ciclo de
Relógio Microoperação Descrição

1 PC  REM Transferir endereço em PC para REM;

2 M  RPG Transferir palavra endereçada para RPG e

PC + 1  PC Incrementa PC;

3 RPG (Opr)  ROP Transferir bits de operação de RPG para ROP.

2
 Após a busca, a parte da operação da instrução foi transferida para ROP e, se houver
operando envolvido na instrução, seu endereço é deixado na parte de endereço de RPG [RPG
(End)].

Instruções elementares:
Uma instrução elementar requer que apenas um único terminal (sinal) seja ativado
(colocado em nível 1), consistindo assim de uma única microoperação, podendo ser executada
num único ciclo de relógio.

Instrução
(microoperação) Descrição Mnemônico

0  RAC Limpar RAC CRA

RAC  RAC Complementar RAC CTA
RAC + 1  RAC Incrementar RAC ITA
0F Limpar flip-flop F CRF
FF Complementar F CTF
PC + 1  PC Saltar (skip) para a SFZ (ou: “saltar a próxima instrução se F = 0”)
instrução seguinte se F = 0
Girar à direita Usa RAC e F ROR
Girar à esquerda Usa RAC e F ROL

MNEMÔNICO (auxílio à memorização) é o nome dado para a abreviação de uma

instrução, tendo a função de ajudar a lembrar o que a instrução faz.

Obs: Se a próxima instrução a ser buscada for SFZ e esta estiver no endereço E de memória,
durante sua busca, PC é incrementado (como acontece na busca de qualquer instrução) e tem-se
PC = E + 1. A seguir, a instrução SFZ é executada. Se F = 1, nada acontece e a próxima instrução
a ser buscada é a do endereço (E + 1). No entanto, se F = 0, ocorrerá um incremento adicional de
PC (PC = E + 1 + 1). Assim, a instrução do endereço (E + 1) será saltada (condicionalmente a F).
A instrução SFZ pode ser usada, por exemplo, em conjunto com a instrução JMP: um caminho ou
outro é selecionado; p.ex.:

3
endereço instrução
(E-1): (instr qualquer)
E : SFZ
(E+1): instr 1 (p.ex., JMP L1)
(E+2): instr 2 (p.ex., JMP L2)
….
L1 : (conjunto de instrs referentes a L1)
…. (ao final deste bloco, há uma instr “JMP L3”)

L2 : (conjunto de instrs referentes a L2)

….

L3 : (novo conjunto de instrs)

….

(fim do programa)

Outras Instruções:

a) ADD end_m: adiciona ao conteúdo de RAC o operando do endereço end_m.

Ciclo de
Relógio Microoperação Descrição

1 RPG (End)  REM Transferir endereço do operando (end_m) para REM;

2 M  RPG Ler da memória a palavra endereçada (o operando) para RPG;

3 RPG + RAC  RAC Adicionar operando de RPG ao conteúdo de RAC.

Para transferir um operando da memória para RAC, ou seja, Carregar RAC, pode-se
utilizar a sequência de instruções CRA e ADD em conjunto.

b) ADDI end_m: adiciona ao conteúdo de RAC o operando do endereço contido no endereço end_m.
Ciclo de
Relógio Microoperação Descrição

1 RPG (End)  REM Transferir endereço (end_m) do endereço do operando p/ REM;

2 M  RPG Ler da memória a palavra endereçada (um endereço) para RPG;

3 RPG (End)  REM Transferir o “endereço do operando” para REM;

4 M  RPG Ler da memória o operando para RPG;

5 RPG + RAC  RAC Adicionar operando a RAC.

4
 Quando o endereço de um operando é obtido dessa forma (a partir de outro endereço) diz-
se que a instrução envolve um Endereço Indireto.

Para fazer um Carregamento Indireto de um operando da memória para RAC pode-se

utilizar a sequência de instruções CRA e ADDI em conjunto.

c) STA end_m: armazena (escreve) o conteúdo de RAC no endereço end_m de memória.

Ciclo de
Relógio Microoperação Descrição

1 RPG (End)  REM Transferir endereço (end_m) para REM;

2 RAC  RPG Transferir conteúdo de RAC para RPG;

3 RPG  M Escrever conteúdo de RPG na memória.

d) JMP end_m: saltar (“jump”) para a instrução no local de memória end_m.

Ciclo de
Relógio Microoperação Descrição

1 RPG (End)  PC Transferir endereço (end_m) da próxima instrução para PC.

Depois de executar (JMP, end_m), a próxima instrução a ser buscada será a do local end_m e, a
partir daí, a máquina prosseguirá em ordem para as instruções em (end_m + 1), (end_m + 2), etc.

e) JMPI end_m: saltar (jump) para a instrução cujo endereço está armazenado no endereço
end_m (forma Indireta da instrução JMP).
Ciclo de
Relógio Microoperação Descrição

1 RPG (End)  REM Transferir endereço (end_m) do endereço da instrução p/ REM;

2 M  RPG Ler da memória a palavra endereçada (um endereço) para RPG;

3 RPG (End)  PC Transferir endereço da próxima instrução para PC;

5
f) CSR end_m: chamar uma subrotina.
Ciclo de
Relógio Microoperação Descrição

1 RPG (End)  REM Transferir end_m (endereço onde end_ret deve ser armazenado) p/ REM;

2 RPG (End)  PC Trocar os conteúdos de RPG e PC (após a troca, PC = end_m e

PC  RPG (End) RPG (End) = end_ret);

3 RPG  M Escrever end_ret no local end_m da memória;

4 PC + 1  PC Incrementar PC (após isso, PC = (end_m + 1), que é o local da próxima

instrução a ser buscada).

Uma Subrotina é uma lista de instruções armazenada num local específico de memória, na
ordem em que elas devem ser executadas.
Quando a instrução (CSR, end_m) é executada, o endereço de retorno “end_ret” ao
programa principal é armazenado no local de memória “end_m” e o processamento é desviado
para o endereço “end_m + 1”, ou seja, executa a subrotina buscando as próximas instruções a
partir do endereço “end_m + 1”. Este processo de desvio da sequência ordenada de instruções é
denominado Chamada de Subrotina. Na conclusão de uma chamada de subrotina deve haver
sempre um retorno ao local do programa principal “end_ret” de onde foi feita a chamada; isso
pode ser feito utilizando a instrução (JMPI, end_m).

CSR end_m Chamada de uma subrotina

end_ret Primeira instrução após concluir a subrotina

end_m xxx end_ret Endereço reservado para armazenar end_ret

end_m+1
Subrotina (de tamanho k)

end_m+k
end_m+k+1 JMPI end_m JMP indireto para end_m p/ recuperar end_ret

6
g) ISZ end_m: lê o valor em end_m, incrementa este valor e o reescreve no seu local original.
Se, depois de incrementar RPG, seu valor for zero (ou seja, Z=1), a próxima instrução é saltada.
Ciclo de
Relógio Microoperação Descrição

1 RPG (End)  REM Transferir endereço (end_m) do valor a ser incrementado para REM;

2 M  RPG Ler da memória o valor para RPG;

3 RPG + 1  RPG Incrementar RPG;

4 RPG  M Reescrever valor (em end_m) na memória;

5 PC + 1  PC Saltar a próxima instrução se RPG = 0 (linha Z = 1).

(se RPG = 0)

A instrução ISZ pode ser usada para a execução repetitiva de uma sequência de
instruções, o chamado Laço de Programa. A última instrução da sequência deve ser uma
instrução de salto (JMP) para o começo do laço. A instrução ISZ é usada para interromper este
processo de retorno quando o laço tiver sido repetido um certo número de vezes: este número de
vezes é armazenado como um valor negativo em end_m e é incrementado até zero; assim, a
próxima instrução (JMP) é saltada, fazendo com que o programa avance para fora do laço.
P.ex.:
….
laço: instr 1
instr 2
….
ISZ Cont (variável para contar num de vezes)
JMP laço
1a. instr fora do laço
….

h) HLT: parar a execução.

7
Exemplos de utilização dessas 16 instruções; os 4 bits mais à esquerda da instrução definem a
operação:
i) Programa para somar três números (representados em hexadecimal):
endereço
00 CRA x x
01 ADD 0 6 Carregar 1o. operando em RAC
02 ADD 0 7
03 ADD 0 8
04 STA 0 9
05 HLT x x
06 0 1 7
07 0 0 B
08 0 1 C
09 ? ? ? Para armazenar o resultado (03EH)

Observar que os endereços especificados nas instruções dependem do programa; no

entanto, talvez sejam necessárias alterações nestes endereços, por exemplo, quando ocorrem
modificações no programa e/ou inclusão de operandos. Para evitar isso, pode-se especificar um
endereço em forma simbólica, o chamado Rótulo (“label”) (os símbolos devem ser substituídos
pelos valores correspondentes quando o programa estiver pronto OU deve existir uma tabela de
alocação para os símbolos).

ii) Programa para somar três números usando endereços simbólicos de memória:
rótulos
CRA
ADD A
ADD B
ADD C
STA R
HLT
A 017
B 00B
C 01C
R ? ? ? (para armazenar resultado)

8
iii) Programa para subtrair dois números (pois não há instrução de subtração):
rótulos
CRA
ADD Sub (carregar subtraendo em RAC)
CTA
ITA
ADD Min (adicionar minuendo a RAC)
STA Dif
HLT
Sub 09C
Min 0B7
Dif ? ? ? (para armazenar a diferença 0B7 – 09C = 01BH)

iv) Programa que envolve dois subtraendos:

rótulos
CRA
ADD Sub1 (carregar 1o. subtraendo em RAC)
CTA
ITA
STA NSub1 (armazenar negativo do 1o. subtraendo em NSub1)
CRA
ADD Sub2 (carregar 2o. subtraendo em RAC)
CTA
ITA
ADD Min (adicionar minuendo a RAC)
ADD NSub1 (adicionar 1o. subtraendo a RAC)
STA Res
HLT
Min 0B7
Sub1 09C
Sub2 005
NSub1 ? ? ? (para armazenar negativo de Sub1)
Res ? ? ? (para armazenar resultado) (Min - Sub1 - Sub2 = Res)

v) Programa para somar 100 números colocados em locais sucessivos da memória (a partir de
EndOp), usando instruções ADDI, ISZ e JMP:
Rótulos
CRA
Laço ADDI End (carregar 1o. operando em RAC)
ISZ End (incrementar endereço dos operandos)
ISZ Cont (incrementar contador)
JMP Laço
STA Res
HLT
Res ? ? ? (para armazenar resultado)
End EndOp (endereço do próximo operando)
9
 Cont F9C (número de operandos = -100)
EndOp Opn1 (endereço 1o. operando)
Opn2
.....
Opn100

vi) Programa para multiplicar dois números (pois não há instrução de multiplicação):
Rótulos
CRA
STA Parc (limpar local Parc)
Laço CRA
ADD Mor (carregar multiplicador em RAC)
ROR (colocar bit mais à direita em F)
STA Mor (rearmazenar multiplicador deslocado em Mor)
SFZ
JMP Um (saltar se F = 1)
JMP Zero (saltar se F = 0)
Um CRA
ADD Mnd (carregar multiplicando deslocado em RAC)
ADD Parc (somar ao resultado parcial)
STA Parc (rearmazenar resultado parcial em Parc)
CRF (p/ não inserir um 1 à direita de Mnd quando for multiplicar por 2)
Zero CRA
ADD Mnd (carregar multiplicando em RAC)
ROL
STA Mnd (rearmazenar multiplicando deslocado em Mnd)
ISZ Cont
JMP Laço
HLT
Cont FF4 (para o contador; inicialmente = -12)
Mnd XXX (para armazenar multiplicando)
Mor YYY (para armazenar multiplicador)
Parc ? ? ? (para produto de 12 bits)

O programa dado usa o esquema de deslocamento e adição. Uma vez que os dados são de 12 bits,
o processo de adicionar produtos parciais (quando F = 1) e de deslocamento deve ser feito 12
vezes

10
vii) Programa para chamada de subrotina de multiplicação, para calcular (N1*N2 + N3*N4)
Rótulos
A N1 (Primeiro operando)
B N2
C N3
D N4
Nbit FF4 (valor -12 a ser usado na subrotina MULT)
CRA
ADD A
STA Mnd (coloca N1 em “Mnd”)
CRA
ADD B
STA Mor (coloca N2 em “Mor”)
CSR MULT
CRA
ADD Parc
STA Res (carregar resultado parcial em “Res”)
CRA
ADD C
STA Mnd (coloca N3 em “Mnd”)
CRA
ADD D
STA Mor (coloca N4 em “Mor”)
CSR MULT
CRA
ADD Parc (carregar RAC com N3 * N4)
ADD Res (fazer N1*N2 + N3*N4)
HLT (parar, deixando o resultado final em RAC)

MULT End_ret (para armazenar endereço de retorno, que é diferente em cada chamada )
CRA
ADD Nbit
STA Cont
CRA (início do processo de multiplicação)
STA Parc
Laço CRA
ADD Mor
.....
.....
STA Mnd
ISZ Cont
JMP Laço (final da subrotina de multiplicação)
JMPI MULT (retorno indireto ao programa principal)
Cont ? ? ? (para o contador; inicialmente = -12)
Mnd ? ? ? (para armazenar multiplicando)
Mor ? ? ? (para armazenar multiplicador)
Parc ? ? ? (para produto de 12 bits)
Res ? ? ? (para soma de produtos)

11
Observação 1: CICLO DE MÁQUINA e CICLO DE INSTRUÇÃO
Define-se como CICLO DE MÁQUINA o número de ciclos de relógio, chamados ESTADOS,
necessários para um computador realizar a busca e a execução de uma instrução que envolve
apenas um acesso a dispositivo externo (por exemplo, memória). Se uma instrução necessita de
apenas um acesso externo (as 8 instruções elementares, JMP e HLT envolvem apenas um acesso
à memória, no ciclo de busca), ela tem um CICLO DE INSTRUÇÃO igual ao ciclo de máquina.
No entanto, se uma instrução necessita de mais de um acesso a dispositivos externos (as outras
instruções), ela terá um ciclo de instrução de dois ou mais ciclos de máquina.

Observação 2: CÓDIGO DE OPERAÇÃO

Para carregar palavras de instruções na memória de um computador tem-se que usar algum tipo
de código que o computador possa interpretar. Este CÓDIGO DE OPERAÇÃO é geralmente
chamado de OP CODE. Assim, se a instrução CRA tivesse o Op Code 0000, ADD tivesse 1000 e
CSR tivesse 1101, pode-se ter:
Conteúdo de Memória:
Endereço Instrução em binário em hexadecimal
01 CRA 0000 xxxx xxxx 0xxH
02 ADD, 3FH 1000 0011 1111 83FH
03 CSR, 5BH 1101 0101 1011 D5BH
04 HLT 1111 xxxx xxxx FxxH

Quando um programa está num formato que utiliza mnemônicos, ele está escrito em
LINGUAGEM DE MONTAGEM, chamado de PROGRAMA FONTE. Se este programa foi
convertido para sua forma em binário (0 e 1), ele está escrito em LINGUAGEM DE MÁQUINA,
chamado de PROGRAMA OBJETO (a versão do programa em hexadecimal também é
considerada como em linguagem de máquina).

12