Datasets:

davish007
/

ExeBench-FHD

license: mit
pretty_name: ExeBench-FHD
language:
  - code
task_categories:
  - text-generation
tags:
  - decompilation
  - binary-analysis
  - reverse-engineering
  - assembly
  - c
size_categories:
  - 1M<n<10M
configs:
  - config_name: default
    data_files:
      - split: train_synth_compilable
        path: train_synth_compilable-*.parquet
      - split: train_real_compilable
        path: train_real_compilable-*.parquet
      - split: train_synth_simple_io
        path: train_synth_simple_io-*.parquet
      - split: train_real_simple_io
        path: train_real_simple_io-*.parquet
      - split: train_synth_rich_io
        path: train_synth_rich_io-*.parquet
      - split: train_not_compilable
        path: train_not_compilable-*.parquet
      - split: valid_synth
        path: valid_synth-*.parquet
      - split: valid_real
        path: valid_real-*.parquet
      - split: test_synth
        path: test_synth-*.parquet
      - split: test_real
        path: test_real-*.parquet

ExeBench-FHD

ExeBench-FHD is an audited and extended version of ExeBench, a dataset of executable C functions used to train and evaluate neural decompilers. Auditing all 6.56M functions in ExeBench's ten splits turned up nine data-quality problems. In three of them, the function's C code cannot be recovered from its assembly alone:

P1, parameter order: x86-64, ARM32 and ARM64 pass integer/pointer and floating-point parameters in separate registers, so the callee's assembly does not show how mixed parameters are ordered.
P2, unused parameters: from -O1 up, an unused parameter leaves no trace in the callee's assembly.
P3, data sections: constants live in .rodata, .data or .bss, and the function's code only refers to them by address.

ExeBench-FHD keeps the 16 columns that load_dataset("jordiae/exebench") returns, with the same names, types and values, and adds 16: the assembly of a call to the function (func_call, P1), wrappers that test a reduced-arity decompilation (opt_*_exe_wrapper, P2), data-section contents (data_section, P3), disassembly of the linked binary on four architectures at five optimization levels (objdump_asm), and five warning flags. Problematic records are flagged rather than removed, so ExeBench-FHD works as a drop-in replacement for ExeBench: code written against jordiae/exebench runs unchanged, and users choose what to filter.

Splits

Split	Rows
`train_synth_compilable`	4,159,373
`train_real_compilable`	885,074
`train_not_compilable`	715,700
`train_synth_simple_io`	640,116
`train_synth_rich_io`	107,250
`train_real_simple_io`	42,769
`valid_synth`	5,000
`valid_real`	2,133
`test_synth`	5,000
`test_real`	2,134
Total	6,564,549

The splits and their rows are ExeBench's own; ExeBench-FHD only adds columns.

Loading

from datasets import load_dataset

# Pass data_files so only that split's shards are downloaded
# (split= alone downloads every split before selecting one).
test = load_dataset("<anonymous-repo-id>", data_files="test_real-*.parquet", split="train")
# The training splits are large - stream them rather than downloading:
train = load_dataset("<anonymous-repo-id>", split="train_real_compilable", streaming=True)

All columns are typed Arrow columns; no decoding is needed for the ExeBench-FHD fields:

row = test[0]
row["objdump_asm"]["x86-64"]["O2"]     # disassembly of the function, x86-64, -O2
row["data_section"]["ARM64"]["O2"]     # data the function reads, ARM64, -O2
row["func_call"]["ARM32"]["O3"]        # call site of the function, ARM32, -O3

As in ExeBench, real_iospec / synth_iospec and each I/O-pair value are JSON strings (json.loads them).

The warning flags are plain booleans. For example, the rows with none of the four data-quality flags set (63.85% of the corpus):

clean = test.filter(lambda r: not (r["dummy_udt"] or r["truncated_funcs"]
                                   or r["no_return"] or r["trivial_function"]))

Fields

Architectures are x86, x86-64, ARM32, ARM64; optimization levels are O0, O1, O2, O3, Os. Per-architecture fields are structs {arch: {level: str}} with all 20 entries present; an entry is null when it does not apply or could not be produced, and the companion *_errors field explains why. func_call and func_call_errors are null as a whole when no call site was generated (see func_call_skip_reason).

Added by ExeBench-FHD (16)

Field	Type	Description
`objdump_asm`	`{arch: {level: str}}`	objdump disassembly of the function from the linked binary (`static`/`inline` stripped before compiling, so optimized builds are not empty).
`objdump_asm_errors`	`{arch: {level: str}}`	Why an `objdump_asm` entry is empty; `null` = no error.
`func_call`	`{arch: {level: str}}`	Assembly of the call site in a driver `main` that calls the function (renamed `func0`) with arguments derived from `argc`/`argv`, so the compiler cannot fold them away. Shows how each argument is passed (P1).
`func_call_errors`	`{arch: {level: str}}`	Why a `func_call` entry is empty; `null` = no error.
`func_call_skip_reason`	str \| null	Why no call site was generated: e.g. `unsupported_param_type:<category>` (struct/union by value, SIMD, `_Complex`), `fname_is_main`, `all_architectures_failed`. `null` = attempted.
`data_section`	`{arch: {level: str}}`	Contents of the data sections (`.rodata`, `.data`, `.bss`, …) the function references, from the same binary as `objdump_asm` (P3). Empty when the function reads no such data.
`data_section_errors`	`{arch: {level: str}}`	Why a `data_section` entry could not be produced; `null` = no error.
`unused_param`	bool	The function has a parameter it never uses, which optimized assembly drops (P2).
`opt_real_exe_wrapper`	str \| null	`real_exe_wrapper` rewritten to call the function without its unused parameters, so a reduced-arity decompilation can be executed and tested. Set when `unused_param` is true.
`opt_real_exe_wrapper_error`	str \| null	Why the wrapper could not be adapted.
`opt_angha_exe_wrapper`	str \| null	Same, for `synth_exe_wrapper` (synthetic I/O).
`opt_angha_exe_wrapper_error`	str \| null	Why the wrapper could not be adapted.
`no_return`	bool	Non-`void` return type, but no `return` statement.
`dummy_udt`	bool	A dependency replaces a real user-defined type with a `{int dummy;}` placeholder.
`trivial_function`	bool	Trivial body: empty, a bare `return`, or at most two non-blank lines.
`truncated_funcs`	bool	`func_def` is truncated upstream: its return type (or part of its name) is missing although `func_head` has it. K&R implicit-`int` definitions are not flagged.

ExeBench fields (16, unchanged)

These are the columns of load_dataset("jordiae/exebench"), in the same order and with the same types.

Field	Type	Description
`path`	str	`owner/repo/path/to/file.c` of the function's GitHub source.
`func_def`	str	C definition of the function.
`func_head`	str	Function header as extracted from the source.
`func_head_types`	str	Function header with each parameter's type and name.
`fname`	str	Function name.
`signature`	list[str]	Return type, then the parameter types.
`asm`	list[{`target`, `code`}]	Compiler-generated assembly of the function per target (`{real\|angha}_gcc_{x86\|arm}_{O0\|O3\|Os}`).
`synth_deps` / `real_deps`	str	Dependencies (types, globals, prototypes): synthesized (AnghaBench-style) / from the original repository.
`synth_io_pairs` / `real_io_pairs`	list[{`input`, `output`, `dummy_funcs`, `dummy_funcs_seed`}]	Input/output examples; `input` and `output` are lists of {`var`, `value`} with `value` JSON-encoded.
`synth_exe_wrapper` / `real_exe_wrapper`	str \| null	C++ harness that runs the function on I/O examples.
`ref`	str	Git ref (branch) of that repository, e.g. `master`.
`synth_iospec` / `real_iospec`	str (JSON)	I/O specification used to build the harness.

real_* fields use the dependencies from the original repository; synth_* fields use synthesized ones. (opt_angha_exe_wrapper* keeps the raw ExeBench angha prefix but pairs with synth_exe_wrapper.)

Licensing

ExeBench-FHD follows ExeBench's licensing. All C functions keep the original license of their GitHub repository (identified by path and ref). The fields ExeBench-FHD adds are released under the MIT license, as are ExeBench's own contributions. The code that produces them is released under Apache-2.0.

Citation

ExeBench-FHD is under anonymous review; its citation will be added here. Please also cite ExeBench:

@inproceedings{armengol2022exebench,
  title     = {ExeBench: an ML-scale dataset of executable C functions},
  author    = {Armengol-Estap{\'e}, Jordi and Woodruff, Jackson and Brauckmann, Alexander and
               de Souza Magalh{\~a}es, Jos{\'e} Wesley and O'Boyle, Michael F. P.},
  booktitle = {Proceedings of the 6th ACM SIGPLAN International Symposium on Machine Programming},
  pages     = {50--59},
  year      = {2022},
  doi       = {10.1145/3520312.3534867}
}