forked from openkylin/dwz
104 lines
2.8 KiB
C
104 lines
2.8 KiB
C
/* Copyright (C) 2001-2021 Red Hat, Inc.
|
|
Copyright (C) 2003 Free Software Foundation, Inc.
|
|
Copyright (C) 2019-2021 SUSE LLC.
|
|
Written by Jakub Jelinek <jakub@redhat.com>, 2012.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 51 Franklin Street - Fifth Floor,
|
|
Boston, MA 02110-1301, USA. */
|
|
|
|
/* Big pool allocator. obstack isn't efficient, because it aligns everything
|
|
too much, and allocates too small chunks. All these objects are only freed
|
|
together. */
|
|
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "pool.h"
|
|
|
|
/* Pointer to the start of the current pool chunk, current first free byte
|
|
in the chunk and byte after the end of the current pool chunk. */
|
|
|
|
static unsigned char *pool, *pool_next, *pool_limit;
|
|
|
|
extern void dwz_oom (void);
|
|
|
|
/* Allocate SIZE bytes with ALIGN bytes alignment from the pool. */
|
|
void *
|
|
pool_alloc_1 (unsigned int align, unsigned int size)
|
|
{
|
|
void *ret;
|
|
if (pool == NULL
|
|
|| (size_t) (pool_limit - pool_next) < (size_t) align + size)
|
|
{
|
|
size_t new_size = (size_t) align + size;
|
|
unsigned char *new_pool;
|
|
new_size += sizeof (void *);
|
|
if (new_size < 16384 * 1024 - 64)
|
|
new_size = 16384 * 1024 - 64;
|
|
new_pool = (unsigned char *) malloc (new_size);
|
|
if (new_pool == NULL)
|
|
dwz_oom ();
|
|
*(unsigned char **) new_pool = pool;
|
|
pool_next = new_pool + sizeof (unsigned char *);
|
|
pool_limit = new_pool + new_size;
|
|
pool = new_pool;
|
|
}
|
|
pool_next = (unsigned char *) (((uintptr_t) pool_next + align - 1)
|
|
& ~(uintptr_t) (align - 1));
|
|
ret = pool_next;
|
|
pool_next += size;
|
|
return ret;
|
|
}
|
|
|
|
/* Finalize a pool and return it. */
|
|
unsigned char *
|
|
finalize_pool (void)
|
|
{
|
|
unsigned char *ret = pool;
|
|
pool = NULL;
|
|
pool_next = NULL;
|
|
pool_limit = NULL;
|
|
return ret;
|
|
}
|
|
|
|
/* Free pool P. */
|
|
static void
|
|
pool_destroy_1 (unsigned char *p)
|
|
{
|
|
while (p)
|
|
{
|
|
void *elem = (void *) p;
|
|
p = *(unsigned char **) p;
|
|
free (elem);
|
|
}
|
|
}
|
|
|
|
/* Free pool P, or the current pool if NULL. */
|
|
void
|
|
pool_destroy (unsigned char *p)
|
|
{
|
|
if (p != NULL)
|
|
{
|
|
pool_destroy_1 (p);
|
|
return;
|
|
}
|
|
|
|
pool_destroy_1 (pool);
|
|
pool = NULL;
|
|
pool_next = NULL;
|
|
pool_limit = NULL;
|
|
}
|