1/*
2
3  Copyright (C) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
4  Portions Copyright (C) 2007-2010  David Anderson. All Rights Reserved.
5
6  This program is free software; you can redistribute it and/or modify it
7  under the terms of version 2.1 of the GNU Lesser General Public License
8  as published by the Free Software Foundation.
9
10  This program is distributed in the hope that it would be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13
14  Further, this software is distributed without any warranty that it is
15  free of the rightful claim of any third person regarding infringement
16  or the like.  Any license provided herein, whether implied or
17  otherwise, applies only to this software file.  Patent licenses, if
18  any, provided herein do not apply to combinations of this program with
19  other software, or any other product whatsoever.
20
21  You should have received a copy of the GNU Lesser General Public
22  License along with this program; if not, write the Free Software
23  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
24  USA.
25
26  Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,
27  Mountain View, CA 94043, or:
28
29  http://www.sgi.com
30
31  For further information regarding this notice, see:
32
33  http://oss.sgi.com/projects/GenInfo/NoticeExplan
34
35*/
36/* The address of the Free Software Foundation is
37   Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
38   Boston, MA 02110-1301, USA.
39   SGI has moved from the Crittenden Lane address.
40*/
41
42
43#undef  DEBUG
44
45#include "config.h"
46#include "dwarf_incl.h"
47#include <sys/types.h>
48
49#include <stdlib.h>
50#include <stdio.h>
51#include "malloc_check.h"
52
53/*
54    These files are included to get the sizes
55    of structs to set the ah_bytes_one_struct field
56    of the Dwarf_Alloc_Hdr_s structs for each
57    allocation type.
58*/
59#include "dwarf_line.h"
60#include "dwarf_global.h"
61#include "dwarf_arange.h"
62#include "dwarf_abbrev.h"
63#include "dwarf_die_deliv.h"
64#include "dwarf_frame.h"
65#include "dwarf_loc.h"
66#include "dwarf_funcs.h"
67#include "dwarf_types.h"
68#include "dwarf_vars.h"
69#include "dwarf_weaks.h"
70
71
72static void _dwarf_free_special_error(Dwarf_Ptr space);
73
74#ifdef DWARF_SIMPLE_MALLOC
75static void _dwarf_simple_malloc_add_to_list(Dwarf_Debug dbg,
76    Dwarf_Ptr addr,
77    unsigned long size,
78    short alloc_type);
79static void _dwarf_simple_malloc_delete_from_list(Dwarf_Debug dbg,
80    Dwarf_Ptr space,
81    short alloc_type);
82void _dwarf_simple_malloc_botch(int err);
83
84#endif /* DWARF_SIMPLE_MALLOC */
85
86
87
88
89/*
90    This macro adds the size of a pointer to the size of a
91    struct that is given to it.  It rounds up the size to
92    be a multiple of the size of a pointer.  This is done
93    so that every struct returned by _dwarf_get_alloc()
94    can be preceded by a pointer to the chunk it came from.
95    Before allocating, it checks if the size of struct is less than
96    the size of a pointer.  If yes, it returns the size
97    of 2 pointers.  The returned size should be at least
98    the size of 2 pointers, since the first points to the
99    chunk the struct was allocated from, and the second
100    is used to link the free list.
101
102    We want DW_RESERVE to be at least the size of
103    a long long and at least the size of a pointer because
104    our struct has a long long and we want that aligned right.
105    Now Standard C defines long long as 8 bytes, so lets
106    make that standard. It will become unworkable when
107    long long or pointer grows beyound 8 bytes.
108    Unclear what to do with wierd requirements, like
109    36 bit pointers.
110
111
112*/
113#define DW_RESERVE 8
114
115/* Round size up to the next multiple of DW_RESERVE bytes
116*/
117#define ROUND_SIZE(inputsize)                 \
118        (((inputsize) % (DW_RESERVE)) == 0 ? \
119            (inputsize):                      \
120            ((inputsize)  +                   \
121               (DW_RESERVE) - ((inputsize) % (DW_RESERVE)) ))
122
123#define ROUND_SIZE_WITH_POINTER(i_size) (ROUND_SIZE(i_size) + DW_RESERVE)
124
125/* SMALL_ALLOC is for trivia where allocation is a waste.
126   Things that should be removed, really. */
127#define SMALL_ALLOC 2
128
129/* BASE_ALLOC is where a basic allocation makes sense, but 'not too large'.
130   No thorough evaluation of this value has been done, though
131   it was found wasteful of memory to have BASE_ALLOC be as large as
132   BIG_ALLOC. */
133#define BASE_ALLOC 64
134
135/* BIG_ALLOC is where a larger-than-BASE_ALLOC
136   allocation makes sense, but still 'not too large'.
137   No thorough evaluation of this value has been done. */
138#define BIG_ALLOC  128
139
140/* This translates into de_alloc_hdr index
141** the 0,1,1 entries are special: they don't use the
142** table values at all.
143** Rearranging the DW_DLA values would break binary compatibility
144** so that is not an option.
145*/
146struct ial_s {
147    int ia_al_num;              /* Index into de_alloc_hdr table. */
148
149    /* In bytes, one struct instance. This does not account for extra
150       space needed per block, but that (DW_RESERVE) will be added in
151       later where it is needed (DW_RESERVE space never added in here).
152     */
153    int ia_struct_size;
154
155
156    /* Number of instances per alloc block. MUST be > 0. */
157    int ia_base_count;
158
159    int (*specialconstructor) (Dwarf_Debug, void *);
160    void (*specialdestructor) (void *);
161};
162
163static const
164struct ial_s index_into_allocated[ALLOC_AREA_INDEX_TABLE_MAX] = {
165    {0, 1, 1, 0, 0},            /* none */
166    {0, 1, 1, 0, 0},            /* 1 DW_DLA_STRING */
167    {1, sizeof(Dwarf_Loc), BASE_ALLOC, 0, 0}
168    ,                           /* 2 DW_DLA_LOC */
169    {2, sizeof(Dwarf_Locdesc), BASE_ALLOC, 0, 0}
170    ,                           /* 3 DW_DLA_LOCDESC */
171    {0, 1, 1, 0, 0}
172    ,                           /* not used *//* 4 DW_DLA_ELLIST */
173    {0, 1, 1, 0, 0}
174    ,                           /* not used *//* 5 DW_DLA_BOUNDS */
175    {3, sizeof(Dwarf_Block), BASE_ALLOC, 0, 0}
176    ,                           /* 6 DW_DLA_BLOCK */
177    {0, 1, 1, 0, 0}
178    ,                           /* the actual dwarf_debug structure *//* 7 DW_DLA_DEBUG */
179    {4, sizeof(struct Dwarf_Die_s), BIG_ALLOC, 0, 0},   /* 8 DW_DLA_DIE
180                                                         */
181    {5, sizeof(struct Dwarf_Line_s), BIG_ALLOC, 0, 0},  /* 9
182                                                           DW_DLA_LINE */
183    {6, sizeof(struct Dwarf_Attribute_s), BIG_ALLOC * 2, 0, 0},
184    /* 10 DW_DLA_ATTR */
185    {0, 1, 1, 0, 0},            /* not used *//* 11 DW_DLA_TYPE */
186    {0, 1, 1, 0, 0},            /* not used *//* 12 DW_DLA_SUBSCR */
187    {7, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0},       /* 13
188                                                                   DW_DLA_GLOBAL
189                                                                 */
190    {8, sizeof(struct Dwarf_Error_s), BASE_ALLOC, 0, 0},        /* 14
191                                                                   DW_DLA_ERROR
192                                                                 */
193    {0, 1, 1, 0, 0},            /* 15 DW_DLA_LIST */
194    {0, 1, 1, 0, 0},            /* not used *//* 16 DW_DLA_LINEBUF */
195    {9, sizeof(struct Dwarf_Arange_s), BASE_ALLOC, 0, 0},       /* 17
196                                                                   DW_DLA_ARANGE
197                                                                 */
198    {10, sizeof(struct Dwarf_Abbrev_s), BIG_ALLOC, 0, 0},       /* 18
199                                                                   DW_DLA_ABBREV
200                                                                 */
201    {11, sizeof(Dwarf_Frame_Op), BIG_ALLOC, 0, 0}
202    ,                           /* 19 DW_DLA_FRAME_OP */
203    {12, sizeof(struct Dwarf_Cie_s), BASE_ALLOC, 0, 0}, /* 20
204                                                           DW_DLA_CIE */
205    {13, sizeof(struct Dwarf_Fde_s), BASE_ALLOC, 0, 0}, /* 21 DW_DLA_FDE */
206    {0, 1, 1, 0, 0},            /* 22 DW_DLA_LOC_BLOCK */
207    {0, 1, 1, 0, 0},            /* 23 DW_DLA_FRAME_BLOCK */
208    {14, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 24 DW_DLA_FUNC
209                                                              UNUSED */
210    {15, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 25
211                                                              DW_DLA_TYPENAME
212                                                              UNUSED */
213    {16, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 26 DW_DLA_VAR
214                                                              UNUSED */
215    {17, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 27 DW_DLA_WEAK
216                                                              UNUSED */
217    {0, 1, 1, 0, 0},            /* 28 DW_DLA_ADDR */
218    {0, 1,1,0,0 },              /* 29 DW_DLA_RANGES */
219
220    /* The following DW_DLA data types
221       are known only inside libdwarf.  */
222
223    {18, sizeof(struct Dwarf_Abbrev_List_s), BIG_ALLOC, 0, 0},
224    /* 30 DW_DLA_ABBREV_LIST */
225
226    {19, sizeof(struct Dwarf_Chain_s), BIG_ALLOC, 0, 0}, /* 31 DW_DLA_CHAIN */
227    {20, sizeof(struct Dwarf_CU_Context_s), BASE_ALLOC, 0, 0},
228    /* 32 DW_DLA_CU_CONTEXT */
229    {21, sizeof(struct Dwarf_Frame_s), BASE_ALLOC,
230     _dwarf_frame_constructor,
231     _dwarf_frame_destructor},  /* 33 DW_DLA_FRAME */
232    {22, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0},
233    /* 34 DW_DLA_GLOBAL_CONTEXT */
234    {23, sizeof(struct Dwarf_File_Entry_s), BASE_ALLOC, 0, 0},  /* 34 */
235    /* 35 DW_DLA_FILE_ENTRY */
236    {24, sizeof(struct Dwarf_Line_Context_s), BASE_ALLOC, 0, 0},
237    /* 36 DW_DLA_LINE_CONTEXT */
238    {25, sizeof(struct Dwarf_Loc_Chain_s), BASE_ALLOC, 0, 0},   /* 36 */
239    /* 37 DW_DLA_LOC_CHAIN */
240
241    {26, sizeof(struct Dwarf_Hash_Table_s),BASE_ALLOC, 0, 0},   /* 37 */
242    /* 38 DW_DLA_HASH_TABLE */
243
244/* The following really use Global struct: used to be unique struct
245   per type, but now merged (11/99).  The opaque types
246   are visible in the interface. The types  for
247   DW_DLA_FUNC,
248   DW_DLA_TYPENAME, DW_DLA_VAR, DW_DLA_WEAK also use
249   the global types.
250
251*/
252    {27, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0},
253    /* 39 DW_DLA_FUNC_CONTEXT */
254    {28, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0},
255    /* 40 DW_DLA_TYPENAME_CONTEXT */
256    {29, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0},
257    /* 41 DW_DLA_VAR_CONTEXT */
258    {30, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0},
259    /* 42 DW_DLA_WEAK_CONTEXT */
260    {31, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0},
261    /* 43 DW_DLA_PUBTYPES_CONTEXT DWARF3 */
262
263    {0,1,1,0,0 },
264    /* 44 DW_DLA_HASH_TABLE_ENTRY */
265
266
267};
268
269#ifndef DWARF_SIMPLE_MALLOC
270
271/*
272    This function is given a pointer to the header
273    structure that is used to allocate 1 struct of
274    the type given by alloc_type.  It first checks
275    if a struct is available in its free list.  If
276    not, it checks if 1 is available in its blob,
277    which is a chunk of memory that is reserved for
278    its use.  If not, it malloc's a chunk.  The
279    initial part of it is used to store the end
280    address of the chunk, and also to keep track
281    of the number of free structs in that chunk.
282    This information is used for freeing the chunk
283    when all the structs in it are free.
284
285    Assume all input arguments have been validated.
286
287    This function can be used only to allocate 1
288    struct of the given type.
289
290    It returns a pointer to the struct that the
291    user can use.  It returns NULL only when it
292    is out of free structs, and cannot malloc
293    any more.  The struct returned is zero-ed.
294
295    A pointer to the chunk that the struct belongs
296    to is stored in the bytes preceding the
297    returned address.  Since this pointer it
298    never overwritten, when a struct is allocated
299    from the free_list this pointer does not
300    have to be written.  In the 2 other cases,
301    where the struct is allocated from a new
302    chunk, or the blob, a pointer to the chunk
303    is written.
304*/
305static Dwarf_Ptr
306_dwarf_find_memory(Dwarf_Alloc_Hdr alloc_hdr)
307{
308    /* Pointer to the struct allocated. */
309    Dwarf_Small *ret_mem = 0;
310
311    /* Pointer to info about chunks allocated. */
312    Dwarf_Alloc_Area alloc_area;
313
314    /* Size of chunk malloc'ed when no free structs left. */
315    Dwarf_Signed mem_block_size;
316
317    /* Pointer to block malloc'ed. */
318    Dwarf_Small *mem_block;
319
320    /*
321       Check the alloc_area from which the last allocation was made
322       (most recent new block). If that is not successful, then search
323       the list of alloc_area's from alloc_header. */
324    alloc_area = alloc_hdr->ah_last_alloc_area;
325    if (alloc_area == NULL || alloc_area->aa_free_structs_in_chunk == 0)
326        for (alloc_area = alloc_hdr->ah_alloc_area_head;
327             alloc_area != NULL; alloc_area = alloc_area->aa_next) {
328
329            if (alloc_area->aa_free_structs_in_chunk > 0) {
330                break;          /* found a free entry! */
331            }
332
333        }
334
335    if (alloc_area != NULL) {
336        alloc_area->aa_free_structs_in_chunk--;
337
338        if (alloc_area->aa_free_list != NULL) {
339            ret_mem = alloc_area->aa_free_list;
340
341            /*
342               Update the free list.  The initial part of the struct is
343               used to hold a pointer to the next struct on the free
344               list.  In this way, the free list chain is maintained at
345               0 memory cost. */
346            alloc_area->aa_free_list =
347                ((Dwarf_Free_List) ret_mem)->fl_next;
348        } else if (alloc_area->aa_blob_start < alloc_area->aa_blob_end) {
349            ret_mem = alloc_area->aa_blob_start;
350
351            /*
352               Store pointer to chunk this struct belongs to in the
353               first few bytes.  Return pointer to bytes after this
354               pointer storage. */
355            *(Dwarf_Alloc_Area *) ret_mem = alloc_area;
356            ret_mem += DW_RESERVE;
357
358            alloc_area->aa_blob_start += alloc_hdr->ah_bytes_one_struct;
359        } else {
360            /* else fall thru , though it should be impossible to fall
361               thru. And represents a disastrous programming error if
362               we get here. */
363#ifdef DEBUG
364            fprintf(stderr, "libdwarf Internal error start %x end %x\n",
365                    (int) alloc_area->aa_blob_start,
366                    (int) alloc_area->aa_blob_end);
367#endif
368        }
369    }
370
371    /* New memory has to malloc'ed since there are no free structs. */
372    if (ret_mem == 0) {
373        Dwarf_Word rounded_area_hdr_size;
374
375        alloc_hdr->ah_chunks_allocated++;
376
377        {                       /* this nonsense avoids a warning */
378            /* CONSTCOND would be better */
379            unsigned long v = sizeof(struct Dwarf_Alloc_Area_s);
380
381            rounded_area_hdr_size = ROUND_SIZE(v);
382        }
383
384        /*
385           Allocate memory to contain the required number of structs
386           and the Dwarf_Alloc_Area_s to control it. */
387        mem_block_size = alloc_hdr->ah_bytes_malloc_per_chunk +
388            rounded_area_hdr_size;
389
390        mem_block = malloc(mem_block_size);
391        if (mem_block == NULL) {
392            return (NULL);
393        }
394
395
396        /*
397           Attach the Dwarf_Alloc_Area_s struct to the list of chunks
398           malloc'ed for this struct type. Also initialize the fields
399           of the Dwarf_Alloc_Area_s. */
400        alloc_area = (Dwarf_Alloc_Area) mem_block;
401        alloc_area->aa_prev = 0;
402        if (alloc_hdr->ah_alloc_area_head != NULL) {
403            alloc_hdr->ah_alloc_area_head->aa_prev = alloc_area;
404        }
405        alloc_area->aa_free_list = 0;
406        alloc_area->aa_next = alloc_hdr->ah_alloc_area_head;
407        alloc_hdr->ah_alloc_area_head = alloc_area;
408
409        alloc_area->aa_alloc_hdr = alloc_hdr;
410        alloc_area->aa_free_structs_in_chunk =
411            (Dwarf_Sword) alloc_hdr->ah_structs_per_chunk - 1;
412        if (alloc_area->aa_free_structs_in_chunk < 1) {
413            /* If we get here, there is a disastrous programming error
414               somewhere. */
415#ifdef DEBUG
416            fprintf(stderr,
417                    "libdwarf Internal error: free structs in chunk %d\n",
418                    (int) alloc_area->aa_free_structs_in_chunk);
419#endif
420            return NULL;
421        }
422
423        /*
424           The struct returned begins immediately after the
425           Dwarf_Alloc_Area_s struct. */
426        ret_mem = mem_block + rounded_area_hdr_size;
427        alloc_area->aa_blob_start =
428            ret_mem + alloc_hdr->ah_bytes_one_struct;
429        alloc_area->aa_blob_end = mem_block + mem_block_size;
430
431        /*
432           Store pointer to chunk this struct belongs to in the first
433           few bytes.  Return pointer to bytes after this pointer
434           storage. */
435        *(Dwarf_Alloc_Area *) ret_mem = alloc_area;
436        ret_mem += DW_RESERVE;
437    }
438
439    alloc_hdr->ah_last_alloc_area = alloc_area;
440    alloc_hdr->ah_struct_user_holds++;
441    memset(ret_mem, 0, alloc_hdr->ah_bytes_one_struct - DW_RESERVE);
442    return (ret_mem);
443}
444
445#endif /* ndef DWARF_SIMPLE_MALLOC */
446
447/*
448    This function returns a pointer to a region
449    of memory.  For alloc_types that are not
450    strings or lists of pointers, only 1 struct
451    can be requested at a time.  This is indicated
452    by an input count of 1.  For strings, count
453    equals the length of the string it will
454    contain, i.e it the length of the string
455    plus 1 for the terminating null.  For lists
456    of pointers, count is equal to the number of
457    pointers.  For DW_DLA_FRAME_BLOCK, DW_DLA_RANGES, and
458    DW_DLA_LOC_BLOCK allocation types also, count
459    is the count of the number of structs needed.
460
461    This function cannot be used to allocate a
462    Dwarf_Debug_s struct.
463
464*/
465Dwarf_Ptr
466_dwarf_get_alloc(Dwarf_Debug dbg,
467                 Dwarf_Small alloc_type, Dwarf_Unsigned count)
468{
469    Dwarf_Alloc_Hdr alloc_hdr;
470
471    Dwarf_Ptr ret_mem;
472
473    Dwarf_Signed size = 0;
474    unsigned int index;
475    unsigned int type = alloc_type;
476
477    if (dbg == NULL) {
478        return (NULL);
479    }
480
481    if (type >= ALLOC_AREA_INDEX_TABLE_MAX) {
482        /* internal error */
483        return NULL;
484    }
485    index = index_into_allocated[type].ia_al_num;
486    /* zero also illegal but not tested for */
487
488    /* If the Dwarf_Debug is not fully set up, we will get index 0 for
489       any type and must do something.  'Not fully set up' can only
490       happen for DW_DLA_ERROR, I (davea) believe, and for that we call
491       special code here.. */
492
493    if (index == 0) {
494        if (alloc_type == DW_DLA_STRING) {
495            size = count;
496        } else if (alloc_type == DW_DLA_LIST) {
497            size = count * sizeof(Dwarf_Ptr);
498        } else if (alloc_type == DW_DLA_FRAME_BLOCK) {
499            size = count * sizeof(Dwarf_Frame_Op);
500        } else if (alloc_type == DW_DLA_LOC_BLOCK) {
501            size = count * sizeof(Dwarf_Loc);
502        } else if (alloc_type == DW_DLA_HASH_TABLE_ENTRY) {
503            size = count * sizeof(struct Dwarf_Hash_Table_Entry_s);
504        } else if (alloc_type == DW_DLA_ADDR) {
505            size = count *
506                (sizeof(Dwarf_Addr) > sizeof(Dwarf_Off) ?
507                 sizeof(Dwarf_Addr) : sizeof(Dwarf_Off));
508        } else if (alloc_type == DW_DLA_RANGES) {
509            size = count * sizeof(Dwarf_Ranges);
510        } else if (alloc_type == DW_DLA_ERROR) {
511            void *m = _dwarf_special_no_dbg_error_malloc();
512
513            dwarf_malloc_check_alloc_data(m, DW_DLA_ERROR);
514            return m;
515
516        } else {
517            /* If we get here, there is a disastrous programming error
518               somewhere. */
519#ifdef DEBUG
520            fprintf(stderr,
521                    "libdwarf Internal error: type %d  unexpected\n",
522                    (int) type);
523#endif
524        }
525    } else {
526        alloc_hdr = &dbg->de_alloc_hdr[index];
527        if (alloc_hdr->ah_bytes_one_struct > 0) {
528#ifdef DWARF_SIMPLE_MALLOC
529            size = alloc_hdr->ah_bytes_one_struct;
530#else
531            {
532                void *m = _dwarf_find_memory(alloc_hdr);
533
534                dwarf_malloc_check_alloc_data(m, type);
535                if (index_into_allocated[type].specialconstructor) {
536                    int res =
537                        index_into_allocated[type].
538                        specialconstructor(dbg, m);
539                    if (res != DW_DLV_OK) {
540                        /* We leak what we allocated in
541                           _dwarf_find_memory when constructor fails. */
542                        return NULL;
543                    }
544                }
545                return m;
546            }
547#endif
548
549        } else {
550            /* Special case: should not really happen at all. */
551            if (type == DW_DLA_ERROR) {
552                /* dwarf_init failure. Because dbg is incomplete we
553                   won't use it to record the malloc. */
554                void *m = _dwarf_special_no_dbg_error_malloc();
555
556                dwarf_malloc_check_alloc_data(m, DW_DLA_ERROR);
557                return m;
558            } else {
559                /* If we get here, there is a disastrous programming
560                   error somewhere. */
561#ifdef DWARF_SIMPLE_MALLOC
562                _dwarf_simple_malloc_botch(3);
563#endif
564#ifdef DEBUG
565                fprintf(stderr,
566                        "libdwarf Internal error: Type %d  unexpected\n",
567                        (int) type);
568#endif
569            }
570        }
571    }
572
573    ret_mem = malloc(size);
574#ifdef DWARF_SIMPLE_MALLOC
575    _dwarf_simple_malloc_add_to_list(dbg, ret_mem, (unsigned long) size,
576                                     type);
577#endif
578    if (ret_mem != NULL)
579        memset(ret_mem, 0, size);
580
581    dwarf_malloc_check_alloc_data(ret_mem, type);
582    if (index_into_allocated[type].specialconstructor) {
583        int res =
584            index_into_allocated[type].specialconstructor(dbg, ret_mem);
585        if (res != DW_DLV_OK) {
586            /* We leak what we allocated in _dwarf_find_memory when
587               constructor fails. */
588            return NULL;
589        }
590    }
591
592    return (ret_mem);
593}
594
595
596
597/*
598    This function is used to deallocate a region of memory
599    that was obtained by a call to _dwarf_get_alloc.  Note
600    that though dwarf_dealloc() is a public function,
601    _dwarf_get_alloc() isn't.
602
603    For lists, typically arrays of pointers, it is assumed
604    that the space was allocated by a direct call to malloc,
605    and so a straight free() is done.  This is also the case
606    for variable length blocks such as DW_DLA_FRAME_BLOCK
607    and DW_DLA_LOC_BLOCK and DW_DLA_RANGES.
608
609    For strings, the pointer might point to a string in
610    .debug_info or .debug_string.  After this is checked,
611    and if found not to be the case, a free() is done,
612    again on the assumption that a malloc was used to
613    obtain the space.
614
615    For other types of structs, a pointer to the chunk that
616    the struct was allocated out of, is present in the bytes
617    preceding the pointer passed in.  For this chunk it is
618    checked whether all the structs in that chunk are now free.
619    If so, the entire chunk is free_ed.  Otherwise, the space
620    is added to the free list for that chunk, and the free count
621    incremented.
622
623    This function does not return anything.
624*/
625void
626dwarf_dealloc(Dwarf_Debug dbg,
627              Dwarf_Ptr space, Dwarf_Unsigned alloc_type)
628{
629    Dwarf_Alloc_Hdr alloc_hdr;
630    Dwarf_Alloc_Area alloc_area;
631    unsigned int type = alloc_type;
632    unsigned int index;
633
634    if (space == NULL) {
635        return;
636    }
637    if (type == DW_DLA_ERROR) {
638        /* Get pointer to Dwarf_Alloc_Area this struct came from. See
639           dwarf_alloc.h ROUND_SIZE_WITH_POINTER stuff */
640        alloc_area =
641            *(Dwarf_Alloc_Area *) ((char *) space - DW_RESERVE);
642        if (alloc_area == 0) {
643            /* This is the special case of a failed dwarf_init(). Also
644               (and more signficantly) there are a variety of other
645               situations where libdwarf does not *know* what dbg is
646               involved (because of a libdwarf-caller-error) so
647               libdwarf uses NULL as the dbg. Those too wind up here. */
648            _dwarf_free_special_error(space);
649            dwarf_malloc_check_dealloc_data(space, type);
650            return;
651        }
652
653    }
654    if (dbg == NULL) {
655        /* App error, or an app that failed to succeed in a
656           dwarf_init() call. */
657        return;
658    }
659    if (type >= ALLOC_AREA_INDEX_TABLE_MAX) {
660        /* internal or user app error */
661        return;
662    }
663
664    index = index_into_allocated[type].ia_al_num;
665    /*
666       A string pointer may point into .debug_info or .debug_string.
667       Otherwise, they are directly malloc'ed. */
668    dwarf_malloc_check_dealloc_data(space, type);
669    if (index == 0) {
670        if (type == DW_DLA_STRING) {
671            if ((Dwarf_Small *) space >= dbg->de_debug_info.dss_data &&
672                (Dwarf_Small *) space <
673                dbg->de_debug_info.dss_data + dbg->de_debug_info.dss_size)
674                return;
675
676            if (dbg->de_debug_line.dss_data != NULL &&
677                (Dwarf_Small *) space >= dbg->de_debug_line.dss_data &&
678                (Dwarf_Small *) space <
679                dbg->de_debug_line.dss_data + dbg->de_debug_line.dss_size)
680                return;
681
682            if (dbg->de_debug_pubnames.dss_data != NULL &&
683                (Dwarf_Small *) space >= dbg->de_debug_pubnames.dss_data &&
684                (Dwarf_Small *) space <
685                dbg->de_debug_pubnames.dss_data +
686                dbg->de_debug_pubnames.dss_size)
687                return;
688
689            if (dbg->de_debug_frame.dss_data != NULL &&
690                (Dwarf_Small *) space >= dbg->de_debug_frame.dss_data &&
691                (Dwarf_Small *) space <
692                dbg->de_debug_frame.dss_data + dbg->de_debug_frame.dss_size)
693                return;
694
695            if (dbg->de_debug_str.dss_data != NULL &&
696                (Dwarf_Small *) space >= dbg->de_debug_str.dss_data &&
697                (Dwarf_Small *) space <
698                dbg->de_debug_str.dss_data + dbg->de_debug_str.dss_size)
699                return;
700
701            if (dbg->de_debug_funcnames.dss_data != NULL &&
702                (Dwarf_Small *) space >= dbg->de_debug_funcnames.dss_data &&
703                (Dwarf_Small *) space <
704                dbg->de_debug_funcnames.dss_data +
705                dbg->de_debug_funcnames.dss_size)
706                return;
707
708            if (dbg->de_debug_typenames.dss_data != NULL &&
709                (Dwarf_Small *) space >= dbg->de_debug_typenames.dss_data &&
710                (Dwarf_Small *) space <
711                dbg->de_debug_typenames.dss_data +
712                dbg->de_debug_typenames.dss_size)
713                return;
714            if (dbg->de_debug_pubtypes.dss_data != NULL &&
715                (Dwarf_Small *) space >= dbg->de_debug_pubtypes.dss_data &&
716                (Dwarf_Small *) space <
717                    dbg->de_debug_pubtypes.dss_data +
718                    dbg->de_debug_pubtypes.dss_size)
719                return;
720
721            if (dbg->de_debug_varnames.dss_data != NULL &&
722                (Dwarf_Small *) space >= dbg->de_debug_varnames.dss_data &&
723                (Dwarf_Small *) space <
724                dbg->de_debug_varnames.dss_data +
725                dbg->de_debug_varnames.dss_size)
726                return;
727
728            if (dbg->de_debug_weaknames.dss_data != NULL &&
729                (Dwarf_Small *) space >= dbg->de_debug_weaknames.dss_data &&
730                (Dwarf_Small *) space <
731                dbg->de_debug_weaknames.dss_data +
732                dbg->de_debug_weaknames.dss_size)
733                return;
734
735#ifdef DWARF_SIMPLE_MALLOC
736            _dwarf_simple_malloc_delete_from_list(dbg, space, type);
737#endif
738            free(space);
739            return;
740        }
741
742        if (type == DW_DLA_LIST ||
743            type == DW_DLA_FRAME_BLOCK ||
744            type == DW_DLA_LOC_BLOCK || type == DW_DLA_ADDR ||
745            type == DW_DLA_RANGES ||
746            type == DW_DLA_HASH_TABLE_ENTRY) {
747
748#ifdef DWARF_SIMPLE_MALLOC
749            _dwarf_simple_malloc_delete_from_list(dbg, space, type);
750#endif
751            free(space);
752            return;
753        }
754        /* else is an alloc type that is not used */
755        /* app or internal error */
756#ifdef DWARF_SIMPLE_MALLOC
757        _dwarf_simple_malloc_botch(4);
758#endif
759        return;
760
761    }
762    if (index_into_allocated[type].specialdestructor) {
763        index_into_allocated[type].specialdestructor(space);
764    }
765#ifdef DWARF_SIMPLE_MALLOC
766    _dwarf_simple_malloc_delete_from_list(dbg, space, type);
767    free(space);
768#else /* !DWARF_SIMPLE_MALLOC */
769    alloc_hdr = &dbg->de_alloc_hdr[index];
770
771    /* Get pointer to Dwarf_Alloc_Area this struct came from. See
772       dwarf_alloc.h ROUND_SIZE_WITH_POINTER stuff */
773    alloc_area = *(Dwarf_Alloc_Area *) ((char *) space - DW_RESERVE);
774
775    /* ASSERT: alloc_area != NULL If NULL we could abort, let it
776       coredump below, or return, pretending all is well. We go on,
777       letting program crash. Is caller error. */
778
779    /*
780       Check that the alloc_hdr field of the alloc_area we have is
781       pointing to the right alloc_hdr.  This is used to catch use of
782       incorrect deallocation code by the user. */
783    if (alloc_area->aa_alloc_hdr != alloc_hdr) {
784        /* If we get here, the user has called dwarf_dealloc wrongly or
785           there is some other disastrous error. By leaking mem here we
786           try to be safe... */
787#ifdef DEBUG
788        fprintf(stderr,
789                "libdwarf Internal error: type %d hdr mismatch %lx %lx "
790                "area ptr %lx\n",
791                (int) type,
792                (long) alloc_area->aa_alloc_hdr,
793                (long) alloc_hdr, (long) alloc_area);
794#endif
795        return;
796    }
797
798    alloc_hdr->ah_struct_user_holds--;
799    alloc_area->aa_free_structs_in_chunk++;
800
801    /*
802       Give chunk back to malloc only when every struct is freed */
803    if (alloc_area->aa_free_structs_in_chunk ==
804        alloc_hdr->ah_structs_per_chunk) {
805        if (alloc_area->aa_prev != NULL) {
806            alloc_area->aa_prev->aa_next = alloc_area->aa_next;
807        } else {
808            alloc_hdr->ah_alloc_area_head = alloc_area->aa_next;
809        }
810
811        if (alloc_area->aa_next != NULL) {
812            alloc_area->aa_next->aa_prev = alloc_area->aa_prev;
813        }
814
815        alloc_hdr->ah_chunks_allocated--;
816
817        if (alloc_area == alloc_hdr->ah_last_alloc_area) {
818            alloc_hdr->ah_last_alloc_area = NULL;
819        }
820        memset(alloc_area, 0, sizeof(*alloc_area));
821        free(alloc_area);
822    }
823
824    else {
825        ((Dwarf_Free_List) space)->fl_next = alloc_area->aa_free_list;
826        alloc_area->aa_free_list = space;
827    }
828#endif /* !DWARF_SIMPLE_MALLOC */
829}
830
831
832/*
833    Allocates space for a Dwarf_Debug_s struct,
834    since one does not exist.
835*/
836Dwarf_Debug
837_dwarf_get_debug(void
838    )
839{
840    Dwarf_Debug dbg;
841
842    dbg = (Dwarf_Debug) malloc(sizeof(struct Dwarf_Debug_s));
843    if (dbg == NULL)
844        return (NULL);
845    else
846        memset(dbg, 0, sizeof(struct Dwarf_Debug_s));
847    return (dbg);
848}
849
850
851/*
852    Sets up the Dwarf_Debug_s struct for all the
853    allocation types currently defined.
854    Allocation types DW_DLA_STRING, DW_DLA_LIST,
855    DW_DLA_FRAME_BLOCK, DW_DLA_LOC_BLOCK, DW_DLA_RANGES are
856    malloc'ed directly.
857
858    This routine should be called after _dwarf_setup(),
859    so that information about the sizes of the Dwarf
860    sections can be used to decide the number of
861    structs of each type malloc'ed.
862
863    Also DW_DLA_ELLIST, DW_DLA_BOUNDS, DW_DLA_TYPE,
864    DW_DLA_SUBSCR, DW_DLA_LINEBUF allocation types
865    are currently not used.
866    The ah_bytes_one_struct and ah_structs_per_chunk fields for
867    these types have been set to 1 for efficiency
868    in dwarf_get_alloc().
869
870    Ah_alloc_num should be greater than 1 for all
871    types that are currently being used.
872
873    Therefore, for these allocation types the
874    ah_bytes_one_struct, and ah_structs_per_chunk fields do not
875    need to be initialized.
876
877    Being an internal routine, assume proper dbg.
878*/
879
880Dwarf_Debug
881_dwarf_setup_debug(Dwarf_Debug dbg)
882{
883    int i;
884
885    for (i = 1; i <= MAX_DW_DLA; i++) {
886        const struct ial_s *ialp = &index_into_allocated[i];
887        unsigned int hdr_index = ialp->ia_al_num;
888        Dwarf_Word str_size = ialp->ia_struct_size;
889        Dwarf_Word str_count = ialp->ia_base_count;
890        Dwarf_Word rnded_size = ROUND_SIZE_WITH_POINTER(str_size);
891
892        Dwarf_Alloc_Hdr alloc_hdr = &dbg->de_alloc_hdr[hdr_index];
893
894        alloc_hdr->ah_bytes_one_struct = (Dwarf_Half) rnded_size;
895
896        /* ah_structs_per_chunk must be >0 else we are in trouble */
897        alloc_hdr->ah_structs_per_chunk = str_count;
898        alloc_hdr->ah_bytes_malloc_per_chunk = rnded_size * str_count;
899    }
900    return (dbg);
901}
902
903/*
904    This function prints out the statistics
905    collected on allocation of memory chunks.
906*/
907void
908dwarf_print_memory_stats(Dwarf_Debug dbg)
909{
910    Dwarf_Alloc_Hdr alloc_hdr;
911    Dwarf_Shalf i;
912
913    /*
914       Alloc types start at 1, not 0. Hence, the first NULL string, and
915       also a size of MAX_DW_DLA + 1. */
916    char *alloc_type_name[MAX_DW_DLA + 1] = {
917        "",
918        "DW_DLA_STRING",
919        "DW_DLA_LOC",
920        "DW_DLA_LOCDESC",
921        "DW_DLA_ELLIST",
922        "DW_DLA_BOUNDS",
923        "DW_DLA_BLOCK",
924        "DW_DLA_DEBUG",
925        "DW_DLA_DIE",
926        "DW_DLA_LINE",
927        "DW_DLA_ATTR",
928        "DW_DLA_TYPE",
929        "DW_DLA_SUBSCR",
930        "DW_DLA_GLOBAL",
931        "DW_DLA_ERROR",
932        "DW_DLA_LIST",
933        "DW_DLA_LINEBUF",
934        "DW_DLA_ARANGE",
935        "DW_DLA_ABBREV",
936        "DW_DLA_FRAME_OP",
937        "DW_DLA_CIE",
938        "DW_DLA_FDE",
939        "DW_DLA_LOC_BLOCK",
940        "DW_DLA_FRAME_BLOCK",
941        "DW_DLA_FUNC",
942        "DW_DLA_TYPENAME",
943        "DW_DLA_VAR",
944        "DW_DLA_WEAK",
945        "DW_DLA_ADDR",
946        "DW_DLA_RANGES",
947        "DW_DLA_ABBREV_LIST",
948        "DW_DLA_CHAIN",
949        "DW_DLA_CU_CONTEXT",
950        "DW_DLA_FRAME",
951        "DW_DLA_GLOBAL_CONTEXT",
952        "DW_DLA_FILE_ENTRY",
953        "DW_DLA_LINE_CONTEXT",
954        "DW_DLA_LOC_CHAIN",
955        "DW_DLA_HASH_TABLE",
956        "DW_DLA_FUNC_CONTEXT",
957        "DW_DLA_TYPENAME_CONTEXT",
958        "DW_DLA_VAR_CONTEXT",
959        "DW_DLA_WEAK_CONTEXT",
960        "DW_DLA_PUBTYPES_CONTEXT",
961        "DW_DLA_HASH_TABLE_ENTRY",
962    };
963
964    if (dbg == NULL)
965        return;
966
967    printf("Size of Dwarf_Debug        %4ld bytes\n",
968           (long) sizeof(*dbg));
969    printf("Size of Dwarf_Alloc_Hdr_s  %4ld bytes\n",
970           (long) sizeof(struct Dwarf_Alloc_Hdr_s));
971    printf("size of Dwarf_Alloc_Area_s %4ld bytes\n",
972           (long) sizeof(struct Dwarf_Alloc_Area_s));
973
974    printf("   Alloc Type                   Curr  Structs byt   str\n");
975    printf("   ----------                   ----  ------- per   per\n");
976    for (i = 1; i <= MAX_DW_DLA; i++) {
977        int indx = index_into_allocated[i].ia_al_num;
978
979        alloc_hdr = &dbg->de_alloc_hdr[indx];
980        if (alloc_hdr->ah_bytes_one_struct != 1) {
981            printf("%2d %-25s   %6d %8d %6d %6d\n",
982                   (int) i,
983                   alloc_type_name[i],
984                   (int) alloc_hdr->ah_chunks_allocated,
985                   (int) alloc_hdr->ah_struct_user_holds,
986                   (int) alloc_hdr->ah_bytes_malloc_per_chunk,
987                   (int) alloc_hdr->ah_structs_per_chunk);
988        }
989    }
990}
991
992
993#ifndef DWARF_SIMPLE_MALLOC
994/*
995    This recursively frees
996    the chunks still allocated, and
997    forward chained through the aa_next
998    pointer.
999*/
1000static void
1001_dwarf_recursive_free(Dwarf_Alloc_Area alloc_area)
1002{
1003    if (alloc_area->aa_next != NULL) {
1004        _dwarf_recursive_free(alloc_area->aa_next);
1005    }
1006
1007    alloc_area->aa_next = 0;
1008    alloc_area->aa_prev = 0;
1009    free(alloc_area);
1010}
1011#endif
1012
1013/* In the 'rela' relocation case we might have malloc'd
1014   space to ensure it is read-write. In that case, free the space.  */
1015static void
1016rela_free(struct Dwarf_Section_s * sec)
1017{
1018    if (sec->dss_data_was_malloc) {
1019        free(sec->dss_data);
1020    }
1021    sec->dss_data = 0;
1022    sec->dss_data_was_malloc = 0;
1023}
1024
1025/*
1026    Used to free all space allocated for this Dwarf_Debug.
1027    The caller should assume that the Dwarf_Debug pointer
1028    itself is no longer valid upon return from this function.
1029
1030    In case of difficulty, this function simply returns quietly.
1031*/
1032int
1033_dwarf_free_all_of_one_debug(Dwarf_Debug dbg)
1034{
1035    Dwarf_Alloc_Hdr alloc_hdr;
1036    Dwarf_Shalf i;
1037    Dwarf_CU_Context context = 0;
1038    Dwarf_CU_Context nextcontext = 0;
1039
1040    if (dbg == NULL)
1041        return (DW_DLV_ERROR);
1042
1043    /* To do complete validation that we have no surprising missing or
1044       erroneous deallocs it is advisable to do the dwarf_deallocs here
1045       that are not things the user can otherwise request.
1046       Housecleaning.  */
1047
1048    for (context = dbg->de_cu_context_list;
1049         context; context = nextcontext) {
1050        Dwarf_Hash_Table hash_table = context->cc_abbrev_hash_table;
1051        _dwarf_free_abbrev_hash_table_contents(dbg,hash_table);
1052        nextcontext = context->cc_next;
1053        dwarf_dealloc(dbg, hash_table, DW_DLA_HASH_TABLE);
1054        dwarf_dealloc(dbg, context, DW_DLA_CU_CONTEXT);
1055    }
1056
1057    /* Housecleaning done. Now really free all the space. */
1058#ifdef DWARF_SIMPLE_MALLOC
1059    if (dbg->de_simple_malloc_base) {
1060        struct simple_malloc_record_s *smp = dbg->de_simple_malloc_base;
1061
1062        while (smp) {
1063            int i;
1064            struct simple_malloc_record_s *prev_smp = 0;
1065
1066            for (i = 0; i < smp->sr_used; ++i) {
1067                struct simple_malloc_entry_s *cur;
1068
1069                cur = &smp->sr_entry[i];
1070                if (cur->se_addr != 0) {
1071                    free(cur->se_addr);
1072                    cur->se_addr = 0;
1073                }
1074            }
1075            prev_smp = smp;
1076            smp = smp->sr_next;
1077            free(prev_smp);
1078        }
1079        dbg->de_simple_malloc_base = 0;
1080    }
1081#else
1082    for (i = 1; i < ALLOC_AREA_REAL_TABLE_MAX; i++) {
1083        int indx = i;
1084
1085        alloc_hdr = &dbg->de_alloc_hdr[indx];
1086        if (alloc_hdr->ah_alloc_area_head != NULL) {
1087            _dwarf_recursive_free(alloc_hdr->ah_alloc_area_head);
1088        }
1089    }
1090
1091#endif
1092    rela_free(&dbg->de_debug_info);
1093    rela_free(&dbg->de_debug_abbrev);
1094    rela_free(&dbg->de_debug_line);
1095    rela_free(&dbg->de_debug_loc);
1096    rela_free(&dbg->de_debug_aranges);
1097    rela_free(&dbg->de_debug_macinfo);
1098    rela_free(&dbg->de_debug_pubnames);
1099    rela_free(&dbg->de_debug_str);
1100    rela_free(&dbg->de_debug_frame);
1101    rela_free(&dbg->de_debug_frame_eh_gnu);
1102    rela_free(&dbg->de_debug_pubtypes);
1103    rela_free(&dbg->de_debug_funcnames);
1104    rela_free(&dbg->de_debug_typenames);
1105    rela_free(&dbg->de_debug_varnames);
1106    rela_free(&dbg->de_debug_weaknames);
1107    rela_free(&dbg->de_debug_ranges);
1108    dwarf_harmless_cleanout(&dbg->de_harmless_errors);
1109
1110    memset(dbg, 0, sizeof(*dbg)); /* Prevent accidental use later. */
1111    free(dbg);
1112    return (DW_DLV_OK);
1113}
1114
1115/* A special case: we have no dbg, no alloc header etc.
1116   So create something out of thin air that we can recognize
1117   in dwarf_dealloc.
1118   Something with the prefix (prefix space hidden from caller).
1119
1120   Only applies to DW_DLA_ERROR, making up an error record.
1121*/
1122
1123struct Dwarf_Error_s *
1124_dwarf_special_no_dbg_error_malloc(void)
1125{
1126    /* the union unused things are to guarantee proper alignment */
1127    union u {
1128        Dwarf_Alloc_Area ptr_not_used;
1129        struct Dwarf_Error_s base_not_used;
1130        char data_space[sizeof(struct Dwarf_Error_s) +
1131                        (DW_RESERVE * 2)];
1132    };
1133    char *mem;
1134
1135    mem = malloc(sizeof(union u));
1136
1137    if (mem == 0) {
1138        return 0;
1139
1140    }
1141    memset(mem, 0, sizeof(union u));
1142    mem += DW_RESERVE;
1143    return (struct Dwarf_Error_s *) mem;
1144}
1145
1146/* The free side of  _dwarf_special_no_dbg_error_malloc()
1147*/
1148static void
1149_dwarf_free_special_error(Dwarf_Ptr space)
1150{
1151    char *mem = (char *) space;
1152
1153    mem -= DW_RESERVE;
1154    free(mem);
1155}
1156
1157
1158#ifdef DWARF_SIMPLE_MALLOC
1159/* here solely for planting a breakpoint. */
1160/* ARGSUSED */
1161void
1162_dwarf_simple_malloc_botch(int err)
1163{
1164       fprintf(stderr,"simple malloc botch %d\n",err);
1165}
1166static void
1167_dwarf_simple_malloc_add_to_list(Dwarf_Debug dbg,
1168                                 Dwarf_Ptr addr,
1169                                 unsigned long size, short alloc_type)
1170{
1171    struct simple_malloc_record_s *cur;
1172    struct simple_malloc_entry_s *newentry;
1173
1174    if (!dbg->de_simple_malloc_base) {
1175        /* First entry to this routine. */
1176        dbg->de_simple_malloc_base =
1177            malloc(sizeof(struct simple_malloc_record_s));
1178        if (!dbg->de_simple_malloc_base) {
1179            _dwarf_simple_malloc_botch(7);
1180            return;             /* no memory, give up */
1181        }
1182        memset(dbg->de_simple_malloc_base,
1183               0, sizeof(struct simple_malloc_record_s));
1184    }
1185    cur = dbg->de_simple_malloc_base;
1186
1187    if (cur->sr_used >= DSM_BLOCK_COUNT) {
1188        /* Better not be > than as that means chaos */
1189
1190        /* Create a new block to link at the head. */
1191
1192        struct simple_malloc_record_s *newblock =
1193            malloc(sizeof(struct simple_malloc_record_s));
1194        if (!newblock) {
1195            _dwarf_simple_malloc_botch(8);
1196            return;             /* Can do nothing, out of memory */
1197        }
1198        memset(newblock, 0, sizeof(struct simple_malloc_record_s));
1199        /* Link the new block at the head of the chain, and make it
1200           'current' */
1201        dbg->de_simple_malloc_base = newblock;
1202        newblock->sr_next = cur;
1203        cur = newblock;
1204    }
1205    newentry = &cur->sr_entry[cur->sr_used];
1206    newentry->se_addr = addr;
1207    newentry->se_size = size;
1208    newentry->se_type = alloc_type;
1209    ++cur->sr_used;
1210}
1211
1212/*
1213   DWARF_SIMPLE_MALLOC: testing the hypothesis that the existing
1214   malloc scheme here (see _dwarf_get_alloc()) is pointless complexity.
1215
1216   DWARF_SIMPLE_MALLOC also makes it easy for a malloc-tracing
1217   tool to verify libdwarf malloc has no botches (though of course
1218   such does not test the complicated standard-libdwarf-alloc code).
1219
1220   To properly answer the question, the simple-malloc allocate
1221   and delete should be something other than a simple list.
1222   Perhaps a heap, or perhaps a red-black tree.
1223
1224*/
1225static void
1226_dwarf_simple_malloc_delete_from_list(Dwarf_Debug dbg,
1227                                      Dwarf_Ptr space, short alloc_type)
1228{
1229    if (space == 0) {
1230        _dwarf_simple_malloc_botch(6);
1231    }
1232    if (dbg->de_simple_malloc_base) {
1233        struct simple_malloc_record_s *smp = dbg->de_simple_malloc_base;
1234
1235        while (smp) {
1236            int i;
1237
1238            for (i = 0; i < smp->sr_used; ++i) {
1239                struct simple_malloc_entry_s *cur;
1240
1241                cur = &smp->sr_entry[i];
1242                if (cur->se_addr == space) {
1243                    if (cur->se_type != alloc_type) {
1244                        _dwarf_simple_malloc_botch(0);
1245                    }
1246                    cur->se_addr = 0;
1247                    return;
1248                }
1249            }
1250            smp = smp->sr_next;
1251        }
1252    }
1253    /* Never found the space. */
1254    _dwarf_simple_malloc_botch(1);
1255    return;
1256
1257}
1258#endif
1259