MIPS

Prof. Carlos Bazilio http://www.ic.uff.br/~bazilio bazilio@ic.uff.br

Introduo
Plataforma projetada da parceria entre NEC, Nintendo, Silicon Graphics e Sony Possui um conjunto de instrues que e utilizado em muitos produtos destes fabricantes Possui um simulador que permite a experimentao durante o curso: http://pages.cs.wisc.edu/~larus/spim.html

Introduo
Visualizando um computador como uma mquina de vrios nveis, o MIPS se localiza no nvel 1 Nvel n: Mquina Virtual Mn com linguagem de mquina Ln ... Nvel 2: Mquina Virtual M2 com linguagem de mquina L2 Nvel 1: Mquina Virtual M1 com linguagem de mquina L1 Nvel 0: Mquina Virtual M0 com linguagem de mquina L0 (circuitos eletrnicos)

Operaes no Hardware
As instrues utilizadas para se programar um hardware so comumente chamadas de conjuntos de instrues Operaes aritmticas so suportadas por todos os computadores Em MIPS, add a, b, c instrui o computador a somar b e c e armazenar em a o resultado

Operaes no Hardware
Entretanto, o conjunto de instrues do MIPS rgido, s permitindo, para as instrues de adio, 3 argumentos Ou seja, para realizarmos a soma a=b+c+d+e Temos que quebrar a atribuio em vrias somas: add a, b, c add a, a, d add a, a, e

Operaes no Hardware
Esta caracterstica rgida de 3 operandos para estas operaes aritmticas favorece a simplicidade do projeto do hardware Suponha agora a seguinte atribuio em linguagem de alto nvel f = (g + h) (i + j); A instruo de subtrao no MIPS sub e possui o mesmo nmero de operados da instruo add Como traduzimos para a linguagem do MIPS?

Operaes no Hardware
Iniciamos a traduo da instruo f = (g + h) (i + j); como as anteriores add f, g, h Entretanto, a soma de i e j no pode ser atribuda a f, nem a i ou j Como isso, vemos a necessidade de utilizarmos temporrias add t0, i, j sub f, f, t0

Operandos das Instrues

Diferentemente das linguagens de alto nvel, as linguagens de montagem possuem restries quanto ao tamanho de suas instrues No MIPS, os operandos das operaes aritmticas so os registradores Nesta arquitetura esto disponveis 32 registradores, cada qual com 32 bits de tamanho Esta limitao possibilita eficincia no uso dos recursos

Conveno no MIPS
No MIPS, os identificadores dos registradores so precedidos por um $s para variveis de um programa e $t para temporrias Dessa forma, o resultado da ltima traduo ficaria, supondo f, g, h, i, j em $s0, $s1, $s2, $s3, $s4: add $s0, $s1, $s2 add $t0, $s3, $s4 sub $s0, $s0, $t0

Operandos em Memria
Operandos de instrues em memria precisam ser trazidos para a CPU para que possam ser manipulados As instrues do MIPS que realizam acesso memria so lw (load word) e sw (store word) Suponha que A seja um vetor de 100 palavras (palavra word - possui tamanho de 32 bits) Como compilamos a expresso g = h + A[8];

Operandos em Memria
Suponha que para a expresso g = h + A[8];, g esteja em $s1, h esteja em $s2 e o endereo base de A esteja em $s3 Relembrando que acessamos elementos diferentes num vetor realizando deslocamentos (offsets) partir da base, temos: lw $t0, 8($s3) add $s1, $s2, $t0

Operandos em Memria
Observe que, para o MIPS, a memria est organizada em palavras (sequncias de 32 bits) Alm disso, as instrues lw e sw realizam transferncias de 32 bits Com isso, o offset fornecido precisa ser multiplicado por 4 para obter o elemento do vetor correto lw $t0, 32($s3) add $s1, $s2, $t0

Operandos em Memria
Como compilamos a seguinte instruo para MIPS: A[12] = h + A[i]; Suponha que o endereo base de A est em $s3, h em $s2 e i em $s4 Inicialmente, temos que multiplicar o ndice i por 4 para enderear palavras add $t1, $s4, $s4 add $t1, $t1, $t1

Operandos em Memria Compilando A[12]=h+A[i];

Podemos adicionar a i o endereo base de A add $t1, $t1, $s3 Carregamos o valor de A[i] para memria: lw $t0, 0($t1) Somamos o valor de h add $t0, $t0, $s2 Finalmente, armazenamos em A[12] sw $t0, 48($t0)

Algumas Observaes Iniciais

Transferncias entre registradores e memria, na verdade, so cpias A memria pode ser vista como um vetor unidimensional Considerando que tarefa do compilador alocar rea de memria para um programa, fica fcil realizar a associao entre variveis e registradores

Algumas Observaes Iniciais

Mquinas que endeream palavras (sequncias de 32 bits) podem ser:
Big endians: consideram o byte mais direita como endereo da palavra Little endians: consideram o byte mais esquerda como endereo da palavra

Representao de Instrues
A conveno entre os registradores e seus valores no MIPS :
$s0..$s7 $t0..$t7 16 a 23 8 a 15

Assim, a instruo add $t0, $s1, $s2 tem a seguinte representao (em decimal): 0
opcode 6 bits

17
rs 5 bits

18
rt 5 bits

8
rd 5 bits

0
shamt 5 bits

32
funct 6 bits

Representao de Instrues
Descrio dos campos:
op (opcode): operao bsica da instruo rs: registrador do primeiro operando de origem rt: registrador do segundo operando de origem rd: registrador do operando de destino shamt (shift ammount): quantidade de deslocamento (no utilizado na adio) funct: seleciona a variante da operao bsica definida

Instruo add $t0, $s1, $s2 em representao binria:

000000 opcode 10001 rs 10010 rt 01000 rd 00000 shamt 100000 funct

Representao de Instrues
Para as instrues de acesso a memria, 5 bits permitiriam o endereamento de apenas 32 (25) clulas de memria De forma a ampliar esta limitao, o formato das instrues modificado da seguinte forma:
opcode 6 bits rs 5 bits rt 5 bits constante ou endereo 16 bits

No MIPS, este formato chamado de formato do tipo I, enquanto o primeiro chamado de tipo R

Representao de Instrues
Exemplificanto a representao do tipo I, a instruo lw $t0, 32($s3) traduzida para a seguinte sequncia de bits:
100011 opcode 10011 rs 01000 rt 0000000000100000 endereo

, onde $s3 (registrador 19) colocado em rs, $t0 (registrador 8) colocado em rt e 32 colocado no campo endereo

Representao de Instrues
Outro exemplo de instruo do tipo I a adio imediata (addi) Esta instruo permite a adio de constantes Por exemplo: addi $s3, $s3, 4 # $s3=$s3+4
001000 opcode 10011 rs 10011 rt 0000000000000100 endereo

Resumo das Instrues

Instruo add sub addi lw sw Tipo R R I I I op 0 0 8 35 43 rs reg reg reg reg reg rt reg reg reg reg reg rd reg reg n.a. n.a. n.a. shamt 0 0 n.a. n.a. n.a. funct 32 34 n.a. n.a. n.a. endereo n.a. n.a. constante endereo endereo

Instrues de Operadores Lgicos

O MIPS oferece operaes lgicas and (& em C), andi, or (| em C), ori e nor (~ em C) As instrues and, or e nor utilizam o formato R, enquanto que andi e ori utilizam o formato I Por exemplo: and $t0, $t1, $t2 #$t0=$t1&$t2 representado pela seguinte sequncia de bits
000000 opcode 01010 rs 01001 rt 01000 rd 00000 shamt 100100 funct

Instrues de Deslocamento
Tambm so oferecidas operaes de deslocamento: sll (<< - shift esquerda), srl (>> - shift direita) Por exemplo: sll $t2, $s0, 4 #$t2=$s0<<4 representado pela sequncia
000000 opcode 00000 rs 10000 rt 01010 rd 00100 shamt 000000 funct

Resumo de Instrues Lgicas e Deslocamento

Instruo Tipo and or andi ori nor sll srl R R I I R R R op 0 0 12 13 0 0 0 rs reg reg reg reg reg n.a. n.a. rt reg reg reg reg reg reg reg rd reg reg n.a. n.a. n.a. reg reg shamt funct 0 0 n.a. n.a. n.a. cte cte 36 37 n.a. n.a. 39 0 2 endereo n.a. n.a. cte cte n.a. n.a. n.a.

Instrues para Tomada de Deciso

beq (branch if equal) e bne (branch if not equal) so instrues de desvio condicional O formato geral destas instrues : (bne / beq) reg1, reg2, L1 onde reg1 e reg2 so os operandos da instruo e L1 o endereo para onde a execuo desviar caso a condio seja vlida

Instrues para Tomada de Deciso

Supondo o seguinte cdigo em C
if (i == j) go to L1; f = g + h; L1: f = f i; // onde, f..j em $s0 .. $s4

Podemos ter o seguinte cdigo em MIPS

beq $s3, $s4, L1 add $s0, $s1, $s2 L1: sub $s0, $s0, $s3

Instrues para Tomada de Deciso

Supondo o seguinte cdigo em C
if (i == j) f = g + h; else f = g h; // onde, f .. j em $s0 .. $s4

Podemos ter o seguinte cdigo em MIPS

bne $s3, $s4, Else add $s0, $s1, $s2 j Exit # desvio incondicional

Else: sub $s0, $s1, $s2 Exit:

Loops
while (save[i] == k) i = i + j; save em $s6 // onde i, j, k em $s3..5 e

Loop: add $t1, $s3, $s3 add $t1, $t1, $t1 add $t1, $t1, $s6 lw $t0, 0($t1) bne $t0, $s5, Exit add $s3, $s3, $s4 j Loop Exit: # $t1 = 4*i

Instrues para Tomada de Deciso

slt (set on less than): compara 2 operandos e define 1 se o 1. menor que o 2. Exemplo: slt $t0, $s3, $s4 # t0 1 se s3<s4 bne $t0, $zero, Less #desvia para Less se $t0<>0 (s3<s4)

Switch / Case
switch(k) { case 0: f = i + j; break; case 1: f = g + h; break; case 2: f = g h; break; } // f .. k em $s0..5, $t2 = 3, L0..2 iniciando em $t4

Procedimentos
Passos a serem tomados na execuo de um procedimento:
1. Colocar os argumentos num local onde possam ser acessados pelo procedimento chamado (responsabilidade do chamador) 2. Garantir os recursos de memria necessrios para execuo do procedimento (chamador) 3. Transferir o controle para o procedimento (chamador)

Procedimentos
(... continuao da execuo de um procedimento):
4. Realizar a tarefa desejada (chamado) 5. Colocar o resultado em local acessvel (chamado) 6. Retornar ao ponto de origem e liberar os recursos (chamador ou chamado)

Procedimentos Registradores e Instrues

$a0 - $a3: 4 registradores utilizados como parmetros de um procedimento $v0 - $v1: 2 registradores utilizados para o retorno de valores por um procedimento $ra: registrador que guarda o ponto de desvio na chamada do procedimento (endereo de retorno return address) jal Endereo # desvia a execuo para Endereo e salva o endereo da instruo seguinte em $ra jr $ra # aps a execuo do procedimento, retorna para o procedimento chamador

Procedimentos Registradores e Instrues

Procedimentos que requerem mais registradores (parmetros e retorno) devem utilizar uma pilha para a passagem de valores Esta pilha acessada pelo registrador $sp (stack pointer)

Procedimentos Exemplo
int f_exemplo (int g, int h, int i, int j) { int f; f = (g + h) - (i + j); return f; } // onde g .. j em $a0..3, f em $s0 f_exemplo: sub $sp, $sp, 12 sw $t1, 8 ($sp) sw $t0, 4 ($sp) sw $s0, 0 ($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $s0, $zero lw $s0, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) add $sp, $sp, 12 jr $ra

... jal rotina # chamada da funo f_exemplo() ...

Conveno do MIPS
$t0..9 so registradores temporrios que no precisam ser preservados $s0..7 so de salvamento que precisam ser preservados

Procedimentos Recursivos
Exemplo do fatorial

Mais Registradores
$fp (frame pointer) $gp (global pointer)

Descrio Completa dos Registradores

Nome $zero $v0-$v1 $a0..3 $t0..7 $s0..7 $t8..9 $gp $sp $fp $ra No. 0 2-3 4-7 8-15 16-23 24-25 28 29 30 31 Uso Cte Resultado Argumentos Temporrios Salvos Temporrios Global Pilha Frame End. Retorno Preservado No No Sim No Sim No Sim Sim Sim Sim

Caracteres / Strings
http://www.tabelaascii.com Cada caracter ocupa 1 byte (8 bits) Como o MIPS trabalha com transferncias de 4 bytes, precisamos de operaes especficas lb e sb so operaes que lem e escrevem 1 byte lb $t0, 0($sp) # l 1 byte (8 bits + direita) sb $t0, 0($gp) # escreve 1 byte (8 bits + direita)

Strings em C
Terminam com o caracter \0 (caracter 0 na tabela ASCII) Ex.: cal definido por: 67, 97, 108, 0
void strcpy (char x[], char y[]) { int i = 0; while ((x[i] = y[i]) != 0) i++ } onde x,y em $a0,$a1 e i em $s0 strcpy: subi $sp, $sp, 4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $a1, $s0 lb $t2, 0($t1) add $t3, $a0, $s0 sb $t2, 0($t3) addi $s0, $s0, 1 bne $t2, $zero, L1 lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra # y[i]
# x[i] # i++

Estilos de Endereamento
Em Registrador
Operando um registrador

Base ou Deslocamento
Operando em memria, cujo endereo a soma de um registrador com constante na instruo

Imediato
Operando uma constante dentro da instruo

Relativo ao PC
Soma do PC a uma constante na instruo

Pseudodireto
Endereo de desvio so os 26 bits da instruo concatenados com os bits mais altos do PC

Traduo dos Labels

while (save[i] == k) i = i + j; save em $s6 80000 80004 80008 80012 80016 80020 80024 80028 0 0 0 35 5 0 2 19 9 9 9 8 19 // onde i, j, k em $s3..5 e Loop: add $t1, $s3, $s3 add $t1, $t1, $t1 add $t1, $t1, $s6 lw $t0, 0($t1) bne $t0, $s5, Exit add $s3, $s3, $s4 j Loop Exit:

19 9 22 9 21 20

9 9 9

0 0 0 0 8

32 32 32

19 80000

32

Traduo de um Programa
Programa C Compilador Programa em Assembly Montador Mdulo em Linguagem de Mquina + Bibliotecas Link-Editor Executvel em Linguagem de Mquina Loader Memria

Traduo de um Programa
Um programa em Linguagem de Montagem (Assembly) composto de instrues e pseudoinstrues A instruo move no MIPS um exemplo de pseudo-instruo, pois traduzida numa instruo equivalente: move $t0, $t1 add $t0, $zero, $t1 Outro exemplo de pseudo-instruo blt (branch on less than) que traduzida para slt/bne

Arquivo Objeto Tpico em Sistemas Unix

Cabealho do Arquivo Objeto: tamanho e posio das demais partes do arquivo Segmento de Texto: cdigo do programa em linguagem de mquina Segmento de Dados: dados necessrios execuo do programa Informaes sobre relocao: identificar as palavras que dependem de endereos absolutos Tabela de smbolos: labels no definidos, como por exemplo, as referncias externas Informaes para anlise de erro (auxlio para o depurador)

Ligador / Link-Editor
O papel do ligador unir as diferentes partes de um programa de forma a se ter um nico arquivo executvel

Carregador / Loader
Etapas de um carregador:
Leitura do cabealho para identificar tamanhos Alocao de espao para armazenamento do programa Cpia para a memria Cpia de parmetros para a pilha Inicializao dos registradores

Vetores x Ponteiros

Outras Arquiteturas
Baseadas em Acumulador
A = B + C traduzido para: load AddressB add AddressC store AddressA

Arquiteturas em Pilha
A = B + C traduzido para: push AddressC push AddressB add pop AddressA

Outras Arquiteturas
Registradores de Propsito Geral
Nome define seu significado Podem ser do tipo:
registrador memria (permitem operando na memria; por ex., acumulador) load/store ou reg/reg (s operandos em registradores; por ex., MIPS) mem/mem (por ex., add EndA, EndB, EndC)

IA-32 80x86
Ao contrrio do MIPS, esta plataforma foi desenvolvida ao longo de anos (quase 20) por muitos projetistas Esse longo perodo torna ainda mais difcil a evoluo de uma arquitetura, pois preciso manter uma compatibilidade com verses anteriores (softwares especficos)
Anlogo a este problema temos o IE e os websites voltados especificamente para o seu funcionamento

IA-32 80x86 Tipos de Instrues

Instrues de movimentos de dados Instrues aritmticas e lgicas; operaes de teste e sobre binrios e decimais Instrues para controle do fluxo de execuo Instrues para manipulao de strings (movimento e comparao, herana do 8080)

IA-32 80x86 Codificao das Instrues

Complexa, com muitos formatos diferentes Tamanho varia de 1 a 17 bytes (possibilidade de + de 1 acesso memria) Usualmente 1 bit indica o tamanho dos operandos (8 ou 32) e a sequncia inicial de bits (opcode) indica o formato da instruo

IA-32 80x86 Falcias e Armadilhas

Instrues mais poderosas significam melhor desempenho
O IA-32 usa prefixos, os quais podem modificar o comportamento da instruo seguinte (por ex., repetir sua execuo at um contador chegar a 0) Realizar a replicao simples desta instruo diminua significativamente o tempo de execuo destas instrues

IA-32 80x86 Falcias e Armadilhas

Programar diretamente em linguagem de montagem para obter melhor desempenho
Atualmente os compiladores geram cdigo bastante otimizado Incoerncia atual em C: uso de varivel register pode tornar a execuo mais lenta Amarrao com a plataforma destino

Aritmtica Computacional
Utilizao de complemento a 2 Qual o maior nmero negativo em 32 bits? Lembre que: 000 001 010 011 100 101 110 111 0 1 2 3 -4 -3 -2 -1

Aritmtica Computacional
Em C, temos: int e unsigned int No MIPS, temos: lb e lbu, slt e sltu, slti e sltiu Por exemplo, suponha: $s0 = 1111 1111 ... 1111 $s1 = 0000 0000 ... 0001 Quanto vale $t0 em: slt $t0, $s0, $s1 1 e 0, respectivamente sltu $t0, $s0, $s1

Regras de Transformao de Valores

Regra para a Negao
Inverso dos bits e adio de 1, descartando o carry do overflow As instrues add, addi, sub, ... sinalizam a ocorrncia de overflow As instrues addu, addiu, subu, ... no sinalizam

Regra para extenso de sinal

Como converter o valor -2 em 16 bits para 32 bits? Adio de bits de sinal esquerda (16 bits)