dwarf_alloc.c revision 07dc1947c362e187fb955d283b692f8769dd5def
/*
Copyright (C) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
Portions Copyright (C) 2007-2010 David Anderson. All Rights Reserved.
under the terms of version 2.1 of the GNU Lesser General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it would be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Further, this software is distributed without any warranty that it is
free of the rightful claim of any third person regarding infringement
or the like. Any license provided herein, whether implied or
otherwise, applies only to this software file. Patent licenses, if
any, provided herein do not apply to combinations of this program with
other software, or any other product whatsoever.
You should have received a copy of the GNU Lesser General Public
License along with this program; if not, write the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
USA.
Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
Mountain View, CA 94043, or:
For further information regarding this notice, see:
*/
/* The address of the Free Software Foundation is
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
Boston, MA 02110-1301, USA.
SGI has moved from the Crittenden Lane address.
*/
#include "config.h"
#include "dwarf_incl.h"
#include <stdlib.h>
#include <stdio.h>
#include "malloc_check.h"
/*
These files are included to get the sizes
of structs to set the ah_bytes_one_struct field
of the Dwarf_Alloc_Hdr_s structs for each
allocation type.
*/
#include "dwarf_line.h"
#include "dwarf_global.h"
#include "dwarf_arange.h"
#include "dwarf_abbrev.h"
#include "dwarf_die_deliv.h"
#include "dwarf_frame.h"
#include "dwarf_loc.h"
#include "dwarf_funcs.h"
#include "dwarf_types.h"
#include "dwarf_vars.h"
#include "dwarf_weaks.h"
#ifdef DWARF_SIMPLE_MALLOC
unsigned long size,
short alloc_type);
short alloc_type);
void _dwarf_simple_malloc_botch(int err);
#endif /* DWARF_SIMPLE_MALLOC */
/*
This macro adds the size of a pointer to the size of a
struct that is given to it. It rounds up the size to
be a multiple of the size of a pointer. This is done
so that every struct returned by _dwarf_get_alloc()
can be preceded by a pointer to the chunk it came from.
Before allocating, it checks if the size of struct is less than
the size of a pointer. If yes, it returns the size
of 2 pointers. The returned size should be at least
the size of 2 pointers, since the first points to the
chunk the struct was allocated from, and the second
is used to link the free list.
We want DW_RESERVE to be at least the size of
a long long and at least the size of a pointer because
our struct has a long long and we want that aligned right.
Now Standard C defines long long as 8 bytes, so lets
make that standard. It will become unworkable when
long long or pointer grows beyound 8 bytes.
Unclear what to do with wierd requirements, like
36 bit pointers.
*/
#define DW_RESERVE 8
/* Round size up to the next multiple of DW_RESERVE bytes
*/
#define ROUND_SIZE(inputsize) \
(((inputsize) % (DW_RESERVE)) == 0 ? \
(inputsize): \
((inputsize) + \
/* SMALL_ALLOC is for trivia where allocation is a waste.
Things that should be removed, really. */
#define SMALL_ALLOC 2
/* BASE_ALLOC is where a basic allocation makes sense, but 'not too large'.
No thorough evaluation of this value has been done, though
it was found wasteful of memory to have BASE_ALLOC be as large as
BIG_ALLOC. */
#define BASE_ALLOC 64
/* BIG_ALLOC is where a larger-than-BASE_ALLOC
allocation makes sense, but still 'not too large'.
No thorough evaluation of this value has been done. */
#define BIG_ALLOC 128
/* This translates into de_alloc_hdr index
** the 0,1,1 entries are special: they don't use the
** table values at all.
** Rearranging the DW_DLA values would break binary compatibility
** so that is not an option.
*/
struct ial_s {
int ia_al_num; /* Index into de_alloc_hdr table. */
/* In bytes, one struct instance. This does not account for extra
space needed per block, but that (DW_RESERVE) will be added in
later where it is needed (DW_RESERVE space never added in here).
*/
int ia_struct_size;
/* Number of instances per alloc block. MUST be > 0. */
int ia_base_count;
int (*specialconstructor) (Dwarf_Debug, void *);
void (*specialdestructor) (void *);
};
static const
{0, 1, 1, 0, 0}, /* none */
{0, 1, 1, 0, 0}, /* 1 DW_DLA_STRING */
, /* 2 DW_DLA_LOC */
, /* 3 DW_DLA_LOCDESC */
{0, 1, 1, 0, 0}
, /* not used *//* 4 DW_DLA_ELLIST */
{0, 1, 1, 0, 0}
, /* not used *//* 5 DW_DLA_BOUNDS */
, /* 6 DW_DLA_BLOCK */
{0, 1, 1, 0, 0}
, /* the actual dwarf_debug structure *//* 7 DW_DLA_DEBUG */
*/
DW_DLA_LINE */
/* 10 DW_DLA_ATTR */
{0, 1, 1, 0, 0}, /* not used *//* 11 DW_DLA_TYPE */
{0, 1, 1, 0, 0}, /* not used *//* 12 DW_DLA_SUBSCR */
DW_DLA_GLOBAL
*/
DW_DLA_ERROR
*/
{0, 1, 1, 0, 0}, /* 15 DW_DLA_LIST */
{0, 1, 1, 0, 0}, /* not used *//* 16 DW_DLA_LINEBUF */
DW_DLA_ARANGE
*/
DW_DLA_ABBREV
*/
, /* 19 DW_DLA_FRAME_OP */
DW_DLA_CIE */
{0, 1, 1, 0, 0}, /* 22 DW_DLA_LOC_BLOCK */
{0, 1, 1, 0, 0}, /* 23 DW_DLA_FRAME_BLOCK */
UNUSED */
DW_DLA_TYPENAME
UNUSED */
UNUSED */
UNUSED */
{0, 1, 1, 0, 0}, /* 28 DW_DLA_ADDR */
{0, 1,1,0,0 }, /* 29 DW_DLA_RANGES */
/* The following DW_DLA data types
are known only inside libdwarf. */
/* 30 DW_DLA_ABBREV_LIST */
/* 32 DW_DLA_CU_CONTEXT */
_dwarf_frame_destructor}, /* 33 DW_DLA_FRAME */
/* 34 DW_DLA_GLOBAL_CONTEXT */
/* 35 DW_DLA_FILE_ENTRY */
/* 36 DW_DLA_LINE_CONTEXT */
/* 37 DW_DLA_LOC_CHAIN */
/* 38 DW_DLA_HASH_TABLE */
/* The following really use Global struct: used to be unique struct
per type, but now merged (11/99). The opaque types
are visible in the interface. The types for
DW_DLA_FUNC,
DW_DLA_TYPENAME, DW_DLA_VAR, DW_DLA_WEAK also use
the global types.
*/
/* 39 DW_DLA_FUNC_CONTEXT */
/* 40 DW_DLA_TYPENAME_CONTEXT */
/* 41 DW_DLA_VAR_CONTEXT */
/* 42 DW_DLA_WEAK_CONTEXT */
/* 43 DW_DLA_PUBTYPES_CONTEXT DWARF3 */
{0,1,1,0,0 },
/* 44 DW_DLA_HASH_TABLE_ENTRY */
};
#ifndef DWARF_SIMPLE_MALLOC
/*
This function is given a pointer to the header
structure that is used to allocate 1 struct of
the type given by alloc_type. It first checks
if a struct is available in its free list. If
not, it checks if 1 is available in its blob,
which is a chunk of memory that is reserved for
its use. If not, it malloc's a chunk. The
initial part of it is used to store the end
address of the chunk, and also to keep track
of the number of free structs in that chunk.
This information is used for freeing the chunk
when all the structs in it are free.
Assume all input arguments have been validated.
This function can be used only to allocate 1
struct of the given type.
It returns a pointer to the struct that the
user can use. It returns NULL only when it
is out of free structs, and cannot malloc
any more. The struct returned is zero-ed.
A pointer to the chunk that the struct belongs
to is stored in the bytes preceding the
returned address. Since this pointer it
never overwritten, when a struct is allocated
from the free_list this pointer does not
have to be written. In the 2 other cases,
where the struct is allocated from a new
chunk, or the blob, a pointer to the chunk
is written.
*/
static Dwarf_Ptr
{
/* Pointer to the struct allocated. */
Dwarf_Small *ret_mem = 0;
/* Pointer to info about chunks allocated. */
/* Size of chunk malloc'ed when no free structs left. */
/* Pointer to block malloc'ed. */
/*
Check the alloc_area from which the last allocation was made
(most recent new block). If that is not successful, then search
the list of alloc_area's from alloc_header. */
if (alloc_area->aa_free_structs_in_chunk > 0) {
break; /* found a free entry! */
}
}
if (alloc_area != NULL) {
/*
Update the free list. The initial part of the struct is
used to hold a pointer to the next struct on the free
list. In this way, the free list chain is maintained at
0 memory cost. */
/*
Store pointer to chunk this struct belongs to in the
first few bytes. Return pointer to bytes after this
pointer storage. */
ret_mem += DW_RESERVE;
} else {
/* else fall thru , though it should be impossible to fall
thru. And represents a disastrous programming error if
we get here. */
#ifdef DEBUG
(int) alloc_area->aa_blob_start,
(int) alloc_area->aa_blob_end);
#endif
}
}
/* New memory has to malloc'ed since there are no free structs. */
if (ret_mem == 0) {
{ /* this nonsense avoids a warning */
/* CONSTCOND would be better */
unsigned long v = sizeof(struct Dwarf_Alloc_Area_s);
}
/*
Allocate memory to contain the required number of structs
and the Dwarf_Alloc_Area_s to control it. */
return (NULL);
}
/*
Attach the Dwarf_Alloc_Area_s struct to the list of chunks
malloc'ed for this struct type. Also initialize the fields
of the Dwarf_Alloc_Area_s. */
alloc_area->aa_prev = 0;
}
alloc_area->aa_free_list = 0;
/* If we get here, there is a disastrous programming error
somewhere. */
#ifdef DEBUG
"libdwarf Internal error: free structs in chunk %d\n",
(int) alloc_area->aa_free_structs_in_chunk);
#endif
return NULL;
}
/*
The struct returned begins immediately after the
Dwarf_Alloc_Area_s struct. */
/*
Store pointer to chunk this struct belongs to in the first
few bytes. Return pointer to bytes after this pointer
storage. */
ret_mem += DW_RESERVE;
}
return (ret_mem);
}
#endif /* ndef DWARF_SIMPLE_MALLOC */
/*
This function returns a pointer to a region
of memory. For alloc_types that are not
strings or lists of pointers, only 1 struct
can be requested at a time. This is indicated
by an input count of 1. For strings, count
equals the length of the string it will
contain, i.e it the length of the string
plus 1 for the terminating null. For lists
of pointers, count is equal to the number of
pointers. For DW_DLA_FRAME_BLOCK, DW_DLA_RANGES, and
DW_DLA_LOC_BLOCK allocation types also, count
is the count of the number of structs needed.
This function cannot be used to allocate a
Dwarf_Debug_s struct.
*/
{
Dwarf_Signed size = 0;
unsigned int index;
unsigned int type = alloc_type;
return (NULL);
}
if (type >= ALLOC_AREA_INDEX_TABLE_MAX) {
/* internal error */
return NULL;
}
/* zero also illegal but not tested for */
/* If the Dwarf_Debug is not fully set up, we will get index 0 for
any type and must do something. 'Not fully set up' can only
happen for DW_DLA_ERROR, I (davea) believe, and for that we call
special code here.. */
if (index == 0) {
if (alloc_type == DW_DLA_STRING) {
} else if (alloc_type == DW_DLA_LIST) {
} else if (alloc_type == DW_DLA_FRAME_BLOCK) {
} else if (alloc_type == DW_DLA_LOC_BLOCK) {
} else if (alloc_type == DW_DLA_HASH_TABLE_ENTRY) {
} else if (alloc_type == DW_DLA_ADDR) {
(sizeof(Dwarf_Addr) > sizeof(Dwarf_Off) ?
sizeof(Dwarf_Addr) : sizeof(Dwarf_Off));
} else if (alloc_type == DW_DLA_RANGES) {
} else if (alloc_type == DW_DLA_ERROR) {
void *m = _dwarf_special_no_dbg_error_malloc();
return m;
} else {
/* If we get here, there is a disastrous programming error
somewhere. */
#ifdef DEBUG
"libdwarf Internal error: type %d unexpected\n",
(int) type);
#endif
}
} else {
if (alloc_hdr->ah_bytes_one_struct > 0) {
#ifdef DWARF_SIMPLE_MALLOC
#else
{
void *m = _dwarf_find_memory(alloc_hdr);
int res =
specialconstructor(dbg, m);
/* We leak what we allocated in
_dwarf_find_memory when constructor fails. */
return NULL;
}
}
return m;
}
#endif
} else {
/* Special case: should not really happen at all. */
if (type == DW_DLA_ERROR) {
/* dwarf_init failure. Because dbg is incomplete we
won't use it to record the malloc. */
void *m = _dwarf_special_no_dbg_error_malloc();
return m;
} else {
/* If we get here, there is a disastrous programming
error somewhere. */
#ifdef DWARF_SIMPLE_MALLOC
#endif
#ifdef DEBUG
"libdwarf Internal error: Type %d unexpected\n",
(int) type);
#endif
}
}
}
#ifdef DWARF_SIMPLE_MALLOC
type);
#endif
int res =
/* We leak what we allocated in _dwarf_find_memory when
constructor fails. */
return NULL;
}
}
return (ret_mem);
}
/*
This function is used to deallocate a region of memory
that was obtained by a call to _dwarf_get_alloc. Note
that though dwarf_dealloc() is a public function,
_dwarf_get_alloc() isn't.
For lists, typically arrays of pointers, it is assumed
that the space was allocated by a direct call to malloc,
and so a straight free() is done. This is also the case
for variable length blocks such as DW_DLA_FRAME_BLOCK
and DW_DLA_LOC_BLOCK and DW_DLA_RANGES.
For strings, the pointer might point to a string in
.debug_info or .debug_string. After this is checked,
and if found not to be the case, a free() is done,
again on the assumption that a malloc was used to
obtain the space.
For other types of structs, a pointer to the chunk that
the struct was allocated out of, is present in the bytes
preceding the pointer passed in. For this chunk it is
checked whether all the structs in that chunk are now free.
If so, the entire chunk is free_ed. Otherwise, the space
is added to the free list for that chunk, and the free count
incremented.
This function does not return anything.
*/
void
{
unsigned int type = alloc_type;
unsigned int index;
return;
}
if (type == DW_DLA_ERROR) {
/* Get pointer to Dwarf_Alloc_Area this struct came from. See
dwarf_alloc.h ROUND_SIZE_WITH_POINTER stuff */
if (alloc_area == 0) {
/* This is the special case of a failed dwarf_init(). Also
(and more signficantly) there are a variety of other
situations where libdwarf does not *know* what dbg is
involved (because of a libdwarf-caller-error) so
libdwarf uses NULL as the dbg. Those too wind up here. */
return;
}
}
/* App error, or an app that failed to succeed in a
dwarf_init() call. */
return;
}
if (type >= ALLOC_AREA_INDEX_TABLE_MAX) {
/* internal or user app error */
return;
}
/*
A string pointer may point into .debug_info or .debug_string.
Otherwise, they are directly malloc'ed. */
if (index == 0) {
if (type == DW_DLA_STRING) {
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
(Dwarf_Small *) space <
return;
#ifdef DWARF_SIMPLE_MALLOC
#endif
return;
}
if (type == DW_DLA_LIST ||
type == DW_DLA_FRAME_BLOCK ||
type == DW_DLA_RANGES ||
type == DW_DLA_HASH_TABLE_ENTRY) {
#ifdef DWARF_SIMPLE_MALLOC
#endif
return;
}
/* else is an alloc type that is not used */
/* app or internal error */
#ifdef DWARF_SIMPLE_MALLOC
#endif
return;
}
}
#ifdef DWARF_SIMPLE_MALLOC
#else /* !DWARF_SIMPLE_MALLOC */
/* Get pointer to Dwarf_Alloc_Area this struct came from. See
dwarf_alloc.h ROUND_SIZE_WITH_POINTER stuff */
/* ASSERT: alloc_area != NULL If NULL we could abort, let it
coredump below, or return, pretending all is well. We go on,
letting program crash. Is caller error. */
/*
Check that the alloc_hdr field of the alloc_area we have is
pointing to the right alloc_hdr. This is used to catch use of
incorrect deallocation code by the user. */
/* If we get here, the user has called dwarf_dealloc wrongly or
there is some other disastrous error. By leaking mem here we
try to be safe... */
#ifdef DEBUG
"libdwarf Internal error: type %d hdr mismatch %lx %lx "
"area ptr %lx\n",
(int) type,
(long) alloc_area->aa_alloc_hdr,
(long) alloc_hdr, (long) alloc_area);
#endif
return;
}
/*
Give chunk back to malloc only when every struct is freed */
if (alloc_area->aa_free_structs_in_chunk ==
} else {
}
}
}
}
else {
}
#endif /* !DWARF_SIMPLE_MALLOC */
}
/*
Allocates space for a Dwarf_Debug_s struct,
since one does not exist.
*/
_dwarf_get_debug(void
)
{
return (NULL);
else
return (dbg);
}
/*
Sets up the Dwarf_Debug_s struct for all the
allocation types currently defined.
Allocation types DW_DLA_STRING, DW_DLA_LIST,
DW_DLA_FRAME_BLOCK, DW_DLA_LOC_BLOCK, DW_DLA_RANGES are
malloc'ed directly.
This routine should be called after _dwarf_setup(),
so that information about the sizes of the Dwarf
sections can be used to decide the number of
structs of each type malloc'ed.
Also DW_DLA_ELLIST, DW_DLA_BOUNDS, DW_DLA_TYPE,
DW_DLA_SUBSCR, DW_DLA_LINEBUF allocation types
are currently not used.
The ah_bytes_one_struct and ah_structs_per_chunk fields for
these types have been set to 1 for efficiency
in dwarf_get_alloc().
Ah_alloc_num should be greater than 1 for all
types that are currently being used.
Therefore, for these allocation types the
ah_bytes_one_struct, and ah_structs_per_chunk fields do not
need to be initialized.
Being an internal routine, assume proper dbg.
*/
{
int i;
for (i = 1; i <= MAX_DW_DLA; i++) {
/* ah_structs_per_chunk must be >0 else we are in trouble */
}
return (dbg);
}
/*
This function prints out the statistics
collected on allocation of memory chunks.
*/
void
{
Dwarf_Shalf i;
/*
Alloc types start at 1, not 0. Hence, the first NULL string, and
also a size of MAX_DW_DLA + 1. */
"",
"DW_DLA_STRING",
"DW_DLA_LOC",
"DW_DLA_LOCDESC",
"DW_DLA_ELLIST",
"DW_DLA_BOUNDS",
"DW_DLA_BLOCK",
"DW_DLA_DEBUG",
"DW_DLA_DIE",
"DW_DLA_LINE",
"DW_DLA_ATTR",
"DW_DLA_TYPE",
"DW_DLA_SUBSCR",
"DW_DLA_GLOBAL",
"DW_DLA_ERROR",
"DW_DLA_LIST",
"DW_DLA_LINEBUF",
"DW_DLA_ARANGE",
"DW_DLA_ABBREV",
"DW_DLA_FRAME_OP",
"DW_DLA_CIE",
"DW_DLA_FDE",
"DW_DLA_LOC_BLOCK",
"DW_DLA_FRAME_BLOCK",
"DW_DLA_FUNC",
"DW_DLA_TYPENAME",
"DW_DLA_VAR",
"DW_DLA_WEAK",
"DW_DLA_ADDR",
"DW_DLA_RANGES",
"DW_DLA_ABBREV_LIST",
"DW_DLA_CHAIN",
"DW_DLA_CU_CONTEXT",
"DW_DLA_FRAME",
"DW_DLA_GLOBAL_CONTEXT",
"DW_DLA_FILE_ENTRY",
"DW_DLA_LINE_CONTEXT",
"DW_DLA_LOC_CHAIN",
"DW_DLA_HASH_TABLE",
"DW_DLA_FUNC_CONTEXT",
"DW_DLA_TYPENAME_CONTEXT",
"DW_DLA_VAR_CONTEXT",
"DW_DLA_WEAK_CONTEXT",
"DW_DLA_PUBTYPES_CONTEXT",
"DW_DLA_HASH_TABLE_ENTRY",
};
return;
printf("Size of Dwarf_Debug %4ld bytes\n",
(long) sizeof(*dbg));
printf("Size of Dwarf_Alloc_Hdr_s %4ld bytes\n",
(long) sizeof(struct Dwarf_Alloc_Hdr_s));
printf("size of Dwarf_Alloc_Area_s %4ld bytes\n",
(long) sizeof(struct Dwarf_Alloc_Area_s));
printf(" Alloc Type Curr Structs byt str\n");
printf(" ---------- ---- ------- per per\n");
for (i = 1; i <= MAX_DW_DLA; i++) {
printf("%2d %-25s %6d %8d %6d %6d\n",
(int) i,
alloc_type_name[i],
(int) alloc_hdr->ah_chunks_allocated,
(int) alloc_hdr->ah_struct_user_holds,
(int) alloc_hdr->ah_bytes_malloc_per_chunk,
(int) alloc_hdr->ah_structs_per_chunk);
}
}
}
#ifndef DWARF_SIMPLE_MALLOC
/*
This recursively frees
the chunks still allocated, and
forward chained through the aa_next
pointer.
*/
static void
{
}
alloc_area->aa_next = 0;
alloc_area->aa_prev = 0;
}
#endif
/* In the 'rela' relocation case we might have malloc'd
space to ensure it is read-write. In that case, free the space. */
static void
{
if (sec->dss_data_was_malloc) {
}
sec->dss_data_was_malloc = 0;
}
/*
Used to free all space allocated for this Dwarf_Debug.
The caller should assume that the Dwarf_Debug pointer
itself is no longer valid upon return from this function.
In case of difficulty, this function simply returns quietly.
*/
int
{
Dwarf_Shalf i;
Dwarf_CU_Context context = 0;
return (DW_DLV_ERROR);
/* To do complete validation that we have no surprising missing or
erroneous deallocs it is advisable to do the dwarf_deallocs here
that are not things the user can otherwise request.
Housecleaning. */
}
/* Housecleaning done. Now really free all the space. */
#ifdef DWARF_SIMPLE_MALLOC
if (dbg->de_simple_malloc_base) {
while (smp) {
int i;
struct simple_malloc_record_s *prev_smp = 0;
struct simple_malloc_entry_s *cur;
}
}
}
dbg->de_simple_malloc_base = 0;
}
#else
for (i = 1; i < ALLOC_AREA_REAL_TABLE_MAX; i++) {
int indx = i;
}
}
#endif
return (DW_DLV_OK);
}
/* A special case: we have no dbg, no alloc header etc.
So create something out of thin air that we can recognize
in dwarf_dealloc.
Something with the prefix (prefix space hidden from caller).
Only applies to DW_DLA_ERROR, making up an error record.
*/
struct Dwarf_Error_s *
{
/* the union unused things are to guarantee proper alignment */
union u {
struct Dwarf_Error_s base_not_used;
char data_space[sizeof(struct Dwarf_Error_s) +
(DW_RESERVE * 2)];
};
char *mem;
if (mem == 0) {
return 0;
}
mem += DW_RESERVE;
return (struct Dwarf_Error_s *) mem;
}
/* The free side of _dwarf_special_no_dbg_error_malloc()
*/
static void
{
mem -= DW_RESERVE;
}
#ifdef DWARF_SIMPLE_MALLOC
/* here solely for planting a breakpoint. */
/* ARGSUSED */
void
{
}
static void
unsigned long size, short alloc_type)
{
struct simple_malloc_record_s *cur;
struct simple_malloc_entry_s *newentry;
if (!dbg->de_simple_malloc_base) {
/* First entry to this routine. */
malloc(sizeof(struct simple_malloc_record_s));
if (!dbg->de_simple_malloc_base) {
return; /* no memory, give up */
}
0, sizeof(struct simple_malloc_record_s));
}
/* Better not be > than as that means chaos */
/* Create a new block to link at the head. */
struct simple_malloc_record_s *newblock =
malloc(sizeof(struct simple_malloc_record_s));
if (!newblock) {
return; /* Can do nothing, out of memory */
}
/* Link the new block at the head of the chain, and make it
'current' */
}
}
/*
DWARF_SIMPLE_MALLOC: testing the hypothesis that the existing
malloc scheme here (see _dwarf_get_alloc()) is pointless complexity.
DWARF_SIMPLE_MALLOC also makes it easy for a malloc-tracing
tool to verify libdwarf malloc has no botches (though of course
such does not test the complicated standard-libdwarf-alloc code).
To properly answer the question, the simple-malloc allocate
and delete should be something other than a simple list.
Perhaps a heap, or perhaps a red-black tree.
*/
static void
{
if (space == 0) {
}
if (dbg->de_simple_malloc_base) {
while (smp) {
int i;
struct simple_malloc_entry_s *cur;
}
return;
}
}
}
}
/* Never found the space. */
return;
}
#endif