Add m-esr52 at 52.6.0

1 files changed, 971 insertions, 0 deletions

diff --git a/js/public/MemoryMetrics.h b/js/public/MemoryMetrics.h
new file mode 100644
index 000000000..9b5caa24b
--- /dev/null
+++ b/js/public/MemoryMetrics.h
@@ -0,0 +1,971 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef js_MemoryMetrics_h
+#define js_MemoryMetrics_h
+
+// These declarations are highly likely to change in the future. Depend on them
+// at your own risk.
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/TypeTraits.h"
+
+#include <string.h>
+
+#include "jsalloc.h"
+#include "jspubtd.h"
+
+#include "js/HashTable.h"
+#include "js/TracingAPI.h"
+#include "js/Utility.h"
+#include "js/Vector.h"
+
+class nsISupports;      // Needed for ObjectPrivateVisitor.
+
+namespace JS {
+
+struct TabSizes
+{
+    enum Kind {
+        Objects,
+        Strings,
+        Private,
+        Other
+    };
+
+    TabSizes() { mozilla::PodZero(this); }
+
+    void add(Kind kind, size_t n) {
+        switch (kind) {
+            case Objects: objects  += n; break;
+            case Strings: strings  += n; break;
+            case Private: private_ += n; break;
+            case Other:   other    += n; break;
+            default:      MOZ_CRASH("bad TabSizes kind");
+        }
+    }
+
+    size_t objects;
+    size_t strings;
+    size_t private_;
+    size_t other;
+};
+
+/** These are the measurements used by Servo. */
+struct ServoSizes
+{
+    enum Kind {
+        GCHeapUsed,
+        GCHeapUnused,
+        GCHeapAdmin,
+        GCHeapDecommitted,
+        MallocHeap,
+        NonHeap,
+        Ignore
+    };
+
+    ServoSizes() { mozilla::PodZero(this); }
+
+    void add(Kind kind, size_t n) {
+        switch (kind) {
+            case GCHeapUsed:        gcHeapUsed        += n; break;
+            case GCHeapUnused:      gcHeapUnused      += n; break;
+            case GCHeapAdmin:       gcHeapAdmin       += n; break;
+            case GCHeapDecommitted: gcHeapDecommitted += n; break;
+            case MallocHeap:        mallocHeap        += n; break;
+            case NonHeap:           nonHeap           += n; break;
+            case Ignore:            /* do nothing */        break;
+            default:                MOZ_CRASH("bad ServoSizes kind");
+        }
+    }
+
+    size_t gcHeapUsed;
+    size_t gcHeapUnused;
+    size_t gcHeapAdmin;
+    size_t gcHeapDecommitted;
+    size_t mallocHeap;
+    size_t nonHeap;
+};
+
+} // namespace JS
+
+namespace js {
+
+/**
+ * In memory reporting, we have concept of "sundries", line items which are too
+ * small to be worth reporting individually.  Under some circumstances, a memory
+ * reporter gets tossed into the sundries bucket if it's smaller than
+ * MemoryReportingSundriesThreshold() bytes.
+ *
+ * We need to define this value here, rather than in the code which actually
+ * generates the memory reports, because NotableStringInfo uses this value.
+ */
+JS_FRIEND_API(size_t) MemoryReportingSundriesThreshold();
+
+/**
+ * This hash policy avoids flattening ropes (which perturbs the site being
+ * measured and requires a JSContext) at the expense of doing a FULL ROPE COPY
+ * on every hash and match! Beware.
+ */
+struct InefficientNonFlatteningStringHashPolicy
+{
+    typedef JSString* Lookup;
+    static HashNumber hash(const Lookup& l);
+    static bool match(const JSString* const& k, const Lookup& l);
+};
+
+struct CStringHashPolicy
+{
+    typedef const char* Lookup;
+    static HashNumber hash(const Lookup& l);
+    static bool match(const char* const& k, const Lookup& l);
+};
+
+// This file features many classes with numerous size_t fields, and each such
+// class has one or more methods that need to operate on all of these fields.
+// Writing these individually is error-prone -- it's easy to add a new field
+// without updating all the required methods.  So we define a single macro list
+// in each class to name the fields (and notable characteristics of them), and
+// then use the following macros to transform those lists into the required
+// methods.
+//
+// - The |tabKind| value is used when measuring TabSizes.
+//
+// - The |servoKind| value is used when measuring ServoSizes and also for
+//   the various sizeOfLiveGCThings() methods.
+//
+// In some classes, one or more of the macro arguments aren't used.  We use '_'
+// for those.
+//
+#define DECL_SIZE(tabKind, servoKind, mSize)        size_t mSize;
+#define ZERO_SIZE(tabKind, servoKind, mSize)        mSize(0),
+#define COPY_OTHER_SIZE(tabKind, servoKind, mSize)  mSize(other.mSize),
+#define ADD_OTHER_SIZE(tabKind, servoKind, mSize)   mSize += other.mSize;
+#define SUB_OTHER_SIZE(tabKind, servoKind, mSize) \
+    MOZ_ASSERT(mSize >= other.mSize); \
+    mSize -= other.mSize;
+#define ADD_SIZE_TO_N(tabKind, servoKind, mSize)                  n += mSize;
+#define ADD_SIZE_TO_N_IF_LIVE_GC_THING(tabKind, servoKind, mSize) \
+    /* Avoid self-comparison warnings by comparing enums indirectly. */ \
+    n += (mozilla::IsSame<int[ServoSizes::servoKind], int[ServoSizes::GCHeapUsed]>::value) \
+         ? mSize \
+         : 0;
+#define ADD_TO_TAB_SIZES(tabKind, servoKind, mSize)               sizes->add(JS::TabSizes::tabKind, mSize);
+#define ADD_TO_SERVO_SIZES(tabKind, servoKind, mSize)             sizes->add(JS::ServoSizes::servoKind, mSize);
+
+} // namespace js
+
+namespace JS {
+
+struct ClassInfo
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(Objects, GCHeapUsed, objectsGCHeap) \
+    macro(Objects, MallocHeap, objectsMallocHeapSlots) \
+    macro(Objects, MallocHeap, objectsMallocHeapElementsNormal) \
+    macro(Objects, MallocHeap, objectsMallocHeapElementsAsmJS) \
+    macro(Objects, MallocHeap, objectsMallocHeapMisc) \
+    macro(Objects, NonHeap,    objectsNonHeapElementsNormal) \
+    macro(Objects, NonHeap,    objectsNonHeapElementsShared) \
+    macro(Objects, NonHeap,    objectsNonHeapElementsWasm) \
+    macro(Objects, NonHeap,    objectsNonHeapCodeWasm)
+
+    ClassInfo()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        wasmGuardPages(0)
+    {}
+
+    void add(const ClassInfo& other) {
+        FOR_EACH_SIZE(ADD_OTHER_SIZE)
+    }
+
+    void subtract(const ClassInfo& other) {
+        FOR_EACH_SIZE(SUB_OTHER_SIZE)
+    }
+
+    size_t sizeOfAllThings() const {
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N)
+        return n;
+    }
+
+    bool isNotable() const {
+        static const size_t NotabilityThreshold = 16 * 1024;
+        return sizeOfAllThings() >= NotabilityThreshold;
+    }
+
+    size_t sizeOfLiveGCThings() const {
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N_IF_LIVE_GC_THING)
+        return n;
+    }
+
+    void addToTabSizes(TabSizes* sizes) const {
+        FOR_EACH_SIZE(ADD_TO_TAB_SIZES)
+    }
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+    size_t wasmGuardPages;
+
+#undef FOR_EACH_SIZE
+};
+
+struct ShapeInfo
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(Other,   GCHeapUsed, shapesGCHeapTree) \
+    macro(Other,   GCHeapUsed, shapesGCHeapDict) \
+    macro(Other,   GCHeapUsed, shapesGCHeapBase) \
+    macro(Other,   MallocHeap, shapesMallocHeapTreeTables) \
+    macro(Other,   MallocHeap, shapesMallocHeapDictTables) \
+    macro(Other,   MallocHeap, shapesMallocHeapTreeKids)
+
+    ShapeInfo()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        dummy()
+    {}
+
+    void add(const ShapeInfo& other) {
+        FOR_EACH_SIZE(ADD_OTHER_SIZE)
+    }
+
+    void subtract(const ShapeInfo& other) {
+        FOR_EACH_SIZE(SUB_OTHER_SIZE)
+    }
+
+    size_t sizeOfAllThings() const {
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N)
+        return n;
+    }
+
+    size_t sizeOfLiveGCThings() const {
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N_IF_LIVE_GC_THING)
+        return n;
+    }
+
+    void addToTabSizes(TabSizes* sizes) const {
+        FOR_EACH_SIZE(ADD_TO_TAB_SIZES)
+    }
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+    int dummy;  // present just to absorb the trailing comma from FOR_EACH_SIZE(ZERO_SIZE)
+
+#undef FOR_EACH_SIZE
+};
+
+/**
+ * Holds data about a notable class (one whose combined object and shape
+ * instances use more than a certain amount of memory) so we can report it
+ * individually.
+ *
+ * The only difference between this class and ClassInfo is that this class
+ * holds a copy of the filename.
+ */
+struct NotableClassInfo : public ClassInfo
+{
+    NotableClassInfo();
+    NotableClassInfo(const char* className, const ClassInfo& info);
+    NotableClassInfo(NotableClassInfo&& info);
+    NotableClassInfo& operator=(NotableClassInfo&& info);
+
+    ~NotableClassInfo() {
+        js_free(className_);
+    }
+
+    char* className_;
+
+  private:
+    NotableClassInfo(const NotableClassInfo& info) = delete;
+};
+
+/** Data for tracking JIT-code memory usage. */
+struct CodeSizes
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(_, NonHeap, ion) \
+    macro(_, NonHeap, baseline) \
+    macro(_, NonHeap, regexp) \
+    macro(_, NonHeap, other) \
+    macro(_, NonHeap, unused)
+
+    CodeSizes()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        dummy()
+    {}
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+    int dummy;  // present just to absorb the trailing comma from FOR_EACH_SIZE(ZERO_SIZE)
+
+#undef FOR_EACH_SIZE
+};
+
+/** Data for tracking GC memory usage. */
+struct GCSizes
+{
+    // |nurseryDecommitted| is marked as NonHeap rather than GCHeapDecommitted
+    // because we don't consider the nursery to be part of the GC heap.
+#define FOR_EACH_SIZE(macro) \
+    macro(_, MallocHeap, marker) \
+    macro(_, NonHeap,    nurseryCommitted) \
+    macro(_, MallocHeap, nurseryMallocedBuffers) \
+    macro(_, MallocHeap, storeBufferVals) \
+    macro(_, MallocHeap, storeBufferCells) \
+    macro(_, MallocHeap, storeBufferSlots) \
+    macro(_, MallocHeap, storeBufferWholeCells) \
+    macro(_, MallocHeap, storeBufferGenerics)
+
+    GCSizes()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        dummy()
+    {}
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+    int dummy;  // present just to absorb the trailing comma from FOR_EACH_SIZE(ZERO_SIZE)
+
+#undef FOR_EACH_SIZE
+};
+
+/**
+ * This class holds information about the memory taken up by identical copies of
+ * a particular string.  Multiple JSStrings may have their sizes aggregated
+ * together into one StringInfo object.  Note that two strings with identical
+ * chars will not be aggregated together if one is a short string and the other
+ * is not.
+ */
+struct StringInfo
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(Strings, GCHeapUsed, gcHeapLatin1) \
+    macro(Strings, GCHeapUsed, gcHeapTwoByte) \
+    macro(Strings, MallocHeap, mallocHeapLatin1) \
+    macro(Strings, MallocHeap, mallocHeapTwoByte)
+
+    StringInfo()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        numCopies(0)
+    {}
+
+    void add(const StringInfo& other) {
+        FOR_EACH_SIZE(ADD_OTHER_SIZE);
+        numCopies++;
+    }
+
+    void subtract(const StringInfo& other) {
+        FOR_EACH_SIZE(SUB_OTHER_SIZE);
+        numCopies--;
+    }
+
+    bool isNotable() const {
+        static const size_t NotabilityThreshold = 16 * 1024;
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N)
+        return n >= NotabilityThreshold;
+    }
+
+    size_t sizeOfLiveGCThings() const {
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N_IF_LIVE_GC_THING)
+        return n;
+    }
+
+    void addToTabSizes(TabSizes* sizes) const {
+        FOR_EACH_SIZE(ADD_TO_TAB_SIZES)
+    }
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+    uint32_t numCopies;     // How many copies of the string have we seen?
+
+#undef FOR_EACH_SIZE
+};
+
+/**
+ * Holds data about a notable string (one which, counting all duplicates, uses
+ * more than a certain amount of memory) so we can report it individually.
+ *
+ * The only difference between this class and StringInfo is that
+ * NotableStringInfo holds a copy of some or all of the string's chars.
+ */
+struct NotableStringInfo : public StringInfo
+{
+    static const size_t MAX_SAVED_CHARS = 1024;
+
+    NotableStringInfo();
+    NotableStringInfo(JSString* str, const StringInfo& info);
+    NotableStringInfo(NotableStringInfo&& info);
+    NotableStringInfo& operator=(NotableStringInfo&& info);
+
+    ~NotableStringInfo() {
+        js_free(buffer);
+    }
+
+    char* buffer;
+    size_t length;
+
+  private:
+    NotableStringInfo(const NotableStringInfo& info) = delete;
+};
+
+/**
+ * This class holds information about the memory taken up by script sources
+ * from a particular file.
+ */
+struct ScriptSourceInfo
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(_, MallocHeap, misc)
+
+    ScriptSourceInfo()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        numScripts(0)
+    {}
+
+    void add(const ScriptSourceInfo& other) {
+        FOR_EACH_SIZE(ADD_OTHER_SIZE)
+        numScripts++;
+    }
+
+    void subtract(const ScriptSourceInfo& other) {
+        FOR_EACH_SIZE(SUB_OTHER_SIZE)
+        numScripts--;
+    }
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+    }
+
+    bool isNotable() const {
+        static const size_t NotabilityThreshold = 16 * 1024;
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N)
+        return n >= NotabilityThreshold;
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+    uint32_t numScripts;    // How many ScriptSources come from this file? (It
+                            // can be more than one in XML files that have
+                            // multiple scripts in CDATA sections.)
+#undef FOR_EACH_SIZE
+};
+
+/**
+ * Holds data about a notable script source file (one whose combined
+ * script sources use more than a certain amount of memory) so we can report it
+ * individually.
+ *
+ * The only difference between this class and ScriptSourceInfo is that this
+ * class holds a copy of the filename.
+ */
+struct NotableScriptSourceInfo : public ScriptSourceInfo
+{
+    NotableScriptSourceInfo();
+    NotableScriptSourceInfo(const char* filename, const ScriptSourceInfo& info);
+    NotableScriptSourceInfo(NotableScriptSourceInfo&& info);
+    NotableScriptSourceInfo& operator=(NotableScriptSourceInfo&& info);
+
+    ~NotableScriptSourceInfo() {
+        js_free(filename_);
+    }
+
+    char* filename_;
+
+  private:
+    NotableScriptSourceInfo(const NotableScriptSourceInfo& info) = delete;
+};
+
+/**
+ * These measurements relate directly to the JSRuntime, and not to zones and
+ * compartments within it.
+ */
+struct RuntimeSizes
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(_, MallocHeap, object) \
+    macro(_, MallocHeap, atomsTable) \
+    macro(_, MallocHeap, contexts) \
+    macro(_, MallocHeap, temporary) \
+    macro(_, MallocHeap, interpreterStack) \
+    macro(_, MallocHeap, mathCache) \
+    macro(_, MallocHeap, sharedImmutableStringsCache) \
+    macro(_, MallocHeap, sharedIntlData) \
+    macro(_, MallocHeap, uncompressedSourceCache) \
+    macro(_, MallocHeap, scriptData)
+
+    RuntimeSizes()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        scriptSourceInfo(),
+        code(),
+        gc(),
+        notableScriptSources()
+    {
+        allScriptSources = js_new<ScriptSourcesHashMap>();
+        if (!allScriptSources || !allScriptSources->init())
+            MOZ_CRASH("oom");
+    }
+
+    ~RuntimeSizes() {
+        // |allScriptSources| is usually deleted and set to nullptr before this
+        // destructor runs. But there are failure cases due to OOMs that may
+        // prevent that, so it doesn't hurt to try again here.
+        js_delete(allScriptSources);
+    }
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+        scriptSourceInfo.addToServoSizes(sizes);
+        code.addToServoSizes(sizes);
+        gc.addToServoSizes(sizes);
+    }
+
+    // The script source measurements in |scriptSourceInfo| are initially for
+    // all script sources.  At the end, if the measurement granularity is
+    // FineGrained, we subtract the measurements of the notable script sources
+    // and move them into |notableScriptSources|.
+    FOR_EACH_SIZE(DECL_SIZE)
+    ScriptSourceInfo scriptSourceInfo;
+    CodeSizes code;
+    GCSizes gc;
+
+    typedef js::HashMap<const char*, ScriptSourceInfo,
+                        js::CStringHashPolicy,
+                        js::SystemAllocPolicy> ScriptSourcesHashMap;
+
+    // |allScriptSources| is only used transiently.  During the reporting phase
+    // it is filled with info about every script source in the runtime.  It's
+    // then used to fill in |notableScriptSources| (which actually gets
+    // reported), and immediately discarded afterwards.
+    ScriptSourcesHashMap* allScriptSources;
+    js::Vector<NotableScriptSourceInfo, 0, js::SystemAllocPolicy> notableScriptSources;
+
+#undef FOR_EACH_SIZE
+};
+
+struct UnusedGCThingSizes
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(Other, GCHeapUnused, object) \
+    macro(Other, GCHeapUnused, script) \
+    macro(Other, GCHeapUnused, lazyScript) \
+    macro(Other, GCHeapUnused, shape) \
+    macro(Other, GCHeapUnused, baseShape) \
+    macro(Other, GCHeapUnused, objectGroup) \
+    macro(Other, GCHeapUnused, string) \
+    macro(Other, GCHeapUnused, symbol) \
+    macro(Other, GCHeapUnused, jitcode) \
+    macro(Other, GCHeapUnused, scope)
+
+    UnusedGCThingSizes()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        dummy()
+    {}
+
+    UnusedGCThingSizes(UnusedGCThingSizes&& other)
+      : FOR_EACH_SIZE(COPY_OTHER_SIZE)
+        dummy()
+    {}
+
+    void addToKind(JS::TraceKind kind, intptr_t n) {
+        switch (kind) {
+          case JS::TraceKind::Object:       object += n;      break;
+          case JS::TraceKind::String:       string += n;      break;
+          case JS::TraceKind::Symbol:       symbol += n;      break;
+          case JS::TraceKind::Script:       script += n;      break;
+          case JS::TraceKind::Shape:        shape += n;       break;
+          case JS::TraceKind::BaseShape:    baseShape += n;   break;
+          case JS::TraceKind::JitCode:      jitcode += n;     break;
+          case JS::TraceKind::LazyScript:   lazyScript += n;  break;
+          case JS::TraceKind::ObjectGroup:  objectGroup += n; break;
+          case JS::TraceKind::Scope:        scope += n;       break;
+          default:
+            MOZ_CRASH("Bad trace kind for UnusedGCThingSizes");
+        }
+    }
+
+    void addSizes(const UnusedGCThingSizes& other) {
+        FOR_EACH_SIZE(ADD_OTHER_SIZE)
+    }
+
+    size_t totalSize() const {
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N)
+        return n;
+    }
+
+    void addToTabSizes(JS::TabSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_TAB_SIZES)
+    }
+
+    void addToServoSizes(JS::ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+    int dummy;  // present just to absorb the trailing comma from FOR_EACH_SIZE(ZERO_SIZE)
+
+#undef FOR_EACH_SIZE
+};
+
+struct ZoneStats
+{
+#define FOR_EACH_SIZE(macro) \
+    macro(Other,   GCHeapUsed,  symbolsGCHeap) \
+    macro(Other,   GCHeapAdmin, gcHeapArenaAdmin) \
+    macro(Other,   GCHeapUsed,  lazyScriptsGCHeap) \
+    macro(Other,   MallocHeap,  lazyScriptsMallocHeap) \
+    macro(Other,   GCHeapUsed,  jitCodesGCHeap) \
+    macro(Other,   GCHeapUsed,  objectGroupsGCHeap) \
+    macro(Other,   MallocHeap,  objectGroupsMallocHeap) \
+    macro(Other,   GCHeapUsed,  scopesGCHeap) \
+    macro(Other,   MallocHeap,  scopesMallocHeap) \
+    macro(Other,   MallocHeap,  typePool) \
+    macro(Other,   MallocHeap,  baselineStubsOptimized) \
+    macro(Other,   MallocHeap,  uniqueIdMap) \
+    macro(Other,   MallocHeap,  shapeTables)
+
+    ZoneStats()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        unusedGCThings(),
+        stringInfo(),
+        shapeInfo(),
+        extra(),
+        allStrings(nullptr),
+        notableStrings(),
+        isTotals(true)
+    {}
+
+    ZoneStats(ZoneStats&& other)
+      : FOR_EACH_SIZE(COPY_OTHER_SIZE)
+        unusedGCThings(mozilla::Move(other.unusedGCThings)),
+        stringInfo(mozilla::Move(other.stringInfo)),
+        shapeInfo(mozilla::Move(other.shapeInfo)),
+        extra(other.extra),
+        allStrings(other.allStrings),
+        notableStrings(mozilla::Move(other.notableStrings)),
+        isTotals(other.isTotals)
+    {
+        other.allStrings = nullptr;
+        MOZ_ASSERT(!other.isTotals);
+    }
+
+    ~ZoneStats() {
+        // |allStrings| is usually deleted and set to nullptr before this
+        // destructor runs. But there are failure cases due to OOMs that may
+        // prevent that, so it doesn't hurt to try again here.
+        js_delete(allStrings);
+    }
+
+    bool initStrings(JSRuntime* rt);
+
+    void addSizes(const ZoneStats& other) {
+        MOZ_ASSERT(isTotals);
+        FOR_EACH_SIZE(ADD_OTHER_SIZE)
+        unusedGCThings.addSizes(other.unusedGCThings);
+        stringInfo.add(other.stringInfo);
+        shapeInfo.add(other.shapeInfo);
+    }
+
+    size_t sizeOfLiveGCThings() const {
+        MOZ_ASSERT(isTotals);
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N_IF_LIVE_GC_THING)
+        n += stringInfo.sizeOfLiveGCThings();
+        n += shapeInfo.sizeOfLiveGCThings();
+        return n;
+    }
+
+    void addToTabSizes(JS::TabSizes* sizes) const {
+        MOZ_ASSERT(isTotals);
+        FOR_EACH_SIZE(ADD_TO_TAB_SIZES)
+        unusedGCThings.addToTabSizes(sizes);
+        stringInfo.addToTabSizes(sizes);
+        shapeInfo.addToTabSizes(sizes);
+    }
+
+    void addToServoSizes(JS::ServoSizes *sizes) const {
+        MOZ_ASSERT(isTotals);
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+        unusedGCThings.addToServoSizes(sizes);
+        stringInfo.addToServoSizes(sizes);
+        shapeInfo.addToServoSizes(sizes);
+    }
+
+    // These string measurements are initially for all strings.  At the end,
+    // if the measurement granularity is FineGrained, we subtract the
+    // measurements of the notable script sources and move them into
+    // |notableStrings|.
+    FOR_EACH_SIZE(DECL_SIZE)
+    UnusedGCThingSizes unusedGCThings;
+    StringInfo stringInfo;
+    ShapeInfo shapeInfo;
+    void* extra;    // This field can be used by embedders.
+
+    typedef js::HashMap<JSString*, StringInfo,
+                        js::InefficientNonFlatteningStringHashPolicy,
+                        js::SystemAllocPolicy> StringsHashMap;
+
+    // |allStrings| is only used transiently.  During the zone traversal it is
+    // filled with info about every string in the zone.  It's then used to fill
+    // in |notableStrings| (which actually gets reported), and immediately
+    // discarded afterwards.
+    StringsHashMap* allStrings;
+    js::Vector<NotableStringInfo, 0, js::SystemAllocPolicy> notableStrings;
+    bool isTotals;
+
+#undef FOR_EACH_SIZE
+};
+
+struct CompartmentStats
+{
+    // We assume that |objectsPrivate| is on the malloc heap, but it's not
+    // actually guaranteed. But for Servo, at least, it's a moot point because
+    // it doesn't provide an ObjectPrivateVisitor so the value will always be
+    // zero.
+#define FOR_EACH_SIZE(macro) \
+    macro(Private, MallocHeap, objectsPrivate) \
+    macro(Other,   GCHeapUsed, scriptsGCHeap) \
+    macro(Other,   MallocHeap, scriptsMallocHeapData) \
+    macro(Other,   MallocHeap, baselineData) \
+    macro(Other,   MallocHeap, baselineStubsFallback) \
+    macro(Other,   MallocHeap, ionData) \
+    macro(Other,   MallocHeap, typeInferenceTypeScripts) \
+    macro(Other,   MallocHeap, typeInferenceAllocationSiteTables) \
+    macro(Other,   MallocHeap, typeInferenceArrayTypeTables) \
+    macro(Other,   MallocHeap, typeInferenceObjectTypeTables) \
+    macro(Other,   MallocHeap, compartmentObject) \
+    macro(Other,   MallocHeap, compartmentTables) \
+    macro(Other,   MallocHeap, innerViewsTable) \
+    macro(Other,   MallocHeap, lazyArrayBuffersTable) \
+    macro(Other,   MallocHeap, objectMetadataTable) \
+    macro(Other,   MallocHeap, crossCompartmentWrappersTable) \
+    macro(Other,   MallocHeap, regexpCompartment) \
+    macro(Other,   MallocHeap, savedStacksSet) \
+    macro(Other,   MallocHeap, varNamesSet) \
+    macro(Other,   MallocHeap, nonSyntacticLexicalScopesTable) \
+    macro(Other,   MallocHeap, jitCompartment) \
+    macro(Other,   MallocHeap, privateData)
+
+    CompartmentStats()
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        classInfo(),
+        extra(),
+        allClasses(nullptr),
+        notableClasses(),
+        isTotals(true)
+    {}
+
+    CompartmentStats(CompartmentStats&& other)
+      : FOR_EACH_SIZE(COPY_OTHER_SIZE)
+        classInfo(mozilla::Move(other.classInfo)),
+        extra(other.extra),
+        allClasses(other.allClasses),
+        notableClasses(mozilla::Move(other.notableClasses)),
+        isTotals(other.isTotals)
+    {
+        other.allClasses = nullptr;
+        MOZ_ASSERT(!other.isTotals);
+    }
+
+    CompartmentStats(const CompartmentStats&) = delete; // disallow copying
+
+    ~CompartmentStats() {
+        // |allClasses| is usually deleted and set to nullptr before this
+        // destructor runs. But there are failure cases due to OOMs that may
+        // prevent that, so it doesn't hurt to try again here.
+        js_delete(allClasses);
+    }
+
+    bool initClasses(JSRuntime* rt);
+
+    void addSizes(const CompartmentStats& other) {
+        MOZ_ASSERT(isTotals);
+        FOR_EACH_SIZE(ADD_OTHER_SIZE)
+        classInfo.add(other.classInfo);
+    }
+
+    size_t sizeOfLiveGCThings() const {
+        MOZ_ASSERT(isTotals);
+        size_t n = 0;
+        FOR_EACH_SIZE(ADD_SIZE_TO_N_IF_LIVE_GC_THING)
+        n += classInfo.sizeOfLiveGCThings();
+        return n;
+    }
+
+    void addToTabSizes(TabSizes* sizes) const {
+        MOZ_ASSERT(isTotals);
+        FOR_EACH_SIZE(ADD_TO_TAB_SIZES);
+        classInfo.addToTabSizes(sizes);
+    }
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        MOZ_ASSERT(isTotals);
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES);
+        classInfo.addToServoSizes(sizes);
+    }
+
+    // The class measurements in |classInfo| are initially for all classes.  At
+    // the end, if the measurement granularity is FineGrained, we subtract the
+    // measurements of the notable classes and move them into |notableClasses|.
+    FOR_EACH_SIZE(DECL_SIZE)
+    ClassInfo classInfo;
+    void* extra;            // This field can be used by embedders.
+
+    typedef js::HashMap<const char*, ClassInfo,
+                        js::CStringHashPolicy,
+                        js::SystemAllocPolicy> ClassesHashMap;
+
+    // These are similar to |allStrings| and |notableStrings| in ZoneStats.
+    ClassesHashMap* allClasses;
+    js::Vector<NotableClassInfo, 0, js::SystemAllocPolicy> notableClasses;
+    bool isTotals;
+
+#undef FOR_EACH_SIZE
+};
+
+typedef js::Vector<CompartmentStats, 0, js::SystemAllocPolicy> CompartmentStatsVector;
+typedef js::Vector<ZoneStats, 0, js::SystemAllocPolicy> ZoneStatsVector;
+
+struct RuntimeStats
+{
+    // |gcHeapChunkTotal| is ignored because it's the sum of all the other
+    // values. |gcHeapGCThings| is ignored because it's the sum of some of the
+    // values from the zones and compartments. Both of those values are not
+    // reported directly, but are just present for sanity-checking other
+    // values.
+#define FOR_EACH_SIZE(macro) \
+    macro(_, Ignore,            gcHeapChunkTotal) \
+    macro(_, GCHeapDecommitted, gcHeapDecommittedArenas) \
+    macro(_, GCHeapUnused,      gcHeapUnusedChunks) \
+    macro(_, GCHeapUnused,      gcHeapUnusedArenas) \
+    macro(_, GCHeapAdmin,       gcHeapChunkAdmin) \
+    macro(_, Ignore,            gcHeapGCThings)
+
+    explicit RuntimeStats(mozilla::MallocSizeOf mallocSizeOf)
+      : FOR_EACH_SIZE(ZERO_SIZE)
+        runtime(),
+        cTotals(),
+        zTotals(),
+        compartmentStatsVector(),
+        zoneStatsVector(),
+        currZoneStats(nullptr),
+        mallocSizeOf_(mallocSizeOf)
+    {}
+
+    // Here's a useful breakdown of the GC heap.
+    //
+    // - rtStats.gcHeapChunkTotal
+    //   - decommitted bytes
+    //     - rtStats.gcHeapDecommittedArenas (decommitted arenas in non-empty chunks)
+    //   - unused bytes
+    //     - rtStats.gcHeapUnusedChunks (empty chunks)
+    //     - rtStats.gcHeapUnusedArenas (empty arenas within non-empty chunks)
+    //     - rtStats.zTotals.unusedGCThings.totalSize() (empty GC thing slots within non-empty arenas)
+    //   - used bytes
+    //     - rtStats.gcHeapChunkAdmin
+    //     - rtStats.zTotals.gcHeapArenaAdmin
+    //     - rtStats.gcHeapGCThings (in-use GC things)
+    //       == rtStats.zTotals.sizeOfLiveGCThings() + rtStats.cTotals.sizeOfLiveGCThings()
+    //
+    // It's possible that some arenas in empty chunks may be decommitted, but
+    // we don't count those under rtStats.gcHeapDecommittedArenas because (a)
+    // it's rare, and (b) this means that rtStats.gcHeapUnusedChunks is a
+    // multiple of the chunk size, which is good.
+
+    void addToServoSizes(ServoSizes *sizes) const {
+        FOR_EACH_SIZE(ADD_TO_SERVO_SIZES)
+        runtime.addToServoSizes(sizes);
+    }
+
+    FOR_EACH_SIZE(DECL_SIZE)
+
+    RuntimeSizes runtime;
+
+    CompartmentStats cTotals;   // The sum of this runtime's compartments' measurements.
+    ZoneStats zTotals;          // The sum of this runtime's zones' measurements.
+
+    CompartmentStatsVector compartmentStatsVector;
+    ZoneStatsVector zoneStatsVector;
+
+    ZoneStats* currZoneStats;
+
+    mozilla::MallocSizeOf mallocSizeOf_;
+
+    virtual void initExtraCompartmentStats(JSCompartment* c, CompartmentStats* cstats) = 0;
+    virtual void initExtraZoneStats(JS::Zone* zone, ZoneStats* zstats) = 0;
+
+#undef FOR_EACH_SIZE
+};
+
+class ObjectPrivateVisitor
+{
+  public:
+    // Within CollectRuntimeStats, this method is called for each JS object
+    // that has an nsISupports pointer.
+    virtual size_t sizeOfIncludingThis(nsISupports* aSupports) = 0;
+
+    // A callback that gets a JSObject's nsISupports pointer, if it has one.
+    // Note: this function does *not* addref |iface|.
+    typedef bool(*GetISupportsFun)(JSObject* obj, nsISupports** iface);
+    GetISupportsFun getISupports_;
+
+    explicit ObjectPrivateVisitor(GetISupportsFun getISupports)
+      : getISupports_(getISupports)
+    {}
+};
+
+extern JS_PUBLIC_API(bool)
+CollectRuntimeStats(JSContext* cx, RuntimeStats* rtStats, ObjectPrivateVisitor* opv, bool anonymize);
+
+extern JS_PUBLIC_API(size_t)
+SystemCompartmentCount(JSContext* cx);
+
+extern JS_PUBLIC_API(size_t)
+UserCompartmentCount(JSContext* cx);
+
+extern JS_PUBLIC_API(size_t)
+PeakSizeOfTemporary(const JSContext* cx);
+
+extern JS_PUBLIC_API(bool)
+AddSizeOfTab(JSContext* cx, JS::HandleObject obj, mozilla::MallocSizeOf mallocSizeOf,
+             ObjectPrivateVisitor* opv, TabSizes* sizes);
+
+extern JS_PUBLIC_API(bool)
+AddServoSizeOf(JSContext* cx, mozilla::MallocSizeOf mallocSizeOf,
+               ObjectPrivateVisitor *opv, ServoSizes *sizes);
+
+} // namespace JS
+
+#undef DECL_SIZE
+#undef ZERO_SIZE
+#undef COPY_OTHER_SIZE
+#undef ADD_OTHER_SIZE
+#undef SUB_OTHER_SIZE
+#undef ADD_SIZE_TO_N
+#undef ADD_SIZE_TO_N_IF_LIVE_GC_THING
+#undef ADD_TO_TAB_SIZES
+
+#endif /* js_MemoryMetrics_h */