GDB 7.6.50

gdb/cli/cli-dump.c

 /* Dump-to-file commands, for GDB, the GNU debugger.
 
-   Copyright (c) 2002, 2005, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2002-2013 Free Software Foundation, Inc.
 
    Contributed by Red Hat.
 
    This file is part of GDB.
 
    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/>.  */
 
 #include "defs.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "cli/cli-decode.h"
 #include "cli/cli-cmds.h"
 #include "value.h"
 #include "completer.h"
-#include "cli/cli-dump.h"
 #include "gdb_assert.h"
 #include <ctype.h>
 #include "target.h"
 #include "readline/readline.h"
 #include "gdbcore.h"
 #include "cli/cli-utils.h"
-
-#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
+#include "gdb_bfd.h"
+#include "filestuff.h"
 
 
-char *
+static char *
 scan_expression_with_cleanup (char **cmd, const char *def)
 {
   if ((*cmd) == NULL || (**cmd) == '\0')
     {
       char *exp = xstrdup (def);
 
       make_cleanup (xfree, exp);
       return exp;
     }
   else
     {
       char *exp;
       char *end;
 
       end = (*cmd) + strcspn (*cmd, " \t");
       exp = savestring ((*cmd), end - (*cmd));
       make_cleanup (xfree, exp);
       (*cmd) = skip_spaces (end);
       return exp;
     }
 }
 
 
-char *
+static char *
 scan_filename_with_cleanup (char **cmd, const char *defname)
 {
   char *filename;
   char *fullname;
 
   /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
 
   /* File.  */
   if ((*cmd) == NULL)
     {
@@ skipping 14 matching lines @@
       (*cmd) = skip_spaces (end);
     }
   gdb_assert (filename != NULL);
 
   fullname = tilde_expand (filename);
   make_cleanup (xfree, fullname);
   
   return fullname;
 }
 
-FILE *
+static FILE *
 fopen_with_cleanup (const char *filename, const char *mode)
 {
-  FILE *file = fopen (filename, mode);
+  FILE *file = gdb_fopen_cloexec (filename, mode);
 
   if (file == NULL)
     perror_with_name (filename);
   make_cleanup_fclose (file);
   return file;
 }
 
 static bfd *
 bfd_openr_with_cleanup (const char *filename, const char *target)
 {
   bfd *ibfd;
 
-  ibfd = bfd_openr (filename, target);
+  ibfd = gdb_bfd_openr (filename, target);
   if (ibfd == NULL)
     error (_("Failed to open %s: %s."), filename, 
            bfd_errmsg (bfd_get_error ()));
 
-  make_cleanup_bfd_close (ibfd);
+  make_cleanup_bfd_unref (ibfd);
   if (!bfd_check_format (ibfd, bfd_object))
     error (_("'%s' is not a recognized file format."), filename);
 
   return ibfd;
 }
 
 static bfd *
 bfd_openw_with_cleanup (const char *filename, const char *target,
                         const char *mode)
 {
   bfd *obfd;
 
   if (*mode == 'w')     /* Write: create new file */
     {
-      obfd = bfd_openw (filename, target);
+      obfd = gdb_bfd_openw (filename, target);
       if (obfd == NULL)
         error (_("Failed to open %s: %s."), filename, 
                bfd_errmsg (bfd_get_error ()));
-      make_cleanup_bfd_close (obfd);
+      make_cleanup_bfd_unref (obfd);
       if (!bfd_set_format (obfd, bfd_object))
         error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
     }
   else if (*mode == 'a')        /* Append to existing file.  */
     {   /* FIXME -- doesn't work...  */
       error (_("bfd_openw does not work with append."));
     }
   else
     error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
 
   return obfd;
 }
 
-struct cmd_list_element *dump_cmdlist;
-struct cmd_list_element *append_cmdlist;
-struct cmd_list_element *srec_cmdlist;
-struct cmd_list_element *ihex_cmdlist;
-struct cmd_list_element *tekhex_cmdlist;
-struct cmd_list_element *binary_dump_cmdlist;
-struct cmd_list_element *binary_append_cmdlist;
+static struct cmd_list_element *dump_cmdlist;
+static struct cmd_list_element *append_cmdlist;
+static struct cmd_list_element *srec_cmdlist;
+static struct cmd_list_element *ihex_cmdlist;
+static struct cmd_list_element *tekhex_cmdlist;
+static struct cmd_list_element *binary_dump_cmdlist;
+static struct cmd_list_element *binary_append_cmdlist;
 
 static void
 dump_command (char *cmd, int from_tty)
 {
   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
   help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
 }
 
 static void
 append_command (char *cmd, int from_tty)
@@ skipping 211 matching lines @@
 };
 
 static void
 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
 {
   struct dump_context *d = get_cmd_context (c);
 
   d->func (args, d->mode);
 }
 
-void
+static void
 add_dump_command (char *name, void (*func) (char *args, char *mode),
                   char *descr)
 
 {
   struct cmd_list_element *c;
   struct dump_context *d;
 
   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
   c->completer =  filename_completer;
   d = XMALLOC (struct dump_context);
@@ skipping 77 matching lines @@
     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd), 
            bfd_errmsg (bfd_get_error ()));
 
   printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
                    bfd_section_name (ibfd, isec), 
                    (unsigned long) sec_start, 
                    (unsigned long) sec_end);
 
   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
     printf_filtered (" into memory (%s to %s)\n",
-                     paddress (target_gdbarch,
+                     paddress (target_gdbarch (),
                                (unsigned long) sec_start
                                + sec_offset + data->load_offset), 
-                     paddress (target_gdbarch,
+                     paddress (target_gdbarch (),
                                (unsigned long) sec_start + sec_offset
                                 + data->load_offset + sec_load_count));
   else
     puts_filtered ("\n");
 
   /* Write the data.  */
   ret = target_write_memory (sec_start + sec_offset + data->load_offset, 
                              buf + sec_offset, sec_load_count);
   if (ret != 0)
     warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
   do_cleanups (old_chain);
   return;
 }
 
 static void
 restore_binary_file (char *filename, struct callback_data *data)
 {
+  struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
   gdb_byte *buf;
   long len;
 
   /* Get the file size for reading.  */
   if (fseek (file, 0, SEEK_END) == 0)
     {
       len = ftell (file);
       if (len < 0)
         perror_with_name (filename);
@@ skipping 25 matching lines @@
   /* Now allocate a buffer and read the file contents.  */
   buf = xmalloc (len);
   make_cleanup (xfree, buf);
   if (fread (buf, 1, len, file) != len)
     perror_with_name (filename);
 
   /* Now write the buffer into target memory.  */
   len = target_write_memory (data->load_start + data->load_offset, buf, len);
   if (len != 0)
     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
-  return;
+  do_cleanups (cleanup);
 }
 
 static void
 restore_command (char *args, int from_tty)
 {
   char *filename;
   struct callback_data data;
   bfd *ibfd;
   int binary_flag = 0;
 
@@ skipping 212 matching lines @@
 
   c = add_com ("restore", class_vars, restore_command, _("\
 Restore the contents of FILE to target memory.\n\
 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
 OFFSET will be added to the base address of the file (default zero).\n\
 If START and END are given, only the file contents within that range\n\
 (file relative) will be restored to target memory."));
   c->completer = filename_completer;
   /* FIXME: completers for other commands.  */
 }