1 /* BFD back-end for s-record objects.
2 Copyright 1990, 1991, 1992, 1993, 1994 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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
27 Ordinary S-Records cannot hold anything but addresses and
28 data, so that's all that we implement.
30 The only interesting thing is that S-Records may come out of
31 order and there is no header, so an initial scan is required
32 to discover the minimum and maximum addresses used to create
33 the vma and size of the only section we create. We
34 arbitrarily call this section ".text".
36 When bfd_get_section_contents is called the file is read
37 again, and this time the data is placed into a bfd_alloc'd
40 Any number of sections may be created for output, we save them
41 up and output them when it's time to close the bfd.
43 An s record looks like:
46 S<type><length><address><data><checksum>
51 is the number of bytes following upto the checksum. Note that
52 this is not the number of chars following, since it takes two
53 chars to represent a byte.
57 1) two byte address data record
58 2) three byte address data record
59 3) four byte address data record
60 7) four byte address termination record
61 8) three byte address termination record
62 9) two byte address termination record
65 is the start address of the data following, or in the case of
66 a termination record, the start address of the image
70 is the sum of all the raw byte data in the record, from the length
71 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
109 #include "libiberty.h"
111 static void srec_init PARAMS ((void));
112 static boolean srec_mkobject PARAMS ((bfd *));
113 static int srec_get_byte PARAMS ((bfd *, boolean *));
114 static void srec_bad_byte PARAMS ((bfd *, unsigned int, int, boolean));
115 static boolean srec_scan PARAMS ((bfd *));
116 static const bfd_target *srec_object_p PARAMS ((bfd *));
117 static const bfd_target *symbolsrec_object_p PARAMS ((bfd *));
118 static boolean srec_read_section PARAMS ((bfd *, asection *, bfd_byte *));
120 static boolean srec_write_record PARAMS ((bfd *, int, bfd_vma,
123 static boolean srec_write_header PARAMS ((bfd *));
124 static boolean srec_write_symbols PARAMS ((bfd *));
126 /* Macros for converting between hex and binary. */
128 static CONST char digs[] = "0123456789ABCDEF";
130 #define NIBBLE(x) hex_value(x)
131 #define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
132 #define TOHEX(d, x, ch) \
133 d[1] = digs[(x) & 0xf]; \
134 d[0] = digs[((x)>>4)&0xf]; \
136 #define ISHEX(x) hex_p(x)
138 /* Initialize by filling in the hex conversion array. */
144 static boolean inited = false;
153 /* The maximum number of bytes on a line is FF */
154 #define MAXCHUNK 0xff
155 /* The number of bytes we fit onto a line on output */
158 /* When writing an S-record file, the S-records can not be output as
159 they are seen. This structure is used to hold them in memory. */
161 struct srec_data_list_struct
163 struct srec_data_list_struct *next;
169 typedef struct srec_data_list_struct srec_data_list_type;
171 /* When scanning the S-record file, a linked list of srec_symbol
172 structures is built to represent the symbol table (if there is
177 struct srec_symbol *next;
182 /* The S-record tdata information. */
184 typedef struct srec_data_struct
186 srec_data_list_type *head;
187 srec_data_list_type *tail;
189 struct srec_symbol *symbols;
190 struct srec_symbol *symtail;
195 static boolean srec_write_section PARAMS ((bfd *, tdata_type *,
196 srec_data_list_type *));
197 static boolean srec_write_terminator PARAMS ((bfd *, tdata_type *));
199 /* Set up the S-record tdata information. */
207 if (abfd->tdata.srec_data == NULL)
209 tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
212 bfd_set_error (bfd_error_no_memory);
215 abfd->tdata.srec_data = tdata;
219 tdata->symbols = NULL;
220 tdata->symtail = NULL;
221 tdata->csymbols = NULL;
227 /* Read a byte from an S record file. Set *ERRORPTR if an error
228 occurred. Return EOF on error or end of file. */
231 srec_get_byte (abfd, errorptr)
237 if (bfd_read (&c, 1, 1, abfd) != 1)
239 if (bfd_get_error () != bfd_error_file_truncated)
244 return (int) (c & 0xff);
247 /* Report a problem in an S record file. FIXME: This probably should
248 not call fprintf, but we really do need some mechanism for printing
252 srec_bad_byte (abfd, lineno, c, error)
261 bfd_set_error (bfd_error_file_truncated);
268 sprintf (buf, "\\%03o", (unsigned int) c);
274 fprintf (stderr, "%s:%d: Unexpected character `%s' in S-record file\n",
275 bfd_get_filename (abfd), lineno, buf);
276 bfd_set_error (bfd_error_bad_value);
280 /* Add a new symbol found in an S-record file. */
283 srec_new_symbol (abfd, name, val)
288 struct srec_symbol *n;
290 n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (struct srec_symbol));
293 bfd_set_error (bfd_error_no_memory);
300 if (abfd->tdata.srec_data->symbols == NULL)
301 abfd->tdata.srec_data->symbols = n;
303 abfd->tdata.srec_data->symtail->next = n;
304 abfd->tdata.srec_data->symtail = n;
312 /* Read the S record file and turn it into sections. We create a new
313 section for each contiguous set of bytes. */
320 unsigned int lineno = 1;
321 boolean error = false;
322 bfd_byte *buf = NULL;
324 asection *sec = NULL;
326 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
329 while ((c = srec_get_byte (abfd, &error)) != EOF)
331 /* We only build sections from contiguous S-records, so if this
332 is not an S-record, then stop building a section. */
333 if (c != 'S' && c != '\r' && c != '\n')
339 srec_bad_byte (abfd, lineno, c, error);
350 /* Starting a module name, which we ignore. */
351 while ((c = srec_get_byte (abfd, &error)) != '\n'
356 srec_bad_byte (abfd, lineno, c, error);
369 /* Starting a symbol definition. */
370 while ((c = srec_get_byte (abfd, &error)) != EOF
371 && (c == ' ' || c == '\t'))
375 srec_bad_byte (abfd, lineno, c, error);
379 obstack_1grow (&abfd->memory, c);
380 while ((c = srec_get_byte (abfd, &error)) != EOF
382 obstack_1grow (&abfd->memory, c);
385 srec_bad_byte (abfd, lineno, c, error);
389 symname = obstack_finish (&abfd->memory);
392 bfd_set_error (bfd_error_no_memory);
396 while ((c = srec_get_byte (abfd, &error)) != EOF
397 && (c == ' ' || c == '\t'))
401 srec_bad_byte (abfd, lineno, c, error);
405 /* Skip a dollar sign before the hex value. */
408 c = srec_get_byte (abfd, &error);
411 srec_bad_byte (abfd, lineno, c, error);
420 symval += NIBBLE (c);
421 c = srec_get_byte (abfd, &error);
424 if (c == EOF || ! isspace (c))
426 srec_bad_byte (abfd, lineno, c, error);
430 if (! srec_new_symbol (abfd, symname, symval))
447 /* Starting an S-record. */
449 pos = bfd_tell (abfd) - 1;
451 if (bfd_read (hdr, 1, 3, abfd) != 3)
454 if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
456 if (! ISHEX (hdr[1]))
460 srec_bad_byte (abfd, lineno, c, error);
464 bytes = HEX (hdr + 1);
465 if (bytes * 2 > bufsize)
469 buf = (bfd_byte *) malloc (bytes * 2);
472 bfd_set_error (bfd_error_no_memory);
478 if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
481 /* Ignore the checksum byte. */
490 /* Prologue--ignore the file name, but stop building a
491 section at this point. */
496 address = HEX (data);
501 address = (address << 8) | HEX (data);
506 address = (address << 8) | HEX (data);
508 address = (address << 8) | HEX (data);
513 && sec->vma + sec->_raw_size == address)
515 /* This data goes at the end of the section we are
516 currently building. */
517 sec->_raw_size += bytes;
524 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
525 secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
526 strcpy (secname, secbuf);
527 sec = bfd_make_section (abfd, secname);
530 sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
532 sec->_raw_size = bytes;
539 address = HEX (data);
543 address = (address << 8) | HEX (data);
547 address = (address << 8) | HEX (data);
549 address = (address << 8) | HEX (data);
552 /* This is a termination record. */
553 abfd->start_address = address;
579 /* Check whether an existing file is an S-record file. */
581 static const bfd_target *
589 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
590 || bfd_read (b, 1, 4, abfd) != 4)
593 if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
595 bfd_set_error (bfd_error_wrong_format);
599 if (! srec_mkobject (abfd)
600 || ! srec_scan (abfd))
606 /* Check whether an existing file is an S-record file with symbols. */
608 static const bfd_target *
609 symbolsrec_object_p (abfd)
616 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
617 || bfd_read (b, 1, 2, abfd) != 2)
620 if (b[0] != '$' || b[1] != '$')
622 bfd_set_error (bfd_error_wrong_format);
626 if (! srec_mkobject (abfd)
627 || ! srec_scan (abfd))
633 /* Read in the contents of a section in an S-record file. */
636 srec_read_section (abfd, section, contents)
642 bfd_size_type sofar = 0;
643 boolean error = false;
644 bfd_byte *buf = NULL;
647 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
650 while ((c = srec_get_byte (abfd, &error)) != EOF)
657 if (c == '\r' || c == '\n')
660 /* This is called after srec_scan has already been called, so we
661 ought to know the exact format. */
662 BFD_ASSERT (c == 'S');
664 if (bfd_read (hdr, 1, 3, abfd) != 3)
667 BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
669 bytes = HEX (hdr + 1);
671 if (bytes * 2 > bufsize)
675 buf = (bfd_byte *) malloc (bytes * 2);
678 bfd_set_error (bfd_error_no_memory);
684 if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
692 BFD_ASSERT (sofar == section->_raw_size);
698 address = HEX (data);
703 address = (address << 8) | HEX (data);
708 address = (address << 8) | HEX (data);
710 address = (address << 8) | HEX (data);
714 if (address != section->vma + sofar)
716 /* We've come to the end of this section. */
717 BFD_ASSERT (sofar == section->_raw_size);
723 /* Don't consider checksum. */
728 contents[sofar] = HEX (data);
740 BFD_ASSERT (sofar == section->_raw_size);
753 /* Get the contents of a section in an S-record file. */
756 srec_get_section_contents (abfd, section, location, offset, count)
763 if (section->used_by_bfd == NULL)
765 section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
766 if (section->used_by_bfd == NULL
767 && section->_raw_size != 0)
769 bfd_set_error (bfd_error_no_memory);
773 if (! srec_read_section (abfd, section, section->used_by_bfd))
777 memcpy (location, (bfd_byte *) section->used_by_bfd + offset, count);
782 /* we have to save up all the Srecords for a splurge before output,
786 srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
791 bfd_size_type bytes_to_do;
793 tdata_type *tdata = abfd->tdata.srec_data;
794 register srec_data_list_type *entry;
796 entry = ((srec_data_list_type *)
797 bfd_alloc (abfd, sizeof (srec_data_list_type)));
800 bfd_set_error (bfd_error_no_memory);
804 if ((section->flags & SEC_ALLOC)
805 && (section->flags & SEC_LOAD))
807 bfd_byte *data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
810 bfd_set_error (bfd_error_no_memory);
813 memcpy ((PTR) data, location, bytes_to_do);
815 if ((section->lma + offset + bytes_to_do) <= 0xffff)
819 else if ((section->lma + offset + bytes_to_do) <= 0xffffff
830 entry->where = section->lma + offset;
831 entry->size = bytes_to_do;
833 /* Sort the records by address. Optimize for the common case of
834 adding a record to the end of the list. */
835 if (tdata->tail != NULL
836 && entry->where >= tdata->tail->where)
838 tdata->tail->next = entry;
844 register srec_data_list_type **look;
846 for (look = &tdata->head;
847 *look != NULL && (*look)->where < entry->where;
848 look = &(*look)->next)
852 if (entry->next == NULL)
859 /* Write a record of type, of the supplied number of bytes. The
860 supplied bytes and length don't have a checksum. That's worked out
864 srec_write_record (abfd, type, address, data, end)
868 const bfd_byte *data;
871 char buffer[MAXCHUNK];
872 unsigned int check_sum = 0;
873 CONST bfd_byte *src = data;
881 dst += 2; /* leave room for dst*/
887 TOHEX (dst, (address >> 24), check_sum);
891 TOHEX (dst, (address >> 16), check_sum);
896 TOHEX (dst, (address >> 8), check_sum);
898 TOHEX (dst, (address), check_sum);
903 for (src = data; src < end; src++)
905 TOHEX (dst, *src, check_sum);
909 /* Fill in the length */
910 TOHEX (length, (dst - length) / 2, check_sum);
912 check_sum = 255 - check_sum;
913 TOHEX (dst, check_sum, check_sum);
918 if (bfd_write ((PTR) buffer, 1, dst - buffer, abfd) != dst - buffer)
926 srec_write_header (abfd)
929 bfd_byte buffer[MAXCHUNK];
930 bfd_byte *dst = buffer;
933 /* I'll put an arbitary 40 char limit on header size */
934 for (i = 0; i < 40 && abfd->filename[i]; i++)
936 *dst++ = abfd->filename[i];
938 return srec_write_record (abfd, 0, 0, buffer, dst);
942 srec_write_section (abfd, tdata, list)
945 srec_data_list_type *list;
947 unsigned int bytes_written = 0;
948 bfd_byte *location = list->data;
950 while (bytes_written < list->size)
954 unsigned int bytes_this_chunk = list->size - bytes_written;
956 if (bytes_this_chunk > CHUNK)
958 bytes_this_chunk = CHUNK;
961 address = list->where + bytes_written;
963 if (! srec_write_record (abfd,
967 location + bytes_this_chunk))
970 bytes_written += bytes_this_chunk;
971 location += bytes_this_chunk;
978 srec_write_terminator (abfd, tdata)
984 return srec_write_record (abfd, 10 - tdata->type,
985 abfd->start_address, buffer, buffer);
991 srec_write_symbols (abfd)
994 char buffer[MAXCHUNK];
995 /* Dump out the symbols of a bfd */
997 int count = bfd_get_symcount (abfd);
1002 asymbol **table = bfd_get_outsymbols (abfd);
1003 sprintf (buffer, "$$ %s\r\n", abfd->filename);
1005 len = strlen (buffer);
1006 if (bfd_write (buffer, len, 1, abfd) != len)
1009 for (i = 0; i < count; i++)
1011 asymbol *s = table[i];
1013 int len = strlen (s->name);
1015 /* If this symbol has a .[ocs] in it, it's probably a file name
1016 and we'll output that as the module name */
1018 if (len > 3 && s->name[len - 2] == '.')
1021 sprintf (buffer, "$$ %s\r\n", s->name);
1022 l = strlen (buffer);
1023 if (bfd_write (buffer, l, 1, abfd) != l)
1028 if (s->flags & (BSF_GLOBAL | BSF_LOCAL)
1029 && (s->flags & BSF_DEBUGGING) == 0
1030 && s->name[0] != '.'
1031 && s->name[0] != 't')
1033 /* Just dump out non debug symbols */
1039 s->value + s->section->output_section->lma
1040 + s->section->output_offset);
1042 while (p[0] == '0' && p[1] != 0)
1044 sprintf (buffer, " %s $%s\r\n", s->name, p);
1045 l = strlen (buffer);
1046 if (bfd_write (buffer, l, 1, abfd) != l)
1050 sprintf (buffer, "$$ \r\n");
1051 len = strlen (buffer);
1052 if (bfd_write (buffer, len, 1, abfd) != len)
1060 internal_srec_write_object_contents (abfd, symbols)
1064 tdata_type *tdata = abfd->tdata.srec_data;
1065 srec_data_list_type *list;
1069 if (! srec_write_symbols (abfd))
1073 if (! srec_write_header (abfd))
1076 /* Now wander though all the sections provided and output them */
1079 while (list != (srec_data_list_type *) NULL)
1081 if (! srec_write_section (abfd, tdata, list))
1085 return srec_write_terminator (abfd, tdata);
1089 srec_write_object_contents (abfd)
1092 return internal_srec_write_object_contents (abfd, 0);
1096 symbolsrec_write_object_contents (abfd)
1099 return internal_srec_write_object_contents (abfd, 1);
1104 srec_sizeof_headers (abfd, exec)
1112 srec_make_empty_symbol (abfd)
1115 asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
1117 new->the_bfd = abfd;
1121 /* Return the amount of memory needed to read the symbol table. */
1124 srec_get_symtab_upper_bound (abfd)
1127 return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1130 /* Return the symbol table. */
1133 srec_get_symtab (abfd, alocation)
1135 asymbol **alocation;
1137 unsigned int symcount = bfd_get_symcount (abfd);
1141 csymbols = abfd->tdata.srec_data->csymbols;
1142 if (csymbols == NULL)
1145 struct srec_symbol *s;
1147 csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
1148 if (csymbols == NULL && symcount != 0)
1150 bfd_set_error (bfd_error_no_memory);
1153 abfd->tdata.srec_data->csymbols = csymbols;
1155 for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1162 c->flags = BSF_GLOBAL;
1163 c->section = bfd_abs_section_ptr;
1168 for (i = 0; i < symcount; i++)
1169 *alocation++ = csymbols++;
1177 srec_get_symbol_info (ignore_abfd, symbol, ret)
1182 bfd_symbol_info (symbol, ret);
1187 srec_print_symbol (ignore_abfd, afile, symbol, how)
1191 bfd_print_symbol_type how;
1193 FILE *file = (FILE *) afile;
1196 case bfd_print_symbol_name:
1197 fprintf (file, "%s", symbol->name);
1200 bfd_print_symbol_vandf ((PTR) file, symbol);
1201 fprintf (file, " %-5s %s",
1202 symbol->section->name,
1208 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup
1209 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1210 #define srec_new_section_hook _bfd_generic_new_section_hook
1212 #define srec_bfd_is_local_label bfd_generic_is_local_label
1213 #define srec_get_lineno _bfd_nosymbols_get_lineno
1214 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
1215 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1217 #define srec_get_reloc_upper_bound \
1218 ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
1219 #define srec_canonicalize_reloc \
1220 ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
1221 #define srec_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
1223 #define srec_set_arch_mach bfd_default_set_arch_mach
1225 #define srec_bfd_get_relocated_section_contents \
1226 bfd_generic_get_relocated_section_contents
1227 #define srec_bfd_relax_section bfd_generic_relax_section
1228 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1229 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
1230 #define srec_bfd_final_link _bfd_generic_final_link
1232 const bfd_target srec_vec =
1235 bfd_target_srec_flavour,
1236 true, /* target byte order */
1237 true, /* target headers byte order */
1238 (HAS_RELOC | EXEC_P | /* object flags */
1239 HAS_LINENO | HAS_DEBUG |
1240 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1241 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1242 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1243 0, /* leading underscore */
1244 ' ', /* ar_pad_char */
1245 16, /* ar_max_namelen */
1246 1, /* minimum alignment */
1247 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1248 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1249 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1250 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1251 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1252 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1256 srec_object_p, /* bfd_check_format */
1263 _bfd_generic_mkarchive,
1266 { /* bfd_write_contents */
1268 srec_write_object_contents,
1269 _bfd_write_archive_contents,
1273 BFD_JUMP_TABLE_GENERIC (srec),
1274 BFD_JUMP_TABLE_COPY (_bfd_generic),
1275 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1276 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1277 BFD_JUMP_TABLE_SYMBOLS (srec),
1278 BFD_JUMP_TABLE_RELOCS (srec),
1279 BFD_JUMP_TABLE_WRITE (srec),
1280 BFD_JUMP_TABLE_LINK (srec),
1281 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1288 const bfd_target symbolsrec_vec =
1290 "symbolsrec", /* name */
1291 bfd_target_srec_flavour,
1292 true, /* target byte order */
1293 true, /* target headers byte order */
1294 (HAS_RELOC | EXEC_P | /* object flags */
1295 HAS_LINENO | HAS_DEBUG |
1296 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1297 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1298 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1299 0, /* leading underscore */
1300 ' ', /* ar_pad_char */
1301 16, /* ar_max_namelen */
1302 1, /* minimum alignment */
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, /* data */
1306 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1307 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1308 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1312 symbolsrec_object_p, /* bfd_check_format */
1319 _bfd_generic_mkarchive,
1322 { /* bfd_write_contents */
1324 symbolsrec_write_object_contents,
1325 _bfd_write_archive_contents,
1329 BFD_JUMP_TABLE_GENERIC (srec),
1330 BFD_JUMP_TABLE_COPY (_bfd_generic),
1331 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1332 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1333 BFD_JUMP_TABLE_SYMBOLS (srec),
1334 BFD_JUMP_TABLE_RELOCS (srec),
1335 BFD_JUMP_TABLE_WRITE (srec),
1336 BFD_JUMP_TABLE_LINK (srec),
1337 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),