Target Architecture Considerations
What you'll learn: How code generators must adapt their output to match the specific hardware capabilities and constraints of different target platforms.
Why Target Architecture Matters
When a compiler generates machine code, it can't produce a one-size-fits-all solution. Each processor family—x86, ARM, RISC-V, etc.—has its own personality, and the code generator must speak its language fluently.
Three Critical Hardware Constraints
Register Count
Different architectures offer different numbers of registers (fast storage locations inside the CPU). An x86-64 processor has 16 general-purpose registers, while older x86 had only 8, and some embedded processors might have even fewer. Your code generator must allocate variables and temporaries to these limited registers efficiently. Too many live values? You'll need to "spill" some to memory—a costly operation.
Instruction Sets
Each architecture supports different operations. One processor might have a native multiply instruction while another requires a software routine. Some have vector instructions for parallel operations; others don't. The code generator must translate your IR operations into whatever instructions actually exist on the target machine, sometimes requiring multiple native instructions for a single IR operation.
Addressing Modes
This refers to how instructions access memory. Can you add a constant offset to a register address? Can you use one register to index into an array held in another? x86 supports complex addressing like [base + index*4 + offset] in a single instruction, while RISC architectures typically require multiple simpler instructions. Understanding these modes lets the generator produce efficient memory access patterns.
Key Takeaway: Code generators must be architecture-aware, tailoring their output to each platform's register availability, native instruction set, and memory addressing capabilities—decisions that directly impact the performance and correctness of generated code.