Memory layout dei programmi

Aree di memoria

L'esecuzione di un programma necessita di tre aree di memoria (che in UNIX sono chiamate regioni):

• Area di testo: contiene il testo del programma, cioè le istruzioni in linguaggio macchina. Non è modificabile dal programma stesso.

• Area dati: contiene le variabili globali (cioè quelle condivise da tutte le procedure) e le strutture dati dinamiche. Queste ultime si trovano in una parte di quest'area chiamata area heap, alla quale puntano quindi le variabili che fanno riferimento alle strutture dinamiche.

  L'area dati ha:

  • contenuto variabile (cambia quando si eseguono assegnamenti alle variabili)
  • dimensione variabile (per la presenza di strutture dati dinamiche)

• Area di stack: contiene i record di attivazione (frame) delle procedure già chiamate ma non ancora terminate. L'indirzzo della cima (top) dello stack, dove è situato il record di attivazione della procedura corrente, è contenuto nel registro di controllo SP (Stack Pointer). Ciascun record di attivazione contiene varie informazioni, tra cui:

  • i parametri attuali
  • le variabili locali
  • il return addres (RA), cioè l'indirizzo della prossima istruzione da eseguire al termine della procedura (ottenuto salvando il valore del PC al momento della chiamata)
  • un puntatore alla cima del record di attivazione della procedura chiamante.

  L'area di stack ha:

  • contenuto variabile (per gli assegnamenti alle variabili locali)
  • dimensione variabile (quando vengono chiamate o terminano le procedure)

Esempio: esecuzione di un programma in C

#include <stdio.h>

//Variabili globali -> area dati
int a = 5;
int b = 6;

int f2(int h){
	int k = h+15; //Variabile locale
	// (punto 3)
	return k;
}

int f1(int s, int t){
	int u = a + s + t; //Variabile locale
	// (punto 2)
	int v = f2(u); //Variabile locale
	// (punto 4)
	return v;
}

int main(void){
	int x = 10; //Variabile locale
	// (punto 1)
	int y = f1(x, b); //Variabile locale
	// (punto 5)
	printf("ecco il valore di y: %d\\n", y);
}

Per questo esempio, si assume che:

• gli indirizzi sono a 16 bit, e quindi rappresentabili con 4 cifre esadecimali
• nel programma compilato:
  • l'istruzione macchina di main che segue la chiamata a f1 si trova all'indirizzo A12E;
  • l'istruzione macchina di f1 che esegue la chiamata a f2 si trova all'indirizzo A39F.

1. In questo punto del codice, lo stack contiene solo il record di attivazione di main, con la variabile locale x inizializzata (al valore 10), mentre y non è ancora stata inizializzata (qui indicato con ??). Invece, le variabili globali a e b, memorizzate nell'area dati, sono state inizializzate ancora prima dell'esecuzione di main.
2. A questo punto, sopra al frame di main è stato aggiunto quello di f1, nel quale:
   • i valori dei parametri attuali (x e b) sono stati assegnati ai parametri formali s e t (copiandoli tali valori dal frame di main a quello di f1)
   • la variabile u è già stata inizializzata, mentre v non ancora
   • il valore del return address è l'indirizzo dell'istruzione macchina di main successiva alla chiamata di f1
   • il valore in cima al frame, e quindi alla pila, è l'indirizzo del valore in cima al record di attivazione di main
3. Con la chiamata di f2, è stato aggiunto un ulteriore record di attivazione in cima alla pila:
   • al parametro formale h è stato assegnato il valore del parametro attuale (u)
   • la variabile locale k è stata inizializzata
   • il RA è l'indirizzo dell'istruzione macchina di f1 successiva alla chiamata di f2
4. Quando f2 è terminata:
   • il valore di k è stato copiato in v (nel frame di f1)
   • il record di attivazione di f2 è stato rimosso logicamente dallo stack, assegnando al registro SP l'indirizzo in cima alla pila (che è l'indirizzo del frame di f1);
   • il return address è stato assegnato al PC, facendo riprendere l'esecuzione di f1 dal punto successivo alla chiamata appena terminata.
5. Essendo terminata anche f1, il suo record di attivazione viene rimosso dallo stack, lasciando solo quello di main, e il valore restituito è stato assegnato a y. L'esecuzione di main continuerà dall'istruzione macchina successiva alla chiamata di f1.

Indirizzi di memoria

Il codice di memoria contiene indirizzi di memoria, che si riferiscono: