source: trunk/src/binutils/bfd/tekhex.c@ 73

Last change on this file since 73 was 10, checked in by bird, 23 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 25.2 KB
Line 
1/* BFD backend for Extended Tektronix Hex Format objects.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22/*
23SUBSECTION
24 Tektronix Hex Format handling
25
26DESCRIPTION
27
28 Tek Hex records can hold symbols and data, but not
29 relocations. Their main application is communication with
30 devices like PROM programmers and ICE equipment.
31
32 It seems that the sections are descibed as being really big,
33 the example I have says that the text section is 0..ffffffff.
34 BFD would barf with this, many apps would try to alloc 4GB to
35 read in the file.
36
37 Tex Hex may contain many sections, but the data which comes in
38 has no tag saying which section it belongs to, so we create
39 one section for each block of data, called "blknnnn" which we
40 stick all the data into.
41
42 TekHex may come out of order and there is no header, so an
43 initial scan is required to discover the minimum and maximum
44 addresses used to create the vma and size of the sections we
45 create.
46 We read in the data into pages of CHUNK_MASK+1 size and read
47 them out from that whenever we need to.
48
49 Any number of sections may be created for output, we save them
50 up and output them when it's time to close the bfd.
51
52 A TekHex record looks like:
53EXAMPLE
54 %<block length><type><checksum><stuff><cr>
55
56DESCRIPTION
57 Where
58 o length
59 is the number of bytes in the record not including the % sign.
60 o type
61 is one of:
62 3) symbol record
63 6) data record
64 8) termination record
65
66The data can come out of order, and may be discontigous. This is a
67serial protocol, so big files are unlikely, so we keep a list of 8k chunks
68*/
69
70#include "bfd.h"
71#include "sysdep.h"
72#include "libbfd.h"
73#include "libiberty.h"
74
75typedef struct
76 {
77 bfd_vma low;
78 bfd_vma high;
79 } addr_range_type;
80
81typedef struct tekhex_symbol_struct
82 {
83
84 asymbol symbol;
85 struct tekhex_symbol_struct *prev;
86
87 } tekhex_symbol_type;
88
89static const char digs[] = "0123456789ABCDEF";
90
91static char sum_block[256];
92
93#define NOT_HEX 20
94#define NIBBLE(x) hex_value(x)
95#define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
96#define TOHEX(d,x) \
97(d)[1] = digs[(x) & 0xf]; \
98(d)[0] = digs[((x)>>4)&0xf];
99#define ISHEX(x) hex_p(x)
100
101static void tekhex_init PARAMS ((void));
102static bfd_vma getvalue PARAMS ((char **));
103static void tekhex_print_symbol
104 PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
105static void tekhex_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
106static asymbol *tekhex_make_empty_symbol PARAMS ((bfd *));
107static int tekhex_sizeof_headers PARAMS ((bfd *, boolean));
108static boolean tekhex_write_object_contents PARAMS ((bfd *));
109static void out PARAMS ((bfd *, int, char *, char *));
110static void writesym PARAMS ((char **, CONST char *));
111static void writevalue PARAMS ((char **, bfd_vma));
112static boolean tekhex_set_section_contents
113 PARAMS ((bfd*, sec_ptr, PTR, file_ptr, bfd_size_type));
114static boolean tekhex_set_arch_mach
115 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
116static boolean tekhex_get_section_contents
117 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
118static void move_section_contents
119 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type, boolean));
120static const bfd_target *tekhex_object_p PARAMS ((bfd *));
121static boolean tekhex_mkobject PARAMS ((bfd *));
122static long tekhex_get_symtab_upper_bound PARAMS ((bfd *));
123static long tekhex_get_symtab PARAMS ((bfd *, asymbol **));
124static void pass_over PARAMS ((bfd *, void (*) (bfd*, int, char *)));
125static void first_phase PARAMS ((bfd *, int, char *));
126static void insert_byte PARAMS ((bfd *, int, bfd_vma));
127static struct data_struct *find_chunk PARAMS ((bfd *, bfd_vma));
128static unsigned int getsym PARAMS ((char *, char **));
129
130/*
131Here's an example
132%3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
133%1B3709T_SEGMENT1108FFFFFFFF
134%2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
135%373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
136%373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
137%373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
138%373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
139%373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
140%373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
141%373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
142%2734D9T_SEGMENT8Bvoid$t15$151035_main10
143%2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
144%2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
145%07 8 10 10
146
147explanation:
148%3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
149 ^ ^^ ^ ^-data
150 | || +------ 4 char integer 0x8000
151 | |+-------- checksum
152 | +--------- type 6 (data record)
153 +----------- length 3a chars
154 <---------------------- 3a (58 chars) ------------------->
155
156%1B3709T_SEGMENT1108FFFFFFFF
157 ^ ^^ ^- 8 character integer 0xffffffff
158 | |+- 1 character integer 0
159 | +-- type 1 symbol (section definition)
160 +------------ 9 char symbol T_SEGMENT
161
162%2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
163%373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
164%373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
165%373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
166%373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
167%373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
168%373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
169%373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
170%2734D9T_SEGMENT8Bvoid$t15$151035_main10
171%2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
172%2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
173%0781010
174
175Turns into
176sac@thepub$ ./objdump -dx -m m68k f
177
178f: file format tekhex
179-----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
180architecture: UNKNOWN!, flags 0x00000010:
181HAS_SYMS
182start address 0x00000000
183SECTION 0 [D00000000] : size 00020000 vma 00000000 align 2**0
184 ALLOC, LOAD
185SECTION 1 [D00008000] : size 00002001 vma 00008000 align 2**0
186
187SECTION 2 [T_SEGMENT] : size ffffffff vma 00000000 align 2**0
188
189SYMBOL TABLE:
19000000000 g T_SEGMENT gcc_compiled$
19100000000 g T_SEGMENT hello$c
19200000000 g T_SEGMENT int$t1$r1$$21474
19300000000 g T_SEGMENT char$t2$r2$0$127
19400000000 g T_SEGMENT long$int$t3$r1$$
19500000000 g T_SEGMENT unsigned$int$t4$
19600000000 g T_SEGMENT long$unsigned$in
19700000000 g T_SEGMENT short$int$t6$r1$
19800000000 g T_SEGMENT long$long$int$t7
19900000000 g T_SEGMENT short$unsigned$i
20000000000 g T_SEGMENT long$long$unsign
20100000000 g T_SEGMENT signed$char$t10$
20200000000 g T_SEGMENT unsigned$char$t1
20300000000 g T_SEGMENT float$t12$r1$4$0
20400000000 g T_SEGMENT double$t13$r1$8$
20500000000 g T_SEGMENT long$double$t14$
20600000000 g T_SEGMENT void$t15$15
20700000000 g T_SEGMENT _main
20800000000 g T_SEGMENT $
20900000000 g T_SEGMENT $
21000000000 g T_SEGMENT $
21100000010 g T_SEGMENT $
21200000000 g T_SEGMENT main$F1
213fcffffff g T_SEGMENT i$1
21400000000 g T_SEGMENT $
21500000010 g T_SEGMENT $
216
217RELOCATION RECORDS FOR [D00000000]: (none)
218
219RELOCATION RECORDS FOR [D00008000]: (none)
220
221RELOCATION RECORDS FOR [T_SEGMENT]: (none)
222
223Disassembly of section D00000000:
224...
22500008000 ($+)7ff0 linkw fp,#-4
22600008004 ($+)7ff4 nop
22700008006 ($+)7ff6 movel #99,d0
22800008008 ($+)7ff8 cmpl fp@(-4),d0
2290000800c ($+)7ffc blts 00008014 ($+)8004
2300000800e ($+)7ffe addql #1,fp@(-4)
23100008012 ($+)8002 bras 00008006 ($+)7ff6
23200008014 ($+)8004 unlk fp
23300008016 ($+)8006 rts
234...
235
236*/
237
238static void
239tekhex_init ()
240{
241 unsigned int i;
242 static boolean inited = false;
243 int val;
244
245 if (inited == false)
246 {
247 inited = true;
248 hex_init ();
249 val = 0;
250 for (i = 0; i < 10; i++)
251 {
252 sum_block[i + '0'] = val++;
253 }
254 for (i = 'A'; i <= 'Z'; i++)
255 {
256 sum_block[i] = val++;
257 }
258 sum_block['$'] = val++;
259 sum_block['%'] = val++;
260 sum_block['.'] = val++;
261 sum_block['_'] = val++;
262 for (i = 'a'; i <= 'z'; i++)
263 {
264 sum_block[i] = val++;
265 }
266 }
267}
268
269/* The maximum number of bytes on a line is FF */
270#define MAXCHUNK 0xff
271/* The number of bytes we fit onto a line on output */
272#define CHUNK 21
273
274/* We cannot output our tekhexords as we see them, we have to glue them
275 together, this is done in this structure : */
276
277struct tekhex_data_list_struct
278{
279 unsigned char *data;
280 bfd_vma where;
281 bfd_size_type size;
282 struct tekhex_data_list_struct *next;
283
284};
285typedef struct tekhex_data_list_struct tekhex_data_list_type;
286
287#define CHUNK_MASK 0x1fff
288
289struct data_struct
290 {
291 char chunk_data[CHUNK_MASK + 1];
292 char chunk_init[CHUNK_MASK + 1];
293 bfd_vma vma;
294 struct data_struct *next;
295 };
296
297typedef struct tekhex_data_struct
298{
299 tekhex_data_list_type *head;
300 unsigned int type;
301 struct tekhex_symbol_struct *symbols;
302 struct data_struct *data;
303} tdata_type;
304
305#define enda(x) (x->vma + x->size)
306
307static bfd_vma
308getvalue (srcp)
309 char **srcp;
310{
311 char *src = *srcp;
312 bfd_vma value = 0;
313 unsigned int len = hex_value(*src++);
314
315 if (len == 0)
316 len = 16;
317 while (len--)
318 {
319 value = value << 4 | hex_value(*src++);
320 }
321 *srcp = src;
322 return value;
323}
324
325static unsigned int
326getsym (dstp, srcp)
327 char *dstp;
328 char **srcp;
329{
330 char *src = *srcp;
331 unsigned int i;
332 unsigned int len = hex_value(*src++);
333
334 if (len == 0)
335 len = 16;
336 for (i = 0; i < len; i++)
337 dstp[i] = src[i];
338 dstp[i] = 0;
339 *srcp = src + i;
340 return len;
341}
342
343static struct data_struct *
344find_chunk (abfd, vma)
345 bfd *abfd;
346 bfd_vma vma;
347{
348 struct data_struct *d = abfd->tdata.tekhex_data->data;
349
350 vma &= ~CHUNK_MASK;
351 while (d && (d->vma) != vma)
352 {
353 d = d->next;
354 }
355 if (!d)
356 {
357 char *sname = bfd_alloc (abfd, 12);
358
359 /* No chunk for this address, so make one up */
360 d = (struct data_struct *)
361 bfd_alloc (abfd, sizeof (struct data_struct));
362
363 if (!sname || !d)
364 return NULL;
365
366 memset (d->chunk_init, 0, CHUNK_MASK + 1);
367 memset (d->chunk_data, 0, CHUNK_MASK + 1);
368 d->next = abfd->tdata.tekhex_data->data;
369 d->vma = vma;
370 abfd->tdata.tekhex_data->data = d;
371 }
372 return d;
373}
374
375static void
376insert_byte (abfd, value, addr)
377 bfd *abfd;
378 int value;
379 bfd_vma addr;
380{
381 /* Find the chunk that this byte needs and put it in */
382 struct data_struct *d = find_chunk (abfd, addr);
383
384 d->chunk_data[addr & CHUNK_MASK] = value;
385 d->chunk_init[addr & CHUNK_MASK] = 1;
386}
387
388/* The first pass is to find the names of all the sections, and see
389 how big the data is */
390static void
391first_phase (abfd, type, src)
392 bfd *abfd;
393 int type;
394 char *src;
395{
396 asection *section = bfd_abs_section_ptr;
397 int len;
398 char sym[17]; /* A symbol can only be 16chars long */
399
400 switch (type)
401 {
402 case '6':
403 /* Data record - read it and store it */
404 {
405 bfd_vma addr = getvalue (&src);
406
407 while (*src)
408 {
409 insert_byte (abfd, HEX (src), addr);
410 src += 2;
411 addr++;
412 }
413 }
414
415 return;
416 case '3':
417 /* Symbol record, read the segment */
418 len = getsym (sym, &src);
419 section = bfd_get_section_by_name (abfd, sym);
420 if (section == (asection *) NULL)
421 {
422 char *n = bfd_alloc (abfd, len + 1);
423
424 if (!n)
425 abort (); /* FIXME */
426 memcpy (n, sym, len + 1);
427 section = bfd_make_section (abfd, n);
428 }
429 while (*src)
430 {
431 switch (*src)
432 {
433 case '1': /* section range */
434 src++;
435 section->vma = getvalue (&src);
436 section->_raw_size = getvalue (&src) - section->vma;
437 section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
438 break;
439 case '0':
440 case '2':
441 case '3':
442 case '4':
443 case '6':
444 case '7':
445 case '8':
446 /* Symbols, add to section */
447 {
448 tekhex_symbol_type *new =
449 (tekhex_symbol_type *) bfd_alloc (abfd,
450 sizeof (tekhex_symbol_type));
451 char type = (*src);
452
453 if (!new)
454 abort (); /* FIXME */
455 new->symbol.the_bfd = abfd;
456 src++;
457 abfd->symcount++;
458 abfd->flags |= HAS_SYMS;
459 new->prev = abfd->tdata.tekhex_data->symbols;
460 abfd->tdata.tekhex_data->symbols = new;
461 len = getsym (sym, &src);
462 new->symbol.name = bfd_alloc (abfd, len + 1);
463 if (!new->symbol.name)
464 abort (); /* FIXME */
465 memcpy ((char *) (new->symbol.name), sym, len + 1);
466 new->symbol.section = section;
467 if (type <= '4')
468 new->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
469 else
470 new->symbol.flags = BSF_LOCAL;
471 new->symbol.value = getvalue (&src) - section->vma;
472 }
473 }
474 }
475 }
476}
477
478/* Pass over an tekhex, calling one of the above functions on each
479 record. */
480
481static void
482pass_over (abfd, func)
483 bfd *abfd;
484 void (*func) PARAMS ((bfd *, int, char *));
485{
486 unsigned int chars_on_line;
487 boolean eof = false;
488
489 /* To the front of the file */
490 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
491 abort ();
492 while (eof == false)
493 {
494 char buffer[MAXCHUNK];
495 char *src = buffer;
496 char type;
497
498 /* Find first '%' */
499 eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
500 while (*src != '%' && !eof)
501 {
502 eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
503 }
504 if (eof)
505 break;
506 src++;
507
508 /* Fetch the type and the length and the checksum */
509 if (bfd_read (src, 1, 5, abfd) != 5)
510 abort (); /* FIXME */
511
512 type = src[2];
513
514 if (!ISHEX (src[0]) || !ISHEX (src[1]))
515 break;
516
517 chars_on_line = HEX (src) - 5; /* Already read five char */
518
519 if (bfd_read (src, 1, chars_on_line, abfd) != chars_on_line)
520 abort (); /* FIXME */
521 src[chars_on_line] = 0; /* put a null at the end */
522
523 func (abfd, type, src);
524 }
525
526}
527
528static long
529tekhex_get_symtab (abfd, table)
530 bfd *abfd;
531 asymbol **table;
532{
533 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
534 unsigned int c = bfd_get_symcount (abfd);
535
536 table[c] = 0;
537 while (p)
538 {
539 table[--c] = &(p->symbol);
540 p = p->prev;
541 }
542
543 return bfd_get_symcount (abfd);
544}
545
546static long
547tekhex_get_symtab_upper_bound (abfd)
548 bfd *abfd;
549{
550 return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
551
552}
553
554static boolean
555tekhex_mkobject (abfd)
556 bfd *abfd;
557{
558 tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
559
560 if (!tdata)
561 return false;
562 abfd->tdata.tekhex_data = tdata;
563 tdata->type = 1;
564 tdata->head = (tekhex_data_list_type *) NULL;
565 tdata->symbols = (struct tekhex_symbol_struct *) NULL;
566 tdata->data = (struct data_struct *) NULL;
567 return true;
568}
569
570/*
571 Return true if the file looks like it's in TekHex format. Just look
572 for a percent sign and some hex digits */
573
574static const bfd_target *
575tekhex_object_p (abfd)
576 bfd *abfd;
577{
578 char b[4];
579
580 tekhex_init ();
581
582 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
583 || bfd_read (b, 1, 4, abfd) != 4)
584 return NULL;
585
586 if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
587 return (const bfd_target *) NULL;
588
589 tekhex_mkobject (abfd);
590
591 pass_over (abfd, first_phase);
592 return abfd->xvec;
593}
594
595static void
596move_section_contents (abfd, section, locationp, offset, count, get)
597 bfd *abfd;
598 asection *section;
599 PTR locationp;
600 file_ptr offset ATTRIBUTE_UNUSED;
601 bfd_size_type count;
602 boolean get;
603{
604 bfd_vma addr;
605 char *location = (char *) locationp;
606 bfd_vma prev_number = 1; /* Nothing can have this as a high bit*/
607 struct data_struct *d = (struct data_struct *) NULL;
608
609 for (addr = section->vma; count != 0; count--, addr++)
610 {
611
612 bfd_vma chunk_number = addr & ~CHUNK_MASK; /* Get high bits of address */
613 bfd_vma low_bits = addr & CHUNK_MASK;
614
615 if (chunk_number != prev_number)
616 {
617 /* Different chunk, so move pointer */
618 d = find_chunk (abfd, chunk_number);
619 }
620
621 if (get)
622 {
623 if (d->chunk_init[low_bits])
624 {
625 *location = d->chunk_data[low_bits];
626 }
627 else
628 {
629 *location = 0;
630 }
631 }
632 else
633 {
634 d->chunk_data[low_bits] = *location;
635 d->chunk_init[low_bits] = (*location != 0);
636 }
637
638 location++;
639
640 }
641
642}
643
644static boolean
645tekhex_get_section_contents (abfd, section, locationp, offset, count)
646 bfd *abfd;
647 asection *section;
648 PTR locationp;
649 file_ptr offset;
650 bfd_size_type count;
651{
652 if (section->flags & (SEC_LOAD | SEC_ALLOC))
653 {
654 move_section_contents (abfd, section, locationp, offset, count, true);
655 return true;
656 }
657 else
658 return false;
659}
660
661static boolean
662tekhex_set_arch_mach (abfd, arch, machine)
663 bfd *abfd;
664 enum bfd_architecture arch;
665 unsigned long machine;
666{
667 return bfd_default_set_arch_mach (abfd, arch, machine);
668}
669
670/* we have to save up all the Tekhexords for a splurge before output,
671 */
672
673static boolean
674tekhex_set_section_contents (abfd, section, locationp, offset, bytes_to_do)
675 bfd *abfd;
676 sec_ptr section;
677 PTR locationp;
678 file_ptr offset;
679 bfd_size_type bytes_to_do;
680{
681
682 if (abfd->output_has_begun == false)
683 {
684 /* The first time around, allocate enough sections to hold all the chunks */
685 asection *s = abfd->sections;
686 bfd_vma vma;
687
688 for (s = abfd->sections; s; s = s->next)
689 {
690 if (s->flags & SEC_LOAD)
691 {
692 for (vma = s->vma & ~CHUNK_MASK;
693 vma < s->vma + s->_raw_size;
694 vma += CHUNK_MASK)
695 find_chunk (abfd, vma);
696 }
697 }
698
699 }
700 if (section->flags & (SEC_LOAD | SEC_ALLOC))
701 {
702 move_section_contents (abfd, section, locationp, offset, bytes_to_do, false);
703 return true;
704 }
705 else
706 return false;
707
708}
709
710static void
711writevalue (dst, value)
712 char **dst;
713 bfd_vma value;
714{
715 char *p = *dst;
716 int len;
717 int shift;
718
719 for (len = 8, shift = 28; shift; shift -= 4, len--)
720 {
721 if ((value >> shift) & 0xf)
722 {
723 *p++ = len + '0';
724 while (len)
725 {
726 *p++ = digs[(value >> shift) & 0xf];
727 shift -= 4;
728 len--;
729 }
730 *dst = p;
731 return;
732
733 }
734 }
735 *p++ = '1';
736 *p++ = '0';
737 *dst = p;
738}
739
740static void
741writesym (dst, sym)
742 char **dst;
743 CONST char *sym;
744{
745 char *p = *dst;
746 int len = (sym ? strlen (sym) : 0);
747
748 if (len >= 16)
749 {
750 *p++ = '0';
751 len = 16;
752 }
753
754 else
755 {
756 if (len == 0)
757 {
758 *p++ = '1';
759 sym = "$";
760 len = 1;
761 }
762 else
763 {
764 *p++ = digs[len];
765 }
766 }
767
768 while (len--)
769 {
770 *p++ = *sym++;
771 }
772 *dst = p;
773}
774
775static void
776out (abfd, type, start, end)
777 bfd *abfd;
778 int type;
779 char *start;
780 char *end;
781{
782 int sum = 0;
783 char *s;
784 char front[6];
785 bfd_size_type wrlen;
786
787 front[0] = '%';
788 TOHEX (front + 1, end - start + 5);
789 front[3] = type;
790
791 for (s = start; s < end; s++)
792 {
793 sum += sum_block[(unsigned char) *s];
794 }
795
796 sum += sum_block[(unsigned char) front[1]]; /* length */
797 sum += sum_block[(unsigned char) front[2]];
798 sum += sum_block[(unsigned char) front[3]]; /* type */
799 TOHEX (front + 4, sum);
800 if (bfd_write (front, 1, 6, abfd) != 6)
801 abort ();
802 end[0] = '\n';
803 wrlen = end - start + 1;
804 if (bfd_write (start, 1, wrlen, abfd) != wrlen)
805 abort ();
806}
807
808static boolean
809tekhex_write_object_contents (abfd)
810 bfd *abfd;
811{
812 int bytes_written;
813 char buffer[100];
814 asymbol **p;
815 asection *s;
816 struct data_struct *d;
817
818 tekhex_init ();
819
820 bytes_written = 0;
821
822 /* And the raw data */
823 for (d = abfd->tdata.tekhex_data->data;
824 d != (struct data_struct *) NULL;
825 d = d->next)
826 {
827 int low;
828
829 CONST int span = 32;
830 int addr;
831
832 /* Write it in blocks of 32 bytes */
833
834 for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
835 {
836 int need = 0;
837
838 /* Check to see if necessary */
839 for (low = 0; !need && low < span; low++)
840 {
841 if (d->chunk_init[addr + low])
842 need = 1;
843 }
844 if (need)
845 {
846 char *dst = buffer;
847
848 writevalue (&dst, addr + d->vma);
849 for (low = 0; low < span; low++)
850 {
851 TOHEX (dst, d->chunk_data[addr + low]);
852 dst += 2;
853 }
854 out (abfd, '6', buffer, dst);
855 }
856 }
857 }
858 /* write all the section headers for the sections */
859 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
860 {
861 char *dst = buffer;
862
863 writesym (&dst, s->name);
864 *dst++ = '1';
865 writevalue (&dst, s->vma);
866 writevalue (&dst, s->vma + s->_raw_size);
867 out (abfd, '3', buffer, dst);
868 }
869
870 /* And the symbols */
871 if (abfd->outsymbols)
872 {
873 for (p = abfd->outsymbols; *p; p++)
874 {
875 int section_code = bfd_decode_symclass (*p);
876
877 if (section_code != '?')
878 { /* do not include debug symbols */
879 asymbol *s = *p;
880 char *dst = buffer;
881
882 writesym (&dst, s->section->name);
883
884 switch (section_code)
885 {
886 case 'A':
887 *dst++ = '2';
888 break;
889 case 'a':
890 *dst++ = '6';
891 break;
892 case 'D':
893 case 'B':
894 case 'O':
895 *dst++ = '4';
896 break;
897 case 'd':
898 case 'b':
899 case 'o':
900 *dst++ = '8';
901 break;
902 case 'T':
903 *dst++ = '3';
904 break;
905 case 't':
906 *dst++ = '7';
907 break;
908 case 'C':
909 case 'U':
910 bfd_set_error (bfd_error_wrong_format);
911 return false;
912 }
913
914 writesym (&dst, s->name);
915 writevalue (&dst, s->value + s->section->vma);
916 out (abfd, '3', buffer, dst);
917 }
918 }
919 }
920
921 /* And the terminator */
922 if (bfd_write ("%0781010\n", 1, 9, abfd) != 9)
923 abort ();
924 return true;
925}
926
927static int
928tekhex_sizeof_headers (abfd, exec)
929 bfd *abfd ATTRIBUTE_UNUSED;
930 boolean exec ATTRIBUTE_UNUSED;
931
932{
933 return 0;
934}
935
936static asymbol *
937tekhex_make_empty_symbol (abfd)
938 bfd *abfd;
939{
940 tekhex_symbol_type *new =
941 (tekhex_symbol_type *) bfd_zalloc (abfd, sizeof (struct tekhex_symbol_struct));
942
943 if (!new)
944 return NULL;
945 new->symbol.the_bfd = abfd;
946 new->prev = (struct tekhex_symbol_struct *) NULL;
947 return &(new->symbol);
948}
949
950static void
951tekhex_get_symbol_info (ignore_abfd, symbol, ret)
952 bfd *ignore_abfd ATTRIBUTE_UNUSED;
953 asymbol *symbol;
954 symbol_info *ret;
955{
956 bfd_symbol_info (symbol, ret);
957}
958
959static void
960tekhex_print_symbol (ignore_abfd, filep, symbol, how)
961 bfd *ignore_abfd ATTRIBUTE_UNUSED;
962 PTR filep;
963 asymbol *symbol;
964 bfd_print_symbol_type how;
965{
966 FILE *file = (FILE *) filep;
967
968 switch (how)
969 {
970 case bfd_print_symbol_name:
971 fprintf (file, "%s", symbol->name);
972 break;
973 case bfd_print_symbol_more:
974 break;
975
976 case bfd_print_symbol_all:
977 {
978 CONST char *section_name = symbol->section->name;
979
980 bfd_print_symbol_vandf ((PTR) file, symbol);
981
982 fprintf (file, " %-5s %s",
983 section_name,
984 symbol->name);
985 }
986 }
987}
988
989#define tekhex_close_and_cleanup _bfd_generic_close_and_cleanup
990#define tekhex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
991#define tekhex_new_section_hook _bfd_generic_new_section_hook
992
993#define tekhex_bfd_is_local_label_name bfd_generic_is_local_label_name
994#define tekhex_get_lineno _bfd_nosymbols_get_lineno
995#define tekhex_find_nearest_line _bfd_nosymbols_find_nearest_line
996#define tekhex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
997#define tekhex_read_minisymbols _bfd_generic_read_minisymbols
998#define tekhex_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
999
1000#define tekhex_bfd_get_relocated_section_contents \
1001 bfd_generic_get_relocated_section_contents
1002#define tekhex_bfd_relax_section bfd_generic_relax_section
1003#define tekhex_bfd_gc_sections bfd_generic_gc_sections
1004#define tekhex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1005#define tekhex_bfd_link_add_symbols _bfd_generic_link_add_symbols
1006#define tekhex_bfd_final_link _bfd_generic_final_link
1007#define tekhex_bfd_link_split_section _bfd_generic_link_split_section
1008
1009#define tekhex_get_section_contents_in_window \
1010 _bfd_generic_get_section_contents_in_window
1011
1012const bfd_target tekhex_vec =
1013{
1014 "tekhex", /* name */
1015 bfd_target_tekhex_flavour,
1016 BFD_ENDIAN_UNKNOWN, /* target byte order */
1017 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
1018 (EXEC_P | /* object flags */
1019 HAS_SYMS | HAS_LINENO | HAS_DEBUG | HAS_RELOC | HAS_LOCALS |
1020 WP_TEXT | D_PAGED),
1021 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1022 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1023 0, /* leading underscore */
1024 ' ', /* ar_pad_char */
1025 16, /* ar_max_namelen */
1026 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1027 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1028 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1029 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1030 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1031 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1032
1033 {
1034 _bfd_dummy_target,
1035 tekhex_object_p, /* bfd_check_format */
1036 _bfd_dummy_target,
1037 _bfd_dummy_target,
1038 },
1039 {
1040 bfd_false,
1041 tekhex_mkobject,
1042 _bfd_generic_mkarchive,
1043 bfd_false,
1044 },
1045 { /* bfd_write_contents */
1046 bfd_false,
1047 tekhex_write_object_contents,
1048 _bfd_write_archive_contents,
1049 bfd_false,
1050 },
1051
1052 BFD_JUMP_TABLE_GENERIC (tekhex),
1053 BFD_JUMP_TABLE_COPY (_bfd_generic),
1054 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1055 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1056 BFD_JUMP_TABLE_SYMBOLS (tekhex),
1057 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1058 BFD_JUMP_TABLE_WRITE (tekhex),
1059 BFD_JUMP_TABLE_LINK (tekhex),
1060 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1061
1062 NULL,
1063
1064 (PTR) 0
1065};
Note: See TracBrowser for help on using the repository browser.