[reference-types] remove single table restriction in IR

CHANGELOG.md

@@ -16,6 +16,32 @@ Current Trunk
 -------------
 
 - `wasm-dis` now supports options to enable or disable Wasm features.
+- Reference types support has been improved by allowing multiple tables in a
+  module.
+- `call_indirect` and `return_call_indirect` now take an additional table name
+  parameter. This is necessary for reference types support.
+- New getter/setter methods have been introduced for `call_indirect` table name:
+  - `BinaryenCallIndirectGetTable`
+  - `BinaryenCallIndirectSetTable`
+  - JS API `CallIndirect.table`
+- New APIs have been added to add and manipulate multiple tables in a module:
+  - `BinaryenAddTable`
+  - `BinaryenRemoveTable`
+  - `BinaryenGetNumTables`
+  - `BinaryenGetTable`
+  - `BinaryenGetTableByIndex`
+  - `BinaryenTableGetName`
+  - `BinaryenTableGetInitial`
+  - `BinaryenTableHasMax`
+  - `BinaryenTableGetMax`
+  - `BinaryenTableImportGetModule`
+  - `BinaryenTableImportGetBase`
+  - `module.addTable`
+  - `module.removeTable`
+  - `module.getTable`
+  - `module.getTableByIndex`
+  - `module.getNumTables`
+  - `binaryen.getTableInfo`
 
 v99
 ---

src/binaryen-c.cpp

@@ -805,13 +805,15 @@ BinaryenExpressionRef BinaryenReturnCall(BinaryenModuleRef module,
 }
 static BinaryenExpressionRef
 makeBinaryenCallIndirect(BinaryenModuleRef module,
+                         const char* table,
                          BinaryenExpressionRef target,
                          BinaryenExpressionRef* operands,
                          BinaryenIndex numOperands,
                          BinaryenType params,
                          BinaryenType results,
                          bool isReturn) {
   auto* ret = ((Module*)module)->allocator.alloc<CallIndirect>();
+  ret->table = table;
   ret->target = (Expression*)target;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
     ret->operands.push_back((Expression*)operands[i]);
@@ -823,23 +825,25 @@ makeBinaryenCallIndirect(BinaryenModuleRef module,
   return static_cast<Expression*>(ret);
 }
 BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module,
+                                           const char* table,
                                            BinaryenExpressionRef target,
                                            BinaryenExpressionRef* operands,
                                            BinaryenIndex numOperands,
                                            BinaryenType params,
                                            BinaryenType results) {
   return makeBinaryenCallIndirect(
-    module, target, operands, numOperands, params, results, false);
+    module, table, target, operands, numOperands, params, results, false);
 }
 BinaryenExpressionRef
 BinaryenReturnCallIndirect(BinaryenModuleRef module,
+                           const char* table,
                            BinaryenExpressionRef target,
                            BinaryenExpressionRef* operands,
                            BinaryenIndex numOperands,
                            BinaryenType params,
                            BinaryenType results) {
   return makeBinaryenCallIndirect(
-    module, target, operands, numOperands, params, results, true);
+    module, table, target, operands, numOperands, params, results, true);
 }
 BinaryenExpressionRef BinaryenLocalGet(BinaryenModuleRef module,
                                        BinaryenIndex index,
@@ -1610,6 +1614,19 @@ void BinaryenCallIndirectSetTarget(BinaryenExpressionRef expr,
   assert(targetExpr);
   static_cast<CallIndirect*>(expression)->target = (Expression*)targetExpr;
 }
+const char* BinaryenCallIndirectGetTable(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<CallIndirect>());
+  return static_cast<CallIndirect*>(expression)->table.c_str();
+}
+void BinaryenCallIndirectSetTable(BinaryenExpressionRef expr,
+                                  const char* table) {
+  Name name(table);
+  auto* expression = (Expression*)expr;
+
+  assert(expression->is<CallIndirect>());
+  static_cast<CallIndirect*>(expression)->table = name;
+}
 BinaryenIndex BinaryenCallIndirectGetNumOperands(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<CallIndirect>());
@@ -3154,9 +3171,11 @@ void BinaryenAddTableImport(BinaryenModuleRef module,
                             const char* internalName,
                             const char* externalModuleName,
                             const char* externalBaseName) {
-  auto& table = ((Module*)module)->table;
-  table.module = externalModuleName;
-  table.base = externalBaseName;
+  auto table = std::make_unique<Table>();
+  table->name = internalName;
+  table->module = externalModuleName;
+  table->base = externalBaseName;
+  ((Module*)module)->addTable(std::move(table));
 }
 void BinaryenAddMemoryImport(BinaryenModuleRef module,
                              const char* internalName,
@@ -3273,43 +3292,100 @@ BinaryenExportRef BinaryenGetExportByIndex(BinaryenModuleRef module,
   return exports[index].get();
 }
 
-// Function table. One per module
-
+// TODO(reference-types): maybe deprecate this function?
 void BinaryenSetFunctionTable(BinaryenModuleRef module,
                               BinaryenIndex initial,
                               BinaryenIndex maximum,
                               const char** funcNames,
                               BinaryenIndex numFuncNames,
                               BinaryenExpressionRef offset) {
+  auto* wasm = (Module*)module;
+  if (wasm->tables.empty()) {
+    wasm->addTable(Builder::makeTable(Name::fromInt(0)));
+  }
+
+  auto& table = wasm->tables.front();
+  table->initial = initial;
+  table->max = maximum;
+
   Table::Segment segment((Expression*)offset);
   for (BinaryenIndex i = 0; i < numFuncNames; i++) {
     segment.data.push_back(funcNames[i]);
   }
-  auto& table = ((Module*)module)->table;
-  table.initial = initial;
-  table.max = maximum;
-  table.exists = true;
-  table.segments.push_back(segment);
+  table->segments.push_back(segment);
+}
+
+BinaryenTableRef BinaryenAddTable(BinaryenModuleRef module,
+                                  const char* name,
+                                  BinaryenIndex initial,
+                                  BinaryenIndex maximum,
+                                  const char** funcNames,
+                                  BinaryenIndex numFuncNames,
+                                  BinaryenExpressionRef offset) {
+  auto table = Builder::makeTable(name, initial, maximum);
+  table->hasExplicitName = true;
+
+  Table::Segment segment((Expression*)offset);
+  for (BinaryenIndex i = 0; i < numFuncNames; i++) {
+    segment.data.push_back(funcNames[i]);
+  }
+  table->segments.push_back(segment);
+  ((Module*)module)->addTable(std::move(table));
+
+  return ((Module*)module)->getTable(name);
+}
+void BinaryenRemoveTable(BinaryenModuleRef module, const char* table) {
+  ((Module*)module)->removeTable(table);
+}
+BinaryenIndex BinaryenGetNumTables(BinaryenModuleRef module) {
+  return ((Module*)module)->tables.size();
+}
+BinaryenTableRef BinaryenGetTable(BinaryenModuleRef module, const char* name) {
+  return ((Module*)module)->getTableOrNull(name);
+}
+BinaryenTableRef BinaryenGetTableByIndex(BinaryenModuleRef module,
+                                         BinaryenIndex index) {
+  const auto& tables = ((Module*)module)->tables;
+  if (tables.size() <= index) {
+    Fatal() << "invalid table index.";
+  }
+  return tables[index].get();
 }
 
 int BinaryenIsFunctionTableImported(BinaryenModuleRef module) {
-  return ((Module*)module)->table.imported();
+  if (((Module*)module)->tables.size() > 0) {
+    return ((Module*)module)->tables[0]->imported();
+  }
+
+  return false;
 }
 BinaryenIndex BinaryenGetNumFunctionTableSegments(BinaryenModuleRef module) {
-  return ((Module*)module)->table.segments.size();
+  if (((Module*)module)->tables.size() > 0) {
+    return ((Module*)module)->tables[0]->segments.size();
+  }
+
+  return 0;
 }
 BinaryenExpressionRef
 BinaryenGetFunctionTableSegmentOffset(BinaryenModuleRef module,
                                       BinaryenIndex segmentId) {
-  const auto& segments = ((Module*)module)->table.segments;
+  if (((Module*)module)->tables.empty()) {
+    Fatal() << "module has no tables.";
+  }
+
+  const auto& segments = ((Module*)module)->tables[0]->segments;
   if (segments.size() <= segmentId) {
     Fatal() << "invalid function table segment id.";
   }
   return segments[segmentId].offset;
 }
 BinaryenIndex BinaryenGetFunctionTableSegmentLength(BinaryenModuleRef module,
                                                     BinaryenIndex segmentId) {
-  const auto& segments = ((Module*)module)->table.segments;
+  if (((Module*)module)->tables.empty()) {
+    Fatal() << "module has no tables.";
+  }
+
+  const auto& segments = ((Module*)module)->tables[0]->segments;
   if (segments.size() <= segmentId) {
     Fatal() << "invalid function table segment id.";
   }
@@ -3318,7 +3394,11 @@ BinaryenIndex BinaryenGetFunctionTableSegmentLength(BinaryenModuleRef module,
 const char* BinaryenGetFunctionTableSegmentData(BinaryenModuleRef module,
                                                 BinaryenIndex segmentId,
                                                 BinaryenIndex dataId) {
-  const auto& segments = ((Module*)module)->table.segments;
+  if (((Module*)module)->tables.empty()) {
+    Fatal() << "module has no tables.";
+  }
+
+  const auto& segments = ((Module*)module)->tables[0]->segments;
   if (segments.size() <= segmentId ||
       segments[segmentId].data.size() <= dataId) {
     Fatal() << "invalid function table segment or data id.";
@@ -3788,6 +3868,21 @@ void BinaryenFunctionSetDebugLocation(BinaryenFunctionRef func,
   ((Function*)func)->debugLocations[(Expression*)expr] = loc;
 }
 
+//
+// =========== Table operations ===========
+//
+
+const char* BinaryenTableGetName(BinaryenTableRef table) {
+  return ((Table*)table)->name.c_str();
+}
+int BinaryenTableGetInitial(BinaryenTableRef table) {
+  return ((Table*)table)->initial;
+}
+int BinaryenTableHasMax(BinaryenTableRef table) {
+  return ((Table*)table)->hasMax();
+}
+int BinaryenTableGetMax(BinaryenTableRef table) { return ((Table*)table)->max; }
+
 //
 // =========== Global operations ===========
 //
@@ -3835,6 +3930,14 @@ const char* BinaryenFunctionImportGetModule(BinaryenFunctionRef import) {
     return "";
   }
 }
+const char* BinaryenTableImportGetModule(BinaryenTableRef import) {
+  auto* table = (Table*)import;
+  if (table->imported()) {
+    return table->module.c_str();
+  } else {
+    return "";
+  }
+}
 const char* BinaryenGlobalImportGetModule(BinaryenGlobalRef import) {
   auto* global = (Global*)import;
   if (global->imported()) {
@@ -3859,6 +3962,14 @@ const char* BinaryenFunctionImportGetBase(BinaryenFunctionRef import) {
     return "";
   }
 }
+const char* BinaryenTableImportGetBase(BinaryenTableRef import) {
+  auto* table = (Table*)import;
+  if (table->imported()) {
+    return table->base.c_str();
+  } else {
+    return "";
+  }
+}
 const char* BinaryenGlobalImportGetBase(BinaryenGlobalRef import) {
   auto* global = (Global*)import;
   if (global->imported()) {

src/binaryen-c.h

@@ -608,6 +608,7 @@ BINARYEN_API BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module,
                                                 BinaryenType returnType);
 BINARYEN_API BinaryenExpressionRef
 BinaryenCallIndirect(BinaryenModuleRef module,
+                     const char* table,
                      BinaryenExpressionRef target,
                      BinaryenExpressionRef* operands,
                      BinaryenIndex numOperands,
@@ -621,6 +622,7 @@ BinaryenReturnCall(BinaryenModuleRef module,
                    BinaryenType returnType);
 BINARYEN_API BinaryenExpressionRef
 BinaryenReturnCallIndirect(BinaryenModuleRef module,
+                           const char* table,
                            BinaryenExpressionRef target,
                            BinaryenExpressionRef* operands,
                            BinaryenIndex numOperands,
@@ -1041,6 +1043,12 @@ BinaryenCallIndirectGetTarget(BinaryenExpressionRef expr);
 BINARYEN_API void
 BinaryenCallIndirectSetTarget(BinaryenExpressionRef expr,
                               BinaryenExpressionRef targetExpr);
+// Gets the table name of a `call_indirect` expression.
+BINARYEN_API const char*
+BinaryenCallIndirectGetTable(BinaryenExpressionRef expr);
+// Sets the table name of a `call_indirect` expression.
+BINARYEN_API void BinaryenCallIndirectSetTable(BinaryenExpressionRef expr,
+                                               const char* table);
 // Gets the number of operands of a `call_indirect` expression.
 BINARYEN_API BinaryenIndex
 BinaryenCallIndirectGetNumOperands(BinaryenExpressionRef expr);
@@ -2039,6 +2047,25 @@ BINARYEN_API BinaryenIndex BinaryenGetFunctionTableSegmentLength(
 BINARYEN_API const char* BinaryenGetFunctionTableSegmentData(
   BinaryenModuleRef module, BinaryenIndex segmentId, BinaryenIndex dataId);
 
+// Tables
+
+BINARYEN_REF(Table);
+
+BINARYEN_API BinaryenTableRef BinaryenAddTable(BinaryenModuleRef module,
+                                               const char* table,
+                                               BinaryenIndex initial,
+                                               BinaryenIndex maximum,
+                                               const char** funcNames,
+                                               BinaryenIndex numFuncNames,
+                                               BinaryenExpressionRef offset);
+BINARYEN_API void BinaryenRemoveTable(BinaryenModuleRef module,
+                                      const char* table);
+BINARYEN_API BinaryenIndex BinaryenGetNumTables(BinaryenModuleRef module);
+BINARYEN_API BinaryenTableRef BinaryenGetTable(BinaryenModuleRef module,
+                                               const char* name);
+BINARYEN_API BinaryenTableRef BinaryenGetTableByIndex(BinaryenModuleRef module,
+                                                      BinaryenIndex index);
+
 // Memory. One per module
 
 // Each segment has data in segments, a start offset in segmentOffsets, and a
@@ -2329,6 +2356,15 @@ BINARYEN_API void BinaryenFunctionSetDebugLocation(BinaryenFunctionRef func,
                                                    BinaryenIndex lineNumber,
                                                    BinaryenIndex columnNumber);
 
+//
+// ========== Table Operations ==========
+//
+
+BINARYEN_API const char* BinaryenTableGetName(BinaryenTableRef table);
+BINARYEN_API int BinaryenTableGetInitial(BinaryenTableRef table);
+BINARYEN_API int BinaryenTableHasMax(BinaryenTableRef table);
+BINARYEN_API int BinaryenTableGetMax(BinaryenTableRef table);
+
 //
 // ========== Global Operations ==========
 //
@@ -2364,12 +2400,14 @@ BINARYEN_API BinaryenType BinaryenEventGetResults(BinaryenEventRef event);
 // Gets the external module name of the specified import.
 BINARYEN_API const char*
 BinaryenFunctionImportGetModule(BinaryenFunctionRef import);
+BINARYEN_API const char* BinaryenTableImportGetModule(BinaryenTableRef import);
 BINARYEN_API const char*
 BinaryenGlobalImportGetModule(BinaryenGlobalRef import);
 BINARYEN_API const char* BinaryenEventImportGetModule(BinaryenEventRef import);
 // Gets the external base name of the specified import.
 BINARYEN_API const char*
 BinaryenFunctionImportGetBase(BinaryenFunctionRef import);
+BINARYEN_API const char* BinaryenTableImportGetBase(BinaryenTableRef import);
 BINARYEN_API const char* BinaryenGlobalImportGetBase(BinaryenGlobalRef import);
 BINARYEN_API const char* BinaryenEventImportGetBase(BinaryenEventRef import);