static void (*ia64_float_to_chars) (char *, LITTLENUM_TYPE *, int);
-static struct hash_control *alias_hash;
-static struct hash_control *alias_name_hash;
-static struct hash_control *secalias_hash;
-static struct hash_control *secalias_name_hash;
+static htab_t alias_hash;
+static htab_t alias_name_hash;
+static htab_t secalias_hash;
+static htab_t secalias_name_hash;
/* List of chars besides those in app.c:symbol_chars that can start an
operand. Used to prevent the scrubber eating vital white-space. */
static struct
{
- struct hash_control *pseudo_hash; /* pseudo opcode hash table */
- struct hash_control *reg_hash; /* register name hash table */
- struct hash_control *dynreg_hash; /* dynamic register hash table */
- struct hash_control *const_hash; /* constant hash table */
- struct hash_control *entry_hash; /* code entry hint hash table */
+ htab_t pseudo_hash; /* pseudo opcode hash table */
+ htab_t reg_hash; /* register name hash table */
+ htab_t dynreg_hash; /* dynamic register hash table */
+ htab_t const_hash; /* constant hash table */
+ htab_t entry_hash; /* code entry hint hash table */
/* If X_op is != O_absent, the register name for the instruction's
qualifying predicate. If NULL, p0 is assumed for instructions
/* First, remove existing names from hash table. */
for (dr = md.dynreg[type]; dr && dr->num_regs; dr = dr->next)
{
- hash_delete (md.dynreg_hash, dr->name, FALSE);
+ str_hash_delete (md.dynreg_hash, dr->name);
/* FIXME: Free dr->name. */
dr->num_regs = 0;
}
drpp = &dr->next;
base_reg += num_regs;
- if (hash_insert (md.dynreg_hash, name, dr))
- {
- as_bad (_("Attempt to redefine register set `%s'"), name);
- obstack_free (¬es, name);
- goto err;
- }
+ str_hash_insert (md.dynreg_hash, name, dr);
if (*input_line_pointer != ',')
break;
static void
dot_entry (int dummy ATTRIBUTE_UNUSED)
{
- const char *err;
char *name;
int c;
symbolS *symbolP;
c = get_symbol_name (&name);
symbolP = symbol_find_or_make (name);
- err = hash_insert (md.entry_hash, S_GET_NAME (symbolP), (void *) symbolP);
- if (err)
- as_fatal (_("Inserting \"%s\" into entry hint table failed: %s"),
- name, err);
+ str_hash_insert (md.entry_hash, S_GET_NAME (symbolP), (void *) symbolP);
*input_line_pointer = c;
SKIP_WHITESPACE_AFTER_NAME ();
static symbolS *
declare_register (const char *name, unsigned int regnum)
{
- const char *err;
symbolS *sym;
sym = symbol_create (name, reg_section, regnum, &zero_address_frag);
- err = hash_insert (md.reg_hash, S_GET_NAME (sym), (void *) sym);
- if (err)
- as_fatal ("Inserting \"%s\" into register table failed: %s",
- name, err);
+ str_hash_insert (md.reg_hash, S_GET_NAME (sym), (void *) sym);
return sym;
}
md_begin (void)
{
int i, j, k, t, goodness, best, ok;
- const char *err;
- char name[8];
md.auto_align = 1;
md.explicit_mode = md.default_explicit_mode;
target_big_endian = -1;
dot_byteorder (default_big_endian);
- alias_hash = hash_new ();
- alias_name_hash = hash_new ();
- secalias_hash = hash_new ();
- secalias_name_hash = hash_new ();
+ alias_hash = str_htab_create ();
+ alias_name_hash = str_htab_create ();
+ secalias_hash = str_htab_create ();
+ secalias_name_hash = str_htab_create ();
pseudo_func[FUNC_DTP_MODULE].u.sym =
symbol_new (".<dtpmod>", undefined_section, FUNC_DTP_MODULE,
for (i = 0; i < NUM_SLOTS; ++i)
md.slot[i].user_template = -1;
- md.pseudo_hash = hash_new ();
+ md.pseudo_hash = str_htab_create ();
for (i = 0; i < NELEMS (pseudo_opcode); ++i)
- {
- err = hash_insert (md.pseudo_hash, pseudo_opcode[i].name,
- (void *) (pseudo_opcode + i));
- if (err)
- as_fatal (_("ia64.md_begin: can't hash `%s': %s"),
- pseudo_opcode[i].name, err);
- }
+ str_hash_insert (md.pseudo_hash, pseudo_opcode[i].name,
+ (void *) (pseudo_opcode + i));
- md.reg_hash = hash_new ();
- md.dynreg_hash = hash_new ();
- md.const_hash = hash_new ();
- md.entry_hash = hash_new ();
+ md.reg_hash = str_htab_create ();
+ md.dynreg_hash = str_htab_create ();
+ md.const_hash = str_htab_create ();
+ md.entry_hash = str_htab_create ();
/* general registers: */
declare_register_set ("r", 128, REG_GR);
declare_register ("psp", REG_PSP);
for (i = 0; i < NELEMS (const_bits); ++i)
- {
- err = hash_insert (md.const_hash, const_bits[i].name,
- (void *) (const_bits + i));
- if (err)
- as_fatal (_("Inserting \"%s\" into constant hash table failed: %s"),
- name, err);
- }
+ str_hash_insert (md.const_hash, const_bits[i].name,
+ (void *) (const_bits + i));
/* Set the architecture and machine depending on defaults and command line
options. */
}
/* first see if NAME is a known register name: */
- sym = hash_find (md.reg_hash, name);
+ sym = str_hash_find (md.reg_hash, name);
if (sym)
{
e->X_op = O_register;
return 1;
}
- cdesc = hash_find (md.const_hash, name);
+ cdesc = str_hash_find (md.const_hash, name);
if (cdesc)
{
e->X_op = O_constant;
end = xstrdup (name);
name = ia64_canonicalize_symbol_name (end);
- if ((dr = hash_find (md.dynreg_hash, name)))
+ if ((dr = str_hash_find (md.dynreg_hash, name)))
{
/* We've got ourselves the name of a rotating register set.
Store the base register number in the low 16 bits of
ch = get_symbol_name (&temp);
mnemonic = temp;
- pdesc = (struct pseudo_opcode *) hash_find (md.pseudo_hash, mnemonic);
+ pdesc = (struct pseudo_opcode *) str_hash_find (md.pseudo_hash, mnemonic);
if (pdesc)
{
(void) restore_line_pointer (ch);
char delim;
char *end_name;
int len;
- const char *error_string;
struct alias *h;
const char *a;
- struct hash_control *ahash, *nhash;
+ htab_t ahash, nhash;
const char *kind;
delim = get_symbol_name (&name);
}
/* Check if alias has been used before. */
- h = (struct alias *) hash_find (ahash, alias);
+
+ h = (struct alias *) str_hash_find (ahash, alias);
if (h)
{
if (strcmp (h->name, name))
as_bad (_("`%s' is already the alias of %s `%s'"),
alias, kind, h->name);
+ obstack_free (¬es, name);
+ obstack_free (¬es, alias);
goto out;
}
/* Check if name already has an alias. */
- a = (const char *) hash_find (nhash, name);
+ a = (const char *) str_hash_find (nhash, name);
if (a)
{
if (strcmp (a, alias))
as_bad (_("%s `%s' already has an alias `%s'"), kind, name, a);
+ obstack_free (¬es, name);
+ obstack_free (¬es, alias);
goto out;
}
h->file = as_where (&h->line);
h->name = name;
- error_string = hash_jam (ahash, alias, (void *) h);
- if (error_string)
- {
- as_fatal (_("inserting \"%s\" into %s alias hash table failed: %s"),
- alias, kind, error_string);
- goto out;
- }
-
- error_string = hash_jam (nhash, name, (void *) alias);
- if (error_string)
- {
- as_fatal (_("inserting \"%s\" into %s name hash table failed: %s"),
- alias, kind, error_string);
- out:
- obstack_free (¬es, name);
- obstack_free (¬es, alias);
- }
+ str_hash_insert (ahash, alias, (void *) h);
+ str_hash_insert (nhash, name, (void *) alias);
+out:
demand_empty_rest_of_line ();
}
/* It renames the original symbol name to its alias. */
-static void
-do_alias (const char *alias, void *value)
+static int
+do_alias (void **slot, void *arg ATTRIBUTE_UNUSED)
{
- struct alias *h = (struct alias *) value;
+ string_tuple_t *tuple = *((string_tuple_t **) slot);
+ struct alias *h = (struct alias *) tuple->value;
symbolS *sym = symbol_find (h->name);
if (sym == NULL)
/* Uses .alias extensively to alias CRTL functions to same with
decc$ prefix. Sometimes function gets optimized away and a
warning results, which should be suppressed. */
- if (strncmp (alias, "decc$", 5) != 0)
+ if (strncmp (tuple->key, "decc$", 5) != 0)
#endif
as_warn_where (h->file, h->line,
_("symbol `%s' aliased to `%s' is not used"),
- h->name, alias);
+ h->name, tuple->key);
}
else
- S_SET_NAME (sym, (char *) alias);
+ S_SET_NAME (sym, (char *) tuple->key);
+
+ return 1;
}
/* Called from write_object_file. */
void
ia64_adjust_symtab (void)
{
- hash_traverse (alias_hash, do_alias);
+ htab_traverse (alias_hash, do_alias, NULL);
}
/* It renames the original section name to its alias. */
-static void
-do_secalias (const char *alias, void *value)
+static int
+do_secalias (void **slot, void *arg ATTRIBUTE_UNUSED)
{
- struct alias *h = (struct alias *) value;
+ string_tuple_t *tuple = *((string_tuple_t **) slot);
+ struct alias *h = (struct alias *) tuple->value;
segT sec = bfd_get_section_by_name (stdoutput, h->name);
if (sec == NULL)
as_warn_where (h->file, h->line,
_("section `%s' aliased to `%s' is not used"),
- h->name, alias);
+ h->name, tuple->key);
else
- sec->name = alias;
+ sec->name = tuple->key;
+
+ return 1;
}
/* Called from write_object_file. */
void
ia64_frob_file (void)
{
- hash_traverse (secalias_hash, do_secalias);
+ htab_traverse (secalias_hash, do_secalias, NULL);
}
#ifdef TE_VMS
projects / deliverable / binutils-gdb.git / blobdiff