Change some arguments to gdb::string_view instead of name+len

Just some code cleanup. This change has a few benefits:
- Shorter argument list in the functions
- If the caller needs to calculate the string, they no longer
  need to explicitly call strlen
- It is easy to pass std::string to this (done in one place
  currently)

This also updates a couple of places that were passing 0/1 to
a bool parameter.

gdb/ChangeLog:

2019-10-29  Christian Biesinger  <cbiesinger@google.com>

	* coffread.c (record_minimal_symbol): Update.
	(process_coff_symbol): Update.
	* dbxread.c (read_dbx_symtab): Update.
	* dwarf2read.c (add_partial_symbol): Update.
	(fixup_go_packaging): Update.
	(load_partial_dies): Update.
	(new_symbol): Update.
	* elfread.c (record_minimal_symbol): Change signature to use
	gdb::string_view instead of name+len.
	(elf_symtab_read): Update.
	(elf_rel_plt_read): Update.
	* mdebugread.c (parse_partial_symbols): Update.
	(handle_psymbol_enumerators): Update.
	(new_symbol): Update.
	* minsyms.c (minimal_symbol_reader::record_full): Change signature
	to use gdb::string_view instead of name+len.
	* minsyms.h (class minimal_symbol_reader) <record_full>: Likewise.
	* psympriv.h (add_psymbol_to_list): Likewise.
	* psymtab.c (add_psymbol_to_bcache): Likewise.
	(add_psymbol_to_list): Likewise.
	* stabsread.c (define_symbol): Update.
	* symtab.c (symbol_set_names): Change signature to use gdb::string_view.
	* symtab.h (SYMBOL_SET_NAMES): Likewise.
	(symbol_set_names): Likewise.
	* xcoffread.c (scan_xcoff_symtab): Update.

Change-Id: I2675c6865e0368f9c755a1081088a53aa54dda4c

1 files changed, 19 insertions, 18 deletions

diff --git a/gdb/symtab.c b/gdb/symtab.c
index a6a9dc9..060e676 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -828,7 +828,7 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
 
 void
 symbol_set_names (struct general_symbol_info *gsymbol,
-		  const char *linkage_name, int len, bool copy_name,
+		  gdb::string_view linkage_name, bool copy_name,
 		  struct objfile_per_bfd_storage *per_bfd)
 {
   struct demangled_name_entry **slot;
@@ -838,14 +838,14 @@ symbol_set_names (struct general_symbol_info *gsymbol,
       /* In Ada, we do the symbol lookups using the mangled name, so
          we can save some space by not storing the demangled name.  */
       if (!copy_name)
-	gsymbol->name = linkage_name;
+	gsymbol->name = linkage_name.data ();
       else
 	{
 	  char *name = (char *) obstack_alloc (&per_bfd->storage_obstack,
-					       len + 1);
+					       linkage_name.length () + 1);
 
-	  memcpy (name, linkage_name, len);
-	  name[len] = '\0';
+	  memcpy (name, linkage_name.data (), linkage_name.length ());
+	  name[linkage_name.length ()] = '\0';
 	  gsymbol->name = name;
 	}
       symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
@@ -856,7 +856,7 @@ symbol_set_names (struct general_symbol_info *gsymbol,
   if (per_bfd->demangled_names_hash == NULL)
     create_demangled_names_hash (per_bfd);
 
-  struct demangled_name_entry entry (gdb::string_view (linkage_name, len));
+  struct demangled_name_entry entry (linkage_name);
   slot = ((struct demangled_name_entry **)
 	  htab_find_slot (per_bfd->demangled_names_hash.get (),
 			  &entry, INSERT));
@@ -870,20 +870,21 @@ symbol_set_names (struct general_symbol_info *gsymbol,
       /* A 0-terminated copy of the linkage name.  Callers must set COPY_NAME
          to true if the string might not be nullterminated.  We have to make
          this copy because demangling needs a nullterminated string.  */
-      const char *linkage_name_copy;
+      gdb::string_view linkage_name_copy;
       if (copy_name)
 	{
-	  char *alloc_name = (char *) alloca (len + 1);
-	  memcpy (alloc_name, linkage_name, len);
-	  alloc_name[len] = '\0';
+	  char *alloc_name = (char *) alloca (linkage_name.length () + 1);
+	  memcpy (alloc_name, linkage_name.data (), linkage_name.length ());
+	  alloc_name[linkage_name.length ()] = '\0';
 
-	  linkage_name_copy = alloc_name;
+	  linkage_name_copy = gdb::string_view (alloc_name,
+						linkage_name.length ());
 	}
       else
 	linkage_name_copy = linkage_name;
 
       gdb::unique_xmalloc_ptr<char> demangled_name_ptr
-	(symbol_find_demangled_name (gsymbol, linkage_name_copy));
+	(symbol_find_demangled_name (gsymbol, linkage_name_copy.data ()));
 
       /* Suppose we have demangled_name==NULL, copy_name==0, and
 	 linkage_name_copy==linkage_name.  In this case, we already have the
@@ -900,8 +901,7 @@ symbol_set_names (struct general_symbol_info *gsymbol,
 	    = ((struct demangled_name_entry *)
 	       obstack_alloc (&per_bfd->storage_obstack,
 			      sizeof (demangled_name_entry)));
-	  new (*slot) demangled_name_entry
-	    (gdb::string_view (linkage_name, len));
+	  new (*slot) demangled_name_entry (linkage_name);
 	}
       else
 	{
@@ -910,12 +910,13 @@ symbol_set_names (struct general_symbol_info *gsymbol,
 	  *slot
 	    = ((struct demangled_name_entry *)
 	       obstack_alloc (&per_bfd->storage_obstack,
-			      sizeof (demangled_name_entry) + len + 1));
+			      sizeof (demangled_name_entry)
+			      + linkage_name.length () + 1));
 	  char *mangled_ptr = reinterpret_cast<char *> (*slot + 1);
-	  memcpy (mangled_ptr, linkage_name, len);
-	  mangled_ptr [len] = '\0';
+	  memcpy (mangled_ptr, linkage_name.data (), linkage_name.length ());
+	  mangled_ptr [linkage_name.length ()] = '\0';
 	  new (*slot) demangled_name_entry
-	    (gdb::string_view (mangled_ptr, len));
+	    (gdb::string_view (mangled_ptr, linkage_name.length ()));
 	}
       (*slot)->demangled = std::move (demangled_name_ptr);
       (*slot)->language = gsymbol->language;