diff options
Diffstat (limited to 'gnu/usr.bin/binutils/gdb/dsrec.c')
| -rw-r--r-- | gnu/usr.bin/binutils/gdb/dsrec.c | 264 |
1 files changed, 264 insertions, 0 deletions
diff --git a/gnu/usr.bin/binutils/gdb/dsrec.c b/gnu/usr.bin/binutils/gdb/dsrec.c new file mode 100644 index 00000000000..0c5b084ef66 --- /dev/null +++ b/gnu/usr.bin/binutils/gdb/dsrec.c @@ -0,0 +1,264 @@ +/* S-record download support for GDB, the GNU debugger. + Copyright 1995, 1996 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" + +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. + 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, maxrecsize, flags, hashmark, waitack) + serial_t desc; + const char *file; + int maxrecsize; + int flags; + int hashmark; + int (*waitack) PARAMS ((void)); +{ + bfd *abfd; + asection *s; + char *srec; + int i; + int reclen; + + 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; + } + + for (s = abfd->sections; s; s = s->next) + if (s->flags & SEC_LOAD) + { + int numbytes; + + printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, s->vma, + s->vma + s->_raw_size); + gdb_flush (gdb_stdout); + + for (i = 0; i < s->_raw_size; i += numbytes) + { + reclen = maxrecsize; + numbytes = make_srec (srec, s->vma + i, abfd, s, i, &reclen, + flags); + + if (remote_debug) + fprintf_unfiltered (gdb_stderr, "%.*s\\r\n", reclen-1, srec); + + /* Repeatedly send the S-record until a good acknowledgement + is sent back. */ + do + { + SERIAL_WRITE (desc, srec, reclen); + } + while (waitack != NULL && !waitack()); + + if (hashmark) + { + putchar_unfiltered ('#'); + gdb_flush (gdb_stdout); + } + } /* Per-packet (or S-record) loop */ + + putchar_unfiltered ('\n'); + } /* Loadable sections */ + + if (hashmark) + putchar_unfiltered ('\n'); + + /* Write a type 7 terminator record. no data for a type 7, and there + is no data, so len is 0. */ + + reclen = maxrecsize; + make_srec (srec, abfd->start_address, NULL, NULL, 0, &reclen, flags); + + if (remote_debug) + fprintf_unfiltered (gdb_stderr, "%.*s\\r\n", reclen-1, srec); + SERIAL_WRITE (desc, srec, reclen); + + SERIAL_WRITE (desc, "\r\r", 2); /* Some monitors need these to wake up */ + + SERIAL_FLUSH_INPUT (desc); +} + +/* + * 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[] = "xx123"; + const static char term_code_table[] = "xx987"; + const static char *formats[] = {NULL, NULL, "S%c%02X%04X", "S%c%02X%06X", + "S%c%02X%08X"}; + char const *code_table; + int addr_size; + int payload_size; + int type_code; + char *binbuf; + char *p; + + if (sect) + { + tmp = flags; /* Data record */ + code_table = data_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) + { + 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 packets have no payload */ + +/* Output the header. */ + + sprintf (srec, formats[addr_size], code_table[addr_size], + addr_size + payload_size + 1, 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; +} |