Add startswith function and use it instead of CONST_STRNEQ.

Message ID b0e46fde-465a-8884-d3e7-2c441a4a62c1@suse.cz
State New
Headers show
Series
  • Add startswith function and use it instead of CONST_STRNEQ.
Related show

Commit Message

Martin Liška March 19, 2021, 12:44 p.m.
On 3/19/21 7:37 AM, Alan Modra wrote:
> On Thu, Mar 18, 2021 at 02:29:26PM -0400, Hans-Peter Nilsson wrote:

>> On Thu, 18 Mar 2021, Martin Li?ka wrote:

>>

>>> Hello.

>>>

>>> This patch is the same what I suggested for the GCC project:

>>> https://gcc.gnu.org/pipermail/gcc-patches/2021-March/566897.html

>>>

>>> In case on binutils, it's hard to find a single header file that

>>> is always used after string.h is included. That's why I for now

>>> use __builtin_* functions.

> 

> Use of builtin functions will need at least a __GNUC__ test and

> fallback for other compilers, which I guess means you may as well

> simply use strncmp and strlen.

> 

>>> Is the binutils community interested in the function?

>>

>> How about instead moving and/or making more use of CONST_STRNEQ

>> from bfd/bfd-in.h?

> 

> To me the name CONST_STRNEQ just doesn't parse well.  Maybe I'm just

> weird, but I read it as "constant string not equal" which of course is

> wrong.  I much prefer startswith as a name.


No, you're not weird! The function name is weird. To be honest, I noticed
the function, but the name was so misleading that I ignored it.

> bfd-in.h ought to work

> for an inline startswith too, since every sysdep.h in binutils already

> includes string.h, and so too does gas/as.h.


Yes, that's a correct location. I tried placing the new function here, but
I didn't notice 'make headers' :)

Anyway, as a first step I'm suggesting to do the renaming and I can carry on
with follow up patches that will use the function more.

Martin

Comments

Hans-Peter Nilsson March 19, 2021, 5:55 p.m. | #1
On Fri, 19 Mar 2021, Martin Li?ka wrote:
> On 3/19/21 7:37 AM, Alan Modra wrote:

> > On Thu, Mar 18, 2021 at 02:29:26PM -0400, Hans-Peter Nilsson wrote:

> > > How about instead moving and/or making more use of CONST_STRNEQ

> > > from bfd/bfd-in.h?

> >

> > To me the name CONST_STRNEQ just doesn't parse well.  Maybe I'm just

> > weird, but I read it as "constant string not equal"


It's not that? :-)

> > which of course is

> > wrong.  I much prefer startswith as a name.

>

> No, you're not weird! The function name is weird. To be honest, I noticed

> the function, but the name was so misleading that I ignored it.

>

> > bfd-in.h ought to work

> > for an inline startswith too, since every sysdep.h in binutils already

> > includes string.h, and so too does gas/as.h.

>

> Yes, that's a correct location. I tried placing the new function here, but

> I didn't notice 'make headers' :)

>

> Anyway, as a first step I'm suggesting to do the renaming and I can carry on

> with follow up patches that will use the function more.


FWIW, I don't mind; I'm not even the author, as obvious from my
comment.  I just had this hunch that "didn't <name withheld> do
something like this some time ago?  Now where *is* that
whatsitsname macro?"

(Maybe CONST_STREQN?  Nah...  I'm out.)

brgds, H-P
Mike Frysinger via Binutils March 20, 2021, 7 a.m. | #2
On Fri, Mar 19, 2021 at 01:44:38PM +0100, Martin Liška wrote:
> @@ -73,6 +64,13 @@ extern "C" {

>  #define LITMEMCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2) - 1)

>  #define LITSTRCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2))

>  

> +/* Return 1 if STR string starts with PREFIX.  */

> +

> +static inline int

> +startswith (const char *str, const char *prefix)

> +{

> +  return __builtin_strncmp (str, prefix, __builtin_strlen (prefix)) == 0;

> +}

>  

>  #define BFD_SUPPORTS_PLUGINS @supports_plugins@

>  


In binutils, we haven't yet made a policy that the project requires
gcc, so builtins can't be used without a fallback.  I tried building
with the following but it runs into a compilation failure in gdb.  I
expect your patch would do the same..

In file included from /home/alan/src/binutils-gdb/gdb/defs.h:37,
                 from /home/alan/src/binutils-gdb/gdb/gdb.c:19:
../bfd/bfd.h:85:1: error: ambiguating new declaration of ‘int startswith(const char*, const char*)’
 startswith (const char *str, const char *prefix)
 ^~~~~~~~~~
In file included from /home/alan/src/binutils-gdb/gdb/../gdbsupport/common-defs.h:125,
                 from /home/alan/src/binutils-gdb/gdb/defs.h:28,
                 from /home/alan/src/binutils-gdb/gdb/gdb.c:19:
/home/alan/src/binutils-gdb/gdb/../gdbsupport/common-utils.h:122:1: note: old declaration ‘bool startswith(const char*, const char*)’
 startswith (const char *string, const char *pattern)
 ^~~~~~~~~~

Forcing gdb to remove their startswith is a bit rude.  Should I use
#ifndef __cplusplus or #ifndef gdb_assert around the bfd version?


bfd/
	* bfd-in.h (startswith): New inline.
	(CONST_STRNEQ): Use startswith.
	* bfd-in2.h: Regenerate.
libctf/
	* ctf-impl.h: Include string.h.

diff --git a/bfd/bfd-in.h b/bfd/bfd-in.h
index c9a7673147..4d99c21d3e 100644
--- a/bfd/bfd-in.h
+++ b/bfd/bfd-in.h
@@ -65,7 +65,6 @@ extern "C" {
    definition of strncmp is provided here.
 
    Note - these macros do NOT work if STR2 is not a constant string.  */
-#define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)
   /* strcpy() can have a similar problem, but since we know we are
      copying a constant string, we can use memcpy which will be faster
      since there is no need to check for a NUL byte inside STR.  We
@@ -73,6 +72,15 @@ extern "C" {
 #define LITMEMCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2) - 1)
 #define LITSTRCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2))
 
+/* Return 1 if STR string starts with PREFIX.  */
+
+static inline int
+startswith (const char *str, const char *prefix)
+{
+  return strncmp (str, prefix, strlen (prefix)) == 0;
+}
+#define CONST_STRNEQ(STR1,STR2) startswith (STR1, STR2)
+
 
 #define BFD_SUPPORTS_PLUGINS @supports_plugins@
 
diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index ad4af32e7e..342d2ff23e 100644
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -32,6 +32,7 @@
 #include <stddef.h>
 #include <stdio.h>
 #include <stdint.h>
+#include <string.h>
 #include <limits.h>
 #include <ctype.h>
 #include <elf.h>


-- 
Alan Modra
Australia Development Lab, IBM
Mike Frysinger via Binutils March 21, 2021, 1:12 p.m. | #3
On Sat, Mar 20, 2021 at 12:58:10PM -0600, Tom Tromey wrote:
> >>>>> "Alan" == Alan Modra via Binutils <binutils@sourceware.org> writes:

> 

> Alan> Forcing gdb to remove their startswith is a bit rude.

> 

> FWIW I think it would be fine, assuming it compiles, considering that

> the functions have identical intended semantics.


Yes, the following compiles.  Fortunately all gdb files that include
gdbsupport/common-utils.h also include bfd.h by one means or another.

Committed.

bfd/
	* bfd-in.h (startswith): New inline.
	(CONST_STRNEQ): Use startswith.
	* bfd-in2.h: Regenerate.
gdbsupport/
	* common-utils.h (startswith): Delete version now supplied by bfd.h.
libctf/
	* ctf-impl.h: Include string.h.

diff --git a/bfd/bfd-in.h b/bfd/bfd-in.h
index c9a7673147..453ac48e26 100644
--- a/bfd/bfd-in.h
+++ b/bfd/bfd-in.h
@@ -65,7 +65,6 @@ extern "C" {
    definition of strncmp is provided here.
 
    Note - these macros do NOT work if STR2 is not a constant string.  */
-#define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)
   /* strcpy() can have a similar problem, but since we know we are
      copying a constant string, we can use memcpy which will be faster
      since there is no need to check for a NUL byte inside STR.  We
@@ -564,3 +563,12 @@ struct ecoff_debug_swap;
 struct ecoff_extr;
 struct bfd_link_info;
 struct bfd_link_hash_entry;
+
+/* Return TRUE if the start of STR matches PREFIX, FALSE otherwise.  */
+
+static inline bfd_boolean
+startswith (const char *str, const char *prefix)
+{
+  return strncmp (str, prefix, strlen (prefix)) == 0;
+}
+#define CONST_STRNEQ(STR1,STR2) startswith (STR1, STR2)
diff --git a/gdbsupport/common-utils.h b/gdbsupport/common-utils.h
index 28c08ee976..1de747f186 100644
--- a/gdbsupport/common-utils.h
+++ b/gdbsupport/common-utils.h
@@ -116,16 +116,8 @@ std::string extract_string_maybe_quoted (const char **arg);
 
 extern const char *safe_strerror (int);
 
-/* Return true if the start of STRING matches PATTERN, false otherwise.  */
-
-static inline bool
-startswith (const char *string, const char *pattern)
-{
-  return strncmp (string, pattern, strlen (pattern)) == 0;
-}
-
-/* Version of startswith that takes string_view arguments.  See comment
-   above.  */
+/* Version of startswith that takes string_view arguments.  Return
+   true if the start of STRING matches PATTERN, false otherwise.  */
 
 static inline bool
 startswith (gdb::string_view string, gdb::string_view pattern)
diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index ad4af32e7e..342d2ff23e 100644
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -32,6 +32,7 @@
 #include <stddef.h>
 #include <stdio.h>
 #include <stdint.h>
+#include <string.h>
 #include <limits.h>
 #include <ctype.h>
 #include <elf.h>

-- 
Alan Modra
Australia Development Lab, IBM
Mike Frysinger via Binutils March 21, 2021, 1:19 p.m. | #4
On Fri, Mar 19, 2021 at 01:44:38PM +0100, Martin Liška wrote:
> 	* (all locations): Replace usage of CONST_STRNEQ with

> 	startswith.


This is OK now that the gdb clash is sorted out.  I guess you should
really mention each file changed in ChangeLogs though.  Thanks!

-- 
Alan Modra
Australia Development Lab, IBM
Tom Tromey March 22, 2021, 2:13 a.m. | #5
Alan> Yes, the following compiles.  Fortunately all gdb files that include
Alan> gdbsupport/common-utils.h also include bfd.h by one means or another.

Sorry, I misunderstood.  I thought the proposal was to put the
function in ansidecl.h.

gdbserver can't generally include bfd.  Maybe it works sometimes, but I
imagine if you do a gdbserver-only build, bfd.h won't even be created.
(At least, it shouldn't be, because gdbserver doesn't require bfd.)

So I think some other approach is needed.  Either ansidecl.h, or a new
header; or rename either the BFD or GDB function and go from there.

I'm happy to implement it if you like.

thanks,
Tom
Mike Frysinger via Binutils March 22, 2021, 6:57 a.m. | #6
On 21 Mar 2021 23:42, Alan Modra via Binutils wrote:
> On Sat, Mar 20, 2021 at 12:58:10PM -0600, Tom Tromey wrote:

> > >>>>> "Alan" == Alan Modra via Binutils <binutils@sourceware.org> writes:

> > 

> > Alan> Forcing gdb to remove their startswith is a bit rude.

> > 

> > FWIW I think it would be fine, assuming it compiles, considering that

> > the functions have identical intended semantics.

> 

> Yes, the following compiles.  Fortunately all gdb files that include

> gdbsupport/common-utils.h also include bfd.h by one means or another.

> 

> Committed.

> 

> bfd/

> 	* bfd-in.h (startswith): New inline.

> 	(CONST_STRNEQ): Use startswith.

> 	* bfd-in2.h: Regenerate.

> gdbsupport/

> 	* common-utils.h (startswith): Delete version now supplied by bfd.h.

> libctf/

> 	* ctf-impl.h: Include string.h.


putting this in the exported header is problematic.  as you see with the libctf
code, anyone including bfd.h now has to make sure string.h is included first
even if they don't use the header themselves.  this is generally considered bad
form for headers.

along those lines, a bunch of sim ports are broken now as they include bfd.h
but not all happen to include string.h first.
-mike
Martin Liška March 22, 2021, 10:04 a.m. | #7
On 3/21/21 2:19 PM, Alan Modra wrote:
> On Fri, Mar 19, 2021 at 01:44:38PM +0100, Martin Liška wrote:

>> 	* (all locations): Replace usage of CONST_STRNEQ with

>> 	startswith.

> 

> This is OK now that the gdb clash is sorted out.  I guess you should

> really mention each file changed in ChangeLogs though.  Thanks!

> 


I've just done that and pushed as 08dedd6631efefbcba63c4dbf60ef97fb615e022.
Thanks for review.

Now I'm going to transform all the strncmp constructs that can use startswith
function.

Martin
Mike Frysinger via Binutils March 22, 2021, 4:13 p.m. | #8
On 3/22/21 9:06 AM, Alan Modra via Gdb-patches wrote:
> On Sun, Mar 21, 2021 at 08:13:06PM -0600, Tom Tromey wrote:

>> Alan> Yes, the following compiles.  Fortunately all gdb files that include

>> Alan> gdbsupport/common-utils.h also include bfd.h by one means or another.

>>

>> Sorry, I misunderstood.  I thought the proposal was to put the

>> function in ansidecl.h.

>>

>> gdbserver can't generally include bfd.  Maybe it works sometimes, but I

>> imagine if you do a gdbserver-only build, bfd.h won't even be created.

>> (At least, it shouldn't be, because gdbserver doesn't require bfd.)

>>

>> So I think some other approach is needed.  Either ansidecl.h, or a new

>> header; or rename either the BFD or GDB function and go from there.

> 

> A new header would be best, I think.

> 

>> I'm happy to implement it if you like.

> 

> Yes, that way you'll get it done properly.  :)  Sorry for the breakage.

> 


Just FTR, I'm seeing breakage in sim/aarch64 and sim/arm. Both are 
complaining about "-Werror=implicit-function-declaration" regarding 
strncmp and strlen.

Is this the breakage you're talking about? Just so I know what to expect 
when it gets fixed.
Martin Liška March 22, 2021, 4:42 p.m. | #9
On 3/22/21 1:06 PM, Alan Modra wrote:
> On Sun, Mar 21, 2021 at 08:13:06PM -0600, Tom Tromey wrote:

>> Alan> Yes, the following compiles.  Fortunately all gdb files that include

>> Alan> gdbsupport/common-utils.h also include bfd.h by one means or another.

>>

>> Sorry, I misunderstood.  I thought the proposal was to put the

>> function in ansidecl.h.

>>

>> gdbserver can't generally include bfd.  Maybe it works sometimes, but I

>> imagine if you do a gdbserver-only build, bfd.h won't even be created.

>> (At least, it shouldn't be, because gdbserver doesn't require bfd.)

>>

>> So I think some other approach is needed.  Either ansidecl.h, or a new

>> header; or rename either the BFD or GDB function and go from there.

> 

> A new header would be best, I think.

> 

>> I'm happy to implement it if you like.

> 

> Yes, that way you'll get it done properly.  :)  Sorry for the breakage.

> 


Hello.

I feel also responsible for the current compilation problems, I pulled the trigger.

Anyway for the sim failures. What about directly including <string.h> in bfd-in.h?

diff --git a/bfd/bfd-in.h b/bfd/bfd-in.h
index fda9fe0198e..d35e2ece516 100644
--- a/bfd/bfd-in.h
+++ b/bfd/bfd-in.h
@@ -38,6 +38,7 @@ extern "C" {
  #include "diagnostics.h"
  #include <stdarg.h>
  #include <sys/stat.h>
+#include <string.h>
  
  #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
  #ifndef SABER

Or do I miss something?
Thanks,
Martin
Mike Frysinger via Binutils March 23, 2021, 12:02 a.m. | #10
On Mon, Mar 22, 2021 at 05:42:50PM +0100, Martin Liška wrote:
> Anyway for the sim failures. What about directly including <string.h> in bfd-in.h?


That would be OK if we didn't care about really old systems.  See for
example the way bfd/sysdep.h includes string.h.

But all of this horrible old code that likely hasn't been tested is
eons should simply disappear.  Instead binutils should be using the
gnulib import already available in the binutils-gdb repository to
support old systems.  I've had that project on my todo list for quite
a while.  We'd be able to include stdint.h and stdbool.h for example,
throwing away bfd_stdint.h and replacing bfd_boolean with bool.

Meanwhile, this is a tidied version of the patch I sent you last
night, Tom.  If you already have one of your own then please ignore
this.

---
Subject: str-util.h

Defining startswith in bfd.h breaks sim targets that don't happen to
include string.h before bfd.h, and since bfd.h is exported, might
break other projects that use bfd.h.

include/
	* str-util.h: New file.
bfd/
	* sysdep.h: Include str-util.h.
	* bfd-in.h (startswith): Delete.
	* bfd-in2.h: Regenerate.
binutils/
	* sysdep.h: Include str-util.h.
gas/
	* as.h: Include str-util.h.
gdbsupport/
	* common-utils.h: Include str-util.h.
ld/
	* sysdep.h: Include str-util.h.
opcodes/
	* sysdep.h: Include str-util.h.

diff --git a/bfd/bfd-in.h b/bfd/bfd-in.h
index fda9fe0198..92391bb6a3 100644
--- a/bfd/bfd-in.h
+++ b/bfd/bfd-in.h
@@ -554,11 +554,3 @@ struct ecoff_debug_swap;
 struct ecoff_extr;
 struct bfd_link_info;
 struct bfd_link_hash_entry;
-
-/* Return TRUE if the start of STR matches PREFIX, FALSE otherwise.  */
-
-static inline bfd_boolean
-startswith (const char *str, const char *prefix)
-{
-  return strncmp (str, prefix, strlen (prefix)) == 0;
-}
diff --git a/bfd/sysdep.h b/bfd/sysdep.h
index 338d731112..b04847ffc3 100644
--- a/bfd/sysdep.h
+++ b/bfd/sysdep.h
@@ -119,6 +119,8 @@ extern char *strrchr ();
 
 #include "filenames.h"
 
+#include "str-util.h"
+
 #if !HAVE_DECL_FFS
 extern int ffs (int);
 #endif
diff --git a/binutils/sysdep.h b/binutils/sysdep.h
index 183bb01653..022029a3f9 100644
--- a/binutils/sysdep.h
+++ b/binutils/sysdep.h
@@ -78,6 +78,8 @@ extern char *strrchr ();
 
 #include "binary-io.h"
 
+#include "str-util.h"
+
 #if !HAVE_DECL_STPCPY
 extern char *stpcpy (char *, const char *);
 #endif
diff --git a/gas/as.h b/gas/as.h
index d6ac208289..a0346ad062 100644
--- a/gas/as.h
+++ b/gas/as.h
@@ -97,6 +97,8 @@
 /* Define the standard progress macros.  */
 #include "progress.h"
 
+#include "str-util.h"
+
 /* Other stuff from config.h.  */
 #ifdef NEED_DECLARATION_ENVIRON
 extern char **environ;
diff --git a/gdbsupport/common-utils.h b/gdbsupport/common-utils.h
index 1de747f186..65569ffe78 100644
--- a/gdbsupport/common-utils.h
+++ b/gdbsupport/common-utils.h
@@ -45,6 +45,8 @@
 
 #include "gdb_string_view.h"
 
+#include "str-util.h"
+
 /* xmalloc(), xrealloc() and xcalloc() have already been declared in
    "libiberty.h". */
 
diff --git a/include/str-util.h b/include/str-util.h
new file mode 100644
index 0000000000..24aba56563
--- /dev/null
+++ b/include/str-util.h
@@ -0,0 +1,27 @@
+/* String utility functions used by GDB and binutils.
+   Copyright (C) 2021 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef STR_UTIL_H
+#define STR_UTIL_H
+
+/* Return 1 if the start of STR matches PREFIX, 0 otherwise.  */
+
+static inline int
+startswith (const char *str, const char *prefix)
+{
+  return strncmp (str, prefix, strlen (prefix)) == 0;
+}
+#endif
diff --git a/ld/sysdep.h b/ld/sysdep.h
index 206c02c8c5..9e97d2d95b 100644
--- a/ld/sysdep.h
+++ b/ld/sysdep.h
@@ -68,6 +68,8 @@ extern char *strrchr ();
 #include "fopen-same.h"
 #endif
 
+#include "str-util.h"
+
 #ifdef HAVE_FCNTL_H
 #include <fcntl.h>
 #else
diff --git a/opcodes/sysdep.h b/opcodes/sysdep.h
index bcac6d851c..a0732861b7 100644
--- a/opcodes/sysdep.h
+++ b/opcodes/sysdep.h
@@ -52,6 +52,8 @@
 #endif
 #endif
 
+#include "str-util.h"
+
 #if !HAVE_DECL_STPCPY
 extern char *stpcpy (char *__dest, const char *__src);
 #endif


-- 
Alan Modra
Australia Development Lab, IBM
Mike Frysinger via Binutils March 23, 2021, 4:49 a.m. | #11
On 23 Mar 2021 10:32, Alan Modra wrote:
> On Mon, Mar 22, 2021 at 05:42:50PM +0100, Martin Liška wrote:

> > Anyway for the sim failures. What about directly including <string.h> in bfd-in.h?

> 

> That would be OK if we didn't care about really old systems.  See for

> example the way bfd/sysdep.h includes string.h.

> 

> But all of this horrible old code that likely hasn't been tested is

> eons should simply disappear.  Instead binutils should be using the

> gnulib import already available in the binutils-gdb repository to

> support old systems.  I've had that project on my todo list for quite

> a while.  We'd be able to include stdint.h and stdbool.h for example,

> throwing away bfd_stdint.h and replacing bfd_boolean with bool.


i agree with the idea that we've accumulated a lot of cruft that we never
test and it's unclear how many users still rely on it.  for the sim, i've
made C11 a requirement inline with GDB's C++11 requirement.  that means i
can assume <string.h> among other things.

> Meanwhile, this is a tidied version of the patch I sent you last

> night, Tom.  If you already have one of your own then please ignore

> this.


this fixes the sim for me, thanks
-mike
Mike Frysinger via Binutils March 25, 2021, 11:54 a.m. | #12
On Thu, Mar 25, 2021 at 07:53:04AM -0300, Luis Machado wrote:
> On 3/22/21 7:56 PM, Alan Modra wrote:

> > On Mon, Mar 22, 2021 at 01:13:00PM -0300, Luis Machado wrote:

> > > Just FTR, I'm seeing breakage in sim/aarch64 and sim/arm. Both are

> > > complaining about "-Werror=implicit-function-declaration" regarding strncmp

> > > and strlen.

> > > 

> > > Is this the breakage you're talking about? Just so I know what to expect

> > > when it gets fixed.

> > 

> > Yes.

> > 

> 

> Thanks. Are there plans to address this or should I come up with a patch?


I posted a patch here
https://sourceware.org/pipermail/binutils/2021-March/115863.html
It's been tested with gdb, sim and binutils builds.

Tom offered to solve the problem himself, so I'm waiting on that or
for someone in the gdb camp to review my patch.  Since I messed this
up in the first place by taking a comment by Tom as a go-ahead rather
than first posting a patch for proper review by gdb maintainers, I'm
being a little cautious in committing the above patch.

-- 
Alan Modra
Australia Development Lab, IBM
Mike Frysinger via Binutils March 25, 2021, 12:05 p.m. | #13
On 3/25/21 8:54 AM, Alan Modra wrote:
> On Thu, Mar 25, 2021 at 07:53:04AM -0300, Luis Machado wrote:

>> On 3/22/21 7:56 PM, Alan Modra wrote:

>>> On Mon, Mar 22, 2021 at 01:13:00PM -0300, Luis Machado wrote:

>>>> Just FTR, I'm seeing breakage in sim/aarch64 and sim/arm. Both are

>>>> complaining about "-Werror=implicit-function-declaration" regarding strncmp

>>>> and strlen.

>>>>

>>>> Is this the breakage you're talking about? Just so I know what to expect

>>>> when it gets fixed.

>>>

>>> Yes.

>>>

>>

>> Thanks. Are there plans to address this or should I come up with a patch?

> 

> I posted a patch here

> https://sourceware.org/pipermail/binutils/2021-March/115863.html

> It's been tested with gdb, sim and binutils builds.

> 

> Tom offered to solve the problem himself, so I'm waiting on that or

> for someone in the gdb camp to review my patch.  Since I messed this

> up in the first place by taking a comment by Tom as a go-ahead rather

> than first posting a patch for proper review by gdb maintainers, I'm

> being a little cautious in committing the above patch.

> 


Ah, I missed that patch. Let me give that a try with the arm/aarch64 
sims and I'll let you know how that works.
Mike Frysinger via Binutils March 26, 2021, 11:44 a.m. | #14
On 3/25/21 7:31 PM, Mike Frysinger wrote:
> On 25 Mar 2021 16:47, Luis Machado wrote:

>> On 3/25/21 8:54 AM, Alan Modra wrote:

>>> On Thu, Mar 25, 2021 at 07:53:04AM -0300, Luis Machado wrote:

>>>> On 3/22/21 7:56 PM, Alan Modra wrote:

>>>>> On Mon, Mar 22, 2021 at 01:13:00PM -0300, Luis Machado wrote:

>>>>>> Just FTR, I'm seeing breakage in sim/aarch64 and sim/arm. Both are

>>>>>> complaining about "-Werror=implicit-function-declaration" regarding strncmp

>>>>>> and strlen.

>>>>>>

>>>>>> Is this the breakage you're talking about? Just so I know what to expect

>>>>>> when it gets fixed.

>>>>>

>>>>> Yes.

>>>>>

>>>>

>>>> Thanks. Are there plans to address this or should I come up with a patch?

>>>

>>> I posted a patch here

>>> https://sourceware.org/pipermail/binutils/2021-March/115863.html

>>> It's been tested with gdb, sim and binutils builds.

>>>

>>> Tom offered to solve the problem himself, so I'm waiting on that or

>>> for someone in the gdb camp to review my patch.  Since I messed this

>>> up in the first place by taking a comment by Tom as a go-ahead rather

>>> than first posting a patch for proper review by gdb maintainers, I'm

>>> being a little cautious in committing the above patch.

>>>

>>

>> I applied the above patch to today's master binutils-gdb and gave

>> configure's --enable-targets=all a try, but I ran into the following:

>>

>> In file included from ../../../repos/binutils-gdb/bfd/archive.c:135:

>> ./bfd.h:568:1: error: redefinition of ‘startswith’

>>     568 | startswith (const char *str, const char *prefix)

>>         | ^~~~~~~~~~

>> In file included from ../../../repos/binutils-gdb/bfd/sysdep.h:122,

>>                    from ../../../repos/binutils-gdb/bfd/archive.c:134:

>> ../../../repos/binutils-gdb/bfd/../include/str-util.h:23:1: note:

>> previous definition of ‘startswith’ was here

>>      23 | startswith (const char *str, const char *prefix)

>>         | ^~~~~~~~~~

> 

> Alan's patch didn't include the regenerated bfd.h inputs, so you'll

> have to do that on your side.

> -mike

> 


Oops. Regenerated now. I gave it a try again and it worked OK.
Mike Frysinger via Binutils March 30, 2021, 11:58 a.m. | #15
Hi Alan, Tom,

On 3/26/21 8:44 AM, Luis Machado wrote:
> On 3/25/21 7:31 PM, Mike Frysinger wrote:

>> On 25 Mar 2021 16:47, Luis Machado wrote:

>>> On 3/25/21 8:54 AM, Alan Modra wrote:

>>>> On Thu, Mar 25, 2021 at 07:53:04AM -0300, Luis Machado wrote:

>>>>> On 3/22/21 7:56 PM, Alan Modra wrote:

>>>>>> On Mon, Mar 22, 2021 at 01:13:00PM -0300, Luis Machado wrote:

>>>>>>> Just FTR, I'm seeing breakage in sim/aarch64 and sim/arm. Both are

>>>>>>> complaining about "-Werror=implicit-function-declaration" 

>>>>>>> regarding strncmp

>>>>>>> and strlen.

>>>>>>>

>>>>>>> Is this the breakage you're talking about? Just so I know what to 

>>>>>>> expect

>>>>>>> when it gets fixed.

>>>>>>

>>>>>> Yes.

>>>>>>

>>>>>

>>>>> Thanks. Are there plans to address this or should I come up with a 

>>>>> patch?

>>>>

>>>> I posted a patch here

>>>> https://sourceware.org/pipermail/binutils/2021-March/115863.html

>>>> It's been tested with gdb, sim and binutils builds.

>>>>

>>>> Tom offered to solve the problem himself, so I'm waiting on that or

>>>> for someone in the gdb camp to review my patch.  Since I messed this

>>>> up in the first place by taking a comment by Tom as a go-ahead rather

>>>> than first posting a patch for proper review by gdb maintainers, I'm

>>>> being a little cautious in committing the above patch.

>>>>

>>>

>>> I applied the above patch to today's master binutils-gdb and gave

>>> configure's --enable-targets=all a try, but I ran into the following:

>>>

>>> In file included from ../../../repos/binutils-gdb/bfd/archive.c:135:

>>> ./bfd.h:568:1: error: redefinition of ‘startswith’

>>>     568 | startswith (const char *str, const char *prefix)

>>>         | ^~~~~~~~~~

>>> In file included from ../../../repos/binutils-gdb/bfd/sysdep.h:122,

>>>                    from ../../../repos/binutils-gdb/bfd/archive.c:134:

>>> ../../../repos/binutils-gdb/bfd/../include/str-util.h:23:1: note:

>>> previous definition of ‘startswith’ was here

>>>      23 | startswith (const char *str, const char *prefix)

>>>         | ^~~~~~~~~~

>>

>> Alan's patch didn't include the regenerated bfd.h inputs, so you'll

>> have to do that on your side.

>> -mike

>>

> 

> Oops. Regenerated now. I gave it a try again and it worked OK.


Given this has been broken for a little while, and given Alan's patch 
fixes the problem for arm/aarch64 sims (from what I tested), can we push 
this for now and get it addressed in some other way later, if someone 
wants it?

I think someone's hit this on riscv as well.
Mike Frysinger via Binutils March 31, 2021, 1:44 p.m. | #16
On 3/31/21 10:12 AM, Martin Liška wrote:
>> Given this has been broken for a little while, and given Alan's patch 

>> fixes the problem for arm/aarch64 sims (from what I tested), can we 

>> push this for now and get it addressed in some other way later, if 

>> someone wants it?

>>

>> I think someone's hit this on riscv as well.

> 

> It's fixed now with Alan's patch:

> 

> commit 57ae980e3290c0c1a9fb4a93144cc5b24457f05a

> Author: Alan Modra <amodra@gmail.com>

> Date:   Wed Mar 31 10:02:08 2021 +1030

> 

>      Include string.h in bfd.h and delete LITMEMCPY, LITSTRCPY

>      This fixes the issue that startswith depends on strncpy being

>      declared, and not all projects using bfd.h include string.h before

>      bfd.h.  I've also deleted some macros that don't find much use

>      anywhere.

>      bfd/

>              * bfd-in.h: Include string.h.

>              (LITMEMCPY, LITSTRCPY): Delete.

>              * bfd-in2.h: Regenerate.

>      binutils/

>              * prdbg.c (pr_function_type): Replace LITSTTCPY with strcpy.

> 

> Cheers,

> Martin


Thanks Alan/Martin. I've confirmed the arm/aarch64 sim failures are 
fixed now.
Tom Tromey March 31, 2021, 8:18 p.m. | #17
Hi.  I'm sorry about the delay on this.

Alan> But all of this horrible old code that likely hasn't been tested is
Alan> eons should simply disappear.

gdb has this issue to a lesser degree as well, where it checks for
headers that have not been missing in 20 years.  This kind of rot is one
of the downsides of the autoconf approach.

Alan> Instead binutils should be using the
Alan> gnulib import already available in the binutils-gdb repository to
Alan> support old systems.  I've had that project on my todo list for quite
Alan> a while.  We'd be able to include stdint.h and stdbool.h for example,
Alan> throwing away bfd_stdint.h and replacing bfd_boolean with bool.

We've had mixed experiences with gnulib in gdb.  Partly that's because
gdb is in C++; but also partly because gnulib is fairly opinionated
about some things, and if you want to be more flexible, it's difficult.

Anyway, I think it would be a good thing to try.  And, it's relatively
easy now that gnulib has moved to the top-level.  The main difficulty
that I would anticipate is that I think there are some gnulib modules
that can't be used for gdb; but if binutils needed these then we'd be in
a bit of a quandary.

I suppose though that the gnulib model is to patch things upstream and
so we could try to work out problems that way.

Alan> Meanwhile, this is a tidied version of the patch I sent you last
Alan> night, Tom.  If you already have one of your own then please ignore
Alan> this.

This looks good to me.  Thank you.

Alan> +#ifndef STR_UTIL_H
Alan> +#define STR_UTIL_H
Alan> +
Alan> +/* Return 1 if the start of STR matches PREFIX, 0 otherwise.  */
Alan> +
Alan> +static inline int
Alan> +startswith (const char *str, const char *prefix)
Alan> +{
Alan> +  return strncmp (str, prefix, strlen (prefix)) == 0;

In keeping with the above, I tend to think that adding a <string.h>
include in this file would be fine, and unlikely to break the build on
any real system.

If there is one, that would be interesting information.

Here's what gnulib has to say about string.h:

https://www.gnu.org/software/gnulib/manual/html_node/string_002eh.html

... if it were missing anywhere, I suppose I'd expect a bullet point to
that effect.

Tom

Patch

From 46f736830ec492521c2562e8364c7c0ec317e358 Mon Sep 17 00:00:00 2001
From: Martin Liska <mliska@suse.cz>
Date: Fri, 19 Mar 2021 11:50:26 +0100
Subject: [PATCH 1/2] Add startswith function and use it instead of
 CONST_STRNEQ.

bfd/ChangeLog:

	* bfd-in.h (startswith): Add startswith function.
	(CONST_STRNEQ): Remove.
	* bfd-in2.h (startswith): Regenerate with make headers.
	* (all locations): Replace usage of CONST_STRNEQ with
	startswith.
---
 bfd/archive.c             | 18 ++++++------
 bfd/archive64.c           |  4 +--
 bfd/bfd-in.h              | 18 ++++++------
 bfd/bfd-in2.h             | 18 ++++++------
 bfd/bfd.c                 |  8 +++---
 bfd/coff-stgo32.c         |  4 +--
 bfd/coffcode.h            | 58 +++++++++++++++++++--------------------
 bfd/coffgen.c             | 16 +++++------
 bfd/cofflink.c            | 12 ++++----
 bfd/compress.c            |  4 +--
 bfd/dwarf2.c              |  8 +++---
 bfd/ecoff.c               |  2 +-
 bfd/elf-m10300.c          |  4 +--
 bfd/elf.c                 |  6 ++--
 bfd/elf32-arm.c           | 12 ++++----
 bfd/elf32-bfin.c          |  4 +--
 bfd/elf32-cr16.c          |  4 +--
 bfd/elf32-cris.c          |  4 +--
 bfd/elf32-csky.c          |  2 +-
 bfd/elf32-hppa.c          |  2 +-
 bfd/elf32-iq2000.c        |  6 ++--
 bfd/elf32-lm32.c          |  2 +-
 bfd/elf32-m32r.c          |  2 +-
 bfd/elf32-m68k.c          |  4 +--
 bfd/elf32-metag.c         |  2 +-
 bfd/elf32-msp430.c        |  4 +--
 bfd/elf32-nios2.c         |  2 +-
 bfd/elf32-or1k.c          |  2 +-
 bfd/elf32-ppc.c           |  2 +-
 bfd/elf32-s390.c          |  2 +-
 bfd/elf32-score.c         |  6 ++--
 bfd/elf32-score7.c        |  6 ++--
 bfd/elf32-sh.c            |  2 +-
 bfd/elf32-tic6x.c         |  6 ++--
 bfd/elf32-vax.c           |  4 +--
 bfd/elf32-xtensa.c        | 22 +++++++--------
 bfd/elf64-alpha.c         |  6 ++--
 bfd/elf64-hppa.c          |  4 +--
 bfd/elf64-ia64-vms.c      | 14 +++++-----
 bfd/elf64-mmix.c          |  2 +-
 bfd/elf64-ppc.c           |  2 +-
 bfd/elf64-s390.c          |  2 +-
 bfd/elflink.c             | 14 +++++-----
 bfd/elfnn-aarch64.c       |  2 +-
 bfd/elfnn-ia64.c          | 10 +++----
 bfd/elfxx-mips.c          | 52 +++++++++++++++++------------------
 bfd/elfxx-sparc.c         |  2 +-
 bfd/elfxx-x86.c           |  4 +--
 bfd/hpux-core.c           |  2 +-
 bfd/libcoff.h             |  2 +-
 bfd/linker.c              |  8 +++---
 bfd/mmo.c                 |  2 +-
 bfd/osf-core.c            |  2 +-
 bfd/pef.c                 |  2 +-
 bfd/pei-x86_64.c          |  2 +-
 bfd/som.c                 |  6 ++--
 bfd/wasm-module.c         |  2 +-
 binutils/dlltool.c        |  4 +--
 binutils/emul_aix.c       |  8 +++---
 binutils/objcopy.c        |  2 +-
 binutils/objdump.c        |  2 +-
 binutils/prdbg.c          |  8 +++---
 binutils/readelf.c        |  2 +-
 binutils/stabs.c          | 12 ++++----
 gas/config/tc-i386.c      |  6 ++--
 gas/config/tc-sparc.c     |  4 +--
 gdb/arm-tdep.c            |  6 ++--
 ld/emultempl/aix.em       |  2 +-
 ld/emultempl/beos.em      |  6 ++--
 ld/emultempl/elf.em       | 12 ++++----
 ld/emultempl/pe.em        |  2 +-
 ld/emultempl/pep.em       |  2 +-
 ld/emultempl/xtensaelf.em |  4 +--
 ld/ldctor.c               |  2 +-
 ld/ldelf.c                | 16 +++++------
 ld/ldfile.c               |  2 +-
 ld/ldlang.c               |  2 +-
 ld/ldmain.c               |  6 ++--
 ld/ldwrite.c              |  4 +--
 ld/lexsup.c               |  2 +-
 ld/pe-dll.c               |  4 +--
 opcodes/aarch64-dis.c     | 10 +++----
 opcodes/arc-dis.c         |  2 +-
 opcodes/arm-dis.c         | 14 +++++-----
 opcodes/cris-dis.c        |  8 +++---
 opcodes/h8300-dis.c       |  2 +-
 opcodes/i386-dis.c        | 24 ++++++++--------
 opcodes/ia64-gen.c        | 48 ++++++++++++++++----------------
 opcodes/mips-dis.c        | 18 ++++++------
 opcodes/s390-dis.c        |  6 ++--
 opcodes/wasm32-dis.c      |  4 +--
 91 files changed, 338 insertions(+), 342 deletions(-)

diff --git a/bfd/archive.c b/bfd/archive.c
index 81ef62f1690..2a9ca56b653 100644
--- a/bfd/archive.c
+++ b/bfd/archive.c
@@ -1175,12 +1175,12 @@  bfd_slurp_armap (bfd *abfd)
   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
     return FALSE;
 
-  if (CONST_STRNEQ (nextname, "__.SYMDEF       ")
-      || CONST_STRNEQ (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
+  if (startswith (nextname, "__.SYMDEF       ")
+      || startswith (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
     return do_slurp_bsd_armap (abfd);
-  else if (CONST_STRNEQ (nextname, "/               "))
+  else if (startswith (nextname, "/               "))
     return do_slurp_coff_armap (abfd);
-  else if (CONST_STRNEQ (nextname, "/SYM64/         "))
+  else if (startswith (nextname, "/SYM64/         "))
     {
       /* 64bit (Irix 6) archive.  */
 #ifdef BFD64
@@ -1190,7 +1190,7 @@  bfd_slurp_armap (bfd *abfd)
       return FALSE;
 #endif
     }
-  else if (CONST_STRNEQ (nextname, "#1/20           "))
+  else if (startswith (nextname, "#1/20           "))
     {
       /* Mach-O has a special name for armap when the map is sorted by name.
 	 However because this name has a space it is slightly more difficult
@@ -1206,8 +1206,8 @@  bfd_slurp_armap (bfd *abfd)
       if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
 	return FALSE;
       extname[20] = 0;
-      if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
-	  || CONST_STRNEQ (extname, "__.SYMDEF"))
+      if (startswith (extname, "__.SYMDEF SORTED")
+	  || startswith (extname, "__.SYMDEF"))
 	return do_slurp_bsd_armap (abfd);
     }
 
@@ -1246,8 +1246,8 @@  _bfd_slurp_extended_name_table (bfd *abfd)
       if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
 	return FALSE;
 
-      if (! CONST_STRNEQ (nextname, "ARFILENAMES/    ")
-	  && ! CONST_STRNEQ (nextname, "//              "))
+      if (! startswith (nextname, "ARFILENAMES/    ")
+	  && ! startswith (nextname, "//              "))
 	{
 	  bfd_ardata (abfd)->extended_names = NULL;
 	  bfd_ardata (abfd)->extended_names_size = 0;
diff --git a/bfd/archive64.c b/bfd/archive64.c
index 42e24cd849b..6d76b4d7796 100644
--- a/bfd/archive64.c
+++ b/bfd/archive64.c
@@ -62,10 +62,10 @@  _bfd_archive_64_bit_slurp_armap (bfd *abfd)
     return FALSE;
 
   /* Archives with traditional armaps are still permitted.  */
-  if (CONST_STRNEQ (nextname, "/               "))
+  if (startswith (nextname, "/               "))
     return bfd_slurp_armap (abfd);
 
-  if (! CONST_STRNEQ (nextname, "/SYM64/         "))
+  if (! startswith (nextname, "/SYM64/         "))
     {
       abfd->has_armap = FALSE;
       return TRUE;
diff --git a/bfd/bfd-in.h b/bfd/bfd-in.h
index c9a76731475..17ba6ad9c36 100644
--- a/bfd/bfd-in.h
+++ b/bfd/bfd-in.h
@@ -56,16 +56,7 @@  extern "C" {
    comma and then the length of the string.  Doing this by hand
    is error prone, so using this macro is safer.  */
 #define STRING_COMMA_LEN(STR) (STR), (sizeof (STR) - 1)
-/* Unfortunately it is not possible to use the STRING_COMMA_LEN macro
-   to create the arguments to another macro, since the preprocessor
-   will mis-count the number of arguments to the outer macro (by not
-   evaluating STRING_COMMA_LEN and so missing the comma).  This is a
-   problem for example when trying to use STRING_COMMA_LEN to build
-   the arguments to the strncmp() macro.  Hence this alternative
-   definition of strncmp is provided here.
-
-   Note - these macros do NOT work if STR2 is not a constant string.  */
-#define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)
+
   /* strcpy() can have a similar problem, but since we know we are
      copying a constant string, we can use memcpy which will be faster
      since there is no need to check for a NUL byte inside STR.  We
@@ -73,6 +64,13 @@  extern "C" {
 #define LITMEMCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2) - 1)
 #define LITSTRCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2))
 
+/* Return 1 if STR string starts with PREFIX.  */
+
+static inline int
+startswith (const char *str, const char *prefix)
+{
+  return __builtin_strncmp (str, prefix, __builtin_strlen (prefix)) == 0;
+}
 
 #define BFD_SUPPORTS_PLUGINS @supports_plugins@
 
diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index 54c1c9a6b64..b79661d9bd3 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -63,16 +63,7 @@  extern "C" {
    comma and then the length of the string.  Doing this by hand
    is error prone, so using this macro is safer.  */
 #define STRING_COMMA_LEN(STR) (STR), (sizeof (STR) - 1)
-/* Unfortunately it is not possible to use the STRING_COMMA_LEN macro
-   to create the arguments to another macro, since the preprocessor
-   will mis-count the number of arguments to the outer macro (by not
-   evaluating STRING_COMMA_LEN and so missing the comma).  This is a
-   problem for example when trying to use STRING_COMMA_LEN to build
-   the arguments to the strncmp() macro.  Hence this alternative
-   definition of strncmp is provided here.
-
-   Note - these macros do NOT work if STR2 is not a constant string.  */
-#define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)
+
   /* strcpy() can have a similar problem, but since we know we are
      copying a constant string, we can use memcpy which will be faster
      since there is no need to check for a NUL byte inside STR.  We
@@ -80,6 +71,13 @@  extern "C" {
 #define LITMEMCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2) - 1)
 #define LITSTRCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2))
 
+/* Return 1 if STR string starts with PREFIX.  */
+
+static inline int
+startswith (const char *str, const char *prefix)
+{
+  return __builtin_strncmp (str, prefix, __builtin_strlen (prefix)) == 0;
+}
 
 #define BFD_SUPPORTS_PLUGINS @supports_plugins@
 
diff --git a/bfd/bfd.c b/bfd/bfd.c
index 2c620857863..757fa5f2819 100644
--- a/bfd/bfd.c
+++ b/bfd/bfd.c
@@ -1746,7 +1746,7 @@  bfd_get_sign_extend_vma (bfd *abfd)
      no place to store this information in the COFF back end.
      Should enough other COFF targets add support for DWARF2,
      a place will have to be found.  Until then, this hack will do.  */
-  if (CONST_STRNEQ (name, "coff-go32")
+  if (startswith (name, "coff-go32")
       || strcmp (name, "pe-i386") == 0
       || strcmp (name, "pei-i386") == 0
       || strcmp (name, "pe-x86-64") == 0
@@ -1757,7 +1757,7 @@  bfd_get_sign_extend_vma (bfd *abfd)
       || strcmp (name, "aix5coff64-rs6000") == 0)
     return 1;
 
-  if (CONST_STRNEQ (name, "mach-o"))
+  if (startswith (name, "mach-o"))
     return 0;
 
   bfd_set_error (bfd_error_wrong_format);
@@ -2660,7 +2660,7 @@  bfd_convert_section_size (bfd *ibfd, sec_ptr isec, bfd *obfd,
     return size;
 
   /* Convert GNU property size.  */
-  if (CONST_STRNEQ (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
+  if (startswith (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
     return _bfd_elf_convert_gnu_property_size (ibfd, obfd);
 
   /* Do nothing if input file will be decompressed.  */
@@ -2718,7 +2718,7 @@  bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
     return TRUE;
 
   /* Convert GNU properties.  */
-  if (CONST_STRNEQ (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
+  if (startswith (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
     return _bfd_elf_convert_gnu_properties (ibfd, isec, obfd, ptr,
 					    ptr_size);
 
diff --git a/bfd/coff-stgo32.c b/bfd/coff-stgo32.c
index 7593b62e8e6..8f75eecf4ee 100644
--- a/bfd/coff-stgo32.c
+++ b/bfd/coff-stgo32.c
@@ -176,7 +176,7 @@  go32exe_create_stub (bfd *abfd)
 	  close (f);
 	  goto stub_end;
 	}
-      if (! CONST_STRNEQ (magic, "go32stub"))
+      if (! startswith (magic, "go32stub"))
 	{
 	  close (f);
 	  goto stub_end;
@@ -306,7 +306,7 @@  go32exe_check_format (bfd *abfd)
   header_end = H_GET_16 (abfd, filehdr_dos.e_cparhdr) * 16UL;
   if (go32exe_temp_stub_size < header_end
       || go32exe_temp_stub_size - header_end < sizeof "go32stub" - 1
-      || !CONST_STRNEQ (go32exe_temp_stub + header_end, "go32stub"))
+      || !startswith (go32exe_temp_stub + header_end, "go32stub"))
     goto fail_format;
 
   /* Set origin to where the COFF header starts and seek there.  */
diff --git a/bfd/coffcode.h b/bfd/coffcode.h
index bcd34d469b6..d1ad669a6db 100644
--- a/bfd/coffcode.h
+++ b/bfd/coffcode.h
@@ -527,8 +527,8 @@  sec_to_styp_flags (const char *sec_name, flagword sec_flags)
       styp_flags = STYP_LIT;
 #endif /* _LIT */
     }
-  else if (CONST_STRNEQ (sec_name, DOT_DEBUG)
-	   || CONST_STRNEQ (sec_name, DOT_ZDEBUG))
+  else if (startswith (sec_name, DOT_DEBUG)
+	   || startswith (sec_name, DOT_ZDEBUG))
     {
       /* Handle the XCOFF debug section and DWARF2 debug sections.  */
       if (!sec_name[6])
@@ -536,13 +536,13 @@  sec_to_styp_flags (const char *sec_name, flagword sec_flags)
       else
 	styp_flags = STYP_DEBUG_INFO;
     }
-  else if (CONST_STRNEQ (sec_name, ".stab"))
+  else if (startswith (sec_name, ".stab"))
     {
       styp_flags = STYP_DEBUG_INFO;
     }
 #ifdef COFF_LONG_SECTION_NAMES
-  else if (CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
-	   || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT))
+  else if (startswith (sec_name, GNU_LINKONCE_WI)
+	   || startswith (sec_name, GNU_LINKONCE_WT))
     {
       styp_flags = STYP_DEBUG_INFO;
     }
@@ -642,13 +642,13 @@  sec_to_styp_flags (const char *sec_name, flagword sec_flags)
   long styp_flags = 0;
   bfd_boolean is_dbg = FALSE;
 
-  if (CONST_STRNEQ (sec_name, DOT_DEBUG)
-      || CONST_STRNEQ (sec_name, DOT_ZDEBUG)
+  if (startswith (sec_name, DOT_DEBUG)
+      || startswith (sec_name, DOT_ZDEBUG)
 #ifdef COFF_LONG_SECTION_NAMES
-      || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
-      || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT)
+      || startswith (sec_name, GNU_LINKONCE_WI)
+      || startswith (sec_name, GNU_LINKONCE_WT)
 #endif
-      || CONST_STRNEQ (sec_name, ".stab"))
+      || startswith (sec_name, ".stab"))
     is_dbg = TRUE;
 
   /* caution: there are at least three groups of symbols that have
@@ -843,16 +843,16 @@  styp_to_sec_flags (bfd *abfd,
 #endif
 	sec_flags |= SEC_ALLOC;
     }
-  else if (CONST_STRNEQ (name, DOT_DEBUG)
-	   || CONST_STRNEQ (name, DOT_ZDEBUG)
+  else if (startswith (name, DOT_DEBUG)
+	   || startswith (name, DOT_ZDEBUG)
 #ifdef _COMMENT
 	   || strcmp (name, _COMMENT) == 0
 #endif
 #ifdef COFF_LONG_SECTION_NAMES
-	   || CONST_STRNEQ (name, GNU_LINKONCE_WI)
-	   || CONST_STRNEQ (name, GNU_LINKONCE_WT)
+	   || startswith (name, GNU_LINKONCE_WI)
+	   || startswith (name, GNU_LINKONCE_WT)
 #endif
-	   || CONST_STRNEQ (name, ".stab"))
+	   || startswith (name, ".stab"))
     {
 #ifdef COFF_PAGE_SIZE
       sec_flags |= SEC_DEBUGGING;
@@ -880,8 +880,8 @@  styp_to_sec_flags (bfd *abfd,
 #endif /* STYP_SDATA */
 
   if ((bfd_applicable_section_flags (abfd) & SEC_SMALL_DATA) != 0
-      && (CONST_STRNEQ (name, ".sbss")
-	  || CONST_STRNEQ (name, ".sdata")))
+      && (startswith (name, ".sbss")
+	  || startswith (name, ".sdata")))
     sec_flags |= SEC_SMALL_DATA;
 
 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
@@ -891,7 +891,7 @@  styp_to_sec_flags (bfd *abfd,
      The symbols will be defined as weak, so that multiple definitions
      are permitted.  The GNU linker extension is to actually discard
      all but one of the sections.  */
-  if (CONST_STRNEQ (name, ".gnu.linkonce"))
+  if (startswith (name, ".gnu.linkonce"))
     sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 #endif
 
@@ -1203,18 +1203,18 @@  styp_to_sec_flags (bfd *abfd,
   bfd_boolean result = TRUE;
   bfd_boolean is_dbg = FALSE;
 
-  if (CONST_STRNEQ (name, DOT_DEBUG)
-      || CONST_STRNEQ (name, DOT_ZDEBUG)
+  if (startswith (name, DOT_DEBUG)
+      || startswith (name, DOT_ZDEBUG)
 #ifdef COFF_LONG_SECTION_NAMES
-      || CONST_STRNEQ (name, GNU_LINKONCE_WI)
-      || CONST_STRNEQ (name, GNU_LINKONCE_WT)
+      || startswith (name, GNU_LINKONCE_WI)
+      || startswith (name, GNU_LINKONCE_WT)
       /* FIXME: These definitions ought to be in a header file.  */
 #define GNU_DEBUGLINK		".gnu_debuglink"
 #define GNU_DEBUGALTLINK	".gnu_debugaltlink"
-      || CONST_STRNEQ (name, GNU_DEBUGLINK)
-      || CONST_STRNEQ (name, GNU_DEBUGALTLINK)
+      || startswith (name, GNU_DEBUGLINK)
+      || startswith (name, GNU_DEBUGALTLINK)
 #endif
-      || CONST_STRNEQ (name, ".stab"))
+      || startswith (name, ".stab"))
     is_dbg = TRUE;
   /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified.  */
   sec_flags = SEC_READONLY;
@@ -1347,8 +1347,8 @@  styp_to_sec_flags (bfd *abfd,
     }
 
   if ((bfd_applicable_section_flags (abfd) & SEC_SMALL_DATA) != 0
-      && (CONST_STRNEQ (name, ".sbss")
-	  || CONST_STRNEQ (name, ".sdata")))
+      && (startswith (name, ".sbss")
+	  || startswith (name, ".sdata")))
     sec_flags |= SEC_SMALL_DATA;
 
 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
@@ -1358,7 +1358,7 @@  styp_to_sec_flags (bfd *abfd,
      The symbols will be defined as weak, so that multiple definitions
      are permitted.  The GNU linker extension is to actually discard
      all but one of the sections.  */
-  if (CONST_STRNEQ (name, ".gnu.linkonce"))
+  if (startswith (name, ".gnu.linkonce"))
     sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 #endif
 
@@ -1679,7 +1679,7 @@  Special entry points for gdb to swap in coff symbol table parts:
 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
 .   PE object file.  *}
 .#define bfd_pei_p(abfd) \
-.  (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
+.  (startswith ((abfd)->xvec->name, "pei-"))
 */
 
 /* See whether the magic number matches.  */
diff --git a/bfd/coffgen.c b/bfd/coffgen.c
index 526e26c662a..f493978815e 100644
--- a/bfd/coffgen.c
+++ b/bfd/coffgen.c
@@ -2635,7 +2635,7 @@  _bfd_coff_section_already_linked (bfd *abfd,
     key = s_comdat->name;
   else
     {
-      if (CONST_STRNEQ (name, ".gnu.linkonce.")
+      if (startswith (name, ".gnu.linkonce.")
 	  && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
 	key++;
       else
@@ -2995,10 +2995,10 @@  coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
 	  if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
 	      || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
 	    o->gc_mark = 1;
-	  else if (CONST_STRNEQ (o->name, ".idata")
-		   || CONST_STRNEQ (o->name, ".pdata")
-		   || CONST_STRNEQ (o->name, ".xdata")
-		   || CONST_STRNEQ (o->name, ".rsrc"))
+	  else if (startswith (o->name, ".idata")
+		   || startswith (o->name, ".pdata")
+		   || startswith (o->name, ".xdata")
+		   || startswith (o->name, ".rsrc"))
 	    o->gc_mark = 1;
 
 	  if (o->gc_mark)
@@ -3109,9 +3109,9 @@  bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
       for (o = sub->sections; o != NULL; o = o->next)
 	{
 	  if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP
-	       || CONST_STRNEQ (o->name, ".vectors")
-	       || CONST_STRNEQ (o->name, ".ctors")
-	       || CONST_STRNEQ (o->name, ".dtors"))
+	       || startswith (o->name, ".vectors")
+	       || startswith (o->name, ".ctors")
+	       || startswith (o->name, ".dtors"))
 	      && !o->gc_mark)
 	    {
 	      if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook))
diff --git a/bfd/cofflink.c b/bfd/cofflink.c
index 874354a70d0..05c6fff746c 100644
--- a/bfd/cofflink.c
+++ b/bfd/cofflink.c
@@ -397,7 +397,7 @@  coff_link_add_symbols (bfd *abfd,
 		  || classification == COFF_SYMBOL_PE_SECTION)
 	      && coff_section_data (abfd, section) != NULL
 	      && coff_section_data (abfd, section)->comdat != NULL
-	      && CONST_STRNEQ (name, "??_")
+	      && startswith (name, "??_")
 	      && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
 	    {
 	      if (*sym_hash == NULL)
@@ -546,7 +546,7 @@  coff_link_add_symbols (bfd *abfd,
 	  asection *stab;
 
 	  for (stab = abfd->sections; stab; stab = stab->next)
-	    if (CONST_STRNEQ (stab->name, ".stab")
+	    if (startswith (stab->name, ".stab")
 		&& (!stab->name[5]
 		    || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
 	    {
@@ -1274,7 +1274,7 @@  process_embedded_commands (bfd *output_bfd,
 	  s++;
 	  continue;
 	}
-      if (CONST_STRNEQ (s, "-attr"))
+      if (startswith (s, "-attr"))
 	{
 	  char *name;
 	  char *attribs;
@@ -1314,14 +1314,14 @@  process_embedded_commands (bfd *output_bfd,
 		asec->flags |= SEC_READONLY;
 	    }
 	}
-      else if (CONST_STRNEQ (s, "-heap"))
+      else if (startswith (s, "-heap"))
 	s = dores_com (s + 5, output_bfd, 1);
 
-      else if (CONST_STRNEQ (s, "-stack"))
+      else if (startswith (s, "-stack"))
 	s = dores_com (s + 6, output_bfd, 0);
 
       /* GNU extension for aligned commons.  */
-      else if (CONST_STRNEQ (s, "-aligncomm:"))
+      else if (startswith (s, "-aligncomm:"))
 	{
 	  /* Common symbols must be aligned on reading, as it
 	  is too late to do anything here, after they have
diff --git a/bfd/compress.c b/bfd/compress.c
index 2e73c760e75..054ea08bb14 100644
--- a/bfd/compress.c
+++ b/bfd/compress.c
@@ -431,7 +431,7 @@  bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec,
       if (compression_header_size == 0)
 	/* In this case, it should be "ZLIB" followed by the uncompressed
 	   section size, 8 bytes in big-endian order.  */
-	compressed = CONST_STRNEQ ((char*) header , "ZLIB");
+	compressed = startswith ((char*) header , "ZLIB");
       else
 	compressed = TRUE;
     }
@@ -536,7 +536,7 @@  bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
     {
       /* In this case, it should be "ZLIB" followed by the uncompressed
 	 section size, 8 bytes in big-endian order.  */
-      if (! CONST_STRNEQ ((char*) header, "ZLIB"))
+      if (! startswith ((char*) header, "ZLIB"))
 	{
 	  bfd_set_error (bfd_error_wrong_format);
 	  return FALSE;
diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c
index b42e641aa3b..c491471783d 100644
--- a/bfd/dwarf2.c
+++ b/bfd/dwarf2.c
@@ -4234,7 +4234,7 @@  find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
 	}
 
       for (msec = abfd->sections; msec != NULL; msec = msec->next)
-	if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
+	if (startswith (msec->name, GNU_LINKONCE_INFO))
 	  return msec;
 
       return NULL;
@@ -4250,7 +4250,7 @@  find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
       if (look != NULL && strcmp (msec->name, look) == 0)
 	return msec;
 
-      if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
+      if (startswith (msec->name, GNU_LINKONCE_INFO))
 	return msec;
     }
 
@@ -4375,7 +4375,7 @@  place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
 	    continue;
 
 	  is_debug_info = (strcmp (sect->name, debug_info_name) == 0
-			   || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
+			   || startswith (sect->name, GNU_LINKONCE_INFO));
 
 	  if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
 	      && !is_debug_info)
@@ -4419,7 +4419,7 @@  place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
 		continue;
 
 	      is_debug_info = (strcmp (sect->name, debug_info_name) == 0
-			       || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
+			       || startswith (sect->name, GNU_LINKONCE_INFO));
 
 	      if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
 		  && !is_debug_info)
diff --git a/bfd/ecoff.c b/bfd/ecoff.c
index 98a00e5da63..dc12b180adb 100644
--- a/bfd/ecoff.c
+++ b/bfd/ecoff.c
@@ -2866,7 +2866,7 @@  _bfd_ecoff_slurp_armap (bfd *abfd)
      bfd_slurp_armap, but that seems inappropriate since no other
      target uses this format.  Instead, we check directly for a COFF
      armap.  */
-  if (CONST_STRNEQ (nextname, "/               "))
+  if (startswith (nextname, "/               "))
     return bfd_slurp_armap (abfd);
 
   /* See if the first element is an armap.  */
diff --git a/bfd/elf-m10300.c b/bfd/elf-m10300.c
index 32aa0be568d..752c1210c27 100644
--- a/bfd/elf-m10300.c
+++ b/bfd/elf-m10300.c
@@ -5070,7 +5070,7 @@  _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
 	  /* Remember whether there is a PLT.  */
 	  ;
 	}
-      else if (CONST_STRNEQ (name, ".rela"))
+      else if (startswith (name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
@@ -5084,7 +5084,7 @@  _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".got")
+      else if (! startswith (name, ".got")
 	       && ! streq (name, ".dynbss"))
 	/* It's not one of our sections, so don't allocate space.  */
 	continue;
diff --git a/bfd/elf.c b/bfd/elf.c
index 35c31cf40bf..ef82b98e9fe 100644
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -1112,7 +1112,7 @@  _bfd_elf_make_section_from_shdr (bfd *abfd,
      The symbols will be defined as weak, so that multiple definitions
      are permitted.  The GNU linker extension is to actually discard
      all but one of the sections.  */
-  if (CONST_STRNEQ (name, ".gnu.linkonce")
+  if (startswith (name, ".gnu.linkonce")
       && elf_next_in_group (newsect) == NULL)
     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
 
@@ -3941,7 +3941,7 @@  assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
 	     string section.  We look for a section with the same name
 	     but without the trailing ``str'', and set its sh_link
 	     field to point to this section.  */
-	  if (CONST_STRNEQ (sec->name, ".stab")
+	  if (startswith (sec->name, ".stab")
 	      && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
 	    {
 	      size_t len;
@@ -10189,7 +10189,7 @@  elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
   if (note->descsz < 4)
     return TRUE;
 
-  if (! CONST_STRNEQ (note->namedata, "win32"))
+  if (! startswith (note->namedata, "win32"))
     return TRUE;
 
   type = bfd_get_32 (abfd, note->descdata);
diff --git a/bfd/elf32-arm.c b/bfd/elf32-arm.c
index d3b412c710a..bf0be0c881e 100644
--- a/bfd/elf32-arm.c
+++ b/bfd/elf32-arm.c
@@ -5961,7 +5961,7 @@  cmse_scan (bfd *input_bfd, struct elf32_arm_link_hash_table *htab,
 	  sym_name = bfd_elf_string_from_elf_section (input_bfd,
 						      symtab_hdr->sh_link,
 						      cmse_sym->st_name);
-	  if (!sym_name || !CONST_STRNEQ (sym_name, CMSE_PREFIX))
+	  if (!sym_name || !startswith (sym_name, CMSE_PREFIX))
 	    continue;
 
 	  /* Special symbol with local binding.  */
@@ -5971,7 +5971,7 @@  cmse_scan (bfd *input_bfd, struct elf32_arm_link_hash_table *htab,
 	{
 	  cmse_hash = elf32_arm_hash_entry (sym_hashes[i - ext_start]);
 	  sym_name = (char *) cmse_hash->root.root.root.string;
-	  if (!CONST_STRNEQ (sym_name, CMSE_PREFIX))
+	  if (!startswith (sym_name, CMSE_PREFIX))
 	    continue;
 
 	  /* Special symbol has incorrect binding or type.  */
@@ -15847,7 +15847,7 @@  elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
 
 		  /* Assume it is a special symbol.  If not, cmse_scan will
 		     warn about it and user can do something about it.  */
-		  if (CONST_STRNEQ (cmse_hash->root.root.root.string,
+		  if (startswith (cmse_hash->root.root.root.string,
 				    CMSE_PREFIX))
 		    {
 		      cmse_sec = cmse_hash->root.root.u.def.section;
@@ -16902,7 +16902,7 @@  elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
 	  /* Remember whether there is a PLT.  */
 	  ;
 	}
-      else if (CONST_STRNEQ (name, ".rel"))
+      else if (startswith (name, ".rel"))
 	{
 	  if (s->size != 0)
 	    {
@@ -17564,8 +17564,8 @@  elf32_arm_final_write_processing (bfd *abfd)
 static bfd_boolean
 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
 {
-  return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
-	  || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
+  return (startswith (name, ELF_STRING_ARM_unwind)
+	  || startswith (name, ELF_STRING_ARM_unwind_once));
 }
 
 
diff --git a/bfd/elf32-bfin.c b/bfd/elf32-bfin.c
index 401683c5367..a0cb1661b9a 100644
--- a/bfd/elf32-bfin.c
+++ b/bfd/elf32-bfin.c
@@ -5186,7 +5186,7 @@  bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
 
       strip = FALSE;
 
-       if (CONST_STRNEQ (name, ".rela"))
+       if (startswith (name, ".rela"))
 	{
 	  if (s->size == 0)
 	    {
@@ -5210,7 +5210,7 @@  bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".got"))
+      else if (! startswith (name, ".got"))
 	{
 	  /* It's not one of our sections, so don't allocate space.  */
 	  continue;
diff --git a/bfd/elf32-cr16.c b/bfd/elf32-cr16.c
index 9c101cbf9f7..4c327d511ed 100644
--- a/bfd/elf32-cr16.c
+++ b/bfd/elf32-cr16.c
@@ -2439,7 +2439,7 @@  _bfd_cr16_elf_size_dynamic_sections (bfd * output_bfd,
 	  /* Remember whether there is a PLT.  */
 	  ;
 	}
-      else if (CONST_STRNEQ (name, ".rela"))
+      else if (startswith (name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
@@ -2453,7 +2453,7 @@  _bfd_cr16_elf_size_dynamic_sections (bfd * output_bfd,
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".got")
+      else if (! startswith (name, ".got")
 	       && strcmp (name, ".dynbss") != 0)
 	/* It's not one of our sections, so don't allocate space.  */
 	continue;
diff --git a/bfd/elf32-cris.c b/bfd/elf32-cris.c
index 0228920e1fd..080f95849b0 100644
--- a/bfd/elf32-cris.c
+++ b/bfd/elf32-cris.c
@@ -3593,7 +3593,7 @@  elf_cris_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  s->size += htab->dtpmod_refcount != 0
 	    ? 8 : 0;
 	}
-      else if (CONST_STRNEQ (name, ".rela"))
+      else if (startswith (name, ".rela"))
 	{
 	  if (strcmp (name, ".rela.got") == 0
 	      && htab->dtpmod_refcount != 0
@@ -3612,7 +3612,7 @@  elf_cris_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".got")
+      else if (! startswith (name, ".got")
 	       && strcmp (name, ".dynbss") != 0
 	       && s != htab->root.sdynrelro)
 	{
diff --git a/bfd/elf32-csky.c b/bfd/elf32-csky.c
index 0b776e5fd8f..4e6db39cf40 100644
--- a/bfd/elf32-csky.c
+++ b/bfd/elf32-csky.c
@@ -2045,7 +2045,7 @@  csky_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  if (htab->elf.hplt != NULL)
 	    strip_section = FALSE;
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rel") )
+      else if (startswith (bfd_section_name (s), ".rel") )
 	{
 	  if (s->size != 0 )
 	    relocs = TRUE;
diff --git a/bfd/elf32-hppa.c b/bfd/elf32-hppa.c
index e47af49b230..ec354c88ff2 100644
--- a/bfd/elf32-hppa.c
+++ b/bfd/elf32-hppa.c
@@ -2232,7 +2232,7 @@  elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	       || sec == htab->etab.sdynbss
 	       || sec == htab->etab.sdynrelro)
 	;
-      else if (CONST_STRNEQ (bfd_section_name (sec), ".rela"))
+      else if (startswith (bfd_section_name (sec), ".rela"))
 	{
 	  if (sec->size != 0)
 	    {
diff --git a/bfd/elf32-iq2000.c b/bfd/elf32-iq2000.c
index e17b0c646ae..b29be24878e 100644
--- a/bfd/elf32-iq2000.c
+++ b/bfd/elf32-iq2000.c
@@ -507,9 +507,9 @@  iq2000_elf_check_relocs (bfd *abfd,
 
 	case R_IQ2000_32:
 	  /* For debug section, change to special harvard-aware relocations.  */
-	  if (CONST_STRNEQ (sec->name, ".debug")
-	      || CONST_STRNEQ (sec->name, ".stab")
-	      || CONST_STRNEQ (sec->name, ".eh_frame"))
+	  if (startswith (sec->name, ".debug")
+	      || startswith (sec->name, ".stab")
+	      || startswith (sec->name, ".eh_frame"))
 	    {
 	      ((Elf_Internal_Rela *) rel)->r_info
 		= ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
diff --git a/bfd/elf32-lm32.c b/bfd/elf32-lm32.c
index fa0b2fcfff3..9d72150ccc1 100644
--- a/bfd/elf32-lm32.c
+++ b/bfd/elf32-lm32.c
@@ -2020,7 +2020,7 @@  lm32_elf_size_dynamic_sections (bfd *output_bfd,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0 && s != htab->root.srelplt)
 	    relocs = TRUE;
diff --git a/bfd/elf32-m32r.c b/bfd/elf32-m32r.c
index e73bbdeeff2..95e0c17bc5c 100644
--- a/bfd/elf32-m32r.c
+++ b/bfd/elf32-m32r.c
@@ -2073,7 +2073,7 @@  m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0 && s != htab->srelplt)
 	    relocs = TRUE;
diff --git a/bfd/elf32-m68k.c b/bfd/elf32-m68k.c
index 16aa5918518..f2222d0ed68 100644
--- a/bfd/elf32-m68k.c
+++ b/bfd/elf32-m68k.c
@@ -3171,7 +3171,7 @@  elf_m68k_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Remember whether there is a PLT.  */
 	  ;
 	}
-      else if (CONST_STRNEQ (name, ".rela"))
+      else if (startswith (name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
@@ -3182,7 +3182,7 @@  elf_m68k_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".got")
+      else if (! startswith (name, ".got")
 	       && strcmp (name, ".dynbss") != 0)
 	{
 	  /* It's not one of our sections, so don't allocate space.  */
diff --git a/bfd/elf32-metag.c b/bfd/elf32-metag.c
index 65453639768..ac6d37977cc 100644
--- a/bfd/elf32-metag.c
+++ b/bfd/elf32-metag.c
@@ -2847,7 +2847,7 @@  elf_metag_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0 && s != htab->etab.srelplt)
 	    relocs = TRUE;
diff --git a/bfd/elf32-msp430.c b/bfd/elf32-msp430.c
index 1aafa844b55..eebe74a6791 100644
--- a/bfd/elf32-msp430.c
+++ b/bfd/elf32-msp430.c
@@ -1855,8 +1855,8 @@  msp430_elf_relax_delete_bytes (bfd * abfd, asection * sec, bfd_vma addr,
 		 the start of the next section.  */
 	      || (isym->st_value == toaddr
 		  && name != NULL
-		  && (CONST_STRNEQ (name, ".Letext")
-		      || CONST_STRNEQ (name, ".LFE")))))
+		  && (startswith (name, ".Letext")
+		      || startswith (name, ".LFE")))))
 	{
 	  if (debug_relocs)
 	    printf ("      adjusting value of local symbol %s from 0x%lx ",
diff --git a/bfd/elf32-nios2.c b/bfd/elf32-nios2.c
index c1727ccac0c..c925bc975e7 100644
--- a/bfd/elf32-nios2.c
+++ b/bfd/elf32-nios2.c
@@ -5825,7 +5825,7 @@  nios2_elf32_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	 of the dynobj section names depend upon the input files.  */
       name = bfd_section_name (s);
 
-      if (CONST_STRNEQ (name, ".rela"))
+      if (startswith (name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
diff --git a/bfd/elf32-or1k.c b/bfd/elf32-or1k.c
index 65938e51378..82a5b4ac8e2 100644
--- a/bfd/elf32-or1k.c
+++ b/bfd/elf32-or1k.c
@@ -3034,7 +3034,7 @@  or1k_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0 && s != htab->root.srelplt)
 	    relocs = TRUE;
diff --git a/bfd/elf32-ppc.c b/bfd/elf32-ppc.c
index 65f59a39d25..fe8b6fdb7d1 100644
--- a/bfd/elf32-ppc.c
+++ b/bfd/elf32-ppc.c
@@ -5812,7 +5812,7 @@  ppc_elf_size_dynamic_sections (bfd *output_bfd,
 	{
 	  strip_section = (s->flags & SEC_KEEP) == 0;
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0)
 	    {
diff --git a/bfd/elf32-s390.c b/bfd/elf32-s390.c
index 0cc1edb7929..55e61031a04 100644
--- a/bfd/elf32-s390.c
+++ b/bfd/elf32-s390.c
@@ -1919,7 +1919,7 @@  elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0)
 	    relocs = TRUE;
diff --git a/bfd/elf32-score.c b/bfd/elf32-score.c
index 50c7405c32a..e34169e989f 100644
--- a/bfd/elf32-score.c
+++ b/bfd/elf32-score.c
@@ -3282,7 +3282,7 @@  s3_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i
 	 of the dynobj section names depend upon the input files.  */
       name = bfd_section_name (s);
 
-      if (CONST_STRNEQ (name, ".rel"))
+      if (startswith (name, ".rel"))
 	{
 	  if (s->size == 0)
 	    {
@@ -3320,7 +3320,7 @@  s3_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i
 		s->reloc_count = 0;
 	    }
 	}
-      else if (CONST_STRNEQ (name, ".got"))
+      else if (startswith (name, ".got"))
 	{
 	  /* s3_bfd_score_elf_always_size_sections() has already done
 	     most of the work, but some symbols may have been mapped
@@ -3333,7 +3333,7 @@  s3_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i
 	     of .text section. So put a dummy. XXX  */
 	  s->size += SCORE_FUNCTION_STUB_SIZE;
 	}
-      else if (! CONST_STRNEQ (name, ".init"))
+      else if (! startswith (name, ".init"))
 	{
 	  /* It's not one of our sections, so don't allocate space.  */
 	  continue;
diff --git a/bfd/elf32-score7.c b/bfd/elf32-score7.c
index 2f63ab8cd5b..9e1b7dae0cb 100644
--- a/bfd/elf32-score7.c
+++ b/bfd/elf32-score7.c
@@ -3090,7 +3090,7 @@  s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i
 	 of the dynobj section names depend upon the input files.  */
       name = bfd_section_name (s);
 
-      if (CONST_STRNEQ (name, ".rel"))
+      if (startswith (name, ".rel"))
 	{
 	  if (s->size == 0)
 	    {
@@ -3128,7 +3128,7 @@  s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i
 		s->reloc_count = 0;
 	    }
 	}
-      else if (CONST_STRNEQ (name, ".got"))
+      else if (startswith (name, ".got"))
 	{
 	  /* s7_bfd_score_elf_always_size_sections() has already done
 	     most of the work, but some symbols may have been mapped
@@ -3141,7 +3141,7 @@  s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i
 	     of .text section. So put a dummy. XXX  */
 	  s->size += SCORE_FUNCTION_STUB_SIZE;
 	}
-      else if (! CONST_STRNEQ (name, ".init"))
+      else if (! startswith (name, ".init"))
 	{
 	  /* It's not one of our sections, so don't allocate space.  */
 	  continue;
diff --git a/bfd/elf32-sh.c b/bfd/elf32-sh.c
index 19375b06a43..10145505c3e 100644
--- a/bfd/elf32-sh.c
+++ b/bfd/elf32-sh.c
@@ -3152,7 +3152,7 @@  sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0 && s != htab->root.srelplt && s != htab->srelplt2)
 	    relocs = TRUE;
diff --git a/bfd/elf32-tic6x.c b/bfd/elf32-tic6x.c
index 3d0640e12d1..53ec572fab9 100644
--- a/bfd/elf32-tic6x.c
+++ b/bfd/elf32-tic6x.c
@@ -1938,8 +1938,8 @@  elf32_tic6x_gc_mark_extra_sections (struct bfd_link_info *info,
 static bfd_boolean
 is_tic6x_elf_unwind_section_name (const char *name)
 {
-  return (CONST_STRNEQ (name, ELF_STRING_C6000_unwind)
-	  || CONST_STRNEQ (name, ELF_STRING_C6000_unwind_once));
+  return (startswith (name, ELF_STRING_C6000_unwind)
+	  || startswith (name, ELF_STRING_C6000_unwind_once));
 }
 
 
@@ -3284,7 +3284,7 @@  elf32_tic6x_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
 	  if (s == htab->elf.splt && s->size > 0)
 	    s->size = (s->size + 31) & ~(bfd_vma)31;
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0
 	      && s != htab->elf.srelplt)
diff --git a/bfd/elf32-vax.c b/bfd/elf32-vax.c
index c7fe7f2f600..ff83062a37a 100644
--- a/bfd/elf32-vax.c
+++ b/bfd/elf32-vax.c
@@ -1082,7 +1082,7 @@  elf_vax_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
 	  /* Remember whether there is a PLT.  */
 	  ;
 	}
-      else if (CONST_STRNEQ (name, ".rela"))
+      else if (startswith (name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
@@ -1094,7 +1094,7 @@  elf_vax_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".got")
+      else if (! startswith (name, ".got")
 	       && strcmp (name, ".dynbss") != 0)
 	{
 	  /* It's not one of our sections, so don't allocate space.  */
diff --git a/bfd/elf32-xtensa.c b/bfd/elf32-xtensa.c
index 6338bc98e82..abc244c04cb 100644
--- a/bfd/elf32-xtensa.c
+++ b/bfd/elf32-xtensa.c
@@ -1691,7 +1691,7 @@  elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	 of the dynobj section names depend upon the input files.  */
       name = bfd_section_name (s);
 
-      if (CONST_STRNEQ (name, ".rela"))
+      if (startswith (name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
@@ -1705,8 +1705,8 @@  elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".plt.")
-	       && ! CONST_STRNEQ (name, ".got.plt.")
+      else if (! startswith (name, ".plt.")
+	       && ! startswith (name, ".got.plt.")
 	       && strcmp (name, ".got") != 0
 	       && strcmp (name, ".plt") != 0
 	       && strcmp (name, ".got.plt") != 0
@@ -11144,8 +11144,8 @@  xtensa_is_property_section (asection *sec)
 static bfd_boolean
 xtensa_is_insntable_section (asection *sec)
 {
-  if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
-      || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
+  if (startswith (sec->name, XTENSA_INSN_SEC_NAME)
+      || startswith (sec->name, ".gnu.linkonce.x."))
     return TRUE;
 
   return FALSE;
@@ -11155,8 +11155,8 @@  xtensa_is_insntable_section (asection *sec)
 static bfd_boolean
 xtensa_is_littable_section (asection *sec)
 {
-  if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
-      || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
+  if (startswith (sec->name, XTENSA_LIT_SEC_NAME)
+      || startswith (sec->name, ".gnu.linkonce.p."))
     return TRUE;
 
   return FALSE;
@@ -11166,8 +11166,8 @@  xtensa_is_littable_section (asection *sec)
 static bfd_boolean
 xtensa_is_proptable_section (asection *sec)
 {
-  if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
-      || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
+  if (startswith (sec->name, XTENSA_PROP_SEC_NAME)
+      || startswith (sec->name, ".gnu.linkonce.prop."))
     return TRUE;
 
   return FALSE;
@@ -11281,7 +11281,7 @@  xtensa_property_section_name (asection *sec, const char *base_name,
       suffix = sec->name + linkonce_len;
       /* For backward compatibility, replace "t." instead of inserting
 	 the new linkonce_kind (but not for "prop" sections).  */
-      if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
+      if (startswith (suffix, "t.") && linkonce_kind[1] == '.')
 	suffix += 2;
       strcat (prop_sec_name + linkonce_len, suffix);
     }
@@ -11396,7 +11396,7 @@  xtensa_callback_required_dependence (bfd *abfd,
   /* ".plt*" sections have no explicit relocations but they contain L32R
      instructions that reference the corresponding ".got.plt*" sections.  */
   if ((sec->flags & SEC_LINKER_CREATED) != 0
-      && CONST_STRNEQ (sec->name, ".plt"))
+      && startswith (sec->name, ".plt"))
     {
       asection *sgotplt;
 
diff --git a/bfd/elf64-alpha.c b/bfd/elf64-alpha.c
index 3d214374753..6fffc438fc4 100644
--- a/bfd/elf64-alpha.c
+++ b/bfd/elf64-alpha.c
@@ -2859,7 +2859,7 @@  elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	 of the dynobj section names depend upon the input files.  */
       name = bfd_section_name (s);
 
-      if (CONST_STRNEQ (name, ".rela"))
+      if (startswith (name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
@@ -2873,7 +2873,7 @@  elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	      s->reloc_count = 0;
 	    }
 	}
-      else if (! CONST_STRNEQ (name, ".got")
+      else if (! startswith (name, ".got")
 	       && strcmp (name, ".plt") != 0
 	       && strcmp (name, ".dynbss") != 0)
 	{
@@ -2890,7 +2890,7 @@  elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	     linker does that before adjust_dynamic_symbol is called, and
 	     it is that function which decides whether anything needs to
 	     go into these sections.  */
-	  if (!CONST_STRNEQ (name, ".got"))
+	  if (!startswith (name, ".got"))
 	    s->flags |= SEC_EXCLUDE;
 	}
       else if ((s->flags & SEC_HAS_CONTENTS) != 0)
diff --git a/bfd/elf64-hppa.c b/bfd/elf64-hppa.c
index 50782fe2c4c..0ce85cced14 100644
--- a/bfd/elf64-hppa.c
+++ b/bfd/elf64-hppa.c
@@ -1754,13 +1754,13 @@  elf64_hppa_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
 	  ;
 	}
       else if (strcmp (name, ".opd") == 0
-	       || CONST_STRNEQ (name, ".dlt")
+	       || startswith (name, ".dlt")
 	       || strcmp (name, ".stub") == 0
 	       || strcmp (name, ".got") == 0)
 	{
 	  /* Strip this section if we don't need it; see the comment below.  */
 	}
-      else if (CONST_STRNEQ (name, ".rela"))
+      else if (startswith (name, ".rela"))
 	{
 	  if (sec->size != 0)
 	    {
diff --git a/bfd/elf64-ia64-vms.c b/bfd/elf64-ia64-vms.c
index b69c9cde7f1..317253fb9a6 100644
--- a/bfd/elf64-ia64-vms.c
+++ b/bfd/elf64-ia64-vms.c
@@ -809,9 +809,9 @@  elf64_ia64_relax_section (bfd *abfd, asection *sec,
 static inline bfd_boolean
 is_unwind_section_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
 {
-  return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
-	   && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
-	  || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
+  return ((startswith (name, ELF_STRING_ia64_unwind)
+	   && ! startswith (name, ELF_STRING_ia64_unwind_info))
+	  || startswith (name, ELF_STRING_ia64_unwind_once));
 }
 
 
@@ -1847,9 +1847,9 @@  get_reloc_section (bfd *abfd,
   if (srel_name == NULL)
     return NULL;
 
-  BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela")
+  BFD_ASSERT ((startswith (srel_name, ".rela")
 	       && strcmp (bfd_section_name (sec), srel_name+5) == 0)
-	      || (CONST_STRNEQ (srel_name, ".rel")
+	      || (startswith (srel_name, ".rel")
 		  && strcmp (bfd_section_name (sec), srel_name+4) == 0));
 
   dynobj = ia64_info->root.dynobj;
@@ -2745,7 +2745,7 @@  elf64_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 
 	  if (strcmp (name, ".got.plt") == 0)
 	    strip = FALSE;
-	  else if (CONST_STRNEQ (name, ".rel"))
+	  else if (startswith (name, ".rel"))
 	    {
 	      if (!strip)
 		{
@@ -4387,7 +4387,7 @@  elf64_ia64_object_p (bfd *abfd)
       if (elf_sec_group (sec) == NULL
 	  && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
 	      == (SEC_LINK_ONCE | SEC_CODE))
-	  && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
+	  && startswith (sec->name, ".gnu.linkonce.t."))
 	{
 	  name = sec->name + 16;
 
diff --git a/bfd/elf64-mmix.c b/bfd/elf64-mmix.c
index f87b26e4929..62365e1e4f7 100644
--- a/bfd/elf64-mmix.c
+++ b/bfd/elf64-mmix.c
@@ -2139,7 +2139,7 @@  mmix_elf_add_symbol_hook (bfd *abfd,
       (*secp)->flags |= SEC_LINKER_CREATED;
     }
   else if ((*namep)[0] == '_' && (*namep)[1] == '_' && (*namep)[2] == '.'
-	   && CONST_STRNEQ (*namep, MMIX_LOC_SECTION_START_SYMBOL_PREFIX))
+	   && startswith (*namep, MMIX_LOC_SECTION_START_SYMBOL_PREFIX))
     {
       /* See if we have another one.  */
       struct bfd_link_hash_entry *h = bfd_link_hash_lookup (info->hash,
diff --git a/bfd/elf64-ppc.c b/bfd/elf64-ppc.c
index ab0e0d33aac..741f510a28d 100644
--- a/bfd/elf64-ppc.c
+++ b/bfd/elf64-ppc.c
@@ -10226,7 +10226,7 @@  ppc64_elf_size_dynamic_sections (bfd *output_bfd,
 	    /* Not sized yet.  */
 	    continue;
 	}
-      else if (CONST_STRNEQ (s->name, ".rela"))
+      else if (startswith (s->name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
diff --git a/bfd/elf64-s390.c b/bfd/elf64-s390.c
index 69a011f7c93..01dcefed48e 100644
--- a/bfd/elf64-s390.c
+++ b/bfd/elf64-s390.c
@@ -1873,7 +1873,7 @@  elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0 && s != htab->elf.srelplt)
 	    relocs = TRUE;
diff --git a/bfd/elflink.c b/bfd/elflink.c
index e1278a5d95e..82b5a8f2e98 100644
--- a/bfd/elflink.c
+++ b/bfd/elflink.c
@@ -4129,7 +4129,7 @@  elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       const char *name;
 
       name = bfd_section_name (s);
-      if (CONST_STRNEQ (name, ".gnu.warning."))
+      if (startswith (name, ".gnu.warning."))
 	{
 	  char *msg;
 	  bfd_size_type sz;
@@ -5693,7 +5693,7 @@  elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	  asection *stab;
 
 	  for (stab = abfd->sections; stab; stab = stab->next)
-	    if (CONST_STRNEQ (stab->name, ".stab")
+	    if (startswith (stab->name, ".stab")
 		&& (!stab->name[5] ||
 		    (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
 		&& (stab->flags & SEC_MERGE) == 0
@@ -13668,7 +13668,7 @@  _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
 
 	  if (!debug_frag_seen
 	      && (isec->flags & SEC_DEBUGGING)
-	      && CONST_STRNEQ (isec->name, ".debug_line."))
+	      && startswith (isec->name, ".debug_line."))
 	    debug_frag_seen = TRUE;
 	  else if (strcmp (bfd_section_name (isec),
 			   "__patchable_function_entries") == 0
@@ -13985,7 +13985,7 @@  bfd_elf_parse_eh_frame_entries (bfd *abfd ATTRIBUTE_UNUSED,
 
       for (sec = ibfd->sections; sec; sec = sec->next)
 	{
-	  if (CONST_STRNEQ (bfd_section_name (sec), ".eh_frame_entry")
+	  if (startswith (bfd_section_name (sec), ".eh_frame_entry")
 	      && init_reloc_cookie_rels (&cookie, info, ibfd, sec))
 	    {
 	      _bfd_elf_parse_eh_frame_entry (info, sec, &cookie);
@@ -14692,7 +14692,7 @@  _bfd_elf_section_already_linked (bfd *abfd,
   else
     {
       /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
-      if (CONST_STRNEQ (name, ".gnu.linkonce.")
+      if (startswith (name, ".gnu.linkonce.")
 	  && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
 	key++;
       else
@@ -14791,10 +14791,10 @@  _bfd_elf_section_already_linked (bfd *abfd,
      `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
      matter as here were are looking only for cross-bfd sections.  */
 
-  if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
+  if ((flags & SEC_GROUP) == 0 && startswith (name, ".gnu.linkonce.r."))
     for (l = already_linked_list->entry; l != NULL; l = l->next)
       if ((l->sec->flags & SEC_GROUP) == 0
-	  && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
+	  && startswith (l->sec->name, ".gnu.linkonce.t."))
 	{
 	  if (abfd != l->sec->owner)
 	    sec->output_section = bfd_abs_section_ptr;
diff --git a/bfd/elfnn-aarch64.c b/bfd/elfnn-aarch64.c
index 1ec405ef1e0..2fee93aa5f9 100644
--- a/bfd/elfnn-aarch64.c
+++ b/bfd/elfnn-aarch64.c
@@ -9047,7 +9047,7 @@  elfNN_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
+      else if (startswith (bfd_section_name (s), ".rela"))
 	{
 	  if (s->size != 0 && s != htab->root.srelplt)
 	    relocs = TRUE;
diff --git a/bfd/elfnn-ia64.c b/bfd/elfnn-ia64.c
index aaa69c4b2cd..281a8375d51 100644
--- a/bfd/elfnn-ia64.c
+++ b/bfd/elfnn-ia64.c
@@ -893,9 +893,9 @@  is_unwind_section_name (bfd *abfd, const char *name)
       && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
     return FALSE;
 
-  return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
-	   && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
-	  || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
+  return ((startswith (name, ELF_STRING_ia64_unwind)
+	   && ! startswith (name, ELF_STRING_ia64_unwind_info))
+	  || startswith (name, ELF_STRING_ia64_unwind_once));
 }
 
 /* Handle an IA-64 specific section when reading an object file.  This
@@ -3161,7 +3161,7 @@  elfNN_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 
 	  if (strcmp (name, ".got.plt") == 0)
 	    strip = FALSE;
-	  else if (CONST_STRNEQ (name, ".rel"))
+	  else if (startswith (name, ".rel"))
 	    {
 	      if (!strip)
 		{
@@ -4859,7 +4859,7 @@  elfNN_ia64_object_p (bfd *abfd)
       if (elf_sec_group (sec) == NULL
 	  && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
 	      == (SEC_LINK_ONCE | SEC_CODE))
-	  && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
+	  && startswith (sec->name, ".gnu.linkonce.t."))
 	{
 	  name = sec->name + 16;
 
diff --git a/bfd/elfxx-mips.c b/bfd/elfxx-mips.c
index 86e15b61edf..41abf4954dc 100644
--- a/bfd/elfxx-mips.c
+++ b/bfd/elfxx-mips.c
@@ -1030,9 +1030,9 @@  static bfd *reldyn_sorting_bfd;
 #define CALL_STUB ".mips16.call."
 #define CALL_FP_STUB ".mips16.call.fp."
 
-#define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
-#define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
-#define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
+#define FN_STUB_P(name) startswith (name, FN_STUB)
+#define CALL_STUB_P(name) startswith (name, CALL_STUB)
+#define CALL_FP_STUB_P(name) startswith (name, CALL_FP_STUB)
 
 /* The format of the first PLT entry in an O32 executable.  */
 static const bfd_vma mips_o32_exec_plt0_entry[] =
@@ -7411,7 +7411,7 @@  _bfd_mips_elf_section_from_shdr (bfd *abfd,
 	return FALSE;
       break;
     case SHT_MIPS_GPTAB:
-      if (! CONST_STRNEQ (name, ".gptab."))
+      if (! startswith (name, ".gptab."))
 	return FALSE;
       break;
     case SHT_MIPS_UCODE:
@@ -7434,7 +7434,7 @@  _bfd_mips_elf_section_from_shdr (bfd *abfd,
 	return FALSE;
       break;
     case SHT_MIPS_CONTENT:
-      if (! CONST_STRNEQ (name, ".MIPS.content"))
+      if (! startswith (name, ".MIPS.content"))
 	return FALSE;
       break;
     case SHT_MIPS_OPTIONS:
@@ -7447,8 +7447,8 @@  _bfd_mips_elf_section_from_shdr (bfd *abfd,
       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
       break;
     case SHT_MIPS_DWARF:
-      if (! CONST_STRNEQ (name, ".debug_")
-	  && ! CONST_STRNEQ (name, ".zdebug_"))
+      if (! startswith (name, ".debug_")
+	  && ! startswith (name, ".zdebug_"))
 	return FALSE;
       break;
     case SHT_MIPS_SYMBOL_LIB:
@@ -7456,8 +7456,8 @@  _bfd_mips_elf_section_from_shdr (bfd *abfd,
 	return FALSE;
       break;
     case SHT_MIPS_EVENTS:
-      if (! CONST_STRNEQ (name, ".MIPS.events")
-	  && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
+      if (! startswith (name, ".MIPS.events")
+	  && ! startswith (name, ".MIPS.post_rel"))
 	return FALSE;
       break;
     case SHT_MIPS_XHASH:
@@ -7594,7 +7594,7 @@  _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
     }
   else if (strcmp (name, ".conflict") == 0)
     hdr->sh_type = SHT_MIPS_CONFLICT;
-  else if (CONST_STRNEQ (name, ".gptab."))
+  else if (startswith (name, ".gptab."))
     {
       hdr->sh_type = SHT_MIPS_GPTAB;
       hdr->sh_entsize = sizeof (Elf32_External_gptab);
@@ -7651,7 +7651,7 @@  _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
       hdr->sh_type = SHT_MIPS_IFACE;
       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
     }
-  else if (CONST_STRNEQ (name, ".MIPS.content"))
+  else if (startswith (name, ".MIPS.content"))
     {
       hdr->sh_type = SHT_MIPS_CONTENT;
       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
@@ -7663,20 +7663,20 @@  _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
       hdr->sh_entsize = 1;
       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
     }
-  else if (CONST_STRNEQ (name, ".MIPS.abiflags"))
+  else if (startswith (name, ".MIPS.abiflags"))
     {
       hdr->sh_type = SHT_MIPS_ABIFLAGS;
       hdr->sh_entsize = sizeof (Elf_External_ABIFlags_v0);
     }
-  else if (CONST_STRNEQ (name, ".debug_")
-	   || CONST_STRNEQ (name, ".zdebug_"))
+  else if (startswith (name, ".debug_")
+	   || startswith (name, ".zdebug_"))
     {
       hdr->sh_type = SHT_MIPS_DWARF;
 
       /* Irix facilities such as libexc expect a single .debug_frame
 	 per executable, the system ones have NOSTRIP set and the linker
 	 doesn't merge sections with different flags so ...  */
-      if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
+      if (SGI_COMPAT (abfd) && startswith (name, ".debug_frame"))
 	hdr->sh_flags |= SHF_MIPS_NOSTRIP;
     }
   else if (strcmp (name, ".MIPS.symlib") == 0)
@@ -7685,8 +7685,8 @@  _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
       /* The sh_link and sh_info fields are set in
 	 final_write_processing.  */
     }
-  else if (CONST_STRNEQ (name, ".MIPS.events")
-	   || CONST_STRNEQ (name, ".MIPS.post_rel"))
+  else if (startswith (name, ".MIPS.events")
+	   || startswith (name, ".MIPS.post_rel"))
     {
       hdr->sh_type = SHT_MIPS_EVENTS;
       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
@@ -10007,7 +10007,7 @@  _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
       if ((s->flags & SEC_LINKER_CREATED) == 0)
 	continue;
 
-      if (CONST_STRNEQ (name, ".rel"))
+      if (startswith (name, ".rel"))
 	{
 	  if (s->size != 0)
 	    {
@@ -10044,14 +10044,14 @@  _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
 	}
       else if (bfd_link_executable (info)
 	       && ! mips_elf_hash_table (info)->use_rld_obj_head
-	       && CONST_STRNEQ (name, ".rld_map"))
+	       && startswith (name, ".rld_map"))
 	{
 	  /* We add a room for __rld_map.  It will be filled in by the
 	     rtld to contain a pointer to the _r_debug structure.  */
 	  s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
 	}
       else if (SGI_COMPAT (output_bfd)
-	       && CONST_STRNEQ (name, ".compact_rel"))
+	       && startswith (name, ".compact_rel"))
 	s->size += mips_elf_hash_table (info)->compact_rel_size;
       else if (s == htab->root.splt)
 	{
@@ -10063,7 +10063,7 @@  _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
 	      && s->size > 0)
 	    s->size += 4;
 	}
-      else if (! CONST_STRNEQ (name, ".init")
+      else if (! startswith (name, ".init")
 	       && s != htab->root.sgot
 	       && s != htab->root.sgotplt
 	       && s != htab->sstubs
@@ -12422,7 +12422,7 @@  _bfd_mips_final_write_processing (bfd *abfd)
 	  BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
 	  name = bfd_section_name ((*hdrpp)->bfd_section);
 	  BFD_ASSERT (name != NULL
-		      && CONST_STRNEQ (name, ".gptab."));
+		      && startswith (name, ".gptab."));
 	  sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
 	  BFD_ASSERT (sec != NULL);
 	  (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
@@ -12432,7 +12432,7 @@  _bfd_mips_final_write_processing (bfd *abfd)
 	  BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
 	  name = bfd_section_name ((*hdrpp)->bfd_section);
 	  BFD_ASSERT (name != NULL
-		      && CONST_STRNEQ (name, ".MIPS.content"));
+		      && startswith (name, ".MIPS.content"));
 	  sec = bfd_get_section_by_name (abfd,
 					 name + sizeof ".MIPS.content" - 1);
 	  BFD_ASSERT (sec != NULL);
@@ -12452,12 +12452,12 @@  _bfd_mips_final_write_processing (bfd *abfd)
 	  BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
 	  name = bfd_section_name ((*hdrpp)->bfd_section);
 	  BFD_ASSERT (name != NULL);
-	  if (CONST_STRNEQ (name, ".MIPS.events"))
+	  if (startswith (name, ".MIPS.events"))
 	    sec = bfd_get_section_by_name (abfd,
 					   name + sizeof ".MIPS.events" - 1);
 	  else
 	    {
-	      BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
+	      BFD_ASSERT (startswith (name, ".MIPS.post_rel"));
 	      sec = bfd_get_section_by_name (abfd,
 					     (name
 					      + sizeof ".MIPS.post_rel" - 1));
@@ -15085,7 +15085,7 @@  _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 	  mdebug_sec = o;
 	}
 
-      if (CONST_STRNEQ (o->name, ".gptab."))
+      if (startswith (o->name, ".gptab."))
 	{
 	  const char *subname;
 	  unsigned int c;
diff --git a/bfd/elfxx-sparc.c b/bfd/elfxx-sparc.c
index bbf129c86e3..c498d1cb70b 100644
--- a/bfd/elfxx-sparc.c
+++ b/bfd/elfxx-sparc.c
@@ -2540,7 +2540,7 @@  _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (CONST_STRNEQ (s->name, ".rela"))
+      else if (startswith (s->name, ".rela"))
 	{
 	  if (s->size != 0)
 	    {
diff --git a/bfd/elfxx-x86.c b/bfd/elfxx-x86.c
index 93ad38c5eb0..6ff9fd56ee7 100644
--- a/bfd/elfxx-x86.c
+++ b/bfd/elfxx-x86.c
@@ -686,13 +686,13 @@  elf_x86_link_hash_table_free (bfd *obfd)
 static bfd_boolean
 elf_i386_is_reloc_section (const char *secname)
 {
-  return CONST_STRNEQ (secname, ".rel");
+  return startswith (secname, ".rel");
 }
 
 static bfd_boolean
 elf_x86_64_is_reloc_section (const char *secname)
 {
-  return CONST_STRNEQ (secname, ".rela");
+  return startswith (secname, ".rela");
 }
 
 /* Create an x86 ELF linker hash table.  */
diff --git a/bfd/hpux-core.c b/bfd/hpux-core.c
index 03d0de33822..d84df68c823 100644
--- a/bfd/hpux-core.c
+++ b/bfd/hpux-core.c
@@ -145,7 +145,7 @@  thread_section_p (bfd *abfd ATTRIBUTE_UNUSED,
 		  asection *sect,
 		  void *obj ATTRIBUTE_UNUSED)
 {
-  return CONST_STRNEQ (sect->name, ".reg/");
+  return startswith (sect->name, ".reg/");
 }
 
 /* this function builds a bfd target if the file is a corefile.
diff --git a/bfd/libcoff.h b/bfd/libcoff.h
index bb9066f5ec5..f2ce3c5e0ca 100644
--- a/bfd/libcoff.h
+++ b/bfd/libcoff.h
@@ -977,7 +977,7 @@  typedef struct
 /* Macro: Returns true if the bfd is a PE executable as opposed to a
    PE object file.  */
 #define bfd_pei_p(abfd) \
-  (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
+  (startswith ((abfd)->xvec->name, "pei-"))
 #ifdef __cplusplus
 }
 #endif
diff --git a/bfd/linker.c b/bfd/linker.c
index 7e0415cbed2..6f6e6842926 100644
--- a/bfd/linker.c
+++ b/bfd/linker.c
@@ -579,7 +579,7 @@  bfd_wrapped_link_hash_lookup (bfd *abfd,
 #define REAL "__real_"
 
       if (*l == '_'
-	  && CONST_STRNEQ (l, REAL)
+	  && startswith (l, REAL)
 	  && bfd_hash_lookup (info->wrap_hash, l + sizeof REAL - 1,
 			      FALSE, FALSE) != NULL)
 	{
@@ -623,7 +623,7 @@  unwrap_hash_lookup (struct bfd_link_info *info,
       || *l == info->wrap_char)
     ++l;
 
-  if (CONST_STRNEQ (l, WRAP))
+  if (startswith (l, WRAP))
     {
       l += sizeof WRAP - 1;
 
@@ -964,7 +964,7 @@  _bfd_generic_link_add_archive_symbols
 
 	  if (h == NULL
 	      && info->pei386_auto_import
-	      && CONST_STRNEQ (arsym->name, "__imp_"))
+	      && startswith (arsym->name, "__imp_"))
 	    h = bfd_link_hash_lookup (info->hash, arsym->name + 6,
 				      FALSE, FALSE, TRUE);
 	  if (h == NULL)
@@ -1536,7 +1536,7 @@  _bfd_generic_link_add_one_symbol (struct bfd_link_info *info,
 		s = name + 1;
 		while (*s == '_')
 		  ++s;
-		if (s[0] == 'G' && CONST_STRNEQ (s, CONS_PREFIX))
+		if (s[0] == 'G' && startswith (s, CONS_PREFIX))
 		  {
 		    char c;
 
diff --git a/bfd/mmo.c b/bfd/mmo.c
index 4ba62d0bc69..53883a31843 100644
--- a/bfd/mmo.c
+++ b/bfd/mmo.c
@@ -2505,7 +2505,7 @@  mmo_internal_write_section (bfd *abfd, asection *sec)
       bfd_set_error (bfd_error_bad_value);
       return FALSE;
     }
-  else if (CONST_STRNEQ (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX))
+  else if (startswith (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX))
     {
       int n = atoi (sec->name + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX));
 
diff --git a/bfd/osf-core.c b/bfd/osf-core.c
index 17cc532396a..999796753f5 100644
--- a/bfd/osf-core.c
+++ b/bfd/osf-core.c
@@ -84,7 +84,7 @@  osf_core_core_file_p (bfd *abfd)
   if (val != sizeof core_header)
     return NULL;
 
-  if (! CONST_STRNEQ (core_header.magic, "Core"))
+  if (! startswith (core_header.magic, "Core"))
     return NULL;
 
   core_hdr (abfd) = (struct osf_core_struct *)
diff --git a/bfd/pef.c b/bfd/pef.c
index 93bc933eec1..c9304115f6d 100644
--- a/bfd/pef.c
+++ b/bfd/pef.c
@@ -219,7 +219,7 @@  bfd_pef_print_symbol (bfd *abfd,
     default:
       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
       fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
-      if (CONST_STRNEQ (symbol->name, "__traceback_"))
+      if (startswith (symbol->name, "__traceback_"))
 	{
 	  unsigned char *buf;
 	  size_t offset = symbol->value + 4;
diff --git a/bfd/pei-x86_64.c b/bfd/pei-x86_64.c
index 6ce808a2c8c..85c0ca2113b 100644
--- a/bfd/pei-x86_64.c
+++ b/bfd/pei-x86_64.c
@@ -835,7 +835,7 @@  static void
 pex64_print_all_pdata_sections (bfd *abfd, asection *pdata, void *arg)
 {
   struct pex64_paps *paps = arg;
-  if (CONST_STRNEQ (pdata->name, ".pdata"))
+  if (startswith (pdata->name, ".pdata"))
     {
       if (pex64_bfd_print_pdata_section (abfd, paps->obj, pdata))
 	paps->pdata_count++;
diff --git a/bfd/som.c b/bfd/som.c
index 872e93341d1..01bcd16cc1e 100644
--- a/bfd/som.c
+++ b/bfd/som.c
@@ -4803,12 +4803,12 @@  som_slurp_symbol_table (bfd *abfd)
 	  && sym->symbol.name[strlen (sym->symbol.name) - 1] == '$'
 	  && !strcmp (sym->symbol.name, sym->symbol.section->name))
 	sym->symbol.flags |= BSF_SECTION_SYM;
-      else if (CONST_STRNEQ (sym->symbol.name, "L$0\002"))
+      else if (startswith (sym->symbol.name, "L$0\002"))
 	{
 	  sym->symbol.flags |= BSF_SECTION_SYM;
 	  sym->symbol.name = sym->symbol.section->name;
 	}
-      else if (CONST_STRNEQ (sym->symbol.name, "L$0\001"))
+      else if (startswith (sym->symbol.name, "L$0\001"))
 	sym->symbol.flags |= BSF_DEBUGGING;
 
       /* Note increment at bottom of loop, since we skip some symbols
@@ -6186,7 +6186,7 @@  som_slurp_armap (bfd *abfd)
     return FALSE;
 
   /* For archives without .o files there is no symbol table.  */
-  if (! CONST_STRNEQ (nextname, "/               "))
+  if (! startswith (nextname, "/               "))
     {
       abfd->has_armap = FALSE;
       return TRUE;
diff --git a/bfd/wasm-module.c b/bfd/wasm-module.c
index a8f65479af9..da9616e3c97 100644
--- a/bfd/wasm-module.c
+++ b/bfd/wasm-module.c
@@ -536,7 +536,7 @@  wasm_compute_custom_section_file_position (bfd *abfd,
   if (idx != 0)
     return;
 
-  if (CONST_STRNEQ (asect->name, WASM_SECTION_PREFIX))
+  if (startswith (asect->name, WASM_SECTION_PREFIX))
     {
       const char *name = asect->name + strlen (WASM_SECTION_PREFIX);
       bfd_size_type payload_len = asect->size;
diff --git a/binutils/dlltool.c b/binutils/dlltool.c
index 3d44a0b9630..ca31df964ef 100644
--- a/binutils/dlltool.c
+++ b/binutils/dlltool.c
@@ -1367,7 +1367,7 @@  scan_drectve_symbols (bfd *abfd)
   while (p < e)
     {
       if (p[0] == '-'
-	  && CONST_STRNEQ (p, "-export:"))
+	  && startswith (p, "-export:"))
 	{
 	  char * name;
 	  char * c;
@@ -1399,7 +1399,7 @@  scan_drectve_symbols (bfd *abfd)
 	      char *tag_start = ++p;
 	      while (p < e && *p != ' ' && *p != '-')
 		p++;
-	      if (CONST_STRNEQ (tag_start, "data"))
+	      if (startswith (tag_start, "data"))
 		flags &= ~BSF_FUNCTION;
 	    }
 
diff --git a/binutils/emul_aix.c b/binutils/emul_aix.c
index 5be8f3891c5..c11c28bd030 100644
--- a/binutils/emul_aix.c
+++ b/binutils/emul_aix.c
@@ -91,25 +91,25 @@  ar_emul_aix_replace (bfd **after_bfd, bfd *new_bfd,
 static bfd_boolean
 ar_emul_aix_parse_arg (char *arg)
 {
-  if (CONST_STRNEQ (arg, "-X32_64"))
+  if (startswith (arg, "-X32_64"))
     {
       big_archive = TRUE;
       X32 = TRUE;
       X64 = TRUE;
     }
-  else if (CONST_STRNEQ (arg, "-X32"))
+  else if (startswith (arg, "-X32"))
     {
       big_archive = TRUE;
       X32 = TRUE;
       X64 = FALSE;
     }
-  else if (CONST_STRNEQ (arg, "-X64"))
+  else if (startswith (arg, "-X64"))
     {
       big_archive = TRUE;
       X32 = FALSE;
       X64 = TRUE;
     }
-  else if (CONST_STRNEQ (arg, "-g"))
+  else if (startswith (arg, "-g"))
     {
       big_archive = FALSE;
       X32 = TRUE;
diff --git a/binutils/objcopy.c b/binutils/objcopy.c
index d58f910f2fa..f5e48e80d08 100644
--- a/binutils/objcopy.c
+++ b/binutils/objcopy.c
@@ -1316,7 +1316,7 @@  is_mergeable_note_section (bfd * abfd, asection * sec)
       && elf_section_data (sec)->this_hdr.sh_type == SHT_NOTE
       /* FIXME: We currently only support merging GNU_BUILD_NOTEs.
 	 We should add support for more note types.  */
-      && (CONST_STRNEQ (sec->name, GNU_BUILD_ATTRS_SECTION_NAME)))
+      && (startswith (sec->name, GNU_BUILD_ATTRS_SECTION_NAME)))
     return TRUE;
 
   return FALSE;
diff --git a/binutils/objdump.c b/binutils/objdump.c
index 0aa037384c6..cb5ce5b057c 100644
--- a/binutils/objdump.c
+++ b/binutils/objdump.c
@@ -3748,7 +3748,7 @@  dump_dwarf_section (bfd *abfd, asection *section,
   const char *match;
   int i;
 
-  if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
+  if (startswith (name, ".gnu.linkonce.wi."))
     match = ".debug_info";
   else
     match = name;
diff --git a/binutils/prdbg.c b/binutils/prdbg.c
index a93dccd544d..614d7f918f5 100644
--- a/binutils/prdbg.c
+++ b/binutils/prdbg.c
@@ -937,10 +937,10 @@  pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
       domain_type = pop_type (info);
       if (domain_type == NULL)
 	return FALSE;
-      if (CONST_STRNEQ (domain_type, "class ")
+      if (startswith (domain_type, "class ")
 	  && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
 	domain_type += sizeof "class " - 1;
-      else if (CONST_STRNEQ (domain_type, "union class ")
+      else if (startswith (domain_type, "union class ")
 	       && (strchr (domain_type + sizeof "union class " - 1, ' ')
 		   == NULL))
 	domain_type += sizeof "union class " - 1;
@@ -1349,7 +1349,7 @@  pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
   if (t == NULL)
     return FALSE;
 
-  if (CONST_STRNEQ (t, "class "))
+  if (startswith (t, "class "))
     t += sizeof "class " - 1;
 
   /* Push it back on to take advantage of the prepend_type and
@@ -2238,7 +2238,7 @@  tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
   if (t == NULL)
     return FALSE;
 
-  if (CONST_STRNEQ (t, "class "))
+  if (startswith (t, "class "))
     t += sizeof "class " - 1;
 
   /* Push it back on to take advantage of the prepend_type and
diff --git a/binutils/readelf.c b/binutils/readelf.c
index 9e8cd873e47..bcd05dfeda6 100644
--- a/binutils/readelf.c
+++ b/binutils/readelf.c
@@ -12707,7 +12707,7 @@  process_lto_symbol_tables (Filedata * filedata)
        i < filedata->file_header.e_shnum;
        i++, section++)
     if (SECTION_NAME_VALID (section)
-	&& CONST_STRNEQ (SECTION_NAME (section), ".gnu.lto_.symtab."))
+	&& startswith (SECTION_NAME (section), ".gnu.lto_.symtab."))
       res &= display_lto_symtab (filedata, section);
 
   return res;
diff --git a/binutils/stabs.c b/binutils/stabs.c
index 90254fdb2a6..5b6842ef04c 100644
--- a/binutils/stabs.c
+++ b/binutils/stabs.c
@@ -1760,12 +1760,12 @@  parse_stab_range_type (void *                dhandle,
 #define ULLHIGH "01777777777777777777777;"
       if (index_type == DEBUG_TYPE_NULL)
 	{
-	  if (CONST_STRNEQ (s2, LLLOW)
-	      && CONST_STRNEQ (s3, LLHIGH))
+	  if (startswith (s2, LLLOW)
+	      && startswith (s3, LLHIGH))
 	    return debug_make_int_type (dhandle, 8, FALSE);
 	  if (! ov2
 	      && n2 == 0
-	      && CONST_STRNEQ (s3, ULLHIGH))
+	      && startswith (s3, ULLHIGH))
 	    return debug_make_int_type (dhandle, 8, TRUE);
 	}
 
@@ -2987,7 +2987,7 @@  parse_stab_argtypes (void *dhandle, struct stab_handle *info,
 				   && (ISDIGIT (argtypes[2])
 				       || argtypes[2] == 'Q'
 				       || argtypes[2] == 't'))
-				  || CONST_STRNEQ (argtypes, "__ct"));
+				  || startswith (argtypes, "__ct"));
 
   is_constructor = (is_full_physname_constructor
 		    || (tagname != NULL
@@ -2995,7 +2995,7 @@  parse_stab_argtypes (void *dhandle, struct stab_handle *info,
   is_destructor = ((argtypes[0] == '_'
 		    && (argtypes[1] == '$' || argtypes[1] == '.')
 		    && argtypes[2] == '_')
-		   || CONST_STRNEQ (argtypes, "__dt"));
+		   || startswith (argtypes, "__dt"));
   is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
 
   if (!(is_destructor || is_full_physname_constructor || is_v3))
@@ -3995,7 +3995,7 @@  stab_demangle_function_name (struct stab_demangle_info *minfo,
   *pp = scan + 2;
 
   if (*pp - name >= 5
-	   && CONST_STRNEQ (name, "type")
+	   && startswith (name, "type")
 	   && (name[4] == '$' || name[4] == '.'))
     {
       const char *tem;
diff --git a/gas/config/tc-i386.c b/gas/config/tc-i386.c
index 079012267fd..84a3f292656 100644
--- a/gas/config/tc-i386.c
+++ b/gas/config/tc-i386.c
@@ -13016,7 +13016,7 @@  md_parse_option (int c, const char *arg)
 
 	list = bfd_target_list ();
 	for (l = list; *l != NULL; l++)
-	  if (CONST_STRNEQ (*l, "elf64-x86-64")
+	  if (startswith (*l, "elf64-x86-64")
 	      || strcmp (*l, "coff-x86-64") == 0
 	      || strcmp (*l, "pe-x86-64") == 0
 	      || strcmp (*l, "pei-x86-64") == 0
@@ -13040,7 +13040,7 @@  md_parse_option (int c, const char *arg)
 
 	  list = bfd_target_list ();
 	  for (l = list; *l != NULL; l++)
-	    if (CONST_STRNEQ (*l, "elf32-x86-64"))
+	    if (startswith (*l, "elf32-x86-64"))
 	      {
 		default_arch = "x86_64:32";
 		break;
@@ -14366,7 +14366,7 @@  x86_64_section_letter (int letter, const char **ptr_msg)
 bfd_vma
 x86_64_section_word (char *str, size_t len)
 {
-  if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
+  if (len == 5 && flag_code == CODE_64BIT && startswith (str, "large"))
     return SHF_X86_64_LARGE;
 
   return -1;
diff --git a/gas/config/tc-sparc.c b/gas/config/tc-sparc.c
index d526a34489a..61cd27d7239 100644
--- a/gas/config/tc-sparc.c
+++ b/gas/config/tc-sparc.c
@@ -548,12 +548,12 @@  md_parse_option (int c, const char *arg)
 	  {
 	    if (sparc_arch_size == 32)
 	      {
-		if (CONST_STRNEQ (*l, "elf32-sparc"))
+		if (startswith (*l, "elf32-sparc"))
 		  break;
 	      }
 	    else
 	      {
-		if (CONST_STRNEQ (*l, "elf64-sparc"))
+		if (startswith (*l, "elf64-sparc"))
 		  break;
 	      }
 	  }
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index 4e2ab32b5ee..23540092e77 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -8535,7 +8535,7 @@  show_disassembly_style_sfunc (struct ui_file *file, int from_tty,
   const char *opt;
 
   FOR_EACH_DISASSEMBLER_OPTION (opt, options)
-    if (CONST_STRNEQ (opt, "reg-names-"))
+    if (startswith (opt, "reg-names-"))
       {
 	style = &opt[strlen ("reg-names-")];
 	len = strcspn (style, ",");
@@ -9575,14 +9575,14 @@  _initialize_arm_tdep ()
     = &disassembler_options_arm ()->options;
   int num_disassembly_styles = 0;
   for (i = 0; disasm_options->name[i] != NULL; i++)
-    if (CONST_STRNEQ (disasm_options->name[i], "reg-names-"))
+    if (startswith (disasm_options->name[i], "reg-names-"))
       num_disassembly_styles++;
 
   /* Initialize the array that will be passed to add_setshow_enum_cmd().  */
   valid_disassembly_styles = XNEWVEC (const char *,
 				      num_disassembly_styles + 1);
   for (i = j = 0; disasm_options->name[i] != NULL; i++)
-    if (CONST_STRNEQ (disasm_options->name[i], "reg-names-"))
+    if (startswith (disasm_options->name[i], "reg-names-"))
       {
 	size_t offset = strlen ("reg-names-");
 	const char *style = disasm_options->name[i];
diff --git a/ld/emultempl/aix.em b/ld/emultempl/aix.em
index e098f2a8850..6fd67b2b7f8 100644
--- a/ld/emultempl/aix.em
+++ b/ld/emultempl/aix.em
@@ -287,7 +287,7 @@  gld${EMULATION_NAME}_parse_args (int argc, char **argv)
   if (indx == 0)
     indx = 1;
 
-  if (indx < argc && CONST_STRNEQ (argv[indx], "-b"))
+  if (indx < argc && startswith (argv[indx], "-b"))
     {
       char *s;
 
diff --git a/ld/emultempl/beos.em b/ld/emultempl/beos.em
index fc43ce14677..d984d3dd198 100644
--- a/ld/emultempl/beos.em
+++ b/ld/emultempl/beos.em
@@ -461,8 +461,8 @@  sort_by_section_name (const void *a, const void *b)
      FIXME stripping images with a .rsrc section still needs to be fixed.  */
   if (i != 0)
     {
-      if ((CONST_STRNEQ (sna, ".stab"))
-	  && (!CONST_STRNEQ (snb, ".stab")))
+      if ((startswith (sna, ".stab"))
+	  && (!startswith (snb, ".stab")))
 	return 1;
     }
   return i;
@@ -536,7 +536,7 @@  sort_sections (lang_statement_union_type *s)
 	    {
 	      /* Is this the .idata section?  */
 	      if (sec->spec.name != NULL
-		  && CONST_STRNEQ (sec->spec.name, ".idata"))
+		  && startswith (sec->spec.name, ".idata"))
 		{
 		  /* Sort the children.  We want to sort any objects in
 		     the same archive.  In order to handle the case of
diff --git a/ld/emultempl/elf.em b/ld/emultempl/elf.em
index 9e7c3d86a9e..986b77e92d9 100644
--- a/ld/emultempl/elf.em
+++ b/ld/emultempl/elf.em
@@ -712,7 +712,7 @@  fragment <<EOF
 	link_info.unresolved_syms_in_objects = RM_IGNORE;
       else if (strcmp (optarg, "muldefs") == 0)
 	link_info.allow_multiple_definition = TRUE;
-      else if (CONST_STRNEQ (optarg, "max-page-size="))
+      else if (startswith (optarg, "max-page-size="))
 	{
 	  char *end;
 
@@ -722,7 +722,7 @@  fragment <<EOF
 	    einfo (_("%F%P: invalid maximum page size \`%s'\n"),
 		   optarg + 14);
 	}
-      else if (CONST_STRNEQ (optarg, "common-page-size="))
+      else if (startswith (optarg, "common-page-size="))
 	{
 	  char *end;
 	  link_info.commonpagesize = strtoul (optarg + 17, &end, 0);
@@ -731,7 +731,7 @@  fragment <<EOF
 	    einfo (_("%F%P: invalid common page size \`%s'\n"),
 		   optarg + 17);
 	}
-      else if (CONST_STRNEQ (optarg, "stack-size="))
+      else if (startswith (optarg, "stack-size="))
 	{
 	  char *end;
 	  link_info.stacksize = strtoul (optarg + 11, &end, 0);
@@ -760,11 +760,11 @@  fragment <<EOF
 	{
 	  link_info.flags_1 |= DF_1_GLOBAUDIT;
 	}
-      else if (CONST_STRNEQ (optarg, "start-stop-gc"))
+      else if (startswith (optarg, "start-stop-gc"))
 	link_info.start_stop_gc = TRUE;
-      else if (CONST_STRNEQ (optarg, "nostart-stop-gc"))
+      else if (startswith (optarg, "nostart-stop-gc"))
 	link_info.start_stop_gc = FALSE;
-      else if (CONST_STRNEQ (optarg, "start-stop-visibility="))
+      else if (startswith (optarg, "start-stop-visibility="))
 	{
 	  if (strcmp (optarg, "start-stop-visibility=default") == 0)
 	    link_info.start_stop_visibility = STV_DEFAULT;
diff --git a/ld/emultempl/pe.em b/ld/emultempl/pe.em
index 748a6b49412..ea11a02e7c8 100644
--- a/ld/emultempl/pe.em
+++ b/ld/emultempl/pe.em
@@ -1529,7 +1529,7 @@  gld_${EMULATION_NAME}_after_open (void)
 	      {
 		if (strcmp (sec->name, ".idata\$2") == 0)
 		  idata2 = 1;
-		if (CONST_STRNEQ (sec->name, ".idata\$"))
+		if (startswith (sec->name, ".idata\$"))
 		  is_imp = 1;
 		reloc_count += sec->reloc_count;
 	      }
diff --git a/ld/emultempl/pep.em b/ld/emultempl/pep.em
index ff49c15c002..5f539cb7a3e 100644
--- a/ld/emultempl/pep.em
+++ b/ld/emultempl/pep.em
@@ -1501,7 +1501,7 @@  gld_${EMULATION_NAME}_after_open (void)
 	      {
 		if (strcmp (sec->name, ".idata\$2") == 0)
 		  idata2 = 1;
-		if (CONST_STRNEQ (sec->name, ".idata\$"))
+		if (startswith (sec->name, ".idata\$"))
 		  is_imp = 1;
 		reloc_count += sec->reloc_count;
 	      }
diff --git a/ld/emultempl/xtensaelf.em b/ld/emultempl/xtensaelf.em
index cdab038db7e..2b0fa5af64c 100644
--- a/ld/emultempl/xtensaelf.em
+++ b/ld/emultempl/xtensaelf.em
@@ -262,7 +262,7 @@  replace_instruction_table_sections (bfd *abfd, asection *sec)
       insn_sec_name = INSN_SEC_BASE_NAME;
       prop_sec_name = PROP_SEC_BASE_NAME;
     }
-  else if (CONST_STRNEQ (sec_name, LINKONCE_SEC_OLD_TEXT_BASE_NAME))
+  else if (startswith (sec_name, LINKONCE_SEC_OLD_TEXT_BASE_NAME))
     {
       insn_sec_name = sec_name;
       owned_prop_sec_name = (char *) xmalloc (strlen (sec_name) + 20);
@@ -1320,7 +1320,7 @@  is_inconsistent_linkonce_section (asection *sec)
   /* Check if this is an Xtensa property section or an exception table
      for Tensilica's XCC compiler.  */
   name = sec_name + linkonce_len;
-  if (CONST_STRNEQ (name, "prop."))
+  if (startswith (name, "prop."))
     name = strchr (name + 5, '.') ? strchr (name + 5, '.') + 1 : name + 5;
   else if (name[1] == '.'
 	   && (name[0] == 'p' || name[0] == 'e' || name[0] == 'h'))
diff --git a/ld/ldctor.c b/ld/ldctor.c
index 7ab6f36c46f..841ffe3b1e5 100644
--- a/ld/ldctor.c
+++ b/ld/ldctor.c
@@ -131,7 +131,7 @@  ctor_prio (const char *name)
   while (*name == '_')
     ++name;
 
-  if (!CONST_STRNEQ (name, "GLOBAL_"))
+  if (!startswith (name, "GLOBAL_"))
     return -1;
 
   name += sizeof "GLOBAL_" - 1;
diff --git a/ld/ldelf.c b/ld/ldelf.c
index a733131e51c..94d775db5cd 100644
--- a/ld/ldelf.c
+++ b/ld/ldelf.c
@@ -321,7 +321,7 @@  ldelf_try_needed (struct dt_needed *needed, int force, int is_linux)
 	      struct bfd_link_needed_list *l;
 
 	      for (l = needs; l != NULL; l = l->next)
-		if (CONST_STRNEQ (l->name, "libc.so"))
+		if (startswith (l->name, "libc.so"))
 		  break;
 	      if (l == NULL)
 		{
@@ -837,7 +837,7 @@  ldelf_parse_ld_so_conf (struct ldelf_ld_so_conf *info, const char *filename)
       if (p[0] == '\0')
 	continue;
 
-      if (CONST_STRNEQ (p, "include") && (p[7] == ' ' || p[7] == '\t'))
+      if (startswith (p, "include") && (p[7] == ' ' || p[7] == '\t'))
 	{
 	  char *dir, c;
 	  p += 8;
@@ -1089,7 +1089,7 @@  ldelf_after_open (int use_libpath, int native, int is_linux, int is_freebsd,
 
 	      if (bfd_is_abs_section (s->output_section))
 		continue;
-	      if (CONST_STRNEQ (name, ".eh_frame_entry"))
+	      if (startswith (name, ".eh_frame_entry"))
 		type = COMPACT_EH_HDR;
 	      else if (strcmp (name, ".eh_frame") == 0 && s->size > 8)
 		type = DWARF2_EH_HDR;
@@ -1820,7 +1820,7 @@  output_rel_find (int isdyn, int rela)
        lookup = lookup->next)
     {
       if (lookup->constraint >= 0
-	  && CONST_STRNEQ (lookup->name, ".rel"))
+	  && startswith (lookup->name, ".rel"))
 	{
 	  int lookrela = lookup->name[4] == 'a';
 
@@ -1971,7 +1971,7 @@  ldelf_place_orphan (asection *s, const char *secname, int constraint)
 	  default:
 	    break;
 	  }
-      else if (CONST_STRNEQ (secname, ".rel"))
+      else if (startswith (secname, ".rel"))
 	{
 	  secname = secname[4] == 'a' ? ".rela.dyn" : ".rel.dyn";
 	  isdyn = 1;
@@ -2084,7 +2084,7 @@  ldelf_place_orphan (asection *s, const char *secname, int constraint)
   /* If this is a final link, then always put .gnu.warning.SYMBOL
      sections into the .text section to get them out of the way.  */
   if (bfd_link_executable (&link_info)
-      && CONST_STRNEQ (s->name, ".gnu.warning.")
+      && startswith (s->name, ".gnu.warning.")
       && hold[orphan_text].os != NULL)
     {
       os = hold[orphan_text].os;
@@ -2124,7 +2124,7 @@  ldelf_place_orphan (asection *s, const char *secname, int constraint)
   else if ((flags & SEC_LOAD) != 0
 	   && (elfinput
 	       ? sh_type == SHT_NOTE
-	       : CONST_STRNEQ (secname, ".note")))
+	       : startswith (secname, ".note")))
     place = &hold[orphan_interp];
   else if ((flags & (SEC_LOAD | SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) == 0)
     place = &hold[orphan_bss];
@@ -2137,7 +2137,7 @@  ldelf_place_orphan (asection *s, const char *secname, int constraint)
   else if ((flags & SEC_LOAD) != 0
 	   && (elfinput
 	       ? sh_type == SHT_RELA || sh_type == SHT_REL
-	       : CONST_STRNEQ (secname, ".rel")))
+	       : startswith (secname, ".rel")))
     place = &hold[orphan_rel];
   else if ((flags & SEC_CODE) == 0)
     place = &hold[orphan_rodata];
diff --git a/ld/ldfile.c b/ld/ldfile.c
index 81cb86d51e2..c428d1487f3 100644
--- a/ld/ldfile.c
+++ b/ld/ldfile.c
@@ -113,7 +113,7 @@  ldfile_add_library_path (const char *name, bfd_boolean cmdline)
      now.  */
   if (name[0] == '=')
     new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
-  else if (CONST_STRNEQ (name, "$SYSROOT"))
+  else if (startswith (name, "$SYSROOT"))
     new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL);
   else
     new_dirs->name = xstrdup (name);
diff --git a/ld/ldlang.c b/ld/ldlang.c
index 684e1d23a21..d02a30981c4 100644
--- a/ld/ldlang.c
+++ b/ld/ldlang.c
@@ -1186,7 +1186,7 @@  lang_add_input_file (const char *name,
 		     const char *target)
 {
   if (name != NULL
-      && (*name == '=' || CONST_STRNEQ (name, "$SYSROOT")))
+      && (*name == '=' || startswith (name, "$SYSROOT")))
     {
       lang_input_statement_type *ret;
       char *sysrooted_name
diff --git a/ld/ldmain.c b/ld/ldmain.c
index 7a3c02aeaa6..aa52205daf4 100644
--- a/ld/ldmain.c
+++ b/ld/ldmain.c
@@ -648,7 +648,7 @@  get_sysroot (int argc, char **argv)
   const char *path = NULL;
 
   for (i = 1; i < argc; i++)
-    if (CONST_STRNEQ (argv[i], "--sysroot="))
+    if (startswith (argv[i], "--sysroot="))
       path = argv[i] + strlen ("--sysroot=");
 
   if (!path)
@@ -681,7 +681,7 @@  get_emulation (int argc, char **argv)
 
   for (i = 1; i < argc; i++)
     {
-      if (CONST_STRNEQ (argv[i], "-m"))
+      if (startswith (argv[i], "-m"))
 	{
 	  if (argv[i][2] == '\0')
 	    {
@@ -935,7 +935,7 @@  add_archive_element (struct bfd_link_info *info,
       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
       if (h == NULL
 	  && info->pei386_auto_import
-	  && CONST_STRNEQ (name, "__imp_"))
+	  && startswith (name, "__imp_"))
 	h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
 
       if (h == NULL)
diff --git a/ld/ldwrite.c b/ld/ldwrite.c
index 2db0b63b792..ef1d88c6ce2 100644
--- a/ld/ldwrite.c
+++ b/ld/ldwrite.c
@@ -281,7 +281,7 @@  build_link_order (lang_statement_union_type *statement)
 static bfd_boolean
 unsplittable_name (const char *name)
 {
-  if (CONST_STRNEQ (name, ".stab"))
+  if (startswith (name, ".stab"))
     {
       /* There are several stab like string sections. We pattern match on
 	 ".stab...str"  */
@@ -326,7 +326,7 @@  clone_section (bfd *abfd, asection *s, const char *name, int *count)
     {
       /* Some section names cannot be truncated, as the name is
 	 used to locate some other section.  */
-      if (CONST_STRNEQ (name, ".stab")
+      if (startswith (name, ".stab")
 	  || strcmp (name, "$GDB_SYMBOLS$") == 0)
 	{
 	  einfo (_ ("%F%P: cannot create split section name for %s\n"), name);
diff --git a/ld/lexsup.c b/ld/lexsup.c
index 36492abb405..88eb79e7f69 100644
--- a/ld/lexsup.c
+++ b/ld/lexsup.c
@@ -1560,7 +1560,7 @@  parse_args (unsigned argc, char **argv)
 	  link_info.discard = discard_all;
 	  break;
 	case 'Y':
-	  if (CONST_STRNEQ (optarg, "P,"))
+	  if (startswith (optarg, "P,"))
 	    optarg += 2;
 	  free (default_dirlist);
 	  default_dirlist = xstrdup (optarg);
diff --git a/ld/pe-dll.c b/ld/pe-dll.c
index 7aba09cd359..154c6846beb 100644
--- a/ld/pe-dll.c
+++ b/ld/pe-dll.c
@@ -545,7 +545,7 @@  pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
 static bfd_boolean
 is_import (const char* n)
 {
-  return (CONST_STRNEQ (n, "__imp_"));
+  return (startswith (n, "__imp_"));
 }
 
 /* abfd is a bfd containing n (or NULL)
@@ -3531,7 +3531,7 @@  pe_implied_import_dll (const char *filename)
 
       /* Skip unwanted symbols, which are
 	 exported in buggy auto-import releases.  */
-      if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
+      if (! startswith (erva + name_rva, "__nm_"))
 	{
 	  int is_dup = 0;
 	  /* is_data is true if the address is in the data, rdata or bss
diff --git a/opcodes/aarch64-dis.c b/opcodes/aarch64-dis.c
index 19482f729ab..349d7ea7ec0 100644
--- a/opcodes/aarch64-dis.c
+++ b/opcodes/aarch64-dis.c
@@ -58,32 +58,32 @@  static void
 parse_aarch64_dis_option (const char *option, unsigned int len ATTRIBUTE_UNUSED)
 {
   /* Try to match options that are simple flags */
-  if (CONST_STRNEQ (option, "no-aliases"))
+  if (startswith (option, "no-aliases"))
     {
       no_aliases = 1;
       return;
     }
 
-  if (CONST_STRNEQ (option, "aliases"))
+  if (startswith (option, "aliases"))
     {
       no_aliases = 0;
       return;
     }
 
-  if (CONST_STRNEQ (option, "no-notes"))
+  if (startswith (option, "no-notes"))
     {
       no_notes = 1;
       return;
     }
 
-  if (CONST_STRNEQ (option, "notes"))
+  if (startswith (option, "notes"))
     {
       no_notes = 0;
       return;
     }
 
 #ifdef DEBUG_AARCH64
-  if (CONST_STRNEQ (option, "debug_dump"))
+  if (startswith (option, "debug_dump"))
     {
       debug_dump = 1;
       return;
diff --git a/opcodes/arc-dis.c b/opcodes/arc-dis.c
index 6a6404a1624..0c9b379bd2b 100644
--- a/opcodes/arc-dis.c
+++ b/opcodes/arc-dis.c
@@ -795,7 +795,7 @@  parse_option (const char *option)
       add_to_decodelist (FLOAT, DP);
       add_to_decodelist (FLOAT, CVT);
     }
-  else if (CONST_STRNEQ (option, "hex"))
+  else if (startswith (option, "hex"))
     print_hex = TRUE;
   else
     /* xgettext:c-format */
diff --git a/opcodes/arm-dis.c b/opcodes/arm-dis.c
index f16a5902479..9647d0019db 100644
--- a/opcodes/arm-dis.c
+++ b/opcodes/arm-dis.c
@@ -11600,7 +11600,7 @@  parse_arm_disassembler_options (const char *options)
 
   FOR_EACH_DISASSEMBLER_OPTION (opt, options)
     {
-      if (CONST_STRNEQ (opt, "reg-names-"))
+      if (startswith (opt, "reg-names-"))
 	{
 	  unsigned int i;
 	  for (i = 0; i < NUM_ARM_OPTIONS; i++)
@@ -11615,11 +11615,11 @@  parse_arm_disassembler_options (const char *options)
 	    opcodes_error_handler (_("unrecognised register name set: %s"),
 				   opt);
 	}
-      else if (CONST_STRNEQ (opt, "force-thumb"))
+      else if (startswith (opt, "force-thumb"))
 	force_thumb = 1;
-      else if (CONST_STRNEQ (opt, "no-force-thumb"))
+      else if (startswith (opt, "no-force-thumb"))
 	force_thumb = 0;
-      else if (CONST_STRNEQ (opt, "coproc"))
+      else if (startswith (opt, "coproc"))
 	{
 	  const char *procptr = opt + sizeof ("coproc") - 1;
 	  char *endptr;
@@ -11637,10 +11637,10 @@  parse_arm_disassembler_options (const char *options)
 	      continue;
 	    }
 	  endptr += 1;
-	  if (CONST_STRNEQ (endptr, "generic"))
+	  if (startswith (endptr, "generic"))
 	    cde_coprocs &= ~(1 << coproc_number);
-	  else if (CONST_STRNEQ (endptr, "cde")
-		   || CONST_STRNEQ (endptr, "CDE"))
+	  else if (startswith (endptr, "cde")
+		   || startswith (endptr, "CDE"))
 	    cde_coprocs |= (1 << coproc_number);
 	  else
 	    {
diff --git a/opcodes/cris-dis.c b/opcodes/cris-dis.c
index f4342491315..3f98cb028b5 100644
--- a/opcodes/cris-dis.c
+++ b/opcodes/cris-dis.c
@@ -786,7 +786,7 @@  print_with_operands (const struct cris_opcode *opcodep,
      better way).  */
   if (opcodep->name[0] == 'j')
     {
-      if (CONST_STRNEQ (opcodep->name, "jsr"))
+      if (startswith (opcodep->name, "jsr"))
 	/* It's "jsr" or "jsrc".  */
 	info->insn_type = dis_jsr;
       else
@@ -1360,16 +1360,16 @@  print_with_operands (const struct cris_opcode *opcodep,
      itself or in a "move.d const,rN, sub.d rN,rM"-like sequence.  */
   if (TRACE_CASE && case_offset_counter == 0)
     {
-      if (CONST_STRNEQ (opcodep->name, "sub"))
+      if (startswith (opcodep->name, "sub"))
 	case_offset = last_immediate;
 
       /* It could also be an "add", if there are negative case-values.  */
-      else if (CONST_STRNEQ (opcodep->name, "add"))
+      else if (startswith (opcodep->name, "add"))
 	/* The first case is the negated operand to the add.  */
 	case_offset = -last_immediate;
 
       /* A bound insn will tell us the number of cases.  */
-      else if (CONST_STRNEQ (opcodep->name, "bound"))
+      else if (startswith (opcodep->name, "bound"))
 	no_of_case_offsets = last_immediate + 1;
 
       /* A jump or jsr or branch breaks the chain of insns for a
diff --git a/opcodes/h8300-dis.c b/opcodes/h8300-dis.c
index 4cd8e3cced4..4696235a8db 100644
--- a/opcodes/h8300-dis.c
+++ b/opcodes/h8300-dis.c
@@ -655,7 +655,7 @@  bfd_h8_disassemble (bfd_vma addr, disassemble_info *info, int mach)
 		   regno[1]);
 	  return qi->length;
 	}
-      if (CONST_STRNEQ (q->name, "mova"))
+      if (startswith (q->name, "mova"))
 	{
 	  const op_type *args = q->args.nib;
 
diff --git a/opcodes/i386-dis.c b/opcodes/i386-dis.c
index 4e3304d4a4c..9e5c412fa4a 100644
--- a/opcodes/i386-dis.c
+++ b/opcodes/i386-dis.c
@@ -9413,38 +9413,38 @@  print_insn (bfd_vma pc, disassemble_info *info)
 
   for (p = info->disassembler_options; p != NULL; )
     {
-      if (CONST_STRNEQ (p, "amd64"))
+      if (startswith (p, "amd64"))
 	isa64 = amd64;
-      else if (CONST_STRNEQ (p, "intel64"))
+      else if (startswith (p, "intel64"))
 	isa64 = intel64;
-      else if (CONST_STRNEQ (p, "x86-64"))
+      else if (startswith (p, "x86-64"))
 	{
 	  address_mode = mode_64bit;
 	  priv.orig_sizeflag |= AFLAG | DFLAG;
 	}
-      else if (CONST_STRNEQ (p, "i386"))
+      else if (startswith (p, "i386"))
 	{
 	  address_mode = mode_32bit;
 	  priv.orig_sizeflag |= AFLAG | DFLAG;
 	}
-      else if (CONST_STRNEQ (p, "i8086"))
+      else if (startswith (p, "i8086"))
 	{
 	  address_mode = mode_16bit;
 	  priv.orig_sizeflag &= ~(AFLAG | DFLAG);
 	}
-      else if (CONST_STRNEQ (p, "intel"))
+      else if (startswith (p, "intel"))
 	{
 	  intel_syntax = 1;
-	  if (CONST_STRNEQ (p + 5, "-mnemonic"))
+	  if (startswith (p + 5, "-mnemonic"))
 	    intel_mnemonic = 1;
 	}
-      else if (CONST_STRNEQ (p, "att"))
+      else if (startswith (p, "att"))
 	{
 	  intel_syntax = 0;
-	  if (CONST_STRNEQ (p + 3, "-mnemonic"))
+	  if (startswith (p + 3, "-mnemonic"))
 	    intel_mnemonic = 0;
 	}
-      else if (CONST_STRNEQ (p, "addr"))
+      else if (startswith (p, "addr"))
 	{
 	  if (address_mode == mode_64bit)
 	    {
@@ -9461,14 +9461,14 @@  print_insn (bfd_vma pc, disassemble_info *info)
 		priv.orig_sizeflag |= AFLAG;
 	    }
 	}
-      else if (CONST_STRNEQ (p, "data"))
+      else if (startswith (p, "data"))
 	{
 	  if (p[4] == '1' && p[5] == '6')
 	    priv.orig_sizeflag &= ~DFLAG;
 	  else if (p[4] == '3' && p[5] == '2')
 	    priv.orig_sizeflag |= DFLAG;
 	}
-      else if (CONST_STRNEQ (p, "suffix"))
+      else if (startswith (p, "suffix"))
 	priv.orig_sizeflag |= SUFFIX_ALWAYS;
 
       p = strchr (p, ',');
diff --git a/opcodes/ia64-gen.c b/opcodes/ia64-gen.c
index 7f3f0edd5d3..de409bb2abd 100644
--- a/opcodes/ia64-gen.c
+++ b/opcodes/ia64-gen.c
@@ -467,7 +467,7 @@  fetch_insn_class (const char *full_name, int create)
   int ind;
   int is_class = 0;
 
-  if (CONST_STRNEQ (full_name, "IC:"))
+  if (startswith (full_name, "IC:"))
     {
       name = xstrdup (full_name + 3);
       is_class = 1;
@@ -746,7 +746,7 @@  parse_resource_users (const char *ref, int **usersp, int *nusersp,
          are read.  Only create new classes if it's *not* an insn class,
          or if it's a composite class (which wouldn't necessarily be in the IC
          table).  */
-      if (! CONST_STRNEQ (name, "IC:") || xsect != NULL)
+      if (! startswith (name, "IC:") || xsect != NULL)
         create = 1;
 
       iclass = fetch_insn_class (name, create);
@@ -1039,7 +1039,7 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
 
   if (ic->comment)
     {
-      if (CONST_STRNEQ (ic->comment, "Format"))
+      if (startswith (ic->comment, "Format"))
         {
           /* Assume that the first format seen is the most restrictive, and
              only keep a later one if it looks like it's more restrictive.  */
@@ -1055,7 +1055,7 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
           else
             format = ic->comment;
         }
-      else if (CONST_STRNEQ (ic->comment, "Field"))
+      else if (startswith (ic->comment, "Field"))
         {
           if (field)
             warn (_("overlapping field %s->%s\n"),
@@ -1069,7 +1069,7 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
      instructions.  */
   if (ic->nsubs == 0 && ic->nxsubs == 0)
     {
-      int is_mov = CONST_STRNEQ (idesc->name, "mov");
+      int is_mov = startswith (idesc->name, "mov");
       int plain_mov = strcmp (idesc->name, "mov") == 0;
       int len = strlen(ic->name);
 
@@ -1128,32 +1128,32 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
 
       if (resolved && format)
         {
-          if (CONST_STRNEQ (idesc->name, "dep")
+          if (startswith (idesc->name, "dep")
                    && strstr (format, "I13") != NULL)
             resolved = idesc->operands[1] == IA64_OPND_IMM8;
-          else if (CONST_STRNEQ (idesc->name, "chk")
+          else if (startswith (idesc->name, "chk")
                    && strstr (format, "M21") != NULL)
             resolved = idesc->operands[0] == IA64_OPND_F2;
-          else if (CONST_STRNEQ (idesc->name, "lfetch"))
+          else if (startswith (idesc->name, "lfetch"))
             resolved = (strstr (format, "M14 M15") != NULL
                         && (idesc->operands[1] == IA64_OPND_R2
                             || idesc->operands[1] == IA64_OPND_IMM9b));
-          else if (CONST_STRNEQ (idesc->name, "br.call")
+          else if (startswith (idesc->name, "br.call")
                    && strstr (format, "B5") != NULL)
             resolved = idesc->operands[1] == IA64_OPND_B2;
-          else if (CONST_STRNEQ (idesc->name, "br.call")
+          else if (startswith (idesc->name, "br.call")
                    && strstr (format, "B3") != NULL)
             resolved = idesc->operands[1] == IA64_OPND_TGT25c;
-          else if (CONST_STRNEQ (idesc->name, "brp")
+          else if (startswith (idesc->name, "brp")
                    && strstr (format, "B7") != NULL)
             resolved = idesc->operands[0] == IA64_OPND_B2;
           else if (strcmp (ic->name, "invala") == 0)
             resolved = strcmp (idesc->name, ic->name) == 0;
-	  else if (CONST_STRNEQ (idesc->name, "st")
+	  else if (startswith (idesc->name, "st")
 		   && (strstr (format, "M5") != NULL
 		       || strstr (format, "M10") != NULL))
 	    resolved = idesc->flags & IA64_OPCODE_POSTINC;
-	  else if (CONST_STRNEQ (idesc->name, "ld")
+	  else if (startswith (idesc->name, "ld")
 		   && (strstr (format, "M2 M3") != NULL
 		       || strstr (format, "M12") != NULL
 		       || strstr (format, "M7 M8") != NULL))
@@ -1166,7 +1166,7 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
          plain brl matches brl.cond.  */
       if (!resolved
           && (strcmp (idesc->name, "brl") == 0
-              || CONST_STRNEQ (idesc->name, "brl."))
+              || startswith (idesc->name, "brl."))
           && strcmp (ic->name, "brl.cond") == 0)
         {
           resolved = 1;
@@ -1175,7 +1175,7 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
       /* Misc br variations ('.cond' is optional).  */
       if (!resolved
           && (strcmp (idesc->name, "br") == 0
-              || CONST_STRNEQ (idesc->name, "br."))
+              || startswith (idesc->name, "br."))
           && strcmp (ic->name, "br.cond") == 0)
         {
           if (format)
@@ -1188,7 +1188,7 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
         }
 
       /* probe variations.  */
-      if (!resolved && CONST_STRNEQ (idesc->name, "probe"))
+      if (!resolved && startswith (idesc->name, "probe"))
         {
           resolved = strcmp (ic->name, "probe") == 0
             && !((strstr (idesc->name, "fault") != NULL)
@@ -1222,7 +1222,7 @@  in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
             }
 
           /* Some variants of mov and mov.[im].  */
-          if (!resolved && CONST_STRNEQ (ic->name, "mov_"))
+          if (!resolved && startswith (ic->name, "mov_"))
 	    resolved = in_iclass_mov_x (idesc, ic, format, field);
         }
 
@@ -1487,13 +1487,13 @@  lookup_specifier (const char *name)
       warn (_("Don't know how to specify # dependency %s\n"),
 	    name);
     }
-  else if (CONST_STRNEQ (name, "AR[FPSR]"))
+  else if (startswith (name, "AR[FPSR]"))
     return IA64_RS_AR_FPSR;
-  else if (CONST_STRNEQ (name, "AR["))
+  else if (startswith (name, "AR["))
     return IA64_RS_ARX;
-  else if (CONST_STRNEQ (name, "CR["))
+  else if (startswith (name, "CR["))
     return IA64_RS_CRX;
-  else if (CONST_STRNEQ (name, "PSR."))
+  else if (startswith (name, "PSR."))
     return IA64_RS_PSR;
   else if (strcmp (name, "InService*") == 0)
     return IA64_RS_INSERVICE;
@@ -2444,7 +2444,7 @@  insert_opcode_dependencies (struct ia64_opcode *opc,
       int j;
 
       if (strcmp (opc->name, "cmp.eq.and") == 0
-          && CONST_STRNEQ (rs->name, "PR%")
+          && startswith (rs->name, "PR%")
           && rs->mode == 1)
         no_class_found = 99;
 
@@ -2455,7 +2455,7 @@  insert_opcode_dependencies (struct ia64_opcode *opc,
           if (in_iclass (opc, ics[rs->regs[j]], NULL, NULL, &ic_note))
             {
               /* We can ignore ic_note 11 for non PR resources.  */
-              if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR"))
+              if (ic_note == 11 && ! startswith (rs->name, "PR"))
                 ic_note = 0;
 
               if (ic_note != 0 && rs->regnotes[j] != 0
@@ -2483,7 +2483,7 @@  insert_opcode_dependencies (struct ia64_opcode *opc,
           if (in_iclass (opc, ics[rs->chks[j]], NULL, NULL, &ic_note))
             {
               /* We can ignore ic_note 11 for non PR resources.  */
-              if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR"))
+              if (ic_note == 11 && ! startswith (rs->name, "PR"))
                 ic_note = 0;
 
               if (ic_note != 0 && rs->chknotes[j] != 0
diff --git a/opcodes/mips-dis.c b/opcodes/mips-dis.c
index 317ced51204..d1f73b4d9f6 100644
--- a/opcodes/mips-dis.c
+++ b/opcodes/mips-dis.c
@@ -923,7 +923,7 @@  set_default_mips_dis_options (struct disassemble_info *info)
 static bfd_boolean
 parse_mips_ase_option (const char *option)
 {
-  if (CONST_STRNEQ (option, "msa"))
+  if (startswith (option, "msa"))
     {
       mips_ase |= ASE_MSA;
       if ((mips_isa & INSN_ISA_MASK) == ISA_MIPS64R2
@@ -934,7 +934,7 @@  parse_mips_ase_option (const char *option)
       return TRUE;
     }
 
-  if (CONST_STRNEQ (option, "virt"))
+  if (startswith (option, "virt"))
     {
       mips_ase |= ASE_VIRT;
       if (mips_isa & ISA_MIPS64R2
@@ -945,38 +945,38 @@  parse_mips_ase_option (const char *option)
       return TRUE;
     }
 
-  if (CONST_STRNEQ (option, "xpa"))
+  if (startswith (option, "xpa"))
     {
       mips_ase |= ASE_XPA;
       return TRUE;
     }
 
-  if (CONST_STRNEQ (option, "ginv"))
+  if (startswith (option, "ginv"))
     {
       mips_ase |= ASE_GINV;
       return TRUE;
     }
 
-  if (CONST_STRNEQ (option, "loongson-mmi"))
+  if (startswith (option, "loongson-mmi"))
     {
       mips_ase |= ASE_LOONGSON_MMI;
       return TRUE;
     }
 
-  if (CONST_STRNEQ (option, "loongson-cam"))
+  if (startswith (option, "loongson-cam"))
     {
       mips_ase |= ASE_LOONGSON_CAM;
       return TRUE;
     }
   
   /* Put here for match ext2 frist */
-  if (CONST_STRNEQ (option, "loongson-ext2"))
+  if (startswith (option, "loongson-ext2"))
     {
       mips_ase |= ASE_LOONGSON_EXT2;
       return TRUE;
     }
 
-  if (CONST_STRNEQ (option, "loongson-ext"))
+  if (startswith (option, "loongson-ext"))
     {
       mips_ase |= ASE_LOONGSON_EXT;
       return TRUE;
@@ -994,7 +994,7 @@  parse_mips_dis_option (const char *option, unsigned int len)
   const struct mips_arch_choice *chosen_arch;
 
   /* Try to match options that are simple flags */
-  if (CONST_STRNEQ (option, "no-aliases"))
+  if (startswith (option, "no-aliases"))
     {
       no_aliases = 1;
       return;
diff --git a/opcodes/s390-dis.c b/opcodes/s390-dis.c
index 1eb372554da..4708b094560 100644
--- a/opcodes/s390-dis.c
+++ b/opcodes/s390-dis.c
@@ -65,11 +65,11 @@  disassemble_init_s390 (struct disassemble_info *info)
 
   for (p = info->disassembler_options; p != NULL; )
     {
-      if (CONST_STRNEQ (p, "esa"))
+      if (startswith (p, "esa"))
 	current_arch_mask = 1 << S390_OPCODE_ESA;
-      else if (CONST_STRNEQ (p, "zarch"))
+      else if (startswith (p, "zarch"))
 	current_arch_mask = 1 << S390_OPCODE_ZARCH;
-      else if (CONST_STRNEQ (p, "insnlength"))
+      else if (startswith (p, "insnlength"))
 	option_use_insn_len_bits_p = 1;
       else
 	/* xgettext:c-format */
diff --git a/opcodes/wasm32-dis.c b/opcodes/wasm32-dis.c
index 2fe5132e129..69266610ad3 100644
--- a/opcodes/wasm32-dis.c
+++ b/opcodes/wasm32-dis.c
@@ -120,9 +120,9 @@  parse_wasm32_disassembler_options (struct disassemble_info *info,
 
   while (opts != NULL)
     {
-      if (CONST_STRNEQ (opts, "registers"))
+      if (startswith (opts, "registers"))
         private->print_registers = TRUE;
-      else if (CONST_STRNEQ (opts, "globals"))
+      else if (startswith (opts, "globals"))
         private->print_well_known_globals = TRUE;
 
       opts = strchr (opts, ',');
-- 
2.30.2