1 /* BFD back-end for s-record objects.
2 Copyright (C) 1990-2018 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 _bfd_srec_len = 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 _bfd_srec_forceS3 = 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 /* xgettext:c-format */
260 (_("%B:%d: Unexpected character `%s' in S-record file\n"),
262 bfd_set_error (bfd_error_bad_value);
266 /* Add a new symbol found in an S-record file. */
269 srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)
271 struct srec_symbol *n;
273 n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n));
280 if (abfd->tdata.srec_data->symbols == NULL)
281 abfd->tdata.srec_data->symbols = n;
283 abfd->tdata.srec_data->symtail->next = n;
284 abfd->tdata.srec_data->symtail = n;
292 /* Read the S record file and turn it into sections. We create a new
293 section for each contiguous set of bytes. */
296 srec_scan (bfd *abfd)
299 unsigned int lineno = 1;
300 bfd_boolean error = FALSE;
301 bfd_byte *buf = NULL;
303 asection *sec = NULL;
306 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
309 while ((c = srec_get_byte (abfd, &error)) != EOF)
311 /* We only build sections from contiguous S-records, so if this
312 is not an S-record, then stop building a section. */
313 if (c != 'S' && c != '\r' && c != '\n')
319 srec_bad_byte (abfd, lineno, c, error);
330 /* Starting a module name, which we ignore. */
331 while ((c = srec_get_byte (abfd, &error)) != '\n'
336 srec_bad_byte (abfd, lineno, c, error);
350 /* Starting a symbol definition. */
351 while ((c = srec_get_byte (abfd, &error)) != EOF
352 && (c == ' ' || c == '\t'))
355 if (c == '\n' || c == '\r')
360 srec_bad_byte (abfd, lineno, c, error);
365 symbuf = (char *) bfd_malloc (alc + 1);
372 while ((c = srec_get_byte (abfd, &error)) != EOF
375 if ((bfd_size_type) (p - symbuf) >= alc)
380 n = (char *) bfd_realloc (symbuf, alc + 1);
383 p = n + (p - symbuf);
392 srec_bad_byte (abfd, lineno, c, error);
397 symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
400 strcpy (symname, symbuf);
404 while ((c = srec_get_byte (abfd, &error)) != EOF
405 && (c == ' ' || c == '\t'))
409 srec_bad_byte (abfd, lineno, c, error);
413 /* Skip a dollar sign before the hex value. */
416 c = srec_get_byte (abfd, &error);
419 srec_bad_byte (abfd, lineno, c, error);
428 symval += NIBBLE (c);
429 c = srec_get_byte (abfd, &error);
432 srec_bad_byte (abfd, lineno, c, error);
437 if (! srec_new_symbol (abfd, symname, symval))
440 while (c == ' ' || c == '\t')
447 srec_bad_byte (abfd, lineno, c, error);
456 unsigned char hdr[3];
457 unsigned int bytes, min_bytes;
460 unsigned char check_sum;
462 /* Starting an S-record. */
464 pos = bfd_tell (abfd) - 1;
466 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
469 if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
471 if (! ISHEX (hdr[1]))
475 srec_bad_byte (abfd, lineno, c, error);
479 check_sum = bytes = HEX (hdr + 1);
481 if (hdr[0] == '2' || hdr[0] == '8')
483 else if (hdr[0] == '3' || hdr[0] == '7')
485 if (bytes < min_bytes)
487 /* xgettext:c-format */
488 _bfd_error_handler (_("%B:%d: byte count %d too small\n"),
489 abfd, lineno, bytes);
490 bfd_set_error (bfd_error_bad_value);
494 if (bytes * 2 > bufsize)
498 buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
504 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
507 /* Ignore the checksum byte. */
516 /* Prologue--ignore the file name, but stop building a
517 section at this point. */
522 check_sum += HEX (data);
523 address = HEX (data);
528 check_sum += HEX (data);
529 address = (address << 8) | HEX (data);
534 check_sum += HEX (data);
535 address = (address << 8) | HEX (data);
537 check_sum += HEX (data);
538 address = (address << 8) | HEX (data);
543 && sec->vma + sec->size == address)
545 /* This data goes at the end of the section we are
546 currently building. */
556 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
557 amt = strlen (secbuf) + 1;
558 secname = (char *) bfd_alloc (abfd, amt);
559 strcpy (secname, secbuf);
560 flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
561 sec = bfd_make_section_with_flags (abfd, secname, flags);
572 check_sum += HEX (data);
576 check_sum = 255 - (check_sum & 0xff);
577 if (check_sum != HEX (data))
580 /* xgettext:c-format */
581 (_("%B:%d: Bad checksum in S-record file\n"),
583 bfd_set_error (bfd_error_bad_value);
590 check_sum += HEX (data);
591 address = HEX (data);
595 check_sum += HEX (data);
596 address = (address << 8) | HEX (data);
600 check_sum += HEX (data);
601 address = (address << 8) | HEX (data);
603 check_sum += HEX (data);
604 address = (address << 8) | HEX (data);
607 /* This is a termination record. */
608 abfd->start_address = address;
610 check_sum = 255 - (check_sum & 0xff);
611 if (check_sum != HEX (data))
614 /* xgettext:c-format */
615 (_("%B:%d: Bad checksum in S-record file\n"),
617 bfd_set_error (bfd_error_bad_value);
647 /* Check whether an existing file is an S-record file. */
649 static const bfd_target *
650 srec_object_p (bfd *abfd)
657 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
658 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
661 if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
663 bfd_set_error (bfd_error_wrong_format);
667 tdata_save = abfd->tdata.any;
668 if (! srec_mkobject (abfd) || ! srec_scan (abfd))
670 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
671 bfd_release (abfd, abfd->tdata.any);
672 abfd->tdata.any = tdata_save;
676 if (abfd->symcount > 0)
677 abfd->flags |= HAS_SYMS;
682 /* Check whether an existing file is an S-record file with symbols. */
684 static const bfd_target *
685 symbolsrec_object_p (bfd *abfd)
692 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
693 || bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
696 if (b[0] != '$' || b[1] != '$')
698 bfd_set_error (bfd_error_wrong_format);
702 tdata_save = abfd->tdata.any;
703 if (! srec_mkobject (abfd) || ! srec_scan (abfd))
705 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
706 bfd_release (abfd, abfd->tdata.any);
707 abfd->tdata.any = tdata_save;
711 if (abfd->symcount > 0)
712 abfd->flags |= HAS_SYMS;
717 /* Read in the contents of a section in an S-record file. */
720 srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
723 bfd_size_type sofar = 0;
724 bfd_boolean error = FALSE;
725 bfd_byte *buf = NULL;
728 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
731 while ((c = srec_get_byte (abfd, &error)) != EOF)
738 if (c == '\r' || c == '\n')
741 /* This is called after srec_scan has already been called, so we
742 ought to know the exact format. */
743 BFD_ASSERT (c == 'S');
745 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
748 BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
750 bytes = HEX (hdr + 1);
752 if (bytes * 2 > bufsize)
756 buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
762 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
770 BFD_ASSERT (sofar == section->size);
776 address = HEX (data);
781 address = (address << 8) | HEX (data);
786 address = (address << 8) | HEX (data);
788 address = (address << 8) | HEX (data);
792 if (address != section->vma + sofar)
794 /* We've come to the end of this section. */
795 BFD_ASSERT (sofar == section->size);
801 /* Don't consider checksum. */
806 contents[sofar] = HEX (data);
818 BFD_ASSERT (sofar == section->size);
831 /* Get the contents of a section in an S-record file. */
834 srec_get_section_contents (bfd *abfd,
843 if (offset + count < count
844 || offset + count > section->size)
846 bfd_set_error (bfd_error_invalid_operation);
850 if (section->used_by_bfd == NULL)
852 section->used_by_bfd = bfd_alloc (abfd, section->size);
853 if (section->used_by_bfd == NULL)
856 if (! srec_read_section (abfd, section,
857 (bfd_byte *) section->used_by_bfd))
861 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
867 /* Set the architecture. We accept an unknown architecture here. */
870 srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
872 if (arch != bfd_arch_unknown)
873 return bfd_default_set_arch_mach (abfd, arch, mach);
875 abfd->arch_info = & bfd_default_arch_struct;
879 /* We have to save up all the Srecords for a splurge before output. */
882 srec_set_section_contents (bfd *abfd,
884 const void * location,
886 bfd_size_type bytes_to_do)
888 int opb = bfd_octets_per_byte (abfd);
889 tdata_type *tdata = abfd->tdata.srec_data;
890 srec_data_list_type *entry;
892 entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
897 && (section->flags & SEC_ALLOC)
898 && (section->flags & SEC_LOAD))
902 data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
905 memcpy ((void *) data, location, (size_t) bytes_to_do);
907 /* If _bfd_srec_forceS3 is TRUE then always select S3 records,
908 regardless of the size of the addresses. */
909 if (_bfd_srec_forceS3)
911 else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffff)
912 ; /* The default, S1, is OK. */
913 else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffffff
920 entry->where = section->lma + offset / opb;
921 entry->size = bytes_to_do;
923 /* Sort the records by address. Optimize for the common case of
924 adding a record to the end of the list. */
925 if (tdata->tail != NULL
926 && entry->where >= tdata->tail->where)
928 tdata->tail->next = entry;
934 srec_data_list_type **look;
936 for (look = &tdata->head;
937 *look != NULL && (*look)->where < entry->where;
938 look = &(*look)->next)
942 if (entry->next == NULL)
949 /* Write a record of type, of the supplied number of bytes. The
950 supplied bytes and length don't have a checksum. That's worked out
954 srec_write_record (bfd *abfd,
957 const bfd_byte *data,
960 char buffer[2 * MAXCHUNK + 6];
961 unsigned int check_sum = 0;
962 const bfd_byte *src = data;
971 dst += 2; /* Leave room for dst. */
977 TOHEX (dst, (address >> 24), check_sum);
982 TOHEX (dst, (address >> 16), check_sum);
988 TOHEX (dst, (address >> 8), check_sum);
990 TOHEX (dst, (address), check_sum);
995 for (src = data; src < end; src++)
997 TOHEX (dst, *src, check_sum);
1001 /* Fill in the length. */
1002 TOHEX (length, (dst - length) / 2, check_sum);
1004 check_sum = 255 - check_sum;
1005 TOHEX (dst, check_sum, check_sum);
1010 wrlen = dst - buffer;
1012 return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
1016 srec_write_header (bfd *abfd)
1018 unsigned int len = strlen (abfd->filename);
1020 /* I'll put an arbitrary 40 char limit on header size. */
1024 return srec_write_record (abfd, 0, (bfd_vma) 0,
1025 (bfd_byte *) abfd->filename,
1026 (bfd_byte *) abfd->filename + len);
1030 srec_write_section (bfd *abfd,
1032 srec_data_list_type *list)
1034 unsigned int octets_written = 0;
1035 bfd_byte *location = list->data;
1037 /* Validate number of data bytes to write. The srec length byte
1038 counts the address, data and crc bytes. S1 (tdata->type == 1)
1039 records have two address bytes, S2 (tdata->type == 2) records
1040 have three, and S3 (tdata->type == 3) records have four.
1041 The total length can't exceed 255, and a zero data length will
1042 spin for a long time. */
1043 if (_bfd_srec_len == 0)
1045 else if (_bfd_srec_len > MAXCHUNK - tdata->type - 2)
1046 _bfd_srec_len = MAXCHUNK - tdata->type - 2;
1048 while (octets_written < list->size)
1051 unsigned int octets_this_chunk = list->size - octets_written;
1053 if (octets_this_chunk > _bfd_srec_len)
1054 octets_this_chunk = _bfd_srec_len;
1056 address = list->where + octets_written / bfd_octets_per_byte (abfd);
1058 if (! srec_write_record (abfd,
1062 location + octets_this_chunk))
1065 octets_written += octets_this_chunk;
1066 location += octets_this_chunk;
1073 srec_write_terminator (bfd *abfd, tdata_type *tdata)
1075 return srec_write_record (abfd, 10 - tdata->type,
1076 abfd->start_address, NULL, NULL);
1080 srec_write_symbols (bfd *abfd)
1082 /* Dump out the symbols of a bfd. */
1084 int count = bfd_get_symcount (abfd);
1089 asymbol **table = bfd_get_outsymbols (abfd);
1091 len = strlen (abfd->filename);
1092 if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
1093 || bfd_bwrite (abfd->filename, len, abfd) != len
1094 || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
1097 for (i = 0; i < count; i++)
1099 asymbol *s = table[i];
1100 if (! bfd_is_local_label (abfd, s)
1101 && (s->flags & BSF_DEBUGGING) == 0)
1103 /* Just dump out non debug symbols. */
1106 len = strlen (s->name);
1107 if (bfd_bwrite (" ", (bfd_size_type) 2, abfd) != 2
1108 || bfd_bwrite (s->name, len, abfd) != len)
1111 sprintf_vma (buf + 2, (s->value
1112 + s->section->output_section->lma
1113 + s->section->output_offset));
1115 while (p[0] == '0' && p[1] != 0)
1123 if (bfd_bwrite (p, len, abfd) != len)
1127 if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
1135 internal_srec_write_object_contents (bfd *abfd, int symbols)
1137 tdata_type *tdata = abfd->tdata.srec_data;
1138 srec_data_list_type *list;
1142 if (! srec_write_symbols (abfd))
1146 if (! srec_write_header (abfd))
1149 /* Now wander though all the sections provided and output them. */
1152 while (list != (srec_data_list_type *) NULL)
1154 if (! srec_write_section (abfd, tdata, list))
1158 return srec_write_terminator (abfd, tdata);
1162 srec_write_object_contents (bfd *abfd)
1164 return internal_srec_write_object_contents (abfd, 0);
1168 symbolsrec_write_object_contents (bfd *abfd)
1170 return internal_srec_write_object_contents (abfd, 1);
1174 srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1175 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1180 /* Return the amount of memory needed to read the symbol table. */
1183 srec_get_symtab_upper_bound (bfd *abfd)
1185 return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1188 /* Return the symbol table. */
1191 srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1193 bfd_size_type symcount = bfd_get_symcount (abfd);
1197 csymbols = abfd->tdata.srec_data->csymbols;
1198 if (csymbols == NULL && symcount != 0)
1201 struct srec_symbol *s;
1203 csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
1204 if (csymbols == NULL)
1206 abfd->tdata.srec_data->csymbols = csymbols;
1208 for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1215 c->flags = BSF_GLOBAL;
1216 c->section = bfd_abs_section_ptr;
1221 for (i = 0; i < symcount; i++)
1222 *alocation++ = csymbols++;
1229 srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1233 bfd_symbol_info (symbol, ret);
1237 srec_print_symbol (bfd *abfd,
1240 bfd_print_symbol_type how)
1242 FILE *file = (FILE *) afile;
1246 case bfd_print_symbol_name:
1247 fprintf (file, "%s", symbol->name);
1250 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1251 fprintf (file, " %-5s %s",
1252 symbol->section->name,
1257 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup
1258 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1259 #define srec_new_section_hook _bfd_generic_new_section_hook
1260 #define srec_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
1261 #define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
1262 #define srec_get_lineno _bfd_nosymbols_get_lineno
1263 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
1264 #define srec_find_line _bfd_nosymbols_find_line
1265 #define srec_find_inliner_info _bfd_nosymbols_find_inliner_info
1266 #define srec_make_empty_symbol _bfd_generic_make_empty_symbol
1267 #define srec_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
1268 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1269 #define srec_read_minisymbols _bfd_generic_read_minisymbols
1270 #define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1271 #define srec_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
1272 #define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
1273 #define srec_bfd_relax_section bfd_generic_relax_section
1274 #define srec_bfd_gc_sections bfd_generic_gc_sections
1275 #define srec_bfd_lookup_section_flags bfd_generic_lookup_section_flags
1276 #define srec_bfd_merge_sections bfd_generic_merge_sections
1277 #define srec_bfd_is_group_section bfd_generic_is_group_section
1278 #define srec_bfd_discard_group bfd_generic_discard_group
1279 #define srec_section_already_linked _bfd_generic_section_already_linked
1280 #define srec_bfd_define_common_symbol bfd_generic_define_common_symbol
1281 #define srec_bfd_define_start_stop bfd_generic_define_start_stop
1282 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1283 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
1284 #define srec_bfd_link_just_syms _bfd_generic_link_just_syms
1285 #define srec_bfd_copy_link_hash_symbol_type _bfd_generic_copy_link_hash_symbol_type
1286 #define srec_bfd_final_link _bfd_generic_final_link
1287 #define srec_bfd_link_split_section _bfd_generic_link_split_section
1288 #define srec_bfd_link_check_relocs _bfd_generic_link_check_relocs
1290 const bfd_target srec_vec =
1293 bfd_target_srec_flavour,
1294 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
1295 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
1296 (HAS_RELOC | EXEC_P | /* Object flags. */
1297 HAS_LINENO | HAS_DEBUG |
1298 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1299 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1300 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
1301 0, /* Leading underscore. */
1302 ' ', /* AR_pad_char. */
1303 16, /* AR_max_namelen. */
1304 0, /* match priority. */
1305 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1306 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1307 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
1308 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1309 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1310 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */
1314 srec_object_p, /* bfd_check_format. */
1319 _bfd_bool_bfd_false_error,
1321 _bfd_generic_mkarchive,
1322 _bfd_bool_bfd_false_error,
1324 { /* bfd_write_contents. */
1325 _bfd_bool_bfd_false_error,
1326 srec_write_object_contents,
1327 _bfd_write_archive_contents,
1328 _bfd_bool_bfd_false_error,
1331 BFD_JUMP_TABLE_GENERIC (srec),
1332 BFD_JUMP_TABLE_COPY (_bfd_generic),
1333 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1334 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1335 BFD_JUMP_TABLE_SYMBOLS (srec),
1336 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1337 BFD_JUMP_TABLE_WRITE (srec),
1338 BFD_JUMP_TABLE_LINK (srec),
1339 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1346 const bfd_target symbolsrec_vec =
1348 "symbolsrec", /* Name. */
1349 bfd_target_srec_flavour,
1350 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
1351 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
1352 (HAS_RELOC | EXEC_P | /* Object flags. */
1353 HAS_LINENO | HAS_DEBUG |
1354 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1355 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1356 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
1357 0, /* Leading underscore. */
1358 ' ', /* AR_pad_char. */
1359 16, /* AR_max_namelen. */
1360 0, /* match priority. */
1361 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1362 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1363 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
1364 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1365 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1366 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
1370 symbolsrec_object_p, /* bfd_check_format. */
1375 _bfd_bool_bfd_false_error,
1377 _bfd_generic_mkarchive,
1378 _bfd_bool_bfd_false_error,
1380 { /* bfd_write_contents. */
1381 _bfd_bool_bfd_false_error,
1382 symbolsrec_write_object_contents,
1383 _bfd_write_archive_contents,
1384 _bfd_bool_bfd_false_error,
1387 BFD_JUMP_TABLE_GENERIC (srec),
1388 BFD_JUMP_TABLE_COPY (_bfd_generic),
1389 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1390 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1391 BFD_JUMP_TABLE_SYMBOLS (srec),
1392 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1393 BFD_JUMP_TABLE_WRITE (srec),
1394 BFD_JUMP_TABLE_LINK (srec),
1395 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),