Hand-Held Devices and Embedded Systems Course

Student: Toms Snchez Lpez

Student ID: 20042116

Outline
What is ELF
Basics Executables

Linking View
Execution View Example Loading and Executing and ELF executable Various Conclusions

What is ELF?
Stands for Executable and Linking Format
Standarized executable file format used in most Unix sytems Subsitute of traditional a.out due to efficiency issues (i.e dynamic linking) Developed originally in Unix Systems Laboratory (USL) and adopted by The Tool Interface Standard (TIS) committe.

Basics
Three main types of ELF object files
Relocatable files: code and data to be linked with other object files Executable files Shared object files: Libraries

Object file: binary representation of programs intended to execute directly on a processor

Executables
Static vs Dynamic Executables Static: Self contained. Too large files due to static inclussion of library code Dynamic: Using external code or data at run time. More convinient Two views of executables according to their participation: Linking view: Executable participation in program linking Execution view: Executable participation in program execution

Executables

Link View: Used at static linking time for relocatable file combination
Execution View: Used at run time to load and execute programs

Executables
Elf Header describes the files organization and resides always at the beginning Program Header Table, if present, tells the system how to create a process image

Section Header Table, if present, contains information describing the filess sections
Relocatable files have section headers tables. Executable files have program headers tables. Shared object files have both.

Linking View
Divides the object files into a collection of sections

Sections have :
Name and type Requested memory ocation at run time Permissions Each section contains a single type of information and can contain flags (writable data, memory space during execution or executable machine instructions)

Linking View
Important Sections:
.interp .text Path name of program interpreter (Dynamic linker) Code (executable instructions) of a program

.data
.bss .init

Initialized data
Uninitilized data Executable instruction for process initilization

.fini
.ptl .re.<x> .dynamic

Executalbe intructions for process termination

Holds the procedure linkage table Relocation information for section <x> Dynamic linking information

Execution View
Simpler view that divides the object file into segments Segments have: Simple type

Requested memory location

Permissions Size (in file and in memory) All loadable sections are packed into segments so that file mapping is easier

Execution View
Segment Types:
LOAD INTERP Portion of file to be loaded into memory Pointer to dynamic linker for this executable (.interp section)

DYNAMIC

Pointer to dynamic linking information (.dynamic section)

Example
int x = 5; int main() { int r = x +funtion (); exit (0); }

Relocatable file 1

Relocatable file 2

int v = 10; int u = 32; int z; int function() { return v+u; }

Example
Relocatable Object files

Headers System code main () a ()

.text

System Code System Data

main () int x = 5
funtion () int v = 10 int u = 32

System Code
System Data int x = 5 int v = 10 int u = 32
Uninitialized data

.data

.bss

int y

others

Loading and Executing and ELF Executable

1. Open the file

2. Map LOAD segments into memory

3. Call the dynamic linker specified in the INTERP segment, passing information about the executable
1. 2. 3. 4. Handles all the dynamic/shared library needs of the executable Retrieves information from the DYNAMIC segment Loads all required libraries into memory Modifies executable so it can access needed resources in the libraries

Load and Executing and ELF Executable

Basically:
Relocatable File 1 Static Linking Executable Object File Shared Libraries Relocatable File N

Dynamic Linker

Executing

Various
Shared Libraries
Need to be compiled memory position independent (PIC) Uses a Global Offset table (GOT) with pointers to variables created at compile and linking time Uses the Procedure Linkage Table (PLT) for procedure library calling Implies some performance disadvantages

Various
Others
Relocations tell dynamic linker to rewrite parts of the excutable to refer to external resources

Exists a dynamic debugging structure offering information about process memory layout and binaries loaded

Conclusions
Logical evolution of old executable formats

Convinient double view depending for linking and executing time

Great support for dynamic linking, crosscompilation and others Convinient separation between file types depending on its function Standard and defined functionality for nowadays executable file needs in diferent platforms

References
For an exhaustive review of ELF specification please refer to: Executable and Linkable Format (ELF)
Tool Interface Standards (TIS), Portable Formats Specification, Version 1.1