Job Description

Project Overview We are building a custom RISC-V ISA-compatible CPU that benefits when application binaries are transformed to create two “internal” software threads inside one OS thread. To enable this, we need a binary rewriting or JIT tooling solution that can rewrite RISC-V binaries at the function/loop level. Key Technical Challenge For the first baby-step, take a Redis Database binary that we supply, and find the loop where it takes successive queries from a batch of queries. The loop currently takes one query, makes a call to process that query, then loops and takes the next, and so on. Modify this loop so that it takes two queries, and makes two calls. Both on the same function, but two flavors. One query goes to the function that uses the lower half of the registers, the other query goes to the function that uses the upper half of the registers. Then, inline those two functions, so that the binary has an instr from one of the two function calls, then an instruction from the other, and so on. Then any functions called by those, do the same, so that the end result each of the queries is completed on one half of the registers, and the instructions for one query are interleaved with the instructions for the other query. This will involve removing the calling convention, and setting up two separate stack pointers, and adjusting the binary, etc. More discussion is needed, please contact me to talk it through. Responsibilities - Evaluate open-source binary rewriting / lifting / DBI frameworks (e.g. GTIRB, Remill, Reopt, rev.ng, QBDI, Dyninst, LLVM passes). - Implement a tool that:

• Performs function callsite rewriting to enforce a custom “half-register” calling convention.
• Clones/splits outer loops so two call-chains run on disjoint register sets.
• Preserves ELF relocations, DWARF/CFI, and standard psABI at function boundaries.
• Handles RISC-V specifics: compressed instructions, linker relaxations, atomics, TLS, exception semantics.
• Deliver a command-line tool + test suite that rewrites input ELF binaries into transformed output binaries.
• Optional: provide a runtime JIT/DBI prototype (e.g. QBDI-based) for dynamic rewriting.

Skills Required

• Strong experience with compilers, binary analysis, and rewriting.
• Hands-on with at least one of: LLVM IR, Remill, Reopt, rev.ng, GTIRB, Dyninst, QBDI.
• Experience with RISC-V toolchains (GCC/LLVM) and ELF internals.
• Proficient in C/C++ or Rust for systems-level development.
• Familiar with reverse engineering practices (relocations, PLT/GOT, DWARF, exception frames).
• Bonus: prior work on custom calling conventions or binary translation/JIT.

Deliverables

• Source code for the rewriter/JIT tool.
• Documentation + examples (including how to mark loops/regions for transformation).
• CI test integration (Renode or QEMU acceptable for validation).
• Performance test results on provided binaries.

Engagement Details

• Remote, part-time or full-time contract (flexible).
• Start: immediate.
• Duration: estimated 2–4 months for prototype + refinement.

Please share:

• Examples of prior work (open-source contributions, compilers, binary rewriting).
• GitHub/portfolio links.
• Availability and hourly/weekly rate.

Budget: $40 - $70 per hour Expected hours per week: 20 Languages: English proficiency required.

Job Tags

Remote job, Hourly pay, Full time, Contract work, Part time, Immediate start, Relocation, Flexible hours,

Similar Jobs