Embedded Files
O código do simulador (versão alfa) pode ser baixado aqui.
Um pequeno tutorial sobre como projetar uma arquitetura usando este simulador pode ser lido no link "Projetando uma Arquitetura" abaixo.
Para conseguir usar satisfatoriamente o simulador há um pré-requisito inapelável: conhecer programação orientada a objetos.
Apresentações (formado Open Document)
O PROJETO
Assembly (Arquiteturas)
Assembly 1
add %<regA> %<regB> || RegB <- RegA + RegB
add <mem> %<regA> || RegA <- memória[mem] + RegA
add %<regA> <mem> || Memória[mem] <- RegA + memória[mem]
add imm %<regA> || RegA <- imm + RegA
sub <regA> <regB> || RegB <- RegA - RegB
sub <mem> %<regA> || RegA <- memória[mem] - RegA
sub %<regA> <mem> || memória[mem] <- RegA - memória[mem]
sub imm %<regA> || RegA <- imm - RegA
imul <mem> %<RegA> || RegA <- RegA x memória[mem] (produto de inteiros)
imul %<RegA> <mem> || memória[mem] <- RegA x memória[mem] (idem)
imul %<RegA> <RegB> || RegB <- RegA x RegB (idem)
move <mem> %<regA> || RegA <- memória[mem]
move %<regA> <mem> || memória[mem] <- RegA
move %<regA> %<regB> || RegB <- RegA
move imm %<regA> || RegA <- immediate
inc %<regA> || RegA ++
jmp <mem> || PC <- mem (desvio incondicional)
jn <mem> || se última operação<0 então PC <- mem (desvio condicional)
jz <mem> || se última operação=0 então PC <- mem (desvio condicional)
jeq %<regA> %<regB> <mem> || se RegA==RegB então PC <- mem (desvio condicional)
jneq %<regA> %<regB> <mem> || se RegA!=RegB então PC <- mem (desvio condiciona
jgt %<regA> %<regB> <mem> || se RegA>RegB então PC <- mem (desvio condicional)
jlw %<regA> %<regB> <mem> || se RegA<RegB então PC <- mem (desvio condicional)
Assembly 2
add %<regA> %<regB> || RegB <- RegA + RegB
add <mem> %<regA> || RegA <- memória[mem] + RegA
add %<regA> <mem> || Memória[mem] <- RegA + memória[mem]
sub <regA> <regB> || RegB <- RegA - RegB
sub <mem> %<regA> || RegA <- memória[mem] - RegA
sub %<regA> <mem> || memória[mem] <- RegA - memória[mem]
imul <mem> %<RegA> || RegA <- RegA x memória[mem] (produto de inteiros)
imul %<RegA> <mem> || memória[mem] <- RegA x memória[mem] (idem)
imul %<RegA> <RegB> || RegB <- RegA x RegB (idem)
move <mem> %<regA> || RegA <- memória[mem]
move %<regA> <mem> || memória[mem] <- RegA
move %<regA> %<regB> || RegB <- RegA
move imm %<regA> || RegA <- immediate
inc %<regA> || RegA ++
inc <mem> || memória[mem] ++
jmp <mem> || PC <- mem (desvio incondicional)
jn <mem> || se última operação<0 então PC <- mem (desvio condicional)
jz <mem> || se última operação=0 então PC <- mem (desvio condicional)
jnz <mem> || se última operação|=0 então PC <- mem (desvio condicional)
jeq %<regA> %<regB> <mem> || se RegA==RegB então PC <- mem (desvio condicional)
jgt %<regA> %<regB> <mem> || se RegA>RegB então PC <- mem (desvio condicional)
jlw %<regA> %<regB> <mem> || se RegA<RegB então PC <- mem (desvio condicional)
Assembly 3
add %<regA> %<regB> || RegB <- RegA + RegB
add <mem> %<regA> || RegA <- memória[mem] + RegA
add %<regA> <mem> || Memória[mem] <- RegA + memória[mem]
add imm %<regA> || RegA <- imm + RegA
sub <regA> <regB> || RegB <- RegA - RegB
sub <mem> %<regA> || RegA <- memória[mem] - RegA
sub %<regA> <mem> || memória[mem] <- RegA - memória[mem]
sub imm %<regA> || RegA <- imm - RegA
move <mem> %<regA> || RegA <- memória[mem]
move %<regA> <mem> || memória[mem] <- RegA
move %<regA> %<regB> || RegB <- RegA
move imm %<regA> || RegA <- immediate
inc %<regA> || RegA ++
jmp <mem> || PC <- mem (desvio incondicional)
jn <mem> || se última operação<0 então PC <- mem (desvio condicional)
jz <mem> || se última operação=0 então PC <- mem (desvio condicional)
jeq %<regA> %<regB> <mem> || se RegA==RegB então PC <- mem (desvio condicional)
jneq %<regA> %<regB> <mem> || se RegA!=RegB então PC <- mem (desvio condiciona
jgt %<regA> %<regB> <mem> || se RegA>RegB então PC <- mem (desvio condicional)
jlw %<regA> %<regB> <mem> || se RegA<RegB então PC <- mem (desvio condicional)
call <mem> || PC <- mem ((desvio incondicional) mas, antes de desviar,empilha o endereço de retorno (endereço da instrução imediatamente posterior ao call (push(PC++) )
ret || PC <- pop() (desvio incondicional)
Assembly 4
add %<regA> %<regB> || RegB <- RegA + RegB
add <mem> %<regA> || RegA <- memória[mem] + RegA
add %<regA> <mem> || Memória[mem] <- RegA + memória[mem]
sub <regA> <regB> || RegB <- RegA - RegB
sub <mem> %<regA> || RegA <- memória[mem] - RegA
sub %<regA> <mem> || memória[mem] <- RegA - memória[mem]
move <mem> %<regA> || RegA <- memória[mem]
move %<regA> <mem> || memória[mem] <- RegA
move %<regA> %<regB> || RegB <- RegA
move imm %<regA> || RegA <- immediate
inc %<regA> || RegA ++
inc <mem> || memória[mem] ++
jmp <mem> || PC <- mem (desvio incondicional)
jn <mem> || se última operação<0 então PC <- mem (desvio condicional)
jz <mem> || se última operação=0 então PC <- mem (desvio condicional)
jnz <mem> || se última operação|=0 então PC <- mem (desvio condicional)
jeq %<regA> %<regB> <mem> || se RegA==RegB então PC <- mem (desvio condicional)
jgt %<regA> %<regB> <mem> || se RegA>RegB então PC <- mem (desvio condicional)
jlw %<regA> %<regB> <mem> || se RegA<RegB então PC <- mem (desvio condicional)
call <mem> || PC <- mem ((desvio incondicional) mas, antes de desviar,empilha o endereço de retorno (endereço da instrução imediatamente posterior ao call (push(PC++) )
ret || PC <- pop() (desvio incondicional)
NOTA: A ULA não possui operação de multiplicação. Com isso as operações imul deverão ser implementadas utilizando-se um trecho de memória (previamente reservada pela própria arquitetura), onde residirá um pequeno microprograma que executa um laço de execução. Lembrem de salvar os valores dos registradores antes de executar o imul, e de restaurá-los depois. Reserve posições de memória pra isso também.
NOTA SOBRE A PILHA
Os registradores StackTop e StackBotton definem uma pilha que deve ser alocada a partir da primeira posição livre da memória, logo abaixo das variáveis. Note que a pilha é alocada em ordem "decrescente", ou seja, cada novo elemento é inserido na posição imediatamente anterior.
O registrador StackTop deve apontar para o topo da pilha e o registrador StackBotton deve apontar para o final da pilha (a posição imediatamente anterior à em que está alocada a última variável).
StackTop começa na mesma posição de StackBotton. A cada chamada Call se faz uma espécie de push(): o endereço de retorno deve ser inserido na posição indicada por StackTop. Em seguida, StackTop é "recuado" uma posição.
A cada chamada de um ret, se faz uma espécie de PC<-pop(): o registrador SackTop é avançado uma posição e o conteúdo da posição apontada or ele deve ser enviado para PC.
Caso haja uma chamada ret em que StackTop e StackBotton estejam apontando para o mesmo endereço, então a pilha estará vazia.
O projeto da disciplina consiste em projetar diferentes arquiteturas de computadores, considerando os aspectos de sua organização, conforme descrito no material da disciplina.
Cada equipe vai solicitar uma Organização diferente para projetar (Organização 1, 2, 3 ou 4), implementando uma linguagem assembly (Arquiteturas 1, 2, 3 ou 4).
Note que, idealmente, carda par (arquitetura/assembly) não se repetirá. Assim, quem solicitar primeiro terá preferência.
As equipes devem entregar o projeto funcionando plenamente: a linguagem executando perfeitamente sobre a arquitetura considerada descrita com exatidão. Elabore programas de exemplo que usem todos os comandos de cada assembly.
Não se esqueça: no nível de Microinstruções, NÃO EXISTE FOR, IF, WHILE E MUITO MENOS CHAMADA A FUNÇÕES! Se lguma destas estruturas aparecerem nos microprogramas do seu projeto, você será penalizado!
Equipes de no mínimo UMA e no máximo CINCO pessoas.
Equipes espontâneas: enviem email com os nomes dos componentes para degas at uesc dot br até a meia-noite do dia 01/11/2024.
Equipes compulsórias: os nomes que não estiverem listados em alguma equipe espontânea serão colocados em equipes formadas compulsoriamente.
-----------------------------------------------------------------------------------------------------
"Degas! Minha equipe me abandonou! O que eu faço?"
Se isto acontecer, foi por um dos dois motivos: ou você escolheu mal seus colegas de equipe, espontaneamente, ou então você não quis escolher seus colegas de equipe.
Em qualquer desses casos culpa é sua, não minha.
😘😘😘😘
EQUIPES ESPONTÂNEAS
Organização 4
Arquitetura 2
ANA LUIZA OLIVEIRA DE FREITAS
JOÃO VÍTOR GUIMARÃES DOS SANTOS
LUCAS GABRIEL FERREIRA
MARIA CLARA SIMÕES DE JESUS
YURI COUTINHO COSTA
Organização 4
Arquitetura 1
CIBELLE SOUSA RODRIGUES
DAVID JÚNIO MARIANO DOS SANTOS
EMANUEL HUMBERTO MENEZES CERQUEIRA
LAISA PEREIRA DA FRANÇA
LUCAS BRAGA ORIHUELA
Organização 3
Arquitetura 1
ALÍCIA OLIVEIRA ARAÚJO
ARTHUR DE OLIVEIRA MOREIRA
BRENO AROUCA NASCIMENTO
EMYLE SANTANA DA SILVA
ISABELA MADUREIRA ARGOLO
Organização 2
Arquitetura 1
ADRIELLE MARIA ALVES QUEIROZ
LAVÍNIA SOUZA CALÓ DE FIGUEIREDO
RAÍSSA SANTOS AMARAL MOREIRA
SOLANA AMETISTA BONFIM LEMOS
SARA RAQUEL PINTO BRANDÃO SILVA
Organização 1
Arquitetura 1
IGOR CAMPOS DE MELO
RAFAEL DO NASCIMENTO PEDREIRA
RAFAEL SILVA SANTOS
TÁRSIS CARVALHO BARRETO
THIAGO SOUZA PEREIRA
Organização 1
Arquitetura 4
BRUNO SCHUMACHER FARIAS SOUZA
Organização 3
Arquitetura 3
ALECSANDER AUGUSTO PAIXÃO ALMEIDA
MARIA VALENTINA DA LUZ MATTOS BARACAT HABIB
RYAN ARAÚJO RIBEIRO
TÁRCIO CONCEIÇÃO DOS SANTOS
JUAN PABLO AZEVEDO SOUSA
EQUIPE COMPULSÓRIA
Organização 2
Arquitetura 2
JOAO PAULO SANTOS LUZ PEREIRA
MATEUS SILVA LISBOA
JOAO PEDRO ANDRADE LEMOS
Page updated
Google Sites
Report abuse