noinst_LIBRARIES = libeu.a
libeu_a_SOURCES = xasprintf.c xstrdup.c xstrndup.c xmalloc.c next_prime.c \
- crc32.c crc32_file.c \
+ crc32.c crc32_file.c eu-search.c \
color.c error.c printversion.c
noinst_HEADERS = fixedsizehash.h libeu.h system.h dynamicsizehash.h list.h \
eu-config.h color.h printversion.h bpf.h \
- atomics.h stdatomic-fbsd.h dynamicsizehash_concurrent.h
+ atomics.h stdatomic-fbsd.h dynamicsizehash_concurrent.h \
+ eu-search.h locks.h
EXTRA_DIST = dynamicsizehash.c dynamicsizehash_concurrent.c
#ifndef EU_CONFIG_H
#define EU_CONFIG_H 1
-#ifdef USE_LOCKS
-# include <pthread.h>
-# include <assert.h>
-# define rwlock_define(class,name) class pthread_rwlock_t name
-# define once_define(class,name) class pthread_once_t name = PTHREAD_ONCE_INIT
-# define RWLOCK_CALL(call) \
- ({ int _err = pthread_rwlock_ ## call; assert_perror (_err); })
-# define ONCE_CALL(call) \
- ({ int _err = pthread_ ## call; assert_perror (_err); })
-# define rwlock_init(lock) RWLOCK_CALL (init (&lock, NULL))
-# define rwlock_fini(lock) RWLOCK_CALL (destroy (&lock))
-# define rwlock_rdlock(lock) RWLOCK_CALL (rdlock (&lock))
-# define rwlock_wrlock(lock) RWLOCK_CALL (wrlock (&lock))
-# define rwlock_unlock(lock) RWLOCK_CALL (unlock (&lock))
-# define once(once_control, init_routine) \
- ONCE_CALL (once (&once_control, init_routine))
-#else
-/* Eventually we will allow multi-threaded applications to use the
- libraries. Therefore we will add the necessary locking although
- the macros used expand to nothing for now. */
-# define rwlock_define(class,name) class int name
-# define rwlock_init(lock) ((void) (lock))
-# define rwlock_fini(lock) ((void) (lock))
-# define rwlock_rdlock(lock) ((void) (lock))
-# define rwlock_wrlock(lock) ((void) (lock))
-# define rwlock_unlock(lock) ((void) (lock))
-# define once_define(class,name)
-# define once(once_control, init_routine) init_routine()
-#endif /* USE_LOCKS */
+#include "locks.h"
#include <libintl.h>
/* gettext helper macros. */
--- /dev/null
+/* Definitions for thread-safe tsearch/tfind
+ Copyright (C) 2023 Rice University
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "eu-search.h"
+
+void *eu_tsearch (const void *key, search_tree *tree,
+ int (*compare)(const void *, const void *))
+{
+ rwlock_wrlock (tree->lock);
+ void *ret = tsearch (key, &tree->root, compare);
+ rwlock_unlock (tree->lock);
+
+ return ret;
+}
+
+void *eu_tfind (const void *key, search_tree *tree,
+ int (*compare)(const void *, const void *))
+{
+ rwlock_rdlock (tree->lock);
+ void *ret = tfind (key, &tree->root, compare);
+ rwlock_unlock (tree->lock);
+
+ return ret;
+}
+
+void *eu_tdelete (const void *key, search_tree *tree,
+ int (*compare)(const void *, const void *))
+{
+ rwlock_wrlock (tree->lock);
+ void *ret = tdelete (key, &tree->root, compare);
+ rwlock_unlock (tree->lock);
+
+ return ret;
+}
+
+void eu_tdestroy (search_tree *tree, void (*free_node)(void *))
+{
+ rwlock_wrlock (tree->lock);
+
+ tdestroy (tree->root, free_node);
+ tree->root = NULL;
+
+ rwlock_unlock (tree->lock);
+}
+
+void eu_search_tree_init (search_tree *tree)
+{
+ tree->root = NULL;
+ rwlock_init (tree->lock);
+}
+
+void eu_search_tree_fini (search_tree *tree, void (*free_node)(void *))
+{
+ eu_tdestroy (tree, free_node);
+ rwlock_fini (tree->lock);
+}
--- /dev/null
+/* Calls for thread-safe tsearch/tfind
+ Copyright (C) 2023 Rice University
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef EU_SEARCH_H
+#define EU_SEARCH_H 1
+
+#include <stdlib.h>
+#include <search.h>
+#include <locks.h>
+
+typedef struct
+{
+ void *root;
+ rwlock_define (, lock);
+} search_tree;
+
+/* Search TREE for KEY and add KEY if not found. Synchronized using
+ TREE's lock. */
+extern void *eu_tsearch (const void *key, search_tree *tree,
+ int (*compare)(const void *, const void *));
+
+/* Search TREE for KEY. Synchronized with TREE's lock. */
+extern void *eu_tfind (const void *key, search_tree *tree,
+ int (*compare)(const void *, const void *));
+
+/* Delete key from TREE. Synchronized with TREE's lock. */
+extern void *eu_tdelete (const void *key, search_tree *tree,
+ int (*compare)(const void *, const void *));
+
+/* Free all nodes from TREE. */
+void eu_tdestroy (search_tree *tree, void (*free_node)(void *));
+
+/* Initialize TREE's root and lock. */
+void eu_search_tree_init (search_tree *tree);
+
+/* Free all nodes from TREE as well as TREE's lock. */
+void eu_search_tree_fini (search_tree *tree, void (*free_node)(void *));
+
+#endif
--- /dev/null
+/* Configuration definitions.
+ Copyright (C) 2024 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef LOCKS_H
+#define LOCKS_H 1
+
+#ifdef USE_LOCKS
+# include <pthread.h>
+# include <assert.h>
+# define rwlock_define(class,name) class pthread_rwlock_t name
+# define once_define(class,name) class pthread_once_t name = PTHREAD_ONCE_INIT
+# define RWLOCK_CALL(call) \
+ ({ int _err = pthread_rwlock_ ## call; assert_perror (_err); })
+# define ONCE_CALL(call) \
+ ({ int _err = pthread_ ## call; assert_perror (_err); })
+# define rwlock_init(lock) RWLOCK_CALL (init (&lock, NULL))
+# define rwlock_fini(lock) RWLOCK_CALL (destroy (&lock))
+# define rwlock_rdlock(lock) RWLOCK_CALL (rdlock (&lock))
+# define rwlock_wrlock(lock) RWLOCK_CALL (wrlock (&lock))
+# define rwlock_unlock(lock) RWLOCK_CALL (unlock (&lock))
+# define once(once_control, init_routine) \
+ ONCE_CALL (once (&once_control, init_routine))
+#else
+/* Eventually we will allow multi-threaded applications to use the
+ libraries. Therefore we will add the necessary locking although
+ the macros used expand to nothing for now. */
+# define rwlock_define(class,name) class int name
+# define rwlock_init(lock) ((void) (lock))
+# define rwlock_fini(lock) ((void) (lock))
+# define rwlock_rdlock(lock) ((void) (lock))
+# define rwlock_wrlock(lock) ((void) (lock))
+# define rwlock_unlock(lock) ((void) (lock))
+# define once_define(class,name)
+# define once(once_control, init_routine) init_routine()
+#endif /* USE_LOCKS */
+
+#endif /* locks.h */
Dwarf_Off next_offset;
/* Search tree for the CIEs, indexed by CIE_pointer (section offset). */
- void *cie_tree;
+ search_tree cie_tree;
/* Search tree for the FDEs, indexed by PC address. */
- void *fde_tree;
+ search_tree fde_tree;
/* Search tree for parsed DWARF expressions, indexed by raw pointer. */
- void *expr_tree;
+ search_tree expr_tree;
/* Backend hook. */
struct ebl *ebl;
#include "cfi.h"
#include "encoded-value.h"
#include <assert.h>
-#include <search.h>
#include <stdlib.h>
+#include "eu-search.h"
static int
cie->initial_state = NULL;
/* Add the new entry to the search tree. */
- if (tsearch (cie, &cache->cie_tree, &compare_cie) == NULL)
+ if (eu_tsearch (cie, &cache->cie_tree, &compare_cie) == NULL)
{
free (cie);
__libdw_seterrno (DWARF_E_NOMEM);
__libdw_find_cie (Dwarf_CFI *cache, Dwarf_Off offset)
{
const struct dwarf_cie cie_key = { .offset = offset };
- struct dwarf_cie **found = tfind (&cie_key, &cache->cie_tree, &compare_cie);
+ struct dwarf_cie **found = eu_tfind (&cie_key, &cache->cie_tree,
+ &compare_cie);
if (found != NULL)
return *found;
__libdw_intern_cie (Dwarf_CFI *cache, Dwarf_Off offset, const Dwarf_CIE *info)
{
const struct dwarf_cie cie_key = { .offset = offset };
- struct dwarf_cie **found = tfind (&cie_key, &cache->cie_tree, &compare_cie);
+ struct dwarf_cie **found = eu_tfind (&cie_key, &cache->cie_tree,
+ &compare_cie);
if (found == NULL)
/* We have not read this CIE yet. Enter it. */
(void) intern_new_cie (cache, offset, info);
result->fake_loc_cu->endp
= (result->sectiondata[IDX_debug_loc]->d_buf
+ result->sectiondata[IDX_debug_loc]->d_size);
- result->fake_loc_cu->locs = NULL;
result->fake_loc_cu->address_size = elf_addr_size;
result->fake_loc_cu->offset_size = 4;
result->fake_loc_cu->version = 4;
result->fake_loc_cu->split = NULL;
+ eu_search_tree_init (&result->fake_loc_cu->locs_tree);
}
}
result->fake_loclists_cu->endp
= (result->sectiondata[IDX_debug_loclists]->d_buf
+ result->sectiondata[IDX_debug_loclists]->d_size);
- result->fake_loclists_cu->locs = NULL;
result->fake_loclists_cu->address_size = elf_addr_size;
result->fake_loclists_cu->offset_size = 4;
result->fake_loclists_cu->version = 5;
result->fake_loclists_cu->split = NULL;
+ eu_search_tree_init (&result->fake_loclists_cu->locs_tree);
}
}
result->fake_addr_cu->endp
= (result->sectiondata[IDX_debug_addr]->d_buf
+ result->sectiondata[IDX_debug_addr]->d_size);
- result->fake_addr_cu->locs = NULL;
result->fake_addr_cu->address_size = elf_addr_size;
result->fake_addr_cu->offset_size = 4;
result->fake_addr_cu->version = 5;
result->fake_addr_cu->split = NULL;
+ eu_search_tree_init (&result->fake_addr_cu->locs_tree);
}
}
cu_free (void *arg)
{
struct Dwarf_CU *p = (struct Dwarf_CU *) arg;
-
- tdestroy (p->locs, noop_free);
+ eu_search_tree_fini (&p->locs_tree, noop_free);
/* Only free the CU internals if its not a fake CU. */
- if(p != p->dbg->fake_loc_cu && p != p->dbg->fake_loclists_cu
+ if (p != p->dbg->fake_loc_cu && p != p->dbg->fake_loclists_cu
&& p != p->dbg->fake_addr_cu)
{
Dwarf_Abbrev_Hash_free (&p->abbrev_hash);
/* The search tree for the CUs. NB: the CU data itself is
allocated separately, but the abbreviation hash tables need
to be handled. */
- tdestroy (dwarf->cu_tree, cu_free);
- tdestroy (dwarf->tu_tree, cu_free);
+ eu_search_tree_fini (&dwarf->cu_tree, cu_free);
+ eu_search_tree_fini (&dwarf->tu_tree, cu_free);
/* Search tree for macro opcode tables. */
- tdestroy (dwarf->macro_ops, noop_free);
+ eu_search_tree_fini (&dwarf->macro_ops_tree, noop_free);
/* Search tree for decoded .debug_lines units. */
- tdestroy (dwarf->files_lines, noop_free);
+ eu_search_tree_fini (&dwarf->files_lines_tree, noop_free);
/* And the split Dwarf. */
- tdestroy (dwarf->split_tree, noop_free);
+ eu_search_tree_fini (&dwarf->split_tree, noop_free);
/* Free the internally allocated memory. */
for (size_t i = 0; i < dwarf->mem_stacks; i++)
cfi->default_same_value = false;
cfi->next_offset = 0;
- cfi->cie_tree = cfi->fde_tree = cfi->expr_tree = NULL;
+
+ eu_search_tree_init (&cfi->cie_tree);
+ eu_search_tree_init (&cfi->fde_tree);
+ eu_search_tree_init (&cfi->expr_tree);
cfi->ebl = NULL;
#endif
#include <dwarf.h>
-#include <search.h>
#include <stdlib.h>
#include <assert.h>
#include <libdwP.h>
+#include "eu-search.h"
static bool
/* For each DW_OP_implicit_value, we store a special entry in the cache.
This points us directly to the block data for later fetching.
- Returns zero on success, -1 on bad DWARF or 1 if tsearch failed. */
+ Returns zero on success, -1 on bad DWARF or 1 if eu_tsearch failed. */
static int
-store_implicit_value (Dwarf *dbg, void **cache, Dwarf_Op *op)
+store_implicit_value (Dwarf *dbg, search_tree *cache, Dwarf_Op *op)
{
if (dbg == NULL)
return -1;
block->addr = op;
block->data = (unsigned char *) data;
block->length = op->number;
- if (unlikely (tsearch (block, cache, loc_compare) == NULL))
+ if (unlikely (eu_tsearch (block, cache, loc_compare) == NULL))
return 1;
return 0;
}
return -1;
struct loc_block_s fake = { .addr = (void *) op };
- struct loc_block_s **found = tfind (&fake, &attr->cu->locs, loc_compare);
+ struct loc_block_s **found = eu_tfind (&fake, &attr->cu->locs_tree,
+ loc_compare);
if (unlikely (found == NULL))
{
__libdw_seterrno (DWARF_E_NO_BLOCK);
/* Check whether we already cached this location. */
struct loc_s fake = { .addr = attr->valp };
- struct loc_s **found = tfind (&fake, &attr->cu->locs, loc_compare);
+ struct loc_s **found = eu_tfind (&fake, &attr->cu->locs_tree, loc_compare);
if (found == NULL)
{
newp->loc = result;
newp->nloc = 1;
- found = tsearch (newp, &attr->cu->locs, loc_compare);
+ found = eu_tsearch (newp, &attr->cu->locs_tree, loc_compare);
}
assert ((*found)->nloc == 1);
internal_function
__libdw_intern_expression (Dwarf *dbg, bool other_byte_order,
unsigned int address_size, unsigned int ref_size,
- void **cache, const Dwarf_Block *block,
+ search_tree *cache, const Dwarf_Block *block,
bool cfap, bool valuep,
Dwarf_Op **llbuf, size_t *listlen, int sec_index)
{
/* Check whether we already looked at this list. */
struct loc_s fake = { .addr = block->data };
- struct loc_s **found = tfind (&fake, cache, loc_compare);
+ struct loc_s **found = eu_tfind (&fake, cache, loc_compare);
if (found != NULL)
{
/* We already saw it. */
newp->addr = block->data;
newp->loc = result;
newp->nloc = *listlen;
- (void) tsearch (newp, cache, loc_compare);
+ eu_tsearch (newp, cache, loc_compare);
/* We did it. */
return 0;
cu->address_size, (cu->version == 2
? cu->address_size
: cu->offset_size),
- &cu->locs, block,
+ &cu->locs_tree, block,
false, false,
llbuf, listlen, sec_index);
}
#include <assert.h>
#include <dwarf.h>
-#include <search.h>
#include <stdlib.h>
#include <string.h>
#include <libdwP.h>
+#include "eu-search.h"
static int
get_offset_from (Dwarf_Die *die, int name, Dwarf_Word *retp)
Dwarf_Die *cudie)
{
Dwarf_Macro_Op_Table fake = { .offset = macoff, .sec_index = sec_index };
- Dwarf_Macro_Op_Table **found = tfind (&fake, &dbg->macro_ops,
+ Dwarf_Macro_Op_Table **found = eu_tfind (&fake, &dbg->macro_ops_tree,
macro_op_compare);
if (found != NULL)
return *found;
if (table == NULL)
return NULL;
- Dwarf_Macro_Op_Table **ret = tsearch (table, &dbg->macro_ops,
+ Dwarf_Macro_Op_Table **ret = eu_tsearch (table, &dbg->macro_ops_tree,
macro_op_compare);
if (unlikely (ret == NULL))
{
#include <assert.h>
#include <stdlib.h>
#include <string.h>
-#include <search.h>
#include "dwarf.h"
#include "libdwP.h"
+#include "eu-search.h"
struct filelist
Dwarf_Lines **linesp, Dwarf_Files **filesp)
{
struct files_lines_s fake = { .debug_line_offset = debug_line_offset };
- struct files_lines_s **found = tfind (&fake, &dbg->files_lines,
- files_lines_compare);
+ struct files_lines_s **found = eu_tfind (&fake, &dbg->files_lines_tree,
+ files_lines_compare);
if (found == NULL)
{
/* This .debug_line is being read for the first time. */
node->debug_line_offset = debug_line_offset;
- found = tsearch (node, &dbg->files_lines, files_lines_compare);
+ found = eu_tsearch (node, &dbg->files_lines_tree, files_lines_compare);
if (found == NULL)
{
__libdw_seterrno (DWARF_E_NOMEM);
#endif
#include "cfi.h"
-#include <search.h>
+#include "eu-search.h"
#include <stdlib.h>
#include "encoded-value.h"
fde->instructions += cie->fde_augmentation_data_size;
/* Add the new entry to the search tree. */
- struct dwarf_fde **tres = tsearch (fde, &cache->fde_tree, &compare_fde);
+ struct dwarf_fde **tres = eu_tsearch (fde, &cache->fde_tree, &compare_fde);
if (tres == NULL)
{
free (fde);
/* Look for a cached FDE covering this address. */
const struct dwarf_fde fde_key = { .start = address, .end = 0 };
- struct dwarf_fde **found = tfind (&fde_key, &cache->fde_tree, &compare_fde);
+ struct dwarf_fde **found = eu_tfind (&fde_key, &cache->fde_tree, &compare_fde);
if (found != NULL)
return *found;
internal_function
__libdw_destroy_frame_cache (Dwarf_CFI *cache)
{
- /* Most of the data is in our two search trees. */
- tdestroy (cache->fde_tree, free_fde);
- tdestroy (cache->cie_tree, free_cie);
- tdestroy (cache->expr_tree, free_expr);
+ /* Most of the data is in our three search trees. */
+ eu_search_tree_fini (&cache->fde_tree, free_fde);
+ eu_search_tree_fini (&cache->cie_tree, free_cie);
+ eu_search_tree_fini (&cache->expr_tree, free_expr);
if (cache->ebl != NULL && cache->ebl != (void *) -1l)
ebl_closebackend (cache->ebl);
#include <libdw.h>
#include <dwarf.h>
+#include "eu-search.h"
/* Known location expressions already decoded. */
size_t pubnames_nsets;
/* Search tree for the CUs. */
- void *cu_tree;
+ search_tree cu_tree;
Dwarf_Off next_cu_offset;
/* Search tree and sig8 hash table for .debug_types type units. */
- void *tu_tree;
+ search_tree tu_tree;
Dwarf_Off next_tu_offset;
Dwarf_Sig8_Hash sig8_hash;
/* Search tree for split Dwarf associated with CUs in this debug. */
- void *split_tree;
+ search_tree split_tree;
/* Search tree for .debug_macro operator tables. */
- void *macro_ops;
+ search_tree macro_ops_tree;
/* Search tree for decoded .debug_line units. */
- void *files_lines;
+ search_tree files_lines_tree;
/* Address ranges read from .debug_aranges. */
Dwarf_Aranges *aranges;
Dwarf_Files *files;
/* Known location lists. */
- void *locs;
+ search_tree locs_tree;
/* Base address for use with ranges and locs.
Don't access directly, call __libdw_cu_base_address. */
bool other_byte_order,
unsigned int address_size,
unsigned int ref_size,
- void **cache, const Dwarf_Block *block,
+ search_tree *cache,
+ const Dwarf_Block *block,
bool cfap, bool valuep,
Dwarf_Op **llbuf, size_t *listlen,
int sec_index)
#include "libdwP.h"
#include "libelfP.h"
+#include "eu-search.h"
#include <limits.h>
-#include <search.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
if (split->unit_type == DW_UT_split_compile
&& cu->unit_id8 == split->unit_id8)
{
- if (tsearch (split->dbg, &cu->dbg->split_tree,
- __libdw_finddbg_cb) == NULL)
+ if (eu_tsearch (split->dbg, &cu->dbg->split_tree,
+ __libdw_finddbg_cb) == NULL)
{
/* Something went wrong. Don't link. */
__libdw_seterrno (DWARF_E_NOMEM);
cu->unit_id8);
if (split != NULL)
{
- if (tsearch (split->dbg, &cu->dbg->split_tree,
- __libdw_finddbg_cb) == NULL)
+ if (eu_tsearch (split->dbg, &cu->dbg->split_tree,
+ __libdw_finddbg_cb) == NULL)
{
/* Something went wrong. Don't link. */
__libdw_seterrno (DWARF_E_NOMEM);
#endif
#include <assert.h>
-#include <search.h>
+#include "eu-search.h"
#include "libdwP.h"
static int
{
Dwarf_Off *const offsetp
= debug_types ? &dbg->next_tu_offset : &dbg->next_cu_offset;
- void **tree = debug_types ? &dbg->tu_tree : &dbg->cu_tree;
+ search_tree *tree = debug_types ? &dbg->tu_tree : &dbg->cu_tree;
Dwarf_Off oldoff = *offsetp;
uint16_t version;
newp->orig_abbrev_offset = newp->last_abbrev_offset = abbrev_offset;
newp->files = NULL;
newp->lines = NULL;
- newp->locs = NULL;
newp->split = (Dwarf_CU *) -1;
newp->base_address = (Dwarf_Addr) -1;
newp->addr_base = (Dwarf_Off) -1;
newp->startp = data->d_buf + newp->start;
newp->endp = data->d_buf + newp->end;
+ eu_search_tree_init (&newp->locs_tree);
/* v4 debug type units have version == 4 and unit_type == DW_UT_type. */
if (debug_types)
Dwarf_Sig8_Hash_insert (&dbg->sig8_hash, unit_id8, newp);
/* Add the new entry to the search tree. */
- if (tsearch (newp, tree, findcu_cb) == NULL)
+ if (eu_tsearch (newp, tree, findcu_cb) == NULL)
{
/* Something went wrong. Undo the operation. */
*offsetp = oldoff;
internal_function
__libdw_findcu (Dwarf *dbg, Dwarf_Off start, bool v4_debug_types)
{
- void **tree = v4_debug_types ? &dbg->tu_tree : &dbg->cu_tree;
+ search_tree *tree = v4_debug_types ? &dbg->tu_tree : &dbg->cu_tree;
Dwarf_Off *next_offset
= v4_debug_types ? &dbg->next_tu_offset : &dbg->next_cu_offset;
/* Maybe we already know that CU. */
struct Dwarf_CU fake = { .start = start, .end = 0 };
- struct Dwarf_CU **found = tfind (&fake, tree, findcu_cb);
+ struct Dwarf_CU **found = eu_tfind (&fake, tree, findcu_cb);
if (found != NULL)
return *found;
internal_function
__libdw_findcu_addr (Dwarf *dbg, void *addr)
{
- void **tree;
+ search_tree *tree;
Dwarf_Off start;
if (addr >= dbg->sectiondata[IDX_debug_info]->d_buf
&& addr < (dbg->sectiondata[IDX_debug_info]->d_buf
return NULL;
struct Dwarf_CU fake = { .start = start, .end = 0 };
- struct Dwarf_CU **found = tfind (&fake, tree, findcu_cb);
+ struct Dwarf_CU **found = eu_tfind (&fake, tree, findcu_cb);
if (found != NULL)
return *found;
/* XXX Assumes split DWARF only has CUs in main IDX_debug_info. */
Elf_Data fake_data = { .d_buf = addr, .d_size = 0 };
Dwarf fake = { .sectiondata[IDX_debug_info] = &fake_data };
- Dwarf **found = tfind (&fake, &dbg->split_tree, __libdw_finddbg_cb);
+ Dwarf **found = eu_tfind (&fake, &dbg->split_tree, __libdw_finddbg_cb);
if (found != NULL)
return *found;
# include <config.h>
#endif
+#include "eu-search.h"
#include "libdwflP.h"
#include "libdwP.h"
#include "memory-access.h"
-#include <search.h>
static inline Dwarf_Arange *
return;
/* We know about all the CUs now, we don't need this table. */
- tdestroy (mod->lazy_cu_root, nofree);
- mod->lazy_cu_root = NULL;
+ eu_tdestroy (&mod->lazy_cu_tree, nofree);
}
static inline Dwarf_Off
struct dwfl_cu key;
key.die.cu = die->cu;
- struct dwfl_cu **found = tsearch (&key, &mod->lazy_cu_root, &compare_cukey);
+ struct dwfl_cu **found = eu_tsearch (&key, &mod->lazy_cu_tree,
+ &compare_cukey);
if (unlikely (found == NULL))
return DWFL_E_NOMEM;
internal_function
__libdwfl_module_free (Dwfl_Module *mod)
{
- if (mod->lazy_cu_root != NULL)
- tdestroy (mod->lazy_cu_root, nofree);
+ eu_search_tree_fini (&mod->lazy_cu_tree, nofree);
if (mod->aranges != NULL)
free (mod->aranges);
mod->low_addr = start;
mod->high_addr = end;
mod->dwfl = dwfl;
+ eu_search_tree_init (&mod->lazy_cu_tree);
return use (mod, tailp, dwfl);
}
#include "libdwP.h" /* We need its INTDECLs. */
#include "libdwelfP.h"
+#include "eu-search.h"
typedef struct Dwfl_Process Dwfl_Process;
/* Known CU's in this module. */
struct dwfl_cu *first_cu, **cu;
- void *lazy_cu_root; /* Table indexed by Dwarf_Off of CU. */
+ search_tree lazy_cu_tree; /* Table indexed by Dwarf_Off of CU. */
struct dwfl_arange *aranges; /* Mapping of addresses in module to CUs. */
/* So far only one block with sections. */
elf->state.elf32.scns_last = &elf->state.elf32.scns;
+ eu_search_tree_init (&elf->state.elf32.rawchunk_tree);
}
else
{
/* So far only one block with sections. */
elf->state.elf64.scns_last = &elf->state.elf64.scns;
+ eu_search_tree_init (&elf->state.elf64.rawchunk_tree);
}
return elf;
case ELF_K_ELF:
{
- void *rawchunks
+ search_tree *rawchunk_tree
= (elf->class == ELFCLASS32
- || (offsetof (struct Elf, state.elf32.rawchunks)
- == offsetof (struct Elf, state.elf64.rawchunks))
- ? elf->state.elf32.rawchunks
- : elf->state.elf64.rawchunks);
- tdestroy (rawchunks, free_chunk);
+ || (offsetof (struct Elf, state.elf32.rawchunk_tree)
+ == offsetof (struct Elf, state.elf64.rawchunk_tree))
+ ? &elf->state.elf32.rawchunk_tree
+ : &elf->state.elf64.rawchunk_tree);
+
+ eu_search_tree_fini (rawchunk_tree, free_chunk);
Elf_ScnList *list = (elf->class == ELFCLASS32
|| (offsetof (struct Elf, state.elf32.scns)
#include <assert.h>
#include <errno.h>
-#include <search.h>
-#include <stdlib.h>
#include <string.h>
#include "libelfP.h"
#include "common.h"
+#include "eu-search.h"
static int
chunk_compare (const void *a, const void *b)
key.offset = offset;
key.data.d.d_size = size;
key.data.d.d_type = type;
- Elf_Data_Chunk **found = tsearch (&key, &elf->state.elf.rawchunks,
- &chunk_compare);
+ Elf_Data_Chunk **found
+ = eu_tsearch (&key, &elf->state.elf.rawchunk_tree, &chunk_compare);
+
if (found == NULL)
goto nomem;
if (rawchunk == NULL)
{
nomem:
- tdelete (&key, &elf->state.elf.rawchunks, &chunk_compare);
+ eu_tdelete (&key, &elf->state.elf.rawchunk_tree, &chunk_compare);
__libelf_seterrno (ELF_E_NOMEM);
goto out;
}
!= size))
{
/* Something went wrong. */
- tdelete (&key, &elf->state.elf.rawchunks, &chunk_compare);
+ eu_tdelete (&key, &elf->state.elf.rawchunk_tree, &chunk_compare);
free (rawchunk);
__libelf_seterrno (ELF_E_READ_ERROR);
goto out;
#include <ar.h>
#include <gelf.h>
+#include "eu-search.h"
#include <errno.h>
#include <stdbool.h>
Elf_ScnList *scns_last; /* Last element in the section list.
If NULL the data has not yet been
read from the file. */
- void *rawchunks; /* Tree of elf_getdata_rawchunk results. */
+ search_tree rawchunk_tree; /* Tree and lock for elf_getdata_rawchunk
+ results. */
unsigned int scnincr; /* Number of sections allocate the last
time. */
int ehdr_flags; /* Flags (dirty) for ELF header. */
Elf_ScnList *scns_last; /* Last element in the section list.
If NULL the data has not yet been
read from the file. */
- void *rawchunks; /* Tree of elf_getdata_rawchunk results. */
+ search_tree rawchunk_tree; /* Tree and lock for
+ elf_getdata_rawchunk results. */
unsigned int scnincr; /* Number of sections allocate the last
time. */
int ehdr_flags; /* Flags (dirty) for ELF header. */
Elf_ScnList *scns_last; /* Last element in the section list.
If NULL the data has not yet been
read from the file. */
- void *rawchunks; /* Tree of elf_getdata_rawchunk results. */
+ search_tree rawchunk_tree; /* Tree and lock for
+ elf_getdata_rawchunk results. */
unsigned int scnincr; /* Number of sections allocate the last
time. */
int ehdr_flags; /* Flags (dirty) for ELF header. */
projects / thirdparty / elfutils.git / commitdiff
