1 /* BFD back-end for s-record objects.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 Ordinary S-Records cannot hold anything but addresses and
30 data, so that's all that we implement.
32 The only interesting thing is that S-Records may come out of
33 order and there is no header, so an initial scan is required
34 to discover the minimum and maximum addresses used to create
35 the vma and size of the only section we create. We
36 arbitrarily call this section ".text".
38 When bfd_get_section_contents is called the file is read
39 again, and this time the data is placed into a bfd_alloc'd
42 Any number of sections may be created for output, we save them
43 up and output them when it's time to close the bfd.
45 An s record looks like:
48 S<type><length><address><data><checksum>
53 is the number of bytes following upto the checksum. Note that
54 this is not the number of chars following, since it takes two
55 chars to represent a byte.
59 1) two byte address data record
60 2) three byte address data record
61 3) four byte address data record
62 7) four byte address termination record
63 8) three byte address termination record
64 9) two byte address termination record
67 is the start address of the data following, or in the case of
68 a termination record, the start address of the image
72 is the sum of all the raw byte data in the record, from the length
73 upwards, modulo 256 and subtracted from 255.
76 Symbol S-Record handling
79 Some ICE equipment understands an addition to the standard
80 S-Record format; symbols and their addresses can be sent
83 The format of this is:
85 (<space> <symbol> <address>)*)
88 so a short symbol table could look like:
102 We allow symbols to be anywhere in the data stream - the module names
110 #include "libiberty.h"
111 #include "safe-ctype.h"
113 static void srec_get_symbol_info
PARAMS ((bfd
*, asymbol
*, symbol_info
*));
114 static void srec_print_symbol
115 PARAMS ((bfd
*, PTR
, asymbol
*, bfd_print_symbol_type
));
116 static void srec_init
PARAMS ((void));
117 static boolean srec_mkobject
PARAMS ((bfd
*));
118 static int srec_get_byte
PARAMS ((bfd
*, boolean
*));
119 static void srec_bad_byte
PARAMS ((bfd
*, unsigned int, int, boolean
));
120 static boolean srec_scan
PARAMS ((bfd
*));
121 static const bfd_target
*srec_object_p
PARAMS ((bfd
*));
122 static const bfd_target
*symbolsrec_object_p
PARAMS ((bfd
*));
123 static boolean srec_read_section
PARAMS ((bfd
*, asection
*, bfd_byte
*));
125 static boolean srec_write_record
PARAMS ((bfd
*, unsigned int, bfd_vma
,
128 static boolean srec_write_header
PARAMS ((bfd
*));
129 static boolean srec_write_symbols
PARAMS ((bfd
*));
130 static boolean srec_new_symbol
PARAMS ((bfd
*, const char *, bfd_vma
));
131 static boolean srec_get_section_contents
132 PARAMS ((bfd
*, asection
*, PTR
, file_ptr
, bfd_size_type
));
133 static boolean srec_set_arch_mach
134 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long));
135 static boolean srec_set_section_contents
136 PARAMS ((bfd
*, sec_ptr
, PTR
, file_ptr
, bfd_size_type
));
137 static boolean internal_srec_write_object_contents
PARAMS ((bfd
*, int));
138 static boolean srec_write_object_contents
PARAMS ((bfd
*));
139 static boolean symbolsrec_write_object_contents
PARAMS ((bfd
*));
140 static int srec_sizeof_headers
PARAMS ((bfd
*, boolean
));
141 static asymbol
*srec_make_empty_symbol
PARAMS ((bfd
*));
142 static long srec_get_symtab_upper_bound
PARAMS ((bfd
*));
143 static long srec_get_symtab
PARAMS ((bfd
*, asymbol
**));
145 /* Macros for converting between hex and binary. */
147 static const char digs
[] = "0123456789ABCDEF";
149 #define NIBBLE(x) hex_value(x)
150 #define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
151 #define TOHEX(d, x, ch) \
152 d[1] = digs[(x) & 0xf]; \
153 d[0] = digs[((x)>>4)&0xf]; \
155 #define ISHEX(x) hex_p(x)
157 /* Initialize by filling in the hex conversion array. */
162 static boolean inited
= false;
171 /* The maximum number of bytes on a line is FF. */
172 #define MAXCHUNK 0xff
174 /* Default size for a CHUNK. */
175 #define DEFAULT_CHUNK 16
177 /* The number of bytes we actually fit onto a line on output.
178 This variable can be modified by objcopy's --srec-len parameter.
179 For a 0x75 byte record you should set --srec-len=0x70. */
180 unsigned int Chunk
= DEFAULT_CHUNK
;
182 /* The type of srec output (free or forced to S3).
183 This variable can be modified by objcopy's --srec-forceS3
185 boolean S3Forced
= 0;
187 /* When writing an S-record file, the S-records can not be output as
188 they are seen. This structure is used to hold them in memory. */
190 struct srec_data_list_struct
192 struct srec_data_list_struct
*next
;
198 typedef struct srec_data_list_struct srec_data_list_type
;
200 /* When scanning the S-record file, a linked list of srec_symbol
201 structures is built to represent the symbol table (if there is
206 struct srec_symbol
*next
;
211 /* The S-record tdata information. */
213 typedef struct srec_data_struct
215 srec_data_list_type
*head
;
216 srec_data_list_type
*tail
;
218 struct srec_symbol
*symbols
;
219 struct srec_symbol
*symtail
;
224 static boolean srec_write_section
PARAMS ((bfd
*, tdata_type
*,
225 srec_data_list_type
*));
226 static boolean srec_write_terminator
PARAMS ((bfd
*, tdata_type
*));
228 /* Set up the S-record tdata information. */
236 if (abfd
->tdata
.srec_data
== NULL
)
238 bfd_size_type amt
= sizeof (tdata_type
);
239 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, amt
);
242 abfd
->tdata
.srec_data
= tdata
;
246 tdata
->symbols
= NULL
;
247 tdata
->symtail
= NULL
;
248 tdata
->csymbols
= NULL
;
254 /* Read a byte from an S record file. Set *ERRORPTR if an error
255 occurred. Return EOF on error or end of file. */
258 srec_get_byte (abfd
, errorptr
)
264 if (bfd_bread (&c
, (bfd_size_type
) 1, abfd
) != 1)
266 if (bfd_get_error () != bfd_error_file_truncated
)
271 return (int) (c
& 0xff);
274 /* Report a problem in an S record file. FIXME: This probably should
275 not call fprintf, but we really do need some mechanism for printing
279 srec_bad_byte (abfd
, lineno
, c
, error
)
288 bfd_set_error (bfd_error_file_truncated
);
295 sprintf (buf
, "\\%03o", (unsigned int) c
);
301 (*_bfd_error_handler
)
302 (_("%s:%d: Unexpected character `%s' in S-record file\n"),
303 bfd_archive_filename (abfd
), lineno
, buf
);
304 bfd_set_error (bfd_error_bad_value
);
308 /* Add a new symbol found in an S-record file. */
311 srec_new_symbol (abfd
, name
, val
)
316 struct srec_symbol
*n
;
317 bfd_size_type amt
= sizeof (struct srec_symbol
);
319 n
= (struct srec_symbol
*) bfd_alloc (abfd
, amt
);
326 if (abfd
->tdata
.srec_data
->symbols
== NULL
)
327 abfd
->tdata
.srec_data
->symbols
= n
;
329 abfd
->tdata
.srec_data
->symtail
->next
= n
;
330 abfd
->tdata
.srec_data
->symtail
= n
;
338 /* Read the S record file and turn it into sections. We create a new
339 section for each contiguous set of bytes. */
346 unsigned int lineno
= 1;
347 boolean error
= false;
348 bfd_byte
*buf
= NULL
;
350 asection
*sec
= NULL
;
353 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
356 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
)
358 /* We only build sections from contiguous S-records, so if this
359 is not an S-record, then stop building a section. */
360 if (c
!= 'S' && c
!= '\r' && c
!= '\n')
366 srec_bad_byte (abfd
, lineno
, c
, error
);
377 /* Starting a module name, which we ignore. */
378 while ((c
= srec_get_byte (abfd
, &error
)) != '\n'
383 srec_bad_byte (abfd
, lineno
, c
, error
);
398 /* Starting a symbol definition. */
399 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
400 && (c
== ' ' || c
== '\t'))
403 if (c
== '\n' || c
== '\r')
408 srec_bad_byte (abfd
, lineno
, c
, error
);
413 symbuf
= (char *) bfd_malloc (alc
+ 1);
420 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
423 if ((bfd_size_type
) (p
- symbuf
) >= alc
)
428 n
= (char *) bfd_realloc (symbuf
, alc
+ 1);
431 p
= n
+ (p
- symbuf
);
440 srec_bad_byte (abfd
, lineno
, c
, error
);
445 symname
= bfd_alloc (abfd
, (bfd_size_type
) (p
- symbuf
));
448 strcpy (symname
, symbuf
);
452 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
453 && (c
== ' ' || c
== '\t'))
457 srec_bad_byte (abfd
, lineno
, c
, error
);
461 /* Skip a dollar sign before the hex value. */
464 c
= srec_get_byte (abfd
, &error
);
467 srec_bad_byte (abfd
, lineno
, c
, error
);
476 symval
+= NIBBLE (c
);
477 c
= srec_get_byte (abfd
, &error
);
480 if (! srec_new_symbol (abfd
, symname
, symval
))
483 while (c
== ' ' || c
== '\t')
490 srec_bad_byte (abfd
, lineno
, c
, error
);
504 /* Starting an S-record. */
506 pos
= bfd_tell (abfd
) - 1;
508 if (bfd_bread (hdr
, (bfd_size_type
) 3, abfd
) != 3)
511 if (! ISHEX (hdr
[1]) || ! ISHEX (hdr
[2]))
513 if (! ISHEX (hdr
[1]))
517 srec_bad_byte (abfd
, lineno
, c
, error
);
521 bytes
= HEX (hdr
+ 1);
522 if (bytes
* 2 > bufsize
)
526 buf
= (bfd_byte
*) bfd_malloc ((bfd_size_type
) bytes
* 2);
532 if (bfd_bread (buf
, (bfd_size_type
) bytes
* 2, abfd
) != bytes
* 2)
535 /* Ignore the checksum byte. */
544 /* Prologue--ignore the file name, but stop building a
545 section at this point. */
550 address
= HEX (data
);
555 address
= (address
<< 8) | HEX (data
);
560 address
= (address
<< 8) | HEX (data
);
562 address
= (address
<< 8) | HEX (data
);
567 && sec
->vma
+ sec
->_raw_size
== address
)
569 /* This data goes at the end of the section we are
570 currently building. */
571 sec
->_raw_size
+= bytes
;
579 sprintf (secbuf
, ".sec%d", bfd_count_sections (abfd
) + 1);
580 amt
= strlen (secbuf
) + 1;
581 secname
= (char *) bfd_alloc (abfd
, amt
);
582 strcpy (secname
, secbuf
);
583 sec
= bfd_make_section (abfd
, secname
);
586 sec
->flags
= SEC_HAS_CONTENTS
| SEC_LOAD
| SEC_ALLOC
;
589 sec
->_raw_size
= bytes
;
596 address
= HEX (data
);
600 address
= (address
<< 8) | HEX (data
);
604 address
= (address
<< 8) | HEX (data
);
606 address
= (address
<< 8) | HEX (data
);
609 /* This is a termination record. */
610 abfd
->start_address
= address
;
638 /* Check whether an existing file is an S-record file. */
640 static const bfd_target
*
648 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
649 || bfd_bread (b
, (bfd_size_type
) 4, abfd
) != 4)
652 if (b
[0] != 'S' || !ISHEX (b
[1]) || !ISHEX (b
[2]) || !ISHEX (b
[3]))
654 bfd_set_error (bfd_error_wrong_format
);
658 if (! srec_mkobject (abfd
)
659 || ! srec_scan (abfd
))
662 if (abfd
->symcount
> 0)
663 abfd
->flags
|= HAS_SYMS
;
668 /* Check whether an existing file is an S-record file with symbols. */
670 static const bfd_target
*
671 symbolsrec_object_p (abfd
)
678 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
679 || bfd_bread (b
, (bfd_size_type
) 2, abfd
) != 2)
682 if (b
[0] != '$' || b
[1] != '$')
684 bfd_set_error (bfd_error_wrong_format
);
688 if (! srec_mkobject (abfd
)
689 || ! srec_scan (abfd
))
692 if (abfd
->symcount
> 0)
693 abfd
->flags
|= HAS_SYMS
;
698 /* Read in the contents of a section in an S-record file. */
701 srec_read_section (abfd
, section
, contents
)
707 bfd_size_type sofar
= 0;
708 boolean error
= false;
709 bfd_byte
*buf
= NULL
;
712 if (bfd_seek (abfd
, section
->filepos
, SEEK_SET
) != 0)
715 while ((c
= srec_get_byte (abfd
, &error
)) != EOF
)
722 if (c
== '\r' || c
== '\n')
725 /* This is called after srec_scan has already been called, so we
726 ought to know the exact format. */
727 BFD_ASSERT (c
== 'S');
729 if (bfd_bread (hdr
, (bfd_size_type
) 3, abfd
) != 3)
732 BFD_ASSERT (ISHEX (hdr
[1]) && ISHEX (hdr
[2]));
734 bytes
= HEX (hdr
+ 1);
736 if (bytes
* 2 > bufsize
)
740 buf
= (bfd_byte
*) bfd_malloc ((bfd_size_type
) bytes
* 2);
746 if (bfd_bread (buf
, (bfd_size_type
) bytes
* 2, abfd
) != bytes
* 2)
754 BFD_ASSERT (sofar
== section
->_raw_size
);
760 address
= HEX (data
);
765 address
= (address
<< 8) | HEX (data
);
770 address
= (address
<< 8) | HEX (data
);
772 address
= (address
<< 8) | HEX (data
);
776 if (address
!= section
->vma
+ sofar
)
778 /* We've come to the end of this section. */
779 BFD_ASSERT (sofar
== section
->_raw_size
);
785 /* Don't consider checksum. */
790 contents
[sofar
] = HEX (data
);
802 BFD_ASSERT (sofar
== section
->_raw_size
);
815 /* Get the contents of a section in an S-record file. */
818 srec_get_section_contents (abfd
, section
, location
, offset
, count
)
825 if (section
->used_by_bfd
== NULL
)
827 section
->used_by_bfd
= bfd_alloc (abfd
, section
->_raw_size
);
828 if (section
->used_by_bfd
== NULL
&& section
->_raw_size
!= 0)
831 if (! srec_read_section (abfd
, section
, section
->used_by_bfd
))
835 memcpy (location
, (bfd_byte
*) section
->used_by_bfd
+ offset
,
841 /* Set the architecture. We accept an unknown architecture here. */
844 srec_set_arch_mach (abfd
, arch
, mach
)
846 enum bfd_architecture arch
;
849 if (arch
== bfd_arch_unknown
)
851 abfd
->arch_info
= &bfd_default_arch_struct
;
854 return bfd_default_set_arch_mach (abfd
, arch
, mach
);
857 /* We have to save up all the Srecords for a splurge before output. */
860 srec_set_section_contents (abfd
, section
, location
, offset
, bytes_to_do
)
865 bfd_size_type bytes_to_do
;
867 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
868 register srec_data_list_type
*entry
;
870 entry
= ((srec_data_list_type
*)
871 bfd_alloc (abfd
, (bfd_size_type
) sizeof (srec_data_list_type
)));
876 && (section
->flags
& SEC_ALLOC
)
877 && (section
->flags
& SEC_LOAD
))
881 data
= (bfd_byte
*) bfd_alloc (abfd
, bytes_to_do
);
884 memcpy ((PTR
) data
, location
, (size_t) bytes_to_do
);
886 /* Ff S3Forced is true then always select S3 records,
887 regardless of the siez of the addresses. */
890 else if ((section
->lma
+ offset
+ bytes_to_do
- 1) <= 0xffff)
891 ; /* The default, S1, is OK. */
892 else if ((section
->lma
+ offset
+ bytes_to_do
- 1) <= 0xffffff
899 entry
->where
= section
->lma
+ offset
;
900 entry
->size
= bytes_to_do
;
902 /* Sort the records by address. Optimize for the common case of
903 adding a record to the end of the list. */
904 if (tdata
->tail
!= NULL
905 && entry
->where
>= tdata
->tail
->where
)
907 tdata
->tail
->next
= entry
;
913 register srec_data_list_type
**look
;
915 for (look
= &tdata
->head
;
916 *look
!= NULL
&& (*look
)->where
< entry
->where
;
917 look
= &(*look
)->next
)
921 if (entry
->next
== NULL
)
928 /* Write a record of type, of the supplied number of bytes. The
929 supplied bytes and length don't have a checksum. That's worked out
933 srec_write_record (abfd
, type
, address
, data
, end
)
937 const bfd_byte
*data
;
940 char buffer
[MAXCHUNK
];
941 unsigned int check_sum
= 0;
942 const bfd_byte
*src
= data
;
951 dst
+= 2; /* Leave room for dst. */
957 TOHEX (dst
, (address
>> 24), check_sum
);
961 TOHEX (dst
, (address
>> 16), check_sum
);
966 TOHEX (dst
, (address
>> 8), check_sum
);
968 TOHEX (dst
, (address
), check_sum
);
973 for (src
= data
; src
< end
; src
++)
975 TOHEX (dst
, *src
, check_sum
);
979 /* Fill in the length. */
980 TOHEX (length
, (dst
- length
) / 2, check_sum
);
982 check_sum
= 255 - check_sum
;
983 TOHEX (dst
, check_sum
, check_sum
);
988 wrlen
= dst
- buffer
;
989 if (bfd_bwrite ((PTR
) buffer
, wrlen
, abfd
) != wrlen
)
995 srec_write_header (abfd
)
998 bfd_byte buffer
[MAXCHUNK
];
999 bfd_byte
*dst
= buffer
;
1002 /* I'll put an arbitary 40 char limit on header size. */
1003 for (i
= 0; i
< 40 && abfd
->filename
[i
]; i
++)
1004 *dst
++ = abfd
->filename
[i
];
1006 return srec_write_record (abfd
, 0, (bfd_vma
) 0, buffer
, dst
);
1010 srec_write_section (abfd
, tdata
, list
)
1013 srec_data_list_type
*list
;
1015 unsigned int octets_written
= 0;
1016 bfd_byte
*location
= list
->data
;
1018 while (octets_written
< list
->size
)
1021 unsigned int octets_this_chunk
= list
->size
- octets_written
;
1023 if (octets_this_chunk
> Chunk
)
1024 octets_this_chunk
= Chunk
;
1026 address
= list
->where
+ octets_written
/ bfd_octets_per_byte (abfd
);
1028 if (! srec_write_record (abfd
,
1032 location
+ octets_this_chunk
))
1035 octets_written
+= octets_this_chunk
;
1036 location
+= octets_this_chunk
;
1043 srec_write_terminator (abfd
, tdata
)
1049 return srec_write_record (abfd
, 10 - tdata
->type
,
1050 abfd
->start_address
, buffer
, buffer
);
1054 srec_write_symbols (abfd
)
1057 char buffer
[MAXCHUNK
];
1058 /* Dump out the symbols of a bfd. */
1060 int count
= bfd_get_symcount (abfd
);
1065 asymbol
**table
= bfd_get_outsymbols (abfd
);
1066 sprintf (buffer
, "$$ %s\r\n", abfd
->filename
);
1068 len
= strlen (buffer
);
1069 if (bfd_bwrite (buffer
, len
, abfd
) != len
)
1072 for (i
= 0; i
< count
; i
++)
1074 asymbol
*s
= table
[i
];
1075 if (! bfd_is_local_label (abfd
, s
)
1076 && (s
->flags
& BSF_DEBUGGING
) == 0)
1078 /* Just dump out non debug symbols. */
1082 s
->value
+ s
->section
->output_section
->lma
1083 + s
->section
->output_offset
);
1085 while (p
[0] == '0' && p
[1] != 0)
1087 sprintf (buffer
, " %s $%s\r\n", s
->name
, p
);
1088 len
= strlen (buffer
);
1089 if (bfd_bwrite (buffer
, len
, abfd
) != len
)
1093 sprintf (buffer
, "$$ \r\n");
1094 len
= strlen (buffer
);
1095 if (bfd_bwrite (buffer
, len
, abfd
) != len
)
1103 internal_srec_write_object_contents (abfd
, symbols
)
1107 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
1108 srec_data_list_type
*list
;
1112 if (! srec_write_symbols (abfd
))
1116 if (! srec_write_header (abfd
))
1119 /* Now wander though all the sections provided and output them. */
1122 while (list
!= (srec_data_list_type
*) NULL
)
1124 if (! srec_write_section (abfd
, tdata
, list
))
1128 return srec_write_terminator (abfd
, tdata
);
1132 srec_write_object_contents (abfd
)
1135 return internal_srec_write_object_contents (abfd
, 0);
1139 symbolsrec_write_object_contents (abfd
)
1142 return internal_srec_write_object_contents (abfd
, 1);
1146 srec_sizeof_headers (abfd
, exec
)
1147 bfd
*abfd ATTRIBUTE_UNUSED
;
1148 boolean exec ATTRIBUTE_UNUSED
;
1154 srec_make_empty_symbol (abfd
)
1159 new = (asymbol
*) bfd_zalloc (abfd
, (bfd_size_type
) sizeof (asymbol
));
1161 new->the_bfd
= abfd
;
1165 /* Return the amount of memory needed to read the symbol table. */
1168 srec_get_symtab_upper_bound (abfd
)
1171 return (bfd_get_symcount (abfd
) + 1) * sizeof (asymbol
*);
1174 /* Return the symbol table. */
1177 srec_get_symtab (abfd
, alocation
)
1179 asymbol
**alocation
;
1181 bfd_size_type symcount
= bfd_get_symcount (abfd
);
1185 csymbols
= abfd
->tdata
.srec_data
->csymbols
;
1186 if (csymbols
== NULL
)
1189 struct srec_symbol
*s
;
1191 csymbols
= (asymbol
*) bfd_alloc (abfd
, symcount
* sizeof (asymbol
));
1192 if (csymbols
== NULL
&& symcount
!= 0)
1194 abfd
->tdata
.srec_data
->csymbols
= csymbols
;
1196 for (s
= abfd
->tdata
.srec_data
->symbols
, c
= csymbols
;
1203 c
->flags
= BSF_GLOBAL
;
1204 c
->section
= bfd_abs_section_ptr
;
1209 for (i
= 0; i
< symcount
; i
++)
1210 *alocation
++ = csymbols
++;
1217 srec_get_symbol_info (ignore_abfd
, symbol
, ret
)
1218 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
1222 bfd_symbol_info (symbol
, ret
);
1226 srec_print_symbol (abfd
, afile
, symbol
, how
)
1230 bfd_print_symbol_type how
;
1232 FILE *file
= (FILE *) afile
;
1235 case bfd_print_symbol_name
:
1236 fprintf (file
, "%s", symbol
->name
);
1239 bfd_print_symbol_vandf (abfd
, (PTR
) file
, symbol
);
1240 fprintf (file
, " %-5s %s",
1241 symbol
->section
->name
,
1247 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup
1248 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1249 #define srec_new_section_hook _bfd_generic_new_section_hook
1251 #define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
1252 #define srec_get_lineno _bfd_nosymbols_get_lineno
1253 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
1254 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1255 #define srec_read_minisymbols _bfd_generic_read_minisymbols
1256 #define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1258 #define srec_get_reloc_upper_bound \
1259 ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
1260 #define srec_canonicalize_reloc \
1261 ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
1262 #define srec_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
1264 #define srec_get_section_contents_in_window \
1265 _bfd_generic_get_section_contents_in_window
1267 #define srec_bfd_get_relocated_section_contents \
1268 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_merge_sections bfd_generic_merge_sections
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_final_link _bfd_generic_final_link
1275 #define srec_bfd_link_split_section _bfd_generic_link_split_section
1277 const bfd_target srec_vec
=
1280 bfd_target_srec_flavour
,
1281 BFD_ENDIAN_UNKNOWN
, /* target byte order */
1282 BFD_ENDIAN_UNKNOWN
, /* target headers byte order */
1283 (HAS_RELOC
| EXEC_P
| /* object flags */
1284 HAS_LINENO
| HAS_DEBUG
|
1285 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1286 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
1287 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
1288 0, /* leading underscore */
1289 ' ', /* ar_pad_char */
1290 16, /* ar_max_namelen */
1291 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1292 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1293 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
1294 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1295 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1296 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1300 srec_object_p
, /* bfd_check_format */
1307 _bfd_generic_mkarchive
,
1310 { /* bfd_write_contents */
1312 srec_write_object_contents
,
1313 _bfd_write_archive_contents
,
1317 BFD_JUMP_TABLE_GENERIC (srec
),
1318 BFD_JUMP_TABLE_COPY (_bfd_generic
),
1319 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1320 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
1321 BFD_JUMP_TABLE_SYMBOLS (srec
),
1322 BFD_JUMP_TABLE_RELOCS (srec
),
1323 BFD_JUMP_TABLE_WRITE (srec
),
1324 BFD_JUMP_TABLE_LINK (srec
),
1325 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
1332 const bfd_target symbolsrec_vec
=
1334 "symbolsrec", /* name */
1335 bfd_target_srec_flavour
,
1336 BFD_ENDIAN_UNKNOWN
, /* target byte order */
1337 BFD_ENDIAN_UNKNOWN
, /* target headers byte order */
1338 (HAS_RELOC
| EXEC_P
| /* object flags */
1339 HAS_LINENO
| HAS_DEBUG
|
1340 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1341 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
1342 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
1343 0, /* leading underscore */
1344 ' ', /* ar_pad_char */
1345 16, /* ar_max_namelen */
1346 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1347 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1348 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
1349 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1350 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1351 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1355 symbolsrec_object_p
, /* bfd_check_format */
1362 _bfd_generic_mkarchive
,
1365 { /* bfd_write_contents */
1367 symbolsrec_write_object_contents
,
1368 _bfd_write_archive_contents
,
1372 BFD_JUMP_TABLE_GENERIC (srec
),
1373 BFD_JUMP_TABLE_COPY (_bfd_generic
),
1374 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1375 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
1376 BFD_JUMP_TABLE_SYMBOLS (srec
),
1377 BFD_JUMP_TABLE_RELOCS (srec
),
1378 BFD_JUMP_TABLE_WRITE (srec
),
1379 BFD_JUMP_TABLE_LINK (srec
),
1380 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),