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
e.X_add_number = 0;
if (!S_IS_LOCAL (unwind.proc_pending.sym)
&& S_IS_DEFINED (unwind.proc_pending.sym))
- e.X_add_symbol = symbol_temp_new (S_GET_SEGMENT (unwind.proc_pending.sym),
- S_GET_VALUE (unwind.proc_pending.sym),
- symbol_get_frag (unwind.proc_pending.sym));
+ e.X_add_symbol
+ = symbol_temp_new (S_GET_SEGMENT (unwind.proc_pending.sym),
+ symbol_get_frag (unwind.proc_pending.sym),
+ S_GET_VALUE (unwind.proc_pending.sym));
else
e.X_add_symbol = unwind.proc_pending.sym;
ia64_cons_fix_new (frag_now, where, bytes_per_address, &e,
symbol_get_obj (sym)->size->X_op = O_subtract;
symbol_get_obj (sym)->size->X_add_symbol
= symbol_new (FAKE_LABEL_NAME, now_seg,
- frag_now_fix (), frag_now);
+ frag_now, frag_now_fix ());
symbol_get_obj (sym)->size->X_op_symbol = sym;
symbol_get_obj (sym)->size->X_add_number = 0;
}
/* 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);
+ sym = symbol_create (name, reg_section, &zero_address_frag, regnum);
- 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,
- &zero_address_frag);
+ symbol_new (".<dtpmod>", undefined_section,
+ &zero_address_frag, FUNC_DTP_MODULE);
pseudo_func[FUNC_DTP_RELATIVE].u.sym =
- symbol_new (".<dtprel>", undefined_section, FUNC_DTP_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<dtprel>", undefined_section,
+ &zero_address_frag, FUNC_DTP_RELATIVE);
pseudo_func[FUNC_FPTR_RELATIVE].u.sym =
- symbol_new (".<fptr>", undefined_section, FUNC_FPTR_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<fptr>", undefined_section,
+ &zero_address_frag, FUNC_FPTR_RELATIVE);
pseudo_func[FUNC_GP_RELATIVE].u.sym =
- symbol_new (".<gprel>", undefined_section, FUNC_GP_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<gprel>", undefined_section,
+ &zero_address_frag, FUNC_GP_RELATIVE);
pseudo_func[FUNC_LT_RELATIVE].u.sym =
- symbol_new (".<ltoff>", undefined_section, FUNC_LT_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltoff>", undefined_section,
+ &zero_address_frag, FUNC_LT_RELATIVE);
pseudo_func[FUNC_LT_RELATIVE_X].u.sym =
- symbol_new (".<ltoffx>", undefined_section, FUNC_LT_RELATIVE_X,
- &zero_address_frag);
+ symbol_new (".<ltoffx>", undefined_section,
+ &zero_address_frag, FUNC_LT_RELATIVE_X);
pseudo_func[FUNC_PC_RELATIVE].u.sym =
- symbol_new (".<pcrel>", undefined_section, FUNC_PC_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<pcrel>", undefined_section,
+ &zero_address_frag, FUNC_PC_RELATIVE);
pseudo_func[FUNC_PLT_RELATIVE].u.sym =
- symbol_new (".<pltoff>", undefined_section, FUNC_PLT_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<pltoff>", undefined_section,
+ &zero_address_frag, FUNC_PLT_RELATIVE);
pseudo_func[FUNC_SEC_RELATIVE].u.sym =
- symbol_new (".<secrel>", undefined_section, FUNC_SEC_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<secrel>", undefined_section,
+ &zero_address_frag, FUNC_SEC_RELATIVE);
pseudo_func[FUNC_SEG_RELATIVE].u.sym =
- symbol_new (".<segrel>", undefined_section, FUNC_SEG_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<segrel>", undefined_section,
+ &zero_address_frag, FUNC_SEG_RELATIVE);
pseudo_func[FUNC_TP_RELATIVE].u.sym =
- symbol_new (".<tprel>", undefined_section, FUNC_TP_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<tprel>", undefined_section,
+ &zero_address_frag, FUNC_TP_RELATIVE);
pseudo_func[FUNC_LTV_RELATIVE].u.sym =
- symbol_new (".<ltv>", undefined_section, FUNC_LTV_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltv>", undefined_section,
+ &zero_address_frag, FUNC_LTV_RELATIVE);
pseudo_func[FUNC_LT_FPTR_RELATIVE].u.sym =
- symbol_new (".<ltoff.fptr>", undefined_section, FUNC_LT_FPTR_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltoff.fptr>", undefined_section,
+ &zero_address_frag, FUNC_LT_FPTR_RELATIVE);
pseudo_func[FUNC_LT_DTP_MODULE].u.sym =
- symbol_new (".<ltoff.dtpmod>", undefined_section, FUNC_LT_DTP_MODULE,
- &zero_address_frag);
+ symbol_new (".<ltoff.dtpmod>", undefined_section,
+ &zero_address_frag, FUNC_LT_DTP_MODULE);
pseudo_func[FUNC_LT_DTP_RELATIVE].u.sym =
- symbol_new (".<ltoff.dptrel>", undefined_section, FUNC_LT_DTP_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltoff.dptrel>", undefined_section,
+ &zero_address_frag, FUNC_LT_DTP_RELATIVE);
pseudo_func[FUNC_LT_TP_RELATIVE].u.sym =
- symbol_new (".<ltoff.tprel>", undefined_section, FUNC_LT_TP_RELATIVE,
- &zero_address_frag);
+ symbol_new (".<ltoff.tprel>", undefined_section,
+ &zero_address_frag, FUNC_LT_TP_RELATIVE);
pseudo_func[FUNC_IPLT_RELOC].u.sym =
- symbol_new (".<iplt>", undefined_section, FUNC_IPLT_RELOC,
- &zero_address_frag);
+ symbol_new (".<iplt>", undefined_section,
+ &zero_address_frag, FUNC_IPLT_RELOC);
#ifdef TE_VMS
pseudo_func[FUNC_SLOTCOUNT_RELOC].u.sym =
- symbol_new (".<slotcount>", undefined_section, FUNC_SLOTCOUNT_RELOC,
- &zero_address_frag);
+ symbol_new (".<slotcount>", undefined_section,
+ &zero_address_frag, FUNC_SLOTCOUNT_RELOC);
#endif
if (md.tune != itanium1)
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;
- }
+ str_hash_insert (ahash, alias, (void *) h);
+ str_hash_insert (nhash, name, (void *) alias);
- 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);
- }
-
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
/* This symbol should be passed on the command line and be variable
according to language. */
sym = symbol_new ("__gnat_vms_display_name@gnat_demangler_rtl",
- absolute_section, 0, &zero_address_frag);
+ absolute_section, &zero_address_frag, 0);
symbol_table_insert (sym);
symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING | BSF_DYNAMIC;