gdbsupport: make gdb_abspath return an std::string

I'm trying to switch these functions to use std::string instead of char
arrays, as much as possible.  Some callers benefit from it (can avoid
doing a copy of the result), while others suffer (have to make one more
copy).

Change-Id: Iced49b8ee2f189744c5072a3b217aab5af17a993

diff --git a/gdb/compile/compile.c b/gdb/compile/compile.c
index 2a1f0f1bd6b97652887947a4f59f3b0b0aa2aabd..5cbb341b383bdc23054a069c640b3fde137c8f64 100644 (file)
--- a/gdb/compile/compile.c
+++ b/gdb/compile/compile.c
@@ -297,8 +297,8 @@ compile_file_command (const char *args, int from_tty)
     error (_("You must provide a filename for this command."));
 
   args = skip_spaces (args);
-  gdb::unique_xmalloc_ptr<char> abspath = gdb_abspath (args);
-  std::string buffer = string_printf ("#include \"%s\"\n", abspath.get ());
+  std::string abspath = gdb_abspath (args);
+  std::string buffer = string_printf ("#include \"%s\"\n", abspath.c_str ());
   eval_compile_command (NULL, buffer.c_str (), scope, NULL);
 }
 

diff --git a/gdb/corelow.c b/gdb/corelow.c
index a23dc81c5af90fc2b175c553edf0e63fb3fda0da..8c33fb7ebb2fac39aedadcd58c88ea89a758d735 100644 (file)
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -469,7 +469,7 @@ core_target_open (const char *arg, int from_tty)
   gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg));
   if (strlen (filename.get ()) != 0
       && !IS_ABSOLUTE_PATH (filename.get ()))
-    filename = gdb_abspath (filename.get ());
+    filename = make_unique_xstrdup (gdb_abspath (filename.get ()).c_str ());
 
   flags = O_BINARY | O_LARGEFILE;
   if (write_files)

diff --git a/gdb/dwarf2/index-cache.c b/gdb/dwarf2/index-cache.c
index 18e60cbd78cd5ee0389e86eca8f828c4c197450b..fb827e04e59b43e6448b48dfd6eff95e4e231422 100644 (file)
--- a/gdb/dwarf2/index-cache.c
+++ b/gdb/dwarf2/index-cache.c
@@ -298,9 +298,7 @@ set_index_cache_directory_command (const char *arg, int from_tty,
                                   cmd_list_element *element)
 {
   /* Make sure the index cache directory is absolute and tilde-expanded.  */
-  gdb::unique_xmalloc_ptr<char> abs
-    = gdb_abspath (index_cache_directory.c_str ());
-  index_cache_directory = abs.get ();
+  index_cache_directory = gdb_abspath (index_cache_directory.c_str ());
   global_index_cache.set_directory (index_cache_directory);
 }
 

diff --git a/gdb/main.c b/gdb/main.c
index 8c0807ff83b2d74aa1d1b2c7a35556772847a78c..ec2b7b017524d5df5a1e27c79cb2743312cae3c4 100644 (file)
--- a/gdb/main.c
+++ b/gdb/main.c
@@ -133,12 +133,7 @@ set_gdb_data_directory (const char *new_datadir)
      "../foo" and "../foo" doesn't exist then we'll record $(pwd)/../foo which
      isn't canonical, but that's ok.  */
   if (!IS_ABSOLUTE_PATH (gdb_datadir.c_str ()))
-    {
-      gdb::unique_xmalloc_ptr<char> abs_datadir
-       = gdb_abspath (gdb_datadir.c_str ());
-
-      gdb_datadir = abs_datadir.get ();
-    }
+    gdb_datadir = gdb_abspath (gdb_datadir.c_str ());
 }
 
 /* Relocate a file or directory.  PROGNAME is the name by which gdb

diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index 0c71e0bd6a9f0fd494186c1baea626cfc8440d08..849c6d73cab83905edd95df72d06b4211fbe5d27 100644 (file)
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -331,7 +331,7 @@ objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
 
   objfile_alloc_data (this);
 
-  gdb::unique_xmalloc_ptr<char> name_holder;
+  std::string name_holder;
   if (name == NULL)
     {
       gdb_assert (abfd == NULL);
@@ -344,7 +344,7 @@ objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
   else
     {
       name_holder = gdb_abspath (name);
-      expanded_name = name_holder.get ();
+      expanded_name = name_holder.c_str ();
     }
   original_name = obstack_strdup (&objfile_obstack, expanded_name);
 

diff --git a/gdb/source.c b/gdb/source.c
index e9016573333c4ec8a922c9ad47341ddbff890534..9d9ff4bbc3e993247afca3f8a0bcf20e091e29d1 100644 (file)
--- a/gdb/source.c
+++ b/gdb/source.c
@@ -537,15 +537,15 @@ add_path (const char *dirname, char **which_path, int parse_separators)
 
   for (const gdb::unique_xmalloc_ptr<char> &name_up : dir_vec)
     {
-      char *name = name_up.get ();
+      const char *name = name_up.get ();
       char *p;
       struct stat st;
-      gdb::unique_xmalloc_ptr<char> new_name_holder;
+      std::string new_name_holder;
 
       /* Spaces and tabs will have been removed by buildargv().
         NAME is the start of the directory.
         P is the '\0' following the end.  */
-      p = name + strlen (name);
+      p = name_up.get () + strlen (name);
 
       while (!(IS_DIR_SEPARATOR (*name) && p <= name + 1)      /* "/" */
 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
@@ -589,16 +589,18 @@ add_path (const char *dirname, char **which_path, int parse_separators)
       if (name[0] == '\0')
         goto skip_dup;
       if (name[0] == '~')
-       new_name_holder.reset (tilde_expand (name));
+       new_name_holder
+         = gdb::unique_xmalloc_ptr<char[]> (tilde_expand (name)).get ();
 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
       else if (IS_ABSOLUTE_PATH (name) && p == name + 2) /* "d:" => "d:." */
-       new_name_holder.reset (concat (name, ".", (char *) NULL));
+       new_name_holder = std::string (name) + ".";
 #endif
       else if (!IS_ABSOLUTE_PATH (name) && name[0] != '$')
        new_name_holder = gdb_abspath (name);
       else
-       new_name_holder.reset (savestring (name, p - name));
-      name = new_name_holder.get ();
+       new_name_holder = std::string (name, p - name);
+
+      name = new_name_holder.c_str ();
 
       /* Unless it's a variable, check existence.  */
       if (name[0] != '$')
@@ -950,7 +952,8 @@ done:
       else if ((opts & OPF_RETURN_REALPATH) != 0)
        *filename_opened = gdb_realpath (filename);
       else
-       *filename_opened = gdb_abspath (filename);
+       *filename_opened
+         = make_unique_xstrdup (gdb_abspath (filename).c_str ());
     }
 
   errno = last_errno;

diff --git a/gdb/top.c b/gdb/top.c
index e776ac2d70e1173335d2b9abb9bbcc9a442c38cd..1cfffbeee7eee2e259455a1bb2dbc7ef2ce2eb86 100644 (file)
--- a/gdb/top.c
+++ b/gdb/top.c
@@ -2167,12 +2167,7 @@ set_history_filename (const char *args,
      that was read.  */
   if (!history_filename.empty ()
       && !IS_ABSOLUTE_PATH (history_filename.c_str ()))
-    {
-      gdb::unique_xmalloc_ptr<char> temp
-       (gdb_abspath (history_filename.c_str ()));
-
-      history_filename = temp.get ();
-    }
+    history_filename = gdb_abspath (history_filename.c_str ());
 }
 
 /* Whether we're in quiet startup mode.  */
@@ -2444,7 +2439,6 @@ _initialize_top ()
       const char *fname = ".gdb_history";
 #endif
 
-      gdb::unique_xmalloc_ptr<char> temp (gdb_abspath (fname));
-      history_filename = temp.get ();
+      history_filename = gdb_abspath (fname);
     }
 }

diff --git a/gdb/tracefile-tfile.c b/gdb/tracefile-tfile.c
index 107236330d1c105b6c7285f1d3e963131c92ee62..f84ad2f4a3fdf06e02eaf7e27d0a967df1bce2a1 100644 (file)
--- a/gdb/tracefile-tfile.c
+++ b/gdb/tracefile-tfile.c
@@ -471,7 +471,7 @@ tfile_target_open (const char *arg, int from_tty)
 
   gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg));
   if (!IS_ABSOLUTE_PATH (filename.get ()))
-    filename = gdb_abspath (filename.get ());
+    filename = make_unique_xstrdup (gdb_abspath (filename.get ()).c_str ());
 
   flags = O_BINARY | O_LARGEFILE;
   flags |= O_RDONLY;

diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index 24925cbbb5f58b8a836a190e2b958cd4ef8f0287..33c42714e726f4c1bc448da9dda27e8baf986071 100644 (file)
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -90,31 +90,31 @@ bool non_stop;
 static struct {
   /* Set the PROGRAM_PATH.  Here we adjust the path of the provided
      binary if needed.  */
-  void set (gdb::unique_xmalloc_ptr<char> &&path)
+  void set (const char *path)
   {
-    m_path = std::move (path);
+    m_path = path;
 
     /* Make sure we're using the absolute path of the inferior when
        creating it.  */
-    if (!contains_dir_separator (m_path.get ()))
+    if (!contains_dir_separator (m_path.c_str ()))
       {
        int reg_file_errno;
 
        /* Check if the file is in our CWD.  If it is, then we prefix
           its name with CURRENT_DIRECTORY.  Otherwise, we leave the
           name as-is because we'll try searching for it in $PATH.  */
-       if (is_regular_file (m_path.get (), &reg_file_errno))
-         m_path = gdb_abspath (m_path.get ());
+       if (is_regular_file (m_path.c_str (), &reg_file_errno))
+         m_path = gdb_abspath (m_path.c_str ());
       }
   }
 
   /* Return the PROGRAM_PATH.  */
-  char *get ()
-  { return m_path.get (); }
+  const char *get ()
+  { return m_path.empty () ? nullptr : m_path.c_str (); }
 
 private:
   /* The program name, adjusted if needed.  */
-  gdb::unique_xmalloc_ptr<char> m_path;
+  std::string m_path;
 } program_path;
 static std::vector<char *> program_args;
 static std::string wrapper_argv;
@@ -3076,7 +3076,7 @@ handle_v_run (char *own_buf)
        }
     }
   else
-    program_path.set (gdb::unique_xmalloc_ptr<char> (new_program_name));
+    program_path.set (new_program_name);
 
   /* Free the old argv and install the new one.  */
   free_vector_argv (program_args);
@@ -3933,7 +3933,7 @@ captured_main (int argc, char *argv[])
       int i, n;
 
       n = argc - (next_arg - argv);
-      program_path.set (make_unique_xstrdup (next_arg[0]));
+      program_path.set (next_arg[0]);
       for (i = 1; i < n; i++)
        program_args.push_back (xstrdup (next_arg[i]));
 

diff --git a/gdbsupport/pathstuff.cc b/gdbsupport/pathstuff.cc
index a347123cf2b334e48ab02930d040a86687d6eef4..dd6ffa49fb420bf9782edeb3ebaaa661986d4e9f 100644 (file)
--- a/gdbsupport/pathstuff.cc
+++ b/gdbsupport/pathstuff.cc
@@ -130,23 +130,23 @@ gdb_realpath_keepfile (const char *filename)
 
 /* See gdbsupport/pathstuff.h.  */
 
-gdb::unique_xmalloc_ptr<char>
+std::string
 gdb_abspath (const char *path)
 {
   gdb_assert (path != NULL && path[0] != '\0');
 
   if (path[0] == '~')
-    return gdb_tilde_expand_up (path);
+    return gdb_tilde_expand (path);
 
   if (IS_ABSOLUTE_PATH (path) || current_directory == NULL)
-    return make_unique_xstrdup (path);
+    return path;
 
   /* Beware the // my son, the Emacs barfs, the botch that catch...  */
-  return gdb::unique_xmalloc_ptr<char>
-    (concat (current_directory,
-            IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
-            ? "" : SLASH_STRING,
-            path, (char *) NULL));
+  return string_printf
+    ("%s%s%s", current_directory,
+     (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
+      ? "" : SLASH_STRING),
+     path);
 }
 
 /* See gdbsupport/pathstuff.h.  */
@@ -229,8 +229,8 @@ get_standard_cache_dir ()
   if (xdg_cache_home != NULL && xdg_cache_home[0] != '\0')
     {
       /* Make sure the path is absolute and tilde-expanded.  */
-      gdb::unique_xmalloc_ptr<char> abs (gdb_abspath (xdg_cache_home));
-      return string_printf ("%s/gdb", abs.get ());
+      std::string abs = gdb_abspath (xdg_cache_home);
+      return string_printf ("%s/gdb", abs.c_str ());
     }
 #endif
 
@@ -238,8 +238,8 @@ get_standard_cache_dir ()
   if (home != NULL && home[0] != '\0')
     {
       /* Make sure the path is absolute and tilde-expanded.  */
-      gdb::unique_xmalloc_ptr<char> abs (gdb_abspath (home));
-      return string_printf ("%s/" HOME_CACHE_DIR "/gdb", abs.get ());
+      std::string abs = gdb_abspath (home);
+      return string_printf ("%s/" HOME_CACHE_DIR "/gdb", abs.c_str ());
     }
 
 #ifdef WIN32
@@ -247,8 +247,8 @@ get_standard_cache_dir ()
   if (win_home != NULL && win_home[0] != '\0')
     {
       /* Make sure the path is absolute and tilde-expanded.  */
-      gdb::unique_xmalloc_ptr<char> abs (gdb_abspath (win_home));
-      return string_printf ("%s/gdb", abs.get ());
+      std::string abs = gdb_abspath (win_home);
+      return string_printf ("%s/gdb", abs.c_str ());
     }
 #endif
 
@@ -296,8 +296,8 @@ get_standard_config_dir ()
   if (xdg_config_home != NULL && xdg_config_home[0] != '\0')
     {
       /* Make sure the path is absolute and tilde-expanded.  */
-      gdb::unique_xmalloc_ptr<char> abs (gdb_abspath (xdg_config_home));
-      return string_printf ("%s/gdb", abs.get ());
+      std::string abs = gdb_abspath (xdg_config_home);
+      return string_printf ("%s/gdb", abs.c_str ());
     }
 #endif
 
@@ -305,8 +305,8 @@ get_standard_config_dir ()
   if (home != NULL && home[0] != '\0')
     {
       /* Make sure the path is absolute and tilde-expanded.  */
-      gdb::unique_xmalloc_ptr<char> abs (gdb_abspath (home));
-      return string_printf ("%s/" HOME_CONFIG_DIR "/gdb", abs.get ());
+      std::string abs = gdb_abspath (home);
+      return string_printf ("%s/" HOME_CONFIG_DIR "/gdb", abs.c_str ());
     }
 
   return {};
@@ -347,9 +347,8 @@ find_gdb_home_config_file (const char *name, struct stat *buf)
   if (homedir != nullptr && homedir[0] != '\0')
     {
       /* Make sure the path is absolute and tilde-expanded.  */
-      gdb::unique_xmalloc_ptr<char> abs (gdb_abspath (homedir));
-      std::string path = (std::string (abs.get ()) + SLASH_STRING
-                         + std::string (name));
+      std::string abs = gdb_abspath (homedir);
+      std::string path = string_printf ("%s/%s", abs.c_str (), name);
       if (stat (path.c_str (), buf) == 0)
        return path;
     }

diff --git a/gdbsupport/pathstuff.h b/gdbsupport/pathstuff.h
index 50e388aad047ab2157142ed113ec8798d5d6f054..04d9bf9029b50a6bba4997eb26d876d5a2568d3d 100644 (file)
--- a/gdbsupport/pathstuff.h
+++ b/gdbsupport/pathstuff.h
@@ -53,7 +53,7 @@ extern gdb::unique_xmalloc_ptr<char>
    If CURRENT_DIRECTORY is NULL, this function returns a copy of
    PATH.  */
 
-extern gdb::unique_xmalloc_ptr<char> gdb_abspath (const char *path);
+extern std::string gdb_abspath (const char *path);
 
 /* If the path in CHILD is a child of the path in PARENT, return a
    pointer to the first component in the CHILD's pathname below the