mirror of
https://github.com/fluencelabs/wasm-bindgen
synced 2025-04-11 14:46:04 +00:00
d5b81595ec
First added in #161 this never ended up panning out, so let's remove the experimental suport which isn't actually used by anything today and hold off on any other changes until an RFC happens.
528 lines
18 KiB
Rust
528 lines
18 KiB
Rust
#![doc(html_root_url = "https://docs.rs/wasm-bindgen-cli-support/0.2")]
|
|
|
|
extern crate parity_wasm;
|
|
extern crate wasm_bindgen_shared as shared;
|
|
extern crate serde_json;
|
|
extern crate wasm_gc;
|
|
extern crate wasmi;
|
|
#[macro_use]
|
|
extern crate failure;
|
|
|
|
use std::any::Any;
|
|
use std::collections::BTreeSet;
|
|
use std::fmt;
|
|
use std::fs;
|
|
use std::mem;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use failure::{Error, ResultExt};
|
|
use parity_wasm::elements::*;
|
|
|
|
mod descriptor;
|
|
mod js;
|
|
pub mod wasm2es6js;
|
|
|
|
pub struct Bindgen {
|
|
input: Input,
|
|
nodejs: bool,
|
|
nodejs_experimental_modules: bool,
|
|
browser: bool,
|
|
no_modules: bool,
|
|
no_modules_global: Option<String>,
|
|
debug: bool,
|
|
typescript: bool,
|
|
demangle: bool,
|
|
keep_debug: bool,
|
|
}
|
|
|
|
enum Input {
|
|
Path(PathBuf),
|
|
Bytes(Vec<u8>, String),
|
|
Module(Module, String),
|
|
None,
|
|
}
|
|
|
|
impl Bindgen {
|
|
pub fn new() -> Bindgen {
|
|
Bindgen {
|
|
input: Input::None,
|
|
nodejs: false,
|
|
nodejs_experimental_modules: false,
|
|
browser: false,
|
|
no_modules: false,
|
|
no_modules_global: None,
|
|
debug: false,
|
|
typescript: false,
|
|
demangle: true,
|
|
keep_debug: false,
|
|
}
|
|
}
|
|
|
|
pub fn input_path<P: AsRef<Path>>(&mut self, path: P) -> &mut Bindgen {
|
|
self.input = Input::Path(path.as_ref().to_path_buf());
|
|
self
|
|
}
|
|
|
|
/// Explicitly specify the already parsed input module.
|
|
///
|
|
/// Note that this API is a little wonky to avoid tying itself with a public
|
|
/// dependency on the `parity-wasm` crate, what we currently use to parse
|
|
/// wasm mdoules.
|
|
///
|
|
/// If the `module` argument is a `parity_wasm::Module` then it will be used
|
|
/// directly. Otherwise it will be passed to `into_bytes` to serialize the
|
|
/// module to a vector of bytes, and this will deserialize the module later.
|
|
///
|
|
/// Note that even if the argument passed in is a `parity_wasm::Module` it
|
|
/// doesn't mean that this won't invoke `into_bytes`, if the `parity_wasm`
|
|
/// crate versions are different we'll have to go through serialization.
|
|
pub fn input_module<T: Any>(
|
|
&mut self,
|
|
name: &str,
|
|
mut module: T,
|
|
into_bytes: impl FnOnce(T) -> Vec<u8>,
|
|
) -> &mut Bindgen {
|
|
let name = name.to_string();
|
|
if let Some(module) = (&mut module as &mut Any).downcast_mut::<Module>() {
|
|
let blank = Module::new(Vec::new());
|
|
self.input = Input::Module(mem::replace(module, blank), name);
|
|
return self
|
|
}
|
|
|
|
self.input = Input::Bytes(into_bytes(module), name);
|
|
self
|
|
}
|
|
|
|
pub fn nodejs(&mut self, node: bool) -> &mut Bindgen {
|
|
self.nodejs = node;
|
|
self
|
|
}
|
|
|
|
pub fn nodejs_experimental_modules(&mut self, node: bool) -> &mut Bindgen {
|
|
self.nodejs_experimental_modules = node;
|
|
self
|
|
}
|
|
|
|
pub fn browser(&mut self, browser: bool) -> &mut Bindgen {
|
|
self.browser = browser;
|
|
self
|
|
}
|
|
|
|
pub fn no_modules(&mut self, no_modules: bool) -> &mut Bindgen {
|
|
self.no_modules = no_modules;
|
|
self
|
|
}
|
|
|
|
pub fn no_modules_global(&mut self, name: &str) -> &mut Bindgen {
|
|
self.no_modules_global = Some(name.to_string());
|
|
self
|
|
}
|
|
|
|
pub fn debug(&mut self, debug: bool) -> &mut Bindgen {
|
|
self.debug = debug;
|
|
self
|
|
}
|
|
|
|
pub fn typescript(&mut self, typescript: bool) -> &mut Bindgen {
|
|
self.typescript = typescript;
|
|
self
|
|
}
|
|
|
|
pub fn demangle(&mut self, demangle: bool) -> &mut Bindgen {
|
|
self.demangle = demangle;
|
|
self
|
|
}
|
|
|
|
pub fn keep_debug(&mut self, keep_debug: bool) -> &mut Bindgen {
|
|
self.keep_debug = keep_debug;
|
|
self
|
|
}
|
|
|
|
pub fn generate<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Error> {
|
|
self._generate(path.as_ref())
|
|
}
|
|
|
|
fn _generate(&mut self, out_dir: &Path) -> Result<(), Error> {
|
|
let (mut module, stem) = match self.input {
|
|
Input::None => bail!("must have an input by now"),
|
|
Input::Module(ref mut m, ref name) => {
|
|
let blank_module = Module::new(Vec::new());
|
|
(mem::replace(m, blank_module), &name[..])
|
|
}
|
|
Input::Bytes(ref b, ref name) => {
|
|
let module = parity_wasm::deserialize_buffer::<Module>(&b)
|
|
.context("failed to parse input file as wasm")?;
|
|
(module, &name[..])
|
|
}
|
|
Input::Path(ref path) => {
|
|
let contents = fs::read(&path)
|
|
.with_context(|_| format!("failed to read `{}`", path.display()))?;
|
|
let module = parity_wasm::deserialize_buffer::<Module>(&contents)
|
|
.context("failed to parse input file as wasm")?;
|
|
let stem = path.file_stem().unwrap().to_str().unwrap();
|
|
(module, stem)
|
|
}
|
|
};
|
|
let programs = extract_programs(&mut module)
|
|
.with_context(|_| "failed to extract wasm-bindgen custom sections")?;
|
|
|
|
// Here we're actually instantiating the module we've parsed above for
|
|
// execution. Why, you might be asking, are we executing wasm code? A
|
|
// good question!
|
|
//
|
|
// Transmitting information from `#[wasm_bindgen]` here to the CLI tool
|
|
// is pretty tricky. Specifically information about the types involved
|
|
// with a function signature (especially generic ones) can be hefty to
|
|
// translate over. As a result, the macro emits a bunch of shims which,
|
|
// when executed, will describe to us what the types look like.
|
|
//
|
|
// This means that whenever we encounter an import or export we'll
|
|
// execute a shim function which informs us about its type so we can
|
|
// then generate the appropriate bindings.
|
|
//
|
|
// TODO: avoid a `clone` here of the module if we can
|
|
let instance = wasmi::Module::from_parity_wasm_module(module.clone())
|
|
.with_context(|_| "failed to create wasmi module")?;
|
|
let instance = wasmi::ModuleInstance::new(&instance, &MyResolver)
|
|
.with_context(|_| "failed to instantiate wasm module")?;
|
|
let instance = instance.not_started_instance();
|
|
|
|
let (js, ts) = {
|
|
let mut cx = js::Context {
|
|
globals: String::new(),
|
|
imports: String::new(),
|
|
footer: String::new(),
|
|
typescript: format!("/* tslint:disable */\n"),
|
|
exposed_globals: Default::default(),
|
|
required_internal_exports: Default::default(),
|
|
imported_names: Default::default(),
|
|
imported_identifiers: Default::default(),
|
|
exported_classes: Default::default(),
|
|
config: &self,
|
|
module: &mut module,
|
|
function_table_needed: false,
|
|
run_descriptor: &|name| {
|
|
let mut v = MyExternals(Vec::new());
|
|
match instance.invoke_export(name, &[], &mut v) {
|
|
Ok(None) => Some(v.0),
|
|
Ok(Some(_)) => unreachable!(
|
|
"there is only one export, and we only return None from it"
|
|
),
|
|
// Allow missing exported describe functions. This can
|
|
// happen when a nested dependency crate exports things
|
|
// but the root crate doesn't use them.
|
|
Err(wasmi::Error::Function(_)) => None,
|
|
Err(e) => panic!("unexpected error running descriptor: {}", e),
|
|
}
|
|
},
|
|
};
|
|
for program in programs.iter() {
|
|
js::SubContext {
|
|
program,
|
|
cx: &mut cx,
|
|
}.generate()?;
|
|
}
|
|
cx.finalize(stem)?
|
|
};
|
|
|
|
let extension = if self.nodejs_experimental_modules { "mjs" } else { "js" };
|
|
let js_path = out_dir.join(stem).with_extension(extension);
|
|
fs::write(&js_path, reset_indentation(&js))
|
|
.with_context(|_| format!("failed to write `{}`", js_path.display()))?;
|
|
|
|
if self.typescript {
|
|
let ts_path = out_dir.join(stem).with_extension("d.ts");
|
|
fs::write(&ts_path, ts)
|
|
.with_context(|_| format!("failed to write `{}`", ts_path.display()))?;
|
|
}
|
|
|
|
let wasm_path = out_dir.join(format!("{}_bg", stem)).with_extension("wasm");
|
|
|
|
if self.nodejs {
|
|
let js_path = wasm_path.with_extension(extension);
|
|
let shim = self.generate_node_wasm_import(&module, &wasm_path);
|
|
fs::write(&js_path, shim)
|
|
.with_context(|_| format!("failed to write `{}`", js_path.display()))?;
|
|
}
|
|
|
|
let wasm_bytes = parity_wasm::serialize(module)?;
|
|
fs::write(&wasm_path, wasm_bytes)
|
|
.with_context(|_| format!("failed to write `{}`", wasm_path.display()))?;
|
|
Ok(())
|
|
}
|
|
|
|
fn generate_node_wasm_import(&self, m: &Module, path: &Path) -> String {
|
|
let mut imports = BTreeSet::new();
|
|
if let Some(i) = m.import_section() {
|
|
for i in i.entries() {
|
|
imports.insert(i.module());
|
|
}
|
|
}
|
|
|
|
let mut shim = String::new();
|
|
|
|
if self.nodejs_experimental_modules {
|
|
for (i, module) in imports.iter().enumerate() {
|
|
shim.push_str(&format!("import * as import{} from '{}';\n",
|
|
i, module));
|
|
}
|
|
// On windows skip the leading `/` which comes out when we parse a
|
|
// url to use `C:\...` instead of `\C:\...`
|
|
shim.push_str(&format!("
|
|
import * as path from 'path';
|
|
import * as fs from 'fs';
|
|
import * as url from 'url';
|
|
import * as process from 'process';
|
|
|
|
let file = path.dirname(url.parse(import.meta.url).pathname);
|
|
if (process.platform === 'win32') {{
|
|
file = file.substring(1);
|
|
}}
|
|
const bytes = fs.readFileSync(path.join(file, '{}'));
|
|
", path.file_name().unwrap().to_str().unwrap()));
|
|
} else {
|
|
shim.push_str(&format!("
|
|
const path = require('path').join(__dirname, '{}');
|
|
const bytes = require('fs').readFileSync(path);
|
|
", path.file_name().unwrap().to_str().unwrap()));
|
|
}
|
|
shim.push_str("let imports = {};\n");
|
|
for (i, module) in imports.iter().enumerate() {
|
|
if self.nodejs_experimental_modules {
|
|
shim.push_str(&format!("imports['{}'] = import{};\n", module, i));
|
|
} else {
|
|
shim.push_str(&format!("imports['{0}'] = require('{0}');\n", module));
|
|
}
|
|
}
|
|
|
|
shim.push_str(&format!(
|
|
"
|
|
const wasmModule = new WebAssembly.Module(bytes);
|
|
const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
|
|
",
|
|
));
|
|
|
|
if self.nodejs_experimental_modules {
|
|
if let Some(e) = m.export_section() {
|
|
for name in e.entries().iter().map(|e| e.field()) {
|
|
shim.push_str("export const ");
|
|
shim.push_str(name);
|
|
shim.push_str(" = wasmInstance.exports.");
|
|
shim.push_str(name);
|
|
shim.push_str(";\n");
|
|
}
|
|
}
|
|
} else {
|
|
shim.push_str("module.exports = wasmInstance.exports;\n");
|
|
}
|
|
|
|
reset_indentation(&shim)
|
|
}
|
|
}
|
|
|
|
fn extract_programs(module: &mut Module) -> Result<Vec<shared::Program>, Error> {
|
|
let version = shared::version();
|
|
let mut ret = Vec::new();
|
|
let mut to_remove = Vec::new();
|
|
|
|
for (i, s) in module.sections().iter().enumerate() {
|
|
let custom = match *s {
|
|
Section::Custom(ref s) => s,
|
|
_ => continue,
|
|
};
|
|
if custom.name() != "__wasm_bindgen_unstable" {
|
|
continue;
|
|
}
|
|
to_remove.push(i);
|
|
|
|
let mut payload = custom.payload();
|
|
let mut added_programs = Vec::new();
|
|
while payload.len() > 0 {
|
|
let len = ((payload[0] as usize) << 0)
|
|
| ((payload[1] as usize) << 8)
|
|
| ((payload[2] as usize) << 16)
|
|
| ((payload[3] as usize) << 24);
|
|
let (a, b) = payload[4..].split_at(len as usize);
|
|
payload = b;
|
|
|
|
// Due to a nasty LLVM bug it's currently possible for LLVM to
|
|
// duplicate custom section directives in intermediate object files.
|
|
// This means that we could see multiple program directives when in
|
|
// fact we were originally only meant to see one!
|
|
//
|
|
// Work around the issue here until the upstream bug,
|
|
// https://bugs.llvm.org/show_bug.cgi?id=38184, is hopefully fixed
|
|
// via some other means.
|
|
if added_programs.iter().any(|p| a == *p) {
|
|
continue
|
|
}
|
|
added_programs.push(a);
|
|
|
|
let p: shared::ProgramOnlySchema = match serde_json::from_slice(&a) {
|
|
Ok(f) => f,
|
|
Err(e) => bail!("failed to decode what looked like wasm-bindgen data: {}", e),
|
|
};
|
|
if p.schema_version != shared::SCHEMA_VERSION {
|
|
bail!(
|
|
"
|
|
|
|
it looks like the Rust project used to create this wasm file was linked against
|
|
a different version of wasm-bindgen than this binary:
|
|
|
|
rust wasm file: {}
|
|
this binary: {}
|
|
|
|
Currently the bindgen format is unstable enough that these two version must
|
|
exactly match, so it's required that these two version are kept in sync by
|
|
either updating the wasm-bindgen dependency or this binary. You should be able
|
|
to update the wasm-bindgen dependency with:
|
|
|
|
cargo update -p wasm-bindgen
|
|
|
|
or you can update the binary with
|
|
|
|
cargo install -f wasm-bindgen-cli
|
|
|
|
if this warning fails to go away though and you're not sure what to do feel free
|
|
to open an issue at https://github.com/rustwasm/wasm-bindgen/issues!
|
|
",
|
|
p.version,
|
|
version
|
|
);
|
|
}
|
|
let p: shared::Program = match serde_json::from_slice(&a) {
|
|
Ok(f) => f,
|
|
Err(e) => bail!("failed to decode what looked like wasm-bindgen data: {}", e),
|
|
};
|
|
ret.push(p);
|
|
}
|
|
}
|
|
|
|
for i in to_remove.into_iter().rev() {
|
|
module.sections_mut().remove(i);
|
|
}
|
|
Ok(ret)
|
|
}
|
|
|
|
struct MyResolver;
|
|
|
|
impl wasmi::ImportResolver for MyResolver {
|
|
fn resolve_func(
|
|
&self,
|
|
module_name: &str,
|
|
field_name: &str,
|
|
signature: &wasmi::Signature,
|
|
) -> Result<wasmi::FuncRef, wasmi::Error> {
|
|
// Route our special "describe" export to 1 and everything else to 0.
|
|
// That way whenever the function 1 is invoked we know what to do and
|
|
// when 0 is invoked (by accident) we'll trap and produce an error.
|
|
let idx = (module_name == "__wbindgen_placeholder__" && field_name == "__wbindgen_describe")
|
|
as usize;
|
|
Ok(wasmi::FuncInstance::alloc_host(signature.clone(), idx))
|
|
}
|
|
|
|
fn resolve_global(
|
|
&self,
|
|
_module_name: &str,
|
|
_field_name: &str,
|
|
descriptor: &wasmi::GlobalDescriptor,
|
|
) -> Result<wasmi::GlobalRef, wasmi::Error> {
|
|
// dummy implementation to ensure instantiation succeeds
|
|
let val = match descriptor.value_type() {
|
|
wasmi::ValueType::I32 => wasmi::RuntimeValue::I32(0),
|
|
wasmi::ValueType::I64 => wasmi::RuntimeValue::I64(0),
|
|
wasmi::ValueType::F32 => wasmi::RuntimeValue::F32(0.0.into()),
|
|
wasmi::ValueType::F64 => wasmi::RuntimeValue::F64(0.0.into()),
|
|
};
|
|
Ok(wasmi::GlobalInstance::alloc(val, descriptor.is_mutable()))
|
|
}
|
|
|
|
fn resolve_memory(
|
|
&self,
|
|
_module_name: &str,
|
|
_field_name: &str,
|
|
descriptor: &wasmi::MemoryDescriptor,
|
|
) -> Result<wasmi::MemoryRef, wasmi::Error> {
|
|
// dummy implementation to ensure instantiation succeeds
|
|
use wasmi::memory_units::Pages;
|
|
let initial = Pages(descriptor.initial() as usize);
|
|
let maximum = descriptor.maximum().map(|i| Pages(i as usize));
|
|
wasmi::MemoryInstance::alloc(initial, maximum)
|
|
}
|
|
|
|
fn resolve_table(
|
|
&self,
|
|
_module_name: &str,
|
|
_field_name: &str,
|
|
descriptor: &wasmi::TableDescriptor,
|
|
) -> Result<wasmi::TableRef, wasmi::Error> {
|
|
// dummy implementation to ensure instantiation succeeds
|
|
let initial = descriptor.initial();
|
|
let maximum = descriptor.maximum();
|
|
wasmi::TableInstance::alloc(initial, maximum)
|
|
}
|
|
}
|
|
|
|
struct MyExternals(Vec<u32>);
|
|
|
|
#[derive(Debug)]
|
|
struct MyError(String);
|
|
|
|
impl wasmi::Externals for MyExternals {
|
|
fn invoke_index(
|
|
&mut self,
|
|
index: usize,
|
|
args: wasmi::RuntimeArgs,
|
|
) -> Result<Option<wasmi::RuntimeValue>, wasmi::Trap> {
|
|
macro_rules! bail {
|
|
($($t:tt)*) => ({
|
|
let s = MyError(format!($($t)*));
|
|
return Err(wasmi::Trap::new(wasmi::TrapKind::Host(Box::new(s))))
|
|
})
|
|
}
|
|
// We only recognize one function here which was mapped to the index 1
|
|
// by the resolver above.
|
|
if index != 1 {
|
|
bail!("only __wbindgen_describe can be run at this time")
|
|
}
|
|
if args.len() != 1 {
|
|
bail!("must have exactly one argument");
|
|
}
|
|
match args.nth_value_checked(0)? {
|
|
wasmi::RuntimeValue::I32(i) => self.0.push(i as u32),
|
|
_ => bail!("expected one argument of i32 type"),
|
|
}
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
impl wasmi::HostError for MyError {}
|
|
|
|
impl fmt::Display for MyError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
self.0.fmt(f)
|
|
}
|
|
}
|
|
|
|
fn reset_indentation(s: &str) -> String {
|
|
let mut indent: u32 = 0;
|
|
let mut dst = String::new();
|
|
|
|
for line in s.lines() {
|
|
let line = line.trim();
|
|
if line.starts_with('}') || (line.ends_with('}') && !line.starts_with('*')) {
|
|
indent = indent.saturating_sub(1);
|
|
}
|
|
let extra = if line.starts_with(':') || line.starts_with('?') { 1 } else { 0 };
|
|
for _ in 0..indent + extra {
|
|
dst.push_str(" ");
|
|
}
|
|
dst.push_str(line);
|
|
dst.push_str("\n");
|
|
if line.ends_with('{') {
|
|
indent += 1;
|
|
}
|
|
}
|
|
return dst
|
|
}
|