mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-10 03:45:46 +00:00
Backed out changeset 2620e5ba1067 (bug 1282795) for 'Concrete' redeclaration in HeapSnapshot.h (static failure). r=backout
This commit is contained in:
parent
ccddc5c404
commit
cfa0d595fb
@ -244,7 +244,7 @@ using mozilla::devtools::DeserializedNode;
|
||||
using mozilla::devtools::DeserializedStackFrame;
|
||||
|
||||
template<>
|
||||
class Concrete<DeserializedNode> : public Base
|
||||
struct Concrete<DeserializedNode> : public Base
|
||||
{
|
||||
protected:
|
||||
explicit Concrete(DeserializedNode* ptr) : Base(ptr) { }
|
||||
@ -253,6 +253,8 @@ protected:
|
||||
}
|
||||
|
||||
public:
|
||||
static const char16_t concreteTypeName[];
|
||||
|
||||
static void construct(void* storage, DeserializedNode* ptr) {
|
||||
new (storage) Concrete(ptr);
|
||||
}
|
||||
@ -271,8 +273,6 @@ public:
|
||||
// We ignore the `bool wantNames` parameter because we can't control whether
|
||||
// the core dump was serialized with edge names or not.
|
||||
js::UniquePtr<EdgeRange> edges(JSRuntime* rt, bool) const override;
|
||||
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
template<>
|
||||
|
@ -641,28 +641,28 @@ class Base {
|
||||
};
|
||||
|
||||
// A traits template with a specialization for each referent type that
|
||||
// ubi::Node supports. The specialization must be the concrete subclass of Base
|
||||
// that represents a pointer to the referent type. It must include these
|
||||
// members:
|
||||
//
|
||||
// // The specific char16_t array returned by Concrete<T>::typeName().
|
||||
// static const char16_t concreteTypeName[];
|
||||
//
|
||||
// // Construct an instance of this concrete class in |storage| referring
|
||||
// // to |referent|. Implementations typically use a placement 'new'.
|
||||
// //
|
||||
// // In some cases, |referent| will contain dynamic type information that
|
||||
// // identifies it a some more specific subclass of |Referent|. For
|
||||
// // example, when |Referent| is |JSObject|, then |referent->getClass()|
|
||||
// // could tell us that it's actually a JSFunction. Similarly, if
|
||||
// // |Referent| is |nsISupports|, we would like a ubi::Node that knows its
|
||||
// // final implementation type.
|
||||
// //
|
||||
// // So we delegate the actual construction to this specialization, which
|
||||
// // knows Referent's details.
|
||||
// static void construct(void* storage, Referent* referent);
|
||||
// ubi::Node supports. The specialization must be the concrete subclass of
|
||||
// Base that represents a pointer to the referent type. It must also
|
||||
// include the members described here.
|
||||
template<typename Referent>
|
||||
class Concrete;
|
||||
struct Concrete {
|
||||
// The specific char16_t array returned by Concrete<T>::typeName.
|
||||
static const char16_t concreteTypeName[];
|
||||
|
||||
// Construct an instance of this concrete class in |storage| referring
|
||||
// to |referent|. Implementations typically use a placement 'new'.
|
||||
//
|
||||
// In some cases, |referent| will contain dynamic type information that
|
||||
// identifies it a some more specific subclass of |Referent|. For example,
|
||||
// when |Referent| is |JSObject|, then |referent->getClass()| could tell us
|
||||
// that it's actually a JSFunction. Similarly, if |Referent| is
|
||||
// |nsISupports|, we would like a ubi::Node that knows its final
|
||||
// implementation type.
|
||||
//
|
||||
// So, we delegate the actual construction to this specialization, which
|
||||
// knows Referent's details.
|
||||
static void construct(void* storage, Referent* referent);
|
||||
};
|
||||
|
||||
// A container for a Base instance; all members simply forward to the contained
|
||||
// instance. This container allows us to pass ubi::Node instances by value.
|
||||
@ -994,24 +994,24 @@ class MOZ_STACK_CLASS RootList {
|
||||
/*** Concrete classes for ubi::Node referent types ************************************************/
|
||||
|
||||
template<>
|
||||
class Concrete<RootList> : public Base {
|
||||
struct Concrete<RootList> : public Base {
|
||||
js::UniquePtr<EdgeRange> edges(JSRuntime* rt, bool wantNames) const override;
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
|
||||
protected:
|
||||
explicit Concrete(RootList* ptr) : Base(ptr) { }
|
||||
RootList& get() const { return *static_cast<RootList*>(ptr); }
|
||||
|
||||
public:
|
||||
static void construct(void* storage, RootList* ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
js::UniquePtr<EdgeRange> edges(JSRuntime* rt, bool wantNames) const override;
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
static void construct(void* storage, RootList* ptr) { new (storage) Concrete(ptr); }
|
||||
};
|
||||
|
||||
// A reusable ubi::Concrete specialization base class for types supported by
|
||||
// JS::TraceChildren.
|
||||
template<typename Referent>
|
||||
class TracerConcrete : public Base {
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
js::UniquePtr<EdgeRange> edges(JSRuntime* rt, bool wantNames) const override;
|
||||
JS::Zone* zone() const override;
|
||||
|
||||
@ -1020,6 +1020,7 @@ class TracerConcrete : public Base {
|
||||
Referent& get() const { return *static_cast<Referent*>(ptr); }
|
||||
|
||||
public:
|
||||
static const char16_t concreteTypeName[];
|
||||
static void construct(void* storage, Referent* ptr) { new (storage) TracerConcrete(ptr); }
|
||||
};
|
||||
|
||||
@ -1041,7 +1042,9 @@ class TracerConcreteWithCompartment : public TracerConcrete<Referent> {
|
||||
// Define specializations for some commonly-used public JSAPI types.
|
||||
// These can use the generic templates above.
|
||||
template<>
|
||||
class Concrete<JS::Symbol> : TracerConcrete<JS::Symbol> {
|
||||
struct Concrete<JS::Symbol> : TracerConcrete<JS::Symbol> {
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
protected:
|
||||
explicit Concrete(JS::Symbol* ptr) : TracerConcrete(ptr) { }
|
||||
|
||||
@ -1049,40 +1052,23 @@ class Concrete<JS::Symbol> : TracerConcrete<JS::Symbol> {
|
||||
static void construct(void* storage, JS::Symbol* ptr) {
|
||||
new (storage) Concrete(ptr);
|
||||
}
|
||||
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
template<>
|
||||
class Concrete<JSScript> : TracerConcreteWithCompartment<JSScript> {
|
||||
template<> struct Concrete<JSScript> : TracerConcreteWithCompartment<JSScript> {
|
||||
CoarseType coarseType() const final { return CoarseType::Script; }
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
const char* scriptFilename() const final;
|
||||
|
||||
protected:
|
||||
explicit Concrete(JSScript *ptr) : TracerConcreteWithCompartment<JSScript>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, JSScript *ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
CoarseType coarseType() const final { return CoarseType::Script; }
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
const char* scriptFilename() const final;
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
// The JSObject specialization.
|
||||
template<>
|
||||
class Concrete<JSObject> : public TracerConcreteWithCompartment<JSObject> {
|
||||
protected:
|
||||
explicit Concrete(JSObject* ptr) : TracerConcreteWithCompartment(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void* storage, JSObject* ptr) {
|
||||
new (storage) Concrete(ptr);
|
||||
}
|
||||
|
||||
const char* jsObjectClassName() const override;
|
||||
MOZ_MUST_USE bool jsObjectConstructorName(JSContext* cx, UniqueTwoByteChars& outName)
|
||||
const override;
|
||||
@ -1093,25 +1079,26 @@ class Concrete<JSObject> : public TracerConcreteWithCompartment<JSObject> {
|
||||
|
||||
CoarseType coarseType() const final { return CoarseType::Object; }
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
protected:
|
||||
explicit Concrete(JSObject* ptr) : TracerConcreteWithCompartment(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void* storage, JSObject* ptr) {
|
||||
new (storage) Concrete(ptr);
|
||||
}
|
||||
};
|
||||
|
||||
// For JSString, we extend the generic template with a 'size' implementation.
|
||||
template<>
|
||||
class Concrete<JSString> : TracerConcrete<JSString> {
|
||||
template<> struct Concrete<JSString> : TracerConcrete<JSString> {
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
CoarseType coarseType() const final { return CoarseType::String; }
|
||||
|
||||
protected:
|
||||
explicit Concrete(JSString *ptr) : TracerConcrete<JSString>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, JSString *ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
CoarseType coarseType() const final { return CoarseType::String; }
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
// The ubi::Node null pointer. Any attempt to operate on a null ubi::Node asserts.
|
||||
@ -1128,6 +1115,7 @@ class Concrete<void> : public Base {
|
||||
|
||||
public:
|
||||
static void construct(void* storage, void* ptr) { new (storage) Concrete(ptr); }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
|
||||
|
@ -788,13 +788,7 @@ IsMarked(const jit::VMFunction*)
|
||||
namespace JS {
|
||||
namespace ubi {
|
||||
template<>
|
||||
class Concrete<js::jit::JitCode> : TracerConcrete<js::jit::JitCode> {
|
||||
protected:
|
||||
explicit Concrete(js::jit::JitCode *ptr) : TracerConcrete<js::jit::JitCode>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, js::jit::JitCode *ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
struct Concrete<js::jit::JitCode> : TracerConcrete<js::jit::JitCode> {
|
||||
CoarseType coarseType() const final { return CoarseType::Script; }
|
||||
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override {
|
||||
@ -804,8 +798,11 @@ class Concrete<js::jit::JitCode> : TracerConcrete<js::jit::JitCode> {
|
||||
return size;
|
||||
}
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
protected:
|
||||
explicit Concrete(js::jit::JitCode *ptr) : TracerConcrete<js::jit::JitCode>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, js::jit::JitCode *ptr) { new (storage) Concrete(ptr); }
|
||||
};
|
||||
|
||||
} // namespace ubi
|
||||
|
@ -41,14 +41,10 @@ namespace JS {
|
||||
namespace ubi {
|
||||
|
||||
template<>
|
||||
class Concrete<FakeNode> : public Base
|
||||
struct Concrete<FakeNode> : public Base
|
||||
{
|
||||
protected:
|
||||
explicit Concrete(FakeNode* ptr) : Base(ptr) { }
|
||||
FakeNode& get() const { return *static_cast<FakeNode*>(ptr); }
|
||||
|
||||
public:
|
||||
static void construct(void* storage, FakeNode* ptr) { new (storage) Concrete(ptr); }
|
||||
static const char16_t concreteTypeName[];
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
|
||||
UniquePtr<EdgeRange> edges(JSRuntime* rt, bool wantNames) const override {
|
||||
return UniquePtr<EdgeRange>(js_new<PreComputedEdgeRange>(get().edges));
|
||||
@ -58,8 +54,11 @@ class Concrete<FakeNode> : public Base
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const char16_t concreteTypeName[];
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static void construct(void* storage, FakeNode* ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
protected:
|
||||
explicit Concrete(FakeNode* ptr) : Base(ptr) { }
|
||||
FakeNode& get() const { return *static_cast<FakeNode*>(ptr); }
|
||||
};
|
||||
|
||||
const char16_t Concrete<FakeNode>::concreteTypeName[] = MOZ_UTF16("FakeNode");
|
||||
|
@ -3831,7 +3831,8 @@ JS::ubi::Concrete<JSObject>::size(mozilla::MallocSizeOf mallocSizeOf) const
|
||||
return obj.tenuredSizeOfThis() + info.sizeOfAllThings();
|
||||
}
|
||||
|
||||
const char16_t JS::ubi::Concrete<JSObject>::concreteTypeName[] = MOZ_UTF16("JSObject");
|
||||
template<> const char16_t JS::ubi::TracerConcrete<JSObject>::concreteTypeName[] =
|
||||
MOZ_UTF16("JSObject");
|
||||
|
||||
void
|
||||
JSObject::traceChildren(JSTracer* trc)
|
||||
|
@ -2552,19 +2552,16 @@ CloneGlobalScript(JSContext* cx, Handle<StaticScope*> enclosingScope, HandleScri
|
||||
namespace JS {
|
||||
namespace ubi {
|
||||
template<>
|
||||
class Concrete<js::LazyScript> : TracerConcrete<js::LazyScript> {
|
||||
struct Concrete<js::LazyScript> : TracerConcrete<js::LazyScript> {
|
||||
CoarseType coarseType() const final { return CoarseType::Script; }
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
const char* scriptFilename() const final;
|
||||
|
||||
protected:
|
||||
explicit Concrete(js::LazyScript *ptr) : TracerConcrete<js::LazyScript>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, js::LazyScript *ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
CoarseType coarseType() const final { return CoarseType::Script; }
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
const char* scriptFilename() const final;
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
} // namespace ubi
|
||||
} // namespace JS
|
||||
|
@ -538,7 +538,7 @@ class Shape : public gc::TenuredCell
|
||||
friend class TenuringTracer;
|
||||
friend struct StackBaseShape;
|
||||
friend struct StackShape;
|
||||
friend class JS::ubi::Concrete<Shape>;
|
||||
friend struct JS::ubi::Concrete<Shape>;
|
||||
friend class js::gc::RelocationOverlay;
|
||||
|
||||
protected:
|
||||
@ -1459,32 +1459,24 @@ ReshapeForAllocKind(JSContext* cx, Shape* shape, TaggedProto proto,
|
||||
namespace JS {
|
||||
namespace ubi {
|
||||
|
||||
template<>
|
||||
class Concrete<js::Shape> : TracerConcreteWithCompartment<js::Shape> {
|
||||
template<> struct Concrete<js::Shape> : TracerConcreteWithCompartment<js::Shape> {
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
protected:
|
||||
explicit Concrete(js::Shape *ptr) : TracerConcreteWithCompartment<js::Shape>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, js::Shape *ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
template<>
|
||||
class Concrete<js::BaseShape> : TracerConcreteWithCompartment<js::BaseShape> {
|
||||
template<> struct Concrete<js::BaseShape> : TracerConcreteWithCompartment<js::BaseShape> {
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
protected:
|
||||
explicit Concrete(js::BaseShape *ptr) : TracerConcreteWithCompartment<js::BaseShape>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, js::BaseShape *ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
} // namespace ubi
|
||||
|
@ -82,7 +82,8 @@ JS::ubi::Concrete<JSString>::size(mozilla::MallocSizeOf mallocSizeOf) const
|
||||
return size;
|
||||
}
|
||||
|
||||
const char16_t JS::ubi::Concrete<JSString>::concreteTypeName[] = MOZ_UTF16("JSString");
|
||||
template<> const char16_t JS::ubi::TracerConcrete<JSString>::concreteTypeName[] =
|
||||
MOZ_UTF16("JSString");
|
||||
|
||||
#ifdef DEBUG
|
||||
|
||||
|
@ -1325,17 +1325,14 @@ namespace JS {
|
||||
namespace ubi {
|
||||
|
||||
template<>
|
||||
class Concrete<js::ObjectGroup> : TracerConcrete<js::ObjectGroup> {
|
||||
struct Concrete<js::ObjectGroup> : TracerConcrete<js::ObjectGroup> {
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
protected:
|
||||
explicit Concrete(js::ObjectGroup *ptr) : TracerConcrete<js::ObjectGroup>(ptr) { }
|
||||
|
||||
public:
|
||||
static void construct(void *storage, js::ObjectGroup *ptr) { new (storage) Concrete(ptr); }
|
||||
|
||||
Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
|
||||
|
||||
const char16_t* typeName() const override { return concreteTypeName; }
|
||||
static const char16_t concreteTypeName[];
|
||||
};
|
||||
|
||||
} // namespace ubi
|
||||
|
@ -371,15 +371,38 @@ Concrete<JSObject>::jsObjectConstructorName(JSContext* cx, UniqueTwoByteChars& o
|
||||
return true;
|
||||
}
|
||||
|
||||
const char16_t Concrete<JS::Symbol>::concreteTypeName[] = MOZ_UTF16("JS::Symbol");
|
||||
const char16_t Concrete<JSScript>::concreteTypeName[] = MOZ_UTF16("JSScript");
|
||||
const char16_t Concrete<js::LazyScript>::concreteTypeName[] = MOZ_UTF16("js::LazyScript");
|
||||
const char16_t Concrete<js::jit::JitCode>::concreteTypeName[] = MOZ_UTF16("js::jit::JitCode");
|
||||
const char16_t Concrete<js::Shape>::concreteTypeName[] = MOZ_UTF16("js::Shape");
|
||||
const char16_t Concrete<js::BaseShape>::concreteTypeName[] = MOZ_UTF16("js::BaseShape");
|
||||
const char16_t Concrete<js::ObjectGroup>::concreteTypeName[] = MOZ_UTF16("js::ObjectGroup");
|
||||
template<> const char16_t TracerConcrete<JS::Symbol>::concreteTypeName[] =
|
||||
MOZ_UTF16("JS::Symbol");
|
||||
template<> const char16_t TracerConcrete<JSScript>::concreteTypeName[] =
|
||||
MOZ_UTF16("JSScript");
|
||||
template<> const char16_t TracerConcrete<js::LazyScript>::concreteTypeName[] =
|
||||
MOZ_UTF16("js::LazyScript");
|
||||
template<> const char16_t TracerConcrete<js::jit::JitCode>::concreteTypeName[] =
|
||||
MOZ_UTF16("js::jit::JitCode");
|
||||
template<> const char16_t TracerConcrete<js::Shape>::concreteTypeName[] =
|
||||
MOZ_UTF16("js::Shape");
|
||||
template<> const char16_t TracerConcrete<js::BaseShape>::concreteTypeName[] =
|
||||
MOZ_UTF16("js::BaseShape");
|
||||
template<> const char16_t TracerConcrete<js::ObjectGroup>::concreteTypeName[] =
|
||||
MOZ_UTF16("js::ObjectGroup");
|
||||
|
||||
|
||||
// Instantiate all the TracerConcrete and templates here, where
|
||||
// we have the member functions' definitions in scope.
|
||||
namespace JS {
|
||||
namespace ubi {
|
||||
template class TracerConcreteWithCompartment<JSObject>;
|
||||
template class TracerConcrete<JSString>;
|
||||
template class TracerConcrete<JS::Symbol>;
|
||||
template class TracerConcreteWithCompartment<JSScript>;
|
||||
template class TracerConcrete<js::LazyScript>;
|
||||
template class TracerConcrete<js::jit::JitCode>;
|
||||
template class TracerConcreteWithCompartment<js::Shape>;
|
||||
template class TracerConcreteWithCompartment<js::BaseShape>;
|
||||
template class TracerConcrete<js::ObjectGroup>;
|
||||
} // namespace ubi
|
||||
} // namespace JS
|
||||
|
||||
namespace JS {
|
||||
namespace ubi {
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user