Projeto

EQUIPES FORMADAS

EQUIPES ESPONTÂNEAS

ALLANA DOS SANTOS CAMPOS

HIAGO RIOS CORDEIRO

JOAO HENRIQUE DOS SANTOS QUEIROZ

MATEUS REIS DOS SANTOS

Arquitetura 1 / Assembly 2

ADRIEL FABRÍCIO DA SILVA OLIVEIRA

ANDRESSA MENDES SOUZA

HENRIQUE ANDRADE SERRA

SAMUEL MENDONÇA VASCONCELOS

Arquitetura 2 / Assembly 1

EDINALDO DE OLIVEIRA JUNIOR

IGOR MESSIAS SANTOS

WESLEI SOUZA MIRANDA

Arquitetura 2 / Assembly 2

JÔNATAS MOREIRA DE CARVALHO

NAELTON MOREIRA DOS SANTOS FILHO

YURI FAUSTINO SILVA

FELIPE GREGUE CHAVES PIRES

Arquitetura 2 / Assembly 1

EMMANUEL NORBERTO RIBEIRO DOS SANTOS

DIEGO MARCELINO SANTOS SILVA

VICTOR DOS SANTOS SANTANA

Arquitetura 1 / Assembly 1

ANDRÉ DE SOUZA ALVES

DANIEL ANDRADE PENÊDO SANTOS

Arquitetura 3 / Assembly 1

EQUIPES COMPULSÓRIAS

GEORGE SILVA ALVES

LUIS DIOGO DE AZEVEDO GALVÃO

NATHAN DA ROCHA SILVA

SAMIR SANTOS COSTA

VANDERLEI RIBEIRO SANTANA

VICTOR GIOVANNI DA SILVA SANTOS

UESLEI SALES VIEIRA MAGALHÃES

Cada equipe deve escolher uma arquitetura e seu respectivo Assembly.

A lista segue abaixo.

Arquiteturas.

Assembly.

Por haver mais de um registrador, este deve ser identificado pelo símbolo %. Por exemplo move %RPG0 %RPG1. Os valores imediatos (constantes) são números simples.

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 - RegAimul <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

move imm <mem>         || Memória[mem] <- imm

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>    || se RegA==RegB então PC <- mem (desvio condicional)

jneq %<regA> %<regB>   || se RegA!=RegB então PC <- mem (desvio condiciona

jgt %<regA> %<regB>    || se RegA>RegB então PC <- mem (desvio condicional)

jlw %<regA> %<regB>    || 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]

add imm <mem>          || Memória[mem] <- imm + 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]

sub imm <mem>          || Memória[mem] <- imm - 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>    || se RegA==RegB então PC <- mem (desvio condicional)

jgt %<regA> %<regB>    || se RegA>RegB então PC <- mem (desvio condicional)

jlw %<regA> %<regB>    || se RegA<RegB então PC <- mem (desvio condicional)

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, onde residirá o laço de execução. Lembrem de salvar os valores dos registradores antes de executar o imul, e de restaurá-los depois.

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 arquitetura diferente para projetar (arquitetura 1, 2 ou 3), além de uma linguagem assembly (1 ou 2).

Note que 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.

Equipes de no mínimo UMA e no máximo QUATRO pessoas.

Equipes espontâneas: enviem email com os nomes dos componentes para degas at uesc dot br até a meia-noite do dia 09/08/2018.

Equipes compulsórias: os nomes que não estiverem listado 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.

Deal with it.