executable context reconstruction

Existing decompilation methods—including LLM-based approaches—struggle to generate source code that is both recompilable and executable, particularly due to semantic information loss induced by compiler optimizations. To address this, we propose the first hybrid decompilation framework incorporating in-context learning, synergistically integrating static analysis with large language models. Our approach explicitly recovers optimization-erased semantic cues via semantic guidance, enabling faithful reconstruction of high-level program structure and behavior. The framework supports diverse compilers and optimization levels without fine-tuning, ensuring broad generalizability. Evaluated on multiple benchmark datasets, our method achieves a ~40% improvement in executable rate over prior state-of-the-art techniques—marking the first systematic breakthrough in achieving practically runnable decompiled code.

This work addresses the limitations of existing automated program repair techniques, which often underperform due to insufficient incorporation of multidimensional program context essential for real-world security practices. To overcome this, the authors propose a context-driven multi-agent framework that systematically integrates three complementary sources of contextual information—code structure, runtime execution traces, and commit history—through specialized sub-agents that collaboratively generate and inject contextual memory into a repair agent for conditional patch synthesis. The approach synergistically combines large language models with cross-file data-flow and memory analysis, crash semantics extraction, and version history mining. Evaluated on SEC-Bench, a benchmark of 300 real-world vulnerabilities, the method achieves a 73% repair success rate, outperforming the strongest baseline by 29%. Ablation studies further confirm the individual contributions of each contextual dimension and the efficacy of the multi-agent architecture.

This work addresses the challenge of automated merge conflict resolution, which is hindered by ambiguous developer intent and intricate cross-file dependencies. To overcome this, the authors propose a novel approach that synergistically integrates program analysis with large language models (LLMs). The method constructs a multi-tier code property graph (MtCPG) to precisely capture cross-file dependencies and employs graph connectivity algorithms to cluster conflicting code regions along with their contextual surroundings. These clusters are then used to generate context-aware prompts that guide the LLM toward producing accurate and coherent resolutions. This framework represents the first deep integration of program analysis and LLMs for merge conflict resolution, significantly outperforming existing baselines—such as MergeGen and WizardMerge—at character, lexical, and semantic levels, yielding solutions that closely resemble human-performed merges.

This work addresses the limited cross-file contextual awareness of code large language models (CodeLLMs) in repository-level code generation. Methodologically, we introduce RepoExec—the first executable and functionally correct repository-level benchmark—and propose Dependency Invocation Rate (DIR), a novel metric quantifying the accuracy of cross-file dependency invocation. We further design an instruction-tuning dataset integrating test-driven validation and context-aware dependency modeling. Our contributions include the first comprehensive evaluation framework encompassing context-awareness, execution-driven assessment, and cross-file dependency modeling. Experimental results demonstrate that instruction tuning significantly improves contextual utilization and debugging capability, whereas pre-trained models exhibit stronger functional correctness. RepoExec has since become the de facto standard benchmark for repository-level code generation research.

This work addresses the limitation of large language models (LLMs), which, trained solely on static code, lack the deep, long-horizon reasoning capabilities essential for real-world software development. To bridge this gap, the authors propose a novel “understanding through refactoring” paradigm that reconceptualizes the development process as a refactorable multi-agent trajectory. By inversely synthesizing high-quality reasoning trajectories—encompassing planning, debugging, and iterative refinement—from static code, and integrating dependency graph–guided trajectory generation with search-based chain-of-thought optimization, the method enables continuous pretraining. Experiments on Llama-3-8B demonstrate significant improvements in long-context comprehension, programming proficiency, and agent-like behavioral capabilities, effectively enhancing the model’s capacity for deep reasoning.

This work addresses the inefficiency of large language model (LLM) agents in repository-scale code repair, where excessive context tokens are consumed by redundant file reads, broad searches, and verbose logs, often obscuring relevant evidence with irrelevant information. To mitigate this, the authors propose ContextSniper—a smart memory layer tailored for code repair—that integrates a Sniper feature selection mechanism combining hybrid retrieval signals with intent-aware context gating. This approach preserves recoverable source context while injecting only compact, high-signal evidence packages. Experimental results on SWE-bench Lite demonstrate that ContextSniper reduces token consumption by 51.5% for OpenClaw and 38.9% for Claude Code, yielding cost savings of 36.4% and 27.3%, respectively, with only a marginal 2-percentage-point drop in commit resolution rate.

This study investigates the impact of granularity and scope of fault localization context on the effectiveness of large language model (LLM)-driven automated program repair. Based on 500 SWE-bench Verified instances, the authors systematically evaluate 61 context configurations spanning file-level, element-level, and line-level granularities, finding that increased context does not necessarily improve performance. They propose an efficient strategy that integrates high-level semantic understanding with precise line-level fault localization and compare LLM-based retrieval against structure-guided heuristics on GPT-5-mini. Results show that file-level localization yields a 15–17× speedup, peak repair success is achieved with 6–10 relevant files, and LLM-based retrieval consistently outperforms heuristic methods in both effectiveness and resource efficiency.

This work addresses the challenge of reliable source-level binary patching in the absence of original source code and toolchains, where existing decompilers often produce outputs riddled with syntactic and semantic errors. To overcome this limitation, the authors propose a static patching framework that integrates decompilation with binary-aware recompilation. By leveraging information extracted directly from the original binary, the framework corrects semantic distortions in decompiled code and enables automated patch generation. The approach substantially improves recompilation correctness, fixing approximately 81% of erroneous functions produced by Hex-Rays, successfully patching 13 out of 14 real-world CVEs, and increasing user experiment success rates from 3.7% to 100%. Furthermore, it supports large-model-driven fully automated patching, demonstrating robust practical applicability.

Concurrent programs are prone to elusive bugs due to the nondeterministic nature of thread execution, and existing automated repair techniques often rely on idealized contextual assumptions, limiting their effectiveness in real-world scenarios. This work proposes ConFixAgent, the first end-to-end large language model (LLM)-driven agent capable of repairing concurrency bugs without requiring prior defect information. ConFixAgent automatically extracts critical contextual dependencies via static Happens-Before graphs to accurately identify concurrency defects and generate precise repairs. Evaluated across multiple benchmark datasets, ConFixAgent significantly outperforms state-of-the-art tools, effectively fixing a wide range of concurrency bugs. Its context extraction mechanism substantially enhances the accuracy of LLM-based program repair by providing semantically relevant and execution-aware information.

This work addresses the challenge that existing large language model (LLM)-based program repair approaches often struggle to accurately localize fault roots due to noisy or irrelevant code in the repair context. To overcome this limitation, the paper introduces CausalRepair, a novel framework that pioneers the concept of causal context by integrating context-aware static slicing with execution-trace-based dynamic slicing to construct minimal, causally relevant repair guidance. This refined context is then leveraged within an interactive dialogue mechanism to iteratively steer the LLM (DeepSeek-V3) toward effective repairs. Evaluated on multiple versions of Defects4J, CausalRepair successfully fixes 313 bugs, substantially outperforming state-of-the-art methods such as ReinFix and TSAPR, while achieving a remarkably low average repair cost of just \$0.029 per bug.