From ccd7a4b83f4fea9c06c89470a2b17ce217292e2d Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Oct 05 2021 20:16:55 +0000 Subject: import gcc-toolset-10-binutils-2.35-8.el8_4.4 --- diff --git a/SOURCES/binutils-CVE-2021-20197.patch b/SOURCES/binutils-CVE-2021-20197.patch new file mode 100644 index 0000000..4e9be45 --- /dev/null +++ b/SOURCES/binutils-CVE-2021-20197.patch @@ -0,0 +1,778 @@ +diff -rup binutils.orig/bfd/bfd-in2.h binutils-2.35.1/bfd/bfd-in2.h +--- binutils.orig/bfd/bfd-in2.h 2021-01-29 11:14:51.848568548 +0000 ++++ binutils-2.35.1/bfd/bfd-in2.h 2021-01-29 11:15:33.431322133 +0000 +@@ -583,6 +583,8 @@ bfd *bfd_openr (const char *filename, co + + bfd *bfd_fdopenr (const char *filename, const char *target, int fd); + ++bfd *bfd_fdopenw (const char *filename, const char *target, int fd); ++ + bfd *bfd_openstreamr (const char * filename, const char * target, + void * stream); + +diff -rup binutils.orig/bfd/opncls.c binutils-2.35.1/bfd/opncls.c +--- binutils.orig/bfd/opncls.c 2021-01-29 11:14:51.846568560 +0000 ++++ binutils-2.35.1/bfd/opncls.c 2021-01-29 11:15:33.431322133 +0000 +@@ -395,6 +395,39 @@ bfd_fdopenr (const char *filename, const + + /* + FUNCTION ++ bfd_fdopenw ++ ++SYNOPSIS ++ bfd *bfd_fdopenw (const char *filename, const char *target, int fd); ++ ++DESCRIPTION ++ <> is exactly like <> with the exception that ++ the resulting BFD is suitable for output. ++*/ ++ ++bfd * ++bfd_fdopenw (const char *filename, const char *target, int fd) ++{ ++ bfd *out = bfd_fdopenr (filename, target, fd); ++ ++ if (out != NULL) ++ { ++ if (!bfd_write_p (out)) ++ { ++ close (fd); ++ _bfd_delete_bfd (out); ++ out = NULL; ++ bfd_set_error (bfd_error_invalid_operation); ++ } ++ else ++ out->direction = write_direction; ++ } ++ ++ return out; ++} ++ ++/* ++FUNCTION + bfd_openstreamr + + SYNOPSIS +diff -rup binutils.orig/binutils/ar.c binutils-2.35.1/binutils/ar.c +--- binutils.orig/binutils/ar.c 2021-01-29 11:14:51.344571539 +0000 ++++ binutils-2.35.1/binutils/ar.c 2021-01-29 11:15:56.174187367 +0000 +@@ -25,6 +25,7 @@ + + #include "sysdep.h" + #include "bfd.h" ++#include "libbfd.h" + #include "libiberty.h" + #include "progress.h" + #include "getopt.h" +@@ -1195,20 +1196,26 @@ write_archive (bfd *iarch) + bfd *obfd; + char *old_name, *new_name; + bfd *contents_head = iarch->archive_next; ++ int ofd = -1; ++ struct stat target_stat; ++ bfd_boolean skip_stat = FALSE; + + old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1); + strcpy (old_name, bfd_get_filename (iarch)); +- new_name = make_tempname (old_name); ++ new_name = make_tempname (old_name, &ofd); + + if (new_name == NULL) + bfd_fatal (_("could not create temporary file whilst writing archive")); + + output_filename = new_name; + +- obfd = bfd_openw (new_name, bfd_get_target (iarch)); ++ obfd = bfd_fdopenw (new_name, bfd_get_target (iarch), ofd); + + if (obfd == NULL) +- bfd_fatal (old_name); ++ { ++ close (ofd); ++ bfd_fatal (old_name); ++ } + + output_bfd = obfd; + +@@ -1237,6 +1244,14 @@ write_archive (bfd *iarch) + if (!bfd_set_archive_head (obfd, contents_head)) + bfd_fatal (old_name); + ++#if !defined (_WIN32) || defined (__CYGWIN32__) ++ ofd = dup (ofd); ++ if (iarch == NULL || iarch->iostream == NULL) ++ skip_stat = TRUE; ++ else if (ofd == -1 || fstat (fileno (iarch->iostream), &target_stat) != 0) ++ bfd_fatal (old_name); ++#endif ++ + if (!bfd_close (obfd)) + bfd_fatal (old_name); + +@@ -1246,7 +1261,7 @@ write_archive (bfd *iarch) + /* We don't care if this fails; we might be creating the archive. */ + bfd_close (iarch); + +- if (smart_rename (new_name, old_name, 0) != 0) ++ if (smart_rename (new_name, old_name, ofd, skip_stat ? NULL : &target_stat, 0) != 0) + xexit (1); + free (old_name); + free (new_name); +diff -rup binutils.orig/binutils/arsup.c binutils-2.35.1/binutils/arsup.c +--- binutils.orig/binutils/arsup.c 2021-01-29 11:14:51.350571503 +0000 ++++ binutils-2.35.1/binutils/arsup.c 2021-01-29 11:15:56.174187367 +0000 +@@ -345,13 +345,25 @@ ar_save (void) + else + { + char *ofilename = xstrdup (bfd_get_filename (obfd)); ++ bfd_boolean skip_stat = FALSE; ++ struct stat target_stat; ++ int ofd = -1; + + if (deterministic > 0) + obfd->flags |= BFD_DETERMINISTIC_OUTPUT; + ++#if !defined (_WIN32) || defined (__CYGWIN32__) ++ /* It's OK to fail; at worst it will result in SMART_RENAME using a slow ++ copy fallback to write the output. */ ++ ofd = dup (fileno (obfd->iostream)); ++ if (lstat (real_name, &target_stat) != 0) ++ skip_stat = TRUE; ++#endif ++ + bfd_close (obfd); + +- smart_rename (ofilename, real_name, 0); ++ smart_rename (ofilename, real_name, ofd, ++ skip_stat ? NULL : &target_stat, 0); + obfd = 0; + free (ofilename); + } +diff -rup binutils.orig/binutils/bucomm.c binutils-2.35.1/binutils/bucomm.c +--- binutils.orig/binutils/bucomm.c 2021-01-29 11:14:51.422571073 +0000 ++++ binutils-2.35.1/binutils/bucomm.c 2021-01-29 11:15:33.431322133 +0000 +@@ -532,7 +532,7 @@ template_in_dir (const char *path) + as FILENAME. */ + + char * +-make_tempname (const char *filename) ++make_tempname (const char *filename, int *ofd) + { + char *tmpname = template_in_dir (filename); + int fd; +@@ -550,7 +550,7 @@ make_tempname (const char *filename) + free (tmpname); + return NULL; + } +- close (fd); ++ *ofd = fd; + return tmpname; + } + +diff -rup binutils.orig/binutils/bucomm.h binutils-2.35.1/binutils/bucomm.h +--- binutils.orig/binutils/bucomm.h 2021-01-29 11:14:51.350571503 +0000 ++++ binutils-2.35.1/binutils/bucomm.h 2021-01-29 11:15:56.174187367 +0000 +@@ -51,7 +51,7 @@ int display_info (void); + + void print_arelt_descr (FILE *, bfd *, bfd_boolean, bfd_boolean); + +-char *make_tempname (const char *); ++char *make_tempname (const char *, int *); + char *make_tempdir (const char *); + + bfd_vma parse_vma (const char *, const char *); +@@ -71,7 +71,8 @@ extern void print_version (const char *) + /* In rename.c. */ + extern void set_times (const char *, const struct stat *); + +-extern int smart_rename (const char *, const char *, int); ++extern int smart_rename (const char *, const char *, int, struct stat *, int); ++ + + /* In libiberty. */ + void *xmalloc (size_t); +diff -rup binutils.orig/binutils/objcopy.c binutils-2.35.1/binutils/objcopy.c +--- binutils.orig/binutils/objcopy.c 2021-01-29 11:14:51.342571551 +0000 ++++ binutils-2.35.1/binutils/objcopy.c 2021-01-29 11:15:56.175187361 +0000 +@@ -20,6 +20,7 @@ + + #include "sysdep.h" + #include "bfd.h" ++#include "libbfd.h" + #include "progress.h" + #include "getopt.h" + #include "libiberty.h" +@@ -3711,9 +3712,9 @@ set_long_section_mode (bfd *output_bfd, + /* The top-level control. */ + + static void +-copy_file (const char *input_filename, const char *output_filename, +- const char *input_target, const char *output_target, +- const bfd_arch_info_type *input_arch) ++copy_file (const char *input_filename, const char *output_filename, int ofd, ++ struct stat *in_stat, const char *input_target, ++ const char *output_target, const bfd_arch_info_type *input_arch) + { + bfd *ibfd; + char **obj_matching; +@@ -3732,7 +3733,7 @@ copy_file (const char *input_filename, c + /* To allow us to do "strip *" without dying on the first + non-object file, failures are nonfatal. */ + ibfd = bfd_openr (input_filename, input_target); +- if (ibfd == NULL) ++ if (ibfd == NULL || fstat (fileno (ibfd->iostream), in_stat) != 0) + { + bfd_nonfatal_message (input_filename, NULL, NULL, NULL); + status = 1; +@@ -3786,9 +3787,14 @@ copy_file (const char *input_filename, c + else + force_output_target = TRUE; + +- obfd = bfd_openw (output_filename, output_target); ++ if (ofd >= 0) ++ obfd = bfd_fdopenw (output_filename, output_target, ofd); ++ else ++ obfd = bfd_openw (output_filename, output_target); ++ + if (obfd == NULL) + { ++ close (ofd); + bfd_nonfatal_message (output_filename, NULL, NULL, NULL); + status = 1; + return; +@@ -3816,13 +3822,19 @@ copy_file (const char *input_filename, c + if (output_target == NULL) + output_target = bfd_get_target (ibfd); + +- obfd = bfd_openw (output_filename, output_target); ++ if (ofd >= 0) ++ obfd = bfd_fdopenw (output_filename, output_target, ofd); ++ else ++ obfd = bfd_openw (output_filename, output_target); ++ + if (obfd == NULL) + { ++ close (ofd); + bfd_nonfatal_message (output_filename, NULL, NULL, NULL); + status = 1; + return; + } ++ + /* This is a no-op on non-Coff targets. */ + set_long_section_mode (obfd, ibfd, long_section_names); + +@@ -4786,6 +4798,8 @@ strip_main (int argc, char *argv[]) + int hold_status = status; + struct stat statbuf; + char *tmpname; ++ int tmpfd = -1; ++ int copyfd = -1; + + if (get_file_size (argv[i]) < 1) + { +@@ -4793,18 +4807,18 @@ strip_main (int argc, char *argv[]) + continue; + } + +- if (preserve_dates) +- /* No need to check the return value of stat(). +- It has already been checked in get_file_size(). */ +- stat (argv[i], &statbuf); +- + if (output_file == NULL + || filename_cmp (argv[i], output_file) == 0) +- tmpname = make_tempname (argv[i]); ++ tmpname = make_tempname (argv[i], &tmpfd); + else + tmpname = output_file; + +- if (tmpname == NULL) ++ if (tmpname == NULL ++#if !defined (_WIN32) || defined (__CYGWIN32__) ++ /* Retain a copy of TMPFD since we will need it for SMART_RENAME. */ ++ || (tmpfd >= 0 && (copyfd = dup (tmpfd)) == -1) ++#endif ++ ) + { + bfd_nonfatal_message (argv[i], NULL, NULL, + _("could not create temporary file to hold stripped copy")); +@@ -4813,7 +4827,8 @@ strip_main (int argc, char *argv[]) + } + + status = 0; +- copy_file (argv[i], tmpname, input_target, output_target, NULL); ++ copy_file (argv[i], tmpname, tmpfd, &statbuf, input_target, ++ output_target, NULL); + if (status == 0) + { + if (preserve_dates) +@@ -4821,12 +4836,18 @@ strip_main (int argc, char *argv[]) + if (output_file != tmpname) + status = (smart_rename (tmpname, + output_file ? output_file : argv[i], +- preserve_dates) != 0); ++ copyfd, &statbuf, preserve_dates) != 0); + if (status == 0) + status = hold_status; + } + else +- unlink_if_ordinary (tmpname); ++ { ++#if !defined (_WIN32) || defined (__CYGWIN32__) ++ if (copyfd >= 0) ++ close (copyfd); ++#endif ++ unlink_if_ordinary (tmpname); ++ } + if (output_file != tmpname) + free (tmpname); + } +@@ -5033,7 +5054,8 @@ copy_main (int argc, char *argv[]) + bfd_boolean formats_info = FALSE; + bfd_boolean use_globalize = FALSE; + bfd_boolean use_keep_global = FALSE; +- int c; ++ int c, tmpfd = -1; ++ int copyfd = -1; + struct stat statbuf; + const bfd_arch_info_type *input_arch = NULL; + +@@ -5870,34 +5892,43 @@ copy_main (int argc, char *argv[]) + convert_efi_target (efi); + } + +- if (preserve_dates) +- if (stat (input_filename, & statbuf) < 0) +- fatal (_("warning: could not locate '%s'. System error message: %s"), +- input_filename, strerror (errno)); +- + /* If there is no destination file, or the source and destination files + are the same, then create a temp and rename the result into the input. */ + if (output_filename == NULL + || filename_cmp (input_filename, output_filename) == 0) +- tmpname = make_tempname (input_filename); ++ tmpname = make_tempname (input_filename, &tmpfd); + else + tmpname = output_filename; + +- if (tmpname == NULL) +- fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"), +- input_filename, strerror (errno)); ++ if (tmpname == NULL ++#if !defined (_WIN32) || defined (__CYGWIN32__) ++ /* Retain a copy of TMPFD since we will need it for SMART_RENAME. */ ++ || (tmpfd >= 0 && (copyfd = dup (tmpfd)) == -1) ++#endif ++ ) ++ { ++ fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"), ++ input_filename, strerror (errno)); ++ } + +- copy_file (input_filename, tmpname, input_target, output_target, input_arch); ++ copy_file (input_filename, tmpname, tmpfd, &statbuf, input_target, ++ output_target, input_arch); + if (status == 0) + { + if (preserve_dates) + set_times (tmpname, &statbuf); + if (tmpname != output_filename) +- status = (smart_rename (tmpname, input_filename, ++ status = (smart_rename (tmpname, input_filename, copyfd, &statbuf, + preserve_dates) != 0); + } + else +- unlink_if_ordinary (tmpname); ++ { ++#if !defined (_WIN32) || defined (__CYGWIN32__) ++ if (copyfd >= 0) ++ close (copyfd); ++#endif ++ unlink_if_ordinary (tmpname); ++ } + + if (tmpname != output_filename) + free (tmpname); +diff -rup binutils.orig/binutils/rename.c binutils-2.35.1/binutils/rename.c +--- binutils.orig/binutils/rename.c 2021-01-29 11:14:51.422571073 +0000 ++++ binutils-2.35.1/binutils/rename.c 2021-01-29 11:15:56.175187361 +0000 +@@ -131,17 +131,55 @@ set_times (const char *destination, cons + #endif + #endif + +-/* Rename FROM to TO, copying if TO is a link. +- Return 0 if ok, -1 if error. */ ++#if !defined (_WIN32) || defined (__CYGWIN32__) ++/* Try to preserve the permission bits and ownership of an existing file when ++ rename overwrites it. FD is the file being renamed and TARGET_STAT has the ++ status of the file that was overwritten. */ ++static void ++try_preserve_permissions (int fd, struct stat *target_stat) ++{ ++ struct stat from_stat; ++ int ret = 0; ++ ++ if (fstat (fd, &from_stat) != 0) ++ return; ++ ++ int from_mode = from_stat.st_mode & 0777; ++ int to_mode = target_stat->st_mode & 0777; ++ ++ /* Fix up permissions before we potentially lose ownership with fchown. ++ Clear the setxid bits because in case the fchown below fails then we don't ++ want to end up with a sxid file owned by the invoking user. If the user ++ hasn't changed or if fchown succeeded, we add back the sxid bits at the ++ end. */ ++ if (from_mode != to_mode) ++ fchmod (fd, to_mode); ++ ++ /* Fix up ownership, this will clear the setxid bits. */ ++ if (from_stat.st_uid != target_stat->st_uid ++ || from_stat.st_gid != target_stat->st_gid) ++ ret = fchown (fd, target_stat->st_uid, target_stat->st_gid); ++ ++ /* Fix up the sxid bits if either the fchown wasn't needed or it ++ succeeded. */ ++ if (ret == 0) ++ fchmod (fd, target_stat->st_mode & 07777); ++} ++#endif ++ ++/* Rename FROM to TO, copying if TO is either a link or is not a regular file. ++ FD is an open file descriptor pointing to FROM that we can use to safely fix ++ up permissions of the file after renaming. TARGET_STAT has the file status ++ that is used to fix up permissions and timestamps after rename. Return 0 if ++ ok, -1 if error and FD is closed before returning. */ + + int +-smart_rename (const char *from, const char *to, int preserve_dates ATTRIBUTE_UNUSED) ++smart_rename (const char *from, const char *to, int fd ATTRIBUTE_UNUSED, ++ struct stat *target_stat ATTRIBUTE_UNUSED, ++ int preserve_dates ATTRIBUTE_UNUSED) + { +- bfd_boolean exists; +- struct stat s; + int ret = 0; +- +- exists = lstat (to, &s) == 0; ++ bfd_boolean exists = target_stat != NULL; + + #if defined (_WIN32) && !defined (__CYGWIN32__) + /* Win32, unlike unix, will not erase `to' in `rename(from, to)' but +@@ -158,36 +196,35 @@ smart_rename (const char *from, const ch + unlink (from); + } + #else +- /* Use rename only if TO is not a symbolic link and has +- only one hard link, and we have permission to write to it. */ ++ /* Avoid a full copy and use rename if we can fix up permissions of the ++ file after renaming, i.e.: ++ ++ - TO is not a symbolic link ++ - TO is a regular file with only one hard link ++ - We have permission to write to TO ++ - FD is available to safely fix up permissions to be the same as the file ++ we overwrote with the rename. ++ ++ Note though that the actual file on disk that TARGET_STAT describes may ++ have changed and we're only trying to preserve the status we know about. ++ At no point do we try to interact with the new file changes, so there can ++ only be two outcomes, i.e. either the external file change survives ++ without knowledge of our change (if it happens after the rename syscall) ++ or our rename and permissions fixup survive without any knowledge of the ++ external change. */ + if (! exists +- || (!S_ISLNK (s.st_mode) +- && S_ISREG (s.st_mode) +- && (s.st_mode & S_IWUSR) +- && s.st_nlink == 1) ++ || (fd >= 0 ++ && !S_ISLNK (target_stat->st_mode) ++ && S_ISREG (target_stat->st_mode) ++ && (target_stat->st_mode & S_IWUSR) ++ && target_stat->st_nlink == 1) + ) + { + ret = rename (from, to); + if (ret == 0) + { + if (exists) +- { +- /* Try to preserve the permission bits and ownership of +- TO. First get the mode right except for the setuid +- bit. Then change the ownership. Then fix the setuid +- bit. We do the chmod before the chown because if the +- chown succeeds, and we are a normal user, we won't be +- able to do the chmod afterward. We don't bother to +- fix the setuid bit first because that might introduce +- a fleeting security problem, and because the chown +- will clear the setuid bit anyhow. We only fix the +- setuid bit if the chown succeeds, because we don't +- want to introduce an unexpected setuid file owned by +- the user running objcopy. */ +- chmod (to, s.st_mode & 0777); +- if (chown (to, s.st_uid, s.st_gid) >= 0) +- chmod (to, s.st_mode & 07777); +- } ++ try_preserve_permissions (fd, target_stat); + } + else + { +@@ -203,9 +240,11 @@ smart_rename (const char *from, const ch + non_fatal (_("unable to copy file '%s'; reason: %s"), to, strerror (errno)); + + if (preserve_dates) +- set_times (to, &s); ++ set_times (to, target_stat); + unlink (from); + } ++ if (fd >= 0) ++ close (fd); + #endif /* _WIN32 && !__CYGWIN32__ */ + + return ret; +diff -rup binutils.orig/binutils/ar.c binutils-2.35.1/binutils/ar.c +--- binutils.orig/binutils/ar.c 2021-02-02 13:01:42.257734944 +0000 ++++ binutils-2.35.1/binutils/ar.c 2021-02-02 13:11:13.340958352 +0000 +@@ -25,7 +25,6 @@ + + #include "sysdep.h" + #include "bfd.h" +-#include "libbfd.h" + #include "libiberty.h" + #include "progress.h" + #include "getopt.h" +@@ -1082,7 +1081,7 @@ open_output_file (bfd * abfd) + output_filename, base); + output_filename = base; + } +- ++ + if (output_dir) + { + size_t len = strlen (output_dir); +@@ -1099,7 +1098,7 @@ open_output_file (bfd * abfd) + + if (verbose) + printf ("x - %s\n", output_filename); +- ++ + FILE * ostream = fopen (output_filename, FOPEN_WB); + if (ostream == NULL) + { +@@ -1198,10 +1197,8 @@ write_archive (bfd *iarch) + bfd *contents_head = iarch->archive_next; + int ofd = -1; + struct stat target_stat; +- bfd_boolean skip_stat = FALSE; + +- old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1); +- strcpy (old_name, bfd_get_filename (iarch)); ++ old_name = xstrdup (bfd_get_filename (iarch)); + new_name = make_tempname (old_name, &ofd); + + if (new_name == NULL) +@@ -1246,11 +1243,9 @@ write_archive (bfd *iarch) + + #if !defined (_WIN32) || defined (__CYGWIN32__) + ofd = dup (ofd); +- if (iarch == NULL || iarch->iostream == NULL) +- skip_stat = TRUE; +- else if (ofd == -1 || fstat (fileno (iarch->iostream), &target_stat) != 0) +- bfd_fatal (old_name); + #endif ++ if (ofd == -1 || bfd_stat (iarch, &target_stat) != 0) ++ bfd_fatal (old_name); + + if (!bfd_close (obfd)) + bfd_fatal (old_name); +@@ -1261,7 +1256,7 @@ write_archive (bfd *iarch) + /* We don't care if this fails; we might be creating the archive. */ + bfd_close (iarch); + +- if (smart_rename (new_name, old_name, ofd, skip_stat ? NULL : &target_stat, 0) != 0) ++ if (smart_rename (new_name, old_name, ofd, &target_stat, 0) != 0) + xexit (1); + free (old_name); + free (new_name); +Only in binutils-2.35.1/binutils/: ar.c.orig +Only in binutils-2.35.1/binutils/: ar.c.rej +diff -rup binutils.orig/binutils/arsup.c binutils-2.35.1/binutils/arsup.c +--- binutils.orig/binutils/arsup.c 2021-02-02 13:01:42.208735269 +0000 ++++ binutils-2.35.1/binutils/arsup.c 2021-02-02 13:11:55.725678308 +0000 +@@ -42,6 +42,8 @@ extern int deterministic; + + static bfd *obfd; + static char *real_name; ++static char *temp_name; ++static int real_ofd; + static FILE *outfile; + + static void +@@ -149,27 +151,24 @@ maybequit (void) + void + ar_open (char *name, int t) + { +- char *tname; +- const char *bname = lbasename (name); +- real_name = name; +- +- /* Prepend tmp- to the beginning, to avoid file-name clashes after +- truncation on filesystems with limited namespaces (DOS). */ +- if (asprintf (&tname, "%.*stmp-%s", (int) (bname - name), name, bname) == -1) ++ real_name = xstrdup (name); ++ temp_name = make_tempname (real_name, &real_ofd); ++ ++ if (temp_name == NULL) + { +- fprintf (stderr, _("%s: Can't allocate memory for temp name (%s)\n"), ++ fprintf (stderr, _("%s: Can't open temporary file (%s)\n"), + program_name, strerror(errno)); + maybequit (); + return; + } + +- obfd = bfd_openw (tname, NULL); ++ obfd = bfd_fdopenw (temp_name, NULL, real_ofd); + + if (!obfd) + { + fprintf (stderr, + _("%s: Can't open output archive %s\n"), +- program_name, tname); ++ program_name, temp_name); + + maybequit (); + } +@@ -344,10 +343,9 @@ ar_save (void) + } + else + { +- char *ofilename = xstrdup (bfd_get_filename (obfd)); + bfd_boolean skip_stat = FALSE; + struct stat target_stat; +- int ofd = -1; ++ int ofd = real_ofd; + + if (deterministic > 0) + obfd->flags |= BFD_DETERMINISTIC_OUTPUT; +@@ -355,17 +353,18 @@ ar_save (void) + #if !defined (_WIN32) || defined (__CYGWIN32__) + /* It's OK to fail; at worst it will result in SMART_RENAME using a slow + copy fallback to write the output. */ +- ofd = dup (fileno (obfd->iostream)); +- if (lstat (real_name, &target_stat) != 0) +- skip_stat = TRUE; ++ ofd = dup (ofd); + #endif +- + bfd_close (obfd); + +- smart_rename (ofilename, real_name, ofd, ++ if (ofd == -1 || fstat (ofd, &target_stat) != 0) ++ skip_stat = TRUE; ++ ++ smart_rename (temp_name, real_name, ofd, + skip_stat ? NULL : &target_stat, 0); + obfd = 0; +- free (ofilename); ++ free (temp_name); ++ free (real_name); + } + } + +Only in binutils-2.35.1/binutils/: arsup.c.orig +Only in binutils-2.35.1/binutils/: arsup.c.rej +diff -rup binutils.orig/binutils/objcopy.c binutils-2.35.1/binutils/objcopy.c +--- binutils.orig/binutils/objcopy.c 2021-02-02 13:01:42.214735229 +0000 ++++ binutils-2.35.1/binutils/objcopy.c 2021-02-02 13:13:27.613071192 +0000 +@@ -20,7 +20,6 @@ + + #include "sysdep.h" + #include "bfd.h" +-#include "libbfd.h" + #include "progress.h" + #include "getopt.h" + #include "libiberty.h" +@@ -3733,7 +3732,7 @@ copy_file (const char *input_filename, c + /* To allow us to do "strip *" without dying on the first + non-object file, failures are nonfatal. */ + ibfd = bfd_openr (input_filename, input_target); +- if (ibfd == NULL || fstat (fileno (ibfd->iostream), in_stat) != 0) ++ if (ibfd == NULL || bfd_stat (ibfd, in_stat) != 0) + { + bfd_nonfatal_message (input_filename, NULL, NULL, NULL); + status = 1; +Only in binutils-2.35.1/binutils/: objcopy.c.orig +Only in binutils-2.35.1/binutils/: objcopy.c.rej +--- binutils.orig/binutils/arsup.c 2021-02-04 10:42:03.265729780 +0000 ++++ binutils-2.35.1/binutils/arsup.c 2021-02-04 10:45:48.439166658 +0000 +@@ -357,8 +357,21 @@ ar_save (void) + #endif + bfd_close (obfd); + +- if (ofd == -1 || fstat (ofd, &target_stat) != 0) +- skip_stat = TRUE; ++ if (lstat (real_name, &target_stat) != 0) ++ { ++ /* The temp file created in ar_open has mode 0600 as per mkstemp. ++ Create the real empty output file here so smart_rename will ++ update the mode according to the process umask. */ ++ obfd = bfd_openw (real_name, NULL); ++ if (obfd == NULL ++ || bfd_stat (obfd, &target_stat) != 0) ++ skip_stat = TRUE; ++ if (obfd != NULL) ++ { ++ bfd_set_format (obfd, bfd_archive); ++ bfd_close (obfd); ++ } ++ } + + smart_rename (temp_name, real_name, ofd, + skip_stat ? NULL : &target_stat, 0); +--- binutils.orig/binutils/rename.c 2021-02-08 11:02:58.767933783 +0000 ++++ binutils-2.35.1/binutils/rename.c 2021-02-08 11:20:37.539179363 +0000 +@@ -179,7 +179,10 @@ smart_rename (const char *from, const ch + int preserve_dates ATTRIBUTE_UNUSED) + { + int ret = 0; +- bfd_boolean exists = target_stat != NULL; ++ struct stat to_stat; ++ bfd_boolean exists; ++ ++ exists = lstat (to, &to_stat) == 0; + + #if defined (_WIN32) && !defined (__CYGWIN32__) + /* Win32, unlike unix, will not erase `to' in `rename(from, to)' but +@@ -214,16 +217,16 @@ smart_rename (const char *from, const ch + external change. */ + if (! exists + || (fd >= 0 +- && !S_ISLNK (target_stat->st_mode) +- && S_ISREG (target_stat->st_mode) +- && (target_stat->st_mode & S_IWUSR) +- && target_stat->st_nlink == 1) ++ && !S_ISLNK (to_stat.st_mode) ++ && S_ISREG (to_stat.st_mode) ++ && (to_stat.st_mode & S_IWUSR) ++ && to_stat.st_nlink == 1) + ) + { + ret = rename (from, to); + if (ret == 0) + { +- if (exists) ++ if (exists && target_stat != NULL) + try_preserve_permissions (fd, target_stat); + } + else +@@ -239,7 +242,7 @@ smart_rename (const char *from, const ch + if (ret != 0) + non_fatal (_("unable to copy file '%s'; reason: %s"), to, strerror (errno)); + +- if (preserve_dates) ++ if (preserve_dates && target_stat != NULL) + set_times (to, target_stat); + unlink (from); + } diff --git a/SOURCES/binutils-gas-speedups.patch b/SOURCES/binutils-gas-speedups.patch new file mode 100644 index 0000000..10b50d8 --- /dev/null +++ b/SOURCES/binutils-gas-speedups.patch @@ -0,0 +1,7750 @@ +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); + } diff --git a/SOURCES/binutils-secondary-relocs-speed.patch b/SOURCES/binutils-secondary-relocs-speed.patch new file mode 100644 index 0000000..3da4ba7 --- /dev/null +++ b/SOURCES/binutils-secondary-relocs-speed.patch @@ -0,0 +1,62 @@ +diff -rup binutils.orig/bfd/elf-bfd.h binutils-2.35/bfd/elf-bfd.h +--- binutils.orig/bfd/elf-bfd.h 2021-06-23 15:00:33.913477324 +0100 ++++ binutils-2.35/bfd/elf-bfd.h 2021-06-23 15:03:42.300235019 +0100 +@@ -1748,6 +1748,11 @@ struct bfd_elf_section_data + /* Link from a text section to its .eh_frame_entry section. */ + asection *eh_frame_entry; + ++ /* TRUE if the section has secondary reloc sections associated with it. ++ FIXME: In the future it might be better to change this into a list ++ of secondary reloc sections, making lookup easier and faster. */ ++ bfd_boolean has_secondary_relocs; ++ + /* A pointer used for various section optimizations. */ + void *sec_info; + }; +diff -rup binutils.orig/bfd/elf.c binutils-2.35/bfd/elf.c +--- binutils.orig/bfd/elf.c 2021-06-23 15:00:33.902477396 +0100 ++++ binutils-2.35/bfd/elf.c 2021-06-23 15:02:36.269672347 +0100 +@@ -12672,6 +12672,7 @@ _bfd_elf_copy_special_section_fields (co + { + asection * isec; + asection * osec; ++ struct bfd_elf_section_data * esd; + + if (isection == NULL) + return FALSE; +@@ -12687,8 +12688,9 @@ _bfd_elf_copy_special_section_fields (co + if (osec == NULL) + return FALSE; + +- BFD_ASSERT (elf_section_data (osec)->sec_info == NULL); +- elf_section_data (osec)->sec_info = elf_section_data (isec)->sec_info; ++ esd = elf_section_data (osec); ++ BFD_ASSERT (esd->sec_info == NULL); ++ esd->sec_info = elf_section_data (isec)->sec_info; + osection->sh_type = SHT_RELA; + osection->sh_link = elf_onesymtab (obfd); + if (osection->sh_link == 0) +@@ -12731,6 +12733,10 @@ _bfd_elf_copy_special_section_fields (co + osection->sh_info = + elf_section_data (isection->bfd_section->output_section)->this_idx; + ++ esd = elf_section_data (isection->bfd_section->output_section); ++ BFD_ASSERT (esd != NULL); ++ osection->sh_info = esd->this_idx; ++ esd->has_secondary_relocs = TRUE; + #if DEBUG_SECONDARY_RELOCS + fprintf (stderr, "update header of %s, sh_link = %u, sh_info = %u\n", + osec->name, osection->sh_link, osection->sh_info); +diff -rup binutils.orig/bfd/elfcode.h binutils-2.35/bfd/elfcode.h +--- binutils.orig/bfd/elfcode.h 2021-06-23 15:00:33.910477344 +0100 ++++ binutils-2.35/bfd/elfcode.h 2021-06-23 15:04:32.506902070 +0100 +@@ -987,7 +987,8 @@ elf_write_relocs (bfd *abfd, asection *s + (*swap_out) (abfd, &src_rela, dst_rela); + } + +- if (!bed->write_secondary_relocs (abfd, sec)) ++ if (elf_section_data (sec)->has_secondary_relocs ++ && !bed->write_secondary_relocs (abfd, sec)) + { + *failedp = TRUE; + return; diff --git a/SPECS/binutils.spec b/SPECS/binutils.spec index d015461..6b8b554 100644 --- a/SPECS/binutils.spec +++ b/SPECS/binutils.spec @@ -5,7 +5,7 @@ Summary: A GNU collection of binary utilities Name: %{?scl_prefix}%{?cross}binutils%{?_with_debug:-debug} Version: 2.35 -Release: 6%{?dist} +Release: 8%{?dist}.4 License: GPLv3+ URL: https://sourceware.org/binutils @@ -267,6 +267,17 @@ Patch31: binutils-aarch64-plt-sh_entsize.patch Patch32: binutils-add-sym-cache-to-elf-link-hash.patch Patch33: binutils-elf-add-objects.patch +# Purpose: Remove a vulnerability in the smart_rename function. +# Lifetime: Fixed in 2.36 +Patch34: binutils-CVE-2021-20197.patch + +# Purpose: Remove a quadratic performance penalty processing files. +# Lifetime: Fixed in 2.35.2 +Patch35: binutils-secondary-relocs-speed.patch + +# Purpose: Remove a quadratic performance penalty processing files. +# Lifetime: Fixed in 2.35.2 +Patch36: binutils-gas-speedups.patch #---------------------------------------------------------------------------- @@ -904,6 +915,21 @@ exit 0 #---------------------------------------------------------------------------- %changelog +* Wed Aug 11 2021 Nick Clifton - 2.35-8.4 +- Backport some more speed up patches. (#1978174) + +* Mon Jul 05 2021 Nick Clifton - 2.35-8.2 +- NVR bump to enable rebuild with correct tag. + +* Mon Jun 28 2021 Nick Clifton - 2.35-8.1 +- Remove a quadratic performance penalty processing files. (#1978174) + +* Mon Feb 08 2021 Nick Clifton - 2.35-8 +- Extend vulnerability fix again. (#1925779) + +* Mon Feb 01 2021 Nick Clifton - 2.35-7 +- Fix a vulnerability in the smart_rename function used by some binutils tools. (#1920641) + * Fri Jan 15 2021 Nick Clifton - 2.35-6 - NVR bump to allow rebuild with new tag.