Allomgie/ido5.3-token-reduced-c

IDO 5.3 Synthetic C Dataset — Dead-Code Reduced

Compiler-verified synthetic C code for MIPS/N64 decompilation research, cleaned through a 4-stage dead-code reduction pipeline using the IDO 5.3 compiler as an oracle.

---

What Is This Dataset?

This dataset contains synthetically generated C source files (plus their corresponding headers) that are guaranteed to compile to valid MIPS-II assembly with the IDO 5.3 compiler — the same toolchain used for Nintendo 64 and SGI MIPS development in the late 1990s.

Every file has been iteratively processed through a custom 4-stage dead-code reduction pipeline until no further reductions were possible. The pipeline uses the IDO compiler itself as an oracle: code is only removed if the resulting MIPS assembly remains binary-identical to the original.

Intended use: Training data for LLM-based MIPS-to-C decompilation models. The cleaning process ensures the model learns from semantically meaningful code rather than noise.

---

Dataset Structure

Each row contains:

Field	Type	Description
id	int	Unique identifier
generator	string	Source engine: YARPGen, csmith, or csmith (with AST mutation)
c_code	string	The reduced C source file
header_code	string	The corresponding header file (struct definitions, extern declarations)

Generator Breakdown

Generator	Engine	Description
csmith	Csmith 2.3.0	Single-function C files with controlled complexity. Csmith parameters tuned for MIPS: --no-longlong, --no-math64, --no-arrays, --max-funcs 1.
csmith	Csmith + pycparser AST mutation	Same base as above, but with post-generation AST transformations: for loops converted to do-while + switch-case constructs via rand_state % n dispatching. These patterns appear frequently in real decompiled N64 code.
YARPGen	YARPGen (patched)	Multi-function files with pointer arithmetic and nested structs. A syntax firewall filters non-MIPS-compatible constructs. Requires a patched binary for IDO 5.3 compatibility.

---

Dead-Code Reduction Pipeline

Every file was processed through a 4-stage pipeline, iterating the entire sequence until convergence (no further changes across all stages). Each stage uses the IDO 5.3 compiler as an oracle:

C source → gcc -E → IDO cc (-O2 -mips2 -G0) → MIPS .o
→ objdump -d (.text) + objdump -s (.rodata, .data, .bss)
→ stack/symbol normalization → MD5 hash
→ compare against baseline

A transformation is accepted only if the assembly hash remains identical.

Stage 1 — AST-Level Delta Debugging

Parses the C source into an AST (via pycparser + gcc -E) and systematically removes nodes, recompiling after each removal.

Phase 1 — Top-level nodes: Removes unreferenced global variables, forward declarations, and dead function definitions.

Phase 2 — Function bodies: Iterates through statements in function bodies (including nested blocks within if, while, for, switch). Removes individual statements, dead stores, and empty blocks.

Header filtering: Uses gcc -E line markers (node.coord.file) to distinguish between nodes originating from the source file vs. injected header declarations — preventing phantom-node cycles where header-injected extern declarations are endlessly "removed" and regenerated.

Stage 2 — Semantic Expression Cleanup

Operates at the expression level within the AST. Applies 9 simplification rules, each validated against the compiler oracle:

Rule	Pattern	Result
add_zero	x + 0, 0 + x, x - 0	x
or_xor_zero	x | 0, x ^ 0	x
mul_div_one	x * 1, x / 1	x
shift_zero	x << 0, x >> 0	x
double_cast	(u32)(u32)x	(u32)x
comma_drop	(a, b) where a is pure	b
ternary_same	cond ? a : a	a
null_eq_null	(void*)0 == (void*)0	1
addr_eq_self	&x == &x	1

Stage 3 — Token-Level Reduction

A Python reimplementation of C-Reduce, optimized for the IDO pipeline with a TCC fast-reject guard (syntax check before invoking IDO, saving ~70% of compiler calls) and a global MD5-based compile cache.

Phase 0 (One-Shots): includes — remove unused includes; blank — whitespace normalization.

Phase 1 (Enablers): regex_atoms — literal simplification; balanced_parens_only / balanced_parens_zero — redundant parenthesis removal; ternary_modus_b / ternary_modus_c — ternary branch collapse.

Phase 2 (Structure): lines — binary-search line-chunk removal; balanced_curly_empty — empty {} block removal; balanced_remove_curly / balanced_remove_parens / balanced_remove_square — balanced-pair elimination; peep_while — while-loop simplification.

Phase 3a (Sub-Expressions): peep_subexpr — replace complex sub-expressions with 0 or 1.

Phase 3b (Arguments): peep_args — function argument reduction (remove trailing args).

Phase 4 (Cleanup): Final pass of parenthesis removal, brace cleanup, and whitespace normalization.

Stage 4 — Clang-Delta Hybrid

Combines fast Python passes (TCC-guarded) with selective invocation of clang_delta for transformations that require full semantic analysis.

Python passes: min_max_identity — min(x,x) → x; ternary_identical — cond ? a : a → a; simplify-if — constant-condition if/else collapse; remove-unused-var — dead local variable elimination; remove-unused-func — unreferenced function removal; simplify-comma — comma operator reduction; neutralize-calls — replace dead calls with 0 or ;; return-void — return type relaxation; dead_store — unused global assignment removal.

Clang-delta pass (conditional): aggregate-to-scalar — simplify struct/array accesses. Only invoked when a gatekeeper analysis detects structs or arrays in the source.

---

Design Decision: Why Some Dead Code Remains

A small fraction of files (~0.3%) contain syntactically unreachable code — statements after continue, return, break, or goto that the IDO compiler never executes. This code is intentionally preserved because removing it changes the assembly output.

IDO 5.3 considers unreachable code during register allocation and stack layout. Removing dead branches causes the optimizer to reassign registers and resize the stack frame, producing functionally equivalent but binary-different output. Here is a concrete example:

Example: func_1 (NOP padding from dead code)

C source (after full pipeline):

void func_1() {
  // ... live code ...
  BSP_Ser_Printf(0, "this is a test\n");
  continue;
  // Everything below is unreachable:
  if(0) continue;
  {
    memcpy();
    SEM_WAIT_FCC();
    SetNav_g_roll(Char2Float());
    // ... 10 more dead calls ...
    SEM_POST_FCC();
  }
}

Assembly with dead code present (original):

    b       .L00000500          # unconditional branch (loop restart)
    lw      $gp, 0x20($sp)     # branch delay slot
    nop                         # ┐
    nop                         # │ 5 NOPs — padding generated
    nop                         # │ by IDO for the dead block
    nop                         # │
    nop                         # ┘
    lw      $ra, 0x24($sp)     # function epilog

Stack frame: -0x70, registers saved: $s0, $s1. Function size: 0x114 bytes.

Assembly with dead code removed:

    b       .L0000050C          # unconditional branch
    lw      $gp, 0x20($sp)     # branch delay slot
    nop                         # ┐ only 2 NOPs
    nop                         # ┘ (alignment padding)
    lw      $ra, 0x24($sp)     # function epilog

Stack frame: -0x68, registers saved: $s0, $s1, $s2 (IDO now caches a string address in a callee-saved register). Function size: 0x118 bytes.

The dead code's presence causes IDO to allocate a larger stack frame and skip a register optimization. Removing it produces functionally identical but structurally different assembly — which breaks the hash match. The pipeline correctly identifies this and preserves the dead code.

This is by design. The dataset is intended for training models to predict what the IDO compiler actually produces, including its quirks. A model trained on artificially cleaned code would learn patterns that do not match real compiler output.

---

How to Load

from datasets import load_dataset

ds = load_dataset("your-username/ido53-synthetic-c-dataset")

# Access a sample
sample = ds["train"][0]
print(sample["generator"])    # e.g. "csmith"
print(sample["c_code"])       # reduced C source
print(sample["header_code"])  # corresponding header

---

Provenance and Licensing

Generated code: All C source files were produced by Csmith (BSD license) and YARPGen (Apache 2.0 license) — both open-source program generators. No handwritten or proprietary source code is included in this dataset.

Pipeline: The dead-code reduction pipeline is released under the MIT license.

IDO 5.3: The compiler used as the oracle is proprietary software from SGI/Nintendo. It is not included in this dataset. The dataset contains only the C source code and headers — no compiler binaries, assembly output, or object files.

---

Known Limitations

• IDO-specific: The reduction is tailored to IDO 5.3 optimization behavior. Code reduced for IDO may not be minimal for GCC or Clang.
• pycparser limits: Files requiring full C99 support (VLAs, complex initializers) may not be fully processed by Stages 1 and 2. Stages 3 and 4 operate at the token level and handle these cases.
• Unreachable code (~0.3% of files): As described above, some dead code is preserved because IDO's optimizer is sensitive to its presence.
• No assembly included: The dataset contains only C source and headers. Assembly output is not distributed due to the proprietary nature of IDO's output format.