Bug 1676688 - Part 3: Merge AtomIndex and ParserAtomIndex. r=tcampbell

Differential Revision: https://phabricator.services.mozilla.com/D96812

js/src/frontend/BytecodeCompiler.cpp

@@ -1207,7 +1207,7 @@ void CompilationInput::trace(JSTracer* trc) {
   TraceNullableRoot(trc, &enclosingScope, "compilation-input-enclosing-scope");
 }
 
-void CompilationAtomCache::trace(JSTracer* trc) { atoms.trace(trc); }
+void CompilationAtomCache::trace(JSTracer* trc) { atoms_.trace(trc); }
 
 void CompilationInfo::trace(JSTracer* trc) { input.trace(trc); }
 

js/src/frontend/CompilationInfo.h

@@ -93,12 +93,20 @@ struct ScopeContext {
 };
 
 struct CompilationAtomCache {
+ private:
   // Atoms lowered into or converted from CompilationStencil.parserAtomData.
   //
   // This field is here instead of in CompilationGCOutput because atoms lowered
   // from JSAtom is part of input (enclosing scope bindings, lazy function name,
   // etc), and having 2 vectors in both input/output is error prone.
-  JS::GCVector<JSAtom*, 0, js::SystemAllocPolicy> atoms;
+  JS::GCVector<JSAtom*, 0, js::SystemAllocPolicy> atoms_;
+
+ public:
+  JSAtom* getExistingAtomAt(ParserAtomIndex index) const;
+  JSAtom* getAtomAt(ParserAtomIndex index) const;
+  bool hasAtomAt(ParserAtomIndex index) const;
+  bool setAtomAt(JSContext* cx, ParserAtomIndex index, JSAtom* atom);
+  bool allocate(JSContext* cx, size_t length);
 
   void trace(JSTracer* trc);
 } JS_HAZ_GC_POINTER;
@@ -252,6 +260,8 @@ struct CompilationStencil {
       asmJS;
 
   // List of parser atoms for this compilation.
+  // This may contain nullptr entries when round-tripping with XDR if the atom
+  // was generated in original parse but not used by stencil.
   ParserAtomVector parserAtomData;
 
   // Parameterized chunk size to use for LifoAlloc.

js/src/frontend/ParserAtom.cpp

@@ -216,8 +216,13 @@ bool ParserAtomEntry::isIndex(uint32_t* indexp) const {
 JSAtom* ParserAtomEntry::toJSAtom(JSContext* cx,
                                   CompilationAtomCache& atomCache) const {
   switch (atomIndexKind_) {
-    case AtomIndexKind::AtomIndex:
+    case AtomIndexKind::ParserAtomIndex: {
-      return atomCache.atoms[atomIndex_];
+      JSAtom* atom = atomCache.getAtomAt(toParserAtomIndex());
+      if (atom) {
+        return atom;
+      }
+      break;
+    }
 
     case AtomIndexKind::WellKnown:
       return GetWellKnownAtom(cx, WellKnownAtomId(atomIndex_));
@@ -229,9 +234,6 @@ JSAtom* ParserAtomEntry::toJSAtom(JSContext* cx,
 
     case AtomIndexKind::Static2:
       return cx->staticStrings().getLength2FromIndex(atomIndex_);
-
-    case AtomIndexKind::NotInstantiated:
-      break;
   }
 
   return instantiate(cx, atomCache);
@@ -240,8 +242,11 @@ JSAtom* ParserAtomEntry::toJSAtom(JSContext* cx,
 JSAtom* ParserAtomEntry::toExistingJSAtom(
     JSContext* cx, CompilationAtomCache& atomCache) const {
   switch (atomIndexKind_) {
-    case AtomIndexKind::AtomIndex:
+    case AtomIndexKind::ParserAtomIndex: {
-      return atomCache.atoms[atomIndex_];
+      JSAtom* atom = atomCache.getExistingAtomAt(toParserAtomIndex());
+      MOZ_ASSERT(atom);
+      return atom;
+    }
 
     case AtomIndexKind::WellKnown:
       return GetWellKnownAtom(cx, WellKnownAtomId(atomIndex_));
@@ -253,9 +258,6 @@ JSAtom* ParserAtomEntry::toExistingJSAtom(
 
     case AtomIndexKind::Static2:
       return cx->staticStrings().getLength2FromIndex(atomIndex_);
-
-    case AtomIndexKind::NotInstantiated:
-      MOZ_CRASH("ParserAtom should already be instantiated");
   }
 
   return nullptr;
@@ -263,8 +265,6 @@ JSAtom* ParserAtomEntry::toExistingJSAtom(
 
 JSAtom* ParserAtomEntry::instantiate(JSContext* cx,
                                      CompilationAtomCache& atomCache) const {
-  MOZ_ASSERT(isNotInstantiated());
-
   JSAtom* atom;
   if (hasLatin1Chars()) {
     atom = AtomizeChars(cx, hash(), latin1Chars(), length());
@@ -275,17 +275,10 @@ JSAtom* ParserAtomEntry::instantiate(JSContext* cx,
     js::ReportOutOfMemory(cx);
     return nullptr;
   }
-  auto index = atomCache.atoms.length();
+  if (!atomCache.setAtomAt(cx, toParserAtomIndex(), atom)) {
-
-  // This cannot be infallibleAppend because there are toJSAtom consumers that
-  // doesn't reserve CompilationAtomCache.atoms beforehand
-  if (!atomCache.atoms.append(atom)) {
-    js::ReportOutOfMemory(cx);
     return nullptr;
   }
 
-  const_cast<ParserAtomEntry*>(this)->setAtomIndex(AtomIndex(index));
-
   return atom;
 }
 
@@ -328,6 +321,7 @@ JS::Result<const ParserAtom*, OOM> ParserAtomsTable::addEntry(
   if (!entries_.append(entry)) {
     return RaiseParserAtomsOOMError(cx);
   }
+  entry->setParserAtomIndex(index);
   if (!entryMap_.add(addPtr, entry, index)) {
     return RaiseParserAtomsOOMError(cx);
   }
@@ -385,27 +379,27 @@ ParserAtomVectorBuilder::ParserAtomVectorBuilder(JSRuntime* rt,
       alloc_(&alloc),
       entries_(entries) {}
 
-bool ParserAtomVectorBuilder::reserve(JSContext* cx, size_t count) {
+bool ParserAtomVectorBuilder::resize(JSContext* cx, size_t count) {
   if (count >= TaggedParserAtomIndex::IndexLimit) {
     ReportAllocationOverflow(cx);
     return false;
   }
-  if (!entries_.reserve(count)) {
+  if (!entries_.resize(count)) {
     ReportOutOfMemory(cx);
     return false;
   }
   return true;
 }
 
-JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::internLatin1(
+JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::internLatin1At(
     JSContext* cx, const Latin1Char* latin1Ptr, HashNumber hash,
-    uint32_t length) {
+    uint32_t length, ParserAtomIndex index) {
-  return intern<Latin1Char, Latin1Char>(cx, latin1Ptr, hash, length);
+  return internAt<Latin1Char, Latin1Char>(cx, latin1Ptr, hash, length, index);
 }
 
-JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::internChar16(
+JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::internChar16At(
     JSContext* cx, LittleEndianChars twoByteLE, HashNumber hash,
-    uint32_t length) {
+    uint32_t length, ParserAtomIndex index) {
 #ifdef DEBUG
   InflatedChar16Sequence<LittleEndianChars> seq(twoByteLE, length);
   bool wide = false;
@@ -419,12 +413,14 @@ JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::internChar16(
   MOZ_ASSERT(wide);
 #endif
 
-  return intern<char16_t, LittleEndianChars>(cx, twoByteLE, hash, length);
+  return internAt<char16_t, LittleEndianChars>(cx, twoByteLE, hash, length,
+                                               index);
 }
 
 template <typename CharT, typename SeqCharT, typename InputCharsT>
-JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::intern(
+JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::internAt(
-    JSContext* cx, InputCharsT chars, HashNumber hash, uint32_t length) {
+    JSContext* cx, InputCharsT chars, HashNumber hash, uint32_t length,
+    ParserAtomIndex index) {
   InflatedChar16Sequence<SeqCharT> seq(chars, length);
 
 #ifdef DEBUG
@@ -437,9 +433,9 @@ JS::Result<const ParserAtom*, OOM> ParserAtomVectorBuilder::intern(
   ParserAtomEntry* entry;
   MOZ_TRY_VAR(entry,
               ParserAtomEntry::allocate<CharT>(cx, *alloc_, seq, length, hash));
-  if (!entries_.append(entry)) {
+  entry->setParserAtomIndex(index);
-    return RaiseParserAtomsOOMError(cx);
+  entries_[index] = entry;
-  }
+
   return entry->asAtom();
 }
 
@@ -533,7 +529,7 @@ JS::Result<const ParserAtom*, OOM> ParserAtomsTable::internChar16(
 
 JS::Result<const ParserAtom*, OOM> ParserAtomsTable::internJSAtom(
     JSContext* cx, CompilationInfo& compilationInfo, JSAtom* atom) {
-  const ParserAtom* id;
+  const ParserAtom* parserAtom;
   {
     JS::AutoCheckCannotGC nogc;
 
@@ -544,24 +540,24 @@ JS::Result<const ParserAtom*, OOM> ParserAtomsTable::internJSAtom(
     if (result.isErr()) {
       return result;
     }
-    id = result.unwrap();
+    parserAtom = result.unwrap();
   }
 
-  if (id->isNotInstantiated()) {
+  if (parserAtom->isParserAtomIndex()) {
-    MOZ_ASSERT(id->equalsJSAtom(atom));
+    ParserAtomIndex index = parserAtom->toParserAtomIndex();
+    auto& atomCache = compilationInfo.input.atomCache;
 
-    auto index = AtomIndex(compilationInfo.input.atomCache.atoms.length());
+    if (!atomCache.hasAtomAt(index)) {
-    if (!compilationInfo.input.atomCache.atoms.append(atom)) {
+      if (!atomCache.setAtomAt(cx, index, atom)) {
-      return RaiseParserAtomsOOMError(cx);
+        return mozilla::Err(PARSER_ATOMS_OOM);
+      }
     }
-
-    const_cast<ParserAtom*>(id)->setAtomIndex(AtomIndex(index));
   }
 
   // We should (infallibly) map back to the same JSAtom.
-  MOZ_ASSERT(id->toJSAtom(cx, compilationInfo.input.atomCache) == atom);
+  MOZ_ASSERT(parserAtom->toJSAtom(cx, compilationInfo.input.atomCache) == atom);
 
-  return id;
+  return parserAtom;
 }
 
 JS::Result<const ParserAtom*, OOM> ParserAtomsTable::concatAtoms(
@@ -643,20 +639,14 @@ const ParserAtom* ParserAtomVectorBuilder::getStatic2(
   return WellKnownParserAtoms::rom_.length2Table[size_t(s)].asAtom();
 }
 
-size_t RequiredNonStaticAtomCount(const ParserAtomVector& entries) {
-  size_t count = 0;
-  for (const auto& entry : entries) {
-    if (entry->isUsedByStencil() || entry->isAtomIndex()) {
-      count++;
-    }
-  }
-  return count;
-}
-
 bool InstantiateMarkedAtoms(JSContext* cx, const ParserAtomVector& entries,
                             CompilationAtomCache& atomCache) {
   for (const auto& entry : entries) {
-    if (entry->isUsedByStencil() && entry->isNotInstantiated()) {
+    if (!entry) {
+      continue;
+    }
+    if (entry->isUsedByStencil() && entry->isParserAtomIndex() &&
+        !atomCache.hasAtomAt(entry->toParserAtomIndex())) {
       if (!entry->instantiate(cx, atomCache)) {
         return false;
       }
@@ -818,7 +808,8 @@ static XDRResult XDRParserAtomTaggedIndex(XDRState<mode>* xdr,
 }
 
 template <XDRMode mode>
-XDRResult XDRParserAtomData(XDRState<mode>* xdr, const ParserAtom** atomp) {
+XDRResult XDRParserAtomDataAt(XDRState<mode>* xdr, const ParserAtom** atomp,
+                              ParserAtomIndex index) {
   static_assert(JSString::MAX_LENGTH <= INT32_MAX,
                 "String length must fit in 31 bits");
 
@@ -865,14 +856,16 @@ XDRResult XDRParserAtomData(XDRState<mode>* xdr, const ParserAtom** atomp) {
       MOZ_TRY(xdr->peekData(&ptr, length * sizeof(Latin1Char)));
       chars = reinterpret_cast<const Latin1Char*>(ptr);
     }
-    mbAtom = xdr->frontendAtoms().internLatin1(cx, chars, hash, length);
+    mbAtom =
+        xdr->frontendAtoms().internLatin1At(cx, chars, hash, length, index);
   } else {
     const uint8_t* twoByteCharsLE = nullptr;
     if (length) {
       MOZ_TRY(xdr->peekData(&twoByteCharsLE, length * sizeof(char16_t)));
     }
     LittleEndianChars leTwoByte(twoByteCharsLE);
-    mbAtom = xdr->frontendAtoms().internChar16(cx, leTwoByte, hash, length);
+    mbAtom =
+        xdr->frontendAtoms().internChar16At(cx, leTwoByte, hash, length, index);
   }
 
   const ParserAtom* atom = mbAtom.unwrapOr(nullptr);
@@ -888,16 +881,16 @@ XDRResult XDRParserAtomData(XDRState<mode>* xdr, const ParserAtom** atomp) {
   return Ok();
 }
 
-template XDRResult XDRParserAtomData(XDRState<XDR_ENCODE>* xdr,
+template XDRResult XDRParserAtomDataAt(XDRState<XDR_ENCODE>* xdr,
-                                     const ParserAtom** atomp);
+                                       const ParserAtom** atomp,
-template XDRResult XDRParserAtomData(XDRState<XDR_DECODE>* xdr,
+                                       ParserAtomIndex index);
-                                     const ParserAtom** atomp);
+template XDRResult XDRParserAtomDataAt(XDRState<XDR_DECODE>* xdr,
+                                       const ParserAtom** atomp,
+                                       ParserAtomIndex index);
 
 template <XDRMode mode>
 XDRResult XDRParserAtom(XDRState<mode>* xdr, const ParserAtom** atomp) {
   if (mode == XDR_ENCODE) {
-    MOZ_ASSERT(xdr->hasAtomMap());
-
     uint32_t atomIndex;
     ParserAtomTag tag = ParserAtomTag::Normal;
     if ((*atomp)->isWellKnownAtomId()) {
@@ -910,14 +903,7 @@ XDRResult XDRParserAtom(XDRState<mode>* xdr, const ParserAtom** atomp) {
       atomIndex = uint32_t((*atomp)->toStaticParserString2());
       tag = ParserAtomTag::Static2;
     } else {
-      MOZ_ASSERT((*atomp)->isNotInstantiated() || (*atomp)->isAtomIndex());
+      atomIndex = uint32_t((*atomp)->toParserAtomIndex());
-      MOZ_ASSERT((*atomp)->isUsedByStencil());
-
-      // Either AtomIndexKind::NotInstantiated or AtomIndexKind::AtomIndex.
-      // References to atoms are encoded as indices into the atom stream.
-      XDRParserAtomMap::Ptr p = xdr->parserAtomMap().lookup(*atomp);
-      MOZ_ASSERT(p);
-      atomIndex = p->value();
       tag = ParserAtomTag::Normal;
     }
     MOZ_TRY(XDRParserAtomTaggedIndex(xdr, &tag, &atomIndex));

js/src/frontend/ParserAtom.h

@@ -35,10 +35,6 @@ class ParserAtomsTable;
 
 mozilla::GenericErrorResult<OOM> RaiseParserAtomsOOMError(JSContext* cx);
 
-// An index into CompilationAtomCache.
-// This is local to the current compilation.
-using AtomIndex = TypedIndex<JSAtom*>;
-
 // An index to map WellKnownParserAtoms to cx->names().
 // This is consistent across multiple compilation.
 //
@@ -209,10 +205,8 @@ class alignas(alignof(uint32_t)) ParserAtomEntry {
 
   // Mapping into from ParserAtoms to JSAtoms.
   enum class AtomIndexKind : uint8_t {
-    // Not yet instantiated
+    // Index into CompilationStencil.parserAtomData.
-    NotInstantiated,
+    ParserAtomIndex,
-    // Index into CompilationAtomCache
-    AtomIndex,
     // WellKnownAtomId to index into cx->names() set
     WellKnown,
     // Index into StaticStrings length-1 set
@@ -221,12 +215,12 @@ class alignas(alignof(uint32_t)) ParserAtomEntry {
     Static2,
   };
   uint32_t atomIndex_ = 0;
-  AtomIndexKind atomIndexKind_ = AtomIndexKind::NotInstantiated;
+  AtomIndexKind atomIndexKind_ = AtomIndexKind::ParserAtomIndex;
 
   // Encoding type.
   bool hasTwoByteChars_ = false;
 
-  // Other flags.
+  // Mutable flags.
   bool usedByStencil_ = false;
 
   // End of fields.
@@ -304,13 +298,9 @@ class alignas(alignof(uint32_t)) ParserAtomEntry {
   HashNumber hash() const { return hash_; }
   uint32_t length() const { return length_; }
 
-  bool isNotInstantiated() const {
-    return atomIndexKind_ == AtomIndexKind::NotInstantiated;
-  }
-
   bool isUsedByStencil() const { return usedByStencil_; }
   void markUsedByStencil() const {
-    if ((isNotInstantiated() || isAtomIndex())) {
+    if (isParserAtomIndex()) {
       // Use const method + const_cast here to avoid marking static strings'
       // field mutable.
       const_cast<ParserAtomEntry*>(this)->usedByStencil_ = true;
@@ -322,6 +312,10 @@ class alignas(alignof(uint32_t)) ParserAtomEntry {
   template <typename CharT>
   bool equalsSeq(HashNumber hash, InflatedChar16Sequence<CharT> seq) const;
 
+  ParserAtomIndex toParserAtomIndex() const {
+    MOZ_ASSERT(isParserAtomIndex());
+    return ParserAtomIndex(atomIndex_);
+  }
   WellKnownAtomId toWellKnownAtomId() const {
     MOZ_ASSERT(isWellKnownAtomId());
     return WellKnownAtomId(atomIndex_);
@@ -335,8 +329,8 @@ class alignas(alignof(uint32_t)) ParserAtomEntry {
     return StaticParserString2(atomIndex_);
   }
 
-  bool isAtomIndex() const {
+  bool isParserAtomIndex() const {
-    return atomIndexKind_ == AtomIndexKind::AtomIndex;
+    return atomIndexKind_ == AtomIndexKind::ParserAtomIndex;
   }
   bool isWellKnownAtomId() const {
     return atomIndexKind_ == AtomIndexKind::WellKnown;
@@ -348,11 +342,12 @@ class alignas(alignof(uint32_t)) ParserAtomEntry {
     return atomIndexKind_ == AtomIndexKind::Static2;
   }
 
- private:
+  void setParserAtomIndex(ParserAtomIndex index) {
-  void setAtomIndex(AtomIndex index) {
     atomIndex_ = index;
-    atomIndexKind_ = AtomIndexKind::AtomIndex;
+    atomIndexKind_ = AtomIndexKind::ParserAtomIndex;
   }
+
+ private:
   constexpr void setWellKnownAtomId(WellKnownAtomId atomId) {
     atomIndex_ = static_cast<uint32_t>(atomId);
     atomIndexKind_ = AtomIndexKind::WellKnown;
@@ -648,10 +643,6 @@ class WellKnownParserAtoms {
   }
 };
 
-// The number of atoms with either usedByStencil or AtomIndex,
-// that requires space in CompilationAtomCache.atoms during instantiation.
-size_t RequiredNonStaticAtomCount(const ParserAtomVector& entries);
-
 bool InstantiateMarkedAtoms(JSContext* cx, const ParserAtomVector& entries,
                             CompilationAtomCache& atomCache);
 
@@ -723,22 +714,23 @@ class ParserAtomVectorBuilder {
   ParserAtomVectorBuilder(JSRuntime* rt, LifoAlloc& alloc,
                           ParserAtomVector& entries);
 
-  bool reserve(JSContext* cx, size_t count);
+  bool resize(JSContext* cx, size_t count);
   size_t length() const { return entries_.length(); }
   ParserAtom* get(size_t index) { return entries_[index]->asAtom(); }
 
-  JS::Result<const ParserAtom*, OOM> internLatin1(
+  JS::Result<const ParserAtom*, OOM> internLatin1At(
       JSContext* cx, const JS::Latin1Char* latin1Ptr, HashNumber hash,
-      uint32_t length);
+      uint32_t length, ParserAtomIndex index);
 
-  JS::Result<const ParserAtom*, OOM> internChar16(
+  JS::Result<const ParserAtom*, OOM> internChar16At(
       JSContext* cx, const LittleEndianChars twoByteLE, HashNumber hash,
-      uint32_t length);
+      uint32_t length, ParserAtomIndex index);
 
  private:
   template <typename CharT, typename SeqCharT, typename InputCharsT>
-  JS::Result<const ParserAtom*, OOM> intern(JSContext* cx, InputCharsT chars,
+  JS::Result<const ParserAtom*, OOM> internAt(JSContext* cx, InputCharsT chars,
-                                            HashNumber hash, uint32_t length);
+                                              HashNumber hash, uint32_t length,
+                                              ParserAtomIndex index);
 
  public:
   const ParserAtom* getWellKnown(WellKnownAtomId atomId) const;

js/src/frontend/Stencil.cpp

@@ -799,9 +799,7 @@ bool CompilationInfoVector::instantiateStencilsAfterPreparation(
 }
 
 bool CompilationInfo::prepareInputAndStencilForInstantiate(JSContext* cx) {
-  if (!input.atomCache.atoms.reserve(
+  if (!input.atomCache.allocate(cx, stencil.parserAtomData.length())) {
-          RequiredNonStaticAtomCount(stencil.parserAtomData))) {
-    ReportOutOfMemory(cx);
     return false;
   }
 
@@ -1583,3 +1581,51 @@ mozilla::Span<ScriptThingVariant> js::frontend::NewScriptThingSpanUninitialized(
 
   return mozilla::Span<ScriptThingVariant>(stencilThings, ngcthings);
 }
+
+JSAtom* CompilationAtomCache::getExistingAtomAt(ParserAtomIndex index) const {
+  return atoms_[index];
+}
+
+JSAtom* CompilationAtomCache::getAtomAt(ParserAtomIndex index) const {
+  if (size_t(index) >= atoms_.length()) {
+    return nullptr;
+  }
+  return atoms_[index];
+}
+
+bool CompilationAtomCache::hasAtomAt(ParserAtomIndex index) const {
+  if (size_t(index) >= atoms_.length()) {
+    return false;
+  }
+  return !!atoms_[index];
+}
+
+bool CompilationAtomCache::setAtomAt(JSContext* cx, ParserAtomIndex index,
+                                     JSAtom* atom) {
+  if (size_t(index) < atoms_.length()) {
+    atoms_[index] = atom;
+    return true;
+  }
+
+  if (!atoms_.resize(size_t(index) + 1)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  atoms_[index] = atom;
+  return true;
+}
+
+bool CompilationAtomCache::allocate(JSContext* cx, size_t length) {
+  MOZ_ASSERT(length >= atoms_.length());
+  if (length == atoms_.length()) {
+    return true;
+  }
+
+  if (!atoms_.resize(length)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  return true;
+}

js/src/vm/Xdr.cpp

@@ -305,45 +305,52 @@ template <XDRMode mode>
 static XDRResult ParserAtomTable(XDRState<mode>* xdr,
                                  frontend::CompilationStencil& stencil) {
   if (mode == XDR_ENCODE) {
+    uint32_t atomVectorLength = stencil.parserAtomData.length();
+    MOZ_TRY(XDRAtomCount(xdr, &atomVectorLength));
+
     uint32_t atomCount = 0;
     for (const auto& entry : stencil.parserAtomData) {
+      if (!entry) {
+        continue;
+      }
       if (entry->isUsedByStencil()) {
         atomCount++;
       }
     }
-
     MOZ_TRY(XDRAtomCount(xdr, &atomCount));
 
-    if (!xdr->parserAtomMap().reserve(atomCount)) {
-      return xdr->fail(JS::TranscodeResult_Throw);
-    }
-
-    uint32_t index = 0;
-
     for (const auto& entry : stencil.parserAtomData) {
+      if (!entry) {
+        continue;
+      }
       if (entry->isUsedByStencil()) {
         const frontend::ParserAtom* atom = entry->asAtom();
-        MOZ_TRY(XDRParserAtomData(xdr, &atom));
+        uint32_t index = atom->toParserAtomIndex();
-
+        MOZ_TRY(xdr->codeUint32(&index));
-        xdr->parserAtomMap().putNewInfallible(atom, index);
+        MOZ_TRY(
-        index++;
+            XDRParserAtomDataAt(xdr, &atom, frontend::ParserAtomIndex(index)));
       }
     }
 
     return Ok();
   }
 
+  uint32_t atomVectorLength;
+  MOZ_TRY(XDRAtomCount(xdr, &atomVectorLength));
+
+  if (!xdr->frontendAtoms().resize(xdr->cx(), atomVectorLength)) {
+    return xdr->fail(JS::TranscodeResult_Throw);
+  }
+
   uint32_t atomCount;
   MOZ_TRY(XDRAtomCount(xdr, &atomCount));
   MOZ_ASSERT(!xdr->hasAtomTable());
 
-  if (!xdr->frontendAtoms().reserve(xdr->cx(), atomCount)) {
-    return xdr->fail(JS::TranscodeResult_Throw);
-  }
-
   for (uint32_t i = 0; i < atomCount; i++) {
     const frontend::ParserAtom* atom = nullptr;
-    MOZ_TRY(XDRParserAtomData(xdr, &atom));
+    uint32_t index;
+    MOZ_TRY(xdr->codeUint32(&index));
+    MOZ_TRY(XDRParserAtomDataAt(xdr, &atom, frontend::ParserAtomIndex(index)));
   }
   xdr->finishAtomTable();
 
@@ -457,7 +464,6 @@ XDRResult XDRState<mode>::codeStencil(
 
   MOZ_ASSERT(isMainBuf());
   MOZ_TRY(XDRCompilationStencil(this, compilationInfo.stencil));
-  MOZ_TRY(finishChunk());
 
   return Ok();
 }
@@ -478,7 +484,6 @@ XDRResult XDRState<mode>::codeFunctionStencil(
   MOZ_TRY(ParserAtomTable(this, stencil));
 
   MOZ_TRY(XDRCompilationStencil(this, stencil));
-  MOZ_TRY(finishChunk());
 
   return Ok();
 }
@@ -709,12 +714,6 @@ XDRResult XDRIncrementalEncoder::linearize(JS::TranscodeBuffer& buffer) {
   return Ok();
 }
 
-XDRResult XDRIncrementalStencilEncoder::finishChunk() {
-  parserAtomMap_.clear();
-
-  return Ok();
-}
-
 XDRResult XDRIncrementalStencilEncoder::linearize(JS::TranscodeBuffer& buffer) {
   switchToHeaderBuf();
 

js/src/vm/Xdr.h

@@ -45,8 +45,6 @@ using XDRResult = XDRResultT<mozilla::Ok>;
 using XDRAtomTable = JS::GCVector<PreBarriered<JSAtom*>>;
 using XDRAtomMap = JS::GCHashMap<PreBarriered<JSAtom*>, uint32_t>;
 
-using XDRParserAtomMap = HashMap<const frontend::ParserAtom*, uint32_t>;
-
 class XDRBufferBase {
  public:
   explicit XDRBufferBase(JSContext* cx, size_t cursor = 0)
@@ -262,10 +260,6 @@ class XDRState : public XDRCoderBase {
 
   virtual bool hasAtomMap() const { return false; }
   virtual XDRAtomMap& atomMap() { MOZ_CRASH("does not have atomMap"); }
-  virtual XDRParserAtomMap& parserAtomMap() {
-    // This accessor is only used when encoding stencils.
-    MOZ_CRASH("does not have parserAtomMap");
-  }
   virtual uint32_t& natoms() { MOZ_CRASH("does not have atomMap."); }
 
   // The number of chunks (CompilationStencils) in the buffer.
@@ -287,7 +281,6 @@ class XDRState : public XDRCoderBase {
     MOZ_CRASH("cannot switch to header buffer.");
   }
 
-  virtual XDRResult finishChunk() { return Ok(); }
   virtual XDRResult codeDelazificationStencils(
       frontend::CompilationInfoVector& compilationInfos) {
     MOZ_CRASH("cannot code delazification stencils.");
@@ -734,10 +727,6 @@ class XDRIncrementalStencilEncoder : public XDRIncrementalEncoderBase {
   //   b. atoms
   //   c. CompilationStencil
 
-  // Map from atoms to their index in the atom buffer
-  // Reset for each chunk.
-  XDRParserAtomMap parserAtomMap_;
-
   using FunctionKey = uint64_t;
   static FunctionKey toFunctionKey(const SourceExtent& extent);
 
@@ -748,9 +737,7 @@ class XDRIncrementalStencilEncoder : public XDRIncrementalEncoderBase {
 
  public:
   explicit XDRIncrementalStencilEncoder(JSContext* cx)
-      : XDRIncrementalEncoderBase(cx),
+      : XDRIncrementalEncoderBase(cx), encodedFunctions_(cx) {}
-        parserAtomMap_(cx),
-        encodedFunctions_(cx) {}
 
   virtual ~XDRIncrementalStencilEncoder() = default;
 
@@ -759,11 +746,6 @@ class XDRIncrementalStencilEncoder : public XDRIncrementalEncoderBase {
 
   bool isForStencil() const override { return true; }
 
-  bool hasAtomMap() const override { return true; }
-  XDRParserAtomMap& parserAtomMap() override { return parserAtomMap_; }
-
-  XDRResult finishChunk() override;
-
   XDRResult linearize(JS::TranscodeBuffer& buffer) override;
 
   XDRResult codeStencils(frontend::CompilationInfoVector& compilationInfos);
@@ -783,8 +765,9 @@ XDRResult XDRParserAtom(XDRState<mode>* xdr,
                         const frontend::ParserAtom** atomp);
 
 template <XDRMode mode>
-XDRResult XDRParserAtomData(XDRState<mode>* xdr,
+XDRResult XDRParserAtomDataAt(XDRState<mode>* xdr,
-                            const frontend::ParserAtom** atomp);
+                              const frontend::ParserAtom** atomp,
+                              frontend::ParserAtomIndex index);
 
 template <XDRMode mode>
 XDRResult XDRParserAtomOrNull(XDRState<mode>* xdr,