diff options
Diffstat (limited to 'src/dom/js/jsgc.c')
| -rw-r--r-- | src/dom/js/jsgc.c | 1423 |
1 files changed, 0 insertions, 1423 deletions
diff --git a/src/dom/js/jsgc.c b/src/dom/js/jsgc.c deleted file mode 100644 index a0efec4d7..000000000 --- a/src/dom/js/jsgc.c +++ /dev/null @@ -1,1423 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- - * - * ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ - * - * Software distributed under the License is distributed on an "AS IS" basis, - * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License - * for the specific language governing rights and limitations under the - * License. - * - * The Original Code is Mozilla Communicator client code, released - * March 31, 1998. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1998 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -/* - * JS Mark-and-Sweep Garbage Collector. - * - * This GC allocates only fixed-sized things big enough to contain two words - * (pointers) on any host architecture. It allocates from an arena pool (see - * jsarena.h). It uses an ideally parallel array of flag bytes to hold the - * mark bit, finalizer type index, etc. - * - * XXX swizzle page to freelist for better locality of reference - */ -#include "jsstddef.h" -#include <stdlib.h> /* for free, called by JS_ARENA_DESTROY */ -#include <string.h> /* for memset, called by jsarena.h macros if DEBUG */ -#include "jstypes.h" -#include "jsarena.h" /* Added by JSIFY */ -#include "jsutil.h" /* Added by JSIFY */ -#include "jshash.h" /* Added by JSIFY */ -#include "jsapi.h" -#include "jsatom.h" -#include "jscntxt.h" -#include "jsconfig.h" -#include "jsdbgapi.h" -#include "jsfun.h" -#include "jsgc.h" -#include "jsinterp.h" -#include "jslock.h" -#include "jsnum.h" -#include "jsobj.h" -#include "jsscope.h" -#include "jsscript.h" -#include "jsstr.h" - -/* - * GC arena sizing depends on amortizing arena overhead using a large number - * of things per arena, and on the thing/flags ratio of 8:1 on most platforms. - * - * On 64-bit platforms, we would have half as many things per arena because - * pointers are twice as big, so we double the bytes for things per arena. - * This preserves the 1024 byte flags sub-arena size, which relates to the - * GC_PAGE_SIZE (see below for why). - */ -#if JS_BYTES_PER_WORD == 8 -# define GC_THINGS_SHIFT 14 /* 16KB for things on Alpha, etc. */ -#else -# define GC_THINGS_SHIFT 13 /* 8KB for things on most platforms */ -#endif -#define GC_THINGS_SIZE JS_BIT(GC_THINGS_SHIFT) -#define GC_FLAGS_SIZE (GC_THINGS_SIZE / sizeof(JSGCThing)) -#define GC_ARENA_SIZE (GC_THINGS_SIZE + GC_FLAGS_SIZE) - -/* - * The private JSGCThing struct, which describes a gcFreeList element. - */ -struct JSGCThing { - JSGCThing *next; - uint8 *flagp; -}; - -/* - * A GC arena contains one flag byte for each thing in its heap, and supports - * O(1) lookup of a flag given its thing's address. - * - * To implement this, we take advantage of the thing/flags numerology: given - * the 8K bytes worth of GC-things, there are 1K flag bytes. We mask a thing's - * address with ~1023 to find a JSGCPageInfo record at the front of a mythical - * "GC page" within the larger 8K thing arena. That JSGCPageInfo contains a - * pointer to the 128 flag bytes corresponding to the things in the page, so we - * index into this flags array using the thing's index within its page. - * - * To align thing pages on 1024-byte boundaries, we must allocate the 9KB of - * flags+things arena payload, then find the first 0 mod 1024 boundary after - * the first payload address. That's where things start, with a JSGCPageInfo - * taking up the first thing-slot, as usual for 0 mod 1024 byte boundaries. - * The effect of this alignment trick is to split the flags into at most 2 - * discontiguous spans, one before the things and one after (if we're really - * lucky, and the arena payload starts on a 0 mod 1024 byte boundary, no need - * to split). - * - * The overhead of this scheme for most platforms is (16+8*(8+1))/(16+9K) or - * .95% (assuming 16 byte JSArena header size, and 8 byte JSGCThing size). - * - * Here's some ASCII art showing an arena: - * - * split - * | - * V - * +--+-------+-------+-------+-------+-------+-------+-------+-------+-----+ - * |fB| tp0 | tp1 | tp2 | tp3 | tp4 | tp5 | tp6 | tp7 | fA | - * +--+-------+-------+-------+-------+-------+-------+-------+-------+-----+ - * ^ ^ - * tI ---------+ | - * tJ -------------------------------------------+ - * - * - fB are the "before split" flags, fA are the "after split" flags - * - tp0-tp7 are the 8 thing pages - * - thing tI points into tp1, whose flags are below the split, in fB - * - thing tJ points into tp5, clearly above the split - * - * In general, one of the thing pages will have some of its things' flags on - * the low side of the split, and the rest of its things' flags on the high - * side. All the other pages have flags only below or only above. Therefore - * we'll have to test something to decide whether the split divides flags in - * a given thing's page. So we store the split pointer (the pointer to tp0) - * in each JSGCPageInfo, along with the flags pointer for the 128 flag bytes - * ideally starting, for tp0 things, at the beginning of the arena's payload - * (at the start of fB). - * - * That is, each JSGCPageInfo's flags pointer is 128 bytes from the previous, - * or at the start of the arena if there is no previous page in this arena. - * Thus these ideal 128-byte flag pages run contiguously from the start of the - * arena (right over the split!), and the JSGCPageInfo flags pointers contain - * no discontinuities over the split created by the thing pages. So if, for a - * given JSGCPageInfo *pi, we find that - * - * pi->flags + ((jsuword)thing % 1024) / sizeof(JSGCThing) >= pi->split - * - * then we must add GC_THINGS_SIZE to the nominal flags pointer to jump over - * all the thing pages that split the flags into two discontiguous spans. - * - * (If we need to implement card-marking for an incremental GC write barrier, - * we can use the low byte of the pi->split pointer as the card-mark, for an - * extremely efficient write barrier: when mutating an object obj, just store - * a 1 byte at (uint8 *) ((jsuword)obj & ~1023) for little-endian platforms. - * When finding flags, we'll of course have to mask split with ~255, but it is - * guaranteed to be 1024-byte aligned, so no information is lost by overlaying - * the card-mark byte on split's low byte.) - */ -#define GC_PAGE_SHIFT 10 -#define GC_PAGE_MASK ((jsuword) JS_BITMASK(GC_PAGE_SHIFT)) -#define GC_PAGE_SIZE JS_BIT(GC_PAGE_SHIFT) - -typedef struct JSGCPageInfo { - uint8 *split; - uint8 *flags; -} JSGCPageInfo; - -#define FIRST_THING_PAGE(a) (((a)->base + GC_FLAGS_SIZE) & ~GC_PAGE_MASK) - -static JSGCThing * -gc_new_arena(JSArenaPool *pool) -{ - uint8 *flagp, *split, *pagep, *limit; - JSArena *a; - JSGCThing *thing; - JSGCPageInfo *pi; - - /* Use JS_ArenaAllocate to grab another 9K-net-size hunk of space. */ - flagp = (uint8 *) JS_ArenaAllocate(pool, GC_ARENA_SIZE); - if (!flagp) - return NULL; - a = pool->current; - - /* Reset a->avail to start at the flags split, aka the first thing page. */ - a->avail = FIRST_THING_PAGE(a); - split = pagep = (uint8 *) a->avail; - a->avail += sizeof(JSGCPageInfo); - thing = (JSGCThing *) a->avail; - a->avail += sizeof(JSGCThing); - - /* Initialize the JSGCPageInfo records at the start of every thing page. */ - limit = pagep + GC_THINGS_SIZE; - do { - pi = (JSGCPageInfo *) pagep; - pi->split = split; - pi->flags = flagp; - flagp += GC_PAGE_SIZE >> (GC_THINGS_SHIFT - GC_PAGE_SHIFT); - pagep += GC_PAGE_SIZE; - } while (pagep < limit); - return thing; -} - -uint8 * -js_GetGCThingFlags(void *thing) -{ - JSGCPageInfo *pi; - uint8 *flagp; - - pi = (JSGCPageInfo *) ((jsuword)thing & ~GC_PAGE_MASK); - flagp = pi->flags + ((jsuword)thing & GC_PAGE_MASK) / sizeof(JSGCThing); - if (flagp >= pi->split) - flagp += GC_THINGS_SIZE; - return flagp; -} - -JSBool -js_IsAboutToBeFinalized(JSContext *cx, void *thing) -{ - uint8 flags = *js_GetGCThingFlags(thing); - - return !(flags & (GCF_MARK | GCF_LOCKMASK | GCF_FINAL)); -} - -typedef void (*GCFinalizeOp)(JSContext *cx, JSGCThing *thing); - -static GCFinalizeOp gc_finalizers[GCX_NTYPES]; - -intN -js_ChangeExternalStringFinalizer(JSStringFinalizeOp oldop, - JSStringFinalizeOp newop) -{ - uintN i; - - for (i = GCX_EXTERNAL_STRING; i < GCX_NTYPES; i++) { - if (gc_finalizers[i] == (GCFinalizeOp) oldop) { - gc_finalizers[i] = (GCFinalizeOp) newop; - return (intN) i; - } - } - return -1; -} - -#ifdef JS_GCMETER -#define METER(x) x -#else -#define METER(x) /* nothing */ -#endif - -/* Initial size of the gcRootsHash table (SWAG, small enough to amortize). */ -#define GC_ROOTS_SIZE 256 -#define GC_FINALIZE_LEN 1024 - -JSBool -js_InitGC(JSRuntime *rt, uint32 maxbytes) -{ - JS_ASSERT(sizeof(JSGCThing) == sizeof(JSGCPageInfo)); - JS_ASSERT(sizeof(JSGCThing) >= sizeof(JSObject)); - JS_ASSERT(sizeof(JSGCThing) >= sizeof(JSString)); - JS_ASSERT(sizeof(JSGCThing) >= sizeof(jsdouble)); - JS_ASSERT(GC_FLAGS_SIZE >= GC_PAGE_SIZE); - JS_ASSERT(sizeof(JSStackHeader) >= 2 * sizeof(jsval)); - - if (!gc_finalizers[GCX_OBJECT]) { - gc_finalizers[GCX_OBJECT] = (GCFinalizeOp)js_FinalizeObject; - gc_finalizers[GCX_STRING] = (GCFinalizeOp)js_FinalizeString; -#ifdef DEBUG - gc_finalizers[GCX_DOUBLE] = (GCFinalizeOp)js_FinalizeDouble; -#endif - gc_finalizers[GCX_MUTABLE_STRING] = (GCFinalizeOp)js_FinalizeString; - } - - JS_InitArenaPool(&rt->gcArenaPool, "gc-arena", GC_ARENA_SIZE, - sizeof(JSGCThing)); - if (!JS_DHashTableInit(&rt->gcRootsHash, JS_DHashGetStubOps(), NULL, - sizeof(JSGCRootHashEntry), GC_ROOTS_SIZE)) { - rt->gcRootsHash.ops = NULL; - return JS_FALSE; - } - rt->gcLocksHash = NULL; /* create lazily */ - rt->gcMaxBytes = maxbytes; - return JS_TRUE; -} - -#ifdef JS_GCMETER -void -js_DumpGCStats(JSRuntime *rt, FILE *fp) -{ - fprintf(fp, "\nGC allocation statistics:\n"); - fprintf(fp, " bytes currently allocated: %lu\n", rt->gcBytes); - fprintf(fp, " alloc attempts: %lu\n", rt->gcStats.alloc); - fprintf(fp, " GC freelist length: %lu\n", rt->gcStats.freelen); - fprintf(fp, " recycles through GC freelist: %lu\n", rt->gcStats.recycle); - fprintf(fp, "alloc retries after running GC: %lu\n", rt->gcStats.retry); - fprintf(fp, " allocation failures: %lu\n", rt->gcStats.fail); - fprintf(fp, " valid lock calls: %lu\n", rt->gcStats.lock); - fprintf(fp, " valid unlock calls: %lu\n", rt->gcStats.unlock); - fprintf(fp, " locks that hit stuck counts: %lu\n", rt->gcStats.stuck); - fprintf(fp, " unlocks that saw stuck counts: %lu\n", rt->gcStats.unstuck); - fprintf(fp, " mark recursion depth: %lu\n", rt->gcStats.depth); - fprintf(fp, " maximum mark recursion depth: %lu\n", rt->gcStats.maxdepth); - fprintf(fp, " maximum GC nesting level: %lu\n", rt->gcStats.maxlevel); - fprintf(fp, " potentially useful GC calls: %lu\n", rt->gcStats.poke); - fprintf(fp, " useless GC calls: %lu\n", rt->gcStats.nopoke); - fprintf(fp, " thing arenas freed so far: %lu\n", rt->gcStats.afree); - fprintf(fp, " extra stack segments scanned: %lu\n", rt->gcStats.stackseg); - fprintf(fp, " stack segment slots scanned: %lu\n", rt->gcStats.segslots); -#ifdef JS_ARENAMETER - JS_DumpArenaStats(fp); -#endif -} -#endif - -#ifdef DEBUG -JS_STATIC_DLL_CALLBACK(JSDHashOperator) -js_root_printer(JSDHashTable *table, JSDHashEntryHdr *hdr, uint32 i, void *arg) -{ - uint32 *leakedroots = (uint32 *)arg; - JSGCRootHashEntry *rhe = (JSGCRootHashEntry *)hdr; - - (*leakedroots)++; - fprintf(stderr, - "JS engine warning: leaking GC root \'%s\' at %p\n", - rhe->name ? (char *)rhe->name : "", rhe->root); - - return JS_DHASH_NEXT; -} -#endif - -void -js_FinishGC(JSRuntime *rt) -{ -#ifdef JS_ARENAMETER - JS_DumpArenaStats(stdout); -#endif -#ifdef JS_GCMETER - js_DumpGCStats(rt, stdout); -#endif - JS_FinishArenaPool(&rt->gcArenaPool); - JS_ArenaFinish(); - - if (rt->gcRootsHash.ops) { -#ifdef DEBUG - uint32 leakedroots = 0; - - /* Warn (but don't assert) debug builds of any remaining roots. */ - JS_DHashTableEnumerate(&rt->gcRootsHash, js_root_printer, - &leakedroots); - if (leakedroots > 0) { - if (leakedroots == 1) { - fprintf(stderr, -"JS engine warning: 1 GC root remains after destroying the JSRuntime.\n" -" This root may point to freed memory. Objects reachable\n" -" through it have not been finalized.\n"); - } else { - fprintf(stderr, -"JS engine warning: %lu GC roots remain after destroying the JSRuntime.\n" -" These roots may point to freed memory. Objects reachable\n" -" through them have not been finalized.\n", - (unsigned long) leakedroots); - } - } -#endif - - JS_DHashTableFinish(&rt->gcRootsHash); - rt->gcRootsHash.ops = NULL; - } - if (rt->gcLocksHash) { - JS_DHashTableDestroy(rt->gcLocksHash); - rt->gcLocksHash = NULL; - } - rt->gcFreeList = NULL; -} - -JSBool -js_AddRoot(JSContext *cx, void *rp, const char *name) -{ - JSBool ok = js_AddRootRT(cx->runtime, rp, name); - if (!ok) - JS_ReportOutOfMemory(cx); - return ok; -} - -JSBool -js_AddRootRT(JSRuntime *rt, void *rp, const char *name) -{ - JSBool ok; - JSGCRootHashEntry *rhe; - - /* - * Due to the long-standing, but now removed, use of rt->gcLock across the - * bulk of js_GC, API users have come to depend on JS_AddRoot etc. locking - * properly with a racing GC, without calling JS_AddRoot from a request. - * We have to preserve API compatibility here, now that we avoid holding - * rt->gcLock across the mark phase (including the root hashtable mark). - * - * If the GC is running and we're called on another thread, wait for this - * GC activation to finish. We can safely wait here (in the case where we - * are called within a request on another thread's context) without fear - * of deadlock because the GC doesn't set rt->gcRunning until after it has - * waited for all active requests to end. - */ - JS_LOCK_GC(rt); -#ifdef JS_THREADSAFE - JS_ASSERT(!rt->gcRunning || rt->gcLevel > 0); - if (rt->gcRunning && rt->gcThread != js_CurrentThreadId()) { - do { - JS_AWAIT_GC_DONE(rt); - } while (rt->gcLevel > 0); - } -#endif - rhe = (JSGCRootHashEntry *) JS_DHashTableOperate(&rt->gcRootsHash, rp, - JS_DHASH_ADD); - if (rhe) { - rhe->root = rp; - rhe->name = name; - ok = JS_TRUE; - } else { - ok = JS_FALSE; - } - JS_UNLOCK_GC(rt); - return ok; -} - -JSBool -js_RemoveRoot(JSRuntime *rt, void *rp) -{ - /* - * Due to the JS_RemoveRootRT API, we may be called outside of a request. - * Same synchronization drill as above in js_AddRoot. - */ - JS_LOCK_GC(rt); -#ifdef JS_THREADSAFE - JS_ASSERT(!rt->gcRunning || rt->gcLevel > 0); - if (rt->gcRunning && rt->gcThread != js_CurrentThreadId()) { - do { - JS_AWAIT_GC_DONE(rt); - } while (rt->gcLevel > 0); - } -#endif - (void) JS_DHashTableOperate(&rt->gcRootsHash, rp, JS_DHASH_REMOVE); - rt->gcPoke = JS_TRUE; - JS_UNLOCK_GC(rt); - return JS_TRUE; -} - -void * -js_AllocGCThing(JSContext *cx, uintN flags) -{ - JSBool tried_gc; - JSRuntime *rt; - JSGCThing *thing; - uint8 *flagp; - -#ifdef TOO_MUCH_GC - js_GC(cx, GC_KEEP_ATOMS); - tried_gc = JS_TRUE; -#else - tried_gc = JS_FALSE; -#endif - - rt = cx->runtime; - JS_LOCK_GC(rt); - JS_ASSERT(!rt->gcRunning); - if (rt->gcRunning) { - METER(rt->gcStats.finalfail++); - JS_UNLOCK_GC(rt); - return NULL; - } - METER(rt->gcStats.alloc++); -retry: - thing = rt->gcFreeList; - if (thing) { - rt->gcFreeList = thing->next; - flagp = thing->flagp; - METER(rt->gcStats.freelen--); - METER(rt->gcStats.recycle++); - } else { - if (rt->gcBytes < rt->gcMaxBytes && - (tried_gc || rt->gcMallocBytes < rt->gcMaxBytes)) - { - /* - * Inline form of JS_ARENA_ALLOCATE adapted to truncate the current - * arena's limit to a GC_PAGE_SIZE boundary, and to skip over every - * GC_PAGE_SIZE-byte-aligned thing (which is actually not a thing, - * it's a JSGCPageInfo record). - */ - JSArenaPool *pool = &rt->gcArenaPool; - JSArena *a = pool->current; - size_t nb = sizeof(JSGCThing); - jsuword p = a->avail; - jsuword q = p + nb; - - if (q > (a->limit & ~GC_PAGE_MASK)) { - thing = gc_new_arena(pool); - } else { - if ((p & GC_PAGE_MASK) == 0) { - /* Beware, p points to a JSGCPageInfo record! */ - p = q; - q += nb; - JS_ArenaCountAllocation(pool, nb); - } - a->avail = q; - thing = (JSGCThing *)p; - } - JS_ArenaCountAllocation(pool, nb); - } - - /* - * Consider doing a "last ditch" GC if thing couldn't be allocated. - * - * Keep rt->gcLock across the call into js_GC so we don't starve and - * lose to racing threads who deplete the heap just after js_GC has - * replenished it (or has synchronized with a racing GC that collected - * a bunch of garbage). This unfair scheduling can happen on certain - * operating systems. For the gory details, see Mozilla bug 162779 - * (http://bugzilla.mozilla.org/show_bug.cgi?id=162779). - */ - if (!thing) { - if (!tried_gc) { - rt->gcPoke = JS_TRUE; - js_GC(cx, GC_KEEP_ATOMS | GC_ALREADY_LOCKED); - tried_gc = JS_TRUE; - METER(rt->gcStats.retry++); - goto retry; - } - METER(rt->gcStats.fail++); - JS_UNLOCK_GC(rt); - JS_ReportOutOfMemory(cx); - return NULL; - } - - /* Find the flags pointer given thing's address. */ - flagp = js_GetGCThingFlags(thing); - } - *flagp = (uint8)flags; - rt->gcBytes += sizeof(JSGCThing) + sizeof(uint8); - cx->newborn[flags & GCF_TYPEMASK] = thing; - - /* - * Clear thing before unlocking in case a GC run is about to scan it, - * finding it via cx->newborn[]. - */ - thing->next = NULL; - thing->flagp = NULL; - JS_UNLOCK_GC(rt); - return thing; -} - -JSBool -js_LockGCThing(JSContext *cx, void *thing) -{ - JSBool ok = js_LockGCThingRT(cx->runtime, thing); - if (!ok) - JS_ReportOutOfMemory(cx); - return ok; -} - -JSBool -js_LockGCThingRT(JSRuntime *rt, void *thing) -{ - uint8 *flagp, flags, lockbits; - JSBool ok; - JSGCLockHashEntry *lhe; - - if (!thing) - return JS_TRUE; - flagp = js_GetGCThingFlags(thing); - flags = *flagp; - - ok = JS_FALSE; - JS_LOCK_GC(rt); - lockbits = (flags & GCF_LOCKMASK); - - if (lockbits != GCF_LOCKMASK) { - if ((flags & GCF_TYPEMASK) == GCX_OBJECT) { - /* Objects may require "deep locking", i.e., rooting by value. */ - if (lockbits == 0) { - if (!rt->gcLocksHash) { - rt->gcLocksHash = - JS_NewDHashTable(JS_DHashGetStubOps(), NULL, - sizeof(JSGCLockHashEntry), - GC_ROOTS_SIZE); - if (!rt->gcLocksHash) - goto error; - } else { -#ifdef DEBUG - JSDHashEntryHdr *hdr = - JS_DHashTableOperate(rt->gcLocksHash, thing, - JS_DHASH_LOOKUP); - JS_ASSERT(JS_DHASH_ENTRY_IS_FREE(hdr)); -#endif - } - lhe = (JSGCLockHashEntry *) - JS_DHashTableOperate(rt->gcLocksHash, thing, JS_DHASH_ADD); - if (!lhe) - goto error; - lhe->thing = thing; - lhe->count = 1; - *flagp = (uint8)(flags + GCF_LOCK); - } else { - JS_ASSERT(lockbits == GCF_LOCK); - lhe = (JSGCLockHashEntry *) - JS_DHashTableOperate(rt->gcLocksHash, thing, - JS_DHASH_LOOKUP); - JS_ASSERT(JS_DHASH_ENTRY_IS_BUSY(&lhe->hdr)); - if (JS_DHASH_ENTRY_IS_BUSY(&lhe->hdr)) { - JS_ASSERT(lhe->count >= 1); - lhe->count++; - } - } - } else { - *flagp = (uint8)(flags + GCF_LOCK); - } - } else { - METER(rt->gcStats.stuck++); - } - - METER(rt->gcStats.lock++); - ok = JS_TRUE; -error: - JS_UNLOCK_GC(rt); - return ok; -} - -JSBool -js_UnlockGCThingRT(JSRuntime *rt, void *thing) -{ - uint8 *flagp, flags, lockbits; - JSGCLockHashEntry *lhe; - - if (!thing) - return JS_TRUE; - flagp = js_GetGCThingFlags(thing); - flags = *flagp; - - JS_LOCK_GC(rt); - lockbits = (flags & GCF_LOCKMASK); - - if (lockbits != GCF_LOCKMASK) { - if ((flags & GCF_TYPEMASK) == GCX_OBJECT) { - /* Defend against a call on an unlocked object. */ - if (lockbits != 0) { - JS_ASSERT(lockbits == GCF_LOCK); - lhe = (JSGCLockHashEntry *) - JS_DHashTableOperate(rt->gcLocksHash, thing, - JS_DHASH_LOOKUP); - JS_ASSERT(JS_DHASH_ENTRY_IS_BUSY(&lhe->hdr)); - if (JS_DHASH_ENTRY_IS_BUSY(&lhe->hdr) && - --lhe->count == 0) { - (void) JS_DHashTableOperate(rt->gcLocksHash, thing, - JS_DHASH_REMOVE); - *flagp = (uint8)(flags & ~GCF_LOCKMASK); - } - } - } else { - *flagp = (uint8)(flags - GCF_LOCK); - } - } else { - METER(rt->gcStats.unstuck++); - } - - rt->gcPoke = JS_TRUE; - METER(rt->gcStats.unlock++); - JS_UNLOCK_GC(rt); - return JS_TRUE; -} - -#ifdef GC_MARK_DEBUG - -#include <stdio.h> -#include <stdlib.h> -#include "jsprf.h" - -JS_FRIEND_DATA(FILE *) js_DumpGCHeap; -JS_EXPORT_DATA(void *) js_LiveThingToFind; - -#ifdef HAVE_XPCONNECT -#include "dump_xpc.h" -#endif - -static const char * -gc_object_class_name(void* thing) -{ - uint8 *flagp = js_GetGCThingFlags(thing); - const char *className = ""; - static char depbuf[32]; - - switch (*flagp & GCF_TYPEMASK) { - case GCX_OBJECT: { - JSObject *obj = (JSObject *)thing; - JSClass *clasp = JSVAL_TO_PRIVATE(obj->slots[JSSLOT_CLASS]); - className = clasp->name; -#ifdef HAVE_XPCONNECT - if (clasp->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) { - jsval privateValue = obj->slots[JSSLOT_PRIVATE]; - - JS_ASSERT(clasp->flags & JSCLASS_HAS_PRIVATE); - if (!JSVAL_IS_VOID(privateValue)) { - void *privateThing = JSVAL_TO_PRIVATE(privateValue); - const char *xpcClassName = GetXPCObjectClassName(privateThing); - - if (xpcClassName) - className = xpcClassName; - } - } -#endif - break; - } - - case GCX_STRING: - case GCX_MUTABLE_STRING: { - JSString *str = (JSString *)thing; - if (JSSTRING_IS_DEPENDENT(str)) { - JS_snprintf(depbuf, sizeof depbuf, "start:%u, length:%u", - JSSTRDEP_START(str), JSSTRDEP_LENGTH(str)); - className = depbuf; - } else { - className = "string"; - } - break; - } - - case GCX_DOUBLE: - className = "double"; - break; - } - - return className; -} - -static void -gc_dump_thing(JSGCThing *thing, uint8 flags, GCMarkNode *prev, FILE *fp) -{ - GCMarkNode *next = NULL; - char *path = NULL; - - while (prev) { - next = prev; - prev = prev->prev; - } - while (next) { - path = JS_sprintf_append(path, "%s(%s).", - next->name, - gc_object_class_name(next->thing)); - next = next->next; - } - if (!path) - return; - - fprintf(fp, "%08lx ", (long)thing); - switch (flags & GCF_TYPEMASK) { - case GCX_OBJECT: - { - JSObject *obj = (JSObject *)thing; - jsval privateValue = obj->slots[JSSLOT_PRIVATE]; - void *privateThing = JSVAL_IS_VOID(privateValue) - ? NULL - : JSVAL_TO_PRIVATE(privateValue); - const char *className = gc_object_class_name(thing); - fprintf(fp, "object %8p %s", privateThing, className); - break; - } - case GCX_DOUBLE: - fprintf(fp, "double %g", *(jsdouble *)thing); - break; - default: - fprintf(fp, "string %s", JS_GetStringBytes((JSString *)thing)); - break; - } - fprintf(fp, " via %s\n", path); - free(path); -} - -#endif /* !GC_MARK_DEBUG */ - -static void -gc_mark_atom_key_thing(void *thing, void *arg) -{ - JSContext *cx = (JSContext *) arg; - - GC_MARK(cx, thing, "atom", NULL); -} - -void -js_MarkAtom(JSContext *cx, JSAtom *atom, void *arg) -{ - jsval key; - - if (atom->flags & ATOM_MARK) - return; - atom->flags |= ATOM_MARK; - key = ATOM_KEY(atom); - if (JSVAL_IS_GCTHING(key)) { -#ifdef GC_MARK_DEBUG - char name[32]; - - if (JSVAL_IS_STRING(key)) { - JS_snprintf(name, sizeof name, "'%s'", - JS_GetStringBytes(JSVAL_TO_STRING(key))); - } else { - JS_snprintf(name, sizeof name, "<%x>", key); - } -#endif - GC_MARK(cx, JSVAL_TO_GCTHING(key), name, arg); - } -} - -void -js_MarkGCThing(JSContext *cx, void *thing, void *arg) -{ - uint8 flags, *flagp; - JSRuntime *rt; - JSObject *obj; - uint32 nslots; - jsval v, *vp, *end; - JSString *str; -#ifdef GC_MARK_DEBUG - JSScope *scope; - JSScopeProperty *sprop; -#endif - - if (!thing) - return; - - flagp = js_GetGCThingFlags(thing); - flags = *flagp; - JS_ASSERT(flags != GCF_FINAL); -#ifdef GC_MARK_DEBUG - if (js_LiveThingToFind == thing) - gc_dump_thing(thing, flags, arg, stderr); -#endif - - if (flags & GCF_MARK) - return; - - *flagp |= GCF_MARK; - rt = cx->runtime; - METER(if (++rt->gcStats.depth > rt->gcStats.maxdepth) - rt->gcStats.maxdepth = rt->gcStats.depth); - -#ifdef GC_MARK_DEBUG - if (js_DumpGCHeap) - gc_dump_thing(thing, flags, arg, js_DumpGCHeap); -#endif - - switch (flags & GCF_TYPEMASK) { - case GCX_OBJECT: - obj = (JSObject *) thing; - vp = obj->slots; - if (!vp) { - /* If obj->slots is null, obj must be a newborn. */ - JS_ASSERT(!obj->map); - goto out; - } - nslots = (obj->map->ops->mark) - ? obj->map->ops->mark(cx, obj, arg) - : JS_MIN(obj->map->freeslot, obj->map->nslots); -#ifdef GC_MARK_DEBUG - scope = OBJ_IS_NATIVE(obj) ? OBJ_SCOPE(obj) : NULL; -#endif - for (end = vp + nslots; vp < end; vp++) { - v = *vp; - if (JSVAL_IS_GCTHING(v)) { -#ifdef GC_MARK_DEBUG - char name[32]; - - if (scope) { - uint32 slot; - jsval nval; - - slot = vp - obj->slots; - for (sprop = SCOPE_LAST_PROP(scope); ; - sprop = sprop->parent) { - if (!sprop) { - switch (slot) { - case JSSLOT_PROTO: - strcpy(name, "__proto__"); - break; - case JSSLOT_PARENT: - strcpy(name, "__parent__"); - break; - case JSSLOT_PRIVATE: - strcpy(name, "__private__"); - break; - default: - JS_snprintf(name, sizeof name, - "**UNKNOWN SLOT %ld**", - (long)slot); - break; - } - break; - } - if (sprop->slot == slot) { - nval = ID_TO_VALUE(sprop->id); - if (JSVAL_IS_INT(nval)) { - JS_snprintf(name, sizeof name, "%ld", - (long)JSVAL_TO_INT(nval)); - } else if (JSVAL_IS_STRING(nval)) { - JS_snprintf(name, sizeof name, "%s", - JS_GetStringBytes(JSVAL_TO_STRING(nval))); - } else { - strcpy(name, "**FINALIZED ATOM KEY**"); - } - break; - } - } - } else { - strcpy(name, "**UNKNOWN OBJECT MAP ENTRY**"); - } -#endif - GC_MARK(cx, JSVAL_TO_GCTHING(v), name, arg); - } - } - break; - -#ifdef DEBUG - case GCX_STRING: - str = (JSString *)thing; - JS_ASSERT(!JSSTRING_IS_DEPENDENT(str)); - break; -#endif - - case GCX_MUTABLE_STRING: - str = (JSString *)thing; - if (JSSTRING_IS_DEPENDENT(str)) - GC_MARK(cx, JSSTRDEP_BASE(str), "base", arg); - break; - } - -out: - METER(rt->gcStats.depth--); -} - -JS_STATIC_DLL_CALLBACK(JSDHashOperator) -gc_root_marker(JSDHashTable *table, JSDHashEntryHdr *hdr, uint32 num, void *arg) -{ - JSGCRootHashEntry *rhe = (JSGCRootHashEntry *)hdr; - jsval *rp = (jsval *)rhe->root; - jsval v = *rp; - - /* Ignore null object and scalar values. */ - if (!JSVAL_IS_NULL(v) && JSVAL_IS_GCTHING(v)) { - JSContext *cx = (JSContext *)arg; -#ifdef DEBUG - JSArena *a; - jsuword firstpage; - JSBool root_points_to_gcArenaPool = JS_FALSE; - void *thing = JSVAL_TO_GCTHING(v); - - for (a = cx->runtime->gcArenaPool.first.next; a; a = a->next) { - firstpage = FIRST_THING_PAGE(a); - if (JS_UPTRDIFF(thing, firstpage) < a->avail - firstpage) { - root_points_to_gcArenaPool = JS_TRUE; - break; - } - } - if (!root_points_to_gcArenaPool && rhe->name) { - fprintf(stderr, -"JS API usage error: the address passed to JS_AddNamedRoot currently holds an\n" -"invalid jsval. This is usually caused by a missing call to JS_RemoveRoot.\n" -"The root's name is \"%s\".\n", - rhe->name); - } - JS_ASSERT(root_points_to_gcArenaPool); -#endif - - GC_MARK(cx, JSVAL_TO_GCTHING(v), rhe->name ? rhe->name : "root", NULL); - } - return JS_DHASH_NEXT; -} - -JS_STATIC_DLL_CALLBACK(JSDHashOperator) -gc_lock_marker(JSDHashTable *table, JSDHashEntryHdr *hdr, uint32 num, void *arg) -{ - JSGCLockHashEntry *lhe = (JSGCLockHashEntry *)hdr; - void *thing = (void *)lhe->thing; - JSContext *cx = (JSContext *)arg; - - GC_MARK(cx, thing, "locked object", NULL); - return JS_DHASH_NEXT; -} - -void -js_ForceGC(JSContext *cx, uintN gcflags) -{ - uintN i; - - for (i = 0; i < GCX_NTYPES; i++) - cx->newborn[i] = NULL; - cx->lastAtom = NULL; - cx->runtime->gcPoke = JS_TRUE; - js_GC(cx, gcflags); - JS_ArenaFinish(); -} - -#define GC_MARK_JSVALS(cx, len, vec, name) \ - JS_BEGIN_MACRO \ - jsval _v, *_vp, *_end; \ - \ - for (_vp = vec, _end = _vp + len; _vp < _end; _vp++) { \ - _v = *_vp; \ - if (JSVAL_IS_GCTHING(_v)) \ - GC_MARK(cx, JSVAL_TO_GCTHING(_v), name, NULL); \ - } \ - JS_END_MACRO - -void -js_GC(JSContext *cx, uintN gcflags) -{ - JSRuntime *rt; - JSContext *iter, *acx; - JSStackFrame *fp, *chain; - uintN i, depth, nslots, type; - JSStackHeader *sh; - JSArena *a, **ap; - uint8 flags, *flagp, *split; - JSGCThing *thing, *limit, **flp, **oflp; - GCFinalizeOp finalizer; - JSBool all_clear; -#ifdef JS_THREADSAFE - jsword currentThread; - uint32 requestDebit; -#endif - - rt = cx->runtime; -#ifdef JS_THREADSAFE - /* Avoid deadlock. */ - JS_ASSERT(!JS_IS_RUNTIME_LOCKED(rt)); -#endif - - /* - * Don't collect garbage if the runtime isn't up, and cx is not the last - * context in the runtime. The last context must force a GC, and nothing - * should suppress that final collection or there may be shutdown leaks, - * or runtime bloat until the next context is created. - */ - if (rt->state != JSRTS_UP && !(gcflags & GC_LAST_CONTEXT)) - return; - - /* - * Let the API user decide to defer a GC if it wants to (unless this - * is the last context). Invoke the callback regardless. - */ - if (rt->gcCallback) { - if (!rt->gcCallback(cx, JSGC_BEGIN) && !(gcflags & GC_LAST_CONTEXT)) - return; - } - - /* Lock out other GC allocator and collector invocations. */ - if (!(gcflags & GC_ALREADY_LOCKED)) - JS_LOCK_GC(rt); - - /* Do nothing if no assignment has executed since the last GC. */ - if (!rt->gcPoke) { - METER(rt->gcStats.nopoke++); - if (!(gcflags & GC_ALREADY_LOCKED)) - JS_UNLOCK_GC(rt); - return; - } - METER(rt->gcStats.poke++); - -#ifdef JS_THREADSAFE - /* Bump gcLevel and return rather than nest on this thread. */ - currentThread = js_CurrentThreadId(); - if (rt->gcThread == currentThread) { - JS_ASSERT(rt->gcLevel > 0); - rt->gcLevel++; - METER(if (rt->gcLevel > rt->gcStats.maxlevel) - rt->gcStats.maxlevel = rt->gcLevel); - if (!(gcflags & GC_ALREADY_LOCKED)) - JS_UNLOCK_GC(rt); - return; - } - - /* - * If we're in one or more requests (possibly on more than one context) - * running on the current thread, indicate, temporarily, that all these - * requests are inactive. NB: if cx->thread is 0, then cx is not using - * the request model, and does not contribute to rt->requestCount. - */ - requestDebit = 0; - if (cx->thread) { - /* - * Check all contexts for any with the same thread-id. XXX should we - * keep a sub-list of contexts having the same id? - */ - iter = NULL; - while ((acx = js_ContextIterator(rt, JS_FALSE, &iter)) != NULL) { - if (acx->thread == cx->thread && acx->requestDepth) - requestDebit++; - } - } else { - /* - * We assert, but check anyway, in case someone is misusing the API. - * Avoiding the loop over all of rt's contexts is a win in the event - * that the GC runs only on request-less contexts with 0 thread-ids, - * in a special thread such as might be used by the UI/DOM/Layout - * "mozilla" or "main" thread in Mozilla-the-browser. - */ - JS_ASSERT(cx->requestDepth == 0); - if (cx->requestDepth) - requestDebit = 1; - } - if (requestDebit) { - JS_ASSERT(requestDebit <= rt->requestCount); - rt->requestCount -= requestDebit; - if (rt->requestCount == 0) - JS_NOTIFY_REQUEST_DONE(rt); - } - - /* If another thread is already in GC, don't attempt GC; wait instead. */ - if (rt->gcLevel > 0) { - /* Bump gcLevel to restart the current GC, so it finds new garbage. */ - rt->gcLevel++; - METER(if (rt->gcLevel > rt->gcStats.maxlevel) - rt->gcStats.maxlevel = rt->gcLevel); - - /* Wait for the other thread to finish, then resume our request. */ - while (rt->gcLevel > 0) - JS_AWAIT_GC_DONE(rt); - if (requestDebit) - rt->requestCount += requestDebit; - if (!(gcflags & GC_ALREADY_LOCKED)) - JS_UNLOCK_GC(rt); - return; - } - - /* No other thread is in GC, so indicate that we're now in GC. */ - rt->gcLevel = 1; - rt->gcThread = currentThread; - - /* Wait for all other requests to finish. */ - while (rt->requestCount > 0) - JS_AWAIT_REQUEST_DONE(rt); - -#else /* !JS_THREADSAFE */ - - /* Bump gcLevel and return rather than nest; the outer gc will restart. */ - rt->gcLevel++; - METER(if (rt->gcLevel > rt->gcStats.maxlevel) - rt->gcStats.maxlevel = rt->gcLevel); - if (rt->gcLevel > 1) - return; - -#endif /* !JS_THREADSAFE */ - - /* - * Set rt->gcRunning here within the GC lock, and after waiting for any - * active requests to end, so that new requests that try to JS_AddRoot, - * JS_RemoveRoot, or JS_RemoveRootRT block in JS_BeginRequest waiting for - * rt->gcLevel to drop to zero, while request-less calls to the *Root* - * APIs block in js_AddRoot or js_RemoveRoot (see above in this file), - * waiting for GC to finish. - */ - rt->gcRunning = JS_TRUE; - JS_UNLOCK_GC(rt); - - /* If a suspended compile is running on another context, keep atoms. */ - if (rt->gcKeepAtoms) - gcflags |= GC_KEEP_ATOMS; - - /* Reset malloc counter. */ - rt->gcMallocBytes = 0; - - /* Drop atoms held by the property cache, and clear property weak links. */ - js_DisablePropertyCache(cx); - js_FlushPropertyCache(cx); -#ifdef DEBUG_brendan - { extern void js_DumpScopeMeters(JSRuntime *rt); - js_DumpScopeMeters(rt); - } -#endif - -restart: - rt->gcNumber++; - - /* - * Mark phase. - */ - JS_DHashTableEnumerate(&rt->gcRootsHash, gc_root_marker, cx); - if (rt->gcLocksHash) - JS_DHashTableEnumerate(rt->gcLocksHash, gc_lock_marker, cx); - js_MarkAtomState(&rt->atomState, gcflags, gc_mark_atom_key_thing, cx); - js_MarkWatchPoints(rt); - iter = NULL; - while ((acx = js_ContextIterator(rt, JS_TRUE, &iter)) != NULL) { - /* - * Iterate frame chain and dormant chains. Temporarily tack current - * frame onto the head of the dormant list to ease iteration. - * - * (NB: see comment on this whole "dormant" thing in js_Execute.) - */ - chain = acx->fp; - if (chain) { - JS_ASSERT(!chain->dormantNext); - chain->dormantNext = acx->dormantFrameChain; - } else { - chain = acx->dormantFrameChain; - } - - for (fp = chain; fp; fp = chain = chain->dormantNext) { - do { - if (fp->callobj) - GC_MARK(cx, fp->callobj, "call object", NULL); - if (fp->argsobj) - GC_MARK(cx, fp->argsobj, "arguments object", NULL); - if (fp->varobj) - GC_MARK(cx, fp->varobj, "variables object", NULL); - if (fp->script) { - js_MarkScript(cx, fp->script, NULL); - if (fp->spbase) { - /* - * Don't mark what has not been pushed yet, or what - * has been popped already. - */ - depth = fp->script->depth; - nslots = (JS_UPTRDIFF(fp->sp, fp->spbase) - < depth * sizeof(jsval)) - ? (uintN)(fp->sp - fp->spbase) - : depth; - GC_MARK_JSVALS(cx, nslots, fp->spbase, "operand"); - } - } - GC_MARK(cx, fp->thisp, "this", NULL); - if (fp->argv) { - nslots = fp->argc; - if (fp->fun && fp->fun->nargs > nslots) - nslots = fp->fun->nargs; - GC_MARK_JSVALS(cx, nslots, fp->argv, "arg"); - } - if (JSVAL_IS_GCTHING(fp->rval)) - GC_MARK(cx, JSVAL_TO_GCTHING(fp->rval), "rval", NULL); - if (fp->vars) - GC_MARK_JSVALS(cx, fp->nvars, fp->vars, "var"); - GC_MARK(cx, fp->scopeChain, "scope chain", NULL); - if (fp->sharpArray) - GC_MARK(cx, fp->sharpArray, "sharp array", NULL); - - if (fp->objAtomMap) { - JSAtom **vector, *atom; - - nslots = fp->objAtomMap->length; - vector = fp->objAtomMap->vector; - for (i = 0; i < nslots; i++) { - atom = vector[i]; - if (atom) - GC_MARK_ATOM(cx, atom, NULL); - } - } - } while ((fp = fp->down) != NULL); - } - - /* Cleanup temporary "dormant" linkage. */ - if (acx->fp) - acx->fp->dormantNext = NULL; - - /* Mark other roots-by-definition in acx. */ - GC_MARK(cx, acx->globalObject, "global object", NULL); - GC_MARK(cx, acx->newborn[GCX_OBJECT], "newborn object", NULL); - GC_MARK(cx, acx->newborn[GCX_STRING], "newborn string", NULL); - GC_MARK(cx, acx->newborn[GCX_DOUBLE], "newborn double", NULL); - GC_MARK(cx, acx->newborn[GCX_MUTABLE_STRING], "newborn mutable string", - NULL); - for (i = GCX_EXTERNAL_STRING; i < GCX_NTYPES; i++) - GC_MARK(cx, acx->newborn[i], "newborn external string", NULL); - if (acx->lastAtom) - GC_MARK_ATOM(cx, acx->lastAtom, NULL); -#if JS_HAS_EXCEPTIONS - if (acx->throwing && JSVAL_IS_GCTHING(acx->exception)) - GC_MARK(cx, JSVAL_TO_GCTHING(acx->exception), "exception", NULL); -#endif -#if JS_HAS_LVALUE_RETURN - if (acx->rval2set && JSVAL_IS_GCTHING(acx->rval2)) - GC_MARK(cx, JSVAL_TO_GCTHING(acx->rval2), "rval2", NULL); -#endif - - for (sh = acx->stackHeaders; sh; sh = sh->down) { - METER(rt->gcStats.stackseg++); - METER(rt->gcStats.segslots += sh->nslots); - GC_MARK_JSVALS(cx, sh->nslots, JS_STACK_SEGMENT(sh), "stack"); - } - } - - if (rt->gcCallback) - (void) rt->gcCallback(cx, JSGC_MARK_END); - - /* - * Sweep phase. - * Finalize as we sweep, outside of rt->gcLock, but with rt->gcRunning set - * so that any attempt to allocate a GC-thing from a finalizer will fail, - * rather than nest badly and leave the unmarked newborn to be swept. - */ - js_SweepAtomState(&rt->atomState); - js_SweepScopeProperties(rt); - js_SweepScriptFilenames(rt); - for (a = rt->gcArenaPool.first.next; a; a = a->next) { - flagp = (uint8 *) a->base; - split = (uint8 *) FIRST_THING_PAGE(a); - limit = (JSGCThing *) a->avail; - for (thing = (JSGCThing *) split; thing < limit; thing++) { - if (((jsuword)thing & GC_PAGE_MASK) == 0) { - flagp++; - thing++; - } - flags = *flagp; - if (flags & GCF_MARK) { - *flagp &= ~GCF_MARK; - } else if (!(flags & (GCF_LOCKMASK | GCF_FINAL))) { - /* Call the finalizer with GCF_FINAL ORed into flags. */ - type = flags & GCF_TYPEMASK; - finalizer = gc_finalizers[type]; - if (finalizer) { - *flagp = (uint8)(flags | GCF_FINAL); - if (type >= GCX_EXTERNAL_STRING) - js_PurgeDeflatedStringCache((JSString *)thing); - finalizer(cx, thing); - } - - /* Set flags to GCF_FINAL, signifying that thing is free. */ - *flagp = GCF_FINAL; - - JS_ASSERT(rt->gcBytes >= sizeof(JSGCThing) + sizeof(uint8)); - rt->gcBytes -= sizeof(JSGCThing) + sizeof(uint8); - } - if (++flagp == split) - flagp += GC_THINGS_SIZE; - } - } - - /* - * Free phase. - * Free any unused arenas and rebuild the JSGCThing freelist. - */ - ap = &rt->gcArenaPool.first.next; - a = *ap; - if (!a) - goto out; - all_clear = JS_TRUE; - flp = oflp = &rt->gcFreeList; - *flp = NULL; - METER(rt->gcStats.freelen = 0); - - do { - flagp = (uint8 *) a->base; - split = (uint8 *) FIRST_THING_PAGE(a); - limit = (JSGCThing *) a->avail; - for (thing = (JSGCThing *) split; thing < limit; thing++) { - if (((jsuword)thing & GC_PAGE_MASK) == 0) { - flagp++; - thing++; - } - if (*flagp != GCF_FINAL) { - all_clear = JS_FALSE; - } else { - thing->flagp = flagp; - *flp = thing; - flp = &thing->next; - METER(rt->gcStats.freelen++); - } - if (++flagp == split) - flagp += GC_THINGS_SIZE; - } - - if (all_clear) { - JS_ARENA_DESTROY(&rt->gcArenaPool, a, ap); - flp = oflp; - METER(rt->gcStats.afree++); - } else { - ap = &a->next; - all_clear = JS_TRUE; - oflp = flp; - } - } while ((a = *ap) != NULL); - - /* Terminate the new freelist. */ - *flp = NULL; - - if (rt->gcCallback) - (void) rt->gcCallback(cx, JSGC_FINALIZE_END); -#ifdef DEBUG_brendan - { extern void DumpSrcNoteSizeHist(); - DumpSrcNoteSizeHist(); - } -#endif - -out: - JS_LOCK_GC(rt); - if (rt->gcLevel > 1) { - rt->gcLevel = 1; - JS_UNLOCK_GC(rt); - goto restart; - } - js_EnablePropertyCache(cx); - rt->gcLevel = 0; - rt->gcLastBytes = rt->gcBytes; - rt->gcPoke = rt->gcRunning = JS_FALSE; - -#ifdef JS_THREADSAFE - /* If we were invoked during a request, pay back the temporary debit. */ - if (requestDebit) - rt->requestCount += requestDebit; - rt->gcThread = 0; - JS_NOTIFY_GC_DONE(rt); - if (!(gcflags & GC_ALREADY_LOCKED)) - JS_UNLOCK_GC(rt); -#endif - - if (rt->gcCallback) { - if (gcflags & GC_ALREADY_LOCKED) - JS_UNLOCK_GC(rt); - (void) rt->gcCallback(cx, JSGC_END); - if (gcflags & GC_ALREADY_LOCKED) - JS_LOCK_GC(rt); - } -} |