OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [cli/] [cli-dump.c] - Diff between revs 227 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 227 Rev 816
/* Dump-to-file commands, for GDB, the GNU debugger.
/* Dump-to-file commands, for GDB, the GNU debugger.
 
 
   Copyright (c) 2002, 2005, 2007, 2008, 2009, 2010
   Copyright (c) 2002, 2005, 2007, 2008, 2009, 2010
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
   Contributed by Red Hat.
   Contributed by Red Hat.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
#include "defs.h"
#include "defs.h"
#include "gdb_string.h"
#include "gdb_string.h"
#include "cli/cli-decode.h"
#include "cli/cli-decode.h"
#include "cli/cli-cmds.h"
#include "cli/cli-cmds.h"
#include "value.h"
#include "value.h"
#include "completer.h"
#include "completer.h"
#include "cli/cli-dump.h"
#include "cli/cli-dump.h"
#include "gdb_assert.h"
#include "gdb_assert.h"
#include <ctype.h>
#include <ctype.h>
#include "target.h"
#include "target.h"
#include "readline/readline.h"
#include "readline/readline.h"
#include "gdbcore.h"
#include "gdbcore.h"
 
 
#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
 
 
 
 
char *
char *
skip_spaces (char *chp)
skip_spaces (char *chp)
{
{
  if (chp == NULL)
  if (chp == NULL)
    return NULL;
    return NULL;
  while (isspace (*chp))
  while (isspace (*chp))
    chp++;
    chp++;
  return chp;
  return chp;
}
}
 
 
char *
char *
scan_expression_with_cleanup (char **cmd, const char *def)
scan_expression_with_cleanup (char **cmd, const char *def)
{
{
  if ((*cmd) == NULL || (**cmd) == '\0')
  if ((*cmd) == NULL || (**cmd) == '\0')
    {
    {
      char *exp = xstrdup (def);
      char *exp = xstrdup (def);
      make_cleanup (xfree, exp);
      make_cleanup (xfree, exp);
      return exp;
      return exp;
    }
    }
  else
  else
    {
    {
      char *exp;
      char *exp;
      char *end;
      char *end;
 
 
      end = (*cmd) + strcspn (*cmd, " \t");
      end = (*cmd) + strcspn (*cmd, " \t");
      exp = savestring ((*cmd), end - (*cmd));
      exp = savestring ((*cmd), end - (*cmd));
      make_cleanup (xfree, exp);
      make_cleanup (xfree, exp);
      (*cmd) = skip_spaces (end);
      (*cmd) = skip_spaces (end);
      return exp;
      return exp;
    }
    }
}
}
 
 
 
 
char *
char *
scan_filename_with_cleanup (char **cmd, const char *defname)
scan_filename_with_cleanup (char **cmd, const char *defname)
{
{
  char *filename;
  char *filename;
  char *fullname;
  char *fullname;
 
 
  /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
  /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
 
 
  /* File.  */
  /* File.  */
  if ((*cmd) == NULL)
  if ((*cmd) == NULL)
    {
    {
      if (defname == NULL)
      if (defname == NULL)
        error (_("Missing filename."));
        error (_("Missing filename."));
      filename = xstrdup (defname);
      filename = xstrdup (defname);
      make_cleanup (xfree, filename);
      make_cleanup (xfree, filename);
    }
    }
  else
  else
    {
    {
      /* FIXME: should parse a possibly quoted string.  */
      /* FIXME: should parse a possibly quoted string.  */
      char *end;
      char *end;
 
 
      (*cmd) = skip_spaces (*cmd);
      (*cmd) = skip_spaces (*cmd);
      end = *cmd + strcspn (*cmd, " \t");
      end = *cmd + strcspn (*cmd, " \t");
      filename = savestring ((*cmd), end - (*cmd));
      filename = savestring ((*cmd), end - (*cmd));
      make_cleanup (xfree, filename);
      make_cleanup (xfree, filename);
      (*cmd) = skip_spaces (end);
      (*cmd) = skip_spaces (end);
    }
    }
  gdb_assert (filename != NULL);
  gdb_assert (filename != NULL);
 
 
  fullname = tilde_expand (filename);
  fullname = tilde_expand (filename);
  make_cleanup (xfree, fullname);
  make_cleanup (xfree, fullname);
 
 
  return fullname;
  return fullname;
}
}
 
 
FILE *
FILE *
fopen_with_cleanup (const char *filename, const char *mode)
fopen_with_cleanup (const char *filename, const char *mode)
{
{
  FILE *file = fopen (filename, mode);
  FILE *file = fopen (filename, mode);
  if (file == NULL)
  if (file == NULL)
    perror_with_name (filename);
    perror_with_name (filename);
  make_cleanup_fclose (file);
  make_cleanup_fclose (file);
  return file;
  return file;
}
}
 
 
static bfd *
static bfd *
bfd_openr_with_cleanup (const char *filename, const char *target)
bfd_openr_with_cleanup (const char *filename, const char *target)
{
{
  bfd *ibfd;
  bfd *ibfd;
 
 
  ibfd = bfd_openr (filename, target);
  ibfd = bfd_openr (filename, target);
  if (ibfd == NULL)
  if (ibfd == NULL)
    error (_("Failed to open %s: %s."), filename,
    error (_("Failed to open %s: %s."), filename,
           bfd_errmsg (bfd_get_error ()));
           bfd_errmsg (bfd_get_error ()));
 
 
  make_cleanup_bfd_close (ibfd);
  make_cleanup_bfd_close (ibfd);
  if (!bfd_check_format (ibfd, bfd_object))
  if (!bfd_check_format (ibfd, bfd_object))
    error (_("'%s' is not a recognized file format."), filename);
    error (_("'%s' is not a recognized file format."), filename);
 
 
  return ibfd;
  return ibfd;
}
}
 
 
static bfd *
static bfd *
bfd_openw_with_cleanup (const char *filename, const char *target,
bfd_openw_with_cleanup (const char *filename, const char *target,
                        const char *mode)
                        const char *mode)
{
{
  bfd *obfd;
  bfd *obfd;
 
 
  if (*mode == 'w')     /* Write: create new file */
  if (*mode == 'w')     /* Write: create new file */
    {
    {
      obfd = bfd_openw (filename, target);
      obfd = bfd_openw (filename, target);
      if (obfd == NULL)
      if (obfd == NULL)
        error (_("Failed to open %s: %s."), filename,
        error (_("Failed to open %s: %s."), filename,
               bfd_errmsg (bfd_get_error ()));
               bfd_errmsg (bfd_get_error ()));
      make_cleanup_bfd_close (obfd);
      make_cleanup_bfd_close (obfd);
      if (!bfd_set_format (obfd, bfd_object))
      if (!bfd_set_format (obfd, bfd_object))
        error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
        error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
    }
    }
  else if (*mode == 'a')        /* Append to existing file */
  else if (*mode == 'a')        /* Append to existing file */
    {   /* FIXME -- doesn't work... */
    {   /* FIXME -- doesn't work... */
      error (_("bfd_openw does not work with append."));
      error (_("bfd_openw does not work with append."));
    }
    }
  else
  else
    error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
    error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
 
 
  return obfd;
  return obfd;
}
}
 
 
struct cmd_list_element *dump_cmdlist;
struct cmd_list_element *dump_cmdlist;
struct cmd_list_element *append_cmdlist;
struct cmd_list_element *append_cmdlist;
struct cmd_list_element *srec_cmdlist;
struct cmd_list_element *srec_cmdlist;
struct cmd_list_element *ihex_cmdlist;
struct cmd_list_element *ihex_cmdlist;
struct cmd_list_element *tekhex_cmdlist;
struct cmd_list_element *tekhex_cmdlist;
struct cmd_list_element *binary_dump_cmdlist;
struct cmd_list_element *binary_dump_cmdlist;
struct cmd_list_element *binary_append_cmdlist;
struct cmd_list_element *binary_append_cmdlist;
 
 
static void
static void
dump_command (char *cmd, int from_tty)
dump_command (char *cmd, int from_tty)
{
{
  printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
  printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
  help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
  help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
}
}
 
 
static void
static void
append_command (char *cmd, int from_tty)
append_command (char *cmd, int from_tty)
{
{
  printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
  printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
  help_list (dump_cmdlist, "append ", -1, gdb_stdout);
  help_list (dump_cmdlist, "append ", -1, gdb_stdout);
}
}
 
 
static void
static void
dump_binary_file (const char *filename, const char *mode,
dump_binary_file (const char *filename, const char *mode,
                  const bfd_byte *buf, int len)
                  const bfd_byte *buf, int len)
{
{
  FILE *file;
  FILE *file;
  int status;
  int status;
 
 
  file = fopen_with_cleanup (filename, mode);
  file = fopen_with_cleanup (filename, mode);
  status = fwrite (buf, len, 1, file);
  status = fwrite (buf, len, 1, file);
  if (status != 1)
  if (status != 1)
    perror_with_name (filename);
    perror_with_name (filename);
}
}
 
 
static void
static void
dump_bfd_file (const char *filename, const char *mode,
dump_bfd_file (const char *filename, const char *mode,
               const char *target, CORE_ADDR vaddr,
               const char *target, CORE_ADDR vaddr,
               const bfd_byte *buf, int len)
               const bfd_byte *buf, int len)
{
{
  bfd *obfd;
  bfd *obfd;
  asection *osection;
  asection *osection;
 
 
  obfd = bfd_openw_with_cleanup (filename, target, mode);
  obfd = bfd_openw_with_cleanup (filename, target, mode);
  osection = bfd_make_section_anyway (obfd, ".newsec");
  osection = bfd_make_section_anyway (obfd, ".newsec");
  bfd_set_section_size (obfd, osection, len);
  bfd_set_section_size (obfd, osection, len);
  bfd_set_section_vma (obfd, osection, vaddr);
  bfd_set_section_vma (obfd, osection, vaddr);
  bfd_set_section_alignment (obfd, osection, 0);
  bfd_set_section_alignment (obfd, osection, 0);
  bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
  bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
                                          | SEC_ALLOC
                                          | SEC_ALLOC
                                          | SEC_LOAD));
                                          | SEC_LOAD));
  osection->entsize = 0;
  osection->entsize = 0;
  bfd_set_section_contents (obfd, osection, buf, 0, len);
  bfd_set_section_contents (obfd, osection, buf, 0, len);
}
}
 
 
static void
static void
dump_memory_to_file (char *cmd, char *mode, char *file_format)
dump_memory_to_file (char *cmd, char *mode, char *file_format)
{
{
  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
  CORE_ADDR lo;
  CORE_ADDR lo;
  CORE_ADDR hi;
  CORE_ADDR hi;
  ULONGEST count;
  ULONGEST count;
  char *filename;
  char *filename;
  void *buf;
  void *buf;
  char *lo_exp;
  char *lo_exp;
  char *hi_exp;
  char *hi_exp;
  int len;
  int len;
 
 
  /* Open the file.  */
  /* Open the file.  */
  filename = scan_filename_with_cleanup (&cmd, NULL);
  filename = scan_filename_with_cleanup (&cmd, NULL);
 
 
  /* Find the low address.  */
  /* Find the low address.  */
  if (cmd == NULL || *cmd == '\0')
  if (cmd == NULL || *cmd == '\0')
    error (_("Missing start address."));
    error (_("Missing start address."));
  lo_exp = scan_expression_with_cleanup (&cmd, NULL);
  lo_exp = scan_expression_with_cleanup (&cmd, NULL);
 
 
  /* Find the second address - rest of line.  */
  /* Find the second address - rest of line.  */
  if (cmd == NULL || *cmd == '\0')
  if (cmd == NULL || *cmd == '\0')
    error (_("Missing stop address."));
    error (_("Missing stop address."));
  hi_exp = cmd;
  hi_exp = cmd;
 
 
  lo = parse_and_eval_address (lo_exp);
  lo = parse_and_eval_address (lo_exp);
  hi = parse_and_eval_address (hi_exp);
  hi = parse_and_eval_address (hi_exp);
  if (hi <= lo)
  if (hi <= lo)
    error (_("Invalid memory address range (start >= end)."));
    error (_("Invalid memory address range (start >= end)."));
  count = hi - lo;
  count = hi - lo;
 
 
  /* FIXME: Should use read_memory_partial() and a magic blocking
  /* FIXME: Should use read_memory_partial() and a magic blocking
     value.  */
     value.  */
  buf = xmalloc (count);
  buf = xmalloc (count);
  make_cleanup (xfree, buf);
  make_cleanup (xfree, buf);
  read_memory (lo, buf, count);
  read_memory (lo, buf, count);
 
 
  /* Have everything.  Open/write the data.  */
  /* Have everything.  Open/write the data.  */
  if (file_format == NULL || strcmp (file_format, "binary") == 0)
  if (file_format == NULL || strcmp (file_format, "binary") == 0)
    {
    {
      dump_binary_file (filename, mode, buf, count);
      dump_binary_file (filename, mode, buf, count);
    }
    }
  else
  else
    {
    {
      dump_bfd_file (filename, mode, file_format, lo, buf, count);
      dump_bfd_file (filename, mode, file_format, lo, buf, count);
    }
    }
 
 
  do_cleanups (old_cleanups);
  do_cleanups (old_cleanups);
}
}
 
 
static void
static void
dump_memory_command (char *cmd, char *mode)
dump_memory_command (char *cmd, char *mode)
{
{
  dump_memory_to_file (cmd, mode, "binary");
  dump_memory_to_file (cmd, mode, "binary");
}
}
 
 
static void
static void
dump_value_to_file (char *cmd, char *mode, char *file_format)
dump_value_to_file (char *cmd, char *mode, char *file_format)
{
{
  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
  struct value *val;
  struct value *val;
  char *filename;
  char *filename;
 
 
  /* Open the file.  */
  /* Open the file.  */
  filename = scan_filename_with_cleanup (&cmd, NULL);
  filename = scan_filename_with_cleanup (&cmd, NULL);
 
 
  /* Find the value.  */
  /* Find the value.  */
  if (cmd == NULL || *cmd == '\0')
  if (cmd == NULL || *cmd == '\0')
    error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
    error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
  val = parse_and_eval (cmd);
  val = parse_and_eval (cmd);
  if (val == NULL)
  if (val == NULL)
    error (_("Invalid expression."));
    error (_("Invalid expression."));
 
 
  /* Have everything.  Open/write the data.  */
  /* Have everything.  Open/write the data.  */
  if (file_format == NULL || strcmp (file_format, "binary") == 0)
  if (file_format == NULL || strcmp (file_format, "binary") == 0)
    {
    {
      dump_binary_file (filename, mode, value_contents (val),
      dump_binary_file (filename, mode, value_contents (val),
                        TYPE_LENGTH (value_type (val)));
                        TYPE_LENGTH (value_type (val)));
    }
    }
  else
  else
    {
    {
      CORE_ADDR vaddr;
      CORE_ADDR vaddr;
 
 
      if (VALUE_LVAL (val))
      if (VALUE_LVAL (val))
        {
        {
          vaddr = value_address (val);
          vaddr = value_address (val);
        }
        }
      else
      else
        {
        {
          vaddr = 0;
          vaddr = 0;
          warning (_("value is not an lval: address assumed to be zero"));
          warning (_("value is not an lval: address assumed to be zero"));
        }
        }
 
 
      dump_bfd_file (filename, mode, file_format, vaddr,
      dump_bfd_file (filename, mode, file_format, vaddr,
                     value_contents (val),
                     value_contents (val),
                     TYPE_LENGTH (value_type (val)));
                     TYPE_LENGTH (value_type (val)));
    }
    }
 
 
  do_cleanups (old_cleanups);
  do_cleanups (old_cleanups);
}
}
 
 
static void
static void
dump_value_command (char *cmd, char *mode)
dump_value_command (char *cmd, char *mode)
{
{
  dump_value_to_file (cmd, mode, "binary");
  dump_value_to_file (cmd, mode, "binary");
}
}
 
 
static void
static void
dump_srec_memory (char *args, int from_tty)
dump_srec_memory (char *args, int from_tty)
{
{
  dump_memory_to_file (args, FOPEN_WB, "srec");
  dump_memory_to_file (args, FOPEN_WB, "srec");
}
}
 
 
static void
static void
dump_srec_value (char *args, int from_tty)
dump_srec_value (char *args, int from_tty)
{
{
  dump_value_to_file (args, FOPEN_WB, "srec");
  dump_value_to_file (args, FOPEN_WB, "srec");
}
}
 
 
static void
static void
dump_ihex_memory (char *args, int from_tty)
dump_ihex_memory (char *args, int from_tty)
{
{
  dump_memory_to_file (args, FOPEN_WB, "ihex");
  dump_memory_to_file (args, FOPEN_WB, "ihex");
}
}
 
 
static void
static void
dump_ihex_value (char *args, int from_tty)
dump_ihex_value (char *args, int from_tty)
{
{
  dump_value_to_file (args, FOPEN_WB, "ihex");
  dump_value_to_file (args, FOPEN_WB, "ihex");
}
}
 
 
static void
static void
dump_tekhex_memory (char *args, int from_tty)
dump_tekhex_memory (char *args, int from_tty)
{
{
  dump_memory_to_file (args, FOPEN_WB, "tekhex");
  dump_memory_to_file (args, FOPEN_WB, "tekhex");
}
}
 
 
static void
static void
dump_tekhex_value (char *args, int from_tty)
dump_tekhex_value (char *args, int from_tty)
{
{
  dump_value_to_file (args, FOPEN_WB, "tekhex");
  dump_value_to_file (args, FOPEN_WB, "tekhex");
}
}
 
 
static void
static void
dump_binary_memory (char *args, int from_tty)
dump_binary_memory (char *args, int from_tty)
{
{
  dump_memory_to_file (args, FOPEN_WB, "binary");
  dump_memory_to_file (args, FOPEN_WB, "binary");
}
}
 
 
static void
static void
dump_binary_value (char *args, int from_tty)
dump_binary_value (char *args, int from_tty)
{
{
  dump_value_to_file (args, FOPEN_WB, "binary");
  dump_value_to_file (args, FOPEN_WB, "binary");
}
}
 
 
static void
static void
append_binary_memory (char *args, int from_tty)
append_binary_memory (char *args, int from_tty)
{
{
  dump_memory_to_file (args, FOPEN_AB, "binary");
  dump_memory_to_file (args, FOPEN_AB, "binary");
}
}
 
 
static void
static void
append_binary_value (char *args, int from_tty)
append_binary_value (char *args, int from_tty)
{
{
  dump_value_to_file (args, FOPEN_AB, "binary");
  dump_value_to_file (args, FOPEN_AB, "binary");
}
}
 
 
struct dump_context
struct dump_context
{
{
  void (*func) (char *cmd, char *mode);
  void (*func) (char *cmd, char *mode);
  char *mode;
  char *mode;
};
};
 
 
static void
static void
call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
{
{
  struct dump_context *d = get_cmd_context (c);
  struct dump_context *d = get_cmd_context (c);
  d->func (args, d->mode);
  d->func (args, d->mode);
}
}
 
 
void
void
add_dump_command (char *name, void (*func) (char *args, char *mode),
add_dump_command (char *name, void (*func) (char *args, char *mode),
                  char *descr)
                  char *descr)
 
 
{
{
  struct cmd_list_element *c;
  struct cmd_list_element *c;
  struct dump_context *d;
  struct dump_context *d;
 
 
  c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
  c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
  c->completer =  filename_completer;
  c->completer =  filename_completer;
  d = XMALLOC (struct dump_context);
  d = XMALLOC (struct dump_context);
  d->func = func;
  d->func = func;
  d->mode = FOPEN_WB;
  d->mode = FOPEN_WB;
  set_cmd_context (c, d);
  set_cmd_context (c, d);
  c->func = call_dump_func;
  c->func = call_dump_func;
 
 
  c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
  c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
  c->completer =  filename_completer;
  c->completer =  filename_completer;
  d = XMALLOC (struct dump_context);
  d = XMALLOC (struct dump_context);
  d->func = func;
  d->func = func;
  d->mode = FOPEN_AB;
  d->mode = FOPEN_AB;
  set_cmd_context (c, d);
  set_cmd_context (c, d);
  c->func = call_dump_func;
  c->func = call_dump_func;
 
 
  /* Replace "Dump " at start of docstring with "Append " (borrowed
  /* Replace "Dump " at start of docstring with "Append " (borrowed
     from [deleted] deprecated_add_show_from_set).  */
     from [deleted] deprecated_add_show_from_set).  */
  if (   c->doc[0] == 'W'
  if (   c->doc[0] == 'W'
      && c->doc[1] == 'r'
      && c->doc[1] == 'r'
      && c->doc[2] == 'i'
      && c->doc[2] == 'i'
      && c->doc[3] == 't'
      && c->doc[3] == 't'
      && c->doc[4] == 'e'
      && c->doc[4] == 'e'
      && c->doc[5] == ' ')
      && c->doc[5] == ' ')
    c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
    c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
}
}
 
 
/* Opaque data for restore_section_callback. */
/* Opaque data for restore_section_callback. */
struct callback_data {
struct callback_data {
  CORE_ADDR load_offset;
  CORE_ADDR load_offset;
  CORE_ADDR load_start;
  CORE_ADDR load_start;
  CORE_ADDR load_end;
  CORE_ADDR load_end;
};
};
 
 
/* Function: restore_section_callback.
/* Function: restore_section_callback.
 
 
   Callback function for bfd_map_over_sections.
   Callback function for bfd_map_over_sections.
   Selectively loads the sections into memory.  */
   Selectively loads the sections into memory.  */
 
 
static void
static void
restore_section_callback (bfd *ibfd, asection *isec, void *args)
restore_section_callback (bfd *ibfd, asection *isec, void *args)
{
{
  struct callback_data *data = args;
  struct callback_data *data = args;
  bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
  bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
  bfd_size_type size = bfd_section_size (ibfd, isec);
  bfd_size_type size = bfd_section_size (ibfd, isec);
  bfd_vma sec_end    = sec_start + size;
  bfd_vma sec_end    = sec_start + size;
  bfd_size_type sec_offset = 0;
  bfd_size_type sec_offset = 0;
  bfd_size_type sec_load_count = size;
  bfd_size_type sec_load_count = size;
  struct cleanup *old_chain;
  struct cleanup *old_chain;
  gdb_byte *buf;
  gdb_byte *buf;
  int ret;
  int ret;
 
 
  /* Ignore non-loadable sections, eg. from elf files. */
  /* Ignore non-loadable sections, eg. from elf files. */
  if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
  if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
    return;
    return;
 
 
  /* Does the section overlap with the desired restore range? */
  /* Does the section overlap with the desired restore range? */
  if (sec_end <= data->load_start
  if (sec_end <= data->load_start
      || (data->load_end > 0 && sec_start >= data->load_end))
      || (data->load_end > 0 && sec_start >= data->load_end))
    {
    {
      /* No, no useable data in this section. */
      /* No, no useable data in this section. */
      printf_filtered (_("skipping section %s...\n"),
      printf_filtered (_("skipping section %s...\n"),
                       bfd_section_name (ibfd, isec));
                       bfd_section_name (ibfd, isec));
      return;
      return;
    }
    }
 
 
  /* Compare section address range with user-requested
  /* Compare section address range with user-requested
     address range (if any).  Compute where the actual
     address range (if any).  Compute where the actual
     transfer should start and end.  */
     transfer should start and end.  */
  if (sec_start < data->load_start)
  if (sec_start < data->load_start)
    sec_offset = data->load_start - sec_start;
    sec_offset = data->load_start - sec_start;
  /* Size of a partial transfer: */
  /* Size of a partial transfer: */
  sec_load_count -= sec_offset;
  sec_load_count -= sec_offset;
  if (data->load_end > 0 && sec_end > data->load_end)
  if (data->load_end > 0 && sec_end > data->load_end)
    sec_load_count -= sec_end - data->load_end;
    sec_load_count -= sec_end - data->load_end;
 
 
  /* Get the data.  */
  /* Get the data.  */
  buf = xmalloc (size);
  buf = xmalloc (size);
  old_chain = make_cleanup (xfree, buf);
  old_chain = make_cleanup (xfree, buf);
  if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
  if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
    error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
    error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
           bfd_errmsg (bfd_get_error ()));
           bfd_errmsg (bfd_get_error ()));
 
 
  printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
  printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
                   bfd_section_name (ibfd, isec),
                   bfd_section_name (ibfd, isec),
                   (unsigned long) sec_start,
                   (unsigned long) sec_start,
                   (unsigned long) sec_end);
                   (unsigned long) sec_end);
 
 
  if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
  if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
    printf_filtered (" into memory (%s to %s)\n",
    printf_filtered (" into memory (%s to %s)\n",
                     paddress (target_gdbarch,
                     paddress (target_gdbarch,
                               (unsigned long) sec_start
                               (unsigned long) sec_start
                               + sec_offset + data->load_offset),
                               + sec_offset + data->load_offset),
                     paddress (target_gdbarch,
                     paddress (target_gdbarch,
                               (unsigned long) sec_start + sec_offset
                               (unsigned long) sec_start + sec_offset
                                + data->load_offset + sec_load_count));
                                + data->load_offset + sec_load_count));
  else
  else
    puts_filtered ("\n");
    puts_filtered ("\n");
 
 
  /* Write the data.  */
  /* Write the data.  */
  ret = target_write_memory (sec_start + sec_offset + data->load_offset,
  ret = target_write_memory (sec_start + sec_offset + data->load_offset,
                             buf + sec_offset, sec_load_count);
                             buf + sec_offset, sec_load_count);
  if (ret != 0)
  if (ret != 0)
    warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
    warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
  do_cleanups (old_chain);
  do_cleanups (old_chain);
  return;
  return;
}
}
 
 
static void
static void
restore_binary_file (char *filename, struct callback_data *data)
restore_binary_file (char *filename, struct callback_data *data)
{
{
  FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
  FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
  int status;
  int status;
  gdb_byte *buf;
  gdb_byte *buf;
  long len;
  long len;
 
 
  /* Get the file size for reading.  */
  /* Get the file size for reading.  */
  if (fseek (file, 0, SEEK_END) == 0)
  if (fseek (file, 0, SEEK_END) == 0)
    len = ftell (file);
    len = ftell (file);
  else
  else
    perror_with_name (filename);
    perror_with_name (filename);
 
 
  if (len <= data->load_start)
  if (len <= data->load_start)
    error (_("Start address is greater than length of binary file %s."),
    error (_("Start address is greater than length of binary file %s."),
           filename);
           filename);
 
 
  /* Chop off "len" if it exceeds the requested load_end addr. */
  /* Chop off "len" if it exceeds the requested load_end addr. */
  if (data->load_end != 0 && data->load_end < len)
  if (data->load_end != 0 && data->load_end < len)
    len = data->load_end;
    len = data->load_end;
  /* Chop off "len" if the requested load_start addr skips some bytes. */
  /* Chop off "len" if the requested load_start addr skips some bytes. */
  if (data->load_start > 0)
  if (data->load_start > 0)
    len -= data->load_start;
    len -= data->load_start;
 
 
  printf_filtered
  printf_filtered
    ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
    ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
     filename,
     filename,
     (unsigned long) (data->load_start + data->load_offset),
     (unsigned long) (data->load_start + data->load_offset),
     (unsigned long) (data->load_start + data->load_offset + len));
     (unsigned long) (data->load_start + data->load_offset + len));
 
 
  /* Now set the file pos to the requested load start pos.  */
  /* Now set the file pos to the requested load start pos.  */
  if (fseek (file, data->load_start, SEEK_SET) != 0)
  if (fseek (file, data->load_start, SEEK_SET) != 0)
    perror_with_name (filename);
    perror_with_name (filename);
 
 
  /* Now allocate a buffer and read the file contents.  */
  /* Now allocate a buffer and read the file contents.  */
  buf = xmalloc (len);
  buf = xmalloc (len);
  make_cleanup (xfree, buf);
  make_cleanup (xfree, buf);
  if (fread (buf, 1, len, file) != len)
  if (fread (buf, 1, len, file) != len)
    perror_with_name (filename);
    perror_with_name (filename);
 
 
  /* Now write the buffer into target memory. */
  /* Now write the buffer into target memory. */
  len = target_write_memory (data->load_start + data->load_offset, buf, len);
  len = target_write_memory (data->load_start + data->load_offset, buf, len);
  if (len != 0)
  if (len != 0)
    warning (_("restore: memory write failed (%s)."), safe_strerror (len));
    warning (_("restore: memory write failed (%s)."), safe_strerror (len));
  return;
  return;
}
}
 
 
static void
static void
restore_command (char *args, int from_tty)
restore_command (char *args, int from_tty)
{
{
  char *filename;
  char *filename;
  struct callback_data data;
  struct callback_data data;
  bfd *ibfd;
  bfd *ibfd;
  int binary_flag = 0;
  int binary_flag = 0;
 
 
  if (!target_has_execution)
  if (!target_has_execution)
    noprocess ();
    noprocess ();
 
 
  data.load_offset = 0;
  data.load_offset = 0;
  data.load_start  = 0;
  data.load_start  = 0;
  data.load_end    = 0;
  data.load_end    = 0;
 
 
  /* Parse the input arguments.  First is filename (required). */
  /* Parse the input arguments.  First is filename (required). */
  filename = scan_filename_with_cleanup (&args, NULL);
  filename = scan_filename_with_cleanup (&args, NULL);
  if (args != NULL && *args != '\0')
  if (args != NULL && *args != '\0')
    {
    {
      char *binary_string = "binary";
      char *binary_string = "binary";
 
 
      /* Look for optional "binary" flag.  */
      /* Look for optional "binary" flag.  */
      if (strncmp (args, binary_string, strlen (binary_string)) == 0)
      if (strncmp (args, binary_string, strlen (binary_string)) == 0)
        {
        {
          binary_flag = 1;
          binary_flag = 1;
          args += strlen (binary_string);
          args += strlen (binary_string);
          args = skip_spaces (args);
          args = skip_spaces (args);
        }
        }
      /* Parse offset (optional). */
      /* Parse offset (optional). */
      if (args != NULL && *args != '\0')
      if (args != NULL && *args != '\0')
      data.load_offset =
      data.load_offset =
        parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
        parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
      if (args != NULL && *args != '\0')
      if (args != NULL && *args != '\0')
        {
        {
          /* Parse start address (optional). */
          /* Parse start address (optional). */
          data.load_start =
          data.load_start =
            parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
            parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
          if (args != NULL && *args != '\0')
          if (args != NULL && *args != '\0')
            {
            {
              /* Parse end address (optional). */
              /* Parse end address (optional). */
              data.load_end = parse_and_eval_long (args);
              data.load_end = parse_and_eval_long (args);
              if (data.load_end <= data.load_start)
              if (data.load_end <= data.load_start)
                error (_("Start must be less than end."));
                error (_("Start must be less than end."));
            }
            }
        }
        }
    }
    }
 
 
  if (info_verbose)
  if (info_verbose)
    printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
    printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
                     filename, (unsigned long) data.load_offset,
                     filename, (unsigned long) data.load_offset,
                     (unsigned long) data.load_start,
                     (unsigned long) data.load_start,
                     (unsigned long) data.load_end);
                     (unsigned long) data.load_end);
 
 
  if (binary_flag)
  if (binary_flag)
    {
    {
      restore_binary_file (filename, &data);
      restore_binary_file (filename, &data);
    }
    }
  else
  else
    {
    {
      /* Open the file for loading. */
      /* Open the file for loading. */
      ibfd = bfd_openr_with_cleanup (filename, NULL);
      ibfd = bfd_openr_with_cleanup (filename, NULL);
 
 
      /* Process the sections. */
      /* Process the sections. */
      bfd_map_over_sections (ibfd, restore_section_callback, &data);
      bfd_map_over_sections (ibfd, restore_section_callback, &data);
    }
    }
  return;
  return;
}
}
 
 
static void
static void
srec_dump_command (char *cmd, int from_tty)
srec_dump_command (char *cmd, int from_tty)
{
{
  printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
  printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
  help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
  help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
}
}
 
 
static void
static void
ihex_dump_command (char *cmd, int from_tty)
ihex_dump_command (char *cmd, int from_tty)
{
{
  printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
  printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
  help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
  help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
}
}
 
 
static void
static void
tekhex_dump_command (char *cmd, int from_tty)
tekhex_dump_command (char *cmd, int from_tty)
{
{
  printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
  printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
  help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
  help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
}
}
 
 
static void
static void
binary_dump_command (char *cmd, int from_tty)
binary_dump_command (char *cmd, int from_tty)
{
{
  printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
  printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
  help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
  help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
}
}
 
 
static void
static void
binary_append_command (char *cmd, int from_tty)
binary_append_command (char *cmd, int from_tty)
{
{
  printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
  printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
  help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
  help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
}
}
 
 
extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
 
 
void
void
_initialize_cli_dump (void)
_initialize_cli_dump (void)
{
{
  struct cmd_list_element *c;
  struct cmd_list_element *c;
  add_prefix_cmd ("dump", class_vars, dump_command, _("\
  add_prefix_cmd ("dump", class_vars, dump_command, _("\
Dump target code/data to a local file."),
Dump target code/data to a local file."),
                  &dump_cmdlist, "dump ",
                  &dump_cmdlist, "dump ",
                  0/*allow-unknown*/,
                  0/*allow-unknown*/,
                  &cmdlist);
                  &cmdlist);
  add_prefix_cmd ("append", class_vars, append_command, _("\
  add_prefix_cmd ("append", class_vars, append_command, _("\
Append target code/data to a local file."),
Append target code/data to a local file."),
                  &append_cmdlist, "append ",
                  &append_cmdlist, "append ",
                  0/*allow-unknown*/,
                  0/*allow-unknown*/,
                  &cmdlist);
                  &cmdlist);
 
 
  add_dump_command ("memory", dump_memory_command, "\
  add_dump_command ("memory", dump_memory_command, "\
Write contents of memory to a raw binary file.\n\
Write contents of memory to a raw binary file.\n\
Arguments are FILE START STOP.  Writes the contents of memory within the\n\
Arguments are FILE START STOP.  Writes the contents of memory within the\n\
range [START .. STOP) to the specifed FILE in raw target ordered bytes.");
range [START .. STOP) to the specifed FILE in raw target ordered bytes.");
 
 
  add_dump_command ("value", dump_value_command, "\
  add_dump_command ("value", dump_value_command, "\
Write the value of an expression to a raw binary file.\n\
Write the value of an expression to a raw binary file.\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION to\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION to\n\
the specified FILE in raw target ordered bytes.");
the specified FILE in raw target ordered bytes.");
 
 
  add_prefix_cmd ("srec", all_commands, srec_dump_command, _("\
  add_prefix_cmd ("srec", all_commands, srec_dump_command, _("\
Write target code/data to an srec file."),
Write target code/data to an srec file."),
                  &srec_cmdlist, "dump srec ",
                  &srec_cmdlist, "dump srec ",
                  0 /*allow-unknown*/,
                  0 /*allow-unknown*/,
                  &dump_cmdlist);
                  &dump_cmdlist);
 
 
  add_prefix_cmd ("ihex", all_commands, ihex_dump_command, _("\
  add_prefix_cmd ("ihex", all_commands, ihex_dump_command, _("\
Write target code/data to an intel hex file."),
Write target code/data to an intel hex file."),
                  &ihex_cmdlist, "dump ihex ",
                  &ihex_cmdlist, "dump ihex ",
                  0 /*allow-unknown*/,
                  0 /*allow-unknown*/,
                  &dump_cmdlist);
                  &dump_cmdlist);
 
 
  add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command, _("\
  add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command, _("\
Write target code/data to a tekhex file."),
Write target code/data to a tekhex file."),
                  &tekhex_cmdlist, "dump tekhex ",
                  &tekhex_cmdlist, "dump tekhex ",
                  0 /*allow-unknown*/,
                  0 /*allow-unknown*/,
                  &dump_cmdlist);
                  &dump_cmdlist);
 
 
  add_prefix_cmd ("binary", all_commands, binary_dump_command, _("\
  add_prefix_cmd ("binary", all_commands, binary_dump_command, _("\
Write target code/data to a raw binary file."),
Write target code/data to a raw binary file."),
                  &binary_dump_cmdlist, "dump binary ",
                  &binary_dump_cmdlist, "dump binary ",
                  0 /*allow-unknown*/,
                  0 /*allow-unknown*/,
                  &dump_cmdlist);
                  &dump_cmdlist);
 
 
  add_prefix_cmd ("binary", all_commands, binary_append_command, _("\
  add_prefix_cmd ("binary", all_commands, binary_append_command, _("\
Append target code/data to a raw binary file."),
Append target code/data to a raw binary file."),
                  &binary_append_cmdlist, "append binary ",
                  &binary_append_cmdlist, "append binary ",
                  0 /*allow-unknown*/,
                  0 /*allow-unknown*/,
                  &append_cmdlist);
                  &append_cmdlist);
 
 
  add_cmd ("memory", all_commands, dump_srec_memory, _("\
  add_cmd ("memory", all_commands, dump_srec_memory, _("\
Write contents of memory to an srec file.\n\
Write contents of memory to an srec file.\n\
Arguments are FILE START STOP.  Writes the contents of memory\n\
Arguments are FILE START STOP.  Writes the contents of memory\n\
within the range [START .. STOP) to the specifed FILE in srec format."),
within the range [START .. STOP) to the specifed FILE in srec format."),
           &srec_cmdlist);
           &srec_cmdlist);
 
 
  add_cmd ("value", all_commands, dump_srec_value, _("\
  add_cmd ("value", all_commands, dump_srec_value, _("\
Write the value of an expression to an srec file.\n\
Write the value of an expression to an srec file.\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
to the specified FILE in srec format."),
to the specified FILE in srec format."),
           &srec_cmdlist);
           &srec_cmdlist);
 
 
  add_cmd ("memory", all_commands, dump_ihex_memory, _("\
  add_cmd ("memory", all_commands, dump_ihex_memory, _("\
Write contents of memory to an ihex file.\n\
Write contents of memory to an ihex file.\n\
Arguments are FILE START STOP.  Writes the contents of memory within\n\
Arguments are FILE START STOP.  Writes the contents of memory within\n\
the range [START .. STOP) to the specifed FILE in intel hex format."),
the range [START .. STOP) to the specifed FILE in intel hex format."),
           &ihex_cmdlist);
           &ihex_cmdlist);
 
 
  add_cmd ("value", all_commands, dump_ihex_value, _("\
  add_cmd ("value", all_commands, dump_ihex_value, _("\
Write the value of an expression to an ihex file.\n\
Write the value of an expression to an ihex file.\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
to the specified FILE in intel hex format."),
to the specified FILE in intel hex format."),
           &ihex_cmdlist);
           &ihex_cmdlist);
 
 
  add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
  add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
Write contents of memory to a tekhex file.\n\
Write contents of memory to a tekhex file.\n\
Arguments are FILE START STOP.  Writes the contents of memory\n\
Arguments are FILE START STOP.  Writes the contents of memory\n\
within the range [START .. STOP) to the specifed FILE in tekhex format."),
within the range [START .. STOP) to the specifed FILE in tekhex format."),
           &tekhex_cmdlist);
           &tekhex_cmdlist);
 
 
  add_cmd ("value", all_commands, dump_tekhex_value, _("\
  add_cmd ("value", all_commands, dump_tekhex_value, _("\
Write the value of an expression to a tekhex file.\n\
Write the value of an expression to a tekhex file.\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
to the specified FILE in tekhex format."),
to the specified FILE in tekhex format."),
           &tekhex_cmdlist);
           &tekhex_cmdlist);
 
 
  add_cmd ("memory", all_commands, dump_binary_memory, _("\
  add_cmd ("memory", all_commands, dump_binary_memory, _("\
Write contents of memory to a raw binary file.\n\
Write contents of memory to a raw binary file.\n\
Arguments are FILE START STOP.  Writes the contents of memory\n\
Arguments are FILE START STOP.  Writes the contents of memory\n\
within the range [START .. STOP) to the specifed FILE in binary format."),
within the range [START .. STOP) to the specifed FILE in binary format."),
           &binary_dump_cmdlist);
           &binary_dump_cmdlist);
 
 
  add_cmd ("value", all_commands, dump_binary_value, _("\
  add_cmd ("value", all_commands, dump_binary_value, _("\
Write the value of an expression to a raw binary file.\n\
Write the value of an expression to a raw binary file.\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
to the specified FILE in raw target ordered bytes."),
to the specified FILE in raw target ordered bytes."),
           &binary_dump_cmdlist);
           &binary_dump_cmdlist);
 
 
  add_cmd ("memory", all_commands, append_binary_memory, _("\
  add_cmd ("memory", all_commands, append_binary_memory, _("\
Append contents of memory to a raw binary file.\n\
Append contents of memory to a raw binary file.\n\
Arguments are FILE START STOP.  Writes the contents of memory within the\n\
Arguments are FILE START STOP.  Writes the contents of memory within the\n\
range [START .. STOP) to the specifed FILE in raw target ordered bytes."),
range [START .. STOP) to the specifed FILE in raw target ordered bytes."),
           &binary_append_cmdlist);
           &binary_append_cmdlist);
 
 
  add_cmd ("value", all_commands, append_binary_value, _("\
  add_cmd ("value", all_commands, append_binary_value, _("\
Append the value of an expression to a raw binary file.\n\
Append the value of an expression to a raw binary file.\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
to the specified FILE in raw target ordered bytes."),
to the specified FILE in raw target ordered bytes."),
           &binary_append_cmdlist);
           &binary_append_cmdlist);
 
 
  c = add_com ("restore", class_vars, restore_command, _("\
  c = add_com ("restore", class_vars, restore_command, _("\
Restore the contents of FILE to target memory.\n\
Restore the contents of FILE to target memory.\n\
Arguments are FILE OFFSET START END where all except FILE are optional.\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\
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\
If START and END are given, only the file contents within that range\n\
(file relative) will be restored to target memory."));
(file relative) will be restored to target memory."));
  c->completer = filename_completer;
  c->completer = filename_completer;
  /* FIXME: completers for other commands. */
  /* FIXME: completers for other commands. */
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.