What is Address Binding?
Learn what address binding is -- compile-time, load-time, execution-time -- with examples and OS interview questions answered.
Expected Interview Answer
Address binding is the process of mapping the logical addresses a program uses -- its symbols, variables, and instruction references -- onto actual memory addresses, and it can happen at compile time, load time, or execution time, with each stage trading off flexibility for performance.
Compile-time binding fixes absolute physical addresses directly into the generated code, which is fastest at runtime but requires recompilation if the program’s load location ever changes, so it is only viable when the physical address is known in advance and never varies (as in some tiny embedded systems). Load-time binding generates relocatable addresses at compile time and lets the loader fix them to actual physical addresses only when the program is loaded into memory, allowing the load address to differ between runs without recompilation, but still fixing it once loading is done. Execution-time (dynamic) binding, the approach used by virtually all modern general-purpose operating systems, keeps addresses as logical/virtual addresses throughout execution and defers the final translation to physical addresses until each individual memory reference, performed at runtime by hardware such as the MMU using the page table; this is what allows a process to be moved in physical memory (e.g., swapped out and back in at a different location) without ever needing its code changed, and it is a prerequisite for supporting virtual memory and demand paging at all.
- Explains why virtual memory requires execution-time address binding
- Clarifies the tradeoff: earlier binding is faster, later binding is more flexible
- Shows why a process can be relocated in RAM without recompilation
- Connects directly to how the MMU and page table perform runtime translation
AI Mentor Explanation
Address binding is like deciding when a stadium assigns a specific numbered seat to a ticket: compile-time binding is printing an exact seat number on the ticket at the print shop, so if that seat is ever unavailable the whole ticket batch must be reprinted. Load-time binding is printing a section letter on the ticket and only assigning the exact seat when the fan actually enters the gate that day, fixed once they walk in. Execution-time binding is giving the fan just a general-admission pass and having an usher (the MMU) direct them to whichever seat is free at that literal moment, even letting them be moved mid-match without ever reprinting the pass.
Step-by-Step Explanation
Step 1
Compile-time binding
The compiler embeds absolute physical addresses directly; any relocation requires recompilation.
Step 2
Load-time binding
The compiler emits relocatable addresses; the loader fixes them to physical addresses once, at load time.
Step 3
Execution-time binding
Addresses stay logical/virtual throughout execution; translation to physical addresses happens on every access, at runtime.
Step 4
Hardware resolves the final mapping
The MMU consults the page table on each reference, which is what lets a process be relocated in RAM without code changes.
What Interviewer Expects
- Naming all three binding stages: compile-time, load-time, execution-time
- Understanding the flexibility-vs-performance tradeoff across stages
- Connecting execution-time binding to the MMU/page table mechanism
- Explaining why virtual memory requires execution-time binding specifically
Common Mistakes
- Conflating address binding with address translation as though they are the same single step
- Assuming modern general-purpose OSes use load-time binding rather than execution-time
- Forgetting that compile-time binding requires recompilation on any relocation
- Not connecting execution-time binding to the ability to swap/relocate a process in RAM
Best Answer (HR Friendly)
“Address binding is about deciding at what point a program’s memory references get turned into real memory addresses -- it could happen when the program is compiled, when it is loaded into memory, or continuously while it runs. Modern operating systems bind addresses at runtime, on every single memory access, which is exactly what lets a program keep running correctly even if the operating system decides to physically move it around in memory.”
Code Example
/* Compile-time binding: address is fixed forever in the generated code */
#define FIXED_ADDR 0x1000
int *compile_time_ptr = (int *) FIXED_ADDR;
/* Load-time binding: loader relocates once at load, then it is fixed */
struct reloc_entry { long symbol_offset; long *resolved_addr; };
void bind_at_load(struct reloc_entry *table, int n, long base) {
for (int i = 0; i < n; i++) {
table[i].resolved_addr = (long *)(base + table[i].symbol_offset);
}
}
/* Execution-time binding: every access is translated fresh via the MMU/page table */
long read_virtual(long virtual_addr, struct pte *page_table) {
long page_num = virtual_addr / PAGE_SIZE;
long offset = virtual_addr % PAGE_SIZE;
long frame = page_table[page_num].frame; /* resolved NOW, at access time */
return *(long *)(frame * PAGE_SIZE + offset);
}Follow-up Questions
- Why does virtual memory require execution-time address binding specifically?
- What tradeoff does load-time binding make compared to compile-time binding?
- How does the MMU perform execution-time address translation on every access?
- What would break if a process using compile-time binding were moved in physical memory?
MCQ Practice
1. Which address binding stage fixes physical addresses directly into the compiled code?
Compile-time binding embeds absolute addresses at compile time, requiring recompilation if the load location ever changes.
2. Which binding stage do modern general-purpose operating systems use to support virtual memory?
Execution-time binding keeps addresses logical throughout execution and translates them on every access via the MMU, which is what enables virtual memory and process relocation.
3. What capability does execution-time binding uniquely enable?
Because translation happens fresh on every access via the page table, a process's physical location can change (e.g., after being swapped) without any code modification.
Flash Cards
What are the three stages of address binding? — Compile-time, load-time, and execution-time (dynamic) binding.
Which binding stage does virtual memory require? — Execution-time binding, so translation can happen fresh on every memory access via the MMU.
What is the downside of compile-time binding? — Any relocation of the program requires full recompilation, since addresses are fixed in the code.
What fixes the address once, at load, under load-time binding? — The loader, which resolves relocatable addresses to physical addresses when the program is loaded.