Add a convenience for getting the function tables

src/module/functions/local_function/emit.rs

@@ -56,7 +56,7 @@ impl Emit<'_, '_> {
         let old = self.id;
         self.id = id;
 
-        match &self.func.get(id) {
+        match self.func.get(id) {
             Const(e) => e.value.emit(self.encoder),
             Block(e) => self.visit_block(e),
             BrTable(e) => self.visit_br_table(e),

src/module/functions/mod.rs

@@ -424,6 +424,7 @@ impl Emit for ModuleFunctions {
         let bytes = functions
             .into_par_iter()
             .map(|(id, func, _size)| {
+                log::debug!("emit function {:?} {:?}", id, cx.module.funcs.get(id).name);
                 let mut wasm = Vec::new();
                 let mut encoder = Encoder::new(&mut wasm);
                 let local_indices = func.emit_locals(id, cx.module, cx.used, &mut encoder);

src/module/tables.rs

@@ -132,6 +132,31 @@ impl ModuleTables {
     pub fn iter(&self) -> impl Iterator<Item = &Table> {
         self.arena.iter().map(|p| p.1)
     }
+
+    /// Finds a unique function table in a module.
+    ///
+    /// Modules produced by compilers like LLVM typically have one function
+    /// table for indirect function calls. This function will look for a single
+    /// function table inside this module, and return that if found. If no
+    /// function tables are present `None` will be returned
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if there are two function tables in this module
+    pub fn main_function_table(&self) -> Result<Option<TableId>> {
+        let mut tables = self.iter().filter_map(|t| match t.kind {
+            TableKind::Function(_) => Some(t.id()),
+            _ => None,
+        });
+        let id = match tables.next() {
+            Some(id) => id,
+            None => return Ok(None),
+        };
+        if tables.next().is_some() {
+            failure::bail!("module contains more than one function table");
+        }
+        Ok(Some(id))
+    }
 }
 
 impl Module {