Computador MIPS Organização básica e conjunto de instruções

MIPS – uma arquitetura RISC (Reduced Instruction Set Computer) MIPS (Microprocessor without Interlocked Pipeline Stages) foi projetado na Universidade de Stanford pela equipe do Prof. John Hennessy. –similar a outras arquiteturas RISC desenvolvidas desde 1980 –Princípio da regularidade, – todas as instruções de 32 bits –Princípio da simplicidade, –instruções simples, somente 3 formatos de instruções –isso favorece o princípio da regularidade. –Aritmética rápida: usar somente registradores para aritmética –32 registradores –Usado por Nintendo, Silicon Graphics

MIPS é uma arquitetura von Neumann ( programa armazenado na memória ) 1) instruções e dados na mesma memória 2) as instruções são lidas da memória e executadas na unidade de processamento, uma a uma, em sequência 3) para apontar para a instrução, o processador usa um apontador de instrução chamado contador de programa. Ciclo de uma instrução típica: 1) ler a instrução na memória 2) ler os operandos 3) executar a operação 4) guardar o resultado 5) atualizar o contador de programa para a leitura da próxima instrução Caracterizada por:

Um esboço preliminar do MIPS Ciclo de instrução: 1) ler a instrução na memória 2) ler os operandos 3) executar a operação 4) guardar o resultado 5) atualizar o contador de programa para a leitura da próxima instrução Mux

Notação para uso de registradores NOME NÚMERO DO REGISTRADORUSO $zero0constante 0 $v0 - $v12-3Resultados $a0 - $a34-7Argumentos $t0 - $t78-15Temporários $s0-$s716-23Dados salvos $t8-$t924-25Temporários $gp28Global pointer $sp29Stack pointer $fp30Frame pointer $ra31Return address Pode-se também usar a notação: $0, $1,...., $31.

Arquitetura do Conjunto de Instruções Instruction Set Architecture (ISA)

Abstração Descendo no nível de abstrações revelam-se outras informações

Aritmética no MIPS As instruções aritméticas tem 3 operandos: A ordem dos operandos é fixa (primeiro o operando destino) Exemplo: código C: A = B + C código MIPS: add $s0, $s1, $s2 Os operandos ficam em registradores e são associados às variáveis do código C, pelo compilador dest.fonte1 fonte2 (Assembly)

add $s0, $s1, $s2 Ilustração do movimento de dados no MIPS $s0 $s1 $s2

Aritmética no MIPS (cont.) código C: A = B + C + D; E = F - A; código MIPS: add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0 B C D A AF E Outro exemplo: (Assembly)

Registradores vs. Memória Os operandos de instruções arithméticas devem estar em registradores, — 32 registradores disponíveis O compilador associa variáveis a registradores E programas com um número grande de variáveis ?

Memória no MIPS A memória é vista como um grande vetor unidimensional, com endereços. Um endereço de memória é um índice para o vetor "Byte addressing" significa que o índice aponta para um byte de memória bits Byte word (palavras) Endereço de bytes

Memória no MIPS (cont.) A maioria dos dados usam palavras ou words Para MIPS, um word é constituído de 32 bits ou 4 bytes bytes têm endereços de 0 a words têm endereços de bytes 0, 4, 8,

Instruções de referência à memória lw (load-word) e sw (store-word) código C: A[8] = h + A[8]; código MIPS: lw $t0, 32($s3) add $t0, $s2, $t0 ; soma sw $t0, 32($s3) ; armazena na memória sw tem destino por último Registrador memória ; carrega no registrador $t0 Endereço de memória (destino) Endereço de memória (origem) Endereço de memória: 32 ($s3) (Endereço = 32 + conteúdo de $s3) Offset (deslocamento) Conteúdo de registrador base Reg.dest. Reg.origem memória

Ilustração do movimento de dados lw $t0, 32($s3) add $t0, $s2, $t0 sw $t0, 32($s3)

Nosso Primeiro Exemplo swap(int v[], int k); { int temp; temp = v[k] v[k] = v[k+1]; v[k+1] = temp; } swap: muli $2, $5, 4 add $2, $4, $2 lw $15, 0($2) lw $16, 4($2) sw $16, 0($2) sw $15, 4($2) jr $31

Revisão: MIPS — carrega words endereçando o primeiro byte dos words — aritmética somente usando registradores InstruçãoSignificado add $s1, $s2, $s3$s1 = $s2 + $s3 sub $s1, $s2, $s3$s1 = $s2 – $s3 lw $s1, 100($s2)$s1 = Memory[$s2+100] sw $s1, 100($s2)Memory[$s2+100] = $s1 Indica uma palavra de memória no endereço $s

–Exemplo: add $t0, $s1, $s2 –registradores tem numerações, $t0=8, $s1=17, $s2=18 op rs rt rdshamtfunct Linguagem de Máquina Código de operação aritmética Função Aritmética add Shift amount (Campo usado pela instr. Shift) Formato de instruções aritméticas tipo R (R de registrador) dest.fonte1fonte2 dest.fonte1fonte2

lw e sw usa um formato tipo-I Exemplo: lw $t0, 32($s2) Formato das instruções tipo-I op rs rt 16 bit number Linguagem de Máquina Deslocamento (offset) Registrador destino Registrador base (endereço) Opcode de lw

Instruções de desvio condicional do MIPS: bne $t0, $t1, Label beq $t0, $t1, Label Exemplo:código C: if (i==j) h = i + j; código MIPS: bne $s0, $s1, Label add $s3, $s0, $s1 Label:.... Instruções de Controle bne – branch if not equal beq – branch if equal Instruções de desvio condicional Formato tipo-I Offset (Label) bne $t0, $t1, Label fonte1fonte2 fonte1 fonte2

Resultado da comparação $t0 $t1 beq $t0, $t1, Label bne $t0, $t1, Label Ilustração para instrução de controle no MIPS Label

Instrução de desvio incondicional: j label Exemplo: if (i!=j) beq $s4, $s5, Lab1 h=i+j;add $s3, $s4, $s5 else j Lab2 h=i-j;Lab1:sub $s3, $s4, $s5 Lab2:... Instruções de Controle (cont.) Formato: tipo-J alvo (label) J label 6 bits 26 bits

Ilustração da instrução Jump (J) J Label

Instrução set-if-less-than if $s1 < $s2 then $t0 = 1 slt $t0, $s1, $s2 else $t0 = 0 Código de operação aritmética Função Aritmética slt Shift amount (Campo usado pela instr. Shift) dest.fonte1fonte

slt $t0, $s1, $s2 Ilustração da instrução set-if-less-than $t0 $s1 $s2 A ULA se encarrega de atribuir 0 ou 1

Revisão: InstruçãoSignificado add $s1,$s2,$s3$s1 = $s2 + $s3 sub $s1,$s2,$s3$s1 = $s2 – $s3 lw $s1,100($s2)$s1 = Memory[$s2+100] sw $s1,100($s2)Memory[$s2+100] = $s1 bne $s4,$s5,Lpróxima instrução é em L se $s4 $s5 beq $s4,$s5,Lpróxima instrução é em L se $s4 = $s5 j LabelNext instr. is at Label slt$t0,$s1,$s2se $s1<$s2 $t0 = 1 senão $t0 = 0 Formatos: op rs rt rdshamtfunct op rs rt 16 bit address op 26 bit address RIJRIJ

Constantes pequenas são usadas frequentemente (50% dos operandos) p.ex., A = A + 5; B = B + 1; C = C - 18; Soluções? –Colocar as constantes “imediatamente” nas instruções –criar registradores hardwired (como $zero) para constantes como um. Instruções com constantes (dados imediatos) do MIPS: addi $29, $29, 4 slti $8, $18, 10 andi $29, $29, 6 ori $29, $29, 4 Constantes Formato: usa formato tipo-I constante (dado imediato) addi $s0, $t1, 4 fonte dest. Dest.Oper.

Esboço mais completo do MIPS