# GNU Compiler Collection

GNU Compiler Collection o in breve GCC (in origine GNU C Compiler) è un compilatore ottimizzante multipiattaforma creato inizialmente dal fondatore della Free Software Foundation, Richard Matthew Stallman, come parte del Progetto GNU. Disponibile per vari linguaggi, architetture e sistemi operativi, GCC è distribuito in forma libera dalla Free Software Foundation tramite la licenza GPL. Le versioni recenti sono incluse nelle principali distribuzioni del sistema operativo GNU/Linux, e di molti altri sistemi, mentre su macOS non è installato di base, ma è parte del pacchetto Xcode, che dalla versione 5.0 comprende un altro compilatore, llvm, che sostituisce gcc.
Nato inizialmente come un compilatore per il linguaggio C, dispone oggi di vari frontend per altri linguaggi, tra cui Java, C++, Objective C, Fortran e Ada, e vari backend che sono in grado di generare linguaggi macchina per molte architetture, tra le quali x86, x86-64, ARM, IA-64, PowerPC, s390, SPARC.

## Storia

GCC è stato creato nel 1987 da Richard Stallman come parte del sistema GNU, che aveva bisogno di un compilatore che fosse software libero. Il suo sviluppo è stato seguito da vicino dalla Free Software Foundation.
Nel 1997 un gruppo di sviluppatori insoddisfatti dalla natura chiusa degli sviluppi e dal loro ritmo troppo lento ha creato il progetto EGCS (Experimental/Enhanced GNU Compiler System), che incorporava diversi fork sperimentali in una linea di sviluppo unica, separata da GCC. Lo sviluppo di EGCS si è dimostrato sufficientemente vitale e nell'aprile del 1999 EGCS è stato promosso al rango di versione ufficiale di GCC.
GCC viene oggi sviluppato da programmatori di ogni parte del mondo ed è stato portato su più tipi di processori e sistemi operativi di qualsiasi altro compilatore.
Oltre a essere il compilatore ufficiale del sistema GNU, incluse le varianti di GNU/Linux, GCC è stato adottato come compilatore principale per la creazione e lo sviluppo di diversi altri sistemi operativi, come i vari BSD, macOS, NeXTSTEP e BeOS e DOS tramite il suo porting DJGPP.

## Linguaggi

La versione standard del compilatore comprende i front end per i linguaggi:
* Ada (GCC per Ada, noto anche come GNAT)
* C
* C++ (GCC per C++ o G++)
* Fortran (GCC per Fortran o gfortran)
* Java (GCC per Java o GCJ)
* Objective-C
* Objective-C++
* Go (GCCGO)

## Architetture

Tra i processori supportati da GCC (alla versione 4.1) vi sono:
* Alpha
* ARM
* AVR e AVR32
* Blackfin
* H8/300
* System/370, System/390
* IA-32 (x86)
* EM64T, AMD64 (x64)
* IA-64 (Itanium)
* Motorola 68000
* Motorola 88000
* MIPS
* PA-RISC
* PDP-11
* PowerPC
* SuperH
* SPARC
* VAX
* le famiglie Renesas R8C/M16C/M32C
* la famiglia MorphoSys
In alcune release standard, sono stati supportati anche processori meno noti, tra cui A29K, ARC, Atmel AVR, C4x, CRIS, D30V, DSP16xx, FR-30, FR-V, Intel i960, IP2000, M32R, 68HC11, MCORE, MMIX, MN10200, MN10300, NS32K, ROMP, Stormy16, V850 ed Xtensa. Altri processori, come D10V, PDP-10, MicroBlaze e Z8000, sono stati supportati da versioni di GCC sviluppate separatamente rispetto versione della Free Software Foundation.

## SDCC (Small Device C Compiler)

L'SDCC (Small Devices C Compiler) è un porting open source per i microcontrollori delle sole famiglie Z80, 8051, 68HC11, Pic è stato separato dal progetto GCC per poter ottimizzare meglio il lavoro dei microcontrollori, dove serve una grande efficienza del compilatore e contemporaneamente vivere in un ambiente molto povero di risorse RAM e ROM, con interfacce personalizzate e dotato di registri speciali incompatibili con l'elaborazione.
Nonostante il piccolo numero di target disponibili, il compilatore è molto quotato e nella maggior parte delle situazioni dà risultati migliori dei sistemi di sviluppo professionali a pagamento.
È disponibile nei repo di Synaptic

## Utilizzo e funzionamento

GCC, in quanto compilatore, ha come scopo primario la traduzione di codice sorgente in codice macchina eseguibile.
Ad esempio, per compilare un file di codice sorgente scritto in C, si può eseguire gcc fornendogli in input il file desiderato. Esiste un grandissimo numero di parametri che è possibile passare al compilatore per gestire i vari aspetti e i vari dettagli del processo di generazione del codice; l'unico obbligatorio è il nome del file da compilare.
Un esempio elementare di compilazione è il comando
che ordina al compilatore di leggere il file main.c (.c è l'estensione standard dei file contenenti codice C) e compilarlo. Poiché non è stato specificato nessun nome per il file di output tramite il parametro -o, il file eseguibile viene chiamato a.out.
La compilazione avviene in tre fasi:
* il file da compilare viene trattato dal preprocessore, che analizza le direttive scritte per il compilatore (definite in alcune righe del codice, solitamente posizionate in testa al file e precedute dal carattere #). Se eseguito con il parametro -E, gcc esegue solo questo passo, fornendo in output il risultato delle attività del preprocessore;
* nella seconda fase, il file dà origine a un nuovo file oggetto, che non è ancora eseguibile;
* a questo punto entra in funzione il linker che produce un unico file eseguibile, contenente il tutto, unendo tra loro tutti i file oggetto e i file delle librerie. Se si desidera non incorporare il codice delle librerie nel file eseguibile, si può usare il collegamento dinamico.