#jit #assembler #dynasm #dynasmrt #dynasm-rs

nightly macro dynasm

A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.

18 releases

0.3.2 Apr 11, 2019
0.3.1 Mar 5, 2019
0.3.0 Dec 25, 2018
0.2.3 Oct 11, 2018
0.0.6 Oct 27, 2016

#4 in Emulators

Download history 82/week @ 2019-04-26 100/week @ 2019-05-03 150/week @ 2019-05-10 117/week @ 2019-05-17 100/week @ 2019-05-24 42/week @ 2019-05-31 163/week @ 2019-06-07 39/week @ 2019-06-14 220/week @ 2019-06-21 108/week @ 2019-06-28 170/week @ 2019-07-05 124/week @ 2019-07-12 133/week @ 2019-07-19 328/week @ 2019-07-26 873/week @ 2019-08-02

482 downloads per month
Used in 5 crates (4 directly)

MPL-2.0 license

337KB
9K SLoC

A Dynamic assembler written in Rust for Rust.

The purpose of this tool is to ease the creation of programs that require run-time assembling.

It is currently in alpha, meaning that while everything should work, a lot of features need to be tested

Build Status

#dynasm-rs on irc.mozilla.org

Features

  • Fully integrated in the rust toolchain, no other tools necessary.
  • The assembly is optimized into a series of Vec.push and Vec.extend statements.
  • Errors are almost all diagnosed at compile time in a clear fashion.
  • Write the to be generated assembly inline in nasm-like syntax using a simple macro.

Documentation

Documentation can be found here.

Limitations

  • Currently only supports the x64 and x86 instruction sets in long and protected mode with every AMD/Intel/VIA extension except for AVX-512.

Example

#![feature(plugin)]
#![plugin(dynasm)]

#[macro_use]
extern crate dynasmrt;

use dynasmrt::{DynasmApi, DynasmLabelApi};

use std::{io, slice, mem};
use std::io::Write;

fn main() {
    let mut ops = dynasmrt::x64::Assembler::new().unwrap();
    let string = "Hello World!";

    dynasm!(ops
        ; ->hello:
        ; .bytes string.as_bytes()
    );

    let hello = ops.offset();
    dynasm!(ops
        ; lea rcx, [->hello]
        ; xor edx, edx
        ; mov dl, BYTE string.len() as _
        ; mov rax, QWORD print as _
        ; sub rsp, BYTE 0x28
        ; call rax
        ; add rsp, BYTE 0x28
        ; ret
    );

    let buf = ops.finalize().unwrap();

    let hello_fn: extern "win64" fn() -> bool = unsafe {
        mem::transmute(buf.ptr(hello))
    };

    assert!(
        hello_fn()
    );
}

pub extern "win64" fn print(buffer: *const u8, length: u64) -> bool {
    io::stdout().write_all(unsafe {
        slice::from_raw_parts(buffer, length as usize)
    }).is_ok()
}

Background

This project is heavily inspired by Dynasm

License

Mozilla Public License, v. 2.0, see LICENSE

Copyright 2016 CensoredUsername

Guaranteed to be working compiler versions

As this project is a compiler plugin, sometimes new compiler versions tend to break it. Here a list is kept of what versions of the compiler are guaranteed to work with specific dynasm-rs versions.

  • v0.2.0: rustc 1.27.0-nightly (ac3c2288f 2018-04-18)
  • v0.2.1: rustc 1.28.0-nightly (a1d4a9503 2018-05-20)
  • v0.2.3: rustc 1.31.0-nightly (96cafc53c 2018-10-09)

Dependencies

~1.5MB
~28K SLoC