GDB (xrefs)
/tmp/gdb-7.10/gdb/dsrec.c
Go to the documentation of this file.
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));
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);
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 ('#');
137  }
138  } /* Per-packet (or S-record) loop. */
139 
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 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define SREC_2_BYTE_ADDR
Definition: srec.h:28
int putchar_unfiltered(int c)
Definition: utils.c:2151
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define SREC_3_BYTE_ADDR
Definition: srec.h:29
struct ui_file * gdb_stdout
Definition: main.c:71
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
int serial_write(struct serial *scb, const void *buf, size_t count)
Definition: serial.c:403
int remote_debug
Definition: top.c:166
#define _(String)
Definition: gdb_locale.h:40
struct bfd * gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:320
void printf_filtered(const char *format,...)
Definition: utils.c:2388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
static int make_srec(char *srec, CORE_ADDR targ_addr, bfd *abfd, asection *sect, int sectoff, int *maxrecsize, int flags)
Definition: dsrec.c:222
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
int serial_flush_input(struct serial *scb)
Definition: serial.c:461
void print_transfer_performance(struct ui_file *stream, unsigned long data_count, unsigned long write_count, const struct timeval *start_time, const struct timeval *end_time)
Definition: symfile.c:2173
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define min(a, b)
Definition: defs.h:106
void puts_debug(char *prefix, char *string, char *suffix)
Definition: utils.c:2192
Definition: serial.h:227
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
#define SREC_TERM_SHIFT
Definition: srec.h:31
#define SREC_4_BYTE_ADDR
Definition: srec.h:30
void load_srec(struct serial *desc, const char *file, bfd_vma load_offset, int maxrecsize, int flags, int hashmark, int(*waitack)(void))
Definition: dsrec.c:45
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
int(* deprecated_ui_load_progress_hook)(const char *section, unsigned long num)
Definition: symfile.c:69
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175