diff options
Diffstat (limited to 'usr/src/tools/ctf/dwarf/common/dwarf_alloc.c')
| -rw-r--r-- | usr/src/tools/ctf/dwarf/common/dwarf_alloc.c | 1292 |
1 files changed, 714 insertions, 578 deletions
diff --git a/usr/src/tools/ctf/dwarf/common/dwarf_alloc.c b/usr/src/tools/ctf/dwarf/common/dwarf_alloc.c index ae94c8b355..ddb423e841 100644 --- a/usr/src/tools/ctf/dwarf/common/dwarf_alloc.c +++ b/usr/src/tools/ctf/dwarf/common/dwarf_alloc.c @@ -1,6 +1,7 @@ /* - Copyright (C) 2000,2002,2004 Silicon Graphics, Inc. All Rights Reserved. + Copyright (C) 2000-2005 Silicon Graphics, Inc. All Rights Reserved. + Portions Copyright (C) 2007-2010 David Anderson. All Rights Reserved. This program is free software; you can redistribute it and/or modify it under the terms of version 2.1 of the GNU Lesser General Public License @@ -19,10 +20,10 @@ 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., 59 Temple Place - Suite 330, Boston MA 02111-1307, + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301, USA. - Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, + Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane, Mountain View, CA 94043, or: http://www.sgi.com @@ -32,8 +33,14 @@ http://oss.sgi.com/projects/GenInfo/NoticeExplan */ +/* 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. +*/ +#undef DEBUG #include "config.h" #include "dwarf_incl.h" @@ -41,7 +48,7 @@ #include <stdlib.h> #include <stdio.h> -#include <malloc.h> +#include "malloc_check.h" /* These files are included to get the sizes @@ -61,15 +68,17 @@ #include "dwarf_vars.h" #include "dwarf_weaks.h" + static void _dwarf_free_special_error(Dwarf_Ptr space); + #ifdef DWARF_SIMPLE_MALLOC static void _dwarf_simple_malloc_add_to_list(Dwarf_Debug dbg, - Dwarf_Ptr addr, - unsigned long size, - short alloc_type); -static void _dwarf_simple_malloc_delete_from_list(Dwarf_Debug dbg, - Dwarf_Ptr space, - short alloc_type); + Dwarf_Ptr addr, + unsigned long size, + short alloc_type); +static void _dwarf_simple_malloc_delete_from_list(Dwarf_Debug dbg, + Dwarf_Ptr space, + short alloc_type); void _dwarf_simple_malloc_botch(int err); #endif /* DWARF_SIMPLE_MALLOC */ @@ -83,40 +92,49 @@ void _dwarf_simple_malloc_botch(int err); 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, it checks if the size of struct is less than + 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. - If this is n32, we want the sizes to be 64-bit aligned - so that longlong in the structure we return to user - is aligned properly. Thus the _dw_fac of 2 + 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. - Only long longs need to be properly aligned: we don't - have long double and don't align for that. */ -#if _MIPS_SIM == _MIPS_SIM_NABI32 -#define _DW_FAC 2 -#define _DW_PS sizeof(void *) -#else -#define _DW_FAC 1 -#define _DW_PS sizeof(void *) -#endif -#define _DW_RESERVE (_DW_FAC * _DW_PS) +#define DW_RESERVE 8 -/* Round size up to the next multiple of _DW_RESERVE bytes +/* Round size up to the next multiple of DW_RESERVE bytes */ #define ROUND_SIZE(inputsize) \ - (((inputsize) % (_DW_RESERVE)) == 0 ? \ + (((inputsize) % (DW_RESERVE)) == 0 ? \ (inputsize): \ ((inputsize) + \ - (_DW_RESERVE) - ((inputsize) % (_DW_RESERVE)) )) + (DW_RESERVE) - ((inputsize) % (DW_RESERVE)) )) + +#define ROUND_SIZE_WITH_POINTER(i_size) (ROUND_SIZE(i_size) + DW_RESERVE) -#define ROUND_SIZE_WITH_POINTER(i_size) (ROUND_SIZE(i_size) + _DW_RESERVE) +/* 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 @@ -126,110 +144,126 @@ void _dwarf_simple_malloc_botch(int err); ** so that is not an option. */ struct ial_s { - int ia_al_num; /* Index into de_alloc_hdr table. */ + 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). */ + 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 struct ial_s index_into_allocated[ALLOC_AREA_INDEX_TABLE_MAX] = { - {0, 1, 1}, /* none */ - {0, 1, 1,}, /* 1 DW_DLA_STRING */ - {1, sizeof(Dwarf_Loc), BASE_ALLOC} - , /* 2 DW_DLA_LOC */ - {2, sizeof(Dwarf_Locdesc), BASE_ALLOC} - , /* 3 DW_DLA_LOCDESC */ - {0, 1, 1} - , /* not used *//* 4 DW_DLA_ELLIST */ - {0, 1, 1} - , /* not used *//* 5 DW_DLA_BOUNDS */ - {3, sizeof(Dwarf_Block), BASE_ALLOC} - , /* 6 DW_DLA_BLOCK */ - {0, 1, 1} - , /* the actual dwarf_debug structure *//* 7 DW_DLA_DEBUG */ - {4, sizeof(struct Dwarf_Die_s), BIG_ALLOC}, /* 8 DW_DLA_DIE */ - {5, sizeof(struct Dwarf_Line_s), BIG_ALLOC}, /* 9 - DW_DLA_LINE */ - {6, sizeof(struct Dwarf_Attribute_s), BIG_ALLOC * 2}, + {0, 1, 1, 0, 0}, /* none */ + {0, 1, 1, 0, 0}, /* 1 DW_DLA_STRING */ + {1, sizeof(Dwarf_Loc), BASE_ALLOC, 0, 0} + , /* 2 DW_DLA_LOC */ + {2, sizeof(Dwarf_Locdesc), BASE_ALLOC, 0, 0} + , /* 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 */ + {3, sizeof(Dwarf_Block), BASE_ALLOC, 0, 0} + , /* 6 DW_DLA_BLOCK */ + {0, 1, 1, 0, 0} + , /* the actual dwarf_debug structure *//* 7 DW_DLA_DEBUG */ + {4, sizeof(struct Dwarf_Die_s), BIG_ALLOC, 0, 0}, /* 8 DW_DLA_DIE + */ + {5, sizeof(struct Dwarf_Line_s), BIG_ALLOC, 0, 0}, /* 9 + DW_DLA_LINE */ + {6, sizeof(struct Dwarf_Attribute_s), BIG_ALLOC * 2, 0, 0}, /* 10 DW_DLA_ATTR */ - {0, 1, 1}, /* not used *//* 11 DW_DLA_TYPE */ - {0, 1, 1}, /* not used *//* 12 DW_DLA_SUBSCR */ - {7, sizeof(struct Dwarf_Global_s), BIG_ALLOC}, /* 13 - DW_DLA_GLOBAL - */ - {8, sizeof(struct Dwarf_Error_s), BASE_ALLOC}, /* 14 - DW_DLA_ERROR - */ - {0, 1, 1}, /* 15 DW_DLA_LIST */ - {0, 1, 1}, /* not used *//* 16 DW_DLA_LINEBUF */ - {9, sizeof(struct Dwarf_Arange_s), BASE_ALLOC}, /* 17 - DW_DLA_ARANGE - */ - {10, sizeof(struct Dwarf_Abbrev_s), BIG_ALLOC}, /* 18 - DW_DLA_ABBREV - */ - {11, sizeof(Dwarf_Frame_Op), BIG_ALLOC} - , /* 19 DW_DLA_FRAME_OP */ - {12, sizeof(struct Dwarf_Cie_s), BASE_ALLOC}, /* 20 - DW_DLA_CIE */ - {13, sizeof(struct Dwarf_Fde_s), BASE_ALLOC}, /* 21 - DW_DLA_FDE */ - {0, 1, 1}, /* 22 DW_DLA_LOC_BLOCK */ - {0, 1, 1}, /* 23 DW_DLA_FRAME_BLOCK */ - {14, sizeof(struct Dwarf_Global_s), BIG_ALLOC}, /* 24 - DW_DLA_FUNC */ - {15, sizeof(struct Dwarf_Global_s), BIG_ALLOC}, /* 25 - DW_DLA_TYPENAME - */ - {16, sizeof(struct Dwarf_Global_s), BIG_ALLOC}, /* 26 - DW_DLA_VAR */ - {17, sizeof(struct Dwarf_Global_s), BASE_ALLOC}, /* 27 - DW_DLA_WEAK */ - {0, 1, 1}, /* 28 DW_DLA_ADDR */ - {18, sizeof(struct Dwarf_Abbrev_List_s), BIG_ALLOC}, - /* 29 DW_DLA_ABBREV_LIST */ - {19, sizeof(struct Dwarf_Chain_s), BIG_ALLOC}, /* 30 - DW_DLA_CHAIN - */ - {20, sizeof(struct Dwarf_CU_Context_s), BASE_ALLOC}, - /* 31 DW_DLA_CU_CONTEXT */ - {21, sizeof(struct Dwarf_Frame_s), BASE_ALLOC}, /* 32 - DW_DLA_FRAME - */ - {22, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC}, - /* 33 DW_DLA_GLOBAL_CONTEXT */ - {23, sizeof(struct Dwarf_File_Entry_s), BASE_ALLOC}, - /* 34 DW_DLA_FILE_ENTRY */ - {24, sizeof(struct Dwarf_Line_Context_s), BASE_ALLOC}, - /* 35 DW_DLA_LINE_CONTEXT */ - {25, sizeof(struct Dwarf_Loc_Chain_s), BASE_ALLOC}, - /* 36 DW_DLA_LOC_CHAIN */ - {26, ABBREV_HASH_TABLE_SIZE * 2 * sizeof(Dwarf_Abbrev_List), - BASE_ALLOC} - , - /* 37 DW_DLA_HASH_TABLE */ + {0, 1, 1, 0, 0}, /* not used *//* 11 DW_DLA_TYPE */ + {0, 1, 1, 0, 0}, /* not used *//* 12 DW_DLA_SUBSCR */ + {7, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 13 + DW_DLA_GLOBAL + */ + {8, sizeof(struct Dwarf_Error_s), BASE_ALLOC, 0, 0}, /* 14 + DW_DLA_ERROR + */ + {0, 1, 1, 0, 0}, /* 15 DW_DLA_LIST */ + {0, 1, 1, 0, 0}, /* not used *//* 16 DW_DLA_LINEBUF */ + {9, sizeof(struct Dwarf_Arange_s), BASE_ALLOC, 0, 0}, /* 17 + DW_DLA_ARANGE + */ + {10, sizeof(struct Dwarf_Abbrev_s), BIG_ALLOC, 0, 0}, /* 18 + DW_DLA_ABBREV + */ + {11, sizeof(Dwarf_Frame_Op), BIG_ALLOC, 0, 0} + , /* 19 DW_DLA_FRAME_OP */ + {12, sizeof(struct Dwarf_Cie_s), BASE_ALLOC, 0, 0}, /* 20 + DW_DLA_CIE */ + {13, sizeof(struct Dwarf_Fde_s), BASE_ALLOC, 0, 0}, /* 21 DW_DLA_FDE */ + {0, 1, 1, 0, 0}, /* 22 DW_DLA_LOC_BLOCK */ + {0, 1, 1, 0, 0}, /* 23 DW_DLA_FRAME_BLOCK */ + {14, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 24 DW_DLA_FUNC + UNUSED */ + {15, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 25 + DW_DLA_TYPENAME + UNUSED */ + {16, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 26 DW_DLA_VAR + UNUSED */ + {17, sizeof(struct Dwarf_Global_s), BASE_ALLOC, 0, 0}, /* 27 DW_DLA_WEAK + 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. */ + + {18, sizeof(struct Dwarf_Abbrev_List_s), BIG_ALLOC, 0, 0}, + /* 30 DW_DLA_ABBREV_LIST */ + + {19, sizeof(struct Dwarf_Chain_s), BIG_ALLOC, 0, 0}, /* 31 DW_DLA_CHAIN */ + {20, sizeof(struct Dwarf_CU_Context_s), BASE_ALLOC, 0, 0}, + /* 32 DW_DLA_CU_CONTEXT */ + {21, sizeof(struct Dwarf_Frame_s), BASE_ALLOC, + _dwarf_frame_constructor, + _dwarf_frame_destructor}, /* 33 DW_DLA_FRAME */ + {22, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0}, + /* 34 DW_DLA_GLOBAL_CONTEXT */ + {23, sizeof(struct Dwarf_File_Entry_s), BASE_ALLOC, 0, 0}, /* 34 */ + /* 35 DW_DLA_FILE_ENTRY */ + {24, sizeof(struct Dwarf_Line_Context_s), BASE_ALLOC, 0, 0}, + /* 36 DW_DLA_LINE_CONTEXT */ + {25, sizeof(struct Dwarf_Loc_Chain_s), BASE_ALLOC, 0, 0}, /* 36 */ + /* 37 DW_DLA_LOC_CHAIN */ + + {26, sizeof(struct Dwarf_Hash_Table_s),BASE_ALLOC, 0, 0}, /* 37 */ + /* 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 are left in existence, - with unchanged numbers. + 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. + */ - {27, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC}, - /* 38 DW_DLA_FUNC_CONTEXT */ - {28, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC}, - /* 39 DW_DLA_TYPENAME_CONTEXT */ - {29, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC}, - /* 40 DW_DLA_VAR_CONTEXT */ - {30, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC}, - /* 41 DW_DLA_WEAK_CONTEXT */ + {27, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0}, + /* 39 DW_DLA_FUNC_CONTEXT */ + {28, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0}, + /* 40 DW_DLA_TYPENAME_CONTEXT */ + {29, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0}, + /* 41 DW_DLA_VAR_CONTEXT */ + {30, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0}, + /* 42 DW_DLA_WEAK_CONTEXT */ + {31, sizeof(struct Dwarf_Global_Context_s), BASE_ALLOC, 0, 0}, + /* 43 DW_DLA_PUBTYPES_CONTEXT DWARF3 */ + + {0,1,1,0,0 }, + /* 44 DW_DLA_HASH_TABLE_ENTRY */ + + }; #ifndef DWARF_SIMPLE_MALLOC @@ -285,126 +319,126 @@ _dwarf_find_memory(Dwarf_Alloc_Hdr alloc_hdr) /* 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. */ + (most recent new block). If that is not successful, then search + the list of alloc_area's from alloc_header. */ alloc_area = alloc_hdr->ah_last_alloc_area; if (alloc_area == NULL || alloc_area->aa_free_structs_in_chunk == 0) - for (alloc_area = alloc_hdr->ah_alloc_area_head; - alloc_area != NULL; alloc_area = alloc_area->aa_next) { + for (alloc_area = alloc_hdr->ah_alloc_area_head; + alloc_area != NULL; alloc_area = alloc_area->aa_next) { - if (alloc_area->aa_free_structs_in_chunk > 0) { - break; /* found a free entry! */ - } + if (alloc_area->aa_free_structs_in_chunk > 0) { + break; /* found a free entry! */ + } - } + } if (alloc_area != NULL) { - alloc_area->aa_free_structs_in_chunk--; - - if (alloc_area->aa_free_list != NULL) { - ret_mem = alloc_area->aa_free_list; - - /* - 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. */ - alloc_area->aa_free_list = - ((Dwarf_Free_List) ret_mem)->fl_next; - } else if (alloc_area->aa_blob_start < alloc_area->aa_blob_end) { - ret_mem = alloc_area->aa_blob_start; - - /* - Store pointer to chunk this struct belongs to in the - first few bytes. Return pointer to bytes after this - pointer storage. */ - *(Dwarf_Alloc_Area *) ret_mem = alloc_area; - ret_mem += _DW_RESERVE; - - alloc_area->aa_blob_start += alloc_hdr->ah_bytes_one_struct; - } else { - /* else fall thru , though it should be impossible to fall - thru. And represents a disastrous programming error if - we get here. */ + alloc_area->aa_free_structs_in_chunk--; + + if (alloc_area->aa_free_list != NULL) { + ret_mem = alloc_area->aa_free_list; + + /* + 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. */ + alloc_area->aa_free_list = + ((Dwarf_Free_List) ret_mem)->fl_next; + } else if (alloc_area->aa_blob_start < alloc_area->aa_blob_end) { + ret_mem = alloc_area->aa_blob_start; + + /* + Store pointer to chunk this struct belongs to in the + first few bytes. Return pointer to bytes after this + pointer storage. */ + *(Dwarf_Alloc_Area *) ret_mem = alloc_area; + ret_mem += DW_RESERVE; + + alloc_area->aa_blob_start += alloc_hdr->ah_bytes_one_struct; + } else { + /* else fall thru , though it should be impossible to fall + thru. And represents a disastrous programming error if + we get here. */ #ifdef DEBUG - fprintf(stderr, "libdwarf Internal error start %x end %x\n", - (int) alloc_area->aa_blob_start, - (int) alloc_area->aa_blob_end); + fprintf(stderr, "libdwarf Internal error start %x end %x\n", + (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) { - Dwarf_Word rounded_area_hdr_size; - - alloc_hdr->ah_chunks_allocated++; - - { /* this nonsense avoids a warning */ - /* CONSTCOND would be better */ - unsigned long v = sizeof(struct Dwarf_Alloc_Area_s); - - rounded_area_hdr_size = ROUND_SIZE(v); - } - - /* - Allocate memory to contain the required number of structs - and the Dwarf_Alloc_Area_s to control it. */ - mem_block_size = alloc_hdr->ah_bytes_malloc_per_chunk + - rounded_area_hdr_size; - - mem_block = malloc(mem_block_size); - if (mem_block == NULL) { - 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 = (Dwarf_Alloc_Area) mem_block; - alloc_area->aa_prev = 0; - if (alloc_hdr->ah_alloc_area_head != NULL) { - alloc_hdr->ah_alloc_area_head->aa_prev = alloc_area; - } - alloc_area->aa_free_list = 0; - alloc_area->aa_next = alloc_hdr->ah_alloc_area_head; - alloc_hdr->ah_alloc_area_head = alloc_area; - - alloc_area->aa_alloc_hdr = alloc_hdr; - alloc_area->aa_free_structs_in_chunk = - (Dwarf_Sword) alloc_hdr->ah_structs_per_chunk - 1; - if (alloc_area->aa_free_structs_in_chunk < 1) { - /* If we get here, there is a disastrous programming error - somewhere. */ + Dwarf_Word rounded_area_hdr_size; + + alloc_hdr->ah_chunks_allocated++; + + { /* this nonsense avoids a warning */ + /* CONSTCOND would be better */ + unsigned long v = sizeof(struct Dwarf_Alloc_Area_s); + + rounded_area_hdr_size = ROUND_SIZE(v); + } + + /* + Allocate memory to contain the required number of structs + and the Dwarf_Alloc_Area_s to control it. */ + mem_block_size = alloc_hdr->ah_bytes_malloc_per_chunk + + rounded_area_hdr_size; + + mem_block = malloc(mem_block_size); + if (mem_block == NULL) { + 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 = (Dwarf_Alloc_Area) mem_block; + alloc_area->aa_prev = 0; + if (alloc_hdr->ah_alloc_area_head != NULL) { + alloc_hdr->ah_alloc_area_head->aa_prev = alloc_area; + } + alloc_area->aa_free_list = 0; + alloc_area->aa_next = alloc_hdr->ah_alloc_area_head; + alloc_hdr->ah_alloc_area_head = alloc_area; + + alloc_area->aa_alloc_hdr = alloc_hdr; + alloc_area->aa_free_structs_in_chunk = + (Dwarf_Sword) alloc_hdr->ah_structs_per_chunk - 1; + if (alloc_area->aa_free_structs_in_chunk < 1) { + /* If we get here, there is a disastrous programming error + somewhere. */ #ifdef DEBUG - fprintf(stderr, - "libdwarf Internal error: free structs in chunk %d\n", - (int) alloc_area->aa_free_structs_in_chunk); + fprintf(stderr, + "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. */ - ret_mem = mem_block + rounded_area_hdr_size; - alloc_area->aa_blob_start = - ret_mem + alloc_hdr->ah_bytes_one_struct; - alloc_area->aa_blob_end = mem_block + mem_block_size; - - /* - Store pointer to chunk this struct belongs to in the first - few bytes. Return pointer to bytes after this pointer - storage. */ - *(Dwarf_Alloc_Area *) ret_mem = alloc_area; - ret_mem += _DW_RESERVE; + return NULL; + } + + /* + The struct returned begins immediately after the + Dwarf_Alloc_Area_s struct. */ + ret_mem = mem_block + rounded_area_hdr_size; + alloc_area->aa_blob_start = + ret_mem + alloc_hdr->ah_bytes_one_struct; + alloc_area->aa_blob_end = mem_block + mem_block_size; + + /* + Store pointer to chunk this struct belongs to in the first + few bytes. Return pointer to bytes after this pointer + storage. */ + *(Dwarf_Alloc_Area *) ret_mem = alloc_area; + ret_mem += DW_RESERVE; } alloc_hdr->ah_last_alloc_area = alloc_area; alloc_hdr->ah_struct_user_holds++; - memset(ret_mem,0, alloc_hdr->ah_bytes_one_struct - _DW_RESERVE); + memset(ret_mem, 0, alloc_hdr->ah_bytes_one_struct - DW_RESERVE); return (ret_mem); } @@ -420,16 +454,17 @@ _dwarf_find_memory(Dwarf_Alloc_Hdr alloc_hdr) 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, and + 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_Ptr _dwarf_get_alloc(Dwarf_Debug dbg, - Dwarf_Small alloc_type, Dwarf_Unsigned count) + Dwarf_Small alloc_type, Dwarf_Unsigned count) { Dwarf_Alloc_Hdr alloc_hdr; @@ -440,12 +475,12 @@ _dwarf_get_alloc(Dwarf_Debug dbg, unsigned int type = alloc_type; if (dbg == NULL) { - return (NULL); + return (NULL); } if (type >= ALLOC_AREA_INDEX_TABLE_MAX) { - /* internal error */ - return NULL; + /* internal error */ + return NULL; } index = index_into_allocated[type].ia_al_num; /* zero also illegal but not tested for */ @@ -456,71 +491,109 @@ _dwarf_get_alloc(Dwarf_Debug dbg, special code here.. */ if (index == 0) { - if (alloc_type == DW_DLA_STRING) { - size = count; - } else if (alloc_type == DW_DLA_LIST) { - size = count * sizeof(Dwarf_Ptr); - } else if (alloc_type == DW_DLA_FRAME_BLOCK) { - size = count * sizeof(Dwarf_Frame_Op); - } else if (alloc_type == DW_DLA_LOC_BLOCK) { - size = count * sizeof(Dwarf_Loc); - } else if (alloc_type == DW_DLA_ADDR) { - size = count * - (sizeof(Dwarf_Addr) > sizeof(Dwarf_Off) ? - sizeof(Dwarf_Addr) : sizeof(Dwarf_Off)); - } else if (alloc_type == DW_DLA_ERROR) { - return _dwarf_special_no_dbg_error_malloc(); - } else { - /* If we get here, there is a disastrous programming error - somewhere. */ + if (alloc_type == DW_DLA_STRING) { + size = count; + } else if (alloc_type == DW_DLA_LIST) { + size = count * sizeof(Dwarf_Ptr); + } else if (alloc_type == DW_DLA_FRAME_BLOCK) { + size = count * sizeof(Dwarf_Frame_Op); + } else if (alloc_type == DW_DLA_LOC_BLOCK) { + size = count * sizeof(Dwarf_Loc); + } else if (alloc_type == DW_DLA_HASH_TABLE_ENTRY) { + size = count * sizeof(struct Dwarf_Hash_Table_Entry_s); + } else if (alloc_type == DW_DLA_ADDR) { + size = count * + (sizeof(Dwarf_Addr) > sizeof(Dwarf_Off) ? + sizeof(Dwarf_Addr) : sizeof(Dwarf_Off)); + } else if (alloc_type == DW_DLA_RANGES) { + size = count * sizeof(Dwarf_Ranges); + } else if (alloc_type == DW_DLA_ERROR) { + void *m = _dwarf_special_no_dbg_error_malloc(); + + dwarf_malloc_check_alloc_data(m, DW_DLA_ERROR); + return m; + + } else { + /* If we get here, there is a disastrous programming error + somewhere. */ #ifdef DEBUG - fprintf(stderr, - "libdwarf Internal error: type %d unexpected\n", - (int) type); + fprintf(stderr, + "libdwarf Internal error: type %d unexpected\n", + (int) type); #endif - } + } } else { - alloc_hdr = &dbg->de_alloc_hdr[index]; - if (alloc_hdr->ah_bytes_one_struct > 0) { + alloc_hdr = &dbg->de_alloc_hdr[index]; + if (alloc_hdr->ah_bytes_one_struct > 0) { #ifdef DWARF_SIMPLE_MALLOC - size = alloc_hdr->ah_bytes_one_struct; + size = alloc_hdr->ah_bytes_one_struct; #else - return (_dwarf_find_memory(alloc_hdr)); + { + void *m = _dwarf_find_memory(alloc_hdr); + + dwarf_malloc_check_alloc_data(m, type); + if (index_into_allocated[type].specialconstructor) { + int res = + index_into_allocated[type]. + specialconstructor(dbg, m); + if (res != DW_DLV_OK) { + /* 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. */ - return _dwarf_special_no_dbg_error_malloc(); - } else { - /* If we get here, there is a disastrous programming - error somewhere. */ + } 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(); + + dwarf_malloc_check_alloc_data(m, DW_DLA_ERROR); + return m; + } else { + /* If we get here, there is a disastrous programming + error somewhere. */ #ifdef DWARF_SIMPLE_MALLOC - _dwarf_simple_malloc_botch(3); + _dwarf_simple_malloc_botch(3); #endif #ifdef DEBUG - fprintf(stderr, - "libdwarf Internal error: Type %d unexpected\n", - (int) type); + fprintf(stderr, + "libdwarf Internal error: Type %d unexpected\n", + (int) type); #endif - } - } + } + } } ret_mem = malloc(size); #ifdef DWARF_SIMPLE_MALLOC - _dwarf_simple_malloc_add_to_list(dbg,ret_mem,(unsigned long)size, - alloc_type); + _dwarf_simple_malloc_add_to_list(dbg, ret_mem, (unsigned long) size, + type); #endif if (ret_mem != NULL) - memset(ret_mem,0, size); + memset(ret_mem, 0, size); + + dwarf_malloc_check_alloc_data(ret_mem, type); + if (index_into_allocated[type].specialconstructor) { + int res = + index_into_allocated[type].specialconstructor(dbg, ret_mem); + if (res != DW_DLV_OK) { + /* 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 @@ -531,7 +604,7 @@ _dwarf_get_alloc(Dwarf_Debug dbg, 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_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, @@ -551,7 +624,7 @@ _dwarf_get_alloc(Dwarf_Debug dbg, */ void dwarf_dealloc(Dwarf_Debug dbg, - Dwarf_Ptr space, Dwarf_Unsigned alloc_type) + Dwarf_Ptr space, Dwarf_Unsigned alloc_type) { Dwarf_Alloc_Hdr alloc_hdr; Dwarf_Alloc_Area alloc_area; @@ -559,145 +632,167 @@ dwarf_dealloc(Dwarf_Debug dbg, unsigned int index; if (space == NULL) { - return; + return; } - if (alloc_type == DW_DLA_ERROR) { - /* Get pointer to Dwarf_Alloc_Area this struct came from. See - dwarf_alloc.h ROUND_SIZE_WITH_POINTER stuff */ - alloc_area = - *(Dwarf_Alloc_Area *) ((char *) space - _DW_RESERVE); - 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. */ - _dwarf_free_special_error(space); - 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 */ + alloc_area = + *(Dwarf_Alloc_Area *) ((char *) space - DW_RESERVE); + 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. */ + _dwarf_free_special_error(space); + dwarf_malloc_check_dealloc_data(space, type); + return; + } } if (dbg == NULL) { - /* App error, or an app that failed to succeed in a - dwarf_init() call. */ - 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; + /* internal or user app error */ + return; } - index = index_into_allocated[alloc_type].ia_al_num; + index = index_into_allocated[type].ia_al_num; /* A string pointer may point into .debug_info or .debug_string. Otherwise, they are directly malloc'ed. */ + dwarf_malloc_check_dealloc_data(space, type); if (index == 0) { - if (alloc_type == DW_DLA_STRING) { - if ((Dwarf_Small *) space >= dbg->de_debug_info && - (Dwarf_Small *) space < - dbg->de_debug_info + dbg->de_debug_info_size) - return; - - if (dbg->de_debug_line != NULL && - (Dwarf_Small *) space >= dbg->de_debug_line && - (Dwarf_Small *) space < - dbg->de_debug_line + dbg->de_debug_line_size) - return; - - if (dbg->de_debug_pubnames != NULL && - (Dwarf_Small *) space >= dbg->de_debug_pubnames && - (Dwarf_Small *) space < - dbg->de_debug_pubnames + dbg->de_debug_pubnames_size) - return; - - if (dbg->de_debug_frame != NULL && - (Dwarf_Small *) space >= dbg->de_debug_frame && - (Dwarf_Small *) space < - dbg->de_debug_frame + dbg->de_debug_frame_size) - return; - - if (dbg->de_debug_str != NULL && - (Dwarf_Small *) space >= dbg->de_debug_str && - (Dwarf_Small *) space < - dbg->de_debug_str + dbg->de_debug_str_size) - return; - - if (dbg->de_debug_funcnames != NULL && - (Dwarf_Small *) space >= dbg->de_debug_funcnames && - (Dwarf_Small *) space < - dbg->de_debug_funcnames + dbg->de_debug_funcnames_size) - return; - - if (dbg->de_debug_typenames != NULL && - (Dwarf_Small *) space >= dbg->de_debug_typenames && - (Dwarf_Small *) space < - dbg->de_debug_typenames + dbg->de_debug_typenames_size) - return; - - if (dbg->de_debug_varnames != NULL && - (Dwarf_Small *) space >= dbg->de_debug_varnames && - (Dwarf_Small *) space < - dbg->de_debug_varnames + dbg->de_debug_varnames_size) - return; - - if (dbg->de_debug_weaknames != NULL && - (Dwarf_Small *) space >= dbg->de_debug_weaknames && - (Dwarf_Small *) space < - dbg->de_debug_weaknames + dbg->de_debug_weaknames_size) - return; - - free(space); - return; - } - - if (alloc_type == DW_DLA_LIST || - alloc_type == DW_DLA_FRAME_BLOCK || - alloc_type == DW_DLA_LOC_BLOCK || - alloc_type == DW_DLA_ADDR) { - - free(space); - return; - } - /* else is an alloc type that is not used */ - /* app or internal error */ + if (type == DW_DLA_STRING) { + if ((Dwarf_Small *) space >= dbg->de_debug_info.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_info.dss_data + dbg->de_debug_info.dss_size) + return; + + if (dbg->de_debug_line.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_line.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_line.dss_data + dbg->de_debug_line.dss_size) + return; + + if (dbg->de_debug_pubnames.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_pubnames.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_pubnames.dss_data + + dbg->de_debug_pubnames.dss_size) + return; + + if (dbg->de_debug_frame.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_frame.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_frame.dss_data + dbg->de_debug_frame.dss_size) + return; + + if (dbg->de_debug_str.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_str.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_str.dss_data + dbg->de_debug_str.dss_size) + return; + + if (dbg->de_debug_funcnames.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_funcnames.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_funcnames.dss_data + + dbg->de_debug_funcnames.dss_size) + return; + + if (dbg->de_debug_typenames.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_typenames.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_typenames.dss_data + + dbg->de_debug_typenames.dss_size) + return; + if (dbg->de_debug_pubtypes.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_pubtypes.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_pubtypes.dss_data + + dbg->de_debug_pubtypes.dss_size) + return; + + if (dbg->de_debug_varnames.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_varnames.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_varnames.dss_data + + dbg->de_debug_varnames.dss_size) + return; + + if (dbg->de_debug_weaknames.dss_data != NULL && + (Dwarf_Small *) space >= dbg->de_debug_weaknames.dss_data && + (Dwarf_Small *) space < + dbg->de_debug_weaknames.dss_data + + dbg->de_debug_weaknames.dss_size) + return; + +#ifdef DWARF_SIMPLE_MALLOC + _dwarf_simple_malloc_delete_from_list(dbg, space, type); +#endif + free(space); + return; + } + + if (type == DW_DLA_LIST || + type == DW_DLA_FRAME_BLOCK || + type == DW_DLA_LOC_BLOCK || type == DW_DLA_ADDR || + type == DW_DLA_RANGES || + type == DW_DLA_HASH_TABLE_ENTRY) { + +#ifdef DWARF_SIMPLE_MALLOC + _dwarf_simple_malloc_delete_from_list(dbg, space, type); +#endif + free(space); + return; + } + /* else is an alloc type that is not used */ + /* app or internal error */ #ifdef DWARF_SIMPLE_MALLOC _dwarf_simple_malloc_botch(4); #endif - return; + return; } - + if (index_into_allocated[type].specialdestructor) { + index_into_allocated[type].specialdestructor(space); + } #ifdef DWARF_SIMPLE_MALLOC - _dwarf_simple_malloc_delete_from_list(dbg, space, alloc_type); + _dwarf_simple_malloc_delete_from_list(dbg, space, type); free(space); -#else /* !DWARF_SIMPLE_MALLOC */ +#else /* !DWARF_SIMPLE_MALLOC */ alloc_hdr = &dbg->de_alloc_hdr[index]; /* Get pointer to Dwarf_Alloc_Area this struct came from. See dwarf_alloc.h ROUND_SIZE_WITH_POINTER stuff */ - alloc_area = *(Dwarf_Alloc_Area *) ((char *) space - _DW_RESERVE); + alloc_area = *(Dwarf_Alloc_Area *) ((char *) space - DW_RESERVE); - /* 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. */ + /* 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 (alloc_area->aa_alloc_hdr != alloc_hdr) { - /* 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... */ + /* 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 - fprintf(stderr, - "libdwarf Internal error: type %d hdr mismatch %x %x area ptr %x\n", - (int) alloc_type, - (int) alloc_area->aa_alloc_hdr, - (int) alloc_hdr, (int) alloc_area); + fprintf(stderr, + "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; + return; } alloc_hdr->ah_struct_user_holds--; @@ -706,29 +801,29 @@ dwarf_dealloc(Dwarf_Debug dbg, /* Give chunk back to malloc only when every struct is freed */ if (alloc_area->aa_free_structs_in_chunk == - alloc_hdr->ah_structs_per_chunk) { - if (alloc_area->aa_prev != NULL) { - alloc_area->aa_prev->aa_next = alloc_area->aa_next; - } else { - alloc_hdr->ah_alloc_area_head = alloc_area->aa_next; - } - - if (alloc_area->aa_next != NULL) { - alloc_area->aa_next->aa_prev = alloc_area->aa_prev; - } - - alloc_hdr->ah_chunks_allocated--; - - if (alloc_area == alloc_hdr->ah_last_alloc_area) { - alloc_hdr->ah_last_alloc_area = NULL; - } - memset(alloc_area,0, sizeof(*alloc_area)); - free(alloc_area); + alloc_hdr->ah_structs_per_chunk) { + if (alloc_area->aa_prev != NULL) { + alloc_area->aa_prev->aa_next = alloc_area->aa_next; + } else { + alloc_hdr->ah_alloc_area_head = alloc_area->aa_next; + } + + if (alloc_area->aa_next != NULL) { + alloc_area->aa_next->aa_prev = alloc_area->aa_prev; + } + + alloc_hdr->ah_chunks_allocated--; + + if (alloc_area == alloc_hdr->ah_last_alloc_area) { + alloc_hdr->ah_last_alloc_area = NULL; + } + memset(alloc_area, 0, sizeof(*alloc_area)); + free(alloc_area); } else { - ((Dwarf_Free_List) space)->fl_next = alloc_area->aa_free_list; - alloc_area->aa_free_list = space; + ((Dwarf_Free_List) space)->fl_next = alloc_area->aa_free_list; + alloc_area->aa_free_list = space; } #endif /* !DWARF_SIMPLE_MALLOC */ } @@ -746,10 +841,9 @@ _dwarf_get_debug(void dbg = (Dwarf_Debug) malloc(sizeof(struct Dwarf_Debug_s)); if (dbg == NULL) - return (NULL); + return (NULL); else - memset(dbg,0, sizeof(struct Dwarf_Debug_s)); - + memset(dbg, 0, sizeof(struct Dwarf_Debug_s)); return (dbg); } @@ -758,7 +852,7 @@ _dwarf_get_debug(void 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 are + DW_DLA_FRAME_BLOCK, DW_DLA_LOC_BLOCK, DW_DLA_RANGES are malloc'ed directly. This routine should be called after _dwarf_setup(), @@ -781,13 +875,6 @@ _dwarf_get_debug(void need to be initialized. Being an internal routine, assume proper dbg. - - - - -*/ -/* -** Set up all the Dwarf_Alloc_Hdr records. */ Dwarf_Debug @@ -796,19 +883,19 @@ _dwarf_setup_debug(Dwarf_Debug dbg) int i; for (i = 1; i <= MAX_DW_DLA; i++) { - const struct ial_s *ialp = &index_into_allocated[i]; - unsigned int hdr_index = ialp->ia_al_num; - Dwarf_Word str_size = ialp->ia_struct_size; - Dwarf_Word str_count = ialp->ia_base_count; - Dwarf_Word rnded_size = ROUND_SIZE_WITH_POINTER(str_size); + const struct ial_s *ialp = &index_into_allocated[i]; + unsigned int hdr_index = ialp->ia_al_num; + Dwarf_Word str_size = ialp->ia_struct_size; + Dwarf_Word str_count = ialp->ia_base_count; + Dwarf_Word rnded_size = ROUND_SIZE_WITH_POINTER(str_size); - Dwarf_Alloc_Hdr alloc_hdr = &dbg->de_alloc_hdr[hdr_index]; + Dwarf_Alloc_Hdr alloc_hdr = &dbg->de_alloc_hdr[hdr_index]; - alloc_hdr->ah_bytes_one_struct = (Dwarf_Half) rnded_size; + alloc_hdr->ah_bytes_one_struct = (Dwarf_Half) rnded_size; - /* ah_structs_per_chunk must be >0 else we are in trouble */ - alloc_hdr->ah_structs_per_chunk = str_count; - alloc_hdr->ah_bytes_malloc_per_chunk = rnded_size * str_count; + /* ah_structs_per_chunk must be >0 else we are in trouble */ + alloc_hdr->ah_structs_per_chunk = str_count; + alloc_hdr->ah_bytes_malloc_per_chunk = rnded_size * str_count; } return (dbg); } @@ -824,86 +911,89 @@ dwarf_print_memory_stats(Dwarf_Debug dbg) Dwarf_Shalf i; /* - Alloc types start at 1, not 0. Hence, the first NULL string, - and also a size of MAX_DW_DLA + 1. */ + Alloc types start at 1, not 0. Hence, the first NULL string, and + also a size of MAX_DW_DLA + 1. */ char *alloc_type_name[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_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_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", }; if (dbg == NULL) - return; + return; printf("Size of Dwarf_Debug %4ld bytes\n", - (long) sizeof(*dbg)); + (long) sizeof(*dbg)); printf("Size of Dwarf_Alloc_Hdr_s %4ld bytes\n", - (long) sizeof(struct Dwarf_Alloc_Hdr_s)); + (long) sizeof(struct Dwarf_Alloc_Hdr_s)); printf("size of Dwarf_Alloc_Area_s %4ld bytes\n", - (long) sizeof(struct Dwarf_Alloc_Area_s)); + (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++) { - int indx = index_into_allocated[i].ia_al_num; - - alloc_hdr = &dbg->de_alloc_hdr[indx]; - if (alloc_hdr->ah_bytes_one_struct != 1) { - 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); - } + int indx = index_into_allocated[i].ia_al_num; + + alloc_hdr = &dbg->de_alloc_hdr[indx]; + if (alloc_hdr->ah_bytes_one_struct != 1) { + 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 function is used to recursively - free the chunks still allocated, and + This recursively frees + the chunks still allocated, and forward chained through the aa_next pointer. */ @@ -911,7 +1001,7 @@ static void _dwarf_recursive_free(Dwarf_Alloc_Area alloc_area) { if (alloc_area->aa_next != NULL) { - _dwarf_recursive_free(alloc_area->aa_next); + _dwarf_recursive_free(alloc_area->aa_next); } alloc_area->aa_next = 0; @@ -920,6 +1010,18 @@ _dwarf_recursive_free(Dwarf_Alloc_Area alloc_area) } #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 +rela_free(struct Dwarf_Section_s * sec) +{ + if (sec->dss_data_was_malloc) { + free(sec->dss_data); + } + sec->dss_data = 0; + 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 @@ -932,46 +1034,80 @@ _dwarf_free_all_of_one_debug(Dwarf_Debug dbg) { Dwarf_Alloc_Hdr alloc_hdr; Dwarf_Shalf i; + Dwarf_CU_Context context = 0; + Dwarf_CU_Context nextcontext = 0; if (dbg == NULL) - return (DW_DLV_ERROR); + 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. */ + + for (context = dbg->de_cu_context_list; + context; context = nextcontext) { + Dwarf_Hash_Table hash_table = context->cc_abbrev_hash_table; + _dwarf_free_abbrev_hash_table_contents(dbg,hash_table); + nextcontext = context->cc_next; + dwarf_dealloc(dbg, hash_table, DW_DLA_HASH_TABLE); + dwarf_dealloc(dbg, context, DW_DLA_CU_CONTEXT); + } + /* Housecleaning done. Now really free all the space. */ #ifdef DWARF_SIMPLE_MALLOC - if(dbg->de_simple_malloc_base) { - struct simple_malloc_record_s *smp = dbg->de_simple_malloc_base; - while( smp) - { - int i; - struct simple_malloc_record_s *prev_smp = 0; - - for(i = 0; i < smp->sr_used; ++i) { - struct simple_malloc_entry_s *cur; - cur = &smp->sr_entry[i]; - if(cur->se_addr != 0) { - free(cur->se_addr); - cur->se_addr = 0; - } - } - prev_smp = smp; - smp = smp->sr_next; - free(prev_smp); - } - dbg->de_simple_malloc_base = 0; - dbg->de_simple_malloc_current = 0; + if (dbg->de_simple_malloc_base) { + struct simple_malloc_record_s *smp = dbg->de_simple_malloc_base; + + while (smp) { + int i; + struct simple_malloc_record_s *prev_smp = 0; + + for (i = 0; i < smp->sr_used; ++i) { + struct simple_malloc_entry_s *cur; + + cur = &smp->sr_entry[i]; + if (cur->se_addr != 0) { + free(cur->se_addr); + cur->se_addr = 0; + } + } + prev_smp = smp; + smp = smp->sr_next; + free(prev_smp); + } + dbg->de_simple_malloc_base = 0; } #else for (i = 1; i < ALLOC_AREA_REAL_TABLE_MAX; i++) { - int indx = i; + int indx = i; - alloc_hdr = &dbg->de_alloc_hdr[indx]; - if (alloc_hdr->ah_alloc_area_head != NULL) { - _dwarf_recursive_free(alloc_hdr->ah_alloc_area_head); - } + alloc_hdr = &dbg->de_alloc_hdr[indx]; + if (alloc_hdr->ah_alloc_area_head != NULL) { + _dwarf_recursive_free(alloc_hdr->ah_alloc_area_head); + } } #endif - - memset(dbg,0, sizeof(*dbg)); /* prevent accidental use later */ + rela_free(&dbg->de_debug_info); + rela_free(&dbg->de_debug_abbrev); + rela_free(&dbg->de_debug_line); + rela_free(&dbg->de_debug_loc); + rela_free(&dbg->de_debug_aranges); + rela_free(&dbg->de_debug_macinfo); + rela_free(&dbg->de_debug_pubnames); + rela_free(&dbg->de_debug_str); + rela_free(&dbg->de_debug_frame); + rela_free(&dbg->de_debug_frame_eh_gnu); + rela_free(&dbg->de_debug_pubtypes); + rela_free(&dbg->de_debug_funcnames); + rela_free(&dbg->de_debug_typenames); + rela_free(&dbg->de_debug_varnames); + rela_free(&dbg->de_debug_weaknames); + rela_free(&dbg->de_debug_ranges); + dwarf_harmless_cleanout(&dbg->de_harmless_errors); + + memset(dbg, 0, sizeof(*dbg)); /* Prevent accidental use later. */ free(dbg); return (DW_DLV_OK); } @@ -989,21 +1125,21 @@ _dwarf_special_no_dbg_error_malloc(void) { /* the union unused things are to guarantee proper alignment */ union u { - Dwarf_Alloc_Area ptr_not_used; - struct Dwarf_Error_s base_not_used; - char data_space[sizeof(struct Dwarf_Error_s) + - (_DW_RESERVE * 2)]; + Dwarf_Alloc_Area ptr_not_used; + struct Dwarf_Error_s base_not_used; + char data_space[sizeof(struct Dwarf_Error_s) + + (DW_RESERVE * 2)]; }; char *mem; mem = malloc(sizeof(union u)); if (mem == 0) { - return 0; + return 0; } - memset(mem,0, sizeof(union u)); - mem += _DW_RESERVE; + memset(mem, 0, sizeof(union u)); + mem += DW_RESERVE; return (struct Dwarf_Error_s *) mem; } @@ -1014,7 +1150,7 @@ _dwarf_free_special_error(Dwarf_Ptr space) { char *mem = (char *) space; - mem -= _DW_RESERVE; + mem -= DW_RESERVE; free(mem); } @@ -1025,56 +1161,57 @@ _dwarf_free_special_error(Dwarf_Ptr space) void _dwarf_simple_malloc_botch(int err) { + fprintf(stderr,"simple malloc botch %d\n",err); } -static void +static void _dwarf_simple_malloc_add_to_list(Dwarf_Debug dbg, - Dwarf_Ptr addr, - unsigned long size, - short alloc_type) + Dwarf_Ptr addr, + unsigned long size, short alloc_type) { - struct simple_malloc_record_s *cur; - struct simple_malloc_entry_s *newentry; - if (!dbg->de_simple_malloc_current) { - /* First entry to this routine. */ - dbg->de_simple_malloc_current = - malloc(sizeof(struct simple_malloc_record_s)); - if(!dbg->de_simple_malloc_current) { - return; /* no memory, give up */ - } - memset(dbg->de_simple_malloc_current, - 0, - sizeof(struct simple_malloc_record_s)); - dbg->de_simple_malloc_base = dbg->de_simple_malloc_current; - } - cur = dbg->de_simple_malloc_current; - - if(cur->sr_used >= DSM_BLOCK_COUNT) { - /* 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 */ - } - memset(newblock,0, sizeof(struct simple_malloc_record_s)); - /* Link the new block at the head of the chain, - and make it 'current' - */ - dbg->de_simple_malloc_current = newblock; - newblock->sr_next = cur; - cur = newblock; - } - newentry = &cur->sr_entry[cur->sr_used]; - newentry->se_addr = addr; - newentry->se_size = size; - newentry->se_type = alloc_type; - ++cur->sr_used; + struct simple_malloc_record_s *cur; + struct simple_malloc_entry_s *newentry; + + if (!dbg->de_simple_malloc_base) { + /* First entry to this routine. */ + dbg->de_simple_malloc_base = + malloc(sizeof(struct simple_malloc_record_s)); + if (!dbg->de_simple_malloc_base) { + _dwarf_simple_malloc_botch(7); + return; /* no memory, give up */ + } + memset(dbg->de_simple_malloc_base, + 0, sizeof(struct simple_malloc_record_s)); + } + cur = dbg->de_simple_malloc_base; + + if (cur->sr_used >= DSM_BLOCK_COUNT) { + /* 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) { + _dwarf_simple_malloc_botch(8); + return; /* Can do nothing, out of memory */ + } + memset(newblock, 0, sizeof(struct simple_malloc_record_s)); + /* Link the new block at the head of the chain, and make it + 'current' */ + dbg->de_simple_malloc_base = newblock; + newblock->sr_next = cur; + cur = newblock; + } + newentry = &cur->sr_entry[cur->sr_used]; + newentry->se_addr = addr; + newentry->se_size = size; + newentry->se_type = alloc_type; + ++cur->sr_used; } + /* - DWARF_SIMPLE_MALLOC is for testing the hypothesis that the existing - complex malloc scheme in libdwarf is pointless complexity. + 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 @@ -1086,37 +1223,36 @@ _dwarf_simple_malloc_add_to_list(Dwarf_Debug dbg, */ static void -_dwarf_simple_malloc_delete_from_list(Dwarf_Debug dbg, - Dwarf_Ptr space, - short alloc_type) +_dwarf_simple_malloc_delete_from_list(Dwarf_Debug dbg, + Dwarf_Ptr space, short alloc_type) { - if(space == 0) { - _dwarf_simple_malloc_botch(6); + if (space == 0) { + _dwarf_simple_malloc_botch(6); } - if(dbg->de_simple_malloc_base) { + if (dbg->de_simple_malloc_base) { struct simple_malloc_record_s *smp = dbg->de_simple_malloc_base; - while( smp) - { + + while (smp) { int i; - for(i = 0; i < smp->sr_used; ++i) { + for (i = 0; i < smp->sr_used; ++i) { struct simple_malloc_entry_s *cur; + cur = &smp->sr_entry[i]; - if(cur->se_addr == space) { - if(cur->se_type != alloc_type ) { - _dwarf_simple_malloc_botch(0); - } - cur->se_addr = 0; - return; + if (cur->se_addr == space) { + if (cur->se_type != alloc_type) { + _dwarf_simple_malloc_botch(0); + } + cur->se_addr = 0; + return; } } smp = smp->sr_next; } } - /* Never found the space */ + /* Never found the space. */ _dwarf_simple_malloc_botch(1); return; } #endif - |