1 /* BFD back-end for s-record objects.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
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.
13
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.
18
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23 /* SUBSECTION
24 S-Record handling
25
26 DESCRIPTION
27
28 Ordinary S-Records cannot hold anything but addresses and
29 data, so that's all that we implement.
30
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".
36
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
39 area.
40
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.
43
44 An s record looks like:
45
46 EXAMPLE
47 S<type><length><address><data><checksum>
48
49 DESCRIPTION
50 Where
51 o length
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.
55 o type
56 is one of:
57 0) header record
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
64
65 o address
66 is the start address of the data following, or in the case of
67 a termination record, the start address of the image
68 o data
69 is the data.
70 o checksum
71 is the sum of all the raw byte data in the record, from the length
72 upwards, modulo 256 and subtracted from 255.
73
74 SUBSECTION
75 Symbol S-Record handling
76
77 DESCRIPTION
78 Some ICE equipment understands an addition to the standard
79 S-Record format; symbols and their addresses can be sent
80 before the data.
81
82 The format of this is:
83 ($$ <modulename>
84 (<space> <symbol> <address>)*)
85 $$
86
87 so a short symbol table could look like:
88
89 EXAMPLE
90 $$ flash.x
91 $$ flash.c
92 _port6 $0
93 _delay $4
94 _start $14
95 _etext $8036
96 _edata $8036
97 _end $8036
98 $$
99
100 DESCRIPTION
101 We allow symbols to be anywhere in the data stream - the module names
102 are always ignored. */
103
104 #include "sysdep.h"
105 #include "bfd.h"
106 #include "libbfd.h"
107 #include "libiberty.h"
108 #include "safe-ctype.h"
109
110
111 /* Macros for converting between hex and binary. */
112
113 static const char digs[] = "0123456789ABCDEF";
114
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]; \
120 ch += ((x) & 0xff);
121 #define ISHEX(x) hex_p(x)
122
123 /* The maximum number of address+data+crc bytes on a line is FF. */
124 #define MAXCHUNK 0xff
125
126 /* Default size for a CHUNK. */
127 #define DEFAULT_CHUNK 16
128
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 Chunk = DEFAULT_CHUNK;
133
134 /* The type of srec output (free or forced to S3).
135 This variable can be modified by objcopy's --srec-forceS3
136 parameter. */
137 bfd_boolean S3Forced = FALSE;
138
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. */
141
142 struct srec_data_list_struct
143 {
144 struct srec_data_list_struct *next;
145 bfd_byte *data;
146 bfd_vma where;
147 bfd_size_type size;
148 };
149
150 typedef struct srec_data_list_struct srec_data_list_type;
151
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
154 one). */
155
156 struct srec_symbol
157 {
158 struct srec_symbol *next;
159 const char *name;
160 bfd_vma val;
161 };
162
163 /* The S-record tdata information. */
164
165 typedef struct srec_data_struct
166 {
167 srec_data_list_type *head;
168 srec_data_list_type *tail;
169 unsigned int type;
170 struct srec_symbol *symbols;
171 struct srec_symbol *symtail;
172 asymbol *csymbols;
173 }
174 tdata_type;
175
176 /* Initialize by filling in the hex conversion array. */
177
178 static void
srec_init(void)179 srec_init (void)
180 {
181 static bfd_boolean inited = FALSE;
182
183 if (! inited)
184 {
185 inited = TRUE;
186 hex_init ();
187 }
188 }
189
190 /* Set up the S-record tdata information. */
191
192 static bfd_boolean
srec_mkobject(bfd * abfd)193 srec_mkobject (bfd *abfd)
194 {
195 tdata_type *tdata;
196
197 srec_init ();
198
199 tdata = bfd_alloc (abfd, sizeof (tdata_type));
200 if (tdata == NULL)
201 return FALSE;
202
203 abfd->tdata.srec_data = tdata;
204 tdata->type = 1;
205 tdata->head = NULL;
206 tdata->tail = NULL;
207 tdata->symbols = NULL;
208 tdata->symtail = NULL;
209 tdata->csymbols = NULL;
210
211 return TRUE;
212 }
213
214 /* Read a byte from an S record file. Set *ERRORPTR if an error
215 occurred. Return EOF on error or end of file. */
216
217 static int
srec_get_byte(bfd * abfd,bfd_boolean * errorptr)218 srec_get_byte (bfd *abfd, bfd_boolean *errorptr)
219 {
220 bfd_byte c;
221
222 if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
223 {
224 if (bfd_get_error () != bfd_error_file_truncated)
225 *errorptr = TRUE;
226 return EOF;
227 }
228
229 return (int) (c & 0xff);
230 }
231
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
234 error messages. */
235
236 static void
srec_bad_byte(bfd * abfd,unsigned int lineno,int c,bfd_boolean error)237 srec_bad_byte (bfd *abfd,
238 unsigned int lineno,
239 int c,
240 bfd_boolean error)
241 {
242 if (c == EOF)
243 {
244 if (! error)
245 bfd_set_error (bfd_error_file_truncated);
246 }
247 else
248 {
249 char buf[10];
250
251 if (! ISPRINT (c))
252 sprintf (buf, "\\%03o", (unsigned int) c);
253 else
254 {
255 buf[0] = c;
256 buf[1] = '\0';
257 }
258 (*_bfd_error_handler)
259 (_("%B:%d: Unexpected character `%s' in S-record file\n"),
260 abfd, lineno, buf);
261 bfd_set_error (bfd_error_bad_value);
262 }
263 }
264
265 /* Add a new symbol found in an S-record file. */
266
267 static bfd_boolean
srec_new_symbol(bfd * abfd,const char * name,bfd_vma val)268 srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)
269 {
270 struct srec_symbol *n;
271
272 n = bfd_alloc (abfd, sizeof (* n));
273 if (n == NULL)
274 return FALSE;
275
276 n->name = name;
277 n->val = val;
278
279 if (abfd->tdata.srec_data->symbols == NULL)
280 abfd->tdata.srec_data->symbols = n;
281 else
282 abfd->tdata.srec_data->symtail->next = n;
283 abfd->tdata.srec_data->symtail = n;
284 n->next = NULL;
285
286 ++abfd->symcount;
287
288 return TRUE;
289 }
290
291 /* Read the S record file and turn it into sections. We create a new
292 section for each contiguous set of bytes. */
293
294 static bfd_boolean
srec_scan(bfd * abfd)295 srec_scan (bfd *abfd)
296 {
297 int c;
298 unsigned int lineno = 1;
299 bfd_boolean error = FALSE;
300 bfd_byte *buf = NULL;
301 size_t bufsize = 0;
302 asection *sec = NULL;
303 char *symbuf = NULL;
304
305 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
306 goto error_return;
307
308 while ((c = srec_get_byte (abfd, &error)) != EOF)
309 {
310 /* We only build sections from contiguous S-records, so if this
311 is not an S-record, then stop building a section. */
312 if (c != 'S' && c != '\r' && c != '\n')
313 sec = NULL;
314
315 switch (c)
316 {
317 default:
318 srec_bad_byte (abfd, lineno, c, error);
319 goto error_return;
320
321 case '\n':
322 ++lineno;
323 break;
324
325 case '\r':
326 break;
327
328 case '$':
329 /* Starting a module name, which we ignore. */
330 while ((c = srec_get_byte (abfd, &error)) != '\n'
331 && c != EOF)
332 ;
333 if (c == EOF)
334 {
335 srec_bad_byte (abfd, lineno, c, error);
336 goto error_return;
337 }
338
339 ++lineno;
340 break;
341
342 case ' ':
343 do
344 {
345 bfd_size_type alc;
346 char *p, *symname;
347 bfd_vma symval;
348
349 /* Starting a symbol definition. */
350 while ((c = srec_get_byte (abfd, &error)) != EOF
351 && (c == ' ' || c == '\t'))
352 ;
353
354 if (c == '\n' || c == '\r')
355 break;
356
357 if (c == EOF)
358 {
359 srec_bad_byte (abfd, lineno, c, error);
360 goto error_return;
361 }
362
363 alc = 10;
364 symbuf = bfd_malloc (alc + 1);
365 if (symbuf == NULL)
366 goto error_return;
367
368 p = symbuf;
369
370 *p++ = c;
371 while ((c = srec_get_byte (abfd, &error)) != EOF
372 && ! ISSPACE (c))
373 {
374 if ((bfd_size_type) (p - symbuf) >= alc)
375 {
376 char *n;
377
378 alc *= 2;
379 n = bfd_realloc (symbuf, alc + 1);
380 if (n == NULL)
381 goto error_return;
382 p = n + (p - symbuf);
383 symbuf = n;
384 }
385
386 *p++ = c;
387 }
388
389 if (c == EOF)
390 {
391 srec_bad_byte (abfd, lineno, c, error);
392 goto error_return;
393 }
394
395 *p++ = '\0';
396 symname = bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
397 if (symname == NULL)
398 goto error_return;
399 strcpy (symname, symbuf);
400 free (symbuf);
401 symbuf = NULL;
402
403 while ((c = srec_get_byte (abfd, &error)) != EOF
404 && (c == ' ' || c == '\t'))
405 ;
406 if (c == EOF)
407 {
408 srec_bad_byte (abfd, lineno, c, error);
409 goto error_return;
410 }
411
412 /* Skip a dollar sign before the hex value. */
413 if (c == '$')
414 {
415 c = srec_get_byte (abfd, &error);
416 if (c == EOF)
417 {
418 srec_bad_byte (abfd, lineno, c, error);
419 goto error_return;
420 }
421 }
422
423 symval = 0;
424 while (ISHEX (c))
425 {
426 symval <<= 4;
427 symval += NIBBLE (c);
428 c = srec_get_byte (abfd, &error);
429 }
430
431 if (! srec_new_symbol (abfd, symname, symval))
432 goto error_return;
433 }
434 while (c == ' ' || c == '\t')
435 ;
436
437 if (c == '\n')
438 ++lineno;
439 else if (c != '\r')
440 {
441 srec_bad_byte (abfd, lineno, c, error);
442 goto error_return;
443 }
444
445 break;
446
447 case 'S':
448 {
449 file_ptr pos;
450 char hdr[3];
451 unsigned int bytes;
452 bfd_vma address;
453 bfd_byte *data;
454
455 /* Starting an S-record. */
456
457 pos = bfd_tell (abfd) - 1;
458
459 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
460 goto error_return;
461
462 if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
463 {
464 if (! ISHEX (hdr[1]))
465 c = hdr[1];
466 else
467 c = hdr[2];
468 srec_bad_byte (abfd, lineno, c, error);
469 goto error_return;
470 }
471
472 bytes = HEX (hdr + 1);
473 if (bytes * 2 > bufsize)
474 {
475 if (buf != NULL)
476 free (buf);
477 buf = bfd_malloc ((bfd_size_type) bytes * 2);
478 if (buf == NULL)
479 goto error_return;
480 bufsize = bytes * 2;
481 }
482
483 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
484 goto error_return;
485
486 /* Ignore the checksum byte. */
487 --bytes;
488
489 address = 0;
490 data = buf;
491 switch (hdr[0])
492 {
493 case '0':
494 case '5':
495 /* Prologue--ignore the file name, but stop building a
496 section at this point. */
497 sec = NULL;
498 break;
499
500 case '3':
501 address = HEX (data);
502 data += 2;
503 --bytes;
504 /* Fall through. */
505 case '2':
506 address = (address << 8) | HEX (data);
507 data += 2;
508 --bytes;
509 /* Fall through. */
510 case '1':
511 address = (address << 8) | HEX (data);
512 data += 2;
513 address = (address << 8) | HEX (data);
514 data += 2;
515 bytes -= 2;
516
517 if (sec != NULL
518 && sec->vma + sec->size == address)
519 {
520 /* This data goes at the end of the section we are
521 currently building. */
522 sec->size += bytes;
523 }
524 else
525 {
526 char secbuf[20];
527 char *secname;
528 bfd_size_type amt;
529 flagword flags;
530
531 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
532 amt = strlen (secbuf) + 1;
533 secname = bfd_alloc (abfd, amt);
534 strcpy (secname, secbuf);
535 flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
536 sec = bfd_make_section_with_flags (abfd, secname, flags);
537 if (sec == NULL)
538 goto error_return;
539 sec->vma = address;
540 sec->lma = address;
541 sec->size = bytes;
542 sec->filepos = pos;
543 }
544 break;
545
546 case '7':
547 address = HEX (data);
548 data += 2;
549 /* Fall through. */
550 case '8':
551 address = (address << 8) | HEX (data);
552 data += 2;
553 /* Fall through. */
554 case '9':
555 address = (address << 8) | HEX (data);
556 data += 2;
557 address = (address << 8) | HEX (data);
558 data += 2;
559
560 /* This is a termination record. */
561 abfd->start_address = address;
562
563 if (buf != NULL)
564 free (buf);
565
566 return TRUE;
567 }
568 }
569 break;
570 }
571 }
572
573 if (error)
574 goto error_return;
575
576 if (buf != NULL)
577 free (buf);
578
579 return TRUE;
580
581 error_return:
582 if (symbuf != NULL)
583 free (symbuf);
584 if (buf != NULL)
585 free (buf);
586 return FALSE;
587 }
588
589 /* Check whether an existing file is an S-record file. */
590
591 static const bfd_target *
srec_object_p(bfd * abfd)592 srec_object_p (bfd *abfd)
593 {
594 void * tdata_save;
595 bfd_byte b[4];
596
597 srec_init ();
598
599 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
600 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
601 return NULL;
602
603 if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
604 {
605 bfd_set_error (bfd_error_wrong_format);
606 return NULL;
607 }
608
609 tdata_save = abfd->tdata.any;
610 if (! srec_mkobject (abfd) || ! srec_scan (abfd))
611 {
612 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
613 bfd_release (abfd, abfd->tdata.any);
614 abfd->tdata.any = tdata_save;
615 return NULL;
616 }
617
618 if (abfd->symcount > 0)
619 abfd->flags |= HAS_SYMS;
620
621 return abfd->xvec;
622 }
623
624 /* Check whether an existing file is an S-record file with symbols. */
625
626 static const bfd_target *
symbolsrec_object_p(bfd * abfd)627 symbolsrec_object_p (bfd *abfd)
628 {
629 void * tdata_save;
630 char b[2];
631
632 srec_init ();
633
634 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
635 || bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
636 return NULL;
637
638 if (b[0] != '$' || b[1] != '$')
639 {
640 bfd_set_error (bfd_error_wrong_format);
641 return NULL;
642 }
643
644 tdata_save = abfd->tdata.any;
645 if (! srec_mkobject (abfd) || ! srec_scan (abfd))
646 {
647 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
648 bfd_release (abfd, abfd->tdata.any);
649 abfd->tdata.any = tdata_save;
650 return NULL;
651 }
652
653 if (abfd->symcount > 0)
654 abfd->flags |= HAS_SYMS;
655
656 return abfd->xvec;
657 }
658
659 /* Read in the contents of a section in an S-record file. */
660
661 static bfd_boolean
srec_read_section(bfd * abfd,asection * section,bfd_byte * contents)662 srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
663 {
664 int c;
665 bfd_size_type sofar = 0;
666 bfd_boolean error = FALSE;
667 bfd_byte *buf = NULL;
668 size_t bufsize = 0;
669
670 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
671 goto error_return;
672
673 while ((c = srec_get_byte (abfd, &error)) != EOF)
674 {
675 bfd_byte hdr[3];
676 unsigned int bytes;
677 bfd_vma address;
678 bfd_byte *data;
679
680 if (c == '\r' || c == '\n')
681 continue;
682
683 /* This is called after srec_scan has already been called, so we
684 ought to know the exact format. */
685 BFD_ASSERT (c == 'S');
686
687 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
688 goto error_return;
689
690 BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
691
692 bytes = HEX (hdr + 1);
693
694 if (bytes * 2 > bufsize)
695 {
696 if (buf != NULL)
697 free (buf);
698 buf = bfd_malloc ((bfd_size_type) bytes * 2);
699 if (buf == NULL)
700 goto error_return;
701 bufsize = bytes * 2;
702 }
703
704 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
705 goto error_return;
706
707 address = 0;
708 data = buf;
709 switch (hdr[0])
710 {
711 default:
712 BFD_ASSERT (sofar == section->size);
713 if (buf != NULL)
714 free (buf);
715 return TRUE;
716
717 case '3':
718 address = HEX (data);
719 data += 2;
720 --bytes;
721 /* Fall through. */
722 case '2':
723 address = (address << 8) | HEX (data);
724 data += 2;
725 --bytes;
726 /* Fall through. */
727 case '1':
728 address = (address << 8) | HEX (data);
729 data += 2;
730 address = (address << 8) | HEX (data);
731 data += 2;
732 bytes -= 2;
733
734 if (address != section->vma + sofar)
735 {
736 /* We've come to the end of this section. */
737 BFD_ASSERT (sofar == section->size);
738 if (buf != NULL)
739 free (buf);
740 return TRUE;
741 }
742
743 /* Don't consider checksum. */
744 --bytes;
745
746 while (bytes-- != 0)
747 {
748 contents[sofar] = HEX (data);
749 data += 2;
750 ++sofar;
751 }
752
753 break;
754 }
755 }
756
757 if (error)
758 goto error_return;
759
760 BFD_ASSERT (sofar == section->size);
761
762 if (buf != NULL)
763 free (buf);
764
765 return TRUE;
766
767 error_return:
768 if (buf != NULL)
769 free (buf);
770 return FALSE;
771 }
772
773 /* Get the contents of a section in an S-record file. */
774
775 static bfd_boolean
srec_get_section_contents(bfd * abfd,asection * section,void * location,file_ptr offset,bfd_size_type count)776 srec_get_section_contents (bfd *abfd,
777 asection *section,
778 void * location,
779 file_ptr offset,
780 bfd_size_type count)
781 {
782 if (section->used_by_bfd == NULL)
783 {
784 section->used_by_bfd = bfd_alloc (abfd, section->size);
785 if (section->used_by_bfd == NULL && section->size != 0)
786 return FALSE;
787
788 if (! srec_read_section (abfd, section, section->used_by_bfd))
789 return FALSE;
790 }
791
792 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
793 (size_t) count);
794
795 return TRUE;
796 }
797
798 /* Set the architecture. We accept an unknown architecture here. */
799
800 static bfd_boolean
srec_set_arch_mach(bfd * abfd,enum bfd_architecture arch,unsigned long mach)801 srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
802 {
803 if (arch != bfd_arch_unknown)
804 return bfd_default_set_arch_mach (abfd, arch, mach);
805
806 abfd->arch_info = & bfd_default_arch_struct;
807 return TRUE;
808 }
809
810 /* We have to save up all the Srecords for a splurge before output. */
811
812 static bfd_boolean
srec_set_section_contents(bfd * abfd,sec_ptr section,const void * location,file_ptr offset,bfd_size_type bytes_to_do)813 srec_set_section_contents (bfd *abfd,
814 sec_ptr section,
815 const void * location,
816 file_ptr offset,
817 bfd_size_type bytes_to_do)
818 {
819 tdata_type *tdata = abfd->tdata.srec_data;
820 srec_data_list_type *entry;
821
822 entry = bfd_alloc (abfd, sizeof (* entry));
823 if (entry == NULL)
824 return FALSE;
825
826 if (bytes_to_do
827 && (section->flags & SEC_ALLOC)
828 && (section->flags & SEC_LOAD))
829 {
830 bfd_byte *data;
831
832 data = bfd_alloc (abfd, bytes_to_do);
833 if (data == NULL)
834 return FALSE;
835 memcpy ((void *) data, location, (size_t) bytes_to_do);
836
837 /* Ff S3Forced is TRUE then always select S3 records,
838 regardless of the siez of the addresses. */
839 if (S3Forced)
840 tdata->type = 3;
841 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
842 ; /* The default, S1, is OK. */
843 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff
844 && tdata->type <= 2)
845 tdata->type = 2;
846 else
847 tdata->type = 3;
848
849 entry->data = data;
850 entry->where = section->lma + offset;
851 entry->size = bytes_to_do;
852
853 /* Sort the records by address. Optimize for the common case of
854 adding a record to the end of the list. */
855 if (tdata->tail != NULL
856 && entry->where >= tdata->tail->where)
857 {
858 tdata->tail->next = entry;
859 entry->next = NULL;
860 tdata->tail = entry;
861 }
862 else
863 {
864 srec_data_list_type **look;
865
866 for (look = &tdata->head;
867 *look != NULL && (*look)->where < entry->where;
868 look = &(*look)->next)
869 ;
870 entry->next = *look;
871 *look = entry;
872 if (entry->next == NULL)
873 tdata->tail = entry;
874 }
875 }
876 return TRUE;
877 }
878
879 /* Write a record of type, of the supplied number of bytes. The
880 supplied bytes and length don't have a checksum. That's worked out
881 here. */
882
883 static bfd_boolean
srec_write_record(bfd * abfd,unsigned int type,bfd_vma address,const bfd_byte * data,const bfd_byte * end)884 srec_write_record (bfd *abfd,
885 unsigned int type,
886 bfd_vma address,
887 const bfd_byte *data,
888 const bfd_byte *end)
889 {
890 char buffer[2 * MAXCHUNK + 6];
891 unsigned int check_sum = 0;
892 const bfd_byte *src = data;
893 char *dst = buffer;
894 char *length;
895 bfd_size_type wrlen;
896
897 *dst++ = 'S';
898 *dst++ = '0' + type;
899
900 length = dst;
901 dst += 2; /* Leave room for dst. */
902
903 switch (type)
904 {
905 case 3:
906 case 7:
907 TOHEX (dst, (address >> 24), check_sum);
908 dst += 2;
909 case 8:
910 case 2:
911 TOHEX (dst, (address >> 16), check_sum);
912 dst += 2;
913 case 9:
914 case 1:
915 case 0:
916 TOHEX (dst, (address >> 8), check_sum);
917 dst += 2;
918 TOHEX (dst, (address), check_sum);
919 dst += 2;
920 break;
921
922 }
923 for (src = data; src < end; src++)
924 {
925 TOHEX (dst, *src, check_sum);
926 dst += 2;
927 }
928
929 /* Fill in the length. */
930 TOHEX (length, (dst - length) / 2, check_sum);
931 check_sum &= 0xff;
932 check_sum = 255 - check_sum;
933 TOHEX (dst, check_sum, check_sum);
934 dst += 2;
935
936 *dst++ = '\r';
937 *dst++ = '\n';
938 wrlen = dst - buffer;
939
940 return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
941 }
942
943 static bfd_boolean
srec_write_header(bfd * abfd)944 srec_write_header (bfd *abfd)
945 {
946 unsigned int len = strlen (abfd->filename);
947
948 /* I'll put an arbitrary 40 char limit on header size. */
949 if (len > 40)
950 len = 40;
951
952 return srec_write_record (abfd, 0, (bfd_vma) 0,
953 (bfd_byte *) abfd->filename,
954 (bfd_byte *) abfd->filename + len);
955 }
956
957 static bfd_boolean
srec_write_section(bfd * abfd,tdata_type * tdata,srec_data_list_type * list)958 srec_write_section (bfd *abfd,
959 tdata_type *tdata,
960 srec_data_list_type *list)
961 {
962 unsigned int octets_written = 0;
963 bfd_byte *location = list->data;
964
965 /* Validate number of data bytes to write. The srec length byte
966 counts the address, data and crc bytes. S1 (tdata->type == 1)
967 records have two address bytes, S2 (tdata->type == 2) records
968 have three, and S3 (tdata->type == 3) records have four.
969 The total length can't exceed 255, and a zero data length will
970 spin for a long time. */
971 if (Chunk == 0)
972 Chunk = 1;
973 else if (Chunk > MAXCHUNK - tdata->type - 2)
974 Chunk = MAXCHUNK - tdata->type - 2;
975
976 while (octets_written < list->size)
977 {
978 bfd_vma address;
979 unsigned int octets_this_chunk = list->size - octets_written;
980
981 if (octets_this_chunk > Chunk)
982 octets_this_chunk = Chunk;
983
984 address = list->where + octets_written / bfd_octets_per_byte (abfd);
985
986 if (! srec_write_record (abfd,
987 tdata->type,
988 address,
989 location,
990 location + octets_this_chunk))
991 return FALSE;
992
993 octets_written += octets_this_chunk;
994 location += octets_this_chunk;
995 }
996
997 return TRUE;
998 }
999
1000 static bfd_boolean
srec_write_terminator(bfd * abfd,tdata_type * tdata)1001 srec_write_terminator (bfd *abfd, tdata_type *tdata)
1002 {
1003 return srec_write_record (abfd, 10 - tdata->type,
1004 abfd->start_address, NULL, NULL);
1005 }
1006
1007 static bfd_boolean
srec_write_symbols(bfd * abfd)1008 srec_write_symbols (bfd *abfd)
1009 {
1010 /* Dump out the symbols of a bfd. */
1011 int i;
1012 int count = bfd_get_symcount (abfd);
1013
1014 if (count)
1015 {
1016 bfd_size_type len;
1017 asymbol **table = bfd_get_outsymbols (abfd);
1018
1019 len = strlen (abfd->filename);
1020 if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
1021 || bfd_bwrite (abfd->filename, len, abfd) != len
1022 || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
1023 return FALSE;
1024
1025 for (i = 0; i < count; i++)
1026 {
1027 asymbol *s = table[i];
1028 if (! bfd_is_local_label (abfd, s)
1029 && (s->flags & BSF_DEBUGGING) == 0)
1030 {
1031 /* Just dump out non debug symbols. */
1032 char buf[43], *p;
1033
1034 len = strlen (s->name);
1035 if (bfd_bwrite (" ", (bfd_size_type) 2, abfd) != 2
1036 || bfd_bwrite (s->name, len, abfd) != len)
1037 return FALSE;
1038
1039 sprintf_vma (buf + 2, (s->value
1040 + s->section->output_section->lma
1041 + s->section->output_offset));
1042 p = buf + 2;
1043 while (p[0] == '0' && p[1] != 0)
1044 p++;
1045 len = strlen (p);
1046 p[len] = '\r';
1047 p[len + 1] = '\n';
1048 *--p = '$';
1049 *--p = ' ';
1050 len += 4;
1051 if (bfd_bwrite (p, len, abfd) != len)
1052 return FALSE;
1053 }
1054 }
1055 if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
1056 return FALSE;
1057 }
1058
1059 return TRUE;
1060 }
1061
1062 static bfd_boolean
internal_srec_write_object_contents(bfd * abfd,int symbols)1063 internal_srec_write_object_contents (bfd *abfd, int symbols)
1064 {
1065 tdata_type *tdata = abfd->tdata.srec_data;
1066 srec_data_list_type *list;
1067
1068 if (symbols)
1069 {
1070 if (! srec_write_symbols (abfd))
1071 return FALSE;
1072 }
1073
1074 if (! srec_write_header (abfd))
1075 return FALSE;
1076
1077 /* Now wander though all the sections provided and output them. */
1078 list = tdata->head;
1079
1080 while (list != (srec_data_list_type *) NULL)
1081 {
1082 if (! srec_write_section (abfd, tdata, list))
1083 return FALSE;
1084 list = list->next;
1085 }
1086 return srec_write_terminator (abfd, tdata);
1087 }
1088
1089 static bfd_boolean
srec_write_object_contents(bfd * abfd)1090 srec_write_object_contents (bfd *abfd)
1091 {
1092 return internal_srec_write_object_contents (abfd, 0);
1093 }
1094
1095 static bfd_boolean
symbolsrec_write_object_contents(bfd * abfd)1096 symbolsrec_write_object_contents (bfd *abfd)
1097 {
1098 return internal_srec_write_object_contents (abfd, 1);
1099 }
1100
1101 static int
srec_sizeof_headers(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED)1102 srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1103 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1104 {
1105 return 0;
1106 }
1107
1108 /* Return the amount of memory needed to read the symbol table. */
1109
1110 static long
srec_get_symtab_upper_bound(bfd * abfd)1111 srec_get_symtab_upper_bound (bfd *abfd)
1112 {
1113 return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1114 }
1115
1116 /* Return the symbol table. */
1117
1118 static long
srec_canonicalize_symtab(bfd * abfd,asymbol ** alocation)1119 srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1120 {
1121 bfd_size_type symcount = bfd_get_symcount (abfd);
1122 asymbol *csymbols;
1123 unsigned int i;
1124
1125 csymbols = abfd->tdata.srec_data->csymbols;
1126 if (csymbols == NULL)
1127 {
1128 asymbol *c;
1129 struct srec_symbol *s;
1130
1131 csymbols = bfd_alloc (abfd, symcount * sizeof (asymbol));
1132 if (csymbols == NULL && symcount != 0)
1133 return 0;
1134 abfd->tdata.srec_data->csymbols = csymbols;
1135
1136 for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1137 s != NULL;
1138 s = s->next, ++c)
1139 {
1140 c->the_bfd = abfd;
1141 c->name = s->name;
1142 c->value = s->val;
1143 c->flags = BSF_GLOBAL;
1144 c->section = bfd_abs_section_ptr;
1145 c->udata.p = NULL;
1146 }
1147 }
1148
1149 for (i = 0; i < symcount; i++)
1150 *alocation++ = csymbols++;
1151 *alocation = NULL;
1152
1153 return symcount;
1154 }
1155
1156 static void
srec_get_symbol_info(bfd * ignore_abfd ATTRIBUTE_UNUSED,asymbol * symbol,symbol_info * ret)1157 srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1158 asymbol *symbol,
1159 symbol_info *ret)
1160 {
1161 bfd_symbol_info (symbol, ret);
1162 }
1163
1164 static void
srec_print_symbol(bfd * abfd,void * afile,asymbol * symbol,bfd_print_symbol_type how)1165 srec_print_symbol (bfd *abfd,
1166 void * afile,
1167 asymbol *symbol,
1168 bfd_print_symbol_type how)
1169 {
1170 FILE *file = (FILE *) afile;
1171
1172 switch (how)
1173 {
1174 case bfd_print_symbol_name:
1175 fprintf (file, "%s", symbol->name);
1176 break;
1177 default:
1178 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1179 fprintf (file, " %-5s %s",
1180 symbol->section->name,
1181 symbol->name);
1182 }
1183 }
1184
1185 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup
1186 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1187 #define srec_new_section_hook _bfd_generic_new_section_hook
1188 #define srec_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
1189 #define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
1190 #define srec_get_lineno _bfd_nosymbols_get_lineno
1191 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
1192 #define srec_find_inliner_info _bfd_nosymbols_find_inliner_info
1193 #define srec_make_empty_symbol _bfd_generic_make_empty_symbol
1194 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1195 #define srec_read_minisymbols _bfd_generic_read_minisymbols
1196 #define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1197 #define srec_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
1198 #define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
1199 #define srec_bfd_relax_section bfd_generic_relax_section
1200 #define srec_bfd_gc_sections bfd_generic_gc_sections
1201 #define srec_bfd_merge_sections bfd_generic_merge_sections
1202 #define srec_bfd_is_group_section bfd_generic_is_group_section
1203 #define srec_bfd_discard_group bfd_generic_discard_group
1204 #define srec_section_already_linked _bfd_generic_section_already_linked
1205 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1206 #define srec_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
1207 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
1208 #define srec_bfd_link_just_syms _bfd_generic_link_just_syms
1209 #define srec_bfd_final_link _bfd_generic_final_link
1210 #define srec_bfd_link_split_section _bfd_generic_link_split_section
1211
1212 const bfd_target srec_vec =
1213 {
1214 "srec", /* Name. */
1215 bfd_target_srec_flavour,
1216 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
1217 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
1218 (HAS_RELOC | EXEC_P | /* Object flags. */
1219 HAS_LINENO | HAS_DEBUG |
1220 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1221 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1222 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
1223 0, /* Leading underscore. */
1224 ' ', /* AR_pad_char. */
1225 16, /* AR_max_namelen. */
1226 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1227 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1228 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
1229 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1230 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1231 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */
1232
1233 {
1234 _bfd_dummy_target,
1235 srec_object_p, /* bfd_check_format. */
1236 _bfd_dummy_target,
1237 _bfd_dummy_target,
1238 },
1239 {
1240 bfd_false,
1241 srec_mkobject,
1242 _bfd_generic_mkarchive,
1243 bfd_false,
1244 },
1245 { /* bfd_write_contents. */
1246 bfd_false,
1247 srec_write_object_contents,
1248 _bfd_write_archive_contents,
1249 bfd_false,
1250 },
1251
1252 BFD_JUMP_TABLE_GENERIC (srec),
1253 BFD_JUMP_TABLE_COPY (_bfd_generic),
1254 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1255 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1256 BFD_JUMP_TABLE_SYMBOLS (srec),
1257 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1258 BFD_JUMP_TABLE_WRITE (srec),
1259 BFD_JUMP_TABLE_LINK (srec),
1260 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1261
1262 NULL,
1263
1264 NULL
1265 };
1266
1267 const bfd_target symbolsrec_vec =
1268 {
1269 "symbolsrec", /* Name. */
1270 bfd_target_srec_flavour,
1271 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
1272 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
1273 (HAS_RELOC | EXEC_P | /* Object flags. */
1274 HAS_LINENO | HAS_DEBUG |
1275 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1276 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1277 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
1278 0, /* Leading underscore. */
1279 ' ', /* AR_pad_char. */
1280 16, /* AR_max_namelen. */
1281 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1282 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1283 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
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, /* Headers. */
1287
1288 {
1289 _bfd_dummy_target,
1290 symbolsrec_object_p, /* bfd_check_format. */
1291 _bfd_dummy_target,
1292 _bfd_dummy_target,
1293 },
1294 {
1295 bfd_false,
1296 srec_mkobject,
1297 _bfd_generic_mkarchive,
1298 bfd_false,
1299 },
1300 { /* bfd_write_contents. */
1301 bfd_false,
1302 symbolsrec_write_object_contents,
1303 _bfd_write_archive_contents,
1304 bfd_false,
1305 },
1306
1307 BFD_JUMP_TABLE_GENERIC (srec),
1308 BFD_JUMP_TABLE_COPY (_bfd_generic),
1309 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1310 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1311 BFD_JUMP_TABLE_SYMBOLS (srec),
1312 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1313 BFD_JUMP_TABLE_WRITE (srec),
1314 BFD_JUMP_TABLE_LINK (srec),
1315 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1316
1317 NULL,
1318
1319 NULL
1320 };
1321