Isolating Compiler Bugs through Compilation Steps Analysis

2025-10-14

AI Summary

Compilers’ internal defects are notoriously difficult to localize due to the lack of causal modeling of compilation processes in existing test-based mutation approaches, hindering precise error propagation tracing. To address this, we propose CompSCAN—a novel method that introduces causal analysis into compiler step sequences for the first time. It operates via a three-stage framework: (1) extracting the sequence of compilation steps from failing executions; (2) identifying error-triggering steps and associating them with relevant code elements; and (3) ranking suspicious elements using a tailored suspiciousness scoring model. Evaluated on 185 real-world LLVM/GCC bugs, CompSCAN achieves Top-1/3/5/10 localization counts of 50/85/100/123, outperforming state-of-the-art methods by up to 50.18% while exhibiting faster average execution. Its core contribution lies in establishing a compiler-step-level causal tracing mechanism, enabling efficient, interpretable, and automated isolation of compiler defects.

Technology Category

• Reasoning under Uncertainty: Causality
• Machine Learning: Causal Learning
• Natural Language Processing: Code Generation / Program Synthesis from Natural Language

Application Category

• Security and Privacy: Large-scale security measurements
• Search and Retrieval-Augmented AI: Efficiency and scalability of Web search engines
• Web Mining and Content Analysis: Web measurements

Abstract

Compilers are essential to software systems, and their bugs can propagate to dependent software. Ensuring compiler correctness is critical. However, isolating compiler bugs remains challenging due to the internal complexity of compiler execution. Existing techniques primarily mutate compilation inputs to generate passing and failing tests, but often lack causal analysis of internal steps, limiting their effectiveness. To address this limitation, we propose CompSCAN, a novel compiler bug isolation technique that applies analysis over the sequence of compilation steps. CompSCAN follows a three-stage process: (1) extracting the array of compilation steps that leads to the original failure, (2) identifying bug-causing steps and collecting corresponding compiler code elements, and (3) calculating suspicious scores for each code element and outputting a suspicious ranking list as the bug isolation result. We evaluate CompSCAN on 185 real-world LLVM and GCC bugs. Results show that CompSCAN outperforms state-of-the-art techniques in both effectiveness and efficiency. CompSCAN successfully isolates 50, 85, 100, and 123 bugs within the Top-1/3/5/10 ranks, respectively. Compared with ETEM and ODFL, two state-of-the-art compiler bug isolation techniques, CompSCAN achieves relative improvements of 44.51% / 50.18% / 36.24% / 24.49% over ETEM, and 31.58% / 49.12% / 44.93% / 21.78% over ODFL on those metrics. Moreover, CompSCAN runs faster on average per bug than both baselines.

Problem

• Isolating compiler bugs through compilation steps analysis
• Addressing lack of causal analysis in compiler bug isolation
• Improving effectiveness and efficiency of compiler bug localization

Innovation

• Analyzes sequence of compilation steps for bugs
• Identifies bug-causing steps and code elements
• Calculates suspicious scores for ranking bug locations