1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* 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 gc_Zone_h
#define gc_Zone_h
#include "mozilla/Array.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/LinkedList.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/PodOperations.h"
#include "mozilla/TimeStamp.h"
#include "jstypes.h"
#include "ds/Bitmap.h"
#include "gc/ArenaList.h"
#include "gc/Barrier.h"
#include "gc/FindSCCs.h"
#include "gc/GCMarker.h"
#include "gc/NurseryAwareHashMap.h"
#include "gc/Pretenuring.h"
#include "gc/Statistics.h"
#include "gc/ZoneAllocator.h"
#include "js/GCHashTable.h"
#include "js/Vector.h"
#include "vm/AtomsTable.h"
#include "vm/InvalidatingFuse.h"
#include "vm/JSObject.h"
#include "vm/JSScript.h"
#include "vm/ShapeZone.h"
namespace js {
class DebugScriptMap;
class RegExpZone;
class WeakRefObject;
namespace jit {
class JitZone;
} // namespace jit
namespace gc {
class FinalizationObservers;
class ZoneList;
using ZoneComponentFinder = ComponentFinder<JS::Zone>;
struct UniqueIdGCPolicy {
static bool traceWeak(JSTracer* trc, Cell** keyp, uint64_t* valuep);
};
// Maps a Cell* to a unique, 64bit id.
using UniqueIdMap = GCHashMap<Cell*, uint64_t, PointerHasher<Cell*>,
SystemAllocPolicy, UniqueIdGCPolicy>;
template <typename T>
class ZoneAllCellIter;
template <typename T>
class ZoneCellIter;
} // namespace gc
// If two different nursery strings are wrapped into the same zone, and have
// the same contents, then deduplication may make them duplicates.
// `DuplicatesPossible` will allow this and map both wrappers to the same (now
// tenured) source string.
using StringWrapperMap =
NurseryAwareHashMap<JSString*, JSString*, ZoneAllocPolicy,
DuplicatesPossible>;
// Cache for NewMaybeExternalString. It has cache entries for both the
// Latin1 JSInlineString path and JSExternalString.
class MOZ_NON_TEMPORARY_CLASS ExternalStringCache {
static const size_t NumEntries = 4;
mozilla::Array<JSExternalString*, NumEntries> externalEntries_;
mozilla::Array<JSInlineString*, NumEntries> inlineEntries_;
public:
ExternalStringCache() { purge(); }
ExternalStringCache(const ExternalStringCache&) = delete;
void operator=(const ExternalStringCache&) = delete;
void purge() {
externalEntries_ = {};
inlineEntries_ = {};
}
MOZ_ALWAYS_INLINE JSExternalString* lookupExternal(
const JS::Latin1Char* chars, size_t len) const;
MOZ_ALWAYS_INLINE JSExternalString* lookupExternal(const char16_t* chars,
size_t len) const;
MOZ_ALWAYS_INLINE void putExternal(JSExternalString* s);
MOZ_ALWAYS_INLINE JSInlineString* lookupInline(const JS::Latin1Char* chars,
size_t len) const;
MOZ_ALWAYS_INLINE JSInlineString* lookupInline(const char16_t* chars,
size_t len) const;
MOZ_ALWAYS_INLINE void putInline(JSInlineString* s);
private:
template <typename CharT>
MOZ_ALWAYS_INLINE JSExternalString* lookupExternalImpl(const CharT* chars,
size_t len) const;
template <typename CharT>
MOZ_ALWAYS_INLINE JSInlineString* lookupInlineImpl(const CharT* chars,
size_t len) const;
};
class MOZ_NON_TEMPORARY_CLASS FunctionToStringCache {
struct Entry {
BaseScript* script;
JSString* string;
void set(BaseScript* scriptArg, JSString* stringArg) {
script = scriptArg;
string = stringArg;
}
};
static const size_t NumEntries = 2;
mozilla::Array<Entry, NumEntries> entries_;
public:
FunctionToStringCache() { purge(); }
FunctionToStringCache(const FunctionToStringCache&) = delete;
void operator=(const FunctionToStringCache&) = delete;
void purge() { mozilla::PodArrayZero(entries_); }
MOZ_ALWAYS_INLINE JSString* lookup(BaseScript* script) const;
MOZ_ALWAYS_INLINE void put(BaseScript* script, JSString* string);
};
} // namespace js
namespace JS {
// [SMDOC] GC Zones
//
// A zone is a collection of compartments. Every compartment belongs to exactly
// one zone. In Firefox, there is roughly one zone per tab along with a system
// zone for everything else. Zones mainly serve as boundaries for garbage
// collection. Unlike compartments, they have no special security properties.
//
// Every GC thing belongs to exactly one zone. GC things from the same zone but
// different compartments can share an arena (4k page). GC things from different
// zones cannot be stored in the same arena. The garbage collector is capable of
// collecting one zone at a time; it cannot collect at the granularity of
// compartments.
//
// GC things are tied to zones and compartments as follows:
//
// - JSObjects belong to a compartment and cannot be shared between
// compartments. If an object needs to point to a JSObject in a different
// compartment, regardless of zone, it must go through a cross-compartment
// wrapper. Each compartment keeps track of its outgoing wrappers in a table.
// JSObjects find their compartment via their ObjectGroup.
//
// - JSStrings do not belong to any particular compartment, but they do belong
// to a zone. Thus, two different compartments in the same zone can point to a
// JSString. When a string needs to be wrapped, we copy it if it's in a
// different zone and do nothing if it's in the same zone. Thus, transferring
// strings within a zone is very efficient.
//
// - Shapes and base shapes belong to a zone and are shared between compartments
// in that zone where possible. Accessor shapes store getter and setter
// JSObjects which belong to a single compartment, so these shapes and all
// their descendants can't be shared with other compartments.
//
// - Scripts are also compartment-local and cannot be shared. A script points to
// its compartment.
//
// - ObjectGroup and JitCode objects belong to a compartment and cannot be
// shared. There is no mechanism to obtain the compartment from a JitCode
// object.
//
// A zone remains alive as long as any GC things in the zone are alive. A
// compartment remains alive as long as any JSObjects, scripts, shapes, or base
// shapes within it are alive.
//
// We always guarantee that a zone has at least one live compartment by refusing
// to delete the last compartment in a live zone.
class Zone : public js::ZoneAllocator, public js::gc::GraphNodeBase<JS::Zone> {
public:
js::gc::ArenaLists arenas;
// Per-zone data for use by an embedder.
js::MainThreadData<void*> data;
// When true, skip calling the metadata callback. We use this:
// - to avoid invoking the callback recursively;
// - to avoid observing lazy prototype setup (which confuses callbacks that
// want to use the types being set up!);
// - to avoid attaching allocation stacks to allocation stack nodes, which
// is silly
// And so on.
js::MainThreadData<bool> suppressAllocationMetadataBuilder;
// Flags permanently set when nursery allocation is disabled for this zone.
js::MainThreadData<bool> nurseryStringsDisabled;
js::MainThreadData<bool> nurseryBigIntsDisabled;
private:
// Flags dynamically updated based on more than one condition, including the
// flags above.
js::MainThreadOrIonCompileData<bool> allocNurseryObjects_;
js::MainThreadOrIonCompileData<bool> allocNurseryStrings_;
js::MainThreadOrIonCompileData<bool> allocNurseryBigInts_;
// Minimum Heap value which results in tenured allocation.
js::MainThreadData<js::gc::Heap> minObjectHeapToTenure_;
js::MainThreadData<js::gc::Heap> minStringHeapToTenure_;
js::MainThreadData<js::gc::Heap> minBigintHeapToTenure_;
public:
// Script side-tables. These used to be held by Realm, but are now placed
// here in order to allow JSScript to access them during finalize (see bug
// 1568245; this change in 1575350). The tables are initialized lazily by
// JSScript.
js::UniquePtr<js::ScriptCountsMap> scriptCountsMap;
js::UniquePtr<js::ScriptLCovMap> scriptLCovMap;
js::MainThreadData<js::DebugScriptMap*> debugScriptMap;
#ifdef MOZ_VTUNE
js::UniquePtr<js::ScriptVTuneIdMap> scriptVTuneIdMap;
#endif
#ifdef JS_CACHEIR_SPEW
js::UniquePtr<js::ScriptFinalWarmUpCountMap> scriptFinalWarmUpCountMap;
#endif
js::MainThreadData<js::StringStats> previousGCStringStats;
js::MainThreadData<js::StringStats> stringStats;
#ifdef DEBUG
js::MainThreadData<unsigned> gcSweepGroupIndex;
#endif
js::gc::PretenuringZone pretenuring;
private:
// Side map for storing unique ids for cells, independent of address.
js::MainThreadOrGCTaskData<js::gc::UniqueIdMap> uniqueIds_;
// Number of allocations since the most recent minor GC for this thread.
uint32_t tenuredAllocsSinceMinorGC_ = 0;
// Live weakmaps in this zone.
js::MainThreadOrGCTaskData<mozilla::LinkedList<js::WeakMapBase>>
gcWeakMapList_;
// The set of compartments in this zone.
using CompartmentVector =
js::Vector<JS::Compartment*, 1, js::SystemAllocPolicy>;
js::MainThreadOrGCTaskData<CompartmentVector> compartments_;
// All cross-zone string wrappers in the zone.
js::MainThreadOrGCTaskData<js::StringWrapperMap> crossZoneStringWrappers_;
// List of non-ephemeron weak containers to sweep during
// beginSweepingSweepGroup.
js::MainThreadOrGCTaskData<mozilla::LinkedList<js::gc::WeakCacheBase>>
weakCaches_;
// Mapping from not yet marked keys to a vector of all values that the key
// maps to in any live weak map. Separate tables for nursery and tenured
// keys.
js::MainThreadOrGCTaskData<js::gc::EphemeronEdgeTable> gcEphemeronEdges_;
js::MainThreadOrGCTaskData<js::gc::EphemeronEdgeTable>
gcNurseryEphemeronEdges_;
js::MainThreadData<js::UniquePtr<js::RegExpZone>> regExps_;
// Bitmap of atoms marked by this zone.
js::MainThreadOrGCTaskData<js::SparseBitmap> markedAtoms_;
// Set of atoms recently used by this Zone. Purged on GC.
js::MainThreadOrGCTaskData<js::AtomSet> atomCache_;
// Cache storing allocated external strings. Purged on GC.
js::MainThreadOrGCTaskData<js::ExternalStringCache> externalStringCache_;
// Cache for Function.prototype.toString. Purged on GC.
js::MainThreadOrGCTaskData<js::FunctionToStringCache> functionToStringCache_;
// Cache for Function.prototype.bind mapping an atom `name` to atom
// `"bound " + name`. Purged on GC.
using BoundPrefixCache =
js::HashMap<JSAtom*, JSAtom*, js::PointerHasher<JSAtom*>,
js::SystemAllocPolicy>;
js::MainThreadData<BoundPrefixCache> boundPrefixCache_;
// Information about Shapes and BaseShapes.
js::MainThreadData<js::ShapeZone> shapeZone_;
// Information about finalization registries, created on demand.
js::MainThreadOrGCTaskData<js::UniquePtr<js::gc::FinalizationObservers>>
finalizationObservers_;
js::MainThreadOrGCTaskOrIonCompileData<js::jit::JitZone*> jitZone_;
// Number of realms in this zone that have a non-null object allocation
// metadata builder.
js::MainThreadOrIonCompileData<size_t> numRealmsWithAllocMetadataBuilder_{0};
// Last time at which JIT code was discarded for this zone. This is only set
// when JitScripts and Baseline code are discarded as well.
js::MainThreadData<mozilla::TimeStamp> lastDiscardedCodeTime_;
js::MainThreadData<bool> gcScheduled_;
js::MainThreadData<bool> gcScheduledSaved_;
js::MainThreadData<bool> gcPreserveCode_;
js::MainThreadData<bool> keepPropMapTables_;
js::MainThreadData<bool> wasCollected_;
// Allow zones to be linked into a list
js::MainThreadOrGCTaskData<Zone*> listNext_;
static Zone* const NotOnList;
friend class js::gc::ZoneList;
using KeptAliveSet =
JS::GCHashSet<js::HeapPtr<JSObject*>,
js::StableCellHasher<js::HeapPtr<JSObject*>>,
js::ZoneAllocPolicy>;
friend class js::WeakRefObject;
js::MainThreadOrGCTaskData<KeptAliveSet> keptObjects;
// To support weak pointers in some special cases we keep a list of objects
// that need to be traced weakly on GC. This is currently only used for the
// JIT's ShapeListObject. It's assumed that there will not be many of these
// objects.
using ObjectVector = js::GCVector<JSObject*, 0, js::SystemAllocPolicy>;
js::MainThreadOrGCTaskData<ObjectVector> objectsWithWeakPointers;
public:
static JS::Zone* from(ZoneAllocator* zoneAlloc) {
return static_cast<Zone*>(zoneAlloc);
}
explicit Zone(JSRuntime* rt, Kind kind = NormalZone);
~Zone();
[[nodiscard]] bool init();
void destroy(JS::GCContext* gcx);
[[nodiscard]] bool findSweepGroupEdges(Zone* atomsZone);
struct DiscardOptions {
DiscardOptions() {}
bool discardJitScripts = false;
bool resetNurseryAllocSites = false;
bool resetPretenuredAllocSites = false;
JSTracer* traceWeakJitScripts = nullptr;
};
void discardJitCode(JS::GCContext* gcx,
const DiscardOptions& options = DiscardOptions());
// Discard JIT code regardless of isPreservingCode().
void forceDiscardJitCode(JS::GCContext* gcx,
const DiscardOptions& options = DiscardOptions());
void resetAllocSitesAndInvalidate(bool resetNurserySites,
bool resetPretenuredSites);
void traceWeakJitScripts(JSTracer* trc);
bool registerObjectWithWeakPointers(JSObject* obj);
void sweepObjectsWithWeakPointers(JSTracer* trc);
void addSizeOfIncludingThis(
mozilla::MallocSizeOf mallocSizeOf, size_t* zoneObject,
JS::CodeSizes* code, size_t* regexpZone, size_t* jitZone,
size_t* cacheIRStubs, size_t* uniqueIdMap, size_t* initialPropMapTable,
size_t* shapeTables, size_t* atomsMarkBitmaps, size_t* compartmentObjects,
size_t* crossCompartmentWrappersTables, size_t* compartmentsPrivateData,
size_t* scriptCountsMapArg);
// Iterate over all cells in the zone. See the definition of ZoneCellIter
// in gc/GC-inl.h for the possible arguments and documentation.
template <typename T, typename... Args>
js::gc::ZoneCellIter<T> cellIter(Args&&... args) {
return js::gc::ZoneCellIter<T>(const_cast<Zone*>(this),
std::forward<Args>(args)...);
}
// As above, but can return about-to-be-finalised things.
template <typename T, typename... Args>
js::gc::ZoneAllCellIter<T> cellIterUnsafe(Args&&... args) {
return js::gc::ZoneAllCellIter<T>(const_cast<Zone*>(this),
std::forward<Args>(args)...);
}
bool hasMarkedRealms();
void scheduleGC() {
MOZ_ASSERT(!RuntimeHeapIsBusy());
gcScheduled_ = true;
}
void unscheduleGC() { gcScheduled_ = false; }
bool isGCScheduled() { return gcScheduled_; }
void setPreservingCode(bool preserving) { gcPreserveCode_ = preserving; }
bool isPreservingCode() const { return gcPreserveCode_; }
mozilla::TimeStamp lastDiscardedCodeTime() const {
return lastDiscardedCodeTime_;
}
void changeGCState(GCState prev, GCState next);
bool isCollecting() const {
MOZ_ASSERT(js::CurrentThreadCanAccessRuntime(runtimeFromMainThread()));
return isCollectingFromAnyThread();
}
inline bool isCollectingFromAnyThread() const {
return needsIncrementalBarrier() || wasGCStarted();
}
GCState initialMarkingState() const;
bool shouldMarkInZone(js::gc::MarkColor color) const {
// Check whether the zone is in one or both of the MarkBlackOnly and
// MarkBlackAndGray states, depending on the mark color. Also check for
// VerifyPreBarriers when the mark color is black (we don't do any gray
// marking when verifying pre-barriers).
if (color == js::gc::MarkColor::Black) {
return isGCMarkingOrVerifyingPreBarriers();
}
return isGCMarkingBlackAndGray();
}
// Was this zone collected in the last GC.
bool wasCollected() const { return wasCollected_; }
void setWasCollected(bool v) { wasCollected_ = v; }
void setNeedsIncrementalBarrier(bool needs);
const BarrierState* addressOfNeedsIncrementalBarrier() const {
return &needsIncrementalBarrier_;
}
static constexpr size_t offsetOfNeedsIncrementalBarrier() {
return offsetof(Zone, needsIncrementalBarrier_);
}
static constexpr size_t offsetOfJitZone() { return offsetof(Zone, jitZone_); }
js::jit::JitZone* getJitZone(JSContext* cx) {
return jitZone_ ? jitZone_ : createJitZone(cx);
}
js::jit::JitZone* jitZone() { return jitZone_; }
bool ensureJitZoneExists(JSContext* cx) { return !!getJitZone(cx); }
void incNumRealmsWithAllocMetadataBuilder() {
numRealmsWithAllocMetadataBuilder_++;
}
void decNumRealmsWithAllocMetadataBuilder() {
MOZ_ASSERT(numRealmsWithAllocMetadataBuilder_ > 0);
numRealmsWithAllocMetadataBuilder_--;
}
bool hasRealmWithAllocMetadataBuilder() const {
return numRealmsWithAllocMetadataBuilder_ > 0;
}
void prepareForCompacting();
void traceRootsInMajorGC(JSTracer* trc);
void sweepAfterMinorGC(JSTracer* trc);
void sweepUniqueIds();
void sweepCompartments(JS::GCContext* gcx, bool keepAtleastOne,
bool destroyingRuntime);
// Remove dead weak maps from gcWeakMapList_ and remove entries from the
// remaining weak maps whose keys are dead.
void sweepWeakMaps(JSTracer* trc);
// Trace all weak maps in this zone. Used to update edges after a moving GC.
void traceWeakMaps(JSTracer* trc);
js::gc::UniqueIdMap& uniqueIds() { return uniqueIds_.ref(); }
void notifyObservingDebuggers();
void noteTenuredAlloc() { tenuredAllocsSinceMinorGC_++; }
uint32_t* addressOfTenuredAllocCount() { return &tenuredAllocsSinceMinorGC_; }
uint32_t getAndResetTenuredAllocsSinceMinorGC() {
uint32_t res = tenuredAllocsSinceMinorGC_;
tenuredAllocsSinceMinorGC_ = 0;
return res;
}
mozilla::LinkedList<js::WeakMapBase>& gcWeakMapList() {
return gcWeakMapList_.ref();
}
CompartmentVector& compartments() { return compartments_.ref(); }
js::StringWrapperMap& crossZoneStringWrappers() {
return crossZoneStringWrappers_.ref();
}
const js::StringWrapperMap& crossZoneStringWrappers() const {
return crossZoneStringWrappers_.ref();
}
void dropStringWrappersOnGC();
void traceWeakCCWEdges(JSTracer* trc);
static void fixupAllCrossCompartmentWrappersAfterMovingGC(JSTracer* trc);
void fixupAfterMovingGC();
void fixupScriptMapsAfterMovingGC(JSTracer* trc);
void setNurseryAllocFlags(bool allocObjects, bool allocStrings,
bool allocBigInts);
bool allocKindInNursery(JS::TraceKind kind) const {
switch (kind) {
case JS::TraceKind::Object:
return allocNurseryObjects_;
case JS::TraceKind::String:
return allocNurseryStrings_;
case JS::TraceKind::BigInt:
return allocNurseryBigInts_;
default:
MOZ_CRASH("Unsupported kind for nursery allocation");
}
}
bool allocNurseryObjects() const { return allocNurseryObjects_; }
// Note that this covers both allocating JSStrings themselves in the nursery,
// as well as (possibly) the character data.
bool allocNurseryStrings() const { return allocNurseryStrings_; }
bool allocNurseryBigInts() const { return allocNurseryBigInts_; }
js::gc::Heap minHeapToTenure(JS::TraceKind kind) const {
switch (kind) {
case JS::TraceKind::Object:
return minObjectHeapToTenure_;
case JS::TraceKind::String:
return minStringHeapToTenure_;
case JS::TraceKind::BigInt:
return minBigintHeapToTenure_;
default:
MOZ_CRASH("Unsupported kind for nursery allocation");
}
}
mozilla::LinkedList<js::gc::WeakCacheBase>& weakCaches() {
return weakCaches_.ref();
}
void registerWeakCache(js::gc::WeakCacheBase* cachep) {
weakCaches().insertBack(cachep);
}
void beforeClearDelegate(JSObject* wrapper, JSObject* delegate) {
if (needsIncrementalBarrier()) {
beforeClearDelegateInternal(wrapper, delegate);
}
}
void afterAddDelegate(JSObject* wrapper) {
if (needsIncrementalBarrier()) {
afterAddDelegateInternal(wrapper);
}
}
void beforeClearDelegateInternal(JSObject* wrapper, JSObject* delegate);
void afterAddDelegateInternal(JSObject* wrapper);
js::gc::EphemeronEdgeTable& gcEphemeronEdges() {
return gcEphemeronEdges_.ref();
}
js::gc::EphemeronEdgeTable& gcNurseryEphemeronEdges() {
return gcNurseryEphemeronEdges_.ref();
}
js::gc::EphemeronEdgeTable& gcEphemeronEdges(const js::gc::Cell* cell) {
return cell->isTenured() ? gcEphemeronEdges() : gcNurseryEphemeronEdges();
}
// Perform all pending weakmap entry marking for this zone after
// transitioning to weak marking mode.
js::gc::IncrementalProgress enterWeakMarkingMode(js::GCMarker* marker,
js::SliceBudget& budget);
// A set of edges from this zone to other zones used during GC to calculate
// sweep groups.
NodeSet& gcSweepGroupEdges() {
return gcGraphEdges; // Defined in GraphNodeBase base class.
}
bool hasSweepGroupEdgeTo(Zone* otherZone) const {
return gcGraphEdges.has(otherZone);
}
[[nodiscard]] bool addSweepGroupEdgeTo(Zone* otherZone) {
MOZ_ASSERT(otherZone->isGCMarking());
return gcSweepGroupEdges().put(otherZone);
}
void clearSweepGroupEdges() { gcSweepGroupEdges().clear(); }
js::RegExpZone& regExps() { return *regExps_.ref(); }
js::SparseBitmap& markedAtoms() { return markedAtoms_.ref(); }
js::AtomSet& atomCache() { return atomCache_.ref(); }
void purgeAtomCache();
js::ExternalStringCache& externalStringCache() {
return externalStringCache_.ref();
};
js::FunctionToStringCache& functionToStringCache() {
return functionToStringCache_.ref();
}
BoundPrefixCache& boundPrefixCache() { return boundPrefixCache_.ref(); }
js::ShapeZone& shapeZone() { return shapeZone_.ref(); }
bool keepPropMapTables() const { return keepPropMapTables_; }
void setKeepPropMapTables(bool b) { keepPropMapTables_ = b; }
void clearRootsForShutdownGC();
void finishRoots();
void traceScriptTableRoots(JSTracer* trc);
void clearScriptCounts(Realm* realm);
void clearScriptLCov(Realm* realm);
// Add the target of JS WeakRef to a kept-alive set maintained by GC.
// https://tc39.es/ecma262/#sec-addtokeptobjects
bool addToKeptObjects(HandleObject target);
void traceKeptObjects(JSTracer* trc);
// Clear the kept-alive set.
// See: https://tc39.es/proposal-weakrefs/#sec-clear-kept-objects
void clearKeptObjects();
js::gc::AllocSite* unknownAllocSite(JS::TraceKind kind) {
return &pretenuring.unknownAllocSite(kind);
}
js::gc::AllocSite* optimizedAllocSite() {
return &pretenuring.optimizedAllocSite;
}
uint32_t nurseryAllocCount(JS::TraceKind kind) const {
return pretenuring.nurseryAllocCount(kind);
}
#ifdef JSGC_HASH_TABLE_CHECKS
void checkAllCrossCompartmentWrappersAfterMovingGC();
void checkStringWrappersAfterMovingGC();
// Assert that the UniqueId table has been redirected successfully.
void checkUniqueIdTableAfterMovingGC();
void checkScriptMapsAfterMovingGC();
#endif
#ifdef DEBUG
// For testing purposes, return the index of the sweep group which this zone
// was swept in in the last GC.
unsigned lastSweepGroupIndex() { return gcSweepGroupIndex; }
#endif
// Support for invalidating fuses
// A dependent script set pairs a fuse with a set of scripts which depend
// on said fuse; this is a vector of script sets because the expectation for
// now is that the number of runtime wide invalidating fuses will be small.
// This will need to be revisited (convert to HashMap?) should that no
// longer be the case
//
// Note: This isn't traced through the zone, but rather through the use
// of JS::WeakCache.
js::Vector<js::DependentScriptSet, 1, js::SystemAllocPolicy> fuseDependencies;
js::DependentScriptSet* getOrCreateDependentScriptSet(
JSContext* cx, js::InvalidatingFuse* fuse);
private:
js::jit::JitZone* createJitZone(JSContext* cx);
bool isQueuedForBackgroundSweep() { return isOnList(); }
void sweepEphemeronTablesAfterMinorGC();
js::gc::FinalizationObservers* finalizationObservers() {
return finalizationObservers_.ref().get();
}
bool ensureFinalizationObservers();
bool isOnList() const;
Zone* nextZone() const;
friend bool js::CurrentThreadCanAccessZone(Zone* zone);
friend class js::gc::GCRuntime;
};
} // namespace JS
namespace js::gc {
const char* StateName(JS::Zone::GCState state);
} // namespace js::gc
#endif // gc_Zone_h
|