O PROCESSADOR MULTICICLO MIPS_S

Transcrição

1 V De: 23/novembro/2016 por Ney Calazans Organzação de Computadores O PROCESSADOR MULTICICLO MIPS_S 1 CARACTERÍSTICAS GERAIS DA ARQUITETURA MIPS A arqutetura MIPS é do tpo load-store, ou seja, as operações lógcas e artmétcas são executadas exclusvamente entre regstradores da arqutetura ou entre constantes medatas e regstradores. As operações de acesso à memóra só executam ou uma letura da memóra (load) ou uma escrta na memóra (store). Devdo à característca load-store, o processador dsponblza um conjunto relatvamente grande de regstradores, para reduzr o número de acessos à memóra externa, pos estes últmos representam perda de desempenho sgnfcatva em relação a operações entre regstradores nternos ao processador. Esta característca dfere de arquteturas baseadas em acumulador, que mantêm todos os dados em memóra, realzando operações artmétcas entre um conteúdo que está em memóra e um, ou poucos regstradores de dados, os denomnados acumuladores. Consdere o exemplo do códgo C a segur: for(=0; <1000; ++). Neste exemplo, caso esteja armazenado em memóra, tem-se 2000 acessos à memóra, realzando letura e escrta a cada teração do laço for. Caso se tenha o valor de armazenado em um regstrador nterno, apenas opera-se sobre este, sem acesso à memóra externa durante a maor parte do tempo. Consderando-se que o tempo de acesso a um regstrador é normalmente de uma a duas ordens de grandeza menor que o tempo de acesso a uma posção de memóra (ou seja, 10 a 100 vezes menor, dependendo de aspectos tas como tecnologa de mplementação do processador e das memóras, padrão de comuncação processador-memóra, etc.), percebe-se o ganho de desempenho que arquteturas load-store podem auferr em relação a arquteturas baseadas em acumulador(es). Dados e endereços na arqutetura MIPS são de 32 bts. Logo, dz-se que a palavra deste processador é de 32 bts, ou smplesmente que se trata de um processador de 32 bts. Obvamente, exstem processadores com outro tamanho de palavra, tal como o 8051 da Intel (8 bts), o TMS9900 da Texas (16bts) e o Itanum da Intel (64 bts). O endereçamento de memóra no MIPS é orentado a byte, ou seja, cada endereço de memóra é um dentfcador de uma posção de memóra onde se armazena apenas 1 byte=8 bts. Então, uma palavra do processador armazenada em memóra ocupa 4 posções de memóra, tpcamente em quatro endereços consecutvas. O banco de regstradores da arqutetura possu 32 regstradores de uso geral, de 32 bts cada um, denomnados $0 a $31. O regstrador $0 não é realmente um regstrador, mas a constante 0 representada em 32 bts, que pode ser referencada como um regstrador ordnáro. Este é dsponblzado para nstruções que empregam o modo de endereçamento a regstrador entre outros, e que necesstem usar tal valor, muto empregado. No MIPS há um formato regular para as nstruções. Todas possuem exatamente o mesmo tamanho, e ocupam 1 palavra em memóra (32 bts), ou seja, o equvalente a 4 endereços consecutvos em memóra. A nstrução contém o códgo da operação e o(s) operando(s), caso exsta(m). Acesso a nstruções são sempre alnhados em uma frontera de palavra ntera. Assm, todo endereço váldo de uma nstrução possu os dos últmos bts guas a 0 (e.g. endereço 0, 4, 16, 32004, etc. representados em decmal). Os modos de endereçamento mas mportantes nesta arqutetura são os modos a regstrador, basedeslocamento e relatvo ao PC. O processador não possu suporte em hardware para gerencar estruturas do tpo plha em memóra, mas exste um regstrador do banco, (o $sp ou $29) que assocado a nstruções operando sobre este, e a duas nstruções especas (JAL/JALR) permtem smular estruturas do tpo plha em memóra para salvamento de contexto de funções e sub-rotnas, por exemplo. Não exstem regstradores para armazenar explctamente qualfcadores sobre a execução de operações, tas como as nformações de que a execução de uma nstrução resultou na constante 0, ou que uma nstrução artmétca gerou va-um (em nglês, carry), ou anda que seu resultado não é correto porque necessta recursos de armazenamento de maor capacdade que os dsponíves no processador (stuação chamada de transbordo, ou, em nglês, overflow). A detecção destas stuações deve ser realzada usando nstruções específcas de comparação dsponíves na arqutetura especfcamente para sto (ver o comportamento das nstruções com prefxo SLT). O que é descrto aqu é um processador que mplementa um subconjunto da arqutetura do MIPS (donde o nome MIPS_S, abrevatura de MIPS Subset). Trata-se pratcamente de uma máquna RISC completa. Faltam,

2 - 2 - contudo algumas característcas que exstem em qualquer RISC, tal como ppelnes, assunto dexado para ser ntroduzdo e estudado em profunddade em outra oportundade. 2 A RELAÇÃO PROCESSADOR - MEMÓRIAS - AMBIENTE EXTERNO A Fgura 1(a) mostra uma proposta de organzação para mplementar o processador MIPS_S. Nela, está explctada a relação entre processador, memóras externas e o mundo exteror ao subsstema processador memóras de dados e nstruções. O mundo externo é o responsável por gerar os snas de clock e reset. Uma característca prmordal desta organzação é que ela é uma organzação Harvard, ou seja, o processador usa nterfaces dstntas para comuncação com as memóras de nstruções e de dados. Outra possbldade sera o uso de uma nterface de memóra unfcada para nstruções e dados, caracterzando uma organzação von Neumann. Segue agora uma breve dscussão da organzação MIPS_S. Esta será detalhada em Seções posterores deste documento. VHDL PARCIAL DO PROCESSADOR MIPS_S NO NÍVEL DE HIERARQUIA MAIS ALTO entty MIPS_S s port(clock, reset: n std_logc; ce, rw, bw: out std_logc; _address, d_address: out std_logc_vector(31 downto 0); nstructon: n std_logc_vector(31 downto 0); data: nout std_logc_vector(31 downto 0) ); Memóra de Instruções clock reset nstructon _address BLOCO DE CONTROLE (BC) salta uns nst_branch end_dv NPC end_mul IR RESULT_OUT BLOCO DE DADOS (BD) DIAGRAMA DE BLOCOS DO PROCESSADOR MIPS_S ce rw bw data d_address Memóra de Dados end MIPS_S; archtecture MIPS_S of MIPS_S s sgnal IR, NPC, RESULT: std_logc_vector(31 downto 0); sgnal uns: mcronstructon; sgnal nst_branch, salta, end_mul, end_dv: std_logc; begn dp: entty work.datapath port map(ck=>clock,rst=>reset,d_address=>d_address, data=>data,nst_branch_out=> nst_branch, salta_out>salta,end_mul=>end_mul,end_dv=>end_dv, RESULT_OUT=>RESULT,uns=>uns,IR_IN=>IR,NPC_IN=>NPC ); ct: entty work.control_unt port map(ck=>clock,rst=>reset,_address=>_address, nstructon=>nstructon,nst_branch_n=>nst_branch, salta_n=>salta,end_mul=>end_mul,end_dv=>end_dv, RESULT_IN=>RESULT,uns=>uns,IR_OUT=>IR,NPC_OUT=>NPC ); ce <= uns.ce; rw <= uns.rw; bw <= uns.bw; end MIPS_S; (a) Dagrama de blocos processador-memóra para a organzação MIPS_S. (b) VHDL parcal do nível mas alto da herarqua de descrção do processador MIPS_S. Fgura 1 Proposta de uma organzação para o processador MIPS_S. Ilustra-se a conectvdade entre o processador, ambente externo, memóras externas e esboço da descrção VHDL de nível herárquco mas alto para a organzação. O processador MIPS_S recebe do mundo externo dos snas de controle. O prmero, denomnado clock, sncronza todos os eventos nternos do processador. O snal reset leva o processador a rencar a execução de nstruções a partr do endereço 0x de memóra (este endereço é defndo por compatbldade com o endereço assumdo pelo smulador MARS como aquele de níco da área de programas). O snal reset pode ser usado para provocar o reníco da operação do processador. Os snas provdos pelo processador MIPS_S para a troca de nformações com o mundo externo, representado pelas memóras, são: _address um barramento undreconal de 32 bts, que defne sempre o endereço da posção de memóra contendo a nstrução a ser buscada a segur; nstructon um barramento undreconal de 32 bts, contém sempre o códgo objeto da nstrução contda na posção de memóra apontada por _address; d_address um barramento undreconal de 32 bts, contendo o endereço da posção de memóra a ser lda ou escrta, da ou para a memóra de dados, respectvamente; data - um barramento bdreconal de 32 bts que transporta dados do ou para o processador MIPS_S; Além dos snas que permtem a nteração com o mundo externo, os prncpas componentes da organzação do processador MIPS_S, o Bloco de Controle (BC) e o Bloco de Dados (BD) nteragem através de 1 A notação ntroduzda aqu, 0x é uma forma de representar números na base hexadecmal. Adota-se a convenção usada no montador/smulador MARS do MIPS, que emprega o prefxo 0x para ndcar que um número está representado na base 16.

3 - 3 - um conjunto de snas específcos. São 5 snas qualfcadores que passam do BD para o BC e três snas que passam do BC para o BD. Os snas gerados no BC são: A palavra de mcronstrução (uns), para comandar a execução passo a passo das nstruções pelo BD. A mcronstrução é responsável por especfcar cada uma das ações untáras que serão executadas pelo hardware do BD a cada cclo de relógo, também chamadas de mcrooperações. Exemplos destas são cada uma das três seleções de regstradores a serem escrto/ldos no/do banco de regstradores, a operação que a ALU (do nglês, Arthmetc Logc Unt) executará, e os snas de controle de acesso à memóra de dados externa; O valor endereço da próxma nstrução a ser executada (conteúdo do regstrador NPC, localzado no BC); O códgo objeto da nstrução corrente (conteúdo do regstrador IR, localzado no BC). Os snas gerados no BD são: O snal salta, que contém o resultado do teste de condções de salto nas nstruções de salto condconal; O snal nst_branch, que qualfca se a nstrução ora em execução é ou não um salto condconal; Os qualfcadores end_mul e end_dv, produzdos no BD pelos operadores de multplcação e dvsão, que nformam ao BC o fnal da execução destas operações com um pulso de duração de 1 cclo de relógo em 1. Isto é necessáro porque trata-se de operações mas complexas que gastam, nesta organzação, múltplos cclos de relógo para executar. O BC comanda o níco da execução delas e aguarda pela nformação de seu térmno para segur com o fluxo normal de cclos de controle; O snal RESULT_OUT, que eventualmente contém um endereço calculado durante nstruções de salto (ncondconas ou condconas), valor este que deve ser escrto no regstrador PC, que se encontra no BC. É mportante ressaltar que o BC e o BD operam sempre e apenas na borda de subda do snal de relógo (clock). A cada borda de subda do clock (ou após a desatvação do snal de reset), o BC gera uma palavra de mcronstrução, e na borda de subda segunte o BD executa as ações comandadas por esta, modfcando seus regstradores. É necessáro que sempre se tenha dados estável antes das bordas de subda relógo em cada um dos blocos 2. A Fgura 1(b) representa um exemplo de codfcação do nível mas alto da herarqua do processador, em lnguagem VHDL. Nesta Fgura, deve-se notar que o BC e o BD são nstancados e conectados entre s por snas, conforme defndo pelos comandos port map no processo de nstancação. 2.1 Estrutura de Acesso à Memóra A partr da dscussão da Fgura 1, percebe-se que ambas as nterfaces de memóra são assíncronas, ou seja, não dependem de snas de relógo tas como o snal clock. Cada uma das nterfaces de acesso defne um mapa de memóra, conforme lustrado na Fgura 2. Um mapa de memóra é uma abstração que permte organzar as nformações às quas o processador tem acesso na forma de uma tabela. Cada posção deste mapa possu um endereço assocado e armazena um valor. Na arqutetura MIPS_S, ambos os mapas (de nstruções e de dados) possuem endereços de 32 bts e conteúdos de 8 bts assocados a cada posção da tabela. Assm, dz-se que as memóras de nstruções e de dados são endereçadas a byte (1 byte=8 bts) e cada um destes mapas possu 2 32 posções ( posções, correspondendo ao número de endereços dferentes de 32 bts, entre 0x e 0xFFFFFFFF). A memóra de nstruções armazena apenas nstruções. Cada nstrução na MIPS_S ocupa exatamente 32 bts. Assm, uma nstrução ocupa 4 posções de memóra. Como vsto na Fgura 1, contudo, o barramento de nstruções é de 32 bts. Logo, uma letura da memóra de nstruções busca desta não apenas o byte cujo endereço está no barramento _address, mas este e os três seguntes (esta é a regra dtada pela arqutetura). Uma outra lmtação mposta para facltar o acesso à memóra de nstruções é alnhar nstruções em uma frontera ntera de palavra. Esta expressão sgnfca que cada nstrução da MIPS_S só pode começar a partr de um endereço múltplo de 4, que correspondem àqueles cujos 2 últmos bts são 00. Assm, por exemplo, uma únca nstrução pode ocupar os endereços de 0xAAA00004 a 0xAAA00007 na memóra de nstruções, mas nunca os endereços 2 Deve estar claro que esta últma afrmação se verfca apenas se a frequênca de relógo for sufcentemente baxa para permtr que os snas establzem em no máxmo um período de relógo (entre duas bordas de subda consecutvas do clock).

4 - 4-0xFF a 0xFF00467A da mesma memóra, embora ambas as faxas correspondam a 4 bytes consecutvos na memóra. Dada esta stuação, o barramento _address não precsara ter 32 bts, apenas 30, pos os 2 últmos valem sempre 00. Não exstem snas de controle para acesso à memóra de nstruções além do endereço em _address. Isto não é necessáro, pos não há fluxo bdreconal de nformação. A memóra de nstruções é vsta pala organzação MIPS_S como uma memóra de apenas letura, que fornece nformações na sua saída (nstruções) a partr do estabelecmento do endereço de memóra pelo processador, va o barramento _address. A memóra de dados possu uma nterface um pouco mas complexa, devdo ao fato de poder ser lda ou escrta. Além dsto, os dados ldos ou gravados nesta memóra podem ter tamanho dversos. Estas necessdades fazem com que o acesso à nformação tenha um formato mas flexível. Por exemplo, um ntero típco ocupa 32 bts, mas um caracter ocupa exatamente 1 byte, e um número em ponto flutuante pode ser de 32 ou de 64 bts. Além dsto, estruturas complexas, tas como usadas em programação de alto nível (e.g. struct de C/Java ou record de Pascal), podem ter qualquer tamanho. Vetores e arranjos multdmensonas de números ou caracteres e de estruturas complexas complcam anda mas a stuação. Logo, a nterface de acesso da memóra de dados deve ser flexível para prover desempenho e proporconar economa de espaço. Anda assm, o barramento de dados (data) é fxo, de 32 bts. Lê-se sempre 4 bytes (ou posções) de memóra de cada vez. O que é ldo pode ser, por exemplo, 1 ntero ou 4 caracteres ou metade de um número em ponto flutuante de precsão dupla. Como a letura é alnhada em qualquer frontera, é até mesmo possível ler metade de um ntero e dos caracteres nos 32 bts. Memóra de Instruções ÁREA DE PROGRAMAS Memóra de Dados ÁREA DE DADOS FFFFFFFF FFFFFFF AC AB Instrução 2 Instrução 1 FFFFFFFF FFFFFFFE FFFFFFFD FFFFFFFC FFFFFFFF FFFFFFFE FFFFFFFD FFFFFFFC 8AB AB AB AB FFFFFFF B B B AF AE AD AC AB Intero 2 Intero 1 Caracter 4 Caracter 3 Caracter 2 Caracter 1 Número Ponto Flutuante (64bts) Fgura 2 - Ilustração da estrutura dos mapas de memóra do MIPS_S. Cada mapa possu 4Gposções de 1 byte. Cada nstrução ocupa exatamente 4 bytes consecutvos na memóra de nstruções, e sempre começa em um endereço onde os 2 últmos bts são 00 (confgurando um acesso alnhado a palavra). O controle de acesso à memóra de dados é feto pelo processador através dos snas ce, rw e bw. O snal ce ndca se está em curso uma operação com a memóra de dados (quando ce = 1) e o snal rw ndca se esta operação é de escrta (quando rw = 0) ou de letura (quando rw = 1). Obvamente, quando ce = 0 o valor do snal rw é rrelevante. O snal bw serve para ndcar se uma operação de escrta na memóra deve escrever apenas um byte na posção da memóra de dados cujo endereço aparece no barramento d_address (bw = 0) ou se esta deve escrever 4 bytes (ou seja, na posção explctada e nas três seguntes). Isto ocorre quando se faz uma escrta de palavra com bw = Uma palavra sobre Endansmo Processadores podem numerar os bytes dentro de uma palavra fazendo o byte com menor número ser ou o byte mas à esquerda ou o byte mas à dreta. A convenção usada por uma máquna é a ordem escolhda. Processadores que usam a arqutetura MIPS podem operar com qualquer das ordens. A ordem escolhda é denomnada o endansmo do processador (ou da organzação deste processador) e pode ser bg-endan ou

5 - 5 - lttle-endan. Processadores bg-endan assumem os 8 bts mas à esquerda de uma palavra (para números a parte mas sgnfcatva deste) como sendo o byte 0, os 8 bts medatamente à dreta deste como o byte 1, etc. Processadores lttle-endan assumem os 8 bts mas à dreta de uma palavra (para números a parte menos sgnfcatva deste) como sendo o byte 0, os 8 bts medatamente à esquerda deste como o byte 1, etc. O smulador a ser usado (MARS) opera com ambas as ordens. A ordem específca do MARS é determnada pela ordem dos bytes da máquna que executa o smulador. Assm, ao rodar o smulador em um PC, MARS é lttleendan, enquanto que ao rodar MARS em uma estação de trabalho Sun (baseada no processador SPARC), MARS é bg-endan. 3 CONJUNTO DE INSTRUÇÕES segur. A Tabela 1 descreve resumdamente cada nstrução da arqutetura MIPS_S, usando as convenções a Convenções Utlzadas na Tabela 1: Rd (destnaton regster) é o regstrador usado na maora das nstruções de três operandos como destno dos dados processados, especfcado por um códgo bnáro de 5 bts. Ver Seção 4; Rs (source regster) e Rt (target regster) são regstradores usados em mutas nstruções como orgem dos operandos para obter os dados. São especfcados por códgos bnáros de 5 bts. Ver Seção 4; Regstradores específcos da máquna são ndcados por $xx, onde xx é o número decmal do regstrador. Ver Seção 4; Os regstradores HI e LO são regstradores especas (que se encontram fora do banco de regstradores de uso geral) usados para armazenar os resultados das operações de multplcação e dvsão (MULTU e DIVU, respectvamente); O snal é usado para desgnar atrbução (escrta) de valores resultantes da avalação da expressão à dreta do snal ao regstrador ou posção de memóra dentfcada à esquerda do snal; Os dentfcadores med16 e med26 representam operandos medatos de 16 e 26 bts, respectvamente; O dentfcador shamt (do nglês, shft amount) representa a quantdade de bts a deslocar nas nstruções SLL, SLLV, SRA, SRAV, SRL e SRLV. O operador mod representa o resto da dvsão ntera do elemento à esquerda do mod pelo elemento à dreta deste; O operador & representa a concatenação de vetores de bts; A expressão PMEMD(X) representa o conteúdo de uma posção de memóra de dados cujo endereço é X (na letura) ou a própra posção da memóra de dados (na escrta). A quantdade de bts relevantes depende da nstrução específca executada. Por exemplo, em LW são 32 bts, em LBU são 8 bts; Está mplícto em todas as nstruções o ncremento do regstrador PC após a busca da nstrução. Na organzação, sto se reflete no uso de um regstrador temporáro denomnado NPC, que contém o valor do PC ncrementado após a busca de uma nstrução. Qualquer outra referênca à manpulação do PC é parte da semântca da nstrução partcular; Extensão de snal é a operação que transforma um dado vetor de bts em outro maor, mas cujo valor em complemento de 2 é equvalente ao valor representado pelo vetor menor. Consste em copar o bt de snal do vetor, ou seja, o seu bt mas sgnfcatvo, localzado na extrema esquerda deste, tantas vezes quanto seja necessáro, para gerar o vetor maor. Por exemplo, na nstrução ADDIU, se med16 for (-1 em complemento de 2, representado em 16 bts), a extensão de snal transforma este vetor em (-1 em complemento de 2, representado em 32 bts). A operação é trvalmente correta também para números postvos, onde o bt de snal estenddo é 0. Quando se mencona extensão de snal, os valores medatos representam números em complemento de 2. Caso contráro, os números são representações bnáras puras, como ocorre na nstrução J 3 ; Os operandos medatos das nstruções de salto têm um tratamento dferente dos operandos das nstruções que não se referem a saltos. Como o endereçamento de ambas as memóras (nstruções e dados) é feto à byte (ou seja, cada byte de memóra possu um endereço dstnto), uma nstrução ocupa quatro endereços de memóra. A CPU manpula operandos de salto multplcando eles por 4 antes de operar (o que é operaconalzado deslocando o operando dos bts à esquerda, nserndo dos 0s). Isto vale apenas para as nstruções BEQ, BGEZ, BLEZ, BNE, J e JAL. 3 CUIDADO!!: Exste um outro smulador bem conhecdo, o SPIM, onde a extensão de snal é feta sobre os 14 bts, e não sobre 16 bts (pode ser um bug do smulador ou uma defnção da arqutetura, e sto afeta a mplementação do processador aqu especfcado).

6 - 6 - Tabela 1 Mnemôncos, codfcação e semântca resumda das nstruções do processador MIPS_S. As constantes numércas dos códgos de nstrução são valores hexadecmas. Instrução FORMATO DA INSTRUÇÃO AÇÃO ADDU Rd, Rs, Rt 00 Rs Rt Rd Rd Rs + Rt SUBU Rd, Rs, Rt 00 Rs Rt Rd Rd Rs Rt AND Rd, Rs, Rt 00 Rs Rt Rd Rd Rs and Rt OR Rd, Rs, Rt 00 Rs Rt Rd Rd Rs or Rt XOR Rd, Rs, Rt 00 Rs Rt Rd Rd Rs xor Rt NOR Rd, Rs, Rt 00 Rs Rt Rd Rd Rs nor Rt SLL Rd, Rt, shamt Rt Rd shamt 00 Rd Rt deslocado shamt bts à esquerda (0s à dreta) SLLV Rd, Rt, Rs 00 Rs Rt Rd Rd Rt deslocado (Rs mod 32) bts à esquerda (0s à dreta) SRA Rd, Rt, shamt Rt Rd shamt 03 Rd Rt deslocado shamt bts à dreta (mantendo snal) SRAV Rd, Rt, Rs 00 Rs Rt Rd Rd Rt deslocado (Rs mod 32) bts à dreta (mantendo snal) SRL Rd, Rt, shamt Rt Rd shamt 02 Rd Rt deslocado shamt bts à dreta (0s à esquerda) SRLV Rd, Rt, Rs 00 Rs Rt Rd Rd Rt deslocado (Rs mod 32) bts à dreta (0s à esquerda) ADDIU Rt, Rs, Imed16 09 Rs Rt Imed16 Rt Rs + (Imed16 com snal estenddo) ANDI Rt, Rs, Imed16 0C Rs Rt Imed16 Rt Rs and (0x0000 & (Imed16)) ORI Rt, Rs, Imed16 0D Rs Rt Imed16 Rt Rs or (0x0000 & (Imed16)) XORI Rt, Rs, Imed16 0E Rs Rt Imed16 Rt Rs xor (0x0000 & (Imed16)) LUI Rt, Imed16 0F 0 Rt Imed16 Rt (Imed16 & 0x0000) LBU Rt, Imed16(Rs) 24 Rs Rt Imed16 Rt 0x & PMEMD(Imed16 com snal estenddo+rs) LW Rt, Imed16(Rs) 23 Rs Rt Imed16 Rt PMEMD(Imed16 com snal estenddo+rs) (4 bytes) SB Rt, Imed16(Rs) 28 Rs Rt Imed16 PMEMD(Imed16 com snal estenddo+rs) Rt [7:0] (1 byte) SW Rt, Imed16(Rs) 2B Rs Rt Imed16 PMEMD(Imed16 com snal estenddo+rs) Rt (4 bytes) SLT Rd, Rs, Rt 00 Rs Rt Rd 00 2A Rd 1 se Rs menor que Rt (c/snal), senão Rd 0 SLTU Rd, Rs, Rt 00 Rs Rt Rd 00 2B Rd 1 se Rs menor que Rt (s/snal), senão Rd 0 SLTI Rt, Rs, Imed16 0A Rs Rt Imed16 Rt 1 se Rs menor que Imed16 (c/snal), senão Rt 0 SLTIU Rt, Rs, Imed16 0B Rs Rt Imed16 Rt 1 se Rs menor que Imed16 (s/snal), senão Rt 0 BEQ Rs, Rt, rótulo 04 Rs Rt Imed16 PC NPC + (Imed16 & 00 com snal estenddo), se Rs=Rt BGEZ Rs, rótulo 01 Rs 01 Imed16 PC NPC + (Imed16 & 00 com snal estenddo), se Rs=>0 BLEZ Rs, rótulo 06 Rs 00 Imed16 PC NPC + (Imed16 & 00 com snal estenddo), se Rs<=0 BNE Rs, Rt, rótulo 05 Rs Rt Imed16 PC NPC + (Imed16 & 00 com snal estenddo), se Rs Rt J rótulo 02 Imed26 PC NPC[31:28] & Imed26 & 00 JAL rótulo 03 Imed26 $31 NPC; PC NPC[31:28] & Imed26 & 00 JALR Rd, Rs 00 Rs 00 Rd Rd NPC; PC Rs JR Rs 00 Rs PC Rs

7 - 7 - MULTU Rs, Rt 00 Rs Rt HI & LO Rs * Rt DIVU Rs, Rt 00 Rs Rt 000 1B LO Rs / Rt; HI Rs mod Rt MFHI Rd Rd Rd HI MFLO Rd Rd Rd LO

8 Classes Funconas de Instruções A partr da Tabela 1, propõe-se a segunte dvsão das nstruções em classes funconas: As nstruções artmétcas são ADDU, SUBU, ADDIU, MULTU, DIVU, SRA, SRAV; As nstruções lógcas são AND, OR, XOR, NOR, ANDI, ORI, XORI, SLL, SLLV, SRL e SRLV; As nstruções de movmentação de dados são LUI, LBU, LW, SB, SW, MFHI, e MFLO; As nstruções de controle de fluxo de execução são BEQ, BGEZ, BLEZ, BNE, J, JAL, JALR, e JR; Exstem também nstruções mscelâneas, SLT, SLTI, SLTU, e SLTIU. 3.2 Observações sobre a Semântca de Instruções no Processador MIPS_S Algumas observações geras e partculares sobre o conjunto de nstruções são apresentadas a segur. A arqutetura MIPS fo elaborada para prvlegar a smplcdade do conjunto de nstruções sem, contudo, sacrfcar sua flexbldade. Devdo à lmtação de todas as nstruções possuírem exatamente o mesmo tamanho, nstruções em geral dsponíves em outros processadores estão ausentes no MIPS. Contudo, fo tomado cudado no projeto desta arqutetura para que tal funconaldade possa ser suprda de forma smples va o conceto de pseudo-nstruções. Pseudo-nstruções são nstruções nexstentes em uma arqutetura, mas dsponblzadas ao programador em lnguagem de montagem. Sua mplementação medante uso de uma sequênca de nstruções exstentes é feta no códgo objeto pelo programa montador. Por exemplo, uma nstrução capaz de carregar uma constante medata de 32 bts em um regstrador obvamente não exste, mas pode ser mplementada por uma sequênca de duas nstruções, LUI e ORI. É possível a programas montadores para o processador MIPS_S dsponblzar uma pseudonstrução LI com um operando medato de 32 bts, gerando como códgo para esta uma sequênca LUI + ORI. Por exemplo, exste no montador/smulador MARS uma pseudo-nstrução (LA, do nglês load address) que usa LUI + ORI para mplementar uma função bastante útl, carregar um regstrador com o endereço de um rótulo (em nglês, label) do programa, seja este da regão de dados ou da regão de programas. As nstruções SLT, SLTU, SLTI e SLTIU servem para suprr a ausênca de bestáves qualfcadores de estado na arqutetura MIPS_S. Elas escrevem no regstrador destno da nstrução ou a constante 0 ou a constante 1, para ndcar o resultado de uma comparação de magntude. Após executar uma destas nstruções, pode-se testar o valor escrto neste regstrador de destno contra a constante 0 (por exemplo, usando as nstruções BEQ, BGEZ, BNE ou BLEZ, tendo como um dos operandos a constante 0, dsponível no regstrador $0 ou $zero). Tas sequêncas de nstrução permtem mplementar todas as comparações de gualdade ou magntude ( menor, maor, menor ou gual e maor ou gual ). Exercíco: Proponha uma sequênca de nstruções do processador MIPS_S para mplementar as seguntes pseudo-nstruções: BGT, BGE, BLT e BLE (respectvamente, salta se maor, se maor ou gual, se menor e se menor ou gual relatvo). Note-se anda que as varações das nstruções SLTxx permtem executar comparações de números naturas (as com sufxo U, do nglês unsgned) e de números nteros representados em complemento de 2 (as sem sufxo U). 4 REGISTRADORES DO PROCESSADOR MIPS_S - BD A partr desta Seção da especfcação, apresenta-se uma possível organzação para o processador MIPS_S. Algumas das característcas menconadas aqu são partes da arqutetura. Isto será explctado no texto a segur, quando for o caso. A organzação aqu proposta contém, pelo menos, o segunte conjunto de regstradores: Um banco de regstradores contendo 32 regstradores de uso geral, cada um de 32 bts, denomnados $0 a $31. Esta é uma característca defnda pela arqutetura. Exste uma denomnação textual alternatva para cada um dos regstradores. Ela está apresentada na Tabela 2 abaxo, retrada do Apêndce A do lvro Organzação e Projeto de Computadores de D. A. Patterson e J. L. Hennessy. Este Apêndce é de domíno públco e pode ser faclmente encontrado na Internet. O banco de regstradores proposto aqu tem uma porta de escrta e duas de letura. Isto sgnfca que é possível escrever em apenas um regstrador por vez, porém é possível fazer, em paralelo com a escrta menconada, duas leturas smultâneas, colocando o conteúdo de um regstrador no barramento de saída R1 e o conteúdo de outro regstrador (ou o mesmo) no barramento de saída R2;

9 - 9 - Regstradores RS, RT e IMED: São regstradores que rão conter os operandos da maora das nstruções executadas; RALU: um regstrador de 32 bts usado para armazenar o resultado produzdo pela ALU; HI e LO: são dos regstradores de 32 bts usados para armazenar o resultado da execução das nstruções MULTU e DIVU. Para manpular estes resultados, exstem as nstruções MFHI e MFLO, que movem valores de HI e LO para um regstrador de uso geral. A necessdade destes regstradores se explca pelo fato de uma multplcação de dos números de 32 bts gerar um valor de 64 bts, bem como pelo fato de uma dvsão (ntera) gerar dos resultados de 32 bts, o quocente e o resto. No caso da nstrução DIVU, o quocente é colocado em LO e o resto é colocado em HI; MDR (memory data regster): é regstrador que recebe dados provenentes da memóra ou de outro local que produza um valor que necesste ser escrto no banco de regstradores no últmo cclo de uma nstrução. Possu 32 bts; Tabela 2 Denomnações dos regstradores da arqutetura MIPS_S. Aconselha-se que os regstradores a serem usados como regstradores de trabalho em programas sejam os regstradores 2 a 25 ($v0 a $t9). Os demas são reservados para operações de controle do montador, sstema operaconal, smulação de plhas, etc. O montador MARS aceta a denomnação da prmera coluna da tabela, ou da segunda coluna, precedda do caracter $. Nome Número Nome Sgnfcado ou Convenção de Utlzação (hexa/bnáro) Alternatvo $0 00 / $zero constante 0 $1 01 / $at reservado para o programa montador $2 02 / $v0 resultado de função $3 03 / $v1 resultado de função $4 04 / $a0 argumento para função $5 05 / $a1 argumento para função $6 06 / $a2 argumento para função $7 07 / $a3 argumento para função $8 08 / $t0 temporáro $9 09 / $t1 temporáro $10 0A / $t2 temporáro $11 0B / $t3 temporáro $12 0C / $t4 temporáro $13 0D / $t5 temporáro $14 0E / $t6 temporáro $15 0F / $t7 temporáro $16 10 / $s0 temporáro (salvo nas chamadas de função/subrotna) $17 11 / $s1 temporáro (salvo nas chamadas de função/subrotna) $18 12 / $s2 temporáro (salvo nas chamadas de função/subrotna) $19 13 / $s3 temporáro (salvo nas chamadas de função/subrotna) $20 14 / $s4 temporáro (salvo nas chamadas de função/subrotna) $21 15 / $s5 temporáro (salvo nas chamadas de função/subrotna) $22 16 / $s6 temporáro (salvo nas chamadas de função/subrotna) $23 17 / $s7 temporáro (salvo nas chamadas de função/subrotna) $24 18 / $t8 temporáro $25 19 / $t9 temporáro $26 1A / $k0 reservado para o SO $27 1B / $k1 reservado para o SO $28 1C / $gp apontador de área global $29 1D / $sp stack ponter $30 1E / $fp frame ponter $31 1F / $ra armazena endereço de retorno de subrotnas Normalmente, sempre há a necessdade de exstrem regstradores adconas, dependendo da organzação mplementada. Na organzação proposta aqu, o valor do regstrador PC é atualzado após a busca, mas o novo valor não é medatamente escrto em PC, mas em um regstrador auxlar NPC, sgla dervada da termnologa new program counter, em nglês. Apenas no últmo cclo de relógo de uma nstrução o valor de NPC (ou outro, dependendo da nstrução) é escrto no PC. Os valores ldos do banco de regstradores são armazenados nos regstradores Rs e Rt, e o valor obtdo pela execução de uma dada operação lógco-artmétca é armazenado no regstrador RALU. Apresentam-se detalhes nas Seções a segur. 5 ORGANIZAÇÃO DO BD DO PROCESSADOR MIPS_S Com a organzação proposta nesta Seção para o processador MIPS_S, a execução de qualquer nstrução requer 3 a 5 cclos de relógo, com a exceção das nstruções MULTU e DIVU. Cada um dos 3/4/5 cclos executa um conjunto lmtado de partes de uma nstrução e são assm denomnados: Cclo 1: busca da nstrução. Comum a todas as nstruções.

10 comparador Memóra de Instruções RALU=d_address ALU Memóra de Dados ads MDR_nt D_H D_Lo Cclo 2: decodfcação e letura de regstradores. Comum a todas as nstruções. Cclo 3: operação com a ALU. Comum a quase todas as nstruções. Cclo 4: acesso à memóra. Realzado conforme a nstrução. Cclo 5: atualzação do banco de regstradores (wrte-back). Comum a quase todas as nstruções. Em todas as nstruções que não fazem acesso à memóra, o Cclo 4 não exste e o cclo 5 passa a ser o Cclo 4. Esta Seção dscute uma proposta de organzação para o BD do processador MIPS_S. A Fgura 3 mostra o dagrama de blocos completo do processador MIPS_S, nclundo o BD e o BC. O BD necessta de um conjunto de snas de controle, organzados em 5 classes: habltação de escrta em regstradores (7, alguns atvando dos ou mas regstradores): wpc, CY1, wreg, CY2, walu, whlo, wmdr. controle de letura/escrta na memóra externa (3): ce, rw e bw. as operações que a undade lógca-artmétca, executa (1). Estas são computadas a partr da nstrução ora Rs sendo executada, o que é nformado através do resultado da decodfcação (snal ). a seleção da operação do comparador (1), também computada a partr da nstrução ora em execução (snal ). os controles dos multplexadores, resultantes da decodfcação da nstrução (11). Estes snas são gerados dretamente da nstrução sendo executada (snal ) e eventualmente de outros snas de controle como a saída do comparador. Máquna de Estados wreg wpc CY1 CY2 rw whlo walu ce rst_md wmdr bw pc=_address dtpc I/ salta_n PC wpc pc=_address Decodfcação npc=npc_out=npc nc_pc +4 NPC CY1 CY1 IR IR[15:11] IR[25:21] IR_IN=IR=IR_OUT IR nstructon NPC IR[20:16] IR[20:16] IR[15:0] IR[25:0] IR[15:0] end_dv NPC IR[20:16] AdWP DataWP AdRP1 R1 DataRP1 Banco de Regstradores EXT SINAL << & IR[25:0] & 00 EXT ZERO end_mul add RESULT RIN DataRP2 AdRP2 R2 wreg npc Rs CY2 Rt cte_m IMED CY2 Rs Rt Rs Rt DIV rst_md rst_md MULT IMED op1 op2 Rs Rt quocente resto produto(63 downto 32) produto(31 downto 0) whlo Lo H whlo outalu RALU walu salta_n= salta= salta_out Lo H MDR ce rw bw Fgura 3 Dagrama de blocos completo do processador MIPS_S, com as memóras externas (de nstruções e de dados) mostradas para fns de clareza. Estão representados todos os 23 snas que o bloco de controle deve gerar (a maora em verde). Os snas clock e reset não estão representados, porém são utlzados em todos os regstradores, bem como no banco de regstradores e na Máquna de Estados do Bloco de Controle. O BD gera três snas qualfcadores que são envados para o BC, para que este tome algumas decsões (snas end_mul, end_dv e salta) Os snas de controle dos multplexadores não são gerados no BC. Eles são dervados dretamente da nstrução corrente. Para uma dea geral mas completa da mplementação do BD do processador MIPS_S, restam apresentar as organzações nternas do banco de regstradores, da undade lógca e artmétca, das operações de multplcação e dvsão e o Bloco de Controle (BC) do MIPS_S. As três Seções a segur dscutem as organzações dos três prmeros blocos ctados, enquanto a Seção 7 dscute o BC. Rt x & data[7:0] data Rt rw ce MDR wmdr

11 5.1 Banco de Regstradores A Fgura 4 lustra a organzação do banco de regstradores, sob forma de um dagrama de blocos. A ALU será dscutda em parte na Seção 5.2. A organzação do banco de regstradores nclu os 32 regstradores em s e a mplementação das duas portas de letura e da porta de escrta, bem como da decodfcação do endereço de escrta para geração da habltação de escrta do regstrador em causa. As portas de letura consstem de multplexadores (32X32):(1X32), controladas pelos endereços de letura. DataWP regstradores de 32 bts REG0 REG1 REG2 REG3 REG4 ck 32 REG28 REG29 REG30 REG31 rst 32 DataRP1 AdRP1 Decodfcador 5 32 enable 32 DataRP2 ce 5 AdWP AdRP2 Fgura 4 - Dagrama em blocos do banco de regstradores de uso geral. 5.2 Resumo das Operações Executadas pela ALU A Tabela 3 lustra a operação do hardware da ALU. Esta últma é um hardware combnaconal que possu duas entradas de dados e uma saída de dados. Além dsto, a ALU possu uma entrada de controle para nformar a operação a ser realzada em cada nstante, dervada da nstrução em execução no momento. Tabela 3 Operações da ALU no processador MIPS_S, para cada nstrução. Instruções ADDU, ADDIU, LBU, LW, SB, SW, BEQ, BGEZ, BLEZ, BNE SUBU AND, ANDI OR, ORI XOR, XORI NOR SLL SLLV SRA SRAV SRL SRLV LUI SLT, SLTI SLTU, SLTIU Operação da ALU OP2 + OP1 OP2 OP1 OP2 and OP1 OP2 or OP1 OP2 xor OP1 OP2 nor OP1 OP1 << OP2[10:6] c/ 0s entrando à dreta OP2 << OP1[4:0] c/ 0s entrando à dreta OP1 >> OP2[10:6] c/ bt 31 entrando à esquerda OP2 >> OP1[4:0] c/ bt 31 entrando à esquerda OP1 >> OP2[10:6] c/ 0s entrando à esquerda OP2 >> OP1[4:0] c/ 0s entrando à esquerda OP2[15:0] & 0x se OP1<OP2 (com snal), senão 0 1 se OP1<OP2 (sem snal), senão 0 J, JAL OP1[31:28] & OP2[27:0] JR, JALR MULTU, DIVU, MFHI, MFLO OP1 Nenhuma operação

12 A operação da ALU é relevante para quase todas as nstruções, embora algumas destas apenas a utlzem para transportar um valor da entrada para a saída e outras (como MULTU e DIVU) sequer utlzam a ALU. O resultado da operação na ALU é armazenado no regstrador RALU. A Tabela 3 defne quas devem ser as operações da ALU, para cada nstrução. 5.3 Organzação para as nstruções MULTU e DIVU As nstruções MULTU e DIVU, que realzam a multplcação e a dvsão de números nteros sem snal, devdo a sua ntrínseca maor complexdade, são mplementadas fora da ALU. Na presente proposta de mplementação as nstruções DIVU e MULTU são ser mplementadas de manera estrutural, usando texto VHDL sntetzável. Para tanto, pode-se usar um algortmo de mplementação de um multplcador em hardware, tal como descrto nas transparêncas 10 a 17 da apresentação dsponível no lnk mostrado abaxo. O algortmo de multplcação pode ser aquele descrto nas transparêncas acma. O algortmo de dvsão deve ser o algortmo sem restauração. Estes e outros algortmos fáces de mplementar sob a forma de um pequeno bloco de dados e uma máquna de estados de controle estão descrtos em algum detalhe no do lvro Organzação e Projeto de Computadores de D. A. Patterson e J. L. Hennessy, na Seção 4.6 da segunda edção deste lvro. 6 CICLOS PARA EXECUTAR INSTRUÇÕES DA ORGANIZAÇÃO MIPS_S Dada a descrção da organzação do bloco de dados da MIPS_S apresentada na Seção anteror, é possível sumarzar o tempo de execução de todas as nstruções em termos de cclos de relógo, o que é então mostrado na Tabela 4 abaxo. Tabela 4 Número de cclos gastos para buscar e executar nstruções na organzação do processador MIPS_S. INSTRUÇÃO NUMERO DE CICLOS INSTRUÇÃO NUMERO DE CICLOS ADDU 4 SB 4 SUBU 4 SW 4 AND 4 SLT 4 OR 4 SLTU 4 XOR 4 SLTI 4 NOR 4 SLTIU 4 SLL 4 BEQ 4 SLLV 4 BGEZ 4 SRA 4 BLEZ 4 SRAV 4 BNE 4 SRL 4 J 4 SRLV 4 JAL 4 ADDIU 4 JALR 4 ANDI 4 JR 4 ORI 4 MULTU 67 4 XORI 4 DIVU 67 5 LUI 4 MFHI 4 LBU 5 MFLO 4 LW O Bloco de Controle (BC) do processador MIPS_S Para comandar a execução de nstruções neste processador, o BC do processador MIPS_S possu um conjunto de quatro estruturas de hardware. São estas: Um regstrador que guarda o códgo da nstrução atualmente em execução (IR); Estruturas para controlar a posção de memóra onde resde a nstrução atual e a próxma a ser executada, compostas por dos regstradores (PC e NPC) e um ncrementador; 4 Valor típco, depende do algortmo escolhdo. 5 Valor típco, depende do algortmo escolhdo.

13 A decodfcação de nstruções, uma tabela que para cada códgo de 32 bts contdo no IR dentfca a nstrução que este representa, ou o fato de o códgo não se referr a nenhuma nstrução válda (valor nvald_nstructon); Uma máquna de estados de controle, que gera uma sequênca de snas usados em cada cclo de execução de uma nstrução; A Fgura 5 lustra a máquna de estados de controle, onde o próxmo estado é função apenas do estado atual e da nstrução armazenada no regstrador IR. Também se ndca nesta Fgura quas regstradores são alterados em cada estado. Não se mostra as atvações dos snas de controle dos multplexadores, ou as operações da ALU. IR (nstructon regster): armazena o códgo de operação (opcode) da nstrução atual e o(s) códgo(s) do(s) operando(s) desta. Possu 32 bts. PC (program counter): é o contador de programa. Possu 32 bts. Também se ndca nesta Fgura quas regstradores são alterados, através da ndcação de qual snal de controle de habltação de escrta é atvado em cada estado. Não se mostram as atvações dos snas de controle dos multplexadores, ou as operações da ALU. A função dos 7 estados mostrados na Fgura pode ser assm descrta: Sfetch: prmero cclo, busca de nstrução; SReg: segundo cclo, letura dos regstradores fonte; SAlu: tercero cclo, operação com a ALU e eventual uso do comparador do hardware de multplcação ou do hardware de dvsão; Wbk: quarto cclo para a maora das nstruções, onde se escreve o resultado no banco de regstradores e atualza-se o contador de programa (qunto cclo para as nstruções LW e LBU); Sld: quarto cclo das nstruções LW e LBU, onde se lê um dado da memóra de dados externa; Sst: últmo cclo das nstruções SW e SB, onde se escreve um dado na memóra de dados externa; Ssalta: últmo cclo das nstruções de salto condconal ou ncondconal, apenas atualza valor do PC. Reset= 1 (todos os regstradores são zerados) Sfetch CY1 Reset= 1 Sreg CY2 rst_md, se IR=MULTU/DIVU IR=(MULTU e end_mul= 0 ) ou (DIVU e end_dv= 0 ) IR=(MULTU e end_mul= 1 ) ou (DIVU e end_dv= 1 ) wpc, whlo walu Salu Caso geral IR=LBU/ LW IR=SB/ SW IR =J/JAL/JALR/JR /BEQ/ BGEZ/BLEZ/BNE Swbk wreg wpc Sld ce wmdr Sst rw0, ce, wpc bw0, se IR=SB Ssalta wpc wreg, se IR=JAL/JALR Fgura 5 - Máquna de estados de controle para a organzação MIPS_S.

14 PROGRAMA PARA TESTAR TODAS AS INSTRUÇÕES DA MIPS_S Recomenda-se escrever os programas em lnguagem de montagem (assembly), gerando-se o códgo objeto automatcamente, a partr do montador/smulador MARS. A ferramenta de smulação, assm como documentação de como utlzar a ferramenta encontra-se na homepage da dscplna, podendo também serem encontradas faclmente na Internet. A Fgura 6 abaxo apresenta um programa escrto em lnguagem de montagem para o processador MIPS_S, contendo pelo menos uma nstânca de cada uma das nstruções do processador. Recomenda-se o uso do smulador MARS para executar este programa e verfcar sua funconaldade, descrta lnha a lnha do programa, através do campo de comentáros.

15 ##################################################################### ## ARQUITETURA MIPS_S - teste de todas as nstruções ## Autor: Ney Calazans (calazans@nf.pucrs.br) ## Teste é exaustvo quanto ao total de nstruções, não quanto a ## cobertura de caso de testes possíves ## Últma alteração: 08/12/2009 #####################################################################.text # Declaração de níco do segmento de texto.globl man # Declaração de que o rótulo man é global ######################################## # testes de nstruções ndvduas ######################################## man: lu $t0,0xf3 # or $t0,$t0,0x23 # $t0<= 0x00f30023 lu $t1,0x52 # or $t1,$t1,0xe2 # $t1<= 0x005200e2 lu $t2,0x00 # or $t2,$t2,0x8f # $t2<= 0x f beq $t1,$t2,loop # Obvamente, esta nstrução nunca deve saltar bne $t1,$t2,next_ # Obvamente, esta nstrução sempre deve saltar addu $t2,$t2,0x8f # Obvamente, esta nstrução nunca deve executar next_: addu $t3,$t0,$t1 # $t3<= 0x00f x005200e2 = 0x subu $t4,$t0,$t1 # $t4<= 0x00f x005200e2 = 0x00a0ff41 subu $t5,$t1,$t1 # $t5<= 0x0 and $t6,$t0,$t1 # $t6<= 0x00f30023 and 0x005200e2 = 0x or $t7,$t0,$t1 # $t7<= 0x00f30023 or 0x005200e2 = 0x00f300e3 xor $t8,$t0,$t1 # $t8<= 0x00f30023 xor 0x005200e2 = 0x00a100c1 nor $t9,$t0,$t1 # $t9<= 0x00f30023 nor 0x005200e2 = 0xff0cff1c multu $t0,$t1 # H & Lo <= 0x00f30023 * 0x005200e2 = 0x00004dd6e1bc1ee6 mfh $s0 # $s0<= 0x00004dd6 mflo $s1 # $s1<= 0xe1bc1ee6 dvu $t0,$t1 # H,Lo<= 0x00f30023 mod,/ 0x005200e2 = 0x4efe5f,0x addu $t0,$t0,0x00ab # $t0<= 0x00f x000000ab = 0x00f300ce and $t0,$t0,0x00ab # $t0<= 0x00f300ce and 0x000000ab = 0x a xor $t0,$t0,0xffab # $t0<= 0x a xor 0x0000ffab = 0x0000ff21 sll $t0,$t0,4 # $t0<= 0x000ff210 (deslocado 4 bts para a esquerda) srl $t0,$t0,9 # $t0<= 0x000007f9 (deslocado 9 bts para a dreta) addu $s2,$zero,8 # $s2<= 0x sllv $t0,$t9,$s2 # $t0<= 0x0007f900 sllv $t0,$t0,$s2 # $t0<= 0x07f90000 sllv $t0,$t0,$s2 # $t0<= 0xf sra $t0,$t0,4 # $t0<= 0xff srav $t0,$t0,$s2 # $t0<= 0xffff9000 srlv $t0,$t0,$s2 # $t0<= 0x00ffff90 la $t0,array # coloca em $t0 o endereço ncal do vetor array (0x ) lbu $t1,6($t0) # $t1<= 0x000000ef (prmero byte é tercero byte do segundo elemento) xor $t1,$t1,0xff # $t1<= 0x , nverte byte nferor sb $t1,6($t0) # segundo byte do segundo elemento do vetor <= 10 (resto não muda) # CUIDADO, mudou elemento do array a ser processado por soma_ct addu $t0,$zero,0x1 # $t0<= 0x subu $t0,$zero,$t0 # $t0<= 0xffffffff bgez $t0,loop # Esta nstrução nunca deve saltar, pos $t0 = -1 slt $t3,$t0,$t1 # $t3<= 0x , pos -1 < 10 sltu $t3,$t0,$t1 # $t3<= 0x , pos (2^32)-1 > 10 slt $t3,$t0,0x1 # $t3<= 0x , pos -1 < 1 sltu $t3,$t0,0x1 # $t3<= 0x , pos (2^32)-1 > 1 ######################################## # soma uma constante a um vetor ######################################## soma_ct:la $t0,array # coloca em $t0 o endereço do vetor (0x ) la $t1,sze # coloca em $t1 o endereço do tamanho do vetor lw $t1,0($t1) # coloca em $t1 o tamanho do vetor la $t2,const # coloca em $t2 o endereço da constante lw $t2,0($t2) # coloca em $t2 a constante loop: blez $t1,end_add # se/quando tamanho é/torna-se 0, fm do processamento lw $t3,0($t0) # coloca em $t3 o próxmo elemento do vetor addu $t3,$t3,$t2 # soma constante sw $t3,0($t0) # atualza no vetor o valor do elemento addu $t0,$t0,4 # atualza pontero do vetor. Lembrar, 1 palavra=4 posções de memóra addu $t1,$t1,-1 # decrementa contador de tamanho do vetor j loop # contnua execução ######################################## # teste de subrotnas annhadas ######################################## end_add:addu $sp,$sp,-4 # assume-se $sp ncalzado, aloca espaço na plha. Usamos 0x sw $ra,0($sp) # salva endereço de retorno de quem chamou (trap handler) jal sum_tst # salta para subrotna sum_tst lw $ra,0($sp) # ao retornar, recupera endereço de retorno da plha addu $sp,$sp,4 # atualza apontador de plha end: jr $ra # volta para o "sstema operaconal" FIM DO PROGRAMA AQUI # Iníco da prmera subrotna: sum_tst sum_tst:la $t0,var_a # pega endereço da prmera varável (pseudo-nstrução) lw $t0,0($t0) # toma o valor de var_a e coloca em $t0 la $t1,var_b # pega endereço da segunda varável (pseudo-nstrução) lw $t1,0($t1) # toma o valor de var_b e coloca em $t1 addu $t2,$t1,$t0 # soma var_a com var_b e coloca resultado em $t2 addu $sp,$sp,-8 # aloca espaço na plha sw $t2,0($sp) # no topo da plha coloca o resultado da soma sw $ra,4($sp) # abaxo do topo coloca o endereço de retorno la $t3,ver_ev # pega endereço da subrotna ver_ev (pseudo-nstrução) jalr $ra,$t3 # chama subrotna que verfca se resultado da soma é par lw $ra,4($sp) # ao retornar, recupera endereço de retorno da plha addu $sp,$sp,8 # atualza apontador de plha jr $ra # PROGRAMA ACABA AQUI. Retorna para quem chamou # Iníco da segunda subrotna: ver_ev. Trata-se de subrotna folha, que não usa plha ver_ev: lw $t3,0($sp) # tra dados to topo da plha (parâmetro) and $t3,$t3,1 # $t3 <= 1 se parâmetro é ímpar, 0 caso contráro jr $ra # e retorna ########################################.data # área de dados ######################################## # para trecho que soma constante a vetor array:.word 0xabcdef03 0xcdefab18 0xefabcd35 0xbadcfeab 0xdcfebacd 0xfebadc77 0xdefabc53 0xcbafed45 # tercero byte da segunda palavra (0xef) vra 0x10 antes de exec soma_ct sze:.word 0x8 const:.word 0xffffffff # constante -1 em complemento de 2 # para trecho de teste de chamadas de subrotnas var_a:.word 0xff # var_b:.word 0x100 # Fgura 6 - Programa exemplo para teste da organzação MIPS_S.

16 O smulador MARS pode gerar arquvos de saída contendo o códgo objeto das áreas de dados e de nstruções de qualquer programa, entre outras nformações. Tas arquvos podem ser salvos usando a opção de menu Fle Dump Memory do smulador. Ele será útl para gerar a entrada do processo de smulação da mplementação de hardware a ser realzada neste trabalho. A Fgura 7 mostra a nterface gráfca do smulador, composta de 5 subjanelas (4 subjanelas estão ocultas, aquela da aba Fle, que mostra o edtor de textos do ambente Mars, duas outras para uso de coprocessadores e uma para operações de entrada e saída): a subjanela Text Segment mostra as nstruções do programa ora em smulação, em três formatos: códgo-objeto, códgo ntermedáro e códgo fonte; a subjanela Data Segment mostra os dados do programa ora em smulação; a subjanela Labels mostra dados sobre os rótulos do programa, tanto da área de nstruções como da área de dados; a subjanela Regsters mostra os conteúdos dos regstradores da arqutetura; a subjanela Mars Messages mostra mensagens que o montador/smulador gera para o usuáro durante a carga, montagem e execução de programas. A ferramenta de montagem tem como entrada o nome do programa descrto em lnguagem de montagem (tpcamente com nome <fle>.asm). É possível gerar um arquvo de saída com o conteúdo de todas as janelas, nclundo o códgo objeto gerado. Este mas tarde poderá, após algum tratamento manual, ser usado como entrada para a smulação VHDL do processador. O códgo objeto pode ser gerado após a letura e montagem de um arquvo contendo um programa em lnguagem de montagem correto. Para tanto, basta salvar como em arquvos texto as áreas de nstruções e dados como vsto em aula. Fgura 7 - Interface gráfca do montador/smulador MARS.