C/JS accessors for function table segments

module.getNumFunctionTableSegments() gives the number of segments.

module.getFunctionTableSegmentInfoByIndex() yields:
```
{
  offset,
  functions: ["func1", "func2"]
}
```

Another piece for #2370

Author: bvibber

src/binaryen-c.cpp

@@ -3561,6 +3561,92 @@ void BinaryenSetFunctionTable(BinaryenModuleRef module,
   wasm->table.segments.push_back(segment);
 }
 
+// Function table segments. Query utilities.
+
+uint32_t BinaryenGetNumFunctionTableSegments(BinaryenModuleRef module) {
+  if (tracing) {
+    std::cout << "  BinaryenGetNumFunctionTableSegments(the_module);\n";
+  }
+
+  auto* wasm = (Module*)module;
+  return wasm->table.segments.size();
+}
+
+uint32_t
+BinaryenGetFunctionTableSegmentOffset(BinaryenModuleRef module, BinaryenIndex id) {
+  if (tracing) {
+    std::cout << "  BinaryenGetFunctionTableSegmentOffset(the_module, " << id
+              << ");\n";
+  }
+
+  auto* wasm = (Module*)module;
+  if (wasm->table.segments.size() <= id) {
+    Fatal() << "invalid segment id.";
+  }
+
+  auto globalOffset = [&](const Expression* const& expr,
+                          int64_t& result) -> bool {
+    if (auto* c = expr->dynCast<Const>()) {
+      result = c->value.getInteger();
+      return true;
+    }
+    return false;
+  };
+
+  const Table::Segment& segment = wasm->table.segments[id];
+
+  int64_t ret;
+  if (globalOffset(segment.offset, ret)) {
+    return ret;
+  }
+  if (auto* get = segment.offset->dynCast<GlobalGet>()) {
+    Global* global = wasm->getGlobal(get->name);
+    if (globalOffset(global->init, ret)) {
+      return ret;
+    }
+  }
+
+  Fatal() << "non-constant offsets aren't supported yet";
+  return 0;
+}
+
+size_t BinaryenGetFunctionTableSegmentLength(BinaryenModuleRef module,
+                                             BinaryenIndex id) {
+  if (tracing) {
+    std::cout << "  BinaryenGetFunctionTableSegmentLength(the_module, " << id
+              << ");\n";
+  }
+
+  auto* wasm = (Module*)module;
+  if (wasm->table.segments.size() <= id) {
+    Fatal() << "invalid segment id.";
+  }
+  const Table::Segment& segment = wasm->table.segments[id];
+  return segment.data.size();
+}
+
+const char *
+BinaryenGetFunctionTableSegmentEntry(BinaryenModuleRef module,
+                                     BinaryenIndex id,
+                                     size_t entry) {
+  if (tracing) {
+    std::cout << "  BinaryenGetFunctionTableSegmentEntry(the_module, " << id << ", "
+              << entry << ");\n";
+  }
+
+  auto* wasm = (Module*)module;
+  if (wasm->memory.segments.size() <= id) {
+    Fatal() << "invalid segment id.";
+  }
+  const Table::Segment& segment = wasm->table.segments[id];
+  if (segment.data.size() <= entry) {
+    Fatal() << "invalid segment entry index.";
+  }
+  return segment.data[entry].c_str();
+}
+
+
+
 // Memory. One per module
 
 void BinaryenSetMemory(BinaryenModuleRef module,

src/binaryen-c.h

@@ -1198,6 +1198,19 @@ BINARYEN_API void BinaryenSetFunctionTable(BinaryenModuleRef module,
                                            BinaryenIndex numFuncNames,
                                            BinaryenExpressionRef offset);
 
+// Function table segments. Query utilities.
+
+BINARYEN_API uint32_t BinaryenGetNumFunctionTableSegments(BinaryenModuleRef module);
+BINARYEN_API uint32_t
+BinaryenGetFunctionTableSegmentOffset(BinaryenModuleRef module, BinaryenIndex id);
+BINARYEN_API size_t BinaryenGetFunctionTableSegmentLength(BinaryenModuleRef module,
+                                                          BinaryenIndex id);
+BINARYEN_API
+const char* BinaryenGetFunctionTableSegmentEntry(BinaryenModuleRef module,
+                                                 BinaryenIndex id,
+                                                 size_t entry);
+
+
 // Memory. One per module
 
 // Each segment has data in segments, a start offset in segmentOffsets, and a

src/js/binaryen.js-post.js

@@ -2158,6 +2158,22 @@ function wrapModule(module, self) {
       );
     });
   };
+  self['getNumFunctionTableSegments'] = function() {
+    return Module['_BinaryenGetNumFunctionTableSegments'](module);
+  };
+  self['getFunctionTableSegmentInfoByIndex'] = function(id) {
+    return {
+      'offset': Module['_BinaryenGetFunctionTableSegmentOffset'](module, id),
+      'functions': (function(){
+        var size = Module['_BinaryenGetFunctionTableSegmentLength'](module, id);
+        var res = new Array(size);
+        for (var i = 0; i < size; i++) {
+          res[i] = UTF8ToString(Module['_BinaryenGetFunctionTableSegmentEntry'](module, id, i));
+        }
+        return res;
+      })()
+    };
+  };
   self['setMemory'] = function(initial, maximum, exportName, segments, shared) {
     // segments are assumed to be { passive: bool, offset: expression ref, data: array of 8-bit data }
     if (!segments) segments = [];

test/binaryen.js/kitchen-sink.js

@@ -966,6 +966,21 @@ function test_for_each() {
     assert(expected_data[i] === str);
   }
 
+  var expected_table_offsets = [0];
+  var expected_table_functions = [
+    ['fn0', 'fn1', 'fn2']
+  ];
+  module.setFunctionTable(3, 3, ['fn0', 'fn1', 'fn2'])
+  assert(expected_table_offsets.length === module.getNumFunctionTableSegments());
+  for (i = 0 ; i < module.getNumFunctionTableSegments() ; i++) {
+    var segment = module.getFunctionTableSegmentInfoByIndex(i);
+    assert(expected_table_offsets[i] === segment.offset);
+    assert(expected_table_functions[i].length === segment.functions.length);
+    for (var j = 0; j < segment.functions.length; j++) {
+      assert(expected_table_functions[i][j] === segment.functions[j]);
+    }
+  }
+
   console.log(module.emitText());
   module.dispose();
 }

test/binaryen.js/kitchen-sink.js.txt

@@ -10317,6 +10317,8 @@ sizeof Literal: 24
  (memory $0 1 256)
  (data (i32.const 10) "hello, world")
  (data (global.get $a-global) "segment data 2")
+ (table $0 3 3 funcref)
+ (elem (i32.const 0) $fn0 $fn1 $fn2)
  (global $a-global i32 (i32.const 125))
  (export "export0" (func $fn0))
  (export "export1" (func $fn1))