gdb/dsrec.c

   1 /* S-record download support for GDB, the GNU debugger.
   2    Copyright 1995, 1996, 1997, 1999, 2000, 2001, 2003, 2004
   3    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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "serial.h"
  24 #include "srec.h"
  25 #include <time.h>
  26 #include "gdb_assert.h"
  27 #include "gdb_string.h"
  28
  29 extern void report_transfer_performance (unsigned long, time_t, time_t);
  30
  31 extern int remote_debug;
  32
  33 static int make_srec (char *srec, CORE_ADDR targ_addr, bfd * abfd,
  34                       asection * sect, int sectoff, int *maxrecsize,
  35                       int flags);
  36
  37 /* Download an executable by converting it to S records.  DESC is a
  38    `struct serial *' to send the data to.  FILE is the name of the
  39    file to be loaded.  LOAD_OFFSET is the offset into memory to load
  40    data into.  It is usually specified by the user and is useful with
  41    the a.out file format.  MAXRECSIZE is the length in chars of the
  42    largest S-record the host can accomodate.  This is measured from
  43    the starting `S' to the last char of the checksum.  FLAGS is
  44    various random flags, and HASHMARK is non-zero to cause a `#' to be
  45    printed out for each record loaded.  WAITACK, if non-NULL, is a
  46    function that waits for an acknowledgement after each S-record, and
  47    returns non-zero if the ack is read correctly.  */
  48
  49 void
  50 load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
  51            int maxrecsize,
  52            int flags, int hashmark, int (*waitack) (void))
  53 {
  54   bfd *abfd;
  55   asection *s;
  56   char *srec;
  57   int i;
  58   int reclen;
  59   time_t start_time, end_time;
  60   unsigned long data_count = 0;
  61
  62   srec = (char *) alloca (maxrecsize + 1);
  63
  64   abfd = bfd_openr (file, 0);
  65   if (!abfd)
  66     {
  67       printf_filtered (_("Unable to open file %s\n"), file);
  68       return;
  69     }
  70
  71   if (bfd_check_format (abfd, bfd_object) == 0)
  72     {
  73       printf_filtered (_("File is not an object file\n"));
  74       return;
  75     }
  76
  77   start_time = time (NULL);
  78
  79   /* Write a type 0 header record. no data for a type 0, and there
  80      is no data, so len is 0.  */
  81
  82   reclen = maxrecsize;
  83   make_srec (srec, 0, NULL, (asection *) 1, 0, &reclen, flags);
  84   if (remote_debug)
  85     {
  86       srec[reclen] = '\0';
  87       puts_debug ("sent -->", srec, "<--");
  88     }
  89   serial_write (desc, srec, reclen);
  90
  91   for (s = abfd->sections; s; s = s->next)
  92     if (s->flags & SEC_LOAD)
  93       {
  94         int numbytes;
  95         bfd_vma addr = bfd_get_section_vma (abfd, s) + load_offset;
  96         bfd_size_type size = bfd_get_section_size (s);
  97         char *section_name = (char *) bfd_get_section_name (abfd, s);
  98         /* Both GDB and BFD have mechanisms for printing addresses.
  99            In the below, GDB's is used so that the address is
 100            consistent with the rest of GDB.  BFD's printf_vma() could
 101            have also been used. cagney 1999-09-01 */
 102         printf_filtered ("%s\t: 0x%s .. 0x%s  ",
 103                          section_name,
 104                          paddr (addr),
 105                          paddr (addr + size));
 106         gdb_flush (gdb_stdout);
 107
 108         data_count += size;
 109
 110         for (i = 0; i < size; i += numbytes)
 111           {
 112             reclen = maxrecsize;
 113             numbytes = make_srec (srec, (CORE_ADDR) (addr + i), abfd, s,
 114                                   i, &reclen, flags);
 115
 116             if (remote_debug)
 117               {
 118                 srec[reclen] = '\0';
 119                 puts_debug ("sent -->", srec, "<--");
 120               }
 121
 122             /* Repeatedly send the S-record until a good
 123                acknowledgement is sent back.  */
 124             do
 125               {
 126                 serial_write (desc, srec, reclen);
 127                 if (deprecated_ui_load_progress_hook)
 128                   if (deprecated_ui_load_progress_hook (section_name,
 129                                                         (unsigned long) i))
 130                     error (_("Canceled the download"));
 131               }
 132             while (waitack != NULL && !waitack ());
 133
 134             if (hashmark)
 135               {
 136                 putchar_unfiltered ('#');
 137                 gdb_flush (gdb_stdout);
 138               }
 139           }                     /* Per-packet (or S-record) loop */
 140
 141         if (deprecated_ui_load_progress_hook)
 142           if (deprecated_ui_load_progress_hook (section_name,
 143                                                 (unsigned long) i))
 144             error (_("Canceled the download"));
 145         putchar_unfiltered ('\n');
 146       }
 147
 148   if (hashmark)
 149     putchar_unfiltered ('\n');
 150
 151   end_time = time (NULL);
 152
 153   /* Write a terminator record.  */
 154
 155   reclen = maxrecsize;
 156   make_srec (srec, abfd->start_address, NULL, NULL, 0, &reclen, flags);
 157
 158   if (remote_debug)
 159     {
 160       srec[reclen] = '\0';
 161       puts_debug ("sent -->", srec, "<--");
 162     }
 163
 164   serial_write (desc, srec, reclen);
 165
 166   /* Some monitors need these to wake up properly.  (Which ones? -sts)  */
 167   serial_write (desc, "\r\r", 2);
 168   if (remote_debug)
 169     puts_debug ("sent -->", "\r\r", "<---");
 170
 171   serial_flush_input (desc);
 172
 173   report_transfer_performance (data_count, start_time, end_time);
 174 }
 175
 176 /*
 177  * make_srec -- make an srecord. This writes each line, one at a
 178  *      time, each with it's own header and trailer line.
 179  *      An srecord looks like this:
 180  *
 181  * byte count-+     address
 182  * start ---+ |        |       data        +- checksum
 183  *          | |        |                   |
 184  *        S01000006F6B692D746573742E73726563E4
 185  *        S315000448600000000000000000FC00005900000000E9
 186  *        S31A0004000023C1400037DE00F023604000377B009020825000348D
 187  *        S30B0004485A0000000000004E
 188  *        S70500040000F6
 189  *
 190  *      S<type><length><address><data><checksum>
 191  *
 192  *      Where
 193  *      - length
 194  *        is the number of bytes following upto the checksum. Note that
 195  *        this is not the number of chars following, since it takes two
 196  *        chars to represent a byte.
 197  *      - type
 198  *        is one of:
 199  *        0) header record
 200  *        1) two byte address data record
 201  *        2) three byte address data record
 202  *        3) four byte address data record
 203  *        7) four byte address termination record
 204  *        8) three byte address termination record
 205  *        9) two byte address termination record
 206  *
 207  *      - address
 208  *        is the start address of the data following, or in the case of
 209  *        a termination record, the start address of the image
 210  *      - data
 211  *        is the data.
 212  *      - checksum
 213  *        is the sum of all the raw byte data in the record, from the length
 214  *        upwards, modulo 256 and subtracted from 255.
 215  *
 216  * This routine returns the length of the S-record.
 217  *
 218  */
 219
 220 static int
 221 make_srec (char *srec, CORE_ADDR targ_addr, bfd *abfd, asection *sect,
 222            int sectoff, int *maxrecsize, int flags)
 223 {
 224   unsigned char checksum;
 225   int tmp;
 226   const static char hextab[] = "0123456789ABCDEF";
 227   const static char data_code_table[] = "123";
 228   const static char term_code_table[] = "987";
 229   const static char header_code_table[] = "000";
 230   char const *code_table;
 231   int addr_size;
 232   int payload_size;
 233   char *binbuf;
 234   char *p;
 235
 236   if (sect)
 237     {
 238       tmp = flags;              /* Data or header record */
 239       code_table = abfd ? data_code_table : header_code_table;
 240       binbuf = alloca (*maxrecsize / 2);
 241     }
 242   else
 243     {
 244       tmp = flags >> SREC_TERM_SHIFT;   /* Term record */
 245       code_table = term_code_table;
 246       binbuf = NULL;
 247     }
 248
 249   if ((tmp & SREC_2_BYTE_ADDR) && (targ_addr <= 0xffff))
 250     addr_size = 2;
 251   else if ((tmp & SREC_3_BYTE_ADDR) && (targ_addr <= 0xffffff))
 252     addr_size = 3;
 253   else if (tmp & SREC_4_BYTE_ADDR)
 254     addr_size = 4;
 255   else
 256     internal_error (__FILE__, __LINE__,
 257                     _("make_srec:  Bad address (0x%s), or bad flags (0x%x)."),
 258                     paddr (targ_addr), flags);
 259
 260   /* Now that we know the address size, we can figure out how much
 261      data this record can hold.  */
 262
 263   if (sect && abfd)
 264     {
 265       payload_size = (*maxrecsize - (1 + 1 + 2 + addr_size * 2 + 2)) / 2;
 266       payload_size = min (payload_size, bfd_get_section_size (sect) - sectoff);
 267
 268       bfd_get_section_contents (abfd, sect, binbuf, sectoff, payload_size);
 269     }
 270   else
 271     payload_size = 0;           /* Term or header packets have no payload */
 272
 273   /* Output the header.  */
 274   snprintf (srec, (*maxrecsize) + 1, "S%c%02X%0*X",
 275             code_table[addr_size - 2],
 276             addr_size + payload_size + 1,
 277             addr_size * 2, (int) targ_addr);
 278
 279   /* Note that the checksum is calculated on the raw data, not the
 280      hexified data.  It includes the length, address and the data
 281      portions of the packet.  */
 282
 283   checksum = 0;
 284
 285   checksum += (payload_size + addr_size + 1     /* Packet length */
 286                + (targ_addr & 0xff)     /* Address... */
 287                + ((targ_addr >> 8) & 0xff)
 288                + ((targ_addr >> 16) & 0xff)
 289                + ((targ_addr >> 24) & 0xff));
 290
 291   /* NOTE: cagney/2003-08-10: The equation is old.  Check that the
 292      recent snprintf changes match that equation.  */
 293   gdb_assert (strlen (srec) == 1 + 1 + 2 + addr_size * 2);
 294   p = srec + 1 + 1 + 2 + addr_size * 2;
 295
 296   /* Build the Srecord.  */
 297   for (tmp = 0; tmp < payload_size; tmp++)
 298     {
 299       unsigned char k;
 300
 301       k = binbuf[tmp];
 302       *p++ = hextab[k >> 4];
 303       *p++ = hextab[k & 0xf];
 304       checksum += k;
 305     }
 306
 307   checksum = ~checksum;
 308
 309   *p++ = hextab[checksum >> 4];
 310   *p++ = hextab[checksum & 0xf];
 311   *p++ = '\r';
 312
 313   *maxrecsize = p - srec;
 314   return payload_size;
 315 }