gdb/dsrec.c

   1 /* S-record download support for GDB, the GNU debugger.
   2    Copyright (C) 1995-2015 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   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.
  10
  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.
  15
  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/>.  */
  18
  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"
  25
  26 extern int remote_debug;
  27
  28 static int make_srec (char *srec, CORE_ADDR targ_addr, bfd * abfd,
  29                       asection * sect, int sectoff, int *maxrecsize,
  30                       int flags);
  31
  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.  */
  43
  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;
  57
  58   srec = (char *) alloca (maxrecsize + 1);
  59
  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     }
  66
  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     }
  74
  75   gettimeofday (&start_time, NULL);
  76
  77   /* Write a type 0 header record. no data for a type 0, and there
  78      is no data, so len is 0.  */
  79
  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);
  88
  89   for (s = abfd->sections; s; s = s->next)
  90     if (s->flags & SEC_LOAD)
  91       {
  92         int numbytes;
  93
  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);
 106
 107         data_count += size;
 108
 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);
 114
 115             if (remote_debug)
 116               {
 117                 srec[reclen] = '\0';
 118                 puts_debug ("sent -->", srec, "<--");
 119               }
 120
 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 ());
 132
 133             if (hashmark)
 134               {
 135                 putchar_unfiltered ('#');
 136                 gdb_flush (gdb_stdout);
 137               }
 138           }                     /* Per-packet (or S-record) loop.  */
 139
 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       }
 146
 147   if (hashmark)
 148     putchar_unfiltered ('\n');
 149
 150   gettimeofday (&end_time, NULL);
 151
 152   /* Write a terminator record.  */
 153
 154   reclen = maxrecsize;
 155   make_srec (srec, abfd->start_address, NULL, NULL, 0, &reclen, flags);
 156
 157   if (remote_debug)
 158     {
 159       srec[reclen] = '\0';
 160       puts_debug ("sent -->", srec, "<--");
 161     }
 162
 163   serial_write (desc, srec, reclen);
 164
 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", "<---");
 169
 170   serial_flush_input (desc);
 171
 172   print_transfer_performance (gdb_stdout, data_count, 0,
 173                               &start_time, &end_time);
 174   do_cleanups (cleanup);
 175 }
 176
 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  */
 220
 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;
 236
 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     }
 249
 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);
 260
 261   /* Now that we know the address size, we can figure out how much
 262      data this record can hold.  */
 263
 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);
 268
 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.  */
 273
 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);
 279
 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.  */
 283
 284   checksum = 0;
 285
 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));
 291
 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;
 296
 297   /* Build the Srecord.  */
 298   for (tmp = 0; tmp < payload_size; tmp++)
 299     {
 300       unsigned char k;
 301
 302       k = binbuf[tmp];
 303       *p++ = hextab[k >> 4];
 304       *p++ = hextab[k & 0xf];
 305       checksum += k;
 306     }
 307
 308   checksum = ~checksum;
 309
 310   *p++ = hextab[checksum >> 4];
 311   *p++ = hextab[checksum & 0xf];
 312   *p++ = '\r';
 313
 314   *maxrecsize = p - srec;
 315   return payload_size;
 316 }