gdb/dsrec.c

   1 /* S-record download support for GDB, the GNU debugger.
   2    Copyright (C) 1995, 1996, 1997, 1999, 2000, 2001, 2003, 2004, 2007, 2008,
   3    2009, 2010, 2011 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "serial.h"
  22 #include "srec.h"
  23 #include <time.h>
  24 #include "gdb_assert.h"
  25 #include "gdb_string.h"
  26
  27 extern void report_transfer_performance (unsigned long, time_t, time_t);
  28
  29 extern int remote_debug;
  30
  31 static int make_srec (char *srec, CORE_ADDR targ_addr, bfd * abfd,
  32                       asection * sect, int sectoff, int *maxrecsize,
  33                       int flags);
  34
  35 /* Download an executable by converting it to S records.  DESC is a
  36    `struct serial *' to send the data to.  FILE is the name of the
  37    file to be loaded.  LOAD_OFFSET is the offset into memory to load
  38    data into.  It is usually specified by the user and is useful with
  39    the a.out file format.  MAXRECSIZE is the length in chars of the
  40    largest S-record the host can accomodate.  This is measured from
  41    the starting `S' to the last char of the checksum.  FLAGS is
  42    various random flags, and HASHMARK is non-zero to cause a `#' to be
  43    printed out for each record loaded.  WAITACK, if non-NULL, is a
  44    function that waits for an acknowledgement after each S-record, and
  45    returns non-zero if the ack is read correctly.  */
  46
  47 void
  48 load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
  49            int maxrecsize,
  50            int flags, int hashmark, int (*waitack) (void))
  51 {
  52   bfd *abfd;
  53   asection *s;
  54   char *srec;
  55   int i;
  56   int reclen;
  57   time_t start_time, end_time;
  58   unsigned long data_count = 0;
  59
  60   srec = (char *) alloca (maxrecsize + 1);
  61
  62   abfd = bfd_openr (file, 0);
  63   if (!abfd)
  64     {
  65       printf_filtered (_("Unable to open file %s\n"), file);
  66       return;
  67     }
  68
  69   if (bfd_check_format (abfd, bfd_object) == 0)
  70     {
  71       printf_filtered (_("File is not an object file\n"));
  72       return;
  73     }
  74
  75   start_time = 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   end_time = 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   report_transfer_performance (data_count, start_time, end_time);
 173 }
 174
 175 /*
 176  * make_srec -- make an srecord.  This writes each line, one at a
 177  *      time, each with it's own header and trailer line.
 178  *      An srecord looks like this:
 179  *
 180  * byte count-+     address
 181  * start ---+ |        |       data        +- checksum
 182  *          | |        |                   |
 183  *        S01000006F6B692D746573742E73726563E4
 184  *        S315000448600000000000000000FC00005900000000E9
 185  *        S31A0004000023C1400037DE00F023604000377B009020825000348D
 186  *        S30B0004485A0000000000004E
 187  *        S70500040000F6
 188  *
 189  *      S<type><length><address><data><checksum>
 190  *
 191  *      Where
 192  *      - length
 193  *        is the number of bytes following upto the checksum.  Note
 194  *        that this is not the number of chars following, since it
 195  *        takes two chars to represent a byte.
 196  *      - type
 197  *        is one of:
 198  *        0) header record
 199  *        1) two byte address data record
 200  *        2) three byte address data record
 201  *        3) four byte address data record
 202  *        7) four byte address termination record
 203  *        8) three byte address termination record
 204  *        9) two byte address termination record
 205  *
 206  *      - address
 207  *        is the start address of the data following, or in the case of
 208  *        a termination record, the start address of the image
 209  *      - data
 210  *        is the data.
 211  *      - checksum
 212  *        is the sum of all the raw byte data in the record, from the length
 213  *        upwards, modulo 256 and subtracted from 255.
 214  *
 215  * This routine returns the length of the S-record.
 216  *
 217  */
 218
 219 static int
 220 make_srec (char *srec, CORE_ADDR targ_addr, bfd *abfd, asection *sect,
 221            int sectoff, int *maxrecsize, int flags)
 222 {
 223   unsigned char checksum;
 224   int tmp;
 225   const static char hextab[] = "0123456789ABCDEF";
 226   const static char data_code_table[] = "123";
 227   const static char term_code_table[] = "987";
 228   const static char header_code_table[] = "000";
 229   char const *code_table;
 230   int addr_size;
 231   int payload_size;
 232   char *binbuf;
 233   char *p;
 234
 235   if (sect)
 236     {
 237       tmp = flags;              /* Data or header record */
 238       code_table = abfd ? data_code_table : header_code_table;
 239       binbuf = alloca (*maxrecsize / 2);
 240     }
 241   else
 242     {
 243       tmp = flags >> SREC_TERM_SHIFT;   /* Term record */
 244       code_table = term_code_table;
 245       binbuf = NULL;
 246     }
 247
 248   if ((tmp & SREC_2_BYTE_ADDR) && (targ_addr <= 0xffff))
 249     addr_size = 2;
 250   else if ((tmp & SREC_3_BYTE_ADDR) && (targ_addr <= 0xffffff))
 251     addr_size = 3;
 252   else if (tmp & SREC_4_BYTE_ADDR)
 253     addr_size = 4;
 254   else
 255     internal_error (__FILE__, __LINE__,
 256                     _("make_srec:  Bad address (%s), or bad flags (0x%x)."),
 257                     paddress (target_gdbarch, targ_addr), flags);
 258
 259   /* Now that we know the address size, we can figure out how much
 260      data this record can hold.  */
 261
 262   if (sect && abfd)
 263     {
 264       payload_size = (*maxrecsize - (1 + 1 + 2 + addr_size * 2 + 2)) / 2;
 265       payload_size = min (payload_size, bfd_get_section_size (sect) - sectoff);
 266
 267       bfd_get_section_contents (abfd, sect, binbuf, sectoff, payload_size);
 268     }
 269   else
 270     payload_size = 0;           /* Term or header packets have no payload.  */
 271
 272   /* Output the header.  */
 273   snprintf (srec, (*maxrecsize) + 1, "S%c%02X%0*X",
 274             code_table[addr_size - 2],
 275             addr_size + payload_size + 1,
 276             addr_size * 2, (int) targ_addr);
 277
 278   /* Note that the checksum is calculated on the raw data, not the
 279      hexified data.  It includes the length, address and the data
 280      portions of the packet.  */
 281
 282   checksum = 0;
 283
 284   checksum += (payload_size + addr_size + 1     /* Packet length */
 285                + (targ_addr & 0xff)             /* Address...  */
 286                + ((targ_addr >> 8) & 0xff)
 287                + ((targ_addr >> 16) & 0xff)
 288                + ((targ_addr >> 24) & 0xff));
 289
 290   /* NOTE: cagney/2003-08-10: The equation is old.  Check that the
 291      recent snprintf changes match that equation.  */
 292   gdb_assert (strlen (srec) == 1 + 1 + 2 + addr_size * 2);
 293   p = srec + 1 + 1 + 2 + addr_size * 2;
 294
 295   /* Build the Srecord.  */
 296   for (tmp = 0; tmp < payload_size; tmp++)
 297     {
 298       unsigned char k;
 299
 300       k = binbuf[tmp];
 301       *p++ = hextab[k >> 4];
 302       *p++ = hextab[k & 0xf];
 303       checksum += k;
 304     }
 305
 306   checksum = ~checksum;
 307
 308   *p++ = hextab[checksum >> 4];
 309   *p++ = hextab[checksum & 0xf];
 310   *p++ = '\r';
 311
 312   *maxrecsize = p - srec;
 313   return payload_size;
 314 }