Example #1
0
//
// Z_ChangeTag
//
void (Z_ChangeTag)(void *ptr, int tag, __string file, int line)
{
   register memblock_t __near *block = VoidToBlock(ptr);

   DEBUG_CHECKHEAP();

   Z_IDCheck(IDBOOL(block->id != ZONEID),
             "Z_ChangeTag: Changed a tag without ZONEID", block, file, line);

   Z_IDCheck(IDBOOL(tag >= PU_PURGELEVEL && !block->user),
             "Z_ChangeTag: an owner is required for purgable blocks",
             block, file, line);

#ifdef INSTRUMENTED
   if(block->tag < PU_PURGELEVEL && tag >= PU_PURGELEVEL)
   {
      active_memory -= block->size - block->extra;
      purgable_memory += block->size - block->extra;
   }
   else if(block->tag >= PU_PURGELEVEL && tag < PU_PURGELEVEL)
   {
      active_memory += block->size - block->extra;
      purgable_memory -= block->size - block->extra;
   }
#endif
   block->tag = tag;

   Z_LogPrintf("* Z_ChangeTag(p=%p, tag=%d, file=%s:%d)\n", ptr, tag, file, line);
}
Example #2
0
//
// Z_FreeTags
//
void (Z_FreeTags)(int lowtag, int hightag, const char *file, int line)
{
   memblock_t *block;

   // haleyjd 03/30/2011: delete ZoneObjects of the same tags as well
   ZoneObject::FreeTags(lowtag, hightag);
   
   if(lowtag <= PU_FREE)
      lowtag = PU_FREE+1;

   if(hightag > PU_CACHE)
      hightag = PU_CACHE;
   
   for(; lowtag <= hightag; ++lowtag)
   {
      for(block = blockbytag[lowtag], blockbytag[lowtag] = NULL; block;)
      {
         memblock_t *next = block->next;

         Z_IDCheck(IDBOOL(block->id != ZONEID),
                   "Z_FreeTags: Changed a tag without ZONEID", 
                   block, file, line);

         (Z_Free)((byte *)block + header_size, file, line);
         block = next;               // Advance to next block
      }
   }

   Z_LogPrintf("* Z_FreeTags(lowtag=%d, hightag=%d, file=%s:%d)\n",
               lowtag, hightag, file, line);
}
Example #3
0
//
// Z_Malloc
//
// You can pass a NULL user if the tag is < PU_PURGELEVEL.
//
void *(Z_Malloc)(size_t size, int tag, void **user, const char *file, int line)
{
   memblock_t *block;
   byte *ret;

   DEBUG_CHECKHEAP();

   Z_IDCheckNB(IDBOOL(tag >= PU_PURGELEVEL && !user),
               "Z_Malloc: an owner is required for purgable blocks", 
               file, line);

   if(!size)
      return user ? *user = NULL : NULL;          // malloc(0) returns NULL
   
   if(!(block = (memblock_t *)(malloc(size + header_size))))
   {
      if(blockbytag[PU_CACHE])
      {
         Z_FreeTags(PU_CACHE, PU_CACHE);
         block = (memblock_t *)(malloc(size + header_size));
      }
   }

   if(!block)
   {
      I_FatalError(I_ERR_KILL, "Z_Malloc: Failure trying to allocate %u bytes\n"
                               "Source: %s:%d\n", (unsigned int)size, file, line);
   }
   
   block->size = size;
   
   if((block->next = blockbytag[tag]))
      block->next->prev = &block->next;
   blockbytag[tag] = block;
   block->prev = &blockbytag[tag];
           
   INSTRUMENT(memorybytag[tag] += block->size);
   INSTRUMENT(block->file = file);
   INSTRUMENT(block->line = line);
         
   IDCHECK(block->id = ZONEID); // signature required in block header
   
   block->tag  = tag;           // tag
   block->user = user;          // user
   
   ret = ((byte *) block + header_size);
   if(user)                     // if there is a user
      *user = ret;              // set user to point to new block
   
   // scramble memory -- weed out any bugs
   SCRAMBLER(ret, size);

   Z_LogPrintf("* %p = Z_Malloc(size=%lu, tag=%d, user=%p, source=%s:%d)\n", 
               ret, size, tag, user, file, line);

   return ret;
}
Example #4
0
//
// Z_CheckTag
//
// haleyjd: a function to return the allocation tag of a block.
// This is needed by W_CacheLumpNum so that it does not
// inadvertently lower the cache level of lump allocations and
// cause code which expects them to be static to lose them
//
int (Z_CheckTag)(void *ptr, const char *file, int line)
{
   memblock_t *block = (memblock_t *)((byte *) ptr - header_size);

   DEBUG_CHECKHEAP();

   Z_IDCheck(IDBOOL(block->id != ZONEID),
             "Z_CheckTag: block doesn't have ZONEID", block, file, line);
   
   return block->tag;
}
Example #5
0
//
// Z_CheckTag
//
// haleyjd: a function to return the allocation tag of a block.
// This is needed by W_CacheLumpNum so that it does not
// inadvertently lower the cache level of lump allocations and
// cause code which expects them to be static to lose them
//
int (Z_CheckTag)(void *ptr, __string file, int line)
{
   register memblock_t __near *block = VoidToBlock(ptr);

   DEBUG_CHECKHEAP();

   Z_IDCheck(IDBOOL(block->id != ZONEID),
             "Z_CheckTag: block doesn't have ZONEID", block, file, line);

   return block->tag;
}
Example #6
0
//
// Z_ChangeTag
//
void (Z_ChangeTag)(void *ptr, int tag, const char *file, int line)
{
   memblock_t *block;
   
   DEBUG_CHECKHEAP();
   
   if(!ptr)
   {
      I_FatalError(I_ERR_KILL, 
                   "Z_ChangeTag: can't change a NULL pointer at %s:%d\n",
                   file, line);
   }
   
   block = (memblock_t *)((byte *) ptr - header_size);

   Z_IDCheck(IDBOOL(block->id != ZONEID),
             "Z_ChangeTag: Changed a tag without ZONEID", block, file, line);

   // haleyjd: permanent blocks are not re-tagged even if the code tries.
   if(block->tag == PU_PERMANENT)
      return;

   Z_IDCheck(IDBOOL(tag >= PU_PURGELEVEL && !block->user),
             "Z_ChangeTag: an owner is required for purgable blocks",
             block, file, line);

   if((*block->prev = block->next))
      block->next->prev = block->prev;
   if((block->next = blockbytag[tag]))
      block->next->prev = &block->next;
   block->prev = &blockbytag[tag];
   blockbytag[tag] = block;

   INSTRUMENT(memorybytag[block->tag] -= block->size);
   INSTRUMENT(memorybytag[tag] += block->size);

   block->tag = tag;

   Z_LogPrintf("* Z_ChangeTag(p=%p, tag=%d, file=%s:%d)\n",
               ptr, tag, file, line);
}
Example #7
0
//
// Z_Free
//
void (Z_Free)(void *p, const char *file, int line)
{
   DEBUG_CHECKHEAP();

   if(p)
   {
      memblock_t *block = (memblock_t *)((byte *) p - header_size);

      Z_IDCheck(IDBOOL(block->id != ZONEID),
                "Z_Free: freed a pointer without ZONEID", block, file, line);

      // haleyjd: permanent blocks are never freed even if the code tries.
      if(block->tag == PU_PERMANENT)
         return;
      
      IDCHECK(block->id = 0); // Nullify id so another free fails

      // haleyjd 01/20/09: check invalid tags
      // catches double frees and possible selective heap corruption
      if(block->tag == PU_FREE || block->tag >= PU_MAX)
      {
         I_FatalError(I_ERR_KILL,
                      "Z_Free: freed a pointer with invalid tag %d\n"
                      "Source: %s:%d\n"
#if defined(ZONEVERBOSE) && defined(INSTRUMENTED)
                      "Source of malloc: %s:%d\n"
                      , block->tag, file, line, block->file, block->line
#else
                      , block->tag, file, line
#endif
                     );
      }
      INSTRUMENT(memorybytag[block->tag] -= block->size);
      block->tag = PU_FREE;       // Mark block freed

      // scramble memory -- weed out any bugs
      SCRAMBLER(p, block->size);

      if(block->user)            // Nullify user if one exists
         *block->user = NULL;

      if((*block->prev = block->next))
         block->next->prev = block->prev;
         
      free(block);
         
      Z_LogPrintf("* Z_Free(p=%p, file=%s:%d)\n", p, file, line);
   }
}
Example #8
0
//
// Z_CheckHeap
//
void (Z_CheckHeap)(const char *file, int line)
{
#ifdef ZONEIDCHECK
   memblock_t *block;
   int lowtag;

   for(lowtag = PU_FREE+1; lowtag < PU_MAX; ++lowtag)
   {
      for(block = blockbytag[lowtag]; block; block = block->next)
      {
         Z_IDCheck(IDBOOL(block->id != ZONEID),
                   "Z_CheckHeap: Block found without ZONEID", 
                   block, file, line);
      }
   }
#endif

#ifndef CHECKHEAP
   Z_LogPrintf("* Z_CheckHeap(file=%s:%d)\n", file, line);
#endif
}
Example #9
0
//
// Z_Realloca
//
// haleyjd 07/08/10: realloc for automatic allocations.
//
void *(Z_Realloca)(void *ptr, size_t n, const char *file, int line)
{
   void *ret;

   if(ptr)
   {
      // get zone block
      memblock_t *block = (memblock_t *)((byte *)ptr - header_size);

      Z_IDCheck(IDBOOL(block->id != ZONEID),
         "Z_Realloca: block found without ZONEID", block, file, line);

      if(block->tag != PU_AUTO)
         I_FatalError(I_ERR_KILL, "Z_Realloca: strange block tag %d\n", block->tag);
   }
   
   ret = (Z_Realloc)(ptr, n, PU_AUTO, NULL, file, line);

   Z_LogPrintf("* %p = Z_Realloca(ptr = %p, n = %lu, file = %s, line = %d)\n", 
               ret, ptr, n, file, line);

   return ret;
}
Example #10
0
//
// Z_FreeAlloca
//
// haleyjd 12/06/06: Frees all blocks allocated with Z_Alloca.
//
void Z_FreeAlloca(void)
{
   memblock_t *block = blockbytag[PU_AUTO];

   if(!block)
      return;
   
   Z_LogPuts("* Freeing alloca blocks\n");

   blockbytag[PU_AUTO] = NULL;

   while(block)
   {
      memblock_t *next = block->next;

      Z_IDCheckNB(IDBOOL(block->id != ZONEID),
                  "Z_FreeAlloca: Freed a tag without ZONEID", 
                  __FILE__, __LINE__);

      Z_Free((byte *)block + header_size);
      block = next;               // Advance to next block
   }
}
Example #11
0
//
// Z_Realloc
//
// For the native heap, this can easily behave as a real realloc, and not
// just an ignorant copy-and-free.
//
void *(Z_Realloc)(void *ptr, size_t n, int tag, void **user,
                  const char *file, int line)
{
   void *p;
   memblock_t *block, *newblock, *origblock;

   // if not allocated at all, defer to Z_Malloc
   if(!ptr)
      return (Z_Malloc)(n, tag, user, file, line);

   // size == 0 is a special case that cannot be handled below
   if(n == 0)
   {
      (Z_Free)(ptr, file, line);
      return NULL;
   }

   DEBUG_CHECKHEAP();

   block = origblock = (memblock_t *)((byte *)ptr - header_size);

   Z_IDCheck(IDBOOL(block->id != ZONEID),
             "Z_Realloc: Reallocated a block without ZONEID\n", 
             block, file, line);

   // haleyjd: realloc cannot change the tag of a permanent block
   if(block->tag == PU_PERMANENT)
      tag = PU_PERMANENT;

   // nullify current user, if any
   if(block->user)
      *(block->user) = NULL;

   // detach from list before reallocation
   if((*block->prev = block->next))
      block->next->prev = block->prev;

   block->next = NULL;
   block->prev = NULL;

   INSTRUMENT(memorybytag[block->tag] -= block->size);

   if(!(newblock = (memblock_t *)(realloc(block, n + header_size))))
   {
      // haleyjd 07/09/10: Note that unlinking the block above makes this safe 
      // even if the current block is PU_CACHE; Z_FreeTags won't find it.
      if(blockbytag[PU_CACHE])
      {
         Z_FreeTags(PU_CACHE, PU_CACHE);
         newblock = (memblock_t *)(realloc(block, n + header_size));
      }
   }

   if(!(block = newblock))
   {
      if(origblock->size >= n)
      {
         block = origblock; // restore original block if size was equal or smaller
         n = block->size;   // keep same size in this event
      }
      else
      {
         I_FatalError(I_ERR_KILL, "Z_Realloc: Failure trying to allocate %u bytes\n"
                                  "Source: %s:%d\n", (unsigned int)n, file, line);
      }
   }

   block->size = n;
   block->tag  = tag;

   p = (byte *)block + header_size;

   // set new user, if any
   block->user = user;
   if(user)
      *user = p;

   // reattach to list at possibly new address, new tag
   if((block->next = blockbytag[tag]))
      block->next->prev = &block->next;
   blockbytag[tag] = block;
   block->prev = &blockbytag[tag];

   INSTRUMENT(memorybytag[tag] += block->size);
   INSTRUMENT(block->file = file);
   INSTRUMENT(block->line = line);

   Z_LogPrintf("* %p = Z_Realloc(ptr=%p, n=%lu, tag=%d, user=%p, source=%s:%d)\n", 
               p, ptr, n, tag, user, file, line);

   return p;
}
Example #12
0
//
// Z_Realloc
//
// haleyjd 09/18/06: Rewritten to be an actual realloc routine. The
// various cases are as follows:
//
// 1. If the block is NULL, is in virtual memory, or we're trying to set it to
//    zero-byte size, we use Z_ReallocOld above.
// 2. If the block is smaller than the new size, we need to expand it. If the
//    next block on the zone heap is free, check to see if it together with the
//    current block is large enough. If so, merge the blocks. Now test to make
//    sure the internal fragmentation does not exceed the split limit. If it
//    does, resplit the blocks at the new boundary. If the next block wasn't
//    free, we have to call Z_ReallocOld to move the entire block elsewhere.
// 3. If the block is larger than the new size, we can shrink it, but we only
//    need to shrink it if the wasted space is larger than the split limit.
//    If so, the block is split at its new boundary. If the next block on the
//    zone heap is free, it is then necessary to merge the new free block with
//    the next block on the heap. In the event the block is not shrunk, only the
//    INSTRUMENTED data needs to be updated to reflect the new internal fragmen-
//    tation.
// 4. If the block is already the same size as "n", we don't need to do anything
//    aside from adjusting the INSTRUMENTED block data for debugging purposes.
//
void *(Z_Realloc)(void *ptr, size_t n, int tag, void **user, __string file, int line)
{
   register memblock_t __near *block, *other;
   register size_t curr_size = 0;

   // davidph 12/09/12: Handle null and size 0 right here instead of in Z_ReallocOld.
   if(n == 0) { (Z_Free)(ptr, file, line); return NULL; }

   if(!ptr)
      return (Z_Malloc)(n, tag, user, file, line);

   // get current size of block
   block = VoidToBlock(ptr);

   Z_IDCheck(IDBOOL(block->id != ZONEID),
             "Z_Realloc: Reallocated a block without ZONEID\n",
             block, file, line);

   other = block->next; // save pointer to next block
   curr_size = block->size;

   // round new size to CHUNK_SIZE
   n = (n + CHUNK_SIZE - 1) & ~(CHUNK_SIZE - 1);

   if(n > curr_size) // is new allocation size larger than current?
   {
      register size_t extra;

      // haleyjd 10/03/06: free adjacent purgable blocks
      while(other != zone && other != block &&
            (other->tag == PU_FREE || other->tag >= PU_PURGELEVEL))
      {
         if(other->tag >= PU_PURGELEVEL)
         {
            (Z_Free)(BlockToVoid(other), file, line);

            // reset pointer to next block
            other = block->next;
         }

         // use current size of block; note it may have increased if it was
         // merged with an adjacent free block

         // if we've freed enough, stop
         if(curr_size + other->size + HEADER_SIZE >= n)
            break;

         // move to next block
         other = other->next;
      }

      // reset pointer
      other = block->next;

      // check to see if it can fit if we merge with the next block
      if(other != zone && other->tag == PU_FREE &&
         curr_size + other->size + HEADER_SIZE >= n)
      {
         // merge the blocks
         if(rover == other)
            rover = block;
         (block->next = other->next)->prev = block;
         block->size += other->size + HEADER_SIZE;

#ifdef INSTRUMENTED
         // lost a block...
         inactive_memory -= HEADER_SIZE;
         // lost a free block...
         free_memory -= other->size;
         // increased active or purgable
         if(block->tag >= PU_PURGELEVEL)
            purgable_memory += other->size + HEADER_SIZE;
         else
            active_memory += other->size + HEADER_SIZE;
#endif

         // check to see if there's enough extra to warrant splitting off
         // a new free block
         extra = block->size - n;

         if(extra >= MIN_BLOCK_SPLIT + HEADER_SIZE)
         {
            register memblock_t __near *newb =
               (memblock_t __near *)((char __near *)block + HEADER_SIZE + n);

            (newb->next = block->next)->prev = newb;
            (newb->prev = block)->next = newb;
            block->size = n;
            newb->size = extra - HEADER_SIZE;
            newb->tag = PU_FREE;

            if(rover == block)
               rover = newb;

#ifdef INSTRUMENTED
            // added a block...
            inactive_memory += HEADER_SIZE;
            // added a free block...
            free_memory += newb->size;
            // decreased active or purgable
            if(block->tag >= PU_PURGELEVEL)
               purgable_memory -= newb->size + HEADER_SIZE;
            else
               active_memory -= newb->size + HEADER_SIZE;
#endif
         }

         // subtract old internal fragmentation and add new
         INSTRUMENT(inactive_memory -= block->extra);
         INSTRUMENT(inactive_memory += (block->extra = block->size - n));
      }
      else // else, do old realloc (make new, copy old, free old)
      {
         // davidph 12/10/12: This was the only place Z_ReallocOld was called.
         //   And we know that ptr != NULL and n != 0 and n > curr_size.

         register void *p = (Z_Malloc)(n, tag, user, file, line);

         memcpy_near((void __near *)p, (void __near *)ptr, curr_size);
         (Z_Free)(ptr, file, line);
         if(user) // in case Z_Free nullified same user
            *user = p;

         return p;
      }
   }
   else if(n < curr_size) // is new allocation size smaller than current?
   {
      // check to see if there's enough extra to warrant splitting off
      // a new free block
      size_t extra = curr_size - n;

      if(extra >= MIN_BLOCK_SPLIT + HEADER_SIZE)
      {
         register memblock_t __near *newb =
            (memblock_t __near *)((char __near *)block + HEADER_SIZE + n);

         (newb->next = block->next)->prev = newb;
         (newb->prev = block)->next = newb;
         block->size = n;
         newb->size = extra - HEADER_SIZE;
         newb->tag = PU_FREE;

#ifdef INSTRUMENTED
         // added a block...
         inactive_memory += HEADER_SIZE;
         // added a free block...
         free_memory += newb->size;
         // decreased purgable or active
         if(block->tag >= PU_PURGELEVEL)
            purgable_memory -= newb->size + HEADER_SIZE;
         else
            active_memory -= newb->size + HEADER_SIZE;
#endif

         // may need to merge new block with next block
         if(other && other->tag == PU_FREE && other != zone)
         {
            if(rover == other) // Move back rover if it points at next block
               rover = newb;
            (newb->next = other->next)->prev = newb;
            newb->size += other->size + HEADER_SIZE;

            // deleted a block...
            INSTRUMENT(inactive_memory -= HEADER_SIZE);
            // space between blocks is now free
            INSTRUMENT(free_memory += HEADER_SIZE);
         }
      }
      // else, leave block the same size

      // subtract old internal fragmentation and add new
      INSTRUMENT(inactive_memory -= block->extra);
      INSTRUMENT(inactive_memory += (block->extra = block->size - n));
   }
   // else new allocation size is same as current, don't change it

   // modify the block
   INSTRUMENT(block->file = file);
   INSTRUMENT(block->line = line);

   // reset ptr for consistency
   ptr = BlockToVoid(block);

   if(block->user != user)
   {
      if(block->user)           // nullify old user if any
         *(block->user) = NULL;
      block->user = user;       // set block's new user
      if(user)                  // if non-null, set user to allocation
         *user = ptr;
   }

   // let Z_ChangeTag handle changing the tag
   if(block->tag != tag)
      (Z_ChangeTag)(ptr, tag, file, line);

   Z_PrintStats();           // print memory allocation stats
   Z_LogPrintf("* Z_Realloc(ptr=%p, n=%u, tag=%d, user=%p, source=%s:%d)\n",
               ptr, n, tag, user, file, line);

   return ptr;
}
Example #13
0
//
// Z_Free
//
void (Z_Free)(void *p, __string file, int line)
{
   register memblock_t __near *other, *block;

   if(!p) return;

   DEBUG_CHECKHEAP();

   block = VoidToBlock(p);

   Z_IDCheck(IDBOOL(block->id != ZONEID),
             "Z_Free: freed a pointer without ZONEID", block, file, line);

   IDCHECK(block->id = 0); // Nullify id so another free fails

   // haleyjd 01/20/09: check invalid tags
   // catches double frees and possible selective heap corruption
   if(block->tag == PU_FREE || block->tag >= PU_MAX)
   {
      zonef("Z_Free: freed a pointer with invalid tag %d\nSource: %s:%d\n"
#ifdef INSTRUMENTED
            "Source of malloc: %s:%d\n"
            , block->tag, file, line, block->file, block->line
#else
            , block->tag, file, line
#endif
            );
      abort();
   }

   SCRAMBLER(p, block->size);

   if(block->user)            // Nullify user if one exists
      *block->user = NULL;

#ifdef INSTRUMENTED
   free_memory += block->size;
   inactive_memory -= block->extra;
   if(block->tag >= PU_PURGELEVEL)
      purgable_memory -= block->size - block->extra;
   else
      active_memory -= block->size - block->extra;
#endif

   block->tag = PU_FREE; // Mark block freed

   if(block != zone)
   {
      other = block->prev; // Possibly merge with previous block
      if(other->tag == PU_FREE)
      {
         if(rover == block)  // Move back rover if it points at block
            rover = other;
         (other->next = block->next)->prev = other;
         other->size += block->size + HEADER_SIZE;
         block = other;

         INSTRUMENT(inactive_memory -= HEADER_SIZE);
         INSTRUMENT(free_memory += HEADER_SIZE);
      }
   }

   other = block->next;        // Possibly merge with next block
   if(other->tag == PU_FREE && other != zone)
   {
      if(rover == other) // Move back rover if it points at next block
         rover = block;
      (block->next = other->next)->prev = block;
      block->size += other->size + HEADER_SIZE;

      INSTRUMENT(inactive_memory -= HEADER_SIZE);
      INSTRUMENT(free_memory += HEADER_SIZE);
   }

   Z_PrintStats(); // print memory allocation stats
   Z_LogPrintf("* Z_Free(p=%p, file=%s:%d)\n", p, file, line);
}
Example #14
0
//
// Z_Malloc
//
// You can pass a NULL user if the tag is < PU_PURGELEVEL.
//
void *(Z_Malloc)(size_t size, int tag, void **user, __string file, int line)
{
   register memblock_t __near *block, *start;

   INSTRUMENT(register size_t size_orig = size);

   // davidph 12/10/12: If zone not initialized, do so now.
   if(!zone) (Z_Init)(file, line);

   DEBUG_CHECKHEAP();

   Z_IDCheckNB(IDBOOL(tag >= PU_PURGELEVEL && !user),
               "Z_Malloc: an owner is required for purgable blocks",
               file, line);

   if(!size)
      return user ? *user = NULL : NULL;          // malloc(0) returns NULL

   size = (size+CHUNK_SIZE-1) & ~(CHUNK_SIZE-1);  // round to chunk size

   block = rover;

   if(block->prev->tag == PU_FREE)
      block = block->prev;

   start = block;

   // haleyjd 01/01/01 (happy new year!):
   // the first if() inside the loop below contains cph's memory
   // purging efficiency fix

   do
   {
      // Free purgable blocks; replacement is roughly FIFO
      if(block->tag >= PU_PURGELEVEL)
      {
         start = block->prev;
         Z_Free((char __near *)block + HEADER_SIZE);

         // cph - If start->next == block, we did not merge with the previous
         //       If !=, we did, so we continue from start.
         //  Important: we've reset start!
         if(start->next == block)
            start = start->next;
         else
            block = start;
      }

      if(block->tag == PU_FREE && block->size >= size)   // First-fit
      {
         size_t extra = block->size - size;
         if(extra >= MIN_BLOCK_SPLIT + HEADER_SIZE)
         {
            memblock_t __near *newb = (memblock_t __near *)((char __near *)block + HEADER_SIZE + size);

            (newb->next = block->next)->prev = newb;
            (newb->prev = block)->next = newb;          // Split up block
            block->size = size;
            newb->size = extra - HEADER_SIZE;
            newb->tag = PU_FREE;

            INSTRUMENT(inactive_memory += HEADER_SIZE);
            INSTRUMENT(free_memory -= HEADER_SIZE);
         }

         rover = block->next;           // set roving pointer for next search

#ifdef INSTRUMENTED
         inactive_memory += block->extra = block->size - size_orig;
         if(tag >= PU_PURGELEVEL)
            purgable_memory += size_orig;
         else
            active_memory += size_orig;
         free_memory -= block->size;
#endif

         INSTRUMENT(block->file = file);
         INSTRUMENT(block->line = line);

         IDCHECK(block->id = ZONEID);// signature required in block header
         block->tag = tag;           // tag
         block->user = user;         // user
         block = BlockToVoid(block);
         if(user)                    // if there is a user
            *user = block;           // set user to point to new block

         Z_PrintStats();             // print memory allocation stats

         // scramble memory -- weed out any bugs
         SCRAMBLER(block, size);

         Z_LogPrintf("* %p = Z_Malloc(size=%u, tag=%d, user=%p, source=%s:%d)\n",
                     block, size, tag, user, file, line);

         return block;
      }
   }
   while((block = block->next) != start);   // detect cycles as failure

   zonef("Z_Malloc: Failure trying to allocate %u bytes\nSource: %s:%d\n", size, file, line);
   abort();
}