1 /* BFD back-end for s-record objects.
2 Copyright (C) 1990-2016 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 Ordinary S-Records cannot hold anything but addresses and
29 data, so that's all that we implement.
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".
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
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.
44 An s record looks like:
47 S<type><length><address><data><checksum>
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.
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
66 is the start address of the data following, or in the case of
67 a termination record, the start address of the image
71 is the sum of all the raw byte data in the record, from the length
72 upwards, modulo 256 and subtracted from 255.
75 Symbol S-Record handling
78 Some ICE equipment understands an addition to the standard
79 S-Record format; symbols and their addresses can be sent
82 The format of this is:
84 (<space> <symbol> <address>)*)
87 so a short symbol table could look like:
101 We allow symbols to be anywhere in the data stream - the module names
102 are always ignored. */
107 #include "libiberty.h"
108 #include "safe-ctype.h"
111 /* Macros for converting between hex and binary. */
113 static const char digs
[] = "0123456789ABCDEF";
115 #define NIBBLE(x) hex_value(x)
116 #define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1]))
117 #define TOHEX(d, x, ch) \
118 d[1] = digs[(x) & 0xf]; \
119 d[0] = digs[((x)>>4)&0xf]; \
121 #define ISHEX(x) hex_p(x)
123 /* The maximum number of address+data+crc bytes on a line is FF. */
124 #define MAXCHUNK 0xff
126 /* Default size for a CHUNK. */
127 #define DEFAULT_CHUNK 16
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 Chunk
= DEFAULT_CHUNK
;
134 /* The type of srec output (free or forced to S3).
135 This variable can be modified by objcopy's --srec-forceS3
137 bfd_boolean S3Forced
= FALSE
;
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. */
142 struct srec_data_list_struct
144 struct srec_data_list_struct
*next
;
150 typedef struct srec_data_list_struct srec_data_list_type
;
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
158 struct srec_symbol
*next
;
163 /* The S-record tdata information. */
165 typedef struct srec_data_struct
167 srec_data_list_type
*head
;
168 srec_data_list_type
*tail
;
170 struct srec_symbol
*symbols
;
171 struct srec_symbol
*symtail
;
176 /* Initialize by filling in the hex conversion array. */
181 static bfd_boolean inited
= FALSE
;
190 /* Set up the S-record tdata information. */
193 srec_mkobject (bfd
*abfd
)
199 tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
203 abfd
->tdata
.srec_data
= tdata
;
207 tdata
->symbols
= NULL
;
208 tdata
->symtail
= NULL
;
209 tdata
->csymbols
= NULL
;
214 /* Read a byte from an S record file. Set *ERRORPTR if an error
215 occurred. Return EOF on error or end of file. */
218 srec_get_byte (bfd
*abfd
, bfd_boolean
*errorptr
)
222 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) != 1)
224 if (bfd_get_error () != bfd_error_file_truncated
)
229 return (int) (c
& 0xff);
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
237 srec_bad_byte (bfd
*abfd
,
245 bfd_set_error (bfd_error_file_truncated
);
252 sprintf (buf
, "\\%03o", (unsigned int) c
& 0xff);
259 (_("%B:%d: Unexpected character `%s' in S-record file\n"),
261 bfd_set_error (bfd_error_bad_value
);
265 /* Add a new symbol found in an S-record file. */
268 srec_new_symbol (bfd
*abfd
, const char *name
, bfd_vma val
)
270 struct srec_symbol
*n
;
272 n
= (struct srec_symbol
*) bfd_alloc (abfd
, sizeof (* n
));
279 if (abfd
->tdata
.srec_data
->symbols
== NULL
)
280 abfd
->tdata
.srec_data
->symbols
= n
;
282 abfd
->tdata
.srec_data
->symtail
->next
= n
;
283 abfd
->tdata
.srec_data
->symtail
= n
;
291 /* Read the S record file and turn it into sections. We create a new
292 section for each contiguous set of bytes. */
295 srec_scan (bfd
*abfd
)
298 unsigned int lineno
= 1;
299 bfd_boolean error
= FALSE
;
300 bfd_byte
*buf
= NULL
;
302 asection
*sec
= NULL
;
305 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
308 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
)
310 /* We only build sections from contiguous S-records, so if this
311 is not an S-record, then stop building a section. */
312 if (c
!= 'S' && c
!= '\r' && c
!= '\n')
318 srec_bad_byte (abfd
, lineno
, c
, error
);
329 /* Starting a module name, which we ignore. */
330 while ((c
= srec_get_byte (abfd
, &error
)) != '\n'
335 srec_bad_byte (abfd
, lineno
, c
, error
);
349 /* Starting a symbol definition. */
350 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
351 && (c
== ' ' || c
== '\t'))
354 if (c
== '\n' || c
== '\r')
359 srec_bad_byte (abfd
, lineno
, c
, error
);
364 symbuf
= (char *) bfd_malloc (alc
+ 1);
371 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
374 if ((bfd_size_type
) (p
- symbuf
) >= alc
)
379 n
= (char *) bfd_realloc (symbuf
, alc
+ 1);
382 p
= n
+ (p
- symbuf
);
391 srec_bad_byte (abfd
, lineno
, c
, error
);
396 symname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) (p
- symbuf
));
399 strcpy (symname
, symbuf
);
403 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
404 && (c
== ' ' || c
== '\t'))
408 srec_bad_byte (abfd
, lineno
, c
, error
);
412 /* Skip a dollar sign before the hex value. */
415 c
= srec_get_byte (abfd
, &error
);
418 srec_bad_byte (abfd
, lineno
, c
, error
);
427 symval
+= NIBBLE (c
);
428 c
= srec_get_byte (abfd
, &error
);
431 srec_bad_byte (abfd
, lineno
, c
, error
);
436 if (! srec_new_symbol (abfd
, symname
, symval
))
439 while (c
== ' ' || c
== '\t')
446 srec_bad_byte (abfd
, lineno
, c
, error
);
455 unsigned char hdr
[3];
456 unsigned int bytes
, min_bytes
;
459 unsigned char check_sum
;
461 /* Starting an S-record. */
463 pos
= bfd_tell (abfd
) - 1;
465 if (bfd_bread (hdr
, (bfd_size_type
) 3, abfd
) != 3)
468 if (! ISHEX (hdr
[1]) || ! ISHEX (hdr
[2]))
470 if (! ISHEX (hdr
[1]))
474 srec_bad_byte (abfd
, lineno
, c
, error
);
478 check_sum
= bytes
= HEX (hdr
+ 1);
480 if (hdr
[0] == '2' || hdr
[0] == '8')
482 else if (hdr
[0] == '3' || hdr
[0] == '7')
484 if (bytes
< min_bytes
)
486 _bfd_error_handler (_("%B:%d: byte count %d too small\n"),
487 abfd
, lineno
, bytes
);
488 bfd_set_error (bfd_error_bad_value
);
492 if (bytes
* 2 > bufsize
)
496 buf
= (bfd_byte
*) bfd_malloc ((bfd_size_type
) bytes
* 2);
502 if (bfd_bread (buf
, (bfd_size_type
) bytes
* 2, abfd
) != bytes
* 2)
505 /* Ignore the checksum byte. */
514 /* Prologue--ignore the file name, but stop building a
515 section at this point. */
520 check_sum
+= HEX (data
);
521 address
= HEX (data
);
526 check_sum
+= HEX (data
);
527 address
= (address
<< 8) | HEX (data
);
532 check_sum
+= HEX (data
);
533 address
= (address
<< 8) | HEX (data
);
535 check_sum
+= HEX (data
);
536 address
= (address
<< 8) | HEX (data
);
541 && sec
->vma
+ sec
->size
== address
)
543 /* This data goes at the end of the section we are
544 currently building. */
554 sprintf (secbuf
, ".sec%d", bfd_count_sections (abfd
) + 1);
555 amt
= strlen (secbuf
) + 1;
556 secname
= (char *) bfd_alloc (abfd
, amt
);
557 strcpy (secname
, secbuf
);
558 flags
= SEC_HAS_CONTENTS
| SEC_LOAD
| SEC_ALLOC
;
559 sec
= bfd_make_section_with_flags (abfd
, secname
, flags
);
570 check_sum
+= HEX (data
);
574 check_sum
= 255 - (check_sum
& 0xff);
575 if (check_sum
!= HEX (data
))
578 (_("%B:%d: Bad checksum in S-record file\n"),
580 bfd_set_error (bfd_error_bad_value
);
587 check_sum
+= HEX (data
);
588 address
= HEX (data
);
592 check_sum
+= HEX (data
);
593 address
= (address
<< 8) | HEX (data
);
597 check_sum
+= HEX (data
);
598 address
= (address
<< 8) | HEX (data
);
600 check_sum
+= HEX (data
);
601 address
= (address
<< 8) | HEX (data
);
604 /* This is a termination record. */
605 abfd
->start_address
= address
;
607 check_sum
= 255 - (check_sum
& 0xff);
608 if (check_sum
!= HEX (data
))
611 (_("%B:%d: Bad checksum in S-record file\n"),
613 bfd_set_error (bfd_error_bad_value
);
643 /* Check whether an existing file is an S-record file. */
645 static const bfd_target
*
646 srec_object_p (bfd
*abfd
)
653 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
654 || bfd_bread (b
, (bfd_size_type
) 4, abfd
) != 4)
657 if (b
[0] != 'S' || !ISHEX (b
[1]) || !ISHEX (b
[2]) || !ISHEX (b
[3]))
659 bfd_set_error (bfd_error_wrong_format
);
663 tdata_save
= abfd
->tdata
.any
;
664 if (! srec_mkobject (abfd
) || ! srec_scan (abfd
))
666 if (abfd
->tdata
.any
!= tdata_save
&& abfd
->tdata
.any
!= NULL
)
667 bfd_release (abfd
, abfd
->tdata
.any
);
668 abfd
->tdata
.any
= tdata_save
;
672 if (abfd
->symcount
> 0)
673 abfd
->flags
|= HAS_SYMS
;
678 /* Check whether an existing file is an S-record file with symbols. */
680 static const bfd_target
*
681 symbolsrec_object_p (bfd
*abfd
)
688 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
689 || bfd_bread (b
, (bfd_size_type
) 2, abfd
) != 2)
692 if (b
[0] != '$' || b
[1] != '$')
694 bfd_set_error (bfd_error_wrong_format
);
698 tdata_save
= abfd
->tdata
.any
;
699 if (! srec_mkobject (abfd
) || ! srec_scan (abfd
))
701 if (abfd
->tdata
.any
!= tdata_save
&& abfd
->tdata
.any
!= NULL
)
702 bfd_release (abfd
, abfd
->tdata
.any
);
703 abfd
->tdata
.any
= tdata_save
;
707 if (abfd
->symcount
> 0)
708 abfd
->flags
|= HAS_SYMS
;
713 /* Read in the contents of a section in an S-record file. */
716 srec_read_section (bfd
*abfd
, asection
*section
, bfd_byte
*contents
)
719 bfd_size_type sofar
= 0;
720 bfd_boolean error
= FALSE
;
721 bfd_byte
*buf
= NULL
;
724 if (bfd_seek (abfd
, section
->filepos
, SEEK_SET
) != 0)
727 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
)
734 if (c
== '\r' || c
== '\n')
737 /* This is called after srec_scan has already been called, so we
738 ought to know the exact format. */
739 BFD_ASSERT (c
== 'S');
741 if (bfd_bread (hdr
, (bfd_size_type
) 3, abfd
) != 3)
744 BFD_ASSERT (ISHEX (hdr
[1]) && ISHEX (hdr
[2]));
746 bytes
= HEX (hdr
+ 1);
748 if (bytes
* 2 > bufsize
)
752 buf
= (bfd_byte
*) bfd_malloc ((bfd_size_type
) bytes
* 2);
758 if (bfd_bread (buf
, (bfd_size_type
) bytes
* 2, abfd
) != bytes
* 2)
766 BFD_ASSERT (sofar
== section
->size
);
772 address
= HEX (data
);
777 address
= (address
<< 8) | HEX (data
);
782 address
= (address
<< 8) | HEX (data
);
784 address
= (address
<< 8) | HEX (data
);
788 if (address
!= section
->vma
+ sofar
)
790 /* We've come to the end of this section. */
791 BFD_ASSERT (sofar
== section
->size
);
797 /* Don't consider checksum. */
802 contents
[sofar
] = HEX (data
);
814 BFD_ASSERT (sofar
== section
->size
);
827 /* Get the contents of a section in an S-record file. */
830 srec_get_section_contents (bfd
*abfd
,
839 if (offset
+ count
< count
840 || offset
+ count
> section
->size
)
842 bfd_set_error (bfd_error_invalid_operation
);
846 if (section
->used_by_bfd
== NULL
)
848 section
->used_by_bfd
= bfd_alloc (abfd
, section
->size
);
849 if (section
->used_by_bfd
== NULL
)
852 if (! srec_read_section (abfd
, section
,
853 (bfd_byte
*) section
->used_by_bfd
))
857 memcpy (location
, (bfd_byte
*) section
->used_by_bfd
+ offset
,
863 /* Set the architecture. We accept an unknown architecture here. */
866 srec_set_arch_mach (bfd
*abfd
, enum bfd_architecture arch
, unsigned long mach
)
868 if (arch
!= bfd_arch_unknown
)
869 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
871 abfd
->arch_info
= & bfd_default_arch_struct
;
875 /* We have to save up all the Srecords for a splurge before output. */
878 srec_set_section_contents (bfd
*abfd
,
880 const void * location
,
882 bfd_size_type bytes_to_do
)
884 int opb
= bfd_octets_per_byte (abfd
);
885 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
886 srec_data_list_type
*entry
;
888 entry
= (srec_data_list_type
*) bfd_alloc (abfd
, sizeof (* entry
));
893 && (section
->flags
& SEC_ALLOC
)
894 && (section
->flags
& SEC_LOAD
))
898 data
= (bfd_byte
*) bfd_alloc (abfd
, bytes_to_do
);
901 memcpy ((void *) data
, location
, (size_t) bytes_to_do
);
903 /* Ff S3Forced is TRUE then always select S3 records,
904 regardless of the siez of the addresses. */
907 else if ((section
->lma
+ (offset
+ bytes_to_do
) / opb
- 1) <= 0xffff)
908 ; /* The default, S1, is OK. */
909 else if ((section
->lma
+ (offset
+ bytes_to_do
) / opb
- 1) <= 0xffffff
916 entry
->where
= section
->lma
+ offset
/ opb
;
917 entry
->size
= bytes_to_do
;
919 /* Sort the records by address. Optimize for the common case of
920 adding a record to the end of the list. */
921 if (tdata
->tail
!= NULL
922 && entry
->where
>= tdata
->tail
->where
)
924 tdata
->tail
->next
= entry
;
930 srec_data_list_type
**look
;
932 for (look
= &tdata
->head
;
933 *look
!= NULL
&& (*look
)->where
< entry
->where
;
934 look
= &(*look
)->next
)
938 if (entry
->next
== NULL
)
945 /* Write a record of type, of the supplied number of bytes. The
946 supplied bytes and length don't have a checksum. That's worked out
950 srec_write_record (bfd
*abfd
,
953 const bfd_byte
*data
,
956 char buffer
[2 * MAXCHUNK
+ 6];
957 unsigned int check_sum
= 0;
958 const bfd_byte
*src
= data
;
967 dst
+= 2; /* Leave room for dst. */
973 TOHEX (dst
, (address
>> 24), check_sum
);
978 TOHEX (dst
, (address
>> 16), check_sum
);
984 TOHEX (dst
, (address
>> 8), check_sum
);
986 TOHEX (dst
, (address
), check_sum
);
991 for (src
= data
; src
< end
; src
++)
993 TOHEX (dst
, *src
, check_sum
);
997 /* Fill in the length. */
998 TOHEX (length
, (dst
- length
) / 2, check_sum
);
1000 check_sum
= 255 - check_sum
;
1001 TOHEX (dst
, check_sum
, check_sum
);
1006 wrlen
= dst
- buffer
;
1008 return bfd_bwrite ((void *) buffer
, wrlen
, abfd
) == wrlen
;
1012 srec_write_header (bfd
*abfd
)
1014 unsigned int len
= strlen (abfd
->filename
);
1016 /* I'll put an arbitrary 40 char limit on header size. */
1020 return srec_write_record (abfd
, 0, (bfd_vma
) 0,
1021 (bfd_byte
*) abfd
->filename
,
1022 (bfd_byte
*) abfd
->filename
+ len
);
1026 srec_write_section (bfd
*abfd
,
1028 srec_data_list_type
*list
)
1030 unsigned int octets_written
= 0;
1031 bfd_byte
*location
= list
->data
;
1033 /* Validate number of data bytes to write. The srec length byte
1034 counts the address, data and crc bytes. S1 (tdata->type == 1)
1035 records have two address bytes, S2 (tdata->type == 2) records
1036 have three, and S3 (tdata->type == 3) records have four.
1037 The total length can't exceed 255, and a zero data length will
1038 spin for a long time. */
1041 else if (Chunk
> MAXCHUNK
- tdata
->type
- 2)
1042 Chunk
= MAXCHUNK
- tdata
->type
- 2;
1044 while (octets_written
< list
->size
)
1047 unsigned int octets_this_chunk
= list
->size
- octets_written
;
1049 if (octets_this_chunk
> Chunk
)
1050 octets_this_chunk
= Chunk
;
1052 address
= list
->where
+ octets_written
/ bfd_octets_per_byte (abfd
);
1054 if (! srec_write_record (abfd
,
1058 location
+ octets_this_chunk
))
1061 octets_written
+= octets_this_chunk
;
1062 location
+= octets_this_chunk
;
1069 srec_write_terminator (bfd
*abfd
, tdata_type
*tdata
)
1071 return srec_write_record (abfd
, 10 - tdata
->type
,
1072 abfd
->start_address
, NULL
, NULL
);
1076 srec_write_symbols (bfd
*abfd
)
1078 /* Dump out the symbols of a bfd. */
1080 int count
= bfd_get_symcount (abfd
);
1085 asymbol
**table
= bfd_get_outsymbols (abfd
);
1087 len
= strlen (abfd
->filename
);
1088 if (bfd_bwrite ("$$ ", (bfd_size_type
) 3, abfd
) != 3
1089 || bfd_bwrite (abfd
->filename
, len
, abfd
) != len
1090 || bfd_bwrite ("\r\n", (bfd_size_type
) 2, abfd
) != 2)
1093 for (i
= 0; i
< count
; i
++)
1095 asymbol
*s
= table
[i
];
1096 if (! bfd_is_local_label (abfd
, s
)
1097 && (s
->flags
& BSF_DEBUGGING
) == 0)
1099 /* Just dump out non debug symbols. */
1102 len
= strlen (s
->name
);
1103 if (bfd_bwrite (" ", (bfd_size_type
) 2, abfd
) != 2
1104 || bfd_bwrite (s
->name
, len
, abfd
) != len
)
1107 sprintf_vma (buf
+ 2, (s
->value
1108 + s
->section
->output_section
->lma
1109 + s
->section
->output_offset
));
1111 while (p
[0] == '0' && p
[1] != 0)
1119 if (bfd_bwrite (p
, len
, abfd
) != len
)
1123 if (bfd_bwrite ("$$ \r\n", (bfd_size_type
) 5, abfd
) != 5)
1131 internal_srec_write_object_contents (bfd
*abfd
, int symbols
)
1133 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
1134 srec_data_list_type
*list
;
1138 if (! srec_write_symbols (abfd
))
1142 if (! srec_write_header (abfd
))
1145 /* Now wander though all the sections provided and output them. */
1148 while (list
!= (srec_data_list_type
*) NULL
)
1150 if (! srec_write_section (abfd
, tdata
, list
))
1154 return srec_write_terminator (abfd
, tdata
);
1158 srec_write_object_contents (bfd
*abfd
)
1160 return internal_srec_write_object_contents (abfd
, 0);
1164 symbolsrec_write_object_contents (bfd
*abfd
)
1166 return internal_srec_write_object_contents (abfd
, 1);
1170 srec_sizeof_headers (bfd
*abfd ATTRIBUTE_UNUSED
,
1171 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1176 /* Return the amount of memory needed to read the symbol table. */
1179 srec_get_symtab_upper_bound (bfd
*abfd
)
1181 return (bfd_get_symcount (abfd
) + 1) * sizeof (asymbol
*);
1184 /* Return the symbol table. */
1187 srec_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
1189 bfd_size_type symcount
= bfd_get_symcount (abfd
);
1193 csymbols
= abfd
->tdata
.srec_data
->csymbols
;
1194 if (csymbols
== NULL
&& symcount
!= 0)
1197 struct srec_symbol
*s
;
1199 csymbols
= (asymbol
*) bfd_alloc (abfd
, symcount
* sizeof (asymbol
));
1200 if (csymbols
== NULL
)
1202 abfd
->tdata
.srec_data
->csymbols
= csymbols
;
1204 for (s
= abfd
->tdata
.srec_data
->symbols
, c
= csymbols
;
1211 c
->flags
= BSF_GLOBAL
;
1212 c
->section
= bfd_abs_section_ptr
;
1217 for (i
= 0; i
< symcount
; i
++)
1218 *alocation
++ = csymbols
++;
1225 srec_get_symbol_info (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
1229 bfd_symbol_info (symbol
, ret
);
1233 srec_print_symbol (bfd
*abfd
,
1236 bfd_print_symbol_type how
)
1238 FILE *file
= (FILE *) afile
;
1242 case bfd_print_symbol_name
:
1243 fprintf (file
, "%s", symbol
->name
);
1246 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
1247 fprintf (file
, " %-5s %s",
1248 symbol
->section
->name
,
1253 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup
1254 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1255 #define srec_new_section_hook _bfd_generic_new_section_hook
1256 #define srec_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
1257 #define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
1258 #define srec_get_lineno _bfd_nosymbols_get_lineno
1259 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
1260 #define srec_find_line _bfd_nosymbols_find_line
1261 #define srec_find_inliner_info _bfd_nosymbols_find_inliner_info
1262 #define srec_make_empty_symbol _bfd_generic_make_empty_symbol
1263 #define srec_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
1264 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1265 #define srec_read_minisymbols _bfd_generic_read_minisymbols
1266 #define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1267 #define srec_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
1268 #define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
1269 #define srec_bfd_relax_section bfd_generic_relax_section
1270 #define srec_bfd_gc_sections bfd_generic_gc_sections
1271 #define srec_bfd_lookup_section_flags bfd_generic_lookup_section_flags
1272 #define srec_bfd_merge_sections bfd_generic_merge_sections
1273 #define srec_bfd_is_group_section bfd_generic_is_group_section
1274 #define srec_bfd_discard_group bfd_generic_discard_group
1275 #define srec_section_already_linked _bfd_generic_section_already_linked
1276 #define srec_bfd_define_common_symbol bfd_generic_define_common_symbol
1277 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1278 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
1279 #define srec_bfd_link_just_syms _bfd_generic_link_just_syms
1280 #define srec_bfd_copy_link_hash_symbol_type _bfd_generic_copy_link_hash_symbol_type
1281 #define srec_bfd_final_link _bfd_generic_final_link
1282 #define srec_bfd_link_split_section _bfd_generic_link_split_section
1283 #define srec_bfd_link_check_relocs _bfd_generic_link_check_relocs
1285 const bfd_target srec_vec
=
1288 bfd_target_srec_flavour
,
1289 BFD_ENDIAN_UNKNOWN
, /* Target byte order. */
1290 BFD_ENDIAN_UNKNOWN
, /* Target headers byte order. */
1291 (HAS_RELOC
| EXEC_P
| /* Object flags. */
1292 HAS_LINENO
| HAS_DEBUG
|
1293 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1294 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
1295 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* Section flags. */
1296 0, /* Leading underscore. */
1297 ' ', /* AR_pad_char. */
1298 16, /* AR_max_namelen. */
1299 0, /* match priority. */
1300 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1301 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1302 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* Data. */
1303 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1304 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1305 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* Hdrs. */
1309 srec_object_p
, /* bfd_check_format. */
1316 _bfd_generic_mkarchive
,
1319 { /* bfd_write_contents. */
1321 srec_write_object_contents
,
1322 _bfd_write_archive_contents
,
1326 BFD_JUMP_TABLE_GENERIC (srec
),
1327 BFD_JUMP_TABLE_COPY (_bfd_generic
),
1328 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1329 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
1330 BFD_JUMP_TABLE_SYMBOLS (srec
),
1331 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
1332 BFD_JUMP_TABLE_WRITE (srec
),
1333 BFD_JUMP_TABLE_LINK (srec
),
1334 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
1341 const bfd_target symbolsrec_vec
=
1343 "symbolsrec", /* Name. */
1344 bfd_target_srec_flavour
,
1345 BFD_ENDIAN_UNKNOWN
, /* Target byte order. */
1346 BFD_ENDIAN_UNKNOWN
, /* Target headers byte order. */
1347 (HAS_RELOC
| EXEC_P
| /* Object flags. */
1348 HAS_LINENO
| HAS_DEBUG
|
1349 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1350 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
1351 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* Section flags. */
1352 0, /* Leading underscore. */
1353 ' ', /* AR_pad_char. */
1354 16, /* AR_max_namelen. */
1355 0, /* match priority. */
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
, /* Data. */
1359 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1360 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1361 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* Headers. */
1365 symbolsrec_object_p
, /* bfd_check_format. */
1372 _bfd_generic_mkarchive
,
1375 { /* bfd_write_contents. */
1377 symbolsrec_write_object_contents
,
1378 _bfd_write_archive_contents
,
1382 BFD_JUMP_TABLE_GENERIC (srec
),
1383 BFD_JUMP_TABLE_COPY (_bfd_generic
),
1384 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1385 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
1386 BFD_JUMP_TABLE_SYMBOLS (srec
),
1387 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
1388 BFD_JUMP_TABLE_WRITE (srec
),
1389 BFD_JUMP_TABLE_LINK (srec
),
1390 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),