• Non ci sono risultati.

Assembler MIPS R2000/R3000 Assembly I

N/A
N/A
Protected

Academic year: 2021

Condividi "Assembler MIPS R2000/R3000 Assembly I"

Copied!
26
0
0

Testo completo

(1)

© 2002-2003 Alberto Montresor, Riccardo Solmi 1

TITLE

Assembler MIPS R2000/R3000 Assembly I

Riccardo Solmi

Bibliografia

§ MIPS – Assembly Language Programmer’s Guide

• Manuale di programmazione assembly MIPS

§ Assemblers, Linkers, and the SPIM Simulator

• Contiene un tutorial per imparare ad usare il simulatore SPIM

§ SPIM – A MIPS R2000/R3000 Simulator

• Assemblatore, simulatore e debugger MIPS

§ Trovate tutto nella pagina web relativa a questo modulo:

• http://www.cs.unibo.it/~solmi/teaching/arch_2002-

2003.html

(2)

© 2002-2003 Alberto Montresor, Riccardo Solmi 3

Indice degli argomenti

§ Le istruzioni assembly MIPS

• Categorie di istruzioni assembly

• Istruzioni di caricamento e salvataggio

• Gestione del segno

• Ordine dei bytes (endianness)

• Modi di indirizzamento

• Istruzioni aritmetiche, logiche e di scorrimento

• Istruzioni di confronto e salto condizionato

• Istruzioni di salto non condizionato

© 2002-2003 Alberto Montresor, Riccardo Solmi 4

Indice degli argomenti

§ Programmazione assembly

• Realizzazione delle principali strutture di controllo

• sequenze

• scelte

• ripetizioni

• Scrittura di semplici programmi assembly:

• operazioni su stringhe

• input e output su console

(3)

© 2002-2003 Alberto Montresor, Riccardo Solmi 5

Categorie di istruzioni assembly

§ Le istruzioni del linguaggio assembly MIPS possono essere divise nelle seguenti categorie:

Istruzioni “Load and Store”

Queste istruzioni spostano dati tra la memoria e i registri generali del processore

Istruzioni “Load Immediate”

Queste istruzioni caricano nei registri valori costanti

Istruzioni “Data Movement”

Queste istruzioni spostano dati tra i registri del processore

Istruzioni aritmetico/logiche

Queste istruzioni effettuano operazioni aritmetico, logiche o di scorrimento sui registri del processore

Categorie di istruzioni assembly

Istruzioni di confronto

Queste istruzioni effettuano il confronto tra i valori contenuti nei registri

Istruzioni di salto condizionato

Queste istruzioni permettono di spostare l’esecuzione da un punto ad un altro di un programma in presenza di certe condizioni

Istruzioni di salto non condizionato

Queste istruzioni permettono di spostare l’esecuzione da un punto ad un altro di un programma

§ NOTA:

Nel seguito, le pseudoistruzioni sono evidenziate in blu e sottolineate

(4)

© 2002-2003 Alberto Montresor, Riccardo Solmi 7

Architettura load and store

§ L'architettura di MIPS è di tipo Load-and-Store

• In pratica, la maggioranza delle istruzioni di MIPS operano tramite i registri interni al processore

• Esempio:

add $t0, $t1, $t2

Somma $t1+$t2 e mette il risultato in $t0

• Per questo motivo

• LOAD: i dati da elaborare devono essere prelevati dalla memoria

• STORE: i risultati devono essere salvati in memoria

© 2002-2003 Alberto Montresor, Riccardo Solmi 8

Istruzioni load and store

lb rdest, address Load Byte at addressin register rdest

lbu rdest, address Load Byte Unsigned at addressin register rdest lh rdest, address Load Halfword at addressin register rdest

lhu rdest, address Load Halfword Unsigned at addressin register rdest lw rdest, address Load Word from addressin register rdest

la rdest, address Load computedAddressin register rdest

sb rsource , address Store lower Byte at addressfrom register rsource sh rsource , address Store lower Halfword at addressfrom register rsource sw rsource , address Store Word at addressfrom register rsource

(5)

© 2002-2003 Alberto Montresor, Riccardo Solmi 9

Esempio istruzioni load and store

§ Esempio:

.text # Inizia il codice lw $t1, operandA # Load operandA lw $t2, operandB # Load operandB

add $t0, $t1, $t2 # operandA + operandB sw $t0, result # Store result

.data # Iniziano i dati operandA: .word 5

operandB: .word 7 result: .word 0

Istruzioni load con e senza segno (bytes)

§ LB $t0, address

• Carica il byte indirizzato da address nel byte meno significativo del registro

• Il bit di segno viene esteso

§ LBU $t0, address

• Carica il byte indirizzato da address nel byte meno significativo del registro

• Gli altri tre byte vengono posti a zero

Memoria

- - -

Registro $t0

address

-

Memoria

0 0 0

Registro $t0 address

(6)

© 2002-2003 Alberto Montresor, Riccardo Solmi 11

Istruzioni load con e senza segno (halfword)

§ LH $t0, address

• Carica i 2 byte indirizzati da address nei 2 byte meno significativi del registro

• Il bit di segno viene esteso

§ LHU $t0, address

• Carica i 2 byte indirizzati da address nei 2 byte meno significativi del registro

• Gli altri due byte vengono posti a zero

Memoria

- -

Registro $t0

address

-

Memoria

0 0

Registro $t0

address

© 2002-2003 Alberto Montresor, Riccardo Solmi 12

Endianness

§ Definizione di endianness

• Come viene rappresentata una word (32 bit) in 4 byte di memoria?

• Esistono due schemi:

• Little Endian: memorizza prima la "little end" (ovvero i bit meno significativi) della word

• Big Endian: memorizza la "big end" (ovvero i bit più significativi) della word

• Terminologia ripresa dai Viaggi di Gulliver di Jonathan Swift, in cui due fazioni sono in lotta per decidere se le uova sode devono essere aperte a partire dalla "little end" o dal

"big end" dell'uovo

(7)

© 2002-2003 Alberto Montresor, Riccardo Solmi 13

Endianness – Esempio

§ Little endian

• Cosa succede se faccio uno

lh $t0, address

?

$t0 = 0x00003412

§ Big endian

• Cosa succede se eseguo un'istruzione

lh $t0, address

?

$t0 = 0x00001234

12 34 56 78

00 00 34 12

Registro $t1 address

Memoria

12 34 56 78

00 00 12 34

Registro $t0 address

Memoria

Endianness

§ Nota:

• I processori x86 sono little-endian

• MIPS può essere little endian o big endian

• L'endianness di SPIM dipende dal sistema in cui viene eseguito, quindi in generale è little endian

§ Quando bisogna affrontare i problemi di endianness?

• Quando si "mischiano" operazioni su 8, 16 e 32 bit.

• Quando invece si utilizzano operazioni uniformi, non vi

sono problemi di sorta

(8)

© 2002-2003 Alberto Montresor, Riccardo Solmi 15

Load address vs load word

§ Importante differenza:

• L'istruzione

lw $t0, address

carica il contenuto della word indirizzata dall'etichetta address in memoria

• L'istruzione

la $t0, address

carica l'indirizzo della word indirizzata dall'etichetta address in memoria

01 00 00 00

00 00 00 01

Registro $t0 address

0x00400030 0x00400031 0x00400032 0x00400033

lw $t0, address

01 00 00 00

00 40 00 30

Registro $t0 address

0x00400030 0x00400031 0x00400032 0x00400033

la $t0, address

© 2002-2003 Alberto Montresor, Riccardo Solmi 16

Load address vs load word

§ Quando utilizzare load address?

• Quando vogliamo caricare in un registro l'indirizzo di una particolare zona di memoria

• Questo registro può essere utilizzato in seguito come indice per leggere il contenuto di byte consecutivi in memoria

• Esempio:

la $t0, spese

# Carica l'indirizzo di spese

loop:

lw $t1, ($t0)

# Carica in $t1 il contenuto della word

# indirizzata da $t0

add $t2, $t2, $t1

# Fai la sommatoria

addi $t0, $t0, 4

# Incrementa $t0 di 4 byte (1 word)

bnez $t1, loop

# Continua finché non trova 0

(9)

© 2002-2003 Alberto Montresor, Riccardo Solmi 17

Modi di indirizzamento

§ Cos'è un modo di indirizzamento?

• Un modo per esprimere un indirizzo di memoria

• NB: alla fine il risultato è sempre un indirizzo di memoria dove andrò a leggere (load) o scrivere (store) un dato.

§ Nel linguaggio macchina MIPS, esiste un solo modo di indirizzame nto

imm(register) dove l’indirizzo è dato dalla somma del valore immediato immpiù il contenuto del registro register

Esempio: lw $t0, 4($sp) (legge una word dall’indirizzo $sp + 4)

§ L’assembler fornisce per comodità più modi di indirizzamento

• Un indirizzo si può esprimere come somma di:

una etichetta+ una espressione+ un registro.

Esempio: lw $t1, array + 0x100($t0) (legge una word dall’indirizzo 0x10010104 assumendo: array = 0x10010000 e $t0 = 4)

• Ogni parte: etichetta, espressione e registro è opzionale e per ragioni storiche ogni combinazione ha il proprio nome (vedi lucidi seguenti)

• In alcuni casi, l'assemblatore può generare più istruzioni

Modi di indirizzamento

§ (base register)

• Specifica un indirizzo tramite registro base, assumendo un offset 0.

• L'indirizzo è dato dal contenuto del base register

• Esempio:

lw $t0,($a0)

§ expression

• Specifica un indirizzo assoluto con una espressione fatta solo di somme e sottrazioni di costanti espresse in decimale o esadecimale.

• L'indirizzo è dato dal risultato dell'espressione (costante).

• Esempio:

lw $t0, 0x00400000+4

• I numeri negativi vanno comunque preceduti anche dal

simbolo +. Esempio:

lw $t0, 0x100100c + -4

(10)

© 2002-2003 Alberto Montresor, Riccardo Solmi 19

Modi di indirizzamento

§ expression(base register)

• Specifica un indirizzo tramite registro base e un'offset tramite un'espressione.

• L'indirizzo è dato dal contenuto del base register + il risultato dell'espressione

• Esempio:

lw $t0, 4($sp)

§ Relocatable-symbol

• Specifica un indirizzo (rilocabile) tramite un'etichetta.

• L'assemblatore genera le istruzioni necessarie per gestire l'etichetta e aggiunge al modulo oggetto generato le informazioni di rilocazione.

• Esempio:

lw $t0, operandA

© 2002-2003 Alberto Montresor, Riccardo Solmi 20

Modi di indirizzamento

§ Relocatable-symbol(index register)

• Specifica un indirizzo base tramite una etichetta, mentre l'offset viene specificato tramite un registro indice

• L'indirizzo è dato dalla somma dell'indirizzo associato all'etichetta con il contenuto del registro indice.

• Esempio:

lw $t0, array($t1)

§ Relocatable-symbol + expression

• Specifica un indirizzo base tramite una etichetta, mentre l'offset viene specificato tramite un'espressione

• L'indirizzo è dato dalla somma dell'indirizzo associato all'etichetta con il risultato dell'espressione

• Esempio:

lw $t0, array + 4

(11)

© 2002-2003 Alberto Montresor, Riccardo Solmi 21

Modi di indirizzamento

§ Relocatable-symbol + expression(index register)

• Specifica un indirizzo base tramite una etichetta, mentre l'offset viene specificato tramite un registro indice e un'espressione

• L'indirizzo è dato dalla somma dell'indirizzo associato all'etichetta con il contenuto del registro indice e il risultato dell'espressione.

• Esempio:

lw $t0, array + 4($t1)

Istruzioni Data Movement and Load Immediate

move rdest , rsource

Move register rsource into register rdest

mfhi rdest

Move register hi into register rdest

mflo rdest

Move register lo into register rdest

mthi rsource

Move register rsource into register hi

mtlo rsource

Move register rsource into register lo

li rdest, imm

Move the immediate imm into register rdest

lui rdest, imm

Move the immediate halfword imm

into the upper halfword of register rdest

(12)

© 2002-2003 Alberto Montresor, Riccardo Solmi 23

Istruzioni Aritmetiche: add, sub, neg, abs

add rd, rs, rt

rd = rs + rt (with overflow)

addu rd, rs, rt

rd = rs + rt (without overflow)

addi rd, rs, imm

rd = rs + imm (with overflow)

addiu rd, rs, imm

rd = rs + imm (without overflow)

sub rd, rs, rt

rd = rs - rt (with overflow)

subu rd, rs, rt

rd = rs - rt (without overflow)

neg rd, rs

rd = - rs (with overflow)

negu rd, rs

rd = - rs (without overflow)

abs rd, rs

rd = |rs|

© 2002-2003 Alberto Montresor, Riccardo Solmi 24

Istruzioni Aritmetiche: mul, div, rem

mult rs, rt hi,lo = rs * rt (signed, overflow impossibile)

multu rs, rt hi,lo = rs * rt (unsigned, overflow impossibile)

mul rd, rs, rt rd = rs * rt (without overflow)

mulo rd, rs, rt rd = rs * rt (with overflow)

mulou rd, rs, rt rd = rs * rt (with overflow, unsigned)

div rs, rt hi,lo = resto e quoz. di rs / rt (signed with overflow)

divu rs, rt hi,lo = resto e quoz. di rs / rt (unsigned, no overflow)

div rd, rs, rt rd = rs / rt (signed with overflow)

divu rd, rs, rt rd = rs / rt (unsigned)

rem rd, rs, rt rd = resto di rs / rt (signed)

remu rd, rs, rt rd = resto di rs / rt (unsigned)

(13)

© 2002-2003 Alberto Montresor, Riccardo Solmi 25

Istruzioni Logiche: and, or, xor, not

and rd, rs, rt

rd = rs AND rt

andi rd, rs, imm

rd = rs AND imm

or rd, rs, rt

rd = rs OR rt

ori rd, rs, imm

rd = rs OR imm

xor rd, rs, rt

rd = rs XOR rt

xori rd, rs, imm

rd = rs XOR imm

nor rd, rs, rt

rd = NOT (rs OR rt)

not rd, rs

rd = NOT rs

NB. XOR è un OR esclusivo. 1 XOR 1 = 0 mentre 1 OR 1 = 1.

Istruzioni di scorrimento

sll rd, rs, rt

rd = rs shifted left rt mod 32 bits

srl rd, rs, rt

rd = rs shifted right rt mod 32 bits

sra rd, rs, rt

rd = rs shifted right rt mod 32 bits (signed)

rol rd, rs, rt

rd = rs rotated left rt mod 32 bits

ror rd, rs, rt

rd = rs rotated right rt mod 32 bits Note:

rt può anche essere una costante es. sll $t1, $t2,4

Shift perde dei bits da una parte e dall’altra inserisce degli zero Rotate inserisce da una parte i bit che escono dall’altra

Left[right] sposta i bit verso quelli più[meno] significativi

(14)

© 2002-2003 Alberto Montresor, Riccardo Solmi 27

Istruzioni immediate e unsigned

§ Versioni immediate (i)

• Le versioni immediate (i) delle istruzioni precedenti

utilizzano un valore costante (risultato di un'espressione) al posto di uno degli operandi

• Non sempre è necessario specificare la i; l'assemblatore è in grado di riconoscere anche istruzioni come

add $t0, $t0, 1

§ Versioni unsigned (u)

• Le versioni unsigned delle istruzioni non gestiscono le problematiche relative all'overflow

• Dettagli in seguito quando parleremo di eccezioni

© 2002-2003 Alberto Montresor, Riccardo Solmi 28

Istruzioni di confronto

slt rd, rs, rt

Set register rd to 1 if rs < rt, 0 otherwise (with overflow)

sltu rd, rs, rt

Set register rd to 1 if rs < rt, 0 otherwise (without overflow)

slti rd, rs, imm

Set register rd to 1 if rs < imm, 0 otherwise (with overflow)

sltiu rd, rs, imm

Set register rd to 1 if rs < imm, 0 otherwise (without overflow)

sle, sgt, sge, seq, sne

Analoghe per testare <=, >, >=, = e !=

NB. Di solito queste istruzioni vengono usate solo dall’assemble r.

I programmatori usano direttamente le istruzioni di salto condizionato

(15)

© 2002-2003 Alberto Montresor, Riccardo Solmi 29

Istruzioni di salto condizionato

beq rs, rt, target

Branch to instruction at target if rs = rt

bne rs, rt, target

Branch to instruction at target if rs != rt

bgez rs, target

Branch to instruction at target if rs >= 0

bgtz rs, target

Branch to instruction at target if rs > 0

blez rs, target

Branch to instruction at target if rs <= 0

bltz rs, target

Branch to instruction at target if rs < 0

beqz rs, target

Branch to instruction at target if rs = 0

bnez rs, target

Branch to instruction at target if rs != 0

Istruzioni di salto condizionato

bge rs, rt, target

Branch to instruction at target if rs >= rt

bgeu rs, rt, target

Branch to instruction at target if rs >= rt (unsigned)

bgt rs, rt, target

Branch to instruction at target if rs > rt

bgtu rs, rt, target

Branch to instruction at target if rs > rt (unsigned)

ble rs, rt, target

Branch to instruction at target if rs <= rt

bleu rs, rt, target

Branch to instruction at target if rs <= rt (unsigned)

blt rs, rt, target

Branch to instruction at target if rs < rt

bltu rs, rt, target

Branch to instruction at target if rs < rt

(unsigned)

(16)

© 2002-2003 Alberto Montresor, Riccardo Solmi 31

Branch: dettagli implementativi

§ Nel linguaggio macchina, l’indirizzo dell’istruzione target in un branch viene espresso come instruction offset rispetto all’istruzione corrente

• E’ possibile saltare 2

15

-1 istruzioni in avanti o 2

15

istruzioni indietro

§ In linguaggio assembly, l’indirizzo dell’istruzione target è dato dall’etichetta associata

• Il calcolo viene fatto automaticamente dall’assembler

• Ulteriore semplificazione dell’assembler rispetto al linguaggio macchina

§ Esempio:

0x00400030 beq $5, $4, 8 [stor-0x00400030] beq $a1, $a0, stor

© 2002-2003 Alberto Montresor, Riccardo Solmi 32

Istruzioni di salto (non condizionato)

j target

Unconditionally jump to instruction at target

jal target

Unconditionally jump to instruction at target, and save the address of the next instruction in register

$ra

jr rsource

Unconditionally jump to the instruction whose address is in register rsource

jalr rsource, rdest

Unconditionally jump to the instruction whose

address is in register rsource and save the address

of the next instruction in register rdest

(17)

© 2002-2003 Alberto Montresor, Riccardo Solmi 33

Sequenze di istruzioni

§ Le istruzioni formano sempre una sequenza che corrisponde all’ordine in cui vengono eseguite

• Il microprocessore non ha una visione di insieme del programma: “vede” solo l’istruzione che deve eseguire e il contenuto dei registri.

• Esegue una istruzione alla volta nell’ordine scritto in memoria

§ Fanno eccezione le istruzioni di salto che fanno proseguire l’esecuzione all’indirizzo specificato.

• L’istruzione che viene eseguita dopo un salto è quella che si trova all’indirizzo specificato come destinazione del salto.

• Se il salto è condizionato e la condizione è falsa si prosegue normalmente con l’istruzione successiva.

Sequenze di istruzioni e salti

§ L’intero programma è una sequenza di istruzioni; con i salti posso

controllare l’ordine di esecuzione

• Il codice seguente è equivalente a quello sulla destra

lw $t0,x lw $t1,y

add $t2,$t0,$t1 mul $t3,$t0,$t1 neg $t2,$t2 add $t3,$t3,$t2 sw $t0,x

sw $t1,y

lw $t0,x lw $t1,y j j1

j2:neg $t2,$t2 add $t3,$t3,$t2 j j3

j1:add $t2,$t0,$t1 mul $t3,$t0,$t1 j j2

j3:sw $t0,x

sw $t1,y

(18)

© 2002-2003 Alberto Montresor, Riccardo Solmi 35

Saltare per scegliere: if

§ Voglio eseguire del codice solo se una condizione (espressione) è vera 1. Codice per valutare l’espressione e mettere il risultato in un registro (o due) 2. Salto condizionato per saltare il codice opzionale se la condizione è falsa 3. Codice opzionale da eseguire solo quando la condizione è vera

§ Esempio in assembly: (ifelse.s)

• Se x > 0 allora y = x*2 (altrimenti y resta invariato cioè uguale a 0) .text

.globl main main:

lw $t0,x # Carica x

blez $t0,endif # Salto se condizione falsa mul $t1,$t0,2 # codice opzionale: $t1 = x*2;

sw $t1,y # Salva $t1 nella variabile y

endif: # Fine if

.data

x: .word 5 # provare con 5 e -5

y: .word 0 # y = x*2 se x>0 altrimenti y = 0

© 2002-2003 Alberto Montresor, Riccardo Solmi 36

Saltare per scegliere: if else

§ Voglio eseguire del codice diverso se una condizione (espressione) è vera oppure falsa

1. Codice per valutare l’espressione e mettere il risultato in un registro (o due) 2. Salto condizionato per saltare il “ramo then” se la condizione è falsa 3. Codice da eseguire solo quando la condizione è vera (ramo then) 4. Salto per evitare di eseguire anche il ramo else

5. Codice da eseguire solo quando la condizione è falsa (ramo else)

NB. Posso scambiare i due rami (punti 3 e 5) se salto quando la condizione è vera

§ Esempio in assembly: (ifelse.s )

• Se x > 0 allora y = x*2 altrimenti y = -x lw $t0, x # Carica x

blez $t0, else # Salto se la condizione è falsa mul $t1,$t0,2 # Ramo then: $t1 = x*2;

j end # Salta fine

else:neg $t1, $t0 # Ramo else: $t1 = -x;

end: sw $t1, y # Scrive $t1 in y

(19)

© 2002-2003 Alberto Montresor, Riccardo Solmi 37

Saltare per scegliere: if annidati

§ Le scelte possono essere annidate a piacere

Si dice condizione annidata una che si trova nel ramo then o nel ramo else di una scelta “contenitore”

Una condizione annidata nel ramo then è del tipo:

se condizione1 è vera allora:

se condizione2 è vera esegui solo codice1 altrimenti esegui solo codice2; (ramo then) altrimenti (condizione1 falsa) esegui solo codice3

Una condizione annidata nel ramo else è del tipo:

se condizione1 è vera esegui solo codice1

altrimenti se condizione2 è vera esegui solo codice2 altrimenti esegui solo codice3 (ramo else)

• Posso annidare le condizioni fino alla profondità che mi serve su ogni ramo. (il codice naturalmente diventa sempre più complesso)

§ Per farlo in assembly mi basta applicare ricorsivamente i due schemi di soluzione già visti nei due lucidi precedenti

Esempio su if annidati

§ Esempio in assembly: (ifelse.s)

• Se x > 0 allora (ramo then 1 che contiene scelta annidata) se y >= 0 allora y = x*2 (ramo then 2)

altrimenti y = -x (ramo else 2) altrimenti incrementa y (ramo else 1) lw $t0,x # Carica x lw $t1,y # Carica y

blez $t0,else1 # Salta se la cond1 è falsa bltz $t1,else2 # Salta se la cond2 è falsa mul $t1,$t0,2 # Ramo then2: $t1 = x*2

j end # Salta fine

else2:neg $t1,$t0 # Ramo else2: $t1 = -x

j end # Salta fine

else1:addi $t1,$t1,1 # Ramo else1: $t1 = y + 1 end: sw $t1, y # Scrive $t1 in y

(20)

© 2002-2003 Alberto Montresor, Riccardo Solmi 39

Saltare per scegliere: switch

§ Caso particolare del precedente: le condizioni davanti ad ogni ramo testano valori diversi di una stessa variabile

• Posso usare degli if annidati come sopra oppure mi faccio una tabella con i riferimenti a tutti i codici dei rami e uso la variabile come indice per caricare dalla tabella l’indirizzo del codice dove saltare.

• Il miglioramento che si ottiene è che viene fatto un solo test anziché uno per ogni ramo, riducendo la complessità da lineare a costante.

§ Esempio in assembly: (switch.s)

• se op = 0 allora y = x*3 se op = 1 allora y = x+5 se op = 2 allora y = -x altrimenti y = x

© 2002-2003 Alberto Montresor, Riccardo Solmi 40

Esempio su switch

§ Esempio in assembly: (switch.s) lw $t0,op

bge $t0,3,default # Salta a default se op >= 3 sll $t0,$t0,2 # $t0 = op*4

lw $t0,stable($t0) # $t0 = (stable+op*4)

jr $t0 # Salta al case corrispondente a op case0:mul $t2,$t1,3 # $t2 = x*3

j end

case1:addi $t2,$t1,5 # $t2 = x+5 j end

case2:div $t2,$t1,2 # $t2 = x/2 j end

default: move $t2,$t1 # $t2 = x

end:sw $t2,y # Scrive $t1 in y .data # oltre a op, x e y

stable: .word case0,case1,case2

(21)

© 2002-2003 Alberto Montresor, Riccardo Solmi 41

Saltare per ripetere: while

§ Voglio eseguire più volte del codice finché una espressione è ve ra. Non so se l’espressione è vera all’inizio (quindi la controllo prima di eseguire il codice)

1. Codice per valutare l’espressione e mettere il risultato in un registro (o due) 2. Salto condizionato per saltare il codice da ripetere se la condizione è falsa 3. Codice da ripetere finché la condizione è vera

4. Salto al punto 1 in modo da poter eseguire il codice un’altra volta oppure Salto condizionato al punto 3 per eseguire un’altra volta se la condizione è vera

§ Esempio in assembly: (loops.s)

• Finché x > 0 lo sommo a y (y = y + x) e lo decremento (x = x – 1) lw $t0,x # Carica x

lw $t1,y # Carica y

blez $t0,end # Salta se condizione è falsa

while: # (Inizio ciclo)

add $t1,$t1,$t0 # Effettua sommatoria sub $t0,$t0,1 # Sottrae uno

bgtz $t0,while # Riesegue ciclo finché cond. vera end:sw $t1,y # Salva risultato in y

Saltare per ripetere: do while

§ Voglio eseguire più volte del codice finché una espressione è ve ra. So che all’inizio l’espressione è vera (quindi eseguo il codice e poi controllo)

Inizializzo i registri che mi servono prima di iniziare il ciclo 1. Codice da ripetere finché la condizione è vera

2. Codice per valutare l’espressione e mettere il risultato in un registro (o due) 3. Salto condizionato al punto 1 per eseguire un’altra volta se la condizione è vera

§ Esempio in assembly: (loops.s)

• Finché x > 0 lo sommo a y (y = y + x) e lo decremento (x = x – 1) lw $t0,x # Carica x

lw $t1,y # Carica y dowhile: # (Inizio ciclo)

add $t1,$t1 $t0 # Effettua sommatoria sub $t0,$t0,1 # Decrementa x

bgtz $t0,dowhile # Riesegue ciclo finché cond. vera sw $t1,y # Salva risultato in y

(22)

© 2002-2003 Alberto Montresor, Riccardo Solmi 43

Saltare per ripetere: for

§ Voglio eseguire del codice per un certo numero di volte; voglio anche poter usare l’indice (numero di volte eseguite) nel codice.

Inizializzo i registri che mi servono prima di iniziare il ciclo (compreso l’indice) 1. Codice da ripetere il numero stabilito di volte

2. Incremento il registro usato come indice

3. Salto condizionato al punto 1 per eseguire un’altra volta se la condizione è vera

§ Esempio in assembly: (loops.s)

• Per 5 volte (contando da 1 a 5) sommo l’indice a y (y = y + x) li $t0,1 # Inizializza indice

lw $t1,y # Carica y

loop: # (Inizio ciclo)

add $t1,$t1,$t0 # Effettua sommatoria addi $t0,$t0,1 # Incrementa indice

ble $t0,5,loop # Continua ciclo se <= 5 volte sw $t1,y # Salva risultato in y

© 2002-2003 Alberto Montresor, Riccardo Solmi 44

Esercizi guidati su stringhe

§ length.s

• Scrivere un programma che calcoli la lunghezza di una stringa. Esempio: “ciao” è lunga 4

§ count.s

• Scrivere un programma che calcoli il numero di occorrenze di un carattere in una stringa. Esempio: “a” in “abbac” è 2

§ reverse.s

• Scrivere un programma che data una stringa ne produce una scritta al contrario.

Es. “assembly MIPS” deve diventare: “SPIM ylbmessa”

• E' possibile scrivere un algoritmo che lavori "sul posto"

(23)

© 2002-2003 Alberto Montresor, Riccardo Solmi 45

Esercizio guidato: length.s

.text .globl main

main: # inizializzo un puntatore alla stringa

# e un contatore per la lunghezza

# finché non arrivo alla fine della stringa (0)

# incremento il contatore

# e faccio avanzare il puntatore

strEnd: sw $t1, result # scrivo il risultato jr $ra

.data

str: .asciiz "hello world!!"

result: .word 0

Esercizio guidato: count.s

.text .globl main

main: # inizializzo un puntatore alla stringa

# un contatore per le occorrenze del carattere

# e il carattere da contare

# finché non arrivo alla fine della stringa (0)

# faccio avanzare il puntatore

# e se è uguale al carattere che cerco

# incremento il contatore delle occorrenze strEnd: sw $t2, result # scrivo il risultato

jr $ra

.data

str: .asciiz "abceebceebeebbacacb"

char: .asciiz "a"

(24)

© 2002-2003 Alberto Montresor, Riccardo Solmi 47

Esercizio guidato: reverse.s

.text .globl main

main:

# inizializzo due indici per puntare l'inizio e la fine della st ringa

# sposto il secondo indice fino alla fine della stringa

# scambio i due caratteri puntati dagli indici

# e faccio avanzare gli indici (verso il centro della stringa)

# finché non ho scambiato tutto

end: jr $ra

.data

str: .asciiz "0123456789" # provare anche "assembly MIPS"

© 2002-2003 Alberto Montresor, Riccardo Solmi 48

Chiamate a funzioni del sistema operativo

§ SPIM fornisce un piccolo insieme di servizi “operating- system-like” attraverso l’istruzione syscall

§ Per richiedere un servizio:

Si carica il numero che identifica il servizio nel registro $v0

Eventuali argomenti vengono caricati nei registri $a0-$a1

• Eventuali risultati vengono collocati dalla chiamata di sistema nel registro $v0

§ Esempio

li $v0,1 # Numero che identifica print_int li $a0,5 # 5 è l’argomento da stampare

syscall # procedi alla stampa

(25)

© 2002-2003 Alberto Montresor, Riccardo Solmi 49

Elenco System Call disponibili

address in $v0 double in $f0 float in $f0 integer in $v0

Results

$a0=amount

$a0=buffer,

$a1=length

$a0 = string

$f12 = double

$f12 = float

$a0= integer

Arguments

read_string 8

9 sbrk

10 exit

7 read_double

read_float 6

5 read_int

4 print_string print_double 3

2 print_float

print_int 1

Code Service

Esempio sulle system calls

.text .globl main main:

li $v0,4 # print_string la $a0,prompt

syscall # stampa il prompt

li $v0,8 # read_string la $a0,buffer

li $a1,256

syscall # legge un nome

li $v0,4 # print_string la $a0,msg

syscall # stampa "ciao " + nome

#... continua

li $v0, 10 # exit

syscall # termina programma

.data

prompt: .asciiz "Come ti chiami : "

msg: .ascii "ciao "

buffer: .space 256

(26)

© 2002-2003 Alberto Montresor, Riccardo Solmi 51

Esercitazione

§ Scrivere un programma in assembly MIPS che:

• Mostra un menu con tre possibilità:

• 1) Lunghezza

Chiede un stringa e scrive la sua lunghezza;

dopo mostra di nuovo il menu

• 2) Occorrenze

Chiede una stringa e una lettera e scrive quante volte compare la lettera nella stringa;

dopo mostra di nuovo il menu

• 3) Esci

Termina l’esecuzione del programma

… e un prompt: Scegli (1,2,3):

© 2002-2003 Alberto Montresor, Riccardo Solmi 52

Esercitazione: modalità di consegna

§ Data di consegna: entro il 25/11/2002

§ Metodo di consegna:

• Tramite mail a solmi@cs.unibo.it

• Subject del mail: ARCH-ES01 (siate precisi!)

• Un file assembly con estensione .s in attachment

• Il vostro nome cognome ed eventuali commenti nel corpo del messaggio

§ Nota:

• Gli esercizi non sono obbligatori…

• …però sono fortemente consigliati!

• Ne discuteremo in aula

Riferimenti

Documenti correlati

Double-balloon endoscopy permits insertion of the endoscope into regions not accessible to the conventional endoscope and allows endoscopic diagnosis of lesions in the distal

The Uppsala trial compared preoperative short-course radiotherapy versus postoperative radiotherapy to 60 Gy in patients with a tumour at stage B or C [3], and the Swedish Rectal

• programma equivalente scritto in linguaggio assembly, che può essere trasformato in un file oggetto da un assembler.. • oppure, direttamente in un

Vengono eseguite le istruzioni della funzione chiamante f che precedono la chiamata (jal) a p.. Chiamata: l’istruzione jal salva l’indirizzo della prossima istruzione da eseguire

• Una word può essere usata anche per contenere l’indirizzo di un’altra struttura dati; in questo caso si dice che punta o che è un puntatore a quest’ultima. • Una funzione

• Le istruzioni estraggono i parametri dallo stack degli operandi e vi inseriscono il risultato. • Lo stack degli operandi sostituisce

• xxx deve essere sostituito con le iniziali dei cognomi dei membri del gruppo in ordine alfabetico. • Esempio: Marco Rossi e Giovanni Neri consegnerebbero un file

Unconditionally jump to the instruction whose address is in register rsource and save the address of the next instruction in register rdest. © 2002-2004 Alberto Montresor,