Yujie Liu
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Yujie Liu has a total of 12 co-authors. Here are the top co-authors by number of shared publications:
- Dan Hao
Key Lab of HCST (PKU), MOE; School of Computer Science, Peking University, China
2 shared publications - Mingxuan Zhu
Peking University, Beijing, China
2 shared publications - Jinhao Dong
Renmin University of China, Beijing, China
1 shared publication - Junzhe Yu
Peking University, Beijing, China
1 shared publication - Lu Zhang
Key Lab of HCST (PKU), MOE; SCS, Peking University, China
1 shared publication - Muhan Zeng
Key Laboratory of High Confidence Software Technologies (Peking University), Ministry of Education, School of Computer Science, Peking University, Beijing, China
1 shared publication
Latest Publications
- Open Access
- 16 November 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
Isolating Compiler Bugs through Compilation Steps Analysis
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.
- 16 November 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
Open AccessIsolating Compiler Bugs through Compilation Steps Analysis
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.
- 27 May 2025
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 51 (7) , 2161-2180
SmartFL: Semantics Based Probabilistic Fault Localization
Testing-based fault localization has been a research focus in software engineering in the past decades. It localizes faulty program elements based on a set of passing and failing test executions. Since whether a fault could be triggered and detected by a test is related to program semantics, it is crucial to model program semantics in fault localization approaches. Existing approaches either consider the full semantics of the program (e.g., mutation-based fault localization and angelic debugging), leading to scalability issues, or ignore the semantics of the program (e.g., spectrum-based fault localization), leading to imprecise localization results. Our key idea is: by modeling only the correctness of program values but not their full semantics, a balance could be reached between effectiveness and scalability. To realize this idea, we introduce a probabilistic model by efficient approximation of program semantics and several techniques to address scalability challenges. Our approach, SmartFL (SeMantics bAsed pRobabilisTic Fault Localization), is evaluated on a real-world dataset, Defects4J 2.0. The top-1 statementlevel accuracy of our approach is 14%, which improves 130% over the best SBFL and MBFL methods. The average time cost is 205 seconds per fault, which is half of SBFL methods. After combining our approach with existing approaches using the CombineFL framework, the performance of the combined approach is significantly boosted by an average of 10% on top-1, top-3, and top-5 accuracy compared to state-of-the-art combination methods.
- 27 May 2025
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 51 (7) , 2161-2180
SmartFL: Semantics Based Probabilistic Fault Localization
Testing-based fault localization has been a research focus in software engineering in the past decades. It localizes faulty program elements based on a set of passing and failing test executions. Since whether a fault could be triggered and detected by a test is related to program semantics, it is crucial to model program semantics in fault localization approaches. Existing approaches either consider the full semantics of the program (e.g., mutation-based fault localization and angelic debugging), leading to scalability issues, or ignore the semantics of the program (e.g., spectrum-based fault localization), leading to imprecise localization results. Our key idea is: by modeling only the correctness of program values but not their full semantics, a balance could be reached between effectiveness and scalability. To realize this idea, we introduce a probabilistic model by efficient approximation of program semantics and several techniques to address scalability challenges. Our approach, SmartFL (SeMantics bAsed pRobabilisTic Fault Localization), is evaluated on a real-world dataset, Defects4J 2.0. The top-1 statementlevel accuracy of our approach is 14%, which improves 130% over the best SBFL and MBFL methods. The average time cost is 205 seconds per fault, which is half of SBFL methods. After combining our approach with existing approaches using the CombineFL framework, the performance of the combined approach is significantly boosted by an average of 10% on top-1, top-3, and top-5 accuracy compared to state-of-the-art combination methods.
- Open Access
- 27 October 2024
- Published by Association for Computing Machinery (ACM)
- p. 819-830
Compiler Bug Isolation via Enhanced Test Program Mutation
Compilers are one of the most fundamental software systems. A large number of software systems rely on compilers for execution. Compiler bugs can significantly hinder software developers from diagnosing issues within their software. Therefore, it is essential to ensure the correctness of compilers and to isolate and fix compiler bugs. Isolating bugs within compilers is challenging due to compilers' complexity and large codebase. The prior studies on compiler bug isolation struggle to generate sufficient test cases for bug isolation and are not effective enough. To improve compiler bug isolation, in this paper, we propose a new compiler bug isolation technique ETEM which generates diverse test programs using feature mutation operators. Specifically, ETEM first searches for simplified optimization configurations that turn off fine-grained options as much as possible to narrow the coverage. Then, ETEM uses a joint reinforcement learning-based search method for mutation operators and mutate positions to get more high-quality test programs. Finally, ETEM uses rank-based aggregation to calculate each file's suspicious value. This paper also evaluates the effectiveness of the proposed technique and the contribution of each component on a dataset consisting of 120 real bugs in GCC and LLVM. The experimental results indicate that ETEM outperforms existing techniques in terms of efficiently isolating compiler bugs. Furthermore, each component of ETEM contributes to its effectiveness. Specifically, ETEM effectively isolates about 23.3%/47.5%/61.4%/76.6% bugs within Top-1/5/10/20. The overall improvements of ETEM over the state-of-the-art techniques ODFL in terms of Top-1/5/10/20 are 64.7%/35.7%/20.3%/15.0%.
- 27 October 2024
- Published by Association for Computing Machinery (ACM)
- p. 819-830
Open AccessCompiler Bug Isolation via Enhanced Test Program Mutation
Compilers are one of the most fundamental software systems. A large number of software systems rely on compilers for execution. Compiler bugs can significantly hinder software developers from diagnosing issues within their software. Therefore, it is essential to ensure the correctness of compilers and to isolate and fix compiler bugs. Isolating bugs within compilers is challenging due to compilers' complexity and large codebase. The prior studies on compiler bug isolation struggle to generate sufficient test cases for bug isolation and are not effective enough. To improve compiler bug isolation, in this paper, we propose a new compiler bug isolation technique ETEM which generates diverse test programs using feature mutation operators. Specifically, ETEM first searches for simplified optimization configurations that turn off fine-grained options as much as possible to narrow the coverage. Then, ETEM uses a joint reinforcement learning-based search method for mutation operators and mutate positions to get more high-quality test programs. Finally, ETEM uses rank-based aggregation to calculate each file's suspicious value. This paper also evaluates the effectiveness of the proposed technique and the contribution of each component on a dataset consisting of 120 real bugs in GCC and LLVM. The experimental results indicate that ETEM outperforms existing techniques in terms of efficiently isolating compiler bugs. Furthermore, each component of ETEM contributes to its effectiveness. Specifically, ETEM effectively isolates about 23.3%/47.5%/61.4%/76.6% bugs within Top-1/5/10/20. The overall improvements of ETEM over the state-of-the-art techniques ODFL in terms of Top-1/5/10/20 are 64.7%/35.7%/20.3%/15.0%.