Fact-checked by Grok 2 weeks ago

Object file

An object file is a binary file produced by a compiler or assembler during the compilation process, containing machine-readable object code, initialized and uninitialized data, symbol information, and relocation directives that enable the linker to combine multiple such files into an executable program, shared library, or other loadable module. These files are relocatable, meaning their contents can be positioned at different memory addresses during linking, and they serve as an essential intermediate step in modular software development, allowing source code modules to be compiled independently before final assembly.^[1]^[2]^[3] The structure of an object file varies by platform but generally includes a header that specifies the file type, target architecture, and entry points; sections or segments that organize code, data, and metadata; and auxiliary tables for symbols, relocations, and debugging information. For instance, in the Executable and Linking Format (ELF), commonly used in Unix-like systems such as Linux, the file begins with an ELF header followed by section headers describing content units like .text (code) and .data, and the raw section data itself. Program headers for loadable segments are present in executable and shared object files. Similarly, Windows object files adhere to the Common Object File Format (COFF), featuring a COFF header with machine type and section count, followed by section headers and raw data including relocations for address adjustments during linking. On Apple platforms, the Mach-O format organizes content into segments such as __TEXT for read-only code and constants, and __DATA for modifiable variables, with sections within segments to fine-tune memory mapping and sharing.^[1]^[2]^[4] Object files play a critical role in the build process by preserving unresolved references to external symbols, which the linker resolves by matching them across files and libraries, thus supporting features like dynamic loading and code optimization. They also include attributes for security, such as executable permissions on code sections, and can embed resources or debug symbols to aid in development and troubleshooting without affecting runtime performance. The use of standardized formats ensures portability within compatible ecosystems, though cross-platform linking often requires format conversion tools.^[1]^[2]^[4]

Overview

Definition and Characteristics

An object file is a file containing object code, typically in the form of machine code or bytecode, along with metadata and ancillary data such as symbol tables and relocation information, generated by a compiler or assembler from source code during the compilation process.^[5]^[6] These files hold sections for instructions, data, and other elements suitable for subsequent processing.^[5] Key characteristics of object files include their relocatability, meaning they contain relocation information that allows the code and data to be positioned at any memory address by adjusting addresses during linking, facilitating combination with other files.^[5] They are not directly executable, as they contain unresolved references to external symbols and lack the complete structure needed for standalone execution.^[7] Object files also incorporate symbols for undefined references, enabling the linker to resolve dependencies, and support multiple processor architectures through standardized formats like ELF.^[5] In contrast to source code, which is human-readable and written in high-level languages for programmers, object files consist of low-level, machine-readable instructions that a CPU can process directly but require additional steps to become functional.^[8] Unlike fully linked executables, which are complete, runnable programs with resolved addresses and no external dependencies, object files serve as intermediate artifacts in the build pipeline.^[9]^[10] Common examples include the .o files produced by the GNU Compiler Collection (GCC) when invoked with the -c option, which compiles source code into relocatable object code without performing linking.^[7] Similarly, Microsoft's CL compiler generates object files that can be specified via the /Fo option for custom naming and directories.^[11]

Historical Development

The concept of an object file originated in the 1950s alongside the development of early high-level compilers, particularly FORTRAN at IBM. The term "object program" was used to describe the machine-language output generated by the compiler from source code, emphasizing efficiency in producing executable code for systems like the IBM 704. This marked a shift from manual assembly of machine code to automated translation, with FORTRAN's first implementation in 1957 setting a precedent for separating compilation from final loading.^[12] In the 1960s, object files evolved with the rise of more structured formats, exemplified by IBM's OS/360 Object File Format introduced for the System/360 mainframe architecture announced in 1964. Early object representations often relied on punch-card systems, where compiled code was stored as sequences of punched cards representing binary data, symbols, and relocation information for batch processing on machines like the IBM 7090. These formats supported absolute addressing but were limited by the physical constraints of cards and tapes, facilitating the linkage of modules in large-scale scientific and business applications.^[13]^[14] The 1970s brought significant advancements with the advent of Unix at Bell Labs, driving a transition from absolute to relocatable object files to support modular programming and dynamic memory allocation. The initial Unix versions, starting around 1971 on the PDP-11, used the simple a.out format for relocatable objects, allowing code sections to be positioned anywhere in memory during linking. A key milestone was the development of the ld linker in early Unix (First Edition, 1971), which automated the resolution of external references and relocation, enabling efficient assembly of multiple object files into executables. This shift was influenced by the demands of emerging multitasking operating systems, which required flexible segmentation to isolate processes and manage shared memory without fixed addresses.^[15]^[16] Subsequent standardization in the late 1970s and 1980s further refined object files for portability across architectures. The Common Object File Format (COFF), designed by AT&T around 1982 and adopted in Unix System V Release 3 (1986), introduced extensible sections for symbols, relocations, and debugging, replacing simpler formats like a.out in many systems. By the 1990s, the Executable and Linking Format (ELF), specified in the System V ABI (1990) and first implemented in Solaris 2.0 (1992), became the dominant standard, offering improved support for dynamic linking and shared libraries in Unix-like environments.^[17]^[18]

Purpose and Role

In the Compilation and Linking Process

In the software build pipeline, object files serve as an intermediate artifact generated during compilation from source code. A compiler translates high-level source code, such as C or C++, through stages including preprocessing, lexical analysis, parsing, code generation, and assembly into relocatable machine code stored in an object file, typically with extensions like .o or .obj. For example, the GNU Compiler Collection (GCC) produces such files when the -c flag is specified, halting the process after assembly to output one object file per source file without performing linking.^[19] Similarly, Clang from the LLVM project follows this approach, generating object files in formats like ELF for Unix-like systems or COFF for Windows. The linking phase follows compilation, where a linker tool combines multiple object files—along with static libraries—into a single executable program or shared library. The GNU linker (ld) reads these inputs, performs symbol resolution by matching external references (uses of functions or variables) in one object file to their definitions in another or in libraries, and allocates sections into a unified memory layout. Microsoft's LINK.EXE operates analogously for COFF object files, integrating modules to form .exe or .dll outputs while resolving inter-module dependencies.^[20] This step enables modular development, as separate compilation units can be built independently before final assembly. Central to linking is the relocation process, which resolves symbolic addresses in object files to their final runtime locations. Object files contain relocation records that mark instructions or data elements requiring address adjustments, such as jumps to external functions or global variables; the linker computes offsets based on the assigned memory positions and patches these sites accordingly.^[21] This ensures code portability across different load addresses, with static relocation occurring fully at link time for executables. Common tools in this workflow include compilers like GCC and Clang for object file generation, and linkers such as ld or LINK.EXE for integration, often invoked automatically by build systems like Make or CMake.^[22] Errors during linking, such as undefined symbols where a reference lacks a corresponding definition, prompt the linker to halt and report failures, ensuring incomplete programs are not produced. Relocation errors, including mismatched types or overflow in address calculations, are similarly flagged to prevent invalid executables.^[23]

Applications and Usage

Object files are integral to static linking, where the linker merges multiple relocatable object files along with static libraries to produce a standalone executable. This approach embeds all required code and data directly into the final binary, eliminating external dependencies at runtime and ensuring portability across systems without additional library installations.^[22]^[24] In dynamic linking, object files compiled as position-independent code serve as the foundation for shared object files (.so), which the operating system's dynamic linker loads into memory only when needed. This enables code sharing among multiple processes, reduces memory usage, and allows updates to libraries without recompiling applications.^[25]^[26] Object files act as the core components for constructing libraries, with static libraries (.a) formed by archiving groups of object files for inclusion in executables during linking. Dynamic libraries, built from object files generated with position-independent flags such as -fPIC, support runtime loading and promote modular software design.^[22] Cross-compilation leverages object files to target diverse architectures, such as generating ARM-compatible files from an x86-based host using specialized toolchains, facilitating development for embedded devices, mobile platforms, and heterogeneous computing environments.^[27] Modern build systems like Make and CMake utilize object files to enable incremental compilation, where only changed source files are recompiled into new object files before relinking, significantly accelerating development cycles for large-scale projects.^[28] In embedded systems, object files are essential for producing optimized firmware, as compilers generate architecture-specific files that link into minimal executables tailored for microcontrollers with limited resources.^[29] Within containerization workflows, such as Docker multi-stage builds, object files emerge as transient intermediates during compilation in builder stages, yielding final binaries or libraries copied to runtime images for efficient, portable deployment.^[30]

Internal Components

Headers and Metadata

Object file headers and metadata provide the foundational structure for interpreting the file's contents, serving as the initial point of access for tools like assemblers, linkers, and loaders. These elements encapsulate critical descriptors that identify the file's format, target environment, and organizational layout, ensuring compatibility and proper processing across diverse systems. By embedding this information at the file's outset, headers facilitate rapid validation and navigation, preventing misinterpretation of subsequent data sections. The core of an object file header typically includes magic numbers, which are unique byte sequences at the file's beginning used to identify the format. For instance, in the Executable and Linkable Format (ELF), the magic number consists of the bytes 0x7F followed by 'E', 'L', and 'F' in the e_ident array, confirming it as an ELF file.^[1] Version fields specify the format iteration, such as ELF's e_version set to 1 for the original specification, allowing tools to handle evolving standards.^[1] Architecture indicators denote the target processor, distinguishing between variants like 32-bit (e.g., EM_386 for x86) and 64-bit (e.g., EM_X86_64), as seen in ELF's e_machine field.^[1] An entry point address, if present, marks the virtual location for program execution startup, such as ELF's e_entry field, which is zero for non-executable object files.^[1] Additional metadata elements include timestamps recording file creation or modification time, offsets to key structures like the section header table (e.g., ELF's e_shoff), and derived file size information from header aggregates. Endianness specifications clarify byte ordering—little-endian (ELFDATA2LSB) or big-endian (ELFDATA2MSB) in ELF via e_ident[EI_DATA]—while ABI details, such as ELF's e_ident[EI_OSABI], outline operating system and application binary interface conventions to ensure interoperability. In the Common Object File Format (COFF), used for Windows object files, the file header includes a timestamp (TimeDateStamp) and machine type for architecture (e.g., 0x8664 for AMD64). The PE format for executables extends COFF with an optional header containing fields such as entry point (AddressOfEntryPoint) and image size (SizeOfImage).^[2] These header components collectively enable loaders and linkers to parse, validate, and process the object file efficiently. For example, ELF headers supply offsets like e_phoff for the program header table and e_shoff for sections, allowing sequential reading without scanning the entire file. In COFF-based formats, the 20-byte file header provides section counts, symbol table pointers, and flags for relocatability, guiding linking operations. This structured metadata ensures that disparate tools can reliably assemble relocatable code into executables or libraries, maintaining system integrity across architectures.^[1]^[2]

Code, Data, and Symbol Sections

Object files primarily consist of sections that store the program's executable code, data, and symbolic references, forming the core payload for linking and loading. These sections are organized to separate executable instructions from modifiable data and metadata, enabling efficient processing by linkers and loaders. The code, data, and symbol sections, along with the section table that catalogs them, provide the essential content while maintaining modularity for relocation and combination during the build process.^[1]^[2] The code section, conventionally named .text, contains the machine instructions generated by the compiler or assembler for the program's execution. This section holds the compiled binary code in a read-only format to prevent unintended modifications during runtime, and it is marked with attributes that allow execution and allocation in memory. For instance, in typical object file structures, the .text section's size is defined to encompass the exact byte length of the instructions, with alignment requirements ensuring proper memory addressing, often to boundaries like 4 or 8 bytes. Permissions restrict it to read and execute operations only, safeguarding the integrity of the program's logic.^[1]^[31]^[32] Data sections store the program's variables and constants, divided into initialized and uninitialized variants to optimize file size and runtime initialization. The initialized data section, often called .data, includes explicitly set values such as global variables with initial assignments, and it is designated as read-write to allow updates during program execution. This section occupies space in the file proportional to the total size of the initialized data, with alignment attributes ensuring compatibility with the target architecture's data access patterns. In contrast, the uninitialized data section, typically .bss, reserves space for variables that start with zero or undefined values; it does not consume file storage but specifies a size for zero-filling by the loader at runtime, also marked as read-write. Both data sections include permissions for memory allocation and writing, distinguishing them from the immutable code section.^[1]^[33]^[31] The symbol table serves as a catalog of identifiers used in the program, such as functions, global variables, and labels, each entry detailing the symbol's name, type (e.g., function or object), scope (local or external), and either a resolved address within the object file or a marker for external resolution during linking. This table facilitates the linker's ability to connect references across multiple object files, supporting both static and dynamic linking processes. Symbols are stored in a structured array where each entry includes binding information to indicate visibility and relocation needs, ensuring that undefined symbols trigger appropriate error handling or library resolution.^[1]^[34] The section table acts as a directory that enumerates all sections in the object file, providing metadata for each including its name, size, offset within the file, alignment constraints, and permission flags such as readable, writable, or executable. This table, typically an array of fixed-size entries, allows tools to navigate and manipulate the file's contents without parsing the entire structure. For example, size attributes specify the byte length allocated for each section, while alignment ensures sections start at optimal memory addresses to avoid performance penalties, and permissions define runtime access controls enforced by the operating system loader. The ELF header points to this table to enable quick access during processing.^[1]^[33]^[31]

Relocation and Debugging Information

Object files include relocation tables to facilitate the adjustment of addresses during linking and loading, allowing code and data references to be resolved relative to a base address without recompilation. These tables consist of entries that specify the offsets within sections where modifications are needed, along with the type of relocation to apply. For instance, in the Executable and Linkable Format (ELF), a relocation entry like R_386_PC32 indicates a 32-bit PC-relative relocation for the x86 architecture, where the linker adjusts the instruction to account for the difference between the reference and the program's counter at runtime.^[35] Each entry typically includes fields such as the offset to the location requiring adjustment, the index into the symbol table for the referenced entity, and the relocation type, enabling the linker to compute the final address by adding offsets, section alignments, or symbol values as needed.^[35] In multi-file scenarios, relocation tables support linking by referencing symbols defined in other object files, allowing the linker to patch references across modules during the creation of an executable or shared library. This process resolves external dependencies, such as function calls or global variables, by matching relocation entries to symbol definitions and applying the appropriate adjustments, which is essential for modular program development.^[35] The purpose of these tables extends to runtime loading, where dynamic linkers like ld.so use them to fix up addresses in position-independent code for shared libraries, ensuring correct execution regardless of the memory location assigned by the operating system.^[35] Debugging information in object files provides source-level mappings that enable developers to analyze program behavior using tools like GDB, without altering the compiled code. Common formats include DWARF, a standardized debugging data format that encodes details such as line numbers, local variables, function scopes, and type information in a compact, hierarchical structure stored in dedicated sections like .debug_info and .debug_line. In contrast, the older stabs format uses a simpler, symbol-table-based approach to record similar data, often embedded in string tables, though it is less efficient and has been largely superseded by DWARF in modern systems.^[36] These formats allow debuggers to correlate machine instructions with original source code, supporting features like breakpoints, stack traces, and variable inspection during execution or post-mortem analysis of core dumps.^[36] By including debugging information directly in object files, compilers enable seamless integration into the linking process, where it is preserved or stripped as needed, facilitating development workflows that prioritize runtime analysis over production efficiency.^[37] This auxiliary data ensures that tools can perform symbolic debugging across linked modules, mapping relocations and symbols back to high-level constructs for effective troubleshooting.^[36]

Types

Relocatable Object Files

Relocatable object files are intermediate binary files produced by compilers or assemblers that contain machine code and data suitable for linking with other such files to form an executable or shared object. These files feature unresolved memory addresses, allowing the linker to assign final locations during the linking process, thereby enabling the code and data to be placed at any position in the final program's memory space.^[38] Key features of relocatable object files include symbol tables that record external references to functions and variables defined in other modules, as well as relocation entries that mark locations in the code or data requiring address adjustments. Relocatable object files compiled for shared libraries may incorporate position-independent code (PIC), which avoids hard-coded absolute addresses to facilitate loading at arbitrary memory locations.^[38]^[39]^[40] Relocation tables within these files provide the necessary information for the linker to resolve these references, though detailed structures are handled during the linking phase.^[38]^[39] The primary advantages of relocatable object files lie in supporting modular compilation, where individual source modules can be compiled independently and later combined, accelerating development and build times for large projects by allowing recompilation of only modified components. This modularity also enhances maintenance, as changes to one module do not necessitate rebuilding the entire program, and facilitates the creation of reusable components like static and shared libraries that can be linked across multiple applications.^[39]^[41] However, relocatable object files have limitations, including the necessity of a linker to resolve symbols and perform address relocations, preventing direct execution without further processing. Additionally, they tend to be larger than final executables due to embedded metadata such as symbol tables, relocation information, and debugging data, which increases storage requirements during development.^[38]

Absolute Object Files

Absolute object files are files that contain machine code, data, and metadata with all addresses resolved to fixed, absolute memory locations, enabling direct loading into memory without requiring relocation or additional linking processes. These files are typically the final output of a linker in embedded or legacy toolchains, where all symbolic references have been replaced with concrete addresses based on a predefined memory map. Unlike relocatable formats, absolute object files omit relocation tables, which specify how addresses should be adjusted during loading, making them suitable for environments with static memory allocation.^[42] Historically, absolute object files played a key role in early computing systems with limited resources and fixed memory models. In MS-DOS, .COM files functioned as simple absolute executables, comprising raw binary code loaded at a predetermined offset of 0x0100 in memory, without headers, symbol tables, or relocation information to keep the format compact for 8086-based systems. Similarly, the S-record (SREC) format, introduced by Motorola in the 1970s for the MC6800 microprocessor, represents absolute object data in an ASCII-hexadecimal structure, where each record specifies data bytes along with their exact absolute addresses, facilitating programming of EPROMs and ROMs in embedded applications. The Intel Absolute Object Module Format (AOMF), a derivative of the 8051 Object Module Format (OMF), further exemplifies this era, structuring records such as content and debug data with absolute offsets and excluding relocation directives to produce a single, self-contained module.^[43]^[44]^[45] Key features of absolute object files include the absence of symbol tables for external references and relocation records, which reduces file size—often by eliminating overhead metadata—and simplifies loading but renders the code inflexible for reuse or modular assembly. This results in a streamlined structure, such as contiguous data blocks with segment identifiers set to zero and explicit offsets, ensuring all elements are positioned for immediate execution in a fixed address space. In modern niches, absolute object files remain relevant in resource-constrained embedded systems, particularly for bootloaders and firmware where memory is preallocated and non-relocatable, allowing direct conversion to formats like SREC for flashing microcontrollers without runtime address resolution. For instance, toolchains like those from Renesas generate absolute S-record outputs from linked binaries to represent firmware images at specific flash addresses.^[45]^[42]^[46]

Common Formats

Executable and Linkable Format (ELF)

The Executable and Linkable Format (ELF) is a standard object file format designed for executables, relocatable object code, shared libraries, and core dumps in Unix-like operating systems.^[5] It provides a flexible, extensible structure that supports multiple architectures and facilitates both static and dynamic linking processes.^[5] ELF files are particularly prevalent in environments requiring efficient loading and execution, such as Linux distributions, Solaris, Android, and embedded Linux systems.^[47]^[48]^[5] Developed by UNIX System Laboratories (USL) in the early 1990s as part of the System V Application Binary Interface (ABI), ELF was introduced with UNIX System V Release 4 to standardize binary formats across Unix variants.^[5] The format was later refined by the Tool Interface Standard (TIS) Committee, with Version 1.2 published in 1995, emphasizing portability for 32-bit Intel architectures while allowing extensions for broader use.^[5] The ELF specification continues to evolve; as of September 2025, a draft for version 4.3 is under public review.^[49] Its adoption extended rapidly due to its support for relocatable objects (for linking), executables (for direct execution), and shared objects (for dynamic libraries), making it a cornerstone for modern Unix-derived systems.^[5] In Android, ELF serves as the exclusive format for native binaries and libraries, enabling cross-compilation via the Native Development Kit (NDK).^[47] Similarly, embedded Linux platforms leverage ELF for its lightweight structure in resource-constrained environments.^[5] The core structure of an ELF file begins with the ELF header, a fixed-size structure at offset zero that identifies the file type and provides metadata such as the architecture (e.g., machine type for x86 or ARM), object file class (32-bit or 64-bit), data encoding (endianness), version, and offsets to subsequent tables.^[5] Following the ELF header are the program header table (optional for executables and shared objects) and the section header table, which describe loadable segments and individual sections, respectively.^[5] Program headers define memory segments for runtime loading, including types like PT_LOAD for code and data segments and PT_DYNAMIC for linker information.^[5] Section headers, in contrast, catalog granular components such as .text (executable code), .data (initialized data), .bss (uninitialized data), and specialized sections like .dynsym (dynamic symbol table) and .strtab (string table).^[5] A distinguishing feature of ELF is its versioning support, with ELF-32 for 32-bit systems using 32-bit addresses and ELF-64 for 64-bit systems accommodating larger address spaces and extended data types.^[5] Dynamic linking is enabled through the .dynamic section, which holds an array of tag-value pairs (e.g., DT_NEEDED for shared library dependencies, DT_PLTRelSZ for procedure linkage table size) that the runtime linker uses to resolve symbols at load time or lazily during execution.^[5] This setup supports position-independent executables (PIE) and shared objects (.so files), promoting modularity and reducing memory footprint in multi-process environments like those in Linux and Solaris.^[5]^[48]

Common Object File Format (COFF)

The Common Object File Format (COFF) is a binary file format originally developed by AT&T in the early 1980s for use in UNIX System V, particularly for non-VAX 32-bit platforms such as the 3B20 computer.^[50] It was designed to store object code, supporting both relocatable object files—which allow linking with other modules—and absolute object files for direct execution or loading.^[2] COFF provided improvements over earlier formats like a.out, including better support for debugging and portability across architectures.^[50] In the Microsoft Windows ecosystem, COFF forms the foundation for the Portable Executable (PE) format, adapted for Windows NT and subsequent operating systems to handle executables, object files, and dynamic-link libraries (DLLs).^[51] The structure of a COFF file begins with a 20-byte file header that specifies essential metadata, including the target machine type (e.g., 0x014c for Intel 386 or compatible processors), the number of sections, a timestamp, pointers to the symbol table and string table, the number of symbols, the size of the optional header, and characteristics flags indicating file properties such as whether it is executable or relocatable.^[51] Following the file header is an optional header, which is mandatory for PE images but can be absent in pure COFF object files; it includes fields like the image base address, entry point, and data directories for additional structures in executables.^[2] An array of section headers then describes each section (typically up to 96 sections), with each 40-byte header detailing the section name (e.g., .text for code or .data for initialized data), virtual and raw sizes, offsets, and characteristics like readability, writability, or executability.^[51] The actual section data follows, containing code, data, or other content. Relocation entries and line number entries are associated with sections to facilitate address fixes during linking and source-level debugging, respectively.^[2] A key component is the symbol table, an array of 18-byte entries located after the sections, each representing a symbol such as a function, variable, or file with fields for the name (via index into a trailing string table), value (e.g., offset within a section), section number, type (combining base type like integer and derived type like function), storage class (e.g., external or static), and the number of auxiliary entries.^[51] Auxiliary entries provide supplementary information, such as function lengths, section checksums, or weak external references, with up to 17 such entries per symbol in formats tailored to the symbol type.^[51] For relocations, COFF defines machine-specific types; for example, IMAGE_REL_I386_DIR32 (value 0x0006) specifies a 32-bit absolute virtual address relocation for x86 architectures, while IMAGE_REL_AMD64_ADDR64 (0x0001) handles 64-bit absolute addresses in x64.^[51] Line number tables map machine instructions to source line numbers, consisting of pairs with a type field (symbol table index or relative virtual address) and the line number, aiding debuggers in correlating binary code with source code.^[51] Over time, COFF was largely superseded by the Executable and Linkable Format (ELF) in Unix-like systems starting in the early 1990s, as ELF offered greater flexibility for dynamic loading and extensibility.^[52] However, Microsoft extended COFF into the PE/COFF specification for Win32 in the early 1990s and further adapted it for 64-bit Windows (PE32+), retaining core COFF elements while adding Windows-specific features like import/export tables and resource sections to support the operating system's loader and runtime environment.^[53] This evolution ensured compatibility with legacy tools while enabling modern Windows applications.^[2]

Mach-O

The Mach-O file format, short for Mach Object, serves as the native binary format for executables, relocatable object code, shared libraries, dynamically loaded modules, and core dumps in Apple's operating systems, including macOS and iOS. Originally developed by NeXT Computer in the late 1980s as part of the NeXTSTEP operating system, it succeeded the older a.out format and was designed to support the Mach microkernel's flexible addressing and dynamic linking needs. Following Apple's acquisition of NeXT in 1997, Mach-O became the foundation for OS X (now macOS) and subsequent platforms, evolving to accommodate architectures like PowerPC, x86, and ARM.^[54] At its core, a Mach-O file consists of a header, followed by load commands and the data they reference. The header includes a magic number to identify the file type (e.g., MH_MAGIC for 32-bit or MH_MAGIC_64 for 64-bit), the target CPU type (such as CPU_TYPE_X86_64 or CPU_TYPE_ARM64), the file type (e.g., MH_OBJECT for relocatable files, MH_EXECUTE for executables, or MH_DYLIB for dynamic libraries), the number of load commands, and their total size. Load commands then detail the file's structure, including segment mappings, symbol tables, and dynamic library dependencies; for instance, LC_SEGMENT_64 specifies a segment's virtual memory address, size, and permissions, while LC_LOAD_DYLIB lists required shared libraries. The file's content is organized into segments—logical groupings like __TEXT (read-only code and constants) and __DATA (writable variables)—each containing one or more sections, such as __text for machine code or __bss for uninitialized data. Segments align to page boundaries (typically 4 KB or 16 KB) for efficient memory mapping.^[55]^[4] Key features distinguish Mach-O from other formats, particularly in supporting Apple's multi-architecture environments. Universal binaries, or "fat" files, encapsulate multiple Mach-O binaries within a single container using a fat_header and array of fat_arch structures, each specifying an offset and length for a particular CPU subtype and byte order; this allows binaries to run on diverse hardware like Intel x86_64 and Apple Silicon ARM without separate distributions. Additionally, Mach-O employs a two-level namespace for symbol resolution, where undefined symbols are qualified by their originating library (e.g., via an ordinal index in the symbol table), reducing conflicts in dynamic linking and enabling features like prebinding for faster startup. These elements facilitate robust dynamic loading via dyld, Apple's dynamic linker/loader, which interprets load commands to bind libraries at runtime or launch.^[54]^[56]^[55] Mach-O's adoption remains central to the Apple ecosystem, powering all native applications, frameworks, and system components in macOS and iOS since their inception. Its design optimizes for security features like code signing and address space layout randomization, while dyld handles just-in-time symbol resolution and library caching to enhance performance across devices. As of 2025, it continues to evolve with support for modern extensions, ensuring compatibility in hybrid Intel-ARM transitions.^[4]^[55]

References

[1]
Chapter 7 Object File Format (Linker and Libraries Guide)
Object files represent some control data with a machine-independent format. making it possible to identify object files and interpret their contents in a common ...
[2]
PE Format - Win32 apps - Microsoft Learn
Jul 14, 2025 · This document specifies the structure of executable (image) files and object files under the Microsoft Windows family of operating systems.
[3]
Source Code and Object Code - UW Research
The object code file contains a sequence of machine-readable instructions that is processed by the CPU in a computer. Operating system or application software ...<|control11|><|separator|>
[4]
Overview of the Mach-O Executable Format - Apple Developer
Mar 10, 2014 · Mach-O is the native executable format of binaries in OS X and is the preferred format for shipping code. An executable format determines the ...
[5]
None
Summary of each segment:
[6]
[PDF] The Compiler and Toolchain
The output of the assembler is object files. An object file contains: Machine code. Data. Metadata about the structure of the code and data. © ...
[7]
Invoking GCC (Using the GNU Compiler Collection (GCC))
### Summary: Object Files and GCC .o File Production
[8]
What happens when you compile?
An object file is not an executable: it may require definitions from other files, including libraries. The assembler can be run separately with the as command.
[9]
Lecture 7, Object Codes, Loaders and Linkers - University of Iowa
On a Unix system, the command cc a.c does not just compile the file named a.c into the default object file a.out; rather, it compiles a.c into an object file ...
[10]
Linking and Shared Libraries - Cornell: Computer Science
Executable files (at least on Unix-based systems) are structured like object files, except with a different header to indicate that they are executable.
[11]
/Fo (Object file name) | Microsoft Learn
Jan 30, 2024 · By default, the object files generated by the compiler are placed in the current directory. They're given the base name of the source file and a ...
[12]
The history of Fortran I, II, and III - ACM Digital Library
To this day I believe that our emphasis on object program efficiency rather than on lan- guage design was basically correct. I believe that had we failed to ...
[13]
http://bitsavers.org/pdf/ibm/360/os/R01-08/C28-6535-0_OS360_Concepts_and_Facilities_1965.pdf
[14]
Which programming systems used object files on punch cards?
Jan 12, 2017 · Plenty of early computers in the 1950s normally used punched cards for both source and object code. Both assemblers for the IBM 704, NYAP1 and ...
[15]
[PDF] The Restoration of Early UNIX Artifacts - USENIX
The history of the development of UNIX has been well documented, and over the past decade or so, efforts have been made to find and conserve the software and ...
[16]
The Earliest Unix Code: An Anniversary Source Code Release - CHM
Oct 17, 2019 · The CHM Software History Center is delighted to make publicly accessible for the first time some of the earliest source code produced in the Unix story.
[17]
Exploring object file formats - MaskRay
Jan 14, 2024 · History of object file formats. Before delving into the technical side, I will share some notes about my archaeological journey. a.out. The a ...
[18]
The ELF Object File Format: Introduction - Linux Journal
Apr 1, 1995 · The ELF Object File Format: Introduction. Software. by Eric Youngdale. on April 1, 1995. Now that we are on the verge of a public release of ELF ...Missing: date | Show results with:date
[19]
Overall Options (Using the GNU Compiler Collection (GCC))
The ultimate output is in the form of an object file for each source file. By default, the object file name for a source file is made by replacing the suffix ' ...
[20]
MSVC linker reference | Microsoft Learn
The linker (link.exe) combines the object files into a single executable file. Linker options can be set inside or outside of Visual Studio.
[21]
Relocation (Linker and Libraries Guide)
Relocation is the process of connecting symbolic references with symbolic definitions. For example, when a program calls a function, the associated call ...
[22]
Link Options (Using the GNU Compiler Collection (GCC))
These options come into play when the compiler links object files into an executable output file. They are meaningless if the compiler is not doing a link step.
[23]
Options (LD) - Sourceware
The default behaviour is to report errors for any undefined symbols ... Normally the linker will generate an error message for each reported unresolved symbol ...
[24]
How static linking works on Linux - Opensource.com
Jun 3, 2022 · Learn how to combine multiple C object files into a single executable with static libraries.
[25]
Dynamic and static linking - IBM
Dynamic linking means that the code for some external routines is located and loaded when the program is first run.
[26]
Chapter 16. Using Libraries with GCC | Red Hat Enterprise Linux | 7
Static linking makes libraries part of the resulting executable file. Dynamic linking keeps these libraries as separate files. Dynamic and static linking can be ...Comparison Of Static And... · Linking A Program Against A... · Using An Rpath Value Stored...<|separator|>
[27]
Cross-Compilation (automake) - GNU.org
To cross-compile is to build on one platform a binary that will run on another platform. When speaking of cross-compilation, it is important to distinguish ...
[28]
cmake-buildsystem(7)
CMake generates build rules to compile the source files into object files and link them into an executable. Link dependencies of executables may be specified ...
[29]
Compiling, Linking, and Locating | Barr Group
The three steps are: first, compile source files into object files; second, link object files into a relocatable program; and third, assign memory addresses to ...The Build Process · Compiling · Linking
[30]
Multi-stage builds - Docker Docs
Multi-stage builds use multiple FROM statements in a Dockerfile, creating stages, and copy artifacts from one stage to another, resulting in a smaller final ...Use Multi-Stage Builds · Name Your Build Stages · Stop At A Specific Build...
[31]
[PDF] Common Object File Format (COFF - Texas Instruments
Apr 8, 2009 · COFF is an implementation of an object file format of the same name that was developed by AT&T for use on UNIX-based systems.
[32]
Object-File Sections - 2025.1 English - UG1400
This section of the object file contains executable program instructions. This section has the x (executable), r (read-only) and i (initialized) flags. This ...<|control11|><|separator|>
[33]
https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#section-table-section-headers
[34]
https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#coff-file-header-object-and-image
[35]
https://refspecs.linuxbase.org/elf/gabi4+/ch4.reloc.html
[36]
Relocation
### Summary of Relocation Tables in ELF Object Files
[37]
Debugging Information in Object Files and Executables
The DWARF format is significantly more compact than recording the same information in stabs format. However, because all the information is copied into the ...
[38]
Debugging Options (Using the GNU Compiler Collection (GCC))
Produce debugging information in the operating system's native format (stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging information. On most ...
[39]
Chapter 7 Object File Format (Linker and Libraries Guide)
A relocatable object file holds sections containing code and data. This file is suitable to be linked with other relocatable object files to create dynamic ...
[40]
[PDF] Linking - Computer Systems: A Programmer's Perspective
Object files come in three forms: • Relocatable object file. Contains binary code and data in a form that can be combined with other relocatable object files at ...
[41]
linking.html
Loaders have evolved in complexity, and the object file formats have evolved in parallel. We will look at several points in the evolution of loaders and object ...
[42]
C51: Where Is the Absolute OMF Object Module? - Arm Developer
The absolute object module (or absolute OMF file) is the output file created by the linker. This object module has NO relocatable entries.Missing: definition | Show results with:definition
[43]
COM - DOS Command File Format
The COM file format is a binary executable format used in Microsoft Windows or MS-DOS. Its structure consists of just a set of instructions.
[44]
[PDF] Reference Manual - SRecord 1.65 - SourceForge
srec aomf - Intel Absolute Object Module Format srec_intel16(5). 103 srec ... This format allows binary files to be uploaded and downloaded between two computer ...
[45]
srec_aomf - SRecord 1.65
The Absolute Object Module Format (AOMF) is a subset of the 8051 OMF. The structure of an absolute object file (the order of the records in it) is similar ...<|separator|>
[46]
https://www.renesas.com/us/en/document/apn/utility-convert-s-record-data-c-structure
[47]
Android ABIs - NDK
Feb 10, 2025 · The format of executable binaries, such as programs and shared libraries, and the types of content they support. Android always uses ELF.
[48]
ELF Header - Oracle Solaris 11.1 Linkers and Libraries Guide
The initial bytes mark the file as an object file. These bytes provide machine-independent data with which to decode and interpret the file's contents. ...
[49]
[PDF] Microsoft Portable Executable and Common Object File Format ...
This document specifies the structure of executable (image) files and object files under the. Microsoft Windows NT® operating system. These files are ...Missing: history | Show results with:history
[50]
https://www.ti.com/lit/pdf/spraao8
[51]
Inside Windows: Win32 Portable Executable File Format in Detail
OBJ files emitted by Microsoft compilers use the COFF format. You can get an idea of how old the COFF format is by looking at some of its fields, which use ...
[52]
[PDF] Mach-O Internals
Feb 10, 2016 · Mach-O Header Structure. There are four possible (single-architecture) magic numbers: ▷ MH_MAGIC = 0xfeedface - 32-bit, big-endian.Missing: e_magic | Show results with:e_magic
[53]
Mirror of OS X ABI Mach-O File Format Reference - GitHub
This document describes the structure of the Mach-O (Mach object) file format, which is the standard used to store programs and libraries on disk in the Mac ...Missing: e_magic cpu_type
[54]
[PDF] Mach-O Runtime Architecture
Aug 31, 2004 · The Mach-O file format provides both intermediate (during the build process) and final (after linking the final product) storage of machine ...