Only in binutils-2.35/gas: ChangeLog.orig Only in binutils-2.35/gas: ChangeLog.rej Only in binutils-2.35/gas: NEWS.orig Only in binutils-2.35/gas: NEWS.rej diff -rup binutils.orig/gas/as.c binutils-2.35/gas/as.c --- binutils.orig/gas/as.c 2021-08-11 17:33:12.486488583 +0100 +++ binutils-2.35/gas/as.c 2021-08-11 17:41:32.630279947 +0100 @@ -345,10 +345,6 @@ Options:\n\ fprintf (stream, _("\ --gdwarf-sections generate per-function section names for DWARF line information\n")); fprintf (stream, _("\ - --hash-size= set the hash table size close to \n")); - fprintf (stream, _("\ - --help show this message and exit\n")); - fprintf (stream, _("\ --target-help show target specific options\n")); fprintf (stream, _("\ -I DIR add DIR to search list for .include directives\n")); @@ -371,10 +367,6 @@ Options:\n\ fprintf (stream, _("\ -R fold data section into text section\n")); fprintf (stream, _("\ - --reduce-memory-overheads \n\ - prefer smaller memory use at the cost of longer\n\ - assembly times\n")); - fprintf (stream, _("\ --statistics print various measured statistics from execution\n")); fprintf (stream, _("\ --strip-local-absolute strip local absolute symbols\n")); @@ -1099,22 +1091,10 @@ This program has absolutely no warranty. break; case OPTION_REDUCE_MEMORY_OVERHEADS: - /* The only change we make at the moment is to reduce - the size of the hash tables that we use. */ - set_gas_hash_table_size (4051); break; case OPTION_HASH_TABLE_SIZE: - { - unsigned long new_size; - - new_size = strtoul (optarg, NULL, 0); - if (new_size) - set_gas_hash_table_size (new_size); - else - as_fatal (_("--hash-size needs a numeric argument")); - break; - } + break; } } Only in binutils-2.35/gas: as.c.orig diff -rup binutils.orig/gas/as.h binutils-2.35/gas/as.h --- binutils.orig/gas/as.h 2021-08-11 17:33:12.203490408 +0100 +++ binutils-2.35/gas/as.h 2021-08-11 17:45:01.315941347 +0100 @@ -565,6 +565,7 @@ int generic_force_reloc (struct fix *); #include "write.h" #include "frags.h" +#include "hashtab.h" #include "hash.h" #include "read.h" #include "symbols.h" diff -rup binutils.orig/gas/config/obj-coff-seh.c binutils-2.35/gas/config/obj-coff-seh.c --- binutils.orig/gas/config/obj-coff-seh.c 2021-08-11 17:33:12.208490376 +0100 +++ binutils-2.35/gas/config/obj-coff-seh.c 2021-08-11 17:39:31.399057590 +0100 @@ -31,7 +31,7 @@ struct seh_seg_list { /* Local data. */ static seh_context *seh_ctx_cur = NULL; -static struct hash_control *seh_hash; +static htab_t seh_hash; static struct seh_seg_list *x_segcur = NULL; static struct seh_seg_list *p_segcur = NULL; @@ -116,17 +116,13 @@ make_pxdata_seg (segT cseg, char *name) static void seh_hash_insert (const char *name, struct seh_seg_list *item) { - const char *error_string; - - if ((error_string = hash_jam (seh_hash, name, (char *) item))) - as_fatal (_("Inserting \"%s\" into structure table failed: %s"), - name, error_string); + str_hash_insert (seh_hash, name, (char *) item); } static struct seh_seg_list * seh_hash_find (char *name) { - return (struct seh_seg_list *) hash_find (seh_hash, name); + return (struct seh_seg_list *) str_hash_find (seh_hash, name); } static struct seh_seg_list * @@ -137,7 +133,7 @@ seh_hash_find_or_make (segT cseg, const /* Initialize seh_hash once. */ if (!seh_hash) - seh_hash = hash_new (); + seh_hash = str_htab_create (); name = get_pxdata_name (cseg, base_name); diff -rup binutils.orig/gas/config/obj-coff.c binutils-2.35/gas/config/obj-coff.c --- binutils.orig/gas/config/obj-coff.c 2021-08-11 17:33:12.214490337 +0100 +++ binutils-2.35/gas/config/obj-coff.c 2021-08-11 17:39:31.399057590 +0100 @@ -117,28 +117,24 @@ stack_pop (stack *st) /* Maintain a list of the tagnames of the structures. */ -static struct hash_control *tag_hash; +static htab_t tag_hash; static void tag_init (void) { - tag_hash = hash_new (); + tag_hash = str_htab_create (); } static void tag_insert (const char *name, symbolS *symbolP) { - const char *error_string; - - if ((error_string = hash_jam (tag_hash, name, (char *) symbolP))) - as_fatal (_("Inserting \"%s\" into structure table failed: %s"), - name, error_string); + str_hash_insert (tag_hash, name, (char *) symbolP); } static symbolS * tag_find (char *name) { - return (symbolS *) hash_find (tag_hash, name); + return (symbolS *) str_hash_find (tag_hash, name); } static symbolS * diff -rup binutils.orig/gas/config/obj-elf.c binutils-2.35/gas/config/obj-elf.c --- binutils.orig/gas/config/obj-elf.c 2021-08-11 17:33:12.215490331 +0100 +++ binutils-2.35/gas/config/obj-elf.c 2021-08-11 17:39:31.399057590 +0100 @@ -2610,7 +2610,7 @@ struct group_list { asection **head; /* Section lists. */ unsigned int num_group; /* Number of lists. */ - struct hash_control *indexes; /* Maps group name to index in head array. */ + htab_t indexes; /* Maps group name to index in head array. */ }; static struct group_list groups; @@ -2648,7 +2648,7 @@ build_additional_section_info (bfd *abfd /* If this group already has a list, add the section to the head of the list. */ - elem_idx = (unsigned int *) hash_find (list->indexes, group_name); + elem_idx = (unsigned int *) str_hash_find (list->indexes, group_name); if (elem_idx != NULL) { elf_next_in_group (sec) = list->head[*elem_idx]; @@ -2670,12 +2670,15 @@ build_additional_section_info (bfd *abfd /* Add index to hash. */ idx_ptr = XNEW (unsigned int); *idx_ptr = i; - hash_insert (list->indexes, group_name, idx_ptr); + str_hash_insert (list->indexes, group_name, (char *)idx_ptr); } -static void free_section_idx (const char *key ATTRIBUTE_UNUSED, void *val) +static int +free_section_idx (void **slot, void *arg ATTRIBUTE_UNUSED) { - free ((unsigned int *) val); + string_tuple_t *tuple = *((string_tuple_t **) slot); + free ((char *)tuple->value); + return 1; } /* Create symbols for group signature. */ @@ -2688,7 +2691,7 @@ elf_adjust_symtab (void) /* Go find section groups. */ groups.num_group = 0; groups.head = NULL; - groups.indexes = hash_new (); + groups.indexes = str_htab_create (); bfd_map_over_sections (stdoutput, build_additional_section_info, &groups); @@ -2860,8 +2863,8 @@ elf_frob_file_after_relocs (void) } /* Cleanup hash. */ - hash_traverse (groups.indexes, free_section_idx); - hash_die (groups.indexes); + htab_traverse (groups.indexes, free_section_idx, NULL); + htab_delete (groups.indexes); #ifdef NEED_ECOFF_DEBUG if (ECOFF_DEBUGGING) Only in binutils-2.35/gas/config: obj-elf.c.orig diff -rup binutils.orig/gas/config/tc-aarch64.c binutils-2.35/gas/config/tc-aarch64.c --- binutils.orig/gas/config/tc-aarch64.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-aarch64.c 2021-08-11 17:40:58.180500928 +0100 @@ -451,21 +451,21 @@ get_reg_expected_msg (aarch64_reg_type r /* Instructions take 4 bytes in the object file. */ #define INSN_SIZE 4 -static struct hash_control *aarch64_ops_hsh; -static struct hash_control *aarch64_cond_hsh; -static struct hash_control *aarch64_shift_hsh; -static struct hash_control *aarch64_sys_regs_hsh; -static struct hash_control *aarch64_pstatefield_hsh; -static struct hash_control *aarch64_sys_regs_ic_hsh; -static struct hash_control *aarch64_sys_regs_dc_hsh; -static struct hash_control *aarch64_sys_regs_at_hsh; -static struct hash_control *aarch64_sys_regs_tlbi_hsh; -static struct hash_control *aarch64_sys_regs_sr_hsh; -static struct hash_control *aarch64_reg_hsh; -static struct hash_control *aarch64_barrier_opt_hsh; -static struct hash_control *aarch64_nzcv_hsh; -static struct hash_control *aarch64_pldop_hsh; -static struct hash_control *aarch64_hint_opt_hsh; +static htab_t aarch64_ops_hsh; +static htab_t aarch64_cond_hsh; +static htab_t aarch64_shift_hsh; +static htab_t aarch64_sys_regs_hsh; +static htab_t aarch64_pstatefield_hsh; +static htab_t aarch64_sys_regs_ic_hsh; +static htab_t aarch64_sys_regs_dc_hsh; +static htab_t aarch64_sys_regs_at_hsh; +static htab_t aarch64_sys_regs_tlbi_hsh; +static htab_t aarch64_sys_regs_sr_hsh; +static htab_t aarch64_reg_hsh; +static htab_t aarch64_barrier_opt_hsh; +static htab_t aarch64_nzcv_hsh; +static htab_t aarch64_pldop_hsh; +static htab_t aarch64_hint_opt_hsh; /* Stuff needed to resolve the label ambiguity As: @@ -764,7 +764,7 @@ parse_reg (char **ccp) p++; while (ISALPHA (*p) || ISDIGIT (*p) || *p == '_'); - reg = (reg_entry *) hash_find_n (aarch64_reg_hsh, start, p - start); + reg = (reg_entry *) str_hash_find_n (aarch64_reg_hsh, start, p - start); if (!reg) return NULL; @@ -1315,7 +1315,7 @@ insert_reg_alias (char *str, int number, reg_entry *new; const char *name; - if ((new = hash_find (aarch64_reg_hsh, str)) != 0) + if ((new = str_hash_find (aarch64_reg_hsh, str)) != 0) { if (new->builtin) as_warn (_("ignoring attempt to redefine built-in register '%s'"), @@ -1337,8 +1337,7 @@ insert_reg_alias (char *str, int number, new->type = type; new->builtin = FALSE; - if (hash_insert (aarch64_reg_hsh, name, (void *) new)) - abort (); + str_hash_insert (aarch64_reg_hsh, name, (void *) new); return new; } @@ -1367,7 +1366,7 @@ create_register_alias (char *newname, ch if (*oldname == '\0') return FALSE; - old = hash_find (aarch64_reg_hsh, oldname); + old = str_hash_find (aarch64_reg_hsh, oldname); if (!old) { as_warn (_("unknown register '%s' -- .req ignored"), oldname); @@ -1456,7 +1455,7 @@ s_unreq (int a ATTRIBUTE_UNUSED) as_bad (_("invalid syntax for .unreq directive")); else { - reg_entry *reg = hash_find (aarch64_reg_hsh, name); + reg_entry *reg = str_hash_find (aarch64_reg_hsh, name); if (!reg) as_bad (_("unknown register alias '%s'"), name); @@ -1468,7 +1467,7 @@ s_unreq (int a ATTRIBUTE_UNUSED) char *p; char *nbuf; - hash_delete (aarch64_reg_hsh, name, FALSE); + str_hash_delete (aarch64_reg_hsh, name); free ((char *) reg->name); free (reg); @@ -1479,20 +1478,20 @@ s_unreq (int a ATTRIBUTE_UNUSED) nbuf = strdup (name); for (p = nbuf; *p; p++) *p = TOUPPER (*p); - reg = hash_find (aarch64_reg_hsh, nbuf); + reg = str_hash_find (aarch64_reg_hsh, nbuf); if (reg) { - hash_delete (aarch64_reg_hsh, nbuf, FALSE); + str_hash_delete (aarch64_reg_hsh, nbuf); free ((char *) reg->name); free (reg); } for (p = nbuf; *p; p++) *p = TOLOWER (*p); - reg = hash_find (aarch64_reg_hsh, nbuf); + reg = str_hash_find (aarch64_reg_hsh, nbuf); if (reg) { - hash_delete (aarch64_reg_hsh, nbuf, FALSE); + str_hash_delete (aarch64_reg_hsh, nbuf); free ((char *) reg->name); free (reg); } @@ -3122,7 +3121,7 @@ parse_shift (char **str, aarch64_opnd_in return FALSE; } - shift_op = hash_find_n (aarch64_shift_hsh, *str, p - *str); + shift_op = str_hash_find_n (aarch64_shift_hsh, *str, p - *str); if (shift_op == NULL) { @@ -3979,7 +3978,7 @@ parse_pldop (char **str) while (ISALNUM (*q)) q++; - o = hash_find_n (aarch64_pldop_hsh, p, q - p); + o = str_hash_find_n (aarch64_pldop_hsh, p, q - p); if (!o) return PARSE_FAIL; @@ -4000,7 +3999,7 @@ parse_barrier (char **str) while (ISALPHA (*q)) q++; - o = hash_find_n (aarch64_barrier_opt_hsh, p, q - p); + o = str_hash_find_n (aarch64_barrier_opt_hsh, p, q - p); if (!o) return PARSE_FAIL; @@ -4022,7 +4021,7 @@ parse_barrier_psb (char **str, while (ISALPHA (*q)) q++; - o = hash_find_n (aarch64_hint_opt_hsh, p, q - p); + o = str_hash_find_n (aarch64_hint_opt_hsh, p, q - p); if (!o) { set_fatal_syntax_error @@ -4057,7 +4056,7 @@ parse_bti_operand (char **str, while (ISALPHA (*q)) q++; - o = hash_find_n (aarch64_hint_opt_hsh, p, q - p); + o = str_hash_find_n (aarch64_hint_opt_hsh, p, q - p); if (!o) { set_fatal_syntax_error @@ -4095,7 +4094,7 @@ parse_bti_operand (char **str, */ static int -parse_sys_reg (char **str, struct hash_control *sys_regs, +parse_sys_reg (char **str, htab_t sys_regs, int imple_defined_p, int pstatefield_p, uint32_t* flags) { @@ -4112,7 +4111,7 @@ parse_sys_reg (char **str, struct hash_c /* Assert that BUF be large enough. */ gas_assert (p - buf == q - *str); - o = hash_find (sys_regs, buf); + o = str_hash_find (sys_regs, buf); if (!o) { if (!imple_defined_p) @@ -4156,7 +4155,7 @@ parse_sys_reg (char **str, struct hash_c for the option, or NULL. */ static const aarch64_sys_ins_reg * -parse_sys_ins_reg (char **str, struct hash_control *sys_ins_regs) +parse_sys_ins_reg (char **str, htab_t sys_ins_regs) { char *p, *q; char buf[32]; @@ -4168,7 +4167,7 @@ parse_sys_ins_reg (char **str, struct ha *p++ = TOLOWER (*q); *p = '\0'; - o = hash_find (sys_ins_regs, buf); + o = str_hash_find (sys_ins_regs, buf); if (!o) return NULL; @@ -5078,7 +5077,7 @@ lookup_mnemonic (const char *start, int { templates *templ = NULL; - templ = hash_find_n (aarch64_ops_hsh, start, len); + templ = str_hash_find_n (aarch64_ops_hsh, start, len); return templ; } @@ -5109,7 +5108,7 @@ opcode_lookup (char **str) /* Handle a possible condition. */ if (dot) { - cond = hash_find_n (aarch64_cond_hsh, dot + 1, end - dot - 1); + cond = str_hash_find_n (aarch64_cond_hsh, dot + 1, end - dot - 1); if (cond) { inst.cond = cond->value; @@ -6160,7 +6159,7 @@ parse_operands (char *str, const aarch64 case AARCH64_OPND_NZCV: { - const asm_nzcv *nzcv = hash_find_n (aarch64_nzcv_hsh, str, 4); + const asm_nzcv *nzcv = str_hash_find_n (aarch64_nzcv_hsh, str, 4); if (nzcv != NULL) { str += 4; @@ -6179,7 +6178,7 @@ parse_operands (char *str, const aarch64 do str++; while (ISALPHA (*str)); - info->cond = hash_find_n (aarch64_cond_hsh, start, str - start); + info->cond = str_hash_find_n (aarch64_cond_hsh, start, str - start); if (info->cond == NULL) { set_syntax_error (_("invalid condition")); @@ -8603,13 +8602,9 @@ aarch64_adjust_symtab (void) } static void -checked_hash_insert (struct hash_control *table, const char *key, void *value) +checked_hash_insert (htab_t table, const char *key, void *value) { - const char *hash_err; - - hash_err = hash_insert (table, key, value); - if (hash_err) - printf ("Internal Error: Can't hash %s\n", key); + str_hash_insert (table, key, value); } static void @@ -8620,7 +8615,7 @@ fill_instruction_hash_table (void) while (opcode->name != NULL) { templates *templ, *new_templ; - templ = hash_find (aarch64_ops_hsh, opcode->name); + templ = str_hash_find (aarch64_ops_hsh, opcode->name); new_templ = XNEW (templates); new_templ->opcode = opcode; @@ -8666,21 +8661,21 @@ md_begin (void) unsigned mach; unsigned int i; - if ((aarch64_ops_hsh = hash_new ()) == NULL - || (aarch64_cond_hsh = hash_new ()) == NULL - || (aarch64_shift_hsh = hash_new ()) == NULL - || (aarch64_sys_regs_hsh = hash_new ()) == NULL - || (aarch64_pstatefield_hsh = hash_new ()) == NULL - || (aarch64_sys_regs_ic_hsh = hash_new ()) == NULL - || (aarch64_sys_regs_dc_hsh = hash_new ()) == NULL - || (aarch64_sys_regs_at_hsh = hash_new ()) == NULL - || (aarch64_sys_regs_tlbi_hsh = hash_new ()) == NULL - || (aarch64_sys_regs_sr_hsh = hash_new ()) == NULL - || (aarch64_reg_hsh = hash_new ()) == NULL - || (aarch64_barrier_opt_hsh = hash_new ()) == NULL - || (aarch64_nzcv_hsh = hash_new ()) == NULL - || (aarch64_pldop_hsh = hash_new ()) == NULL - || (aarch64_hint_opt_hsh = hash_new ()) == NULL) + if ((aarch64_ops_hsh = str_htab_create ()) == NULL + || (aarch64_cond_hsh = str_htab_create ()) == NULL + || (aarch64_shift_hsh = str_htab_create ()) == NULL + || (aarch64_sys_regs_hsh = str_htab_create ()) == NULL + || (aarch64_pstatefield_hsh = str_htab_create ()) == NULL + || (aarch64_sys_regs_ic_hsh = str_htab_create ()) == NULL + || (aarch64_sys_regs_dc_hsh = str_htab_create ()) == NULL + || (aarch64_sys_regs_at_hsh = str_htab_create ()) == NULL + || (aarch64_sys_regs_tlbi_hsh = str_htab_create ()) == NULL + || (aarch64_sys_regs_sr_hsh = str_htab_create ()) == NULL + || (aarch64_reg_hsh = str_htab_create ()) == NULL + || (aarch64_barrier_opt_hsh = str_htab_create ()) == NULL + || (aarch64_nzcv_hsh = str_htab_create ()) == NULL + || (aarch64_pldop_hsh = str_htab_create ()) == NULL + || (aarch64_hint_opt_hsh = str_htab_create ()) == NULL) as_fatal (_("virtual memory exhausted")); fill_instruction_hash_table (); Only in binutils-2.35/gas/config: tc-aarch64.c.orig Only in binutils-2.35/gas/config: tc-aarch64.c.rej diff -rup binutils.orig/gas/config/tc-alpha.c binutils-2.35/gas/config/tc-alpha.c --- binutils.orig/gas/config/tc-alpha.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-alpha.c 2021-08-11 17:39:31.401057577 +0100 @@ -297,10 +297,10 @@ static unsigned alpha_target = AXP_OPCOD static const char *alpha_target_name = ""; /* The hash table of instruction opcodes. */ -static struct hash_control *alpha_opcode_hash; +static htab_t alpha_opcode_hash; /* The hash table of macro opcodes. */ -static struct hash_control *alpha_macro_hash; +static htab_t alpha_macro_hash; #ifdef OBJ_ECOFF /* The $gp relocation symbol. */ @@ -514,7 +514,7 @@ struct alpha_reloc_tag }; /* Hash table to link up literals with the appropriate lituse. */ -static struct hash_control *alpha_literal_hash; +static htab_t alpha_literal_hash; /* Sequence numbers for internal use by macros. */ static long next_sequence_num = -1; @@ -589,11 +589,10 @@ get_alpha_reloc_tag (long sequence) sprintf (buffer, "!%ld", sequence); - info = (struct alpha_reloc_tag *) hash_find (alpha_literal_hash, buffer); + info = (struct alpha_reloc_tag *) str_hash_find (alpha_literal_hash, buffer); if (! info) { size_t len = strlen (buffer); - const char *errmsg; info = (struct alpha_reloc_tag *) xcalloc (sizeof (struct alpha_reloc_tag) + len, 1); @@ -601,9 +600,7 @@ get_alpha_reloc_tag (long sequence) info->segment = now_seg; info->sequence = sequence; strcpy (info->string, buffer); - errmsg = hash_insert (alpha_literal_hash, info->string, (void *) info); - if (errmsg) - as_fatal ("%s", errmsg); + str_hash_insert (alpha_literal_hash, info->string, (void *) info); #ifdef OBJ_EVAX info->sym = 0; info->psym = 0; @@ -1171,7 +1168,7 @@ assemble_tokens_to_insn (const char *opn const struct alpha_opcode *opcode; /* Search opcodes. */ - opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname); + opcode = (const struct alpha_opcode *) str_hash_find (alpha_opcode_hash, opname); if (opcode) { int cpumatch; @@ -3319,7 +3316,7 @@ assemble_tokens (const char *opname, if (local_macros_on) { macro = ((const struct alpha_macro *) - hash_find (alpha_macro_hash, opname)); + str_hash_find (alpha_macro_hash, opname)); if (macro) { found_something = 1; @@ -3333,7 +3330,7 @@ assemble_tokens (const char *opname, } /* Search opcodes. */ - opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname); + opcode = (const struct alpha_opcode *) str_hash_find (alpha_opcode_hash, opname); if (opcode) { found_something = 1; @@ -5419,17 +5416,14 @@ md_begin (void) } /* Create the opcode hash table. */ - alpha_opcode_hash = hash_new (); + alpha_opcode_hash = str_htab_create (); for (i = 0; i < alpha_num_opcodes;) { - const char *name, *retval, *slash; + const char *name, *slash; name = alpha_opcodes[i].name; - retval = hash_insert (alpha_opcode_hash, name, (void *) &alpha_opcodes[i]); - if (retval) - as_fatal (_("internal error: can't hash opcode `%s': %s"), - name, retval); + str_hash_insert (alpha_opcode_hash, name, (void *) &alpha_opcodes[i]); /* Some opcodes include modifiers of various sorts with a "/mod" syntax, like the architecture manual suggests. However, for @@ -5443,7 +5437,7 @@ md_begin (void) memcpy (p, name, slash - name); strcpy (p + (slash - name), slash + 1); - (void) hash_insert (alpha_opcode_hash, p, (void *) &alpha_opcodes[i]); + (void) str_hash_insert (alpha_opcode_hash, p, (void *) &alpha_opcodes[i]); /* Ignore failures -- the opcode table does duplicate some variants in different forms, like "hw_stq" and "hw_st/q". */ } @@ -5455,17 +5449,14 @@ md_begin (void) } /* Create the macro hash table. */ - alpha_macro_hash = hash_new (); + alpha_macro_hash = str_htab_create (); for (i = 0; i < alpha_num_macros;) { - const char *name, *retval; + const char *name; name = alpha_macros[i].name; - retval = hash_insert (alpha_macro_hash, name, (void *) &alpha_macros[i]); - if (retval) - as_fatal (_("internal error: can't hash macro `%s': %s"), - name, retval); + str_hash_insert (alpha_macro_hash, name, (void *) &alpha_macros[i]); while (++i < alpha_num_macros && (alpha_macros[i].name == name @@ -5520,7 +5511,7 @@ md_begin (void) #endif /* Create literal lookup hash table. */ - alpha_literal_hash = hash_new (); + alpha_literal_hash = str_htab_create (); subseg_set (text_section, 0); } diff -rup binutils.orig/gas/config/tc-arc.c binutils-2.35/gas/config/tc-arc.c --- binutils.orig/gas/config/tc-arc.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-arc.c 2021-08-11 17:39:31.401057577 +0100 @@ -428,16 +428,16 @@ enum mach_selection_type static enum mach_selection_type mach_selection_mode = MACH_SELECTION_NONE; /* The hash table of instruction opcodes. */ -static struct hash_control *arc_opcode_hash; +static htab_t arc_opcode_hash; /* The hash table of register symbols. */ -static struct hash_control *arc_reg_hash; +static htab_t arc_reg_hash; /* The hash table of aux register symbols. */ -static struct hash_control *arc_aux_hash; +static htab_t arc_aux_hash; /* The hash table of address types. */ -static struct hash_control *arc_addrtype_hash; +static htab_t arc_addrtype_hash; #define ARC_CPU_TYPE_A6xx(NAME,EXTRA) \ { #NAME, ARC_OPCODE_ARC600, bfd_mach_arc_arc600, \ @@ -704,7 +704,7 @@ arc_find_opcode (const char *name) { const struct arc_opcode_hash_entry *entry; - entry = hash_find (arc_opcode_hash, name); + entry = str_hash_find (arc_opcode_hash, name); return entry; } @@ -754,21 +754,18 @@ arc_opcode_hash_entry_iterator_next (con static void arc_insert_opcode (const struct arc_opcode *opcode) { - const char *name, *retval; + const char *name; struct arc_opcode_hash_entry *entry; name = opcode->name; - entry = hash_find (arc_opcode_hash, name); + entry = str_hash_find (arc_opcode_hash, name); if (entry == NULL) { entry = XNEW (struct arc_opcode_hash_entry); entry->count = 0; entry->opcode = NULL; - retval = hash_insert (arc_opcode_hash, name, (void *) entry); - if (retval) - as_fatal (_("internal error: can't hash opcode '%s': %s"), - name, retval); + str_hash_insert (arc_opcode_hash, name, (void *) entry); } entry->opcode = XRESIZEVEC (const struct arc_opcode *, entry->opcode, @@ -1920,7 +1917,7 @@ find_opcode_match (const struct arc_opco tmpp = strdup (p); for (pp = tmpp; *pp; ++pp) *pp = TOLOWER (*pp); - auxr = hash_find (arc_aux_hash, tmpp); + auxr = str_hash_find (arc_aux_hash, tmpp); if (auxr) { /* We modify the token array here, safe in the @@ -2528,14 +2525,10 @@ md_assemble (char *str) static void declare_register (const char *name, int number) { - const char *err; symbolS *regS = symbol_create (name, reg_section, number, &zero_address_frag); - err = hash_insert (arc_reg_hash, S_GET_NAME (regS), (void *) regS); - if (err) - as_fatal (_("Inserting \"%s\" into register table failed: %s"), - name, err); + str_hash_insert (arc_reg_hash, S_GET_NAME (regS), (void *) regS); } /* Construct symbols for each of the general registers. */ @@ -2563,15 +2556,11 @@ declare_register_set (void) static void declare_addrtype (const char *name, int number) { - const char *err; symbolS *addrtypeS = symbol_create (name, undefined_section, number, &zero_address_frag); - err = hash_insert (arc_addrtype_hash, S_GET_NAME (addrtypeS), - (void *) addrtypeS); - if (err) - as_fatal (_("Inserting \"%s\" into address type table failed: %s"), - name, err); + str_hash_insert (arc_addrtype_hash, S_GET_NAME (addrtypeS), + (void *) addrtypeS); } /* Port-specific assembler initialization. This function is called @@ -2595,7 +2584,7 @@ md_begin (void) bfd_set_private_flags (stdoutput, selected_cpu.eflags); /* Set up a hash table for the instructions. */ - arc_opcode_hash = hash_new (); + arc_opcode_hash = str_htab_create (); if (arc_opcode_hash == NULL) as_fatal (_("Virtual memory exhausted")); @@ -2613,7 +2602,7 @@ md_begin (void) }while (opcode->name); /* Register declaration. */ - arc_reg_hash = hash_new (); + arc_reg_hash = str_htab_create (); if (arc_reg_hash == NULL) as_fatal (_("Virtual memory exhausted")); @@ -2666,7 +2655,7 @@ md_begin (void) memset (&arc_last_insns[0], 0, sizeof (arc_last_insns)); /* Aux register declaration. */ - arc_aux_hash = hash_new (); + arc_aux_hash = str_htab_create (); if (arc_aux_hash == NULL) as_fatal (_("Virtual memory exhausted")); @@ -2674,8 +2663,6 @@ md_begin (void) unsigned int i; for (i = 0; i < arc_num_aux_regs; i++, auxr++) { - const char *retval; - if (!(auxr->cpu & selected_cpu.flags)) continue; @@ -2683,14 +2670,11 @@ md_begin (void) && !check_cpu_feature (auxr->subclass)) continue; - retval = hash_insert (arc_aux_hash, auxr->name, (void *) auxr); - if (retval) - as_fatal (_("internal error: can't hash aux register '%s': %s"), - auxr->name, retval); + str_hash_insert (arc_aux_hash, auxr->name, (void *) auxr); } /* Address type declaration. */ - arc_addrtype_hash = hash_new (); + arc_addrtype_hash = str_htab_create (); if (arc_addrtype_hash == NULL) as_fatal (_("Virtual memory exhausted")); @@ -3396,7 +3380,7 @@ arc_parse_name (const char *name, && e->X_md == O_absent) return FALSE; - sym = hash_find (arc_reg_hash, name); + sym = str_hash_find (arc_reg_hash, name); if (sym) { e->X_op = O_register; @@ -3404,7 +3388,7 @@ arc_parse_name (const char *name, return TRUE; } - sym = hash_find (arc_addrtype_hash, name); + sym = str_hash_find (arc_addrtype_hash, name); if (sym) { e->X_op = O_addrtype; @@ -4369,7 +4353,7 @@ tc_arc_regname_to_dw2regnum (char *regna { struct symbol *sym; - sym = hash_find (arc_reg_hash, regname); + sym = str_hash_find (arc_reg_hash, regname); if (sym) return S_GET_VALUE (sym); @@ -4859,7 +4843,6 @@ arc_extcorereg (int opertype) { extRegister_t ereg; struct arc_aux_reg *auxr; - const char *retval; struct arc_flag_operand *ccode; memset (&ereg, 0, sizeof (ereg)); @@ -4882,10 +4865,7 @@ arc_extcorereg (int opertype) auxr->cpu = selected_cpu.flags; auxr->subclass = NONE; auxr->address = ereg.number; - retval = hash_insert (arc_aux_hash, auxr->name, (void *) auxr); - if (retval) - as_fatal (_("internal error: can't hash aux register '%s': %s"), - auxr->name, retval); + str_hash_insert (arc_aux_hash, auxr->name, (void *) auxr); break; case EXT_COND_CODE: /* Condition code. */ Only in binutils-2.35/gas/config: tc-arc.c.orig diff -rup binutils.orig/gas/config/tc-arm.c binutils-2.35/gas/config/tc-arm.c --- binutils.orig/gas/config/tc-arm.c 2021-08-11 17:33:12.215490331 +0100 +++ binutils-2.35/gas/config/tc-arm.c 2021-08-11 17:39:31.403057564 +0100 @@ -945,15 +945,15 @@ struct asm_opcode #define BAD_EL_TYPE _("bad element type for instruction") #define MVE_BAD_QREG _("MVE vector register Q[0..7] expected") -static struct hash_control * arm_ops_hsh; -static struct hash_control * arm_cond_hsh; -static struct hash_control * arm_vcond_hsh; -static struct hash_control * arm_shift_hsh; -static struct hash_control * arm_psr_hsh; -static struct hash_control * arm_v7m_psr_hsh; -static struct hash_control * arm_reg_hsh; -static struct hash_control * arm_reloc_hsh; -static struct hash_control * arm_barrier_opt_hsh; +static htab_t arm_ops_hsh; +static htab_t arm_cond_hsh; +static htab_t arm_vcond_hsh; +static htab_t arm_shift_hsh; +static htab_t arm_psr_hsh; +static htab_t arm_v7m_psr_hsh; +static htab_t arm_reg_hsh; +static htab_t arm_reloc_hsh; +static htab_t arm_barrier_opt_hsh; /* Stuff needed to resolve the label ambiguity As: @@ -1427,7 +1427,7 @@ arm_reg_parse_multi (char **ccp) p++; while (ISALPHA (*p) || ISDIGIT (*p) || *p == '_'); - reg = (struct reg_entry *) hash_find_n (arm_reg_hsh, start, p - start); + reg = (struct reg_entry *) str_hash_find_n (arm_reg_hsh, start, p - start); if (!reg) return NULL; @@ -2546,7 +2546,7 @@ parse_reloc (char **str) return -1; if ((r = (struct reloc_entry *) - hash_find_n (arm_reloc_hsh, p, q - p)) == NULL) + str_hash_find_n (arm_reloc_hsh, p, q - p)) == NULL) return -1; *str = q + 1; @@ -2561,7 +2561,7 @@ insert_reg_alias (char *str, unsigned nu struct reg_entry *new_reg; const char *name; - if ((new_reg = (struct reg_entry *) hash_find (arm_reg_hsh, str)) != 0) + if ((new_reg = (struct reg_entry *) str_hash_find (arm_reg_hsh, str)) != 0) { if (new_reg->builtin) as_warn (_("ignoring attempt to redefine built-in register '%s'"), str); @@ -2583,8 +2583,7 @@ insert_reg_alias (char *str, unsigned nu new_reg->builtin = FALSE; new_reg->neon = NULL; - if (hash_insert (arm_reg_hsh, name, (void *) new_reg)) - abort (); + str_hash_insert (arm_reg_hsh, name, new_reg); return new_reg; } @@ -2632,7 +2631,7 @@ create_register_alias (char * newname, c if (*oldname == '\0') return FALSE; - old = (struct reg_entry *) hash_find (arm_reg_hsh, oldname); + old = (struct reg_entry *) str_hash_find (arm_reg_hsh, oldname); if (!old) { as_warn (_("unknown register '%s' -- .req ignored"), oldname); @@ -2884,7 +2883,7 @@ s_unreq (int a ATTRIBUTE_UNUSED) as_bad (_("invalid syntax for .unreq directive")); else { - struct reg_entry *reg = (struct reg_entry *) hash_find (arm_reg_hsh, + struct reg_entry *reg = (struct reg_entry *) str_hash_find (arm_reg_hsh, name); if (!reg) @@ -2897,7 +2896,7 @@ s_unreq (int a ATTRIBUTE_UNUSED) char * p; char * nbuf; - hash_delete (arm_reg_hsh, name, FALSE); + str_hash_delete (arm_reg_hsh, name); free ((char *) reg->name); free (reg->neon); free (reg); @@ -2909,10 +2908,10 @@ s_unreq (int a ATTRIBUTE_UNUSED) nbuf = strdup (name); for (p = nbuf; *p; p++) *p = TOUPPER (*p); - reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf); + reg = (struct reg_entry *) str_hash_find (arm_reg_hsh, nbuf); if (reg) { - hash_delete (arm_reg_hsh, nbuf, FALSE); + str_hash_delete (arm_reg_hsh, nbuf); free ((char *) reg->name); free (reg->neon); free (reg); @@ -2920,10 +2919,10 @@ s_unreq (int a ATTRIBUTE_UNUSED) for (p = nbuf; *p; p++) *p = TOLOWER (*p); - reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf); + reg = (struct reg_entry *) str_hash_find (arm_reg_hsh, nbuf); if (reg) { - hash_delete (arm_reg_hsh, nbuf, FALSE); + str_hash_delete (arm_reg_hsh, nbuf); free ((char *) reg->name); free (reg->neon); free (reg); @@ -5537,7 +5536,7 @@ parse_shift (char **str, int i, enum par return FAIL; } - shift_name = (const struct asm_shift_name *) hash_find_n (arm_shift_hsh, *str, + shift_name = (const struct asm_shift_name *) str_hash_find_n (arm_shift_hsh, *str, p - *str); if (shift_name == NULL) @@ -6338,7 +6337,7 @@ parse_psr (char **str, bfd_boolean lhs) || strncasecmp (start, "psr", 3) == 0) p = start + strcspn (start, "rR") + 1; - psr = (const struct asm_psr *) hash_find_n (arm_v7m_psr_hsh, start, + psr = (const struct asm_psr *) str_hash_find_n (arm_v7m_psr_hsh, start, p - start); if (!psr) @@ -6441,7 +6440,7 @@ parse_psr (char **str, bfd_boolean lhs) } else { - psr = (const struct asm_psr *) hash_find_n (arm_psr_hsh, start, + psr = (const struct asm_psr *) str_hash_find_n (arm_psr_hsh, start, p - start); if (!psr) goto error; @@ -6633,7 +6632,7 @@ parse_cond (char **str) n++; } - c = (const struct asm_cond *) hash_find_n (arm_cond_hsh, cond, n); + c = (const struct asm_cond *) str_hash_find_n (arm_cond_hsh, cond, n); if (!c) { inst.error = _("condition required"); @@ -6656,7 +6655,7 @@ parse_barrier (char **str) while (ISALPHA (*q)) q++; - o = (const struct asm_barrier_opt *) hash_find_n (arm_barrier_opt_hsh, p, + o = (const struct asm_barrier_opt *) str_hash_find_n (arm_barrier_opt_hsh, p, q - p); if (!o) return FAIL; @@ -15606,7 +15605,7 @@ do_vfp_nsyn_opcode (const char *opname) { const struct asm_opcode *opcode; - opcode = (const struct asm_opcode *) hash_find (arm_ops_hsh, opname); + opcode = (const struct asm_opcode *) str_hash_find (arm_ops_hsh, opname); if (!opcode) abort (); @@ -22618,7 +22617,7 @@ opcode_lookup (char **str) *str = end; /* Look for unaffixed or special-case affixed mnemonic. */ - opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base, + opcode = (const struct asm_opcode *) str_hash_find_n (arm_ops_hsh, base, end - base); if (opcode) { @@ -22632,7 +22631,7 @@ opcode_lookup (char **str) if (warn_on_deprecated && unified_syntax) as_tsktsk (_("conditional infixes are deprecated in unified syntax")); affix = base + (opcode->tag - OT_odd_infix_0); - cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2); + cond = (const struct asm_cond *) str_hash_find_n (arm_cond_hsh, affix, 2); gas_assert (cond); inst.cond = cond->value; @@ -22645,8 +22644,8 @@ opcode_lookup (char **str) if (end - base < 2) return NULL; affix = end - 1; - cond = (const struct asm_cond *) hash_find_n (arm_vcond_hsh, affix, 1); - opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base, + cond = (const struct asm_cond *) str_hash_find_n (arm_vcond_hsh, affix, 1); + opcode = (const struct asm_opcode *) str_hash_find_n (arm_ops_hsh, base, affix - base); /* If this opcode can not be vector predicated then don't accept it with a vector predication code. */ @@ -22662,8 +22661,8 @@ opcode_lookup (char **str) /* Look for suffixed mnemonic. */ affix = end - 2; - cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2); - opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base, + cond = (const struct asm_cond *) str_hash_find_n (arm_cond_hsh, affix, 2); + opcode = (const struct asm_opcode *) str_hash_find_n (arm_ops_hsh, base, affix - base); } @@ -22713,13 +22712,13 @@ opcode_lookup (char **str) /* Look for infixed mnemonic in the usual position. */ affix = base + 3; - cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2); + cond = (const struct asm_cond *) str_hash_find_n (arm_cond_hsh, affix, 2); if (!cond) return NULL; memcpy (save, affix, 2); memmove (affix, affix + 2, (end - affix) - 2); - opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base, + opcode = (const struct asm_opcode *) str_hash_find_n (arm_ops_hsh, base, (end - base) - 2); memmove (affix + 2, affix, (end - affix) - 2); memcpy (affix, save, 2); @@ -27987,16 +27986,19 @@ arm_tc_equal_in_insn (int c ATTRIBUTE_UN for (p = nbuf; *p; p++) *p = TOLOWER (*p); - if (hash_find (arm_ops_hsh, nbuf) != NULL) + if (str_hash_find (arm_ops_hsh, nbuf) != NULL) { - static struct hash_control * already_warned = NULL; + static htab_t already_warned = NULL; if (already_warned == NULL) - already_warned = hash_new (); + already_warned = str_htab_create (); /* Only warn about the symbol once. To keep the code - simple we let hash_insert do the lookup for us. */ - if (hash_insert (already_warned, nbuf, NULL) == NULL) - as_warn (_("[-mwarn-syms]: Assignment makes a symbol match an ARM instruction: %s"), name); + simple we let str_hash_insert do the lookup for us. */ + if (str_hash_find (already_warned, nbuf) == NULL) + { + as_warn (_("[-mwarn-syms]: Assignment makes a symbol match an ARM instruction: %s"), name); + str_hash_insert (already_warned, nbuf, NULL); + } } else free (nbuf); @@ -30712,36 +30714,37 @@ md_begin (void) unsigned mach; unsigned int i; - if ( (arm_ops_hsh = hash_new ()) == NULL - || (arm_cond_hsh = hash_new ()) == NULL - || (arm_vcond_hsh = hash_new ()) == NULL - || (arm_shift_hsh = hash_new ()) == NULL - || (arm_psr_hsh = hash_new ()) == NULL - || (arm_v7m_psr_hsh = hash_new ()) == NULL - || (arm_reg_hsh = hash_new ()) == NULL - || (arm_reloc_hsh = hash_new ()) == NULL - || (arm_barrier_opt_hsh = hash_new ()) == NULL) + if ( (arm_ops_hsh = str_htab_create ()) == NULL + || (arm_cond_hsh = str_htab_create ()) == NULL + || (arm_vcond_hsh = str_htab_create ()) == NULL + || (arm_shift_hsh = str_htab_create ()) == NULL + || (arm_psr_hsh = str_htab_create ()) == NULL + || (arm_v7m_psr_hsh = str_htab_create ()) == NULL + || (arm_reg_hsh = str_htab_create ()) == NULL + || (arm_reloc_hsh = str_htab_create ()) == NULL + || (arm_barrier_opt_hsh = str_htab_create ()) == NULL) as_fatal (_("virtual memory exhausted")); for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++) - hash_insert (arm_ops_hsh, insns[i].template_name, (void *) (insns + i)); + if (str_hash_find (arm_ops_hsh, insns[i].template_name) == NULL) + str_hash_insert (arm_ops_hsh, insns[i].template_name, (void *) (insns + i)); for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++) - hash_insert (arm_cond_hsh, conds[i].template_name, (void *) (conds + i)); + str_hash_insert (arm_cond_hsh, conds[i].template_name, (void *) (conds + i)); for (i = 0; i < sizeof (vconds) / sizeof (struct asm_cond); i++) - hash_insert (arm_vcond_hsh, vconds[i].template_name, (void *) (vconds + i)); + str_hash_insert (arm_vcond_hsh, vconds[i].template_name, (void *) (vconds + i)); for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++) - hash_insert (arm_shift_hsh, shift_names[i].name, (void *) (shift_names + i)); + str_hash_insert (arm_shift_hsh, shift_names[i].name, (void *) (shift_names + i)); for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++) - hash_insert (arm_psr_hsh, psrs[i].template_name, (void *) (psrs + i)); + str_hash_insert (arm_psr_hsh, psrs[i].template_name, (void *) (psrs + i)); for (i = 0; i < sizeof (v7m_psrs) / sizeof (struct asm_psr); i++) - hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template_name, + str_hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template_name, (void *) (v7m_psrs + i)); for (i = 0; i < sizeof (reg_names) / sizeof (struct reg_entry); i++) - hash_insert (arm_reg_hsh, reg_names[i].name, (void *) (reg_names + i)); + str_hash_insert (arm_reg_hsh, reg_names[i].name, (void *) (reg_names + i)); for (i = 0; i < sizeof (barrier_opt_names) / sizeof (struct asm_barrier_opt); i++) - hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template_name, + str_hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template_name, (void *) (barrier_opt_names + i)); #ifdef OBJ_ELF for (i = 0; i < ARRAY_SIZE (reloc_names); i++) @@ -30752,7 +30755,7 @@ md_begin (void) /* This makes encode_branch() use the EABI versions of this relocation. */ entry->reloc = BFD_RELOC_UNUSED; - hash_insert (arm_reloc_hsh, entry->name, (void *) entry); + str_hash_insert (arm_reloc_hsh, entry->name, (void *) entry); } #endif Only in binutils-2.35/gas/config: tc-arm.c.orig diff -rup binutils.orig/gas/config/tc-avr.c binutils-2.35/gas/config/tc-avr.c --- binutils.orig/gas/config/tc-avr.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-avr.c 2021-08-11 17:39:31.404057558 +0100 @@ -524,13 +524,13 @@ typedef union } mod_index; /* Opcode hash table. */ -static struct hash_control *avr_hash; +static htab_t avr_hash; /* Reloc modifiers hash control (hh8,hi8,lo8,pm_xx). */ -static struct hash_control *avr_mod_hash; +static htab_t avr_mod_hash; /* Whether some opcode does not change SREG. */ -static struct hash_control *avr_no_sreg_hash; +static htab_t avr_no_sreg_hash; static const char* const avr_no_sreg[] = { @@ -808,33 +808,35 @@ md_begin (void) unsigned int i; struct avr_opcodes_s *opcode; - avr_hash = hash_new (); + avr_hash = str_htab_create (); /* Insert unique names into hash table. This hash table then provides a quick index to the first opcode with a particular name in the opcode table. */ for (opcode = avr_opcodes; opcode->name; opcode++) - hash_insert (avr_hash, opcode->name, (char *) opcode); + if (str_hash_find (avr_hash, opcode->name) == NULL) + str_hash_insert (avr_hash, opcode->name, (char *) opcode); - avr_mod_hash = hash_new (); + avr_mod_hash = str_htab_create (); for (i = 0; i < ARRAY_SIZE (exp_mod); ++i) { mod_index m; m.index = i + 10; - hash_insert (avr_mod_hash, EXP_MOD_NAME (i), m.ptr); + str_hash_find (avr_mod_hash, EXP_MOD_NAME (i)); + str_hash_insert (avr_mod_hash, EXP_MOD_NAME (i), m.ptr); } - avr_no_sreg_hash = hash_new (); + avr_no_sreg_hash = str_htab_create (); for (i = 0; i < ARRAY_SIZE (avr_no_sreg); ++i) { - gas_assert (hash_find (avr_hash, avr_no_sreg[i])); - hash_insert (avr_no_sreg_hash, avr_no_sreg[i], (char*) 4 /* dummy */); + gas_assert (str_hash_find (avr_hash, avr_no_sreg[i])); + str_hash_insert (avr_no_sreg_hash, avr_no_sreg[i], (char*) 4 /* dummy */); } - avr_gccisr_opcode = (struct avr_opcodes_s*) hash_find (avr_hash, "__gcc_isr"); + avr_gccisr_opcode = (struct avr_opcodes_s*) str_hash_find (avr_hash, "__gcc_isr"); gas_assert (avr_gccisr_opcode); bfd_set_arch_mach (stdoutput, TARGET_ARCH, avr_mcu->mach); @@ -923,7 +925,7 @@ avr_ldi_expression (expressionS *exp) { mod_index m; - m.ptr = hash_find (avr_mod_hash, op); + m.ptr = str_hash_find (avr_mod_hash, op); mod = m.index; if (mod) @@ -1874,7 +1876,7 @@ md_assemble (char *str) if (!op[0]) as_bad (_("can't find opcode ")); - opcode = (struct avr_opcodes_s *) hash_find (avr_hash, op); + opcode = (struct avr_opcodes_s *) str_hash_find (avr_hash, op); if (opcode && !avr_opt.all_opcodes) { @@ -2453,7 +2455,7 @@ avr_update_gccisr (struct avr_opcodes_s /* SREG: Look up instructions that don't clobber SREG. */ if (!avr_isr.need_sreg - && !hash_find (avr_no_sreg_hash, opcode->name)) + && !str_hash_find (avr_no_sreg_hash, opcode->name)) { avr_isr.need_sreg = 1; } @@ -2497,7 +2499,7 @@ avr_emit_insn (const char *insn, int reg const int sreg = 0x3f; unsigned bin = 0; const struct avr_opcodes_s *op - = (struct avr_opcodes_s*) hash_find (avr_hash, insn); + = (struct avr_opcodes_s*) str_hash_find (avr_hash, insn); /* We only have to deal with: IN, OUT, PUSH, POP, CLR, LDI 0. All of these deal with at least one Reg and are 1-word instructions. */ diff -rup binutils.orig/gas/config/tc-cr16.c binutils-2.35/gas/config/tc-cr16.c --- binutils.orig/gas/config/tc-cr16.c 2021-08-11 17:33:12.211490357 +0100 +++ binutils-2.35/gas/config/tc-cr16.c 2021-08-11 17:39:31.404057558 +0100 @@ -53,15 +53,15 @@ typedef enum op_err; /* Opcode mnemonics hash table. */ -static struct hash_control *cr16_inst_hash; +static htab_t cr16_inst_hash; /* CR16 registers hash table. */ -static struct hash_control *reg_hash; +static htab_t reg_hash; /* CR16 register pair hash table. */ -static struct hash_control *regp_hash; +static htab_t regp_hash; /* CR16 processor registers hash table. */ -static struct hash_control *preg_hash; +static htab_t preg_hash; /* CR16 processor registers 32 bit hash table. */ -static struct hash_control *pregp_hash; +static htab_t pregp_hash; /* Current instruction we're assembling. */ const inst *instruction; @@ -324,7 +324,7 @@ get_register (char *reg_name) { const reg_entry *rreg; - rreg = (const reg_entry *) hash_find (reg_hash, reg_name); + rreg = (const reg_entry *) str_hash_find (reg_hash, reg_name); if (rreg != NULL) return rreg->value.reg_val; @@ -345,10 +345,10 @@ get_register_pair (char *reg_name) tmp_rp[0] = '('; strcat (tmp_rp, reg_name); strcat (tmp_rp,")"); - rreg = (const reg_entry *) hash_find (regp_hash, tmp_rp); + rreg = (const reg_entry *) str_hash_find (regp_hash, tmp_rp); } else - rreg = (const reg_entry *) hash_find (regp_hash, reg_name); + rreg = (const reg_entry *) str_hash_find (regp_hash, reg_name); if (rreg != NULL) return rreg->value.reg_val; @@ -363,7 +363,7 @@ get_index_register (char *reg_name) { const reg_entry *rreg; - rreg = (const reg_entry *) hash_find (reg_hash, reg_name); + rreg = (const reg_entry *) str_hash_find (reg_hash, reg_name); if ((rreg != NULL) && ((rreg->value.reg_val == 12) || (rreg->value.reg_val == 13))) @@ -378,7 +378,7 @@ get_index_register_pair (char *reg_name) { const reg_entry *rreg; - rreg = (const reg_entry *) hash_find (regp_hash, reg_name); + rreg = (const reg_entry *) str_hash_find (regp_hash, reg_name); if (rreg != NULL) { @@ -399,7 +399,7 @@ get_pregister (char *preg_name) { const reg_entry *prreg; - prreg = (const reg_entry *) hash_find (preg_hash, preg_name); + prreg = (const reg_entry *) str_hash_find (preg_hash, preg_name); if (prreg != NULL) return prreg->value.preg_val; @@ -414,7 +414,7 @@ get_pregisterp (char *preg_name) { const reg_entry *prreg; - prreg = (const reg_entry *) hash_find (pregp_hash, preg_name); + prreg = (const reg_entry *) str_hash_find (pregp_hash, preg_name); if (prreg != NULL) return prreg->value.preg_val; @@ -794,25 +794,18 @@ md_pcrel_from (fixS *fixp) } static void -initialise_reg_hash_table (struct hash_control ** hash_table, +initialise_reg_hash_table (htab_t * hash_table, const reg_entry * register_table, const unsigned int num_entries) { const reg_entry * rreg; - const char *hashret; - - if ((* hash_table = hash_new ()) == NULL) + if ((* hash_table = str_htab_create ()) == NULL) as_fatal (_("Virtual memory exhausted")); for (rreg = register_table; rreg < (register_table + num_entries); rreg++) - { - hashret = hash_insert (* hash_table, rreg->name, (char *) rreg); - if (hashret) - as_fatal (_("Internal Error: Can't hash %s: %s"), - rreg->name, hashret); - } + str_hash_insert (* hash_table, rreg->name, (char *) rreg); } /* This function is called once, at assembler startup time. This should @@ -824,21 +817,15 @@ md_begin (void) int i = 0; /* Set up a hash table for the instructions. */ - if ((cr16_inst_hash = hash_new ()) == NULL) + if ((cr16_inst_hash = str_htab_create ()) == NULL) as_fatal (_("Virtual memory exhausted")); while (cr16_instruction[i].mnemonic != NULL) { - const char *hashret; const char *mnemonic = cr16_instruction[i].mnemonic; - hashret = hash_insert (cr16_inst_hash, mnemonic, - (char *)(cr16_instruction + i)); - - if (hashret != NULL && *hashret != '\0') - as_fatal (_("Can't hash `%s': %s\n"), cr16_instruction[i].mnemonic, - *hashret == 0 ? _("(unknown reason)") : hashret); - + str_hash_insert (cr16_inst_hash, mnemonic, + (char *)(cr16_instruction + i)); /* Insert unique names into hash table. The CR16 instruction set has many identical opcode names that have different opcodes based on the operands. This hash table then provides a quick index to @@ -2505,7 +2492,7 @@ cr16_assemble (const char *op, char *par ins cr16_ins; /* Find the instruction. */ - instruction = (const inst *) hash_find (cr16_inst_hash, op); + instruction = (const inst *) str_hash_find (cr16_inst_hash, op); if (instruction == NULL) { as_bad (_("Unknown opcode: `%s'"), op); @@ -2575,7 +2562,7 @@ md_assemble (char *op) { strcpy (param1, param); /* Find the instruction. */ - instruction = (const inst *) hash_find (cr16_inst_hash, op); + instruction = (const inst *) str_hash_find (cr16_inst_hash, op); parse_operands (&cr16_ins, param1); if (((&cr16_ins)->arg[0].type == arg_ic) && ((&cr16_ins)->arg[0].constant >= 0)) diff -rup binutils.orig/gas/config/tc-cris.c binutils-2.35/gas/config/tc-cris.c --- binutils.orig/gas/config/tc-cris.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-cris.c 2021-08-11 17:39:31.404057558 +0100 @@ -160,7 +160,7 @@ static void cris_sym_no_leading_undersco static char *cris_insn_first_word_frag (void); /* Handle to the opcode hash table. */ -static struct hash_control *op_hash = NULL; +static htab_t op_hash = NULL; /* If we target cris-axis-linux-gnu (as opposed to generic cris-axis-elf), we default to no underscore and required register-prefixes. The @@ -1186,11 +1186,10 @@ cris_insn_first_word_frag (void) void md_begin (void) { - const char *hashret = NULL; int i = 0; /* Set up a hash table for the instructions. */ - op_hash = hash_new (); + op_hash = str_htab_create (); if (op_hash == NULL) as_fatal (_("Virtual memory exhausted")); @@ -1222,12 +1221,8 @@ md_begin (void) continue; } - /* Need to cast to get rid of "const". FIXME: Fix hash_insert instead. */ - hashret = hash_insert (op_hash, name, (void *) &cris_opcodes[i]); - - if (hashret != NULL && *hashret != '\0') - as_fatal (_("Can't hash `%s': %s\n"), cris_opcodes[i].name, - *hashret == 0 ? _("(unknown reason)") : hashret); + /* Need to cast to get rid of "const". FIXME: Fix str_hash_insert instead. */ + str_hash_insert (op_hash, name, (void *) &cris_opcodes[i]); do { if (cris_opcodes[i].match & cris_opcodes[i].lose) @@ -1558,7 +1553,7 @@ cris_process_instruction (char *insn_tex } /* Find the instruction. */ - instruction = (struct cris_opcode *) hash_find (op_hash, insn_text); + instruction = (struct cris_opcode *) str_hash_find (op_hash, insn_text); if (instruction == NULL) { as_bad (_("Unknown opcode: `%s'"), insn_text); diff -rup binutils.orig/gas/config/tc-crx.c binutils-2.35/gas/config/tc-crx.c --- binutils.orig/gas/config/tc-crx.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-crx.c 2021-08-11 17:39:31.404057558 +0100 @@ -63,11 +63,11 @@ typedef enum op_err; /* Opcode mnemonics hash table. */ -static struct hash_control *crx_inst_hash; +static htab_t crx_inst_hash; /* CRX registers hash table. */ -static struct hash_control *reg_hash; +static htab_t reg_hash; /* CRX coprocessor registers hash table. */ -static struct hash_control *copreg_hash; +static htab_t copreg_hash; /* Current instruction we're assembling. */ static const inst *instruction; @@ -208,7 +208,7 @@ get_register (char *reg_name) { const reg_entry *rreg; - rreg = (const reg_entry *) hash_find (reg_hash, reg_name); + rreg = (const reg_entry *) str_hash_find (reg_hash, reg_name); if (rreg != NULL) return rreg->value.reg_val; @@ -223,7 +223,7 @@ get_copregister (char *copreg_name) { const reg_entry *coreg; - coreg = (const reg_entry *) hash_find (copreg_hash, copreg_name); + coreg = (const reg_entry *) str_hash_find (copreg_hash, copreg_name); if (coreg != NULL) return coreg->value.copreg_val; @@ -527,24 +527,19 @@ md_pcrel_from (fixS *fixp) void md_begin (void) { - const char *hashret = NULL; int i = 0; /* Set up a hash table for the instructions. */ - if ((crx_inst_hash = hash_new ()) == NULL) + if ((crx_inst_hash = str_htab_create ()) == NULL) as_fatal (_("Virtual memory exhausted")); while (crx_instruction[i].mnemonic != NULL) { const char *mnemonic = crx_instruction[i].mnemonic; - hashret = hash_insert (crx_inst_hash, mnemonic, + str_hash_insert (crx_inst_hash, mnemonic, (void *) &crx_instruction[i]); - if (hashret != NULL && *hashret != '\0') - as_fatal (_("Can't hash `%s': %s\n"), crx_instruction[i].mnemonic, - *hashret == 0 ? _("(unknown reason)") : hashret); - /* Insert unique names into hash table. The CRX instruction set has many identical opcode names that have different opcodes based on the operands. This hash table then provides a quick index to @@ -558,7 +553,7 @@ md_begin (void) } /* Initialize reg_hash hash table. */ - if ((reg_hash = hash_new ()) == NULL) + if ((reg_hash = str_htab_create ()) == NULL) as_fatal (_("Virtual memory exhausted")); { @@ -566,17 +561,11 @@ md_begin (void) for (regtab = crx_regtab; regtab < (crx_regtab + NUMREGS); regtab++) - { - hashret = hash_insert (reg_hash, regtab->name, (void *) regtab); - if (hashret) - as_fatal (_("Internal error: Can't hash %s: %s"), - regtab->name, - hashret); - } + str_hash_insert (reg_hash, regtab->name, (void *) regtab); } /* Initialize copreg_hash hash table. */ - if ((copreg_hash = hash_new ()) == NULL) + if ((copreg_hash = str_htab_create ()) == NULL) as_fatal (_("Virtual memory exhausted")); { @@ -584,14 +573,8 @@ md_begin (void) for (copregtab = crx_copregtab; copregtab < (crx_copregtab + NUMCOPREGS); copregtab++) - { - hashret = hash_insert (copreg_hash, copregtab->name, - (void *) copregtab); - if (hashret) - as_fatal (_("Internal error: Can't hash %s: %s"), - copregtab->name, - hashret); - } + str_hash_insert (copreg_hash, copregtab->name, + (void *) copregtab); } /* Set linkrelax here to avoid fixups in most sections. */ linkrelax = 1; @@ -1989,7 +1972,7 @@ md_assemble (char *op) *param++ = '\0'; /* Find the instruction. */ - instruction = (const inst *) hash_find (crx_inst_hash, op); + instruction = (const inst *) str_hash_find (crx_inst_hash, op); if (instruction == NULL) { as_bad (_("Unknown opcode: `%s'"), op); diff -rup binutils.orig/gas/config/tc-csky.c binutils-2.35/gas/config/tc-csky.c --- binutils.orig/gas/config/tc-csky.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-csky.c 2021-08-11 17:39:31.405057552 +0100 @@ -754,8 +754,8 @@ size_t md_longopts_size = sizeof (md_lon static struct csky_insn_info csky_insn; -static struct hash_control *csky_opcodes_hash; -static struct hash_control *csky_macros_hash; +static htab_t csky_opcodes_hash; +static htab_t csky_macros_hash; static struct csky_macro_info v1_macros_table[] = { @@ -1354,16 +1354,16 @@ md_begin (void) } /* Establish hash table for opcodes and macros. */ - csky_macros_hash = hash_new (); - csky_opcodes_hash = hash_new (); + csky_macros_hash = str_htab_create (); + csky_opcodes_hash = str_htab_create (); for ( ; opcode->mnemonic != NULL; opcode++) if ((isa_flag & (opcode->isa_flag16 | opcode->isa_flag32)) != 0) - hash_insert (csky_opcodes_hash, opcode->mnemonic, (char *)opcode); + str_hash_insert (csky_opcodes_hash, opcode->mnemonic, (char *)opcode); for ( ; macro->name != NULL; macro++) if ((isa_flag & macro->isa_flag) != 0) - hash_insert (csky_macros_hash, macro->name, (char *)macro); + str_hash_insert (csky_macros_hash, macro->name, (char *)macro); if (do_nolrw && (isa_flag & CSKYV2_ISA_1E2) != 0) - hash_insert (csky_macros_hash, + str_hash_insert (csky_macros_hash, v2_lrw_macro_opcode.name, (char *)&v2_lrw_macro_opcode); /* Set e_flag to ELF Head. */ @@ -2931,9 +2931,9 @@ parse_opcode (char *str) csky_insn.number = csky_count_operands (opcode_end); /* Find hash by name in csky_macros_hash and csky_opcodes_hash. */ - csky_insn.macro = (struct csky_macro_info *) hash_find (csky_macros_hash, + csky_insn.macro = (struct csky_macro_info *) str_hash_find (csky_macros_hash, macro_name); - csky_insn.opcode = (struct csky_opcode *) hash_find (csky_opcodes_hash, + csky_insn.opcode = (struct csky_opcode *) str_hash_find (csky_opcodes_hash, name); if (csky_insn.macro == NULL && csky_insn.opcode == NULL) @@ -3155,7 +3155,7 @@ get_operand_value (struct csky_opcode_in { const char *name = "movi"; csky_insn.opcode = (struct csky_opcode *) - hash_find (csky_opcodes_hash, name); + str_hash_find (csky_opcodes_hash, name); csky_insn.val[csky_insn.idx - 1] = 1 << val; } return TRUE; @@ -3189,7 +3189,7 @@ get_operand_value (struct csky_opcode_in { const char *name = "movi"; csky_insn.opcode = (struct csky_opcode *) - hash_find (csky_opcodes_hash, name); + str_hash_find (csky_opcodes_hash, name); as_warn (_("translating mgeni to movi")); } else @@ -3223,7 +3223,7 @@ get_operand_value (struct csky_opcode_in { const char *op_movi = "movi"; csky_insn.opcode = (struct csky_opcode *) - hash_find (csky_opcodes_hash, op_movi); + str_hash_find (csky_opcodes_hash, op_movi); if (csky_insn.opcode == NULL) return FALSE; csky_insn.val[csky_insn.idx - 1] = (1 << mask_val) - 1; @@ -3273,7 +3273,7 @@ get_operand_value (struct csky_opcode_in { const char *op_movi = "movi"; csky_insn.opcode = (struct csky_opcode *) - hash_find (csky_opcodes_hash, op_movi); + str_hash_find (csky_opcodes_hash, op_movi); if (csky_insn.opcode == NULL) return FALSE; csky_insn.val[csky_insn.idx - 1] = (1 << (mask_val + 1)) - 1; @@ -5953,7 +5953,7 @@ v1_work_jbsr (void) /* Using jsri instruction. */ const char *name = "jsri"; csky_insn.opcode = (struct csky_opcode *) - hash_find (csky_opcodes_hash, name); + str_hash_find (csky_opcodes_hash, name); csky_insn.opcode_idx = 0; csky_insn.isize = 2; @@ -6291,7 +6291,7 @@ v2_work_rotlc (void) { const char *name = "addc"; csky_insn.opcode - = (struct csky_opcode *) hash_find (csky_opcodes_hash, name); + = (struct csky_opcode *) str_hash_find (csky_opcodes_hash, name); csky_insn.opcode_idx = 0; if (csky_insn.isize == 2) { @@ -6329,7 +6329,7 @@ v2_work_bgeni (void) val >>= 16; } csky_insn.opcode - = (struct csky_opcode *) hash_find (csky_opcodes_hash, name); + = (struct csky_opcode *) str_hash_find (csky_opcodes_hash, name); csky_insn.opcode_idx = 0; csky_insn.val[1] = val; @@ -6347,7 +6347,7 @@ v2_work_not (void) { const char *name = "nor"; csky_insn.opcode - = (struct csky_opcode *) hash_find (csky_opcodes_hash, name); + = (struct csky_opcode *) str_hash_find (csky_opcodes_hash, name); csky_insn.opcode_idx = 0; if (csky_insn.number == 1) { Only in binutils-2.35/gas/config: tc-csky.c.orig diff -rup binutils.orig/gas/config/tc-d10v.c binutils-2.35/gas/config/tc-d10v.c --- binutils.orig/gas/config/tc-d10v.c 2021-08-11 17:33:12.215490331 +0100 +++ binutils-2.35/gas/config/tc-d10v.c 2021-08-11 17:39:31.405057552 +0100 @@ -101,7 +101,7 @@ struct option md_longopts[] = size_t md_longopts_size = sizeof (md_longopts); /* Opcode hash table. */ -static struct hash_control *d10v_hash; +static htab_t d10v_hash; /* Do a binary search of the d10v_predefined_registers array to see if NAME is a valid register name. Return the register number from the @@ -277,7 +277,7 @@ md_begin (void) { const char *prev_name = ""; struct d10v_opcode *opcode; - d10v_hash = hash_new (); + d10v_hash = str_htab_create (); /* Insert unique names into hash table. The D10v instruction set has many identical opcode names that have different opcodes based @@ -289,7 +289,7 @@ md_begin (void) if (strcmp (prev_name, opcode->name)) { prev_name = (char *) opcode->name; - hash_insert (d10v_hash, opcode->name, (char *) opcode); + str_hash_insert (d10v_hash, opcode->name, (char *) opcode); } } @@ -1430,7 +1430,7 @@ do_assemble (char *str, struct d10v_opco return -1; /* Find the first opcode with the proper name. */ - *opcode = (struct d10v_opcode *) hash_find (d10v_hash, name); + *opcode = (struct d10v_opcode *) str_hash_find (d10v_hash, name); if (*opcode == NULL) return -1; @@ -1558,8 +1558,8 @@ md_apply_fix (fixS *fixP, valueT *valP, { struct d10v_opcode *rep, *repi; - rep = (struct d10v_opcode *) hash_find (d10v_hash, "rep"); - repi = (struct d10v_opcode *) hash_find (d10v_hash, "repi"); + rep = (struct d10v_opcode *) str_hash_find (d10v_hash, "rep"); + repi = (struct d10v_opcode *) str_hash_find (d10v_hash, "repi"); if ((insn & FM11) == FM11 && ((repi != NULL && (insn & repi->mask) == (unsigned) repi->opcode) diff -rup binutils.orig/gas/config/tc-d30v.c binutils-2.35/gas/config/tc-d30v.c --- binutils.orig/gas/config/tc-d30v.c 2021-08-11 17:33:12.215490331 +0100 +++ binutils-2.35/gas/config/tc-d30v.c 2021-08-11 17:39:31.405057552 +0100 @@ -118,7 +118,7 @@ struct option md_longopts[] = size_t md_longopts_size = sizeof (md_longopts); /* Opcode hash table. */ -static struct hash_control *d30v_hash; +static htab_t d30v_hash; /* Do a binary search of the pre_defined_registers array to see if NAME is a valid register name. Return the register number from the @@ -310,11 +310,11 @@ void md_begin (void) { struct d30v_opcode *opcode; - d30v_hash = hash_new (); + d30v_hash = str_htab_create (); /* Insert opcode names into a hash table. */ for (opcode = (struct d30v_opcode *) d30v_opcode_table; opcode->name; opcode++) - hash_insert (d30v_hash, opcode->name, (char *) opcode); + str_hash_insert (d30v_hash, opcode->name, (char *) opcode); fixups = &FixUps[0]; FixUps[0].next = &FixUps[1]; @@ -1390,7 +1390,7 @@ do_assemble (char *str, } /* Find the first opcode with the proper name. */ - opcode->op = (struct d30v_opcode *) hash_find (d30v_hash, name); + opcode->op = (struct d30v_opcode *) str_hash_find (d30v_hash, name); if (opcode->op == NULL) { as_bad (_("unknown opcode: %s"), name); diff -rup binutils.orig/gas/config/tc-dlx.c binutils-2.35/gas/config/tc-dlx.c --- binutils.orig/gas/config/tc-dlx.c 2021-08-11 17:33:12.212490350 +0100 +++ binutils-2.35/gas/config/tc-dlx.c 2021-08-11 17:39:31.405057552 +0100 @@ -43,7 +43,7 @@ #define RELOC_DLX_VTENTRY BFD_RELOC_VTABLE_ENTRY /* handle of the OPCODE hash table */ -static struct hash_control *op_hash = NULL; +static htab_t op_hash = NULL; struct machine_it { @@ -276,31 +276,18 @@ s_proc (int end_p) void md_begin (void) { - const char *retval = NULL; - int lose = 0; unsigned int i; /* Create a new hash table. */ - op_hash = hash_new (); + op_hash = str_htab_create (); /* Hash up all the opcodes for fast use later. */ for (i = 0; i < num_dlx_opcodes; i++) { const char *name = machine_opcodes[i].name; - - retval = hash_insert (op_hash, name, (void *) &machine_opcodes[i]); - - if (retval != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - machine_opcodes[i].name, retval); - lose = 1; - } + str_hash_insert (op_hash, name, (void *) &machine_opcodes[i]); } - if (lose) - as_fatal (_("Broken assembler. No assembly attempted.")); - define_some_regs (); } @@ -694,7 +681,7 @@ machine_ip (char *str) } /* Hash the opcode, insn will have the string from opcode table. */ - if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL) + if ((insn = (struct machine_opcode *) str_hash_find (op_hash, str)) == NULL) { /* Handle the ret and return macro here. */ if ((strcmp (str, "ret") == 0) || (strcmp (str, "return") == 0)) diff -rup binutils.orig/gas/config/tc-ft32.c binutils-2.35/gas/config/tc-ft32.c --- binutils.orig/gas/config/tc-ft32.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-ft32.c 2021-08-11 17:39:31.405057552 +0100 @@ -34,7 +34,7 @@ const char line_separator_chars[] = ";"; const char line_comment_chars[] = "#"; static int pending_reloc; -static struct hash_control *opcode_hash_control; +static htab_t opcode_hash_control; static valueT md_chars_to_number (char * buf, int n); @@ -54,11 +54,11 @@ void md_begin (void) { const ft32_opc_info_t *opcode; - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); /* Insert names into hash table. */ for (opcode = ft32_opc_info; opcode->name; opcode++) - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->name, (char *) opcode); bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0); if (!norelax) @@ -231,7 +231,7 @@ md_assemble (char *str) if (nlen == 0) as_bad (_("can't find opcode ")); - opcode = (ft32_opc_info_t *) hash_find (opcode_hash_control, op_start); + opcode = (ft32_opc_info_t *) str_hash_find (opcode_hash_control, op_start); *op_end = pend; if (opcode == NULL) diff -rup binutils.orig/gas/config/tc-h8300.c binutils-2.35/gas/config/tc-h8300.c --- binutils.orig/gas/config/tc-h8300.c 2021-08-11 17:33:12.212490350 +0100 +++ binutils-2.35/gas/config/tc-h8300.c 2021-08-11 17:39:31.406057545 +0100 @@ -224,7 +224,7 @@ const char EXP_CHARS[] = "eE"; or 0d1.2345e12. */ const char FLT_CHARS[] = "rRsSfFdDxXpP"; -static struct hash_control *opcode_hash_control; /* Opcode mnemonics. */ +static htab_t opcode_hash_control; /* Opcode mnemonics. */ /* This function is called once, at assembler startup time. This should set up all the tables, etc. that the MD part of the assembler @@ -242,7 +242,7 @@ md_begin (void) if (!bfd_set_arch_mach (stdoutput, bfd_arch_h8300, default_mach)) as_warn (_("could not set architecture and machine")); - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); prev_buffer[0] = 0; nopcodes = sizeof (h8_opcodes) / sizeof (struct h8_opcode); @@ -283,7 +283,7 @@ md_begin (void) len = dst - buffer; if (cmplen == 0) cmplen = len; - hash_insert (opcode_hash_control, buffer, (char *) pi); + str_hash_insert (opcode_hash_control, buffer, (char *) pi); strcpy (prev_buffer, buffer); idx++; @@ -1940,7 +1940,7 @@ md_assemble (char *str) *slash = TOLOWER (*slash); instruction = (const struct h8_instruction *) - hash_find (opcode_hash_control, op_start); + str_hash_find (opcode_hash_control, op_start); if (instruction == NULL) { diff -rup binutils.orig/gas/config/tc-hppa.c binutils-2.35/gas/config/tc-hppa.c --- binutils.orig/gas/config/tc-hppa.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-hppa.c 2021-08-11 17:39:31.406057545 +0100 @@ -550,7 +550,7 @@ static struct call_info *last_call_info; static struct call_desc last_call_desc; /* handle of the OPCODE hash table */ -static struct hash_control *op_hash = NULL; +static htab_t op_hash = NULL; /* These characters can be suffixes of opcode names and they may be followed by meaningful whitespace. We don't include `,' and `!' @@ -3214,7 +3214,7 @@ pa_ip (char *str) } /* Look up the opcode in the hash table. */ - if ((insn = (struct pa_opcode *) hash_find (op_hash, str)) == NULL) + if ((insn = (struct pa_opcode *) str_hash_find (op_hash, str)) == NULL) { as_bad (_("Unknown opcode: `%s'"), str); return; @@ -8215,7 +8215,6 @@ pa_lsym (int unused ATTRIBUTE_UNUSED) void md_begin (void) { - const char *retval = NULL; int lose = 0; unsigned int i = 0; @@ -8238,18 +8237,13 @@ md_begin (void) pa_spaces_begin (); #endif - op_hash = hash_new (); + op_hash = str_htab_create (); while (i < NUMOPCODES) { const char *name = pa_opcodes[i].name; - retval = hash_insert (op_hash, name, (struct pa_opcode *) &pa_opcodes[i]); - if (retval != NULL && *retval != '\0') - { - as_fatal (_("Internal error: can't hash `%s': %s\n"), name, retval); - lose = 1; - } + str_hash_insert (op_hash, name, (void *)&pa_opcodes[i]); do { diff -rup binutils.orig/gas/config/tc-i386.c binutils-2.35/gas/config/tc-i386.c --- binutils.orig/gas/config/tc-i386.c 2021-08-11 17:33:12.208490376 +0100 +++ binutils-2.35/gas/config/tc-i386.c 2021-08-11 17:39:31.407057539 +0100 @@ -1362,10 +1362,10 @@ const pseudo_typeS md_pseudo_table[] = extern char *input_line_pointer; /* Hash table for instruction mnemonic lookup. */ -static struct hash_control *op_hash; +static htab_t op_hash; /* Hash table for register lookup. */ -static struct hash_control *reg_hash; +static htab_t reg_hash; /* Various efficient no-op patterns for aligning code labels. Note: Don't try to assemble the instructions in the comments. @@ -3009,13 +3009,11 @@ i386_mach (void) void md_begin (void) { - const char *hash_err; - /* Support pseudo prefixes like {disp32}. */ lex_type ['{'] = LEX_BEGIN_NAME; /* Initialize op_hash hash table. */ - op_hash = hash_new (); + op_hash = str_htab_create (); { const insn_template *optab; @@ -3035,15 +3033,7 @@ md_begin (void) /* different name --> ship out current template list; add to hash table; & begin anew. */ core_optab->end = optab; - hash_err = hash_insert (op_hash, - (optab - 1)->name, - (void *) core_optab); - if (hash_err) - { - as_fatal (_("can't hash %s: %s"), - (optab - 1)->name, - hash_err); - } + str_hash_insert (op_hash, (optab - 1)->name, (void *) core_optab); if (optab->name == NULL) break; core_optab = XNEW (templates); @@ -3053,19 +3043,13 @@ md_begin (void) } /* Initialize reg_hash hash table. */ - reg_hash = hash_new (); + reg_hash = str_htab_create (); { const reg_entry *regtab; unsigned int regtab_size = i386_regtab_size; for (regtab = i386_regtab; regtab_size--; regtab++) - { - hash_err = hash_insert (reg_hash, regtab->reg_name, (void *) regtab); - if (hash_err) - as_fatal (_("can't hash %s: %s"), - regtab->reg_name, - hash_err); - } + str_hash_insert (reg_hash, regtab->reg_name, (void *) regtab); } /* Fill in lexical tables: mnemonic_chars, operand_chars. */ @@ -3152,8 +3136,8 @@ md_begin (void) void i386_print_statistics (FILE *file) { - hash_print_statistics (file, "i386 opcode", op_hash); - hash_print_statistics (file, "i386 register", reg_hash); + htab_print_statistics (file, "i386 opcode", op_hash); + htab_print_statistics (file, "i386 register", reg_hash); } #ifdef DEBUG386 @@ -5043,7 +5027,7 @@ parse_insn (char *line, char *mnemonic) } /* Look up instruction (or prefix) via hash table. */ - current_templates = (const templates *) hash_find (op_hash, mnemonic); + current_templates = (const templates *) str_hash_find (op_hash, mnemonic); if (*l != END_OF_INSN && (!is_space_char (*l) || l[1] != END_OF_INSN) @@ -5165,7 +5149,7 @@ parse_insn (char *line, char *mnemonic) goto check_suffix; mnem_p = dot_p; *dot_p = '\0'; - current_templates = (const templates *) hash_find (op_hash, mnemonic); + current_templates = (const templates *) str_hash_find (op_hash, mnemonic); } if (!current_templates) @@ -5185,7 +5169,7 @@ parse_insn (char *line, char *mnemonic) case QWORD_MNEM_SUFFIX: i.suffix = mnem_p[-1]; mnem_p[-1] = '\0'; - current_templates = (const templates *) hash_find (op_hash, + current_templates = (const templates *) str_hash_find (op_hash, mnemonic); break; case SHORT_MNEM_SUFFIX: @@ -5194,7 +5178,7 @@ parse_insn (char *line, char *mnemonic) { i.suffix = mnem_p[-1]; mnem_p[-1] = '\0'; - current_templates = (const templates *) hash_find (op_hash, + current_templates = (const templates *) str_hash_find (op_hash, mnemonic); } break; @@ -5208,7 +5192,7 @@ parse_insn (char *line, char *mnemonic) else i.suffix = LONG_MNEM_SUFFIX; mnem_p[-1] = '\0'; - current_templates = (const templates *) hash_find (op_hash, + current_templates = (const templates *) str_hash_find (op_hash, mnemonic); } break; @@ -7492,7 +7476,7 @@ process_operands (void) i.flags[j] = i.flags[j - 1]; } i.op[0].regs - = (const reg_entry *) hash_find (reg_hash, "xmm0"); + = (const reg_entry *) str_hash_find (reg_hash, "xmm0"); i.types[0] = regxmm; i.tm.operand_types[0] = regxmm; @@ -10861,10 +10845,10 @@ i386_index_check (const char *operand_st && current_templates->end[-1].operand_types[1] .bitfield.baseindex)) op = 1; - expected_reg = hash_find (reg_hash, di_si[addr_mode][op == es_op]); + expected_reg = (const reg_entry *)str_hash_find (reg_hash, di_si[addr_mode][op == es_op]); } else - expected_reg = hash_find (reg_hash, bx[addr_mode]); + expected_reg = (const reg_entry *)str_hash_find (reg_hash, bx[addr_mode]); if (i.base_reg != expected_reg || i.index_reg @@ -12498,7 +12482,7 @@ parse_real_register (char *reg_string, c *end_op = s; - r = (const reg_entry *) hash_find (reg_hash, reg_name_given); + r = (const reg_entry *) str_hash_find (reg_hash, reg_name_given); /* Handle floating point regs, allowing spaces in the (i) part. */ if (r == i386_regtab /* %st is first entry of table */) @@ -12525,7 +12509,7 @@ parse_real_register (char *reg_string, c if (*s == ')') { *end_op = s + 1; - r = (const reg_entry *) hash_find (reg_hash, "st(0)"); + r = (const reg_entry *) str_hash_find (reg_hash, "st(0)"); know (r); return r + fpr; } Only in binutils-2.35/gas/config: tc-i386.c.orig diff -rup binutils.orig/gas/config/tc-ia64.c binutils-2.35/gas/config/tc-ia64.c --- binutils.orig/gas/config/tc-ia64.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-ia64.c 2021-08-11 17:39:31.408057532 +0100 @@ -185,10 +185,10 @@ static void ia64_float_to_chars_littleen 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. */ @@ -228,11 +228,11 @@ size_t md_longopts_size = sizeof (md_lon 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 @@ -4602,7 +4602,7 @@ dot_rot (int type) /* 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; } @@ -4683,12 +4683,7 @@ dot_rot (int type) 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; @@ -5166,7 +5161,6 @@ dot_pred_rel (int type) static void dot_entry (int dummy ATTRIBUTE_UNUSED) { - const char *err; char *name; int c; symbolS *symbolP; @@ -5176,10 +5170,7 @@ dot_entry (int dummy ATTRIBUTE_UNUSED) 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 (); @@ -5378,15 +5369,11 @@ pseudo_opcode[] = 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; } @@ -7241,8 +7228,6 @@ void 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; @@ -7253,10 +7238,10 @@ md_begin (void) 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 (".", undefined_section, FUNC_DTP_MODULE, @@ -7405,20 +7390,15 @@ md_begin (void) 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); @@ -7471,13 +7451,8 @@ md_begin (void) 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. */ @@ -7980,7 +7955,7 @@ ia64_parse_name (char *name, expressionS } /* 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; @@ -7988,7 +7963,7 @@ ia64_parse_name (char *name, expressionS return 1; } - cdesc = hash_find (md.const_hash, name); + cdesc = str_hash_find (md.const_hash, name); if (cdesc) { e->X_op = O_constant; @@ -8054,7 +8029,7 @@ ia64_parse_name (char *name, expressionS 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 @@ -10675,7 +10650,7 @@ md_assemble (char *str) 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); @@ -11750,10 +11725,9 @@ dot_alias (int section) 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); @@ -11810,21 +11784,26 @@ dot_alias (int section) } /* 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; } @@ -11832,32 +11811,19 @@ dot_alias (int section) 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) @@ -11866,43 +11832,48 @@ do_alias (const char *alias, void *value /* 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 diff -rup binutils.orig/gas/config/tc-iq2000.c binutils-2.35/gas/config/tc-iq2000.c --- binutils.orig/gas/config/tc-iq2000.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-iq2000.c 2021-08-11 17:43:57.988347560 +0100 @@ -106,7 +106,7 @@ struct iq2000_hi_fixup static struct iq2000_hi_fixup * iq2000_hi_fixup_list; /* Macro hash table, which we will add to. */ -extern struct hash_control *macro_hash; +extern struct htab *macro_hash; const char *md_shortopts = ""; struct option md_longopts[] = @@ -246,7 +246,10 @@ iq2000_add_macro (const char * name, formal_entry ** p = ¯o->formals; macro->formal_count = 0; - macro->formal_hash = hash_new (); + macro->formal_hash = htab_create_alloc (7, hash_formal_entry, + eq_formal_entry, + NULL, xcalloc, free); + while (*arguments != NULL) { @@ -272,8 +275,9 @@ iq2000_add_macro (const char * name, sb_add_string (& formal->name, *arguments); /* Add to macro's hash table. */ - hash_jam (macro->formal_hash, sb_terminate (& formal->name), formal); - + htab_insert (macro->formal_hash, + formal_entry_alloc (sb_terminate (& formal->name), + formal)); formal->index = macro->formal_count; macro->formal_count++; *p = formal; @@ -285,7 +289,7 @@ iq2000_add_macro (const char * name, sb_add_string (¯o_name, name); namestr = sb_terminate (¯o_name); - hash_jam (macro_hash, namestr, macro); + htab_insert (macro_hash, macro_entry_alloc (namestr, macro)); macro_defined = 1; } diff -rup binutils.orig/gas/config/tc-m68hc11.c binutils-2.35/gas/config/tc-m68hc11.c --- binutils.orig/gas/config/tc-m68hc11.c 2021-08-11 17:33:12.211490357 +0100 +++ binutils-2.35/gas/config/tc-m68hc11.c 2021-08-11 17:39:31.408057532 +0100 @@ -263,7 +263,7 @@ static short flag_print_insn_syntax = 0; static short flag_print_opcodes = 0; /* Opcode hash table. */ -static struct hash_control *m68hc11_hash; +static htab_t m68hc11_hash; /* Current cpu (either cpu6811 or cpu6812). This is determined automagically by 'get_default_target' by looking at default BFD vector. This is overridden @@ -472,7 +472,7 @@ m68hc11_print_statistics (FILE *file) int i; struct m68hc11_opcode_def *opc; - hash_print_statistics (file, "opcode table", m68hc11_hash); + htab_print_statistics (file, "opcode table", m68hc11_hash); opc = m68hc11_opcode_defs; if (opc == 0 || m68hc11_nb_opcode_defs == 0) @@ -610,7 +610,7 @@ md_begin (void) get_default_target (); - m68hc11_hash = hash_new (); + m68hc11_hash = str_htab_create (); /* Get a writable copy of the opcode table and sort it on the names. */ opcodes = XNEWVEC (struct m68hc11_opcode, m68hc11_num_opcodes); @@ -664,7 +664,7 @@ md_begin (void) opc->nb_modes = 0; opc->opcode = opcodes; opc->used = 0; - hash_insert (m68hc11_hash, opcodes->name, opc); + str_hash_insert (m68hc11_hash, opcodes->name, opc); } opc->nb_modes++; opc->format |= opcodes->format; @@ -1010,7 +1010,7 @@ print_insn_format (char *name) struct m68hc11_opcode *opcode; char buf[128]; - opc = (struct m68hc11_opcode_def *) hash_find (m68hc11_hash, name); + opc = (struct m68hc11_opcode_def *) str_hash_find (m68hc11_hash, name); if (opc == NULL) { as_bad (_("Instruction `%s' is not recognized."), name); @@ -2848,7 +2848,7 @@ md_assemble (char *str) if (current_architecture == cpuxgate) { /* Find the opcode definition given its name. */ - opc = (struct m68hc11_opcode_def *) hash_find (m68hc11_hash, name); + opc = (struct m68hc11_opcode_def *) str_hash_find (m68hc11_hash, name); if (opc == NULL) { as_bad (_("Opcode `%s' is not recognized."), name); @@ -3469,7 +3469,7 @@ md_assemble (char *str) } /* Find the opcode definition given its name. */ - opc = (struct m68hc11_opcode_def *) hash_find (m68hc11_hash, name); + opc = (struct m68hc11_opcode_def *) str_hash_find (m68hc11_hash, name); /* If it's not recognized, look for 'jbsr' and 'jbxx'. These are pseudo insns for relative branch. For these branches, we always @@ -3477,7 +3477,7 @@ md_assemble (char *str) is given. */ if (opc == NULL && name[0] == 'j' && name[1] == 'b') { - opc = (struct m68hc11_opcode_def *) hash_find (m68hc11_hash, &name[1]); + opc = (struct m68hc11_opcode_def *) str_hash_find (m68hc11_hash, &name[1]); if (opc && (!(opc->format & M6811_OP_JUMP_REL) || (opc->format & M6811_OP_BITMASK))) @@ -3508,7 +3508,7 @@ md_assemble (char *str) { name[nlen++] = TOLOWER (*op_end++); name[nlen] = 0; - opc = (struct m68hc11_opcode_def *) hash_find (m68hc11_hash, + opc = (struct m68hc11_opcode_def *) str_hash_find (m68hc11_hash, name); } } diff -rup binutils.orig/gas/config/tc-m68k.c binutils-2.35/gas/config/tc-m68k.c --- binutils.orig/gas/config/tc-m68k.c 2021-08-11 17:33:12.212490350 +0100 +++ binutils-2.35/gas/config/tc-m68k.c 2021-08-11 17:44:04.214307612 +0100 @@ -1320,7 +1320,7 @@ tc_gen_reloc (asection *section ATTRIBUT /* Handle of the OPCODE hash table. NULL means any use before m68k_ip_begin() will crash. */ -static struct hash_control *op_hash; +static htab_t op_hash; /* Assemble an m68k instruction. */ @@ -1375,7 +1375,7 @@ m68k_ip (char *instring) c = *p; *p = '\0'; - opcode = (const struct m68k_incant *) hash_find (op_hash, instring); + opcode = (const struct m68k_incant *) str_hash_find (op_hash, instring); *p = c; if (pdot != NULL) @@ -4496,7 +4496,6 @@ md_begin (void) { const struct m68k_opcode *ins; struct m68k_incant *hack, *slak; - const char *retval = 0; /* Empty string, or error msg text. */ int i; /* Set up hash tables with 68000 instructions. @@ -4527,7 +4526,7 @@ md_begin (void) qsort (m68k_sorted_opcodes, m68k_numopcodes, sizeof (m68k_sorted_opcodes[0]), m68k_compare_opcode); - op_hash = hash_new (); + op_hash = str_htab_create (); obstack_begin (&robyn, 4000); for (i = 0; i < m68k_numopcodes; i++) @@ -4571,22 +4570,18 @@ md_begin (void) } while (slak); - retval = hash_insert (op_hash, ins->name, (char *) hack); - if (retval) - as_fatal (_("Internal Error: Can't hash %s: %s"), ins->name, retval); + str_hash_insert (op_hash, ins->name, (char *) hack); } for (i = 0; i < m68k_numaliases; i++) { const char *name = m68k_opcode_aliases[i].primary; const char *alias = m68k_opcode_aliases[i].alias; - void *val = hash_find (op_hash, name); + void *val = (void *)str_hash_find (op_hash, name); if (!val) as_fatal (_("Internal Error: Can't find %s in hash table"), name); - retval = hash_insert (op_hash, alias, val); - if (retval) - as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval); + str_hash_insert (op_hash, alias, val); } /* In MRI mode, all unsized branches are variable sized. Normally, @@ -4619,13 +4614,11 @@ md_begin (void) { const char *name = mri_aliases[i].primary; const char *alias = mri_aliases[i].alias; - void *val = hash_find (op_hash, name); + void *val = (void *)str_hash_find (op_hash, name); if (!val) as_fatal (_("Internal Error: Can't find %s in hash table"), name); - retval = hash_jam (op_hash, alias, val); - if (retval) - as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval); + str_hash_insert (op_hash, alias, val); } } @@ -4680,7 +4673,7 @@ md_begin (void) while (mote_pseudo_table[n].poc_name) { hack = XOBNEW (&robyn, struct m68k_incant); - hash_insert (op_hash, + str_hash_insert (op_hash, mote_pseudo_table[n].poc_name, (char *) hack); hack->m_operands = 0; hack->m_opnum = n; @@ -5560,7 +5553,7 @@ s_proc (int ignore ATTRIBUTE_UNUSED) alignment is needed. */ int -m68k_conditional_pseudoop (pseudo_typeS *pop) +m68k_conditional_pseudoop (const pseudo_typeS *pop) { return (pop->poc_handler == s_mri_if || pop->poc_handler == s_mri_else); Only in binutils-2.35/gas/config: tc-m68k.c.orig diff -rup binutils.orig/gas/config/tc-m68k.h binutils-2.35/gas/config/tc-m68k.h --- binutils.orig/gas/config/tc-m68k.h 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-m68k.h 2021-08-11 17:44:04.214307612 +0100 @@ -47,7 +47,7 @@ extern const char *m68k_comment_chars; extern void m68k_mri_mode_change (int); #define MRI_MODE_CHANGE(i) m68k_mri_mode_change (i) -extern int m68k_conditional_pseudoop (pseudo_typeS *); +extern int m68k_conditional_pseudoop (const pseudo_typeS *); #define tc_conditional_pseudoop(pop) m68k_conditional_pseudoop (pop) extern void m68k_frob_label (symbolS *); diff -rup binutils.orig/gas/config/tc-mcore.c binutils-2.35/gas/config/tc-mcore.c --- binutils.orig/gas/config/tc-mcore.c 2021-08-11 17:33:12.214490337 +0100 +++ binutils-2.35/gas/config/tc-mcore.c 2021-08-11 17:39:31.408057532 +0100 @@ -135,7 +135,7 @@ static unsigned long poolspan; #define SPANEXIT (600) static symbolS * poolsym; /* Label for current pool. */ static char poolname[8]; -static struct hash_control * opcode_hash_control; /* Opcode mnemonics. */ +static htab_t opcode_hash_control; /* Opcode mnemonics. */ #define POOL_END_LABEL ".LE" #define POOL_START_LABEL ".LS" @@ -457,7 +457,7 @@ md_begin (void) const char * prev_name = ""; unsigned int i; - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); /* Insert unique names into hash table. */ for (i = 0; i < ARRAY_SIZE (mcore_table); i++) @@ -465,7 +465,7 @@ md_begin (void) if (! streq (prev_name, mcore_table[i].name)) { prev_name = mcore_table[i].name; - hash_insert (opcode_hash_control, mcore_table[i].name, (char *) &mcore_table[i]); + str_hash_insert (opcode_hash_control, mcore_table[i].name, (char *) &mcore_table[i]); } } } @@ -881,7 +881,7 @@ md_assemble (char * str) return; } - opcode = (mcore_opcode_info *) hash_find (opcode_hash_control, name); + opcode = (mcore_opcode_info *) str_hash_find (opcode_hash_control, name); if (opcode == NULL) { as_bad (_("unknown opcode \"%s\""), name); diff -rup binutils.orig/gas/config/tc-microblaze.c binutils-2.35/gas/config/tc-microblaze.c --- binutils.orig/gas/config/tc-microblaze.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-microblaze.c 2021-08-11 17:39:31.409057526 +0100 @@ -114,7 +114,7 @@ const relax_typeS md_relax_table[] = { 0x7fffffff, 0x80000000, INST_WORD_SIZE*2, 0 } /* 18: TEXT_PC_OFFSET. */ }; -static struct hash_control * opcode_hash_control; /* Opcode mnemonics. */ +static htab_t opcode_hash_control; /* Opcode mnemonics. */ static segT sbss_segment = 0; /* Small bss section. */ static segT sbss2_segment = 0; /* Section not used. */ @@ -413,11 +413,11 @@ md_begin (void) { struct op_code_struct * opcode; - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); /* Insert unique names into hash table. */ for (opcode = opcodes; opcode->name; opcode ++) - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->name, (char *) opcode); } /* Try to parse a reg name. */ @@ -942,7 +942,7 @@ md_assemble (char * str) return; } - opcode = (struct op_code_struct *) hash_find (opcode_hash_control, name); + opcode = (struct op_code_struct *) str_hash_find (opcode_hash_control, name); if (opcode == NULL) { as_bad (_("unknown opcode \"%s\""), name); @@ -1072,9 +1072,9 @@ md_assemble (char * str) count = 32 - reg1; if (streq (name, "lmi")) - opcode = (struct op_code_struct *) hash_find (opcode_hash_control, "lwi"); + opcode = (struct op_code_struct *) str_hash_find (opcode_hash_control, "lwi"); else - opcode = (struct op_code_struct *) hash_find (opcode_hash_control, "swi"); + opcode = (struct op_code_struct *) str_hash_find (opcode_hash_control, "swi"); if (opcode == NULL) { as_bad (_("unknown opcode \"%s\""), "lwi"); @@ -1106,7 +1106,7 @@ md_assemble (char * str) if ((temp != 0) && (temp != 0xFFFF8000)) { /* Needs an immediate inst. */ - opcode1 = (struct op_code_struct *) hash_find (opcode_hash_control, "imm"); + opcode1 = (struct op_code_struct *) str_hash_find (opcode_hash_control, "imm"); if (opcode1 == NULL) { as_bad (_("unknown opcode \"%s\""), "imm"); @@ -1559,7 +1559,7 @@ md_assemble (char * str) if ((temp != 0) && (temp != 0xFFFF8000)) { /* Needs an immediate inst. */ - opcode1 = (struct op_code_struct *) hash_find (opcode_hash_control, "imm"); + opcode1 = (struct op_code_struct *) str_hash_find (opcode_hash_control, "imm"); if (opcode1 == NULL) { as_bad (_("unknown opcode \"%s\""), "imm"); @@ -1625,7 +1625,7 @@ md_assemble (char * str) if ((temp != 0) && (temp != 0xFFFF8000)) { /* Needs an immediate inst. */ - opcode1 = (struct op_code_struct *) hash_find (opcode_hash_control, "imm"); + opcode1 = (struct op_code_struct *) str_hash_find (opcode_hash_control, "imm"); if (opcode1 == NULL) { as_bad (_("unknown opcode \"%s\""), "imm"); @@ -1698,7 +1698,7 @@ md_assemble (char * str) if ((temp != 0) && (temp != 0xFFFF8000)) { /* Needs an immediate inst. */ - opcode1 = (struct op_code_struct *) hash_find (opcode_hash_control, "imm"); + opcode1 = (struct op_code_struct *) str_hash_find (opcode_hash_control, "imm"); if (opcode1 == NULL) { as_bad (_("unknown opcode \"%s\""), "imm"); @@ -2119,7 +2119,7 @@ md_apply_fix (fixS * fixP, buf[i + INST_WORD_SIZE] = buf[i]; /* Generate the imm instruction. */ - opcode1 = (struct op_code_struct *) hash_find (opcode_hash_control, "imm"); + opcode1 = (struct op_code_struct *) str_hash_find (opcode_hash_control, "imm"); if (opcode1 == NULL) { as_bad (_("unknown opcode \"%s\""), "imm"); @@ -2167,7 +2167,7 @@ md_apply_fix (fixS * fixP, buf[i + INST_WORD_SIZE] = buf[i]; /* Generate the imm instruction. */ - opcode1 = (struct op_code_struct *) hash_find (opcode_hash_control, "imm"); + opcode1 = (struct op_code_struct *) str_hash_find (opcode_hash_control, "imm"); if (opcode1 == NULL) { as_bad (_("unknown opcode \"%s\""), "imm"); diff -rup binutils.orig/gas/config/tc-mips.c binutils-2.35/gas/config/tc-mips.c --- binutils.orig/gas/config/tc-mips.c 2021-08-11 17:33:12.211490357 +0100 +++ binutils-2.35/gas/config/tc-mips.c 2021-08-11 17:39:31.410057520 +0100 @@ -675,13 +675,13 @@ static int g_switch_seen = 0; static int nopic_need_relax (symbolS *, int); /* Handle of the OPCODE hash table. */ -static struct hash_control *op_hash = NULL; +static htab_t op_hash = NULL; /* The opcode hash table we use for the mips16. */ -static struct hash_control *mips16_op_hash = NULL; +static htab_t mips16_op_hash = NULL; /* The opcode hash table we use for the microMIPS ASE. */ -static struct hash_control *micromips_op_hash = NULL; +static htab_t micromips_op_hash = NULL; /* This array holds the chars that always start a comment. If the pre-processor is disabled, these aren't very useful. */ @@ -3673,7 +3673,6 @@ validate_micromips_insn (const struct mi void md_begin (void) { - const char *retval = NULL; int i = 0; int broken = 0; @@ -3693,21 +3692,14 @@ md_begin (void) if (! bfd_set_arch_mach (stdoutput, bfd_arch_mips, file_mips_opts.arch)) as_warn (_("could not set architecture and machine")); - op_hash = hash_new (); + op_hash = str_htab_create (); mips_operands = XCNEWVEC (struct mips_operand_array, NUMOPCODES); for (i = 0; i < NUMOPCODES;) { const char *name = mips_opcodes[i].name; - retval = hash_insert (op_hash, name, (void *) &mips_opcodes[i]); - if (retval != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - mips_opcodes[i].name, retval); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("broken assembler, no assembly attempted")); - } + str_hash_insert (op_hash, name, (void *) &mips_opcodes[i]); do { if (!validate_mips_insn (&mips_opcodes[i], 0xffffffff, @@ -3730,7 +3722,7 @@ md_begin (void) while ((i < NUMOPCODES) && !strcmp (mips_opcodes[i].name, name)); } - mips16_op_hash = hash_new (); + mips16_op_hash = str_htab_create (); mips16_operands = XCNEWVEC (struct mips_operand_array, bfd_mips16_num_opcodes); @@ -3739,10 +3731,7 @@ md_begin (void) { const char *name = mips16_opcodes[i].name; - retval = hash_insert (mips16_op_hash, name, (void *) &mips16_opcodes[i]); - if (retval != NULL) - as_fatal (_("internal: can't hash `%s': %s"), - mips16_opcodes[i].name, retval); + str_hash_insert (mips16_op_hash, name, (void *) &mips16_opcodes[i]); do { if (!validate_mips16_insn (&mips16_opcodes[i], &mips16_operands[i])) @@ -3758,7 +3747,7 @@ md_begin (void) && strcmp (mips16_opcodes[i].name, name) == 0); } - micromips_op_hash = hash_new (); + micromips_op_hash = str_htab_create (); micromips_operands = XCNEWVEC (struct mips_operand_array, bfd_micromips_num_opcodes); @@ -3767,11 +3756,8 @@ md_begin (void) { const char *name = micromips_opcodes[i].name; - retval = hash_insert (micromips_op_hash, name, + str_hash_insert (micromips_op_hash, name, (void *) µmips_opcodes[i]); - if (retval != NULL) - as_fatal (_("internal: can't hash `%s': %s"), - micromips_opcodes[i].name, retval); do { struct mips_cl_insn *micromips_nop_insn; @@ -9027,7 +9013,7 @@ macro_build (expressionS *ep, const char bfd_reloc_code_real_type r[3]; const struct mips_opcode *amo; const struct mips_operand *operand; - struct hash_control *hash; + htab_t hash; struct mips_cl_insn insn; va_list args; unsigned int uval; @@ -9045,7 +9031,7 @@ macro_build (expressionS *ep, const char r[1] = BFD_RELOC_UNUSED; r[2] = BFD_RELOC_UNUSED; hash = mips_opts.micromips ? micromips_op_hash : op_hash; - amo = (struct mips_opcode *) hash_find (hash, name); + amo = (struct mips_opcode *) str_hash_find (hash, name); gas_assert (amo); gas_assert (strcmp (name, amo->name) == 0); @@ -9203,7 +9189,7 @@ mips16_macro_build (expressionS *ep, con bfd_reloc_code_real_type r[3] = {BFD_RELOC_UNUSED, BFD_RELOC_UNUSED, BFD_RELOC_UNUSED}; - mo = (struct mips_opcode *) hash_find (mips16_op_hash, name); + mo = (struct mips_opcode *) str_hash_find (mips16_op_hash, name); gas_assert (mo); gas_assert (strcmp (name, mo->name) == 0); @@ -14263,7 +14249,7 @@ mips16_macro (struct mips_cl_insn *ip) opcode bits in *OPCODE_EXTRA. */ static struct mips_opcode * -mips_lookup_insn (struct hash_control *hash, const char *start, +mips_lookup_insn (htab_t hash, const char *start, ssize_t length, unsigned int *opcode_extra) { char *name, *dot, *p; @@ -14275,7 +14261,7 @@ mips_lookup_insn (struct hash_control *h name = xstrndup (start, length); /* Look up the instruction as-is. */ - insn = (struct mips_opcode *) hash_find (hash, name); + insn = (struct mips_opcode *) str_hash_find (hash, name); if (insn) goto end; @@ -14287,7 +14273,7 @@ mips_lookup_insn (struct hash_control *h if (*p == 0 && mask != 0) { *dot = 0; - insn = (struct mips_opcode *) hash_find (hash, name); + insn = (struct mips_opcode *) str_hash_find (hash, name); *dot = '.'; if (insn && (insn->pinfo2 & INSN2_VU0_CHANNEL_SUFFIX) != 0) { @@ -14313,7 +14299,7 @@ mips_lookup_insn (struct hash_control *h if (suffix) { memmove (name + opend - 2, name + opend, length - opend + 1); - insn = (struct mips_opcode *) hash_find (hash, name); + insn = (struct mips_opcode *) str_hash_find (hash, name); if (insn) { forced_insn_length = suffix; @@ -14338,7 +14324,7 @@ static void mips_ip (char *str, struct mips_cl_insn *insn) { const struct mips_opcode *first, *past; - struct hash_control *hash; + htab_t hash; char format; size_t end; struct mips_operand_token *tokens; @@ -14434,7 +14420,7 @@ mips16_ip (char *str, struct mips_cl_ins forced_insn_length = l; *end = 0; - first = (struct mips_opcode *) hash_find (mips16_op_hash, str); + first = (struct mips_opcode *) str_hash_find (mips16_op_hash, str); *end = c; if (!first) Only in binutils-2.35/gas/config: tc-mips.c.orig diff -rup binutils.orig/gas/config/tc-mmix.c binutils-2.35/gas/config/tc-mmix.c --- binutils.orig/gas/config/tc-mmix.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-mmix.c 2021-08-11 17:39:31.410057520 +0100 @@ -217,7 +217,7 @@ struct option md_longopts[] = size_t md_longopts_size = sizeof (md_longopts); -static struct hash_control *mmix_opcode_hash; +static htab_t mmix_opcode_hash; /* We use these when implementing the PREFIX pseudo. */ char *mmix_current_prefix; @@ -769,13 +769,13 @@ mmix_md_begin (void) only way to make ':' part of a name, and a name beginner. */ lex_type[':'] = (LEX_NAME | LEX_BEGIN_NAME); - mmix_opcode_hash = hash_new (); + mmix_opcode_hash = str_htab_create (); real_reg_section = bfd_make_section_old_way (stdoutput, MMIX_REG_SECTION_NAME); for (opcode = mmix_opcodes; opcode->name; opcode++) - hash_insert (mmix_opcode_hash, opcode->name, (char *) opcode); + str_hash_insert (mmix_opcode_hash, opcode->name, (char *) opcode); /* We always insert the ordinary registers 0..255 as registers. */ for (i = 0; i < 256; i++) @@ -843,7 +843,7 @@ md_assemble (char *str) *operands++ = '\0'; } - instruction = (struct mmix_opcode *) hash_find (mmix_opcode_hash, str); + instruction = (struct mmix_opcode *) str_hash_find (mmix_opcode_hash, str); if (instruction == NULL) { as_bad (_("unknown opcode: `%s'"), str); diff -rup binutils.orig/gas/config/tc-mn10200.c binutils-2.35/gas/config/tc-mn10200.c --- binutils.orig/gas/config/tc-mn10200.c 2021-08-11 17:33:12.214490337 +0100 +++ binutils-2.35/gas/config/tc-mn10200.c 2021-08-11 17:39:31.410057520 +0100 @@ -101,7 +101,7 @@ const pseudo_typeS md_pseudo_table[] = }; /* Opcode hash table. */ -static struct hash_control *mn10200_hash; +static htab_t mn10200_hash; /* This table is sorted. Suitable for searching by a binary search. */ static const struct reg_name data_registers[] = @@ -685,7 +685,7 @@ md_begin (void) const char *prev_name = ""; const struct mn10200_opcode *op; - mn10200_hash = hash_new (); + mn10200_hash = str_htab_create (); /* Insert unique names into hash table. The MN10200 instruction set has many identical opcode names that have different opcodes based @@ -698,7 +698,7 @@ md_begin (void) if (strcmp (prev_name, op->name)) { prev_name = (char *) op->name; - hash_insert (mn10200_hash, op->name, (char *) op); + str_hash_insert (mn10200_hash, op->name, (char *) op); } op++; } @@ -890,7 +890,7 @@ md_assemble (char *str) *s++ = '\0'; /* Find the first opcode with the proper name. */ - opcode = (struct mn10200_opcode *) hash_find (mn10200_hash, str); + opcode = (struct mn10200_opcode *) str_hash_find (mn10200_hash, str); if (opcode == NULL) { as_bad (_("Unrecognized opcode: `%s'"), str); diff -rup binutils.orig/gas/config/tc-mn10300.c binutils-2.35/gas/config/tc-mn10300.c --- binutils.orig/gas/config/tc-mn10300.c 2021-08-11 17:33:12.208490376 +0100 +++ binutils-2.35/gas/config/tc-mn10300.c 2021-08-11 17:39:31.411057513 +0100 @@ -121,7 +121,7 @@ size_t md_longopts_size = sizeof (md_lon #define HAVE_AM30 (current_machine == AM30) /* Opcode hash table. */ -static struct hash_control *mn10300_hash; +static htab_t mn10300_hash; /* This table is sorted. Suitable for searching by a binary search. */ static const struct reg_name data_registers[] = @@ -911,7 +911,7 @@ md_begin (void) const char *prev_name = ""; const struct mn10300_opcode *op; - mn10300_hash = hash_new (); + mn10300_hash = str_htab_create (); /* Insert unique names into hash table. The MN10300 instruction set has many identical opcode names that have different opcodes based @@ -924,7 +924,7 @@ md_begin (void) if (strcmp (prev_name, op->name)) { prev_name = (char *) op->name; - hash_insert (mn10300_hash, op->name, (char *) op); + str_hash_insert (mn10300_hash, op->name, (char *) op); } op++; } @@ -1247,7 +1247,7 @@ md_assemble (char *str) *s++ = '\0'; /* Find the first opcode with the proper name. */ - opcode = (struct mn10300_opcode *) hash_find (mn10300_hash, str); + opcode = (struct mn10300_opcode *) str_hash_find (mn10300_hash, str); if (opcode == NULL) { as_bad (_("Unrecognized opcode: `%s'"), str); diff -rup binutils.orig/gas/config/tc-moxie.c binutils-2.35/gas/config/tc-moxie.c --- binutils.orig/gas/config/tc-moxie.c 2021-08-11 17:33:12.212490350 +0100 +++ binutils-2.35/gas/config/tc-moxie.c 2021-08-11 17:39:31.411057513 +0100 @@ -32,7 +32,7 @@ const char line_separator_chars[] = ";"; const char line_comment_chars[] = "#"; static int pending_reloc; -static struct hash_control *opcode_hash_control; +static htab_t opcode_hash_control; const pseudo_typeS md_pseudo_table[] = { @@ -62,17 +62,17 @@ md_begin (void) { int count; const moxie_opc_info_t *opcode; - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); /* Insert names into hash table. */ for (count = 0, opcode = moxie_form1_opc_info; count++ < 64; opcode++) - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->name, (char *) opcode); for (count = 0, opcode = moxie_form2_opc_info; count++ < 4; opcode++) - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->name, (char *) opcode); for (count = 0, opcode = moxie_form3_opc_info; count++ < 10; opcode++) - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->name, (char *) opcode); bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0); } @@ -178,7 +178,7 @@ md_assemble (char *str) if (nlen == 0) as_bad (_("can't find opcode ")); - opcode = (moxie_opc_info_t *) hash_find (opcode_hash_control, op_start); + opcode = (moxie_opc_info_t *) str_hash_find (opcode_hash_control, op_start); *op_end = pend; if (opcode == NULL) diff -rup binutils.orig/gas/config/tc-msp430.c binutils-2.35/gas/config/tc-msp430.c --- binutils.orig/gas/config/tc-msp430.c 2021-08-11 17:33:12.215490331 +0100 +++ binutils-2.35/gas/config/tc-msp430.c 2021-08-11 17:39:31.411057513 +0100 @@ -194,7 +194,7 @@ const char FLT_CHARS[] = "dD"; /* Handle long expressions. */ extern LITTLENUM_TYPE generic_bignum[]; -static struct hash_control *msp430_hash; +static htab_t msp430_hash; /* Relaxations. */ #define STATE_UNCOND_BRANCH 1 /* jump */ @@ -1834,10 +1834,11 @@ void md_begin (void) { struct msp430_opcode_s * opcode; - msp430_hash = hash_new (); + msp430_hash = str_htab_create (); for (opcode = msp430_opcodes; opcode->name; opcode++) - hash_insert (msp430_hash, opcode->name, (char *) opcode); + if (str_hash_find (msp430_hash, opcode->name) == NULL) + str_hash_insert (msp430_hash, opcode->name, (char *) opcode); bfd_set_arch_mach (stdoutput, TARGET_ARCH, target_is_430x () ? bfd_mach_msp430x : bfd_mach_msp11); @@ -2871,7 +2872,7 @@ msp430_operands (struct msp430_opcode_s char real_name[32]; sprintf (real_name, "%sa", old_name); - opcode = hash_find (msp430_hash, real_name); + opcode = str_hash_find (msp430_hash, real_name); if (opcode == NULL) { as_bad (_("instruction %s.a does not exist"), old_name); @@ -4355,7 +4356,7 @@ md_assemble (char * str) return; } - opcode = (struct msp430_opcode_s *) hash_find (msp430_hash, cmd); + opcode = (struct msp430_opcode_s *) str_hash_find (msp430_hash, cmd); if (opcode == NULL) { Only in binutils-2.35/gas/config: tc-msp430.c.orig diff -rup binutils.orig/gas/config/tc-nds32.c binutils-2.35/gas/config/tc-nds32.c --- binutils.orig/gas/config/tc-nds32.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-nds32.c 2021-08-11 17:39:31.411057513 +0100 @@ -82,8 +82,8 @@ static int vec_size = 0; ".flag verbatim" at beginning of the content. We have 'nds32_flag' to parse it and set this field to be non-zero. */ static int verbatim = 0; -static struct hash_control *nds32_gprs_hash; -static struct hash_control *nds32_hint_hash; +static htab_t nds32_gprs_hash; +static htab_t nds32_hint_hash; #define TLS_REG "$r27" #define GOT_NAME "_GLOBAL_OFFSET_TABLE_" @@ -109,7 +109,7 @@ enum ict_option { static enum ict_option ict_flag = ICT_NONE; -static struct hash_control *nds32_relax_info_hash; +static htab_t nds32_relax_info_hash; /* Branch patterns. */ static relax_info_t relax_table[] = @@ -2569,12 +2569,12 @@ struct nds32_pseudo_opcode }; #define PV_DONT_CARE 0 -static struct hash_control *nds32_pseudo_opcode_hash = NULL; +static htab_t nds32_pseudo_opcode_hash = NULL; static int builtin_isreg (const char *s, const char *x ATTRIBUTE_UNUSED) { - if (s [0] == '$' && hash_find (nds32_gprs_hash, (s + 1))) + if (s [0] == '$' && str_hash_find (nds32_gprs_hash, (s + 1))) return 1; return 0; } @@ -2586,7 +2586,7 @@ builtin_regnum (const char *s, const cha if (*s != '$') return -1; s++; - k = hash_find (nds32_gprs_hash, s); + k = str_hash_find (nds32_gprs_hash, s); if (k == NULL) return -1; @@ -3434,18 +3434,18 @@ nds32_init_nds32_pseudo_opcodes (void) { struct nds32_pseudo_opcode *opcode = nds32_pseudo_opcode_table; - nds32_pseudo_opcode_hash = hash_new (); + nds32_pseudo_opcode_hash = str_htab_create (); for ( ; opcode->opcode; opcode++) { void *op; - op = hash_find (nds32_pseudo_opcode_hash, opcode->opcode); + op = str_hash_find (nds32_pseudo_opcode_hash, opcode->opcode); if (op != NULL) { as_warn (_("Duplicated pseudo-opcode %s."), opcode->opcode); continue; } - hash_insert (nds32_pseudo_opcode_hash, opcode->opcode, opcode); + str_hash_insert (nds32_pseudo_opcode_hash, opcode->opcode, opcode); } } @@ -3466,7 +3466,7 @@ nds32_lookup_pseudo_opcode (const char * } op[i] = '\0'; - result = hash_find (nds32_pseudo_opcode_hash, op); + result = str_hash_find (nds32_pseudo_opcode_hash, op); free (op); return result; } @@ -4291,12 +4291,12 @@ nds32_relax_hint (int mode ATTRIBUTE_UNU /* Find relax hint entry for next instruction, and all member will be initialized at that time. */ - relocs = hash_find (nds32_hint_hash, name); + relocs = str_hash_find (nds32_hint_hash, name); if (relocs == NULL) { relocs = XNEW (struct nds32_relocs_pattern); memset (relocs, 0, sizeof (struct nds32_relocs_pattern)); - hash_insert (nds32_hint_hash, name, relocs); + str_hash_insert (nds32_hint_hash, name, relocs); } else { @@ -4623,17 +4623,17 @@ md_begin (void) nds32_asm_init (&asm_desc, flags); /* Initial general purpose registers hash table. */ - nds32_gprs_hash = hash_new (); + nds32_gprs_hash = str_htab_create (); for (k = keyword_gpr; k->name; k++) - hash_insert (nds32_gprs_hash, k->name, k); + str_hash_insert (nds32_gprs_hash, k->name, k); /* Initial branch hash table. */ - nds32_relax_info_hash = hash_new (); + nds32_relax_info_hash = str_htab_create (); for (relax_info = relax_table; relax_info->opcode; relax_info++) - hash_insert (nds32_relax_info_hash, relax_info->opcode, relax_info); + str_hash_insert (nds32_relax_info_hash, relax_info->opcode, relax_info); /* Initial relax hint hash table. */ - nds32_hint_hash = hash_new (); + nds32_hint_hash = str_htab_create (); enable_16bit = nds32_16bit_ext; } @@ -5813,7 +5813,7 @@ nds32_find_reloc_table (struct nds32_rel if (opc) { /* Branch relax pattern. */ - relax_info = hash_find (nds32_relax_info_hash, opc); + relax_info = str_hash_find (nds32_relax_info_hash, opc); if (!relax_info) return FALSE; fixup_info = relax_info->relax_fixup[range]; @@ -6272,6 +6272,15 @@ nds32_elf_append_relax_relocs (const cha frchain_now = frchain_bak; } +static int +nds32_elf_append_relax_relocs_traverse (void **slot, void *arg ATTRIBUTE_UNUSED) +{ + string_tuple_t *tuple = *((string_tuple_t **) slot); + nds32_elf_append_relax_relocs (tuple->key, tuple->value); + return 1; +} + + static void nds32_str_tolower (const char *src, char *dest) { @@ -6757,7 +6766,7 @@ nds32_relax_branch_instructions (segT se return 0; } - relax_info = hash_find (nds32_relax_info_hash, opcode->opcode); + relax_info = str_hash_find (nds32_relax_info_hash, opcode->opcode); if (relax_info == NULL) return adjust; @@ -7046,7 +7055,7 @@ md_convert_frag (bfd *abfd ATTRIBUTE_UNU if (fragP->tc_frag_data.flag & NDS32_FRAG_RELAXABLE_BRANCH) { - relax_info = hash_find (nds32_relax_info_hash, opcode->opcode); + relax_info = str_hash_find (nds32_relax_info_hash, opcode->opcode); if (relax_info == NULL) return; @@ -7106,7 +7115,7 @@ md_convert_frag (bfd *abfd ATTRIBUTE_UNU else if (fragP->tc_frag_data.flag & NDS32_FRAG_BRANCH) { /* Branch instruction adjust and append relocations. */ - relax_info = hash_find (nds32_relax_info_hash, opcode->opcode); + relax_info = str_hash_find (nds32_relax_info_hash, opcode->opcode); if (relax_info == NULL) return; @@ -7481,7 +7490,7 @@ nds32_insert_relax_entry (bfd *abfd ATTR static void nds32_elf_analysis_relax_hint (void) { - hash_traverse (nds32_hint_hash, nds32_elf_append_relax_relocs); + htab_traverse (nds32_hint_hash, nds32_elf_append_relax_relocs_traverse, NULL); } static void @@ -7966,7 +7975,7 @@ nds32_parse_name (char const *name, expr int tc_nds32_regname_to_dw2regnum (char *regname) { - struct nds32_keyword *sym = hash_find (nds32_gprs_hash, regname); + struct nds32_keyword *sym = str_hash_find (nds32_gprs_hash, regname); if (!sym) return -1; diff -rup binutils.orig/gas/config/tc-nios2.c binutils-2.35/gas/config/tc-nios2.c --- binutils.orig/gas/config/tc-nios2.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-nios2.c 2021-08-11 17:39:31.412057507 +0100 @@ -184,20 +184,20 @@ typedef struct nios2_ps_insn_info } nios2_ps_insn_infoS; /* Opcode hash table. */ -static struct hash_control *nios2_opcode_hash = NULL; +static htab_t nios2_opcode_hash = NULL; #define nios2_opcode_lookup(NAME) \ - ((struct nios2_opcode *) hash_find (nios2_opcode_hash, (NAME))) + ((struct nios2_opcode *) str_hash_find (nios2_opcode_hash, (NAME))) /* Register hash table. */ -static struct hash_control *nios2_reg_hash = NULL; +static htab_t nios2_reg_hash = NULL; #define nios2_reg_lookup(NAME) \ - ((struct nios2_reg *) hash_find (nios2_reg_hash, (NAME))) + ((struct nios2_reg *) str_hash_find (nios2_reg_hash, (NAME))) /* Pseudo-op hash table. */ -static struct hash_control *nios2_ps_hash = NULL; +static htab_t nios2_ps_hash = NULL; #define nios2_ps_lookup(NAME) \ - ((nios2_ps_insn_infoS *) hash_find (nios2_ps_hash, (NAME))) + ((nios2_ps_insn_infoS *) str_hash_find (nios2_ps_hash, (NAME))) /* The known current alignment of the current section. */ static int nios2_current_align; @@ -3603,7 +3603,6 @@ void md_begin (void) { int i; - const char *inserted; switch (nios2_architecture) { @@ -3620,52 +3619,21 @@ md_begin (void) /* Create and fill a hashtable for the Nios II opcodes, registers and arguments. */ - nios2_opcode_hash = hash_new (); - nios2_reg_hash = hash_new (); - nios2_ps_hash = hash_new (); + nios2_opcode_hash = str_htab_create (); + nios2_reg_hash = str_htab_create (); + nios2_ps_hash = str_htab_create (); for (i = 0; i < nios2_num_opcodes; ++i) - { - inserted - = hash_insert (nios2_opcode_hash, nios2_opcodes[i].name, - (PTR) & nios2_opcodes[i]); - if (inserted != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - nios2_opcodes[i].name, inserted); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - } - } + str_hash_insert (nios2_opcode_hash, nios2_opcodes[i].name, + (PTR) & nios2_opcodes[i]); for (i = 0; i < nios2_num_regs; ++i) - { - inserted - = hash_insert (nios2_reg_hash, nios2_regs[i].name, - (PTR) & nios2_regs[i]); - if (inserted != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - nios2_regs[i].name, inserted); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - } - - } + str_hash_insert (nios2_reg_hash, nios2_regs[i].name, + (PTR) & nios2_regs[i]); for (i = 0; i < nios2_num_ps_insn_info_structs; ++i) - { - inserted - = hash_insert (nios2_ps_hash, nios2_ps_insn_info_structs[i].pseudo_insn, - (PTR) & nios2_ps_insn_info_structs[i]); - if (inserted != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - nios2_ps_insn_info_structs[i].pseudo_insn, inserted); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - } - } + str_hash_insert (nios2_ps_hash, nios2_ps_insn_info_structs[i].pseudo_insn, + (PTR) & nios2_ps_insn_info_structs[i]); /* Assembler option defaults. */ nios2_as_options.noat = FALSE; diff -rup binutils.orig/gas/config/tc-ns32k.c binutils-2.35/gas/config/tc-ns32k.c --- binutils.orig/gas/config/tc-ns32k.c 2021-08-11 17:33:12.208490376 +0100 +++ binutils-2.35/gas/config/tc-ns32k.c 2021-08-11 17:39:31.412057507 +0100 @@ -84,7 +84,7 @@ struct addr_mode typedef struct addr_mode addr_modeS; char *freeptr, *freeptr_static; /* Points at some number of free bytes. */ -struct hash_control *inst_hash_handle; +htab_t inst_hash_handle; struct ns32k_opcode *desc; /* Pointer at description of instruction. */ addr_modeS addr_modeP; @@ -1103,7 +1103,7 @@ parse (const char *line, int recursive_l c = *lineptr; *(char *) lineptr = '\0'; - if (!(desc = (struct ns32k_opcode *) hash_find (inst_hash_handle, line))) + if (!(desc = (struct ns32k_opcode *) str_hash_find (inst_hash_handle, line))) as_fatal (_("No such opcode")); *(char *) lineptr = c; @@ -1895,18 +1895,13 @@ md_begin (void) { /* Build a hashtable of the instructions. */ const struct ns32k_opcode *ptr; - const char *status; const struct ns32k_opcode *endop; - inst_hash_handle = hash_new (); + inst_hash_handle = str_htab_create (); endop = ns32k_opcodes + sizeof (ns32k_opcodes) / sizeof (ns32k_opcodes[0]); for (ptr = ns32k_opcodes; ptr < endop; ptr++) - { - if ((status = hash_insert (inst_hash_handle, ptr->name, (char *) ptr))) - /* Fatal. */ - as_fatal (_("Can't hash %s: %s"), ptr->name, status); - } + str_hash_insert (inst_hash_handle, ptr->name, (char *) ptr); /* Some private space please! */ freeptr_static = XNEWVEC (char, PRIVATE_SIZE); diff -rup binutils.orig/gas/config/tc-pdp11.c binutils-2.35/gas/config/tc-pdp11.c --- binutils.orig/gas/config/tc-pdp11.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-pdp11.c 2021-08-11 17:39:31.412057507 +0100 @@ -82,7 +82,7 @@ const pseudo_typeS md_pseudo_table[] = { 0, 0, 0 }, }; -static struct hash_control *insn_hash = NULL; +static htab_t insn_hash = NULL; static int set_option (const char *arg) @@ -188,14 +188,14 @@ md_begin (void) init_defaults (); - insn_hash = hash_new (); + insn_hash = str_htab_create (); if (insn_hash == NULL) as_fatal (_("Virtual memory exhausted")); for (i = 0; i < pdp11_num_opcodes; i++) - hash_insert (insn_hash, pdp11_opcodes[i].name, (void *) (pdp11_opcodes + i)); + str_hash_insert (insn_hash, pdp11_opcodes[i].name, (void *) (pdp11_opcodes + i)); for (i = 0; i < pdp11_num_aliases; i++) - hash_insert (insn_hash, pdp11_aliases[i].name, (void *) (pdp11_aliases + i)); + str_hash_insert (insn_hash, pdp11_aliases[i].name, (void *) (pdp11_aliases + i)); } void @@ -713,7 +713,7 @@ md_assemble (char *instruction_string) c = *p; *p = '\0'; - op = (struct pdp11_opcode *)hash_find (insn_hash, str); + op = (struct pdp11_opcode *)str_hash_find (insn_hash, str); *p = c; if (op == 0) { diff -rup binutils.orig/gas/config/tc-pj.c binutils-2.35/gas/config/tc-pj.c --- binutils.orig/gas/config/tc-pj.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-pj.c 2021-08-11 17:39:31.412057507 +0100 @@ -31,7 +31,7 @@ const char line_separator_chars[] = ";"; const char line_comment_chars[] = "/!#"; static int pending_reloc; -static struct hash_control *opcode_hash_control; +static htab_t opcode_hash_control; static void little (int ignore ATTRIBUTE_UNUSED) @@ -176,7 +176,7 @@ fake_opcode (const char *name, fake->opcode = -1; fake->opcode_next = -1; fake->u.func = func; - hash_insert (opcode_hash_control, name, (char *) fake); + str_hash_insert (opcode_hash_control, name, (char *) fake); } /* Enter another entry into the opcode hash table so the same opcode @@ -185,8 +185,8 @@ fake_opcode (const char *name, static void alias (const char *new_name, const char *old) { - hash_insert (opcode_hash_control, new_name, - (char *) hash_find (opcode_hash_control, old)); + str_hash_insert (opcode_hash_control, new_name, + (char *) str_hash_find (opcode_hash_control, old)); } /* This function is called once, at assembler startup time. It sets @@ -197,11 +197,11 @@ void md_begin (void) { const pj_opc_info_t *opcode; - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); /* Insert names into hash table. */ for (opcode = pj_opc_info; opcode->u.name; opcode++) - hash_insert (opcode_hash_control, opcode->u.name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->u.name, (char *) opcode); /* Insert the only fake opcode. */ fake_opcode ("ipush", ipush_code); @@ -252,7 +252,7 @@ md_assemble (char *str) if (nlen == 0) as_bad (_("can't find opcode ")); - opcode = (pj_opc_info_t *) hash_find (opcode_hash_control, op_start); + opcode = (pj_opc_info_t *) str_hash_find (opcode_hash_control, op_start); *op_end = pend; if (opcode == NULL) diff -rup binutils.orig/gas/config/tc-ppc.c binutils-2.35/gas/config/tc-ppc.c --- binutils.orig/gas/config/tc-ppc.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-ppc.c 2021-08-11 17:39:31.413057500 +0100 @@ -1004,10 +1004,10 @@ ppc_optimize_expr (expressionS *left, op static unsigned int ppc_obj64 = BFD_DEFAULT_TARGET_SIZE == 64; /* Opcode hash table. */ -static struct hash_control *ppc_hash; +static htab_t ppc_hash; /* Macro hash table. */ -static struct hash_control *ppc_macro_hash; +static htab_t ppc_macro_hash; #ifdef OBJ_ELF /* What type of shared library support to use. */ @@ -1656,12 +1656,12 @@ ppc_setup_opcodes (void) bfd_boolean bad_insn = FALSE; if (ppc_hash != NULL) - hash_die (ppc_hash); + htab_delete (ppc_hash); if (ppc_macro_hash != NULL) - hash_die (ppc_macro_hash); + htab_delete (ppc_macro_hash); /* Insert the opcodes into a hash table. */ - ppc_hash = hash_new (); + ppc_hash = str_htab_create (); if (ENABLE_CHECKING) { @@ -1738,22 +1738,12 @@ ppc_setup_opcodes (void) if ((ppc_cpu & op->flags) != 0 && !(ppc_cpu & op->deprecated)) - { - const char *retval; - - retval = hash_insert (ppc_hash, op->name, (void *) op); - if (retval != NULL) - { - as_bad (_("duplicate instruction %s"), - op->name); - bad_insn = TRUE; - } - } + str_hash_insert (ppc_hash, op->name, (void *) op); } if ((ppc_cpu & PPC_OPCODE_ANY) != 0) for (op = powerpc_opcodes; op < op_end; op++) - hash_insert (ppc_hash, op->name, (void *) op); + str_hash_insert (ppc_hash, op->name, (void *) op); op_end = prefix_opcodes + prefix_num_opcodes; for (op = prefix_opcodes; op < op_end; op++) @@ -1782,22 +1772,12 @@ ppc_setup_opcodes (void) if ((ppc_cpu & op->flags) != 0 && !(ppc_cpu & op->deprecated)) - { - const char *retval; - - retval = hash_insert (ppc_hash, op->name, (void *) op); - if (retval != NULL) - { - as_bad (_("duplicate instruction %s"), - op->name); - bad_insn = TRUE; - } - } + str_hash_insert (ppc_hash, op->name, (void *) op); } if ((ppc_cpu & PPC_OPCODE_ANY) != 0) for (op = prefix_opcodes; op < op_end; op++) - hash_insert (ppc_hash, op->name, (void *) op); + str_hash_insert (ppc_hash, op->name, (void *) op); op_end = vle_opcodes + vle_num_opcodes; for (op = vle_opcodes; op < op_end; op++) @@ -1827,17 +1807,7 @@ ppc_setup_opcodes (void) if ((ppc_cpu & op->flags) != 0 && !(ppc_cpu & op->deprecated)) - { - const char *retval; - - retval = hash_insert (ppc_hash, op->name, (void *) op); - if (retval != NULL) - { - as_bad (_("duplicate instruction %s"), - op->name); - bad_insn = TRUE; - } - } + str_hash_insert (ppc_hash, op->name, (void *) op); } /* SPE2 instructions */ @@ -1871,40 +1841,21 @@ ppc_setup_opcodes (void) } if ((ppc_cpu & op->flags) != 0 && !(ppc_cpu & op->deprecated)) - { - const char *retval; - - retval = hash_insert (ppc_hash, op->name, (void *) op); - if (retval != NULL) - { - as_bad (_("duplicate instruction %s"), - op->name); - bad_insn = TRUE; - } - } + str_hash_insert (ppc_hash, op->name, (void *) op); } for (op = spe2_opcodes; op < op_end; op++) - hash_insert (ppc_hash, op->name, (void *) op); + str_hash_insert (ppc_hash, op->name, (void *) op); } /* Insert the macros into a hash table. */ - ppc_macro_hash = hash_new (); + ppc_macro_hash = str_htab_create (); macro_end = powerpc_macros + powerpc_num_macros; for (macro = powerpc_macros; macro < macro_end; macro++) { if ((macro->flags & ppc_cpu) != 0 || (ppc_cpu & PPC_OPCODE_ANY) != 0) - { - const char *retval; - - retval = hash_insert (ppc_macro_hash, macro->name, (void *) macro); - if (retval != (const char *) NULL) - { - as_bad (_("duplicate macro %s"), macro->name); - bad_insn = TRUE; - } - } + str_hash_insert (ppc_macro_hash, macro->name, (void *) macro); } if (bad_insn) @@ -3319,12 +3270,12 @@ md_assemble (char *str) *s++ = '\0'; /* Look up the opcode in the hash table. */ - opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str); + opcode = (const struct powerpc_opcode *) str_hash_find (ppc_hash, str); if (opcode == (const struct powerpc_opcode *) NULL) { const struct powerpc_macro *macro; - macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str); + macro = (const struct powerpc_macro *) str_hash_find (ppc_macro_hash, str); if (macro == (const struct powerpc_macro *) NULL) as_bad (_("unrecognized opcode: `%s'"), str); else Only in binutils-2.35/gas/config: tc-ppc.c.orig diff -rup binutils.orig/gas/config/tc-pru.c binutils-2.35/gas/config/tc-pru.c --- binutils.orig/gas/config/tc-pru.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-pru.c 2021-08-11 17:39:31.413057500 +0100 @@ -132,14 +132,14 @@ typedef struct pru_insn_info } pru_insn_infoS; /* Opcode hash table. */ -static struct hash_control *pru_opcode_hash = NULL; +static htab_t pru_opcode_hash = NULL; #define pru_opcode_lookup(NAME) \ - ((struct pru_opcode *) hash_find (pru_opcode_hash, (NAME))) + ((struct pru_opcode *) str_hash_find (pru_opcode_hash, (NAME))) /* Register hash table. */ -static struct hash_control *pru_reg_hash = NULL; +static htab_t pru_reg_hash = NULL; #define pru_reg_lookup(NAME) \ - ((struct pru_reg *) hash_find (pru_reg_hash, (NAME))) + ((struct pru_reg *) str_hash_find (pru_reg_hash, (NAME))) /* The known current alignment of the current section. */ static int pru_current_align; @@ -1557,41 +1557,19 @@ void md_begin (void) { int i; - const char *inserted; /* Create and fill a hashtable for the PRU opcodes, registers and arguments. */ - pru_opcode_hash = hash_new (); - pru_reg_hash = hash_new (); + pru_opcode_hash = str_htab_create (); + pru_reg_hash = str_htab_create (); for (i = 0; i < NUMOPCODES; ++i) - { - inserted - = hash_insert (pru_opcode_hash, pru_opcodes[i].name, - (PTR) & pru_opcodes[i]); - if (inserted != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - pru_opcodes[i].name, inserted); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - } - } + str_hash_insert (pru_opcode_hash, pru_opcodes[i].name, + (PTR) & pru_opcodes[i]); for (i = 0; i < pru_num_regs; ++i) - { - inserted - = hash_insert (pru_reg_hash, pru_regs[i].name, - (PTR) & pru_regs[i]); - if (inserted != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - pru_regs[i].name, inserted); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - } - - } + str_hash_insert (pru_reg_hash, pru_regs[i].name, + (PTR) & pru_regs[i]); linkrelax = pru_opt.link_relax; /* Initialize the alignment data. */ @@ -1811,8 +1789,8 @@ md_pcrel_from (fixS *fixP ATTRIBUTE_UNUS void md_end (void) { - hash_die (pru_opcode_hash); - hash_die (pru_reg_hash); + htab_delete (pru_opcode_hash); + htab_delete (pru_reg_hash); } symbolS * diff -rup binutils.orig/gas/config/tc-riscv.c binutils-2.35/gas/config/tc-riscv.c --- binutils.orig/gas/config/tc-riscv.c 2021-08-11 17:33:12.214490337 +0100 +++ binutils-2.35/gas/config/tc-riscv.c 2021-08-11 17:39:31.413057500 +0100 @@ -242,28 +242,18 @@ riscv_multi_subset_supports (enum riscv_ } /* Handle of the extension with version hash table. */ -static struct hash_control *ext_version_hash = NULL; +static htab_t ext_version_hash = NULL; -static struct hash_control * +static htab_t init_ext_version_hash (const struct riscv_ext_version *table) { int i = 0; - struct hash_control *hash = hash_new (); + htab_t hash = str_htab_create (); while (table[i].name) { const char *name = table[i].name; - const char *hash_error = - hash_insert (hash, name, (void *) &table[i]); - - if (hash_error != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - table[i].name, hash_error); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - return NULL; - } + str_hash_insert (hash, name, (void *) &table[i]); i++; while (table[i].name @@ -287,7 +277,7 @@ riscv_get_default_ext_version (const cha if (name == NULL || default_isa_spec == ISA_SPEC_CLASS_NONE) return; - ext = (struct riscv_ext_version *) hash_find (ext_version_hash, name); + ext = (struct riscv_ext_version *) str_hash_find (ext_version_hash, name); while (ext && ext->name && strcmp (ext->name, name) == 0) @@ -321,10 +311,10 @@ riscv_set_arch (const char *s) } /* Handle of the OPCODE hash table. */ -static struct hash_control *op_hash = NULL; +static htab_t op_hash = NULL; /* Handle of the type of .insn hash table. */ -static struct hash_control *insn_type_hash = NULL; +static htab_t insn_type_hash = NULL; /* This array holds the chars that always start a comment. If the pre-processor is disabled, these aren't very useful */ @@ -559,23 +549,16 @@ static const struct opcode_name_t opcode }; /* Hash table for lookup opcode name. */ -static struct hash_control *opcode_names_hash = NULL; +static htab_t opcode_names_hash = NULL; /* Initialization for hash table of opcode name. */ static void init_opcode_names_hash (void) { - const char *retval; const struct opcode_name_t *opcode; for (opcode = &opcode_name_list[0]; opcode->name != NULL; ++opcode) - { - retval = hash_insert (opcode_names_hash, opcode->name, (void *)opcode); - - if (retval != NULL) - as_fatal (_("internal error: can't hash `%s': %s"), - opcode->name, retval); - } + str_hash_insert (opcode_names_hash, opcode->name, (void *)opcode); } /* Find `s` is a valid opcode name or not, @@ -598,7 +581,7 @@ opcode_name_lookup (char **s) save_c = *e; *e = '\0'; - o = (struct opcode_name_t *) hash_find (opcode_names_hash, *s); + o = (struct opcode_name_t *) str_hash_find (opcode_names_hash, *s); /* Advance to next token if one was recognized. */ if (o) @@ -619,8 +602,8 @@ enum reg_class RCLASS_CSR }; -static struct hash_control *reg_names_hash = NULL; -static struct hash_control *csr_extra_hash = NULL; +static htab_t reg_names_hash = NULL; +static htab_t csr_extra_hash = NULL; #define ENCODE_REG_HASH(cls, n) \ ((void *)(uintptr_t)((n) * RCLASS_MAX + (cls) + 1)) @@ -631,10 +614,7 @@ static void hash_reg_name (enum reg_class class, const char *name, unsigned n) { void *hash = ENCODE_REG_HASH (class, n); - const char *retval = hash_insert (reg_names_hash, name, hash); - - if (retval != NULL) - as_fatal (_("internal error: can't hash `%s': %s"), name, retval); + str_hash_insert (reg_names_hash, name, hash); } static void @@ -655,11 +635,10 @@ riscv_init_csr_hash (const char *name, enum riscv_priv_spec_class abort_version) { struct riscv_csr_extra *entry, *pre_entry; - const char *hash_error = NULL; bfd_boolean need_enrty = TRUE; pre_entry = NULL; - entry = (struct riscv_csr_extra *) hash_find (csr_extra_hash, name); + entry = (struct riscv_csr_extra *) str_hash_find (csr_extra_hash, name); while (need_enrty && entry != NULL) { if (entry->csr_class == class @@ -686,16 +665,7 @@ riscv_init_csr_hash (const char *name, Otherwise, attach the extra information to the entry which is already in the hash table. */ if (pre_entry == NULL) - { - hash_error = hash_insert (csr_extra_hash, name, (void *) entry); - if (hash_error != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - name, hash_error); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - } - } + str_hash_insert (csr_extra_hash, name, (void *) entry); else pre_entry->next = entry; } @@ -772,7 +742,7 @@ static unsigned int reg_csr_lookup_internal (const char *s) { struct riscv_csr_extra *r = - (struct riscv_csr_extra *) hash_find (csr_extra_hash, s); + (struct riscv_csr_extra *) str_hash_find (csr_extra_hash, s); if (r == NULL) return -1U; @@ -794,7 +764,7 @@ reg_lookup_internal (const char *s, enum if (class == RCLASS_CSR) return reg_csr_lookup_internal (s); - r = hash_find (reg_names_hash, s); + r = str_hash_find (reg_names_hash, s); if (r == NULL || DECODE_REG_CLASS (r) != class) return -1; @@ -1018,26 +988,17 @@ struct percent_op_match /* Common hash table initialization function for instruction and .insn directive. */ -static struct hash_control * +static htab_t init_opcode_hash (const struct riscv_opcode *opcodes, bfd_boolean insn_directive_p) { int i = 0; int length; - struct hash_control *hash = hash_new (); + htab_t hash = str_htab_create (); while (opcodes[i].name) { const char *name = opcodes[i].name; - const char *hash_error = - hash_insert (hash, name, (void *) &opcodes[i]); - - if (hash_error != NULL) - { - fprintf (stderr, _("internal error: can't hash `%s': %s\n"), - opcodes[i].name, hash_error); - /* Probably a memory allocation problem? Give up now. */ - as_fatal (_("Broken assembler. No assembly attempted.")); - } + str_hash_insert (hash, name, (void *) &opcodes[i]); do { @@ -1074,7 +1035,7 @@ md_begin (void) op_hash = init_opcode_hash (riscv_opcodes, FALSE); insn_type_hash = init_opcode_hash (riscv_insn_types, TRUE); - reg_names_hash = hash_new (); + reg_names_hash = str_htab_create (); hash_reg_names (RCLASS_GPR, riscv_gpr_names_numeric, NGPR); hash_reg_names (RCLASS_GPR, riscv_gpr_names_abi, NGPR); hash_reg_names (RCLASS_FPR, riscv_fpr_names_numeric, NFPR); @@ -1083,7 +1044,7 @@ md_begin (void) hash_reg_name (RCLASS_GPR, "fp", 8); /* Create and insert CSR hash tables. */ - csr_extra_hash = hash_new (); + csr_extra_hash = str_htab_create (); #define DECLARE_CSR(name, num, class, define_version, abort_version) \ riscv_init_csr_hash (#name, num, class, define_version, abort_version); #define DECLARE_CSR_ALIAS(name, num, class, define_version, abort_version) \ @@ -1091,7 +1052,7 @@ md_begin (void) #include "opcode/riscv-opc.h" #undef DECLARE_CSR - opcode_names_hash = hash_new (); + opcode_names_hash = str_htab_create (); init_opcode_names_hash (); /* Set the default alignment for the text section. */ @@ -1196,7 +1157,7 @@ macro_build (expressionS *ep, const char va_start (args, fmt); r = BFD_RELOC_UNUSED; - mo = (struct riscv_opcode *) hash_find (op_hash, name); + mo = (struct riscv_opcode *) str_hash_find (op_hash, name); gas_assert (mo); /* Find a non-RVC variant of the instruction. append_insn will compress @@ -1796,7 +1757,7 @@ riscv_is_priv_insn (insn_t insn) static const char * riscv_ip (char *str, struct riscv_cl_insn *ip, expressionS *imm_expr, - bfd_reloc_code_real_type *imm_reloc, struct hash_control *hash) + bfd_reloc_code_real_type *imm_reloc, htab_t hash) { char *s; const char *args; @@ -1812,7 +1773,7 @@ riscv_ip (char *str, struct riscv_cl_ins bfd_boolean insn_with_csr = FALSE; /* Parse the name of the instruction. Terminate the string if whitespace - is found so that hash_find only sees the name part of the string. */ + is found so that str_hash_find only sees the name part of the string. */ for (s = str; *s != '\0'; ++s) if (ISSPACE (*s)) { @@ -1821,7 +1782,7 @@ riscv_ip (char *str, struct riscv_cl_ins break; } - insn = (struct riscv_opcode *) hash_find (hash, str); + insn = (struct riscv_opcode *) str_hash_find (hash, str); argsStart = s; for ( ; insn && insn->name && strcmp (insn->name, str) == 0; insn++) diff -rup binutils.orig/gas/config/tc-s390.c binutils-2.35/gas/config/tc-s390.c --- binutils.orig/gas/config/tc-s390.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-s390.c 2021-08-11 17:39:31.413057500 +0100 @@ -197,10 +197,10 @@ register_name (expressionS *expressionP) /* Local variables. */ /* Opformat hash table. */ -static struct hash_control *s390_opformat_hash; +static htab_t s390_opformat_hash; /* Opcode hash table. */ -static struct hash_control *s390_opcode_hash = NULL; +static htab_t s390_opcode_hash = NULL; /* Flags to set in the elf header */ static flagword s390_flags = 0; @@ -494,13 +494,12 @@ s390_setup_opcodes (void) const struct s390_opcode *op; const struct s390_opcode *op_end; bfd_boolean dup_insn = FALSE; - const char *retval; if (s390_opcode_hash != NULL) - hash_die (s390_opcode_hash); + htab_delete (s390_opcode_hash); /* Insert the opcodes into a hash table. */ - s390_opcode_hash = hash_new (); + s390_opcode_hash = str_htab_create (); op_end = s390_opcodes + s390_num_opcodes; for (op = s390_opcodes; op < op_end; op++) @@ -532,15 +531,7 @@ s390_setup_opcodes (void) use_opcode = ((f & current_flags) == f); } if (use_opcode) - { - retval = hash_insert (s390_opcode_hash, op->name, (void *) op); - if (retval != (const char *) NULL) - { - as_bad (_("Internal assembler error for instruction %s"), - op->name); - dup_insn = TRUE; - } - } + str_hash_insert (s390_opcode_hash, op->name, (void *) op); while (op < op_end - 1 && strcmp (op->name, op[1].name) == 0) op++; @@ -559,7 +550,6 @@ md_begin (void) { const struct s390_opcode *op; const struct s390_opcode *op_end; - const char *retval; /* Give a warning if the combination -m64-bit and -Aesa is used. */ if (s390_arch_size == 64 && current_cpu < S390_OPCODE_Z900) @@ -572,16 +562,11 @@ md_begin (void) bfd_set_private_flags (stdoutput, s390_flags); /* Insert the opcode formats into a hash table. */ - s390_opformat_hash = hash_new (); + s390_opformat_hash = str_htab_create (); op_end = s390_opformats + s390_num_opformats; for (op = s390_opformats; op < op_end; op++) - { - retval = hash_insert (s390_opformat_hash, op->name, (void *) op); - if (retval != (const char *) NULL) - as_bad (_("Internal assembler error for instruction format %s"), - op->name); - } + str_hash_insert (s390_opformat_hash, op->name, (void *) op); s390_setup_opcodes (); @@ -1693,7 +1678,7 @@ md_assemble (char *str) *s++ = '\0'; /* Look up the opcode in the hash table. */ - opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str); + opcode = (struct s390_opcode *) str_hash_find (s390_opcode_hash, str); if (opcode == (const struct s390_opcode *) NULL) { as_bad (_("Unrecognized opcode: `%s'"), str); @@ -1761,7 +1746,7 @@ s390_insn (int ignore ATTRIBUTE_UNUSED) /* Look up the opcode in the hash table. */ opformat = (struct s390_opcode *) - hash_find (s390_opformat_hash, input_line_pointer); + str_hash_find (s390_opformat_hash, input_line_pointer); if (opformat == (const struct s390_opcode *) NULL) { as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer); diff -rup binutils.orig/gas/config/tc-score.c binutils-2.35/gas/config/tc-score.c --- binutils.orig/gas/config/tc-score.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-score.c 2021-08-11 17:39:31.414057494 +0100 @@ -459,7 +459,7 @@ struct s3_reg_map { const struct s3_reg_entry *names; int max_regno; - struct hash_control *htab; + htab_t htab; const char *expected; }; @@ -470,8 +470,8 @@ static struct s3_reg_map s3_all_reg_maps {s3_score_crn_table, 31, NULL, N_("S+core co-processor register expected")}, }; -static struct hash_control *s3_score_ops_hsh = NULL; -static struct hash_control *s3_dependency_insn_hsh = NULL; +static htab_t s3_score_ops_hsh = NULL; +static htab_t s3_dependency_insn_hsh = NULL; struct s3_datafield_range @@ -1027,7 +1027,7 @@ s3_end_of_line (char *str) } static int -s3_score_reg_parse (char **ccp, struct hash_control *htab) +s3_score_reg_parse (char **ccp, htab_t htab) { char *start = *ccp; char c; @@ -1044,7 +1044,7 @@ s3_score_reg_parse (char **ccp, struct h c = *p++; *--p = 0; - reg = (struct s3_reg_entry *) hash_find (htab, start); + reg = (struct s3_reg_entry *) str_hash_find (htab, start); *p = c; if (reg) @@ -2203,7 +2203,7 @@ s3_dependency_type_from_insn (char *insn const struct s3_insn_to_dependency *tmp; strcpy (name, insn_name); - tmp = (const struct s3_insn_to_dependency *) hash_find (s3_dependency_insn_hsh, name); + tmp = (const struct s3_insn_to_dependency *) str_hash_find (s3_dependency_insn_hsh, name); if (tmp) return tmp->type; @@ -2662,7 +2662,7 @@ s3_parse_16_32_inst (char *insnstr, bfd_ c = *p; *p = '\0'; - opcode = (const struct s3_asm_opcode *) hash_find (s3_score_ops_hsh, operator); + opcode = (const struct s3_asm_opcode *) str_hash_find (s3_score_ops_hsh, operator); *p = c; memset (&s3_inst, '\0', sizeof (s3_inst)); @@ -2708,7 +2708,7 @@ s3_parse_48_inst (char *insnstr, bfd_boo c = *p; *p = '\0'; - opcode = (const struct s3_asm_opcode *) hash_find (s3_score_ops_hsh, operator); + opcode = (const struct s3_asm_opcode *) str_hash_find (s3_score_ops_hsh, operator); *p = c; memset (&s3_inst, '\0', sizeof (s3_inst)); @@ -6251,7 +6251,7 @@ s3_s_score_lcomm (int bytes_p) } static void -s3_insert_reg (const struct s3_reg_entry *r, struct hash_control *htab) +s3_insert_reg (const struct s3_reg_entry *r, htab_t htab) { int i = 0; int len = strlen (r->name) + 2; @@ -6265,8 +6265,8 @@ s3_insert_reg (const struct s3_reg_entry } buf2[i] = '\0'; - hash_insert (htab, buf, (void *) r); - hash_insert (htab, buf2, (void *) r); + str_hash_insert (htab, buf, (void *) r); + str_hash_insert (htab, buf2, (void *) r); } static void @@ -6274,7 +6274,7 @@ s3_build_reg_hsh (struct s3_reg_map *map { const struct s3_reg_entry *r; - if ((map->htab = hash_new ()) == NULL) + if ((map->htab = str_htab_create ()) == NULL) { as_fatal (_("virtual memory exhausted")); } @@ -6309,7 +6309,7 @@ s3_build_score_ops_hsh (void) new_opcode->relax_value = insn->relax_value; new_opcode->type = insn->type; new_opcode->bitmask = insn->bitmask; - hash_insert (s3_score_ops_hsh, new_opcode->template_name, + str_hash_insert (s3_score_ops_hsh, new_opcode->template_name, (void *) new_opcode); } } @@ -6336,7 +6336,7 @@ s3_build_dependency_insn_hsh (void) strcpy (buf, tmp->insn_name); new_i2n->insn_name = buf; new_i2n->type = tmp->type; - hash_insert (s3_dependency_insn_hsh, new_i2n->insn_name, + str_hash_insert (s3_dependency_insn_hsh, new_i2n->insn_name, (void *) new_i2n); } } @@ -6505,12 +6505,12 @@ s3_begin (void) segT seg; subsegT subseg; - if ((s3_score_ops_hsh = hash_new ()) == NULL) + if ((s3_score_ops_hsh = str_htab_create ()) == NULL) as_fatal (_("virtual memory exhausted")); s3_build_score_ops_hsh (); - if ((s3_dependency_insn_hsh = hash_new ()) == NULL) + if ((s3_dependency_insn_hsh = str_htab_create ()) == NULL) as_fatal (_("virtual memory exhausted")); s3_build_dependency_insn_hsh (); diff -rup binutils.orig/gas/config/tc-score7.c binutils-2.35/gas/config/tc-score7.c --- binutils.orig/gas/config/tc-score7.c 2021-08-11 17:33:12.208490376 +0100 +++ binutils-2.35/gas/config/tc-score7.c 2021-08-11 17:39:31.414057494 +0100 @@ -520,7 +520,7 @@ struct s7_reg_map { const struct s7_reg_entry *names; int max_regno; - struct hash_control *htab; + htab_t htab; const char *expected; }; @@ -531,8 +531,8 @@ static struct s7_reg_map s7_all_reg_maps {s7_score_crn_table, 31, NULL, N_("S+core co-processor register expected")}, }; -static struct hash_control *s7_score_ops_hsh = NULL; -static struct hash_control *s7_dependency_insn_hsh = NULL; +static htab_t s7_score_ops_hsh = NULL; +static htab_t s7_dependency_insn_hsh = NULL; struct s7_datafield_range @@ -1112,7 +1112,7 @@ s7_end_of_line (char *str) } static int -s7_score_reg_parse (char **ccp, struct hash_control *htab) +s7_score_reg_parse (char **ccp, htab_t htab) { char *start = *ccp; char c; @@ -1129,7 +1129,7 @@ s7_score_reg_parse (char **ccp, struct h c = *p++; *--p = 0; - reg = (struct s7_reg_entry *) hash_find (htab, start); + reg = (struct s7_reg_entry *) str_hash_find (htab, start); *p = c; if (reg) @@ -2321,7 +2321,7 @@ s7_dependency_type_from_insn (char *insn const struct s7_insn_to_dependency *tmp; strcpy (name, insn_name); - tmp = (const struct s7_insn_to_dependency *) hash_find (s7_dependency_insn_hsh, name); + tmp = (const struct s7_insn_to_dependency *) str_hash_find (s7_dependency_insn_hsh, name); if (tmp) return tmp->type; @@ -2789,7 +2789,7 @@ s7_parse_16_32_inst (char *insnstr, bfd_ c = *p; *p = '\0'; - opcode = (const struct s7_asm_opcode *) hash_find (s7_score_ops_hsh, operator); + opcode = (const struct s7_asm_opcode *) str_hash_find (s7_score_ops_hsh, operator); *p = c; memset (&s7_inst, '\0', sizeof (s7_inst)); @@ -5103,7 +5103,7 @@ s7_build_score_ops_hsh (void) new_opcode->relax_value = insn->relax_value; new_opcode->type = insn->type; new_opcode->bitmask = insn->bitmask; - hash_insert (s7_score_ops_hsh, new_opcode->template_name, + str_hash_insert (s7_score_ops_hsh, new_opcode->template_name, (void *) new_opcode); } } @@ -5130,7 +5130,7 @@ s7_build_dependency_insn_hsh (void) strcpy (insn_name, tmp->insn_name); new_i2d->insn_name = insn_name; new_i2d->type = tmp->type; - hash_insert (s7_dependency_insn_hsh, new_i2d->insn_name, + str_hash_insert (s7_dependency_insn_hsh, new_i2d->insn_name, (void *) new_i2d); } } @@ -5345,7 +5345,7 @@ s7_parse_pce_inst (char *insnstr) static void -s7_insert_reg (const struct s7_reg_entry *r, struct hash_control *htab) +s7_insert_reg (const struct s7_reg_entry *r, htab_t htab) { int i = 0; int len = strlen (r->name) + 2; @@ -5359,8 +5359,8 @@ s7_insert_reg (const struct s7_reg_entry } buf2[i] = '\0'; - hash_insert (htab, buf, (void *) r); - hash_insert (htab, buf2, (void *) r); + str_hash_insert (htab, buf, (void *) r); + str_hash_insert (htab, buf2, (void *) r); } static void @@ -5368,7 +5368,7 @@ s7_build_reg_hsh (struct s7_reg_map *map { const struct s7_reg_entry *r; - if ((map->htab = hash_new ()) == NULL) + if ((map->htab = str_htab_create ()) == NULL) { as_fatal (_("virtual memory exhausted")); } @@ -6115,12 +6115,12 @@ s7_begin (void) segT seg; subsegT subseg; - if ((s7_score_ops_hsh = hash_new ()) == NULL) + if ((s7_score_ops_hsh = str_htab_create ()) == NULL) as_fatal (_("virtual memory exhausted")); s7_build_score_ops_hsh (); - if ((s7_dependency_insn_hsh = hash_new ()) == NULL) + if ((s7_dependency_insn_hsh = str_htab_create ()) == NULL) as_fatal (_("virtual memory exhausted")); s7_build_dependency_insn_hsh (); diff -rup binutils.orig/gas/config/tc-sh.c binutils-2.35/gas/config/tc-sh.c --- binutils.orig/gas/config/tc-sh.c 2021-08-11 17:33:12.212490350 +0100 +++ binutils-2.35/gas/config/tc-sh.c 2021-08-11 17:39:31.414057494 +0100 @@ -240,7 +240,7 @@ const relax_typeS md_relax_table[C (END, #undef EMPTY -static struct hash_control *opcode_hash_control; /* Opcode mnemonics */ +static htab_t opcode_hash_control; /* Opcode mnemonics */ #ifdef OBJ_ELF @@ -564,7 +564,7 @@ md_begin (void) = preset_target_arch ? preset_target_arch : arch_sh_up & ~arch_sh_has_dsp; valid_arch = target_arch; - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); /* Insert unique names into hash table. */ for (opcode = sh_table; opcode->name; opcode++) @@ -574,7 +574,7 @@ md_begin (void) if (!SH_MERGE_ARCH_SET_VALID (opcode->arch, target_arch)) continue; prev_name = opcode->name; - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->name, (char *) opcode); } } } @@ -2196,7 +2196,7 @@ find_cooked_opcode (char **str_p) if (nlen == 0) as_bad (_("can't find opcode ")); - return (sh_opcode_info *) hash_find (opcode_hash_control, name); + return (sh_opcode_info *) str_hash_find (opcode_hash_control, name); } /* Assemble a parallel processing insn. */ diff -rup binutils.orig/gas/config/tc-sparc.c binutils-2.35/gas/config/tc-sparc.c --- binutils.orig/gas/config/tc-sparc.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-sparc.c 2021-08-11 17:39:31.415057487 +0100 @@ -126,7 +126,7 @@ int sparc_cie_data_alignment; #endif /* Handle of the OPCODE hash table. */ -static struct hash_control *op_hash; +static htab_t op_hash; static void s_data1 (void); static void s_seg (int); @@ -941,7 +941,6 @@ cmp_perc_entry (const void *parg, const void md_begin (void) { - const char *retval = NULL; int lose = 0; unsigned int i = 0; @@ -952,18 +951,12 @@ md_begin (void) init_default_arch (); sparc_cie_data_alignment = sparc_arch_size == 64 ? -8 : -4; - op_hash = hash_new (); + op_hash = str_htab_create (); while (i < (unsigned int) sparc_num_opcodes) { const char *name = sparc_opcodes[i].name; - retval = hash_insert (op_hash, name, (void *) &sparc_opcodes[i]); - if (retval != NULL) - { - as_bad (_("Internal error: can't hash `%s': %s\n"), - sparc_opcodes[i].name, retval); - lose = 1; - } + str_hash_insert (op_hash, name, (void *) &sparc_opcodes[i]); do { if (sparc_opcodes[i].match & sparc_opcodes[i].lose) @@ -984,7 +977,7 @@ md_begin (void) const char *name = ((sparc_arch_size == 32) ? native_op_table[i].name32 : native_op_table[i].name64); - insn = (struct sparc_opcode *) hash_find (op_hash, name); + insn = (struct sparc_opcode *) str_hash_find (op_hash, name); if (insn == NULL) { as_bad (_("Internal error: can't find opcode `%s' for `%s'\n"), @@ -992,16 +985,8 @@ md_begin (void) lose = 1; } else - { - retval = hash_insert (op_hash, native_op_table[i].name, - (void *) insn); - if (retval != NULL) - { - as_bad (_("Internal error: can't hash `%s': %s\n"), - sparc_opcodes[i].name, retval); - lose = 1; - } - } + str_hash_insert (op_hash, native_op_table[i].name, + (void *) insn); } if (lose) @@ -1759,7 +1744,7 @@ sparc_ip (char *str, const struct sparc_ *pinsn = NULL; return special_case; } - insn = (struct sparc_opcode *) hash_find (op_hash, str); + insn = (struct sparc_opcode *) str_hash_find (op_hash, str); *pinsn = insn; if (insn == NULL) { diff -rup binutils.orig/gas/config/tc-spu.c binutils-2.35/gas/config/tc-spu.c --- binutils.orig/gas/config/tc-spu.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-spu.c 2021-08-11 17:39:31.415057487 +0100 @@ -57,7 +57,7 @@ static void spu_brinfo (int); static void spu_cons (int); extern char *myname; -static struct hash_control *op_hash = NULL; +static htab_t op_hash = NULL; /* These bits should be turned off in the first address of every segment */ int md_seg_align = 7; @@ -110,26 +110,19 @@ unsigned int brinfo; void md_begin (void) { - const char *retval = NULL; int i; /* initialize hash table */ - op_hash = hash_new (); + op_hash = str_htab_create (); /* loop until you see the end of the list */ for (i = 0; i < spu_num_opcodes; i++) - { - /* hash each mnemonic and record its position */ - - retval = hash_insert (op_hash, spu_opcodes[i].mnemonic, - (void *) &spu_opcodes[i]); - - if (retval != NULL && strcmp (retval, "exists") != 0) - as_fatal (_("Can't hash instruction '%s':%s"), - spu_opcodes[i].mnemonic, retval); - } + /* hash each mnemonic and record its position */ + if (str_hash_find (op_hash, spu_opcodes[i].mnemonic) == NULL) + str_hash_insert (op_hash, spu_opcodes[i].mnemonic, + (void *) &spu_opcodes[i]); } const char *md_shortopts = ""; @@ -285,7 +278,7 @@ md_assemble (char *op) /* try to find the instruction in the hash table */ - if ((format = (struct spu_opcode *) hash_find (op_hash, op)) == NULL) + if ((format = (struct spu_opcode *) str_hash_find (op_hash, op)) == NULL) { as_bad (_("Invalid mnemonic '%s'"), op); return; diff -rup binutils.orig/gas/config/tc-tic30.c binutils-2.35/gas/config/tc-tic30.c --- binutils.orig/gas/config/tc-tic30.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-tic30.c 2021-08-11 17:39:31.415057487 +0100 @@ -99,78 +99,56 @@ debug (const char *string, ...) } /* Hash table for opcode lookup. */ -static struct hash_control *op_hash; +static htab_t op_hash; /* Hash table for parallel opcode lookup. */ -static struct hash_control *parop_hash; +static htab_t parop_hash; /* Hash table for register lookup. */ -static struct hash_control *reg_hash; +static htab_t reg_hash; /* Hash table for indirect addressing lookup. */ -static struct hash_control *ind_hash; +static htab_t ind_hash; void md_begin (void) { - const char *hash_err; - debug ("In md_begin()\n"); - op_hash = hash_new (); + op_hash = str_htab_create (); { const insn_template *current_optab = tic30_optab; for (; current_optab < tic30_optab_end; current_optab++) - { - hash_err = hash_insert (op_hash, current_optab->name, - (char *) current_optab); - if (hash_err) - as_fatal ("Internal Error: Can't Hash %s: %s", - current_optab->name, hash_err); - } + str_hash_insert (op_hash, current_optab->name, + (char *) current_optab); } - parop_hash = hash_new (); + parop_hash = str_htab_create (); { const partemplate *current_parop = tic30_paroptab; for (; current_parop < tic30_paroptab_end; current_parop++) - { - hash_err = hash_insert (parop_hash, current_parop->name, - (char *) current_parop); - if (hash_err) - as_fatal ("Internal Error: Can't Hash %s: %s", - current_parop->name, hash_err); - } + str_hash_insert (parop_hash, current_parop->name, + (char *) current_parop); } - reg_hash = hash_new (); + reg_hash = str_htab_create (); { const reg *current_reg = tic30_regtab; for (; current_reg < tic30_regtab_end; current_reg++) - { - hash_err = hash_insert (reg_hash, current_reg->name, - (char *) current_reg); - if (hash_err) - as_fatal ("Internal Error: Can't Hash %s: %s", - current_reg->name, hash_err); - } + str_hash_insert (reg_hash, current_reg->name, + (char *) current_reg); } - ind_hash = hash_new (); + ind_hash = str_htab_create (); { const ind_addr_type *current_ind = tic30_indaddr_tab; for (; current_ind < tic30_indaddrtab_end; current_ind++) - { - hash_err = hash_insert (ind_hash, current_ind->syntax, - (char *) current_ind); - if (hash_err) - as_fatal ("Internal Error: Can't Hash %s: %s", - current_ind->syntax, hash_err); - } + str_hash_insert (ind_hash, current_ind->syntax, + (char *) current_ind); } /* Fill in lexical tables: opcode_chars, operand_chars, space_chars. */ @@ -476,7 +454,7 @@ tic30_operand (char *token) && (*(token + count) == 'r' || *(token + count) == 'R')) { /* AR reference is found, so get its number and remove - it from the buffer so it can pass through hash_find(). */ + it from the buffer so it can pass through str_hash_find(). */ if (found_ar) { as_bad (_("More than one AR register found in indirect reference")); @@ -538,7 +516,7 @@ tic30_operand (char *token) return NULL; } - ind_addr_op = (ind_addr_type *) hash_find (ind_hash, ind_buffer); + ind_addr_op = (ind_addr_type *) str_hash_find (ind_hash, ind_buffer); if (ind_addr_op) { debug ("Found indirect reference: %s\n", ind_addr_op->syntax); @@ -577,7 +555,7 @@ tic30_operand (char *token) } else { - reg *regop = (reg *) hash_find (reg_hash, token); + reg *regop = (reg *) str_hash_find (reg_hash, token); if (regop) { @@ -674,7 +652,7 @@ tic30_parallel_insn (char *token) /* Find instruction. */ save_char = *current_posn; *current_posn = '\0'; - p_opcode = (partemplate *) hash_find (parop_hash, token); + p_opcode = (partemplate *) str_hash_find (parop_hash, token); if (p_opcode) { debug ("Found instruction %s\n", p_opcode->name); @@ -719,7 +697,7 @@ tic30_parallel_insn (char *token) debug ("first_opcode = %s\n", first_opcode); debug ("second_opcode = %s\n", second_opcode); sprintf (token, "q_%s_%s", second_opcode, first_opcode); - p_opcode = (partemplate *) hash_find (parop_hash, token); + p_opcode = (partemplate *) str_hash_find (parop_hash, token); if (p_opcode) { @@ -1466,7 +1444,7 @@ md_assemble (char *line) /* Find instruction. */ save_char = *current_posn; *current_posn = '\0'; - op = (insn_template *) hash_find (op_hash, token_start); + op = (insn_template *) str_hash_find (op_hash, token_start); if (op) { debug ("Found instruction %s\n", op->name); diff -rup binutils.orig/gas/config/tc-tic4x.c binutils-2.35/gas/config/tc-tic4x.c --- binutils.orig/gas/config/tc-tic4x.c 2021-08-11 17:33:12.210490363 +0100 +++ binutils-2.35/gas/config/tc-tic4x.c 2021-08-11 17:39:31.415057487 +0100 @@ -53,10 +53,10 @@ #define TIC4X_ALT_SYNTAX /* Handle of the inst mnemonic hash table. */ -static struct hash_control *tic4x_op_hash = NULL; +static htab_t tic4x_op_hash = NULL; /* Handle asg pseudo. */ -static struct hash_control *tic4x_asg_hash = NULL; +static htab_t tic4x_asg_hash = NULL; static unsigned int tic4x_cpu = 0; /* Default to TMS320C40. */ static unsigned int tic4x_revision = 0; /* CPU revision */ @@ -727,10 +727,7 @@ tic4x_asg (int x ATTRIBUTE_UNUSED) c = get_symbol_name (&name); /* Get terminator. */ str = xstrdup (str); name = xstrdup (name); - if (hash_find (tic4x_asg_hash, name)) - hash_replace (tic4x_asg_hash, name, (void *) str); - else - hash_insert (tic4x_asg_hash, name, (void *) str); + str_hash_insert (tic4x_asg_hash, name, str); (void) restore_line_pointer (c); demand_empty_rest_of_line (); } @@ -1209,23 +1206,17 @@ tic4x_init_symbols (void) } /* Insert a new instruction template into hash table. */ -static int +static void tic4x_inst_insert (const tic4x_inst_t *inst) { static char prev_name[16]; - const char *retval = NULL; /* Only insert the first name if have several similar entries. */ if (!strcmp (inst->name, prev_name) || inst->name[0] == '\0') - return 1; + return; - retval = hash_insert (tic4x_op_hash, inst->name, (void *) inst); - if (retval != NULL) - fprintf (stderr, "internal error: can't hash `%s': %s\n", - inst->name, retval); - else - strcpy (prev_name, inst->name); - return retval == NULL; + str_hash_insert (tic4x_op_hash, inst->name, (void *) inst); + strcpy (prev_name, inst->name); } /* Make a new instruction template. */ @@ -1258,13 +1249,12 @@ tic4x_inst_make (const char *name, unsig } /* Add instruction template, creating dynamic templates as required. */ -static int +static void tic4x_inst_add (const tic4x_inst_t *insts) { const char *s = insts->name; char *d; unsigned int i; - int ok = 1; char name[16]; d = name; @@ -1272,7 +1262,7 @@ tic4x_inst_add (const tic4x_inst_t *inst /* We do not care about INSNs that is not a part of our oplevel setting. */ if ((insts->oplevel & tic4x_oplevel) == 0) - return ok; + return; while (1) { @@ -1296,8 +1286,8 @@ tic4x_inst_add (const tic4x_inst_t *inst *e = '\0'; /* If instruction found then have already processed it. */ - if (hash_find (tic4x_op_hash, name)) - return 1; + if (str_hash_find (tic4x_op_hash, name)) + return; do { @@ -1306,18 +1296,17 @@ tic4x_inst_add (const tic4x_inst_t *inst (*s == 'B' ? 16 : 23)), insts[k].args); if (k == 0) /* Save strcmp() with following func. */ - ok &= tic4x_inst_insert (inst); + tic4x_inst_insert (inst); k++; } while (!strcmp (insts->name, insts[k].name)); } - return ok; - break; + return; case '\0': - return tic4x_inst_insert (insts); - break; + tic4x_inst_insert (insts); + return; default: *d++ = *s++; @@ -1332,7 +1321,6 @@ tic4x_inst_add (const tic4x_inst_t *inst void md_begin (void) { - int ok = 1; unsigned int i; /* Setup the proper opcode level according to the @@ -1364,21 +1352,18 @@ md_begin (void) tic4x_oplevel |= OP_IDLE2; /* Create hash table for mnemonics. */ - tic4x_op_hash = hash_new (); + tic4x_op_hash = str_htab_create (); /* Create hash table for asg pseudo. */ - tic4x_asg_hash = hash_new (); + tic4x_asg_hash = str_htab_create (); /* Add mnemonics to hash table, expanding conditional mnemonics on fly. */ for (i = 0; i < tic4x_num_insts; i++) - ok &= tic4x_inst_add (tic4x_insts + i); + tic4x_inst_add (tic4x_insts + i); /* Create dummy inst to avoid errors accessing end of table. */ tic4x_inst_make ("", 0, ""); - if (!ok) - as_fatal ("Broken assembler. No assembly attempted."); - /* Add registers to symbol table. */ tic4x_init_regtable (); @@ -1509,7 +1494,7 @@ tic4x_operand_parse (char *s, tic4x_oper c = get_symbol_name (&str); /* Get terminator. */ new_pointer = input_line_pointer; - if (strlen (str) && (entry = hash_find (tic4x_asg_hash, str)) != NULL) + if (strlen (str) && (entry = str_hash_find (tic4x_asg_hash, str)) != NULL) { (void) restore_line_pointer (c); input_line_pointer = (char *) entry; @@ -2444,7 +2429,7 @@ md_assemble (char *str) /* Skip past instruction mnemonic. */ while (*s && *s != ' ') s++; - if (*s) /* Null terminate for hash_find. */ + if (*s) /* Null terminate for str_hash_find. */ *s++ = '\0'; /* and skip past null. */ len = strlen (insn->name); snprintf (insn->name + len, TIC4X_NAME_MAX - len, "_%s", str); @@ -2465,7 +2450,7 @@ md_assemble (char *str) if (insn->in_use) { if ((insn->inst = (struct tic4x_inst *) - hash_find (tic4x_op_hash, insn->name)) == NULL) + str_hash_find (tic4x_op_hash, insn->name)) == NULL) { as_bad (_("Unknown opcode `%s'."), insn->name); insn->parallel = 0; @@ -2508,7 +2493,7 @@ md_assemble (char *str) s = str; while (*s && *s != ' ') /* Skip past instruction mnemonic. */ s++; - if (*s) /* Null terminate for hash_find. */ + if (*s) /* Null terminate for str_hash_find. */ *s++ = '\0'; /* and skip past null. */ strncpy (insn->name, str, TIC4X_NAME_MAX - 1); insn->name[TIC4X_NAME_MAX - 1] = '\0'; diff -rup binutils.orig/gas/config/tc-tic54x.c binutils-2.35/gas/config/tc-tic54x.c --- binutils.orig/gas/config/tc-tic54x.c 2021-08-11 17:33:12.211490357 +0100 +++ binutils-2.35/gas/config/tc-tic54x.c 2021-08-11 17:39:31.416057481 +0100 @@ -181,12 +181,12 @@ static symbolS *last_label_seen = NULL; /* This ensures that all new labels are unique. */ static int local_label_id; -static struct hash_control *subsym_recurse_hash; /* Prevent infinite recurse. */ -static struct hash_control *math_hash; /* Built-in math functions. */ +static htab_t subsym_recurse_hash; /* Prevent infinite recurse. */ +static htab_t math_hash; /* Built-in math functions. */ /* Allow maximum levels of macro nesting; level 0 is the main substitution symbol table. The other assembler only does 32 levels, so there! */ #define MAX_SUBSYM_HASH 100 -static struct hash_control *subsym_hash[MAX_SUBSYM_HASH]; +static htab_t subsym_hash[MAX_SUBSYM_HASH]; /* Keep track of local labels so we can substitute them before GAS sees them since macros use their own 'namespace' for local labels, use a separate hash @@ -197,18 +197,18 @@ static struct hash_control *subsym_hash[ We use our own macro nesting counter, since GAS overloads it when expanding other things (like conditionals and repeat loops). */ static int macro_level = 0; -static struct hash_control *local_label_hash[100]; +static htab_t local_label_hash[100]; /* Keep track of struct/union tags. */ -static struct hash_control *stag_hash; -static struct hash_control *op_hash; -static struct hash_control *parop_hash; -static struct hash_control *reg_hash; -static struct hash_control *mmreg_hash; -static struct hash_control *cc_hash; -static struct hash_control *cc2_hash; -static struct hash_control *cc3_hash; -static struct hash_control *sbit_hash; -static struct hash_control *misc_symbol_hash; +static htab_t stag_hash; +static htab_t op_hash; +static htab_t parop_hash; +static htab_t reg_hash; +static htab_t mmreg_hash; +static htab_t cc_hash; +static htab_t cc2_hash; +static htab_t cc3_hash; +static htab_t sbit_hash; +static htab_t misc_symbol_hash; /* Only word (et al.), align, or conditionals are allowed within .struct/.union. */ @@ -569,7 +569,7 @@ stag_add_field_symbols (struct stag *sta replacement = concat (S_GET_NAME (rootsym), "+", root_stag_name, name + strlen (S_GET_NAME (rootsym)), NULL); - hash_insert (subsym_hash[0], name, replacement); + str_hash_insert (subsym_hash[0], name, replacement); } /* Recurse if the field is a structure. @@ -740,7 +740,7 @@ tic54x_endstruct (int is_union) /* Nested .structs don't get put in the stag table. */ if (current_stag->outer == NULL) { - hash_insert (stag_hash, current_stag->name, current_stag); + str_hash_insert (stag_hash, current_stag->name, current_stag); stag_add_field_symbols (current_stag, path, S_GET_VALUE (current_stag->sym), NULL, NULL); @@ -770,7 +770,7 @@ tic54x_tag (int ignore ATTRIBUTE_UNUSED) { char *name; int c = get_symbol_name (&name); - struct stag *stag = (struct stag *) hash_find (stag_hash, name); + struct stag *stag = (struct stag *) str_hash_find (stag_hash, name); if (!stag) { @@ -1117,11 +1117,14 @@ tic54x_global (int type) /* Remove the symbol from the local label hash lookup. */ -static void -tic54x_remove_local_label (const char *key, void *value ATTRIBUTE_UNUSED) +static int +tic54x_remove_local_label (void **slot, void *arg ATTRIBUTE_UNUSED) { - void *elem = hash_delete (local_label_hash[macro_level], key, FALSE); + string_tuple_t *tuple = *((string_tuple_t **) slot); + void *elem = str_hash_find (local_label_hash[macro_level], tuple->key); + str_hash_delete (local_label_hash[macro_level], tuple->key); free (elem); + return 0; } /* Reset all local labels. */ @@ -1129,7 +1132,7 @@ tic54x_remove_local_label (const char *k static void tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED) { - hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label); + htab_traverse (local_label_hash[macro_level], tic54x_remove_local_label, NULL); } /* .text @@ -2235,7 +2238,7 @@ tic54x_var (int ignore ATTRIBUTE_UNUSED) c = get_symbol_name (&name); /* .var symbols start out with a null string. */ name = xstrdup (name); - hash_insert (subsym_hash[macro_level], name, empty); + str_hash_insert (subsym_hash[macro_level], name, empty); c = restore_line_pointer (c); if (c == ',') { @@ -2503,8 +2506,8 @@ tic54x_macro_start (void) as_fatal (_("Macro nesting is too deep")); return; } - subsym_hash[macro_level] = hash_new (); - local_label_hash[macro_level] = hash_new (); + subsym_hash[macro_level] = str_htab_create (); + local_label_hash[macro_level] = str_htab_create (); } void @@ -2520,7 +2523,7 @@ tic54x_macro_info (const macro_entry *ma name[entry->name.len] = '\0'; value[entry->actual.len] = '\0'; - hash_insert (subsym_hash[macro_level], name, value); + str_hash_insert (subsym_hash[macro_level], name, value); } } @@ -2529,9 +2532,9 @@ tic54x_macro_info (const macro_entry *ma void tic54x_macro_end (void) { - hash_die (subsym_hash[macro_level]); + htab_delete (subsym_hash[macro_level]); subsym_hash[macro_level] = NULL; - hash_die (local_label_hash[macro_level]); + htab_delete (local_label_hash[macro_level]); local_label_hash[macro_level] = NULL; --macro_level; } @@ -2685,9 +2688,9 @@ subsym_isname (char *a, char *ignore ATT static int subsym_isreg (char *a, char *ignore ATTRIBUTE_UNUSED) { - if (hash_find (reg_hash, a)) + if (str_hash_find (reg_hash, a)) return 1; - if (hash_find (mmreg_hash, a)) + if (str_hash_find (mmreg_hash, a)) return 1; return 0; } @@ -2697,7 +2700,7 @@ subsym_isreg (char *a, char *ignore ATTR static int subsym_structsz (char *name, char *ignore ATTRIBUTE_UNUSED) { - struct stag *stag = (struct stag *) hash_find (stag_hash, name); + struct stag *stag = (struct stag *) str_hash_find (stag_hash, name); if (stag) return stag->size; @@ -2965,7 +2968,6 @@ md_begin (void) tic54x_symbol *sym; const subsym_proc_entry *subsym_proc; const math_proc_entry *math_proc; - const char *hash_err; char **symname; char *TIC54X_DIR = getenv ("TIC54X_DIR"); char *A_DIR = TIC54X_DIR ? TIC54X_DIR : getenv ("A_DIR"); @@ -2989,27 +2991,21 @@ md_begin (void) while (tmp != NULL); } - op_hash = hash_new (); + op_hash = str_htab_create (); for (tm = (insn_template *) tic54x_optab; tm->name; tm++) { - if (hash_find (op_hash, tm->name)) + if (str_hash_find (op_hash, tm->name)) continue; - hash_err = hash_insert (op_hash, tm->name, (char *) tm); - if (hash_err) - as_fatal ("Internal Error: Can't hash %s: %s", - tm->name, hash_err); + str_hash_insert (op_hash, tm->name, (char *) tm); } - parop_hash = hash_new (); + parop_hash = str_htab_create (); for (tm = (insn_template *) tic54x_paroptab; tm->name; tm++) { - if (hash_find (parop_hash, tm->name)) + if (str_hash_find (parop_hash, tm->name)) continue; - hash_err = hash_insert (parop_hash, tm->name, (char *) tm); - if (hash_err) - as_fatal ("Internal Error: Can't hash %s: %s", - tm->name, hash_err); + str_hash_insert (parop_hash, tm->name, (char *) tm); } - reg_hash = hash_new (); + reg_hash = str_htab_create (); for (sym = (tic54x_symbol *) regs; sym->name; sym++) { /* Add basic registers to the symbol table. */ @@ -3017,54 +3013,54 @@ md_begin (void) (valueT) sym->value, &zero_address_frag); SF_SET_LOCAL (symbolP); symbol_table_insert (symbolP); - hash_err = hash_insert (reg_hash, sym->name, (char *) sym); + str_hash_insert (reg_hash, sym->name, (char *) sym); } for (sym = (tic54x_symbol *) mmregs; sym->name; sym++) - hash_err = hash_insert (reg_hash, sym->name, (char *) sym); - mmreg_hash = hash_new (); + str_hash_insert (reg_hash, sym->name, (char *) sym); + mmreg_hash = str_htab_create (); for (sym = (tic54x_symbol *) mmregs; sym->name; sym++) - hash_err = hash_insert (mmreg_hash, sym->name, (char *) sym); + str_hash_insert (mmreg_hash, sym->name, (char *) sym); - cc_hash = hash_new (); + cc_hash = str_htab_create (); for (sym = (tic54x_symbol *) condition_codes; sym->name; sym++) - hash_err = hash_insert (cc_hash, sym->name, (char *) sym); + str_hash_insert (cc_hash, sym->name, (char *) sym); - cc2_hash = hash_new (); + cc2_hash = str_htab_create (); for (sym = (tic54x_symbol *) cc2_codes; sym->name; sym++) - hash_err = hash_insert (cc2_hash, sym->name, (char *) sym); + str_hash_insert (cc2_hash, sym->name, (char *) sym); - cc3_hash = hash_new (); + cc3_hash = str_htab_create (); for (sym = (tic54x_symbol *) cc3_codes; sym->name; sym++) - hash_err = hash_insert (cc3_hash, sym->name, (char *) sym); + str_hash_insert (cc3_hash, sym->name, (char *) sym); - sbit_hash = hash_new (); + sbit_hash = str_htab_create (); for (sym = (tic54x_symbol *) status_bits; sym->name; sym++) - hash_err = hash_insert (sbit_hash, sym->name, (char *) sym); + str_hash_insert (sbit_hash, sym->name, (char *) sym); - misc_symbol_hash = hash_new (); + misc_symbol_hash = str_htab_create (); for (symname = (char **) misc_symbols; *symname; symname++) - hash_err = hash_insert (misc_symbol_hash, *symname, *symname); + str_hash_insert (misc_symbol_hash, *symname, *symname); /* Only the base substitution table and local label table are initialized; the others (for local macro substitution) get instantiated as needed. */ - local_label_hash[0] = hash_new (); - subsym_hash[0] = hash_new (); + local_label_hash[0] = str_htab_create (); + subsym_hash[0] = str_htab_create (); for (subsym_proc = subsym_procs; subsym_proc->name; subsym_proc++) - hash_err = hash_insert (subsym_hash[0], subsym_proc->name, - (char *) subsym_proc); + str_hash_insert (subsym_hash[0], subsym_proc->name, + (char *) subsym_proc); - math_hash = hash_new (); + math_hash = str_htab_create (); for (math_proc = math_procs; math_proc->name; math_proc++) { /* Insert into the main subsym hash for recognition; insert into the math hash to actually store information. */ - hash_err = hash_insert (subsym_hash[0], math_proc->name, - (char *) math_proc); - hash_err = hash_insert (math_hash, math_proc->name, - (char *) math_proc); + str_hash_insert (subsym_hash[0], math_proc->name, + (char *) math_proc); + str_hash_insert (math_hash, math_proc->name, + (char *) math_proc); } - subsym_recurse_hash = hash_new (); - stag_hash = hash_new (); + subsym_recurse_hash = str_htab_create (); + stag_hash = str_htab_create (); } static int @@ -3257,7 +3253,7 @@ is_mmreg (struct opstruct *operand) { return (is_absolute (operand) || is_immediate (operand) - || hash_find (mmreg_hash, operand->buf) != 0); + || str_hash_find (mmreg_hash, operand->buf) != 0); } static int @@ -3301,13 +3297,13 @@ is_type (struct opstruct *operand, enum return strncasecmp ("ar", operand->buf, 2) == 0 && ISDIGIT (operand->buf[2]); case OP_SBIT: - return hash_find (sbit_hash, operand->buf) != 0 || is_absolute (operand); + return str_hash_find (sbit_hash, operand->buf) != 0 || is_absolute (operand); case OP_CC: - return hash_find (cc_hash, operand->buf) != 0; + return str_hash_find (cc_hash, operand->buf) != 0; case OP_CC2: - return hash_find (cc2_hash, operand->buf) != 0; + return str_hash_find (cc2_hash, operand->buf) != 0; case OP_CC3: - return hash_find (cc3_hash, operand->buf) != 0 + return str_hash_find (cc3_hash, operand->buf) != 0 || is_immediate (operand) || is_absolute (operand); case OP_16: return (is_immediate (operand) || is_absolute (operand)) @@ -3649,7 +3645,7 @@ encode_integer (tic54x_insn *insn, static int encode_condition (tic54x_insn *insn, struct opstruct *operand) { - tic54x_symbol *cc = (tic54x_symbol *) hash_find (cc_hash, operand->buf); + tic54x_symbol *cc = (tic54x_symbol *) str_hash_find (cc_hash, operand->buf); if (!cc) { as_bad (_("Unrecognized condition code \"%s\""), operand->buf); @@ -3709,7 +3705,7 @@ encode_condition (tic54x_insn *insn, str static int encode_cc3 (tic54x_insn *insn, struct opstruct *operand) { - tic54x_symbol *cc3 = (tic54x_symbol *) hash_find (cc3_hash, operand->buf); + tic54x_symbol *cc3 = (tic54x_symbol *) str_hash_find (cc3_hash, operand->buf); int value = cc3 ? cc3->value : operand->exp.X_add_number << 8; if ((value & 0x0300) != value) @@ -3738,7 +3734,7 @@ encode_arx (tic54x_insn *insn, struct op static int encode_cc2 (tic54x_insn *insn, struct opstruct *operand) { - tic54x_symbol *cc2 = (tic54x_symbol *) hash_find (cc2_hash, operand->buf); + tic54x_symbol *cc2 = (tic54x_symbol *) str_hash_find (cc2_hash, operand->buf); if (!cc2) { @@ -3898,7 +3894,7 @@ encode_operand (tic54x_insn *insn, enum case OP_SBIT: { tic54x_symbol *sbit = (tic54x_symbol *) - hash_find (sbit_hash, operand->buf); + str_hash_find (sbit_hash, operand->buf); int value = is_absolute (operand) ? operand->exp.X_add_number : (sbit ? sbit->value : -1); int reg = 0; @@ -3912,7 +3908,7 @@ encode_operand (tic54x_insn *insn, enum } /* Guess the register based on the status bit; "ovb" is the last status bit defined for st0. */ - if (sbit > (tic54x_symbol *) hash_find (sbit_hash, "ovb")) + if (sbit > (tic54x_symbol *) str_hash_find (sbit_hash, "ovb")) reg = 1; } if (value == -1) @@ -4152,7 +4148,7 @@ optimize_insn (tic54x_insn *insn) static int tic54x_parse_insn (tic54x_insn *insn, char *line) { - insn->tm = (insn_template *) hash_find (op_hash, insn->mnemonic); + insn->tm = (insn_template *) str_hash_find (op_hash, insn->mnemonic); if (!insn->tm) { as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic); @@ -4175,7 +4171,7 @@ tic54x_parse_insn (tic54x_insn *insn, ch /* SUCCESS! now try some optimizations. */ if (optimize_insn (insn)) { - insn->tm = (insn_template *) hash_find (op_hash, + insn->tm = (insn_template *) str_hash_find (op_hash, insn->mnemonic); continue; } @@ -4210,7 +4206,7 @@ next_line_shows_parallel (char *next_lin static int tic54x_parse_parallel_insn_firstline (tic54x_insn *insn, char *line) { - insn->tm = (insn_template *) hash_find (parop_hash, insn->mnemonic); + insn->tm = (insn_template *) str_hash_find (parop_hash, insn->mnemonic); if (!insn->tm) { as_bad (_("Unrecognized parallel instruction \"%s\""), @@ -4341,17 +4337,8 @@ subsym_create_or_replace (char *name, ch int i; for (i = macro_level; i > 0; i--) - { - if (hash_find (subsym_hash[i], name)) - { - hash_replace (subsym_hash[i], name, value); - return; - } - } - if (hash_find (subsym_hash[0], name)) - hash_replace (subsym_hash[0], name, value); - else - hash_insert (subsym_hash[0], name, value); + str_hash_insert (subsym_hash[i], name, value); + str_hash_insert (subsym_hash[0], name, value); } /* Look up the substitution string replacement for the given symbol. @@ -4361,7 +4348,7 @@ subsym_create_or_replace (char *name, ch static char * subsym_lookup (char *name, int nest_level) { - char *value = hash_find (subsym_hash[nest_level], name); + char *value = str_hash_find (subsym_hash[nest_level], name); if (value || nest_level == 0) return value; @@ -4482,7 +4469,7 @@ subsym_substitute (char *line, int force } /* Avoid infinite recursion; if a symbol shows up a second time for substitution, leave it as is. */ - if (hash_find (subsym_recurse_hash, name) == NULL) + if (str_hash_find (subsym_recurse_hash, name) == NULL) value = subsym_lookup (name, macro_level); else as_warn (_("%s symbol recursion stopped at " @@ -4498,7 +4485,7 @@ subsym_substitute (char *line, int force { /* Use an existing identifier for that label if, available, or create a new, unique identifier. */ - value = hash_find (local_label_hash[macro_level], name); + value = str_hash_find (local_label_hash[macro_level], name); if (value == NULL) { char digit[11]; @@ -4510,7 +4497,7 @@ subsym_substitute (char *line, int force value[strlen (value) - 1] = '\0'; sprintf (digit, ".%d", local_label_id++); strcat (value, digit); - hash_insert (local_label_hash[macro_level], namecopy, value); + str_hash_insert (local_label_hash[macro_level], namecopy, value); } /* Indicate where to continue looking for substitutions. */ ptr = tail; @@ -4519,7 +4506,7 @@ subsym_substitute (char *line, int force else if (value != NULL && *name == '$') { subsym_proc_entry *entry = (subsym_proc_entry *) value; - math_proc_entry *math_entry = hash_find (math_hash, name); + math_proc_entry *math_entry = str_hash_find (math_hash, name); char *arg1, *arg2 = NULL; *ptr = c; @@ -4631,9 +4618,9 @@ subsym_substitute (char *line, int force try to replace a symbol once. */ if (recurse) { - hash_insert (subsym_recurse_hash, name, name); + str_hash_insert (subsym_recurse_hash, name, name); value = subsym_substitute (value, macro_level > 0); - hash_delete (subsym_recurse_hash, name, FALSE); + str_hash_delete (subsym_recurse_hash, name); } /* Temporarily zero-terminate where the symbol started. */ @@ -5022,19 +5009,19 @@ tic54x_undefined_symbol (char *name) tic54x_symbol *sym; /* Not sure how to handle predefined symbols. */ - if ((sym = (tic54x_symbol *) hash_find (cc_hash, name)) != NULL || - (sym = (tic54x_symbol *) hash_find (cc2_hash, name)) != NULL || - (sym = (tic54x_symbol *) hash_find (cc3_hash, name)) != NULL || - (sym = (tic54x_symbol *) hash_find (misc_symbol_hash, name)) != NULL || - (sym = (tic54x_symbol *) hash_find (sbit_hash, name)) != NULL) + if ((sym = (tic54x_symbol *) str_hash_find (cc_hash, name)) != NULL || + (sym = (tic54x_symbol *) str_hash_find (cc2_hash, name)) != NULL || + (sym = (tic54x_symbol *) str_hash_find (cc3_hash, name)) != NULL || + (sym = (tic54x_symbol *) str_hash_find (misc_symbol_hash, name)) != NULL || + (sym = (tic54x_symbol *) str_hash_find (sbit_hash, name)) != NULL) { return symbol_new (name, reg_section, (valueT) sym->value, &zero_address_frag); } - if ((sym = (tic54x_symbol *) hash_find (reg_hash, name)) != NULL || - (sym = (tic54x_symbol *) hash_find (mmreg_hash, name)) != NULL || + if ((sym = (tic54x_symbol *) str_hash_find (reg_hash, name)) != NULL || + (sym = (tic54x_symbol *) str_hash_find (mmreg_hash, name)) != NULL || !strcasecmp (name, "a") || !strcasecmp (name, "b")) { return symbol_new (name, reg_section, diff -rup binutils.orig/gas/config/tc-tic6x.c binutils-2.35/gas/config/tc-tic6x.c --- binutils.orig/gas/config/tc-tic6x.c 2021-08-11 17:33:12.208490376 +0100 +++ binutils-2.35/gas/config/tc-tic6x.c 2021-08-11 17:39:31.416057481 +0100 @@ -742,7 +742,7 @@ const pseudo_typeS md_pseudo_table[] = /* Hash table of opcodes. For each opcode name, this stores a pointer to a tic6x_opcode_list listing (in an arbitrary order) all opcode table entries with that name. */ -static struct hash_control *opcode_hash; +static htab_t opcode_hash; /* Initialize the assembler (called once at assembler startup). */ @@ -757,17 +757,14 @@ md_begin (void) bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0); /* Insert opcodes into the hash table. */ - opcode_hash = hash_new (); + opcode_hash = str_htab_create (); for (id = 0; id < tic6x_opcode_max; id++) { - const char *errmsg; tic6x_opcode_list *opc = XNEW (tic6x_opcode_list); opc->id = id; - opc->next = hash_find (opcode_hash, tic6x_opcode_table[id].name); - if ((errmsg = hash_jam (opcode_hash, tic6x_opcode_table[id].name, opc)) - != NULL) - as_fatal ("%s", _(errmsg)); + opc->next = str_hash_find (opcode_hash, tic6x_opcode_table[id].name); + str_hash_insert (opcode_hash, tic6x_opcode_table[id].name, opc); } /* Save the current subseg so we can restore it [it's the default one and @@ -3187,7 +3184,7 @@ md_assemble (char *str) this_insn_label_list = seginfo->tc_segment_info_data.label_list; seginfo->tc_segment_info_data.label_list = NULL; - opc_list = hash_find_n (opcode_hash, str, p - str); + opc_list = str_hash_find_n (opcode_hash, str, p - str); if (opc_list == NULL) { char c = *p; diff -rup binutils.orig/gas/config/tc-tilegx.c binutils-2.35/gas/config/tc-tilegx.c --- binutils.orig/gas/config/tc-tilegx.c 2021-08-11 17:33:12.209490370 +0100 +++ binutils-2.35/gas/config/tc-tilegx.c 2021-08-11 17:39:31.416057481 +0100 @@ -177,13 +177,13 @@ md_show_usage (FILE *stream) #define O_hw1_last_plt O_md27 #define O_hw2_last_plt O_md28 -static struct hash_control *special_operator_hash; +static htab_t special_operator_hash; /* Hash tables for instruction mnemonic lookup. */ -static struct hash_control *op_hash; +static htab_t op_hash; /* Hash table for spr lookup. */ -static struct hash_control *spr_hash; +static htab_t spr_hash; /* True temporarily while parsing an SPR expression. This changes the * namespace to include SPR names. */ @@ -231,7 +231,7 @@ static int allow_suspicious_bundles; for that register (e.g. r63 instead of zero), so we should generate a warning. The attempted register number can be found by clearing NONCANONICAL_REG_NAME_FLAG. */ -static struct hash_control *main_reg_hash; +static htab_t main_reg_hash; /* We cannot unambiguously store a 0 in a hash table and look it up, @@ -273,9 +273,9 @@ md_begin (void) tilegx_cie_data_alignment = (tilegx_arch_size == 64 ? -8 : -4); /* Initialize special operator hash table. */ - special_operator_hash = hash_new (); + special_operator_hash = str_htab_create (); #define INSERT_SPECIAL_OP(name) \ - hash_insert (special_operator_hash, #name, (void *)O_##name) + str_hash_insert (special_operator_hash, #name, (void *)O_##name) INSERT_SPECIAL_OP (hw0); INSERT_SPECIAL_OP (hw1); @@ -285,7 +285,7 @@ md_begin (void) INSERT_SPECIAL_OP (hw1_last); INSERT_SPECIAL_OP (hw2_last); /* hw3_last is a convenience alias for the equivalent hw3. */ - hash_insert (special_operator_hash, "hw3_last", (void*)O_hw3); + str_hash_insert (special_operator_hash, "hw3_last", (void*)O_hw3); INSERT_SPECIAL_OP (hw0_got); INSERT_SPECIAL_OP (hw0_last_got); INSERT_SPECIAL_OP (hw1_last_got); @@ -310,36 +310,32 @@ md_begin (void) #undef INSERT_SPECIAL_OP /* Initialize op_hash hash table. */ - op_hash = hash_new (); + op_hash = str_htab_create (); for (op = &tilegx_opcodes[0]; op->name != NULL; op++) - { - const char *hash_err = hash_insert (op_hash, op->name, (void *)op); - if (hash_err != NULL) - as_fatal (_("Internal Error: Can't hash %s: %s"), op->name, hash_err); - } + str_hash_insert (op_hash, op->name, (void *)op); /* Initialize the spr hash table. */ parsing_spr = 0; - spr_hash = hash_new (); + spr_hash = str_htab_create (); for (i = 0; i < tilegx_num_sprs; i++) - hash_insert (spr_hash, tilegx_sprs[i].name, + str_hash_insert (spr_hash, tilegx_sprs[i].name, (void *) &tilegx_sprs[i]); /* Set up the main_reg_hash table. We use this instead of creating a symbol in the register section to avoid ambiguities with labels that have the same names as registers. */ - main_reg_hash = hash_new (); + main_reg_hash = str_htab_create (); for (i = 0; i < TILEGX_NUM_REGISTERS; i++) { char buf[64]; - hash_insert (main_reg_hash, tilegx_register_names[i], + str_hash_insert (main_reg_hash, tilegx_register_names[i], (void *) (long) (i | CANONICAL_REG_NAME_FLAG)); /* See if we should insert a noncanonical alias, like r63. */ sprintf (buf, "r%d", i); if (strcmp (buf, tilegx_register_names[i]) != 0) - hash_insert (main_reg_hash, xstrdup (buf), + str_hash_insert (main_reg_hash, xstrdup (buf), (void *) (long) (i | NONCANONICAL_REG_NAME_FLAG)); } } @@ -1013,7 +1009,7 @@ tilegx_parse_name (char *name, expressio if (parsing_spr) { - void* val = hash_find (spr_hash, name); + void* val = str_hash_find (spr_hash, name); if (val == NULL) return 0; @@ -1031,7 +1027,7 @@ tilegx_parse_name (char *name, expressio else { /* Look up the operator in our table. */ - void* val = hash_find (special_operator_hash, name); + void* val = str_hash_find (special_operator_hash, name); if (val == 0) return 0; op = (operatorT)(long)val; @@ -1098,7 +1094,7 @@ parse_reg_expression (expressionS* expre terminating_char = get_symbol_name (®name); - pval = hash_find (main_reg_hash, regname); + pval = str_hash_find (main_reg_hash, regname); if (pval == NULL) as_bad (_("Expected register, got '%s'."), regname); @@ -1243,7 +1239,7 @@ md_assemble (char *str) old_char = str[opname_len]; str[opname_len] = '\0'; - op = hash_find(op_hash, str); + op = str_hash_find(op_hash, str); str[opname_len] = old_char; if (op == NULL) { diff -rup binutils.orig/gas/config/tc-tilepro.c binutils-2.35/gas/config/tc-tilepro.c --- binutils.orig/gas/config/tc-tilepro.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-tilepro.c 2021-08-11 17:39:31.416057481 +0100 @@ -126,13 +126,13 @@ md_show_usage (FILE *stream) #define O_tls_gd_add O_md22 #define O_tls_ie_load O_md23 -static struct hash_control *special_operator_hash; +static htab_t special_operator_hash; /* Hash tables for instruction mnemonic lookup. */ -static struct hash_control *op_hash; +static htab_t op_hash; /* Hash table for spr lookup. */ -static struct hash_control *spr_hash; +static htab_t spr_hash; /* True temporarily while parsing an SPR expression. This changes the * namespace to include SPR names. */ @@ -181,7 +181,7 @@ static int allow_suspicious_bundles; for that register (e.g. r63 instead of zero), so we should generate a warning. The attempted register number can be found by clearing NONCANONICAL_REG_NAME_FLAG. */ -static struct hash_control *main_reg_hash; +static htab_t main_reg_hash; /* We cannot unambiguously store a 0 in a hash table and look it up, @@ -216,9 +216,9 @@ md_begin (void) inside_bundle = 0; /* Initialize special operator hash table. */ - special_operator_hash = hash_new (); + special_operator_hash = str_htab_create (); #define INSERT_SPECIAL_OP(name) \ - hash_insert (special_operator_hash, #name, (void *)O_##name) + str_hash_insert (special_operator_hash, #name, (void *)O_##name) INSERT_SPECIAL_OP(lo16); INSERT_SPECIAL_OP(hi16); @@ -246,54 +246,47 @@ md_begin (void) #undef INSERT_SPECIAL_OP /* Initialize op_hash hash table. */ - op_hash = hash_new (); + op_hash = str_htab_create (); for (op = &tilepro_opcodes[0]; op->name != NULL; op++) - { - const char *hash_err = hash_insert (op_hash, op->name, (void *)op); - if (hash_err != NULL) - { - as_fatal (_("Internal Error: Can't hash %s: %s"), - op->name, hash_err); - } - } + str_hash_insert (op_hash, op->name, (void *)op); /* Initialize the spr hash table. */ parsing_spr = 0; - spr_hash = hash_new (); + spr_hash = str_htab_create (); for (i = 0; i < tilepro_num_sprs; i++) - hash_insert (spr_hash, tilepro_sprs[i].name, + str_hash_insert (spr_hash, tilepro_sprs[i].name, (void *) &tilepro_sprs[i]); /* Set up the main_reg_hash table. We use this instead of * creating a symbol in the register section to avoid ambiguities * with labels that have the same names as registers. */ - main_reg_hash = hash_new (); + main_reg_hash = str_htab_create (); for (i = 0; i < TILEPRO_NUM_REGISTERS; i++) { char buf[64]; - hash_insert (main_reg_hash, tilepro_register_names[i], + str_hash_insert (main_reg_hash, tilepro_register_names[i], (void *) (long)(i | CANONICAL_REG_NAME_FLAG)); /* See if we should insert a noncanonical alias, like r63. */ sprintf (buf, "r%d", i); if (strcmp (buf, tilepro_register_names[i]) != 0) - hash_insert (main_reg_hash, xstrdup (buf), + str_hash_insert (main_reg_hash, xstrdup (buf), (void *) (long)(i | NONCANONICAL_REG_NAME_FLAG)); } /* Insert obsolete backwards-compatibility register names. */ - hash_insert (main_reg_hash, "io0", + str_hash_insert (main_reg_hash, "io0", (void *) (long) (TREG_IDN0 | CANONICAL_REG_NAME_FLAG)); - hash_insert (main_reg_hash, "io1", + str_hash_insert (main_reg_hash, "io1", (void *) (long) (TREG_IDN1 | CANONICAL_REG_NAME_FLAG)); - hash_insert (main_reg_hash, "us0", + str_hash_insert (main_reg_hash, "us0", (void *) (long) (TREG_UDN0 | CANONICAL_REG_NAME_FLAG)); - hash_insert (main_reg_hash, "us1", + str_hash_insert (main_reg_hash, "us1", (void *) (long) (TREG_UDN1 | CANONICAL_REG_NAME_FLAG)); - hash_insert (main_reg_hash, "us2", + str_hash_insert (main_reg_hash, "us2", (void *) (long) (TREG_UDN2 | CANONICAL_REG_NAME_FLAG)); - hash_insert (main_reg_hash, "us3", + str_hash_insert (main_reg_hash, "us3", (void *) (long) (TREG_UDN3 | CANONICAL_REG_NAME_FLAG)); } @@ -903,7 +896,7 @@ tilepro_parse_name (char *name, expressi if (parsing_spr) { - void *val = hash_find (spr_hash, name); + void *val = str_hash_find (spr_hash, name); if (val == NULL) return 0; @@ -922,7 +915,7 @@ tilepro_parse_name (char *name, expressi else { /* Look up the operator in our table. */ - void *val = hash_find (special_operator_hash, name); + void *val = str_hash_find (special_operator_hash, name); if (val == 0) return 0; op = (operatorT)(long)val; @@ -984,7 +977,7 @@ parse_reg_expression (expressionS* expre char *regname; char terminating_char = get_symbol_name (®name); - void* pval = hash_find (main_reg_hash, regname); + void* pval = str_hash_find (main_reg_hash, regname); if (pval == NULL) as_bad (_("Expected register, got '%s'."), regname); @@ -1128,7 +1121,7 @@ md_assemble (char *str) old_char = str[opname_len]; str[opname_len] = '\0'; - op = hash_find(op_hash, str); + op = str_hash_find(op_hash, str); str[opname_len] = old_char; if (op == NULL) { diff -rup binutils.orig/gas/config/tc-v850.c binutils-2.35/gas/config/tc-v850.c --- binutils.orig/gas/config/tc-v850.c 2021-08-11 17:33:12.214490337 +0100 +++ binutils-2.35/gas/config/tc-v850.c 2021-08-11 17:39:31.417057475 +0100 @@ -599,7 +599,7 @@ const pseudo_typeS md_pseudo_table[] = }; /* Opcode hash table. */ -static struct hash_control *v850_hash; +static htab_t v850_hash; /* This table is sorted. Suitable for searching by a binary search. */ static const struct reg_name pre_defined_registers[] = @@ -1952,7 +1952,7 @@ md_begin (void) if (soft_float == -1) soft_float = machine < bfd_mach_v850e2v3; - v850_hash = hash_new (); + v850_hash = str_htab_create (); /* Insert unique names into hash table. The V850 instruction set has many identical opcode names that have different opcodes based @@ -1964,7 +1964,8 @@ md_begin (void) if (strcmp (prev_name, op->name)) { prev_name = (char *) op->name; - hash_insert (v850_hash, op->name, (char *) op); + if (str_hash_find (v850_hash, op->name) == NULL) + str_hash_insert (v850_hash, op->name, (char *) op); } op++; } @@ -2321,7 +2322,7 @@ md_assemble (char *str) *s++ = '\0'; /* Find the first opcode with the proper name. */ - opcode = (struct v850_opcode *) hash_find (v850_hash, str); + opcode = (struct v850_opcode *) str_hash_find (v850_hash, str); if (opcode == NULL) { /* xgettext:c-format */ diff -rup binutils.orig/gas/config/tc-vax.c binutils-2.35/gas/config/tc-vax.c --- binutils.orig/gas/config/tc-vax.c 2021-08-11 17:33:12.212490350 +0100 +++ binutils-2.35/gas/config/tc-vax.c 2021-08-11 17:39:31.417057475 +0100 @@ -736,7 +736,7 @@ md_ri_to_chars (char *the_bytes, struct source file, and changed the makefile. */ /* Handle of the OPCODE hash table. */ -static struct hash_control *op_hash; +static htab_t op_hash; /* In: 1 character, from "bdfghloqpw" being the data-type of an operand of a vax instruction. @@ -950,29 +950,26 @@ vip_op_defaults (const char *immediate, instruction table. You must nominate metacharacters for eg DEC's "#", "@", "^". */ -static const char * +static void vip_begin (int synthetic_too, /* 1 means include jXXX op-codes. */ const char *immediate, const char *indirect, const char *displen) { const struct vot *vP; /* scan votstrs */ - const char *retval = 0; /* error text */ - op_hash = hash_new (); + op_hash = str_htab_create (); - for (vP = votstrs; *vP->vot_name && !retval; vP++) - retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail); + for (vP = votstrs; *vP->vot_name; vP++) + str_hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail); if (synthetic_too) - for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++) - retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail); + for (vP = synthetic_votstrs; *vP->vot_name; vP++) + str_hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail); #ifndef CONST_TABLE vip_op_defaults (immediate, indirect, displen); #endif - - return retval; } /* Take 3 char.s, the last of which may be `\0` (non-existent) @@ -1887,7 +1884,7 @@ vip (struct vit *vitP, /* We build an e /* Here with instring pointing to what better be an op-name, and p pointing to character just past that. We trust instring points to an op-name, with no whitespace. */ - vwP = (struct vot_wot *) hash_find (op_hash, instring); + vwP = (struct vot_wot *) str_hash_find (op_hash, instring); /* Restore char after op-code. */ *p = c; if (vwP == 0) @@ -1986,8 +1983,7 @@ main (void) printf ("enter displen symbols eg enter ^ "); gets (my_displen); - if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen)) - error ("vip_begin=%s", p); + vip_begin (mysynth, my_immediate, my_indirect, my_displen) printf ("An empty input line will quit you from the vax instruction parser\n"); for (;;) @@ -3256,12 +3252,10 @@ md_assemble (char *instruction_string) void md_begin (void) { - const char *errtxt; FLONUM_TYPE *fP; int i; - if ((errtxt = vip_begin (1, "$", "*", "`")) != 0) - as_fatal (_("VIP_BEGIN error:%s"), errtxt); + vip_begin (1, "$", "*", "`"); for (i = 0, fP = float_operand; fP < float_operand + VIT_MAX_OPERANDS; diff -rup binutils.orig/gas/config/tc-wasm32.c binutils-2.35/gas/config/tc-wasm32.c --- binutils.orig/gas/config/tc-wasm32.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-wasm32.c 2021-08-11 17:39:31.417057475 +0100 @@ -92,7 +92,7 @@ const pseudo_typeS md_pseudo_table[] = /* Opcode hash table. */ -static struct hash_control *wasm32_hash; +static htab_t wasm32_hash; struct option md_longopts[] = { @@ -158,13 +158,13 @@ md_begin (void) { struct wasm32_opcode_s *opcode; - wasm32_hash = hash_new (); + wasm32_hash = str_htab_create (); /* Insert unique names into hash table. This hash table then provides a quick index to the first opcode with a particular name in the opcode table. */ for (opcode = wasm32_opcodes; opcode->name; opcode++) - hash_insert (wasm32_hash, opcode->name, (char *) opcode); + str_hash_insert (wasm32_hash, opcode->name, (char *) opcode); linkrelax = 0; flag_sectname_subst = 1; @@ -746,7 +746,7 @@ md_assemble (char *str) if (!op[0]) as_bad (_("can't find opcode ")); - opcode = (struct wasm32_opcode_s *) hash_find (wasm32_hash, op); + opcode = (struct wasm32_opcode_s *) str_hash_find (wasm32_hash, op); if (opcode == NULL) { diff -rup binutils.orig/gas/config/tc-xgate.c binutils-2.35/gas/config/tc-xgate.c --- binutils.orig/gas/config/tc-xgate.c 2021-08-11 17:33:12.213490344 +0100 +++ binutils-2.35/gas/config/tc-xgate.c 2021-08-11 17:39:31.417057475 +0100 @@ -113,7 +113,7 @@ static void xgate_scan_operands (struct static unsigned int xgate_parse_operand (struct xgate_opcode *, int *, int, char **, s_operand); -static struct hash_control *xgate_hash; +static htab_t xgate_hash; /* Previous opcode. */ static unsigned int prev = 0; @@ -324,7 +324,7 @@ md_begin (void) op_handles = XNEWVEC (struct xgate_opcode_handle, number_of_op_handles); /* Insert unique opcode names into hash table, aliasing duplicates. */ - xgate_hash = hash_new (); + xgate_hash = str_htab_create (); prev_op_name = ""; for (xgate_opcode_ptr = xgate_op_table, i = 0, j = 0; i < xgate_num_opcodes; @@ -342,7 +342,7 @@ md_begin (void) j++; op_handles[j].name = xgate_opcode_ptr->name; op_handles[j].opc0[0] = xgate_opcode_ptr; - hash_insert (xgate_hash, (char *) op_handles[j].name, + str_hash_insert (xgate_hash, (char *) op_handles[j].name, (char *) &(op_handles[j])); } op_handles[j].number_of_modes = handle_enum; @@ -492,7 +492,7 @@ md_assemble (char *input_line) if (!op_name[0]) as_bad (_("opcode missing or not found on input line")); - if (!(opcode_handle = (struct xgate_opcode_handle *) hash_find (xgate_hash, + if (!(opcode_handle = (struct xgate_opcode_handle *) str_hash_find (xgate_hash, op_name))) { as_bad (_("opcode %s not found in opcode hash table"), op_name); @@ -544,7 +544,7 @@ md_assemble (char *input_line) p = extract_word (p, op_name, 10); if (!(opcode_handle = (struct xgate_opcode_handle *) - hash_find (xgate_hash, op_name))) + str_hash_find (xgate_hash, op_name))) { as_bad (_(": processing macro, real opcode handle" " not found in hash")); diff -rup binutils.orig/gas/config/tc-z8k.c binutils-2.35/gas/config/tc-z8k.c --- binutils.orig/gas/config/tc-z8k.c 2021-08-11 17:33:12.214490337 +0100 +++ binutils-2.35/gas/config/tc-z8k.c 2021-08-11 17:39:31.417057475 +0100 @@ -137,7 +137,7 @@ const char EXP_CHARS[] = "eE"; const char FLT_CHARS[] = "rRsSfFdDxXpP"; /* Opcode mnemonics. */ -static struct hash_control *opcode_hash_control; +static htab_t opcode_hash_control; void md_begin (void) @@ -145,13 +145,13 @@ md_begin (void) const opcode_entry_type *opcode; unsigned int idx = -1u; - opcode_hash_control = hash_new (); + opcode_hash_control = str_htab_create (); for (opcode = z8k_table; opcode->name; opcode++) { /* Only enter unique codes into the table. */ if (idx != opcode->idx) - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + str_hash_insert (opcode_hash_control, opcode->name, (char *) opcode); idx = opcode->idx; } @@ -166,7 +166,7 @@ md_begin (void) fake_opcode->name = md_pseudo_table[idx].poc_name; fake_opcode->func = (void *) (md_pseudo_table + idx); fake_opcode->opcode = 250; - hash_insert (opcode_hash_control, fake_opcode->name, fake_opcode); + str_hash_insert (opcode_hash_control, fake_opcode->name, fake_opcode); } } @@ -1224,9 +1224,9 @@ md_assemble (char *str) } c = *op_end; - *op_end = 0; /* Zero-terminate op code string for hash_find() call. */ + *op_end = 0; /* Zero-terminate op code string for str_hash_find() call. */ - opcode = (opcode_entry_type *) hash_find (opcode_hash_control, op_start); + opcode = (opcode_entry_type *) str_hash_find (opcode_hash_control, op_start); if (opcode == NULL) { diff -rup binutils.orig/gas/doc/as.texi binutils-2.35/gas/doc/as.texi --- binutils.orig/gas/doc/as.texi 2021-08-11 17:33:12.207490382 +0100 +++ binutils-2.35/gas/doc/as.texi 2021-08-11 17:41:32.630279947 +0100 @@ -238,7 +238,6 @@ gcc(1), ld(1), and the Info entries for [@b{--listing-cont-lines}=@var{NUM}] [@b{--keep-locals}] [@b{--no-pad-sections}] [@b{-o} @var{objfile}] [@b{-R}] - [@b{--hash-size}=@var{NUM}] [@b{--reduce-memory-overheads}] [@b{--statistics}] [@b{-v}] [@b{-version}] [@b{--version}] [@b{-W}] [@b{--warn}] [@b{--fatal-warnings}] [@b{-w}] [@b{-x}] @@ -875,18 +874,6 @@ Name the object-file output from @comman @item -R Fold the data section into the text section. -@item --hash-size=@var{number} -Set the default size of GAS's hash tables to a prime number close to -@var{number}. Increasing this value can reduce the length of time it takes the -assembler to perform its tasks, at the expense of increasing the assembler's -memory requirements. Similarly reducing this value can reduce the memory -requirements at the expense of speed. - -@item --reduce-memory-overheads -This option reduces GAS's memory requirements, at the expense of making the -assembly processes slower. Currently this switch is a synonym for -@samp{--hash-size=4051}, but in the future it may have other effects as well. - @ifset ELF @item --sectname-subst Honor substitution sequences in section names. diff -rup binutils.orig/gas/doc/internals.texi binutils-2.35/gas/doc/internals.texi --- binutils.orig/gas/doc/internals.texi 2021-08-11 17:33:12.206490389 +0100 +++ binutils-2.35/gas/doc/internals.texi 2021-08-11 17:41:32.630279947 +0100 @@ -1915,38 +1915,6 @@ type is narrow enough, a decimal number in hexadecimal. The value itself is not examined to make this determination. @end deftypefun -@node Hash tables -@subsection Hash tables -@cindex hash tables - -@deftypefun @{@} @{struct hash_control *@} hash_new (void) -Creates the hash table control structure. -@end deftypefun - -@deftypefun @{@} void hash_die (struct hash_control *) -Destroy a hash table. -@end deftypefun - -@deftypefun @{@} void *hash_delete (struct hash_control *, const char *, int) -Deletes entry from the hash table, returns the value it had. If the last -arg is non-zero, free memory allocated for this entry and all entries -allocated more recently than this entry. -@end deftypefun - -@deftypefun @{@} void *hash_replace (struct hash_control *, const char *, void *) -Updates the value for an entry already in the table, returning the old value. -If no entry was found, just returns NULL. -@end deftypefun - -@deftypefun @{@} @{const char *@} hash_insert (struct hash_control *, const char *, void *) -Inserting a value already in the table is an error. -Returns an error message or NULL. -@end deftypefun - -@deftypefun @{@} @{const char *@} hash_jam (struct hash_control *, const char *, void *) -Inserts if the value isn't already present, updates it if it is. -@end deftypefun - @node Test suite @section Test suite @cindex test suite diff -rup binutils.orig/gas/dw2gencfi.c binutils-2.35/gas/dw2gencfi.c --- binutils.orig/gas/dw2gencfi.c 2021-08-11 17:33:12.205490395 +0100 +++ binutils-2.35/gas/dw2gencfi.c 2021-08-11 17:39:16.182155202 +0100 @@ -115,7 +115,7 @@ static bfd_boolean compact_eh; #define compact_eh 0 #endif -static struct hash_control *dwcfi_hash; +static htab_t dwcfi_hash; /* Emit a single byte into the current segment. */ @@ -325,20 +325,10 @@ make_debug_seg (segT cseg, char *name, i return r; } -static void -dwcfi_hash_insert (const char *name, struct dwcfi_seg_list *item) -{ - const char *error_string; - - if ((error_string = hash_jam (dwcfi_hash, name, (char *) item))) - as_fatal (_("Inserting \"%s\" into structure table failed: %s"), - name, error_string); -} - static struct dwcfi_seg_list * dwcfi_hash_find (char *name) { - return (struct dwcfi_seg_list *) hash_find (dwcfi_hash, name); + return (struct dwcfi_seg_list *) str_hash_find (dwcfi_hash, name); } static struct dwcfi_seg_list * @@ -349,7 +339,7 @@ dwcfi_hash_find_or_make (segT cseg, cons /* Initialize dwcfi_hash once. */ if (!dwcfi_hash) - dwcfi_hash = hash_new (); + dwcfi_hash = str_htab_create (); name = get_debugseg_name (cseg, base_name); @@ -358,7 +348,7 @@ dwcfi_hash_find_or_make (segT cseg, cons { item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name); - dwcfi_hash_insert (item->seg_name, item); + str_hash_insert (dwcfi_hash, item->seg_name, (char *) item); } else free (name); diff -rup binutils.orig/gas/ecoff.c binutils-2.35/gas/ecoff.c --- binutils.orig/gas/ecoff.c 2021-08-11 17:33:12.203490408 +0100 +++ binutils-2.35/gas/ecoff.c 2021-08-11 17:39:23.430108707 +0100 @@ -946,7 +946,7 @@ typedef struct efdr { varray_t aux_syms; /* auxiliary symbols */ struct efdr *next_file; /* next file descriptor */ /* string/type hash tables */ - struct hash_control *str_hash; /* string hash table */ + htab_t str_hash; /* string hash table */ thash_t *thash_head[THASH_SIZE]; } efdr_t; @@ -994,7 +994,7 @@ static const efdr_t init_file = { (struct efdr *)0, /* next_file: next file structure */ - (struct hash_control *)0, /* str_hash: string hash table */ + (htab_t)0, /* str_hash: string hash table */ { 0 }, /* thash_head: type hash table */ }; @@ -1111,7 +1111,7 @@ static const type_info_t type_info_init static varray_t file_desc = INIT_VARRAY (efdr_t); -static struct hash_control *tag_hash; +static htab_t tag_hash; /* Static types for int and void. Also, remember the last function's type (which is set up when we encounter the declaration for the @@ -1408,7 +1408,7 @@ static char stabs_symbol[] = STABS_SYMBO static void add_varray_page (varray_t *vp); static symint_t add_string (varray_t *vp, - struct hash_control *hash_tbl, + htab_t hash_tbl, const char *str, shash_t **ret_hash); static localsym_t *add_ecoff_symbol (const char *str, st_t type, @@ -1475,7 +1475,7 @@ static lineno_list_t *allocate_lineno_li void ecoff_read_begin_hook (void) { - tag_hash = hash_new (); + tag_hash = str_htab_create (); top_tag_head = allocate_thead (); top_tag_head->first_tag = (tag_t *) NULL; top_tag_head->free = (thead_t *) NULL; @@ -1548,7 +1548,7 @@ add_varray_page (varray_t *vp /* varray static symint_t add_string (varray_t *vp, /* string obstack */ - struct hash_control *hash_tbl, /* ptr to hash table */ + htab_t hash_tbl, /* ptr to hash table */ const char *str, /* string */ shash_t **ret_hash /* return hash pointer */) { @@ -1558,11 +1558,9 @@ add_string (varray_t *vp, /* string ob if (len >= PAGE_USIZE) as_fatal (_("string too big (%lu bytes)"), len); - hash_ptr = (shash_t *) hash_find (hash_tbl, str); + hash_ptr = (shash_t *) str_hash_find (hash_tbl, str); if (hash_ptr == (shash_t *) NULL) { - const char *err; - if (vp->objects_last_page + len >= PAGE_USIZE) { vp->num_allocated = @@ -1580,10 +1578,7 @@ add_string (varray_t *vp, /* string ob strcpy (hash_ptr->string, str); - err = hash_insert (hash_tbl, str, (char *) hash_ptr); - if (err) - as_fatal (_("inserting \"%s\" into string hash table: %s"), - str, err); + str_hash_insert (hash_tbl, str, (char *) hash_ptr); } if (ret_hash != (shash_t **) NULL) @@ -2009,13 +2004,12 @@ get_tag (const char *tag, /* tag name */ bt_t basic_type /* bt_Struct, bt_Union, or bt_Enum */) { shash_t *hash_ptr; - const char *err; tag_t *tag_ptr; if (cur_file_ptr == (efdr_t *) NULL) as_fatal (_("no current file pointer")); - hash_ptr = (shash_t *) hash_find (tag_hash, tag); + hash_ptr = (shash_t *) str_hash_find (tag_hash, tag); if (hash_ptr != (shash_t *) NULL && hash_ptr->tag_ptr != (tag_t *) NULL) @@ -2036,10 +2030,7 @@ get_tag (const char *tag, /* tag name */ perm = xstrdup (tag); hash_ptr = allocate_shash (); - err = hash_insert (tag_hash, perm, (char *) hash_ptr); - if (err) - as_fatal (_("inserting \"%s\" into tag hash table: %s"), - tag, err); + str_hash_insert (tag_hash, perm, (char *) hash_ptr); hash_ptr->string = perm; } @@ -2281,7 +2272,7 @@ add_file (const char *file_name, int ind fil_ptr->fake = fake; /* Allocate the string hash table. */ - fil_ptr->str_hash = hash_new (); + fil_ptr->str_hash = str_htab_create (); /* Make sure 0 byte in string table is null */ add_string (&fil_ptr->strings, diff -rup binutils.orig/gas/hash.c binutils-2.35/gas/hash.c --- binutils.orig/gas/hash.c 2021-08-11 17:33:12.485488589 +0100 +++ binutils-2.35/gas/hash.c 2021-08-11 17:47:12.479099992 +0100 @@ -18,578 +18,28 @@ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ -/* This version of the hash table code is a wholescale replacement of - the old hash table code, which was fairly bad. This is based on - the hash table code in BFD, but optimized slightly for the - assembler. The assembler does not need to derive structures that - are stored in the hash table. Instead, it always stores a pointer. - The assembler uses the hash table mostly to store symbols, and we - don't need to confuse the symbol structure with a hash table - structure. */ - #include "as.h" -#include "safe-ctype.h" -#include "obstack.h" - -/* An entry in a hash table. */ - -struct hash_entry { - /* Next entry for this hash code. */ - struct hash_entry *next; - /* String being hashed. */ - const char *string; - /* Hash code. This is the full hash code, not the index into the - table. */ - unsigned long hash; - /* Pointer being stored in the hash table. */ - void *data; -}; - -/* A hash table. */ - -struct hash_control { - /* The hash array. */ - struct hash_entry **table; - /* The number of slots in the hash table. */ - unsigned int size; - /* An obstack for this hash table. */ - struct obstack memory; - -#ifdef HASH_STATISTICS - /* Statistics. */ - unsigned long lookups; - unsigned long hash_compares; - unsigned long string_compares; - unsigned long insertions; - unsigned long replacements; - unsigned long deletions; -#endif /* HASH_STATISTICS */ -}; - -/* The default number of entries to use when creating a hash table. - Note this value can be reduced to 4051 by using the command line - switch --reduce-memory-overheads, or set to other values by using - the --hash-size= switch. */ - -static unsigned long gas_hash_table_size = 65537; - -void -set_gas_hash_table_size (unsigned long size) -{ - gas_hash_table_size = bfd_hash_set_default_size (size); -} - -/* Create a hash table. This return a control block. */ - -struct hash_control * -hash_new_sized (unsigned long size) -{ - unsigned long alloc; - struct hash_control *ret; - - ret = XNEW (struct hash_control); - obstack_begin (&ret->memory, chunksize); - alloc = size * sizeof (struct hash_entry *); - ret->table = (struct hash_entry **) obstack_alloc (&ret->memory, alloc); - memset (ret->table, 0, alloc); - ret->size = size; - -#ifdef HASH_STATISTICS - ret->lookups = 0; - ret->hash_compares = 0; - ret->string_compares = 0; - ret->insertions = 0; - ret->replacements = 0; - ret->deletions = 0; -#endif - - return ret; -} - -struct hash_control * -hash_new (void) -{ - return hash_new_sized (gas_hash_table_size); -} - -/* Delete a hash table, freeing all allocated memory. */ - -void -hash_die (struct hash_control *table) -{ - obstack_free (&table->memory, 0); - free (table); -} - -/* Look up a string in a hash table. This returns a pointer to the - hash_entry, or NULL if the string is not in the table. If PLIST is - not NULL, this sets *PLIST to point to the start of the list which - would hold this hash entry. If PHASH is not NULL, this sets *PHASH - to the hash code for KEY. - - Each time we look up a string, we move it to the start of the list - for its hash code, to take advantage of referential locality. */ - -static struct hash_entry * -hash_lookup (struct hash_control *table, const char *key, size_t len, - struct hash_entry ***plist, unsigned long *phash) -{ - unsigned long hash; - size_t n; - unsigned int c; - unsigned int hindex; - struct hash_entry **list; - struct hash_entry *p; - struct hash_entry *prev; - -#ifdef HASH_STATISTICS - ++table->lookups; -#endif - - hash = 0; - for (n = 0; n < len; n++) - { - c = key[n]; - hash += c + (c << 17); - hash ^= hash >> 2; - } - hash += len + (len << 17); - hash ^= hash >> 2; - - if (phash != NULL) - *phash = hash; - - hindex = hash % table->size; - list = table->table + hindex; - - if (plist != NULL) - *plist = list; - - prev = NULL; - for (p = *list; p != NULL; p = p->next) - { -#ifdef HASH_STATISTICS - ++table->hash_compares; -#endif - - if (p->hash == hash) - { -#ifdef HASH_STATISTICS - ++table->string_compares; -#endif - - if (strncmp (p->string, key, len) == 0 && p->string[len] == '\0') - { - if (prev != NULL) - { - prev->next = p->next; - p->next = *list; - *list = p; - } - - return p; - } - } - - prev = p; - } - - return NULL; -} - -/* Insert an entry into a hash table. This returns NULL on success. - On error, it returns a printable string indicating the error. It - is considered to be an error if the entry already exists in the - hash table. */ - -const char * -hash_insert (struct hash_control *table, const char *key, void *val) -{ - struct hash_entry *p; - struct hash_entry **list; - unsigned long hash; - - p = hash_lookup (table, key, strlen (key), &list, &hash); - if (p != NULL) - return "exists"; - -#ifdef HASH_STATISTICS - ++table->insertions; -#endif - - p = (struct hash_entry *) obstack_alloc (&table->memory, sizeof (*p)); - p->string = key; - p->hash = hash; - p->data = val; - - p->next = *list; - *list = p; - - return NULL; -} - -/* Insert or replace an entry in a hash table. This returns NULL on - success. On error, it returns a printable string indicating the - error. If an entry already exists, its value is replaced. */ - -const char * -hash_jam (struct hash_control *table, const char *key, void *val) -{ - struct hash_entry *p; - struct hash_entry **list; - unsigned long hash; - - p = hash_lookup (table, key, strlen (key), &list, &hash); - if (p != NULL) - { -#ifdef HASH_STATISTICS - ++table->replacements; -#endif - - p->data = val; - } - else - { -#ifdef HASH_STATISTICS - ++table->insertions; -#endif - - p = (struct hash_entry *) obstack_alloc (&table->memory, sizeof (*p)); - p->string = key; - p->hash = hash; - p->data = val; - - p->next = *list; - *list = p; - } - - return NULL; -} - -/* Replace an existing entry in a hash table. This returns the old - value stored for the entry. If the entry is not found in the hash - table, this does nothing and returns NULL. */ - -void * -hash_replace (struct hash_control *table, const char *key, void *value) -{ - struct hash_entry *p; - void *ret; - - p = hash_lookup (table, key, strlen (key), NULL, NULL); - if (p == NULL) - return NULL; - -#ifdef HASH_STATISTICS - ++table->replacements; -#endif - - ret = p->data; - - p->data = value; - - return ret; -} - -/* Find an entry in a hash table, returning its value. Returns NULL - if the entry is not found. */ - -void * -hash_find (struct hash_control *table, const char *key) -{ - struct hash_entry *p; - - p = hash_lookup (table, key, strlen (key), NULL, NULL); - if (p == NULL) - return NULL; - - return p->data; -} - -/* As hash_find, but KEY is of length LEN and is not guaranteed to be - NUL-terminated. */ - -void * -hash_find_n (struct hash_control *table, const char *key, size_t len) -{ - struct hash_entry *p; - p = hash_lookup (table, key, len, NULL, NULL); - if (p == NULL) - return NULL; - - return p->data; -} - -/* Delete an entry from a hash table. This returns the value stored - for that entry, or NULL if there is no such entry. */ - -void * -hash_delete (struct hash_control *table, const char *key, int freeme) -{ - struct hash_entry *p; - struct hash_entry **list; - - p = hash_lookup (table, key, strlen (key), &list, NULL); - if (p == NULL) - return NULL; - - if (p != *list) - abort (); - -#ifdef HASH_STATISTICS - ++table->deletions; -#endif - - *list = p->next; - - if (freeme) - obstack_free (&table->memory, p); - - return p->data; -} - -/* Traverse a hash table. Call the function on every entry in the - hash table. */ +/* Insert ELEMENT into HTAB. If the element exists, it is overwritten. */ void -hash_traverse (struct hash_control *table, - void (*pfn) (const char *key, void *value)) +htab_insert (htab_t htab, PTR element) { - unsigned int i; - - for (i = 0; i < table->size; ++i) - { - struct hash_entry *p; + void **slot = htab_find_slot (htab, element, INSERT); + if (slot != NULL && htab->del_f) + (*htab->del_f) (*slot); - for (p = table->table[i]; p != NULL; p = p->next) - (*pfn) (p->string, p->data); - } + *slot = element; } -/* Print hash table statistics on the specified file. NAME is the - name of the hash table, used for printing a header. */ +/* Print statistics about a hash table. */ void -hash_print_statistics (FILE *f ATTRIBUTE_UNUSED, - const char *name ATTRIBUTE_UNUSED, - struct hash_control *table ATTRIBUTE_UNUSED) +htab_print_statistics (FILE *f, const char *name, htab_t table) { -#ifdef HASH_STATISTICS - unsigned int i; - unsigned long total; - unsigned long empty; - fprintf (f, "%s hash statistics:\n", name); - fprintf (f, "\t%lu lookups\n", table->lookups); - fprintf (f, "\t%lu hash comparisons\n", table->hash_compares); - fprintf (f, "\t%lu string comparisons\n", table->string_compares); - fprintf (f, "\t%lu insertions\n", table->insertions); - fprintf (f, "\t%lu replacements\n", table->replacements); - fprintf (f, "\t%lu deletions\n", table->deletions); - - total = 0; - empty = 0; - for (i = 0; i < table->size; ++i) - { - struct hash_entry *p; - - if (table->table[i] == NULL) - ++empty; - else - { - for (p = table->table[i]; p != NULL; p = p->next) - ++total; - } - } - - fprintf (f, "\t%g average chain length\n", (double) total / table->size); - fprintf (f, "\t%lu empty slots\n", empty); -#endif -} - -#ifdef TEST - -/* This test program is left over from the old hash table code. */ - -/* Number of hash tables to maintain (at once) in any testing. */ -#define TABLES (6) - -/* We can have 12 statistics. */ -#define STATBUFSIZE (12) - -/* Display statistics here. */ -int statbuf[STATBUFSIZE]; - -/* Human farts here. */ -char answer[100]; - -/* We test many hash tables at once. */ -char *hashtable[TABLES]; - -/* Points to current hash_control. */ -char *h; -char **pp; -char *p; -char *name; -char *value; -int size; -int used; -char command; - -/* Number 0:TABLES-1 of current hashed symbol table. */ -int number; - -int -main () -{ - void applicatee (); - void destroy (); - char *what (); - int *ip; - - number = 0; - h = 0; - printf ("type h for help\n"); - for (;;) - { - printf ("hash_test command: "); - gets (answer); - command = answer[0]; - command = TOLOWER (command); /* Ecch! */ - switch (command) - { - case '#': - printf ("old hash table #=%d.\n", number); - whattable (); - break; - case '?': - for (pp = hashtable; pp < hashtable + TABLES; pp++) - { - printf ("address of hash table #%d control block is %xx\n", - pp - hashtable, *pp); - } - break; - case 'a': - hash_traverse (h, applicatee); - break; - case 'd': - hash_traverse (h, destroy); - hash_die (h); - break; - case 'f': - p = hash_find (h, name = what ("symbol")); - printf ("value of \"%s\" is \"%s\"\n", name, p ? p : "NOT-PRESENT"); - break; - case 'h': - printf ("# show old, select new default hash table number\n"); - printf ("? display all hashtable control block addresses\n"); - printf ("a apply a simple display-er to each symbol in table\n"); - printf ("d die: destroy hashtable\n"); - printf ("f find value of nominated symbol\n"); - printf ("h this help\n"); - printf ("i insert value into symbol\n"); - printf ("j jam value into symbol\n"); - printf ("n new hashtable\n"); - printf ("r replace a value with another\n"); - printf ("s say what %% of table is used\n"); - printf ("q exit this program\n"); - printf ("x delete a symbol from table, report its value\n"); - break; - case 'i': - p = hash_insert (h, name = what ("symbol"), value = what ("value")); - if (p) - { - printf ("symbol=\"%s\" value=\"%s\" error=%s\n", name, value, - p); - } - break; - case 'j': - p = hash_jam (h, name = what ("symbol"), value = what ("value")); - if (p) - { - printf ("symbol=\"%s\" value=\"%s\" error=%s\n", name, value, p); - } - break; - case 'n': - h = hashtable[number] = (char *) hash_new (); - break; - case 'q': - exit (EXIT_SUCCESS); - case 'r': - p = hash_replace (h, name = what ("symbol"), value = what ("value")); - printf ("old value was \"%s\"\n", p ? p : "{}"); - break; - case 's': - hash_say (h, statbuf, STATBUFSIZE); - for (ip = statbuf; ip < statbuf + STATBUFSIZE; ip++) - { - printf ("%d ", *ip); - } - printf ("\n"); - break; - case 'x': - p = hash_delete (h, name = what ("symbol")); - printf ("old value was \"%s\"\n", p ? p : "{}"); - break; - default: - printf ("I can't understand command \"%c\"\n", command); - break; - } - } + fprintf (f, "\t%u searches\n", table->searches); + fprintf (f, "\t%u collisions\n", table->collisions); + fprintf (f, "\t%lu elements\n", (unsigned long) htab_elements (table)); + fprintf (f, "\t%lu table size\n", (unsigned long) htab_size (table)); } - -char * -what (description) - char *description; -{ - printf (" %s : ", description); - gets (answer); - return xstrdup (answer); -} - -void -destroy (string, value) - char *string; - char *value; -{ - free (string); - free (value); -} - -void -applicatee (string, value) - char *string; - char *value; -{ - printf ("%.20s-%.20s\n", string, value); -} - -/* Determine number: what hash table to use. - Also determine h: points to hash_control. */ - -void -whattable () -{ - for (;;) - { - printf (" what hash table (%d:%d) ? ", 0, TABLES - 1); - gets (answer); - sscanf (answer, "%d", &number); - if (number >= 0 && number < TABLES) - { - h = hashtable[number]; - if (!h) - { - printf ("warning: current hash-table-#%d. has no hash-control\n", number); - } - return; - } - else - { - printf ("invalid hash table number: %d\n", number); - } - } -} - -#endif /* TEST */ Only in binutils-2.35/gas: hash.c.orig Only in binutils-2.35/gas: hash.c.rej diff -rup binutils.orig/gas/hash.h binutils-2.35/gas/hash.h --- binutils.orig/gas/hash.h 2021-08-11 17:33:12.203490408 +0100 +++ binutils-2.35/gas/hash.h 2021-08-11 17:50:49.581707254 +0100 @@ -21,68 +21,101 @@ #ifndef HASH_H #define HASH_H -struct hash_control; +/* Insert ELEMENT into HTAB. If REPLACE is non-zero existing elements + are overwritten. If ELEMENT already exists, a pointer to the slot + is returned. Otherwise NULL is returned. */ + +extern void htab_insert (htab_t, void * /* element */); + +/* Print statistics about a hash table. */ + +extern void htab_print_statistics (FILE *f, const char *name, htab_t table); + +/* String hash table functions. */ + +struct string_tuple +{ + const char *key; + char *value; +}; + +typedef struct string_tuple string_tuple_t; + +/* Hash function for a string_tuple. */ + +static hashval_t +hash_string_tuple (const void *e) +{ + string_tuple_t *tuple = (string_tuple_t *) e; + return htab_hash_string (tuple->key); +} + +/* Equality function for a string_tuple. */ + +static int +eq_string_tuple (const void *a, const void *b) +{ + const string_tuple_t *ea = (const string_tuple_t *) a; + const string_tuple_t *eb = (const string_tuple_t *) b; + + return strcmp (ea->key, eb->key) == 0; +} + +static inline string_tuple_t * +string_tuple_alloc (const char *key, char *value) +{ + string_tuple_t *tuple = XNEW (string_tuple_t); + tuple->key = key; + tuple->value = value; + return tuple; +} + +static inline void * +str_hash_find (htab_t table, const char *key) +{ + string_tuple_t needle = { key, NULL }; + string_tuple_t *tuple = htab_find (table, &needle); + return tuple != NULL ? tuple->value : NULL; +} + +static inline void * +str_hash_find_n (htab_t table, const char *key, size_t n) +{ + char *tmp = XNEWVEC (char, n + 1); + memcpy (tmp, key, n); + tmp[n] = '\0'; + string_tuple_t needle = { tmp, NULL }; + string_tuple_t *tuple = htab_find (table, &needle); + free (tmp); + return tuple != NULL ? tuple->value : NULL; +} + +static inline void +str_hash_delete (htab_t table, const char *key) +{ + string_tuple_t needle = { key, NULL }; + htab_remove_elt (table, &needle); +} + +static inline void +str_hash_insert (htab_t table, const char *key, void *value) +{ + htab_insert (table, string_tuple_alloc (key, value)); +} + +static inline htab_t +str_htab_create (void) +{ + return htab_create_alloc (16, hash_string_tuple, eq_string_tuple, + NULL, xcalloc, free); +} -/* Set the size of the hash table used. */ +/* Insert ELEMENT into HTAB. If the element exists, it is overwritten. */ -void set_gas_hash_table_size (unsigned long); +extern void htab_insert (htab_t, void *); -/* Create a hash table. This return a control block. */ +/* Print statistics about a hash table. */ -extern struct hash_control *hash_new (void); -extern struct hash_control *hash_new_sized (unsigned long); - -/* Delete a hash table, freeing all allocated memory. */ - -extern void hash_die (struct hash_control *); - -/* Insert an entry into a hash table. This returns NULL on success. - On error, it returns a printable string indicating the error. It - is considered to be an error if the entry already exists in the - hash table. */ - -extern const char *hash_insert (struct hash_control *, - const char *key, void *value); - -/* Insert or replace an entry in a hash table. This returns NULL on - success. On error, it returns a printable string indicating the - error. If an entry already exists, its value is replaced. */ - -extern const char *hash_jam (struct hash_control *, - const char *key, void *value); - -/* Replace an existing entry in a hash table. This returns the old - value stored for the entry. If the entry is not found in the hash - table, this does nothing and returns NULL. */ - -extern void *hash_replace (struct hash_control *, const char *key, - void *value); - -/* Find an entry in a hash table, returning its value. Returns NULL - if the entry is not found. */ - -extern void *hash_find (struct hash_control *, const char *key); - -/* As hash_find, but KEY is of length LEN and is not guaranteed to be - NUL-terminated. */ - -extern void *hash_find_n (struct hash_control *, const char *key, size_t len); - -/* Delete an entry from a hash table. This returns the value stored - for that entry, or NULL if there is no such entry. */ - -extern void *hash_delete (struct hash_control *, const char *key, int); - -/* Traverse a hash table. Call the function on every entry in the - hash table. */ - -extern void hash_traverse (struct hash_control *, - void (*pfn) (const char *key, void *value)); - -/* Print hash table statistics on the specified file. NAME is the - name of the hash table, used for printing a header. */ - -extern void hash_print_statistics (FILE *, const char *name, - struct hash_control *); +extern void htab_print_statistics (FILE *f, const char *name, htab_t table); #endif /* HASH_H */ Only in binutils-2.35/gas: hash.h.orig Only in binutils-2.35/gas: hash.h.rej diff -rup binutils.orig/gas/macro.c binutils-2.35/gas/macro.c --- binutils.orig/gas/macro.c 2021-08-11 17:33:12.204490402 +0100 +++ binutils-2.35/gas/macro.c 2021-08-11 17:43:57.989347554 +0100 @@ -44,7 +44,7 @@ /* The macro hash table. */ -struct hash_control *macro_hash; +struct htab *macro_hash; /* Whether any macros have been defined. */ @@ -76,7 +76,8 @@ void macro_init (int alternate, int mri, int strip_at, size_t (*exp) (const char *, size_t, sb *, offsetT *)) { - macro_hash = hash_new (); + macro_hash = htab_create_alloc (16, hash_macro_entry, eq_macro_entry, + NULL, xcalloc, free); macro_defined = 0; macro_alternate = alternate; macro_mri = mri; @@ -566,8 +567,8 @@ do_formals (macro_entry *macro, size_t i } /* Add to macro's hash table. */ - if (! hash_find (macro->formal_hash, name)) - hash_jam (macro->formal_hash, name, formal); + if (formal_entry_find (macro->formal_hash, name) == NULL) + htab_insert (macro->formal_hash, formal_entry_alloc (name, formal)); else as_bad_where (macro->file, macro->line, @@ -605,13 +606,13 @@ do_formals (macro_entry *macro, size_t i sb_add_string (&formal->name, name); /* Add to macro's hash table. */ - if (hash_find (macro->formal_hash, name)) + if (formal_entry_find (macro->formal_hash, name)) as_bad_where (macro->file, macro->line, _("Reserved word `%s' used as parameter in macro `%s'"), name, macro->name); - hash_jam (macro->formal_hash, name, formal); + htab_insert (macro->formal_hash, formal_entry_alloc (name, formal)); formal->index = NARG_INDEX; *p = formal; @@ -635,7 +636,7 @@ free_macro (macro_entry *macro) formal = formal->next; del_formal (f); } - hash_die (macro->formal_hash); + htab_delete (macro->formal_hash); sb_kill (¯o->sub); free (macro); } @@ -662,7 +663,8 @@ define_macro (size_t idx, sb *in, sb *la macro->formal_count = 0; macro->formals = 0; - macro->formal_hash = hash_new_sized (7); + macro->formal_hash = htab_create_alloc (7, hash_formal_entry, eq_formal_entry, + NULL, xcalloc, free); idx = sb_skip_white (idx, in); if (! buffer_and_nest ("MACRO", "ENDM", ¯o->sub, get_line)) @@ -707,10 +709,10 @@ define_macro (size_t idx, sb *in, sb *la /* And stick it in the macro hash table. */ for (idx = 0; idx < name.len; idx++) name.ptr[idx] = TOLOWER (name.ptr[idx]); - if (hash_find (macro_hash, macro->name)) + if (macro_entry_find (macro_hash, macro->name)) error = _("Macro `%s' was already defined"); if (!error) - error = hash_jam (macro_hash, macro->name, (void *) macro); + htab_insert (macro_hash, macro_entry_alloc (macro->name, macro)); if (namep != NULL) *namep = macro->name; @@ -740,7 +742,7 @@ get_apost_token (size_t idx, sb *in, sb /* Substitute the actual value for a formal parameter. */ static size_t -sub_actual (size_t start, sb *in, sb *t, struct hash_control *formal_hash, +sub_actual (size_t start, sb *in, sb *t, struct htab *formal_hash, int kind, sb *out, int copyifnotthere) { size_t src; @@ -754,7 +756,7 @@ sub_actual (size_t start, sb *in, sb *t, && (src == start || in->ptr[src - 1] != '@')) ptr = NULL; else - ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (t)); + ptr = formal_entry_find (formal_hash, sb_terminate (t)); if (ptr) { if (ptr->actual.len) @@ -790,7 +792,7 @@ sub_actual (size_t start, sb *in, sb *t, static const char * macro_expand_body (sb *in, sb *out, formal_entry *formals, - struct hash_control *formal_hash, const macro_entry *macro) + struct htab *formal_hash, const macro_entry *macro) { sb t; size_t src = 0; @@ -912,7 +914,7 @@ macro_expand_body (sb *in, sb *out, form src = get_token (src, in, &f->name); name = sb_terminate (&f->name); - if (! hash_find (formal_hash, name)) + if (formal_entry_find (formal_hash, name) == NULL) { static int loccnt; char buf[20]; @@ -924,9 +926,7 @@ macro_expand_body (sb *in, sb *out, form sprintf (buf, IS_ELF ? ".LL%04x" : "LL%04x", ++loccnt); sb_add_string (&f->actual, buf); - err = hash_jam (formal_hash, name, f); - if (err != NULL) - break; + htab_insert (formal_hash, formal_entry_alloc (name, f)); } else { @@ -966,7 +966,7 @@ macro_expand_body (sb *in, sb *out, form sb_reset (&t); src = get_token (src + 2, in, &t); - ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (&t)); + ptr = formal_entry_find (formal_hash, sb_terminate (&t)); if (ptr == NULL) { /* FIXME: We should really return a warning string here, @@ -1010,7 +1010,8 @@ macro_expand_body (sb *in, sb *out, form f = loclist->next; name = sb_terminate (&loclist->name); - hash_delete (formal_hash, name, f == NULL); + formal_hash_entry_t needle = { name, NULL }; + htab_remove_elt (formal_hash, &needle); del_formal (loclist); loclist = f; } @@ -1095,7 +1096,7 @@ macro_expand (size_t idx, sb *in, macro_ } /* Lookup the formal in the macro's list. */ - ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t)); + ptr = formal_entry_find (m->formal_hash, sb_terminate (&t)); if (!ptr) { as_bad (_("Parameter named `%s' does not exist for macro `%s'"), @@ -1193,7 +1194,7 @@ macro_expand (size_t idx, sb *in, macro_ sb_reset (&t); sb_add_string (&t, macro_strip_at ? "$NARG" : "NARG"); - ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t)); + ptr = formal_entry_find (m->formal_hash, sb_terminate (&t)); sprintf (buffer, "%d", narg); sb_add_string (&ptr->actual, buffer); } @@ -1253,7 +1254,7 @@ check_macro (const char *line, sb *expan for (cls = copy; *cls != '\0'; cls ++) *cls = TOLOWER (*cls); - macro = (macro_entry *) hash_find (macro_hash, copy); + macro = macro_entry_find (macro_hash, copy); free (copy); if (macro == NULL) @@ -1294,14 +1295,14 @@ delete_macro (const char *name) /* We can only ask hash_delete to free memory if we are deleting macros in reverse order to their definition. So just clear out the entry. */ - if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL) + macro = macro_entry_find (macro_hash, copy); + if (macro) { - hash_jam (macro_hash, copy, NULL); + htab_insert (macro_hash, macro_entry_alloc (copy, NULL)); free_macro (macro); } else as_warn (_("Attempt to purge non-existing macro `%s'"), copy); - free (copy); } /* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a @@ -1313,8 +1314,8 @@ expand_irp (int irpc, size_t idx, sb *in { sb sub; formal_entry f; - struct hash_control *h; - const char *err; + struct htab *h; + const char *err = NULL; idx = sb_skip_white (idx, in); @@ -1330,10 +1331,10 @@ expand_irp (int irpc, size_t idx, sb *in if (f.name.len == 0) return _("missing model parameter"); - h = hash_new (); - err = hash_jam (h, sb_terminate (&f.name), &f); - if (err != NULL) - return err; + h = htab_create_alloc (16, hash_formal_entry, eq_formal_entry, + NULL, xcalloc, free); + + htab_insert (h, formal_entry_alloc (sb_terminate (&f.name), &f)); f.index = 1; f.next = NULL; @@ -1392,7 +1393,7 @@ expand_irp (int irpc, size_t idx, sb *in } } - hash_die (h); + htab_delete (h); sb_kill (&f.actual); sb_kill (&f.def); sb_kill (&f.name); diff -rup binutils.orig/gas/macro.h binutils-2.35/gas/macro.h --- binutils.orig/gas/macro.h 2021-08-11 17:33:12.484488595 +0100 +++ binutils-2.35/gas/macro.h 2021-08-11 17:43:57.989347554 +0100 @@ -63,7 +63,7 @@ typedef struct macro_struct sb sub; /* Substitution text. */ int formal_count; /* Number of formal args. */ formal_entry *formals; /* Pointer to list of formal_structs. */ - struct hash_control *formal_hash; /* Hash table of formals. */ + struct htab *formal_hash; /* Hash table of formals. */ const char *name; /* Macro name. */ const char *file; /* File the macro was defined in. */ unsigned int line; /* Line number of definition. */ @@ -79,7 +79,97 @@ extern int macro_nest; /* The macro hash table. */ -extern struct hash_control *macro_hash; +extern struct htab *macro_hash; + +struct macro_hash_entry +{ + const char *name; + macro_entry *macro; +}; + +typedef struct macro_hash_entry macro_hash_entry_t; + +/* Hash function for a macro_hash_entry. */ + +static inline hashval_t +hash_macro_entry (const void *e) +{ + const macro_hash_entry_t *entry = (const macro_hash_entry_t *) e; + return htab_hash_string (entry->name); +} + +/* Equality function for a macro_hash_entry. */ + +static inline int +eq_macro_entry (const void *a, const void *b) +{ + const macro_hash_entry_t *ea = (const macro_hash_entry_t *) a; + const macro_hash_entry_t *eb = (const macro_hash_entry_t *) b; + + return strcmp (ea->name, eb->name) == 0; +} + +static inline macro_hash_entry_t * +macro_entry_alloc (const char *name, macro_entry *macro) +{ + macro_hash_entry_t *entry = XNEW (macro_hash_entry_t); + entry->name = name; + entry->macro = macro; + return entry; +} + +static inline macro_entry * +macro_entry_find (htab_t table, const char *name) +{ + macro_hash_entry_t needle = { name, NULL }; + macro_hash_entry_t *entry = htab_find (table, &needle); + return entry != NULL ? entry->macro : NULL; +} + +struct formal_hash_entry +{ + const char *name; + formal_entry *formal; +}; + +typedef struct formal_hash_entry formal_hash_entry_t; + +/* Hash function for a macro_hash_entry. */ + +static inline hashval_t +hash_formal_entry (const void *e) +{ + const formal_hash_entry_t *entry = (const formal_hash_entry_t *) e; + return htab_hash_string (entry->name); +} + +/* Equality function for a formal_hash_entry. */ + +static inline int +eq_formal_entry (const void *a, const void *b) +{ + const formal_hash_entry_t *ea = (const formal_hash_entry_t *) a; + const formal_hash_entry_t *eb = (const formal_hash_entry_t *) b; + + return strcmp (ea->name, eb->name) == 0; +} + +static inline formal_hash_entry_t * +formal_entry_alloc (const char *name, formal_entry *formal) +{ + formal_hash_entry_t *entry = XNEW (formal_hash_entry_t); + entry->name = name; + entry->formal = formal; + return entry; +} + +static inline formal_entry * +formal_entry_find (htab_t table, const char *name) +{ + formal_hash_entry_t needle = { name, NULL }; + formal_hash_entry_t *entry = htab_find (table, &needle); + return entry != NULL ? entry->formal : NULL; +} extern int buffer_and_nest (const char *, const char *, sb *, size_t (*) (sb *)); diff -rup binutils.orig/gas/read.c binutils-2.35/gas/read.c --- binutils.orig/gas/read.c 2021-08-11 17:33:12.205490395 +0100 +++ binutils-2.35/gas/read.c 2021-08-11 17:44:41.265069954 +0100 @@ -293,7 +293,53 @@ address_bytes (void) /* Set up pseudo-op tables. */ -static struct hash_control *po_hash; +struct po_entry +{ + const char *poc_name; + + const pseudo_typeS *pop; +}; + +typedef struct po_entry po_entry_t; + +/* Hash function for a po_entry. */ + +static hashval_t +hash_po_entry (const void *e) +{ + const po_entry_t *entry = (const po_entry_t *) e; + return htab_hash_string (entry->poc_name); +} + +/* Equality function for a po_entry. */ + +static int +eq_po_entry (const void *a, const void *b) +{ + const po_entry_t *ea = (const po_entry_t *) a; + const po_entry_t *eb = (const po_entry_t *) b; + + return strcmp (ea->poc_name, eb->poc_name) == 0; +} + +static po_entry_t * +po_entry_alloc (const char *poc_name, const pseudo_typeS *pop) +{ + po_entry_t *entry = XNEW (po_entry_t); + entry->poc_name = poc_name; + entry->pop = pop; + return entry; +} + +static const pseudo_typeS * +po_entry_find (htab_t table, const char *poc_name) +{ + po_entry_t needle = { poc_name, NULL }; + po_entry_t *entry = htab_find (table, &needle); + return entry != NULL ? entry->pop : NULL; +} + +static struct htab *po_hash; static const pseudo_typeS potable[] = { {"abort", s_abort, 0}, @@ -512,14 +558,14 @@ static const char *pop_table_name; void pop_insert (const pseudo_typeS *table) { - const char *errtxt; const pseudo_typeS *pop; for (pop = table; pop->poc_name; pop++) { - errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop); - if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists"))) - as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name, - errtxt); + int exists = po_entry_find (po_hash, pop->poc_name) != NULL; + if (!pop_override_ok && exists) + as_fatal (_("error constructing %s pseudo-op table"), pop_table_name); + else if (!exists) + htab_insert (po_hash, po_entry_alloc (pop->poc_name, pop)); } } @@ -538,7 +584,8 @@ pop_insert (const pseudo_typeS *table) static void pobegin (void) { - po_hash = hash_new (); + po_hash = htab_create_alloc (16, hash_po_entry, eq_po_entry, NULL, + xcalloc, xfree); /* Do the target-specific pseudo ops. */ pop_table_name = "md"; @@ -817,7 +864,7 @@ read_a_source_file (const char *name) char next_char; char *s; /* String of symbol, '\0' appended. */ int temp; - pseudo_typeS *pop; + const pseudo_typeS *pop; #ifdef WARN_COMMENTS found_comment = 0; @@ -1067,7 +1114,7 @@ read_a_source_file (const char *name) { /* The MRI assembler uses pseudo-ops without a period. */ - pop = (pseudo_typeS *) hash_find (po_hash, s); + pop = po_entry_find (po_hash, s); if (pop != NULL && pop->poc_handler == NULL) pop = NULL; } @@ -1082,7 +1129,7 @@ read_a_source_file (const char *name) already know that the pseudo-op begins with a '.'. */ if (pop == NULL) - pop = (pseudo_typeS *) hash_find (po_hash, s + 1); + pop = po_entry_find (po_hash, s + 1); if (pop && !pop->poc_handler) pop = NULL; @@ -2723,10 +2770,10 @@ s_macro (int ignore ATTRIBUTE_UNUSED) } if (((NO_PSEUDO_DOT || flag_m68k_mri) - && hash_find (po_hash, name) != NULL) + && po_entry_find (po_hash, name) != NULL) || (!flag_m68k_mri && *name == '.' - && hash_find (po_hash, name + 1) != NULL)) + && po_entry_find (po_hash, name + 1) != NULL)) as_warn_where (file, line, _("attempt to redefine pseudo-op `%s' ignored"), @@ -6112,7 +6159,7 @@ s_ignore (int arg ATTRIBUTE_UNUSED) void read_print_statistics (FILE *file) { - hash_print_statistics (file, "pseudo-op table", po_hash); + htab_print_statistics (file, "pseudo-op table", po_hash); } /* Inserts the given line into the input stream. Only in binutils-2.35/gas: read.c.orig Only in binutils-2.35/gas: read.c.rej diff -rup binutils.orig/gas/symbols.c binutils-2.35/gas/symbols.c --- binutils.orig/gas/symbols.c 2021-08-11 17:33:12.486488583 +0100 +++ binutils-2.35/gas/symbols.c 2021-08-11 17:44:52.579997372 +0100 @@ -151,6 +151,57 @@ struct local_symbol #endif }; +struct symbol_entry +{ + const char *symbol_name; + hashval_t hash; + void *symbol; +}; + +typedef struct symbol_entry symbol_entry_t; + +/* Hash function for a symbol_entry. */ + +static hashval_t +hash_symbol_entry (const void *e) +{ + symbol_entry_t *entry = (symbol_entry_t *) e; + if (entry->hash == 0) + entry->hash = htab_hash_string (entry->symbol_name); + + return entry->hash; +} + +/* Equality function for a symbol_entry. */ + +static int +eq_symbol_entry (const void *a, const void *b) +{ + const symbol_entry_t *ea = (const symbol_entry_t *) a; + const symbol_entry_t *eb = (const symbol_entry_t *) b; + + return strcmp (ea->symbol_name, eb->symbol_name) == 0; +} + +static symbol_entry_t * +symbol_entry_alloc (const char *symbol_name, void *symbol) +{ + symbol_entry_t *entry = XNEW (symbol_entry_t); + entry->symbol_name = symbol_name; + entry->hash = 0; + entry->symbol = symbol; + return entry; +} + +static void * +symbol_entry_find (htab_t table, const char *symbol_name) +{ + symbol_entry_t needle = { symbol_name, 0, NULL }; + symbol_entry_t *entry = htab_find (table, &needle); + return entry != NULL ? entry->symbol : NULL; +} + + #define local_symbol_converted_p(l) ((l)->lsy_section == reg_section) #define local_symbol_mark_converted(l) ((l)->lsy_section = reg_section) #define local_symbol_resolved_p(l) ((l)->lsy_flags.sy_resolved) @@ -169,10 +220,10 @@ extern int new_broken_words; #endif /* symbol-name => struct symbol pointer */ -static struct hash_control *sy_hash; +static htab_t sy_hash; /* Table of local symbols. */ -static struct hash_control *local_hash; +static htab_t local_hash; /* Below are commented in "symbols.h". */ symbolS *symbol_rootP; @@ -340,7 +391,7 @@ local_symbol_make (const char *name, seg local_symbol_set_frag (ret, frag); ret->lsy_value = val; - hash_jam (local_hash, name_copy, (void *) ret); + htab_insert (local_hash, symbol_entry_alloc (name_copy, ret)); return ret; } @@ -377,7 +428,7 @@ local_symbol_convert (struct local_symbo local_symbol_mark_converted (locsym); local_symbol_set_real_symbol (locsym, ret); - hash_jam (local_hash, locsym->lsy_name, NULL); + htab_insert (local_hash, symbol_entry_alloc (locsym->lsy_name, NULL)); return ret; } @@ -616,26 +667,16 @@ colon (/* Just seen "x:" - rattle symbol void symbol_table_insert (symbolS *symbolP) { - const char *error_string; - know (symbolP); know (S_GET_NAME (symbolP)); if (LOCAL_SYMBOL_CHECK (symbolP)) - { - error_string = hash_jam (local_hash, S_GET_NAME (symbolP), - (void *) symbolP); - if (error_string != NULL) - as_fatal (_("inserting \"%s\" into symbol table failed: %s"), - S_GET_NAME (symbolP), error_string); - return; - } - - if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (void *) symbolP))) - { - as_fatal (_("inserting \"%s\" into symbol table failed: %s"), - S_GET_NAME (symbolP), error_string); - } /* on error */ + htab_insert (local_hash, + symbol_entry_alloc (S_GET_NAME (symbolP), + (struct local_symbol *)symbolP)); + else + htab_insert (sy_hash, symbol_entry_alloc (S_GET_NAME (symbolP), + (struct local_symbol *)symbolP)); } /* If a symbol name does not exist, create it as undefined, and insert @@ -869,14 +910,11 @@ symbol_find_exact (const char *name) symbolS * symbol_find_exact_noref (const char *name, int noref) { - struct local_symbol *locsym; - symbolS* sym; + symbolS *sym = symbol_entry_find (local_hash, name); + if (sym) + return sym; - locsym = (struct local_symbol *) hash_find (local_hash, name); - if (locsym != NULL) - return (symbolS *) locsym; - - sym = ((symbolS *) hash_find (sy_hash, name)); + sym = symbol_entry_find (sy_hash, name); /* Any references to the symbol, except for the reference in .weakref, must clear this flag, such that the symbol does not @@ -1670,15 +1708,16 @@ resolve_symbol_value (symbolS *symp) return final_val; } -static void resolve_local_symbol (const char *, void *); - /* A static function passed to hash_traverse. */ -static void -resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value) +static int +resolve_local_symbol (void **slot, void *arg ATTRIBUTE_UNUSED) { - if (value != NULL) - resolve_symbol_value ((symbolS *) value); + symbol_entry_t *entry = *((symbol_entry_t **) slot); + if (entry->symbol != NULL) + resolve_symbol_value ((symbolS *) entry->symbol); + + return 1; } /* Resolve all local symbols. */ @@ -1686,7 +1725,7 @@ resolve_local_symbol (const char *key AT void resolve_local_symbol_values (void) { - hash_traverse (local_hash, resolve_local_symbol); + htab_traverse (local_hash, resolve_local_symbol, NULL); } /* Obtain the current value of a symbol without changing any @@ -2988,8 +3027,10 @@ symbol_begin (void) { symbol_lastP = NULL; symbol_rootP = NULL; /* In case we have 0 symbols (!!) */ - sy_hash = hash_new (); - local_hash = hash_new (); + sy_hash = htab_create_alloc (16, hash_symbol_entry, eq_symbol_entry, + NULL, xcalloc, free); + local_hash = htab_create_alloc (16, hash_symbol_entry, eq_symbol_entry, + NULL, xcalloc, free); memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol)); #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL) @@ -3244,8 +3285,8 @@ print_expr (expressionS *exp) void symbol_print_statistics (FILE *file) { - hash_print_statistics (file, "symbol table", sy_hash); - hash_print_statistics (file, "mini local symbol table", local_hash); + htab_print_statistics (file, "symbol table", sy_hash); + htab_print_statistics (file, "mini local symbol table", local_hash); fprintf (file, "%lu mini local symbols created, %lu converted\n", local_symbol_count, local_symbol_conversion_count); }