ExeBench-Obfuscated

ExeBench-Obfuscated is a C decompilation dataset for studying neural decompilation under compiler-based code obfuscation. It accompanies the RQ3 experiments in the paper Rethinking Neural Decompilation (ICICS 2026), which investigates whether targeted fine-tuning and generate-then-select inference improve the recovery of obfuscated functions.

The dataset contains reference C functions paired with Ghidra pseudo-code obtained from their obfuscated compiled binaries. It covers four Obfuscator-LLVM (OLLVM) transformations and four compiler optimization levels. The source projects are partitioned between the training and test sets to reduce repository-level leakage.

Dataset Summary

Split	Samples
Train	287,790
Test	74,857
Total	362,647

The available OLLVM transformations are:

• bcf: bogus control flow
• fla: control-flow flattening
• fla+split: control-flow flattening combined with basic-block splitting
• sub: instruction substitution

Each transformation is represented at compiler optimization levels O0, O1, O2, and O3.

Loading the Dataset

Install the Hugging Face Datasets library:

pip install -U datasets

Load both splits:

from datasets import load_dataset

dataset = load_dataset("gautiiii/ExeBench-Obfuscated")
train_dataset = dataset["train"]
test_dataset = dataset["test"]

Data Fields

Each record contains the following fields:

Field	Description
task_id	Stable identifier assigned to the mapped function sample.
func_name	Function name recovered from the source metadata.
c_func	Reference C source function associated with the obfuscated binary and used as the target output.
input_asm_prompt	Ghidra pseudo-code recovered from the corresponding obfuscated binary and supplied as model input.
type	Compiler optimization level (O0, O1, O2, or O3; some tooling may display these with a leading hyphen).
obf_pass	Applied OLLVM transformation (bcf, fla, fla+split, or sub).
path	Source-repository path associated with the original function.
c_test	C test harness used for functional evaluation.
real_io_pairs	Structured input/output examples associated with the function.
real_iospec	Serialized input/output specification used by the evaluation pipeline.

Dataset Construction

The corpus was derived from ExeBench functions. Each function was compiled under combinations of the four OLLVM transformations and four optimization levels, after which Ghidra was used to recover pseudo-code from the resulting binaries. The generated records were mapped back to their source repository and ExeBench execution metadata. Empty or trivial function records were removed, and the remaining data were split by source repository rather than by individual function. This prevents functions from the same repository from being distributed across the training and test partitions.

The final records retain the reference function, decompiler input, optimization and obfuscation labels, source metadata, and available functional test information. Additional filtering for the paper's model experiments, including the 4096-token context limit and the fixed 1,000-sample RQ3 test subset, is performed by the accompanying experiment code rather than by this Hub dataset.

Intended Use

The dataset is intended for research on:

• neural decompilation of obfuscated binaries;
• robustness to compiler optimization and OLLVM transformations;
• decompilation model fine-tuning;
• candidate generation and selection; and
• static and functional evaluation of recovered C code.

It is not intended to establish that a model can deobfuscate every binary or generalize to packing, virtualization, self-modifying code, or obfuscation families not represented here.

Licensing and Provenance

The dataset is derived from functions associated with multiple upstream ExeBench source repositories. Those repositories may use different licenses. The other license tag therefore does not grant a new uniform license over all underlying source code. Users are responsible for consulting the relevant upstream repository and its license before redistributing or using individual records. The path field is retained to support provenance analysis.

Citation

If you use this dataset, please cite the accompanying paper:

Rethinking Neural Decompilation. ICICS 2026.

The final proceedings BibTeX entry and DOI should be added here when they are available.

This dataset is derived from ExeBench. Please also cite the original ExeBench publication:

@inproceedings{10.1145/3520312.3534867,
  author = {Armengol-Estap\'{e}, Jordi and Woodruff, Jackson and
            Brauckmann, Alexander and Magalh\~{a}es, Jos\'{e} Wesley de Souza
            and O'Boyle, Michael F. P.},
  title = {ExeBench: An ML-Scale Dataset of Executable C Functions},
  year = {2022},
  isbn = {9781450392730},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3520312.3534867},
  doi = {10.1145/3520312.3534867},
  booktitle = {Proceedings of the 6th ACM SIGPLAN International Symposium
               on Machine Programming},
  pages = {50--59},
  numpages = {10},
  keywords = {Code Dataset, Program Synthesis, Mining Software Repositories,
              C, Machine Learning for Code, Compilers},
  location = {San Diego, CA, USA},
  series = {MAPS 2022}
}

Reproducibility

The training, evaluation, and candidate-selection scripts are available in the companion repository:

https://github.com/UzL-ITS/rethinking-neural-decompilation

The RQ3 README in that repository documents the fine-tuning and evaluation pipeline used in the paper.