Wat is het O-bestandsformaat?
Een .o-bestand is een gecompileerd objectbestand - een binair tussenproduct geproduceerd door een compiler zoals GCC of Clang wanneer deze een enkel C-bronbestand vertaalt naar machinecode. De uitvoer bevat machine-instructies, geïnitialiseerde en niet-geïnitialiseerde datasegmenten, een symbooltabel en relocatie-items, maar het is nog niet uitvoerbaar: verwijzingen naar functies en variabelen die in andere vertaaleenheden zijn gedefinieerd, blijven achter als onopgeloste tijdelijke aanduidingen voor de linker.
Het binaire formaat hangt af van het doelplatform:
- Op Linux en de meeste Unix/BSD-systemen gebruiken
.o-bestanden de ELF (Executable and Linkable Format) container, herkenbaar aan de magic bytes\x7FELFop byte-offset 0 en eene_typevanET_REL(relocatable, waarde0x0001). - Op macOS gebruikt het equivalent het Mach-O formaat, beginnend met
CF FA ED FE(64-bit little-endian). - Op Windows wordt het functioneel identieke bestand benoemd met de .obj extensie en gebruikt het de COFF-indeling.
Na compilatie combineert de linker (ld) een of meer .o-bestanden met bibliotheken om een uitvoerbaar bestand of een shared library te produceren. Meerdere .o-bestanden kunnen ook worden gebundeld in een statisch archief met behulp van het ar-commando.
.o-bestanden zijn tijdelijke build-artefacten die automatisch door de toolchain worden gegenereerd en zijn niet bedoeld om door eindgebruikers te worden geopend. Ontwikkelaars die ze moeten inspecteren, kunnen nm, objdump of readelf gebruiken om symbolen, secties en disassembly te onderzoeken.
Beveiliging & veiligheid
RISICO: LOWEen .o-bestand bevat gegevens voor de bouwfase, niet iets dat het besturingssysteem start, dus het vormt weinig direct risico voor eindgebruikers - je kunt er niet op dubbelklikken om het uit te voeren. Voor ontwikkelaars is het vertrouwen in de toeleveringsketen van belang: het linken van een object uit een niet-vertrouwde bron bakt de machinecode rechtstreeks in je programma, dus bouw alleen met objecten/bibliotheken van bronnen die je vertrouwt. De objecten in je eigen build-tree kunnen veilig worden verwijderd; ze worden bij de volgende compilatie opnieuw gegenereerd.
Formaatdetails
in een notendopVOLLEDIGE NAAMCompiled Object Fileook bekend als object file, object code
ONTWIKKELAARUnix lineage; ELF defined by System V ABI / Tool Interface Standard, COFF/Mach-O by Microsoft/Apple. No single vendor.sinds Object-file concept from early Unix (1970s); ELF since System V Release 4 (early 1990s)
CATEGORIEOntwikkelaarsbestanden
MIME-TYPEapplication/x-object
TYPEGecompileerd verplaatsbaar objectbestand (machinecode + symbolen, nog niet gelinkt)
STANDAARDOpen · royaltyvrij
MAGIC BYTES · BESTANDSSIGNATUUR
OFFSET
00010203
HEX
7F454C46
ASCII
·ELF
De .o-extensie is een rol, geen enkel byte-formaat. Op Linux/Unix is een .o een ELF-object beginnend met 7F 45 4C 46 („\x7FELF”) met e_type = ET_REL (0x0001, relocatable). Op macOS is een .o Mach-O, beginnend met CF FA ED FE (64-bit LE) of FE ED FA CF (big-endian). Windows COFF .obj-objecten hebben geen vaste leidende magic (machineveld, bijv. 64 86 voor x86-64, nabij het begin). Identificeer op basis van de objectcontainer van het platform, niet op basis van één universele handtekening.
Programma's die O-bestanden openen
Windows2 apps
Microsoft Visual Studio
Freemium MSVC gebruikt COFF .obj, niet Unix .o. Een Unix .o bouwt alleen op Windows via WSL/MinGW met een bijbehorende toolchain - het is geen native opener. 
MinGW-w64 / WSL (gcc, binutils)
Open-source Biedt gcc/clang + binutils op Windows zodat je Unix-stijl .o-bestanden kunt linken en inspecteren. 
macOS2 apps
Apple Xcode / Clang
Gratis Xcode's clang bouwt en linkt Mach-O .o-bestanden. Inspecteer met 'nm'/'otool -tv file.o' (installeer via 'xcode-select --install').
GCC (Homebrew)
Open-source Alternatieve compiler om .o-bestanden te bouwen/linken; produceert Mach-O objecten op macOS. 
Linux3 apps
GCC / Clang (linker)
Open-source Je opent een .o niet - je linkt het: 'gcc a.o b.o -o app' produceert het uitvoerbare bestand. Compileer een enkel object met 'gcc -c file.c'.
binutils (nm / objdump / readelf)
Open-source 'nm file.o' geeft een lijst met symbolen; 'objdump -d file.o' disassembliert; 'readelf -a file.o' toont de volledige ELF-structuur.
Ghidra
Open-source Importeer de .o voor volledige disassembly/decompilatie bij het reverse-engineeren van gecompileerde code. Technische details
diepe specificaties| Containerformaat | ELF op Linux/Unix, Mach-O op macOS, COFF op Windows (waar het bestand meestal `.obj` wordt genoemd) |
| Bestandscodering | Binair (niet door mensen leesbare tekst) |
| ELF magic bytes | `7F 45 4C 46` (`\x7FELF`) op byte-offset 0 - aanwezig in alle op ELF gebaseerde objectbestanden |
| ELF objecttype-veld | `e_type = ET_REL` (0x0001) in de ELF-header - onderscheidt een verplaatsbaar object van een uitvoerbaar bestand (`ET_EXEC`) of gedeelde bibliotheek (`ET_DYN`) |
| MIME-type | `application/x-object`; ook verzonden als `application/octet-stream` door generieke servers |
| Byte-volgorde | Gecodeerd in de `EI_DATA` byte van de ELF-header: little-endian (`ELFDATA2LSB`) op x86/x86-64/ARM, big-endian (`ELFDATA2MSB`) op PowerPC/SPARC |
| Belangrijke secties | `.text` (uitvoerbare code), `.data` (geïnitialiseerde globale variabelen), `.bss` (op nul geïnitialiseerde globale variabelen), `.rodata` (read-only constanten) |
| Symbooltabel | De `.symtab`-sectie vermeldt de naam van elk gedefinieerd en gerefereerd symbool, de binding (lokaal/globaal/zwak), het type (functie/object) en de waarde |
| Relocatie-items | `.rel.text` / `.rela.text` secties registreren elk adres dat de linker moet patchen bij het samenvoegen van objectbestanden tot een definitief binair bestand |
| Architectuuridentificatie | Het `e_machine` veld in de ELF-header identificeert het CPU-doel: `EM_X86_64` (0x3E), `EM_AARCH64` (0xB7), `EM_386` (0x03), enz. |
| Typische bestandsgrootte | 1 KB tot enkele MB per vertaaleenheid, afhankelijk van de complexiteit van de broncode en het optimalisatieniveau van de compiler |
| Compressie | Geen - objectbestanden worden opgeslagen als ruwe, ongecomprimeerde binaire gegevens |
| Eén-op-één compilatiemodel | Er wordt precies één `.o`-bestand gegenereerd per bronvertaaleenheid (één per `.c` of `.cpp` bestand); de linker voegt deze later samen |
| Statische bibliotheekverpakking | Meerdere `.o`-bestanden worden gearchiveerd in een `.a` statische bibliotheek met behulp van `ar`, waarbij elk object als een benoemd lid behouden blijft |
| Alleen resolutie tijdens link-tijd | In tegenstelling tot `.so` / `.dylib` gedeelde bibliotheken, worden alle symboolverwijzingen in een `.o` volledig opgelost tijdens het linken, waardoor er geen runtime dynamische afhankelijkheden overblijven |
| Inspectietools | `nm` (lijst symbolen), `objdump` (disassembly en sectiedumps), `readelf` (ELF-header en sectiedetails), `otool` (macOS Mach-O equivalent) |
| Uitgebracht | Object-file concept from early Unix (1970s); ELF since System V Release 4 (early 1990s) |
| Laatste versie | ELF format frozen since the 1990s; container evolves with each compiler/ABI |
| Open standaard | Ja · royaltyvrij |
| Specificatie | refspecs.linuxfoundation.org |
O conversies
Mogelijk
.O .EXEGIDS
Ja - koppel uw .o-bestanden met GCC of Clang met één enkele opdracht: gcc *.o -o app
Hoe te converteren
.O .AGIDS
Ja, u kunt .o-bestanden bundelen in een .a statische bibliotheek met één ar-opdracht - er vindt geen binaire…
Hoe te converteren
.O .SOGIDS
U kunt een .so produceren van .o-bestanden door te linken met GCC of Clang, maar alleen als de objecten zijn…
Hoe te converteren
Niet mogelijk
Community V&A
gevraagd door gebruikersNog geen vragen - wees de eerste om iets te vragen over O-bestanden.
Veelgestelde vragen
Wat is een .o-bestand?
Een gecompileerd objectbestand - de machinecode-output die een compiler produceert voor één bronbestand vóór het linken. De linker combineert verschillende .o-bestanden (plus bibliotheken) tot een voltooid uitvoerbaar bestand of bibliotheek. Op Windows wordt voor dezelfde rol de .obj-extensie gebruikt.
Hoe open ik een .o-bestand?
Je opent het niet zoals een document - het wordt door de linker verwerkt tijdens een build. Om het te inspecteren, voer je 'nm file.o' (symbolen), 'objdump -d file.o' (disassembly) of 'readelf -a file.o' (ELF-details) uit op Linux/macOS.
Kan ik .o-bestanden verwijderen?
Ja - objectbestanden zijn tussenproducten van het bouwproces. Ze verwijderen (of 'make clean' uitvoeren) betekent alleen dat de compiler ze bij de volgende build opnieuw genereert. Verwijder ze niet halverwege een build.
Wat is het verschil tussen .o, .a en .so?
Een .o is een enkel gecompileerd object. Een .a is een statische bibliotheek - een archief van .o-bestanden die tijdens het linken in je programma worden gekopieerd. Een .so is een gedeelde bibliotheek die tijdens runtime wordt geladen. Alle drie zijn gebouwd op basis van dezelfde objecten.
Is een .o hetzelfde als een Windows .obj?
Dezelfde rol (een gecompileerd object), maar een andere container: Unix .o is ELF/Mach-O, Windows .obj is COFF. Ze zijn niet uitwisselbaar - hercompileer de broncode voor het doelplatform.
Waarom krijg ik 'undefined reference' bij het linken van mijn .o-bestanden?
Een symbool (functie/variabele) dat je object gebruikt, is niet gedefinieerd in een .o of bibliotheek die je linkt. Voeg het ontbrekende object/bibliotheek toe aan het link-commando, of definieer het symbool. 'multiple definition' is het tegenovergestelde - hetzelfde symbool in twee objecten.
Referenties
1GNU Binutils - nm/objdump/readelf documentationwww.gnu.org
2Wikipedia - Object fileen.wikipedia.org
