Cover Image

ClozeMaster: Fuzzing Rust Compiler by Harnessing LLMs for Infilling Masked Real Programs

Fuente: arXiv

Saved in:

Bibliographic Details
Main Authors:	Gao, Hongyan, Yang, Yibiao, Sun, Maolin, Wu, Jiangchang, Zhou, Yuming, Xu, Baowen
Format:	Preprint
Published:	2026
Subjects:	Software Engineering
Online Access:	Acceder al recurso
Tags:	Add Tag No Tags, Be the first to tag this record!

Similar Items

DebugHarness: Emulating Human Dynamic Debugging for Autonomous Program Repair
by: Sun, Maolin, et al.
Published: (2026)

Using a Sledgehammer to Crack a Nut? Revisiting Automated Compiler Fault Isolation
by: Yang, Yibiao, et al.
Published: (2025)

Isolating Compiler Faults via Multiple Pairs of Adversarial Compilation Configurations
by: Li, Qingyang, et al.
Published: (2025)

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

PanicFI: An Infrastructure for Fixing Panic Bugs in Real-World Rust Programs
by: Ni, Yunbo, et al.
Published: (2024)

PALM: Synergizing Program Analysis and LLMs to Enhance Rust Unit Test Coverage
by: Chu, Bei, et al.
Published: (2025)

C2RustXW: Program-Structure-Aware C-to-Rust Translation via Program Analysis and LLM
by: Yan, Yanyan, et al.
Published: (2026)

Harnessing LLMs for Document-Guided Fuzzing of OpenCV Library
by: Duan, Bin, et al.
Published: (2025)

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

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

Agentic Harness for Real-World Compilers
by: Zheng, Yingwei, et al.
Published: (2026)

deepSURF: Detecting Memory Safety Vulnerabilities in Rust Through Fuzzing LLM-Augmented Harnesses
by: Androutsopoulos, Georgios, et al.
Published: (2025)

Data-driven Test Generation for Fuzzing AI Compiler
by: Shen, Qingchao
Published: (2026)

Evolutionary Generative Fuzzing for Differential Testing of the Kotlin Compiler
by: Georgescu, Calin, et al.
Published: (2024)

Decompiling Rust: An Empirical Study of Compiler Optimizations and Reverse Engineering Challenges
by: Zhou, Zixu
Published: (2025)

Program Environment Fuzzing
by: Meng, Ruijie, et al.
Published: (2024)

Mut4All: Fuzzing Compilers via LLM-Synthesized Mutators Learned from Bug Reports
by: Wang, Bo, et al.
Published: (2025)

Towards Translating Real-World Code with LLMs: A Study of Translating to Rust
by: Eniser, Hasan Ferit, et al.
Published: (2024)

Fearless Unsafe. A More User-friendly Document for Unsafe Rust Programming Base on Refined Safety Properties
by: Cui, Mohan, et al.
Published: (2024)

RustMap: Towards Project-Scale C-to-Rust Migration via Program Analysis and LLM
by: Cai, Xuemeng, et al.
Published: (2025)

MicroFuzz: An Efficient Fuzzing Framework for Microservices
by: Di, Peng, et al.
Published: (2024)

HarnessAgent: Scaling Automatic Fuzzing Harness Construction with Tool-Augmented LLM Pipelines
by: Yang, Kang, et al.
Published: (2025)

Harnessing Large Language Models for Seed Generation in Greybox Fuzzing
by: Shi, Wenxuan, et al.
Published: (2024)

WITNESS: A lightweight and practical approach to fine-grained predictive mutation testing
by: Lu, Zeyu, et al.
Published: (2025)

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

Program Feature-based Fuzzing Benchmarking
by: Miao, Miao
Published: (2025)

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

From LLMs to Agents in Programming: The Impact of Providing an LLM with a Compiler
by: Kjellberg, Viktor, et al.
Published: (2026)

Quality-Assured Fuzz Harness Generation via the Four Principles Framework
by: Sheng, Ze, et al.
Published: (2026)

When Fuzzing Meets LLMs: Challenges and Opportunities
by: Jiang, Yu, et al.
Published: (2024)

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

CompileAgent: Automated Real-World Repo-Level Compilation with Tool-Integrated LLM-based Agent System
by: Hu, Li, et al.
Published: (2025)

Fuzzing Microservices: A Series of User Studies in Industry on Industrial Systems with EvoMaster
by: Zhang, Man, et al.
Published: (2022)

Characterizing Unsafe Code Encapsulation In Real-world Rust Systems
by: Rao, Zihao, et al.
Published: (2024)

MISRust: Mapping MISRA-C++ Coding Guidelines to the Rust Programming Language
by: Molz, Marius, et al.
Published: (2026)

MASFuzzer: Fuzz Driver Generation and Adaptive Scheduling via Multidimensional API Sequences
by: Liu, Xingyu, et al.
Published: (2026)

LLMs as Compiler for Arabic Programming Language
by: Sibaee, Serry, et al.
Published: (2024)

Coverage-Guided Multi-Agent Harness Generation for Java Library Fuzzing
by: Loose, Nils, et al.
Published: (2026)

An Empirical Study of Fuzz Harness Degradation
by: Görz, Philipp, et al.
Published: (2025)

Does Programming Language Matter? An Empirical Study of Fuzzing Bug Detection
by: Shirai, Tatsuya, et al.
Published: (2026)