| Sections and Relocation

Previous | The GNU Assembler | Next

Roughly, a section is a range of addresses, with no gaps; all data "in" those addresses is treated the same for some particular purpose. For example there may be a "read only" section.
The linker `ld` reads many object files (partial programs) and combines their contents to form a runnable program. When `as` emits an object file, the partial program is assumed to start at address 0. `ld` assigns the final addresses for the partial program, so that different partial programs do not overlap. This is actually an oversimplification, but it suffices to explain how `as` uses sections.
`ld` moves blocks of bytes of your program to their run-time addresses. These blocks slide to their run-time addresses as rigid units; their length does not change and neither does the order of bytes within them. Such a rigid unit is called a section. Assigning run-time addresses to sections is called relocation. It includes the task of adjusting mentions of object-file addresses so they refer to the proper run-time addresses.
An object file written by `as` has at least three sections, any of which may be empty. These are named text, data and bss sections.
`as` can also generate whatever other named sections you specify using the `.section` directive. If you do not use any directives that place output in the `.text` or `.data` sections, these sections still exist, but are empty. Within the object file, the text section starts at address `0`, the data section follows, and the bss section follows the data section.
To let `ld` know which data changes when the sections are relocated, and how to change that data, `as` also writes to the object file details of the relocation needed. To perform relocation `ld` must know, each time an address in the object file is mentioned:

- Where in the object file is the beginning of this reference to an address?
- How long (in bytes) is this reference?
- Which section does the address refer to? What is the numeric value of (address) - (start-address of section)?
- Is the reference to an address "Program-Counter relative"?

In fact, every address `as` ever uses is expressed as (section) + (offset into section)
Further, most expressions `as` computes have this section-relative nature. In this manual we use the notation {secname N} to mean "offset N into section secname."
Apart from text, data and bss sections you need to know about the absolute section. When `ld` mixes partial programs, addresses in the absolute section remain unchanged. For example, address `{absolute 0}` is "relocated" to run-time address 0 by `ld`. Although the linker never arranges two partial programs' data sections with overlapping addresses after linking, by definition their absolute sections must overlap. Address `{absolute 239}` in one part of a program is always the same address when the program is running as address `{absolute 239}` in any other part of the program.
The idea of sections is extended to the undefined section. Any address whose section is unknown at assembly time is by definition rendered {undefined U} - where U is filled in later. Since numbers are always defined, the only way to generate an undefined address is to mention an undefined symbol. A reference to a named common block would be such a symbol: its value is unknown at assembly time so it has section undefined.
By analogy the word section is used to describe groups of sections in the linked program. `ld` puts all partial programs' text sections in contiguous addresses in the linked program. It is customary to refer to the text section of a program, meaning all the addresses of all partial programs' text sections. Likewise for data and bss sections.
Some sections are manipulated by `ld`; others are invented for use of `as` and have no meaning except during assembly.

- Linker Sections
- Assembler Internal Sections
- Sub-Sections
- bss Section