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"
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 *, 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 tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
241 abfd->tdata.srec_data = tdata;
245 tdata->symbols = NULL;
246 tdata->symtail = NULL;
247 tdata->csymbols = NULL;
253 /* Read a byte from an S record file. Set *ERRORPTR if an error
254 occurred. Return EOF on error or end of file. */
257 srec_get_byte (abfd, errorptr)
263 if (bfd_read (&c, 1, 1, abfd) != 1)
265 if (bfd_get_error () != bfd_error_file_truncated)
270 return (int) (c & 0xff);
273 /* Report a problem in an S record file. FIXME: This probably should
274 not call fprintf, but we really do need some mechanism for printing
278 srec_bad_byte (abfd, lineno, c, error)
287 bfd_set_error (bfd_error_file_truncated);
294 sprintf (buf, "\\%03o", (unsigned int) c);
300 (*_bfd_error_handler)
301 (_("%s:%d: Unexpected character `%s' in S-record file\n"),
302 bfd_get_filename (abfd), lineno, buf);
303 bfd_set_error (bfd_error_bad_value);
307 /* Add a new symbol found in an S-record file. */
310 srec_new_symbol (abfd, name, val)
315 struct srec_symbol *n;
317 n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (struct srec_symbol));
324 if (abfd->tdata.srec_data->symbols == NULL)
325 abfd->tdata.srec_data->symbols = n;
327 abfd->tdata.srec_data->symtail->next = n;
328 abfd->tdata.srec_data->symtail = n;
336 /* Read the S record file and turn it into sections. We create a new
337 section for each contiguous set of bytes. */
344 unsigned int lineno = 1;
345 boolean error = false;
346 bfd_byte *buf = NULL;
348 asection *sec = NULL;
351 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
354 while ((c = srec_get_byte (abfd, &error)) != EOF)
356 /* We only build sections from contiguous S-records, so if this
357 is not an S-record, then stop building a section. */
358 if (c != 'S' && c != '\r' && c != '\n')
364 srec_bad_byte (abfd, lineno, c, error);
375 /* Starting a module name, which we ignore. */
376 while ((c = srec_get_byte (abfd, &error)) != '\n'
381 srec_bad_byte (abfd, lineno, c, error);
396 /* Starting a symbol definition. */
397 while ((c = srec_get_byte (abfd, &error)) != EOF
398 && (c == ' ' || c == '\t'))
401 if (c == '\n' || c == '\r')
406 srec_bad_byte (abfd, lineno, c, error);
411 symbuf = (char *) bfd_malloc (alc + 1);
418 while ((c = srec_get_byte (abfd, &error)) != EOF
421 if ((unsigned int) (p - symbuf) >= alc)
426 n = (char *) bfd_realloc (symbuf, alc + 1);
429 p = n + (p - symbuf);
438 srec_bad_byte (abfd, lineno, c, error);
443 symname = bfd_alloc (abfd, p - symbuf);
446 strcpy (symname, symbuf);
450 while ((c = srec_get_byte (abfd, &error)) != EOF
451 && (c == ' ' || c == '\t'))
455 srec_bad_byte (abfd, lineno, c, error);
459 /* Skip a dollar sign before the hex value. */
462 c = srec_get_byte (abfd, &error);
465 srec_bad_byte (abfd, lineno, c, error);
474 symval += NIBBLE (c);
475 c = srec_get_byte (abfd, &error);
478 if (! srec_new_symbol (abfd, symname, symval))
481 while (c == ' ' || c == '\t')
488 srec_bad_byte (abfd, lineno, c, error);
502 /* Starting an S-record. */
504 pos = bfd_tell (abfd) - 1;
506 if (bfd_read (hdr, 1, 3, abfd) != 3)
509 if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
511 if (! ISHEX (hdr[1]))
515 srec_bad_byte (abfd, lineno, c, error);
519 bytes = HEX (hdr + 1);
520 if (bytes * 2 > bufsize)
524 buf = (bfd_byte *) bfd_malloc (bytes * 2);
530 if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
533 /* Ignore the checksum byte. */
542 /* Prologue--ignore the file name, but stop building a
543 section at this point. */
548 address = HEX (data);
553 address = (address << 8) | HEX (data);
558 address = (address << 8) | HEX (data);
560 address = (address << 8) | HEX (data);
565 && sec->vma + sec->_raw_size == address)
567 /* This data goes at the end of the section we are
568 currently building. */
569 sec->_raw_size += bytes;
576 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
577 secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
578 strcpy (secname, secbuf);
579 sec = bfd_make_section (abfd, secname);
582 sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
585 sec->_raw_size = bytes;
592 address = HEX (data);
596 address = (address << 8) | HEX (data);
600 address = (address << 8) | HEX (data);
602 address = (address << 8) | HEX (data);
605 /* This is a termination record. */
606 abfd->start_address = address;
634 /* Check whether an existing file is an S-record file. */
636 static const bfd_target *
644 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
645 || bfd_read (b, 1, 4, abfd) != 4)
648 if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
650 bfd_set_error (bfd_error_wrong_format);
654 if (! srec_mkobject (abfd)
655 || ! srec_scan (abfd))
658 if (abfd->symcount > 0)
659 abfd->flags |= HAS_SYMS;
664 /* Check whether an existing file is an S-record file with symbols. */
666 static const bfd_target *
667 symbolsrec_object_p (abfd)
674 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
675 || bfd_read (b, 1, 2, abfd) != 2)
678 if (b[0] != '$' || b[1] != '$')
680 bfd_set_error (bfd_error_wrong_format);
684 if (! srec_mkobject (abfd)
685 || ! srec_scan (abfd))
688 if (abfd->symcount > 0)
689 abfd->flags |= HAS_SYMS;
694 /* Read in the contents of a section in an S-record file. */
697 srec_read_section (abfd, section, contents)
703 bfd_size_type sofar = 0;
704 boolean error = false;
705 bfd_byte *buf = NULL;
708 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
711 while ((c = srec_get_byte (abfd, &error)) != EOF)
718 if (c == '\r' || c == '\n')
721 /* This is called after srec_scan has already been called, so we
722 ought to know the exact format. */
723 BFD_ASSERT (c == 'S');
725 if (bfd_read (hdr, 1, 3, abfd) != 3)
728 BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
730 bytes = HEX (hdr + 1);
732 if (bytes * 2 > bufsize)
736 buf = (bfd_byte *) bfd_malloc (bytes * 2);
742 if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
750 BFD_ASSERT (sofar == section->_raw_size);
756 address = HEX (data);
761 address = (address << 8) | HEX (data);
766 address = (address << 8) | HEX (data);
768 address = (address << 8) | HEX (data);
772 if (address != section->vma + sofar)
774 /* We've come to the end of this section. */
775 BFD_ASSERT (sofar == section->_raw_size);
781 /* Don't consider checksum. */
786 contents[sofar] = HEX (data);
798 BFD_ASSERT (sofar == section->_raw_size);
811 /* Get the contents of a section in an S-record file. */
814 srec_get_section_contents (abfd, section, location, offset, count)
821 if (section->used_by_bfd == NULL)
823 section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
824 if (section->used_by_bfd == NULL
825 && section->_raw_size != 0)
828 if (! srec_read_section (abfd, section, section->used_by_bfd))
832 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
838 /* Set the architecture. We accept an unknown architecture here. */
841 srec_set_arch_mach (abfd, arch, mach)
843 enum bfd_architecture arch;
846 if (arch == bfd_arch_unknown)
848 abfd->arch_info = &bfd_default_arch_struct;
851 return bfd_default_set_arch_mach (abfd, arch, mach);
854 /* We have to save up all the Srecords for a splurge before output. */
857 srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
862 bfd_size_type bytes_to_do;
864 tdata_type *tdata = abfd->tdata.srec_data;
865 register srec_data_list_type *entry;
867 entry = ((srec_data_list_type *)
868 bfd_alloc (abfd, sizeof (srec_data_list_type)));
873 && (section->flags & SEC_ALLOC)
874 && (section->flags & SEC_LOAD))
876 bfd_byte *data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
879 memcpy ((PTR) data, location, (size_t) bytes_to_do);
881 /* Ff S3Forced is true then always select S3 records,
882 regardless of the siez of the addresses. */
885 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
886 ; /* The default, S1, is OK. */
887 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff
894 entry->where = section->lma + offset;
895 entry->size = bytes_to_do;
897 /* Sort the records by address. Optimize for the common case of
898 adding a record to the end of the list. */
899 if (tdata->tail != NULL
900 && entry->where >= tdata->tail->where)
902 tdata->tail->next = entry;
908 register srec_data_list_type **look;
910 for (look = &tdata->head;
911 *look != NULL && (*look)->where < entry->where;
912 look = &(*look)->next)
916 if (entry->next == NULL)
923 /* Write a record of type, of the supplied number of bytes. The
924 supplied bytes and length don't have a checksum. That's worked out
928 srec_write_record (abfd, type, address, data, end)
932 const bfd_byte *data;
935 char buffer[MAXCHUNK];
936 unsigned int check_sum = 0;
937 CONST bfd_byte *src = data;
946 dst += 2; /* Leave room for dst. */
952 TOHEX (dst, (address >> 24), check_sum);
956 TOHEX (dst, (address >> 16), check_sum);
961 TOHEX (dst, (address >> 8), check_sum);
963 TOHEX (dst, (address), check_sum);
968 for (src = data; src < end; src++)
970 TOHEX (dst, *src, check_sum);
974 /* Fill in the length. */
975 TOHEX (length, (dst - length) / 2, check_sum);
977 check_sum = 255 - check_sum;
978 TOHEX (dst, check_sum, check_sum);
983 wrlen = dst - buffer;
984 if (bfd_write ((PTR) buffer, 1, wrlen, abfd) != wrlen)
990 srec_write_header (abfd)
993 bfd_byte buffer[MAXCHUNK];
994 bfd_byte *dst = buffer;
997 /* I'll put an arbitary 40 char limit on header size. */
998 for (i = 0; i < 40 && abfd->filename[i]; i++)
999 *dst++ = abfd->filename[i];
1001 return srec_write_record (abfd, 0, 0, buffer, dst);
1005 srec_write_section (abfd, tdata, list)
1008 srec_data_list_type *list;
1010 unsigned int octets_written = 0;
1011 bfd_byte *location = list->data;
1013 while (octets_written < list->size)
1016 unsigned int octets_this_chunk = list->size - octets_written;
1018 if (octets_this_chunk > Chunk)
1019 octets_this_chunk = Chunk;
1021 address = list->where + octets_written / bfd_octets_per_byte (abfd);
1023 if (! srec_write_record (abfd,
1027 location + octets_this_chunk))
1030 octets_written += octets_this_chunk;
1031 location += octets_this_chunk;
1038 srec_write_terminator (abfd, tdata)
1044 return srec_write_record (abfd, 10 - tdata->type,
1045 abfd->start_address, buffer, buffer);
1049 srec_write_symbols (abfd)
1052 char buffer[MAXCHUNK];
1053 /* Dump out the symbols of a bfd. */
1055 int count = bfd_get_symcount (abfd);
1060 asymbol **table = bfd_get_outsymbols (abfd);
1061 sprintf (buffer, "$$ %s\r\n", abfd->filename);
1063 len = strlen (buffer);
1064 if (bfd_write (buffer, len, 1, abfd) != len)
1067 for (i = 0; i < count; i++)
1069 asymbol *s = table[i];
1070 if (! bfd_is_local_label (abfd, s)
1071 && (s->flags & BSF_DEBUGGING) == 0)
1073 /* Just dump out non debug symbols. */
1078 s->value + s->section->output_section->lma
1079 + s->section->output_offset);
1081 while (p[0] == '0' && p[1] != 0)
1083 sprintf (buffer, " %s $%s\r\n", s->name, p);
1084 l = strlen (buffer);
1085 if (bfd_write (buffer, l, 1, abfd) != l)
1089 sprintf (buffer, "$$ \r\n");
1090 len = strlen (buffer);
1091 if (bfd_write (buffer, len, 1, abfd) != len)
1099 internal_srec_write_object_contents (abfd, symbols)
1103 tdata_type *tdata = abfd->tdata.srec_data;
1104 srec_data_list_type *list;
1108 if (! srec_write_symbols (abfd))
1112 if (! srec_write_header (abfd))
1115 /* Now wander though all the sections provided and output them. */
1118 while (list != (srec_data_list_type *) NULL)
1120 if (! srec_write_section (abfd, tdata, list))
1124 return srec_write_terminator (abfd, tdata);
1128 srec_write_object_contents (abfd)
1131 return internal_srec_write_object_contents (abfd, 0);
1135 symbolsrec_write_object_contents (abfd)
1138 return internal_srec_write_object_contents (abfd, 1);
1142 srec_sizeof_headers (abfd, exec)
1143 bfd *abfd ATTRIBUTE_UNUSED;
1144 boolean exec ATTRIBUTE_UNUSED;
1150 srec_make_empty_symbol (abfd)
1153 asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
1155 new->the_bfd = abfd;
1159 /* Return the amount of memory needed to read the symbol table. */
1162 srec_get_symtab_upper_bound (abfd)
1165 return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1168 /* Return the symbol table. */
1171 srec_get_symtab (abfd, alocation)
1173 asymbol **alocation;
1175 unsigned int symcount = bfd_get_symcount (abfd);
1179 csymbols = abfd->tdata.srec_data->csymbols;
1180 if (csymbols == NULL)
1183 struct srec_symbol *s;
1185 csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
1186 if (csymbols == NULL && symcount != 0)
1188 abfd->tdata.srec_data->csymbols = csymbols;
1190 for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1197 c->flags = BSF_GLOBAL;
1198 c->section = bfd_abs_section_ptr;
1203 for (i = 0; i < symcount; i++)
1204 *alocation++ = csymbols++;
1211 srec_get_symbol_info (ignore_abfd, symbol, ret)
1212 bfd *ignore_abfd ATTRIBUTE_UNUSED;
1216 bfd_symbol_info (symbol, ret);
1220 srec_print_symbol (ignore_abfd, afile, symbol, how)
1221 bfd *ignore_abfd ATTRIBUTE_UNUSED;
1224 bfd_print_symbol_type how;
1226 FILE *file = (FILE *) afile;
1229 case bfd_print_symbol_name:
1230 fprintf (file, "%s", symbol->name);
1233 bfd_print_symbol_vandf ((PTR) file, symbol);
1234 fprintf (file, " %-5s %s",
1235 symbol->section->name,
1241 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup
1242 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1243 #define srec_new_section_hook _bfd_generic_new_section_hook
1245 #define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
1246 #define srec_get_lineno _bfd_nosymbols_get_lineno
1247 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
1248 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1249 #define srec_read_minisymbols _bfd_generic_read_minisymbols
1250 #define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1252 #define srec_get_reloc_upper_bound \
1253 ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
1254 #define srec_canonicalize_reloc \
1255 ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
1256 #define srec_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
1258 #define srec_get_section_contents_in_window \
1259 _bfd_generic_get_section_contents_in_window
1261 #define srec_bfd_get_relocated_section_contents \
1262 bfd_generic_get_relocated_section_contents
1263 #define srec_bfd_relax_section bfd_generic_relax_section
1264 #define srec_bfd_gc_sections bfd_generic_gc_sections
1265 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1266 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
1267 #define srec_bfd_final_link _bfd_generic_final_link
1268 #define srec_bfd_link_split_section _bfd_generic_link_split_section
1270 const bfd_target srec_vec =
1273 bfd_target_srec_flavour,
1274 BFD_ENDIAN_UNKNOWN, /* target byte order */
1275 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
1276 (HAS_RELOC | EXEC_P | /* object flags */
1277 HAS_LINENO | HAS_DEBUG |
1278 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1279 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1280 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1281 0, /* leading underscore */
1282 ' ', /* ar_pad_char */
1283 16, /* ar_max_namelen */
1284 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1285 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1286 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1287 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1288 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1289 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1293 srec_object_p, /* bfd_check_format */
1300 _bfd_generic_mkarchive,
1303 { /* bfd_write_contents */
1305 srec_write_object_contents,
1306 _bfd_write_archive_contents,
1310 BFD_JUMP_TABLE_GENERIC (srec),
1311 BFD_JUMP_TABLE_COPY (_bfd_generic),
1312 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1313 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1314 BFD_JUMP_TABLE_SYMBOLS (srec),
1315 BFD_JUMP_TABLE_RELOCS (srec),
1316 BFD_JUMP_TABLE_WRITE (srec),
1317 BFD_JUMP_TABLE_LINK (srec),
1318 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1325 const bfd_target symbolsrec_vec =
1327 "symbolsrec", /* name */
1328 bfd_target_srec_flavour,
1329 BFD_ENDIAN_UNKNOWN, /* target byte order */
1330 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
1331 (HAS_RELOC | EXEC_P | /* object flags */
1332 HAS_LINENO | HAS_DEBUG |
1333 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1334 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1335 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1336 0, /* leading underscore */
1337 ' ', /* ar_pad_char */
1338 16, /* ar_max_namelen */
1339 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1340 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1341 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1342 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1343 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1344 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1348 symbolsrec_object_p, /* bfd_check_format */
1355 _bfd_generic_mkarchive,
1358 { /* bfd_write_contents */
1360 symbolsrec_write_object_contents,
1361 _bfd_write_archive_contents,
1365 BFD_JUMP_TABLE_GENERIC (srec),
1366 BFD_JUMP_TABLE_COPY (_bfd_generic),
1367 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1368 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1369 BFD_JUMP_TABLE_SYMBOLS (srec),
1370 BFD_JUMP_TABLE_RELOCS (srec),
1371 BFD_JUMP_TABLE_WRITE (srec),
1372 BFD_JUMP_TABLE_LINK (srec),
1373 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),