From a8fb432d2b574c613d477dfd0550c0a0bf708602 Mon Sep 17 00:00:00 2001 From: Peter Elliott Date: Tue, 13 Aug 2019 22:52:55 -0700 Subject: [PATCH] added aliases also added: - conditonal compilation - updated examples - bumped version --- Cargo.toml | 2 +- README.md | 23 +++++------- src/jitstate.rs | 93 ++++++++++++++++++++++++++++++++++++++++++++----- src/lib.rs | 23 +++++------- 4 files changed, 104 insertions(+), 37 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 622ebf8..afb9eb1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "lightning-sys" -version = "0.1.1" +version = "0.1.2" authors = ["Peter Elliott "] edition = "2018" license = "GPL-3.0-or-later" diff --git a/README.md b/README.md index 468d9ad..ffd6825 100644 --- a/README.md +++ b/README.md @@ -9,19 +9,18 @@ Safe gnu lightning bindings for rust ### a function that increments a number by one ```rust -use lightning_sys::{Jit, Reg, JitPointer}; +use lightning_sys::{Jit, Reg, JitPointer, JitWord}; let jit = Jit::new(); let js = jit.new_state(); js.prolog(); let inarg = js.arg(); -//TODO: use regular getarg -js.getarg_i(Reg::R(0), &inarg); +js.getarg(Reg::R(0), &inarg); js.addi(Reg::R(0), Reg::R(0), 1); js.retr(Reg::R(0)); -let incr = unsafe { js.emit:: i32>() }; +let incr = unsafe { js.emit:: JitWord>() }; js.clear(); assert_eq!(incr(5), 6); @@ -47,8 +46,7 @@ fn main() { let start = js.note(file!(), line!()); js.prolog(); let inarg = js.arg(); - //TODO: use regular getarg - js.getarg_i(Reg::R(1), &inarg); + js.getarg(Reg::R(1), &inarg); js.prepare(); js.pushargi(cs.as_ptr() as JitWord); js.ellipsis(); @@ -58,7 +56,7 @@ fn main() { js.epilog(); let end = js.note(file!(), line!()); - let my_function = unsafe{ js.emit::() }; + let my_function = unsafe{ js.emit::() }; /* call the generated code, passing its size as argument */ my_function((js.address(&end) as u64 - js.address(&start) as u64).try_into().unwrap()); js.clear(); @@ -79,8 +77,7 @@ fn main() { let label = js.label(); js.prolog(); let inarg = js.arg(); - //TODO: use regular getarg - js.getarg_i(Reg::R(0), &inarg); + js.getarg(Reg::R(0), &inarg); let zero = js.beqi(Reg::R(0), 0); js.movr(Reg::V(0), Reg::R(0)); js.movi(Reg::R(0), 1); @@ -91,14 +88,12 @@ fn main() { js.pushargr(Reg::V(1)); let call = js.finishi(NULL); js.patch_at(&call, &label); - //TODO: use normal retval - js.retval_i(Reg::V(1)); + js.retval(Reg::V(1)); js.prepare(); js.pushargr(Reg::V(2)); let call2 = js.finishi(NULL); js.patch_at(&call2, &label); - //TODO: use normal retval - js.retval_i(Reg::R(1)); + js.retval(Reg::R(1)); js.addr(Reg::R(0), Reg::R(0), Reg::V(1)); js.patch(&refr); @@ -106,7 +101,7 @@ fn main() { js.retr(Reg::R(0)); js.epilog(); - let fib = unsafe{ js.emit:: i32>() }; + let fib = unsafe{ js.emit:: JitWord>() }; js.clear(); println!("fib({})={}", 32, fib(32)); diff --git a/src/jitstate.rs b/src/jitstate.rs index 3167b25..83d5080 100644 --- a/src/jitstate.rs +++ b/src/jitstate.rs @@ -69,7 +69,7 @@ macro_rules! jit_impl { ( $op:ident, i_wp ) => { jit_impl_inner!($op, wp, a: Reg => JitWord, b: JitPointer => _); }; ( $op:ident, i_fp ) => { jit_impl_inner!($op, fp, a: Reg => JitWord, b: JitPointer => _); }; ( $op:ident, i_dp ) => { jit_impl_inner!($op, dp, a: Reg => JitWord, b: JitPointer => _); }; - ( $op:ident, i_pw ) => { jit_impl_inner!($op, pw, a: Reg => JitWord, b: JitWord => _); }; + ( $op:ident, i_pw ) => { jit_impl_inner!($op, pw, a: JitPointer => _, b: Reg => JitWord); }; ( $op:ident, i_wf ) => { jit_impl_inner!($op, wf, a: Reg => JitWord, b: f32 => _); }; ( $op:ident, i_wd ) => { jit_impl_inner!($op, wd, a: Reg => JitWord, b: f64 => _); }; @@ -179,6 +179,20 @@ macro_rules! jit_branch { }; } +macro_rules! jit_alias { + ( $targ:ident => $new:ident $(, $arg:ident : $typ:ty )*; -> JitNode ) => { + pub fn $new<'b>(&'b self $(, $arg: $typ )*) -> JitNode<'b> { + self.$targ($( $arg ),*) + } + }; + ( $targ:ident => $new:ident $(, $arg:ident : $typ:ty )*; -> $ret:ty) => { + pub fn $new<'b>(&'b self $(, $arg: $typ )*) -> $ret { + self.$targ($( $arg ),*) + } + }; + ( $targ:ident => $new:ident $(, $arg:ident : $typ:ty )*) => { jit_alias!($targ => $new $(, $arg : $typ)*; -> ()); } +} + // implmentations of instructions impl<'a> JitState<'a> { jit_impl!(live, w); @@ -221,7 +235,12 @@ impl<'a> JitState<'a> { jit_reexport!(getarg_us, reg: Reg, node: &JitNode); jit_reexport!(getarg_i, reg: Reg, node: &JitNode); jit_reexport!(getarg_ui, reg: Reg, node: &JitNode); + #[cfg(target_pointer_width = "64")] jit_reexport!(getarg_l, reg: Reg, node: &JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(getarg_l => getarg, reg: Reg, node: &JitNode); + #[cfg(target_pointer_width = "32")] + jit_alias!(getarg_i => getarg, reg: Reg, node: &JitNode); jit_reexport!(putargr, reg: Reg, arg: &JitNode); jit_reexport!(putargi, imm: JitWord, arg: &JitNode); @@ -309,12 +328,24 @@ impl<'a> JitState<'a> { jit_impl!(extr_uc, ww); jit_impl!(extr_s, ww); jit_impl!(extr_us, ww); + #[cfg(target_pointer_width = "64")] jit_impl!(extr_i, ww); + #[cfg(target_pointer_width = "64")] jit_impl!(extr_ui, ww); jit_impl!(htonr_us, ww); + jit_alias!(htonr_us => ntohr_us, targ: Reg, src: Reg; -> JitNode); jit_impl!(htonr_ui, ww); + jit_alias!(htonr_ui => ntohr_ui, targ: Reg, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "64")] jit_impl!(htonr_ul, ww); + #[cfg(target_pointer_width = "64")] + jit_alias!(htonr_ul => ntohr_ul, targ: Reg, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "32")] + jit_alias!(htonr_ui => htonr, targ: Reg, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(htonr_ul => htonr, targ: Reg, src: Reg; -> JitNode); + jit_alias!(htonr => ntohr, targ: Reg, src: Reg; -> JitNode); jit_impl!(ldr_c, ww); jit_impl!(ldi_c, i_wp); @@ -326,10 +357,22 @@ impl<'a> JitState<'a> { jit_impl!(ldi_us, i_wp); jit_impl!(ldr_i, ww); jit_impl!(ldi_i, i_wp); + #[cfg(target_pointer_width = "64")] jit_impl!(ldr_ui, ww); + #[cfg(target_pointer_width = "64")] jit_impl!(ldi_ui, i_wp); + #[cfg(target_pointer_width = "64")] jit_impl!(ldr_l, ww); + #[cfg(target_pointer_width = "64")] jit_impl!(ldi_l, i_wp); + #[cfg(target_pointer_width = "32")] + jit_alias!(ldr_i => ldr, targ: Reg, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "32")] + jit_alias!(ldi_i => ldr, targ: Reg, src: JitPointer; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(ldr_l => ldr, targ: Reg, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(ldi_l => ldi, targ: Reg, src: JitPointer; -> JitNode); jit_impl!(ldxr_c, www); jit_impl!(ldxi_c, i_www); @@ -339,28 +382,56 @@ impl<'a> JitState<'a> { jit_impl!(ldxi_us, i_www); jit_impl!(ldxr_i, www); jit_impl!(ldxi_i, i_www); + #[cfg(target_pointer_width = "64")] jit_impl!(ldxr_ui, www); + #[cfg(target_pointer_width = "64")] jit_impl!(ldxi_ui, i_www); + #[cfg(target_pointer_width = "64")] jit_impl!(ldxr_l, www); + #[cfg(target_pointer_width = "64")] jit_impl!(ldxi_l, i_www); + #[cfg(target_pointer_width = "32")] + jit_alias!(ldxr_i => ldxr, targ: Reg, a: Reg, b: Reg; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(ldxr_l => ldxr, targ: Reg, a: Reg, b: Reg; -> JitNode); jit_impl!(str_c, ww); - jit_impl!(sti_c, i_wp); + jit_impl!(sti_c, i_pw); jit_impl!(str_s, ww); - jit_impl!(sti_s, i_wp); + jit_impl!(sti_s, i_pw); jit_impl!(str_i, ww); - jit_impl!(sti_i, i_wp); + jit_impl!(sti_i, i_pw); + #[cfg(target_pointer_width = "64")] jit_impl!(str_l, ww); - jit_impl!(sti_l, i_wp); + #[cfg(target_pointer_width = "64")] + jit_impl!(sti_l, i_pw); + #[cfg(target_pointer_width = "32")] + jit_alias!(str_i => str, targ: Reg, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "32")] + jit_alias!(sti_i => sti, targ: JitPointer, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(str_l => str, targ: Reg, src: Reg; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(sti_i => sti, targ: JitPointer, src: Reg; -> JitNode); jit_impl!(stxr_c, www); jit_impl!(stxi_c, i_www); - jit_impl!(stxr_s, ww); + jit_impl!(stxr_s, www); jit_impl!(stxi_s, i_www); - jit_impl!(stxr_i, ww); + jit_impl!(stxr_i, www); jit_impl!(stxi_i, i_www); - jit_impl!(stxr_l, ww); + #[cfg(target_pointer_width = "64")] + jit_impl!(stxr_l, www); + #[cfg(target_pointer_width = "64")] jit_impl!(stxi_l, i_www); + #[cfg(target_pointer_width = "32")] + jit_alias!(stxr_i => stxr, targ: Reg, src: Reg, off: Reg; -> JitNode); + #[cfg(target_pointer_width = "32")] + jit_alias!(stxi_i => stxi, targ: Reg, src: Reg, off: JitWord; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(stxr_l => stxr, targ: Reg, src: Reg, off: Reg; -> JitNode); + #[cfg(target_pointer_width = "64")] + jit_alias!(stxi_l => stxi, targ: Reg, src: Reg, off: JitWord; -> JitNode); jit_branch!(bltr, r); jit_branch!(blti, i); @@ -427,8 +498,14 @@ impl<'a> JitState<'a> { jit_reexport!(retval_s, rv: Reg); jit_reexport!(retval_us, rv: Reg); jit_reexport!(retval_i, rv: Reg); + #[cfg(target_pointer_width = "64")] jit_reexport!(retval_ui, rv: Reg); + #[cfg(target_pointer_width = "64")] jit_reexport!(retval_l, rv: Reg); + #[cfg(target_pointer_width = "32")] + jit_alias!(retval_i => retval, rv: Reg); + #[cfg(target_pointer_width = "64")] + jit_alias!(retval_l => retval, rv: Reg); jit_reexport!(epilog); diff --git a/src/lib.rs b/src/lib.rs index 037ff64..0aaf016 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,19 +3,18 @@ //! ## Examples: //! ### a function that increments a number by one //! ``` -//! use lightning_sys::{Jit, Reg, JitPointer}; +//! use lightning_sys::{Jit, Reg, JitPointer, JitWord}; //! //! let jit = Jit::new(); //! let js = jit.new_state(); //! //! js.prolog(); //! let inarg = js.arg(); -//! //TODO: use regular getarg -//! js.getarg_i(Reg::R(0), &inarg); +//! js.getarg(Reg::R(0), &inarg); //! js.addi(Reg::R(0), Reg::R(0), 1); //! js.retr(Reg::R(0)); //! -//! let incr = unsafe { js.emit:: i32>() }; +//! let incr = unsafe { js.emit:: JitWord>() }; //! js.clear(); //! //! assert_eq!(incr(5), 6); @@ -41,8 +40,7 @@ //! let start = js.note(file!(), line!()); //! js.prolog(); //! let inarg = js.arg(); -//! //TODO: use regular getarg -//! js.getarg_i(Reg::R(1), &inarg); +//! js.getarg(Reg::R(1), &inarg); //! js.prepare(); //! js.pushargi(cs.as_ptr() as JitWord); //! js.ellipsis(); @@ -52,7 +50,7 @@ //! js.epilog(); //! let end = js.note(file!(), line!()); //! -//! let my_function = unsafe{ js.emit::() }; +//! let my_function = unsafe{ js.emit::() }; //! /* call the generated code, passing its size as argument */ //! my_function((js.address(&end) as u64 - js.address(&start) as u64).try_into().unwrap()); //! js.clear(); @@ -73,8 +71,7 @@ //! let label = js.label(); //! js.prolog(); //! let inarg = js.arg(); -//! //TODO: use regular getarg -//! js.getarg_i(Reg::R(0), &inarg); +//! js.getarg(Reg::R(0), &inarg); //! let zero = js.beqi(Reg::R(0), 0); //! js.movr(Reg::V(0), Reg::R(0)); //! js.movi(Reg::R(0), 1); @@ -85,14 +82,12 @@ //! js.pushargr(Reg::V(1)); //! let call = js.finishi(NULL); //! js.patch_at(&call, &label); -//! //TODO: use normal retval -//! js.retval_i(Reg::V(1)); +//! js.retval(Reg::V(1)); //! js.prepare(); //! js.pushargr(Reg::V(2)); //! let call2 = js.finishi(NULL); //! js.patch_at(&call2, &label); -//! //TODO: use normal retval -//! js.retval_i(Reg::R(1)); +//! js.retval(Reg::R(1)); //! js.addr(Reg::R(0), Reg::R(0), Reg::V(1)); //! //! js.patch(&refr); @@ -100,7 +95,7 @@ //! js.retr(Reg::R(0)); //! js.epilog(); //! -//! let fib = unsafe{ js.emit:: i32>() }; +//! let fib = unsafe{ js.emit:: JitWord>() }; //! js.clear(); //! //! println!("fib({})={}", 32, fib(32));