grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

docs

Browse Source
This commit is contained in:
debris 2015-12-22 17:00:30 +01:00
parent 61a4b59da5
commit ff747ba349
1 changed files with 145 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
rust-evmjit/src/lib.rs
View File

@ -1,33 +1,22 @@
//! Bare rust wrapper around evmjit
//!
//! Requires latest version of Ethereum EVM JIT. https://github.com/debris/evmjit
//!
//! ```
//! extern crate evmjit;
//! use evmjit::*;
//!
//! fn main() {
//! let mut context = ContextHandle::new(RuntimeDataHandle::new(), EnvHandle::empty());
//! assert_eq!(context.exec(), ReturnCode::Stop);
//! }
//!
//! ```
extern crate libc;
use self::ffi::*;
#[repr(C)]
pub struct JitI256 {
pub words: [u64; 4]
}
#[repr(C)]
pub struct JitRuntimeData {
pub gas: i64,
pub gas_price: i64,
pub call_data: *const libc::c_char,
pub call_data_size: u64,
pub address: JitI256,
pub caller: JitI256,
pub origin: JitI256,
pub call_value: JitI256,
pub coinbase: JitI256,
pub difficulty: JitI256,
pub gas_limit: JitI256,
pub number: u64,
pub timestamp: i64,
pub code: *const libc::c_char,
pub code_size: u64,
pub code_hash: JitI256
}
pub use self::ffi::JitReturnCode as ReturnCode;
/// Component oriented safe handle to `JitRuntimeData`.
pub struct RuntimeDataHandle {
@ -59,22 +48,6 @@ impl Drop for RuntimeDataHandle {
}
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub enum JitReturnCode {
Stop = 0,
Return = 1,
Suicide = 2,
OutOfGas = -1,
LLVMError = -101,
UnexpectedError = -111
}
/// JitContext struct declaration.
pub enum JitContext {}
/// Safe handle for jit context.
pub struct ContextHandle {
context: *mut JitContext,
@ -83,7 +56,7 @@ pub struct ContextHandle {
impl ContextHandle {
/// Creates new context handle.
pub fn new(mut data_handle: RuntimeDataHandle, mut env: Env) -> Self {
pub fn new(mut data_handle: RuntimeDataHandle, mut env: EnvHandle) -> Self {
let context = unsafe { evmjit_create_context(data_handle.mut_runtime_data(), &mut env) };
ContextHandle {
context: context,
@ -104,29 +77,29 @@ impl Drop for ContextHandle {
}
/// Component oriented wrapper around jit env c interface.
pub trait JitEnv {
pub trait Env {
fn sload(&mut self);
}
/// C abi compatible wrapper for JitEnvTrait implementers.
pub struct Env {
env_impl: Option<Box<JitEnv>>
/// C abi compatible wrapper for jit env implementers.
pub struct EnvHandle {
env_impl: Option<Box<Env>>
}
impl Env {
impl EnvHandle {
/// Creates new environment wrapper for given implementation
pub fn new<T>(env_impl: T) -> Self where T: JitEnv + 'static {
Env { env_impl: Some(Box::new(env_impl)) }
pub fn new<T>(env_impl: T) -> Self where T: Env + 'static {
EnvHandle { env_impl: Some(Box::new(env_impl)) }
}
/// Creates empty environment.
/// It can be used to for any operations.
pub fn empty() -> Self {
Env { env_impl: None }
EnvHandle { env_impl: None }
}
}
impl JitEnv for Env {
impl Env for EnvHandle {
fn sload(&mut self) {
match self.env_impl {
Some(ref mut env) => env.sload(),
@ -135,39 +108,88 @@ impl JitEnv for Env {
}
}
#[no_mangle]
pub unsafe extern fn env_sload(env: *mut Env, _index: *const JitI256, _value: *const JitI256) {
/// ffi functions
pub mod ffi {
use super::*;
use libc;
/// Jit context struct declaration.
pub enum JitContext {}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
/// Jit context execution return code.
pub enum JitReturnCode {
Stop = 0,
Return = 1,
Suicide = 2,
OutOfGas = -1,
LLVMError = -101,
UnexpectedError = -111
}
#[repr(C)]
/// Signed 256 bit integer.
pub struct JitI256 {
pub words: [u64; 4]
}
#[repr(C)]
/// Jit runtime data.
pub struct JitRuntimeData {
pub gas: i64,
pub gas_price: i64,
pub call_data: *const libc::c_char,
pub call_data_size: u64,
pub address: JitI256,
pub caller: JitI256,
pub origin: JitI256,
pub call_value: JitI256,
pub coinbase: JitI256,
pub difficulty: JitI256,
pub gas_limit: JitI256,
pub number: u64,
pub timestamp: i64,
pub code: *const libc::c_char,
pub code_size: u64,
pub code_hash: JitI256
}
#[no_mangle]
pub unsafe extern fn env_sload(env: *mut EnvHandle, _index: *const JitI256, _value: *const JitI256) {
let env = &mut *env;
env.sload();
}
}
#[no_mangle]
pub extern fn env_sstore(_env: *mut Env, _index: *const JitI256, _value: *const JitI256) {
#[no_mangle]
pub extern fn env_sstore(_env: *mut EnvHandle, _index: *const JitI256, _value: *const JitI256) {
unimplemented!()
}
}
#[no_mangle]
pub extern fn env_balance(_env: *mut Env, _address: *const JitI256, _value: *const JitI256) {
#[no_mangle]
pub extern fn env_balance(_env: *mut EnvHandle, _address: *const JitI256, _value: *const JitI256) {
unimplemented!()
}
}
#[no_mangle]
pub extern fn env_blockhash(_env: *mut Env, _number: *const JitI256, _hash: *const JitI256) {
#[no_mangle]
pub extern fn env_blockhash(_env: *mut EnvHandle, _number: *const JitI256, _hash: *const JitI256) {
unimplemented!()
}
}
#[no_mangle]
pub extern fn env_create(_env: *mut Env,
#[no_mangle]
pub extern fn env_create(_env: *mut EnvHandle,
_io_gas: *const u64,
_endowment: *const JitI256,
_init_beg: *const u8,
_init_size: *const u64,
_address: *const JitI256) {
unimplemented!()
}
}
#[no_mangle]
pub extern fn env_call(_env: *mut Env,
#[no_mangle]
pub extern fn env_call(_env: *mut EnvHandle,
_io_gas: *const u64,
_call_gas: *const u64,
_receive_address: *const JitI256,
@ -178,20 +200,20 @@ pub extern fn env_call(_env: *mut Env,
_out_size: *const u64,
_code_address: JitI256) {
unimplemented!()
}
}
#[no_mangle]
pub extern fn env_sha3(_begin: *const u8, _size: *const u64, _hash: *const JitI256) {
#[no_mangle]
pub extern fn env_sha3(_begin: *const u8, _size: *const u64, _hash: *const JitI256) {
unimplemented!()
}
}
#[no_mangle]
pub extern fn env_extcode(_env: *mut Env, _address: *const JitI256, _size: *const u64) {
#[no_mangle]
pub extern fn env_extcode(_env: *mut EnvHandle, _address: *const JitI256, _size: *const u64) {
unimplemented!()
}
}
#[no_mangle]
pub extern fn env_log(_env: *mut Env,
#[no_mangle]
pub extern fn env_log(_env: *mut EnvHandle,
_beg: *const u8,
_size: *const u64,
_topic1: *const JitI256,
@ -199,29 +221,30 @@ pub extern fn env_log(_env: *mut Env,
_topic3: *const JitI256,
_topic4: *const JitI256) {
unimplemented!()
}
}
#[link(name="evmjit")]
extern "C" {
#[link(name="evmjit")]
extern "C" {
pub fn evmjit_create_runtime_data() -> *mut JitRuntimeData;
pub fn evmjit_destroy_runtime_data(data: *mut JitRuntimeData);
pub fn evmjit_destroy_context(context: *mut JitContext);
pub fn evmjit_exec(context: *mut JitContext) -> JitReturnCode;
}
}
#[link(name="evmjit")]
// Env does not have to by a C type
#[allow(improper_ctypes)]
extern "C" {
pub fn evmjit_create_context(data: *mut JitRuntimeData, env: *mut Env) -> *mut JitContext;
#[link(name="evmjit")]
// EnvHandle does not have to by a C type
#[allow(improper_ctypes)]
extern "C" {
pub fn evmjit_create_context(data: *mut JitRuntimeData, env: *mut EnvHandle) -> *mut JitContext;
}
}
#[test]
fn ffi_test() {
unsafe {
let data = evmjit_create_runtime_data();
let context = evmjit_create_context(data, &mut Env::empty());
let context = evmjit_create_context(data, &mut EnvHandle::empty());
let code = evmjit_exec(context);
assert_eq!(code, JitReturnCode::Stop);
@ -233,6 +256,6 @@ fn ffi_test() {
#[test]
fn handle_test() {
let mut context = ContextHandle::new(RuntimeDataHandle::new(), Env::empty());
assert_eq!(context.exec(), JitReturnCode::Stop);
let mut context = ContextHandle::new(RuntimeDataHandle::new(), EnvHandle::empty());
assert_eq!(context.exec(), ReturnCode::Stop);
}