gdb/dsrec.c - gdb

Functions defined

Source code

  1. /* S-record download support for GDB, the GNU debugger.
  2.    Copyright (C) 1995-2015 Free Software Foundation, Inc.

  4.    This file is part of GDB.

  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 3 of the License, or
  9.    (at your option) any later version.

  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.

  16.    You should have received a copy of the GNU General Public License
  17.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  19. #include "defs.h"
  20. #include "serial.h"
  21. #include "srec.h"
  22. #include <sys/time.h>
  23. #include <time.h>
  24. #include "gdb_bfd.h"

  26. extern int remote_debug;

  28. static int make_srec (char *srec, CORE_ADDR targ_addr, bfd * abfd,
  29.                       asection * sect, int sectoff, int *maxrecsize,
  30.                       int flags);

  32. /* Download an executable by converting it to S records.  DESC is a
  33.    `struct serial *' to send the data to.  FILE is the name of the
  34.    file to be loaded.  LOAD_OFFSET is the offset into memory to load
  35.    data into.  It is usually specified by the user and is useful with
  36.    the a.out file format.  MAXRECSIZE is the length in chars of the
  37.    largest S-record the host can accomodate.  This is measured from
  38.    the starting `S' to the last char of the checksum.  FLAGS is
  39.    various random flags, and HASHMARK is non-zero to cause a `#' to be
  40.    printed out for each record loaded.  WAITACK, if non-NULL, is a
  41.    function that waits for an acknowledgement after each S-record, and
  42.    returns non-zero if the ack is read correctly.  */

  44. void
  45. ‌load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
  46.            int maxrecsize,
  47.            int flags, int hashmark, int (*waitack) (void))
  48. {
  49.   bfd *abfd;
  50.   asection *s;
  51.   char *srec;
  52.   int i;
  53.   int reclen;
  54.   struct timeval start_time, end_time;
  55.   unsigned long data_count = 0;
  56.   struct cleanup *cleanup;

  58.   srec = (char *) alloca (maxrecsize + 1);

  60.   abfd = gdb_bfd_open (file, NULL, -1);
  61.   if (!abfd)
  62.     {
  63.       printf_filtered (_("Unable to open file %s\n"), file);
  64.       return;
  65.     }

  67.   cleanup = make_cleanup_bfd_unref (abfd);
  68.   if (bfd_check_format (abfd, bfd_object) == 0)
  69.     {
  70.       printf_filtered (_("File is not an object file\n"));
  71.       do_cleanups (cleanup);
  72.       return;
  73.     }

  75.   gettimeofday (&start_time, NULL);

  77.   /* Write a type 0 header record. no data for a type 0, and there
  78.      is no data, so len is 0.  */

  80.   reclen = maxrecsize;
  81.   make_srec (srec, 0, NULL, (asection *) 1, 0, &reclen, flags);
  82.   if (remote_debug)
  83.     {
  84.       srec[reclen] = '\0';
  85.       puts_debug ("sent -->", srec, "<--");
  86.     }
  87.   serial_write (desc, srec, reclen);

  89.   for (s = abfd->sections; s; s = s->next)
  90.     if (s->flags & SEC_LOAD)
  91.       {
  92.         int numbytes;

  94.         bfd_vma addr = bfd_get_section_vma (abfd, s) + load_offset;
  95.         bfd_size_type size = bfd_get_section_size (s);
  96.         char *section_name = (char *) bfd_get_section_name (abfd, s);
  97.         /* Both GDB and BFD have mechanisms for printing addresses.
  98.            In the below, GDB's is used so that the address is
  99.            consistent with the rest of GDB.  BFD's printf_vma() could
  100.            have also been used.  cagney 1999-09-01 */
  101.         printf_filtered ("%s\t: %s .. %s  ",
  102.                          section_name,
  103.                          paddress (target_gdbarch (), addr),
  104.                          paddress (target_gdbarch (), addr + size));
  105.         gdb_flush (gdb_stdout);

  107.         data_count += size;

  109.         for (i = 0; i < size; i += numbytes)
  110.           {
  111.             reclen = maxrecsize;
  112.             numbytes = make_srec (srec, (CORE_ADDR) (addr + i), abfd, s,
  113.                                   i, &reclen, flags);

  115.             if (remote_debug)
  116.               {
  117.                 srec[reclen] = '\0';
  118.                 puts_debug ("sent -->", srec, "<--");
  119.               }

  121.             /* Repeatedly send the S-record until a good
  122.                acknowledgement is sent back.  */
  123.             do
  124.               {
  125.                 serial_write (desc, srec, reclen);
  126.                 if (deprecated_ui_load_progress_hook)
  127.                   if (deprecated_ui_load_progress_hook (section_name,
  128.                                                         (unsigned long) i))
  129.                     error (_("Canceled the download"));
  130.               }
  131.             while (waitack != NULL && !waitack ());

  133.             if (hashmark)
  134.               {
  135.                 putchar_unfiltered ('#');
  136.                 gdb_flush (gdb_stdout);
  137.               }
  138.           }                        /* Per-packet (or S-record) loop.  */

  140.         if (deprecated_ui_load_progress_hook)
  141.           if (deprecated_ui_load_progress_hook (section_name,
  142.                                                 (unsigned long) i))
  143.             error (_("Canceled the download"));
  144.         putchar_unfiltered ('\n');
  145.       }

  147.   if (hashmark)
  148.     putchar_unfiltered ('\n');

  150.   gettimeofday (&end_time, NULL);

  152.   /* Write a terminator record.  */

  154.   reclen = maxrecsize;
  155.   make_srec (srec, abfd->start_address, NULL, NULL, 0, &reclen, flags);

  157.   if (remote_debug)
  158.     {
  159.       srec[reclen] = '\0';
  160.       puts_debug ("sent -->", srec, "<--");
  161.     }

  163.   serial_write (desc, srec, reclen);

  165.   /* Some monitors need these to wake up properly.  (Which ones? -sts)  */
  166.   serial_write (desc, "\r\r", 2);
  167.   if (remote_debug)
  168.     puts_debug ("sent -->", "\r\r", "<---");

  170.   serial_flush_input (desc);

  172.   print_transfer_performance (gdb_stdout, data_count, 0,
  173.                               &start_time, &end_time);
  174.   do_cleanups (cleanup);
  175. }

  177. /*
  178. * make_srec -- make an srecord.  This writes each line, one at a
  179. *      time, each with it's own header and trailer line.
  180. *      An srecord looks like this:
  181. *
  182. * byte count-+     address
  183. * start ---+ |        |       data        +- checksum
  184. *          | |        |                   |
  185. *        S01000006F6B692D746573742E73726563E4
  186. *        S315000448600000000000000000FC00005900000000E9
  187. *        S31A0004000023C1400037DE00F023604000377B009020825000348D
  188. *        S30B0004485A0000000000004E
  189. *        S70500040000F6
  190. *
  191. *      S<type><length><address><data><checksum>
  192. *
  193. *      Where
  194. *      - length
  195. *        is the number of bytes following upto the checksum.  Note
  196. *        that this is not the number of chars following, since it
  197. *        takes two chars to represent a byte.
  198. *      - type
  199. *        is one of:
  200. *        0) header record
  201. *        1) two byte address data record
  202. *        2) three byte address data record
  203. *        3) four byte address data record
  204. *        7) four byte address termination record
  205. *        8) three byte address termination record
  206. *        9) two byte address termination record
  207. *
  208. *      - address
  209. *        is the start address of the data following, or in the case of
  210. *        a termination record, the start address of the image
  211. *      - data
  212. *        is the data.
  213. *      - checksum
  214. *        is the sum of all the raw byte data in the record, from the length
  215. *        upwards, modulo 256 and subtracted from 255.
  216. *
  217. * This routine returns the length of the S-record.
  218. *
  219. */

  221. static int
  222. ‌make_srec (char *srec, CORE_ADDR targ_addr, bfd *abfd, asection *sect,
  223.            int sectoff, int *maxrecsize, int flags)
  224. {
  225.   unsigned char checksum;
  226.   int tmp;
  227.   static const char hextab[] = "0123456789ABCDEF";
  228.   static const char data_code_table[] = "123";
  229.   static const char term_code_table[] = "987";
  230.   static const char header_code_table[] = "000";
  231.   char const *code_table;
  232.   int addr_size;
  233.   int payload_size;
  234.   char *binbuf;
  235.   char *p;

  237.   if (sect)
  238.     {
  239.       tmp = flags;                /* Data or header record */
  240.       code_table = abfd ? data_code_table : header_code_table;
  241.       binbuf = alloca (*maxrecsize / 2);
  242.     }
  243.   else
  244.     {
  245.       tmp = flags >> SREC_TERM_SHIFT;        /* Term record */
  246.       code_table = term_code_table;
  247.       binbuf = NULL;
  248.     }

  250.   if ((tmp & SREC_2_BYTE_ADDR) && (targ_addr <= 0xffff))
  251.     addr_size = 2;
  252.   else if ((tmp & SREC_3_BYTE_ADDR) && (targ_addr <= 0xffffff))
  253.     addr_size = 3;
  254.   else if (tmp & SREC_4_BYTE_ADDR)
  255.     addr_size = 4;
  256.   else
  257.     internal_error (__FILE__, __LINE__,
  258.                     _("make_srec:  Bad address (%s), or bad flags (0x%x)."),
  259.                     paddress (target_gdbarch (), targ_addr), flags);

  261.   /* Now that we know the address size, we can figure out how much
  262.      data this record can hold.  */

  264.   if (sect && abfd)
  265.     {
  266.       payload_size = (*maxrecsize - (1 + 1 + 2 + addr_size * 2 + 2)) / 2;
  267.       payload_size = min (payload_size, bfd_get_section_size (sect) - sectoff);

  269.       bfd_get_section_contents (abfd, sect, binbuf, sectoff, payload_size);
  270.     }
  271.   else
  272.     payload_size = 0;                /* Term or header packets have no payload.  */

  274.   /* Output the header.  */
  275.   snprintf (srec, (*maxrecsize) + 1, "S%c%02X%0*X",
  276.             code_table[addr_size - 2],
  277.             addr_size + payload_size + 1,
  278.             addr_size * 2, (int) targ_addr);

  280.   /* Note that the checksum is calculated on the raw data, not the
  281.      hexified data.  It includes the length, address and the data
  282.      portions of the packet.  */

  284.   checksum = 0;

  286.   checksum += (payload_size + addr_size + 1        /* Packet length */
  287.                + (targ_addr & 0xff)                /* Address...  */
  288.                + ((targ_addr >> 8) & 0xff)
  289.                + ((targ_addr >> 16) & 0xff)
  290.                + ((targ_addr >> 24) & 0xff));

  292.   /* NOTE: cagney/2003-08-10: The equation is old.  Check that the
  293.      recent snprintf changes match that equation.  */
  294.   gdb_assert (strlen (srec) == 1 + 1 + 2 + addr_size * 2);
  295.   p = srec + 1 + 1 + 2 + addr_size * 2;

  297.   /* Build the Srecord.  */
  298.   for (tmp = 0; tmp < payload_size; tmp++)
  299.     {
  300.       unsigned char k;

  302.       k = binbuf[tmp];
  303.       *p++ = hextab[k >> 4];
  304.       *p++ = hextab[k & 0xf];
  305.       checksum += k;
  306.     }

  308.   checksum = ~checksum;

  310.   *p++ = hextab[checksum >> 4];
  311.   *p++ = hextab[checksum & 0xf];
  312.   *p++ = '\r';

  314.   *maxrecsize = p - srec;
  315.   return payload_size;
  316. }