Finding and understanding bugs in C compilers
The DOI matches its Crossref record; 22 of the 23 references it cites were found in a registry or an index.
Abstract
Compilers should be correct. To improve the quality of C compilers, we created Csmith, a randomized test-case generation tool, and spent three years using it to find compiler bugs. During this period we reported more than 325 previously unknown bugs to compiler developers. Every compiler we tested was found to crash and also to silently generate wrong code when presented with valid input. In this paper we present our compiler-testing tool and the results of our bug-hunting study. Our first contribution is to advance the state of the art in compiler testing. Unlike previous tools, Csmith generates programs that cover a large subset of C while avoiding the undefined and unspecified behaviors that would destroy its ability to automatically find wrong-code bugs. Our second contribution is a collection of qualitative and quantitative results about the bugs we have found in open-source C compilers.
Overview
Integrity signals
Registry
Cites
Statistics
Verification
Claims the paper makes
Claims other papers make about this one
Each is checked against this paper’s own text: does it say what the citing paper says it does?
In the citing paper
“This paper demonstrates that modern titanic LLMs can be leveraged to directly perform both generation-based and mutation-based fuzzing studied for decades, while being fully automated, generalizable, and applicable to domains challenging for traditional approaches (such as DL systems).”
From Large Language Models Are Zero-Shot Fuzzers: Fuzzing Deep-Learning Libraries via Large Language Models (2023) · cites this paper as [80]
Citations
Cites
International Organization for Standardization
(2011) · SpringerReference · doi:10.1007/springerreference_16847 · Cited by 12,534
Klein, G., Elphinstone, K., Heiser, G., Andronick, J., Cock, D., Derrin, P., Elkaduwe, D., Engelhardt, K., Kolanski, R., Norrish, M., et al. (2009) · Proceedings of the ACM SIGOPS 22nd symposium on Operating systems principles · doi:10.1145/1629575.1629596 · Cited by 1,633 · cited 1×
“As measured by the responses to our bug reports, the defects discovered by Csmith are important.”
MethodAn empirical study of the reliability of UNIX utilities
Miller, B. P., Fredriksen, L., & So, B. (1990) · Communications of the ACM · doi:10.1145/96267.96279 · Cited by 1,281
Formal verification of a realistic compiler
Leroy, X. (2009) · Communications of the ACM · doi:10.1145/1538788.1538814 · Cited by 1,187 · cited 1×
“Wolfe [30], talk ing about independent software vendors (ISVs) says: An ISV with a complex code can work around correctness, turn off the optimizer in one or two .les, and usually they have to do that for any of the compilers they use (emphasis ours).”
BackgroundEncyclopedia of Software Engineering
(2002) · Wiley eBooks · doi:10.1002/0471028959 · Cited by 1,161
Simplifying and isolating failure-inducing input
Zeller, A., & Hildebrandt, R. (2002) · IEEE Transactions on Software Engineering · doi:10.1109/32.988498 · Cited by 1,079
An experimental evaluation of the assumption of independence in multiversion programming
Knight, J. C., & Leveson, N. G. (1986) · IEEE Transactions on Software Engineering · doi:10.1109/tse.1986.6312924 · Cited by 774 · cited 3×
“In summary, despite the fact that Knight and Leveson [13] found a substantial number of correlated errors in an experiment on Nversion programming, Csmith has yielded no evidence of correlated failures among unrelated C compilers.”
BackgroundInfluential(1998) · Cited by 469
Grammar-based whitebox fuzzing
Godefroid, P., Kiezun, A., & Levin, M. Y. (2008) · Proceedings of the 29th ACM SIGPLAN Conference on Programming Language Design and Implementation · doi:10.1145/1375581.1375607 · Cited by 462 · cited 1×
“[8] showed a way to solve this problem by integrating a constraint solver with a grammar for the language being generated.”
BackgroundHDD: hierarchical delta debugging
Misherghi, G., & Su, Z. (2006) · Proceedings of the 28th international conference on Software engineering · doi:10.1145/1134285.1134307 · Cited by 274 · cited 1×
“Delta debugging [31] automates test-case reduction, but all existing variants that are intended for reducing C programs—such as hierarchical delta debugging [18] and Wilkerson’s implementation [29]—introduce undefined behavior.”
Background
Research works printed but not linked: 7
- F. Bellard . TCC: Tiny C compiler, ver. 0.9.25 , May 2009 . http://bellard.org/tcc/. F. Bellard. TCC: Tiny C compiler, ver. 0.9.25, May 2009. http://bellard.org/tcc/.
- C. L. Biffle . Undefined behavior in Google NaCl , Jan. 2010 . http://code.google.com/p/nativeclient/issues/detail?id=245. C. L. Biffle. Undefined behavior in Google NaCl, Jan. 2010. http://code.google.com/p/nativeclient/issues/detail?id=245.
- 10.1002/spe.v37:14 · doi:10.1002/spe.v37:14
- B. Turner . Random Program Generator , Jan. 2007 . http://sites.google.com/site/brturn2/randomcprogramgenerator. B. Turner. Random Program Generator, Jan. 2007. http://sites.google.com/site/brturn2/randomcprogramgenerator.
- 10.5555/1060289.1060313 · doi:10.5555/1060289.1060313
- D. S. Wilkerson . Delta ver . 2006 .08.03, Aug. 2006. http://delta.tigris.org/. D. S. Wilkerson. Delta ver. 2006.08.03, Aug. 2006. http://delta.tigris.org/.
- C. Zhao Automated test program generation for an industrial optimizing compiler . In Proc. ICSE Workshop on Automation of Software Test , pages 36 -- 43 , May 2009 . C. Zhao et al. Automated test program generation for an industrial optimizing compiler. In Proc. ICSE Workshop on Automation of Software Test, pages 36--43, May 2009.
Cited by
Items 701–800 of 833
Early Bug Detection through Shift Left Testing
Venkitaraman, A. (2024) · International Journal of Innovative Science and Research Technology (IJISRT) · doi:10.38124/ijisrt/ijisrt24nov177
Compiler Version Identification Based on Multi-Feature Fusion
Wang, D., Wang, J., & Li, R. (2024) · IEEE International Conference on Information Systems and Computer Aided Education (ICISCAE) · doi:10.1109/iciscae62304.2024.10761773
“Since the overall workflow of the compiler is: form program, pre-compile, compile, assemble, and link [5] .”
The Faultless Way of Programming
Noble, J., & Weir, C. (2024) · European Conference on Pattern Languages of Programs · doi:10.1145/3698322.3698340
“CompCert C [2023] is a formally verified C compiler that won the ACM Software Systems award in 2021: a comprehensive study Yang et al. [30] found no bugs in the CompCert C compiler compared to the GCC [10] and LLVM [18] toolchains.”
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705595
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705602
Formal Verification of Impure Coq JITs
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705600
Formally Verified Speculative Optimizations
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705599
Background on the CompCert Compiler
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705597
(2025) · ACM eBooks · doi:10.1145/3705593.3705594
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705603
(2025) · ACM eBooks · doi:10.1145/3705593.3705606
(2025) · ACM eBooks · doi:10.1145/3705593.3705605
Formal Verification of a JIT Backend Compiler
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705601
Relating the Developments to the Book
(2025) · ACM eBooks · doi:10.1145/3705593.3705604
Designing Formally Verified JITs
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705598
Background on Just-in-Time Compilation
Barrière, A. (2025) · ACM eBooks · doi:10.1145/3705593.3705596
Automatic Test Case Generation for Jasper App HDL Compiler: An Industry Experience
Crepalde, M. A., Mafra, A., Cavalini, L., Martins, L., Amorim, G., Santos, P. H., & Peixoto, F. (2025) · ACM SIGPLAN International Conference on Compiler Construction (CC) · doi:10.1145/3708493.3712681
“More recently, in 2011 Yang et al. [19] published their random program generator for the C programming language, Csmith, which was able to identify new bugs in main streams of production compilers used in industry.”
Hercules: Efficient Verification of High-Level Synthesis Designs with FPGA Acceleration
Xu, S., Jiang, Z., Zhang, Y., Boland, D., Bao, Y., & Shi, K. (2025) · ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA) · doi:10.1145/3706628.3708866
CTDip: a diversity-guided test program synthesis approach for boosting compiler bug detection
Tang, Y., Zeng, J., Zhang, J., Li, W., & Huang, Z. (2025) · Empirical Software Engineering · doi:10.1007/s10664-025-10642-0
“Differential testing is a widely employed software testing technique that has been utilized in recent years for detecting compiler bugs (Yang et al. 2011; Sun et al. 2016c; Chen et al. 2016a).”
InfluentialJiapi: A Pluggable Type Checker Generator for Statically-Typed JVM-Based Languages
Cisneros, B., & Pedersen, J. B. (2025) · Advances in intelligent systems and computing · doi:10.1007/978-3-031-89063-5_55
BoostPolyGlot: A Structured IR Generation-Based Fuzz Testing Framework for GCC Compiler Frontend
Hui, L., Guo, H., Liu, P., & Hou, T. (2025) · Applied Sciences · doi:10.3390/app15115935 · Cited by 1
Compiler Identification with Divisive Analysis and Support Vector Machine
Liu, C., Zhang, Y., Zuo, P., & Wang, P. (2025) · Symmetry · doi:10.3390/sym17060867
Vellvm: Formalizing the Informal LLVM
Beck, C., Chen, H., & Zdancewic, S. (2025) · Lecture notes in computer science · doi:10.1007/978-3-031-93706-4_6
“Generating random programs to differentially test compiler implementations is not a new technique: CSmith [24] and its successors YARPGen (both versions 1 and 2) [14, 15] are capable of generating expressive C programs targeting arithmetic operations and control-flow, respectively.”
Intrinsic Verification of Parsers and Formal Grammar Theory in Dependent Lambek Calculus
Schaefer, S., Varner, N., de Amorim, P. H. A., & New, M. S. (2025) · Proceedings of the ACM on Programming Languages · doi:10.1145/3729281
Sembug: Detecting Logic Bugs in Dbms Through Generating Semantic-Aware Non-Optimizing Query
Ye, S., Ni, C., Wang, J., Pang, Q., Li, X., & Xu, X. (2025) · IEEE International Conference on Program Comprehension (ICPC) · doi:10.1109/icpc66645.2025.00021 · Cited by 1
HuntFUZZ: Enhancing error handling testing through clustering based fuzzing
Wei, J., Chen, P., Dai, J., Sun, X., Zhang, Z., Xu, C., & Wang, Y. (2025) · Journal of Computer Security · doi:10.1177/0926227x251343867
“21 While some traditional fuzzers 23,39 are adept at discovering some errors by rapidly generating program inputs, these input-driven fuzzing approaches often fall short in detecting input-independent errors, because these types of errors typically stem from exceptional events that sporadically…”
Random test generators demystified: Differences and potential for compiler reliability
Wang, Y., Lu, Z., Wu, B., Yang, Y., Lu, H., & Zhou, Y. (2025) · Science of Computer Programming · doi:10.1016/j.scico.2025.103359
A Comprehensive Approach to Rustc Optimization Vulnerability Detection in Industrial Control Systems
Xie, K., Wan, J., Chen, L., & Wang, Y. (2025) · Mathematics · doi:10.3390/math13152459
Unveiling Logic Bugs in SPJG Query Optimizations within DBMS
Tang, X., Yang, S., Wu, S., Zhang, D., Zhou, W., Li, F., & Chen, G. (2025) · ACM Transactions on Database Systems · doi:10.1145/3764583 · Cited by 1
“Differential testing has been shown to be effective in many areas [14, 18, 32, 35, 40, 62].”
Live Region Mutation Testing for Commercial Cyber-Physical System Development Tool Chain
Zhang, L., Guo, S., Wang, Z., Wang, X., Li, X., & Jiang, H. (2025) · ACM/IEEE Design Automation Conference (DAC) · doi:10.1109/dac63849.2025.11133188
“Tools like Csmith [15] generates random programs to uncover compiler bugs, while other approaches mutate programs in dead and live regions to maintain equivalence modulo inputs.”
Beyond Syntax: Testing LLM Semantic Understanding of Code
Sabané, A., & Bissyandé, T. F. (2025) · Communications in computer and information science · doi:10.1007/978-3-031-98327-6_1
Posing New Challenges to Function Entry Identification through Fine-Grained CFI Obfuscation
Zhang, T., Pang, C., Peng, F., Wang, L., & Mao, B. (2025) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3770582
“Usmith is built on Csmith [54], which could generate C programs automatically with predefined rules.”
Pyrosome: Verified Compilation for Modular Metatheory
Jamner, D., Kammer, G., Nag, R., & Chlipala, A. J. (2025) · Proceedings of the ACM on Programming Languages · doi:10.1145/3763052
SRLRF: Fine-Grained Root Cause Analysis and Prediction for Compiler Optimization Defects
Luo, H., Tang, Y., Zhang, J., Zhu, X., Li, J., & Zou, W. (2025) · Asia-Pacific Symposium on Internetware · doi:10.1145/3755881.3755906
Emerging Compiler Testing Based on Test Case Reuse
Zhu, K., Wang, Y., Wang, L., & Li, X. (2025) · Asia-Pacific Symposium on Internetware · doi:10.1145/3755881.3755917
Nüwa: Enhancing MLIR Fuzzing with LLM-Driven Generation and Adaptive Mutation
Cao, B., Tong, W., Tang, Z., Wang, Z., Huang, H., & Yan, Y. (2025) · IEEE International Conference on Software Maintenance (ICSM) · doi:10.1109/icsme64153.2025.00055
“Typical approaches involve hard-coded grammar rules [11], user-supplied grammar specifications [47], or intermediate representations (IR) to generate code for various downstream languages.”
False-Positive Bug Reports in Deep Learning Compilers: Stages, Root Causes, and Mitigation
Huang, L., Shen, Q., Wang, D., Wu, Y., Wang, M., & Chen, J. (2025) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3774889 · Cited by 4
SSFuzz: Synthesizing and scheduling bug-triggering code segments for history-driven compiler testing
Hu, T., Fan, Z., Ye, Z., Ye, G., & He, L. (2025) · Empirical Software Engineering · doi:10.1007/s10664-025-10777-0
“Just like any other complex software, although these JVMs are meticulously maintained by professional teams, these implementations remain susceptible to bugs and security vulnerabilities (Yang et al. 2011; Chen et al. 2020).”
Li, C., Li, W., Yu, Y., & Huang, Z. (2025) · Lecture notes in computer science · doi:10.1007/978-981-96-9849-3_25
On the Practicality of LLM-Based Compiler Fuzzing
Ricardo, G. G. D. S., Junior, N. D. S., Figueiredo, F., & Pereira, F. M. Q. (2025) · doi:10.5753/sblp.2025.12264 · Cited by 1
Detecting WebAssembly Runtime Bugs With Grammar-Guided Program Mutation
Lu, X., Zhou, Z., Li, X., Xuan, J., Wu, H., Jiang, H., & Ren, Z. (2025) · IEEE Transactions on Reliability · doi:10.1109/tr.2025.3614352 · Cited by 1
TAIDL: Tensor Accelerator ISA Definition Language with Auto-generation of Scalable Test Oracles
Jain, D., Frigo, M., Arora, J., Pardeshi, A., Wang, Z., Patel, K., & Mendis, C. (2025) · IEEE/ACM International Symposium on Microarchitecture (MICRO) · doi:10.1145/3725843.3756075 · Cited by 5
Optimization-Aware Test Generation for Deep Learning Compilers
Shen, Q., Wang, Z., Ma, H., Tian, Y., Huang, L., Xiao, Z., Chen, J., & Cheung, S.-C. (2026) · ACM/IEEE International Conference on Software Engineering: Companion Proceedings (ICSE-Companion) · doi:10.1145/3744916.3773216 · Cited by 8
“Consequently, fuzzing techniques [29, 55, 58] for traditional compilers cannot be applied to DL compilers due to significant differences in input formats and test objectives [42, 43].”
GrammLLM: Grammar-Guided LLM Test Generation for Compiler Validation
Talaat, M. G., Hassan, M. M., Sayed, M., Mohamed, M., & Ahmed, I. (2025) · doi:10.1109/icm66518.2025.11322450
“Csmith [6] demonstrated effectiveness for C compilers, finding hundreds of bugs in GCC and LLVM.”
PerturbGen: A Population Based Perturbation Method for Processor Test Generation
Wang, J., Chen, R., & Wang, L. (2025) · Conference proceedings/Conference proceedings - IEEE International Conference on Systems, Man, and Cybernetics · doi:10.1109/smc58881.2025.11343428
“Random program generators hard-code the high-level language specifications to produce test programs, avoiding the generated programs with unspecified and undefined behavior, such as Csmith [5] and YARPGen [6].”
Latra: A Template-Based Language-Agnostic Transformation Framework for Effective Program Reduction
Xu, Z., Wang, Y., Tian, Y., Zhang, M., & Sun, C. P. (2025) · IEEE/ACM International Conference on Automated Software Engineering (ASE) · doi:10.1109/ase63991.2025.00188
“Programs that trigger such bugs can be extraordinarily large, sometimes spanning thousands of lines of code [1]–[9].”
Tephra: Principled Discovery of Fuzzer Limitations
Sarafov, V., Markvica, D., & Brunthaler, S. (2025) · IEEE/ACM International Conference on Automated Software Engineering (ASE) · doi:10.1109/ase63991.2025.00224 · Cited by 1
“Tools like the csmith family [17], [18] generate C and C++ microbenchmarks to test semantic preservation under optimization, detect missed optimizations [56], [57], and find better optimization sequences [58]. b) Fuzzing obstacles: In a registered report from 2023 [59], Gao et al. argue there is a…”
ZendDiff: Differential Testing of PHP Interpreter
Jiang, Y., Wang, J., Liu, Q., Fu, Y., Mao, J., Yap, R. H. C., & Liang, Z. (2025) · IEEE/ACM International Conference on Automated Software Engineering (ASE) · doi:10.1109/ase63991.2025.00095 · Cited by 1
“Existing solutions for detecting bugs in other compilers and interpreters mainly concentrate on fuzzing techniques, such as C/C++[48, 19], Rust[24, 49], and JavaScript (JS) [50, 47, 17], to mitigate potential cascading security issues.”
CPerfSmith: A Randomized C Program Generator for Performance-Oriented Compiler Testing
Boda, Y., Chunduri, A., Kumari, R., & Pandey, A. (2026) · ACM SIGPLAN International Conference on Compiler Construction (CC) · doi:10.1145/3771775.3786271
“Existing tools such as Csmith [24], YARPGen [17], JFS [14], CLsmith [22], and LangFuzz [11] are effective for detecting compiler bugs and supporting robustness and security testing.”
InfluentialInterleaved Learning and Exploration: A Self-Adaptive Fuzz Testing Framework for MLIR
Sun, Z., Liang, J., Wang, W., Suo, C., Chen, J., & Xu, F. (2025) · IEEE/ACM International Conference on Automated Software Engineering (ASE) · doi:10.1109/ase63991.2025.00196 · Cited by 1
“Considering MLIR’s multi-level IR design and its support for hybrid IR patterns, general compiler testing methods, which typically target only specific source code [21]–[23] or a fixed-level IR [24], [25], cannot effectively address the unique syntactic and semantic features of MLIR.”
ORThrus: Detecting Deep Learning Compiler Bugs via Optimization Resistance Transformations
Zhang, T., & Hua, B. (2025) · IEEE International Conference on Trust, Security and Privacy in Computing and Communications (TrustCom) · doi:10.1109/trustcom66490.2025.00258 · Cited by 1
“Therefore, these unique characteristics of deep learning compilers makes it challenging to directly apply bug detection techniques that have been proposed for traditional non-deep learning compilers [12] [13].”
From Stochastic to Semantic: Advanced Attribute-Guided Compiler Testing
Wu, J., Yang, Y., Sun, M., Li, Q., Chen, K., Xu, L., & Zhou, Y. (2026) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3793554 · Cited by 1
“This approach can avoid duplicate bug reports as much as possible because once bugs are found in the trunk version, developers tend to quickly fix them [29, 65].”
InfluentialLiu, H., Guo, S., Liu, J., Wang, Y., Cheng, H., Li, X., & Jiang, H. L. (2026) · ACM Transactions on Design Automation of Electronic Systems · doi:10.1145/3797030
Towards Threading the Needle of Debuggable Optimized Binaries
Assaiante, C., di Biasio, S., Kumar, S., Luna, G. A. D., D’Elia, D. C., & Querzoni, L. (2026) · Proceedings of the CGO/Proceedings of the ... CGO · doi:10.1109/cgo68049.2026.11395216
“We tested this approach on the 5000 synthetic programs generated via Csmith [23] that both works used.”
Mutation-based fuzzer for the swift compiler
Hyatt, S. C., & Dewey, K. T. (2026) · Science of Computer Programming · doi:10.1016/j.scico.2026.103465 · Cited by 1
Research on Compiler Fuzzing Based on Syntax-semantics Dual-Dimensional Classification
Wang, S., Han, L., Chen, M., & Li, H. (2025) · International Conference on Electronic Information Engineering and Computer Communication (EIECC) · doi:10.1109/eiecc67963.2025.11409518 · Cited by 1
“Csmith [1] randomly generates test programs based on the probabilistic grammar of the C language and has discovered more than 400 compiler errors; the EMI method proposed by Le [2] et al. generates equivalent programs through code insertion and deletion.”
FLAT: Formal Languages as Types
Zhu, F., & Zeller, A. (2026) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3799978
“CSmith [25] generates random C programs from a subset of the C grammar with hand-crafted generators, which detected hundreds of correctness bugs in mainstream C compilers like GCC and LLVM. LangFuzz [12] enables black-box fuzzing based on a CFG, and discovers security issues on the Mozilla…”
Formal Analysis-Based Vulnerability Discovery Methods for TLS 1.2 ProtocolsPreprint
Yu, T., & Jiang, R. (2026) · SSRN Electronic Journal · doi:10.2139/ssrn.6388942
UpgradeShield: Detecting logic-state in-consistencies in smart contract upgrades
Li, W., Su, Y., Nan, Y., Ning, K., Zhang, J., Wu, J., & Zheng, Z. (2026) · Automated Software Engineering · doi:10.1007/s10515-026-00603-2
“In the context of software reliability, tools like Csmith (Yang et al. 2011) generate randomized test cases and compile them using different compilers— differences in output signal potential implementation flaws.”
Cir-Fuzzer: Automated Generation of Diverse Circuit Schematics for EDA Tool Chain Defect Detection
Li, M., Li, H., Wang, S., Ma, Q., Zhan, F., & Guo, S. (2026) · ACM Transactions on Design Automation of Electronic Systems · doi:10.1145/3803420
“Mutation operations typically focus on program structures that are independent of the given input, while test inputs are provided by high-quality random program generators such as Csmith [32], effectively enhancing test diversity and coverage.”
Etna: An evaluation platform for property-based testing
Keleş, A., Shi, J., Kamath, N., Liu, T. N., Mert, C., Goldstein, H., Pierce, B. C., & Lampropoulos, L. (2026) · Journal of Functional Programming · doi:10.46298/jfp.17867
“For yet sparser preconditions, such as C programs with no undefined behaviors [Yang et al. 2011], the approach is hopeless.”
Compiler optimisations and relaxed memory consistency models
Morisset, R. (2017) · theses.fr (ABES) · doi:10.70675/5c9ea897z1b59z4f1bza9d9z9019d5a87c13
Verification of a Concurrent Garbage Collector
Zakowski, Y. (2017) · theses.fr (ABES) · doi:10.70675/17cadd9fzfc41z474ez9d5az4268292af437 · Cited by 1
Low-cost memory analyses for efficient compilers
Kammoun, M. M. (2017) · theses.fr (ABES) · doi:10.70675/c67e8053z267fz4ae3zab50ze739326ec124
Vers la compilation vérifiée de Sea of Nodes : propriétés et raisonnement sémantiques
de Retana, Y. F. (2018) · theses.fr (ABES) · doi:10.70675/f9ce3bffz5f3cz4aa5zacbdzdfa890f1713b
Verifying constant-time implementations in a verified compilation toolchain
Trieu, A. (2018) · theses.fr (ABES) · doi:10.70675/c041309azf0faz4ae5za91fz3eb6c96c0d82
Beurdouche, B. (2020) · theses.fr (ABES) · doi:10.70675/d6848aaaz6964z4c3ezb276z8aa93e0e7831 · Cited by 5
Optimized and formally-verified compilation for a VLIW processor
Six, C. (2021) · theses.fr (ABES) · doi:10.70675/4ca8962fz96b1z4291zbc7bz64918999dbe3 · Cited by 5
Proof-oriented domain-specific language design for high-assurance software
Merigoux, D. (2021) · theses.fr (ABES) · doi:10.70675/95fceee8z06bbz48ccz8b06z87fb9e672ea8 · Cited by 5
Formal Verification of Just-in-Time Compilation
Barrière, A. (2022) · theses.fr (ABES) · doi:10.70675/bfb1bf73z45cez4651z9900z881984e8c420
Fuzzing in the 2020s : novel approaches and solutions
Fioraldi, A. (2023) · theses.fr (ABES) · doi:10.70675/ccab4797z84b7z4bbdzbe73z40ecb48da494 · Cited by 1
Verified compilation of a synchronous dataflow language with state machines
Pesin, B. (2023) · theses.fr (ABES) · doi:10.70675/39a5d53bzce3fz4517z9ee1z77b5242313f9
VeriEQ: Finding Verilog Simulators and Synthesizers Bugs with Equivalence Circuit Transformation
Yan, Z., Chen, Y., Ma, F., Yu, Z., Shi, D., & Jiang, Y. (2026) · Proceedings of the ACM on Programming Languages · doi:10.1145/3798235
“For instance, Equivalence Modulo Inputs [68] has been successfully used for C/C++ compiler validation by generating program variants that preserve behavior on a fixed input but expose behavioral deviations through divergent outputs.”
Self-citationCLower: Detecting Compiler Pessimization Bugs through Redundant Memory Accesses
Xu, J., Zhang, K., Payer, M., Lu, K., & Mao, B. (2026) · Proceedings of the ACM on Programming Languages · doi:10.1145/3798250
“We build upon Csmith [45], fundamentally extending its random generation workflow to enforce global access restrictions and compute the metadata required for our test oracle.”
Detecting Compiler-Introduced Security Bugs via IR Mutation and Coverage-Guided Fuzzing
Oh, S., & Kim, S. (2026) · European Workshop on System Security · doi:10.1145/3803525.3804981
QEMI: A Quantum Software Stacks Testing Framework via Equivalence Modulo Inputs
Luo, J., Xia, S., Zhang, F., & Zhao, J. (2026) · Lecture notes in computer science · doi:10.1007/978-3-032-22774-4_8 · Cited by 9
NSGen: A Template-Based Framework to Find Bugs in Computer-Aided Engineering Tools
Li, X., Zou, P., Liu, H., Guo, S., Ren, Z., & Jiang, H. (2026) · IEEE Transactions on Software Engineering · doi:10.1109/tse.2026.3687867
“NSGen is designed as a domain-specific test case generator like Csmith [31], VeriSmith [32], and SLforge [33].”
CoverFuzz: A Coverage‐Guided and General‐Purpose Fuzzing Framework
Lin, R., Wang, R., Xu, X., Long, G., & Zhang, D. (2026) · Journal of Software Evolution and Process · doi:10.1002/smr.70122
OptFuzz: Enhancing Compiler Testing via LLM-Powered Compilation Option Generation
Huang, Y. N., Yang, Y. W., Sun, M., Wu, J., Li, Q., Lu, Z., & Zhou, Y. (2026) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3817602 · Cited by 2
“Inthelast two decades, substantial research efforts have been devoted to compiler testing to improve compiler quality [4, 6, 7, 19, 32, 36, 41, 63, 82, 87].”
Towards Removing Undef Values from LLVM IR
Lobo, P., McIver, J., Mitenkov, G., Lee, J., Sundararajah, K., & Lopes, N. P. (2026) · Proceedings of the ACM on Programming Languages · doi:10.1145/3808250
“Because of the non-intuitive semantics of undef , which makes many innocent-looking optimizations unsound, undef has been a persistent source of bugs in LLVM [28, 47, 55, 61].”
Enumerating Ill-Typed Programs for Testing Type Analyzers
Sotiropoulos, T., & Su, Z. (2026) · Proceedings of the ACM on Programming Languages · doi:10.1145/3808320
“Testing of program analysis/verification: Cuoq et al. [11] and GrayC [17] leverage Csmith [52] and coverage-guided mutations, respectively, to test static analyses in Frama-C.”
Interpreter Memory Safety via Differential Fuzzing with a CHERI on Top
Feng, K., Wang, H., Singer, J., & Wang, Z. (2026) · ACM SIGPLAN International Symposium on Memory Management (ISMM) · doi:10.1145/3814942.3816133
Rinard, M. (2026) · doi:10.1145/3819802.3820579
“I anticipate that the processes, software structures, and rationales presented in this paper will be useful in similar development efforts.”
Bendrissou, B., Donaldson, A. F., & Cadar, C. (2026) · Proceedings of the ACM on software engineering. · doi:10.1145/3832229
“Tools such as Csmith [78], CsmithEdge [32], GrayC [33], and YARP-Gen [51] focus on generating well-formed C programs, free from undefined behaviour, and have been highly effective for testing C compilers.”
LPR+: Diverse Transformations for LLM-Aided Program Reduction
Zhang, Z., Liu, J., Yao, X., & Tian, Y. (2026) · ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH) · doi:10.1145/3837729.3840504
DECODE: Dynamic Exploration for Constraint-Guided Vulnerability Discovery in Deep Learning Operators
Liu, H., Wang, Z., Liu, Z., & Li, W. (2026) · Proceedings of the ACM on software engineering. · doi:10.1145/3808174
CuFuzz: An API-Knowledge-Graph Coverage-Driven Fuzzing Framework for CUDA Libraries
Fan, X., Fang, Y., Jia, P., Liu, Y., Xu, Y., Peng, X., & Zhou, Y. (2026) · Proceedings of the ACM on software engineering. · doi:10.1145/3808170
“CUDASmith[21], CLSmith[27], and CSmith[49] can be traced to the same lineage (as implied by their names), all utilizing the differential testing approach to fuzz NVCC, OpenCL(which can be seen as an open-source alternative to CUDA), and C compilers (such as gcc and clang), respectively.”
ACME: Automated Clause Mapping Engine for Testing Emerging Database Systems
Jiang, Y., Wang, J., Zhang, C., Yap, R. H. C., Liang, Z., & Rigger, M. (2026) · Proceedings of the ACM on software engineering. · doi:10.1145/3797134
Reusing Legacy Code in Wasm: Key Challenges of Compilation and Code Semantics Preservation
Baradaran, S., Huang, L., Raghothaman, M., & Wang, W. (2026) · IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) · doi:10.1109/saner67736.2026.00029 · Cited by 1
“Csmith [70] is a randomized code generation tool that leverages differential testing for bug discovery in C compilers.”
WasmWeaver: A Framework for Runtime-Aware WebAssembly Program Generation with Reinforcement Learning
Müller, K., Mane, S., Wägemann, P., & Franchi, N. (2026) · IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) · doi:10.1109/saner67736.2026.00045 · Cited by 1
“Below, we discuss related program generators, automatic baselines, and prior work on execution reasoning. a) Program Code Generators: Yang et al. introduced Csmith, a seminal generator for stress-testing C compilers [18].”
Random Generation of Small Quantitative Automata for Algorithm Debugging
Dahlsen-Jensen, M. B., & van de Pol, J. (2026) · Lecture notes in computer science · doi:10.1007/978-3-032-30693-7_13
“Random generation to stress-test analysis tools is well-established: compiler testing [13] and SMT solver fuzzing [5] demonstrate that random inputs reliably surface subtle implementation faults.”
FPGA-Accelerated Error Diffusion Halftoning for High-Throughput Wide-Format Industrial Printing
Luo, Q., Zhong, Y., & Kong, C. S. (2026) · Lecture notes in computer science · doi:10.1007/978-3-032-22261-9_22
Beyond Spec Conformance: A Logic for Validating Stakeholder Expectations
Klimis, V. (2026) · ACM/IEEE International Conference on Software Engineering: Companion Proceedings (ICSE-Companion) · doi:10.1145/3786582.3786821
Anh, L. H. N., Luong, H. V. D., & Vũ, V. A. (2026) · Genetic and Evolutionary Computation Conference (GECCO) · doi:10.1145/3795095.3805199 · Cited by 1
Constraint-Driven Fuzzing at Scale with FANDANGO
Amaya, J. A. Z., Smytzek, M., Liggesmeyer, A., Huber, V., & Zeller, A. (2026) · IEEE International Conference on Software Testing, Verification and Validation (ICST) · doi:10.1109/icst69053.2026.00033
“Domain-specific generators like CSMITH [27], TLS -Attacker [28], and MOR-PHEUS [29] handle such requirements, but represent substantial engineering investments.”
GRANDSLAM: Linearly Scalable Model Synthesis
Boll, A. (2026) · IEEE International Conference on Software Testing, Verification and Validation (ICST) · doi:10.1109/icst69053.2026.00058
“Chowdhury et al. [29] developed CyFuzz (generates models up to size of ∼ 35 Blocks), a generative approach, which was inspired by CSmith [36] to fuzz Simulink’s code generator.”
Compilomorphic Fuzzing: Turning a Compiler Against Itself
Klimis, V. (2026) · ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) · doi:10.1145/3803437.3805569
Ensemble Fuzzing with Dynamic Resource Scheduling and Multidimensional Seed Evaluation
Zhao, Y., Wang, S., Wang, J., Hu, X., & Xia, X. (2026) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3834771 · Cited by 2
Metadata
- Authors
- Yang, X., Chen, Y., Eide, E., & Regehr, J.
- Affiliations
- University of Utah (US)
- Venue
- Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation
- Publisher
- ACM
- Published
- 2011-06-04
- Pages
- 283-294
- ISSN
- 1531-7102 (ISSN-L)
- OpenAlex
- W4238083723
- Cited by
- 825
- References
- 23
- Citations by year
- 2026: 71 · 2025: 115 · 2024: 93 · 2023: 88 · 2022: 59 · 2021: 50 · 2020: 58 · 2019: 45 · 2018: 50 · 2017: 40 · 2016: 42 · 2015: 45 · 2014: 24 · 2013: 23 · 2012: 19
- FWCI
- 15.95
- Type
- conference paper
- Language
- en
- Open access
- closed
- Locations
- Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (publishedVersion)
- Topics
- Physical Sciences › Computer Science › Software › Software Testing and Debugging Techniques
- Physical Sciences › Computer Science › Information Systems › Software Engineering Research
- Physical Sciences › Computer Science › Software › Logic, programming, and type systems
- Keywords
- compiler bugs, C compiler, compiler testing, undefined behavior, bug reports
About these checks
Registry, retraction, Cites and statistics results are computed, not judged, with one exception: a printed reference that no index lists is read once by a model before it counts as a citation error. Claims are extracted by a model and kept only when their quote appears verbatim in the text; each cited source is then checked, with a model’s help, for whether it says what the claim relies on. Those verdicts can be wrong — read the claim’s quote and the cited source before relying on one.
Statistics and arithmetic are recomputed, not judged.
Confidence bands are shown only for fields calibrated on our annotated test set. None is calibrated yet, so no band is shown.
What counts as a claim ›How we measure confidence ›How we check this ›
Are you an author, or do you see a problem with this page? Request a review
Data sources
Bibliographic data: Semantic Scholar, OpenAlex, Crossref.
Contains information from the Semantic Scholar Academic Graph Datasets, made available under the ODC Attribution License (ODC-BY 1.0).
Semantic Scholar’s data is described in: Kinney, R., et al. (2023). The Semantic Scholar Open Data Platform. arXiv:2301.10140.