LLM-Enabled Compilation Techniques

• LLM-enabled compilation is a paradigm that integrates large language models into compiler pipelines for tasks like code translation, optimization, and error repair.
• LLM modules function as selectors, translators, and generators across various abstraction levels, enabling efficient handling of full program compilation, autotuning, and agentic build orchestration.
• Empirical studies and systems such as LEGO-Compiler and CompileAgent demonstrate measurable improvements in compilation success rates and repair accuracy through iterative, feedback-driven workflows.

LLM-enabled compilation refers to the integration of LLMs into compiler pipelines as core components for translation, optimization, verification, and code generation tasks. This paradigm generalizes across applications such as full program compilation, error repair, program translation, autotuning, agentic build orchestration, and hierarchical skill compilation. LLMs are positioned as selectors, translators, or generators, and can operate at various abstraction levels: natural language (NL), programming language (PL), intermediate representation (IR), assembly (ASM), or cross-level transformations. This field—systematized in recent surveys and exemplified by empirical platforms—has driven both practical gains and research into verifiable and scalable compiler construction (Zhang et al., 5 Jan 2026).

1. Taxonomy, Integration Points, and Scope

LLM-enabled compilation encompasses any system where traditional compiler components are augmented or replaced by LLM modules for tasks including, but not limited to, translation (e.g., C→x86), optimization (e.g., peephole or IR-level), repair (automated patching), and orchestration (repo-level build, parallel tool execution). The systematic survey (Zhang et al., 5 Jan 2026) presents a four-fold taxonomy:

• Design Philosophy
  • Selector: LLM picks among enumerated actions (flags, optimization passes).
  • Translator: LLM performs text-to-text code transformation (source-to-source or cross-representation).
  • Generator: LLM synthesizes new compiler routines or tools.
• LLM Methodology
  • Training-required: Pretraining on code IRs, supervised fine-tuning, RL with compiler feedback.
  • Training-free: Prompt engineering (including CoT), retrieval-augmented generation (RAG), agentic workflows.
• Level of Code Abstraction
  • NL↔PL, PL↔IR/ASM, ASM↔PL, and cross-modal tasks.
• Task Type
  • Intra-level transforms (transpilation, repair, optimization), cross-level translation (PL→ASM), and utility tasks (fuzzing, binary analysis).

The formal model is a composition 𝒞_LLM = T_compiler ∘ f_LLM, with f_LLM invoked at one or more pipeline points (Zhang et al., 5 Jan 2026).

2. Architectures and Key System Designs

Architectural Innovations

• Composable Translation via Block Decomposition: Systems such as LEGO-Compiler decompose the input CFG into basic or control-flow blocks ("LEGO pieces"), translating each block independently and reassembling in the original graph order. The workflow is organized as verifiable steps (variable renaming, type analysis, mapping, translation, rebuild, behavioral verification), with feedback-guided self-correction for error recovery (Zhang et al., 26 May 2025).
• End-to-End Agents for Compilation: CompileAgent arranges LLM-driven instruction search and error resolution into a policy that invokes external tools (shell, file navigation, instruction extraction, web search, and multi-agent discussion) to raise repo-level compilation success from ∼25% to 89–96% on modern LLMs (Hu et al., 7 May 2025).
• LLM-Enabled Accelerated Compilation: For hardware accelerators (e.g., tensor processors), LLMs generate hardware-specific DSL or ISA code from high-level source via prompt-driven synthesis and multi-step repair, with a two-phase workflow: correctness validation followed by cost-model-driven optimization (Hong et al., 2024).
• Hierarchical Skill Compilation: HERAKLES frames skill compilation for open-ended RL agents as a hierarchical process, with the LLM composing mastered goals into the low-level policy, expanding the subgoal space and improving sample efficiency via distillation and advantage-weighted regression (Carta et al., 20 Aug 2025).

Examples of Core Algorithmic Workflows

System	Decomposition Strategy	Verification/Feedback	Error Recovery
LEGO-Compiler	CFG block split (“LEGO”)	Verifiable sub-steps	Diagnostic feedback, k=5 self-correction
CompileAgent	Flow-based agent invoking tool suite	Real-world build/test logs	Web, agentic, and cross-feedback
SMCFixer	Context-aware AST code slicing	KB retrieval + synth patches	Iterative patch, test, re-slice (Tₘₐₓ=5)
HERAKLES	Hierarchical skill growth	Competence estimator	Constrained decoding; skill re-compilation

These architectures demonstrate decomposition for tractability, prompt/data-driven verification, and iterative or agentic feedback for semantic correctness.

3. Empirical Performance and Evaluation Metrics

Benchmarks and evaluation strategies vary across use cases:

• Executable/Behavioral Accuracy: LEGO-Compiler achieves >99% unit-test passing rate on ExeBench (C→x86_64) and 94/96 function-level behavioral pass on industrial AnsiBench, with performance robust to code size scaling up to >5000 tokens. Hardest random programs (Csmith) yielded 25/40 pass rates with the LEGO workflow vs. 4/40 for direct translation (Zhang et al., 26 May 2025).
• Compilation Success and Repair Accuracy:
  • Repo-level: CompileAgentBench shows 89–96% compilation success (CSR) against prior baselines at 25–79% (Hu et al., 7 May 2025).
  • Solidity contract migration: SMCFixer improves pass rate from 72.7% (standalone GPT-4o) to 96.97% (SMCFixer), with statistically significant 24.24% uplift; BLEU-4 and edit similarity scores corroborate patch minimality and correctness (Ye et al., 14 Aug 2025).
  • Rust error repair: RustAssistant attains 74%–93% fix rate on real-world Rust errors, commits, and lints, with >90% accuracy for individual error corrections; multi-step changelogs and format-constrained prompts are critical (Deligiannis et al., 2023).
  • Industrial CI auto-repair: LLMs repair up to 63% of C/C++ compilation failures, of which 83% are reasonable, with sub-8 minute median time-to-repair (vs. 150 minutes human) (Fu et al., 15 Oct 2025).
• Cross-Platform Compilation: LLMs are capable of generating code for multiple ISAs, with higher success rates and lower syntax error profiles on ARM and RISC-V than x86 when given appropriately specialized prompts (Zhang et al., 6 Nov 2025).

4. Theoretical Foundations and Reasoning Techniques

Multiple works introduce formal constructs and reasoning enhancements:

• Translation Composability: LEGO-Compiler formalizes composability. For translation $T$ and concatenation algebras $(\mathcal{L}_\text{src}, \odot)$, $(\mathcal{L}_\text{dst}, \oplus)$, if $T(P_1 \odot P_2) ≡ T(P_1) \oplus T(P_2)$, correct global translation is ensured. Theorems provide inductive structure for CFG-based block translation correctness (Zhang et al., 26 May 2025).
• Reasoning/Chain-of-Thought: Chain-of-thought (CoT) in optimization (e.g., peephole, MCTS-guided autotuning) significantly increases correctness. For peephole optimization, the GPT-o1 reasoning-enabled model exceeds fine-tuned Llama2 in exact-match, syntactic and IO accuracy, especially on hard blocks (+14–30pp over GPT-4o) without domain-specific SFT (Fang et al., 2024). Similarly, MCTS-guided optimization compilers using LLM reasoning achieve up to 16× better sample efficiency for kernel autotuning (Tang et al., 2 Jun 2025).
• Competence Estimation in Hierarchies: Skill compilation systems integrate LLM-based competence estimation to filter and expand admissible subgoal sets, combining hierarchical decomposition with learning (Carta et al., 20 Aug 2025).

5. Practical Limitations, Challenges, and Scalability

Despite high accuracy in controlled or modular tasks, LLM-enabled compilation faces significant practical constraints (Zhang et al., 26 May 2025, Zhang et al., 5 Jan 2026):

• Performance: LLM compilation workflows are ≈10⁶–10⁷ times slower than traditional pipeline compilers (gcc/clang) due to per-block or per-step invocation.
• Semantic Robustness: Deeply nested constructs, complex arithmetic, or multi-file, macro-heavy codebases remain challenging. Failure modes range from syntactic errors (e.g., invalid mnemonics, register misuse) to semantic errors (wrong variable wiring, off-by-one loops) (Fang et al., 2024, Zhang et al., 6 Nov 2025). For networked workflows, prompt design and error localization are non-trivial.
• Scalability: Context-window limitations (32k tokens upper bound) prevent single-pass handling of large or multi-procedural codebases. Divide-and-conquer approaches ameliorate but do not fully resolve context fragmentation (Zhang et al., 5 Jan 2026).
• Verifiability: Run-time feedback (unit tests, static analyzers, formal SMT verification) is required post-LLM translation to guard against "hallucinations" in code generation.
• Language/Paradigm Coverage: Current LLM compilers have gaps for patterns prominent in Rust (ownership/borrowing), C++ (RAII), or features like exceptions and coroutines.

6. Hybrid Architectures, Future Research, and Outlook

The field is converging on hybrid LLM–compiler architectures as a stable path forward:

• Guardrailed Integration: Hybrid pipelines have the traditional compiler handle standard paths, with LLMs invoked only for "hard" transformations or migration scenarios. Self-improving compiler loops can gather verified LLM-originated optimizations into new passes, enabled by both generation and formal verification (Zhang et al., 5 Jan 2026).
• Agentic and Retrieval-Augmented Systems: RAG and agentic orchestration (e.g., CompileAgent) facilitate multi-language, multi-tool, large-scale compilation, while minimizing manual engineering through self-guided, iterative workflows (Hu et al., 7 May 2025, Ye et al., 14 Aug 2025).
• Adaptive Prompting and Long-Context LLMs: Progress in meta-prompting and memory-augmented inference aims to overcome scalability and context fragmentation (Zhang et al., 26 May 2025).
• Formal Verification and Soundness: Integration with SMT solvers, static analysis overlays, and grammar-constrained decoding are proposed to improve trust and correctness (Zhang et al., 6 Nov 2025, Zhang et al., 5 Jan 2026).
• Benchmarks and Evaluation: The need for standardized, LLM-attuned benchmarks (function-level, whole repo, cross-ISA) is recognized as critical for tracking real-world viability.

A practical implication is that LLM-enabled compilers, while not currently competitive with highly engineered pipeline compilers in raw speed or optimization, enable rapid prototyping for new ISAs, code migration, agentic build automation, and repair at software-engineering scale. Incremental improvements in model reasoning, verifiability, and hybrid system design are essential to transition from research prototypes to widespread industrial adoption. The future trajectory is strongly oriented toward deep integration with static verification, agentic build/test frameworks, and interactive debugging capabilities (Zhang et al., 5 Jan 2026, Zhang et al., 26 May 2025, Hu et al., 7 May 2025).