The Tor Browser: js/src/jsgcinlines.h@129ffea94266 (annotated)

js/src/jsgcinlines.h@129ffea94266 (annotated)

js/src/jsgcinlines.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * 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 jsgcinlines_h
 #define jsgcinlines_h
 #include "jsgc.h"
 #include "gc/Zone.h"
 namespace js {
 class Shape;
 /*
  * This auto class should be used around any code that might cause a mark bit to
  * be set on an object in a dead zone. See AutoMaybeTouchDeadZones
  * for more details.
  */
 struct AutoMarkInDeadZone
 {
     AutoMarkInDeadZone(JS::Zone *zone)
       : zone(zone),
         scheduled(zone->scheduledForDestruction)
     {
         JSRuntime *rt = zone->runtimeFromMainThread();
         if (rt->gcManipulatingDeadZones && zone->scheduledForDestruction) {
             rt->gcObjectsMarkedInDeadZones++;
             zone->scheduledForDestruction = false;
         }
     }
     ~AutoMarkInDeadZone() {
         zone->scheduledForDestruction = scheduled;
     }
   private:
     JS::Zone *zone;
     bool scheduled;
 };
 inline Allocator *const
 ThreadSafeContext::allocator()
 {
     JS_ASSERT_IF(isJSContext(), &asJSContext()->zone()->allocator == allocator_);
     return allocator_;
 }
 template <typename T>
 inline bool
 ThreadSafeContext::isThreadLocal(T thing) const
 {
     if (!isForkJoinContext())
         return true;
     if (!IsInsideNursery(runtime_, thing) &&
         allocator_->arenas.containsArena(runtime_, thing->arenaHeader()))
     {
         // GC should be suppressed in preparation for mutating thread local
         // objects, as we don't want to trip any barriers.
         JS_ASSERT(!thing->zoneFromAnyThread()->needsBarrier());
         JS_ASSERT(!thing->runtimeFromAnyThread()->needsBarrier());
         return true;
     }
     return false;
 }
 namespace gc {
 static inline AllocKind
 GetGCObjectKind(const Class *clasp)
 {
     if (clasp == FunctionClassPtr)
         return JSFunction::FinalizeKind;
     uint32_t nslots = JSCLASS_RESERVED_SLOTS(clasp);
     if (clasp->flags & JSCLASS_HAS_PRIVATE)
         nslots++;
     return GetGCObjectKind(nslots);
 }
 #ifdef JSGC_GENERATIONAL
 inline bool
 ShouldNurseryAllocate(const Nursery &nursery, AllocKind kind, InitialHeap heap)
 {
     return nursery.isEnabled() && IsNurseryAllocable(kind) && heap != TenuredHeap;
 }
 #endif
 inline JSGCTraceKind
 GetGCThingTraceKind(const void *thing)
 {
     JS_ASSERT(thing);
     const Cell *cell = static_cast<const Cell *>(thing);
 #ifdef JSGC_GENERATIONAL
     if (IsInsideNursery(cell->runtimeFromAnyThread(), cell))
         return JSTRACE_OBJECT;
 #endif
     return MapAllocToTraceKind(cell->tenuredGetAllocKind());
 }
 static inline void
 GCPoke(JSRuntime *rt)
 {
     rt->gcPoke = true;
 #ifdef JS_GC_ZEAL
     /* Schedule a GC to happen "soon" after a GC poke. */
     if (rt->gcZeal() == js::gc::ZealPokeValue)
         rt->gcNextScheduled = 1;
 #endif
 }
 class ArenaIter
 {
     ArenaHeader *aheader;
     ArenaHeader *remainingHeader;
   public:
     ArenaIter() {
         init();
     }
     ArenaIter(JS::Zone *zone, AllocKind kind) {
         init(zone, kind);
     }
     void init() {
         aheader = nullptr;
         remainingHeader = nullptr;
     }
     void init(ArenaHeader *aheaderArg) {
         aheader = aheaderArg;
         remainingHeader = nullptr;
     }
     void init(JS::Zone *zone, AllocKind kind) {
         aheader = zone->allocator.arenas.getFirstArena(kind);
         remainingHeader = zone->allocator.arenas.getFirstArenaToSweep(kind);
         if (!aheader) {
             aheader = remainingHeader;
             remainingHeader = nullptr;
         }
     }
     bool done() {
         return !aheader;
     }
     ArenaHeader *get() {
         return aheader;
     }
     void next() {
         aheader = aheader->next;
         if (!aheader) {
             aheader = remainingHeader;
             remainingHeader = nullptr;
         }
     }
 };
 class CellIterImpl
 {
     size_t firstThingOffset;
     size_t thingSize;
     ArenaIter aiter;
     FreeSpan firstSpan;
     const FreeSpan *span;
     uintptr_t thing;
     Cell *cell;
   protected:
     CellIterImpl() {
     }
     void initSpan(JS::Zone *zone, AllocKind kind) {
         JS_ASSERT(zone->allocator.arenas.isSynchronizedFreeList(kind));
         firstThingOffset = Arena::firstThingOffset(kind);
         thingSize = Arena::thingSize(kind);
         firstSpan.initAsEmpty();
         span = &firstSpan;
         thing = span->first;
     }
     void init(ArenaHeader *singleAheader) {
         initSpan(singleAheader->zone, singleAheader->getAllocKind());
         aiter.init(singleAheader);
         next();
         aiter.init();
     }
     void init(JS::Zone *zone, AllocKind kind) {
         initSpan(zone, kind);
         aiter.init(zone, kind);
         next();
     }
   public:
     bool done() const {
         return !cell;
     }
     template<typename T> T *get() const {
         JS_ASSERT(!done());
         return static_cast<T *>(cell);
     }
     Cell *getCell() const {
         JS_ASSERT(!done());
         return cell;
     }
     void next() {
         for (;;) {
             if (thing != span->first)
                 break;
             if (MOZ_LIKELY(span->hasNext())) {
                 thing = span->last + thingSize;
                 span = span->nextSpan();
                 break;
             }
             if (aiter.done()) {
                 cell = nullptr;
                 return;
             }
             ArenaHeader *aheader = aiter.get();
             firstSpan = aheader->getFirstFreeSpan();
             span = &firstSpan;
             thing = aheader->arenaAddress() | firstThingOffset;
             aiter.next();
         }
         cell = reinterpret_cast<Cell *>(thing);
         thing += thingSize;
     }
 };
 class CellIterUnderGC : public CellIterImpl
 {
   public:
     CellIterUnderGC(JS::Zone *zone, AllocKind kind) {
 #ifdef JSGC_GENERATIONAL
         JS_ASSERT(zone->runtimeFromAnyThread()->gcNursery.isEmpty());
 #endif
         JS_ASSERT(zone->runtimeFromAnyThread()->isHeapBusy());
         init(zone, kind);
     }
     CellIterUnderGC(ArenaHeader *aheader) {
         JS_ASSERT(aheader->zone->runtimeFromAnyThread()->isHeapBusy());
         init(aheader);
     }
 };
 class CellIter : public CellIterImpl
 {
     ArenaLists *lists;
     AllocKind kind;
 #ifdef DEBUG
     size_t *counter;
 #endif
   public:
     CellIter(JS::Zone *zone, AllocKind kind)
       : lists(&zone->allocator.arenas),
         kind(kind)
     {
         /*
          * We have a single-threaded runtime, so there's no need to protect
          * against other threads iterating or allocating. However, we do have
          * background finalization; we have to wait for this to finish if it's
          * currently active.
          */
         if (IsBackgroundFinalized(kind) &&
             zone->allocator.arenas.needBackgroundFinalizeWait(kind))
         {
             gc::FinishBackgroundFinalize(zone->runtimeFromMainThread());
         }
 #ifdef JSGC_GENERATIONAL
         /* Evict the nursery before iterating so we can see all things. */
         JSRuntime *rt = zone->runtimeFromMainThread();
         if (!rt->gcNursery.isEmpty())
             MinorGC(rt, JS::gcreason::EVICT_NURSERY);
 #endif
         if (lists->isSynchronizedFreeList(kind)) {
             lists = nullptr;
         } else {
             JS_ASSERT(!zone->runtimeFromMainThread()->isHeapBusy());
             lists->copyFreeListToArena(kind);
         }
 #ifdef DEBUG
         /* Assert that no GCs can occur while a CellIter is live. */
         counter = &zone->runtimeFromAnyThread()->noGCOrAllocationCheck;
         ++*counter;
 #endif
         init(zone, kind);
     }
     ~CellIter() {
 #ifdef DEBUG
         JS_ASSERT(*counter > 0);
         --*counter;
 #endif
         if (lists)
             lists->clearFreeListInArena(kind);
     }
 };
 class GCZonesIter
 {
   private:
     ZonesIter zone;
   public:
     GCZonesIter(JSRuntime *rt) : zone(rt, WithAtoms) {
         if (!zone->isCollecting())
             next();
     }
     bool done() const { return zone.done(); }
     void next() {
         JS_ASSERT(!done());
         do {
             zone.next();
         } while (!zone.done() && !zone->isCollecting());
     }
     JS::Zone *get() const {
         JS_ASSERT(!done());
         return zone;
     }
     operator JS::Zone *() const { return get(); }
     JS::Zone *operator->() const { return get(); }
 };
 typedef CompartmentsIterT<GCZonesIter> GCCompartmentsIter;
 /* Iterates over all zones in the current zone group. */
 class GCZoneGroupIter {
   private:
     JS::Zone *current;
   public:
     GCZoneGroupIter(JSRuntime *rt) {
         JS_ASSERT(rt->isHeapBusy());
         current = rt->gcCurrentZoneGroup;
     }
     bool done() const { return !current; }
     void next() {
         JS_ASSERT(!done());
         current = current->nextNodeInGroup();
     }
     JS::Zone *get() const {
         JS_ASSERT(!done());
         return current;
     }
     operator JS::Zone *() const { return get(); }
     JS::Zone *operator->() const { return get(); }
 };
 typedef CompartmentsIterT<GCZoneGroupIter> GCCompartmentGroupIter;
 #ifdef JSGC_GENERATIONAL
 /*
  * Attempt to allocate a new GC thing out of the nursery. If there is not enough
  * room in the nursery or there is an OOM, this method will return nullptr.
  */
 template <AllowGC allowGC>
 inline JSObject *
 TryNewNurseryObject(ThreadSafeContext *cxArg, size_t thingSize, size_t nDynamicSlots)
 {
     JSContext *cx = cxArg->asJSContext();
     JS_ASSERT(!IsAtomsCompartment(cx->compartment()));
     JSRuntime *rt = cx->runtime();
     Nursery &nursery = rt->gcNursery;
     JSObject *obj = nursery.allocateObject(cx, thingSize, nDynamicSlots);
     if (obj)
         return obj;
     if (allowGC && !rt->mainThread.suppressGC) {
         MinorGC(cx, JS::gcreason::OUT_OF_NURSERY);
         /* Exceeding gcMaxBytes while tenuring can disable the Nursery. */
         if (nursery.isEnabled()) {
             JSObject *obj = nursery.allocateObject(cx, thingSize, nDynamicSlots);
             JS_ASSERT(obj);
             return obj;
         }
     }
     return nullptr;
 }
 #endif /* JSGC_GENERATIONAL */
 static inline bool
 PossiblyFail()
 {
     JS_OOM_POSSIBLY_FAIL();
     return true;
 }
 template <AllowGC allowGC>
 static inline bool
 CheckAllocatorState(ThreadSafeContext *cx, AllocKind kind)
 {
     if (!cx->isJSContext())
         return true;
     JSContext *ncx = cx->asJSContext();
     JSRuntime *rt = ncx->runtime();
 #if defined(JS_GC_ZEAL) || defined(DEBUG)
     JS_ASSERT_IF(rt->isAtomsCompartment(ncx->compartment()),
                  kind == FINALIZE_STRING ||
                  kind == FINALIZE_FAT_INLINE_STRING ||
                  kind == FINALIZE_JITCODE);
     JS_ASSERT(!rt->isHeapBusy());
     JS_ASSERT(!rt->noGCOrAllocationCheck);
 #endif
     // For testing out of memory conditions
     if (!PossiblyFail()) {
         js_ReportOutOfMemory(cx);
         return false;
     }
     if (allowGC) {
 #ifdef JS_GC_ZEAL
         if (rt->needZealousGC())
             js::gc::RunDebugGC(ncx);
 #endif
         if (rt->interrupt) {
             // Invoking the interrupt callback can fail and we can't usefully
             // handle that here. Just check in case we need to collect instead.
             js::gc::GCIfNeeded(ncx);
         }
     }
     return true;
 }
 template <typename T>
 static inline void
 CheckIncrementalZoneState(ThreadSafeContext *cx, T *t)
 {
 #ifdef DEBUG
     if (!cx->isJSContext())
         return;
     Zone *zone = cx->asJSContext()->zone();
     JS_ASSERT_IF(t && zone->wasGCStarted() && (zone->isGCMarking() || zone->isGCSweeping()),
                  t->arenaHeader()->allocatedDuringIncremental);
 #endif
 }
 /*
  * Allocate a new GC thing. After a successful allocation the caller must
  * fully initialize the thing before calling any function that can potentially
  * trigger GC. This will ensure that GC tracing never sees junk values stored
  * in the partially initialized thing.
  */
 template <AllowGC allowGC>
 inline JSObject *
 AllocateObject(ThreadSafeContext *cx, AllocKind kind, size_t nDynamicSlots, InitialHeap heap)
 {
     size_t thingSize = Arena::thingSize(kind);
     JS_ASSERT(thingSize == Arena::thingSize(kind));
     if (!CheckAllocatorState<allowGC>(cx, kind))
         return nullptr;
 #ifdef JSGC_GENERATIONAL
     if (cx->hasNursery() && ShouldNurseryAllocate(cx->nursery(), kind, heap)) {
         JSObject *obj = TryNewNurseryObject<allowGC>(cx, thingSize, nDynamicSlots);
         if (obj)
             return obj;
     }
 #endif
     HeapSlot *slots = nullptr;
     if (nDynamicSlots) {
         slots = cx->pod_malloc<HeapSlot>(nDynamicSlots);
         if (MOZ_UNLIKELY(!slots))
             return nullptr;
         js::Debug_SetSlotRangeToCrashOnTouch(slots, nDynamicSlots);
     }
     JSObject *obj = static_cast<JSObject *>(cx->allocator()->arenas.allocateFromFreeList(kind, thingSize));
     if (!obj)
         obj = static_cast<JSObject *>(js::gc::ArenaLists::refillFreeList<allowGC>(cx, kind));
     if (obj)
         obj->setInitialSlots(slots);
     else
         js_free(slots);
     CheckIncrementalZoneState(cx, obj);
     return obj;
 }
 template <typename T, AllowGC allowGC>
 inline T *
 AllocateNonObject(ThreadSafeContext *cx)
 {
     AllocKind kind = MapTypeToFinalizeKind<T>::kind;
     size_t thingSize = sizeof(T);
     JS_ASSERT(thingSize == Arena::thingSize(kind));
     if (!CheckAllocatorState<allowGC>(cx, kind))
         return nullptr;
     T *t = static_cast<T *>(cx->allocator()->arenas.allocateFromFreeList(kind, thingSize));
     if (!t)
         t = static_cast<T *>(js::gc::ArenaLists::refillFreeList<allowGC>(cx, kind));
     CheckIncrementalZoneState(cx, t);
     return t;
 }
 /*
  * When allocating for initialization from a cached object copy, we will
  * potentially destroy the cache entry we want to copy if we allow GC. On the
  * other hand, since these allocations are extremely common, we don't want to
  * delay GC from these allocation sites. Instead we allow the GC, but still
  * fail the allocation, forcing the non-cached path.
  */
 template <AllowGC allowGC>
 inline JSObject *
 AllocateObjectForCacheHit(JSContext *cx, AllocKind kind, InitialHeap heap)
 {
 #ifdef JSGC_GENERATIONAL
     if (ShouldNurseryAllocate(cx->nursery(), kind, heap)) {
         size_t thingSize = Arena::thingSize(kind);
         JS_ASSERT(thingSize == Arena::thingSize(kind));
         if (!CheckAllocatorState<NoGC>(cx, kind))
             return nullptr;
         JSObject *obj = TryNewNurseryObject<NoGC>(cx, thingSize, 0);
         if (!obj && allowGC) {
             MinorGC(cx, JS::gcreason::OUT_OF_NURSERY);
             return nullptr;
         }
         return obj;
     }
 #endif
     JSObject *obj = AllocateObject<NoGC>(cx, kind, 0, heap);
     if (!obj && allowGC) {
         MaybeGC(cx);
         return nullptr;
     }
     return obj;
 }
 } /* namespace gc */
 template <js::AllowGC allowGC>
 inline JSObject *
 NewGCObject(js::ThreadSafeContext *cx, js::gc::AllocKind kind, size_t nDynamicSlots, js::gc::InitialHeap heap)
 {
     JS_ASSERT(kind >= js::gc::FINALIZE_OBJECT0 && kind <= js::gc::FINALIZE_OBJECT_LAST);
     return js::gc::AllocateObject<allowGC>(cx, kind, nDynamicSlots, heap);
 }
 template <js::AllowGC allowGC>
 inline jit::JitCode *
 NewJitCode(js::ThreadSafeContext *cx)
 {
     return gc::AllocateNonObject<jit::JitCode, allowGC>(cx);
 }
 inline
 types::TypeObject *
 NewTypeObject(js::ThreadSafeContext *cx)
 {
     return gc::AllocateNonObject<types::TypeObject, js::CanGC>(cx);
 }
 } /* namespace js */
 template <js::AllowGC allowGC>
 inline JSString *
 js_NewGCString(js::ThreadSafeContext *cx)
 {
     return js::gc::AllocateNonObject<JSString, allowGC>(cx);
 }
 template <js::AllowGC allowGC>
 inline JSFatInlineString *
 js_NewGCFatInlineString(js::ThreadSafeContext *cx)
 {
     return js::gc::AllocateNonObject<JSFatInlineString, allowGC>(cx);
 }
 inline JSExternalString *
 js_NewGCExternalString(js::ThreadSafeContext *cx)
 {
     return js::gc::AllocateNonObject<JSExternalString, js::CanGC>(cx);
 }
 inline JSScript *
 js_NewGCScript(js::ThreadSafeContext *cx)
 {
     return js::gc::AllocateNonObject<JSScript, js::CanGC>(cx);
 }
 inline js::LazyScript *
 js_NewGCLazyScript(js::ThreadSafeContext *cx)
 {
     return js::gc::AllocateNonObject<js::LazyScript, js::CanGC>(cx);
 }
 inline js::Shape *
 js_NewGCShape(js::ThreadSafeContext *cx)
 {
     return js::gc::AllocateNonObject<js::Shape, js::CanGC>(cx);
 }
 template <js::AllowGC allowGC>
 inline js::BaseShape *
 js_NewGCBaseShape(js::ThreadSafeContext *cx)
 {
     return js::gc::AllocateNonObject<js::BaseShape, allowGC>(cx);
 }
 #endif /* jsgcinlines_h */

The Tor Browser / annotate

js/src/jsgcinlines.h@129ffea94266 (annotated)

js/src/jsgcinlines.h