mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1273908 - Refactor GC to make it easier to add new kinds of GC thing r=terrence

This commit is contained in:
Jon Coppeard 2016-05-19 10:12:54 +01:00
Родитель e5d11edbeb
Коммит 3d8e7a7e44
11 изменённых файлов: 123 добавлений и 292 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

13
js/public/TraceKind.h
Просмотреть файл

@ -98,15 +98,10 @@ JS_FOR_EACH_TRACEKIND(JS_EXPAND_DEF);
enum class RootKind : int8_t
{
// These map 1:1 with trace kinds.
BaseShape = 0,
JitCode,
LazyScript,
Object,
ObjectGroup,
Script,
Shape,
String,
Symbol,
#define EXPAND_ROOT_KIND(name, _0, _1) \
name,
JS_FOR_EACH_TRACEKIND(EXPAND_ROOT_KIND)
#undef EXPAND_ROOT_KIND
// These tagged pointers are special-cased for performance.
Id,

17
js/src/gc/Allocator.cpp
Просмотреть файл

@ -217,23 +217,10 @@ js::Allocate(ExclusiveContext* cx)
return GCRuntime::tryNewTenuredThing<T, allowGC>(cx, kind, thingSize);
}
#define FOR_ALL_NON_OBJECT_GC_LAYOUTS(macro) \
macro(JS::Symbol) \
macro(JSExternalString) \
macro(JSFatInlineString) \
macro(JSScript) \
macro(JSString) \
macro(js::AccessorShape) \
macro(js::BaseShape) \
macro(js::LazyScript) \
macro(js::ObjectGroup) \
macro(js::Shape) \
macro(js::jit::JitCode)
#define DECL_ALLOCATOR_INSTANCES(type) \
#define DECL_ALLOCATOR_INSTANCES(allocKind, traceKind, type, sizedType) \
template type* js::Allocate<type, NoGC>(ExclusiveContext* cx);\
template type* js::Allocate<type, CanGC>(ExclusiveContext* cx);
FOR_ALL_NON_OBJECT_GC_LAYOUTS(DECL_ALLOCATOR_INSTANCES)
FOR_EACH_NONOBJECT_ALLOCKIND(DECL_ALLOCATOR_INSTANCES)
#undef DECL_ALLOCATOR_INSTANCES
template <typename T, AllowGC allowGC>

116
js/src/gc/Heap.h
Просмотреть файл

@ -114,39 +114,60 @@ enum class AllocKind {
LAST = LIMIT - 1
};
// Macro to enumerate the different allocation kinds supplying information about
// the trace kind, C++ type and allocation size.
#define FOR_EACH_OBJECT_ALLOCKIND(D) \
/* AllocKind TraceKind TypeName SizedType */ \
D(FUNCTION, Object, JSObject, JSFunction) \
D(FUNCTION_EXTENDED, Object, JSObject, FunctionExtended) \
D(OBJECT0, Object, JSObject, JSObject_Slots0) \
D(OBJECT0_BACKGROUND, Object, JSObject, JSObject_Slots0) \
D(OBJECT2, Object, JSObject, JSObject_Slots2) \
D(OBJECT2_BACKGROUND, Object, JSObject, JSObject_Slots2) \
D(OBJECT4, Object, JSObject, JSObject_Slots4) \
D(OBJECT4_BACKGROUND, Object, JSObject, JSObject_Slots4) \
D(OBJECT8, Object, JSObject, JSObject_Slots8) \
D(OBJECT8_BACKGROUND, Object, JSObject, JSObject_Slots8) \
D(OBJECT12, Object, JSObject, JSObject_Slots12) \
D(OBJECT12_BACKGROUND, Object, JSObject, JSObject_Slots12) \
D(OBJECT16, Object, JSObject, JSObject_Slots16) \
D(OBJECT16_BACKGROUND, Object, JSObject, JSObject_Slots16)
#define FOR_EACH_NONOBJECT_ALLOCKIND(D) \
/* AllocKind TraceKind TypeName SizedType */ \
D(SCRIPT, Script, JSScript, JSScript) \
D(LAZY_SCRIPT, LazyScript, js::LazyScript, js::LazyScript) \
D(SHAPE, Shape, js::Shape, js::Shape) \
D(ACCESSOR_SHAPE, Shape, js::AccessorShape, js::AccessorShape) \
D(BASE_SHAPE, BaseShape, js::BaseShape, js::BaseShape) \
D(OBJECT_GROUP, ObjectGroup, js::ObjectGroup, js::ObjectGroup) \
D(FAT_INLINE_STRING, String, JSFatInlineString, JSFatInlineString) \
D(STRING, String, JSString, JSString) \
D(EXTERNAL_STRING, String, JSExternalString, JSExternalString) \
D(SYMBOL, Symbol, JS::Symbol, JS::Symbol) \
D(JITCODE, JitCode, js::jit::JitCode, js::jit::JitCode)
#define FOR_EACH_ALLOCKIND(D) \
/* PrettyName TypeName */ \
D(FUNCTION, JSFunction) \
D(FUNCTION_EXTENDED, JSFunction) \
D(OBJECT0, JSObject) \
D(OBJECT0_BACKGROUND, JSObject) \
D(OBJECT2, JSObject) \
D(OBJECT2_BACKGROUND, JSObject) \
D(OBJECT4, JSObject) \
D(OBJECT4_BACKGROUND, JSObject) \
D(OBJECT8, JSObject) \
D(OBJECT8_BACKGROUND, JSObject) \
D(OBJECT12, JSObject) \
D(OBJECT12_BACKGROUND, JSObject) \
D(OBJECT16, JSObject) \
D(OBJECT16_BACKGROUND, JSObject) \
D(SCRIPT, JSScript) \
D(LAZY_SCRIPT, js::LazyScript) \
D(SHAPE, js::Shape) \
D(ACCESSOR_SHAPE, js::AccessorShape) \
D(BASE_SHAPE, js::BaseShape) \
D(OBJECT_GROUP, js::ObjectGroup) \
D(FAT_INLINE_STRING, JSFatInlineString) \
D(STRING, JSString) \
D(EXTERNAL_STRING, JSExternalString) \
D(SYMBOL, JS::Symbol) \
D(JITCODE, js::JitCode)
FOR_EACH_OBJECT_ALLOCKIND(D) \
FOR_EACH_NONOBJECT_ALLOCKIND(D)
static_assert(int(AllocKind::FIRST) == 0, "Various places depend on AllocKind starting at 0, "
"please audit them carefully!");
static_assert(int(AllocKind::OBJECT_FIRST) == 0, "Various places depend on AllocKind::OBJECT_FIRST "
"being 0, please audit them carefully!");
inline bool
IsAllocKind(AllocKind kind)
{
return kind >= AllocKind::FIRST && kind <= AllocKind::LIMIT;
}
inline bool
IsValidAllocKind(AllocKind kind)
{
return kind >= AllocKind::FIRST && kind <= AllocKind::LAST;
}
inline bool
IsObjectAllocKind(AllocKind kind)
{
@ -159,17 +180,6 @@ IsShapeAllocKind(AllocKind kind)
return kind == AllocKind::SHAPE || kind == AllocKind::ACCESSOR_SHAPE;
}
inline bool
IsValidAllocKind(AllocKind kind)
{
return kind >= AllocKind::FIRST && kind <= AllocKind::LAST;
}
inline bool IsAllocKind(AllocKind kind)
{
return kind >= AllocKind::FIRST && kind <= AllocKind::LIMIT;
}
// Returns a sequence for use in a range-based for loop,
// to iterate over all alloc kinds.
inline decltype(mozilla::MakeEnumeratedRange<int>(AllocKind::FIRST, AllocKind::LIMIT))
@ -210,31 +220,10 @@ static inline JS::TraceKind
MapAllocToTraceKind(AllocKind kind)
{
static const JS::TraceKind map[] = {
JS::TraceKind::Object, /* AllocKind::FUNCTION */
JS::TraceKind::Object, /* AllocKind::FUNCTION_EXTENDED */
JS::TraceKind::Object, /* AllocKind::OBJECT0 */
JS::TraceKind::Object, /* AllocKind::OBJECT0_BACKGROUND */
JS::TraceKind::Object, /* AllocKind::OBJECT2 */
JS::TraceKind::Object, /* AllocKind::OBJECT2_BACKGROUND */
JS::TraceKind::Object, /* AllocKind::OBJECT4 */
JS::TraceKind::Object, /* AllocKind::OBJECT4_BACKGROUND */
JS::TraceKind::Object, /* AllocKind::OBJECT8 */
JS::TraceKind::Object, /* AllocKind::OBJECT8_BACKGROUND */
JS::TraceKind::Object, /* AllocKind::OBJECT12 */
JS::TraceKind::Object, /* AllocKind::OBJECT12_BACKGROUND */
JS::TraceKind::Object, /* AllocKind::OBJECT16 */
JS::TraceKind::Object, /* AllocKind::OBJECT16_BACKGROUND */
JS::TraceKind::Script, /* AllocKind::SCRIPT */
JS::TraceKind::LazyScript, /* AllocKind::LAZY_SCRIPT */
JS::TraceKind::Shape, /* AllocKind::SHAPE */
JS::TraceKind::Shape, /* AllocKind::ACCESSOR_SHAPE */
JS::TraceKind::BaseShape, /* AllocKind::BASE_SHAPE */
JS::TraceKind::ObjectGroup, /* AllocKind::OBJECT_GROUP */
JS::TraceKind::String, /* AllocKind::FAT_INLINE_STRING */
JS::TraceKind::String, /* AllocKind::STRING */
JS::TraceKind::String, /* AllocKind::EXTERNAL_STRING */
JS::TraceKind::Symbol, /* AllocKind::SYMBOL */
JS::TraceKind::JitCode, /* AllocKind::JITCODE */
#define EXPAND_ELEMENT(allocKind, traceKind, type, sizedType) \
JS::TraceKind::traceKind,
FOR_EACH_ALLOCKIND(EXPAND_ELEMENT)
#undef EXPAND_ELEMENT
};
static_assert(MOZ_ARRAY_LENGTH(map) == size_t(AllocKind::LIMIT),
@ -326,6 +315,9 @@ class TenuredCell : public Cell
static MOZ_ALWAYS_INLINE void writeBarrierPost(void* cellp, TenuredCell* prior,
TenuredCell* next);
// Default implementation for kinds that don't require fixup.
void fixupAfterMovingGC() {}
#ifdef DEBUG
inline bool isAligned() const;
#endif

20
js/src/gc/Marking.cpp
Просмотреть файл

@ -350,6 +350,9 @@ AssertRootMarkingPhase(JSTracer* trc)
// statically select the correct Cell layout for marking. Below, we instantiate
// each override with a declaration of the most derived layout type.
//
// The use of TraceKind::Null for the case where the type is not matched
// generates a compile error as no template instantiated for that kind.
//
// Usage:
// BaseGCType<T>::type
//
@ -357,16 +360,13 @@ AssertRootMarkingPhase(JSTracer* trc)
// BaseGCType<JSFunction>::type => JSObject
// BaseGCType<UnownedBaseShape>::type => BaseShape
// etc.
template <typename T,
JS::TraceKind = IsBaseOf<JSObject, T>::value ? JS::TraceKind::Object
: IsBaseOf<JSString, T>::value ? JS::TraceKind::String
: IsBaseOf<JS::Symbol, T>::value ? JS::TraceKind::Symbol
: IsBaseOf<JSScript, T>::value ? JS::TraceKind::Script
: IsBaseOf<Shape, T>::value ? JS::TraceKind::Shape
: IsBaseOf<BaseShape, T>::value ? JS::TraceKind::BaseShape
: IsBaseOf<jit::JitCode, T>::value ? JS::TraceKind::JitCode
: IsBaseOf<LazyScript, T>::value ? JS::TraceKind::LazyScript
: JS::TraceKind::ObjectGroup>
template <typename T, JS::TraceKind =
#define EXPAND_MATCH_TYPE(name, type, _) \
IsBaseOf<type, T>::value ? JS::TraceKind::name :
JS_FOR_EACH_TRACEKIND(EXPAND_MATCH_TYPE)
#undef EXPAND_MATCH_TYPE
JS::TraceKind::Null>
struct BaseGCType;
#define IMPL_BASE_GC_TYPE(name, type_, _) \
template <typename T> struct BaseGCType<T, JS::TraceKind:: name> { typedef type_ type; };

1
js/src/jit/IonCode.h
Просмотреть файл

@ -114,7 +114,6 @@ class JitCode : public gc::TenuredCell
void traceChildren(JSTracer* trc);
void finalize(FreeOp* fop);
void fixupAfterMovingGC() {}
void setInvalidated() {
invalidated_ = true;
}

217
js/src/jsgc.cpp
Просмотреть файл

@ -261,52 +261,22 @@ const AllocKind gc::slotsToThingKind[] = {
static_assert(JS_ARRAY_LENGTH(slotsToThingKind) == SLOTS_TO_THING_KIND_LIMIT,
"We have defined a slot count for each kind.");
// Assert that SortedArenaList::MinThingSize and sizeof(FreeSpan) are <= the
// real minimum thing size. Also assert each size is a multiple of CellSize.
#define CHECK_THING_SIZE_INNER(x_) \
static_assert(x_ >= SortedArenaList::MinThingSize, \
#x_ " is less than SortedArenaList::MinThingSize!"); \
static_assert(x_ >= sizeof(FreeSpan), \
#x_ " is less than sizeof(FreeSpan)"); \
static_assert(x_ % CellSize == 0, \
#x_ " not a multiple of CellSize");
#define CHECK_THING_SIZE(allocKind, traceKind, type, sizedType) \
static_assert(sizeof(sizedType) >= SortedArenaList::MinThingSize, \
#sizedType " is smaller than SortedArenaList::MinThingSize!"); \
static_assert(sizeof(sizedType) >= sizeof(FreeSpan), \
#sizedType " is smaller than FreeSpan"); \
static_assert(sizeof(sizedType) % CellSize == 0, \
"Size of " #sizedType " is not a multiple of CellSize");
FOR_EACH_ALLOCKIND(CHECK_THING_SIZE);
#undef CHECK_THING_SIZE
#define CHECK_THING_SIZE(...) { __VA_ARGS__ }; /* Define the array. */ \
MOZ_FOR_EACH(CHECK_THING_SIZE_INNER, (), (__VA_ARGS__ 0x20))
#define CHECK_ZEAL(name, value) \
static_assert(ZealMode::Limit >= ZealMode::name, \
"ZealMode::Limit shouldn't be smaller than " #name);
JS_FOR_EACH_ZEAL_MODE(CHECK_ZEAL)
#undef CHECK_ZEAL
const uint32_t Arena::ThingSizes[] = CHECK_THING_SIZE(
sizeof(JSFunction), /* AllocKind::FUNCTION */
sizeof(FunctionExtended), /* AllocKind::FUNCTION_EXTENDED */
sizeof(JSObject_Slots0), /* AllocKind::OBJECT0 */
sizeof(JSObject_Slots0), /* AllocKind::OBJECT0_BACKGROUND */
sizeof(JSObject_Slots2), /* AllocKind::OBJECT2 */
sizeof(JSObject_Slots2), /* AllocKind::OBJECT2_BACKGROUND */
sizeof(JSObject_Slots4), /* AllocKind::OBJECT4 */
sizeof(JSObject_Slots4), /* AllocKind::OBJECT4_BACKGROUND */
sizeof(JSObject_Slots8), /* AllocKind::OBJECT8 */
sizeof(JSObject_Slots8), /* AllocKind::OBJECT8_BACKGROUND */
sizeof(JSObject_Slots12), /* AllocKind::OBJECT12 */
sizeof(JSObject_Slots12), /* AllocKind::OBJECT12_BACKGROUND */
sizeof(JSObject_Slots16), /* AllocKind::OBJECT16 */
sizeof(JSObject_Slots16), /* AllocKind::OBJECT16_BACKGROUND */
sizeof(JSScript), /* AllocKind::SCRIPT */
sizeof(LazyScript), /* AllocKind::LAZY_SCRIPT */
sizeof(Shape), /* AllocKind::SHAPE */
sizeof(AccessorShape), /* AllocKind::ACCESSOR_SHAPE */
sizeof(BaseShape), /* AllocKind::BASE_SHAPE */
sizeof(ObjectGroup), /* AllocKind::OBJECT_GROUP */
sizeof(JSFatInlineString), /* AllocKind::FAT_INLINE_STRING */
sizeof(JSString), /* AllocKind::STRING */
sizeof(JSExternalString), /* AllocKind::EXTERNAL_STRING */
sizeof(JS::Symbol), /* AllocKind::SYMBOL */
sizeof(jit::JitCode), /* AllocKind::JITCODE */
);
const uint32_t Arena::ThingSizes[] = {
#define EXPAND_THING_SIZE(allocKind, traceKind, type, sizedType) \
sizeof(sizedType),
FOR_EACH_ALLOCKIND(EXPAND_THING_SIZE)
#undef EXPAND_THING_SIZE
};
FreeSpan ArenaLists::placeholder;
@ -316,31 +286,10 @@ FreeSpan ArenaLists::placeholder;
#define OFFSET(type) uint32_t(ArenaHeaderSize + (ArenaSize - ArenaHeaderSize) % sizeof(type))
const uint32_t Arena::FirstThingOffsets[] = {
OFFSET(JSFunction), /* AllocKind::FUNCTION */
OFFSET(FunctionExtended), /* AllocKind::FUNCTION_EXTENDED */
OFFSET(JSObject_Slots0), /* AllocKind::OBJECT0 */
OFFSET(JSObject_Slots0), /* AllocKind::OBJECT0_BACKGROUND */
OFFSET(JSObject_Slots2), /* AllocKind::OBJECT2 */
OFFSET(JSObject_Slots2), /* AllocKind::OBJECT2_BACKGROUND */
OFFSET(JSObject_Slots4), /* AllocKind::OBJECT4 */
OFFSET(JSObject_Slots4), /* AllocKind::OBJECT4_BACKGROUND */
OFFSET(JSObject_Slots8), /* AllocKind::OBJECT8 */
OFFSET(JSObject_Slots8), /* AllocKind::OBJECT8_BACKGROUND */
OFFSET(JSObject_Slots12), /* AllocKind::OBJECT12 */
OFFSET(JSObject_Slots12), /* AllocKind::OBJECT12_BACKGROUND */
OFFSET(JSObject_Slots16), /* AllocKind::OBJECT16 */
OFFSET(JSObject_Slots16), /* AllocKind::OBJECT16_BACKGROUND */
OFFSET(JSScript), /* AllocKind::SCRIPT */
OFFSET(LazyScript), /* AllocKind::LAZY_SCRIPT */
OFFSET(Shape), /* AllocKind::SHAPE */
OFFSET(AccessorShape), /* AllocKind::ACCESSOR_SHAPE */
OFFSET(BaseShape), /* AllocKind::BASE_SHAPE */
OFFSET(ObjectGroup), /* AllocKind::OBJECT_GROUP */
OFFSET(JSFatInlineString), /* AllocKind::FAT_INLINE_STRING */
OFFSET(JSString), /* AllocKind::STRING */
OFFSET(JSExternalString), /* AllocKind::EXTERNAL_STRING */
OFFSET(JS::Symbol), /* AllocKind::SYMBOL */
OFFSET(jit::JitCode), /* AllocKind::JITCODE */
#define EXPAND_FIRST_THING_OFFSET(allocKind, traceKind, type, sizedType) \
OFFSET(sizedType),
FOR_EACH_ALLOCKIND(EXPAND_FIRST_THING_OFFSET)
#undef EXPAND_FIRST_THING_OFFSET
};
#undef OFFSET
@ -348,31 +297,10 @@ const uint32_t Arena::FirstThingOffsets[] = {
#define COUNT(type) uint32_t((ArenaSize - ArenaHeaderSize) / sizeof(type))
const uint32_t Arena::ThingsPerArena[] = {
COUNT(JSFunction), /* AllocKind::FUNCTION */
COUNT(FunctionExtended), /* AllocKind::FUNCTION_EXTENDED */
COUNT(JSObject_Slots0), /* AllocKind::OBJECT0 */
COUNT(JSObject_Slots0), /* AllocKind::OBJECT0_BACKGROUND */
COUNT(JSObject_Slots2), /* AllocKind::OBJECT2 */
COUNT(JSObject_Slots2), /* AllocKind::OBJECT2_BACKGROUND */
COUNT(JSObject_Slots4), /* AllocKind::OBJECT4 */
COUNT(JSObject_Slots4), /* AllocKind::OBJECT4_BACKGROUND */
COUNT(JSObject_Slots8), /* AllocKind::OBJECT8 */
COUNT(JSObject_Slots8), /* AllocKind::OBJECT8_BACKGROUND */
COUNT(JSObject_Slots12), /* AllocKind::OBJECT12 */
COUNT(JSObject_Slots12), /* AllocKind::OBJECT12_BACKGROUND */
COUNT(JSObject_Slots16), /* AllocKind::OBJECT16 */
COUNT(JSObject_Slots16), /* AllocKind::OBJECT16_BACKGROUND */
COUNT(JSScript), /* AllocKind::SCRIPT */
COUNT(LazyScript), /* AllocKind::LAZY_SCRIPT */
COUNT(Shape), /* AllocKind::SHAPE */
COUNT(AccessorShape), /* AllocKind::ACCESSOR_SHAPE */
COUNT(BaseShape), /* AllocKind::BASE_SHAPE */
COUNT(ObjectGroup), /* AllocKind::OBJECT_GROUP */
COUNT(JSFatInlineString), /* AllocKind::FAT_INLINE_STRING */
COUNT(JSString), /* AllocKind::STRING */
COUNT(JSExternalString), /* AllocKind::EXTERNAL_STRING */
COUNT(JS::Symbol), /* AllocKind::SYMBOL */
COUNT(jit::JitCode), /* AllocKind::JITCODE */
#define EXPAND_THINGS_PER_ARENA(allocKind, traceKind, type, sizedType) \
COUNT(sizedType),
FOR_EACH_ALLOCKIND(EXPAND_THINGS_PER_ARENA)
#undef EXPAND_THINGS_PER_ARENA
};
#undef COUNT
@ -604,43 +532,12 @@ FinalizeArenas(FreeOp* fop,
ArenaLists::KeepArenasEnum keepArenas)
{
switch (thingKind) {
case AllocKind::FUNCTION:
case AllocKind::FUNCTION_EXTENDED:
case AllocKind::OBJECT0:
case AllocKind::OBJECT0_BACKGROUND:
case AllocKind::OBJECT2:
case AllocKind::OBJECT2_BACKGROUND:
case AllocKind::OBJECT4:
case AllocKind::OBJECT4_BACKGROUND:
case AllocKind::OBJECT8:
case AllocKind::OBJECT8_BACKGROUND:
case AllocKind::OBJECT12:
case AllocKind::OBJECT12_BACKGROUND:
case AllocKind::OBJECT16:
case AllocKind::OBJECT16_BACKGROUND:
return FinalizeTypedArenas<JSObject>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::SCRIPT:
return FinalizeTypedArenas<JSScript>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::LAZY_SCRIPT:
return FinalizeTypedArenas<LazyScript>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::SHAPE:
return FinalizeTypedArenas<Shape>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::ACCESSOR_SHAPE:
return FinalizeTypedArenas<AccessorShape>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::BASE_SHAPE:
return FinalizeTypedArenas<BaseShape>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::OBJECT_GROUP:
return FinalizeTypedArenas<ObjectGroup>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::STRING:
return FinalizeTypedArenas<JSString>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::FAT_INLINE_STRING:
return FinalizeTypedArenas<JSFatInlineString>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::EXTERNAL_STRING:
return FinalizeTypedArenas<JSExternalString>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::SYMBOL:
return FinalizeTypedArenas<JS::Symbol>(fop, src, dest, thingKind, budget, keepArenas);
case AllocKind::JITCODE:
return FinalizeTypedArenas<jit::JitCode>(fop, src, dest, thingKind, budget, keepArenas);
#define EXPAND_CASE(allocKind, traceKind, type, sizedType) \
case AllocKind::allocKind: \
return FinalizeTypedArenas<type>(fop, src, dest, thingKind, budget, keepArenas);
FOR_EACH_ALLOCKIND(EXPAND_CASE)
#undef EXPAND_CASE
default:
MOZ_CRASH("Invalid alloc kind");
}
@ -2543,49 +2440,15 @@ static void
UpdateArenaPointers(MovingTracer* trc, Arena* arena)
{
AllocKind kind = arena->getAllocKind();
JS::TraceKind traceKind = MapAllocToTraceKind(kind);
switch (kind) {
case AllocKind::FUNCTION:
case AllocKind::FUNCTION_EXTENDED:
case AllocKind::OBJECT0:
case AllocKind::OBJECT0_BACKGROUND:
case AllocKind::OBJECT2:
case AllocKind::OBJECT2_BACKGROUND:
case AllocKind::OBJECT4:
case AllocKind::OBJECT4_BACKGROUND:
case AllocKind::OBJECT8:
case AllocKind::OBJECT8_BACKGROUND:
case AllocKind::OBJECT12:
case AllocKind::OBJECT12_BACKGROUND:
case AllocKind::OBJECT16:
case AllocKind::OBJECT16_BACKGROUND:
UpdateArenaPointersTyped<JSObject>(trc, arena, traceKind);
return;
case AllocKind::SCRIPT:
UpdateArenaPointersTyped<JSScript>(trc, arena, traceKind);
return;
case AllocKind::LAZY_SCRIPT:
UpdateArenaPointersTyped<LazyScript>(trc, arena, traceKind);
return;
case AllocKind::SHAPE:
UpdateArenaPointersTyped<Shape>(trc, arena, traceKind);
return;
case AllocKind::ACCESSOR_SHAPE:
UpdateArenaPointersTyped<AccessorShape>(trc, arena, traceKind);
return;
case AllocKind::BASE_SHAPE:
UpdateArenaPointersTyped<BaseShape>(trc, arena, traceKind);
return;
case AllocKind::OBJECT_GROUP:
UpdateArenaPointersTyped<ObjectGroup>(trc, arena, traceKind);
return;
case AllocKind::STRING:
UpdateArenaPointersTyped<JSString>(trc, arena, traceKind);
return;
case AllocKind::JITCODE:
UpdateArenaPointersTyped<jit::JitCode>(trc, arena, traceKind);
#define EXPAND_CASE(allocKind, traceKind, type, sizedType) \
case AllocKind::allocKind: \
UpdateArenaPointersTyped<type>(trc, arena, JS::TraceKind::traceKind); \
return;
FOR_EACH_ALLOCKIND(EXPAND_CASE)
#undef EXPAND_CASE
default:
MOZ_CRASH("Invalid alloc kind for UpdateArenaPointers");
}
@ -3961,11 +3824,13 @@ static const char*
AllocKindToAscii(AllocKind kind)
{
switch(kind) {
#define MAKE_CASE(name, _) case AllocKind:: name: return #name;
FOR_EACH_ALLOCKIND(MAKE_CASE)
#define MAKE_CASE(allocKind, traceKind, type, sizedType) \
case AllocKind:: allocKind: return #allocKind;
FOR_EACH_ALLOCKIND(MAKE_CASE)
#undef MAKE_CASE
case AllocKind::LIMIT: MOZ_FALLTHROUGH;
default: MOZ_CRASH("Unknown AllocKind in AllocKindToAscii");
default:
MOZ_CRASH("Unknown AllocKind in AllocKindToAscii");
}
}
#endif // DEBUG

24
js/src/jsgc.h
Просмотреть файл

@ -53,19 +53,19 @@ enum State {
NUM_STATES
};
/* Map from C++ type to alloc kind. JSObject does not have a 1:1 mapping, so must use Arena::thingSize. */
/*
* Map from C++ type to alloc kind for non-object types. JSObject does not have
* a 1:1 mapping, so must use Arena::thingSize.
*
* The AllocKind is available as MapTypeToFinalizeKind<SomeType>::kind.
*/
template <typename T> struct MapTypeToFinalizeKind {};
template <> struct MapTypeToFinalizeKind<JSScript> { static const AllocKind kind = AllocKind::SCRIPT; };
template <> struct MapTypeToFinalizeKind<LazyScript> { static const AllocKind kind = AllocKind::LAZY_SCRIPT; };
template <> struct MapTypeToFinalizeKind<Shape> { static const AllocKind kind = AllocKind::SHAPE; };
template <> struct MapTypeToFinalizeKind<AccessorShape> { static const AllocKind kind = AllocKind::ACCESSOR_SHAPE; };
template <> struct MapTypeToFinalizeKind<BaseShape> { static const AllocKind kind = AllocKind::BASE_SHAPE; };
template <> struct MapTypeToFinalizeKind<ObjectGroup> { static const AllocKind kind = AllocKind::OBJECT_GROUP; };
template <> struct MapTypeToFinalizeKind<JSFatInlineString> { static const AllocKind kind = AllocKind::FAT_INLINE_STRING; };
template <> struct MapTypeToFinalizeKind<JSString> { static const AllocKind kind = AllocKind::STRING; };
template <> struct MapTypeToFinalizeKind<JSExternalString> { static const AllocKind kind = AllocKind::EXTERNAL_STRING; };
template <> struct MapTypeToFinalizeKind<JS::Symbol> { static const AllocKind kind = AllocKind::SYMBOL; };
template <> struct MapTypeToFinalizeKind<jit::JitCode> { static const AllocKind kind = AllocKind::JITCODE; };
#define EXPAND_MAPTYPETOFINALIZEKIND(allocKind, traceKind, type, sizedType) \
template <> struct MapTypeToFinalizeKind<type> { \
static const AllocKind kind = AllocKind::allocKind; \
};
FOR_EACH_NONOBJECT_ALLOCKIND(EXPAND_MAPTYPETOFINALIZEKIND)
#undef EXPAND_MAPTYPETOFINALIZEKIND
template <typename T> struct ParticipatesInCC {};
#define EXPAND_PARTICIPATES_IN_CC(_, type, addToCCKind) \

2
js/src/jsscript.h
Просмотреть файл

@ -1942,7 +1942,6 @@ class JSScript : public js::gc::TenuredCell
#endif
void finalize(js::FreeOp* fop);
void fixupAfterMovingGC() {}
static const JS::TraceKind TraceKind = JS::TraceKind::Script;
@ -2397,7 +2396,6 @@ class LazyScript : public gc::TenuredCell
friend class GCMarker;
void traceChildren(JSTracer* trc);
void finalize(js::FreeOp* fop);
void fixupAfterMovingGC() {}
static const JS::TraceKind TraceKind = JS::TraceKind::LazyScript;

1
js/src/vm/ObjectGroup.h
Просмотреть файл

@ -424,7 +424,6 @@ class ObjectGroup : public gc::TenuredCell
size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
void finalize(FreeOp* fop);
void fixupAfterMovingGC() {}
static const JS::TraceKind TraceKind = JS::TraceKind::ObjectGroup;

2
js/src/vm/Shape.h
Просмотреть файл

@ -454,8 +454,6 @@ class BaseShape : public gc::TenuredCell
void traceChildren(JSTracer* trc);
void traceChildrenSkipShapeTable(JSTracer* trc);
void fixupAfterMovingGC() {}
private:
static void staticAsserts() {
JS_STATIC_ASSERT(offsetof(BaseShape, clasp_) == offsetof(js::shadow::BaseShape, clasp_));

2
js/src/vm/String.h
Просмотреть файл

@ -474,8 +474,6 @@ class JSString : public js::gc::TenuredCell
inline void finalize(js::FreeOp* fop);
void fixupAfterMovingGC() {}
/* Gets the number of bytes that the chars take on the heap. */
size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf);