3 files changed, 53 insertions, 63 deletions

diff --git a/src/ir/module-utils.h b/src/ir/module-utils.h
index 485bc4833..e589f5052 100644
--- a/src/ir/module-utils.h
+++ b/src/ir/module-utils.h
@@ -28,58 +28,6 @@ namespace wasm {
 
 namespace ModuleUtils {
 
-// Computes the indexes in a wasm binary, i.e., with function imports
-// and function implementations sharing a single index space, etc.,
-// and with the imports first (the Module's functions and globals
-// arrays are not assumed to be in a particular order, so we can't
-// just use them directly).
-struct BinaryIndexes {
-  std::unordered_map<Name, Index> functionIndexes;
-  std::unordered_map<Name, Index> eventIndexes;
-  std::unordered_map<Name, Index> globalIndexes;
-
-  BinaryIndexes(Module& wasm) {
-    auto addIndexes = [&](auto& source, auto& indexes) {
-      auto addIndex = [&](auto* curr) {
-        auto index = indexes.size();
-        indexes[curr->name] = index;
-      };
-      for (auto& curr : source) {
-        if (curr->imported()) {
-          addIndex(curr.get());
-        }
-      }
-      for (auto& curr : source) {
-        if (!curr->imported()) {
-          addIndex(curr.get());
-        }
-      }
-    };
-    addIndexes(wasm.functions, functionIndexes);
-    addIndexes(wasm.events, eventIndexes);
-
-    // Globals may have tuple types in the IR, in which case they lower to
-    // multiple globals, one for each tuple element, in the binary. Tuple
-    // globals therefore occupy multiple binary indices, and we have to take
-    // that into account when calculating indices.
-    Index globalCount = 0;
-    auto addGlobal = [&](auto* curr) {
-      globalIndexes[curr->name] = globalCount;
-      globalCount += curr->type.size();
-    };
-    for (auto& curr : wasm.globals) {
-      if (curr->imported()) {
-        addGlobal(curr.get());
-      }
-    }
-    for (auto& curr : wasm.globals) {
-      if (!curr->imported()) {
-        addGlobal(curr.get());
-      }
-    }
-  }
-};
-
 inline Function* copyFunction(Function* func, Module& out) {
   auto* ret = new Function();
   ret->name = func->name;
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 18f2beb43..a87eae325 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -1455,8 +1455,6 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
   Function::DebugLocation lastPrintedLocation;
   bool debugInfo;
 
-  std::unordered_map<Name, Index> functionIndexes;
-
   PrintSExpression(std::ostream& o) : o(o) {
     setMinify(false);
     if (!full) {
@@ -2124,14 +2122,6 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
     o << '(';
     printMajor(o, "func ");
     printName(curr->name, o);
-    if (currModule && !minify) {
-      // emit the function index in a comment
-      if (functionIndexes.empty()) {
-        ModuleUtils::BinaryIndexes indexes(*currModule);
-        functionIndexes = std::move(indexes.functionIndexes);
-      }
-      o << " (; " << functionIndexes[curr->name] << " ;)";
-    }
     if (!printStackIR && curr->stackIR && !minify) {
       o << " (; has Stack IR ;)";
     }
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 1a13dbb75..7063dc5f9 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -951,6 +951,58 @@ inline S32LEB binaryType(Type type) {
 // Writes out wasm to the binary format
 
 class WasmBinaryWriter {
+  // Computes the indexes in a wasm binary, i.e., with function imports
+  // and function implementations sharing a single index space, etc.,
+  // and with the imports first (the Module's functions and globals
+  // arrays are not assumed to be in a particular order, so we can't
+  // just use them directly).
+  struct BinaryIndexes {
+    std::unordered_map<Name, Index> functionIndexes;
+    std::unordered_map<Name, Index> eventIndexes;
+    std::unordered_map<Name, Index> globalIndexes;
+
+    BinaryIndexes(Module& wasm) {
+      auto addIndexes = [&](auto& source, auto& indexes) {
+        auto addIndex = [&](auto* curr) {
+          auto index = indexes.size();
+          indexes[curr->name] = index;
+        };
+        for (auto& curr : source) {
+          if (curr->imported()) {
+            addIndex(curr.get());
+          }
+        }
+        for (auto& curr : source) {
+          if (!curr->imported()) {
+            addIndex(curr.get());
+          }
+        }
+      };
+      addIndexes(wasm.functions, functionIndexes);
+      addIndexes(wasm.events, eventIndexes);
+
+      // Globals may have tuple types in the IR, in which case they lower to
+      // multiple globals, one for each tuple element, in the binary. Tuple
+      // globals therefore occupy multiple binary indices, and we have to take
+      // that into account when calculating indices.
+      Index globalCount = 0;
+      auto addGlobal = [&](auto* curr) {
+        globalIndexes[curr->name] = globalCount;
+        globalCount += curr->type.size();
+      };
+      for (auto& curr : wasm.globals) {
+        if (curr->imported()) {
+          addGlobal(curr.get());
+        }
+      }
+      for (auto& curr : wasm.globals) {
+        if (!curr->imported()) {
+          addGlobal(curr.get());
+        }
+      }
+    }
+  };
+
 public:
   WasmBinaryWriter(Module* input, BufferWithRandomAccess& o)
     : wasm(input), o(o), indexes(*input) {
@@ -1050,7 +1102,7 @@ public:
 private:
   Module* wasm;
   BufferWithRandomAccess& o;
-  ModuleUtils::BinaryIndexes indexes;
+  BinaryIndexes indexes;
   std::unordered_map<Signature, Index> typeIndices;
   std::vector<Signature> types;