Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/srec.c
Line
Count
Source (jump to first uncovered line)
1
/* BFD back-end for s-record objects.
2
   Copyright (C) 1990-2024 Free Software Foundation, Inc.
3
   Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
4
5
   This file is part of BFD, the Binary File Descriptor library.
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, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
22
23
/* SUBSECTION
24
  S-Record handling
25
26
   DESCRIPTION
27
28
  Ordinary S-Records cannot hold anything but addresses and
29
  data, so that's all that we implement.
30
31
  The only interesting thing is that S-Records may come out of
32
  order and there is no header, so an initial scan is required
33
  to discover the minimum and maximum addresses used to create
34
  the vma and size of the only section we create.  We
35
  arbitrarily call this section ".text".
36
37
  When bfd_get_section_contents is called the file is read
38
  again, and this time the data is placed into a bfd_alloc'd
39
  area.
40
41
  Any number of sections may be created for output, we save them
42
  up and output them when it's time to close the bfd.
43
44
  An s record looks like:
45
46
   EXAMPLE
47
  S<type><length><address><data><checksum>
48
49
   DESCRIPTION
50
  Where
51
  o length
52
  is the number of bytes following upto the checksum. Note that
53
  this is not the number of chars following, since it takes two
54
  chars to represent a byte.
55
  o type
56
  is one of:
57
  0) header record
58
  1) two byte address data record
59
  2) three byte address data record
60
  3) four byte address data record
61
  7) four byte address termination record
62
  8) three byte address termination record
63
  9) two byte address termination record
64
65
  o address
66
  is the start address of the data following, or in the case of
67
  a termination record, the start address of the image
68
  o data
69
  is the data.
70
  o checksum
71
  is the sum of all the raw byte data in the record, from the length
72
  upwards, modulo 256 and subtracted from 255.
73
74
   SUBSECTION
75
  Symbol S-Record handling
76
77
   DESCRIPTION
78
  Some ICE equipment understands an addition to the standard
79
  S-Record format; symbols and their addresses can be sent
80
  before the data.
81
82
  The format of this is:
83
  ($$ <modulename>
84
    (<space> <symbol> <address>)*)
85
  $$
86
87
  so a short symbol table could look like:
88
89
   EXAMPLE
90
  $$ flash.x
91
  $$ flash.c
92
    _port6 $0
93
    _delay $4
94
    _start $14
95
    _etext $8036
96
    _edata $8036
97
    _end $8036
98
  $$
99
100
   DESCRIPTION
101
  We allow symbols to be anywhere in the data stream - the module names
102
  are always ignored.  */
103
104
#include "sysdep.h"
105
#include "bfd.h"
106
#include "libbfd.h"
107
#include "libiberty.h"
108
#include "safe-ctype.h"
109
110
111
/* Macros for converting between hex and binary.  */
112
113
static const char digs[] = "0123456789ABCDEF";
114
115
183k
#define NIBBLE(x)    hex_value(x)
116
79.5k
#define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1]))
117
#define TOHEX(d, x, ch) \
118
0
  d[1] = digs[(x) & 0xf]; \
119
0
  d[0] = digs[((x)>>4)&0xf]; \
120
0
  ch += ((x) & 0xff);
121
31.1k
#define ISHEX(x)    hex_p(x)
122
123
/* The maximum number of address+data+crc bytes on a line is FF.  */
124
0
#define MAXCHUNK 0xff
125
126
/* Default size for a CHUNK.  */
127
#define DEFAULT_CHUNK 16
128
129
/* The number of data bytes we actually fit onto a line on output.
130
   This variable can be modified by objcopy's --srec-len parameter.
131
   For a 0x75 byte record you should set --srec-len=0x70.  */
132
unsigned int _bfd_srec_len = DEFAULT_CHUNK;
133
134
/* The type of srec output (free or forced to S3).
135
   This variable can be modified by objcopy's --srec-forceS3
136
   parameter.  */
137
bool _bfd_srec_forceS3 = false;
138
139
/* When writing an S-record file, the S-records can not be output as
140
   they are seen.  This structure is used to hold them in memory.  */
141
142
struct srec_data_list_struct
143
{
144
  struct srec_data_list_struct *next;
145
  bfd_byte *data;
146
  bfd_vma where;
147
  bfd_size_type size;
148
};
149
150
typedef struct srec_data_list_struct srec_data_list_type;
151
152
/* When scanning the S-record file, a linked list of srec_symbol
153
   structures is built to represent the symbol table (if there is
154
   one).  */
155
156
struct srec_symbol
157
{
158
  struct srec_symbol *next;
159
  const char *name;
160
  bfd_vma val;
161
};
162
163
/* The S-record tdata information.  */
164
165
typedef struct srec_data_struct
166
  {
167
    srec_data_list_type *head;
168
    srec_data_list_type *tail;
169
    unsigned int type;
170
    struct srec_symbol *symbols;
171
    struct srec_symbol *symtail;
172
    asymbol *csymbols;
173
  }
174
tdata_type;
175
176
/* Initialize by filling in the hex conversion array.  */
177
178
static void
179
srec_init (void)
180
3.41M
{
181
3.41M
  static bool inited = false;
182
183
3.41M
  if (! inited)
184
11
    {
185
11
      inited = true;
186
11
      hex_init ();
187
11
    }
188
3.41M
}
189
190
/* Set up the S-record tdata information.  */
191
192
static bool
193
srec_mkobject (bfd *abfd)
194
16.2k
{
195
16.2k
  tdata_type *tdata;
196
197
16.2k
  srec_init ();
198
199
16.2k
  tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
200
16.2k
  if (tdata == NULL)
201
0
    return false;
202
203
16.2k
  abfd->tdata.srec_data = tdata;
204
16.2k
  tdata->type = 1;
205
16.2k
  tdata->head = NULL;
206
16.2k
  tdata->tail = NULL;
207
16.2k
  tdata->symbols = NULL;
208
16.2k
  tdata->symtail = NULL;
209
16.2k
  tdata->csymbols = NULL;
210
211
16.2k
  return true;
212
16.2k
}
213
214
/* Read a byte from an S record file.  Set *ERRORPTR if an error
215
   occurred.  Return EOF on error or end of file.  */
216
217
static int
218
srec_get_byte (bfd *abfd, bool *errorptr)
219
1.13M
{
220
1.13M
  bfd_byte c;
221
222
1.13M
  if (bfd_read (&c, 1, abfd) != 1)
223
11.8k
    {
224
11.8k
      if (bfd_get_error () != bfd_error_file_truncated)
225
1.65k
  *errorptr = true;
226
11.8k
      return EOF;
227
11.8k
    }
228
229
1.12M
  return (int) (c & 0xff);
230
1.13M
}
231
232
/* Report a problem in an S record file.  FIXME: This probably should
233
   not call fprintf, but we really do need some mechanism for printing
234
   error messages.  */
235
236
static void
237
srec_bad_byte (bfd *abfd,
238
         unsigned int lineno,
239
         int c,
240
         bool error)
241
6.48k
{
242
6.48k
  if (c == EOF)
243
3.41k
    {
244
3.41k
      if (! error)
245
1.98k
  bfd_set_error (bfd_error_file_truncated);
246
3.41k
    }
247
3.07k
  else
248
3.07k
    {
249
3.07k
      char buf[40];
250
251
3.07k
      if (! ISPRINT (c))
252
1.37k
  sprintf (buf, "\\%03o", (unsigned int) c & 0xff);
253
1.69k
      else
254
1.69k
  {
255
1.69k
    buf[0] = c;
256
1.69k
    buf[1] = '\0';
257
1.69k
  }
258
3.07k
      _bfd_error_handler
259
  /* xgettext:c-format */
260
3.07k
  (_("%pB:%d: unexpected character `%s' in S-record file"),
261
3.07k
   abfd, lineno, buf);
262
3.07k
      bfd_set_error (bfd_error_bad_value);
263
3.07k
    }
264
6.48k
}
265
266
/* Add a new symbol found in an S-record file.  */
267
268
static bool
269
srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)
270
16.8k
{
271
16.8k
  struct srec_symbol *n;
272
273
16.8k
  n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n));
274
16.8k
  if (n == NULL)
275
0
    return false;
276
277
16.8k
  n->name = name;
278
16.8k
  n->val = val;
279
280
16.8k
  if (abfd->tdata.srec_data->symbols == NULL)
281
5.33k
    abfd->tdata.srec_data->symbols = n;
282
11.5k
  else
283
11.5k
    abfd->tdata.srec_data->symtail->next = n;
284
16.8k
  abfd->tdata.srec_data->symtail = n;
285
16.8k
  n->next = NULL;
286
287
16.8k
  ++abfd->symcount;
288
289
16.8k
  return true;
290
16.8k
}
291
292
/* Read the S record file and turn it into sections.  We create a new
293
   section for each contiguous set of bytes.  */
294
295
static bool
296
srec_scan (bfd *abfd)
297
16.2k
{
298
16.2k
  int c;
299
16.2k
  unsigned int lineno = 1;
300
16.2k
  bool error = false;
301
16.2k
  bfd_byte *buf = NULL;
302
16.2k
  size_t bufsize = 0;
303
16.2k
  asection *sec = NULL;
304
16.2k
  char *symbuf = NULL;
305
306
16.2k
  if (bfd_seek (abfd, 0, SEEK_SET) != 0)
307
0
    goto error_return;
308
309
177k
  while ((c = srec_get_byte (abfd, &error)) != EOF)
310
169k
    {
311
      /* We only build sections from contiguous S-records, so if this
312
   is not an S-record, then stop building a section.  */
313
169k
      if (c != 'S' && c != '\r' && c != '\n')
314
46.4k
  sec = NULL;
315
316
169k
      switch (c)
317
169k
  {
318
1.39k
  default:
319
1.39k
    srec_bad_byte (abfd, lineno, c, error);
320
1.39k
    goto error_return;
321
322
105k
  case '\n':
323
105k
    ++lineno;
324
105k
    break;
325
326
6.31k
  case '\r':
327
6.31k
    break;
328
329
16.6k
  case '$':
330
    /* Starting a module name, which we ignore.  */
331
598k
    while ((c = srec_get_byte (abfd, &error)) != '\n'
332
598k
     && c != EOF)
333
581k
      ;
334
16.6k
    if (c == EOF)
335
1.03k
      {
336
1.03k
        srec_bad_byte (abfd, lineno, c, error);
337
1.03k
        goto error_return;
338
1.03k
      }
339
340
15.6k
    ++lineno;
341
15.6k
    break;
342
343
28.4k
  case ' ':
344
28.4k
    do
345
34.5k
      {
346
34.5k
        bfd_size_type alc;
347
34.5k
        char *p, *symname;
348
34.5k
        bfd_vma symval;
349
350
        /* Starting a symbol definition.  */
351
99.6k
        while ((c = srec_get_byte (abfd, &error)) != EOF
352
99.6k
         && (c == ' ' || c == '\t'))
353
65.1k
    ;
354
355
34.5k
        if (c == '\n' || c == '\r')
356
15.2k
    break;
357
358
19.2k
        if (c == EOF)
359
296
    {
360
296
      srec_bad_byte (abfd, lineno, c, error);
361
296
      goto error_return;
362
296
    }
363
364
18.9k
        alc = 10;
365
18.9k
        symbuf = (char *) bfd_malloc (alc + 1);
366
18.9k
        if (symbuf == NULL)
367
0
    goto error_return;
368
369
18.9k
        p = symbuf;
370
371
18.9k
        *p++ = c;
372
179k
        while ((c = srec_get_byte (abfd, &error)) != EOF
373
179k
         && ! ISSPACE (c))
374
160k
    {
375
160k
      if ((bfd_size_type) (p - symbuf) >= alc)
376
6.96k
        {
377
6.96k
          char *n;
378
379
6.96k
          alc *= 2;
380
6.96k
          n = (char *) bfd_realloc (symbuf, alc + 1);
381
6.96k
          if (n == NULL)
382
0
      goto error_return;
383
6.96k
          p = n + (p - symbuf);
384
6.96k
          symbuf = n;
385
6.96k
        }
386
387
160k
      *p++ = c;
388
160k
    }
389
390
18.9k
        if (c == EOF)
391
932
    {
392
932
      srec_bad_byte (abfd, lineno, c, error);
393
932
      goto error_return;
394
932
    }
395
396
18.0k
        *p++ = '\0';
397
18.0k
        symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
398
18.0k
        if (symname == NULL)
399
0
    goto error_return;
400
18.0k
        strcpy (symname, symbuf);
401
18.0k
        free (symbuf);
402
18.0k
        symbuf = NULL;
403
404
50.3k
        while ((c = srec_get_byte (abfd, &error)) != EOF
405
50.3k
         && (c == ' ' || c == '\t'))
406
32.2k
    ;
407
18.0k
        if (c == EOF)
408
371
    {
409
371
      srec_bad_byte (abfd, lineno, c, error);
410
371
      goto error_return;
411
371
    }
412
413
        /* Skip a dollar sign before the hex value.  */
414
17.6k
        if (c == '$')
415
3.97k
    {
416
3.97k
      c = srec_get_byte (abfd, &error);
417
3.97k
      if (c == EOF)
418
227
        {
419
227
          srec_bad_byte (abfd, lineno, c, error);
420
227
          goto error_return;
421
227
        }
422
3.97k
    }
423
424
17.4k
        symval = 0;
425
17.4k
        while (ISHEX (c))
426
24.7k
    {
427
24.7k
      symval <<= 4;
428
24.7k
      symval += NIBBLE (c);
429
24.7k
      c = srec_get_byte (abfd, &error);
430
24.7k
      if (c == EOF)
431
555
        {
432
555
          srec_bad_byte (abfd, lineno, c, error);
433
555
          goto error_return;
434
555
        }
435
24.7k
    }
436
437
16.8k
        if (! srec_new_symbol (abfd, symname, symval))
438
0
    goto error_return;
439
16.8k
      }
440
28.4k
    while (c == ' ' || c == '\t')
441
26.0k
      ;
442
443
26.0k
    if (c == '\n')
444
15.5k
      ++lineno;
445
10.5k
    else if (c != '\r')
446
595
      {
447
595
        srec_bad_byte (abfd, lineno, c, error);
448
595
        goto error_return;
449
595
      }
450
451
25.4k
    break;
452
453
25.4k
  case 'S':
454
10.4k
    {
455
10.4k
      file_ptr pos;
456
10.4k
      unsigned char hdr[3];
457
10.4k
      unsigned int bytes, min_bytes;
458
10.4k
      bfd_vma address;
459
10.4k
      bfd_byte *data;
460
10.4k
      unsigned char check_sum;
461
462
      /* Starting an S-record.  */
463
464
10.4k
      pos = bfd_tell (abfd) - 1;
465
466
10.4k
      if (bfd_read (hdr, 3, abfd) != 3)
467
128
        goto error_return;
468
469
10.2k
      if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
470
1.07k
        {
471
1.07k
    if (! ISHEX (hdr[1]))
472
647
      c = hdr[1];
473
432
    else
474
432
      c = hdr[2];
475
1.07k
    srec_bad_byte (abfd, lineno, c, error);
476
1.07k
    goto error_return;
477
1.07k
        }
478
479
9.22k
      check_sum = bytes = HEX (hdr + 1);
480
9.22k
      min_bytes = 3;
481
9.22k
      if (hdr[0] == '2' || hdr[0] == '8')
482
1.26k
        min_bytes = 4;
483
7.95k
      else if (hdr[0] == '3' || hdr[0] == '7')
484
1.00k
        min_bytes = 5;
485
9.22k
      if (bytes < min_bytes)
486
24
        {
487
    /* xgettext:c-format */
488
24
    _bfd_error_handler (_("%pB:%d: byte count %d too small"),
489
24
            abfd, lineno, bytes);
490
24
    bfd_set_error (bfd_error_bad_value);
491
24
    goto error_return;
492
24
        }
493
494
9.19k
      if (bytes * 2 > bufsize)
495
5.93k
        {
496
5.93k
    free (buf);
497
5.93k
    buf = bfd_malloc (bytes * 2);
498
5.93k
    if (buf == NULL)
499
0
      goto error_return;
500
5.93k
    bufsize = bytes * 2;
501
5.93k
        }
502
503
9.19k
      if (bfd_read (buf, bytes * 2, abfd) != bytes * 2)
504
611
        goto error_return;
505
506
      /* Ignore the checksum byte.  */
507
8.58k
      --bytes;
508
509
8.58k
      address = 0;
510
8.58k
      data = buf;
511
8.58k
      switch (hdr[0])
512
8.58k
        {
513
1.67k
        case '0':
514
2.43k
        case '5':
515
    /* Prologue--ignore the file name, but stop building a
516
       section at this point.  */
517
2.43k
    sec = NULL;
518
2.43k
    break;
519
520
973
        case '3':
521
973
    check_sum += HEX (data);
522
973
    address = HEX (data);
523
973
    data += 2;
524
973
    --bytes;
525
    /* Fall through.  */
526
1.90k
        case '2':
527
1.90k
    check_sum += HEX (data);
528
1.90k
    address = (address << 8) | HEX (data);
529
1.90k
    data += 2;
530
1.90k
    --bytes;
531
    /* Fall through.  */
532
3.29k
        case '1':
533
3.29k
    check_sum += HEX (data);
534
3.29k
    address = (address << 8) | HEX (data);
535
3.29k
    data += 2;
536
3.29k
    check_sum += HEX (data);
537
3.29k
    address = (address << 8) | HEX (data);
538
3.29k
    data += 2;
539
3.29k
    bytes -= 2;
540
541
3.29k
    if (sec != NULL
542
3.29k
        && sec->vma + sec->size == address)
543
1.12k
      {
544
        /* This data goes at the end of the section we are
545
           currently building.  */
546
1.12k
        sec->size += bytes;
547
1.12k
      }
548
2.17k
    else
549
2.17k
      {
550
2.17k
        char secbuf[20];
551
2.17k
        char *secname;
552
2.17k
        size_t amt;
553
2.17k
        flagword flags;
554
555
2.17k
        sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
556
2.17k
        amt = strlen (secbuf) + 1;
557
2.17k
        secname = (char *) bfd_alloc (abfd, amt);
558
2.17k
        strcpy (secname, secbuf);
559
2.17k
        flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
560
2.17k
        sec = bfd_make_section_with_flags (abfd, secname, flags);
561
2.17k
        if (sec == NULL)
562
0
          goto error_return;
563
2.17k
        sec->vma = address;
564
2.17k
        sec->lma = address;
565
2.17k
        sec->size = bytes;
566
2.17k
        sec->filepos = pos;
567
2.17k
      }
568
569
50.4k
    while (bytes > 0)
570
47.1k
      {
571
47.1k
        check_sum += HEX (data);
572
47.1k
        data += 2;
573
47.1k
        bytes--;
574
47.1k
      }
575
3.29k
    check_sum = 255 - (check_sum & 0xff);
576
3.29k
    if (check_sum != HEX (data))
577
414
      {
578
414
        _bfd_error_handler
579
          /* xgettext:c-format */
580
414
          (_("%pB:%d: bad checksum in S-record file"),
581
414
           abfd, lineno);
582
414
        bfd_set_error (bfd_error_bad_value);
583
414
        goto error_return;
584
414
      }
585
586
2.88k
    break;
587
588
2.88k
        case '7':
589
12
    check_sum += HEX (data);
590
12
    address = HEX (data);
591
12
    data += 2;
592
    /* Fall through.  */
593
122
        case '8':
594
122
    check_sum += HEX (data);
595
122
    address = (address << 8) | HEX (data);
596
122
    data += 2;
597
    /* Fall through.  */
598
134
        case '9':
599
134
    check_sum += HEX (data);
600
134
    address = (address << 8) | HEX (data);
601
134
    data += 2;
602
134
    check_sum += HEX (data);
603
134
    address = (address << 8) | HEX (data);
604
134
    data += 2;
605
606
    /* This is a termination record.  */
607
134
    abfd->start_address = address;
608
609
134
    check_sum = 255 - (check_sum & 0xff);
610
134
    if (check_sum != HEX (data))
611
129
      {
612
129
        _bfd_error_handler
613
          /* xgettext:c-format */
614
129
          (_("%pB:%d: bad checksum in S-record file"),
615
129
           abfd, lineno);
616
129
        bfd_set_error (bfd_error_bad_value);
617
129
        goto error_return;
618
129
      }
619
620
5
    free (buf);
621
5
    return true;
622
8.58k
        }
623
8.58k
    }
624
8.03k
    break;
625
169k
  }
626
169k
    }
627
628
8.47k
  if (error)
629
228
    goto error_return;
630
631
8.24k
  free (buf);
632
8.24k
  return true;
633
634
8.02k
 error_return:
635
8.02k
  free (symbuf);
636
8.02k
  free (buf);
637
8.02k
  return false;
638
8.47k
}
639
640
/* Check whether an existing file is an S-record file.  */
641
642
static bfd_cleanup
643
srec_object_p (bfd *abfd)
644
1.70M
{
645
1.70M
  void * tdata_save;
646
1.70M
  bfd_byte b[4];
647
648
1.70M
  srec_init ();
649
650
1.70M
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
651
1.70M
      || bfd_read (b, 4, abfd) != 4)
652
2.79k
    return NULL;
653
654
1.69M
  if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
655
1.69M
    {
656
1.69M
      bfd_set_error (bfd_error_wrong_format);
657
1.69M
      return NULL;
658
1.69M
    }
659
660
3.10k
  tdata_save = abfd->tdata.any;
661
3.10k
  if (! srec_mkobject (abfd) || ! srec_scan (abfd))
662
1.00k
    {
663
1.00k
      if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
664
1.00k
  bfd_release (abfd, abfd->tdata.any);
665
1.00k
      abfd->tdata.any = tdata_save;
666
1.00k
      return NULL;
667
1.00k
    }
668
669
2.09k
  if (abfd->symcount > 0)
670
512
    abfd->flags |= HAS_SYMS;
671
672
2.09k
  return _bfd_no_cleanup;
673
3.10k
}
674
675
/* Check whether an existing file is an S-record file with symbols.  */
676
677
static bfd_cleanup
678
symbolsrec_object_p (bfd *abfd)
679
1.70M
{
680
1.70M
  void * tdata_save;
681
1.70M
  char b[2];
682
683
1.70M
  srec_init ();
684
685
1.70M
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
686
1.70M
      || bfd_read (b, 2, abfd) != 2)
687
1.25k
    return NULL;
688
689
1.69M
  if (b[0] != '$' || b[1] != '$')
690
1.68M
    {
691
1.68M
      bfd_set_error (bfd_error_wrong_format);
692
1.68M
      return NULL;
693
1.68M
    }
694
695
13.1k
  tdata_save = abfd->tdata.any;
696
13.1k
  if (! srec_mkobject (abfd) || ! srec_scan (abfd))
697
7.01k
    {
698
7.01k
      if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
699
7.01k
  bfd_release (abfd, abfd->tdata.any);
700
7.01k
      abfd->tdata.any = tdata_save;
701
7.01k
      return NULL;
702
7.01k
    }
703
704
6.15k
  if (abfd->symcount > 0)
705
3.16k
    abfd->flags |= HAS_SYMS;
706
707
6.15k
  return _bfd_no_cleanup;
708
13.1k
}
709
710
/* Read in the contents of a section in an S-record file.  */
711
712
static bool
713
srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
714
2
{
715
2
  int c;
716
2
  bfd_size_type sofar = 0;
717
2
  bool error = false;
718
2
  bfd_byte *buf = NULL;
719
2
  size_t bufsize = 0;
720
721
2
  if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
722
0
    goto error_return;
723
724
4
  while ((c = srec_get_byte (abfd, &error)) != EOF)
725
2
    {
726
2
      bfd_byte hdr[3];
727
2
      unsigned int bytes;
728
2
      bfd_vma address;
729
2
      bfd_byte *data;
730
731
2
      if (c == '\r' || c == '\n')
732
0
  continue;
733
734
      /* This is called after srec_scan has already been called, so we
735
   ought to know the exact format.  */
736
2
      if (c != 'S')
737
0
  goto error_return;
738
739
2
      if (bfd_read (hdr, 3, abfd) != 3)
740
0
  goto error_return;
741
742
2
      BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
743
744
2
      bytes = HEX (hdr + 1);
745
746
2
      if (bytes * 2 > bufsize)
747
2
  {
748
2
    free (buf);
749
2
    buf = bfd_malloc (bytes * 2);
750
2
    if (buf == NULL)
751
0
      goto error_return;
752
2
    bufsize = bytes * 2;
753
2
  }
754
755
2
      if (bfd_read (buf, bytes * 2, abfd) != bytes * 2)
756
0
  goto error_return;
757
758
2
      address = 0;
759
2
      data = buf;
760
2
      switch (hdr[0])
761
2
  {
762
0
  default:
763
0
    if (sofar != section->size)
764
0
      goto error_return;
765
0
    free (buf);
766
0
    return true;
767
768
0
  case '3':
769
0
    address = HEX (data);
770
0
    data += 2;
771
0
    --bytes;
772
    /* Fall through.  */
773
0
  case '2':
774
0
    address = (address << 8) | HEX (data);
775
0
    data += 2;
776
0
    --bytes;
777
    /* Fall through.  */
778
2
  case '1':
779
2
    address = (address << 8) | HEX (data);
780
2
    data += 2;
781
2
    address = (address << 8) | HEX (data);
782
2
    data += 2;
783
2
    bytes -= 2;
784
785
2
    if (address != section->vma + sofar)
786
0
      {
787
        /* We've come to the end of this section.  */
788
0
        if (sofar != section->size)
789
0
    goto error_return;
790
0
        free (buf);
791
0
        return true;
792
0
      }
793
794
    /* Don't consider checksum.  */
795
2
    --bytes;
796
797
7
    while (bytes-- != 0)
798
5
      {
799
5
        contents[sofar] = HEX (data);
800
5
        data += 2;
801
5
        ++sofar;
802
5
      }
803
804
2
    break;
805
2
  }
806
2
    }
807
808
2
  if (error)
809
0
    goto error_return;
810
811
2
  if (sofar != section->size)
812
0
    goto error_return;
813
814
2
  free (buf);
815
2
  return true;
816
817
0
 error_return:
818
0
  free (buf);
819
0
  return false;
820
2
}
821
822
/* Get the contents of a section in an S-record file.  */
823
824
static bool
825
srec_get_section_contents (bfd *abfd,
826
         asection *section,
827
         void * location,
828
         file_ptr offset,
829
         bfd_size_type count)
830
2
{
831
2
  if (count == 0)
832
0
    return true;
833
834
2
  if (offset + count < count
835
2
      || offset + count > section->size)
836
0
    {
837
0
      bfd_set_error (bfd_error_invalid_operation);
838
0
      return false;
839
0
    }
840
841
2
  if (section->used_by_bfd == NULL)
842
2
    {
843
2
      section->used_by_bfd = bfd_alloc (abfd, section->size);
844
2
      if (section->used_by_bfd == NULL)
845
0
  return false;
846
847
2
      if (! srec_read_section (abfd, section,
848
2
             (bfd_byte *) section->used_by_bfd))
849
0
  return false;
850
2
    }
851
852
2
  memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
853
2
    (size_t) count);
854
855
2
  return true;
856
2
}
857
858
/* Set the architecture.  We accept an unknown architecture here.  */
859
860
static bool
861
srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
862
0
{
863
0
  if (arch != bfd_arch_unknown)
864
0
    return bfd_default_set_arch_mach (abfd, arch, mach);
865
866
0
  abfd->arch_info = & bfd_default_arch_struct;
867
0
  return true;
868
0
}
869
870
/* We have to save up all the Srecords for a splurge before output.  */
871
872
static bool
873
srec_set_section_contents (bfd *abfd,
874
         sec_ptr section,
875
         const void * location,
876
         file_ptr offset,
877
         bfd_size_type bytes_to_do)
878
0
{
879
0
  int opb = bfd_octets_per_byte (abfd, NULL);
880
0
  tdata_type *tdata = abfd->tdata.srec_data;
881
0
  srec_data_list_type *entry;
882
883
0
  entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
884
0
  if (entry == NULL)
885
0
    return false;
886
887
0
  if (bytes_to_do
888
0
      && (section->flags & SEC_ALLOC)
889
0
      && (section->flags & SEC_LOAD))
890
0
    {
891
0
      bfd_byte *data;
892
893
0
      data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
894
0
      if (data == NULL)
895
0
  return false;
896
0
      memcpy ((void *) data, location, (size_t) bytes_to_do);
897
898
      /* If _bfd_srec_forceS3 is TRUE then always select S3 records,
899
   regardless of the size of the addresses.  */
900
0
      if (_bfd_srec_forceS3)
901
0
  tdata->type = 3;
902
0
      else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffff)
903
0
  ;  /* The default, S1, is OK.  */
904
0
      else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffffff
905
0
         && tdata->type <= 2)
906
0
  tdata->type = 2;
907
0
      else
908
0
  tdata->type = 3;
909
910
0
      entry->data = data;
911
0
      entry->where = section->lma + offset / opb;
912
0
      entry->size = bytes_to_do;
913
914
      /* Sort the records by address.  Optimize for the common case of
915
   adding a record to the end of the list.  */
916
0
      if (tdata->tail != NULL
917
0
    && entry->where >= tdata->tail->where)
918
0
  {
919
0
    tdata->tail->next = entry;
920
0
    entry->next = NULL;
921
0
    tdata->tail = entry;
922
0
  }
923
0
      else
924
0
  {
925
0
    srec_data_list_type **look;
926
927
0
    for (look = &tdata->head;
928
0
         *look != NULL && (*look)->where < entry->where;
929
0
         look = &(*look)->next)
930
0
      ;
931
0
    entry->next = *look;
932
0
    *look = entry;
933
0
    if (entry->next == NULL)
934
0
      tdata->tail = entry;
935
0
  }
936
0
    }
937
0
  return true;
938
0
}
939
940
/* Write a record of type, of the supplied number of bytes. The
941
   supplied bytes and length don't have a checksum. That's worked out
942
   here.  */
943
944
static bool
945
srec_write_record (bfd *abfd,
946
       unsigned int type,
947
       bfd_vma address,
948
       const bfd_byte *data,
949
       const bfd_byte *end)
950
0
{
951
0
  char buffer[2 * MAXCHUNK + 6];
952
0
  unsigned int check_sum = 0;
953
0
  const bfd_byte *src = data;
954
0
  char *dst = buffer;
955
0
  char *length;
956
0
  bfd_size_type wrlen;
957
958
0
  *dst++ = 'S';
959
0
  *dst++ = '0' + type;
960
961
0
  length = dst;
962
0
  dst += 2;     /* Leave room for dst.  */
963
964
0
  switch (type)
965
0
    {
966
0
    case 3:
967
0
    case 7:
968
0
      TOHEX (dst, (address >> 24), check_sum);
969
0
      dst += 2;
970
      /* Fall through.  */
971
0
    case 8:
972
0
    case 2:
973
0
      TOHEX (dst, (address >> 16), check_sum);
974
0
      dst += 2;
975
      /* Fall through.  */
976
0
    case 9:
977
0
    case 1:
978
0
    case 0:
979
0
      TOHEX (dst, (address >> 8), check_sum);
980
0
      dst += 2;
981
0
      TOHEX (dst, (address), check_sum);
982
0
      dst += 2;
983
0
      break;
984
985
0
    }
986
0
  for (src = data; src < end; src++)
987
0
    {
988
0
      TOHEX (dst, *src, check_sum);
989
0
      dst += 2;
990
0
    }
991
992
  /* Fill in the length.  */
993
0
  TOHEX (length, (dst - length) / 2, check_sum);
994
0
  check_sum &= 0xff;
995
0
  check_sum = 255 - check_sum;
996
0
  TOHEX (dst, check_sum, check_sum);
997
0
  dst += 2;
998
999
0
  *dst++ = '\r';
1000
0
  *dst++ = '\n';
1001
0
  wrlen = dst - buffer;
1002
1003
0
  return bfd_write (buffer, wrlen, abfd) == wrlen;
1004
0
}
1005
1006
static bool
1007
srec_write_header (bfd *abfd)
1008
0
{
1009
0
  unsigned int len = strlen (bfd_get_filename (abfd));
1010
1011
  /* I'll put an arbitrary 40 char limit on header size.  */
1012
0
  if (len > 40)
1013
0
    len = 40;
1014
1015
0
  return srec_write_record (abfd, 0, (bfd_vma) 0,
1016
0
          (bfd_byte *) bfd_get_filename (abfd),
1017
0
          (bfd_byte *) bfd_get_filename (abfd) + len);
1018
0
}
1019
1020
static bool
1021
srec_write_section (bfd *abfd,
1022
        tdata_type *tdata,
1023
        srec_data_list_type *list)
1024
0
{
1025
0
  unsigned int octets_written = 0;
1026
0
  bfd_byte *location = list->data;
1027
1028
  /* Validate number of data bytes to write.  The srec length byte
1029
     counts the address, data and crc bytes.  S1 (tdata->type == 1)
1030
     records have two address bytes, S2 (tdata->type == 2) records
1031
     have three, and S3 (tdata->type == 3) records have four.
1032
     The total length can't exceed 255, and a zero data length will
1033
     spin for a long time.  */
1034
0
  if (_bfd_srec_len == 0)
1035
0
    _bfd_srec_len = 1;
1036
0
  else if (_bfd_srec_len > MAXCHUNK - tdata->type - 2)
1037
0
    _bfd_srec_len = MAXCHUNK - tdata->type - 2;
1038
1039
0
  while (octets_written < list->size)
1040
0
    {
1041
0
      bfd_vma address;
1042
0
      unsigned int octets_this_chunk = list->size - octets_written;
1043
1044
0
      if (octets_this_chunk > _bfd_srec_len)
1045
0
  octets_this_chunk = _bfd_srec_len;
1046
1047
0
      address = list->where + (octets_written
1048
0
             / bfd_octets_per_byte (abfd, NULL));
1049
1050
0
      if (! srec_write_record (abfd,
1051
0
             tdata->type,
1052
0
             address,
1053
0
             location,
1054
0
             location + octets_this_chunk))
1055
0
  return false;
1056
1057
0
      octets_written += octets_this_chunk;
1058
0
      location += octets_this_chunk;
1059
0
    }
1060
1061
0
  return true;
1062
0
}
1063
1064
static bool
1065
srec_write_terminator (bfd *abfd, tdata_type *tdata)
1066
0
{
1067
0
  return srec_write_record (abfd, 10 - tdata->type,
1068
0
          abfd->start_address, NULL, NULL);
1069
0
}
1070
1071
static bool
1072
srec_write_symbols (bfd *abfd)
1073
0
{
1074
  /* Dump out the symbols of a bfd.  */
1075
0
  int i;
1076
0
  int count = bfd_get_symcount (abfd);
1077
1078
0
  if (count)
1079
0
    {
1080
0
      bfd_size_type len;
1081
0
      asymbol **table = bfd_get_outsymbols (abfd);
1082
1083
0
      len = strlen (bfd_get_filename (abfd));
1084
0
      if (bfd_write ("$$ ", 3, abfd) != 3
1085
0
    || bfd_write (bfd_get_filename (abfd), len, abfd) != len
1086
0
    || bfd_write ("\r\n", 2, abfd) != 2)
1087
0
  return false;
1088
1089
0
      for (i = 0; i < count; i++)
1090
0
  {
1091
0
    asymbol *s = table[i];
1092
1093
0
    if (! bfd_is_local_label (abfd, s)
1094
0
        && (s->flags & BSF_DEBUGGING) == 0
1095
0
        && s->section != NULL
1096
0
        && s->section->output_section != NULL)
1097
0
      {
1098
        /* Just dump out non debug symbols.  */
1099
0
        char buf[43];
1100
1101
0
        len = strlen (s->name);
1102
0
        if (bfd_write ("  ", 2, abfd) != 2
1103
0
      || bfd_write (s->name, len, abfd) != len)
1104
0
    return false;
1105
1106
0
        sprintf (buf, " $%" PRIx64 "\r\n",
1107
0
           (uint64_t) (s->value
1108
0
           + s->section->output_section->lma
1109
0
           + s->section->output_offset));
1110
0
        len = strlen (buf);
1111
0
        if (bfd_write (buf, len, abfd) != len)
1112
0
    return false;
1113
0
      }
1114
0
  }
1115
0
      if (bfd_write ("$$ \r\n", 5, abfd) != 5)
1116
0
  return false;
1117
0
    }
1118
1119
0
  return true;
1120
0
}
1121
1122
static bool
1123
internal_srec_write_object_contents (bfd *abfd, int symbols)
1124
0
{
1125
0
  tdata_type *tdata = abfd->tdata.srec_data;
1126
0
  srec_data_list_type *list;
1127
1128
0
  if (symbols)
1129
0
    {
1130
0
      if (! srec_write_symbols (abfd))
1131
0
  return false;
1132
0
    }
1133
1134
0
  if (! srec_write_header (abfd))
1135
0
    return false;
1136
1137
  /* Now wander though all the sections provided and output them.  */
1138
0
  list = tdata->head;
1139
1140
0
  while (list != (srec_data_list_type *) NULL)
1141
0
    {
1142
0
      if (! srec_write_section (abfd, tdata, list))
1143
0
  return false;
1144
0
      list = list->next;
1145
0
    }
1146
0
  return srec_write_terminator (abfd, tdata);
1147
0
}
1148
1149
static bool
1150
srec_write_object_contents (bfd *abfd)
1151
0
{
1152
0
  return internal_srec_write_object_contents (abfd, 0);
1153
0
}
1154
1155
static bool
1156
symbolsrec_write_object_contents (bfd *abfd)
1157
0
{
1158
0
  return internal_srec_write_object_contents (abfd, 1);
1159
0
}
1160
1161
static int
1162
srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1163
         struct bfd_link_info *info ATTRIBUTE_UNUSED)
1164
0
{
1165
0
  return 0;
1166
0
}
1167
1168
/* Return the amount of memory needed to read the symbol table.  */
1169
1170
static long
1171
srec_get_symtab_upper_bound (bfd *abfd)
1172
127
{
1173
127
  return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1174
127
}
1175
1176
/* Return the symbol table.  */
1177
1178
static long
1179
srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1180
127
{
1181
127
  bfd_size_type symcount = bfd_get_symcount (abfd);
1182
127
  asymbol *csymbols;
1183
127
  unsigned int i;
1184
1185
127
  csymbols = abfd->tdata.srec_data->csymbols;
1186
127
  if (csymbols == NULL && symcount != 0)
1187
87
    {
1188
87
      asymbol *c;
1189
87
      struct srec_symbol *s;
1190
1191
87
      csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
1192
87
      if (csymbols == NULL)
1193
0
  return -1;
1194
87
      abfd->tdata.srec_data->csymbols = csymbols;
1195
1196
87
      for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1197
1.74k
     s != NULL;
1198
1.66k
     s = s->next, ++c)
1199
1.66k
  {
1200
1.66k
    c->the_bfd = abfd;
1201
1.66k
    c->name = s->name;
1202
1.66k
    c->value = s->val;
1203
1.66k
    c->flags = BSF_GLOBAL;
1204
1.66k
    c->section = bfd_abs_section_ptr;
1205
1.66k
    c->udata.p = NULL;
1206
1.66k
  }
1207
87
    }
1208
1209
2.26k
  for (i = 0; i < symcount; i++)
1210
2.14k
    *alocation++ = csymbols++;
1211
127
  *alocation = NULL;
1212
1213
127
  return symcount;
1214
127
}
1215
1216
static void
1217
srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1218
          asymbol *symbol,
1219
          symbol_info *ret)
1220
479
{
1221
479
  bfd_symbol_info (symbol, ret);
1222
479
}
1223
1224
static void
1225
srec_print_symbol (bfd *abfd,
1226
       void * afile,
1227
       asymbol *symbol,
1228
       bfd_print_symbol_type how)
1229
0
{
1230
0
  FILE *file = (FILE *) afile;
1231
1232
0
  switch (how)
1233
0
    {
1234
0
    case bfd_print_symbol_name:
1235
0
      fprintf (file, "%s", symbol->name);
1236
0
      break;
1237
0
    default:
1238
0
      bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1239
0
      fprintf (file, " %-5s %s",
1240
0
         symbol->section->name,
1241
0
         symbol->name);
1242
0
    }
1243
0
}
1244
1245
#define srec_close_and_cleanup        _bfd_generic_close_and_cleanup
1246
#define srec_bfd_free_cached_info     _bfd_generic_bfd_free_cached_info
1247
#define srec_new_section_hook       _bfd_generic_new_section_hook
1248
#define srec_bfd_is_target_special_symbol   _bfd_bool_bfd_asymbol_false
1249
#define srec_bfd_is_local_label_name      bfd_generic_is_local_label_name
1250
#define srec_get_lineno         _bfd_nosymbols_get_lineno
1251
#define srec_find_nearest_line        _bfd_nosymbols_find_nearest_line
1252
#define srec_find_nearest_line_with_alt     _bfd_nosymbols_find_nearest_line_with_alt
1253
#define srec_find_line          _bfd_nosymbols_find_line
1254
#define srec_find_inliner_info        _bfd_nosymbols_find_inliner_info
1255
#define srec_make_empty_symbol        _bfd_generic_make_empty_symbol
1256
#define srec_get_symbol_version_string      _bfd_nosymbols_get_symbol_version_string
1257
#define srec_bfd_make_debug_symbol      _bfd_nosymbols_bfd_make_debug_symbol
1258
#define srec_read_minisymbols       _bfd_generic_read_minisymbols
1259
#define srec_minisymbol_to_symbol     _bfd_generic_minisymbol_to_symbol
1260
#define srec_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
1261
#define srec_bfd_relax_section        bfd_generic_relax_section
1262
#define srec_bfd_gc_sections        bfd_generic_gc_sections
1263
#define srec_bfd_lookup_section_flags     bfd_generic_lookup_section_flags
1264
#define srec_bfd_merge_sections       bfd_generic_merge_sections
1265
#define srec_bfd_is_group_section     bfd_generic_is_group_section
1266
#define srec_bfd_group_name       bfd_generic_group_name
1267
#define srec_bfd_discard_group        bfd_generic_discard_group
1268
#define srec_section_already_linked     _bfd_generic_section_already_linked
1269
#define srec_bfd_define_common_symbol     bfd_generic_define_common_symbol
1270
#define srec_bfd_link_hide_symbol     _bfd_generic_link_hide_symbol
1271
#define srec_bfd_define_start_stop      bfd_generic_define_start_stop
1272
#define srec_bfd_link_hash_table_create     _bfd_generic_link_hash_table_create
1273
#define srec_bfd_link_add_symbols     _bfd_generic_link_add_symbols
1274
#define srec_bfd_link_just_syms       _bfd_generic_link_just_syms
1275
#define srec_bfd_copy_link_hash_symbol_type   _bfd_generic_copy_link_hash_symbol_type
1276
#define srec_bfd_final_link       _bfd_generic_final_link
1277
#define srec_bfd_link_split_section     _bfd_generic_link_split_section
1278
#define srec_bfd_link_check_relocs      _bfd_generic_link_check_relocs
1279
1280
const bfd_target srec_vec =
1281
{
1282
  "srec",     /* Name.  */
1283
  bfd_target_srec_flavour,
1284
  BFD_ENDIAN_UNKNOWN,   /* Target byte order.  */
1285
  BFD_ENDIAN_UNKNOWN,   /* Target headers byte order.  */
1286
  (HAS_RELOC | EXEC_P |   /* Object flags.  */
1287
   HAS_LINENO | HAS_DEBUG |
1288
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1289
  (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1290
   | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
1291
  0,        /* Leading underscore.  */
1292
  ' ',        /* AR_pad_char.  */
1293
  16,       /* AR_max_namelen.  */
1294
  0,        /* match priority.  */
1295
  TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
1296
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1297
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1298
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data.  */
1299
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1300
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1301
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs.  */
1302
1303
  {
1304
    _bfd_dummy_target,
1305
    srec_object_p,    /* bfd_check_format.  */
1306
    _bfd_dummy_target,
1307
    _bfd_dummy_target,
1308
  },
1309
  {
1310
    _bfd_bool_bfd_false_error,
1311
    srec_mkobject,
1312
    _bfd_generic_mkarchive,
1313
    _bfd_bool_bfd_false_error,
1314
  },
1315
  {       /* bfd_write_contents.  */
1316
    _bfd_bool_bfd_false_error,
1317
    srec_write_object_contents,
1318
    _bfd_write_archive_contents,
1319
    _bfd_bool_bfd_false_error,
1320
  },
1321
1322
  BFD_JUMP_TABLE_GENERIC (srec),
1323
  BFD_JUMP_TABLE_COPY (_bfd_generic),
1324
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
1325
  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1326
  BFD_JUMP_TABLE_SYMBOLS (srec),
1327
  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1328
  BFD_JUMP_TABLE_WRITE (srec),
1329
  BFD_JUMP_TABLE_LINK (srec),
1330
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1331
1332
  NULL,
1333
1334
  NULL
1335
};
1336
1337
const bfd_target symbolsrec_vec =
1338
{
1339
  "symbolsrec",     /* Name.  */
1340
  bfd_target_srec_flavour,
1341
  BFD_ENDIAN_UNKNOWN,   /* Target byte order.  */
1342
  BFD_ENDIAN_UNKNOWN,   /* Target headers byte order.  */
1343
  (HAS_RELOC | EXEC_P |   /* Object flags.  */
1344
   HAS_LINENO | HAS_DEBUG |
1345
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1346
  (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1347
   | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
1348
  0,        /* Leading underscore.  */
1349
  ' ',        /* AR_pad_char.  */
1350
  16,       /* AR_max_namelen.  */
1351
  0,        /* match priority.  */
1352
  TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
1353
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1354
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1355
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data.  */
1356
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1357
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1358
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers.  */
1359
1360
  {
1361
    _bfd_dummy_target,
1362
    symbolsrec_object_p,  /* bfd_check_format.  */
1363
    _bfd_dummy_target,
1364
    _bfd_dummy_target,
1365
  },
1366
  {
1367
    _bfd_bool_bfd_false_error,
1368
    srec_mkobject,
1369
    _bfd_generic_mkarchive,
1370
    _bfd_bool_bfd_false_error,
1371
  },
1372
  {       /* bfd_write_contents.  */
1373
    _bfd_bool_bfd_false_error,
1374
    symbolsrec_write_object_contents,
1375
    _bfd_write_archive_contents,
1376
    _bfd_bool_bfd_false_error,
1377
  },
1378
1379
  BFD_JUMP_TABLE_GENERIC (srec),
1380
  BFD_JUMP_TABLE_COPY (_bfd_generic),
1381
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
1382
  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1383
  BFD_JUMP_TABLE_SYMBOLS (srec),
1384
  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1385
  BFD_JUMP_TABLE_WRITE (srec),
1386
  BFD_JUMP_TABLE_LINK (srec),
1387
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1388
1389
  NULL,
1390
1391
  NULL
1392
};