Você está na página 1de 14

Unidade central de Processamento

realiza operaes bsicas codificadas em 0s e 1s

instruo contm cdigo de operao e informao dos operandos

programa composto de instrues de mquina armazenadas em seqncia na


memria

Ciclo de instruo
1

Busca a prxima instruo

Interpreta a instruo (decodificao)

Executa a instruo

Volta para passo 1

Atividades da UCP

Processamento- ULA e registradores

Controle - Contador de Instrues (PC), Unidade de controle e relgio

Instruo de mquina

operaes bsicas que podem ser executadas pelo hardware:


o somar dois nmeros
o multiplicar 2 nmeros
o transferir palavra de dados da memria para UCP
o desviar condicionalmente e incondicionalmente
o operaes lgicas
o transferir bytes da E/S para memria principal

quanto menor e mais simples o conjunto de instrues, menor pode ser o ciclo
do processador

CISC(complex instruction set computer)

RISC(reduced instruction set computer)

Projeto de um processador inclui definir o conjunto de instrues e implementar


o hardware para execut-lo

instrues podem ter tamanho fixo ou varivel

Linguagem de montagem
Programa em C:
a=b+c

Programa em Linguagem de montagem:


add b c a

Variveis ficam em registradores. 8 registradores de 32 bits cada um: 0,1,2,3,4,5,6 e 7


Programa em C:
f=(g+h)+(i+j)

Programa em Linguagem de montagem:


add g h t0
add i j t1
add t0 t1 f

Supondo g alocada para registrador 1, h alocada para registrador 2, i alocada para


registrador 3, j alocada para registrador 4 e f alocada para registrador 5:
add 1 2 6
add 3 4 7
add 6 7 5

Estruturas de dados mantidas na memria porque no h espao nos registradores.


Operaes lgicas e aritmticas somente realizadas entre registradores. Logo, necessitase de instrues para realizar transferncia entre a memria e registradores.
Programa em C
g=h+A[8]

Programa em linguagem de montagem, supondo g alocada no registrador 2, h alocada


em 3 e endereo inicial de A se encontra no registrador 4:
lw 4 1 8
add 1 3 2

Programa em C
A[12]=h+A[8]

Programa em linguagem de montagem, supondo h alocada no registrador 2 e endereo


inicial de A no registrador 4:
lw 4 1 8
add 1 2 1
sw 4 1 12

Arquitetura do conjunto de instrues


O processador hipottico apresentado em sala de aula possui as seguintes
caractersticas:
1

palavra de 32 bits

8 registradores de 32 bits com os respectivos identificadores:


0,1,2,3,4,5,6,7, sendo que o registrador 0 armazena o valor constante
0

capacidade mxima de endereamento de 65536 palavras de


memria

instrues de 32 bits

O conjunto de instrues desta mquina composto de 8 instrues:

Instruo em
Linguagem de
Montagem

Ao

add regA regB


destreg

soma o contedo do registrador regA com o contedo


de regB e armazena resultado no registrador destreg

addi regA regB


imediato

soma o contedo do registrador regA com o valor


imediato e armazena resultado no registrador regB

lw regA regB
deslocamento

carrega no registrador regB o contedo da palavra da


memria cujo endereo a soma do contedo do
registrador regA com o valor deslocamento

sw regA regB
deslocamento

armazena o contedo do registrador regB na palavra da


memria cujo endereo a soma do contedo do
registrador regA com o valor deslocamento

beq regA regB


deslocamento

caso os contedos dos registradores regA e regB sejam


iguais, vai para o endereo PC+1+deslocamento, onde
PC o endereo da instruo beq

halt

incrementa o valor de PC e para execuo do programa

noop

incrementa o valor de PC e vai para prxima instruo

Linguagem de mquina - Representando instrues em binrio


Cada registrador possui um conjunto de bits associado:

0=000

1=001

2=010

3=011

4=100

5=101

6=110

7=111

add regA regB destreg


31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao
21-19=regA
18-16=regB
15-3=0
2-0=destreg
add 1 2 5
31-25 = 0
24-22=cdigo de operao=000
21-19=regA=1=001
18-16=regB=2=010
15-3=0
2-0=destreg=5=101
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| 0| 0| 0| 0| 0| 0| 0| 0| 0| 0| 0| 0| 1| 0| 1| 0| 0| 0| 0| 0| 0| 0| 0|
0| 0| 0| 0| 0| 0| 1| 0| 1|
-----------------------------------------------------------------------------------------------

lw regA regB deslocamento


31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=010
21-19=regA
18-16=regB
15-0=deslocamento expresso em C2 (16 bits: -32768 a +32767)
Programa em C:
A[300]=h+A[300]
Programa em linguagem de montagem:
Supondo h alocada no registrador 2
registrador 6:

e endereo base de A no

lw 6 5 300
add 5 2 5
sw 6 5 300
lw 6 5 300
31-25 = 0
24-22=cdigo de operao=010
21-19=regA=6=110
18-16=regB=5=101
15-0=0000000100101100
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| 0| 0| 0| 0| 0| 0| 0| 0| 1| 0| 1| 1| 0| 1| 0| 1| 0| 0| 0| 0| 0| 0| 0|
1| 0| 0| 1| 0| 1| 1| 0| 0|
----------------------------------------------------------------------------------------------add 5 2 5
31-25 = 0
24-22=cdigo de operao=000
21-19=regA=5=101
18-16=regB=2=010
15-3=0
2-0=destreg=5=101
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| 0| 0| 0| 0| 0| 0| 0| 0| 0| 0| 0| 1| 0| 1| 0| 1| 0| 0| 0| 0| 0| 0| 0|
0| 0| 0| 0| 0| 0| 1| 0| 1|
----------------------------------------------------------------------------------------------sw 6 5 300
31-25 = 0
24-22=cdigo de operao=011
21-19=regA=6=110

18-16=regB=5=101
15-0=0000000100101100
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| 0| 0| 0| 0| 0| 0| 0| 0| 1| 1| 1| 1| 0| 1| 0| 1| 0| 0| 0| 0| 0| 0| 0|
1| 0| 0| 1| 0| 1| 1| 0| 0|
-----------------------------------------------------------------------------------------------

Instrues de desvio
Programa em C:

if (x!=y)
f=g+x;
else
f=g+y;

Instruo de linguagem de montagem: beq regA regB L1


Caso contedo de regA igual ao contedo de regB vai para instruo no
endereo L1, caso contrrio executa a prxima instruo.
Supondo x alocada no registrador 1, y em 2, f em 3 e g em 4, teremos o
seguinte cdigo:

ELSE
EXIT

beq
add
beq
add

1
4
1
4

2 ELSE
1 3
1 EXIT
2 3

Formato das instrues:


beq regA regB label
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=100
21-19=regA
18-16=regB
15-0=deslocamento expresso em C2 (16 bits: -32768 a +32767)-vai para
PC+1+deslocamento

Conjunto de instrues de linguagem de montagem


Cada registrador possui um conjunto de bits associado a ele:

0=000

1=001

2=010

3=011

4=100

5=101

6=110

7=111

add regA regB destreg


destreg=regA+regB
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=000
21-19=regA
18-16=regB
15-3=0
2-0=destreg
lw regA regB deslocamento
regB=Mem[regA+deslocamento]
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=010
21-19=regA
18-16=regB
15-0=deslocamento expresso em C2 (16 bits: -32768 a +32767)
sw regA regB deslocamento
Mem[regA+deslocamento]=regB
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
-----------------------------------------------------------------------------------------------

| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=011
21-19=regA
18-16=regB
15-0=deslocamento expresso em C2 (16 bits: -32768 a +32767)

Programa em C:
while (A[i] != k)
i=i+j;

Supondo i alocada no registrador 1, j em 2, k em 3 e endereo inicial de A em 4:


Programa em linguagem de montagem:
Loop

EXIT

add
lw
beq
add
beq

4
5
5
1
1

1
5
3
2
1

5
0
EXIT
1
Loop

Formato das instrues:


beq regA regB label
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=100
21-19=regA
18-16=regB
15-0=deslocamento expresso em C2 (16 bits: -32768 a +32767)-vai para
PC+1+deslocamento

Outras operaes:
addi regA regB imediato
regB=regA+imediato
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=001
21-19=regA
18-16=regB
15-0=valor imediato expresso em C2 (16 bits: -32768 a +32767)

addi 5 6 5
31-25 = 0
24-22=cdigo de operao=001
21-19=5=101
18-16=6=110
15-0=5=00000000000000101
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| 0| 0| 0| 0| 0| 0| 0| 0| 0| 1| 1| 1| 0| 1| 0| 1| 0| 0| 0| 0| 0| 0| 0|
0| 0| 0| 0| 0| 0| 1| 0| 1|
----------------------------------------------------------------------------------------------halt
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=110
21-0=0
noop
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------------------------------| | | | | | | | | | | | | | | | | | | | | | | |
| | | | | | | | |
----------------------------------------------------------------------------------------------31-25 = 0
24-22=cdigo de operao=111
21-0=0

Exemplo:
Programa em C:
for (i=0; i< 9; i++)
A[i]=A[i+1];
A[9]=0;

Traduo para linguagem de montagem:


Supondo i alocada no registrador 1 e endereo inicial de A no registrador 2,
teremos o seguinte cdigo:
addi 0 1 0
addi 0 3 9
valor 9
FOR
beq 1 3 SAI
add 1 2 4
addi 4 5 1

inicializa i com o valor 0


inicializa varivel de controle do loop com
verifica se i < 9
obtm endereo de A[i]
obtm endereo de A[i+1]

lw 5 5 0
sw 4 5 0
addi 1 1 1
beq 0 0 FOR
sw 2 0 9

SAI

obtm elemento A[i+1]


armazena A[i+1] em A[i]
incrementa i
armazena 0 em A[9]

Modos de endereamento
Os operandos das instrues da linguagem de montagem utilizada podem ser acessados
atravs dos seguintes modos:
1

Endereamento por registrador: O identificador do registrador indica onde o


operando se encontra.
Ex: add 1 2 3

Endereamento por base ou deslocamento: O operando se encontra em um


endereo de memria formado pela soma do contedo de um registrador e uma
constante que so indicados na instruo.
Ex: lw 1 2 100

Imediato ou Constante: O operando uma constante indicada na prpria


instruo.
Ex: addi 1 2 200

Endereamento relativo ao PC: O operando um endereo formado pela soma


do valor atual do PC e um valor constante especificado na instruo.
Ex: beq 1 1 5 ( A prxima instruo a ser executada est no endereo PC+1+5)

Aula de laboratrio - Programao em linguagem de


montagem
Arquitetura do conjunto de instrues
O processador hipottico apresentado em sala de aula possui as seguintes
caractersticas:
1

palavra de 32 bits

8 registradores de 32 bits com os respectivos identificadores:


0,1,2,3,4,5,6,7, sendo que o registrador 0 armazena o valor constante
0

capacidade mxima de endereamento de 65536 palavras de


memria

instrues de 32 bits

O conjunto de instrues desta mquina composto de 8 instrues:

Instruo em
Linguagem de
Montagem

Ao

add regA regB


destreg

soma o contedo do registrador regA com o contedo


de regB e armazena resultado no registrador destreg

addi regA regB


imediato

soma o contedo do registrador regA com o valor


imediato e armazena resultado no registrador regB

lw regA regB
deslocamento

carrega no registrador regB o contedo da palavra da


memria cujo endereo a soma do contedo do
registrador regA com o valor deslocamento

sw regA regB
deslocamento

armazena o contedo do registrador regB na palavra da


memria cujo endereo a soma do contedo do
registrador regA com o valor deslocamento

beq regA regB


deslocamento

caso os contedos dos registradores regA e regB sejam


iguais, vai para o endereo PC+1+deslocamento, onde
PC o endereo da instruo beq

halt

incrementa o valor de PC e para execuo do programa

noop

incrementa o valor de PC e vai para prxima instruo

As instrues possuem 32 bits e so codificadas da seguinte maneira:

bits 31-25 no so utilizados e devem ser iguais a 0

bits 24-22: cdigo de operao

instruo add

bits 21-19: regA

bits 18-16: regB

bits 15-3: no utilizados (devem ser iguais a 0)

bits 2-0: destreg

instruo addi,lw, sw, beq:


o

bits 21-19: regA

bits 18-16: regB

bits 15-0: valor em complemento a 2

instruo halt,noop:
o

bits 21-0: no utilizados (devem ser iguais a o)

Instruo em Linguagem de Montagem

Cdigo de operao

add regA regB destreg

000

addi regA regB imediato

001

lw regA regB deslocamento

010

sw regA regB deslocamento

011

beq regA regB deslocamento

100

halt

110

noop

111

Simulador
O programa SimulaPC traduz um programa escrito na linguagem de
montagem especificada acima e simula sua execuo na mquina
hipottica. Para utilizar esta ferramenta, um programa deve ser escrito na
linguagem de montagem, carregado e traduzido pela ferramenta. Aps esta
traduo o programa poder ser executado diretamente ou no modo passo
a passo. O simulador sempre carrega o programa a partir do endereo 0.

O formato de cada linha de programa deve ser o seguinte:


label<espao>instruo<espao>campo 0<espao>campo 1<espao>campo
2<espao>comentrios

O campo mais esquerda deve ser o campo label que deve conter no mximo 6
caracteres e pode conter letras ou nmeros e sempre comear por letra.O campo label
opcional, mas o espao aps este campo necessrio.
Para cada tipo de instruo os campos 0, 1 e 2 so utilizados de forma diversa:

instruo add requer 3 campos: campo 0 regA, campo 1 regB e


campo 2 destreg

instrues addi, lw, sw e beq requerem 3 campos: campo 0 regA,


campo 1 regB e campo 2 um valor numrico ou um endereo
simblico que consiste de um label

as instrues noop e halt no requerem campos

O ltimo campo deve ser utilizado para comentrios do programa.

Alm das instrues, um programa escrito em linguagem de montagem pode conter


diretivas para o montador do programa. A nica diretiva utilizada neste simulador a
diretiva
.fill <valor numrico ou label>

que indica ao montador que um valor numrico deve ser colocado no lugar
onde seria colocada uma instruo. Esta diretiva utiliza um nico campo que
pode ser um valor numrico ou um label.
Como utilizar o simulador
Para utilizar o simulador voc deve salvar em um diretrio o arquivo
SimulaPC.exe que contm o cdigo executvel do simulador.

O programa prog1.asc mostrado abaixo soma os valores 5 e 10 e coloca o resultado no


registrador 3.

val

addi 0 1 5
lw
0 2 val
add 1 2 3
halt
.fill 10

Voc ir utilizar o simulador para traduzir este programa para linguagem de


mquina e simular sua execuo. Para isto, execute o simulador
SimulaPC.exe. Carregue o programa prog1.asc, atravs da opo Arquivo,
Carregar Arquivo Fonte.... O arquivo fonte dever aparecer na janela
Cdigo-Fonte. Para traduzir este programa para linguagem de mquina,
escolha a opo CPU, Traduzir. Na janela intitulada Sada, ser colocado o
resultado da traduo, indicando se foram encontrados erros no arquivo
fonte.

Caso o programa tenha sido traduzido com sucesso, verifique o cdigo gerado pelo
montador mostrado na janela Display e confirme se o cdigo gerado est correto.
Agora, voc ir executar o programa passo a passo. Escolha a opo CPU, Executar
Passo-a-Passo. O simulador mostra o contedo dos 8 registradores e de dois outros
registradores: Contador de Instrues que indica o endereo da instruo a ser executada
e Registrador de Instrues que contm a instruo.
Execute uma instruo de cada vez, clicando o boto Executar ao lado da janela
Display e verifique como o contedo dos registradores modificado.
Questo 1:
Mostre como o programa deve ser modificado de modo que ele some 15
com 20. Utilize o simulador para verificar se seu programa est
funcionando.

Questo 2:
Mostre como o programa deve ser modificado de modo que o resultado da
soma seja armazenado em uma posio de memria depois da posio da
linha "val". Utilize o simulador para verificar se seu programa est
funcionando.
Implementao de laos
O comando em C
(for i=4;i>0;i--);

inicia a varivel i com o valor 4, testa se ela maior que 0 e em caso


positivo decrementa o valor de i e volta a test-lo. Em caso negativo, o
prximo comando depois deste ser executado.

Supondo que a varivel i esteja alocada ao registrador 1, o programa prog2.asc


mostrado abaixo implementa este comando:

ini
fim

addi 0 1 4
beq 0 1 fim
addi 1 1 -1
beq 0 0 ini
halt

Carregue este programa na ferramenta, traduza e executa passo a passo


para entender o seu funcionamento.
Questo 3:
A partir do cdigo acima, crie um programa para executar o seguinte cdigo
em C:
int x,i;
x=3;
for (i=5;i>0;i--)
x=x+2;

Este trecho de programa utiliza as variveis x e i do tipo inteiro e ao final de


sua execuo a varivel x ter o valor 13. Considere que a varivel x est
alocada ao registrador 2 e a varivel i ao registrador 1.