/* Routines for name->symbol lookups in GDB.
- Copyright (C) 2003, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2003-2016 Free Software Foundation, Inc.
Contributed by David Carlton <carlton@bactrian.org> and by Kealia,
Inc.
#include "gdb_obstack.h"
#include "symtab.h"
#include "buildsym.h"
-#include "gdb_assert.h"
#include "dictionary.h"
/* This file implements dictionaries, which are tables that associate
* Define a function dict_<op> that looks up <op> in the dict_vector
and calls the appropriate function. Add a declaration for
- dict_<op> to dictionary.h.
-
-*/
+ dict_<op> to dictionary.h. */
/* An enum representing the various implementations of dictionaries.
Used only for debugging. */
struct symbol *(*iterator_next) (struct dict_iterator *iterator);
/* Functions to iterate over symbols with a given name. */
struct symbol *(*iter_match_first) (const struct dictionary *dict,
- const char *name,
- int (*equiv) (const char *,
- const char *),
- struct dict_iterator *iterator);
+ const char *name,
+ symbol_compare_ftype *equiv,
+ struct dict_iterator *iterator);
struct symbol *(*iter_match_next) (const char *name,
- int (*equiv) (const char *,
- const char *),
+ symbol_compare_ftype *equiv,
struct dict_iterator *iterator);
/* A size function, for maint print symtabs. */
int (*size) (const struct dictionary *dict);
static struct symbol *iter_match_first_hashed (const struct dictionary *dict,
const char *name,
- int (*compare) (const char *,
- const char *),
+ symbol_compare_ftype *compare,
struct dict_iterator *iterator);
static struct symbol *iter_match_next_hashed (const char *name,
- int (*compare) (const char *,
- const char *),
+ symbol_compare_ftype *compare,
struct dict_iterator *iterator);
static unsigned int dict_hash (const char *string);
static struct symbol *iter_match_first_linear (const struct dictionary *dict,
const char *name,
- int (*compare) (const char *,
- const char *),
+ symbol_compare_ftype *compare,
struct dict_iterator *iterator);
static struct symbol *iter_match_next_linear (const char *name,
- int (*compare) (const char *,
- const char *),
+ symbol_compare_ftype *compare,
struct dict_iterator *iterator);
static int size_linear (const struct dictionary *dict);
struct symbol **buckets;
const struct pending *list_counter;
- retval = obstack_alloc (obstack, sizeof (struct dictionary));
+ retval = XOBNEW (obstack, struct dictionary);
DICT_VECTOR (retval) = &dict_hashed_vector;
/* Calculate the number of symbols, and allocate space for them. */
}
nbuckets = DICT_HASHTABLE_SIZE (nsyms);
DICT_HASHED_NBUCKETS (retval) = nbuckets;
- buckets = obstack_alloc (obstack, nbuckets * sizeof (struct symbol *));
+ buckets = XOBNEWVEC (obstack, struct symbol *, nbuckets);
memset (buckets, 0, nbuckets * sizeof (struct symbol *));
DICT_HASHED_BUCKETS (retval) = buckets;
extern struct dictionary *
dict_create_hashed_expandable (void)
{
- struct dictionary *retval;
+ struct dictionary *retval = XNEW (struct dictionary);
- retval = xmalloc (sizeof (struct dictionary));
DICT_VECTOR (retval) = &dict_hashed_expandable_vector;
DICT_HASHED_NBUCKETS (retval) = DICT_EXPANDABLE_INITIAL_CAPACITY;
- DICT_HASHED_BUCKETS (retval) = xcalloc (DICT_EXPANDABLE_INITIAL_CAPACITY,
- sizeof (struct symbol *));
+ DICT_HASHED_BUCKETS (retval) = XCNEWVEC (struct symbol *,
+ DICT_EXPANDABLE_INITIAL_CAPACITY);
DICT_HASHED_EXPANDABLE_NSYMS (retval) = 0;
return retval;
struct symbol **syms;
const struct pending *list_counter;
- retval = obstack_alloc (obstack, sizeof (struct dictionary));
+ retval = XOBNEW (obstack, struct dictionary);
DICT_VECTOR (retval) = &dict_linear_vector;
/* Calculate the number of symbols, and allocate space for them. */
nsyms += list_counter->nsyms;
}
DICT_LINEAR_NSYMS (retval) = nsyms;
- syms = obstack_alloc (obstack, nsyms * sizeof (struct symbol *));
+ syms = XOBNEWVEC (obstack, struct symbol *, nsyms );
DICT_LINEAR_SYMS (retval) = syms;
/* Now fill in the symbols. Start filling in from the back, so as
struct dictionary *
dict_create_linear_expandable (void)
{
- struct dictionary *retval;
+ struct dictionary *retval = XNEW (struct dictionary);
- retval = xmalloc (sizeof (struct dictionary));
DICT_VECTOR (retval) = &dict_linear_expandable_vector;
DICT_LINEAR_NSYMS (retval) = 0;
- DICT_LINEAR_EXPANDABLE_CAPACITY (retval)
- = DICT_EXPANDABLE_INITIAL_CAPACITY;
+ DICT_LINEAR_EXPANDABLE_CAPACITY (retval) = DICT_EXPANDABLE_INITIAL_CAPACITY;
DICT_LINEAR_SYMS (retval)
- = xmalloc (DICT_LINEAR_EXPANDABLE_CAPACITY (retval)
- * sizeof (struct symbol *));
+ = XNEWVEC (struct symbol *, DICT_LINEAR_EXPANDABLE_CAPACITY (retval));
return retval;
}
(DICT_VECTOR (dict))->add_symbol (dict, sym);
}
+/* Utility to add a list of symbols to a dictionary.
+ DICT must be an expandable dictionary. */
+
+void
+dict_add_pending (struct dictionary *dict, const struct pending *symbol_list)
+{
+ const struct pending *list;
+ int i;
+
+ for (list = symbol_list; list != NULL; list = list->next)
+ {
+ for (i = 0; i < list->nsyms; ++i)
+ dict_add_symbol (dict, list->symbol[i]);
+ }
+}
+
/* Initialize ITERATOR to point at the first symbol in DICT, and
return that first symbol, or NULL if DICT is empty. */
struct symbol *
dict_iter_match_first (const struct dictionary *dict,
- const char *name,
- int (*compare) (const char *, const char *),
+ const char *name, symbol_compare_ftype *compare,
struct dict_iterator *iterator)
{
- return (DICT_VECTOR (dict))->iter_match_first (dict, name, compare, iterator);
+ return (DICT_VECTOR (dict))->iter_match_first (dict, name,
+ compare, iterator);
}
struct symbol *
-dict_iter_match_next (const char *name,
- int (*compare) (const char *, const char *),
+dict_iter_match_next (const char *name, symbol_compare_ftype *compare,
struct dict_iterator *iterator)
{
return (DICT_VECTOR (DICT_ITERATOR_DICT (iterator)))
}
static struct symbol *
-iter_match_first_hashed (const struct dictionary *dict,
- const char *name,
- int (*compare) (const char *, const char *),
+iter_match_first_hashed (const struct dictionary *dict, const char *name,
+ symbol_compare_ftype *compare,
struct dict_iterator *iterator)
{
unsigned int hash_index = dict_hash (name) % DICT_HASHED_NBUCKETS (dict);
}
static struct symbol *
-iter_match_next_hashed (const char *name,
- int (*compare) (const char *, const char *),
+iter_match_next_hashed (const char *name, symbol_compare_ftype *compare,
struct dict_iterator *iterator)
{
struct symbol *next;
{
int old_nbuckets = DICT_HASHED_NBUCKETS (dict);
struct symbol **old_buckets = DICT_HASHED_BUCKETS (dict);
- int new_nbuckets = 2*old_nbuckets + 1;
- struct symbol **new_buckets = xcalloc (new_nbuckets,
- sizeof (struct symbol *));
+ int new_nbuckets = 2 * old_nbuckets + 1;
+ struct symbol **new_buckets = XCNEWVEC (struct symbol *, new_nbuckets);
int i;
DICT_HASHED_NBUCKETS (dict) = new_nbuckets;
string = string0;
if (*string == '_')
{
- if (strncmp (string, "_ada_", 5) == 0)
+ if (startswith (string, "_ada_"))
string += 5;
else
return msymbol_hash_iw (string0);
hash = 0;
while (*string)
{
+ /* Ignore "TKB" suffixes.
+
+ These are used by Ada for subprograms implementing a task body.
+ For instance for a task T inside package Pck, the name of the
+ subprogram implementing T's body is `pck__tTKB'. We need to
+ ignore the "TKB" suffix because searches for this task body
+ subprogram are going to be performed using `pck__t' (the encoded
+ version of the natural name `pck.t'). */
+ if (strcmp (string, "TKB") == 0)
+ return hash;
+
switch (*string)
{
case '$':
}
/* FALL THROUGH */
default:
- hash = hash * 67 + *string - 113;
+ hash = SYMBOL_HASH_NEXT (hash, *string);
string += 1;
break;
}
static struct symbol *
iter_match_first_linear (const struct dictionary *dict,
- const char *name,
- int (*compare) (const char *, const char *),
+ const char *name, symbol_compare_ftype *compare,
struct dict_iterator *iterator)
{
DICT_ITERATOR_DICT (iterator) = dict;
}
static struct symbol *
-iter_match_next_linear (const char *name,
- int (*compare) (const char *, const char *),
+iter_match_next_linear (const char *name, symbol_compare_ftype *compare,
struct dict_iterator *iterator)
{
const struct dictionary *dict = DICT_ITERATOR_DICT (iterator);
{
DICT_LINEAR_EXPANDABLE_CAPACITY (dict) *= 2;
DICT_LINEAR_SYMS (dict)
- = xrealloc (DICT_LINEAR_SYMS (dict),
- DICT_LINEAR_EXPANDABLE_CAPACITY (dict)
- * sizeof (struct symbol *));
+ = XRESIZEVEC (struct symbol *, DICT_LINEAR_SYMS (dict),
+ DICT_LINEAR_EXPANDABLE_CAPACITY (dict));
}
DICT_LINEAR_SYM (dict, nsyms - 1) = sym;
projects / deliverable / binutils-gdb.git / blobdiff