Introduo Curta ao MIPS

Simo Melo de Sousa

RELEASE - RELiablE And SEcure Computation Group Computer Science Department University of Beira Interior, Portugal desousa@di.ubi.pt http://www.di.ubi.pt/desousa/

S. Melo de Sousa (DIUBI)

MIPS

1 / 45

Este documento uma traduo adaptada do captulo "Introduction lassembleur MIPS" da sebenta "Cours de Compilation" de Jean-Christophe Filliatre (http://www.lri.fr/lliatr).

S. Melo de Sousa (DIUBI)

MIPS

2 / 45

Plano

1 2

MIPS - conceitos e overview MIPS, formato compacto...

S. Melo de Sousa (DIUBI)

MIPS

3 / 45

Arquitectura e assembly MIPS

Mquina alvo para estas aulas. MIPS na wikipedia Um bom livro de Arquitectura de computador que introduz a arquitectura MIPs: Computer Organization & Design: The Hardware/Software Interface, Second Edition. By John Hennessy and David Patterson. Published by Morgan Kaufmann, 1997. ISBN 1-55860-428-6. uns acetatos completos e pedaggicos sobre o MIPS: (link1) (link2) SPIM: Simulador MIPS (link1) (link2)

S. Melo de Sousa (DIUBI)

MIPS

4 / 45

Um pouco de Arquitectura de Computadores

De forma muitio resumida, um computador composto de: Uma unidade de clculo (CPU), contendo un pequeno numero de registos inteiros ou utuantes mecanismos de clculo de uma memria (RAM) composta de um grande nmero de bytes (8 bits) 33 por exemplo, 1Gb = 230 bytes = 233 bits, ou seja, 22 conguraes possveis da memria contm dados e programas (instrues)

S. Melo de Sousa (DIUBI)

MIPS

5 / 45

Um pouco de Arquitectura de Computadores

O acesso memria custa carro (tendo uma arquitectura capaz de realizar um bilio de instruo por segundo, a luz s consegue percorrer 30 centmetros entre cada instruo)
S. Melo de Sousa (DIUBI) MIPS 6 / 45

Um pouco de Arquitectura de Computadores

A realidade um pouco mais complexa... presena de vrios (co)processadores, alguns deles dedicados a operaes sobre utuantes uma ou vrias caches (polticas LRU, random etc..) virtualizao da memria (MMU) etc...

S. Melo de Sousa (DIUBI)

MIPS

7 / 45

Princpio de execuo

Esquematicamente, a execuo decorre da seguinte forma: um registo ($pc) contm o endereo da instruo por executar l-se os 4 (ou 8) bytes endereados por $pc (fase designada de fetch) interpretar estes bits como sendo instrues (fase designada de decode) executar a dita instruo (fase designada de execute) modica-se o registo $pc por forma a que este enderea a prxima instruo (a instruo seguinte, em geral, caso a instruo actual no obriga a um salto)

S. Melo de Sousa (DIUBI)

MIPS

8 / 45

Princpio de execuo

instruo: 000000 00001 00010 0000000000001010 descodicao: add $a1 $a2 10 i.e. juntar 10 ao registo $a1 e arquivar o resultado no registo $a2
S. Melo de Sousa (DIUBI) MIPS 9 / 45

Princpio de execuo

Aqui tambm, a realidade bem mais complexa do que este ltimo, muito simples, exemplo. Pipelines: vrias instrues so executadas em paralelo (por exemplo, numa sequncia de 3 instrues, enquanto que a primeira executada, a segunda j descodicada e a terceira carregada, isso tudo num s ciclo CPU - i.e. em simultneo) Branch prediction. Para optimizar o pipelining, existe a possibilidade de adivinhar (com base em determinadas heursticas) o resultado de instrues de salto (que necessitam fazer um ush do pipeline caso haja salto)

S. Melo de Sousa (DIUBI)

MIPS

10 / 45

Arquitectura MIPS

32 registos, r0 r31

r0 contm sempre 0 Estes registos podem ser referenciados por outros nomes (correspondentes a uma conveno de nomes admitida nos simuladores que vamos usar): zero, at, v0-v1, a0-a3, t0-t9, s0-s7, k0-k1, gp, sp, fp, ra trs tipos de instrues:
instrues de transferncias, entre registos e/ou memria instrues de clculo instrues de salto

S. Melo de Sousa (DIUBI)

MIPS

11 / 45

SPIM

Na prtica , utilizaremos um simulador MIPS designado por SPIM Em linha de comando: spim [-file] file.s Em modo grco: xspim -file file.s (execuo passo a passo, visualizao dos registos, da memria, etc.)

S. Melo de Sousa (DIUBI)

MIPS

12 / 45

Instrues MIPS

Carregamento de uma constante (16 bits com signo) num registo li $a0, 42 lui $a0, 42 # a0 <- 42 # a0 <- 42 * 2^16

Cpia de um registo para outro move $a0, $a1 # cpia de *a1* para *a0*

S. Melo de Sousa (DIUBI)

MIPS

13 / 45

Instrues MIPS - aritmtica

Soma de dois registos add $a0, $a1, $a2 add $a2, $a2, $t5 idem para sub, mul, div soma do valor de um registo com uma constante addi $a0, $a1, 42 # a0 <- a1 + 42 # a0 <- a1 + a2 # a2 <- a2 + t5

(aqui no h o equivalente com subi, muli, divi) negao neg $a0, $a1 valor absoluto abs $a0, $a1
S. Melo de Sousa (DIUBI)

# a0 <- -a1

# a0 <- |a1|
MIPS 14 / 45

Instrues MIPS - bit-wise

Negao lgica (not 1001112 = 0110002 ) not $a0, $a1 # a0 <- not(a1)

Conjuno lgica (and (1001112 , 1010012 )= 1000012 ) and $a0, $a1, $a2 andi $a0, $a1, 0x3f # a0 <- and(a1,a2) # a0 <- and(a1,0...0111111)

Disjuno lgica (or (1001112 , 1010012 )= 1011112 ) and $a0, $a1, $a2 andi $a0, $a1, 42 # a0 <- or(a1,a2) # a0 <- or(a1,0...0101010)

S. Melo de Sousa (DIUBI)

MIPS

15 / 45

Instrues MIPS - shift

left shift (insero de zeros) sll $a0, $a1, 2 sllv $a1, $a2, $a3 # a0 <- a1 * 4 # a1 <- a2 * 2^a3

right shift aritmtico (cpia do bit do sinal) sra $a0, $a1, 2 # a0 <- a1 / 4

right shift lgico (insero de zeros) srl $a0, $a1, 2

Rotao rol ror $a0, $a1, 2 $a0, $a1, 2

S. Melo de Sousa (DIUBI)

MIPS

16 / 45

Instrues MIPS - transferncias/leituras

ler uma palavra (32 bits) em memria lw $a0, 42($a1) # a0 <- mem[a1 + 42]

O endereo dado por um registo e um oset dado no formato 16 bits com sinal variantes para ler 8 ou 16 com sinal ou no (lb, lh, lbu, lhu).

S. Melo de Sousa (DIUBI)

MIPS

17 / 45

Instrues MIPS - transferncias/escritas

escrever uma palavra (32 bits) em memria sw $a0, 42($a1) # mem[a1 + 42] <- a0 #(cuidado com a ordem # dos parmetros)

O endereo dado por um registo e um oset dado no formato 16 bits com sinal variantes para ler 8 ou 16 (sb, sh).

S. Melo de Sousa (DIUBI)

MIPS

18 / 45

Instrues MIPS - saltos

salto condicional beq $a0, $a1, label # se a0 = a1 salto para label # seno... nada

variantes: bne, blt, ble, bgt, bge (assim como comparaes sem sinal). variantes: (comparaes com zero) beqz, bnez, bltz, blez, bgtz, bgez.

S. Melo de Sousa (DIUBI)

MIPS

19 / 45

Instrues MIPS - saltos

salto incondicional para um endereo j label para um endereo, com arquivo do endereo da instruo seguinte no registo $ra. jal label # jump and link

para um endereo arquivado num registo. jr $a0 para um endereo arquivado num registo, com arquivo do endereo da instruo seguinte num registo. jalr $a0, $a1 # salto para $a0, e arquivo da prxima # instruo em $a1
MIPS 20 / 45

S. Melo de Sousa (DIUBI)

Instrues MIPS - chamadas ao sistema

possvel invocar alguns servios disponibilizados pela arquitectura de suporte (num simulador, so servios do sistema operativo subjacente). A instruo MIPS para esta chamada syscall. O cdigo da instruo por chamar deve estar no registo $v0, os argumentos em $a0 - $a3. O resultado ser colocado no registo $v0. Por exemplo, para usufruir dos servios da funo print_int basta: li $v0, 1 li $a0,42 syscall #cdigo de print_int #o valor (do universo) por mostrar

S. Melo de Sousa (DIUBI)

MIPS

21 / 45

Assembly MIPS

Como j sabem..... no costume programar em linguagem mquina, mas sim com recurso ao assembly. O assembly fornece certas facilidades: labels simblicos alocaes de dados globais pseudo-instrues

S. Melo de Sousa (DIUBI)

MIPS

22 / 45

Assembly MIPS
A directiva .text indica que instrues seguem. A directiva .data indica que dados seguem O cdigo car arquivado a partir do endereo 0x400000 e os dados caro arquivados a partir do endereo 0x10000000. Uma etiqueta simblica (label) introduzida por label: e o endereo que ela representa pode ser carregado num registo la $a0, label
MIPS 23 / 45

S. Melo de Sousa (DIUBI)

Hello world!

SPIM invoca o programa endereado por main e entrega-lhe o endereo onde recomear no m da sua execuo no registo $ra .text main: li $v0, 4 # cdigo de print_int la $a0, hw # endereo da string syscall # chamada ao sistema jr $ra # fin do programa .data hw: .asciiz "hello world\n" ( .asciiz uma facilidade para .byte 104, 101, ... 0)

S. Melo de Sousa (DIUBI)

MIPS

24 / 45

Compilao e MIPS

O desao da compilao para o assembly (MIPS, em particular) conseguir traduzir um linguagem de alto nvel para este conjunto de instrues. Em particular, preciso: traduzir as estruturas de controlo (testes, ciclos, excepes, etc.) traduzir as chamadas s funes traduzir as estruturas de dados complexas (vectores, registos, objectos, fechos, etc.) alocar memria de forma dinmica

S. Melo de Sousa (DIUBI)

MIPS

25 / 45

Chamadas a funes

Facto: as chamadas a funes podem estar arbitrariamente aninhadas. Os registos podem no chegar para arquivar todos os parmetros, variveis locais e outros dados locais a cada chamada necessrio alocar memria para tal As funes procedem na base de uma poltica last-in rst-out, i.e. uma pilha.

S. Melo de Sousa (DIUBI)

MIPS

26 / 45

A pilha

A pilha posicionada na parte superior, e cresce no sentido dos endereos decrescentes. O registo $sp aponta para o topo da pilha. Os dados dinmicos (que sobrevivem s chamadas a funes) so alocadas na heap (eventualmente por um GC), na parte inferior da zona de dados, logo a seguir aos dados estticos. Assim temos casa arrumada...

S. Melo de Sousa (DIUBI)

MIPS

27 / 45

Chamadas a funes
Quando uma funo f (quem invoca, ou caller) pretende invocar uma funo g (que chamado ou callee), f executa: jal g quando a funo invocada termina, esta devolve o controlo para o caller, com: jr $ra Mas ento: se g ela prpria invoca uma funo, o registo $ra ser actualizado (e perder o valor de que chamou g ) da mesma forma, qualquer registo utilizado por g car inutilizvel por f posteriormente. Existe vrias formas de resolver esta problemtica, mas de forma geral costuma-se respeitar uma conveno para chamadas
S. Melo de Sousa (DIUBI) MIPS 28 / 45

Conveno para chamadas

Uso dos registos: $at, $k0, $k1 esto reservados para o Sistema Operativos $a0, ... , $a3 usados para passar os 4 primeiros argumentos (ou outros so passados via pilha) $v0, ... , $v1 usados para passar devolver o resultado de uma chamada $t0, ... , $t9 so registos caller-saved, i.e. o caller deve salvaguarda-los, se necessrio. So usados tipicamente para dados que no necessitam sobreviver s chamadas $s0, ... , $s7 so registos callee-saved, i.e. o callee deve salvaguarda-los, se necessrio. So usados tipicamente para dados de durao longa, que necessitam assim de sobreviver s chamadas $sp, $fp, $ra, $gp so, respectivamente, o apontador para o topo da pilha, o apontador para a frame, o return address e o registo que aponta para o meio da zona de dados estticos (1000800016 )
S. Melo de Sousa (DIUBI) MIPS 29 / 45

Chamada, em 4 etapas

H 4 fases numa chamada a uma funo:

1 2 3 4

Para o caller, mesmo antes da chamada Para o callee, logo a seguir chamada Para o callee, mesmo antes do m da chamada Para o caller, logo a seguir ao m da chamada

Estas organizam-se na base de um segmente de memria localizado no topo da pilha, designada de tabela de activao ou (em ingls) de stack frame, estando este situado entre $fp e $sp.

S. Melo de Sousa (DIUBI)

MIPS

30 / 45

caller, mesmo antes da chamada

Passa os argumentos em $a0 - $a3, e os restantes na pilha (se houver mais do que 4 argumentos) salvaguarda os registos $t0-$t9 que entende utilizar aps a chamada (na sua prpria tabela de activao ) executa: jal callee

S. Melo de Sousa (DIUBI)

MIPS

31 / 45

callee, no incio da chamada

Alocar a sua tabela de activao, por exemplo: addi $sp, $sp, -28

Salvaguardar $fp e, a seguir, posicion-lo, por exemplo sw $fp, 24($sp) addi $fp, $sp, 24

salvaguardar $0 - $s7 e $ra caso seja necessrio $fp permite alcanar facilmente os argumentos e as variveis locais, com base num oset xo, qualquer que seja o estado da pilha.
3

S. Melo de Sousa (DIUBI)

MIPS

32 / 45

o callee, no m da chamada

1 2 3

coloca o resultado em $v0 (e em $v1 se for necessrio) restabelece os registos salvaguardados pop da sua tabela de activao, por exemplo addi $sp, $sp, 28

executa jr $ra

S. Melo de Sousa (DIUBI)

MIPS

33 / 45

caller, logo a seguir ao m da chamada

pop dos eventuais argumentos 5, 6, etc.... (os que no couberam nos reguistos $a0 - $a3) restabelece os registos caller-saved.

S. Melo de Sousa (DIUBI)

MIPS

34 / 45

Plano

1 2

MIPS - conceitos e overview MIPS, formato compacto...

S. Melo de Sousa (DIUBI)

MIPS

35 / 45

MIPS em resumo
li $r0, C lui $r0, C move $r0, $r1 add addi sub div div mul neg slt slti sle seq sne $r0, $r0, $r0, $r0, $r1, $r0, $r0, $r0, $r0, $r0, $r0, $r0, $r1, $r1, $r1, $r1, $r2 $r1, $r1 $r1, $r1, $r1, $r1, $r1, $r C $r2 $r2 $r2 $r0 <- C $r0 <- 2^16*C $r0 <- $r1 $r0 $r0 $r0 $r0 $lo $r0 $r0 $r0 $r0 $r0 $r0 $r0 <<<<<<<<<<<<$r1 + $r1 + $r1 $r1 / $r1 / $r1 * -$r1 1 1 1 1 1 se se se se se $r2 C $r2 $r2 $r2, $hi <- $r1 mod $r2 $r2 (sem overflow)

$r2 C $r2 $r2 $r2

$r1 $r1 $r1 $r1 $r1

< < <= = <>

$r2, C, $r2, $r2, $r2,

$r0 $r0 $r0 $r0 $r0

<<<<<-

0 0 0 0 0

seno seno seno seno seno

S. Melo de Sousa (DIUBI)

MIPS

36 / 45

MIPS em resumo
la lw sw beq beqz bgt bgtz $r0, adr $r0, adr $r0, adr $r0, $r0, $r0, $r0, $r1, label label $r1, label label $r0 <- adr $r0 <- mem[adr] mem[adr] <- $r0 salto salto salto salto se se se se $r0 $r0 $r0 $r0 = = > > $r1 0 $r1 0

beqzal $r0, label bgtzal $r0, label j jal jr jalr label label $r0 $r0

salto se $r0 = 0, $ra <- $pc + 1 salto se $r0 > 0, $ra <- $pc + 1 salto salto salto salto
MIPS

para para para para

label label, $ra <- $pc + 1 $r0 $r0, $ra <- $pc + 1
37 / 45

S. Melo de Sousa (DIUBI)

MIPS em resumo
Registers Calling Convention Name Number Use Callee must preserve? $zero $0 constant 0 N/A $at $1 assembler temporary No $v0-$v1 $2-$3 values for function returns and expression evaluation No $a0-$a3 $4-$7 function arguments No $t0-$t7 $8-$15 temporaries No $s0-$s7 $16-$23 saved temporaries Yes $t8-$t9 $24-$25 temporaries No $k0-$k1 $26-$27 reserved for OS kernel N/A $gp $28 global pointer Yes $sp $29 stack pointer Yes $fp $30 frame pointer Yes $ra $31 return address N/A
S. Melo de Sousa (DIUBI) MIPS 38 / 45

MIPS - syscall - Chamadas ao sistema

Pode depender do simulador utilizado (consultar documentao)
Servio print_int print_oat print_double print_string read_int read_oat read_double read_string sbrk/malloc exit Cdigo em $v0 1 2 3 4 5 6 7 8 9 10 $a0 = endereo da string por ler $a1 = comprimento da string $a0 = quantidade de memria por alocar $v0 = o cdigo devolvido Argumentos $a0 = o inteiro por imprimir $f12 = o oat por imprimir $f12 = o double por imprimir $a0 = endereo da string por imprimir $v0 = o inteiro devolvido $f0 = o oat devolvido $f0 = o double devolvido Resultados

endereo em $v0

S. Melo de Sousa (DIUBI)

MIPS

39 / 45

MIPS - syscall - Chamadas ao sistema

#Print out integer value contained in register $t2 li $v0, 1 # load appropriate system call code into register $v0; # code for printing integer is 1 move $a0, $t2 # move integer to be printed into $a0: $a0 = $t2 syscall # call operating system to perform operation #Read integer value, store in RAM location with label int_value #(presumably declared in data section) li $v0, 5 # load appropriate system call code into register $v0; # code for reading integer is 5 syscall # call operating system to perform operation sw $v0, int_value # value read from keyboard returned in register $v0; # store this in desired location #Print out string (useful for prompts) .data string1 .asciiz "Print this.\n" # declaration for string variable, # .asciiz directive makes string null terminated .text main: li $v0, 4 # load appropriate system call code into register $v0; # code for printing string is 4 la $a0, string1 # load address of string to be printed into $a0 syscall # call operating system to perform print operation
S. Melo de Sousa (DIUBI) MIPS 40 / 45

MIPS - um exemplo : Fib

#-----------------------------------------------# fib - recursive Fibonacci function. # http://www.cs.bilkent.edu.tr/~will/courses/ # CS224/MIPS%20Programs/fib_a.htm # # a0 - holds parameter n # s0 - holds fib(n-1) # v0 - returns result #-----------------------------------------------# Code segment .text fib: sub $sp,$sp,12 # save registers on stack sw $a0,0($sp) sw $s0,4($sp) sw $ra,8($sp) bgt $a0,1,notOne move $v0,$a0 b fret

S. Melo de Sousa (DIUBI)

# fib(0)=0, fib(1)=1 # if n<=1

MIPS

41 / 45

MIPS - um exemplo : Fib

notOne: sub $a0,$a0,1 jal fib move $s0,$v0 sub $a0,$a0,1 jal fib add $v0,$v0,$s0 fret: lw $a0,0($sp) lw $s0,4($sp) lw $ra,8($sp) add $sp,$sp,12 jr $ra # param = n-1 # compute fib(n-1) # save fib(n-1) # set param to n-2 # and make recursive call # add fib(n-2) # restore registers

# data segment .data endl: .asciiz "\n"

S. Melo de Sousa (DIUBI) MIPS 42 / 45

Instrues macros para a mquina de pilhas

Um registo $sp (stack pointer) que aponta para a primeira clula livre da pilha O endereamento faz-se com base em bytes: uma palavra de 32 bits cabe em 4 bytes. Funes de arquivo e de carregamento na pilha:
l e t p u s h r r = sub $sp , $sp , 4 sw r , 0 ( $ s p ) l e t p o p r r = lw r , 0 ( $ s p ) | add $sp , $sp , 4 |

S. Melo de Sousa (DIUBI)

MIPS

43 / 45

S. Melo de Sousa (DIUBI)

MIPS

44 / 45

S. Melo de Sousa (DIUBI)

MIPS

45 / 45