Gestione delle subroutine

(1)

Gestione delle subroutine

(2)

Vantaggi delle subroutines

In maniera analoga alle funzioni/metodi dei linguaggi di alto livello, anche in assembly le subroutines garantiscono una maggiore semplicità, modularità e riusabilità del software.

Inoltre riducono il consumo di memoria necessario per la

memorizzazione del codice, nel caso in cui un determinato insieme di istruzioni debba essere richiamato più volte durante

l’elaborazione.

(3)

Salto a sottoprogramma

L’istruzione di salto a subroutine (JSR) permette di saltare da un programma – programma principale – ad un altro programma – sottoprogramma.

Esempio

JSR moltiplicazione ;salta al sottoprogramma “moltiplicazione”

L’esecuzione del sottoprogramma termina con l’istruzione RET, con la quale si ritorna ad eseguire il programma principale, o meglio il programma chiamante.

(4)

Collegamento tra programma e sottoprogramma

JSR A

RET

Programma principale Sottoprogramma A

JSR A

(5)

Differenza tra JMP e JSR

La sintassi di JSR (Jump To Subroutine) è la stessa dell’istruzione di salto incondizionato JMP, cioè:

JSR <dest>

dove dest è l’indirizzo di memoria della prima istruzione della subroutine espresso sotto forma di numero binario a 32 bit o di riferimento simbolico.

A differenza dell’istruzione JMP, il microprogramma associato all’istruzione JSR, prima di rimpiazzare il contenuto del PC con l’indirizzo <dest>, deve memorizzarne il valore in memoria.

In questo modo, al termine della subroutine, l’esecuzione può riprendere dall’istruzione successiva alla JSR.

L’area di memoria preposta alla memorizzazione degli indirizzi di ritorno delle subroutines deve permettere di gestire efficentemente anche situazioni più

complesse, in cui i sottoprogrammi chiamano a loro volta altri sottoprogrammi (nested subroutines).

(6)

Nested subroutines

JSR A

RET Programma

principale Sottoprogr.

A

JSR A RET

Sottoprogr.

B

JSR B

RET

Sottoprogr.

C

JSR C 1

2 3

4 6 5

(7)

Lo stack

La gestione dei sottoprogrammi è basata su una struttura dati

chiamata stack (pila), gestita con una tecnica LIFO (Last In First Out): gli elementi vengono prelevati a partire dall’ultimo che è stato memorizzato.

L’operazione di inserimento di un alla sommità (top) dello stack è chiamata push, mentre l’operazione inversa è chiamata pop.

Le operazioni di PUSH e POP, sebbene non disponibili nel set di istruzioni del PD32, vengono comunque implementate come

pseudoistruzioni di movimento dati.

Le pseudoistruzioni sono non sono implementate a livello hardware, ma sono messe a disposizione dall’assemblatore che provvede a

mapparle nelle istruzioni del microprocessore equivalenti.

(8)

La gestione dello stack nel PD32

Nel PD32 lo stack è costituito da longword e ad esso è associato un particolare registro detto SP (Stack Pointer) che nel PD32 coincide con il registro R7. Tale registro punta sempre alla cima (top) dello stack.

Per “ragioni storiche”, nel PD32 lo stack cresce verso indirizzi di memoria decrescenti. Sia S l’indirizzo iniziale dello stack (base), allora gli n elementi presenti sono memorizzati nelle locazioni consecutive:

S, S-4, S-8,…,S-4*n

STACK

elem.2 byte 2

BASE S

S-1 S-2 S-3 S-4 S-5 S-6 S-7 S-8 elem.1 byte 4 LSB

elem.1 byte 3 elem.1 byte 2 elem.1 byte 1 MSB

elem.2 byte 4 LSB elem.2 byte 3 elem.2 byte 1 MSB

S-8 R7

TOP

(9)

Le pseudoistruzioni per la gestione dello stack

PSEUDO-

ISTRUZIONE OP. COMMENTO

PUSH S Inserisce in cima allo stack una longword indirizzata

dall’operando sorgente S. Viene tradotta come: MOVL S, -(R7) POP D Estrae dallo stack una longword e la pone nella locazione

indicata dall’operando D. Viene tradotta come: MOVL (R7)+, D PUSHSR

^- Inserisce lo Status Register in cima allo stack. Viene tradotta

come: MOVRFRSR -(R7)

POPSR

^- Ripristina lo Status Register con la longword presente in cima allo stack. Viene tradotta come: MOVTOSR (R7)+

(10)

Esempio esecuzione PUSH

PRIMA DI ESEGUIRE PUSH R6…

000027FC BASE

78 56 34 12

000027F8 000027F8 TOP

R7PCR6 0000041011223344

000027FC BASE

78 56 34 12

000027F4 000027F8

R7PCR6 0000041411223344 44 33 22

000027F4 11 TOP

… E DOPO

(11)

Esempio esecuzione POP

PRIMA DI ESEGUIRE POP R5… … E DOPO

000027FC BASE

78 56 34 000027F8 12

00000414 PC FFFFFFFF R5

44 33 22

000027F4 11 TOP

000027F4 R7

000027FC BASE

78 56 34

12 TOP

000027F8

00000418 PC 11223344 R5

000027F8 R7

(12)

Lo stack e le subroutines

L’istruzione JSR inserisce (PUSH) in cima allo stack il valore del PC, ovvero l’indirizzo di ritorno della subroutine. In maniera

analoga, l’istruzione RET estrae dalla cima dello stack una

longword che memorizza all’interno del PC. Nella successiva fase di fetch sarà quindi caricata nell’IR l’istruzione che segue la JSR.

Lo stack è inoltre utilizzato dalla subroutine chiamata per salvare i registri che saranno utilizzati e quindi sovrascritti, così da poterne ripristinare il valore originale prima di eseguire il RET. Questa operazione assicura che la funzione chiamante trovi i registri inalterati una volta terminata l’esecuzione della subroutine.

(13)

Il passaggio di parametri alle subroutine

Esistono diverse tecniche per il passaggio di parametri ad una subroutine:

•La soluzione più efficiente è prevedere l’utilizzo di uno o più registri per il passaggio diretto dei alla subroutines. In tal modo si evitano completamente accessi alla memoria. Il limite di tale tecnica è legato al ristretto numero di registri disponibili.

•Nel caso in cui i parametri da passare alla subroutine non possano essere memorizzati direttamente all’interno dei registri del PD32 è comunque possibile utilizzare i registri per indirizzare una o più aree di memoria nelle quali siano state preventivamente memorizzate i parametri da scambiare.

(14)

Le variabili nell’assembly

del PD32

(15)

Direttive di definizione variabili

Sintassi: label dl/dw/db n {,n_j}

Dichiara una variabile di nome label inizializzata al valore n.

Eventuali altri numeri specificati oltre il primo sono allocati

consecutivamente in memoria a partire dall’indirizzo associato a label. Tale indirizzo è scelto dall’assemblatore!

var1 DW 4

var1 è un place-holder per una word collocata in memoria in una locazione scelta dall’assemblatore ed inizializzata a 4.

var2 DL 4, 22h, 3

alloca 3 longwords inizializzate a 4, 22h e 3. var2 punta alla prima locazione

(16)

Esempi

org 400h

var1 DW 2 ; memorizzata in 400h

var2 DL 4, 22h, 3; memorizzata a partire da 402h code

movw var1,R0 ; R0=2

movl #var1,R1 ; R1=400h

movw R1,var1 ; scrive nella locazione 400h il valore 400h movl #0,r0

movl var2(R0), R1 ;r1=4h=00000004h;

movl #1,r0

movl var2(R0), R1 ;r1=22000000h movl #2,r0

movl var2(R0), R1; r1=00220000h movl #4,r0

movl var2(R0), R1; r1=22h=00000022h;

halt end