dllaa/MultDivDesc.doc · Web viewUNIVERSIDADE FEDERAL DE PERNAMBUCO - CENTRO DE INFORMÁTICA -...

UNIVERSIDADE FEDERAL DE PERNAMBUCO- CENTRO DE INFORMÁTICA -

PROFA. DRA. EDNA NATIVIDADE BARROSCADEIRA DE INFRA-ESTRUTURA DE HARDWARE

RELATÓRIO DE DESENVOLVIMENTO:CPU ARQUITETURA MIPS, 32 BITS

Sumário

1. Equipe de desenvolvimento

2. Concepção do Projeto

2.1 Introdução2.2 Objetivos2.3 Recursos Utilizados

2.3.1 Recursos Humanos2.3.2 Recursos de Software2.3.3 Recursos de Hardware

3. Especificação do Projeto

3.1 Repertório de Instruções3.2 Formato das Instruções

3.2.1 Formato F13.2.2 Formato F23.2.3 Formato F3

4. Unidade de Processamento

4.1 Módulos concedidos4.1.1 Memória 256 bytes4.1.2 Banco de Registradores4.1.3 Registrador de Instruções4.1.4 Registrador de Deslocamento4.1.5 Unidade Lógica e Aritmética4.1.6 Registrador comum de dados, 32 bits4.1.7 RegistradorDesl

4.2 Módulos Desenvolvidos:4.2.1 Desl2vezes264.2.2 Desl2vezes324.2.3 ExtensorLUI4.2.4 Extensor14.2.5 Extensor54.2.6 Extensor84.2.7 Extensor164.2.8 StoreBH4.2.9 MultDiv

4.3 Módulos Auxiliares4.3.1 mux214.3.2 Mux21Cond4.3.3 mux2_Ndesl4.3.4 mux21Ext84.3.5 mux41

4.3.6 mux41_RegWrite4.3.7 mux41Ext164.3.8 mux81

4.4 Mapeamento da Unidade de Processamento4.4.1 Codificação do Mapeamento da CPU4.4.2 Unidade de Controle

5. Referências

1. Equipe de desenvolvimento

__________________________________Rebeka Gomes de Oliveira

<[email protected]> - Ciências da Computação

__________________________________Durval Augusto Lira Queiroz dos Santos

< [email protected] > - Ciências da Computação

__________________________________David Levy Lucena Alves Aragão


__________________________________Viviane Eugênia Siqueira de Souza


2. Concepção do Projeto

2.1 Introdução

O projeto aqui apresentado refere-se à implementação de uma unidade central de processamento de 32 bits, baseada na arquitetura MIPS. Para o desenvolvimento deste projeto fez-se uso da ferramenta QUARTUS II 3.0 da Altera, utilizando a linguagem VHDL (Very High Speed Integrated Circuit Hardware Description Language), a qual descreve o comportamento e a arquitetura do hardware.

A arquitetura MIPS tem sido usada em larga escala por empresas de grande porte da área de sistemas embarcados como BroadCom, Cisco, Sony, NEC, Phillips e Toshiba. Como exemplo A MIPS Technologies, uma das líderes da indústria de arquitetura de processadores para aplicações residenciais e comerciais, anunciou ontem que a arquitertura do seu processador MIPS64 foi licenciada pela Sony Computer Entertainment Inc. (SCEI). Como já é fato, a SCEI sempre foi uma das maiores usuárias da tecnologia MIPS, usada largamente nos produtos da série PlayStation. O PlayStation 2, por exemplo, possui dois processadores desse tipo, incluindo o EmotionEngine de 128-Bits.

Uma das maiores características do processador MIPS é a regularidade, fator que contribui para sua relativa simplicidade.

mailto:[email protected]




Essa simplicidade da arquitetura MIPS, um reconhecimento no âmbito comercial, fazendo com que vertentes comerciais façam relevantes investimentos no tocante a desenvolvimentos baseados na mesma.

Dentre outras, algumas caracteristicas pode-se ser ressaltadas, tais como:viabilidade econômica, baixo consumo de potência, eficiência em aplicações pesadas de software e compatibilidade com sistemas de tempo real.

Portanto, este material apesar da natureza acadêmica, reflete uma realidade que pode ser aproveitada num contexto comercial.

2.2 Objetivos

O seguinte projeto, é referente à implementação de um processador MIPS, requerido para avaliação da disciplina de Graduação Infra Estrutura de Hardware, ministrada pela professora Dra. Edna Natividade Barros.

O desenvolvimento do mesmo possibilita o aprendizado, na prática, de uma tecnologia brevemente elucidada na introdução. E, através desse relatório, são apresentadas de maneira detalhada todas as atividades realizadas, bem como os componentes desenvolvidos. É também detalhada a maneira com a qual o processador funciona e seus principais fundamentos..

2.3 Recursos utilizados

2.3.1- Recursos Humanos:

O pessoal alocado para o desenvolvimento do projeto contemplou a prof. Dra. Edna Natividade Barros, com o acompanhamentos periodicos, o monitor João Marcelo e a seguinte equipe de graduandos em Ciências da Computação:

Rebeka Gomes de Oliveira Viviane Souza David Aragão Durval Augusto Lira

2.3.2 - Recursos de Software:

Microsoft Windows XP Professional - Microsoft Word Quartus II 3.0

2.3.3 - Recursos de Hardware

Foram utilizados os computadores disponíveis no Cin com processadores com a configuração mínima destacada abaixo:

Processador AMD Semprom (tm) 2200 + 1.51 GHz 448 MB de RAM

HD de 40 GB Monitor Samsung 550s

3. Especificação do Projeto

O trabalho consiste na implementação de um Sistema que simule uma CPU,na arquitetura MIPS. O sistema consiste de 32 registradores de 32 bits cada, organizados em uma estrutura a qual se convencionou chamar Banco de Registradores. É fornecido um componente de Memória, com a capacidade de armazenamento de 256 bytes; a palavra de processamento no sistema é um vetor de 32 bits; todas as instruções com que trabalha o processador têm comprimento de 32 bits; a entidade a ser produzida deve processar números de 32 bits, escritos na notação complemento a dois; deve haver suporte a tratamento de exceções; deve haver suporte a rotinas reentrantes e recursivas por meio de utilização do apontador da pilha.

A parte que começa a partir de agora, considerará todos os aspectos mencionados na sucinta descrição de acima. Imediatamente a seguir, foi colocada uma descrição particular e pormenorizada de cada instrução implementada pela unidade central de processamento. Logo após, os formatos de instrução permitidos são especificados em detalhes, contribuindo positivamente especificação da atividade realizada.

3.1 Repertório de Instruções

O repertório de instruções a ser implementado é um subconjunto da definição amplamente conhecida do MIPS. Concentra-se nas instruções básicas de referência à memória, operações lógico-aritméticas, desvio e deslocamento. Foram exigidas as operações de multiplicação e divisão para inteiros, não se tornando obrigatório, porém, o suporte ao trabalho com números de ponto-flutuante. As tabelas abaixo apresentam de forma breve o conjunto de instruções em consideração. Em sua estrutura, é apresentado o nome da instrução, seu mnemônico assembly para a maioria dos compiladores de linguagem de máquina, o resumo de sua atividade em notação matemática informal e a descrição breve de sua atuação em linguagem humana escrita.

Descrição geral das instruções implementadas

No Operation

nop: no operation

Executa nenhuma operação por ocasião de sua chamada. Durante um ciclo inteiro de relógio, o dispositivo permanece inerte. Útil em diversos contextos, é instrução fundamental, presente no desenvolvimento de qualquer processador.

Load WordLw reg, desl(reg_base): reg = (Memory[reg_base + desl])Carrega o conteúdo de memória à posição indicada pelo conteúdo do registrador base somado do deslocamento passado como constante no registrador cujo número é especificado.

Store Wordsw reg, desl(reg_base): Memory[reg_base + desl] = regArmazena o conteúdo do registrador cujo número é especificado na posição de memória indicada pelo conteúdo do registrador base somado do deslocamento passado como constante.

Load Bytelb reg, desl(reg_base): reg[7-0] = (Memory[reg_base + desl][7-0])Carrega byte mais significativo do conteúdo de memória à posição indicada pelo conteúdo do registrador base somado do deslocamento passado como constante no registrador cujo número é especificado.

Load Halflh reg, desl(reg_base): reg[15-0] = (Memory[reg_base + desl][15-0])Carrega a meia palavra mais significativa do conteúdo de memória à posição indicada pelo conteúdo do registrador base somado do deslocamento passado como constante no registrador cujo número é especificado.

Store Bytesb reg, desl(reg_base): Memory[reg_base + desl][7-0] = reg[7-0]Armazena o byte mais significativo do conteúdo do registrador cujo número é especificado na posição de memória indicada pelo conteúdo do registrador base somado do deslocamento passado como constante.

Store Halfsh reg, desl(reg_base): Memory[reg_base + desl][15-0] = reg[15-0]Armazena a meia palavra mais significativa do conteúdo do registrador cujo número é especificado na posição de memória indicada pelo conteúdo do registrador base somado do deslocamento passado como constante.

Load Upper ImmediateLui reg, constante: reg[31-16] = constanteCarrega o valor constante de 16 bits passado como parâmetro na metade mais significativa do registrador cujo número é indicado.

Move Highmfhi rd: rd = (reg_hi)Move o conteúdo do registrador específico REG_HI, de 32 bits, para o registrador cujo número é indicado como parâmetro da instrução.

Move Lowmflo rd: rd = (reg_lo)Move o conteúdo do registrador específico REG_LO, de 32 bits, para o registrador cujo número é indicado como parâmetro da instrução.

Additionadd regi, regj, regk: regi = (regj) + (regk)Coloca no registrador cujo número é passado inicialmente, o resultado da soma do conteúdo dos registradores cujos números são indicados em posição posterior. A Unidade de Controle é sensível ao caso de estouro de caixa, conhecido pela expressão inglesa overflow.

Subtractionsub regi, regj, regk: regi = (regj) - (regk)Coloca no registrador cujo número é passado inicialmente, o resultado da operação de subtração entre o conteúdo dos registradores cujos números são indicados em posição posterior. A Unidade de Controle é sensível ao caso de estouro de caixa, conhecido pela expressão inglesa overflow.

Xor Operationxor regi, regj, regk: regi = (regj) xor (regk)Coloca no registrador cujo número é passado inicialmente, o resultado da operação de OU exclusivo lógico entre o conteúdo dos registradores cujos números são indicados em posição posterior.

And Operationand regi, regj, regk: regi = (regj) and (regk)Coloca no registrador cujo número é passado inicialmente, o resultado da operação de AND lógico entre o conteúdo dos registradores cujos números são indicados em posição posterior.

Addition Unsignedaddu regi, regj, regk: regi = (regj) + (regk)Coloca no registrador cujo número é passado inicialmente, o resultado da operação aritmética de adição entre o conteúdo dos registradores cujos números são indicados em posição posterior. A Unidade de Controle não considera o caso de estouro de caixa, conhecido pela expressão inglesa overflow.

Subtraction Unsignedsubu regi, regj, regk: regi = (regj) - (regk)Coloca no registrador cujo número é passado inicialmente, o resultado da operação aritmética de subtração entre o conteúdo dos registradores cujos números são indicados em posição posterior. A Unidade de Controle não considera o caso de estouro de caixa, overflow.

Addition Immediateaddi regi, regj, constant: regi = (regj) + constantColoca no registrador cujo número é passado inicialmente, o resultado da operação aritmética de adição entre o conteúdo do registrador passado em segundo lugar e o valor constante passado como parâmetro da instrução. A Unidade de Controle é sensível ao caso de estouro de caixa, overflow.

Addition Immediate Unsigned addiu regi, regj, constant: regi = (regj) + ConstantColoca no registrador cujo número é passado inicialmente, o resultado da operação aritmética de adição entre o conteúdo do registrador passado em segundo lugar e o valor constante passado como parâmetro da instrução. A Unidade de Controle não considera o caso de estouro de caixa, overflow.

And Operation Immediateandi regi, regj, constant: regi = (regj) and constantColoca no registrador cujo número é passado inicialmente, o resultado da operação de AND lógico entre o conteúdo do registrador passado em segundo lugar e o valor constante passado como parâmetro da instrução.

Xor Operation Immediatexori regi, regj, constant: regi = (regj) xori ConstantColoca no registrador cujo número é passado inicialmente, o resultado da operação de OU exclusivo lógico entre o conteúdo do registrador passado em segundo lugar e o valor constante passado como parâmetro da instrução.

Multiplicationmult rs, rt: reg_hi=reg_lo = rs x rtColoca nos registradores específicos REG_HI e REG_LO, respectivamente, a parte mais significativa e a menos significativa da operação aritmética de multiplicação entre o conteúdo dos registradores cujos números são passados como parâmetros da instrução.

DivisionDiv rs, rt: reg_hi = rs/rt (quociente), reg_lo = (resto da divisão)Coloca nos registradores específicos REG_HI e REG_LO, respectivamente, o quociente e o resto da operação aritmética de divisão inteira entre o conteúdo dos registradores cujos números são passados como parâmetros da instrução.

Shift Right ArtithmeticSra regd, regd, n: rd = shift(regs, n) Coloca no registrador cujo número é passado inicialmente, o resultado da operação de deslocamento aritmético à direita no vetor de 32 bits contido no registrador cujo número é indicado. O número de deslocamentos a serem realizados, contido no intervalo fechado de 0 a 32, é passado como o terceiro parâmetro da instrução.

Shift Right Logicalsrl regd, regd, n: rd = shift(regs, n)Coloca no registrador cujo número é passado inicialmente, o resultado da operação de deslocamento lógico à direita no vetor de 32 bits contido no registrador cujo número é indicado. O número de deslocamentos a serem realizados, contido no intervalo fechado de 0 a 32, é passado como o terceiro parâmetro da instrução.

Shift Left Logicalsll regd, regd, n: rd = shift(regs, n)Coloca no registrador cujo número é passado inicialmente, o resultado da operação de deslocamento lógico à esquerda no vetor de 32 bits contido no registrador cujo número é indicado. O número de deslocamentos a serem realizados, contido no intervalo fechado de 0 a 32, é passado como o terceiro parâmetro da instrução.

Branch on Equalbeq regi, regj, desl: PC = PC + (desl * 4) (if regj = regk)Implementa o desvio condicional do contador do programa. Caso o conteúdo dos registradores cujos números são passados como parâmetro for igual, o registrador contador do programa é desviado de tantas instruções quanto o número indicado no conteúdo constante do campo deslocamento, de 16 bits, passado como parâmetro.

Branch if Not Equalbne regi, regj, desl: PC = PC + (desl * 4) (if regj != regk)Implementa de outra forma o desvio condicional do contador do programa. Caso os conteúdos dos registradores cujos números são passados como parâmetro forem iguais, o registrador contador do programa é desviado de tantas instruções quanto o número indicado no conteúdo constante do campo deslocamento, de 16 bits, passado como parâmetro.

Set if Less Thanslt regi, regj, regk: regi = 1 if regj < regk and regi = 0 otherwiseMarca o registrador cujo número é indicado inicialmente com o valor 1, caso os registradores cujos números indicados posteriormente contiverem valores iguais e com 0, caso contrário.

Set if Less Than Immediateslti regi, regj, constant: regi = 1 if regj < constant and regi = 0 otherwiseMarca o registrador cujo número é indicado inicialmente com o valor 1, caso o registrador cujo número é indicado posteriormente contiver valor igual ao da constante passada como parâmetro da instrução e com 0, caso contrário.

JumpJ end: PC = endImplementa o desvio absoluto do contador do programa. A chamada a jump faz com que o registrador contador do programa receba o valor de 26 bits passado como parâmetro da instrução. Embora o desvio seja absoluto, os 4 bits mais significativos do contador do programa são mantidos. A instrução jump, portanto, não utiliza todo o potencial de endereçamento de memória de 232 referências, utilizando, apenas, um espaço de 226 posições de grupo.

Return from Exceptionrte: retorna ao ponto do programa onde houve uma exceção

Dada a ocorrência de uma exceção, o processador faz o registrador contador do programa apontar para uma posição de memória fixa que armazena o endereço efetivo das rotinas específicas de tratamento de exceção. Cada exceção exige uma rotina particular. Ao término da execução desses procedimentos compensatórios, o processador deve retornar ao exato ponto do programa em que ocorreu a exceção. Esse retorno é executado pela chamada da instrução rte.

Breakbreak: pára a execução do programa (desativa o processador)A chamada break implementa a saída do caso de exceção impensada, não tratável e crítica do processador. Realiza a parada abrupta da execução de um programa, colocando o dispositivo em um estado de inatividade contínua, do qual se retira apenas pelo reinício das atividades de todo o sistema, indicado pela negação da energia motriz. Por ser também útil em circunstâncias diversas, é padrão na arquitetura de computadores.

Jump Registerj reg: PC = (reg)Implementa o desvio absoluto completo do contador do programa. A chamada a jump register faz com que o registrador contador do programa receba o valor de 32 bits contido no registrador cujo número é passado como parâmetro da instrução. Neste caso, todo o espaço de endereçamento é utilizado, sendo claramente possível a realização de 232 referências a endereços de memória. Observação importante: não é seguro realizar-se referências aleatórias a posições de memória mediante a permuta e uso das instruções jump e jump register.

Jump and Link jal end: R31 = PC; PC = endImplementa outra forma de desvio absoluto completo do contador do programa. A chamada a jump and link permite que o registrador contador do programa receba o valor constante de 26 bits passado como parâmetro da instrução, exatamente como no caso da instrução jump. A diferença significativa encontra-se unicamente no fato de que, neste caso, o valor atual do registrador contador do programa é salvo no registrador específico de número 31, da arquitetura. Essa medida facilita a implementação de chamadas seriais e reentrantes de alto nível de grau 1.

3.2 Formato das Instruções

A máquina colocada em funcionamento seguiu o padrão internacional MIPS para formatos de instruções. Segundo essa especificação clara, visando ao favorecimento da regularidade, e tendo em vista que uma boa arquitetura demanda compromisso, todas as instruções devem conter o mesmo tamanho de 32 bits. Os seis bits iniciais são impreterivelmente reservados para a indicação do código da operação, conhecido mais amplamente pelo designativo abreviado”opcode” (do inglês, operation code). Essa medida proporciona extrema simplicidade ao processo interno de decodificação das instruções, reduzindo significativamente a complexidade, tamanho e custo da unidade de processamento e de controle.

De acordo com a definição, há três formatos possíveis de dados nas instruções implementadas pela arquitetura. Em todos os casos, os campos reservados para se fazer referência a registradores específicos do banco de registradores são secções com o comprimento de 5 bits. Trata-se de algo somente esperado, uma vez que o número total de registradores no banco é 32. No tocante a outros campos em particular, há explicações específicas para cada caso; serão consideradas, portanto, as situações individualmente.

3.2.1 Formato F1

O primeiro formato de instruções apresenta a seguinte disposição:

6 bits 5 bits 5 bits 5 bits 5 bits 6 bitsopcode Rs1 rs2 rd shamt funct

Utilizado em todas as instruções aritméticas e lógicas que não envolvam constantes, instruções de deslocamento, de desvio absoluto completo (jump register) e nas instruções de carregamento dos registradores REG_HI e REG_LO (mfhi e mflo), o formato F1 apresenta a disposição mais geral para as instruções implementadas.

Nas instruções aritméticas e lógicas, o campo rs1 indica o número do primeiro registrador operando, o campo rs2 o número do segundo registrador operando e o campo rd o número do registrador destino da operação. Em seu conteúdo será colocado o resultado do que foi analisado pela instrução.

O campo shamt é somente utilizado pelas instruções de deslocamento em vetores de bits, sendo representativo do número de deslocamentos a serem realizados na especificação do projeto esse campo possui 5 bits mas poderia inclusive possuir menos bits.

Em todo caso de instruções aritméticas, deve ser analisado o campo funct pela Unidade de Controle. Indicando a funcionalidade, estabelece a diferença para os casos de instruções com o mesmo código de operação. Trata-se de uma decisão de implementação

por parte dos projetistas do MIPS: todas as instruções aritméticas possuem o mesmo código de operação. A distinção se dá pelo campo da funcionalidade.

3.2.2 Formato F2

O segundo possível para a cadeia de bits recebida como instrução por parte do processador implementado é o seguinte:

6 bits 5 bits 5 bits 16 bitsopcode rs1 rs2 Deslocamento

As instruções que utilizam o formato F2 são todas as de referência à memória, todas as que manipulam constantes e as de desvio condicional relativo (beq e bne).

No caso das que fazem referência à memória para carregamento em registrador (load word, load byte, load half), o campo rs1 indica o número do registrador base da operação e o campo rs2 o número do registrador no qual se deseja carregar o valor armazenado na memória; o campo deslocamento, de 16 bits, armazena o número a ser somado ao valor contido no registrador base para que se encontre a posição de memória na qual há o dado a ser carregado para o registrador. Para as instruções de referência à memória para escrita (store word, store byte, store half) rs2 indica o registrador fonte dos dados para escrita.

A manipulação de constantes é feita por meio do campo deslocamento, sendo nele colocado o dado a ser tratado.

Quanto às instruções de desvio condicional, rs1 indica o número do registrador que armazena o primeiro valor operando para a verificação, rs2 o número do segundo registrador operando e deslocamento o número de instruções a serem desviadas caso o resultado da análise seja positivo.

3.2.3 Formato F3

O terceiro e último formato permitido para instruções na arquitetura em consideração é o seguinte:

6 bits 26 bitsopcode Deslocamento

O formato F3 é utilizado para a representação de instruções de desvio absoluto incompleto (instruções jump e jump and link).

Em ambos os casos, o campo deslocamento é utilizado para armazenar o número constante passado como parâmetro para o qual deve apontar o registrador contador do programa (program counter, PC). Visto que PC possui, como todo registrador da arquitetura, 32 bits, a estratégia para implementação dessas instruções consiste em estender os 26 bits recebidos para 28, por meio da operação de deslocamento duplo à esquerda (o equivalente à multiplicação por quatro do valor decimal) e concatená-los aos 4 bits mais significativos do PC.

Desse modo, o formato de instrução F3 é o de menor amplitude dentre os três.

4. Unidade de ProcessamentoA parte inicial do projeto consistiu da estruturação completa da unidade de

processamento do sistema a ser implementado incluindo seus componentes. O grupo recebeu da equipe coordenadora uma versão significativamente limitada do datapath a ser produzido. A estrutura fornecida implementava 6 (seis) instruções da arquitetura MIPS. Como primeira etapa, o grupo deveria estendê-la de modo a que fosse capaz de executar todas as 34 apresentadas na especificação oficial fazendo as alterações nescessárias..

De acordo com a orientação a descrição foi realizada nos moldes tradicionais, escrita por lápis em papel cartolina e apresentada como desenho preliminar à equipe de ensino da cadeira vinculada ao trabalho, do Centro de Informática da UFPE. A metodologia sugerida mostrou-se efetivamente prática, dado que o trabalho de construção realizado dessa forma proporciona um nível agradável de abstração quanto à complexidade do modelo teórico de um computador, a saber, o conceito de uma máquina de estados relativamente grande. De modo o trabalho se deu da seguinte forma:

- tomou-se o modelo inicial e limitado de projeto da arquitetura MIPS fornecido pela equipe de ensino (veja a figura 2.1);

- como forma de estudo da versão limitada da unidade de processamento concedida, analisou-se cuidadosamente o fluxo de execução de cada instrução implementada pela estrutura concedida;

- ao término da análise, tomou-se o repertório de instruções extras a serem implementadas e verificou-se, uma a uma, quais as alterações necessárias a serem produzidas na estrutura fornecida para que todas pudessem ser executadas quando o sistema fosse posto em funcionamento.

Shiftleft 2

PCMux

0

1

RegistersWriteregister

Writedata

Readdata 1

Readdata 2

Readregister 1

Readregister 2

Instruction[15– 11]

Mux

0

1

Mux

0

1

4


Signextend

3216




Instructionregister

ALUcontrol

ALUresult

ALUZero

Memorydata

register

A

B

IorD

MemRead

MemWrite

MemtoReg

PCWriteCond

PCWrite

IRWrite

ALUOp

ALUSrcB

ALUSrcA

RegDst

PCSource

RegWriteControl

Outputs

Op[5– 0]

Instruction[31-26]

Instruction [5– 0]

Mux

0

2

Jumpaddress [31-0]Instruction [25– 0] 26 28

Shiftleft 2

PC [31-28]

1

1 Mux

0

32

Mux

0

1ALUOut

Memory

MemData

Writedata

Address

Figura 2.1 Unidade de Processamento parcial, concedida.

4.1 Módulos concedidos

A seção que se inicia apresentará exatamente quais blocos da unidade foram concedidos à equipe de desenvolvimento. Neste sentido, ficará completamente evidente a qualquer observador atento o caráter eminentemente didático do trabalho.

Contudo, é fundamental que seja colocado que o espaço de tempo exigido para a conclusão geral das atividades foi de um mês, incluso neste intervalo toda as atividades de análise, projeto, implementação e testes, bem como a edição deste relatório de desenvolvimento. Fica claro, portanto, que a disposição dos módulos expostos a seguir não é informação que restringe o grupo de capacidades ou operabilidades. Trata-se de necessidade puramente situacional.

4.1.1 Memória 256 bytes

O componente representativo da Memória Principal de um sistema de computação concedido para a implementação sistema que inclui a Unidade Central de Processamento em desenvolvimento trabalha com palavras de 32 bits e possui endereçamento por byte. Apesar de o endereço possuir 32 bits, a memória só possui 256 bytes. As entradas e saídas da memória são: a entrada de dados da memória (32 bits), utilizada para o procedimento de escrita; o endereço de entrada da memória (32 bits), colocado para o recebimento do conteúdo à posição indicada; o sinal de escrita, que informa se o procedimento ativo é leitura ou escrita no componente; o clock do sistema; e a saída de Dados da memória (32 bits), informando o conteúdo à posição indicada.

Figura 2.2 Memória 256 bytes com endereçamento por byte

O código VHDL da Memória é apresentado logo a seguir.

---------------------------------------------------------------------------------- Title : Memória da CPU-- Project : CPU Multi-ciclo---------------------------------------------------------------------------------- File : Memoria.vhd-- Author : Emannuel Gomes Macêdo <[email protected]>-- Fernando Raposo Camara da Silva <[email protected]>-- Pedro Machado Manhães de Castro <[email protected]>-- Rodrigo Alves Costa <[email protected]>-- Organization : Universidade Federal de Pernambuco-- Created : 26/07/2002-- Last update : 23/11/2002-- Plataform : Flex10K-- Simulators : Altera Max+plus II-- Synthesizers : -- Targets : -- Dependency : ---------------------------------------------------------------------------------- Description : Entidade responsável pela leitura e escrita em memória.---------------------------------------------------------------------------------- Copyright (c) notice-- Universidade Federal de Pernambuco (UFPE).-- CIn - Centro de Informatica.-- Developed by computer science undergraduate students.-- This code may be used for educational and non-educational purposes as -- long as its copyright notice remains unchanged. ---------------------------------------------------------------------------------- Revisions : 1-- Revision Number : 1.0-- Version : 1.1-- Date : 23/11/2002-- Modifier : Marcus Vinicius Lima e Machado <[email protected]>-- Paulo Roberto Santana Oliveira Filho <[email protected]>-- Viviane Cristina Oliveira Aureliano <[email protected]>-- Description :--------------------------------------------------------------------------------

package ram_constants isconstant DATA_WIDTH : INTEGER := 8;constant ADDR_WIDTH : INTEGER := 8;

constant INIT_FILE : STRING := "ram_instrucoes.mif";end ram_constants;

--*************************************************************************library IEEE;use IEEE.std_logic_1164.all;USE ieee.std_logic_arith.all;

library lpm;use lpm.lpm_components.all;

library work;use work.ram_constants.all;--*************************************************************************

--Short name: memENTITY Memoria IS PORT(

Address : IN BIT_VECTOR(31 DOWNTO 0); -- Endereço de memória a ser lido Clock : IN BIT; -- Clock do sistema

Wr : IN BIT; -- Indica se a memória será lida (0) ou escrita (1) Dataout : OUT BIT_VECTOR (31 DOWNTO 0); -- Valor a ser escrito quando Wr = 1 Datain : IN BIT_VECTOR(31 DOWNTO 0) -- Valor lido da memória quando Wr = 0 );END Memoria;

-- Arquitetura que define o comportamento da memória-- SimulationARCHITECTURE behavioral_arch OF Memoria IS

signal add : bit_vector(7 downto 0); signal addS0 : STD_LOGIC_VECTOR (ADDR_WIDTH-1 DOWNTO 0);

signal addS1 : STD_LOGIC_VECTOR (ADDR_WIDTH-1 DOWNTO 0);signal addS2 : STD_LOGIC_VECTOR (ADDR_WIDTH-1 DOWNTO 0);signal addS3 : STD_LOGIC_VECTOR (ADDR_WIDTH-1 DOWNTO 0);

signal dataoutS : STD_LOGIC_VECTOR (31 DOWNTO 0);signal datainS : STD_LOGIC_VECTOR (31 DOWNTO 0);

signal dataoutS0 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0); signal dataoutS1 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0); signal dataoutS2 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0); signal dataoutS3 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0); signal datainS0 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0); signal datainS1 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0);

signal datainS2 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0); signal datainS3 : STD_LOGIC_VECTOR (DATA_WIDTH-1 DOWNTO 0);

signal wrS : STD_LOGIC;signal clockS : STD_LOGIC;

signal add0 : integer;signal add2 : integer;signal add1 : integer;signal add3 : integer;

signal addu : unsigned(7 downto 0);

BEGIN

-- Usa apenas 8 bits menos significativos do endereço add <= Address(7 downto 0);

-- Conversão de bit-vector em inteiro addu(0) <= To_StdULogic(add(0)); addu(1) <= To_StdULogic(add(1)); addu(2) <= To_StdULogic(add(2)); addu(3) <= To_StdULogic(add(3)); addu(4) <= To_StdULogic(add(4)); addu(5) <= To_StdULogic(add(5)); addu(6) <= To_StdULogic(add(6)); addu(7) <= To_StdULogic(add(7));

-- Cálculo dos 4 endereços (inteiros) a serem lidos devido ao endereçamento por byte add1 <= add0 + 1;

add2 <= add0 + 2; add3 <= add0 + 3; add0 <= CONV_INTEGER(addu);

-- Conversão dos endereços no formato STD_LOGIC_VECTOR addS0 <= CONV_STD_LOGIC_VECTOR(add0, 8);

addS1 <= CONV_STD_LOGIC_VECTOR(add1, 8); addS2 <= CONV_STD_LOGIC_VECTOR(add2, 8); addS3 <= CONV_STD_LOGIC_VECTOR(add3, 8);

-- Conversão do dado (entrada) no formato STD_LOGIC_VECTOR datainS <= To_StdLogicVector(datain);

wrS <= To_StdULogic(wr);

clockS <= To_StdULogic(clock);

-- Conversão de dado (saída) para bit_vectordataout <= To_BitVector(dataoutS);

-- Distribuição dos vetores de dados para os bancos de memória datainS0 <= datainS(7 downto 0); datainS1 <= datainS(15 downto 8); datainS2 <= datainS(23 downto 16); datainS3 <= datainS(31 downto 24);

dataoutS(7 downto 0) <= dataoutS0; dataoutS(15 downto 8) <= dataoutS1; dataoutS(23 downto 16) <= dataoutS2; dataoutS(31 downto 24) <= dataoutS3;

-- Bancos de memórias (cada banco possui 256 bytes)MEM: lpm_ram_dqGENERIC MAP (lpm_widthad => ADDR_WIDTH, lpm_width => DATA_WIDTH, lpm_file =>

INIT_FILE)PORT MAP (data => datainS0, Address => addS0, we => wrS, inclock => clockS,

outclock => clockS, q => dataoutS0);

MEM_plus_One: lpm_ram_dqGENERIC MAP (lpm_widthad => ADDR_WIDTH, lpm_width => DATA_WIDTH, lpm_file =>



MEM_plus_Two: lpm_ram_dqGENERIC MAP (lpm_widthad => ADDR_WIDTH, lpm_width => DATA_WIDTH, lpm_file =>



MEM_plus_Three: lpm_ram_dqGENERIC MAP (lpm_widthad => ADDR_WIDTH, lpm_width => DATA_WIDTH, lpm_file =>



END behavioral_arch;

Código 4.1 Comportamental VHDL da Memória 256 bytes

4.1.2 Banco de Registradores

O módulo que se convencionou chamar banco de registradores é uma estrutura composta por 32 registradores de 32 bits cada. O componente possui duas saídas de 32 bits, apresentando o conteúdo de dois registradores simultaneamente.

O procedimento interno para a leitura do conteúdo dos registradores é puramente combinacional, isto é se os valores nas entradas ReadRegister1 ou ReadRegister2 forem alterados, os valores nas saídas ReadData1 ou ReadData2 podem ser alterados durante o mesmo ciclo de relógio.

O registrador a ser escrito é selecionado pela entrada WriteRegister. Quando a entrada RegWrite é ativada, com valor igual a 1, o registrador selecionado recebe o conteúdo da entrada WriteData.

É informação importante o fato de que o sinal de reset atribui valor zero a todos os registradores e é assíncrono.

Figura 2.3 Banco de Registradores

O código VHDL para o componente Banco de Registradores é apresentado logo em seguida. Verifique a especificação dos sinais de entrada e saída. Sua relação com os demais blocos do sistema será explicada dentro em breve.

---------------------------------------------------------------------------------- Title : Banco de Registradores-- Project : CPU Multi-ciclo---------------------------------------------------------------------------------- File : Banco_reg.vhd-- Author : Emannuel Gomes Macêdo ([email protected])-- Fernando Raposo Camara da Silva ([email protected])-- Pedro Machado Manhães de Castro ([email protected])-- Rodrigo Alves Costa ([email protected])-- Organization : Universidade Federal de Pernambuco-- Created : 29/07/2002-- Last update : 21/11/2002-- Plataform : Flex10K-- Simulators : Altera Max+plus II-- Synthesizers : -- Targets : -- Dependency : ---------------------------------------------------------------------------------- Description : Entidade que armazena o conjunto de registradores da cpu, no-- qual pode ser efetuado leitura e escrita de dados.---------------------------------------------------------------------------------- Copyright (c) notice-- Universidade Federal de Pernambuco (UFPE).-- CIn - Centro de Informatica.-- Developed by computer science undergraduate students.-- This code may be used for educational and non-educational purposes as -- long as its copyright notice remains unchanged. ---------------------------------------------------------------------------------- Revisions : 1-- Revision Number : 1.0-- Version : 1.1-- Date : 21/11/2002-- Modifier : Marcus Vinicius Lima e Machado ([email protected])-- Paulo Roberto Santana Oliveira Filho ([email protected])-- Viviane Cristina Oliveira Aureliano ([email protected])-- Description :--------------------------------------------------------------------------------

InstructionRegisters

Writeregister

Readdata 1

Readdata 2

Readregister 1

Readregister 2

Writedata

RegWrite

InstructionRegisters

Writeregister

Readdata 1

Readdata 2

Readregister 1

Readregister 2

Writedata

RegWrite

--Short name: bregENTITY Banco_reg IS

PORT(Clk : IN bit;

-- Clock do banco de registradoresReset : IN bit;

-- Reinicializa o conteudo dos registradoresRegWrite : IN bit;

-- Indica se a operação é de escrita ou leituraReadReg1 : IN bit_vector (4 downto 0); -- Indica o

registrador #1 a ser lidoReadReg2 : IN bit_vector (4 downto 0); -- Indica o

registrador #2 a ser lidoWriteReg : IN bit_vector (4 downto 0); -- Indica o

registrador a ser escritoWriteData : IN bit_vector (31 downto 0); -- Indica o dado

a ser escritoReadData1 : OUT bit_vector (31 downto 0); -- Mostra a

informaçao presente no registrador #1ReadData2 : OUT bit_vector (31 downto 0) -- Mostra a

informação presente no registrador #2);

END Banco_reg ;

-- Arquitetura que define comportamento do Banco de Registradores-- SimulationARCHITECTURE behavioral_arch OF Banco_reg IS

SIGNAL Reg0 : bit_vector (31 downto 0); -- Conjunto SIGNAL Reg1 : bit_vector (31 downto 0); -- das informaçõesSIGNAL Reg2 : bit_vector (31 downto 0); -- pertencentesSIGNAL Reg3 : bit_vector (31 downto 0); -- aos registradores.SIGNAL Reg4 : bit_vector (31 downto 0); -- Esta CPUSIGNAL Reg5 : bit_vector (31 downto 0); -- possuiSIGNAL Reg6 : bit_vector (31 downto 0); -- 32 registradoresSIGNAL Reg7 : bit_vector (31 downto 0); -- de usoSIGNAL Reg8 : bit_vector (31 downto 0); -- comum.SIGNAL Reg9 : bit_vector (31 downto 0);SIGNAL Reg10 : bit_vector (31 downto 0);SIGNAL Reg11 : bit_vector (31 downto 0);SIGNAL Reg12 : bit_vector (31 downto 0);SIGNAL Reg13 : bit_vector (31 downto 0);SIGNAL Reg14 : bit_vector (31 downto 0);SIGNAL Reg15 : bit_vector (31 downto 0);SIGNAL Reg16 : bit_vector (31 downto 0);SIGNAL Reg17 : bit_vector (31 downto 0);SIGNAL Reg18 : bit_vector (31 downto 0);SIGNAL Reg19 : bit_vector (31 downto 0);SIGNAL Reg20 : bit_vector (31 downto 0);SIGNAL Reg21 : bit_vector (31 downto 0);SIGNAL Reg22 : bit_vector (31 downto 0);SIGNAL Reg23 : bit_vector (31 downto 0);SIGNAL Reg24 : bit_vector (31 downto 0);SIGNAL Reg25 : bit_vector (31 downto 0);SIGNAL Reg26 : bit_vector (31 downto 0);SIGNAL Reg27 : bit_vector (31 downto 0);SIGNAL Reg28 : bit_vector (31 downto 0);SIGNAL Reg29 : bit_vector (31 downto 0);SIGNAL Reg30 : bit_vector (31 downto 0);SIGNAL Reg31 : bit_vector (31 downto 0);BEGIN

-- selecao do primeiro registradorWITH ReadReg1 SELECT

ReadData1 <= Reg0 WHEN "00000", -- acesso às informações do registrador correspondente Reg1 WHEN "00001", Reg2 WHEN "00010", Reg3 WHEN "00011",

Reg4 WHEN "00100", Reg5 WHEN "00101",

Reg6 WHEN "00110", Reg7 WHEN "00111", Reg8 WHEN "01000",

Reg9 WHEN "01001", Reg10 WHEN "01010", Reg11 WHEN "01011", Reg12 WHEN "01100", Reg13 WHEN "01101",

Reg14 WHEN "01110", Reg15 WHEN "01111", Reg16 WHEN "10000", Reg17 WHEN "10001", Reg18 WHEN "10010", Reg19 WHEN "10011",



Reg30 WHEN "11110", Reg31 WHEN "11111";

-- Clocked Processprocess (Clk,Reset)

begin------------------------------------------- Reset inicializa o conjunto de registradores

if(Reset = '1') thenReg0 <= "00000000000000000000000000000000";Reg1 <= "00000000000000000000000000000000";Reg2 <= "00000000000000000000000000000000";Reg3 <= "00000000000000000000000000000000";Reg4 <= "00000000000000000000000000000000";Reg5 <= "00000000000000000000000000000000";Reg6 <= "00000000000000000000000000000000";Reg7 <= "00000000000000000000000000000000";Reg8 <= "00000000000000000000000000000000";Reg9 <= "00000000000000000000000000000000";Reg10 <= "00000000000000000000000000000000";Reg11 <= "00000000000000000000000000000000";Reg12 <= "00000000000000000000000000000000";Reg13 <= "00000000000000000000000000000000";Reg14 <= "00000000000000000000000000000000";Reg15 <= "00000000000000000000000000000000";Reg16 <= "00000000000000000000000000000000";Reg17 <= "00000000000000000000000000000000";Reg18 <= "00000000000000000000000000000000";Reg19 <= "00000000000000000000000000000000";Reg20 <= "00000000000000000000000000000000";Reg21 <= "00000000000000000000000000000000";Reg22 <= "00000000000000000000000000000000";Reg23 <= "00000000000000000000000000000000";Reg24 <= "00000000000000000000000000000000";Reg25 <= "00000000000000000000000000000000";Reg26 <= "00000000000000000000000000000000";Reg27 <= "00000000000000000000000000000000";Reg28 <= "00000000000000000000000000000000";Reg29 <= "00000000000000000000000000000000";Reg30 <= "00000000000000000000000000000000";Reg31 <= "00000000000000000000000000000000";

------------------------------------------ Início do processo relacionado ao clock elsif (Clk = '1' and clk'event) then

if(RegWrite = '1') thencase WriteReg is

when "00000" => Reg0 <= WriteData;when "00001" => Reg1 <= WriteData;

when "00010" => Reg2 <= WriteData;when "00011" => Reg3 <= WriteData;when "00100" => Reg4 <= WriteData;when "00101" => Reg5 <= WriteData;when "00110" => Reg6 <= WriteData;when "00111" => Reg7 <= WriteData;when "01000" => Reg8 <= WriteData;when "01001" => Reg9 <= WriteData;when "01010" => Reg10 <= WriteData;when "01011" => Reg11 <= WriteData;when "01100" => Reg12 <= WriteData;when "01101" => Reg13 <= WriteData;when "01110" => Reg14 <= WriteData;when "01111" => Reg15 <= WriteData;when "10000" => Reg16 <= WriteData;when "10001" => Reg17 <= WriteData;when "10010" => Reg18 <= WriteData;when "10011" => Reg19 <= WriteData;when "10100" => Reg20 <= WriteData;when "10101" => Reg21 <= WriteData;when "10110" => Reg22 <= WriteData;when "10111" => Reg23 <= WriteData;when "11000" => Reg24 <= WriteData;when "11001" => Reg25 <= WriteData;when "11010" => Reg26 <= WriteData;when "11011" => Reg27 <= WriteData;when "11100" => Reg28 <= WriteData;when "11101" => Reg29 <= WriteData;when "11110" => Reg30 <= WriteData;when "11111" => Reg31 <= WriteData;

end case;end if;

end if;------------------------------------------ Fim do processo relacionado ao clock

end process;------------------------------------------ Fim da Arquitetura END behavioral_arch;

Código 4.2 Descrição comportamental VHDL do Banco de Registradores

4.1.3 Registrador de Instruções

Componente fundamental para a ordem no procedimento de análise e decodificação da instrução, o Registrador de Instruções (mais conhecido pelo designativo inglês IR, de Instruction Register) recebe o dado diretamente da Memória e apresenta como saída os diversos campos especificados na definição dos formatos de instrução. Associado ao clock do sistema, possui um sinal de reset, como todo registrador e um sinal de escrita que habilita leitura de seu conteúdo ou carga em seu interior.

Figura 2.4 Registrador de Instruções

O código VHDL do Registrador de Instruções é apresentado a seguir.

---------------------------------------------------------------------------------- Title : Registrador de Intruções-- Project : CPU multi-ciclo---------------------------------------------------------------------------------- File : instr_reg.vhd-- Author : Marcus Vinicius Lima e Machado ([email protected])-- Paulo Roberto Santana Oliveira Filho ([email protected])-- Viviane Cristina Oliveira Aureliano ([email protected])-- Organization : Universidade Federal de Pernambuco-- Created : 29/07/2002-- Last update : 21/11/2002-- Plataform : Flex10K-- Simulators : Altera Max+plus II-- Synthesizers :-- Targets :-- Dependency :---------------------------------------------------------------------------------- Description : Entidade que registra a instrução a ser executada, modulando-- corretamente a saída de acordo com o layout padrão das intruções do Mips.---------------------------------------------------------------------------------- Copyright (c) notice-- Universidade Federal de Pernambuco (UFPE).-- CIn - Centro de Informatica.-- Developed by computer science undergraduate students.-- This code may be used for educational and non-educational purposes as-- long as its copyright notice remains unchanged.---------------------------------------------------------------------------------- Revisions :-- Revision Number :-- Version :-- Date :-- Modifier :-- Description :--------------------------------------------------------------------------------

-- Short name: irentity Instr_reg is

port(Clk : in bit; -- Clock do sistemaReset : in bit; -- ResetLoad_ir : in bit; -- Bit para ativar carga do registrador de

intruçõesEntrada : in bit_vector (31 downto 0); -- Intrução a ser

carregadaInstr31_26 : out bit_vector (5 downto 0); -- Bits 31 a 26 da

instruçãoInstr25_21 : out bit_vector (4 downto 0); -- Bits 25 a 21 da

instruçãoInstr20_16 : out bit_vector (4 downto 0); -- Bits 20 a 16 da

instruçãoInstr15_0 : out bit_vector (15 downto 0) -- Bits 15 a 0 da

instrução);

end Instr_reg;

-- Arquitetura que define o comportamento interno do Registrador de Intruções-- Simulationarchitecture behavioral_arch of Instr_reg is

signal saida : bit_vector (31 downto 0); -- Sinal interno que guarda a intrução a ser modulada

begin

-- Clocked processprocess (clk, reset)

begin

if(reset = '1') thensaida <= "00000000000000000000000000000000";

elsif (clk = '1' and clk'event) thenif (load_ir = '1') then

saida (31 downto 0) <= entrada; -- Carrega instruçãoend if;

end if;

end process;

Instr31_26 <= saida (31 downto 26); -- Modula instrução (31 a 26)Instr25_21 <= saida (25 downto 21); -- Modula instrução (25 a 21)Instr20_16 <= saida (20 downto 16); -- Modula instrução (20 a 16)Instr15_0 <= saida (15 downto 0); -- Modula instrução (15 a 0)

end behavioral_arch;

Código 4.3 Descrição comportamental VHDL do Registrador de Instruções

4.1.4 Registrador de Deslocamento

O registrador de deslocamento é um componente capaz de deslocar um número inteiro de 32 bits para esquerda e para a direita. No deslocamento à direita o sinal pode ser preservado ou não. O número de deslocamentos pode variar entre 0 e 7 e é especificado na entrada n (3 bits) do componente. A funcionalidade desejada do registrador de deslocamento é especificada na entrada shift (3 bits menos significativos) conforme figura abaixo. As atividades discriminadas na entrada shift são síncronas com o clock e o reset é assíncrono.

Figura 2.5 Registrador de Deslocamento

O código VHDL do Registrador de Deslocamento é apresentado logo a seguir.

---------------------------------------------------------------------------------- Title : Registrador de Deslocamento-- Project : CPU Multi-ciclo---------------------------------------------------------------------------------- File : RegDesloc.vhd-- Author : Emannuel Gomes Macêdo <[email protected]>-- Fernando Raposo Camara da Silva <[email protected]>-- Pedro Machado Manhães de Castro <[email protected]>-- Rodrigo Alves Costa <[email protected]>-- Organization : Universidade Federal de Pernambuco-- Created : 10/07/2002-- Last update : 26/11/2002-- Plataform : Flex10K-- Simulators : Altera Max+plus II-- Synthesizers : -- Targets : -- Dependency : --------------------------------------------------------------------------------

-- Description : Entidade responsável pelo deslocamento de um vetor de 32 -- bits para a direita e para a esquerda. -- Entradas:-- * N: vetor de 3 bits que indica a quantidade de -- deslocamentos -- * Shift: vetor de 3 bits que indica a função a ser -- realizada pelo registrador -- Abaixo seguem os valores referentes à entrada shift e as -- respectivas funções do registrador: -- -- Shift FUNÇÃO DO REGISTRADOR-- 000 faz nada-- 001 carrega vetor (sem deslocamentos)-- 010 deslocamento à esquerda n vezes-- 011 deslocamento à direita lógico n vezes-- 100 deslocamento à direita aritmético n vezes-- 101 rotação à direita n vezes-- 110 rotação à esquerda n vezes---------------------------------------------------------------------------------- Copyright (c) notice-- Universidade Federal de Pernambuco (UFPE).-- CIn - Centro de Informatica.-- Developed by computer science undergraduate students.-- This code may be used for educational and non-educational purposes as -- long as its copyright notice remains unchanged. ---------------------------------------------------------------------------------- Revisions : 2-- Revision Number : 2.0-- Version : 1.2-- Date : 26/11/2002-- Modifier : Marcus Vinicius Lima e Machado <[email protected]>-- Paulo Roberto Santana Oliveira Filho <[email protected]>-- Viviane Cristina Oliveira Aureliano <[email protected]>-- Description :--------------------------------------------------------------------------------

-- Short name: deslENTITY RegDesloc IS

PORT(Clk : IN bit; -- Clock do sistema

Reset : IN bit; -- ResetShift : IN bit_vector (2 downto 0); -- Função a ser

realizada pelo registrador N : IN bit_vector (2 downto 0); -- Quantidade de

deslocamentosEntrada : IN bit_vector (31 downto 0); -- Vetor a ser

deslocadoSaida : OUT bit_vector (31 downto 0) -- Vetor deslocado

);END RegDesloc;

-- Arquitetura que define o comportamento do registrador de deslocamento-- SimulationARCHITECTURE behavioral_arch OF RegDesloc IS

signal temp : bit_vector (31 downto 0); -- Vetor temporário

begin

-- Clocked processprocess (Clk, Reset)

beginif(Reset = '1') then

temp <= "00000000000000000000000000000000";

elsif (Clk = '1' and Clk'event) thencase Shift is

when "000" => -- Faz nada

temp <= temp;when "001" =>

-- Carrega vetor de entrada, não faz deslocamentostemp <= Entrada;

when "010" =>-- Deslocamento à esquerda N vezes

case N iswhen "000" =>

-- Deslocamento à esquerda nenhuma veztemp <= temp;

when "001" =>-- Deslocamento à esquerda 1 vez

temp(0) <= '0';temp(31 downto 1) <= temp(30

downto 0);when "010" =>

-- Deslocamento à esquerda 2 vezestemp(1 downto 0) <= "00";temp(31 downto 2) <= temp(29











downto 0);end case;

-- Deslocamento à direita lógico N vezeswhen "011" =>

case n iswhen "000" =>

-- Deslocamento à direita lógico nenhuma veztemp <= temp;

when "001" =>-- Deslocamento à direita lógico 1 vez

temp(30 downto 0) <= temp(31 downto 1);

temp(31) <= '0';when "010" =>

-- Deslocamento à direita lógico 2 vezestemp(29 downto 0) <= temp(31

downto 2);temp(31 downto 30) <= "00";

when "011" =>-- Deslocamento à direita lógico 3 vezes


temp(31 downto 29) <= "000";when "100" =>





temp(31 downto 27) <= "00000";when "110" =>





temp(31 downto 25) <= "0000000";

end case;

-- Deslocamento à direita aritmético N vezeswhen "100" =>


-- Deslocamento à direita aritmético nenhuma veztemp <= temp;

when "001" =>-- Deslocamento à direita aritmético 1 vezes


temp(31) <= temp(31);when "010" =>

-- Deslocamento à direita aritmético 2 vezestemp(29 downto 0) <= temp(31

downto 2);temp(30) <= temp(31);temp(31) <= temp(31);



temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);



temp(28) <= temp(31);temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);



temp(27) <= temp(31);temp(28) <= temp(31);temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);



temp(26) <= temp(31);temp(27) <= temp(31);temp(28) <= temp(31);temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);



temp(25) <= temp(31);temp(26) <= temp(31);temp(27) <= temp(31);temp(28) <= temp(31);temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);

end case;

-- Rotação à direita N vezeswhen "101" =>


-- Rotação à direita nenhuma veztemp <= temp;

when "001" =>-- Rotação à direita 1 vez


temp(31) <= temp(0);when "010" =>

-- Rotação à direita 2 vezestemp(29 downto 0) <= temp(31

downto 2);temp(31 downto 30) <= temp(1
















downto 0);end case;

-- Rotação à esquerda N vezeswhen "110" =>

case n is

when "000" =>-- Rotação à esquerda nenhuma vez


-- Rotação à esquerda 1 veztemp(0) <= temp(31);temp(31 downto 1) <= temp(30


-- Rotação à esquerda 2 vezestemp(1 downto 0) <= temp(31

















downto 0);end case;

-- Funcionalidade não definidawhen others =>-- Faz nada

end case;end if;Saida <= temp;

end process;END behavioral_arch;

Código 4.4 Comportamental VHDL do componenteRegistrador de Deslocamento.

4.1.5 Unidade Lógica e Aritmética

A Unidade Lógico e Aritmética (ALU, do inglês Arithmetic and Logic Unit) é um circuito combinacional que permite a operação com números de 32 bits na notação

complemento a dois. A funcionalidade é especificada pela entrada F conforme descrito na tabela abaixo.

Figura 2.6 Unidade Lógica e Aritmética

F Operação Descrição Flags afetados000 S = A Nenhum Z,N001 S = A + B Soma Z,N,O010 S = A - B Subtração Z,N,O011 S = A and B And lógico Z100 S = inc A Incremento Z,N,O101 S = not A Complemento Z110 S = A xor B Ou exclusivo Z111 S = A comp B Comparação EG,GT,LT

Tabela 2.1 Funcionalidades da Unidade Lógica e Aritmética

O código VHDL da Unidade de Lógica e Aritmética é apresentado a seguir.

---------------------------------------------------------------------------------- Title : Unidade de Lógica e Aritmética-- Project : CPU multi-ciclo---------------------------------------------------------------------------------- File : ula32.vhd-- Author : Emannuel Gomes Macêdo ([email protected])-- Fernando Raposo Camara da Silva ([email protected])-- Pedro Machado Manhães de Castro ([email protected])-- Rodrigo Alves Costa ([email protected])-- Organization : Universidade Federal de Pernambuco-- Created : 29/07/2002-- Last update : 21/11/2002-- Plataform : Flex10K-- Simulators : Altera Max+plus II-- Synthesizers : -- Targets : -- Dependency : ---------------------------------------------------------------------------------- Description : Entidade que processa as operações lógicas e aritméticas da-- cpu.

---------------------------------------------------------------------------------- Copyright (c) notice-- Universidade Federal de Pernambuco (UFPE).-- CIn - Centro de Informatica.-- Developed by computer science undergraduate students.-- This code may be used for educational and non-educational purposes as -- long as its copyright notice remains unchanged. ---------------------------------------------------------------------------------- Revisions : 1-- Revision Number : 1-- Version : 1.1-- Date : 21/11/2002-- Modifier : Marcus Vinicius Lima e Machado ([email protected])-- Paulo Roberto Santana Oliveira Filho ([email protected])

A B

S

ZN

OEQ

LTGT

ALU

32 32

32

-- Viviane Cristina Oliveira Aureliano ([email protected])-- Description :--------------------------------------------------------------------------------

-- Short name: ulaentity Ula32 is

port ( A : in bit_vector (31 downto 0); -- Operando A da

ULAB : in bit_vector (31 downto 0); -- Operando B da

ULASeletor : in bit_vector(2 downto 0); -- Seletor da operação da ULAS : out bit_vector (31 downto 0); -- Resultado da

operação (SOMA, SUB, AND, NOT, INCREMENTO, XOR) Overflow : out bit;

-- Sinaliza overflow aritméticoNegativo : out bit;

-- Sinaliza valor negativoz : out bit;

-- Sinaliza quando S for zeroIgual : out bit;

-- Sinaliza se A=BMaior : out bit;

-- Sinaliza se A>BMenor : out bit

-- Sinaliza se A<B);

end Ula32;

-- Simulationarchitecture behavioral of Ula32 is

signal s_temp : bit_vector(31 downto 0);-- Sinal que recebe valor temporário da operação realizada signal soma_temp : bit_vector(31 downto 0); -- Sinal que recebe o valor temporario da soma, subtração ou incremento

signal carry_temp : bit_vector (31 downto 0); -- Vetor para auxílio no cálculo das operações e do overflow aritmético

signal novo_B : bit_vector (31 downto 0); -- Vetor que fornece o operando B, 1 ou not(B) para operações de soma, incremento ou subtração respectivamente

signal i_temp : bit_vector(31 downto 0); -- Vetor para calculo de incremento

signal igual_temp : bit;-- Bit que armazena instancia temporária de igualdade

signal overflow_temp: bit;-- Bit que armazena valor temporário do overflow

begin

with Seletor select

s_temp <= A when "000", -- LOAD soma_temp when "001", -- SOMA soma_temp when "010", -- SUB (A and B) when "011", -- AND (A xor B) when "110", -- A XOR B

not(A) when "101", -- NOT A soma_temp when "100", -- INCREMENTO

"00000000000000000000000000000000" when others; -- NAO DEFINIDO

S <= s_temp;

Negativo <= s_temp(31);

i_temp <= "00000000000000000000000000000001";

z <= '1' when s_temp = "00000000000000000000000000000000" else '0';

---------------------------------------------------------------------------------- Regiao que calcula a soma, subtracao e incremento

----------------------------------------------------------------------------------

with Seletor select

novo_B <= B when "001", -- Soma

i_temp when "100", -- Incremento not(B) when others; -- Subtracao e outros

soma_temp(0) <= A(0) xor novo_B(0) xor seletor(1);

soma_temp(1) <= A(1) xor novo_B(1) xor carry_temp(0);soma_temp(2) <= A(2) xor novo_B(2) xor carry_temp(1);soma_temp(3) <= A(3) xor novo_B(3) xor carry_temp(2);soma_temp(4) <= A(4) xor novo_B(4) xor carry_temp(3);soma_temp(5) <= A(5) xor novo_B(5) xor carry_temp(4);soma_temp(6) <= A(6) xor novo_B(6) xor carry_temp(5);soma_temp(7) <= A(7) xor novo_B(7) xor carry_temp(6);soma_temp(8) <= A(8) xor novo_B(8) xor carry_temp(7);soma_temp(9) <= A(9) xor novo_B(9) xor carry_temp(8);soma_temp(10) <= A(10) xor novo_B(10) xor carry_temp(9);soma_temp(11) <= A(11) xor novo_B(11) xor carry_temp(10);soma_temp(12) <= A(12) xor novo_B(12) xor carry_temp(11);soma_temp(13) <= A(13) xor novo_B(13) xor carry_temp(12);soma_temp(14) <= A(14) xor novo_B(14) xor carry_temp(13);soma_temp(15) <= A(15) xor novo_B(15) xor carry_temp(14);soma_temp(16) <= A(16) xor novo_B(16) xor carry_temp(15);soma_temp(17) <= A(17) xor novo_B(17) xor carry_temp(16);soma_temp(18) <= A(18) xor novo_B(18) xor carry_temp(17);soma_temp(19) <= A(19) xor novo_B(19) xor carry_temp(18);soma_temp(20) <= A(20) xor novo_B(20) xor carry_temp(19);soma_temp(21) <= A(21) xor novo_B(21) xor carry_temp(20);soma_temp(22) <= A(22) xor novo_B(22) xor carry_temp(21);soma_temp(23) <= A(23) xor novo_B(23) xor carry_temp(22);soma_temp(24) <= A(24) xor novo_B(24) xor carry_temp(23);soma_temp(25) <= A(25) xor novo_B(25) xor carry_temp(24);soma_temp(26) <= A(26) xor novo_B(26) xor carry_temp(25);soma_temp(27) <= A(27) xor novo_B(27) xor carry_temp(26);soma_temp(28) <= A(28) xor novo_B(28) xor carry_temp(27);soma_temp(29) <= A(29) xor novo_B(29) xor carry_temp(28);soma_temp(30) <= A(30) xor novo_B(30) xor carry_temp(29);soma_temp(31) <= A(31) xor novo_B(31) xor carry_temp(30);

carry_temp(0) <= (seletor(1) and (A(0) or novo_B(0))) or (A(0) and novo_B(0));

carry_temp(1) <= (carry_temp(0) and (A(1) or novo_B(1))) or (A(1) and novo_B(1));































overflow_temp <= carry_temp(31) xor carry_temp(30);

Overflow <= overflow_temp;

---------------------------------------------------------------------------------- Regiao que calcula a comparação

----------------------------------------------------------------------------------

-- No codigo da comparacao (110) sera executada a subtracao na parte relativa

-- ao calculo da SOMA, SUBTRACAO e INCREMENTO.

igual_temp <= not(overflow_temp) when soma_temp = "00000000000000000000000000000000"

else '0'; -- Quando subtracao e zero

Igual <= igual_temp;

-- Se nao teve overflow -> resultado baseado no bit mais significativo de A - B.-- Se teve overflow -> A e B possuem, necessariamente, sinais contrarios. Resultado -- baseado no bit mais significativo de A.-- Devemos tambem checar se A e B nao sao iguais

Maior <= ( (not(soma_temp(31)) and (not(overflow_temp)) )or (overflow_temp and (not(A(31))))) and (not(igual_temp));

-- Se nao teve overflow -> resultado baseado no bit mais significativo de A - B.-- Se teve overflow -> A e B possuem, necessariamente, sinais contrarios. Resultado -- baseado no bit mais significativo de A.

Menor <= ((soma_temp(31) and (not(overflow_temp))) or (overflow_temp and A(31)));

end behavioral;

Código 4.5 Comportamental VHDL da Unidade Lógica e Aritmética

4.1.6 Registrador comum de dados, 32 bits

Componente básico da arquitetura de qualquer computador, um registrador é um conjunto seqüencial de células de memória, conhecidas amplamente no domínio de desenvolvimento de sistemas digitais pelos termos ingleses latches e flip-flops. Conforme já explicado, por definição, no MIPS, todos os registradores de uso interno são componentes capazes de armazenar 32 bits de informação. Para armazenar instruções e dados, bem como o endereço de instruções, serão utilizados esses componentes.

Figura 2.7 Registrador de dados, 32 bits.

O código VHDL para o componente registrador é simples. Encontra-se apresentado abaixo.O registardor é peça fundamental de um processador e como tal é utilizado em várias vezes na nossa implementação.Utilizamos este componente da seguinte forma:Para armazenar a saída da ULA;Para armazenar os sinais HI e LO.Para armazenar os conteúdos que vem do banco de registradores em A e B no caso;Para guardar o PC.Para guardar o conteúdo que sai de MDR.Para guardar o PC atual em EPC.

---------------------------------------------------------------------------------- Title : Registrador de Uso Geral-- Project : CPU Multi-ciclo---------------------------------------------------------------------------------- File : Registrador.vhd-- Author : Emannuel Gomes Macêdo ([email protected])-- Fernando Raposo Camara da Silva ([email protected])-- Pedro Machado Manhães de Castro ([email protected])-- Rodrigo Alves Costa ([email protected])-- Organization : Universidade Federal de Pernambuco-- Created : 11/07/2002-- Last update : 21/11/2002-- Plataform : Flex10K-- Simulators : Altera Max+plus II-- Synthesizers : -- Targets : -- Dependency : ---------------------------------------------------------------------------------- Description : Entidade que representa a unidade básica de uma cpu ou um-- circuito que armazena dados na forma de bits.

---------------------------------------------------------------------------------- Copyright (c) notice-- Universidade Federal de Pernambuco (UFPE).-- CIn - Centro de Informatica.-- Developed by computer science undergraduate students.-- This code may be used for educational and non-educational purposes as -- long as its copyright notice remains unchanged. ---------------------------------------------------------------------------------- Revisions : 1-- Revision Number : 1.0-- Version : 1.1-- Date : 21/11/2002-- Modifier : Marcus Vinicius Lima e Machado ([email protected])-- Paulo Roberto Santana Oliveira Filho ([email protected])-- Viviane Cristina Oliveira Aureliano ([email protected])-- Description :--------------------------------------------------------------------------------

--Short name: regENTITY Registrador IS

PORT(Clk : IN bit;

-- Clock do registradorReset : IN bit;

-- Reinicializa o conteudo do registradorLoad : IN bit;

-- Carrega o registrador com o vetor EntradaEntrada : IN bit_vector (31 downto 0);

-- Vetor de bits que possui a informação a ser carregada no registradorSaida : OUT bit_vector (31 downto 0)

-- Vetor de bits que possui a informação já carregada no registrador);

END Registrador;

-- Arquitetura que define comportamento do Registrador-- SimulationARCHITECTURE behavioral_arch OF Registrador IS

begin-- Clocked process

process (Clk, Reset)begin

------------------------------------------- Reset inicializa o registrador comumif(Reset = '1') then

Saida <= "00000000000000000000000000000000";

------------------------------------------- Início do processo relacionado ao clock elsif (Clk = '1' and clk'event) then

if (Load = '1') thenSaida <= Entrada;

end if;end if;

------------------------------------------- Fim do processo relacionado ao clock end process;------------------------------------------- Fim da ArquiteturaEND behavioral_arch;

Código 4.6 Descrição comportamental VHDL do Registador 32 bits.

4.2 Módulos Desenvolvidos

Durante a análise do fluxo de execução das instruções implementadas pela estrutura fornecida, desenrolou-se um processo de compreensão profunda do sistema proposto a desenvolvimento. Visando à implementação de uma unidade de

processamento capaz de implementar o repertório exigido, a equipe de desenvolvimento produziu módulos, componentes específicos e exclusivos e os alocou convenientemente à unidade parcial em mãos. Segue-se a descrição pormenorizada dos blocos internos desenvolvidos a que se faz referência.

4.2.1 RegistradorDesl

Entidade responsável pelo envio de um vetor que indica a quantidade de deslocamentos a ser realizada no registrador. Esta entidade possibilita que a quantidade de deslocamentos possíveis pelo registrador seja de até 32 deslocamentos. Pois a quantidade é informada por partes (em até 5 partes) para o registrador.

Entradas:N: vetor de 5 bits que indica a quantidade de deslocamentosShift: vetor de 3 bits que indica a função a ser realizada pelo

registrador.

Abaixo seguem os valores referentes à entrada shift e as respectivas funções do registrador:

Shift FUNÇÃO DO REGISTRADOR 000 faz nada 001 carrega vetor (sem deslocamentos) 010 deslocamento à esquerda n vezes 011 deslocamento à direita lógico n vezes 100 deslocamento à direita aritmético n vezes 101 rotação à direita n vezes 110 rotação à esquerda n vezes

Nesta entidade só é utilizado a entrada 001 do Shift para verificar se foi introduzido alguma nova entrada no módulo a fim de zerar todos os sinais desta entidade.

Segue a descrição em VHDL do componente. ---------------------------------------------------------------------------------- Title : Registrador de Deslocamento-- Project : CPU Multi-ciclo---------------------------------------------------------------------------------- File : RegDesloc.vhd-- Author : Emannuel Gomes Macêdo <[email protected]>-- Fernando Raposo Camara da Silva <[email protected]>-- Pedro Machado Manhães de Castro <[email protected]>-- Rodrigo Alves Costa <[email protected]>-- Organization : Universidade Federal de Pernambuco-- Created : 10/07/2002-- Last update : 26/11/2002-- Plataform : Flex10K-- Simulators : Altera Max+plus II-- Synthesizers : -- Targets : -- Dependency : ---------------------------------------------------------------------------------- Description : Entidade responsável pelo deslocamento de um vetor de 32 -- bits para a direita e para a esquerda. -- Entradas:-- * N: vetor de 3 bits que indica a quantidade de -- deslocamentos

-- * Shift: vetor de 3 bits que indica a função a ser -- realizada pelo registrador -- Abaixo seguem os valores referentes à entrada shift e as -- respectivas funções do registrador: -- -- Shift FUNÇÃO DO REGISTRADOR-- 000 faz nada-- 001 carrega vetor (sem deslocamentos)-- 010 deslocamento à esquerda n vezes-- 011 deslocamento à direita lógico n vezes-- 100 deslocamento à direita aritmético n vezes-- 101 rotação à direita n vezes-- 110 rotação à esquerda n vezes---------------------------------------------------------------------------------- Copyright (c) notice-- Universidade Federal de Pernambuco (UFPE).-- CIn - Centro de Informatica.-- Developed by computer science undergraduate students.-- This code may be used for educational and non-educational purposes as -- long as its copyright notice remains unchanged. ---------------------------------------------------------------------------------- Revisions : 2-- Revision Number : 2.0-- Version : 1.2-- Date : 26/11/2002-- Modifier : Marcus Vinicius Lima e Machado <[email protected]>-- Paulo Roberto Santana Oliveira Filho <[email protected]>-- Viviane Cristina Oliveira Aureliano <[email protected]>-- Description :--------------------------------------------------------------------------------

-- Short name: deslENTITY RegDesloc IS

PORT(Clk : IN bit; -- Clock do sistema





);END RegDesloc;

-- Arquitetura que define o comportamento do registrador de deslocamento-- SimulationARCHITECTURE behavioral_arch OF RegDesloc IS

signal temp : bit_vector (31 downto 0); -- Vetor temporário

begin

-- Clocked processprocess (Clk, Reset)

beginif(Reset = '1') then

temp <= "00000000000000000000000000000000";

elsif (Clk = '1' and Clk'event) thencase Shift is

when "000" => -- Faz nada


-- Carrega vetor de entrada, não faz deslocamentostemp <= Entrada;

when "010" =>-- Deslocamento à esquerda N vezes

case N iswhen "000" =>

-- Deslocamento à esquerda nenhuma veztemp <= temp;

when "001" => -- Deslocamento à esquerda 1 vez

temp(0) <= '0';temp(31 downto 1) <= temp(30

downto 0);when "010" => --

Deslocamento à esquerda 2 vezestemp(1 downto 0) <= "00";temp(31 downto 2) <= temp(29

downto 0);when "011" => --


downto 0);when "100" => --


downto 0);when "101" => --


downto 0);when "110" => --


downto 0);when "111" => --


downto 0);end case;

-- Deslocamento à direita lógico N vezeswhen "011" =>


-- Deslocamento à direita lógico nenhuma veztemp <= temp;

when "001" =>-- Deslocamento à direita lógico 1 vez


temp(31) <= '0';when "010" =>





temp(31 downto 29) <= "000";



temp(31 downto 28) <= "0000";when "101" =>





temp(31 downto 26) <= "000000";when "111" =>


downto 7);temp(31 downto 25) <=

"0000000";end case;

-- Deslocamento à direita aritmético N vezeswhen "100" =>


-- Deslocamento à direita aritmético nenhuma veztemp <= temp;



temp(31) <= temp(31);when "010" =>

-- Deslocamento à direita aritmético 2 vezestemp(29 downto 0) <= temp(31

downto 2);temp(30) <= temp(31);temp(31) <= temp(31);






temp(28) <= temp(31);temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);



temp(27) <= temp(31);temp(28) <= temp(31);temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);







temp(25) <= temp(31);temp(26) <= temp(31);temp(27) <= temp(31);temp(28) <= temp(31);temp(29) <= temp(31);temp(30) <= temp(31);temp(31) <= temp(31);

end case;

-- Rotação à direita N vezeswhen "101" =>


-- Rotação à direita nenhuma veztemp <= temp;

when "001" =>-- Rotação à direita 1 vez


temp(31) <= temp(0);when "010" =>


















downto 0);end case;

-- Rotação à esquerda N vezeswhen "110" =>


-- Rotação à esquerda nenhuma veztemp <= temp;

when "001" =>-- Rotação à esquerda 1 vez

temp(0) <= temp(31);temp(31 downto 1) <= temp(30



















downto 0);end case;

-- Funcionalidade não definidawhen others =>-- Faz nada

end case;end if;Saida <= temp;

end process;END behavioral_arch;

Código 4.7 Descrição comportamental VHDL do RegistradorDesl.

4.2.2 ShiftLeft26

Faz um mero deslocamento da entrada (26 bits) para a esquerda em 2 bits, resultando em uma saída de 28 bitsENTITY shiftleft26 IS

PORT (

ENT : IN bit_vector(25 downto 0);SAI : OUT bit_vector(27 downto 0)

);END shiftleft26;

ARCHITECTURE deslocamento OF shiftleft26 IS

begin

SAI(27 downto 2) <= ENT(25 downto 0);SAI(1 downto 0) <= "00";

END deslocamento;

Código 4.8 Descrição comportamental VHDL do Shift_Left26.

4.2.3 ShiftLeft2_32bits

Faz um mero deslocamento da entrada (32 bits) para a esquerda em 2 bits, resultando em uma saída de 32 bits e coloca zero nos dois bits menos significativos.

entity Desl2vezes32 isport(

Entrada : in bit_vector (31 downto 0);Saida : out bit_vector (31 downto 0));

end Desl2vezes32;

architecture behavioral of Desl2vezes32 is

signal saida_temp : bit_vector(31 downto 0);

beginsaida_temp(0) <= '0';saida_temp(1) <= '0';saida_temp(31 downto 2) <= Entrada(29 downto 0);

Saida <= saida_temp;end behavioral;

Código 4.9 Descrição comportamental VHDL do Desl2vezes32.

4.2.4 ExtendLUI

Um simples extensor de 16 para 32 bits, cujo comportamento é descrito abaixo,sendo que a parte mais a direita nesse caso é completada com zero.

entity ExtensorLUI isport(

Entrada : in bit_vector (15 downto 0);Saida : out bit_vector (31 downto 0)

);end ExtensorLUI;

architecture behavioral of ExtensorLUI is

signal saida_temp : bit_vector(31 downto 0);

beginsaida_temp(31 downto 16) <= Entrada;

saida_temp(15 downto 0) <= "0000000000000000";

Saida <= saida_temp;end behavioral;

Código 4.10 Descrição comportamental VHDL do ExtendLUI.

4.2.5 SignExtend

Um simples extensor de 16 para 32 bits, cujo comportamento é descrito abaixo.

ENTITY signExtend IS

PORT(entrada : IN bit_vector(15 downto 0); Contr : IN bit; saida : OUT bit_vector(31 downto 0)

);END signExtend;

ARCHITECTURE extend OF signExtend IS

signal temp : bit_vector (31 downto 0);

beginprocess(Contr)

begincase Contr is

when '0' =>if(entrada(15)='1') then

temp(31 downto 16) <= "1111111111111111";temp(15 downto 0) <= entrada;

elsetemp(31 downto 16) <= "0000000000000000";temp(15 downto 0) <= entrada;

end if;when '1' =>

temp(31 downto 16) <= entrada;temp(15 downto 0) <= "0000000000000000";

end case;saida <= temp;

end process;END extend;

Código 4.11 Descrição comportamental VHDL do SignExtend.

4.2.9 StoresBH

Concatena dados de um registrador a dados advindos da memória, de acordo com a seleção feita pela Unidade de Controle.

ENTITY StoreBH IS

PORT(storeControl : IN bit;Reg : IN bit_VECTOR(31 downto 0);Memo : IN bit_VECTOR(31 downto 0);Saida : OUT bit_VECTOR(31 downto 0));

END StoreBH;

ARCHITECTURE behavioral OF StoreBH IS

BEGIN process(storeControl)

begin

if(storecontrol = '0') thensaida(31 downto 24) <= Reg(7 downto 0);saida(23 downto 0) <= Memo(23 downto 0);

elsesaida(31 downto 16) <= Reg(15 downto 0);saida(15 downto 0) <= Memo(15 downto 0);

end if;

end process;END behavioral;

Código 4.12 Descrição comportamental VHDL do StoresBH.

4.2.10 Multiplicador/Divisor

Descrição do componente responsável pela Multiplicação e Divisão no Projeto.

Considerações iniciais:

Foram implementadas ambas as operações num mesmo componente. Utilizamos também o clock para a execução do algorítmo. Para implementar os algoritmos utilizamos uma máquina de estados interna ao componente com três estados que chamanos de: inicio,meio e fim.

Entradas e saídas do componente:

O componente MultDiv foi implementado com as seguintes entradas: ”LoadDivMult” que é um sinal de um bit ,“EntradaA”,”entradaB” que são vetores de 32 bits, o “clock” e “reset” que são sinais de um bit.E com as seguintes saídas: o “saidaCont” que é um sinal de um bit, “saidaHi” e “saidaLo” que são vetores de 32 bits e o sinal de erro.No caso de o “reset” estar acionado, no caso de ambas as operações leva para o estado “inicio” e atribui (zero) ao sinal “SaidaCont”. O sinal de

erro será acionado caso o vetor EntradaB for igual zero o que indica que houve uma operação inválida e que deverá ser tratada ou seja, ocorreu uma exceção.

Vejamos os aspectos da implementação do multiplicador em separado:

Quando o sinal LoadDivMult que vem da Unidade de Controle é ‘0’ indica que a operação a ser realizada é a multiplicação.

Detalhes sobre a implementação do algorítmo de Booth para a divisão:

Inicialmente, carreamos a entradaA num vetor temporário e que representa o multiplicando e a entradaB na parte mais a direita do vetor temporário que representa o produto e que é de 64 bits.Feito isso devemos guardar dois bits que serão uma espécie de flags para que operação realizada no algorítmo essa flag é formada pelo bit(LSB) do registrador produto e um bit que chamamos de fictício e que será inicializado com zero.

Dependendo dessa flag o algorítmo deve fazer as seguintes operações:

00: Nenhuma operação;01: Some o multiplicando a metade a esquerda do produto;10: Subtaria o multiplicando da metade a esquerda do produto;11: Nenhuma operação;

No final de cada iteração no loop deve-se deslocar o produto um bit a direita de acordo com o algorítmo.

Observação:

Como o algorítmo de Booth já trata os sinais não devemos fazer nenhuma implementação extra para o mesmo o que não acontece com a divisão.

Vejamos agora os detalhes sobre a implementação da divisão:

Inicialmente os vetores EntradaA e entradaB são carregados nos vetores temporários que representam dividendo e divisor respectivamente e que vem do conteúdo dos registradores especificados na instrução.Inicialmente analisamos o valor do bit mais significativo das entradas se for zero, significa que o vetor representa um número positivo e o algorítmo prossegue normalmente mais se for “um” haverá uma mudança de sinal que será tratada no final do algorítmo.

A parte mais a esquerda do vetor resto é carregada com zero.

Passada essa parte o algorítmo prossegue para o estado “meio” que é onde o algorítmo da divisão é implementada de fato:

O primeiro passo é deslocar o vetor temporário que representa o resto um bit à esquerda,o segundo passo é subtrair o conteúdo do registrador divisor do conteúdo da metade esquerda do registrador resto(temporário) e colocar o resultado na metade esquerda do registrador resto esse passo deve ser executado no início de cada iteração.

Feito isso deve-se verificar o valor do bit mais significativo do vetor resto.Caso seja 1 deve-se restaurar o valor inicial somando o conteúdo do registrador divisor ao conteúdo mais a esquerda do resgistrador resto e colocar o resultado na parte mais a esquerda do registrador resto e ainda deslocar um bit a esquerda o registrador resto colocando zero no bit menos significativo e subtrair a parte mais a esquerda do resto do valor do divisor. Caso seja zero, deve-se deslocar o registrador resto um bit a esquerda colocando 1 no novo bit mais a direita.Voltando para o laço até que a operação seja concluída.

Tratamento de sinais:

No estado “fim” caso não tenha havido nenhuma exceção deve-se fazer o tratamento dos sinais de acordo com os valores sigA e sigB obtidos no início durante o carregamento das entradas.Ainda no estado “fim” deve-se carregar os valores do quociente e o resto da divisão calculados nos registradores Hi e Lo.O sinal de erro é enviado para a unidade de controle caso tenha havido uma exceção e o sinal saidaCont indica o fim da operação.

Veja a seguir como ficou o código de implementação:

LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.ALL;USE IEEE.STD_LOGIC_arith.ALL;USE IEEE.STD_LOGIC_unsigned.ALL;

entity MultDivs is port(

LoadDivMult : in std_logic; --bit q vem da unidade de controle, indica a funcao

entradaA : in std_logic_vector (31 downto 0); --dividendo/multiplicando entradaB : in std_logic_vector (31 downto 0); --divisor/multiplicadorclock : in std_logic;reset : in std_logic;saidaCont : out std_logic; -- saida para a unidade de controlesaidaHi : out std_logic_vector (31 downto 0); --quociente/parte do

produtosaidaLo : out std_logic_vector (31 downto 0); --resto/outra parte do

produtoerro : out std_logic

);

end MultDivs;

ARCHITECTURE arqmultdivs OF MultDivs IS

type Tstate is (inicio, meio, fim); signal state : Tstate;signal temp : std_logic_vector (63 downto 0); -- Vetor temporáriosignal ficticio : std_logic;--signalsignal temp2 : std_logic_vector (31 downto 0);signal erroAux : std_logic;signal sigA : std_logic;signal sigB : std_logic;

begin

process(clock, reset)variable count : std_logic_vector(5 downto 0);begin

if(reset = '1') thenstate <= inicio;saidaCont <= '0';

elsif (clock'EVENT and clock = '1') then

if(LoadDivMult = '0') thencase state is

when inicio => temp2 <= entradaA;temp(31 downto 0) <= entradaB;

temp(63 downto 32) <= "00000000000000000000000000000000";ficticio <= '0';saidaCont <= '0'; count := "100000";state <= meio;

when meio =>if (count = "000000") then

state <= fim;--temp(62 downto 0) <= temp(63 downto 1);

else count := count - "000001";

if(temp(0) = '0')thenif(ficticio = '1')then

temp(63 downto 32) <= temp2 + temp(63 downto 32);end if;

else if(ficticio = '0')then

temp(63 downto 32) <= temp(63 downto 32) - temp2;end if;

end if;

-- deslocamentoo à direita aritméticoficticio <= temp (0);temp(62 downto 0) <= temp(63 downto 1);

end if;

when fim =>

saidaHi <= temp(63 downto 32);saidaLo <= temp(31 downto 0);saidaCont <= '1';

end case;

else -- DIVISAO

case state is

when inicio =>sigA <= entradaA(31);sigB <= entradaB(31);

if(sigA = '0')thentemp(31 downto 0) <= entradaA;

elsetemp(31 downto 0) <= "00000000000000000000000000000000" - entradaA;

end if;

temp(63 downto 32) <= "00000000000000000000000000000000";

if(sigB = '0')thentemp2 <= entradaB;

elsetemp(31 downto 0) <= "00000000000000000000000000000000" - entradaB;

end if;

count := "100000";saidaCont <= '0';-- deslocamentotemp(63 downto 1) <= temp(62 downto 0);temp(0) <= '0';if(temp2 = "00000000000000000000000000000000")then

state <= fim;erroAux <= '1';

elsestate <= inicio;erroAux <= '0';

end if; when meio =>

if (count = "000000") thentemp(62 downto 32) <= temp(63 downto 33);

temp(63) <= '0';state <= fim;

else temp(63 downto 32) <= temp(63 downto 32) - temp2;

if(temp(63) = '0')thentemp(62 downto 0) <= temp(63 downto 1);temp(0) <= '1';

elsetemp(63 downto 32) <= temp(63 downto 32) + temp2;temp(62 downto 0) <= temp(63 downto 1);temp(0) <= '0';

end if;count := count - "000001";

end if;

when fim =>

if (erroAux /= '1') then

if(sigA = '1')thentemp(63 downto 32) <= "00000000000000000000000000000000" - temp(63

downto 32);if(sigB = '0')then

temp(31 downto 0) <= "00000000000000000000000000000000" - temp(31 downto 0);

end if;else

if(sigB = '1')thentemp(31 downto 0) <= "00000000000000000000000000000000" -

temp(31 downto 0);end if;

end if;erro <= erroAux;saidaHi <= temp(31 downto 0);saidaLo <= temp(63 downto 32);

end if;

saidaCont <= '1';

end case;

end if;

end if;

end process;

end arqmultdivs;

Código 4.13 Descrição comportamental VHDL do Multiplicador/Divisor

4.3 Módulos Auxiliares

Os componentes de multiplexação a seguir apresentados representam uma camada auxiliar no desenvolvimento da arquitetura do MIPS, haja vista serem criados dinamicamente, ou seja, a depender das necessidades que surgiam no projeto,cabendo ao projetista definir o número de entradas que o componente vai multiplexar.

Situados convenientemente no mapeamento da Unidade de Processamento, multiplexadores são dispositivos digitais simples, implementados em Lógica Combinacional. Apesar de simples em conceito e implementação, são elementos imprescindíveis para a estruturação de trabalhos complexos em Circuitos Digitais.

O desenvovimento dos referidos componentes deu-se, assim como o restante do projeto, em VHDL, os quais são apresentados a seguir:

4.3.1 mux21

Multiplexador para escolher 1 saída dentre 2 entradas (32 bits).Esse tipo de mux é utilizado no projeto para selecionar a entrada no registrador HI e LO que no caso pode vir ou do registrador B ou da saída do multiplicador/divisor; para selecionar o conteudo a ser escrito na memória(Store_out ou B);E ainda para selecionar se a instrução deslocamento está sendo iniciada ou não.

O código VHDL do Mux2 é apresentado a seguir.-- File : mux2.vhd---------------------------------------------------------------------------------- Description : Multiplexador que escolhe entre 2 vetores de 32 bits--------------------------------------------------------------------------------

ENTITY mux21 IS

PORT(sel : IN bit;Entrada1 : IN bit_VECTOR(31 downto 0);Entrada2 : IN bit_VECTOR(31 downto 0);Saida : OUT bit_VECTOR(31 downto 0));

END mux21;

ARCHITECTURE behavioral OF mux21 IS

BEGIN process(sel)

begin

If(sel='0') thenSaida <= Entrada1;

elseSaida <= Entrada2;

end if; end process;END behavioral;

Código 4.16 Descrição comportamental VHDL do Mux2.

4.3.2 mux2_1Cond

Multiplexador para escolher 1 saída dentre 2 entradas (1 bit).Esse mux foi utilizado para selecionar qual o tipo de desvio condicional(Bne ou Beq).


ENTITY mux21Cond IS

PORT(sel : IN bit;Entrada1 : IN bit;Entrada2 : IN bit;Saida : OUT bit);

END mux21Cond;

ARCHITECTURE behavioral OF mux21Cond IS

BEGIN process(sel) begin





4.3.3 mux21_Ndesl

Multiplexador para escolher 1 saída dentre 2 entradas (3 bits).Esse mux foi utilizado para selecionar de onde vem o sinal que indica o número de deslocamentos a ser realizados no atual ciclo de clock.

O código VHDL do Mux21_Ndesl é apresentado a seguir.

-- File : Mux21_Ndesl.vhd---------------------------------------------------------------------------------- Description : Multiplexador que escolhe entre 2 vetores de 3 bits--------------------------------------------------------------------------------

ENTITY mux21_Ndesl IS


END mux21_Ndesl;

ARCHITECTURE behavioral OF mux21_Ndesl IS

BEGIN process(sel) begin




Código 4.15 Descrição comportamental VHDL do Mux2_Ndesl.

4.3.4 mux21Ext8

Multiplexador para escolher 1 saída(mux21Ext8_out) dentre 4 entradas (8 bits): MDR_out(7 downto 0); B_out(7 downto 0).

ENTITY mux21Ext8 IS

PORT( sel : IN bit; Entrada1 : IN bit_VECTOR(7 downto 0); Entrada2 : IN bit_VECTOR(7 downto 0); Saida : OUT bit_VECTOR(7 downto 0)

);

END mux21Ext8;

ARCHITECTURE behavioral OF mux21Ext8 IS

BEGIN process(sel) begin If(sel='0') then Saida <= Entrada1; else Saida <= Entrada2; end if; end process;END behavioral;

Código 4.xx Descrição comportamental VHDL do mux21Ext8.

4.3.5 mux41

Multiplexador para escolher 1 saída dentre 4 entradas (32 bits).Esse tipo de mux foi utilizado no nosso projeto para selecionar o endereço da rotinna de tratamento (entradas: 253,254,255,ground) no caso de ser gerada uma exceção(muxErro_out);Para selecionar de onde vem a entrada(ULA_out,pc_out,MuxErro_out) de endereço de memória(MuxPosPc_out); e também para selecionar a entrada(pc_out,Ext5_out,A_out,ULA_out) do primeiro operando da ULA(muxPosA_out).


ENTITY mux41 IS

PORT(sel : IN bit_vector(1 downto 0);Entrada1 : IN bit_VECTOR(31 downto 0);Entrada2 : IN bit_VECTOR(31 downto 0);Entrada3 : IN bit_VECTOR(31 downto 0);Entrada4 : IN bit_VECTOR(31 downto 0);Saida : OUT bit_VECTOR(31 downto 0));

END mux41;


BEGIN

process(sel) begin

If(sel="00") thenSaida <= Entrada1;

elsif(sel="01") thenSaida <= Entrada2;



end if;



4.3.6 mux41_RegWrite

Multiplexador para escolher 1 saída dentre 4 entradas (5 bits).Esse mux vai escolher o registrador a ser escrito no banco de registradores.

O código VHDL do Mux4_5bits é apresentado a seguir.

-- File : mux41_5bits.vhd---------------------------------------------------------------------------------- Description : Multiplexador que escolhe entre 4 vetores de 5 bits--------------------------------------------------------------------------------

ENTITY mux41_regWrite IS


END mux41_regWrite;

ARCHITECTURE behavioral OF mux41_regWrite IS

BEGIN

process(sel) begin





end if;


Código 4.19 Descrição comportamental VHDL do Mux4RegWrite.

4.3.7 mux41Ext16

Multiplexador para escolher 1 saída(mux41Ext16_out) dentre 4 entradas (16 bits): B_out(15 downto 0); Ext8_out(15 downto 0); IR150_out(15 downto 0); MDR_out(15 downto 0).

O código VHDL do Mux4_16bits é apresentado a seguir.-- File : mux4_5bits.vhd---------------------------------------------------------------------------------- Description : Multiplexador que escolhe entre 4 vetores de 16 bits--------------------------------------------------------------------------------

ENTITY mux41Ext16 IS


END mux41Ext16;

ARCHITECTURE behavioral OF mux41Ext16 IS

BEGIN

process(sel) begin





end if;


Código 4.17 Descrição comportamental VHDL do Mux4_16bits.

4.3.8 mux81

Multiplexador para escolher 1 saída dentre 8 entradas (32 bits).O código VHDL do Mux8 é apresentado a seguir.Esse tipo de mux foi utilizado

para selecionar(entradas: S_ULA, Ula_out, desl2vezes26_out, EPC_out, A_out, memo_out, ground ) qual será o novo PC(MuxPrePc_out); para selecionar(B_out, 4, Ext16_out, Ext16_desl_2_out, 0 , 7 , ground , ground ) o conteúdo do segundo operando quen entra na ULA; e para selecionar ( selMuxReset_out, regDesl_out, RegHi_out, RegLo_out, Ext16_out, Pc_out, MDR_out, ULA_out) de onde vem o conteúdo que vai ser escrito no registrador indicado pelo muxRegWrite_out.

-- File : mux81.vhd---------------------------------------------------------------------------------- Description : Multiplexador que escolhe entre 8 vetores de 32 bits--------------------------------------------------------------------------------

ENTITY mux81 IS

PORT(sel : IN bit_vector(2 downto 0);Entrada1 : IN bit_VECTOR(31 downto 0);Entrada2 : IN bit_VECTOR(31 downto 0);Entrada3 : IN bit_VECTOR(31 downto 0);Entrada4 : IN bit_VECTOR(31 downto 0);Entrada5 : IN bit_VECTOR(31 downto 0);Entrada6 : IN bit_VECTOR(31 downto 0);Entrada7 : IN bit_VECTOR(31 downto 0);Entrada8 : IN bit_VECTOR(31 downto 0);Saida : OUT bit_VECTOR(31 downto 0));

END mux81;


BEGIN

process(sel) begin









end if;

end process;

END behavioral;


4.4 Mapeamento da Unidade de Processamento

As seções anteriores apresentaram a descrição geral dos componentes utilizados para a construção da Unidade de Processamento da CPU em desenvolvimento,descreendo seu comportamento interno. A seção que aqui se inicia, por sua vez, terá a finalidade de apresentar o resultado final desta fase do projeto, colocando à disposição do leitor o material da implementação da estrutura apresentada, o código VHDL da unidade de processamento (referenciada pelo termo Datapath, na codificação colocada).

4.4.1 Codificação do Mapeamento da CPU

Segue o mapeamento completo da CPU incluindo controle e processamento. Como explicado, fazemos as ligações entre o controle, os demais módulos e entre estes, tendo os sinais da unidade de controle como input/output.

ENTITY CPU ISPORT

(CPUClock :IN bit;CPUReset :IN bit;Instr150 :OUT bit_vector(15 downto 0);-- teste...Dado_out :OUT bit_vector(31 downto 0);Reg_out :OUT bit_vector(4 downto 0);LoadBR_out :OUT bit;SelMuxRegWrite_out : out bit_vector(1 downto 0);PC_teste :OUT bit_vector(31 downto 0);PC_esc_out :OUT bit;LoadPC_out :OUT bit;Aout :OUT bit_vector(31 downto 0);Bout :OUT bit_vector(31 downto 0);ALUout : OUT bit_vector(31 downto 0);MDRout :OUT bit_vector(31 downto 0);SelMuxDataWriteOut : OUT bit_vector(2 downto 0); SelMuxWriteMemoOut : OUT bit;SelMuxPrePCOut : OUT bit_vector(2 downto 0);SelMuxPosPCOut : OUT bit_vector(1 downto 0);SelMuxResetOut : OUT bit_vector(1 downto 0);SelMuxExt16Out : OUT bit_vector(1 downto 0); SelMuxExt8Out : OUT bit;SelMuxPosAOut : OUT bit_vector(1 downto 0);SelMuxPosBOut : OUT bit_vector(2 downto 0);StoreControlout : OUT bit;StoreOut : OUT bit_vector(31 downto 0);LoadMemoriaOut : OUT bit;OpULAOut : OUT bit_vector(2 downto 0);WriteMemo : OUT bit_vector(31 downto 0);Memo : OUT bit_vector(31 downto 0);MuxPosPCOut : OUT bit_vector(31 downto 0)

);

END CPU;

ARCHITECTURE CPU_Arch OF CPU IS

--sinais do reset dos componentes--signal ResetPC :bit;signal ResetMDR :bit;signal ResetIR :bit;signal ResetBR :bit;signal ResetA :bit;signal ResetB :bit;signal ResetULAOut :bit;signal ResetHi :bit;signal ResetLo :bit;signal ResetRegDesl :bit;signal ResetEPC :bit;

-- sinais de Load dos componentessignal LoadPC :bit; -- vem da lógica externa (próxima a unidade de controle)signal LoadMemoria :bit;signal LoadIR :bit;signal LoadMultDiv :bit;signal LoadMDR :bit;signal LoadBR :bit;signal LoadULAOUT :bit;signal LoadEPC :bit;signal LoadRegHi :bit;signal LoadRegLo :bit;signal LoadA :bit;signal LoadB :bit;

signal StoreControl :bit;signal RegDeslControl :bit_vector(2 downto 0);

-- seletores dos mux's...signal SelMuxErro :bit_vector(1 downto 0);signal SelMuxPosPC :bit_vector(1 downto 0);signal SelMuxWriteMemo :bit;signal SelMuxRegHi :bit;signal SelMuxRegLo :bit;signal SelMuxExt8 :bit;signal SelMuxRegWrite :bit_vector(1 downto 0);signal SelMuxReset :bit_vector(1 downto 0);signal SelMuxDataWrite :bit_vector(2 downto 0);signal SelMuxExt16 :bit_vector(1 downto 0);signal SelMuxPosA :bit_vector(1 downto 0);signal SelMuxPosB :bit_vector(2 downto 0);signal SelMuxPrePC :bit_vector(2 downto 0);signal SelMuxNDesl :bit;signal SelMuxEDesl :bit;

--sinais que entram na unidade de controle--signal ULAControl_EQ :bit;signal ULAControl_N :bit;signal ULAControl_O :bit;signal ULAControl_Z :bit;signal ULAControl_LT :bit;signal ULAControl_GT :bit;signal SDivControl :bit;signal IR250 :bit_vector(25 downto 0);-- IR3126_OUT-- erro

--sinais que saem do IR--

signal IR150_OUT :bit_vector (15 downto 0);signal IR2016_OUT :bit_vector (4 downto 0);signal IR2521_OUT :bit_vector (4 downto 0);signal IR3126_OUT :bit_vector (5 downto 0);

-- sinais q entram no extensorLui-- ir150_out

-- sinais q saem do extensorLuisignal extlui_OUT :bit_vector (31 downto 0);

-- sinais q entram no muxReset-- extlui_out-- ext1_out-- cte 227

-- sinais q saem o muxreset-- muxreset_out

-- sinais q entram no ext1-- ulacontrol_n

-- sinais q saem do ext1signal ext1_out :bit_vector(31 downto 0);

--sinais que entram no Banco de Registradores---- LoadBR signal MUXRegWrite_out :bit_vector (4 downto 0);signal MUXDataWrite_out :bit_vector (31 downto 0);-- IR2521_out -- IR2016_out

--sinais que entram no registrador A--signal Reg1_OUT :bit_vector (31 downto 0);-- LoadA

--sinais que entram no registrador B--signal Reg2_OUT :bit_vector (31 downto 0);-- LoadB

--sinais que entram no MUX PosA--signal A_OUT :bit_vector (31 downto 0);signal PC_OUT :bit_vector (31 downto 0);signal Ext5_OUT :bit_vector (31 downto 0);signal ULA_OUT :bit_vector (31 downto 0); -- isso é a saída do ALUOUT

--sinais que entram no MUXPosB--signal B_OUT :bit_vector (31 downto 0);-- cte 4

-- cte 0-- cte 7signal Ext16_OUT :bit_vector (31 downto 0);signal Ext16_Desl_2_OUT :bit_vector (31 downto 0);

--sinais que entram na ULA--signal MuxPosA_OUT :bit_vector (31 downto 0);signal MUXPosB_OUT :bit_vector (31 downto 0);signal OpULA :bit_vector (2 downto 0);

--sinais que saem na ULA--signal S_ULA :bit_vector (31 downto 0);-- ULAControl_EQ -- ULAControl_N -- ULAControl_O -- ULAControl_Z -- ULAControl_LT -- ULAControl_GT

-- sinais que entram no MuxPrePc --signal EPC_OUT :bit_vector (31 downto 0);-- Memo_OUT-- A_Out-- Ext16_outsignal Desl2VEZES26_out :bit_vector (31 downto 0);-- ULA_out-- S_ula-- PC_out

--sinais q entram no epc-- pc_OUT-- LoadEPC

-- sinais q entram em pc-- LoadPC signal MuxPrePc_OUT :bit_vector (31 downto 0);

-- sinais q saem de pc-- PC_OUT

-- sinais que entram no MuxPosPC-- PC_OUT-- ULA_OUTsignal MuxErro_OUT :bit_vector (31 downto 0);

-- sinais que saem do MuxPosPCsignal MuxPosPC_OUT :bit_vector (31 downto 0);

-- sinais q entram na memoria-- muxpospc_outsignal MuxWriteMemo_OUT :bit_vector (31 downto 0);

-- sinais q saem da memoriasignal Memo_OUT :bit_vector (31 downto 0);

-- sinais q entram no muxErro-- cte "00000000000000000000000011111101"-- cte "00000000000000000000000011111110"-- cte "00000000000000000000000011111111"

-- sinais q entram no storesignal MDR_OUT :bit_vector (31 downto 0);-- B_OUT

--sinais q saem do storesignal Store_OUT :bit_vector (31 downto 0);

-- sinais q entram em MuxWriteMemo-- B_OUT-- Store_out

--sinais q saem de MuxWriteMemo--MuxWriteMemo_OUT

-- sinais q entram em MultDiv-- A_OUT-- B_OUT-- LoadMultDiv

--sinais q saem de MultDiv-- SDivControlsignal erro :bit;signal SaidaRegHi :bit_vector (31 downto 0);signal SaidaRegLo :bit_vector (31 downto 0);

-- sinais q entram no MuxRegHi-- b_out-- saidaRegHi

-- sinais q entram no MuxRegLo-- b_out-- saidaRegLo

-- sinais q saem do muxRegHisignal RegHiIN :bit_vector (31 downto 0);

-- sinais q saem do muxRegLo

signal RegLoIN :bit_vector (31 downto 0);

-- sinais q entram do RegHi-- RegHiIN

-- sinais q entram do RegLo-- RegLoIN

-- sinais q saem do reghisignal RegHi_OUT :bit_vector (31 downto 0);

-- sinais q saem do regLosignal RegLo_OUT :bit_vector (31 downto 0);

--sinais q entram no muxExt8signal MDR_OUT_8 :bit_vector (7 downto 0);signal B_OUT_8 :bit_vector (7 downto 0);

-- sinais q saem do muxExt8signal MuxExt8_OUT :bit_vector (7 downto 0);

--sinais q entram no Ext8-- MuxExt8_out

-- sinais q saem do Ext8signal Ext8_OUT :bit_vector (15 downto 0);

-- sinais q entram no MUXExt16signal B_out_16 :bit_vector (15 downto 0);-- Ext8_OUT-- IR150_OUTsignal MDR_out_16 :bit_vector (15 downto 0);

-- sinais q entram no ext16signal MuxExt16_OUT :bit_vector (15 downto 0);

-- sinais q saem no ext16-- Ext16_out

-- sinais q entram no desl2vezes32-- ext16_out

-- sinais q saem no desl2vezes32-- Ext16_Desl_2_OUT

-- sinais q entram no muxregwrite-- ir2016_outsignal ir1511 :bit_vector (4 downto 0);-- cte "11111"-- cte "11101"

-- sinais q entram em muxDataWritesignal muxReset_OUT :bit_vector (31 downto 0);-- regDesl_OUT -- regHi_OUT-- regLo_OUT-- ext16_out-- pc_out-- mdr_out-- ULA_out

-- sinais q entram em mux reset-- cte 227-- ext1_out-- extLui_out

-- sinais q entram no Extensor5signal IR106 : bit_vector (4 downto 0); -- ajeitar ...

-- sinais q saem do Extensor5-- Ext5_OUT

-- sinais q entram no muxNDesl-- cte 7signal ULA_Out_3 :bit_vector (2 downto 0); -- ajeitar ...

-- sinais q saem do muxNDeslsignal MuxNDesl_OUT :bit_vector (2 downto 0);

-- sinais q entram no reg_desl-- RegDeslcontrol-- muxNDesl_OUTsignal MuxEDesl_OUT :bit_vector (31 downto 0);

--sinais q saem do regDeslsignal RegDesl_OUT :bit_vector (31 downto 0);

-- muxEDesl-- entrada: A_out e RegDesl_OUT-- saída: MuxEDesl_OUT

-- desl2vezes26-- entrada: parte de ir, pc_out-- saida: Desl2vezes26_OUT

signal pcesc :bit;signal pcesccond :bit;signal selMuxCond: bit;signal muxcond_out :bit;

----------------------------------------------------------------

component ControlePORT(

-- ENTRADASCPUClock :IN bit; -- tenho q mudarCPUReset :IN bit; -- tenho q mudar

ULAControl_EQ :IN bit; ULAControl_O :IN bit; ULAControl_N :IN bit; ULAControl_Z :IN bit;

ULAControl_LT :IN bit;ULAControl_GT :IN bit;

erro :IN bit;SDivControl :IN bit;

-- SAIDAS -- MUXs SelMuxErro :OUT bit_vector(1 downto 0); SelMuxPosPC :OUT bit_vector(1 downto 0); SelMuxWriteMemo :OUT bit; SelMuxRegHi :OUT bit; SelMuxRegLo :OUT bit; SelMuxExt8 :OUT bit; SelMuxRegWrite :OUT bit_vector(1 downto 0); SelMuxReset :OUT bit_vector(1 downto 0); SelMuxDataWrite :OUT bit_vector(2 downto 0); SelMuxExt16 :OUT bit_vector(1 downto 0); SelMuxPosA :OUT bit_vector(1 downto 0); SelMuxPosB :OUT bit_vector(2 downto 0); SelMuxPrePC :OUT bit_vector(2 downto 0); SelMuxNDesl :OUT bit; SelMuxEDesl :OUT bit;

SelMuxCond :OUT bit;

-- Registradores -- RESET ResetPC :OUT bit; ResetMDR :OUT bit; ResetIR :OUT bit; ResetBR :OUT bit; ResetA :OUT bit; ResetB :OUT bit; ResetULAOut :OUT bit; ResetHi :OUT bit; ResetLo :OUT bit; ResetRegDesl :OUT bit; ResetEPC :OUT bit;

-- LOAD PcEscCond :OUT bit; -- vem da lógica externa (próxima a unidade de controle)

PCEsc :OUT bit; -- vem da lógica externa (próxima a unidade de controle) LoadMemoria :OUT bit; LoadIR :OUT bit; LoadMultDiv :OUT bit; -- é para indicar se é mult ou div LoadMDR :OUT bit; LoadBR :OUT bit; LoadULAOUT :OUT bit; LoadEPC :OUT bit; LoadRegHi :OUT bit; LoadRegLo :OUT bit; LoadA :OUT bit; LoadB :OUT bit;

-- ULA OpULA :OUT bit_vector (2 downto 0); -- nome diferente... acho...

-- MEMORIA --Wr : OUT BIT;

-- REGISTRADOR DE DESLOCAMENTO RegDeslControl :OUT bit_vector (2 downto 0);

-- CAIXINHA DE STORE(BYTE OU HALF) StoreControl :OUT bit;

Ir150_out :IN bit_vector(15 downto 0);Ir2016_out :IN bit_vector(4 downto 0);Ir2521_out :IN bit_vector(4 downto 0);Ir3126_out :in bit_vector(5 downto 0));

end component;

component Instr_regPORT(

Clk : IN bit; -- Clock do sistemaReset : IN bit; -- ResetLoad_ir : IN bit; -- Bit para ativar carga do registrador de

intruçõesEntrada : IN bit_vector (31 downto 0); -- Intrução a ser

carregadaInstr31_26 : OUT bit_vector (5 downto 0); -- Bits 31 a 26 da

instruçãoInstr25_21 : OUT bit_vector (4 downto 0); -- Bits 25 a 21 da

instruçãoInstr20_16 : OUT bit_vector (4 downto 0); -- Bits 20 a 16 da

instruçãoInstr15_0 : OUT bit_vector (15 downto 0) -- Bits 15 a 0 da

instrução );end component;

component Memoria PORT( Address : IN BIT_VECTOR(31 DOWNTO 0); -- Endereço de memória a ser lido

Clock : IN BIT; -- Clock do sistema Wr : IN BIT; -- Indica se a

memória será lida (0) ou escrita (1) Dataout : OUT BIT_VECTOR (31 DOWNTO 0); -- Valor a ser escrito quando Wr = 1 Datain : IN BIT_VECTOR(31 DOWNTO 0) -- Valor lido da memória quando Wr = 0 );end component;

component regdesloc

PORT( Clk : IN bit; -- Clock do sistema





);end component;

component Registrador PORT(

Clk : IN bit; -- Clock do registrador

Reset : IN bit; -- Reinicializa o conteudo do registrador

Load : IN bit; -- Carrega o registrador com o vetor Entrada

Entrada : IN bit_vector (31 downto 0); -- Vetor de bits que possui a informação a ser carregada no registrador

Saida : OUT bit_vector (31 downto 0) -- Vetor de bits que possui a informação já carregada no registrador

);end component;

component Ula32PORT(

A : in bit_vector (31 downto 0); -- Operando A da ULA

B : in bit_vector (31 downto 0); -- Operando B da ULA

Seletor : in bit_vector(2 downto 0); -- Seletor da operação da ULAS : out bit_vector (31 downto 0); -- Resultado da

operação (SOMA, SUB, AND, NOT, INCREMENTO, XOR) Overflow : out bit; --

Sinaliza overflow aritméticoNegativo : out bit; --

Sinaliza valor negativoz : out bit;

-- Sinaliza quando S for zeroIgual : out bit; --

Sinaliza se A=BMaior : out bit; --

Sinaliza se A>BMenor : out bit --

Sinaliza se A<B);

end component;

component mux21PORT(

sel : IN bit;Entrada1 : IN bit_VECTOR(31 downto 0);Entrada2 : IN bit_VECTOR(31 downto 0);Saida : OUT bit_VECTOR(31 downto 0));

end component;

component mux41


end component;

component mux81PORT(

sel : IN bit_vector(2 downto 0);Entrada1 : IN bit_VECTOR(31 downto 0);Entrada2 : IN bit_VECTOR(31 downto 0);Entrada3 : IN bit_VECTOR(31 downto 0);Entrada4 : IN bit_VECTOR(31 downto 0);Entrada5 : IN bit_VECTOR(31 downto 0);Entrada6 : IN bit_VECTOR(31 downto 0);Entrada7 : IN bit_VECTOR(31 downto 0);Entrada8 : IN bit_VECTOR(31 downto 0);Saida : OUT bit_VECTOR(31 downto 0));

end component;

component Extensor16PORT(


end component;



end component;

component mux41Ext16PORT(

sel : IN bit_vector(1 downto 0);Entrada1 : IN bit_VECTOR(15 downto 0);Entrada2 : IN bit_VECTOR(15 downto 0);Entrada3 : IN bit_VECTOR(15 downto 0);Entrada4 : IN bit_VECTOR(15 downto 0);Saida : OUT bit_VECTOR(15 downto 0));

end component;

component mux41Ext8PORT(


end component;



end component;

component MultdivPORT(

LoadDivMult : in bit; --bit q vem da unidade de controle, indica a funcaoentrada1 : in bit_vector (31 downto 0); --dividendo/multiplicando entrada2 : in bit_vector (31 downto 0); --divisor/multiplicadorclock : in bit;reset : in bit;saidaCont : out bit; -- saida para a unidade de controlesaidaHi : out bit_vector (31 downto 0); --quociente/parte do produtosaidaLo : out bit_vector (31 downto 0); --resto/outra parte do produtoerro : out bit);

end component;

component Desl2vezes32PORT(

Entrada : in bit_vector (31 downto 0); Saida : out bit_vector (31 downto 0)

);end component;

component Desl2vezes26PORT(

Entrada1 : in bit_vector (15 downto 0); Entrada2 : in bit_vector (4 downto 0); Entrada3 : in bit_vector (4 downto 0); PC : in bit_vector (31 downto 0); Saida : out bit_vector (31 downto 0)

);end component;

component StoreBHPORT(

storeControl : IN bit; Reg : IN bit_VECTOR(31 downto 0); Memo : IN bit_VECTOR(31 downto 0); Saida : OUT bit_VECTOR(31 downto 0));

end component;

component Banco_RegPORT(

Clk : IN bit;-- Clock do banco de registradores

Reset : IN bit; -- Reinicializa o conteudo dos registradores

RegWrite : IN bit; -- Indica se a operação é de escrita ou leitura

ReadReg1 : IN bit_vector (4 downto 0); -- Indica o registrador #1 a ser lido

ReadReg2 : IN bit_vector (4 downto 0); -- Indica o registrador #2 a ser lido

WriteReg : IN bit_vector (4 downto 0); -- Indica o registrador a ser escrito

WriteData : IN bit_vector (31 downto 0); -- Indica o dado a ser escrito

ReadData1 : OUT bit_vector (31 downto 0); -- Mostra a informaçao presente no registrador #1

ReadData2 : OUT bit_vector (31 downto 0) -- Mostra a informação presente no registrador #2

);end component;

component ExtensorLUIPORT(

Entrada : in bit_vector (15 downto 0); Saida : out bit_vector (31 downto 0)

);end component;

Component mux41_regWritePORT(


end component;

Component mux21_Ndesl


END component;

Component Extensor1port(

Entrada : in bit;Saida : out bit_vector (31 downto 0));

end component;

Component mux21Ext8PORT(

sel : IN bit;Entrada1 : IN bit_VECTOR(7 downto 0);Entrada2 : IN bit_VECTOR(7 downto 0);Saida : OUT bit_VECTOR(7 downto 0));

end component;

Component mux21CondPORT(

sel : IN bit;Entrada1 : IN bit;

Entrada2 : IN bit;Saida : OUT bit);

END component;

--------------------------------------------------------------------------------------

Begin

loadpc <= (pcesccond and muxCond_out)or pcesc;

PC: Registrador PORT MAP(Clk => CPUClock,Reset => CPUReset,Load => LoadPC,Entrada => MUXPrePC_OUT,Saida => PC_OUT

);

MDR: Registrador PORT MAP(Clk => CPUClock,Reset => CPUReset,Load => LoadMDR, Entrada => Memo_OUT,Saida => MDR_OUT

);

RegA: Registrador PORT MAP(Clk => CPUClock,Reset => CPUReset,Load => LoadA, Entrada => Reg1_OUT,Saida => A_OUT

);

RegB: Registrador PORT MAP(Clk => CPUClock,Reset => CPUReset,Load => LoadB, Entrada => Reg2_OUT,Saida => B_OUT

);

ULAOut: Registrador PORT MAP(Clk => CPUClock,Reset => CPUReset,Load => LoadULAOut, Entrada => S_ULA, Saida => ULA_OUT

);

EPC: Registrador PORT MAP(Clk => CPUClock,Reset => CPUReset,Load => LoadEPC, Entrada => PC_OUT,Saida => EPC_OUT

);

RegHi: Registrador PORT MAP(Clk => CPUClock,

Reset => CPUReset,Load => LoadRegHi,Entrada => RegHiIN,Saida => RegHi_OUT

);

RegLo: Registrador PORT MAP(Clk => CPUClock,Reset => CPUReset,Load => LoadRegLo, Entrada => RegLoIN,Saida => RegLo_OUT

);

Mem: Memoria PORT MAP(Address => MUXPosPC_out,

Clock => CPUClock, Wr => LoadMemoria,

Dataout => Memo_OUT, Datain => MUXWriteMemo_out

);

IR: Instr_reg PORT MAP(Clk => CPUClock,Reset => CPUReset,Load_ir => LoadIR, Entrada => Memo_OUT,Instr31_26 => IR3126_OUT, Instr25_21 => IR2521_OUT, Instr20_16 => IR2016_OUT,Instr15_0 => IR150_OUT

);

BR: Banco_reg PORT MAP(Clk => CPUClock,Reset => CPUReset,RegWrite => LoadBR, ReadReg1 => IR2521_OUT, ReadReg2 => IR2016_OUT,WriteReg => MUXRegWrite_out,

WriteData => MUXDataWrite_out,ReadData1 => Reg1_OUT,ReadData2 => Reg2_OUT

);

ULA: Ula32 PORT MAP(A => MUXPosA_out,B => MUXPosB_out,Seletor => OpULA,S => S_ULA,Overflow => ULAControl_O, Negativo => ULAControl_N, Z => ULAControl_Z, Igual => ULAControl_EQ, Maior => ULAControl_GT, Menor => ULAControl_LT

);

Ext1: Extensor1 port map(Entrada => ULAControl_N,Saida => Ext1_out

);

ExtLui: ExtensorLUI port map(Entrada => IR150_out,Saida => Extlui_out

);

CONT: Controle PORT MAP(

ResetPC => resetPc,ResetMDR => resetMDR,ResetIR => resetIR,ResetBR => resetBR,ResetA => resetA,ResetB => resetB,ResetULAOut => resetULAout,ResetHi => resetHi,ResetLo => resetLo,ResetRegDesl => resetRegDesl,ResetEPC => resetEPc,

cpuReset => cpureset,cpuClock => CPUclock,

OpULA => OpULA,ULAControl_O => ULAControl_O, ULAControl_Z => ULAControl_Z,ULAControl_LT => ULAControl_LT,ULAControl_GT => ULAControl_GT,ULAControl_N => ULAControl_N,ULAControl_EQ => ULAControl_EQ,ERRo => erro,SDivControl => SDivControl,

IR150_out => IR150_out,Ir2016_out => IR2016_out,Ir2521_out => IR2521_out,Ir3126_out => IR3126_out,

PCEsc => PCEsc,PCEscCond => PCEscCond,

LoadMemoria => LoadMemoria,LoadIR => LoadIR,LoadMultDiv => LoadMultDiv,

LoadMDR => LoadMDR, LoadBR => LoadBR, LoadULAOUT => LoadULAOut,

LoadEPC => LoadEPC, LoadRegHi => LoadRegHi, LoadRegLo => LoadRegLo,

LoadA => Loada, LoadB => LoadB,

StoreControl => StoreControl,RegDeslControl => RegDeslControl,

SelMuxErro => SelMuxErro,SelMuxPosPC => SelMuxPosPC ,SelMuxWriteMemo => SelMuxWriteMemo,SelMuxRegHi => SelMuxRegHi,SelMuxRegLo => SelMuxRegLo,SelMuxExt8 => SelMuxExt8,SelMuxRegWrite => SelMuxRegWrite,SelMuxReset => SelMuxReset,SelMuxDataWrite => SelMuxDataWrite ,SelMuxExt16 => SelMuxExt16 ,SelMuxPosA => SelMuxPosA,SelMuxPosB => SelMuxPosB,SelMuxPrePC => SelMuxPrePC,SelMuxEDesl => SelMuxEDesl

);

MUXErro: mux41 PORT MAP(Entrada1 =>"00000000000000000000000011111101",Entrada2 =>"00000000000000000000000011111110", Entrada3 =>"00000000000000000000000011111111", Entrada4 => "00000000000000000000000000000000",

Sel => selMuxErro, Saida => MUXerro_OUT

);

MuxPosPc: mux41 port map(Entrada1 =>ula_out,Entrada2 =>pc_out, Entrada3 =>MuxErro_out,Entrada4 =>"00000000000000000000000000000000",saida =>MuxPosPc_out, sel =>selMuxPosPc

);

MuxCond: mux21Cond port map(Entrada1 => UlaControl_EQ,Entrada2 => not(UlaControl_EQ),saida => MuxCond_out, sel => selMuxCond

);

MuxWriteMemo: mux21 port map(Entrada1 =>store_out,Entrada2 =>B_out, sel =>selMuxWriteMemo,saida =>MuxWriteMemo_out

);

MuxRegHi: mux21 port map(Entrada1 =>B_out,Entrada2 =>saidaRegHi, sel =>selMuxRegHi,saida =>RegHiIn

);

MuxRegLo: mux21 port map(Entrada1 =>SaidaRegLo,Entrada2 =>B_out, sel =>selMuxRegLo,saida =>RegLoin

);

MuxExt8: mux21ext8 port map(

Entrada1 => MDR_out(7 downto 0), -- falta declarar!!!Entrada2 => B_OUT(7 downto 0), -- falta declarar!!!!sel => selMuxExt8,saida => MuxExt8_out

);

MuxReset: mux41 port map(Entrada1 => "00000000000000000000000011100011",Entrada2 => ExtLui_out,Entrada3 => Ext1_out,Entrada4 => "00000000000000000000000000000000",sel => selMuxReset,saida => MuxReset_out

);

MuxRegWrite: Mux41_regWrite port map(Entrada1 =>IR2016_out,Entrada2 =>IR150_out(15 downto 11),Entrada3 =>"11111",Entrada4 =>"11101",sel =>selMuxRegWrite,saida =>muxRegWrite_out

);

MuxDataWrite: mux81 PORT MAP(

Entrada1 => MuxReset_out,Entrada2 => RegDesl_out,Entrada3 => RegHi_out,Entrada4 => RegLo_out,Entrada5 => Ext16_out,Entrada6 => PC_out,Entrada7 => MDR_out, Entrada8 => ULA_out,

Sel => SelMuxDataWrite,Saida => MuxDataWrite_out

);

MuxExt16: mux41Ext16 PORT MAP(Entrada1 => B_out(15 downto 0), Entrada2 => Ext8_out,Entrada3 => IR150_out,Entrada4 => MDR_out(15 downto 0),

Sel => SelMuxExt16, Saida => MuxExt16_out

);

MUXPosA: mux41 PORT MAP(Entrada1 => pc_OUT,Entrada2 => ext5_OUT,Entrada3 => a_OUT,Entrada4 => ULA_OUT,

Sel => SelMUXPosA, Saida => MUXPosA_OUT

);

MUXPosB: mux81 PORT MAP(

Entrada1 => B_OUT,Entrada2 => "00000000000000000000000000000100",Entrada3 => Ext16_OUT,Entrada4 => Ext16_Desl_2_OUT,Entrada5 => "00000000000000000000000000000000",Entrada6 => "00000000000000000000000000000111",Entrada7 => "00000000000000000000000000000000", Entrada8 => "00000000000000000000000000000000",

Sel => SelMUXPosB,

Saida => MUXPosB_OUT);

MuxPrePC: mux81 PORT MAP(

Entrada1 => S_ula,Entrada2 => Ula_out,Entrada3 => Desl2vezes26_out,Entrada4 => EPC_out,Entrada5 => A_out, -- ver pq...Entrada6 => memo_out,Entrada7 => Ext16_out,Entrada8 => PC_out,

Sel => SelMuxPrePC,Saida => MuxPrePC_out

);

Mux_Ndesl: mux21_Ndesl port map(

Entrada1 =>"111",Entrada2 =>ULA_out (2 downto 0),sel =>UlaControl_N,Saida =>MuxNdesl_out

);

Mux_Edesl: mux21 port map(

sel =>SelMuxEdesl,Entrada1 =>A_out,Entrada2 =>RegDesl_out,Saida =>MuxEdesl_out

); StoreBH1: StoreBH port map(

storeControl => StoreControl,Reg => B_out,Memo => MDR_out,Saida => store_out

);

Ext8: Extensor8 port map(

Entrada => MuxExt8_out,Saida => Ext8_out

);


Entrada => MuxExt16_out,Saida => Ext16_out

);


Entrada => IR150_out(10 downto 6),Saida => Ext5_out

);

Desl2x26: Desl2vezes26 port map(Entrada1 => IR150_out,Entrada2 => IR2016_out,Entrada3 => IR2521_out,

PC => PC_out,Saida => Desl2VEZES26_out

);

Desl2x32: Desl2vezes32 port map(Entrada => Ext16_out,Saida => Ext16_Desl_2_OUT

);

RegDesl: RegDesloc PORT MAP(Clk => CPUClock,

Reset => ResetRegDesl,Shift => RegDeslControl,N => muxNDesl_out,Entrada => muxEdesl_out,Saida => RegDesl_out

);

Instr150 <= IR150_out;Dado_out <= MUXDataWrite_out;Reg_out <= MUXRegWrite_out;LoadBR_out <= LoadBR;SelMuxRegWrite_out <= SelMuxRegWrite;PC_teste <= PC_out;PC_Esc_out <= PCEsc;LoadPC_out <= LoadPC; Aout <= A_out;Bout <= B_out;ALUout <= ULA_out;MDRout <= MDR_out;SelMuxDataWriteOut <= SelMuxDataWrite; SelMuxWriteMemoOut <= SelMuxWriteMemo;SelMuxPrePCOut <= SelMuxPrePC;SelMuxPosPCOut <= SelMuxPosPC;SelMuxResetOut <= SelMuxReset;SelMuxExt16Out <= SelMuxExt16; SelMuxExt8Out <= SelMuxExt8;SelMuxPosAOut <= SelMuxPosA;SelMuxPosBOut <= SelMuxPosB;StoreControlout <= StoreControl;StoreOut <= Store_Out;LoadMemoriaOut <= LoadMemoria;OpULAOut <= OpULA;WriteMemo <= MuxWriteMemo_out; Memo <= Memo_out;MuxPosPCOut <= MuxPosPC_Out;

END CPU_Arch;

Código 4.21 Mapeamento da Unidade de Processamento, Datapath.

4.4.2 Unidade de Controle

Finalmente, chegamos ao “cérebro” do nosso processador. Este é o módulo que vai controlar os demais, informando o que deve ser feito e a que momento. Partindo dos estados apresentados no livro de referência, expandimos a máquina de estados de forma a possibilitar a execução de todas as 34 instruções solicitadas. Para

viabilizar esse trabalho, foi fundamental o uso da cartolina, que nos possibilitou uma visão integrada da máquina que implementamos.

Em vhdl, chegamos ao seguinte código:

ENTITY controle ISPORT(

-- ENTRADASCPUClock :IN bit; -- tenho q mudarCPUReset :IN bit; -- tenho q mudarULAControl_EQ :IN bit;

ULAControl_O :IN bit; ULAControl_N :IN bit; ULAControl_Z :IN bit;

ULAControl_LT :IN bit;ULAControl_GT :IN bit;

erro :IN bit;SDivControl :IN bit;IR3126_out :IN bit_vector(5 downto 0);IR2521_out :IN bit_vector(4 downto 0);IR2016_out :IN bit_vector(4 downto 0);IR150_out :IN bit_vector(15 downto 0);

-- SAIDAS -- MUXs SelMuxErro :OUT bit_vector(1 downto 0); SelMuxPosPC :OUT bit_vector(1 downto 0); SelMuxWriteMemo :OUT bit; SelMuxRegHi :OUT bit; SelMuxRegLo :OUT bit; SelMuxExt8 :OUT bit; SelMuxRegWrite :OUT bit_vector(1 downto 0); SelMuxReset :OUT bit_vector(1 downto 0); SelMuxDataWrite :OUT bit_vector(2 downto 0); SelMuxExt16 :OUT bit_vector(1 downto 0); SelMuxPosA :OUT bit_vector(1 downto 0); SelMuxPosB :OUT bit_vector(2 downto 0); SelMuxPrePC :OUT bit_vector(2 downto 0); SelMuxNDesl :OUT bit; SelMuxEDesl :OUT bit;

SelMuxCond :OUT bit;

-- Registradores -- RESET ResetPC :OUT bit; ResetMDR :OUT bit; ResetIR :OUT bit; ResetBR :OUT bit; ResetA :OUT bit; ResetB :OUT bit; ResetULAOut :OUT bit; ResetHi :OUT bit; ResetLo :OUT bit; ResetRegDesl :OUT bit; ResetEPC :OUT bit;

-- LOAD PcEscCond :OUT bit; -- vem da lógica externa (próxima a unidade de controle)

PCEsc :OUT bit; -- vem da lógica externa (próxima a unidade de controle) LoadMemoria :OUT bit; LoadIR :OUT bit; LoadMultDiv :OUT bit; -- é para indicar se é mult ou div LoadMDR :OUT bit; LoadBR :OUT bit; LoadULAOUT :OUT bit; LoadEPC :OUT bit;

LoadRegHi :OUT bit; LoadRegLo :OUT bit; LoadA :OUT bit; LoadB :OUT bit;

-- ULA OpULA :OUT bit_vector (2 downto 0);

-- MEMORIA --Wr : OUT BIT;

-- REGISTRADOR DE DESLOCAMENTO RegDeslControl :OUT bit_vector (2 downto 0);

-- CAIXINHA DE STORE(BYTE OU HALF) StoreControl :OUT bit

);END controle;

ARCHITECTURE Behavior OF controle IS

type state_type is (INICIAL, ESPERANDO_LER_MEM1, ESPERANDO_LER_MEM2,BUSCA_INST1, ESPERANDO_IR, BUSCA_INST2, BUSCA_INST3, BUSCA_INST4,

ESPERANDO_UAL_OUT, UAL_OUT_TO_RD1,LOAD, UAL_OUT_TO_MEM, ESPERANDO_LER_MEM3, ESPERANDO_LER_MEM4, REGISTRAR_NO_MDR,REGISTRANDO_NO_MDR, SEL_FUNCAO, STORE, SEL_STORE, CARREGA_LT1, CARREGA_LT2, BREAK,MULTIPLICANDO, DIVIDINDO, TRATA_EXC, CARREGA_EQ1, CARREGA_EQ2, RESETANDO,CARREGA_Shift, ESPERA_REGDES,TERMINA_Shift, ESPERANDO_JAL, UAL_OUT_TO_RD2,

ESPERANDO_LER_MEM_STORE1,STORE_MDR1, ESPERANDO_LER_MEM_STORE2, STORE_MDR2, STORE_MDR3,STORE_MDR4,

CARREGA_EQ3, TRATA_EXC2, TRATA_EXC3, TRATA_EXC4,DIVIDINDO2, TRATA_EXC5);

signal state: state_type;

beginprocess(CPUReset,CPUClock)

beginif(CPUReset = '1') then

state <= RESETANDO;

elsif(CPUClock = '1' and CPUClock'event) then

case state is

when RESETANDO =>ResetPC <= '1';

ResetMDR <= '1'; ResetIR <= '1'; ResetBR <= '1'; ResetA <= '1'; ResetB <= '1'; ResetULAOut <= '1'; ResetHi <= '1'; ResetLo <= '1'; ResetRegDesl <= '1'; ResetEPC <= '1';

state <= INICIAL;

when INICIAL=> --INICIAL == BUSCA ResetPC <= '0';

ResetMDR <= '0'; ResetIR <= '0'; ResetBR <= '0'; ResetA <= '0'; ResetB <= '0'; ResetULAOut <= '0'; ResetHi <= '0';

ResetLo <= '0'; ResetRegDesl <= '0'; ResetEPC <= '0';

SelMuxPosPC <= "01"; -- vai escolher PC na entrada da memória

PCEsc <= '0';-- acho q é PCnormal!!!!loadMemoria <= '0'; -- seta a memoria para leituraSelMuxPosB <= "001"; -- escolhe 4 na ULASelMuxPosA <= "00"; -- escolhe PC na ULAOpULA <= "001"; --addLoadIR <= '0';--naum carrega instrução

LoadBR <= '0'; --seta para leitura o banco de registradores

LoadULAOUT <= '1';--dá load na ula--no proximo--SelMuxPrePC <= "00"; -- escolhe a

saida da ULA para carregar o PC state <= ESPERANDO_LER_MEM1;

when ESPERANDO_LER_MEM1 =>--LerMem <= '0';state <= ESPERANDO_LER_MEM2;

when ESPERANDO_LER_MEM2 => --ESPERANDO_LER_MEM2 == DECODIFICA

SelMuxPrePC <= "001"; --escolhe a saida da ULA para carregar o PC PCEsc <= '1';

state <= BUSCA_INST1;

when BUSCA_INST1 =>PCEsc <= '0'; -- pra n carregar o PCSelMuxExt16 <= "10";-- escolhe a instrução(15..0) na

entrada do ext32(naum sei se dah tempo)SelMuxPosB <= "011"; -- escolhe a saída de sl2 na ULASelMuxPosA <= "00"; -- escolhe PC na ULAOpULA <= "001";-- addLoadULAOUT <= '1';--carrega(pc+ desl*4) em ALUoutLoadIR <= '1'; -- carrega instrução--loadBR <= '0';--ver loadRegstate <= ESPERANDO_IR;

when ESPERANDO_IR =>LoadIR <= '0';state <= BUSCA_INST2;

when BUSCA_INST2 =>LoadA <= '1';--carrega ALoadB <= '1';--carrega Bstate <= BUSCA_INST3;

when BUSCA_INST3 =>state <= BUSCA_INST4;

when BUSCA_INST4 =>LoadA <= '0';LoadB <= '0';case IR3126_out is

when "000000" =>if ((IR2521_out = "00000") and

(IR2016_out = "00000") and (IR150_out = "000000")) then--nopstate <= INICIAL; --naum faz

nada elsif(IR150_out(5 downto 0) = "010000")

then --mfhiSelMuxDataWrite <= "010"; --

escolhe a saida do RegHI no mux de dado do BRSelMuxRegWrite <= "01"; --

escolhe a instrução(15..11) como n° do reg a ser escrito

LoadBR <= '1'; -- seta o BR para escrita

state <= INICIAL;elsif(IR150_out(5 downto 0) =

"010010") then --mfloSelMuxDataWrite <= "011"; --

escolhe a saida do RegLO no mux de dado do BRSelMuxRegWrite <= "01"; --

escolhe a instrução(15..11) como n° do reg a ser escritoLoadBR <= '1'; -- seta o BR

para escrita state <= INICIAL; elsif (IR150_out(5 downto 0) = "010001") then --mthi SelMuxRegHi <= '0'; --escolhe B LoadRegHi <= '1'; --seta para carregar state <= INICIAL; elsif (IR150_out(5 downto 0) = "010011") then --mtlo SelMuxRegLo <= '1'; --escolhe A LoadRegLo <= '1'; -- seta para carregar state <= INICIAL;

elsif((IR150_out(5 downto 0) = "100000") or (IR150_out(5 downto 0) = "100001")) then --add/addu

SelMuxRegWrite <= "01"; -- escolhe a instrução(15..11) como n° do reg a ser escrito selMuxPosA <= "10"; -- escolhe a saida de A para a ULA

selMuxPosB <= "000"; -- escolhe a saida de B para a ULA

OpULA <= "001"; -- addstate <= ESPERANDO_UAL_OUT;

elsif((IR150_out(5 downto 0) = "100010") or (IR150_out(5 downto 0) = "100011")) then --sub/subu



OpULA <= "010"; -- substate <= ESPERANDO_UAL_OUT;

elsif(IR150_out(5 downto 0) = "100100") then --and



OpULA <= "011"; -- andstate <= ESPERANDO_UAL_OUT;

elsif(IR150_out(5 downto 0) = "100110") then --xor



OpULA <= "110"; -- xorstate <= ESPERANDO_UAL_OUT;

elsif(IR150_out(5 downto 0) = "101010") then --slt

selMuxPosA <= "10"; -- escolhe a saida de A para a ULA


OpULA <= "111"; --comparaçãostate <= CARREGA_LT1;

elsif((IR150_out(5 downto 0) = "000011") or (IR150_out(5 downto 0) = "000010") or (IR150_out(5 downto 0) = "000000")) then --srl/sra/sll

selMuxPosA <= "01"; -- escolhe a saida de ext(5/32) para a ULA

selMuxPosB <= "100"; -- escolhe o zero para a ULA

OpULA <= "001"; --addLoadULAout <= '1';--carregar a

saida da ULA em ALUout SelMuxEDesl <= '0'; --carrega a A no regDesl RegDeslControl <= "001"; -- da load na entrada (no regDesl)

--ver com Monitor, tah sem escolher a entrada

state <= CARREGA_Shift; -- ver se da certo

elsif(IR150_out(5 downto 0) = "001000") then --jr

SelMuxPrePC <= "100"; --escolhe A para carregar PC

PCEsc <= '1';state <= INICIAL;

elsif(IR150_out(5 downto 0) = "001101") then --break

state <= BREAK; -- fica em um loop eterno(ver com Edna)

elsif(IR150_out(5 downto 0) = "011000") then --mult

--sDivControl <= '0';--indica q n acabou (talvez seja necessario um sinal pra indicar que começou?)

LoadMultDiv <= '0';--escolhe a mult

state <= MULTIPLICANDO;elsif(IR150_out(5 downto 0) =

"011010") then --div--sDivControl <= '0';--indica q

n acabouLoadMultDiv <= '1';--escolhe a

divstate <= DIVIDINDO;

end if;

when "100011" => --lw SelMuxExt16 <= "10";-- escolhe a

instrução(15..0) na entrada do ext32state <= LOAD;

when "100000" => --lbSelMuxExt16 <= "10";-- escolhe a

instrução(15..0) na entrada do ext32 state <= LOAD;

when "100001" => --lh SelMuxExt16 <= "10";-- escolhe a

instrução(15..0) na entrada do ext32state <= LOAD;

when "101011" => --sw SelMuxExt16 <= "10";-- escolhe a

instrução(15..0) na entrada do ext32state <= STORE;

when "101000" => --sb SelMuxExt16 <= "10";-- escolhe a

instrução(15..0) na entrada do ext32

state <= STORE;

when "101001" => --sh SelMuxExt16 <= "10";-- escolhe a

instrução(15..0) na entrada do ext32(naum sei se dah tempo)state <= STORE;

when "001010" => --sltiSelMuxExt16 <= "10"; -- escolhe a

instrução(15..0) para o extensor32 (acho q naum dah tempo) SelMuxPosA <= "10"; -- a entrada A para a UlA SelMuxPosB <= "010"; --escolhe a saida do extensor32 para a ULA opULA <= "111"; -- compara state <= CARREGA_LT2;--jah tow comparando aqui

when "001000" => --addi SelMuxExt16 <= "10";-- escolhe a

instrução(15..0) para o extensor32 (acho q naum dah tempo) colocar no estado de decodificação

SelMuxPosA <= "10"; -- escolhe A para entrar na ULA

SelMuxPosB <= "010"; --escolhe a saida do extensor32 para entrar na ULA

OpULA <= "001"; --add--LoadULAout <= '1'; --carregar a

saida ULA em ALUoutSelMuxRegWrite <= "00"; --

instrução(20..16) para regWritestate <= ESPERANDO_UAL_OUT;

when "001110" => --xoriSelMuxExt16 <= "10";-- escolhe a

instrução(15..0) para o extensor32 (acho q naum dah tempo) colocar no estado de decodificação



OpULA <= "110"; --xor--LoadULAout <= '1'; --carregar a



when "001111" => --luiLoadBR <= '1';--seta BR para escritaSelMuxRegWrite <= "00"; --

instrução(20..16) para regWriteSelMuxDataWrite <= "000"; --seleciona

entrada do muxReset SelMuxReset <= "01";--escolhe a saida do extensorLUI

state <= INICIAL;

when "001101" => --andi

SelMuxExt16 <= "10";-- escolhe a instrução(15..0) para o extensor32 (acho q naum dah tempo) colocar no estado de decodificação



OpULA <= "011"; --and--LoadULAout <= '1'; --carregar a


instrução(20..16) para regWrite

state <= ESPERANDO_UAL_OUT;

when "000010" => --j SelMuxPrePC <= "010"; --escolhe a saida do (desl2 + 4bits do PC) para carregar o PC PCEsc <= '1'; -- permite mudar o PC

state <= INICIAL;

when "000100" => --beqSelMuxPosA <= "10"; --escolhe A para

entrar na ULASelMuxPosB <= "000"; --escolhe B para

entrar na ULAOpULA <= "111"; -- comparaLoadULAOut <= '0'; -- para não

carregar o ALUoutSelMuxPrePC <= "001"; -- escolhe o reg

ALUout para carregar o PCstate <= CARREGA_EQ1; --VER O QUE

FALTA NO PAPEL

when "000101" => --bne TAH FALTANDO O MuxCond

SelMuxPosA <= "10"; --escolhe A para entrar na ULA

SelMuxPosB <= "000"; --escolhe B para entrar na ULA

OpULA <= "111"; -- comparaLoadULAOut <= '0'; -- para não

carregar o ALUoutSelMuxPrePC <= "001"; -- escolhe o reg

ALUout para carregar o PCstate <= CARREGA_EQ2;

when "000011" => --jalSelMuxRegWrite <= "10"; --escolhe $31

para regWriteSelMuxDataWrite <= "101"; --escolhe o

PC como dado a ser gravadoLoadBR <= '1';--seta O BR para escritaSelMuxPrePC<="010"; --escolhe a saida

do (desl2 + 4bits do PC) para carregar o PCPcEsc <='1'; --permite carregar PCstate <= ESPERANDO_JAL;

when "010000" => --rteif((IR150_out(5 downto 0) = "010000"))

thenSelMuxPrePC<="011"; --escohe

EPC para carregar o PCPCEsc <= '1'; --permite

carregar PCstate <=INICIAL;

end if;

when "001001" =>-- addiu SelMuxExt16 <= "10";-- escolhe a instrução(15..0) para o extensor32 (acho q naum dah tempo) colocar no estado de decodificação



OpULA <= "001"; --add--LoadULAout <= '1'; --carregar a



when others =>state <= TRATA_EXC;

end case;

when ESPERANDO_UAL_OUT =>LoadULAOut <= '1'; -- carrega o reg ALUoutif((ULAControl_O = '1') and((IR3126_out = "001000") or ((IR3126_out = "000000")

and((IR150_out(5 downto 0) = "100000") or (IR150_out(5

downto 0) = "100010"))))) then--SelExc <= "01";state <= TRATA_EXC;

elsif((IR3126_out = "001101") or (IR3126_out = "001001") or (IR3126_out = "001110") or (IR3126_out = "001000") or ((IR3126_out = "000000") and

((IR150_out(5 downto 0) = "100000") or (IR150_out(5 downto 0) = "100001") or (IR150_out(5 downto 0) = "100100") or (IR150_out(5 downto 0) = "100110") or (IR150_out(5 downto 0) = "100010") or

(IR150_out(5 downto 0) = "100011")))) thenstate <= UAL_OUT_TO_RD1;

elsif((IR3126_out = "100011") or (IR3126_out = "100000") or (IR3126_out = "100001")) then

state <= UAL_OUT_TO_MEM;elsif((IR3126_out = "101011") or (IR3126_out =

"101000") or (IR3126_out = "101001")) thenstate <= SEL_STORE;

end if;

when UAL_OUT_TO_RD1 =>SelMuxDataWrite <= "111"; -- escolhe o regALUoutLoadBR <= '1'; -- seta o BR para escritastate <= UAL_OUT_TO_RD2;

when UAL_OUT_TO_RD2 =>state <= INICIAL;

when LOAD => -- TEM Q ESCOLHER A ENTRADA DO EXTENSOR (FOI

ESCOLHIDO ANTES)SelMuxPosA <= "10"; -- escolhe A para entrar na ULASelMuxPosB <= "010"; -- escolhe a saida do extensor32

para entrar na ULAOpULA <= "001"; --addLoadULAout <= '1'; --carregar no reg ALUout

state <= ESPERANDO_UAL_OUT;

when UAL_OUT_TO_MEM =>SelMuxPosPC <= "00"; -- escolhe o reg ALUout para

carregar o PCstate <= ESPERANDO_LER_MEM3;

when ESPERANDO_LER_MEM3 =>state <= ESPERANDO_LER_MEM4;

when ESPERANDO_LER_MEM4 =>state <= REGISTRAR_NO_MDR;

when REGISTRAR_NO_MDR =>LoadMDR <= '1'; -- carrega dado lido da memoria em

MDRstate <= REGISTRANDO_NO_MDR;

when REGISTRANDO_NO_MDR =>LoadMDR <= '0'; -- para não mudar o valor de MDRstate <= SEL_FUNCAO;

when SEL_FUNCAO =>LoadBR <= '1'; --seta BR para escrita

if(IR3126_out = "100011") thenSelMuxDataWrite <= "110"; -- escolhe MDR para

escrever no BRelsif(IR3126_out = "100000") then

-- tem que ver se dah tempo SelMuxExt8 <= '1'; -- byte que vem de MDR SelMuxExt16 <= "01"; -- escolhe a saida do extensor8 para entrar no extensor32 SelMuxDataWrite <= "100"; -- escolhe a saida do extensor32 para ser escrito no BR

elsif(IR3126_out = "100001") thenSelMuxExt16 <= "11"; -- escolhe o MDR(15..0)

para entrar no extensor32 SelMuxDataWrite <= "100"; -- escolhe a saida do extensor32 para ser escrito no BR

end if;SelMuxRegWrite <= "00"; -- registrador a ser escrito

é a inst(20..16)state <= INICIAL;

when STORE =>

SelMuxPosA <= "10"; -- escolhe A para entrar na ULASelMuxPosB <= "010"; -- escolhe a saida do extensor32

para entrar na ULAOpULA <= "001"; --addLoadULAout <= '1'; --carregar no reg ALUoutstate <= ESPERANDO_UAL_OUT;

when SEL_STORE =>SelMuxPosPC <= "00"; -- seleciona o reg ALUout para

endereço de memoriaif(IR3126_out = "101011") then

SelMuxWriteMemo <= '1'; -- escolhe B como dado a ser escrrito na memoria

LoadMemoria <= '1'; -- seta a memoria para escrita

state <= INICIAL;elsif(IR3126_out = "101000") then

LoadMemoria <= '0'; --seta memoria para leitura

state <= ESPERANDO_LER_MEM_STORE1;elsif(IR3126_out = "101001") then

LoadMemoria <= '0'; --seta memoria para leitura

state <= ESPERANDO_LER_MEM_STORE1;end if;

when ESPERANDO_LER_MEM_STORE1 =>state <= ESPERANDO_LER_MEM_STORE2;

when ESPERANDO_LER_MEM_STORE2 =>state <= STORE_MDR1;

when STORE_MDR1 =>LoadMDR <= '1'; -- carrega MDRstate <= STORE_MDR2;

when STORE_MDR2 =>LoadMDR <= '0'; -- para não mudar o valor de MDRif(IR3126_out = "101000") then

StoreControl <= '0'; -- indica que vai ser pego soh o byte

elsif(IR3126_out = "101001") thenStoreControl <= '1'; -- indica que vai ser

pego meia palavraend if;SelMuxWriteMemo <= '0'; -- escolhe o que sai da

caixinha "store"LoadMemoria <= '1'; -- seta a memoria para escrita

state <= STORE_MDR3;

when STORE_MDR3 =>state <= STORE_MDR4;

when STORE_MDR4 =>state <= INICIAL;

when CARREGA_LT1 =>SelMuxReset <= "10"; -- escolhe a saida do extensor1

no muxErro SelMuxDataWrite <= "000"; -- escolhe o muxErro SelMuxRegWrite <= "01"; -- escolhe inst(15..11) na entrada de BR

LoadBR <= '1'; --seta BR para escritastate <= INICIAL;

when CARREGA_LT2 =>SelMuxReset <= "10"; -- escolhe a saida do extensor1

no muxErro SelMuxDataWrite <= "000"; -- escolhe o muxErro SelMuxRegWrite <= "00"; -- escolhe inst(20..16) na entrada de BR

LoadBR <= '1'; --seta BR para escritastate <= INICIAL;

when CARREGA_EQ1 =>PcEsc <= '0'; -- para carregar dependendo da ULA

PcEscCond <= '1'; -- para indicar que e condicional SelMuxCond <= '0'; -- saida EQ da ULA state <= CARREGA_EQ3;

when CARREGA_EQ2 =>PcEsc <= '0'; -- para carregar dependendo da ULA

PcEscCond <= '1'; -- para indicar que e condicional SelMuxCond <= '1'; -- negação da saida EQ da ULA state <= CARREGA_EQ3;

when CARREGA_EQ3 =>state <= INICIAL;

when BREAK=>state <= BREAK;

when MULTIPLICANDO =>--MDComeco <= '0';if(sDivControl = '1') then

SelMuxRegHI <= '1';SelMuxRegLO <= '1';

LoadRegHi <= '1';LoadRegLo <= '1';state <= INICIAL;

elsestate <= MULTIPLICANDO;

end if;

when DIVIDINDO =>state <= DIVIDINDO2;

when DIVIDINDO2 =>--MDComeco <= '0';if(erro = '1') then

state <= TRATA_EXC;elsif(sDivControl = '1') then SelMuxRegHI <= '1';

SelMuxRegLO <= '1'; LoadRegHi <= '1';

LoadRegLo <= '1';state <= INICIAL;

elsestate <= DIVIDINDO2;

end if;

when CARREGA_Shift => SelMuxEDesl <= '1'; --carrega a saida do proprio

regDesl RegDeslControl <= "001"; -- da load na entrada (no

regDesl) SelMuxPosA <= "11"; -- escolhe o ALUout como entrada

da ULA SelMuxPosB <= "101"; -- escolhe o 1 como entrada da ULA OpULA <= "010"; -- sub LoadULAOUT <= '0'; -- não deixa ALUout mudar -- e melhor colocar antes °> if(IR150_out(5 downto 0) = "000011") then RegDeslControl <= "100"; -- shift para direita aritmetico elsif(IR150_out(5 downto 0) = "000010") then RegDeslControl <= "011"; -- shift para direita logico elsif(IR150_out(5 downto 0) = "000000") then RegDeslControl <= "010"; -- shift para esquerda

end if; state <= ESPERA_REGDES; when ESPERA_REGDES => if(ULAControl_N = '1') then --LoadALUout <= '0'; SelMuxNDesl <= '1'; -- desloca quantas vezes tem em ALUout(e o passado ainda) state <= TERMINA_Shift; -- ou coloca mais um estado antes else LoadULAOUT <= '1'; -- carrega ALUout SelMuxNDesl <= '0'; -- desloca 7 vezes state <= CARREGA_Shift; --para ficar no loop ate ser negativo end if;

when TERMINA_Shift => SelMuxRegWrite <= "01"; -- inst(15..11) SelMuxDataWrite <= "001"; -- escolhe a saida do RegDesl --erro LoadBR <= '1'; --seta BR para escrita state <= INICIAL;

when ESPERANDO_JAL =>LoadBR <= '0'; -- para voltar a modo leiturastate <= INICIAL;

when TRATA_EXC => -- posso tentar deixar em um estado soh º>SelMuxPosB <= "001"; --escolhe 4 para entrar na ULASelMuxPosA <= "00"; --escolhe PC para entrar na ULAOpULA <= "010"; --subLoadEPC <= '1'; --carrega epc com o valor do PC que

deu erro(PC - 4)SelMuxPosPC <= "10"; --escolhe a saida do muxErro

para entrar na memoriaif(erro = '1') then

SelMuxErro <= "10"; --escolhe 255 no mux de erro (div por 0)

elsif(ULAControl_O = '1')thenSelMuxErro <= "01"; --escolhe 254 no mux de erro

(overflow)else

SelMuxErro <= "00"; --escolhe 253 no mux de erro (OpCode inexistente)

end if;LoadMemoria <= '0'; -- seta a memoria para leiturastate <= TRATA_EXC2;

when TRATA_EXC2 =>state <= TRATA_EXC3;

when TRATA_EXC3 => SelMuxPosPC <= "01";-- escolhe a saida do regPC

state <= TRATA_EXC4;

when TRATA_EXC4 =>LoadEPC <= '0'; --não muda o valor de EPCSelMuxPrePC <= "101"; -- escolhe a saída da memoria

(ver se é preciso pegar soh um byte)PCEsc <= '1'; -- permite mudar PC

state <= TRATA_EXC5;

when TRATA_EXC5 =>state <= INICIAL;

--when others

end case;end if;

end process;

--process(Clock)--begin

-- if(Clock = '1' and Clock'event) then-- ESTADO_ATUAL <= PROXIMO_ESTADO;-- end if;

-- end process;END Behavior;

Código 4.22 Unidade de Controle.

5. Referências Computer Organization and Design: The Hardware/Software Interface, Second Edition. David A. Patterson , University of California, Berkeley ;John L. Hennessy , Stanford University ISBN 155860491X · Paperback Morgan Kaufmann · Published December 1997

www.inf.pucrs.br/~calazans/arq1.htmlwww.inf.ufrgs.br/~flavio/ ensino/ArqServ/processadores.pdfwww.inf.ufrgs.br/~flavio/ensino/cmp114/aula13.pdfwww.microprocessadores.hpg.com.br/page9.htmlwww.dcc.unicamp.br/~ducatte/mc722/Material/arq_hp4.pdf

http://www.dcc.unicamp.br/~ducatte/mc722/Material/arq_hp4.pdf

http://www.microprocessadores.hpg.com.br/page9.html

http://www.inf.ufrgs.br/~flavio/ensino/cmp114/aula13.pdf

http://www.inf.pucrs.br/~calazans/arq1.html

dllaa/MultDivDesc.doc · Web viewUNIVERSIDADE FEDERAL DE PERNAMBUCO - CENTRO DE INFORMÁTICA -...

Documents

Transcript of dllaa/MultDivDesc.doc · Web viewUNIVERSIDADE FEDERAL DE PERNAMBUCO - CENTRO DE INFORMÁTICA -...