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
110 /* Macros for converting between hex and binary */
112 static CONST
char digs
[] = "0123456789ABCDEF";
114 static char hex_value
[1 + (unsigned char) ~0];
117 #define NIBBLE(x) hex_value[(unsigned char)(x)]
118 #define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
119 #define TOHEX(d, x, ch) \
120 d[1] = digs[(x) & 0xf]; \
121 d[0] = digs[((x)>>4)&0xf]; \
123 #define ISHEX(x) (hex_value[(unsigned char)(x)] != NOT_HEX)
128 DEFUN_VOID (srec_init
)
131 static boolean inited
= false;
138 for (i
= 0; i
< sizeof (hex_value
); i
++)
140 hex_value
[i
] = NOT_HEX
;
143 for (i
= 0; i
< 10; i
++)
145 hex_value
[i
+ '0'] = i
;
148 for (i
= 0; i
< 6; i
++)
150 hex_value
[i
+ 'a'] = i
+ 10;
151 hex_value
[i
+ 'A'] = i
+ 10;
157 /* The maximum number of bytes on a line is FF */
158 #define MAXCHUNK 0xff
159 /* The number of bytes we fit onto a line on output */
162 /* We cannot output our srecords as we see them, we have to glue them
163 together, this is done in this structure : */
165 struct srec_data_list_struct
170 struct srec_data_list_struct
*next
;
174 typedef struct srec_data_list_struct srec_data_list_type
;
177 typedef struct srec_data_struct
179 srec_data_list_type
*head
;
182 int done_symbol_read
;
194 called once per input S-Record, used to work out vma and size of data.
197 static bfd_vma low
, high
;
201 size_symbols (abfd
, buf
, len
, val
)
208 abfd
->tdata
.srec_data
->string_size
+= len
+ 1;
212 fillup_symbols (abfd
, buf
, len
, val
)
218 if (!abfd
->tdata
.srec_data
->done_symbol_read
)
221 if (abfd
->tdata
.srec_data
->symbols
== 0)
223 abfd
->tdata
.srec_data
->symbols
= (asymbol
*) bfd_alloc (abfd
, abfd
->symcount
* sizeof (asymbol
));
224 abfd
->tdata
.srec_data
->strings
= (char *) bfd_alloc (abfd
, abfd
->tdata
.srec_data
->string_size
);
225 if (!abfd
->tdata
.srec_data
->symbols
|| !abfd
->tdata
.srec_data
->strings
)
227 bfd_set_error (bfd_error_no_memory
);
228 abort (); /* FIXME */
230 abfd
->tdata
.srec_data
->symbol_idx
= 0;
231 abfd
->tdata
.srec_data
->string_idx
= 0;
234 p
= abfd
->tdata
.srec_data
->symbols
+ abfd
->tdata
.srec_data
->symbol_idx
++;
236 p
->name
= abfd
->tdata
.srec_data
->strings
+ abfd
->tdata
.srec_data
->string_idx
;
237 memcpy ((char *) (p
->name
), buf
, len
+ 1);
238 abfd
->tdata
.srec_data
->string_idx
+= len
+ 1;
240 p
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
241 p
->section
= &bfd_abs_section
;
247 DEFUN (size_srec
, (abfd
, section
, address
, raw
, length
),
249 asection
* section AND
256 if (address
+ length
> high
)
257 high
= address
+ length
- 1;
262 called once per input S-Record, copies data from input into bfd_alloc'd area
267 DEFUN (fillup
, (abfd
, section
, address
, raw
, length
),
269 asection
* section AND
276 (bfd_byte
*) (section
->used_by_bfd
) + address
- section
->vma
;
277 /* length -1 because we don't read in the checksum */
278 for (i
= 0; i
< length
- 1; i
++)
286 /* Pass over an S-Record file, calling one of the above functions on each
293 return (x
== ' ' || x
== '\t' || x
== '\n' || x
== '\r');
296 skipwhite (src
, abfd
)
301 while (white (*src
) && !eof
)
303 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
309 DEFUN (srec_mkobject
, (abfd
),
312 if (abfd
->tdata
.srec_data
== 0)
314 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
317 bfd_set_error (bfd_error_no_memory
);
320 abfd
->tdata
.srec_data
= tdata
;
322 tdata
->head
= (srec_data_list_type
*) NULL
;
329 pass_over (abfd
, func
, symbolfunc
, section
)
332 void (*symbolfunc
) ();
335 unsigned int bytes_on_line
;
338 srec_mkobject (abfd
);
339 /* To the front of the file */
340 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
343 char buffer
[MAXCHUNK
];
348 /* Find first 'S' or $ */
349 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
358 /* Inside a symbol definition - just ignore the module name */
359 while (*src
!= '\n' && !eof
)
361 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
366 /* spaces - maybe just before a symbol */
367 while (*src
!= '\n' && *src
!= '\r' && white (*src
))
369 eof
= skipwhite (src
, abfd
);
374 char symbol
[MAXCHUNK
];
376 /* get the symbol part */
377 while (!eof
&& !white (*src
) && slen
< MAXCHUNK
)
379 symbol
[slen
++] = *src
;
380 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
383 eof
= skipwhite (src
, abfd
);
384 /* skip the $ for the hex value */
387 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
390 /* Scan off the hex number */
391 while (isxdigit (*src
))
396 else if (isupper (*src
))
398 val
+= *src
- 'A' + 10;
402 val
+= *src
- 'a' + 10;
404 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
406 symbolfunc (abfd
, symbol
, slen
, val
);
413 /* Fetch the type and the length */
414 bfd_read (src
, 1, 3, abfd
);
418 if (!ISHEX (src
[0]) || !ISHEX (src
[1]))
421 bytes_on_line
= HEX (src
);
423 if (bytes_on_line
> MAXCHUNK
/ 2)
427 bfd_read (src
, 1, bytes_on_line
* 2, abfd
);
433 /* Prologue - ignore */
441 address
= HEX (src
) | (address
<< 8);
445 address
= HEX (src
) | (address
<< 8);
447 address
= HEX (src
) | (address
<< 8);
450 func (abfd
, section
, address
, src
, bytes_on_line
);
465 /* We create one section called .text for all the contents,
466 and allocate enough room for the entire file. */
468 section
= bfd_make_section (abfd
, ".text");
469 section
->_raw_size
= 0;
470 section
->vma
= 0xffffffff;
473 pass_over (abfd
, size_srec
, size_symbols
, section
);
474 section
->_raw_size
= high
- low
;
476 section
->flags
= SEC_HAS_CONTENTS
| SEC_LOAD
| SEC_ALLOC
;
479 abfd
->flags
|= HAS_SYMS
;
484 DEFUN (srec_object_p
, (abfd
),
491 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
492 bfd_read (b
, 1, 4, abfd
);
494 if (b
[0] != 'S' || !ISHEX (b
[1]) || !ISHEX (b
[2]) || !ISHEX (b
[3]))
495 return (bfd_target
*) NULL
;
497 /* We create one section called .text for all the contents,
498 and allocate enough room for the entire file. */
500 return object_p (abfd
);
505 DEFUN (symbolsrec_object_p
, (abfd
),
512 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
513 bfd_read (b
, 1, 4, abfd
);
515 if (b
[0] != '$' || b
[1] != '$')
516 return (bfd_target
*) NULL
;
518 return object_p (abfd
);
523 DEFUN (srec_get_section_contents
, (abfd
, section
, location
, offset
, count
),
525 asection
* section AND
530 if (section
->used_by_bfd
== (PTR
) NULL
)
532 section
->used_by_bfd
= (PTR
) bfd_alloc (abfd
, section
->_raw_size
);
533 if (!section
->used_by_bfd
)
535 bfd_set_error (bfd_error_no_memory
);
539 pass_over (abfd
, fillup
, fillup_symbols
, section
);
541 memcpy ((PTR
) location
,
542 (PTR
) ((char *) (section
->used_by_bfd
) + offset
),
550 DEFUN (srec_set_arch_mach
, (abfd
, arch
, machine
),
552 enum bfd_architecture arch AND
553 unsigned long machine
)
555 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
559 /* we have to save up all the Srecords for a splurge before output,
563 DEFUN (srec_set_section_contents
, (abfd
, section
, location
, offset
, bytes_to_do
),
568 bfd_size_type bytes_to_do
)
570 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
571 srec_data_list_type
*entry
= (srec_data_list_type
*)
572 bfd_alloc (abfd
, sizeof (srec_data_list_type
));
576 bfd_set_error (bfd_error_no_memory
);
580 if ((section
->flags
& SEC_ALLOC
)
581 && (section
->flags
& SEC_LOAD
))
583 unsigned char *data
= (unsigned char *) bfd_alloc (abfd
, bytes_to_do
);
586 bfd_set_error (bfd_error_no_memory
);
589 memcpy (data
, location
, bytes_to_do
);
591 if ((section
->lma
+ offset
+ bytes_to_do
) <= 0xffff)
595 else if ((section
->lma
+ offset
+ bytes_to_do
) <= 0xffffff
606 entry
->where
= section
->lma
+ offset
;
607 entry
->size
= bytes_to_do
;
608 entry
->next
= tdata
->head
;
614 /* Write a record of type, of the supplied number of bytes. The
615 supplied bytes and length don't have a checksum. That's worked out
620 DEFUN (srec_write_record
, (abfd
, type
, address
, data
, end
),
624 CONST
unsigned char *data AND
625 CONST
unsigned char *end
)
628 char buffer
[MAXCHUNK
];
630 unsigned int check_sum
= 0;
631 CONST
unsigned char *src
= data
;
640 dst
+= 2; /* leave room for dst*/
646 TOHEX (dst
, (address
>> 24), check_sum
);
650 TOHEX (dst
, (address
>> 16), check_sum
);
655 TOHEX (dst
, (address
>> 8), check_sum
);
657 TOHEX (dst
, (address
), check_sum
);
662 for (src
= data
; src
< end
; src
++)
664 TOHEX (dst
, *src
, check_sum
);
668 /* Fill in the length */
669 TOHEX (length
, (dst
- length
) / 2, check_sum
);
671 check_sum
= 255 - check_sum
;
672 TOHEX (dst
, check_sum
, check_sum
);
677 bfd_write ((PTR
) buffer
, 1, dst
- buffer
, abfd
);
683 DEFUN (srec_write_header
, (abfd
),
686 unsigned char buffer
[MAXCHUNK
];
687 unsigned char *dst
= buffer
;
690 /* I'll put an arbitary 40 char limit on header size */
691 for (i
= 0; i
< 40 && abfd
->filename
[i
]; i
++)
693 *dst
++ = abfd
->filename
[i
];
695 srec_write_record (abfd
, 0, 0, buffer
, dst
);
699 DEFUN (srec_write_section
, (abfd
, tdata
, list
),
701 tdata_type
* tdata AND
702 srec_data_list_type
* list
)
704 unsigned int bytes_written
= 0;
705 unsigned char *location
= list
->data
;
707 while (bytes_written
< list
->size
)
711 unsigned int bytes_this_chunk
= list
->size
- bytes_written
;
713 if (bytes_this_chunk
> CHUNK
)
715 bytes_this_chunk
= CHUNK
;
718 address
= list
->where
+ bytes_written
;
720 srec_write_record (abfd
,
724 location
+ bytes_this_chunk
);
726 bytes_written
+= bytes_this_chunk
;
727 location
+= bytes_this_chunk
;
733 DEFUN (srec_write_terminator
, (abfd
, tdata
),
737 unsigned char buffer
[2];
739 srec_write_record (abfd
, 10 - tdata
->type
,
740 abfd
->start_address
, buffer
, buffer
);
746 srec_write_symbols (abfd
)
749 char buffer
[MAXCHUNK
];
750 /* Dump out the symbols of a bfd */
752 int len
= bfd_get_symcount (abfd
);
756 asymbol
**table
= bfd_get_outsymbols (abfd
);
757 sprintf (buffer
, "$$ %s\r\n", abfd
->filename
);
759 bfd_write (buffer
, strlen (buffer
), 1, abfd
);
761 for (i
= 0; i
< len
; i
++)
763 asymbol
*s
= table
[i
];
765 int len
= strlen (s
->name
);
767 /* If this symbol has a .[ocs] in it, it's probably a file name
768 and we'll output that as the module name */
770 if (len
> 3 && s
->name
[len
- 2] == '.')
773 sprintf (buffer
, "$$ %s\r\n", s
->name
);
775 bfd_write (buffer
, l
, 1, abfd
);
779 if (s
->flags
& (BSF_GLOBAL
| BSF_LOCAL
)
780 && (s
->flags
& BSF_DEBUGGING
) == 0
782 && s
->name
[0] != 't')
784 /* Just dump out non debug symbols */
790 s
->value
+ s
->section
->output_section
->lma
791 + s
->section
->output_offset
);
793 while (p
[0] == '0' && p
[1] != 0)
795 sprintf (buffer
, " %s $%s\r\n", s
->name
, p
);
797 bfd_write (buffer
, l
, 1, abfd
);
800 sprintf (buffer
, "$$ \r\n");
801 bfd_write (buffer
, strlen (buffer
), 1, abfd
);
806 internal_srec_write_object_contents (abfd
, symbols
)
810 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
811 srec_data_list_type
*list
;
814 srec_write_symbols (abfd
);
816 srec_write_header (abfd
);
818 /* Now wander though all the sections provided and output them */
821 while (list
!= (srec_data_list_type
*) NULL
)
823 srec_write_section (abfd
, tdata
, list
);
826 srec_write_terminator (abfd
, tdata
);
831 srec_write_object_contents (abfd
)
834 return internal_srec_write_object_contents (abfd
, 0);
838 symbolsrec_write_object_contents (abfd
)
841 return internal_srec_write_object_contents (abfd
, 1);
846 DEFUN (srec_sizeof_headers
, (abfd
, exec
),
854 DEFUN (srec_make_empty_symbol
, (abfd
),
857 asymbol
*new = (asymbol
*) bfd_zalloc (abfd
, sizeof (asymbol
));
864 srec_get_symtab_upper_bound (abfd
)
867 /* Read in all the info */
868 srec_get_section_contents (abfd
, abfd
->sections
, 0, 0, 0);
869 return (bfd_get_symcount (abfd
) + 1) * (sizeof (asymbol
*));
873 DEFUN (srec_get_symtab
, (abfd
, alocation
),
875 asymbol
** alocation
)
877 int lim
= abfd
->symcount
;
879 for (i
= 0; i
< lim
; i
++)
881 alocation
[i
] = abfd
->tdata
.srec_data
->symbols
+ i
;
889 DEFUN (srec_get_symbol_info
, (ignore_abfd
, symbol
, ret
),
890 bfd
* ignore_abfd AND
894 bfd_symbol_info (symbol
, ret
);
899 DEFUN (srec_print_symbol
, (ignore_abfd
, afile
, symbol
, how
),
900 bfd
* ignore_abfd AND
903 bfd_print_symbol_type how
)
905 FILE *file
= (FILE *) afile
;
908 case bfd_print_symbol_name
:
909 fprintf (file
, "%s", symbol
->name
);
912 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
913 fprintf (file
, " %-5s %s",
914 symbol
->section
->name
,
921 #define srec_new_section_hook (FOO(boolean, (*), (bfd *, asection *)))bfd_true
923 #define srec_get_reloc_upper_bound (FOO(unsigned int, (*),(bfd*, asection *)))bfd_false
924 #define srec_canonicalize_reloc (FOO(unsigned int, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0
928 #define srec_openr_next_archived_file (FOO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr
929 #define srec_find_nearest_line (FOO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false
930 #define srec_generic_stat_arch_elt (FOO(int, (*), (bfd *,struct stat *))) bfd_0
933 #define srec_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
934 #define srec_core_file_failing_signal (int (*)())bfd_0
935 #define srec_core_file_matches_executable_p (FOO(boolean, (*),(bfd*, bfd*)))bfd_false
936 #define srec_slurp_armap bfd_true
937 #define srec_slurp_extended_name_table bfd_true
938 #define srec_truncate_arname (void (*)())bfd_nullvoidptr
939 #define srec_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
940 #define srec_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
941 #define srec_close_and_cleanup bfd_generic_close_and_cleanup
942 #define srec_bfd_debug_info_start bfd_void
943 #define srec_bfd_debug_info_end bfd_void
944 #define srec_bfd_debug_info_accumulate (FOO(void, (*), (bfd *, asection *))) bfd_void
945 #define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
946 #define srec_bfd_relax_section bfd_generic_relax_section
947 #define srec_bfd_reloc_type_lookup \
948 ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
949 #define srec_bfd_make_debug_symbol \
950 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
951 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
952 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
953 #define srec_bfd_final_link _bfd_generic_final_link
955 bfd_target srec_vec
=
958 bfd_target_srec_flavour
,
959 true, /* target byte order */
960 true, /* target headers byte order */
961 (HAS_RELOC
| EXEC_P
| /* object flags */
962 HAS_LINENO
| HAS_DEBUG
|
963 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
964 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
965 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
966 0, /* leading underscore */
967 ' ', /* ar_pad_char */
968 16, /* ar_max_namelen */
969 1, /* minimum alignment */
970 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
971 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
972 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
973 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
974 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
975 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
979 srec_object_p
, /* bfd_check_format */
980 (struct bfd_target
* (*)()) bfd_nullvoidptr
,
981 (struct bfd_target
* (*)()) bfd_nullvoidptr
,
986 _bfd_generic_mkarchive
,
989 { /* bfd_write_contents */
991 srec_write_object_contents
,
992 _bfd_write_archive_contents
,
1000 bfd_target symbolsrec_vec
=
1002 "symbolsrec", /* name */
1003 bfd_target_srec_flavour
,
1004 true, /* target byte order */
1005 true, /* target headers byte order */
1006 (HAS_RELOC
| EXEC_P
| /* object flags */
1007 HAS_LINENO
| HAS_DEBUG
|
1008 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1009 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
1010 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
1011 0, /* leading underscore */
1012 ' ', /* ar_pad_char */
1013 16, /* ar_max_namelen */
1014 1, /* minimum alignment */
1015 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1016 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1017 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
1018 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1019 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1020 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1024 symbolsrec_object_p
, /* bfd_check_format */
1025 (struct bfd_target
* (*)()) bfd_nullvoidptr
,
1026 (struct bfd_target
* (*)()) bfd_nullvoidptr
,
1031 _bfd_generic_mkarchive
,
1034 { /* bfd_write_contents */
1036 symbolsrec_write_object_contents
,
1037 _bfd_write_archive_contents
,