1 /* S-record download support for GDB, the GNU debugger.
2 Copyright 1995, 1996, 1997, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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. */
27 extern void report_transfer_performance (unsigned long, time_t, time_t);
29 extern int remote_debug
;
31 static int make_srec (char *srec
, CORE_ADDR targ_addr
, bfd
* abfd
,
32 asection
* sect
, int sectoff
, int *maxrecsize
,
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. */
48 load_srec (struct serial
*desc
, const char *file
, bfd_vma load_offset
,
50 int flags
, int hashmark
, int (*waitack
) (void))
57 time_t start_time
, end_time
;
58 unsigned long data_count
= 0;
60 srec
= (char *) alloca (maxrecsize
+ 1);
62 abfd
= bfd_openr (file
, 0);
65 printf_filtered ("Unable to open file %s\n", file
);
69 if (bfd_check_format (abfd
, bfd_object
) == 0)
71 printf_filtered ("File is not an object file\n");
75 start_time
= 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. */
81 make_srec (srec
, 0, NULL
, (asection
*) 1, 0, &reclen
, flags
);
85 puts_debug ("sent -->", srec
, "<--");
87 serial_write (desc
, srec
, reclen
);
89 for (s
= abfd
->sections
; s
; s
= s
->next
)
90 if (s
->flags
& SEC_LOAD
)
93 bfd_vma addr
= bfd_get_section_vma (abfd
, s
) + load_offset
;
94 bfd_size_type size
= bfd_get_section_size_before_reloc (s
);
95 char *section_name
= (char *) bfd_get_section_name (abfd
, s
);
96 /* Both GDB and BFD have mechanisms for printing addresses.
97 In the below, GDB's is used so that the address is
98 consistent with the rest of GDB. BFD's printf_vma() could
99 have also been used. cagney 1999-09-01 */
100 printf_filtered ("%s\t: 0x%s .. 0x%s ",
103 paddr (addr
+ size
));
104 gdb_flush (gdb_stdout
);
108 for (i
= 0; i
< size
; i
+= numbytes
)
111 numbytes
= make_srec (srec
, (CORE_ADDR
) (addr
+ i
), abfd
, s
,
117 puts_debug ("sent -->", srec
, "<--");
120 /* Repeatedly send the S-record until a good
121 acknowledgement is sent back. */
124 serial_write (desc
, srec
, reclen
);
125 if (ui_load_progress_hook
)
126 if (ui_load_progress_hook (section_name
, (unsigned long) i
))
127 error ("Canceled the download");
129 while (waitack
!= NULL
&& !waitack ());
133 putchar_unfiltered ('#');
134 gdb_flush (gdb_stdout
);
136 } /* Per-packet (or S-record) loop */
138 if (ui_load_progress_hook
)
139 if (ui_load_progress_hook (section_name
, (unsigned long) i
))
140 error ("Canceled the download");
141 putchar_unfiltered ('\n');
145 putchar_unfiltered ('\n');
147 end_time
= time (NULL
);
149 /* Write a terminator record. */
152 make_srec (srec
, abfd
->start_address
, NULL
, NULL
, 0, &reclen
, flags
);
157 puts_debug ("sent -->", srec
, "<--");
160 serial_write (desc
, srec
, reclen
);
162 /* Some monitors need these to wake up properly. (Which ones? -sts) */
163 serial_write (desc
, "\r\r", 2);
165 puts_debug ("sent -->", "\r\r", "<---");
167 serial_flush_input (desc
);
169 report_transfer_performance (data_count
, start_time
, end_time
);
173 * make_srec -- make an srecord. This writes each line, one at a
174 * time, each with it's own header and trailer line.
175 * An srecord looks like this:
177 * byte count-+ address
178 * start ---+ | | data +- checksum
180 * S01000006F6B692D746573742E73726563E4
181 * S315000448600000000000000000FC00005900000000E9
182 * S31A0004000023C1400037DE00F023604000377B009020825000348D
183 * S30B0004485A0000000000004E
186 * S<type><length><address><data><checksum>
190 * is the number of bytes following upto the checksum. Note that
191 * this is not the number of chars following, since it takes two
192 * chars to represent a byte.
196 * 1) two byte address data record
197 * 2) three byte address data record
198 * 3) four byte address data record
199 * 7) four byte address termination record
200 * 8) three byte address termination record
201 * 9) two byte address termination record
204 * is the start address of the data following, or in the case of
205 * a termination record, the start address of the image
209 * is the sum of all the raw byte data in the record, from the length
210 * upwards, modulo 256 and subtracted from 255.
212 * This routine returns the length of the S-record.
217 make_srec (char *srec
, CORE_ADDR targ_addr
, bfd
*abfd
, asection
*sect
,
218 int sectoff
, int *maxrecsize
, int flags
)
220 unsigned char checksum
;
222 const static char hextab
[] = "0123456789ABCDEF";
223 const static char data_code_table
[] = "123";
224 const static char term_code_table
[] = "987";
225 const static char header_code_table
[] = "000";
226 const static char *formats
[] =
230 char const *code_table
;
238 tmp
= flags
; /* Data or header record */
239 code_table
= abfd
? data_code_table
: header_code_table
;
240 binbuf
= alloca (*maxrecsize
/ 2);
244 tmp
= flags
>> SREC_TERM_SHIFT
; /* Term record */
245 code_table
= term_code_table
;
249 if ((tmp
& SREC_2_BYTE_ADDR
) && (targ_addr
<= 0xffff))
251 else if ((tmp
& SREC_3_BYTE_ADDR
) && (targ_addr
<= 0xffffff))
253 else if (tmp
& SREC_4_BYTE_ADDR
)
256 internal_error (__FILE__
, __LINE__
,
257 "make_srec: Bad address (0x%s), or bad flags (0x%x).",
258 paddr (targ_addr
), flags
);
260 /* Now that we know the address size, we can figure out how much
261 data this record can hold. */
265 payload_size
= (*maxrecsize
- (1 + 1 + 2 + addr_size
* 2 + 2)) / 2;
266 payload_size
= min (payload_size
, sect
->_raw_size
- sectoff
);
268 bfd_get_section_contents (abfd
, sect
, binbuf
, sectoff
, payload_size
);
271 payload_size
= 0; /* Term or header packets have no payload */
273 /* Output the header. */
275 sprintf (srec
, formats
[addr_size
- 2], code_table
[addr_size
- 2],
276 addr_size
+ payload_size
+ 1, (int) targ_addr
);
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. */
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));
290 p
= srec
+ 1 + 1 + 2 + addr_size
* 2;
292 /* Build the Srecord. */
293 for (tmp
= 0; tmp
< payload_size
; tmp
++)
298 *p
++ = hextab
[k
>> 4];
299 *p
++ = hextab
[k
& 0xf];
303 checksum
= ~checksum
;
305 *p
++ = hextab
[checksum
>> 4];
306 *p
++ = hextab
[checksum
& 0xf];
309 *maxrecsize
= p
- srec
;
This page took 0.035655 seconds and 4 git commands to generate.