OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [dsrec.c] - Blame information for rev 294

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.