Il processo di compilazione

Transcript

1 Il processo di compilazione Il processo che porta dal codice scritto in linguaggio C alla creazione del corrispondente file eseguibile può essere schematizzato in questo modo: 0. Scrittura del codice C 1. Analisi del codice da parte del Preprocessore e creazione del file che verrà analizzato dal compilatore 2. Il compilatore trasforma le istruzioni scritte in linguaggio C (codice ad alto livello) in istruzioni in linguaggio assembly (codice a basso livello) le quali poi, grazie all'assembler, vengono tradotte in linguaggio macchina. Il codice così prodotto è già nella forma tale da poter essere eseguito dal calcolatore ed esso viene indicato con il termine di codice oggetto. Tale codice, però, non rappresenta ancora il programma eseguibile. 3. L'ultimo passaggio, che permette di passare dal codice oggetto al codice eseguibile, richiede che vengano risolti eventuali riferimenti a funzioni esterne al codice (ad esempio, funzioni di libreria). Questo compito è affidato al linker che unisce al codice oggetto porzioni di codice oggetto presenti nelle librerie. Completato questo passaggio, si ottiene il file eseguibile. Fino ad ora tutti questi passaggi non sono stati "visibili", in quanto il programma gcc richiama autonomamente il preprocessore, il compilatore, l'assemblatore ed il linker senza che sia richiesto l'intervento dell'utente. Vediamo nel dettaglio come si svolgono e cosa producono i passaggi visti sopra. 0. Scrittura del codice. Supponiamo di aver preparato questo semplice programma e di averlo salvato nel file prog.c : /* inizio codice questo commento verrà rimosso da parte del preprocessore */ #include <stdio.h> #define VALORE 30 {int a = VALORE; printf("\n il valore della variabile e\' : %d",a); /* fine codice */

2 1. Passiamo ora alla fase successiva Preprocessore: il preprocessore rimuove eventuali commenti presenti nel testo ed interpreta le direttive ad esso rivolte. Dopo l'azione del preprocessore il file si presenta così:... qui c'è tutto il codice C contenuto in stdio.h... {int a = 30; printf("\n il valore della variabile e\' : %d",a); Per visualizzare questo risultato è sufficiente dare questo comando gcc -E programma.c -o prog_preprocessore.c Il significato dell'opzione -E è il seguente: il file va interpretato SOLO dal preprocessore. Una volta interpretato il file, il risultato dell'interpretazione, ovvero l'output prodotto dal preprocessore, va inserito nel file prog_preprocessore.c 2. Preparazione del codice oggetto. Per produrre il codice oggetto, il compilatore (e poi l'assemblatore) deve poter interpretare il contenuto del file prodotto dal preprocessore, ovvero il contenuto di prog_preprocessore.c Per ottenere questo risultato dobbiamo usare questo comando: gcc -c prog_preprocessore.c -o prog_oggetto.o Il suo significato è il seguente: gcc deve effettuare il solo passo di compilazione (a questo serve l'opzione -c) e, per compiere questo passo deve analizzare il contenuto del file prog_preprocessore.c, file che deve essere interpretato come output del preprocessore. Il risultato della sola compilazione, cioè l'output prodotto da questo comando, ovvero il codice oggetto, deve essere inserito nel file prog_oggetto.o Nota:

3 Per visualizzare anche la versione del codice in linguaggio assembly, è sufficiente bloccare il processo di compilazione al passo che precede quello in cui viene prodotto l'oggetto. gcc -S prog_preprocessore.c -o prog_assembler.s per creare poi l'oggetto si usa il comando gcc -c prog_assembler.s -o prog_oggetto.o Fino a questo punto, tutti i passaggi sono stati prodotti a partire dal codice iniziale (e dal contenuto dei file di intestazione in esso eventualmente inclusi). Il codice oggetto, quindi, contiene la versione in linguaggio macchina delle istruzioni contenute nel file prog.c; tale codice, però, non contiene informazioni relative al funzionamento di printf(), non essendo stata tale funzione implementata nè nel codice nè all'interno del file di intestazione stdio.h. Tali informazioni devono essere prese dai file di libreria, e questo è il compito del linker. 3. Preparazione del codice eseguibile. Per far entrare in azione il linker, è sufficiente far interpretare al programma gcc il codice oggetto prodotto al punto precedente. Questo risultato si ottiene scrivendo gcc prog_oggetto.o -o prog_eseguibile Il significato di tale comando è: analizza il file prog_oggetto.o (dalla sua estensione gcc capisce che si tratta di codice oggetto), se al suo interno ci sono richiami a funzioni esterne al codice vai nella libreria in cui è contenuto il codice oggetto di tali funzioni, allega al codice oggetto prodotto al punto precedente il codice oggetto relativo alle funzioni e produci il file eseguibile. L'output di tale processo va inserito in prog_eseguibile, che rappresenta finalmente il file che può essere mandato in esecuzione dal sistema operativo. Fino a questo momento la nostra attenzione è stata rivolta al punto 0, ovvero della scrittura del codice C, in quanto le librerie (ovvero gli archivi contenenti il codice oggetto relativo alle funzioni non implementate dall'utente che venivano di volta in volta inserite nel codice) erano già disponibili sul pc.

4 Proviamo ora a costruire una libreria! Ricetta: scrivere le funzioni di interesse e inserire in un archivio il corrispondente codice oggetto. Alla libreria dovrà essere poi allegato un file di intestazione. Facciamo un esempio semplice; il metodo potrà essere poi applicato alle funzioni contenute nel file mie_funzioni.h La struttura del file mie_funzioni.h è la seguente: #include <stdio.h> #include <string.h> int miafuzione(char*); eventuali direttive dichiarazioni int miafunzione(char* stringa) {int tmp=strlen(stringa); printf("\n la stringa è composta da %d caratteri",tmp); return tmp; } implementazioni Cosa serve per la preparazione del file di intestazione: i PROTOTIPI Cosa serve per la preparazione della libreria: le implementazioni Creiamo due file a partire da mie_funzioni.h File con le implementazioni e le eventuali direttive per il preprocessore user_functions.c #include <stdio.h> #include <string.h> int miafunzione(char* stringa) {int tmp=strlen(stringa); printf("\n la stringa è composta da %d File con le intestazioni user_functions.h /* visto che qui non compare l'implementazione, è buona norma scrivere un commento per descrivere il compito svolto dalla funzione */

5 caratteri",tmp); return tmp; } int miafuzione(char*); A questo punto è possibile produrre il codice oggetto a partire dal file user_functions.c gcc -c user_functions.c -o user_functions.o Tale codice oggetto va ora inserito in un archivio. Per compiere quest'operazione si utilizza il programma dedicato alla creazione degli archivi: ar ar -r libuser.a user_functions.o Ora la libreria è stata creata. (Nello scegliere il nome, il prefisso lib e l'estensione.a sono obbligatori) Cosa ce ne facciamo??? Prepariamo un codice C, prova.c, che richiami la funzione miafunzione() /* inizio codice */ #include <user_functions.h> {miafunzione("ciao ciao"); /* fine codice */ A questo punto, non posso compilare normalmente prova.c, in quanto l'implementazione della funzione non è presente nè in prova.c nè in user_functions.h. Devo quindi specificare che il codice oggetto relativo alla funzione si trova nella libreria libuser.a. Questo si indica così: gcc nome_file_da_compilare -Lnome_directory_libreria -lnome_lib -o nome_file_eseguibile dove

6 nome_file_da_compilare rappresenta il nome del file contenente le istruzioni in C nome_directory_libreria è il nome della directory in cui si trova il file di libreria nome_lib è il nome del file di libreria Questo comando nel nostro caso diventa: gcc prova.c -L./ -luser -o prova_eseguibile La cosa ricorda un po' la modalità di compilazione utilizzata quando nel codice erano presenti funzioni appartenenti alla libreria matematica; in quel caso non era stata usata l'opzione -L in quanto la libreria matematica si trova in una delle directory in cui il compilatore cerca automaticamente i file di libreria. Se preferite arrivare al medesimo risultato, ovvero riuscire a produrre l'eseguibile a partire dal file prova.c, e volete evitare la creazione di una libreria, è sufficiente dire al linker di unire il codice oggetto prodotto a partire da user_functions.c con quello prodotto a partire da prova.c gcc -c prova.c -o prova.o (con questa istruzione produco il codice oggetto di prova.c) gcc -c user_functions.c -o user_functions.o gcc prova.o user_functions.o -o prova_eseguibile Oltre a permetterci di creare un "pacchetto" che permette di raggruppare tutti i codici oggetto relativi alle varie funzioni implementate (oltre che a farci risparmiare il tempo richiesto per la compilazione dei file che servono per la creazione delle librerie, tempo che per programmi complessi può anche essere molto lungo), quali vantaggi possiamo

7 trarre dalla compilazione effettuata suddividendo il codice in più file? Torniamo al codice scritto ieri. Nel file, la gestione dell'area di memoria contenente la stringa inserita dall'utente veniva effettuata solo mediante delle chiamate ad opportune funzioni di gestione. Il programmatore, dall'interno di main(), era però comunque in grado di accedere all'area di memoria contenente tale stringa ed, eventualmente, in grado di modificarla. /* inizio codice */ #include <stdio.h> #include <stdlib.h> #include <string.h> char * CreaArray(int); void Cifratura(char *); char* Copia(char *); void OrdinaStringa(char*); void OrdinaParola(char*); void Visualizza(char *); void Inizializza(char *); /* implementazione di main() */ {char *parola, *ordinata1,*ordinata2; int i; parola = CreaArray(0); Inizializza(parola); /* visualizziamo la stringa */ Visualizza(parola); /* prima di continuare facciamo due copie della stringa */ ordinata1 = Copia(parola);

8 ordinata2 = Copia(parola); /* ora possiamo codificare la stringa originale */ Cifratura(parola); Visualizza(parola); /* ordiniamo la stringa ordinata1 */ OrdinaChar(ordinata1); Visualizza(ordinata1); /* ordiniamo le parole contenute nella stringa ordinata2 */ OrdinaParola(ordinata2); Visualizza(ordinata2); /* le implementazioni delle funzioni implementate ieri sono state omesse per brevità */ void Visualizza(char *stringa) {printf("\n ecco la stringa: %s",stringa);} void Inizializza(char *stringa) {printf("\n inserisci delle parole: "); gets(stringa); } /* fine codice */ Nell'ipotesi in cui si volessero evitare modifiche accidentali da parte del programmatore all'area di memoria considerata o si volesse impedire l'accesso diretto, da parte del programmatore, a tale area di memoria è necessario modificare la struttura del programma. Questa situazione ci si è presentata all'atto della gestione dell'area di memoria contenente il buffer di input: al programmatore è consentito accedervi solo attraverso le funzioni che prelevano caratteri, parole o stringhe dal buffer stesso, non direttamente. Passo 1: trasformiamo la variabile che ci interessa proteggere in una variabile globale Questo, da un lato, implica un aumento del campo di visibilità della variabile, dall'altro richiede che i prototipi e le implementazioni delle funzioni che permetteranno di accedere

9 a tale variabile vengano modificati. Ovvero, è necessario costruire un set di funzioni che diventeranno le funzioni di accesso (in lettura e scrittura) a tale variabile. Supponiamo che le funzioni con accesso privilegiato siano: CreaArray(), per l'allocazione di memoria Inizializza(), per assegnare un valore alla stringa Copia(), per salvare il valore della stringa all'interno di un'altra stringa Tali funzioni non necessitano di un parametro perché si assume implicitamente che esso sia il puntatore parola, accessibile alle funzioni in quanto si tratta di una variabile con un campo di visibilità esteso a tutto il codice /* inizio codice: passo 1 */ #include <stdio.h> #include <stdlib.h> #include <string.h> void CreaArray(int); char* Copia(void); void Inizializza(void); void Cifratura(char *); void Visualizza(char *); void OrdinaParola(char*); void OrdinaStringa(char*); char *parola; {char *ordinata1,*ordinata2; /* viene allocata memoria per la stringa */ CreaArray(0); /* la stringa viene inizializzata */ Inizializza(); ordinata1 = Copia(); ordinata2 = Copia(); OrdinaChar(ordinata1); Visualizza(ordinata1); OrdinaParola(ordinata2); Visualizza(ordinata2); /* qui di seguito vengono inserite solo le NUOVE implementazioni */

10 void CreaArray(int numero_caratteri) {char *parola = NULL; if(numero_caratteri == 0) { printf("\n di quanti caratteri vuoi sia composta la stringa? -> "); scanf("%d", & numero_caratteri); } else if(numero_caratteri < 0) {printf("\n Il valore del parametro non è corretto -> il programma termina "); exit(0);} parola = (char*) malloc((numero_caratteri+1) * sizeof(char)); if(parola == NULL) {printf("\n l'allocazione di memoria non e\' riuscita! -> il programma viene terminato "); exit(0);} } char * Copia(void) {char *nuova_stringa = (char*) malloc(sizeof(char)*(strlen(parola)+1); if(nuova_stringa==null) {printf("copia fallita - il programma termina"); exit(0);} strcpy(nuova_stringa,parola); return nuova_stringa; } void Inizializza(void) {printf("inserisci una stringa di testo"); gets(parola); } /* fine codice: passo 1 */ Importante: ora creiamo un file di intestazione ed uno con le implementazioni delle funzioni e, soprattutto, modifichiamo la classe di memorizzazione della variabile globale. La separazione del file in tre parti non porta a sostanziali modifiche rispetto alla situazione di partenza. Il cambiamento principale si ha solo grazie al cambio della classe di memorizzazione della variabile parola. 1. File di intestazione con i prototipi: intest.h /* inizio file di intestazione */ void CreaArray(int); char* Copia(void); void Inizializza(void);

11 void Cifratura(char *); void Visualizza(char *); void OrdinaParola(char*); void OrdinaStringa(char*); /* fine file di intestazione */ 2. File con le implementazioni e le direttive necessarie a tali implementazioni: impl.c /* inizio file con le implementazioni */ #include <stdio.h> #include <stdlib.h> #include <string.h> static char *parola; /* ora il campo di visibilità della variabile è esteso alle sole funzioni di impl.c. In assenza dello specificatore la variabile era visibile a tutto il codice (ovvero a tutti e tre i file). Grazie allo specificatore static ora essa è visibile SOLO alle funzioni implementate nei file appartenenti alla stessa unità di compilazione del file in cui è inserita la variabile. */ /* qui di seguito vengono inserite solo le NUOVE implementazioni */ void CreaArray(int numero_caratteri) {char *parola = NULL; if(numero_caratteri == 0) { printf("\n di quanti caratteri vuoi sia composta la stringa? -> "); scanf("%d", & numero_caratteri); } else if(numero_caratteri < 0) {printf("\n Il valore del parametro non è corretto -> il programma termina "); exit(0);} parola = (char*) malloc((numero_caratteri+1) * sizeof(char)); if(parola == NULL) {printf("\n l'allocazione di memoria non e\' riuscita! -> il programma viene terminato "); exit(0);} } char * Copia(void) {char *nuova_stringa = (char*) malloc(sizeof(char)*(strlen(parola)+1); if(nuova_stringa==null) {printf("copia fallita - il programma termina"); exit(0);} strcpy(nuova_stringa,parola); return nuova_stringa; } void Inizializza(void) {printf("inserisci una stringa di testo"); gets(parola); }

12 /* fine file con le implementazioni */ 3. File con main(): maincode.c /* inizio file con main()*/ #include <intest.h> {char *ordinata1,*ordinata2; /* viene allocata memoria per la stringa */ CreaArray(0); /* la stringa viene inizializzata */ Inizializza(); ordinata1 = Copia(); ordinata2 = Copia(); OrdinaChar(ordinata1); Visualizza(ordinata1); OrdinaParola(ordinata2); Visualizza(ordinata2); /* fine file con main() */ Ora posso compilare separatamente i vari moduli e poi unirli con il linker gcc -c maincode.c -o maincode.o gcc -c impl.c -o impl.o gcc impl.o maincode.o -o newprog Esercizio: trasformare il file mie_funzioni.h in una libreria vera e propria, composta da un file di intestazione e da un archivio con i codici oggetto alterare il codice di maincode.c ed inserire un'istruzione in cui viene modificata la

13 variabile parola: confrontare il caso in cui sia presenta lo specificatore static con quello in cui tale specificatore non sia presenta /* inizio file con main()*/ #include <intest.h> {char *ordinata1,*ordinata2; extern char* parola; /* questa istruzione produce un errore */ /* viene allocata memoria per la stringa */ CreaArray(0); /* la stringa viene inizializzata */ Inizializza(); parola=null; /* questa istruzione produce un errore */ ordinata1 = Copia(); ordinata2 = Copia(); OrdinaChar(ordinata1); Visualizza(ordinata1); OrdinaParola(ordinata2); Visualizza(ordinata2); /* fine file con main() */