js/src/gc/PrivateIterators-inl.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /*
   8  * GC-internal iterators for various data structures.
   9  */
  10
  11 #ifndef gc_PrivateIterators_inl_h
  12 #define gc_PrivateIterators_inl_h
  13
  14 #include "gc/PublicIterators.h"
  15
  16 #include "gc/GC-inl.h"
  17
  18 namespace js::gc {
  19
  20 class ArenaCellIterUnderGC : public ArenaCellIter {
  21  public:
  22   explicit ArenaCellIterUnderGC(Arena* arena) : ArenaCellIter(arena) {
  23     MOZ_ASSERT(CurrentThreadIsPerformingGC());
  24   }
  25 };
  26
  27 class ArenaCellIterUnderFinalize : public ArenaCellIter {
  28  public:
  29   explicit ArenaCellIterUnderFinalize(Arena* arena) : ArenaCellIter(arena) {
  30     MOZ_ASSERT(CurrentThreadIsGCFinalizing());
  31   }
  32 };
  33
  34 class GrayObjectIter : public ZoneAllCellIter<js::gc::TenuredCell> {
  35  public:
  36   explicit GrayObjectIter(JS::Zone* zone, AllocKind kind)
  37       : ZoneAllCellIter<js::gc::TenuredCell>() {
  38     initForTenuredIteration(zone, kind);
  39   }
  40
  41   JSObject* get() const {
  42     return ZoneAllCellIter<js::gc::TenuredCell>::get<JSObject>();
  43   }
  44   operator JSObject*() const { return get(); }
  45   JSObject* operator->() const { return get(); }
  46 };
  47
  48 class GCZonesIter {
  49   AllZonesIter zone;
  50
  51  public:
  52   explicit GCZonesIter(GCRuntime* gc) : zone(gc) {
  53     MOZ_ASSERT(gc->heapState() != JS::HeapState::Idle);
  54     if (!done() && !zone->wasGCStarted()) {
  55       next();
  56     }
  57   }
  58   explicit GCZonesIter(JSRuntime* rt) : GCZonesIter(&rt->gc) {}
  59
  60   bool done() const { return zone.done(); }
  61
  62   void next() {
  63     MOZ_ASSERT(!done());
  64     do {
  65       zone.next();
  66     } while (!zone.done() && !zone->wasGCStarted());
  67   }
  68
  69   JS::Zone* get() const {
  70     MOZ_ASSERT(!done());
  71     return zone;
  72   }
  73
  74   operator JS::Zone*() const { return get(); }
  75   JS::Zone* operator->() const { return get(); }
  76 };
  77
  78 using GCCompartmentsIter =
  79     CompartmentsOrRealmsIterT<GCZonesIter, CompartmentsInZoneIter>;
  80 using GCRealmsIter = CompartmentsOrRealmsIterT<GCZonesIter, RealmsInZoneIter>;
  81
  82 /* Iterates over all zones in the current sweep group. */
  83 class SweepGroupZonesIter {
  84   JS::Zone* current;
  85
  86  public:
  87   explicit SweepGroupZonesIter(GCRuntime* gc)
  88       : current(gc->getCurrentSweepGroup()) {
  89     MOZ_ASSERT(CurrentThreadIsPerformingGC());
  90   }
  91   explicit SweepGroupZonesIter(JSRuntime* rt) : SweepGroupZonesIter(&rt->gc) {}
  92
  93   bool done() const { return !current; }
  94
  95   void next() {
  96     MOZ_ASSERT(!done());
  97     current = current->nextNodeInGroup();
  98   }
  99
 100   JS::Zone* get() const {
 101     MOZ_ASSERT(!done());
 102     return current;
 103   }
 104
 105   operator JS::Zone*() const { return get(); }
 106   JS::Zone* operator->() const { return get(); }
 107 };
 108
 109 using SweepGroupCompartmentsIter =
 110     CompartmentsOrRealmsIterT<SweepGroupZonesIter, CompartmentsInZoneIter>;
 111 using SweepGroupRealmsIter =
 112     CompartmentsOrRealmsIterT<SweepGroupZonesIter, RealmsInZoneIter>;
 113
 114 // Iterate the free cells in an arena. See also ArenaCellIter which iterates
 115 // the allocated cells.
 116 class ArenaFreeCellIter {
 117   Arena* arena;
 118   size_t thingSize;
 119   FreeSpan span;
 120   uint_fast16_t thing;
 121
 122  public:
 123   explicit ArenaFreeCellIter(Arena* arena)
 124       : arena(arena),
 125         thingSize(arena->getThingSize()),
 126         span(*arena->getFirstFreeSpan()),
 127         thing(span.first) {
 128     MOZ_ASSERT(arena);
 129     MOZ_ASSERT(thing < ArenaSize);
 130   }
 131
 132   bool done() const {
 133     MOZ_ASSERT(thing < ArenaSize);
 134     return !thing;
 135   }
 136
 137   TenuredCell* get() const {
 138     MOZ_ASSERT(!done());
 139     return reinterpret_cast<TenuredCell*>(uintptr_t(arena) + thing);
 140   }
 141
 142   void next() {
 143     MOZ_ASSERT(!done());
 144     MOZ_ASSERT(thing >= span.first && thing <= span.last);
 145
 146     if (thing == span.last) {
 147       span = *span.nextSpan(arena);
 148       thing = span.first;
 149     } else {
 150       thing += thingSize;
 151     }
 152
 153     MOZ_ASSERT(thing < ArenaSize);
 154   }
 155
 156   operator TenuredCell*() const { return get(); }
 157   TenuredCell* operator->() const { return get(); }
 158 };
 159
 160 }  // namespace js::gc
 161
 162 #endif  // gc_PrivateIterators_inl_h