--- a/js/src/wasm/WasmAST.h
+++ b/js/src/wasm/WasmAST.h
@@ -783,30 +783,33 @@ class AstModule : public AstNode
     AstResizableVector   memories_;
     ExportVector         exports_;
     Maybe<AstStartFunc>  startFunc_;
     FuncVector           funcs_;
     AstDataSegmentVector dataSegments_;
     AstElemSegmentVector elemSegments_;
     AstGlobalVector      globals_;
 
+    size_t numGlobalImports_;
+
   public:
     explicit AstModule(LifoAlloc& lifo)
       : lifo_(lifo),
         sigs_(lifo),
         sigMap_(lifo),
         imports_(lifo),
         funcImportNames_(lifo),
         tables_(lifo),
         memories_(lifo),
         exports_(lifo),
         funcs_(lifo),
         dataSegments_(lifo),
         elemSegments_(lifo),
-        globals_(lifo)
+        globals_(lifo),
+        numGlobalImports_(0)
     {}
     bool init() {
         return sigMap_.init();
     }
     bool addMemory(AstName name, const Limits& memory) {
         return memories_.append(AstResizable(memory, false, name));
     }
     bool hasMemory() const {
@@ -886,19 +889,19 @@ class AstModule : public AstNode
             if (!tables_.append(AstResizable(imp->limits(), true)))
                 return false;
             break;
           case DefinitionKind::Memory:
             if (!memories_.append(AstResizable(imp->limits(), true)))
                 return false;
             break;
           case DefinitionKind::Global:
+            numGlobalImports_++;
             break;
         }
-
         return imports_.append(imp);
     }
     const ImportVector& imports() const {
         return imports_;
     }
     const NameVector& funcImportNames() const {
         return funcImportNames_;
     }
@@ -912,16 +915,19 @@ class AstModule : public AstNode
         return exports_;
     }
     bool append(AstGlobal* glob) {
         return globals_.append(glob);
     }
     const AstGlobalVector& globals() const {
         return globals_;
     }
+    size_t numGlobalImports() const {
+        return numGlobalImports_;
+    }
 };
 
 class AstUnaryOperator final : public AstExpr
 {
     Op op_;
     AstExpr* operand_;
 
   public:

--- a/js/src/wasm/WasmTextToBinary.cpp
+++ b/js/src/wasm/WasmTextToBinary.cpp
@@ -2655,17 +2655,17 @@ ParseFunc(WasmParseContext& c, AstModule
                 return false;
 
             auto* imp = new(c.lifo) AstImport(funcName, names.module.text(), names.field.text(), sig);
             return imp && module->append(imp);
         }
 
         if (c.ts.getIf(WasmToken::Export)) {
             AstRef ref = funcName.empty()
-                         ? AstRef(module->funcImportNames().length() + module->funcs().length())
+                         ? AstRef(module->numFuncImports() + module->funcs().length())
                          : AstRef(funcName);
             if (!ParseInlineExport(c, DefinitionKind::Function, module, ref))
                 return false;
             if (!c.ts.match(WasmToken::CloseParen, c.error))
                 return false;
         } else {
             c.ts.unget(openParen);
         }
@@ -3222,17 +3222,18 @@ ParseGlobal(WasmParseContext& c, AstModu
 
             auto* imp = new(c.lifo) AstImport(name, names.module.text(), names.field.text(),
                                               AstGlobal(AstName(), typeToken.valueType(),
                                                         isMutable));
             return imp && module->append(imp);
         }
 
         if (c.ts.getIf(WasmToken::Export)) {
-            AstRef ref = name.empty() ? AstRef(module->globals().length()) : AstRef(name);
+            size_t refIndex = module->numGlobalImports() + module->globals().length();
+            AstRef ref = name.empty() ? AstRef(refIndex) : AstRef(name);
             if (!ParseInlineExport(c, DefinitionKind::Global, module, ref))
                 return false;
             if (!c.ts.match(WasmToken::CloseParen, c.error))
                 return false;
         } else {
             c.ts.unget(openParen);
         }
     }