Bug 1199215 - Implement JS::ubi::Node::size for JS::Symbol referents; r=sfink

js/public/UbiNode.h

@@ -1005,7 +1005,18 @@ class TracerConcreteWithCompartment : public TracerConcrete<Referent> {
 
 // Define specializations for some commonly-used public JSAPI types.
 // These can use the generic templates above.
-template<> struct Concrete<JS::Symbol> : TracerConcrete<JS::Symbol> { };
+template<>
+struct Concrete<JS::Symbol> : TracerConcrete<JS::Symbol> {
+    Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
+
+  protected:
+    explicit Concrete(JS::Symbol* ptr) : TracerConcrete(ptr) { }
+
+  public:
+    static void construct(void* storage, JS::Symbol* ptr) {
+        new (storage) Concrete(ptr);
+    }
+};
 
 template<> struct Concrete<JSScript> : TracerConcreteWithCompartment<JSScript> {
     CoarseType coarseType() const final { return CoarseType::Script; }

js/src/jit-test/tests/heap-analysis/byteSize-of-symbol.js

@@ -0,0 +1,25 @@
+// Check JS::ubi::Node::size results for symbols.
+
+// We actually hard-code specific sizes into this test, even though they're
+// implementation details, because in practice there are only two architecture
+// variants to consider (32-bit and 64-bit), and if these sizes change, that's
+// something SpiderMonkey hackers really want to know; they're supposed to be
+// stable.
+
+// Run this test only if we're using jemalloc. Other malloc implementations
+// exhibit surprising behaviors. For example, 32-bit Fedora builds have
+// non-deterministic allocation sizes.
+var config = getBuildConfiguration();
+if (!config['moz-memory'])
+  quit(0);
+
+const SIZE_OF_SYMBOL = config['pointer-byte-size'] == 4 ? 16 : 24;
+
+// Without a description.
+assertEq(byteSize(Symbol()), SIZE_OF_SYMBOL);
+
+// With a description.
+assertEq(byteSize(Symbol("This is a relatively long description to be passed to "
+                         + "Symbol() but it doesn't matter because it just gets "
+                         + "interned as a JSAtom* anyways.")),
+         SIZE_OF_SYMBOL);

js/src/vm/Symbol.cpp

@@ -152,3 +152,13 @@ js::ToSymbolPrimitive(Value v)
     MOZ_ASSERT(IsSymbolOrSymbolWrapper(v));
     return v.isSymbol() ? v.toSymbol() : v.toObject().as<SymbolObject>().unbox();
 }
+
+
+JS::ubi::Node::Size
+JS::ubi::Concrete<JS::Symbol>::size(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    // If we start allocating symbols in the nursery, we will need to update
+    // this method.
+    MOZ_ASSERT(get().isTenured());
+    return js::gc::Arena::thingSize(get().asTenured().getAllocKind());
+}

js/src/vm/Symbol.h

@@ -67,6 +67,10 @@ class Symbol : public js::gc::TenuredCell
             thing->asTenured().writeBarrierPre(thing);
     }
 
+    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return mallocSizeOf(this);
+    }
+
 #ifdef DEBUG
     void dump(FILE* fp = stderr);
 #endif