LLVM如何生成AArch64的JumpTable？代码实现存疑

Great question! This is a perfect example of how LLVM's modular, shared infrastructure handles common code generation tasks, so target-specific backends don't need to reinvent the wheel. Let's break down what's happening:

1. Jump Table Logic Lives in LLVM's Generic Asm Printer Framework #

Most of the heavy lifting for jump table emission is handled by the base AsmPrinter class and related shared utilities (like JumpTableSupport), not in target-specific .cpp files. The generic code takes care of:

• Iterating over jump table entries
• Calculating memory offsets
• Emitting the core structure of the table

AArch64 leverages this generic infrastructure instead of reimplementing everything from scratch in AArch64AsmPrinter.cpp.

2. AArch64 Configures Jump Table Behavior via TargetLowering #

Instead of hardcoding jump table logic in the asm printer, AArch64 defines how it wants jump tables to behave in its TargetLowering implementation (AArch64TargetLowering.cpp). Key configuration hooks include:

• getJumpTableEncoding: Returns the encoding type that fits AArch64's instruction set (e.g., efficient PC-relative addressing)
• getJumpTableEntrySize: Specifies the size of each table entry, aligned to AArch64's memory requirements
• Custom handlers for edge cases (if needed)

These settings tell the generic asm printer exactly how to generate jump tables that work with AArch64's architecture.

3. ARM32 Needs Custom Code Because of Unique Constraints #

You noticed ArmAsmPrinter.cpp has explicit jump table code because ARM32 has more complex constraints:

• It supports both ARM and Thumb instruction sets, each with distinct jump table formats
• Limited PC-relative addressing range requires special handling for larger tables
• Some legacy ABIs enforce specific jump table layout rules

So ARM32 needs to override the generic logic to handle these target-specific edge cases, hence the explicit code in its asm printer.

4. The Final Binary Generation Flow #

When compiling code with a switch statement to AArch64:

1. The frontend converts the switch to LLVM IR with a switch instruction
2. The AArch64 backend lowers this IR to a jump table, guided by AArch64TargetLowering rules
3. The generic AsmPrinter uses AArch64's configurations to emit the correct assembly for the jump table
4. The assembler and linker process this into the final binary's jump table section

In short, AArch64 doesn't need explicit jump table code in its asm printer because it relies on LLVM's shared infrastructure, configured via target-specific lowering rules.

内容的提问来源于stack exchange，提问作者Twinkle HanA