Cover Image

Mut4All: Fuzzing Compilers via LLM-Synthesized Mutators Learned from Bug Reports

Fuente: arXiv

Saved in:

Bibliographic Details
Main Authors:	Wang, Bo, Wang, Pengyang, Chen, Chong, Deng, Ming, Shi, Jieke, Sun, Qi, Yang, Chengran, Lin, Youfang, Yang, Zhou, Chen, Junjie, Sun, Jun, Lo, David
Format:	Preprint
Published:	2025
Subjects:	Software Engineering
Online Access:	Acceder al recurso
Tags:	Add Tag No Tags, Be the first to tag this record!

Similar Items

Bug Histories as Sources of Compiler Fuzzing Mutators
by: Liu, Lingjun, et al.
Published: (2025)

Boosting LLMs for Mutation Generation
by: Wang, Bo, et al.
Published: (2026)

AgentSZZ: Teaching the LLM Agent to Play Detective with Bug-Inducing Commits
by: Lyu, Yunbo, et al.
Published: (2026)

Think Like Human Developers: Harnessing Community Knowledge for Structured Code Reasoning
by: Yang, Chengran, et al.
Published: (2025)

Compiling Code LLMs into Lightweight Executables
by: Shi, Jieke, et al.
Published: (2026)

ACECode: A Reinforcement Learning Framework for Aligning Code Efficiency and Correctness in Code Language Models
by: Yang, Chengran, et al.
Published: (2024)

Fuzzing MLIR Compilers with Custom Mutation Synthesis
by: Limpanukorn, Ben, et al.
Published: (2024)

Once4All: Skeleton-Guided SMT Solver Fuzzing with LLM-Synthesized Generators
by: Sun, Maolin, et al.
Published: (2025)

Improving Compiler Bug Isolation by Leveraging Large Language Models
by: Qi, Yixian, et al.
Published: (2025)

DESIL: Detecting Silent Bugs in MLIR Compiler Infrastructure
by: Suo, Chenyao, et al.
Published: (2025)

A Systematic Exploration of Mutation‐Based Fault Localization Formulae
by: Bo Wang, et al.
Published: (2024)

Characterizing and Mitigating False-Positive Bug Reports in the Linux Kernel
by: Tian, Jiashuo, et al.
Published: (2026)

Synthesizing Efficient and Permissive Programmatic Runtime Shields for Neural Policies
by: Shi, Jieke, et al.
Published: (2024)

Towards Understanding the Bugs in Solidity Compiler
by: Ma, Haoyang, et al.
Published: (2024)

MirrorFuzz: Leveraging LLM and Shared Bugs for Deep Learning Framework APIs Fuzzing
by: Ou, Shiwen, et al.
Published: (2025)

LLM-Powered Silent Bug Fuzzing in Deep Learning Libraries via Versatile and Controlled Bug Transfer
by: Zhang, Kunpeng, et al.
Published: (2026)

A Comprehensive Study on Large Language Models for Mutation Testing
by: Wang, Bo, et al.
Published: (2024)

Hidden Licensing Risks in the LLMware Ecosystem
by: Wang, Bo, et al.
Published: (2026)

Uncovering Business Logic Bugs via Semantics-Driven Unit Test Generation
by: Yang, Chen, et al.
Published: (2026)

TestDecision: Sequential Test Suite Generation via Greedy Optimization and Reinforcement Learning
by: Wang, Guoqing, et al.
Published: (2026)

Curiosity-Driven Testing for Sequential Decision-Making Process
by: He, Junda, et al.
Published: (2025)

Efficient and Green Large Language Models for Software Engineering: Literature Review, Vision, and the Road Ahead
by: Shi, Jieke, et al.
Published: (2024)

BugLens: Leveraging Bisection for Lightweight Compiler Bug Deduplication
by: Zhou, Xintong, et al.
Published: (2025)

Finding Memory Leaks in C/C++ Programs via Neuro-Symbolic Augmented Static Analysis
by: Huang, Huihui, et al.
Published: (2026)

ClozeMaster: Fuzzing Rust Compiler by Harnessing LLMs for Infilling Masked Real Programs
by: Gao, Hongyan, et al.
Published: (2026)

Executing as You Generate: Hiding Execution Latency in LLM Code Generation
by: Sun, Zhensu, et al.
Published: (2026)

MutDafny: A Mutation-Based Approach to Assess Dafny Specifications
by: Amaral, Isabel, et al.
Published: (2025)

Token Sugar: Making Source Code Sweeter for LLMs through Token-Efficient Shorthand
by: Sun, Zhensu, et al.
Published: (2025)

Interleaved Learning and Exploration: A Self-Adaptive Fuzz Testing Framework for MLIR
by: Sun, Zeyu, et al.
Published: (2025)

PenForge: On-the-Fly Expert Agent Construction for Automated Penetration Testing
by: Huang, Huihui, et al.
Published: (2026)

Finding Safety Violations of AI-Enabled Control Systems through the Lens of Synthesized Proxy Programs
by: Shi, Jieke, et al.
Published: (2024)

ParityFuzz: Finding Inconsistencies across Solidity Compilers via Fine-Grained Mutation and Differential Analysis
by: Su, Bowei, et al.
Published: (2026)

TENSURE: Fuzzing Sparse Tensor Compilers (Registered Report)
by: Mahathevan, Kabilan, et al.
Published: (2026)

Low-Cost and Comprehensive Non-textual Input Fuzzing with LLM-Synthesized Input Generators
by: Zhang, Kunpeng, et al.
Published: (2025)

RVISmith: Fuzzing Compilers for RVV Intrinsics
by: He, Yibo, et al.
Published: (2025)

Ecosystem of Large Language Models for Code
by: Yang, Zhou, et al.
Published: (2024)

Understanding Typing-Related Bugs in Solidity Compiler
by: Li, Lantian, et al.
Published: (2025)

Selecting Initial Seeds for Better JVM Fuzzing
by: Gao, Tianchang, et al.
Published: (2024)

Isolating Compiler Bugs through Compilation Steps Analysis
by: Liu, Yujie, et al.
Published: (2025)

Peeling Off the Cocoon: Unveiling Suppressed Golden Seeds for Mutational Greybox Fuzzing
by: Qian, Ruixiang, et al.
Published: (2026)