# Arquitetura MIPS

MIPS, acrônimo para Microprocessor without interlocked pipeline stages (microprocessador sem estágios intertravados de pipeline), é uma arquitetura de microprocessadores RISC desenvolvida pela MIPS Computer Systems.
Em meados de 1990s estimou-se que um em cada três microprocessadores RISC era MIPS.
Os processadores MIPS são usados em aplicações tais como:
* Computadores da Silicon Graphics;
* Muitos sistemas embarcados;
* Dispositivos com Windows CE;
* Roteadores da Cisco;
* Videogames como Nintendo 64 e PlayStation.

## Arquitetura

O MIPS é uma arquitetura baseada em registrador, ou seja, a CPU usa apenas registradores para realizar as suas operações aritméticas e lógicas. Existem outros tipos de processadores, tais como processadores baseados em pilha e processadores baseados em acumuladores. Processadores baseados no conjunto de instruções do MIPS estão em produção desde 1988. Ao longo do tempo foram feitas várias melhorias do conjunto de instruções. As diferentes revisões que foram introduzidas são MIPS I, MIPS II, MIPS III, MIPS IV e MIPS V. Cada revisão é um super conjunto de seus antecessores. Quando a MIPS Technologies saiu da Silicon Graphics em 1998, a definição da arquitetura foi alterada para definir um conjunto de instruções MIPS32 de 32 bits e um MIPS64 de 64 bits.
Existem diversas extensões opcionais, incluindo MIPS-3D, que é um conjunto simples de instruções SIMD de ponto flutuante, dedicado a tarefas comuns em 3D; MDMX (MaDMaX) que é um conjunto de instruções SIMD inteiras mais extenso usando os registradores de ponto flutuante de 64 bits; MIPS16e que adicionou compressão ao fluxo de instruções de modo que os programas ocupassem menos espaço na memória; e MIPS MT, que adicionou capacidade multithreading ao MIPS.
Diversos cursos de arquitetura de computadores em universidades e escolas técnicas frequentemente estudam a arquitetura MIPS. A arquitetura influenciou fortemente projetos posteriores de arquitetura como os processadores da linha Alpha, lançado pela Digital Equipment Corporation (DEC).

## História

Um grupo liderado por David Patterson e Carlo Séquin, em Berkeley, desenvolveu chips processadores; para dar um nome a este conceito eles utilizaram o termo RISC, atribuindo ao chip desenvolvido por eles nessa filosofia o nome RISC I, no ano de 1980. Esse chip foi quase imediatamente seguido pelo RISC II, projetado pelos mesmos dois pesquisadores. Pouco mais tarde, em 1981, John Hennessy, pesquisador de Stanford, universidade situada do outro lado da baía de San Francisco, projetou e fabricou um chip diferente, ao qual ele deu o nome de MIPS. O conceito básico era aumentar muito o desempenho com o uso de pipelines profundos para as instruções, uma técnica que, embora boa, viria a revelar-se difícil de levar a cabo. Geralmente, um pipeline divide a tarefa de executar uma instrução em diversas etapas, executando, de forma sobreposta, várias instruções ao mesmo tempo. Porém, os projetos tradicionais da época esperavam para terminar uma instrução inteira antes de seguir adiante, deixando assim o processador sem fazer nada por boa parte do tempo enquanto uma instrução era concluída.
Apesar das várias dificuldades surgidas no momento da implementação de um processador com pipeline, o mais preocupante eram as medidas de verificação de término de instruções, quando estas duravam mais que um ciclo de clock. Estas medidas impedem o carregamento de novos dados antes da conclusão da instrução, provocando uma pausa no carregamento do pipeline. Isto poderia prejudicar o desempenho no futuro, mas para o projeto MIPS todas as instruções necessárias deveriam ser concluídas em um único ciclo, assim não haveria este problema. Esta foi uma escolha que simplificou e acelerou o projeto, mas também trouxe desvantagens óbvias, como a eliminação de instruções úteis, tais como multiplicação e divisão que requerem múltiplos passos. Alguns observadores notaram que o projeto MIPS (abrangendo a filosofia RISC), exige que o programador substitua as instruções de multiplicações e divisões com uma série de operações simples e, portanto, a melhoria do desempenho foi eliminada ou reduzida em boa parte.
Os analistas responsáveis pela eliminação dessas instruções foram bastante controversos, e muitos pensaram que o MIPS (RISC e processadores em geral) não se concretizaria. Se uma única instrução tem de ocorrer em meio a outras, o tempo total seria o mesmo de uma instrução executada após a outra, então onde estaria o aumento de velocidade? Esta análise simplista, não considerou que a chave para a velocidade do processador estava nos pipelines.
Hennessy começou a acreditar no potencial da arquitetura, e formou a MIPS Computer Systems, no ano de 1984. A empresa apresentou seu primeiro projeto, o R2000, em 1985 como a primeira máquina comercial RISC, as falhas encontradas nesta máquina foram corrigidas com o lançamento do R3000 em 1988. Este projeto era a base da companhia na década de 1980, e foi utilizado principalmente em algumas séries de estações de trabalho da Silicon Graphics Inc. Estes projetos comerciais deram início, na Stanford, a uma série de pesquisas acadêmicas em áreas como a implementação da maioria dos bloqueios de hardware e instruções completas para a multiplicação e divisão, entre outros.
Os novos processadores criados por Hennessy eram muito diferentes dos processadores comercializados na época. Considerando que tais processadores não precisavam ser compatíveis com nenhum outro, seus projetistas tinham toda a liberdade para escolher novos conjuntos de instruções que viessem a maximizar o desempenho do sistema. Apesar de a ênfase inicial ter privilegiado instruções simples, que pudessem ser executadas rapidamente, logo ficou clara a importância de se projetarem instruções que pudessem ser iniciadas prontamente, como questão fundamental para o bom desempenho. O tempo que uma instrução leva para ser executada passou a importar menos do que a quantidade de instruções que pudessem ser iniciadas em um ciclo.
O primeiro microprocessador de 64 bits utilizando a tecnologia MIPS chega ao mercado em 1991; o R4000TM também pode executar facilmente aplicações de 32 bits mesmo que o processador esteja rodando em 64 bits. Os principais destaques do R4000TM são: 64 bits em unidade lógica aritmética (ULA) e 64 bits em espaço de endereço virtual.
A Silicon Graphics Inc., adquire a MIPS Computer Systems em 1992, dando sequência ao desenvolvimento de microprocessadores MIPS através do seu Grupo, e incorpora MIPS Technologies, Inc. como uma subsidiária de propriedade da SGI. Três anos depois o R4700 entra no mercado como uma versão de baixo custo levando o título de microprocessador do ano.
Em 1996, a arquitetura MIPS tornou-se arquitetura RISC que teve maior ascensão no mundo, com 19,2 milhões de processadores licenciados MIPS. No ano seguinte foram licenciados 48 milhões de processadores fazendo com que a arquitetura mips ultrapassesse o processador 68000 Motorola com tecnologia CISC.
Em 1998, estava claro que havia um mercado emergente onde microprocessadores 32-bit poderiam trabalhar em desktops para uso nas casas. Como o custo de projetar e fabricar microprocessadores baseados na tecnologia MIPS diminuiu, foi um grande momento para a MIPS atender diretamente o mercado. Em 30 de junho de 1998, a MIPS Technologies lançou oferta como empresa de Sociedade Anônima. E em 1999, os padrões de arquitetura MIPS64 e MIPS32 são introduzidos, incorporando todas as instruções MIPS anteriores ao conjunto destas arquiteturas e fornecendo uma base para todo o desenvolvimento futuro dos processadores MIPS.
No ano 2001 são apresentadas melhorias para as arquiteturas MIPS32 e MIPS64. Estas melhorias são intituladas como “versão 2” da arquitetura, obtendo de novo o mais alto desempenho da indústria com 32 bits disponíveis. Posteriormente é apresentado um pequeno processador, de alto desempenho e baixo consumo de energia, o MIPS32 M4K® core, projetado para múltiplos núcleos de CPU, logo substituído pelo MIPS32 24k, com núcleos de alta performance.
Em 2007, a MIPS Technologies adquire a Chipidea, empresa voltada para o projeto e fabricação de semicondutores. Agora, com mais de 250 milhões de clientes ao redor do mundo, a empresa tem o controle de alguns dos produtos mais populares do mundo para o entretenimento digital, redes domésticas sem fio, e mercados de mídia portáteis. No mesmo ano anuncia uma entrada estratégica no mercado de microcontroladores com 32 bits. Também em 2007, o próprio recorde em fabricação de processadores foi mais uma vez quebrado com mais de 350 milhões de unidades expedidas durante todo o ano.
Após dez anos como uma empresa de Sociedade Anônima, a MIPS Technologies introduz o MIPS Navigator Integrated Component Suite (ICS) com o intuito de permitir que desenvolvedores giram mais facilmente o código e possam depurar e analisar sistemas Linux em MIPS-BasedTM e sistemas embarcados. Agora a MIPS Tecnologies tem cinco grandes famílias de núcleos de processador com opções de configuração robusta para uma ampla gama de mercados e aplicações, bem como quatro grandes linhas de produtos analógicos. Além disto, a MIPS Technologies em 2008 apresenta um completo portfólio de ferramentas de desenvolvimento com algumas das soluções mais avançadas da indústria para ajudar os desenvolvedores a diminuir custos e obter mais rapidamente um elevado grau de confiança no mercado.
Em 2009, a MIPS Technologies publicou informações sobre o uso do Android em processadores MIPS. Os desenvolvedores podem usar esta plataforma para dispositivos de consumo, tais como, televisores digitais, dispositivos móveis de internet, telefones celulares, players de mídia e sistemas de VoIP em casa. Também foi oferecido um programa de acesso a fabricantes de produtos, que poderão ter contato com engenheiros da empresa e fazer adaptações específicas de software e hardware utilizando o Android.
Neste mesmo ano a MIPS anunciou sua aproximação do sistema do Google durante a feira Computex, na China, mostrando um tocador de mídia residencial e uma tela LCD de 10,4 polegadas com um computador portátil rodando o sistema Android. Estes foram os primeiros produtos fora da categoria de celulares e smartphones com o sistema do Google.

## Família do processador central

O primeiro modelo comercial do processador MIPS, o R2000, foi anunciado em 1985. Adicionou instruções de multiplicação e divisão inteiras realizadas em múltiplos ciclos de relógio em uma unidade um tanto quanto independente dentro do chip. Novas instruções foram adicionadas para recuperar os resultados de volta dessa unidade para o banco de registradores. Ironicamente essas instruções de recuperação de resultados eram inter-travadas, o que fazia o nome MIPS ficar sem sentido.
O R2000 podia ser iniciado usando tanto a ordenação de dados no formato big-endian como no little-endian. Ele tinha 32 registradores de 32 bits de uso geral, mas o nenhum registrador de código de condição, já que os projetistas consideravam o seu uso um gargalo em potencial, uma característica que compartilhou com processadores como o AMD 29000 e o Alpha da DEC. Ao contrário de outros registradores, o apontador de instruções (PC) não era diretamente acessível.
O R2000 teve também a sustentação para até quatro co-processadores, um de que foi construído no processador central principal e segurou exceções e armadilhas, quando os outros três foram deixados para outros usos. Um destes poderia ser enchido pelo R2010 opcional FPU, que teve o thirty-two 32 registradores do bits que poderiam ser usados como dezesseis registradores 64-bit para precisão dupla.
O R3000 sucedeu o R2000 em 1988, adicionanda caches de 32 kB (aumentados logo a 64 KB) para instruções e dados, junto com a sustentação da coerência da cache para o uso do multi-processor. Quando havia umas falhas na sustentação do multiprocessor de R3000, controlou ainda ser uma parte de diversos projetos bem sucedidos do multiprocessor. O R3000 incluiu também um MMU interno, uma característica comum nos processadores centrais da era. O R3000 era os primeiros MIPS bem sucedidos projeta no marketplace, e sobre 1 milhão foram feitos eventualmente. O R3000A, usado em Sony extremamente bem sucedido PlayStation, era uma versão colidida velocidade que funciona em 40 Mhz que entregou um desempenho de 32 VUPs. Como o R2000, o R3000 foi emparelhado com o R3010 FPU. Pacemips produziu um R3400 e IDT produziu R3500, ambos ele era R3000s com o fpu R3010 em uma única microplaqueta. R3900 de Toshiba era virtualmente um primeiro SoC para os PCes Handheld adiantados baseados no CE de Windows.
A série R4000, liberada em 1991, estendida o jogo de instrução dos MIPS a uma arquitetura 64-bit cheia, movida o FPU no dado principal para criar um sistema single-chip, e operada em uma velocidade de relógio interna radical elevada (foi introduzida em 100 Mhz). Entretanto, a fim conseguir a velocidade de relógio os esconderijos foram reduzidos a 8 KB cada e fizeram exame de três ciclos ao acesso. As freqüências operando-se elevadas foram conseguidas com a técnica do encanamento profundo (chamado super-encanamento naquele tempo). Com a introdução do R4000 um número de versões melhoradas seguiram logo, including o R4400 de 1993 que incluíram esconderijos de 16 KB, a operação 64-bit pela maior parte bug-free, e um controlador para um outra cache externo de 1 MB (2 nivelados).
Os MIPS, agora uma divisão do SGI chamaram MTI, projetams o baixo-custo R4200, e mais tarde o custo mesmo mais baixo R4300, que era o R4200 com uma barra-ônibus externa de 32 bocados. Nintendo 64 usou um processador central de NEC VR4300 que fosse baseado nos MIPS low-cost R4300i.
Os dispositivos do efeito de Quantum (QED), uma companhia separada enfiada por refugees dos MIPS, projetaram o R4600 “Orion”, o R4700 “Orion”, o R4650 e o R5000. Onde o R4000 tinha empurrado a freqüência de relógio e é sacrificado a capacidade da cache, os projetos de QED emfatizaram os esconderijos grandes que poderiam ser alcançados em apenas dois ciclos e no uso eficiente da área do silicone. Os R4600 e os R4700 foram usados nas versões low-cost da estação de trabalho do SGI Indy assim como os primeiros roteadores da Cisco baseados em MIPS, tais como os roteadores 36x0 e 7x00-séries. O R4650 foi usado nas caixas originais do ajust-alto de WebTV (agora tevê de Microsoft). O R5000 FPU teve programar floating-point mais flexível de precisão simples do que o R4000, e em conseqüência, R5000-based SGI Indys teve o desempenho para gráficos muito melhor do que R4400 similarmente cronometrado Indys com a mesma ferragem dos gráficos. O SGI deu à placa velha dos gráficos um nome novo quando foi combinado com o R5000 a fim emfatizar a melhoria. QED projetou mais tarde a família RM7000 e RM9000 dos dispositivos para mercados encaixados como o trabalho em rede e as impressoras de laser. QED foi adquirido pelo PMC-Sierra do fabricante do semicondutor em agosto 2000, última companhia que continua a invest na arquitetura dos MIPS.
O R8000 (1994) era os primeiros MIPS superescalar projeta, capaz de executar dois ALU e duas operações de memória por o ciclo. O projeto foi espalhado sobre seis microplaquetas: uma unidade do inteiro (com esconderijos de dados de 16 KB da instrução e de 16 KB L1), uma unidade floating-point, três ram secundárias do Tag da cache do cheio-costume (dois para acessos secundários da cache, um para a barra-ônibus que snooping), e um controlador ASIC da cache. O projeto mandou a precisão dois dobro inteiramente pipelined multiplic-adicionar as unidades, que poderiam fluir dados da cache secundário off-chip do MB 4. O R8000 powered usuários do computador do desafio do poder do SGI nos 1990s mid e tornou-se mais tarde disponível na estação de trabalho do poder Indigo2. Seus desempenho limitado do inteiro e custo elevado umedeceram a apelação para a maioria de usuários, embora seus usuários científicos aptos do desempenho de FPU completamente bem, e o R8000 não fossem no marketplace por somente um ano e remanescessem razoavelmente raros.
Em 1995, o R10000 foi liberado. Este processador era um projeto single-chip, funcionava em uma velocidade de relógio mais rápida do que o R8000, e tinha 32 KB maiores esconderijos preliminares da instrução e dos dados. Era também superescalar, mas sua inovação principal era execução out-of-order. Mesmo com um único encanamento da memória e um FPU mais simples, o desempenho do inteiro, o preço mais baixo vastamente melhorado, e a densidade mais elevada fizeram o R10000 preferível para a maioria de clientes.
Os projetos recentes tudo foram baseados no núcleo R10000. O R12000 usou o processo de fabricação melhorado encolher a microplaqueta e operar-se em umas velocidades de relógio mais elevadas. O R14000 revisado permitiu umas velocidades de relógio mais elevadas com sustentação adicional para DDR SRAM na cache off-chip, e uma barra-ônibus mais rápida do lado dianteiro cronometrou a 200 Mhz para o throughput melhor. Umas iterações mais atrasadas são nomeadas o R16000 e o R16000A e caracterizam a velocidade de relógio aumentada, a cache L1 adicional, e o processo de fabricação menor do dado comparado com antes.
| Modelo | Freqüência [Mhz] | Ano | Processo [µm] | Transistores [milhões] | Tamanho do chip [mm²] | Pinos de E/S | Potência [W] | Tensão | D-Cache [k] | I-cache [k] | S-cache [k] |
| R2000 | 8-16.7 | 1985 | 2,0 | 0,11 | -- | -- | -- | -- | 32 | 64 | nenhum |
| R3000 | 20-40 | 1988 | 1,2 | 0,11 | 66,12 | 145 | 4 | -- | 64 | 64 | nenhum |
| R4000 | 100 | 1991 | 0,8 | 1,35 | 213 | 179 | 15 | 5 | 8 | 8 | 1024 |
| R4400 | 100-250 | 1992 | 0,6 | 2,3 | 186 | 179 | 15 | 5 | 16 | 16 | 1024 |
| R4600 | 100-13 | 1994 | 0,64 | 2,2 | 77 | 179 | 4.6 | 5 | 16 | 16 | 512 |
| R5000 | 150-200 | 1996 | 0,35 | 3,7 | 84 | 223 | 10 | 3,3 | 32 | 32 | 1024 |
| R8000 | 75-90 | 1994 | 0,5 | 2,6 | 299 | 591 | 30 | 3,3 | 16 | 16 | 1024 |
| R10000 | 150-250 | 1995 | 0,35 | 6,8 | 299 | 599 | 30 | 3,3 | 32 | 32 | 512 |
| R12000 | 270-400 | 1998 | 0,18-0,25 | 6,9 | 204 | 600 | 20 | 4 | 32 | 32 | 1024 |
| R14000 | 500-600 | 2001 | 0,13 | 7,2 | 204 | 527 | 17 | -- | 32 | 64 | 2048 |
| R16000 | 700-800 | 2002 | 0,11 | -- | -- | -- | 20 | -- | 64 | 64 | 4096 |
Especificações dos microprocessadores MIPS
Nota: Estas especificações são somente configurações comuns do processador. As variações existem, especialmente na cache do nível 2 (S-cache).

## Aplicações

Entre os fabricantes que fizeram sistemas computacionais do tipo "estação de trabalho" que usam processadores MIPS estão: SGI, MIPS, Inc., Olivetti, Siemens-Nixdorf, Acer, Digital Equipment Corporation e NEC. Vários sistemas operacionais foram portados à arquitetura, tais como o IRIX da SGI, Windows NT da Microsoft, Linux, sistema V do DEB, do UNIX, SINIX, MIPS próprio RISC/os dos sistemas computatorizados, e outros.
Entretanto, o uso dos MIPS como o processador principal de estações de trabalho do computador declinou, e a SGI anunciou que suas plantas industriais cessariam de desenvolver estações high-performance com a arquitetura dos MIPS em favor de usar processadores da Intel IA64-based (ver a “outra seção dos modelos e das plantas futuras” abaixo).
Por outro lado, o uso dos microprocessadores dos MIPS em sistemas embarcados é provável remanescer comum, por causa das características baixas de execuções encaixadas dos MIPS, a disponibilidade larga do poder-consumo e do calor de ferramentas de desenvolvimento encaixadas para MIPS, assim como sua arquitetura inteligente.

## Outros modelos e plantas futuras

Outros membros da família dos MIPS incluem o R6000, uma execução do ECL da arquitetura dos MIPS que foi produzida pela tecnologia integrada bipolar. O microprocessador R6000 introduziu o jogo de instrução dos MIPS II. Sua arquitetura de TLB e de esconderijo é diferente de todos membros restantes da família dos MIPS. O R6000 não entregou os benefícios prometidos do desempenho, e embora visse algum uso em máquinas dos dados de controle, desapareceu rapidamente do mercado mainstream. O RM7000 era uma versão do R5000 com um built-in 256 esconderijo do nível 2 do kB e um controlador para a cache opcional do nível três. Foi alvejado primeiramente em projetos encaixados, including processadores dos gráficos do SGI e várias soluções do trabalho em rede, primeiramente por Cisco. O nome R9000 foi usado nunca.
Em uma vez o SGI tinha pretendido mover-se fora da plataforma dos MIPS para Intel Itanium, e o desenvolvimento era ter terminado com o R10000. O sempre-mais longo atrasa em introduzir o Itanium significou que a base instalada de máquinas MIPS-baseadas continuou a aumentar. Por 1999 estava desobstruído que o desenvolvimento tinha terminado demasiado logo, e os R14000 e os R16000 foram liberados em conseqüência. O SGI tinha sugerido R8000 em um estilo mais complexo FPU para umas R-séries mais atrasadas, e também em um processador duplo do núcleo, mas os problemas financeiros e o uso oficialmente suportado do SGI da emulation de QuickTransit funcionar binaries de IRIX em Altix eliminaram essencialmente o desenvolvimento da ferragem de IRIX/MIPS.

## Núcleos

Em anos recentes da tecnologia usada nas várias gerações dos MIPS foi oferecido mais como IP-núcleos (edifício-obstrui) para projetos encaixados do processador. Os bits ambos os 32 e os núcleos básicos 64-bit são oferecidos, sabido como o 4K e o 5K respectivamente, e o projeto próprio pode ser licenciado como MIPS32 e MIPS64. Estes núcleos podem ser misturados com as unidades add-in tais como FPUs, sistemas de SIMD, a vária entrada - dispositivos de saída, etc.
Os MIPS dos núcleos foram comercialmente bem sucedidos, agora sendo usado nos muitos consumidor e aplicações industriais. Os MIPS dos núcleos podem ser encontrados em uns roteadores mais novos de Cisco e de Linksys, em uns modem de cabo e em uns modem do ADSL, em uns smartcards, em uns motores da impressora de laser, em umas caixas do ajust-alto, em uns robôs, em computadores handheld, em Sony PlayStation 2 e em Sony PlayStation portátil. Em aplicações de cellphone/PDA, o núcleo dos MIPS foi incapaz de deslocar o encarregado, núcleo competindo do ARM.
Exemplos de dispositivos baseados em MIPS: Broadcom BCM5352E - Processador do roteador de WiFi com 802.11g WLAN, Fast Ethernet, 200 Mhz, ins 16KiB. esconderijo dos dados 8KiB, esconderijo do prefetch 256B, MMU, 16 flash de série/paralelo do controlador do Mhz SDRAM do bits 100, 5 Ethernet do porto 100 Mbit/s (interruptor), 16 GPIO, JTAG, 2xUART, 336 esfera BGA. BCM 11xx, 12xx, 14xx - linha dos MIPS de 64bit “SiByte”.
IDT RC32438, ATI Xilleon, Alchemy Au1000, 1100, 1200, Broadcom Sentry5, Cavium Octeon CN34xx e CN38xx, tecnologias EasyPort de Infineon, Amazon, ADM5120, WildPass, INCA-IP, INCA-IP2, EMMA de NEC e EMMA2, NEC VR4181A, VR4121, VR4122, VR4181A, VR5432, VR5500, geração das tecnologias do carvalho, PMC-Sierra RM11200, QuickLogic QuickMIPS ESP, Toshiba “Donau”, Toshiba TMPR492x, TX4925, TX9956, TX7901

## Programação e emulação

Há dos “um simulador livremente disponível” SPIM chamado MIPS R2000/R3000 para diversos sistemas operacionais (UNIX, especificamente GNU/Linux; Mac OS X; MS Windows 95, 98, NT, 2000, XP; e DOS) qual é útil para o aprendizado de programação no conjunto de instruções MIPS e os conceitos gerais de programação RISC: http://www.cs.wisc.edu/~larus/spim.html
Um emulador livre característica-mais rico dos MIPS está disponível do projeto de GXemul (sabido anteriormente como o projeto de mips64emul), que emula não somente os vários MIPS III e uns microprocessadores mais elevados (do R4000 com o R10000), mas emula também os sistemas computadorizados inteiros que usam os microprocessadores. Por exemplo, GXemul pode emular um DECstation com um processador central dos MIPS R4400 (e o carregador a Ultrix), e um O2 do SGI com um processador central dos MIPS R10000 (embora a habilidade de carregar Irix seja limitada), entre outros, assim como os vários framebuffers, os controladores de SCSI, e o gosto que compreendem aqueles sistemas. Mips das chamadas do sistema serviço Código da armadilha Entrada Saída Notas print_int $v0=1 inteiro de $a0= a imprimir imprime a0 à saída padrão print_string $v0=4 endereço de $a0= do primeiro caráter imprime uma corda de caráter à saída padrão sbrk $v0=9 número de $a0= dos bytes requeridos endereço de $v0= da memória alocada Aloca a memória do heap

## Resumo do conjunto de instruções R3000

As instruções são divididas em três tipos do formato: Formato de R, de I e de J. O formato de R consiste em três registradores e campo funcional, o formato I contém dois registradores e o valor imediato de 16 bits, e por último o formato J, no qual seu opcode tem seis bits seguido de um valor imediato de 26 bits.
Nome de registrador, número, uso, e convenções da chamada: registradores Nome Número Uso O Callee deve preservar? $zero $0 constante 0 N/A $at $1 ajuntador provisório não $v0-$v1 $2–$3 Valores para retornos da função e avaliação da expressão não $a0-$a3 $4–$7 argumentos da função não $t0-$t7 $8–$15 temporaries não $s0-$s7 $16–$23 temporaries conservados sim $t8-$t9 $24–$25 temporaries não $k0-$k1 $26–$27 reservado para a semente do ósmio não $gp $28 ponteiro global sim $sp $29 ponteiro de pilha sim $fp $30 ponteiro do frame sim $ra $31 endereço do retorno N/A
Regista que é preservado através de uma chamada é os registradores que (pela convenção) não será mudado por uma chamada do sistema ou pela chamada do procedimento (função). Por exemplo, $s-registers deve ser conservado à pilha por um procedimento que necessite o usar, e $sp e $fp estão incrementados sempre por constantes, e decrecidos para trás depois que o procedimento é feito com elas (e a memória que apontam a). Pelo contraste, $ra é mudado automaticamente por toda a ligação de controle normal (umas que usa o jal), e $t-registers deve ser conservado pelo programa antes de qualquer chamada do procedimento (se o programa necessita os valores dentro deles após a chamada).

## Instruções reais

Estas são as instruções que têm a execução de ferragem direta. Isto é ao contrário das pseudo-instruções que são traduzidas em instruções reais múltiplas antes de ser montada.
Os seguintes são os três formatos usados para o jogo de instrução do núcleo: Tipo -31 - formato (bitss) -0
R opcode (6) rs (5) rt (5) rd (5) shamt (5) funct (6)
I opcode (6) rs (5) rt (5) imediato (16)
J opcode (6) endereço (26)
* CONST denota uma constante (“imediato”).
* No seguinte, os números do registrador são somente exemplos, e todos os outros registradores podem ser usados em seus lugares.
* Opcodes e os códigos do funct estão no hexadecimal.
| Categoria | Nome | Sintaxe da Instrução | Significado | Format/opcode/funct | Format/opcode/funct | Format/opcode/funct | Notas |
| Aritmetica | Add | add $1,$2,$3 | $1 = $2 + $3 (signed) | R | 0 | $20_{16}$ | Adiciona dois registros, estende sinal de largura de registro. |
| Aritmetica | Add unsigned | addu $1,$2,$3 | $1 = $2 + $3 (unsigned) | R | 0 | $21_{16}$ | Como acima, sem extensão de sinal de largura de registro. |
| Aritmetica | Subtract | sub $1,$2,$3 | $1 = $2 – $3 (signed) | R | 0 | $22_{16}$ | Subtrai dois registradores. |
| Aritmetica | Subtract unsigned | subu $1,$2,$3 | $1 = $2 – $3 (unsigned) | R | 0 | | Como acima, sem extensão de sinal de largura de registro |
| Aritmetica | Add immediate | addi $1,$2,CONST | $1 = $2 + CONST (signed) | I | $8_{16}$ | | Usado para adicionar constantes ( e também para copiar um registro para outro "addi $ 1, $ 2, 0" ), estende sinal de largura de registro. |
| Aritmetica | Add immediate unsigned | addiu $1,$2,CONST | $1 = $2 + CONST (unsigned) | I | $9_{16}$ | | Como acima, sem extensão de sinal de largura de registro. |
| Aritmetica | Multiply | mult $1,$2 | LO = (($1 * $2) << 32) >> 32; HI = ($1 * $2) >> 32; | R | 0 | $18_{16}$ | Multiplica dois registradores e coloca o resultado de 64 bits em dois pontos especiais de memória - LOW e HI. Como alternativa, pode-se dizer que o resultado dessa operação é: (int HI, int LO) = (64-bit) $1 * $2. |
| Aritmetica | Divide | div $1, $2 | LO = $1 / $2 HI = $1 % $2 | R | | | Divide dois registradores e coloca o resultado inteiro de 32 bits em LO e o restante em HI. |
| Transferência de Dados | Load word | lw $1,CONST($2) | $1 = Memory[$2 + CONST] | I | $23_{16}$ | | Carrega a termo armazenada a partir de: MEM[$s2+CONST] e os seguintes 3 ​​bytes. |
| Transferência de Dados | Load halfword | lh $1,CONST($2) | $1 = Memory[$2 + CONST] (signed) | I | $25_{16}$ | | Carrega a meia termo armazenado a partir de: MEM[$2+CONST] e o byte seguinte, estende sinal de largura de registro. |
| Transferência de Dados | Load halfword unsigned | lhu $1,CONST($2) | $1 = Memory[$2 + CONST] (unsigned) | I | | | Como acima, sem extensão de sinal de largura de registro. |
| Transferência de Dados | Load byte | lb $1,CONST($2) | $1 = Memory[$2 + CONST] (signed) | I | | | Carrega o byte armazenado: MEM[$2+CONST]. |
| Transferência de Dados | Load byte unsigned | lbu $1,CONST($2) | $1 = Memory[$2 + CONST] (unsigned) | I | | | Como acima, sem extensão de sinal de largura de registro. |
| Transferência de Dados | Store word | sw $1,CONST($2) | Memory[$2 + CONST] = $1 | I | | | Armazena um termo em: MEM [$2+CONST] e os seguintes 3 ​​bytes. A ordem dos operadores é uma grande fonte de confusão. |
| Transferência de Dados | Store half | sh $1,CONST($2) | Memory[$2 + CONST] = $1 | I | | | Armazena a primeira metade do um registrador (uma meio termo) em: MEM[$2+CONST] e o byte seguinte. |
| Transferência de Dados | Store byte | sb $1,CONST($2) | Memory[$2 + CONST] = $1 | I | | | Aarmazena o primeiro quarto de um registro (um byte) em: MEM [$2+CONST]. |
| Transferência de Dados | Load upper immediate | lui $1,CONST | $1 = CONST << 16 | I | | | Carrega um operador imediato de 16 bits para os 16 bits superiores do registro especificado. O valor máximo da constante é 216 - 1 |
| Transferência de Dados | Move from high | mfhi $1 | $1 = HI | R | | | Move um valor de HI a um registrador. Não use uma multiplicação ou uma instrução de divisão dentro de duas instruções de mfhi (que a ação é indefinida por causa do MIPS pipeline). |
| Transferência de Dados | Move from low | mflo $1 | $1 = LO | R | 0 | $12_{16}$ | Move um valor de LO a um registro. Não use uma multiplicação ou uma instrução de divisão dentro de duas instruções de MFLO (que a ação é indefinida por causa do MIPS pipeline). |
| Transferência de Dados | Move from Control Register | mfcZ $1, $2 | $1 = Coprocessor[Z].ControlRegister[$2] | R | | | Move um valor de 4 bytes do co-processador Z o controle registra um registro de uso geral. estende sinal de largura de registro. |
| Transferência de Dados | Move to Control Register | mtcZ $1, $2 | Coprocessor[Z].ControlRegister[$2] = $1 | R | | | Moves a 4 byte value from a general purpose register to a Coprocessor Z Control register. Sign extension. |
| Transferência de Dados | Load word coprocessor | lwcZ $1,CONST($2) | Coprocessor[Z].DataRegister[$1] = Memory[$2 + CONST] | I | | | Loads the 4 byte word stored from: MEM[$2+CONST] into a Coprocessor data register. Sign extension. |
| Transferência de Dados | Store word coprocessor | swcZ $1,CONST($2) | Memory[$2 + CONST] = Coprocessor[Z].DataRegister[$1] | I | | | Stores the 4 byte word held by a Coprocessor data register into: MEM[$2+CONST]. Sign extension. |
| lógico | And | and $1,$2,$3 | $1 = $2 & $3 | R | | | Bitwise and |
| lógico | And immediate | andi $1,$2,CONST | $1 = $2 & CONST | I | | | |
| lógico | Or | or $1,$2,$3 | $1 = $2 | $3 | R | | | Bitwise or |
| lógico | Or immediate | ori $1,$2,CONST | $1 = $2 | CONST | I | | | |
| lógico | Exclusive or | xor $1,$2,$3 | $1 = $2 ^ $3 | R | | | |
| lógico | Nor | nor $1,$2,$3 | $1 = ~($2 | $3) | R | | | Bitwise nor |
| lógico | Set on less than | slt $1,$2,$3 | $1 = ($2 < $3) | R | | | Testa se um registrador é menor do que o outro |
| lógico | Set on less than immediate | slti $1,$2,CONST | $1 = ($2 < CONST) | I | | | Testa se um registrador é menor do que uma constante |
| Deslocamento bit a bit | Shift left logical | sll $1,$2,CONST | $1 = $2 << CONST | R | | | shifts CONST number of bits to the left (multiplies by $2^{CONST}$) |
| Deslocamento bit a bit | Shift right logical | srl $1,$2,CONST | $1 = $2 >> CONST | R | | | shifts CONST number of bits to the right - zeros are shifted in (divides by $2^{CONST}$). Note that this instruction only works as division of a two's complement number if the value is positive. |
| Deslocamento bit a bit | Shift right arithmetic | sra $1,$2,CONST | $\$1=\$2>>CONST+\$ ${\bigg{\bigg\sum _{n=1}^{CONST}2^{31-n}{\bigg )}\cdot \$2>>31{\bigg )}$ | R | | | shifts CONST number of bits - the sign bit is shifted in (divides 2's complement number by $2^{CONST}$) |
| desvio condicional | Branch on equal | beq $1,$2,CONST | if ($1 == $2) go to PC+4+CONST | I | | | Vai para a instrução no endereço especificado se os dois registradores tiverem o mesmo valor. |
| desvio condicional | Branch on not equal | bne $1,$2,CONST | if ($1 != $2) go to PC+4+CONST | I | | | Vai para a instrução no endereço especificado se os dois registradores tiverem valor diferente. |
| salto incondicional | Jump | j CONST | goto address CONST | J | | | Pula incondicionalmente para a instrução no endereço especificado. |
| salto incondicional | Jump register | jr $1 | goto address $1 | R | | | Pula para o endereço contido no registrador específico |
| salto incondicional | Jump and link | jal CONST | $31 = PC + 4; goto CONST | J | | | For procedure call - used to call a subroutine, $31 holds the return address; returning from a subroutine is done by: jr $31 |
NOTA: nas instruções ramificar e de salto, o offset pode ser substituído por um presente da etiqueta em algum lugar no código.
As pseudo-instruções são traduzidos em instruções reais múltiplas (ver acima) antes de ser montada.
| Nome | Sintaxe da Instrução | Tradução instrução real | Significado |
| Load Address | la $1, LabelAddr | lui $1, LabelAddr[31:16]; ori $1,$1, LabelAddr[15:0] | $1 = Label Address |
| Load Immediate | li $1, IMMED[31:0] | lui $1, IMMED[31:16]; ori $1,$1, IMMED[15:0] | $1 = 32 bit Immediate value |
| Branch greater than | bgt | | if(R[rs]>R[rt]) PC=Label |
| Branch less than | blt | | if(R[rs]<R[rt]) PC=Label |
| Branch greater than or equal | bge | | if(R[rs]>=R[rt]) PC=Label |
| Branch less than or equal | ble | | if(R[rs]⇐R[rt]) PC=Label |
| Branch greater than unsigned | bgtu | | if(R[rs]⇒R[rt]) PC=Label |
| Branch greater than zero | bgtz | | if(R[rs]>0) PC=Label |

## Outras instruções

Estas instruções devem ser colocadas acima “nas seções reais das instruções” ou das “pseudo-instruções”.

### Instruções lógicas comuns (bitwise)

addiu $1, $2.100 $1 = $2 + 100 (imediato não assinado) addu $1, $2, $3 $1 = $2 + $3 (não assinado) div $1, $2 HI = $ 1% $2; = $1 BAIXOS/$2 subu $1, $2, $3 $1 = $2 – $3 (não assinado)

### Memória para registar instruções de transferência

lbu $1.100 ($2) carrega um byte não assinado lhu $1.100 ($2) carrega um halfword não assinado lwcz $1.100 ($2) carrega uma palavra ao coprocessor de “z” (“z” é o número do coprocessor)
Anotar que não há nenhuma da “instrução imediata correspondente carga mais baixo”; isto pode ser feito usando o addi (adicionar imediato, vêem abaixo) ou o ori (ou imediato) com o registrador $0 (cujo valor é sempre zero). Por exemplo, o addi $1, $0, 100 e ori $1, $0, 100 carrega o valor decimal 100 no registrador $1.

### Registar às instruções de transferência da memória

swcz $1.100 ($2) armazena uma palavra do coprocessor de “z” (“z” é o número do coprocessor).

### Registro - a - instruções do registrador (movimento)

mfcz $1, $c1 move um valor no registrador $1 do coprocessor para o registrador principal $1 do processador (“z” é o número do coprocessor) mtcz $1, $c1 move um valor do registrador principal $1 do processador para o registrador $1 do coprocessor mov.d $fp1, $fp3 move um valor com precisão dobro do registrador $3 de FPU para o registrador $1 de f.p. mov.s $fp1, $fp3 move um valor com única precisão do registrador $3 de FPU para o registrador $1 de f.p.
(valores com registradores adjacentes do uso dois FPU da precisão dobro)
Uma operação com os immediates assinados difere de um com os não assinados que não joga uma exceção. Subtrair um imediato pode ser feito com adição da negação desse valor como o imediato.

## Algumas outras instruções importantes

* nop (nenhuma operação) (código de máquina 0x00000000, interpretado pelo processador central como o sll $0, $0,0)
* ruptura (rupturas o programa, usado por debuggers)
* syscall (usos para chamadas do sistema ao sistema se operando)
* um jogo de instruções FPU-relacionadas
* um jogo vasto de instruções virtuais, decomposed pelo ajuntador em instruções nativas

## Curiosidade

Em Super Mario 64, o coelho é nomeado Mips em homenagem ao processador MIPS usado no sistema Nintendo 64.