Che cos'è il formato di file O?
Un file .o è un file oggetto compilato - un binario intermedio prodotto da un compilatore come GCC o Clang quando traduce un singolo file sorgente C in codice macchina. L'output contiene istruzioni macchina, segmenti di dati inizializzati e non inizializzati, una tabella dei simboli e voci di rilocazione, ma non è ancora eseguibile: i riferimenti a funzioni e variabili definite in altre unità di traduzione sono lasciati come segnaposto non risolti per il linker.
Il formato binario dipende dalla piattaforma di destinazione:
- Su Linux e sulla maggior parte dei sistemi Unix/BSD, i file
.outilizzano il contenitore ELF (Executable and Linkable Format), riconosciuto dai magic bytes\x7FELFall'offset 0 e une_typediET_REL(rilocabile, valore0x0001). - Su macOS, l'equivalente utilizza il formato Mach-O, che inizia con
CF FA ED FE(64-bit little-endian). - Su Windows, il file funzionalmente identico è denominato con l'estensione .obj e utilizza il formato COFF.
Dopo la compilazione, il linker (ld) combina uno o più file .o con le librerie per produrre un eseguibile o una libreria condivisa. Più file .o possono anche essere raggruppati in un archivio statico utilizzando il comando ar.
I file .o sono artefatti di build temporanei generati automaticamente dalla toolchain e non sono destinati ad essere aperti dagli utenti finali. Gli sviluppatori che hanno necessità di ispezionarli possono usare nm, objdump o readelf per esaminare simboli, sezioni e disassemblaggio.
Sicurezza e incolumità
RISCHIO: LOWUn .o è un dato del tempo di build, non qualcosa che il sistema operativo lancia, quindi presenta scarsi rischi diretti per gli utenti finali - non è possibile fare doppio clic ed eseguirlo. Per gli sviluppatori, la preoccupazione riguarda la fiducia nella catena di approvvigionamento: collegare un oggetto da una fonte non attendibile inserisce il suo codice macchina direttamente nel programma, quindi compila solo con oggetti/librerie provenienti da fonti fidate. Gli oggetti nel tuo albero di build sono sicuri da eliminare; si rigenerano alla compilazione successiva.
Dettagli del formato
in sintesiNOME COMPLETOCompiled Object Fileanche noto come object file, object code
SVILUPPATOREUnix lineage; ELF defined by System V ABI / Tool Interface Standard, COFF/Mach-O by Microsoft/Apple. No single vendor.dal Object-file concept from early Unix (1970s); ELF since System V Release 4 (early 1990s)
CATEGORIAFile di sviluppo
TIPO MIMEapplication/x-object
TIPOFile oggetto rilocabile compilato (codice macchina + simboli, non ancora collegato)
STANDARDAperto · royalty-free
MAGIC BYTES · FIRMA DEL FILE
OFFSET
00010203
HEX
7F454C46
ASCII
·ELF
L'estensione .o rappresenta un ruolo, non un singolo formato di byte. Su Linux/Unix un .o è un oggetto ELF che inizia con 7F 45 4C 46 («\x7FELF») con e_type = ET_REL (0x0001, rilocabile). Su macOS un .o è Mach-O, che inizia con CF FA ED FE (64-bit LE) o FE ED FA CF (big-endian). Gli oggetti COFF .obj di Windows non hanno un magic iniziale fisso (campo machine, es. 64 86 per x86-64, vicino all'inizio). Identificali tramite il contenitore oggetto della piattaforma, non tramite una firma universale.
Programmi che aprono file O
Windows2 apps
Microsoft Visual Studio
Freemium MSVC utilizza COFF .obj, non il .o di Unix. Un .o di Unix si compila su Windows solo tramite WSL/MinGW con una toolchain corrispondente - non è un'apertura nativa. 
MinGW-w64 / WSL (gcc, binutils)
Open-source Fornisce gcc/clang + binutils su Windows in modo da poter collegare e ispezionare file .o in stile Unix. 
macOS2 apps
Apple Xcode / Clang
Gratuito Il clang di Xcode compila e collega file .o Mach-O. Ispeziona con «nm»/«otool -tv file.o» (installa tramite «xcode-select --install»).
GCC (Homebrew)
Open-source Compilatore alternativo per compilare/collegare file .o; emette oggetti Mach-O su macOS. 
Linux3 apps
GCC / Clang (linker)
Open-source Non si apre un .o - si collega: «gcc a.o b.o -o app» produce l'eseguibile. Compila un singolo oggetto con «gcc -c file.c».
binutils (nm / objdump / readelf)
Open-source «nm file.o» elenca i simboli; «objdump -d file.o» disassembla; «readelf -a file.o» mostra l'intera struttura ELF.
Ghidra
Open-source Importa il .o per il disassemblaggio/decompilazione completa durante il reverse-engineering del codice compilato. Dettagli tecnici
specifiche approfondite| Formato contenitore | ELF su Linux/Unix, Mach-O su macOS, COFF su Windows (dove il file è tipicamente denominato `.obj`) |
| Codifica file | Binario (testo non leggibile dall'uomo) |
| Magic bytes ELF | `7F 45 4C 46` (`\x7FELF`) all'offset 0 - presente in tutti i file oggetto basati su ELF |
| Campo tipo oggetto ELF | `e_type = ET_REL` (0x0001) nell'intestazione ELF - distingue un oggetto rilocabile da un eseguibile (`ET_EXEC`) o da una libreria condivisa (`ET_DYN`) |
| Tipo MIME | `application/x-object`; trasportato anche come `application/octet-stream` dai server generici |
| Ordine dei byte | Codificato nel byte `EI_DATA` dell'intestazione ELF: little-endian (`ELFDATA2LSB`) su x86/x86-64/ARM, big-endian (`ELFDATA2MSB`) su PowerPC/SPARC |
| Sezioni chiave | `.text` (codice eseguibile), `.data` (globali inizializzati), `.bss` (globali inizializzati a zero), `.rodata` (costanti in sola lettura) |
| Tabella dei simboli | La sezione `.symtab` elenca il nome di ogni simbolo definito e referenziato, il binding (local/global/weak), il tipo (function/object) e il valore |
| Voci di rilocazione | Le sezioni `.rel.text` / `.rela.text` registrano ogni slot di indirizzo che il linker deve correggere quando unisce i file oggetto in un binario finale |
| Identificazione architettura | Il campo `e_machine` nell'intestazione ELF identifica la CPU di destinazione: `EM_X86_64` (0x3E), `EM_AARCH64` (0xB7), `EM_386` (0x03), ecc. |
| Dimensione tipica del file | Da 1 KB a diversi MB per unità di traduzione, a seconda della complessità del sorgente e del livello di ottimizzazione del compilatore |
| Compressione | Nessuna - i file oggetto sono memorizzati come dati binari grezzi non compressi |
| Modello di compilazione uno-a-uno | Viene emesso esattamente un file `.o` per ogni unità di traduzione sorgente (uno per ogni file `.c` o `.cpp`); il linker li unirà successivamente |
| Packaging in libreria statica | Più file `.o` vengono archiviati in una libreria statica `.a` usando `ar`, che preserva ogni oggetto come membro denominato |
| Risoluzione solo al link-time | A differenza delle librerie condivise `.so` / `.dylib`, tutti i riferimenti ai simboli in un `.o` vengono risolti interamente al momento del collegamento, senza lasciare dipendenze dinamiche al runtime |
| Strumenti di ispezione | `nm` (elenco simboli), `objdump` (disassemblaggio e dump delle sezioni), `readelf` (intestazione ELF e dettagli sezioni), `otool` (equivalente Mach-O per macOS) |
| Rilasciato | Object-file concept from early Unix (1970s); ELF since System V Release 4 (early 1990s) |
| Ultima versione | ELF format frozen since the 1990s; container evolves with each compiler/ABI |
| Standard aperto | Sì · royalty-free |
| Specifica | refspecs.linuxfoundation.org |
Conversioni O
Possibile
.O .EXEGUIDA
Sì - collega i tuoi file .o con GCC o Clang usando un singolo comando: gcc *.o -o app
Come convertire
.O .AGUIDA
Sì, puoi raggruppare i file .o in una libreria statica .a con un comando ar - non avviene alcuna…
Come convertire
.O .SOGUIDA
Puoi produrre un .so da file .o collegandoli con GCC o Clang, ma solo se gli oggetti sono stati compilati con…
Come convertire
Non possibile
Domande e risposte della community
chiesto dagli utentiAncora nessuna domanda - sii il primo a chiedere informazioni sui file O.
Domande frequenti
Cos'è un file .o?
Un file oggetto compilato - l'output in codice macchina che un compilatore produce per un file sorgente prima del linking. Il linker combina diversi file .o (più le librerie) in un eseguibile o una libreria finiti. Su Windows lo stesso ruolo utilizza l'estensione .obj.
Come apro un file .o?
Non si apre come un documento - viene consumato dal linker durante la build. Per ispezionarlo, esegui «nm file.o» (simboli), «objdump -d file.o» (disassemblaggio) o «readelf -a file.o» (dettagli ELF) su Linux/macOS.
Posso eliminare i file .o?
Sì - i file oggetto sono artefatti di build intermedi. Eliminarli (o eseguire «make clean») significa semplicemente che il compilatore li rigenererà alla build successiva. Non eliminarli a metà build.
Qual è la differenza tra .o, .a e .so?
Un .o è un singolo oggetto compilato. Un .a è una libreria statica - un archivio di file .o copiati nel programma al momento del link. Un .so è una libreria condivisa caricata al runtime. Tutti e tre sono costruiti a partire dagli stessi oggetti.
Un file .o è uguale a un .obj di Windows?
Stesso ruolo (un oggetto compilato), contenitore diverso: il .o di Unix è ELF/Mach-O, il .obj di Windows è COFF. Non sono intercambiabili - ricompila il sorgente per la piattaforma di destinazione.
Perché ricevo «undefined reference» collegando i miei file .o?
Un simbolo (funzione/variabile) usato dal tuo oggetto non è definito in nessun .o o libreria che stai collegando. Aggiungi l'oggetto/libreria mancante al comando di link, o definisci il simbolo. «multiple definition» è l'opposto - lo stesso simbolo presente in due oggetti.
Riferimenti
1GNU Binutils - nm/objdump/readelf documentationwww.gnu.org
2Wikipedia - Object fileen.wikipedia.org
