T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove stray file in C API (#1464)

Browse Source 
Forgot to delete this from a previous PR!
This commit is contained in:
Alex Crichton
2020-04-03 13:53:33 -05:00
committed by GitHub
parent a799f9f6b5
commit 7728703ec7
1 changed files with 0 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

286
crates/c-api/src/ext.rs
View File

@@ -1,286 +0,0 @@
//! This file defines the extern "C" API extension, which are specific
//! to the wasmtime implementation.
use crate::*;
use std::str;
use wasmtime::{Extern, Linker, OptLevel, ProfilingStrategy, Strategy};
#[repr(u8)]
#[derive(Clone)]
pub enum wasmtime_strategy_t {
WASMTIME_STRATEGY_AUTO,
WASMTIME_STRATEGY_CRANELIFT,
WASMTIME_STRATEGY_LIGHTBEAM,
}
#[repr(u8)]
#[derive(Clone)]
pub enum wasmtime_opt_level_t {
WASMTIME_OPT_LEVEL_NONE,
WASMTIME_OPT_LEVEL_SPEED,
WASMTIME_OPT_LEVEL_SPEED_AND_SIZE,
}
#[repr(u8)]
#[derive(Clone)]
pub enum wasmtime_profiling_strategy_t {
WASMTIME_PROFILING_STRATEGY_NONE,
WASMTIME_PROFILING_STRATEGY_JITDUMP,
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_debug_info_set(c: *mut wasm_config_t, enable: bool) {
(*c).config.debug_info(enable);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_wasm_threads_set(c: *mut wasm_config_t, enable: bool) {
(*c).config.wasm_threads(enable);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_wasm_reference_types_set(
c: *mut wasm_config_t,
enable: bool,
) {
(*c).config.wasm_reference_types(enable);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_wasm_simd_set(c: *mut wasm_config_t, enable: bool) {
(*c).config.wasm_simd(enable);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_wasm_bulk_memory_set(c: *mut wasm_config_t, enable: bool) {
(*c).config.wasm_bulk_memory(enable);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_wasm_multi_value_set(c: *mut wasm_config_t, enable: bool) {
(*c).config.wasm_multi_value(enable);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_strategy_set(
c: *mut wasm_config_t,
strategy: wasmtime_strategy_t,
) {
use wasmtime_strategy_t::*;
drop((*c).config.strategy(match strategy {
WASMTIME_STRATEGY_AUTO => Strategy::Auto,
WASMTIME_STRATEGY_CRANELIFT => Strategy::Cranelift,
WASMTIME_STRATEGY_LIGHTBEAM => Strategy::Lightbeam,
}));
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_cranelift_debug_verifier_set(
c: *mut wasm_config_t,
enable: bool,
) {
(*c).config.cranelift_debug_verifier(enable);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_cranelift_opt_level_set(
c: *mut wasm_config_t,
opt_level: wasmtime_opt_level_t,
) {
use wasmtime_opt_level_t::*;
(*c).config.cranelift_opt_level(match opt_level {
WASMTIME_OPT_LEVEL_NONE => OptLevel::None,
WASMTIME_OPT_LEVEL_SPEED => OptLevel::Speed,
WASMTIME_OPT_LEVEL_SPEED_AND_SIZE => OptLevel::SpeedAndSize,
});
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_config_profiler_set(
c: *mut wasm_config_t,
strategy: wasmtime_profiling_strategy_t,
) {
use wasmtime_profiling_strategy_t::*;
drop((*c).config.profiler(match strategy {
WASMTIME_PROFILING_STRATEGY_NONE => ProfilingStrategy::None,
WASMTIME_PROFILING_STRATEGY_JITDUMP => ProfilingStrategy::JitDump,
}));
}
#[no_mangle]
pub extern "C" fn wasmtime_wat2wasm(
wat: &wasm_byte_vec_t,
ret: &mut wasm_byte_vec_t,
error: Option<&mut wasm_byte_vec_t>,
) -> bool {
let wat = match str::from_utf8(wat.as_slice()) {
Ok(s) => s,
Err(_) => {
if let Some(error) = error {
error.set_buffer(b"input was not valid utf-8".to_vec());
}
return false;
}
};
match wat::parse_str(wat) {
Ok(bytes) => {
ret.set_buffer(bytes.into());
true
}
Err(e) => {
if let Some(error) = error {
error.set_buffer(e.to_string().into_bytes());
}
false
}
}
}
#[repr(C)]
pub struct wasmtime_linker_t {
linker: Linker,
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_linker_new(store: *mut wasm_store_t) -> *mut wasmtime_linker_t {
Box::into_raw(Box::new(wasmtime_linker_t {
linker: Linker::new(&(*store).store.borrow()),
}))
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_linker_allow_shadowing(
linker: *mut wasmtime_linker_t,
allow_shadowing: bool,
) {
(*linker).linker.allow_shadowing(allow_shadowing);
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_linker_delete(linker: *mut wasmtime_linker_t) {
drop(Box::from_raw(linker));
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_linker_define(
linker: *mut wasmtime_linker_t,
module: *const wasm_name_t,
name: *const wasm_name_t,
item: *const wasm_extern_t,
) -> bool {
let linker = &mut (*linker).linker;
let module = match str::from_utf8((*module).as_slice()) {
Ok(s) => s,
Err(_) => return false,
};
let name = match str::from_utf8((*name).as_slice()) {
Ok(s) => s,
Err(_) => return false,
};
let item = match &(*item).which {
ExternHost::Func(e) => Extern::Func(e.borrow().clone()),
ExternHost::Table(e) => Extern::Table(e.borrow().clone()),
ExternHost::Global(e) => Extern::Global(e.borrow().clone()),
ExternHost::Memory(e) => Extern::Memory(e.borrow().clone()),
};
linker.define(module, name, item).is_ok()
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_linker_define_wasi(
linker: *mut wasmtime_linker_t,
instance: *const wasi_instance_t,
) -> bool {
let linker = &mut (*linker).linker;
(*instance).add_to_linker(linker).is_ok()
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_linker_define_instance(
linker: *mut wasmtime_linker_t,
name: *const wasm_name_t,
instance: *const wasm_instance_t,
) -> bool {
let linker = &mut (*linker).linker;
let name = match str::from_utf8((*name).as_slice()) {
Ok(s) => s,
Err(_) => return false,
};
linker
.instance(name, &(*instance).instance.borrow())
.is_ok()
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_linker_instantiate(
linker: *const wasmtime_linker_t,
module: *const wasm_module_t,
trap: *mut *mut wasm_trap_t,
) -> *mut wasm_instance_t {
let linker = &(*linker).linker;
handle_instantiate(linker.instantiate(&(*module).module.borrow()), trap)
}
pub type wasmtime_func_callback_t = unsafe extern "C" fn(
caller: *const wasmtime_caller_t,
args: *const wasm_val_t,
results: *mut wasm_val_t,
) -> *mut wasm_trap_t;
pub type wasmtime_func_callback_with_env_t = unsafe extern "C" fn(
caller: *const wasmtime_caller_t,
env: *mut std::ffi::c_void,
args: *const wasm_val_t,
results: *mut wasm_val_t,
) -> *mut wasm_trap_t;
#[repr(C)]
pub struct wasmtime_caller_t<'a> {
pub inner: wasmtime::Caller<'a>,
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_func_new(
store: *mut wasm_store_t,
ty: *const wasm_functype_t,
callback: wasmtime_func_callback_t,
) -> *mut wasm_func_t {
crate::create_function(store, ty, crate::Callback::Wasmtime(callback))
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_func_new_with_env(
store: *mut wasm_store_t,
ty: *const wasm_functype_t,
callback: wasmtime_func_callback_with_env_t,
env: *mut std::ffi::c_void,
finalizer: Option<unsafe extern "C" fn(arg1: *mut std::ffi::c_void)>,
) -> *mut wasm_func_t {
crate::create_function_with_env(
store,
ty,
crate::CallbackWithEnv::Wasmtime(callback),
env,
finalizer,
)
}
#[no_mangle]
pub unsafe extern "C" fn wasmtime_caller_export_get(
caller: *const wasmtime_caller_t,
name: *const wasm_name_t,
) -> *mut wasm_extern_t {
let name = match str::from_utf8((*name).as_slice()) {
Ok(s) => s,
Err(_) => return std::ptr::null_mut(),
};
match (*caller).inner.get_export(name).map(|e| match e {
Extern::Func(f) => ExternHost::Func(HostRef::new(f.clone())),
Extern::Global(g) => ExternHost::Global(HostRef::new(g.clone())),
Extern::Memory(m) => ExternHost::Memory(HostRef::new(m.clone())),
Extern::Table(t) => ExternHost::Table(HostRef::new(t.clone())),
}) {
Some(export) => Box::into_raw(Box::new(wasm_extern_t { which: export })),
None => std::ptr::null_mut(),
}
}