Update to NSPR 4.10.2.

nspr/lib/ds/plarena.c

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 
 /*
  * Lifetime-based fast allocation, inspired by much prior art, including
  * "Fast Allocation and Deallocation of Memory Based on Object Lifetimes"
  * David R. Hanson, Software -- Practice and Experience, Vol. 20(1).
  */
@@ skipping 135 matching lines @@
     char *rp;     /* returned pointer */
 
     PR_ASSERT((nb & pool->mask) == 0);
     
     nb = (PRUword)PL_ARENA_ALIGN(pool, nb); /* force alignment */
 
     /* attempt to allocate from arenas at pool->current */
     {
         a = pool->current;
         do {
-            if ( a->avail +nb <= a->limit )  {
+            if ( nb <= a->limit - a->avail )  {
                 pool->current = a;
                 rp = (char *)a->avail;
                 a->avail += nb;
                 return rp;
             }
         } while( NULL != (a = a->next) );
     }
 
     /* attempt to allocate from arena_freelist */
     {
         PLArena *p; /* previous pointer, for unlinking from freelist */
 
         /* lock the arena_freelist. Make access to the freelist MT-Safe */
         if ( PR_FAILURE == LockArena())
             return(0);
 
         for ( a = arena_freelist, p = NULL; a != NULL ; p = a, a = a->next ) {
-            if ( a->base +nb <= a->limit )  {
+            if ( nb <= a->limit - a->base )  {
                 if ( p == NULL )
                     arena_freelist = a->next;
                 else
                     p->next = a->next;
                 UnlockArena();
                 a->avail = a->base;
                 rp = (char *)a->avail;
                 a->avail += nb;
                 /* the newly allocated arena is linked after pool->current 
                 *  and becomes pool->current */
                 a->next = pool->current->next;
                 pool->current->next = a;
                 pool->current = a;
                 if ( NULL == pool->first.next )
                     pool->first.next = a;
                 return(rp);
             }
         }
         UnlockArena();
     }
 
     /* attempt to allocate from the heap */ 
     {  
         PRUint32 sz = PR_MAX(pool->arenasize, nb);
-        sz += sizeof *a + pool->mask;  /* header and alignment slop */
-        a = (PLArena*)PR_MALLOC(sz);
+        if (PR_UINT32_MAX - sz < sizeof *a + pool->mask) {
+            a = NULL;
+        } else {
+            sz += sizeof *a + pool->mask;  /* header and alignment slop */
+            a = (PLArena*)PR_MALLOC(sz);
+        }
         if ( NULL != a )  {
             a->limit = (PRUword)a + sz;
             a->base = a->avail = (PRUword)PL_ARENA_ALIGN(pool, a + 1);
+            PL_MAKE_MEM_NOACCESS((void*)a->avail, a->limit - a->avail);
             rp = (char *)a->avail;
             a->avail += nb;
             /* the newly allocated arena is linked after pool->current 
             *  and becomes pool->current */
             a->next = pool->current->next;
             pool->current->next = a;
             pool->current = a;
             if ( NULL == pool->first.next )
                 pool->first.next = a;
             PL_COUNT_ARENA(pool,++);
@@ skipping 16 matching lines @@
         memcpy(newp, p, size);
     return newp;
 }
 
 static void ClearArenaList(PLArena *a, PRInt32 pattern)
 {
 
     for (; a; a = a->next) {
         PR_ASSERT(a->base <= a->avail && a->avail <= a->limit);
         a->avail = a->base;
-        PL_CLEAR_UNUSED_PATTERN(a, pattern);
+        PL_CLEAR_UNUSED_PATTERN(a, pattern);
+        PL_MAKE_MEM_NOACCESS((void*)a->avail, a->limit - a->avail);
     }
 }
 
 PR_IMPLEMENT(void) PL_ClearArenaPool(PLArenaPool *pool, PRInt32 pattern)
 {
     ClearArenaList(pool->first.next, pattern);
 }
 
 /*
  * Free tail arenas linked after head, which may not be the true list head.
@@ skipping 15 matching lines @@
     if (reallyFree) {
         do {
             *ap = a->next;
             PL_CLEAR_ARENA(a);
             PL_COUNT_ARENA(pool,--);
             PR_DELETE(a);
         } while ((a = *ap) != 0);
     } else {
         /* Insert the whole arena chain at the front of the freelist. */
         do {
+            PL_MAKE_MEM_NOACCESS((void*)(*ap)->base,
+                                 (*ap)->limit - (*ap)->base);
             ap = &(*ap)->next;
         } while (*ap);
         LockArena();
         *ap = arena_freelist;
         arena_freelist = a;
         head->next = 0;
         UnlockArena();
     }
 
     pool->current = head;
@@ skipping 52 matching lines @@
     }
     arena_freelist = NULL;
 
     if (arenaLock) {
         PR_DestroyLock(arenaLock);
         arenaLock = NULL;
     }
     once = pristineCallOnce;
 }
 
+PR_IMPLEMENT(size_t) PL_SizeOfArenaPoolExcludingPool(
+    const PLArenaPool *pool, PLMallocSizeFn mallocSizeOf)
+{
+    /*
+     * The first PLArena is within |pool|, so don't measure it.  Subsequent
+     * PLArenas are separate and must be measured.
+     */
+    size_t size = 0;
+    const PLArena *arena = pool->first.next;
+    while (arena) {
+        size += mallocSizeOf(arena);
+        arena = arena->next;
+    }
+    return size;
+}
+
 #ifdef PL_ARENAMETER
 PR_IMPLEMENT(void) PL_ArenaCountAllocation(PLArenaPool *pool, PRUint32 nb)
 {
     pool->stats.nallocs++;
     pool->stats.nbytes += nb;
     if (nb > pool->stats.maxalloc)
         pool->stats.maxalloc = nb;
     pool->stats.variance += nb * nb;
 }
 
@@ skipping 51 matching lines @@
         fprintf(fp, "    number of in-place growths: %u\n", stats->ninplace);
         fprintf(fp, "number of released allocations: %u\n", stats->nreleases);
         fprintf(fp, "       number of fast releases: %u\n", stats->nfastrels);
         fprintf(fp, "         total bytes allocated: %u\n", stats->nbytes);
         fprintf(fp, "          mean allocation size: %g\n", mean);
         fprintf(fp, "            standard deviation: %g\n", sqrt(variance));
         fprintf(fp, "       maximum allocation size: %u\n", stats->maxalloc);
     }
 }
 #endif /* PL_ARENAMETER */