Prepare for type exports (#7335)

Change the type of the field `value` in class `Export` to
`std::variant<Name, HeapType>`, since a type export references a heap
type and not a named component.

Author: vouillon

src/binaryen-c.cpp

@@ -4908,50 +4908,35 @@ WASM_DEPRECATED BinaryenExportRef BinaryenAddExport(BinaryenModuleRef module,
 BinaryenExportRef BinaryenAddFunctionExport(BinaryenModuleRef module,
                                             const char* internalName,
                                             const char* externalName) {
-  auto* ret = new Export();
-  ret->value = internalName;
-  ret->name = externalName;
-  ret->kind = ExternalKind::Function;
+  auto* ret = new Export(externalName, ExternalKind::Function, internalName);
   ((Module*)module)->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddTableExport(BinaryenModuleRef module,
                                          const char* internalName,
                                          const char* externalName) {
-  auto* ret = new Export();
-  ret->value = internalName;
-  ret->name = externalName;
-  ret->kind = ExternalKind::Table;
+  auto* ret = new Export(externalName, ExternalKind::Table, internalName);
   ((Module*)module)->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddMemoryExport(BinaryenModuleRef module,
                                           const char* internalName,
                                           const char* externalName) {
-  auto* ret = new Export();
-  ret->value = internalName;
-  ret->name = externalName;
-  ret->kind = ExternalKind::Memory;
+  auto* ret = new Export(externalName, ExternalKind::Memory, internalName);
   ((Module*)module)->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddGlobalExport(BinaryenModuleRef module,
                                           const char* internalName,
                                           const char* externalName) {
-  auto* ret = new Export();
-  ret->value = internalName;
-  ret->name = externalName;
-  ret->kind = ExternalKind::Global;
+  auto* ret = new Export(externalName, ExternalKind::Global, internalName);
   ((Module*)module)->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddTagExport(BinaryenModuleRef module,
                                        const char* internalName,
                                        const char* externalName) {
-  auto* ret = new Export();
-  ret->value = internalName;
-  ret->name = externalName;
-  ret->kind = ExternalKind::Tag;
+  auto* ret = new Export(externalName, ExternalKind::Tag, internalName);
   ((Module*)module)->addExport(ret);
   return ret;
 }
@@ -5102,11 +5087,8 @@ void BinaryenSetMemory(BinaryenModuleRef module,
   memory->shared = shared;
   memory->addressType = memory64 ? Type::i64 : Type::i32;
   if (exportName) {
-    auto memoryExport = std::make_unique<Export>();
-    memoryExport->name = exportName;
-    memoryExport->value = memory->name;
-    memoryExport->kind = ExternalKind::Memory;
-    ((Module*)module)->addExport(memoryExport.release());
+    ((Module*)module)
+      ->addExport(new Export(exportName, ExternalKind::Memory, memory->name));
   }
   ((Module*)module)->removeDataSegments([&](DataSegment* curr) {
     return true;
@@ -5940,7 +5922,7 @@ const char* BinaryenExportGetName(BinaryenExportRef export_) {
   return ((Export*)export_)->name.str.data();
 }
 const char* BinaryenExportGetValue(BinaryenExportRef export_) {
-  return ((Export*)export_)->value.str.data();
+  return ((Export*)export_)->getInternalName()->str.data();
 }
 
 //

src/ir/export-utils.cpp

@@ -28,7 +28,8 @@ std::vector<T*> getExportedByKind(Module& wasm, G getModuleItem) {
   std::vector<T*> ret;
   for (auto& ex : wasm.exports) {
     if (ex->kind == K) {
-      ret.push_back(getModuleItem(ex->value));
+      // The kind is either ExternalKind::Function or ExternalKind::Global
+      ret.push_back(getModuleItem(*ex->getInternalName()));
     }
   }
   return ret;

src/ir/export-utils.h

@@ -27,7 +27,7 @@ std::vector<Global*> getExportedGlobals(Module& wasm);
 inline bool isExported(const Module& module, const Function& func) {
   for (auto& exportFunc : module.exports) {
     if (exportFunc->kind == ExternalKind::Function &&
-        exportFunc->value == func.name) {
+        *exportFunc->getInternalName() == func.name) {
       return true;
     }
   }

src/ir/module-splitting.cpp

@@ -355,9 +355,9 @@ void ModuleSplitter::setupJSPI() {
   // Support the first version of JSPI, where the JSPI pass added the load
   // secondary module export.
   // TODO: remove this when the new JSPI API is only supported.
-  if (primary.getExportOrNull(LOAD_SECONDARY_MODULE)) {
-    internalLoadSecondaryModule =
-      primary.getExport(LOAD_SECONDARY_MODULE)->value;
+  if (auto* loadSecondary = primary.getExportOrNull(LOAD_SECONDARY_MODULE);
+      loadSecondary && loadSecondary->kind == ExternalKind::Function) {
+    internalLoadSecondaryModule = *loadSecondary->getInternalName();
     // Remove the exported LOAD_SECONDARY_MODULE function since it's only needed
     // internally.
     primary.removeExport(LOAD_SECONDARY_MODULE);
@@ -471,7 +471,7 @@ ModuleSplitter::initExportedPrimaryFuncs(const Module& primary) {
   std::map<Name, Name> functionExportNames;
   for (auto& ex : primary.exports) {
     if (ex->kind == ExternalKind::Function) {
-      functionExportNames[ex->value] = ex->name;
+      functionExportNames[*ex->getInternalName()] = ex->name;
     }
   }
   return functionExportNames;
@@ -527,10 +527,10 @@ void ModuleSplitter::thunkExportedSecondaryFunctions() {
   Builder builder(primary);
   for (auto& ex : primary.exports) {
     if (ex->kind != ExternalKind::Function ||
-        !secondaryFuncs.count(ex->value)) {
+        !secondaryFuncs.count(*ex->getInternalName())) {
       continue;
     }
-    Name secondaryFunc = ex->value;
+    Name secondaryFunc = *ex->getInternalName();
     if (primary.getFunctionOrNull(secondaryFunc)) {
       // We've already created a thunk for this function
       continue;
@@ -823,7 +823,9 @@ void ModuleSplitter::shareImportableItems() {
   std::unordered_map<std::pair<ExternalKind, Name>, Name> exports;
   for (auto& ex : primary.exports) {
     if (ex->kind != ExternalKind::Function) {
-      exports[std::make_pair(ex->kind, ex->value)] = ex->name;
+      if (auto* name = ex->getInternalName()) {
+        exports[std::make_pair(ex->kind, *name)] = ex->name;
+      }
     }
   }
 
@@ -843,7 +845,7 @@ void ModuleSplitter::shareImportableItems() {
                                     ? minified.getName()
                                     : genericExportName);
       Name exportName = Names::getValidExportName(primary, baseName);
-      primary.addExport(new Export{exportName, primaryItem.name, kind});
+      primary.addExport(new Export(exportName, kind, primaryItem.name));
       secondaryItem.base = exportName;
     }
   };

src/ir/module-utils.cpp

@@ -632,12 +632,12 @@ void classifyTypeVisibility(Module& wasm,
   for (auto& ex : wasm.exports) {
     switch (ex->kind) {
       case ExternalKind::Function: {
-        auto* func = wasm.getFunction(ex->value);
+        auto* func = wasm.getFunction(*ex->getInternalName());
         notePublic(func->type);
         continue;
       }
       case ExternalKind::Table: {
-        auto* table = wasm.getTable(ex->value);
+        auto* table = wasm.getTable(*ex->getInternalName());
         assert(table->type.isRef());
         notePublic(table->type.getHeapType());
         continue;
@@ -646,14 +646,14 @@ void classifyTypeVisibility(Module& wasm,
         // Never a reference type.
         continue;
       case ExternalKind::Global: {
-        auto* global = wasm.getGlobal(ex->value);
+        auto* global = wasm.getGlobal(*ex->getInternalName());
         if (global->type.isRef()) {
           notePublic(global->type.getHeapType());
         }
         continue;
       }
       case ExternalKind::Tag:
-        notePublic(wasm.getTag(ex->value)->type);
+        notePublic(wasm.getTag(*ex->getInternalName())->type);
         continue;
       case ExternalKind::Invalid:
         break;

src/ir/possible-contents.cpp

@@ -2183,7 +2183,7 @@ Flower::Flower(Module& wasm, const PassOptions& options)
 
   for (auto& ex : wasm.exports) {
     if (ex->kind == ExternalKind::Table) {
-      shared.publicTables.insert(ex->value);
+      shared.publicTables.insert(*ex->getInternalName());
     }
   }
 
@@ -2295,7 +2295,7 @@ Flower::Flower(Module& wasm, const PassOptions& options)
   // Exports can be modified from the outside.
   for (auto& ex : wasm.exports) {
     if (ex->kind == ExternalKind::Function) {
-      calledFromOutside(ex->value);
+      calledFromOutside(*ex->getInternalName());
     } else if (ex->kind == ExternalKind::Table) {
       // If any table is exported, assume any function in any table (including
       // other tables) can be called from the outside.
@@ -2319,7 +2319,7 @@ Flower::Flower(Module& wasm, const PassOptions& options)
     } else if (ex->kind == ExternalKind::Global) {
       // Exported mutable globals are roots, since the outside may write any
       // value to them.
-      auto name = ex->value;
+      auto name = *ex->getInternalName();
       auto* global = wasm.getGlobal(name);
       if (global->mutable_) {
         roots[GlobalLocation{name}] = PossibleContents::fromType(global->type);
@@ -2337,7 +2337,7 @@ Flower::Flower(Module& wasm, const PassOptions& options)
   }
   for (auto& ex : wasm.exports) {
     if (ex->kind == ExternalKind::Tag) {
-      publicTags.insert(ex->value);
+      publicTags.insert(*ex->getInternalName());
     }
   }
   for (auto tag : publicTags) {

src/passes/Asyncify.cpp

@@ -1668,7 +1668,7 @@ struct Asyncify : public Pass {
         for (auto& theExport : module->exports) {
           if (theExport->kind == ExternalKind::Memory &&
               theExport->name == asyncifyMemoryValue) {
-            asyncifyMemory = theExport->value;
+            asyncifyMemory = *theExport->getInternalName();
             break;
           }
         }
@@ -1901,7 +1901,9 @@ struct ModAsyncify
   void doWalkFunction(Function* func) {
     // Find the asyncify state name.
     auto* unwind = this->getModule()->getExport(ASYNCIFY_STOP_UNWIND);
-    auto* unwindFunc = this->getModule()->getFunction(unwind->value);
+    auto* unwindFunc = this->getModule()->getFunction(
+      ((unwind->kind == ExternalKind::Function)) ? *unwind->getInternalName()
+                                                 : Name());
     FindAll<GlobalSet> sets(unwindFunc->body);
     assert(sets.list.size() == 1);
     asyncifyStateName = sets.list[0]->name;

src/passes/DeadArgumentElimination.cpp

@@ -260,7 +260,7 @@ struct DAE : public Pass {
     // Exports are considered unseen calls.
     for (auto& curr : module->exports) {
       if (curr->kind == ExternalKind::Function) {
-        hasUnseenCalls.insert(curr->value);
+        hasUnseenCalls.insert(*curr->getInternalName());
       }
     }
 

src/passes/Directize.cpp

@@ -223,7 +223,7 @@ struct Directize : public Pass {
 
     for (auto& ex : module->exports) {
       if (ex->kind == ExternalKind::Table) {
-        tables[ex->value].mayBeModified = true;
+        tables[*ex->getInternalName()].mayBeModified = true;
       }
     }
 

src/passes/EncloseWorld.cpp

@@ -52,11 +52,12 @@ struct EncloseWorld : public Pass {
     std::vector<std::unique_ptr<Export>> newExports;
     for (auto& ex : module->exports) {
       if (ex->kind == ExternalKind::Function) {
-        auto* func = module->getFunction(ex->value);
+        auto* name = ex->getInternalName();
+        auto* func = module->getFunction(*name);
         // If this opens up types, replace it with an enclosed stub.
         if (opensTypes(func)) {
           auto stubName = makeStubStubForExport(func, module);
-          ex->value = stubName;
+          *name = stubName;
         }
       }
     }