[thirdparty/binutils-gdb.git] / gdb / dsrec.c

/* S-record download support for GDB, the GNU debugger.
   Copyright 1995, 1996, 1997 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "serial.h"
#include "srec.h"
#include <time.h>

int (*ui_load_progress_hook) PARAMS ((char *, unsigned long));
extern void report_transfer_performance PARAMS ((unsigned long, time_t, time_t));

extern int remote_debug;

static int make_srec PARAMS ((char *srec, CORE_ADDR targ_addr, bfd * abfd,
			      asection * sect, int sectoff, int *maxrecsize,
			      int flags));

/* Download an executable by converting it to S records.  DESC is a
   serial_t to send the data to.  FILE is the name of the file to be
   loaded.  LOAD_OFFSET is the offset into memory to load data into.
   It is usually specified by the user and is useful with the a.out
   file format.  MAXRECSIZE is the length in chars of the largest
   S-record the host can accomodate.  This is measured from the
   starting `S' to the last char of the checksum.  FLAGS is various
   random flags, and HASHMARK is non-zero to cause a `#' to be
   printed out for each record loaded.  WAITACK, if non-NULL, is a
   function that waits for an acknowledgement after each S-record,
   and returns non-zero if the ack is read correctly.  */

void
load_srec (desc, file, load_offset, maxrecsize, flags, hashmark, waitack)
     serial_t desc;
     const char *file;
     bfd_vma load_offset;
     int maxrecsize;
     int flags;
     int hashmark;
     int (*waitack) PARAMS ((void));
{
  bfd *abfd;
  asection *s;
  char *srec;
  int i;
  int reclen;
  time_t start_time, end_time;
  unsigned long data_count = 0;

  srec = (char *) alloca (maxrecsize + 1);

  abfd = bfd_openr (file, 0);
  if (!abfd)
    {
      printf_filtered ("Unable to open file %s\n", file);
      return;
    }

  if (bfd_check_format (abfd, bfd_object) == 0)
    {
      printf_filtered ("File is not an object file\n");
      return;
    }

  start_time = time (NULL);

  /* Write a type 0 header record. no data for a type 0, and there
     is no data, so len is 0.  */

  reclen = maxrecsize;
  make_srec (srec, 0, NULL, (asection *) 1, 0, &reclen, flags);
  if (remote_debug)
    {
      srec[reclen] = '\0';
      puts_debug ("sent -->", srec, "<--");
    }
  SERIAL_WRITE (desc, srec, reclen);

  for (s = abfd->sections; s; s = s->next)
    if (s->flags & SEC_LOAD)
      {
	int numbytes;
	bfd_vma addr = bfd_get_section_vma (abfd, s) + load_offset;
	bfd_size_type size = bfd_get_section_size_before_reloc (s);
	char *section_name = (char *) bfd_get_section_name (abfd, s);
	printf_filtered ("%s\t: 0x%08x .. 0x%08x  ",
			 section_name, (int) addr, (int) addr + size);
	gdb_flush (gdb_stdout);

	data_count += size;

	for (i = 0; i < size; i += numbytes)
	  {
	    reclen = maxrecsize;
	    numbytes = make_srec (srec, (CORE_ADDR) (addr + i), abfd, s,
				  i, &reclen, flags);

	    if (remote_debug)
	      {
		srec[reclen] = '\0';
		puts_debug ("sent -->", srec, "<--");
	      }

	    /* Repeatedly send the S-record until a good
	       acknowledgement is sent back.  */
	    do
	      {
		SERIAL_WRITE (desc, srec, reclen);
		if (ui_load_progress_hook)
		  if (ui_load_progress_hook (section_name, (unsigned long) i))
		    error ("Canceled the download");
	      }
	    while (waitack != NULL && !waitack ());

	    if (hashmark)
	      {
		putchar_unfiltered ('#');
		gdb_flush (gdb_stdout);
	      }
	  }			/* Per-packet (or S-record) loop */

	if (ui_load_progress_hook)
	  if (ui_load_progress_hook (section_name, (unsigned long) i))
	    error ("Canceled the download");
	putchar_unfiltered ('\n');
      }

  if (hashmark)
    putchar_unfiltered ('\n');

  end_time = time (NULL);

  /* Write a terminator record.  */

  reclen = maxrecsize;
  make_srec (srec, abfd->start_address, NULL, NULL, 0, &reclen, flags);

  if (remote_debug)
    {
      srec[reclen] = '\0';
      puts_debug ("sent -->", srec, "<--");
    }

  SERIAL_WRITE (desc, srec, reclen);

  /* Some monitors need these to wake up properly.  (Which ones? -sts)  */
  SERIAL_WRITE (desc, "\r\r", 2);
  if (remote_debug)
    puts_debug ("sent -->", "\r\r", "<---");

  SERIAL_FLUSH_INPUT (desc);

  report_transfer_performance (data_count, start_time, end_time);
}

/*
 * make_srec -- make an srecord. This writes each line, one at a
 *      time, each with it's own header and trailer line.
 *      An srecord looks like this:
 *
 * byte count-+     address
 * start ---+ |        |       data        +- checksum
 *          | |        |                   |
 *        S01000006F6B692D746573742E73726563E4
 *        S315000448600000000000000000FC00005900000000E9
 *        S31A0004000023C1400037DE00F023604000377B009020825000348D
 *        S30B0004485A0000000000004E
 *        S70500040000F6
 *
 *      S<type><length><address><data><checksum>
 *
 *      Where
 *      - length
 *        is the number of bytes following upto the checksum. Note that
 *        this is not the number of chars following, since it takes two
 *        chars to represent a byte.
 *      - type
 *        is one of:
 *        0) header record
 *        1) two byte address data record
 *        2) three byte address data record
 *        3) four byte address data record
 *        7) four byte address termination record
 *        8) three byte address termination record
 *        9) two byte address termination record
 *       
 *      - address
 *        is the start address of the data following, or in the case of
 *        a termination record, the start address of the image
 *      - data
 *        is the data.
 *      - checksum
 *        is the sum of all the raw byte data in the record, from the length
 *        upwards, modulo 256 and subtracted from 255.
 *
 * This routine returns the length of the S-record.
 *
 */

static int
make_srec (srec, targ_addr, abfd, sect, sectoff, maxrecsize, flags)
     char *srec;
     CORE_ADDR targ_addr;
     bfd *abfd;
     asection *sect;
     int sectoff;
     int *maxrecsize;
     int flags;
{
  unsigned char checksum;
  int tmp;
  const static char hextab[] = "0123456789ABCDEF";
  const static char data_code_table[] = "123";
  const static char term_code_table[] = "987";
  const static char header_code_table[] = "000";
  const static char *formats[] =
  {"S%c%02X%04X",
   "S%c%02X%06X",
   "S%c%02X%08X"};
  char const *code_table;
  int addr_size;
  int payload_size;
  char *binbuf;
  char *p;

  if (sect)
    {
      tmp = flags;		/* Data or header record */
      code_table = abfd ? data_code_table : header_code_table;
      binbuf = alloca (*maxrecsize / 2);
    }
  else
    {
      tmp = flags >> SREC_TERM_SHIFT;	/* Term record */
      code_table = term_code_table;
    }

  if ((tmp & SREC_2_BYTE_ADDR) && (targ_addr <= 0xffff))
    addr_size = 2;
  else if ((tmp & SREC_3_BYTE_ADDR) && (targ_addr <= 0xffffff))
    addr_size = 3;
  else if (tmp & SREC_4_BYTE_ADDR)
    addr_size = 4;
  else
    fatal ("make_srec:  Bad address (0x%x), or bad flags (0x%x).",
	   targ_addr, flags);

  /* Now that we know the address size, we can figure out how much
     data this record can hold.  */

  if (sect && abfd)
    {
      payload_size = (*maxrecsize - (1 + 1 + 2 + addr_size * 2 + 2)) / 2;
      payload_size = min (payload_size, sect->_raw_size - sectoff);

      bfd_get_section_contents (abfd, sect, binbuf, sectoff, payload_size);
    }
  else
    payload_size = 0;		/* Term or header packets have no payload */

  /* Output the header.  */

  sprintf (srec, formats[addr_size - 2], code_table[addr_size - 2],
	   addr_size + payload_size + 1, (int) targ_addr);

  /* Note that the checksum is calculated on the raw data, not the
     hexified data.  It includes the length, address and the data
     portions of the packet.  */

  checksum = 0;

  checksum += (payload_size + addr_size + 1	/* Packet length */
	       + (targ_addr & 0xff)	/* Address... */
	       + ((targ_addr >> 8) & 0xff)
	       + ((targ_addr >> 16) & 0xff)
	       + ((targ_addr >> 24) & 0xff));

  p = srec + 1 + 1 + 2 + addr_size * 2;

  /* Build the Srecord.  */
  for (tmp = 0; tmp < payload_size; tmp++)
    {
      unsigned char k;

      k = binbuf[tmp];
      *p++ = hextab[k >> 4];
      *p++ = hextab[k & 0xf];
      checksum += k;
    }

  checksum = ~checksum;

  *p++ = hextab[checksum >> 4];
  *p++ = hextab[checksum & 0xf];
  *p++ = '\r';

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