Executable and Linkable Format

From Wikipedia, the free encyclopedia
Jump to: navigation, search
Filename extension none, .axf, .bin, .elf, .o, .prx, .puff and .so
Magic number 0x7F 'E' 'L' 'F'
Developed by Unix System Laboratories[1]:3
Type of format Binary, executable, object, shared libraries, core dump
Container for Many executable binary formats
An ELF file has two views: the program header shows the segments used at run-time, whereas the section header lists the set of sections of the binary.

In computing, the Executable and Linkable Format (ELF, formerly called Extensible Linking Format) is a common standard file format for executables, object code, shared libraries, and core dumps. First published in the System V Release 4 (SVR4) Application Binary Interface (ABI) specification,[2] and later in the Tool Interface Standard,[1] it was quickly accepted among different vendors of Unix systems. In 1999 it was chosen as the standard binary file format for Unix and Unix-like systems on x86 by the 86open project.

ELF is flexible and extensible by design, and it is not bound to any particular processor or architecture. This has allowed it to be adopted by many different operating systems on many different platforms.

File layout[edit]

Each ELF file is made up of one ELF header, followed by file data. The file data can include:

  • Program header table, describing zero or more segments
  • Section header table, describing zero or more sections
  • Data referred to by entries in the program header table or section header table

The segments contain information that is necessary for runtime execution of the file, while sections contain important data for linking and relocation. Any byte in the entire file can be owned by at most one section, and there can be orphan bytes which are not owned by any section.

00000000 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 |.ELF............|

00000010 02 00 3e 00 01 00 00 00 c5 48 40 00 00 00 00 00 |..>......H@.....|

Example hexdump of ELF file header[3]

File header[edit]

The ELF header defines whether 32- or 64-bit addresses are to be used. The header itself contains three fields that are affected by this setting and offset other fields that follow them. The 64-bit header is 64 bytes long.

ELF header[4]
Offset Size (Bytes) Field Purpose
32-bit 64-bit 32-bit 64-bit
0x00 4 e_ident[EI_MAG0] through e_ident[EI_MAG3] 0x7F followed by ELF(45 4c 46) in ASCII; these four bytes constitute the magic number.
0x04 1 e_ident[EI_CLASS] This byte is set to either 1 or 2 to signify 32- or 64-bit format, respectively.
0x05 1 e_ident[EI_DATA] This byte is set to either 1 or 2 to signify little or big endianness, respectively. This affects interpretation of multi-byte fields starting with offset 0x10.
0x06 1 e_ident[EI_VERSION] Set to 1 for the original version of ELF.
0x07 1 e_ident[EI_OSABI] Identifies the target operating system ABI.
Value ABI
0x00 System V
0x01 HP-UX
0x02 NetBSD
0x03 Linux
0x06 Solaris
0x07 AIX
0x08 IRIX
0x09 FreeBSD
0x0C OpenBSD
0x0D OpenVMS

It is often set to 0 regardless of the target platform.

0x08 1 e_ident[EI_ABIVERSION] Further specifies the ABI version. Its interpretation depends on the target ABI. Linux kernel (after at least 2.6) has no definition of it.[5] In that case, offset and size of EI_PAD are 8.
0x09 7 e_ident[EI_PAD] currently unused
0x10 2 e_type 1, 2, 3, 4 specify whether the object is relocatable, executable, shared, or core, respectively.
0x12 2 e_machine Specifies target instruction set architecture. Some examples are:
Value ISA
0x00 No specific instruction set
0x02 SPARC
0x03 x86
0x08 MIPS
0x14 PowerPC
0x28 ARM
0x2A SuperH
0x32 IA-64
0x3E x86-64
0xB7 AArch64
0x14 4 e_version Set to 1 for the original version of ELF.
0x18 4 8 e_entry This is the memory address of the entry point from where the process starts executing. This field is either 32 or 64 bits long depending on the format defined earlier.
0x1C 0x20 4 8 e_phoff Points to the start of the program header table. It usually follows the file header immediately making the offset 0x40 for 64-bit ELF executables.
0x20 0x28 4 8 e_shoff Points to the start of the section header table.
0x24 0x30 4 e_flags Interpretation of this field depends on the target architecture.
0x28 0x34 2 e_ehsize Contains the size of this header, normally 64 bytes for 64-bit and 52 for 32-bit format.
0x2A 0x36 2 e_phentsize Contains the size of a program header table entry.
0x2C 0x38 2 e_phnum Contains the number of entries in the program header table.
0x2E 0x3A 2 e_shentsize Contains the size of a section header table entry.
0x30 0x3C 2 e_shnum Contains the number of entries in the section header table.
0x32 0x3E 2 e_shstrndx Contains index of the section header table entry that contains the section names.

Program Header[edit]

The program header table tells the system how to create a process image. It is found at file offset e_phoff, and consists of e_phnum entries, each with size e_phentsize. For 32-bit ELF, each entry is structured as:

Program header (32-bit)[6]
Offset Size (Bytes) Field Purpose
0x00 4 p_type Identifies the type of the segment.
Value Name
0x00000000 PT_NULL
0x00000001 PT_LOAD
0x00000002 PT_DYNAMIC
0x00000003 PT_INTERP
0x00000004 PT_NOTE
0x00000005 PT_SHLIB
0x00000006 PT_PHDR
0x60000000 PT_LOOS
0x70000000 PT_LOPROC

PT_LOOS to PT_HIOS (PT_LOPROC to PT_HIPROC) is an inclusive reserved ranges for operating system (processor) specific semantics.

0x04 4 p_offset Offset of the segment in the file image.
0x08 4 p_vaddr Virtual address of the segment in memory.
0x0C 4 p_paddr On systems where physical address is relevant, reserved for segment's physical address.
0x10 4 p_filesz Size in bytes of the segment in the file image. May be 0.
0x14 4 p_memsz Size in bytes of the segment in memory. May be 0.
0x18 4 p_flags Segment-dependent flags.
0x1C 4 p_align 0 and 1 specifies no alignment. Otherwise should be a positive, integral power of 2, with p_vaddr equating p_offset modulus p_align.

Section Header[edit]


  • readelf is a Unix binary utility that displays information about one or more ELF files. A free software implementation is provided by GNU Binutils.
  • elfutils provides alternative tools to GNU Binutils purely for Linux.[7]
  • elfdump is a command for viewing ELF information in an ELF file, available under Solaris and FreeBSD.
  • objdump provides a wide range of information about ELF files and other object formats. objdump uses the Binary File Descriptor library as a back-end to structure the ELF data.
  • The Unix file utility can display some information about ELF files, including the instruction set architecture for which the code in a relocatable, executable, or shared object file is intended, or on which an ELF core dump was produced.


The ELF format has replaced older executable formats in various environments. It has replaced a.out and COFF formats in Unix-like operating systems:

ELF has also seen some adoption in non-Unix operating systems, such as:

Some game consoles also use ELF:

Other operating systems running on PowerPC using ELF:

  • AmigaOS 4, the ELF executable has replaced the previous EHF (Extended Hunk Format) which was used on Amigas equipped with PPC processor expansion cards.
  • MorphOS
  • AROS

Some operating systems for mobile phones and mobile devices use ELF:

Some phones can run ELF files through the use of a patch that adds assembly code to the main firmware, which is a feature known as ELFPack in the underground modding culture. The ELF file format is also used with the Atmel AVR (8-bit), AVR32[12] and with Texas Instruments MSP430 microcontroller architectures. Some implementations of Open Firmware can also load ELF files, most notably Apple's implementation used in almost all PowerPC machines the company produced.


The Linux Standard Base (LSB) supplements some of the above specifications for architectures in which it is specified.[13] For example, that is the case for the System V ABI, AMD64 Supplement.[14][15]


86open was a project to form consensus on a common binary file format for Unix and Unix-like operating systems on the common PC compatible x86 architecture, in order to encourage software developers to port to the architecture.[16] The initial idea was to standardize on a small subset of Spec 1170, a predecessor of the Single UNIX Specification, and the GNU C Library (glibc) to enable unmodified binaries to run on the x86 UNIX-like operating systems. The project was originally designated "Spec 150".

The format eventually chosen was ELF, specifically the Linux implementation of ELF, after it had turned out to be a de facto standard supported by all involved vendors and operating systems.

The group started email discussions in 1997 and first met together at the Santa Cruz Operation offices on August 22, 1997.

The steering committee was Marc Ewing, Dion Johnson, Evan Leibovitch, Bruce Perens, Andrew Roach, Bryan Sparks and Linus Torvalds. Other people on the project were Keith Bostic, Chuck Cranor, Michael Davidson, Chris G. Demetriou, Ulrich Drepper, Don Dugger, Steve Ginzburg, Jon "maddog" Hall, Ron Holt, Jordan Hubbard, Dave Jensen, Kean Johnston, Andrew Josey, Robert Lipe, Bela Lubkin, Tim Marsland, Greg Page, Ronald Joe Record, Tim Ruckle, Joel Silverstein, Chia-pi Tien and Erik Troan. Operating systems and companies represented were BeOS, BSDI, FreeBSD, Intel, Linux, NetBSD, SCO and SunSoft, Inc..

The project progressed and in mid-1998, SCO began developing lxrun, an open-source compatibility layer capable of running Linux binaries on OpenServer, UnixWare, and Solaris. SCO announced official support of lxrun at LinuxWorld in March 1999. Sun Microsystems began officially supporting lxrun for Solaris in early 1999,[17] and has since moved to integrated support of the Linux binary format via Solaris Containers for Linux Applications.

With the BSDs having long supported Linux binaries (through a compatibility layer) and the main x86 Unix vendors having added support for the format, the project decided that Linux ELF was the format chosen by the industry and "declare[d] itself dissolved" on July 25, 1999.[18]

FatELF: Universal Binaries for Linux[edit]

FatELF is an ELF binary-format extension which adds Fat binary capabilities.[19] It is aimed for Linux and other Unix-like operating systems. Additionally to the CPU architecture abstraction (byte order, word size, CPU instruction set etc.), there is the potential advantage of software-platform abstraction e.g. binaries which support multiple kernel ABI versions.

A proof-of-concept Ubuntu 9.04 image (VM image of Ubuntu 9.04 with Fat Binary support) and development tools are available. As of 2014, support for FatELF is not integrated in the Linux kernel mainline.[20][21][22]

See also[edit]


  1. ^ a b Tool Interface Standard (TIS) Executable and Linking Format (ELF) Specification Version 1.2 (May 1995)
  2. ^ System V Application Binary Interface Edition 4.1 (1997-03-18)
  3. ^ http://pygments.org/docs/lexers/#lexers-for-hexadecimal-dumps
  4. ^ "ELF Header". Sco.com. July 2000. Retrieved 2014-02-07. 
  5. ^ "LXR linux/include/linux/elf.h". linux.no. Retrieved 27 April 2015. 
  6. ^ "Program Header". Sco.com. July 2000. Retrieved 2016-01-13. 
  7. ^ "elfutils". fedorahosted.org. Retrieved 27 April 2015. 
  8. ^ "MinixReleases - Minix Wiki". Wiki.minix3.org. Retrieved 2014-01-19. 
  9. ^ "GCCSDK - RISC OS". Riscos.info. 2012-04-22. Retrieved 2014-01-19. 
  10. ^ PlayStation Portable use encrypted & relocated ELF : PSP
  11. ^ Symbian OS executable file format
  12. ^ "Chapter 4: Object Files", System V Application Binary Interface, 2009-10-26, e_machine 
  13. ^ "LSB Referenced Specifications". linuxfoundation.org. Retrieved 27 April 2015. 
  14. ^ "Executable and Linking Format (ELF)". linuxfoundation.org. Retrieved 27 April 2015. 
  15. ^ "Introduction". linuxfoundation.org. Retrieved 27 April 2015. 
  16. ^ Leibovitch, Evan (1997-12-23). "86Open Frequently-Asked Questions". Archived from the original on 2007-03-11. Retrieved 2007-06-06. 
  17. ^ Record, Ronald (1998-05-21). "Bulletin on status of 86open at SCO". Retrieved 2008-05-06. 
  18. ^ Leibovitch, Evan (1999-07-25). "The86open Project - FINAL UPDATE". Archived from the original on 2007-02-27. Retrieved 2007-05-06. 
  19. ^ Gordon, Ryan. "fatelf-specification v1". icculus.org. Retrieved 2010-07-25. 
  20. ^ Gordon, Ryan. "FatELF: Turns out I liked the uncertainty better.". icculus.org. Retrieved 2010-07-13. 
  21. ^ Holwerda, Thom (2009-11-03). "Ryan Gordon Halts FatELF Project". osnews.com. Retrieved 2010-07-05. 
  22. ^ Brockmeier, Joe (June 23, 2010). "SELF: Anatomy of an (alleged) failure". Linux Weekly News. Retrieved 2011-02-06. 

Further reading[edit]

External links[edit]