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

[deliverable/binutils-gdb.git] / gdb / symtab.c

diff --git a/gdb/symtab.c b/gdb/symtab.c
index a6a9dc9c6eba8a8774e9189bf6e0de5a60ea4b9c..060e676bbb60ac3a1a099be6a9070fb4635ee529 100644 (file)
--- 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;