| --- |
| 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](https://huggingface.co/datasets/jordiae/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 |
|
|
| ```python |
| 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: |
|
|
| ```python |
| 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): |
|
|
| ```python |
| 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: |
|
|
| ```bibtex |
| @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} |
| } |
| ``` |
|
|
