table64

Cargo.toml

@@ -7,8 +7,8 @@ license = "Apache-2.0 WITH LLVM-exception"
 edition = "2018"
 
 [dependencies]
-wasmparser = "0.202"
-wasm-encoder = "0.202"
+wasmparser = "0.212"
+wasm-encoder = "0.212"
 anyhow = "1.0"
 structopt = "0.3"
 log = "0.4"
@@ -26,6 +26,7 @@ indexmap = "2.2.2"
 stacker = "0.1.15"
 wasm-smith = { version = "0.202", optional = true }
 paste = "1.0.15"
+serde = { version = "1.0.204", features = ["derive"] }
 
 [features]
 default = []

src/backend/mod.rs

@@ -8,6 +8,7 @@ use anyhow::Result;
 use rayon::prelude::*;
 use std::borrow::Cow;
 use wasm_encoder::CustomSection;
+use wasm_encoder::Encode;
 
 pub mod stackify;
 use stackify::{Context as StackifyContext, WasmBlock};
@@ -210,8 +211,8 @@ impl<'a> WasmFuncBackend<'a> {
                         self.lower_value(value, func);
                     }
                     func.instruction(&wasm_encoder::Instruction::ReturnCallIndirect {
-                        ty: sig.index() as u32,
-                        table: table.index() as u32,
+                        type_index: sig.index() as u32,
+                        table_index: table.index() as u32,
                     });
                 }
                 WasmBlock::ReturnCallRef { sig, values } => {
@@ -299,8 +300,8 @@ impl<'a> WasmFuncBackend<'a> {
                 sig_index,
                 table_index,
             } => Some(wasm_encoder::Instruction::CallIndirect {
-                ty: sig_index.index() as u32,
-                table: table_index.index() as u32,
+                type_index: sig_index.index() as u32,
+                table_index: table_index.index() as u32,
             }),
             Operator::Select => Some(wasm_encoder::Instruction::Select),
             Operator::TypedSelect { ty } => Some(wasm_encoder::Instruction::TypedSelect(
@@ -1141,9 +1142,11 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
                     minimum: table
                         .func_elements
                         .as_ref()
-                        .map(|elts| elts.len() as u32)
+                        .map(|elts| elts.len() as u64)
                         .unwrap_or(table.initial),
                     maximum: table.max,
+                    table64: table.table64,
+                    
                 })
             }
             &ImportKind::Global(global) => {
@@ -1152,6 +1155,7 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
                 wasm_encoder::EntityType::Global(wasm_encoder::GlobalType {
                     val_type: wasm_encoder::ValType::from(global.ty),
                     mutable: global.mutable,
+                    shared: false,
                 })
             }
             &ImportKind::Memory(mem) => {
@@ -1162,6 +1166,7 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
                     shared: mem.shared,
                     minimum: mem.initial_pages as u64,
                     maximum: mem.maximum_pages.map(|val| val as u64),
+                    page_size_log2: None,
                 })
             }
         };
@@ -1192,8 +1197,9 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
                 .func_elements
                 .as_ref()
                 .map(|elt| elt.len())
-                .unwrap_or(0) as u32,
+                .unwrap_or(0) as u64,
             maximum: table_data.max,
+            table64: table_data.table64,
         });
     }
     into_mod.section(&tables);
@@ -1205,6 +1211,7 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
             maximum: mem_data.maximum_pages.map(|val| val as u64),
             memory64: mem_data.memory64,
             shared: mem_data.shared,
+            page_size_log2: None,
         });
     }
     into_mod.section(&memories);
@@ -1215,6 +1222,7 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
             wasm_encoder::GlobalType {
                 val_type: wasm_encoder::ValType::from(global_data.ty),
                 mutable: global_data.mutable,
+                shared: false,
             },
             &const_init(global_data.ty, global_data.value),
         );
@@ -1296,11 +1304,6 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
 
     let mut code = wasm_encoder::CodeSection::new();
 
-    enum FuncOrRawBytes<'a> {
-        Raw(&'a [u8]),
-        Func(Cow<'a, wasm_encoder::Function>),
-    }
-
     let bodies = module
         .funcs
         .entries()
@@ -1311,16 +1314,14 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
             match func_decl {
                 FuncDecl::Lazy(_, _name, reader) => {
                     let data = &module.orig_bytes[reader.range()];
-                    Ok(FuncOrRawBytes::Raw(data))
-                }
-                FuncDecl::Compiled(_, _name, encoder) => {
-                    Ok(FuncOrRawBytes::Func(Cow::Borrowed(encoder)))
+                    Ok(Cow::Borrowed(data))
                 }
+                FuncDecl::Compiled(_, _name, bytes) => Ok(Cow::Borrowed(&bytes[..])),
                 FuncDecl::Body(_, name, body) => {
                     log::debug!("Compiling {} \"{}\"", func, name);
                     WasmFuncBackend::new(body)?
                         .compile()
-                        .map(|func| FuncOrRawBytes::Func(Cow::Owned(func)))
+                        .map(|func| Cow::Owned(func.into_raw_body()))
                 }
                 FuncDecl::Import(_, _) => unreachable!("Should have skipped imports"),
                 FuncDecl::None => panic!("FuncDecl::None at compilation time"),
@@ -1329,14 +1330,7 @@ pub fn compile(module: &Module<'_>) -> anyhow::Result<wasm_encoder::Module> {
         .collect::<Result<Vec<_>>>()?;
 
     for body in bodies {
-        match body {
-            FuncOrRawBytes::Raw(bytes) => {
-                code.raw(bytes);
-            }
-            FuncOrRawBytes::Func(func) => {
-                code.function(&*func);
-            }
-        }
+        code.raw(&body);
     }
     into_mod.section(&code);
 

src/bin/waffle-util.rs

@@ -124,7 +124,7 @@ fn main() -> Result<()> {
             let mut ctx = InterpContext::new(&module)?;
             debug!("Calling start function");
             if let Some(start) = module.start_func {
-                ctx.call(&module, start, &[]).ok().unwrap();
+                ctx.call(&mut module, start, &[]).ok().unwrap();
             }
             // Find a function called `_start`, if any.
             if let Some(waffle::Export {
@@ -133,7 +133,7 @@ fn main() -> Result<()> {
             }) = module.exports.iter().find(|e| &e.name == "_start")
             {
                 debug!("Calling _start");
-                ctx.call(&module, *func, &[]).ok().unwrap();
+                ctx.call(&mut module, *func, &[]).ok().unwrap();
             }
         }
     }

src/entity.rs

@@ -22,7 +22,7 @@ pub trait EntityRef: Clone + Copy + PartialEq + Eq + PartialOrd + Ord + Hash {
 #[macro_export]
 macro_rules! declare_entity {
     ($name:tt, $prefix:tt) => {
-        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
         pub struct $name(u32);
 
         impl $crate::entity::EntityRef for $name {
@@ -73,7 +73,7 @@ macro_rules! declare_entity {
     };
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct EntityVec<Idx: EntityRef, T: Clone + Debug>(Vec<T>, PhantomData<Idx>);
 
 impl<Idx: EntityRef, T: Clone + Debug> std::default::Default for EntityVec<Idx, T> {
@@ -151,7 +151,7 @@ impl<Idx: EntityRef, T: Clone + Debug> IndexMut<Idx> for EntityVec<Idx, T> {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub struct PerEntity<Idx: EntityRef, T: Clone + Debug + Default>(Vec<T>, PhantomData<Idx>, T);
 
 impl<Idx: EntityRef, T: Clone + Debug + Default> Index<Idx> for PerEntity<Idx, T> {

src/frontend.rs

@@ -13,9 +13,7 @@ use anyhow::{bail, Result};
 use fxhash::{FxHashMap, FxHashSet};
 use log::trace;
 use std::convert::TryFrom;
-use wasmparser::{
-    BlockType, DataKind, ExternalKind, Name, NameSectionReader, Parser, Payload, TypeRef,
-};
+use wasmparser::{BlockType, DataKind, ExternalKind, KnownCustom, Name, Parser, Payload, TypeRef};
 
 #[derive(Clone, Copy, Debug, Default)]
 pub struct FrontendOptions {
@@ -137,6 +135,7 @@ fn handle_payload<'a>(
                             ty.element_type.into(),
                             ty.initial,
                             ty.maximum,
+                            ty.table64,
                         );
                         ImportKind::Table(table)
                     }
@@ -184,6 +183,7 @@ fn handle_payload<'a>(
                     table.ty.element_type.into(),
                     table.ty.initial,
                     table.ty.maximum,
+                    table.ty.table64,
                 );
             }
         }
@@ -255,72 +255,68 @@ fn handle_payload<'a>(
                 }
             }
         }
-        Payload::CustomSection(reader) if reader.name() == "name" => {
-            let name_reader = NameSectionReader::new(reader.data(), reader.data_offset());
-            for subsection in name_reader {
-                let subsection = subsection?;
-                match subsection {
-                    Name::Function(names) => {
-                        for name in names {
-                            let name = name?;
-                            module.funcs[Func::new(name.index as usize)].set_name(name.name);
+        Payload::CustomSection(reader) => match reader.as_known() {
+            KnownCustom::Name(name_reader) => {
+                for subsection in name_reader {
+                    let subsection = subsection?;
+                    match subsection {
+                        Name::Function(names) => {
+                            for name in names {
+                                let name = name?;
+                                module.funcs[Func::new(name.index as usize)].set_name(name.name);
+                            }
                         }
+                        _ => {}
                     }
-                    _ => {}
                 }
             }
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_info" => {
-            dwarf.debug_info = gimli::DebugInfo::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_abbrev" => {
-            dwarf.debug_abbrev = gimli::DebugAbbrev::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_addr" => {
-            dwarf.debug_addr =
-                gimli::DebugAddr::from(gimli::EndianSlice::new(reader.data(), gimli::LittleEndian));
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_aranges" => {
-            dwarf.debug_aranges = gimli::DebugAranges::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_line" => {
-            dwarf.debug_line = gimli::DebugLine::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_line_str" => {
-            dwarf.debug_line_str = gimli::DebugLineStr::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_str" => {
-            dwarf.debug_str = gimli::DebugStr::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_str_offsets" => {
-            dwarf.debug_str_offsets = gimli::DebugStrOffsets::from(gimli::EndianSlice::new(
-                reader.data(),
-                gimli::LittleEndian,
-            ));
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_types" => {
-            dwarf.debug_types = gimli::DebugTypes::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_loc" => {
-            extra_sections.debug_loc = gimli::DebugLoc::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_loclists" => {
-            extra_sections.debug_loclists =
-                gimli::DebugLocLists::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_ranges" => {
-            extra_sections.debug_ranges =
-                gimli::DebugRanges::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) if reader.name() == ".debug_rnglists" => {
-            extra_sections.debug_rnglists =
-                gimli::DebugRngLists::new(reader.data(), gimli::LittleEndian);
-        }
-        Payload::CustomSection(reader) => {
-            module
-                .custom_sections
-                .insert(reader.name().to_owned(), reader.data().to_owned());
-        }
+            KnownCustom::Unknown => {
+                if reader.name() == ".debug_info" {
+                    dwarf.debug_info = gimli::DebugInfo::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_abbrev" {
+                    dwarf.debug_abbrev =
+                        gimli::DebugAbbrev::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_addr" {
+                    dwarf.debug_addr = gimli::DebugAddr::from(gimli::EndianSlice::new(
+                        reader.data(),
+                        gimli::LittleEndian,
+                    ));
+                } else if reader.name() == ".debug_aranges" {
+                    dwarf.debug_aranges =
+                        gimli::DebugAranges::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_line" {
+                    dwarf.debug_line = gimli::DebugLine::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_line_str" {
+                    dwarf.debug_line_str =
+                        gimli::DebugLineStr::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_str" {
+                    dwarf.debug_str = gimli::DebugStr::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_str_offsets" {
+                    dwarf.debug_str_offsets = gimli::DebugStrOffsets::from(
+                        gimli::EndianSlice::new(reader.data(), gimli::LittleEndian),
+                    );
+                } else if reader.name() == ".debug_types" {
+                    dwarf.debug_types = gimli::DebugTypes::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_loc" {
+                    extra_sections.debug_loc =
+                        gimli::DebugLoc::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_loclists" {
+                    extra_sections.debug_loclists =
+                        gimli::DebugLocLists::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_ranges" {
+                    extra_sections.debug_ranges =
+                        gimli::DebugRanges::new(reader.data(), gimli::LittleEndian);
+                } else if reader.name() == ".debug_rnglists" {
+                    extra_sections.debug_rnglists =
+                        gimli::DebugRngLists::new(reader.data(), gimli::LittleEndian);
+                }else{
+                    module
+                    .custom_sections
+                    .insert(reader.name().to_owned(), reader.data().to_owned());
+                }
+            }
+            _ => {}
+        },
         Payload::Version { .. } => {}
         Payload::ElementSection(reader) => {
             for element in reader {

src/interp.rs

@@ -6,6 +6,7 @@ use crate::ops::Operator;
 use smallvec::{smallvec, SmallVec};
 
 use std::collections::HashMap;
+use std::sync::Arc;
 
 mod wasi;
 
@@ -18,8 +19,7 @@ pub struct InterpContext {
     pub globals: PerEntity<Global, ConstVal>,
     pub fuel: u64,
     pub trace_handler: Option<Box<dyn Fn(usize, Vec<ConstVal>) -> bool + Send>>,
-    pub import_hander:
-        Option<Box<dyn FnMut(&mut InterpContext, &str, &[ConstVal]) -> InterpResult>>,
+    pub import_hander: Arc<dyn Fn(&mut InterpContext,&mut Module<'_>, &str, &[ConstVal]) -> InterpResult>,
 }
 
 type MultiVal = SmallVec<[ConstVal; 2]>;
@@ -88,11 +88,11 @@ impl InterpContext {
             globals,
             fuel: u64::MAX,
             trace_handler: None,
-            import_hander: None,
+            import_hander: Arc::new(|_, _, _,_| InterpResult::TraceHandlerQuit),
         })
     }
 
-    pub fn call(&mut self, module: &Module<'_>, mut func: Func, args: &[ConstVal]) -> InterpResult {
+    pub fn call(&mut self, module: &mut Module<'_>, mut func: Func, args: &[ConstVal]) -> InterpResult {
         let mut args = args.to_vec();
         'redo: loop {
             let body = match &module.funcs[func] {
@@ -101,9 +101,9 @@ impl InterpContext {
                 FuncDecl::Import(..) => {
                     let import = &module.imports[func.index()];
                     assert_eq!(import.kind, ImportKind::Func(func));
-                    return self.call_import(&import.name[..], &args);
+                    return self.call_import(module,&import.name[..].to_owned(), &args);
                 }
-                FuncDecl::Body(_, _, body) => body,
+                FuncDecl::Body(_, _, body) => body.clone(),
                 FuncDecl::None => panic!("FuncDecl::None in call()"),
             };
 
@@ -178,6 +178,25 @@ impl InterpContext {
                                 _ => return result,
                             }
                         }
+                        &ValueDef::Operator(Operator::CallRef { .. }, args, _) => {
+                            let args = body.arg_pool[args]
+                                .iter()
+                                .map(|&arg| {
+                                    let arg = body.resolve_alias(arg);
+                                    let multivalue = frame.values.get(&arg).unwrap();
+                                    assert_eq!(multivalue.len(), 1);
+                                    multivalue[0]
+                                })
+                                .collect::<Vec<_>>();
+                            let ConstVal::Ref(Some(func)) = args.last().unwrap() else {
+                                return InterpResult::TraceHandlerQuit;
+                            };
+                            let result = self.call(module, *func, &args[..args.len() - 1]);
+                            match result {
+                                InterpResult::Ok(vals) => vals,
+                                _ => return result,
+                            }
+                        }
                         &ValueDef::Operator(ref op, args, _) => {
                             let args = body.arg_pool[args]
                                 .iter()
@@ -284,7 +303,7 @@ impl InterpContext {
                         return InterpResult::Trap(frame.func, frame.cur_block, u32::MAX)
                     }
                     &Terminator::Br { ref target } => {
-                        frame.apply_target(body, target);
+                        frame.apply_target(&body, target);
                     }
                     &Terminator::CondBr {
                         cond,
@@ -295,9 +314,9 @@ impl InterpContext {
                         let cond = frame.values.get(&cond).unwrap();
                         let cond = cond[0].as_u32().unwrap() != 0;
                         if cond {
-                            frame.apply_target(body, if_true);
+                            frame.apply_target(&body, if_true);
                         } else {
-                            frame.apply_target(body, if_false);
+                            frame.apply_target(&body, if_false);
                         }
                     }
                     &Terminator::Select {
@@ -309,9 +328,9 @@ impl InterpContext {
                         let value = frame.values.get(&value).unwrap();
                         let value = value[0].as_u32().unwrap() as usize;
                         if value < targets.len() {
-                            frame.apply_target(body, &targets[value]);
+                            frame.apply_target(&body, &targets[value]);
                         } else {
-                            frame.apply_target(body, default);
+                            frame.apply_target(&body, default);
                         }
                     }
                     &Terminator::Return { ref values } => {
@@ -325,16 +344,35 @@ impl InterpContext {
                         log::trace!("returning from {}: {:?}", func, values);
                         return InterpResult::Ok(values);
                     }
-                    Terminator::ReturnCallRef { sig, args } => todo!(),
+                    Terminator::ReturnCallRef {
+                        sig,
+                        args: ref args2,
+                    } => {
+                        let args2 = args2
+                            .iter()
+                            .map(|&arg| {
+                                let arg = body.resolve_alias(arg);
+                                let multivalue = frame.values.get(&arg).unwrap();
+                                assert_eq!(multivalue.len(), 1);
+                                multivalue[0]
+                            })
+                            .collect::<Vec<_>>();
+                        let ConstVal::Ref(Some(fu)) = args.last().unwrap() else {
+                            return InterpResult::TraceHandlerQuit;
+                        };
+                        func = *fu;
+                        args = args2[..args2.len() - 1].to_vec();
+                        continue 'redo;
+                    }
                 }
             }
         }
     }
 
-    fn call_import(&mut self, name: &str, args: &[ConstVal]) -> InterpResult {
-        let mut r = self.import_hander.take().unwrap();
-        let rs = r(self, name, args);
-        self.import_hander = Some(r);
+    fn call_import(&mut self,module: &mut Module<'_>, name: &str, args: &[ConstVal]) -> InterpResult {
+        let mut r = self.import_hander.clone();
+        let rs = r(self, module,name, args);
+        // self.import_hander = Some(r);
         return rs;
     }
 }
@@ -388,6 +426,7 @@ pub enum ConstVal {
     I64(u64),
     F32(u32),
     F64(u64),
+    Ref(Option<Func>),
     #[default]
     None,
 }
@@ -995,9 +1034,32 @@ pub fn const_eval(
             ConstVal::None
         }),
 
-        (Operator::TableGet { .. }, _)
-        | (Operator::TableSet { .. }, _)
-        | (Operator::TableGrow { .. }, _) => None,
+        (Operator::TableGet { table_index }, [ConstVal::I32(i)]) => ctx.and_then(|global| {
+            Some(ConstVal::Ref(
+                global.tables[*table_index]
+                    .elements
+                    .get(*i as usize)
+                    .and_then(|x| {
+                        if *x == Func::invalid() {
+                            None
+                        } else {
+                            Some(*x)
+                        }
+                    }),
+            ))
+        }),
+        (Operator::TableSet { table_index }, [ConstVal::I32(i), ConstVal::Ref(r)]) => {
+            ctx.and_then(|global| {
+                global.tables[*table_index].elements[*i as usize] = r.unwrap_or_default();
+                Some(ConstVal::I32(0))
+            })
+        }
+        (Operator::TableGrow { table_index }, [ConstVal::I32(i)]) => ctx.and_then(|global| {
+            global.tables[*table_index]
+                .elements
+                .extend((0..*i).map(|a| Func::default()));
+            Some(ConstVal::I32(0))
+        }),
 
         (Operator::TableSize { table_index }, []) => {
             ctx.map(|global| ConstVal::I32(global.tables[*table_index].elements.len() as u32))
@@ -1232,6 +1294,16 @@ pub fn const_eval(
                 write_u64(&mut global.memories[memory.memory], addr, *data);
                 Some(ConstVal::None)
             }),
+        (Operator::RefFunc { func_index }, []) => Some(ConstVal::Ref(Some(*func_index))),
+        (
+            Operator::RefNull {
+                ty: Type::FuncRef | Type::TypedFuncRef { .. },
+            },
+            [],
+        ) => Some(ConstVal::Ref(None)),
+        (Operator::RefIsNull, [ConstVal::Ref(r)]) => {
+            Some(ConstVal::I32(if r.is_none() { 1 } else { 0 }))
+        }
         (_, args) if args.iter().any(|&arg| arg == ConstVal::None) => None,
         _ => None,
     }

src/ir.rs

@@ -2,7 +2,7 @@
 
 use crate::{declare_entity, entity::EntityRef};
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
 pub enum Type {
     I32,
     I64,

src/ir/debug.rs

@@ -9,7 +9,7 @@ use std::collections::HashMap;
 declare_entity!(SourceFile, "file");
 declare_entity!(SourceLoc, "loc");
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub struct Debug {
     pub source_files: EntityVec<SourceFile, String>,
     source_file_dedup: HashMap<String, SourceFile>,
@@ -17,7 +17,7 @@ pub struct Debug {
     source_loc_dedup: HashMap<SourceLocData, SourceLoc>,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
 pub struct SourceLocData {
     pub file: SourceFile,
     pub line: u32,
@@ -46,7 +46,7 @@ impl Debug {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub struct DebugMap {
     /// Offset of code section relative to the Wasm file start.
     pub code_offset: u32,

src/ir/func.rs

@@ -13,16 +13,16 @@ use std::collections::HashSet;
 
 /// A declaration of a function: there is one `FuncDecl` per `Func`
 /// index.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub enum FuncDecl<'a> {
     /// An imported function.
     Import(Signature, String),
     /// An un-expanded body that can be lazily expanded if needed.
-    Lazy(Signature, String, wasmparser::FunctionBody<'a>),
+    #[serde(skip)]Lazy(Signature, String, wasmparser::FunctionBody<'a>),
     /// A modified or new function body that requires compilation.
     Body(Signature, String, FunctionBody),
     /// A compiled function body (was IR, has been collapsed back to bytecode).
-    Compiled(Signature, String, wasm_encoder::Function),
+    Compiled(Signature, String, Vec<u8>),
     /// A placeholder.
     #[default]
     None,
@@ -113,7 +113,7 @@ impl<'a> FuncDecl<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub struct FunctionBody {
     /// How many parameters the function has. (Their types are the
     /// first `n_params` values in `locals`.)
@@ -481,7 +481,7 @@ impl FunctionBody {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub struct BlockDef {
     /// Instructions in this block.
     pub insts: Vec<Value>,
@@ -501,7 +501,7 @@ pub struct BlockDef {
     pub desc: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct BlockTarget {
     pub block: Block,
     pub args: Vec<Value>,
@@ -518,7 +518,7 @@ impl std::fmt::Display for BlockTarget {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum Terminator {
     Br {
         target: BlockTarget,

src/ir/module.rs

@@ -7,7 +7,7 @@ use indexmap::IndexMap;
 
 pub use crate::frontend::FrontendOptions;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct Module<'a> {
     pub orig_bytes: &'a [u8],
     pub funcs: EntityVec<Func, FuncDecl<'a>>,
@@ -23,13 +23,13 @@ pub struct Module<'a> {
     pub custom_sections: IndexMap<String, Vec<u8>>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
 pub struct SignatureData {
     pub params: Vec<Type>,
     pub returns: Vec<Type>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
 pub struct MemoryData {
     pub initial_pages: usize,
     pub maximum_pages: Option<usize>,
@@ -38,21 +38,22 @@ pub struct MemoryData {
     pub shared: bool,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
 pub struct MemorySegment {
     pub offset: usize,
     pub data: Vec<u8>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
 pub struct TableData {
     pub ty: Type,
-    pub initial: u32,
-    pub max: Option<u32>,
+    pub table64: bool,
+    pub initial: u64,
+    pub max: Option<u64>,
     pub func_elements: Option<Vec<Func>>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
 pub struct GlobalData {
     pub ty: Type,
     pub value: Option<u64>,
@@ -81,14 +82,14 @@ impl From<wasmparser::FuncType> for SignatureData {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct Import {
     pub module: String,
     pub name: String,
     pub kind: ImportKind,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum ImportKind {
     Table(Table),
     Func(Func),
@@ -108,13 +109,13 @@ impl std::fmt::Display for ImportKind {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct Export {
     pub name: String,
     pub kind: ExportKind,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ExportKind {
     Table(Table),
     Func(Func),
@@ -177,13 +178,14 @@ impl<'a> Module<'a> {
 }
 
 impl<'a> Module<'a> {
-    pub(crate) fn frontend_add_table(&mut self, ty: Type, initial: u32, max: Option<u32>) -> Table {
+    pub(crate) fn frontend_add_table(&mut self, ty: Type, initial: u64, max: Option<u64>, table64: bool) -> Table {
         let func_elements = Some(vec![]);
         self.tables.push(TableData {
             ty,
             func_elements,
             initial,
             max,
+            table64
         })
     }
 

src/ir/value.rs

@@ -2,7 +2,7 @@ use super::{Block, Type, Value};
 use crate::pool::{ListPool, ListRef};
 use crate::Operator;
 
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub enum ValueDef {
     BlockParam(Block, u32, Type),
     Operator(Operator, ListRef<Value>, ListRef<Type>),

src/lib.rs

@@ -4,6 +4,8 @@
 
 // Re-export wasmparser for easier use of the right version by our embedders.
 pub use wasmparser;
+// Likewise for wasm-encoder.
+pub use wasm_encoder;
 
 mod backend;
 pub mod cfg;

src/op_traits.rs

@@ -257,12 +257,24 @@ pub fn op_inputs(
         Operator::F64ReinterpretI64 => Ok(Cow::Borrowed(&[Type::I64])),
         Operator::I32ReinterpretF32 => Ok(Cow::Borrowed(&[Type::F32])),
         Operator::I64ReinterpretF64 => Ok(Cow::Borrowed(&[Type::F64])),
-        Operator::TableGet { .. } => Ok(Cow::Borrowed(&[Type::I32])),
+        Operator::TableGet { table_index } => if module.tables[*table_index].table64{
+            Ok(Cow::Borrowed(&[Type::I64]))
+        }else{
+            Ok(Cow::Borrowed(&[Type::I32]))
+        },
         Operator::TableSet { table_index } => {
-            Ok(vec![Type::I32, module.tables[*table_index].ty].into())
+            Ok(vec![if module.tables[*table_index].table64{
+                Type::I64
+            }else{
+                Type::I32
+            }, module.tables[*table_index].ty].into())
         }
         Operator::TableGrow { table_index } => {
-            Ok(vec![Type::I32, module.tables[*table_index].ty].into())
+            Ok(vec![if module.tables[*table_index].table64{
+                Type::I64
+            }else{
+                Type::I32
+            }, module.tables[*table_index].ty].into())
         }
         Operator::TableSize { .. } => Ok(Cow::Borrowed(&[])),
         Operator::MemorySize { .. } => Ok(Cow::Borrowed(&[])),
@@ -1302,7 +1314,11 @@ pub fn op_outputs(
         Operator::TableGet { table_index } => Ok(vec![module.tables[*table_index].ty].into()),
         Operator::TableSet { .. } => Ok(Cow::Borrowed(&[])),
         Operator::TableGrow { .. } => Ok(Cow::Borrowed(&[])),
-        Operator::TableSize { .. } => Ok(Cow::Borrowed(&[Type::I32])),
+        Operator::TableSize { table_index } => Ok(Cow::Borrowed(if module.tables[*table_index].table64{
+            &[Type::I64]
+        }else{
+            &[Type::I32]
+        })),
         Operator::MemorySize { mem } => Ok(if module.memories[*mem].memory64 {
             Cow::Borrowed(&[Type::I64])
         } else {

src/ops.rs

@@ -5,7 +5,7 @@ use anyhow::Context;
 use std::convert::TryFrom;
 pub use wasmparser::{Ieee32, Ieee64};
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct MemoryArg {
     pub align: u32,
     pub offset: u64 ,
@@ -23,7 +23,7 @@ impl std::fmt::Display for MemoryArg {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub enum Operator {
     Unreachable,
     Nop,

src/passes/mem_fusing.rs

@@ -1,4 +1,4 @@
-use std::{collections::BTreeMap, convert::Infallible, iter::empty};
+use std::{collections::BTreeMap, convert::Infallible, iter::{empty, once}};
 
 use anyhow::Context;
 // use libc::name_t;
@@ -55,7 +55,7 @@ impl Fuse {
             target: d,
         });
     }
-    pub fn finalize(self, m: &mut Module) -> Memory{
+    pub fn finalize(self, m: &mut Module) -> Memory {
         let mem = m.memories[self.target].clone();
         m.memories = EntityVec::default();
         let new = m.memories.push(mem);
@@ -110,7 +110,7 @@ impl Fuse {
         // }
         return new;
     }
-    pub fn process(&self, f: &mut FunctionBody) {
+    pub fn process(&self, m: &mut Module, f: &mut FunctionBody) {
         let vz = f.arg_pool.from_iter(empty());
         let tz = f.type_pool.from_iter(empty());
         let ti = f.type_pool.from_iter(vec![Type::I32].into_iter());
@@ -123,6 +123,42 @@ impl Fuse {
                 // let vi = v;
                 if let ValueDef::Operator(a, b, c) = &mut w {
                     let mut bp = f.arg_pool[*b].to_vec();
+                    fn g(
+                        a: impl for<'a> FnMut(&mut Module,&mut FunctionBody, Memory, &'a mut crate::Value),
+                    ) -> impl for<'a> FnMut(&mut Module,&mut FunctionBody, Memory, &'a mut crate::Value)
+                    {
+                        return a;
+                    }
+                    let mut p = g(|m: &mut Module,f, mem, v| {
+                        match (m.memories[mem].memory64, m.memories[self.target].memory64) {
+                            (true, true) => {}
+                            (true, false) => {
+                                let ti = f.type_pool.from_iter(once(Type::I32));
+                                let w = f.arg_pool.from_iter(vec![*v].into_iter());
+                                let x = f.add_value(ValueDef::Operator(
+                                    Operator::I32WrapI64,
+                                    w,
+                                    ti,
+                                ));
+                                f.append_to_block(k, x);
+                                // crate::append_before(f, x, vi, k);
+                                *v = x;
+                            }
+                            (false, true) => {
+                                let ti = f.type_pool.from_iter(once(Type::I64));
+                                let w = f.arg_pool.from_iter(vec![*v].into_iter());
+                                let x = f.add_value(ValueDef::Operator(
+                                    Operator::I64ExtendI32U,
+                                    w,
+                                    ti,
+                                ));
+                                f.append_to_block(k, x);
+                                // crate::append_before(f, x, vi, k);
+                                *v = x;
+                            },
+                            (false, false) => {}
+                        }
+                    });
                     match a.clone() {
                         Operator::MemorySize { mem } => {
                             if mem != self.target {
@@ -139,6 +175,7 @@ impl Fuse {
                                     function_index: self.size,
                                 };
                                 bp.push(ia);
+                                p(m,f, mem, &mut bp[0]);
                             }
                         }
                         Operator::MemoryGrow { mem } => {
@@ -156,20 +193,22 @@ impl Fuse {
                                     function_index: self.grow,
                                 };
                                 bp.push(ia);
+                                p(m, f,mem, &mut bp[0]);
                             }
                         }
-                        _ => crate::op_traits::rewrite_mem(a, &mut bp, |m, v| {
-                            if *m != self.target{
+                        _ => crate::op_traits::rewrite_mem(a, &mut bp, |mem, v| {
+                            if *mem != self.target {
                                 let ia = f.add_value(ValueDef::Operator(
                                     Operator::I32Const {
-                                        value: m.index() as u32,
+                                        value: mem.index() as u32,
                                     },
                                     vz,
                                     ti,
                                 ));
-                                f.append_to_block(k, ia); 
+                                f.append_to_block(k, ia);
                                 // append_before(f, ia, vi, k);
                                 if let Some(v) = v {
+                                    p(m,f, *mem, &mut *v);
                                     let w = f.arg_pool.from_iter(vec![*v, ia].into_iter());
                                     let x = f.add_value(ValueDef::Operator(
                                         Operator::Call {
@@ -182,10 +221,11 @@ impl Fuse {
                                     // crate::append_before(f, x, vi, k);
                                     *v = x;
                                 }
-                                *m = self.target;
+                                *mem = self.target;
                             }
-                            Ok::<(),Infallible>(())
-                        }).unwrap(),
+                            Ok::<(), Infallible>(())
+                        })
+                        .unwrap(),
                     }
                     *b = *ka
                         .entry(bp.clone())
@@ -201,7 +241,7 @@ pub fn fuse(m: &mut Module) -> anyhow::Result<()> {
     let f = Fuse::new(m).context("in getting the fuse funcs")?;
     crate::passes::unmem::metafuse_all(m, &mut crate::passes::unmem::All {});
     // crate::passes::splice::splice_module(m)?;
-    m.per_func_body(|b| f.process(b));
+    m.take_per_func_body(|m, b| f.process(m, b));
     f.finalize(m);
     return Ok(());
 }

src/pool.rs

@@ -5,7 +5,7 @@ use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ops::{Index, IndexMut};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct ListPool<T: Clone + Debug> {
     pub storage: Vec<T>,
 }
@@ -16,7 +16,7 @@ impl<T: Clone + Debug> Default for ListPool<T> {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub struct ListRef<T>(u32, u32, PhantomData<T>);
 
 impl<T> Default for ListRef<T> {