Touches most files in bfd/, so likely will be blamed for everything..
[binutils.git] / bfd / tekhex.c
blobf5d5160b5cefece3e4c0a638faaa8975ff9b823c
1 /* BFD backend for Extended Tektronix Hex Format objects.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 SUBSECTION
24 Tektronix Hex Format handling
26 DESCRIPTION
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.
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.
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.
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.
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.
52 A TekHex record looks like:
53 EXAMPLE
54 %<block length><type><checksum><stuff><cr>
56 DESCRIPTION
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
66 The data can come out of order, and may be discontigous. This is a
67 serial protocol, so big files are unlikely, so we keep a list of 8k chunks
70 #include "bfd.h"
71 #include "sysdep.h"
72 #include "libbfd.h"
73 #include "libiberty.h"
75 typedef struct
77 bfd_vma low;
78 bfd_vma high;
79 } addr_range_type;
81 typedef struct tekhex_symbol_struct
84 asymbol symbol;
85 struct tekhex_symbol_struct *prev;
87 } tekhex_symbol_type;
89 static const char digs[] = "0123456789ABCDEF";
91 static char sum_block[256];
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)
101 static void tekhex_init PARAMS ((void));
102 static bfd_vma getvalue PARAMS ((char **));
103 static void tekhex_print_symbol
104 PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
105 static void tekhex_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
106 static asymbol *tekhex_make_empty_symbol PARAMS ((bfd *));
107 static int tekhex_sizeof_headers PARAMS ((bfd *, boolean));
108 static boolean tekhex_write_object_contents PARAMS ((bfd *));
109 static void out PARAMS ((bfd *, int, char *, char *));
110 static void writesym PARAMS ((char **, const char *));
111 static void writevalue PARAMS ((char **, bfd_vma));
112 static boolean tekhex_set_section_contents
113 PARAMS ((bfd*, sec_ptr, PTR, file_ptr, bfd_size_type));
114 static boolean tekhex_set_arch_mach
115 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
116 static boolean tekhex_get_section_contents
117 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
118 static void move_section_contents
119 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type, boolean));
120 static const bfd_target *tekhex_object_p PARAMS ((bfd *));
121 static boolean tekhex_mkobject PARAMS ((bfd *));
122 static long tekhex_get_symtab_upper_bound PARAMS ((bfd *));
123 static long tekhex_get_symtab PARAMS ((bfd *, asymbol **));
124 static void pass_over PARAMS ((bfd *, void (*) (bfd*, int, char *)));
125 static void first_phase PARAMS ((bfd *, int, char *));
126 static void insert_byte PARAMS ((bfd *, int, bfd_vma));
127 static struct data_struct *find_chunk PARAMS ((bfd *, bfd_vma));
128 static unsigned int getsym PARAMS ((char *, char **));
131 Here'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
147 explanation:
148 %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
149 ^ ^^ ^ ^-data
150 | || +------ 4 char integer 0x8000
151 | |+-------- checksum
152 | +--------- type 6 (data record)
153 +----------- length 3a chars
154 <---------------------- 3a (58 chars) ------------------->
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
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
175 Turns into
176 sac@thepub$ ./objdump -dx -m m68k f
178 f: file format tekhex
179 -----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
180 architecture: UNKNOWN!, flags 0x00000010:
181 HAS_SYMS
182 start address 0x00000000
183 SECTION 0 [D00000000] : size 00020000 vma 00000000 align 2**0
184 ALLOC, LOAD
185 SECTION 1 [D00008000] : size 00002001 vma 00008000 align 2**0
187 SECTION 2 [T_SEGMENT] : size ffffffff vma 00000000 align 2**0
189 SYMBOL TABLE:
190 00000000 g T_SEGMENT gcc_compiled$
191 00000000 g T_SEGMENT hello$c
192 00000000 g T_SEGMENT int$t1$r1$$21474
193 00000000 g T_SEGMENT char$t2$r2$0$127
194 00000000 g T_SEGMENT long$int$t3$r1$$
195 00000000 g T_SEGMENT unsigned$int$t4$
196 00000000 g T_SEGMENT long$unsigned$in
197 00000000 g T_SEGMENT short$int$t6$r1$
198 00000000 g T_SEGMENT long$long$int$t7
199 00000000 g T_SEGMENT short$unsigned$i
200 00000000 g T_SEGMENT long$long$unsign
201 00000000 g T_SEGMENT signed$char$t10$
202 00000000 g T_SEGMENT unsigned$char$t1
203 00000000 g T_SEGMENT float$t12$r1$4$0
204 00000000 g T_SEGMENT double$t13$r1$8$
205 00000000 g T_SEGMENT long$double$t14$
206 00000000 g T_SEGMENT void$t15$15
207 00000000 g T_SEGMENT _main
208 00000000 g T_SEGMENT $
209 00000000 g T_SEGMENT $
210 00000000 g T_SEGMENT $
211 00000010 g T_SEGMENT $
212 00000000 g T_SEGMENT main$F1
213 fcffffff g T_SEGMENT i$1
214 00000000 g T_SEGMENT $
215 00000010 g T_SEGMENT $
217 RELOCATION RECORDS FOR [D00000000]: (none)
219 RELOCATION RECORDS FOR [D00008000]: (none)
221 RELOCATION RECORDS FOR [T_SEGMENT]: (none)
223 Disassembly of section D00000000:
225 00008000 ($+)7ff0 linkw fp,#-4
226 00008004 ($+)7ff4 nop
227 00008006 ($+)7ff6 movel #99,d0
228 00008008 ($+)7ff8 cmpl fp@(-4),d0
229 0000800c ($+)7ffc blts 00008014 ($+)8004
230 0000800e ($+)7ffe addql #1,fp@(-4)
231 00008012 ($+)8002 bras 00008006 ($+)7ff6
232 00008014 ($+)8004 unlk fp
233 00008016 ($+)8006 rts
238 static void
239 tekhex_init ()
241 unsigned int i;
242 static boolean inited = false;
243 int val;
245 if (inited == false)
247 inited = true;
248 hex_init ();
249 val = 0;
250 for (i = 0; i < 10; i++)
252 sum_block[i + '0'] = val++;
254 for (i = 'A'; i <= 'Z'; i++)
256 sum_block[i] = val++;
258 sum_block['$'] = val++;
259 sum_block['%'] = val++;
260 sum_block['.'] = val++;
261 sum_block['_'] = val++;
262 for (i = 'a'; i <= 'z'; i++)
264 sum_block[i] = val++;
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
274 /* We cannot output our tekhexords as we see them, we have to glue them
275 together, this is done in this structure : */
277 struct tekhex_data_list_struct
279 unsigned char *data;
280 bfd_vma where;
281 bfd_size_type size;
282 struct tekhex_data_list_struct *next;
285 typedef struct tekhex_data_list_struct tekhex_data_list_type;
287 #define CHUNK_MASK 0x1fff
289 struct data_struct
291 char chunk_data[CHUNK_MASK + 1];
292 char chunk_init[CHUNK_MASK + 1];
293 bfd_vma vma;
294 struct data_struct *next;
297 typedef struct tekhex_data_struct
299 tekhex_data_list_type *head;
300 unsigned int type;
301 struct tekhex_symbol_struct *symbols;
302 struct data_struct *data;
303 } tdata_type;
305 #define enda(x) (x->vma + x->size)
307 static bfd_vma
308 getvalue (srcp)
309 char **srcp;
311 char *src = *srcp;
312 bfd_vma value = 0;
313 unsigned int len = hex_value(*src++);
315 if (len == 0)
316 len = 16;
317 while (len--)
319 value = value << 4 | hex_value(*src++);
321 *srcp = src;
322 return value;
325 static unsigned int
326 getsym (dstp, srcp)
327 char *dstp;
328 char **srcp;
330 char *src = *srcp;
331 unsigned int i;
332 unsigned int len = hex_value(*src++);
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;
343 static struct data_struct *
344 find_chunk (abfd, vma)
345 bfd *abfd;
346 bfd_vma vma;
348 struct data_struct *d = abfd->tdata.tekhex_data->data;
350 vma &= ~CHUNK_MASK;
351 while (d && (d->vma) != vma)
353 d = d->next;
355 if (!d)
357 char *sname = bfd_alloc (abfd, (bfd_size_type) 12);
359 /* No chunk for this address, so make one up */
360 d = ((struct data_struct *)
361 bfd_alloc (abfd, (bfd_size_type) sizeof (struct data_struct)));
363 if (!sname || !d)
364 return NULL;
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;
372 return d;
375 static void
376 insert_byte (abfd, value, addr)
377 bfd *abfd;
378 int value;
379 bfd_vma addr;
381 /* Find the chunk that this byte needs and put it in */
382 struct data_struct *d = find_chunk (abfd, addr);
384 d->chunk_data[addr & CHUNK_MASK] = value;
385 d->chunk_init[addr & CHUNK_MASK] = 1;
388 /* The first pass is to find the names of all the sections, and see
389 how big the data is */
390 static void
391 first_phase (abfd, type, src)
392 bfd *abfd;
393 int type;
394 char *src;
396 asection *section = bfd_abs_section_ptr;
397 unsigned int len;
398 char sym[17]; /* A symbol can only be 16chars long */
400 switch (type)
402 case '6':
403 /* Data record - read it and store it */
405 bfd_vma addr = getvalue (&src);
407 while (*src)
409 insert_byte (abfd, HEX (src), addr);
410 src += 2;
411 addr++;
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)
422 char *n = bfd_alloc (abfd, (bfd_size_type) len + 1);
424 if (!n)
425 abort (); /* FIXME */
426 memcpy (n, sym, len + 1);
427 section = bfd_make_section (abfd, n);
429 while (*src)
431 switch (*src)
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 */
448 bfd_size_type amt = sizeof (tekhex_symbol_type);
449 tekhex_symbol_type *new =
450 (tekhex_symbol_type *) bfd_alloc (abfd, amt);
451 char stype = (*src);
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, (bfd_size_type) 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 (stype <= '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;
478 /* Pass over an tekhex, calling one of the above functions on each
479 record. */
481 static void
482 pass_over (abfd, func)
483 bfd *abfd;
484 void (*func) PARAMS ((bfd *, int, char *));
486 unsigned int chars_on_line;
487 boolean eof = false;
489 /* To the front of the file */
490 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
491 abort ();
492 while (eof == false)
494 char buffer[MAXCHUNK];
495 char *src = buffer;
496 char type;
498 /* Find first '%' */
499 eof = (boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
500 while (*src != '%' && !eof)
502 eof = (boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
504 if (eof)
505 break;
506 src++;
508 /* Fetch the type and the length and the checksum */
509 if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
510 abort (); /* FIXME */
512 type = src[2];
514 if (!ISHEX (src[0]) || !ISHEX (src[1]))
515 break;
517 chars_on_line = HEX (src) - 5; /* Already read five char */
519 if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
520 abort (); /* FIXME */
521 src[chars_on_line] = 0; /* put a null at the end */
523 func (abfd, type, src);
528 static long
529 tekhex_get_symtab (abfd, table)
530 bfd *abfd;
531 asymbol **table;
533 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
534 unsigned int c = bfd_get_symcount (abfd);
536 table[c] = 0;
537 while (p)
539 table[--c] = &(p->symbol);
540 p = p->prev;
543 return bfd_get_symcount (abfd);
546 static long
547 tekhex_get_symtab_upper_bound (abfd)
548 bfd *abfd;
550 return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
554 static boolean
555 tekhex_mkobject (abfd)
556 bfd *abfd;
558 tdata_type *tdata;
560 tdata = (tdata_type *) bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
561 if (!tdata)
562 return false;
563 abfd->tdata.tekhex_data = tdata;
564 tdata->type = 1;
565 tdata->head = (tekhex_data_list_type *) NULL;
566 tdata->symbols = (struct tekhex_symbol_struct *) NULL;
567 tdata->data = (struct data_struct *) NULL;
568 return true;
572 Return true if the file looks like it's in TekHex format. Just look
573 for a percent sign and some hex digits */
575 static const bfd_target *
576 tekhex_object_p (abfd)
577 bfd *abfd;
579 char b[4];
581 tekhex_init ();
583 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
584 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
585 return NULL;
587 if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
588 return (const bfd_target *) NULL;
590 tekhex_mkobject (abfd);
592 pass_over (abfd, first_phase);
593 return abfd->xvec;
596 static void
597 move_section_contents (abfd, section, locationp, offset, count, get)
598 bfd *abfd;
599 asection *section;
600 PTR locationp;
601 file_ptr offset;
602 bfd_size_type count;
603 boolean get;
605 bfd_vma addr;
606 char *location = (char *) locationp;
607 bfd_vma prev_number = 1; /* Nothing can have this as a high bit*/
608 struct data_struct *d = (struct data_struct *) NULL;
610 BFD_ASSERT (offset == 0);
611 for (addr = section->vma; count != 0; count--, addr++)
613 /* Get high bits of address. */
614 bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
615 bfd_vma low_bits = addr & CHUNK_MASK;
617 if (chunk_number != prev_number)
619 /* Different chunk, so move pointer */
620 d = find_chunk (abfd, chunk_number);
623 if (get)
625 if (d->chunk_init[low_bits])
627 *location = d->chunk_data[low_bits];
629 else
631 *location = 0;
634 else
636 d->chunk_data[low_bits] = *location;
637 d->chunk_init[low_bits] = (*location != 0);
640 location++;
646 static boolean
647 tekhex_get_section_contents (abfd, section, locationp, offset, count)
648 bfd *abfd;
649 asection *section;
650 PTR locationp;
651 file_ptr offset;
652 bfd_size_type count;
654 if (section->flags & (SEC_LOAD | SEC_ALLOC))
656 move_section_contents (abfd, section, locationp, offset, count, true);
657 return true;
659 else
660 return false;
663 static boolean
664 tekhex_set_arch_mach (abfd, arch, machine)
665 bfd *abfd;
666 enum bfd_architecture arch;
667 unsigned long machine;
669 return bfd_default_set_arch_mach (abfd, arch, machine);
672 /* we have to save up all the Tekhexords for a splurge before output,
675 static boolean
676 tekhex_set_section_contents (abfd, section, locationp, offset, bytes_to_do)
677 bfd *abfd;
678 sec_ptr section;
679 PTR locationp;
680 file_ptr offset;
681 bfd_size_type bytes_to_do;
684 if (abfd->output_has_begun == false)
686 /* The first time around, allocate enough sections to hold all the chunks */
687 asection *s = abfd->sections;
688 bfd_vma vma;
690 for (s = abfd->sections; s; s = s->next)
692 if (s->flags & SEC_LOAD)
694 for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
695 vma < s->vma + s->_raw_size;
696 vma += CHUNK_MASK)
697 find_chunk (abfd, vma);
702 if (section->flags & (SEC_LOAD | SEC_ALLOC))
704 move_section_contents (abfd, section, locationp, offset, bytes_to_do,
705 false);
706 return true;
708 else
709 return false;
713 static void
714 writevalue (dst, value)
715 char **dst;
716 bfd_vma value;
718 char *p = *dst;
719 int len;
720 int shift;
722 for (len = 8, shift = 28; shift; shift -= 4, len--)
724 if ((value >> shift) & 0xf)
726 *p++ = len + '0';
727 while (len)
729 *p++ = digs[(value >> shift) & 0xf];
730 shift -= 4;
731 len--;
733 *dst = p;
734 return;
738 *p++ = '1';
739 *p++ = '0';
740 *dst = p;
743 static void
744 writesym (dst, sym)
745 char **dst;
746 const char *sym;
748 char *p = *dst;
749 int len = (sym ? strlen (sym) : 0);
751 if (len >= 16)
753 *p++ = '0';
754 len = 16;
757 else
759 if (len == 0)
761 *p++ = '1';
762 sym = "$";
763 len = 1;
765 else
767 *p++ = digs[len];
771 while (len--)
773 *p++ = *sym++;
775 *dst = p;
778 static void
779 out (abfd, type, start, end)
780 bfd *abfd;
781 int type;
782 char *start;
783 char *end;
785 int sum = 0;
786 char *s;
787 char front[6];
788 bfd_size_type wrlen;
790 front[0] = '%';
791 TOHEX (front + 1, end - start + 5);
792 front[3] = type;
794 for (s = start; s < end; s++)
796 sum += sum_block[(unsigned char) *s];
799 sum += sum_block[(unsigned char) front[1]]; /* length */
800 sum += sum_block[(unsigned char) front[2]];
801 sum += sum_block[(unsigned char) front[3]]; /* type */
802 TOHEX (front + 4, sum);
803 if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
804 abort ();
805 end[0] = '\n';
806 wrlen = end - start + 1;
807 if (bfd_bwrite (start, wrlen, abfd) != wrlen)
808 abort ();
811 static boolean
812 tekhex_write_object_contents (abfd)
813 bfd *abfd;
815 int bytes_written;
816 char buffer[100];
817 asymbol **p;
818 asection *s;
819 struct data_struct *d;
821 tekhex_init ();
823 bytes_written = 0;
825 /* And the raw data */
826 for (d = abfd->tdata.tekhex_data->data;
827 d != (struct data_struct *) NULL;
828 d = d->next)
830 int low;
832 const int span = 32;
833 int addr;
835 /* Write it in blocks of 32 bytes */
837 for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
839 int need = 0;
841 /* Check to see if necessary */
842 for (low = 0; !need && low < span; low++)
844 if (d->chunk_init[addr + low])
845 need = 1;
847 if (need)
849 char *dst = buffer;
851 writevalue (&dst, addr + d->vma);
852 for (low = 0; low < span; low++)
854 TOHEX (dst, d->chunk_data[addr + low]);
855 dst += 2;
857 out (abfd, '6', buffer, dst);
861 /* write all the section headers for the sections */
862 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
864 char *dst = buffer;
866 writesym (&dst, s->name);
867 *dst++ = '1';
868 writevalue (&dst, s->vma);
869 writevalue (&dst, s->vma + s->_raw_size);
870 out (abfd, '3', buffer, dst);
873 /* And the symbols */
874 if (abfd->outsymbols)
876 for (p = abfd->outsymbols; *p; p++)
878 int section_code = bfd_decode_symclass (*p);
880 if (section_code != '?')
881 { /* do not include debug symbols */
882 asymbol *sym = *p;
883 char *dst = buffer;
885 writesym (&dst, sym->section->name);
887 switch (section_code)
889 case 'A':
890 *dst++ = '2';
891 break;
892 case 'a':
893 *dst++ = '6';
894 break;
895 case 'D':
896 case 'B':
897 case 'O':
898 *dst++ = '4';
899 break;
900 case 'd':
901 case 'b':
902 case 'o':
903 *dst++ = '8';
904 break;
905 case 'T':
906 *dst++ = '3';
907 break;
908 case 't':
909 *dst++ = '7';
910 break;
911 case 'C':
912 case 'U':
913 bfd_set_error (bfd_error_wrong_format);
914 return false;
917 writesym (&dst, sym->name);
918 writevalue (&dst, sym->value + sym->section->vma);
919 out (abfd, '3', buffer, dst);
924 /* And the terminator */
925 if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
926 abort ();
927 return true;
930 static int
931 tekhex_sizeof_headers (abfd, exec)
932 bfd *abfd ATTRIBUTE_UNUSED;
933 boolean exec ATTRIBUTE_UNUSED;
936 return 0;
939 static asymbol *
940 tekhex_make_empty_symbol (abfd)
941 bfd *abfd;
943 bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
944 tekhex_symbol_type *new = (tekhex_symbol_type *) bfd_zalloc (abfd, amt);
946 if (!new)
947 return NULL;
948 new->symbol.the_bfd = abfd;
949 new->prev = (struct tekhex_symbol_struct *) NULL;
950 return &(new->symbol);
953 static void
954 tekhex_get_symbol_info (ignore_abfd, symbol, ret)
955 bfd *ignore_abfd ATTRIBUTE_UNUSED;
956 asymbol *symbol;
957 symbol_info *ret;
959 bfd_symbol_info (symbol, ret);
962 static void
963 tekhex_print_symbol (abfd, filep, symbol, how)
964 bfd *abfd;
965 PTR filep;
966 asymbol *symbol;
967 bfd_print_symbol_type how;
969 FILE *file = (FILE *) filep;
971 switch (how)
973 case bfd_print_symbol_name:
974 fprintf (file, "%s", symbol->name);
975 break;
976 case bfd_print_symbol_more:
977 break;
979 case bfd_print_symbol_all:
981 const char *section_name = symbol->section->name;
983 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
985 fprintf (file, " %-5s %s",
986 section_name,
987 symbol->name);
992 #define tekhex_close_and_cleanup _bfd_generic_close_and_cleanup
993 #define tekhex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
994 #define tekhex_new_section_hook _bfd_generic_new_section_hook
996 #define tekhex_bfd_is_local_label_name bfd_generic_is_local_label_name
997 #define tekhex_get_lineno _bfd_nosymbols_get_lineno
998 #define tekhex_find_nearest_line _bfd_nosymbols_find_nearest_line
999 #define tekhex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1000 #define tekhex_read_minisymbols _bfd_generic_read_minisymbols
1001 #define tekhex_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1003 #define tekhex_bfd_get_relocated_section_contents \
1004 bfd_generic_get_relocated_section_contents
1005 #define tekhex_bfd_relax_section bfd_generic_relax_section
1006 #define tekhex_bfd_gc_sections bfd_generic_gc_sections
1007 #define tekhex_bfd_merge_sections bfd_generic_merge_sections
1008 #define tekhex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1009 #define tekhex_bfd_link_add_symbols _bfd_generic_link_add_symbols
1010 #define tekhex_bfd_final_link _bfd_generic_final_link
1011 #define tekhex_bfd_link_split_section _bfd_generic_link_split_section
1013 #define tekhex_get_section_contents_in_window \
1014 _bfd_generic_get_section_contents_in_window
1016 const bfd_target tekhex_vec =
1018 "tekhex", /* name */
1019 bfd_target_tekhex_flavour,
1020 BFD_ENDIAN_UNKNOWN, /* target byte order */
1021 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
1022 (EXEC_P | /* object flags */
1023 HAS_SYMS | HAS_LINENO | HAS_DEBUG | HAS_RELOC | HAS_LOCALS |
1024 WP_TEXT | D_PAGED),
1025 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1026 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1027 0, /* leading underscore */
1028 ' ', /* ar_pad_char */
1029 16, /* ar_max_namelen */
1030 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1031 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1032 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1033 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1034 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1035 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1038 _bfd_dummy_target,
1039 tekhex_object_p, /* bfd_check_format */
1040 _bfd_dummy_target,
1041 _bfd_dummy_target,
1044 bfd_false,
1045 tekhex_mkobject,
1046 _bfd_generic_mkarchive,
1047 bfd_false,
1049 { /* bfd_write_contents */
1050 bfd_false,
1051 tekhex_write_object_contents,
1052 _bfd_write_archive_contents,
1053 bfd_false,
1056 BFD_JUMP_TABLE_GENERIC (tekhex),
1057 BFD_JUMP_TABLE_COPY (_bfd_generic),
1058 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1059 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1060 BFD_JUMP_TABLE_SYMBOLS (tekhex),
1061 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1062 BFD_JUMP_TABLE_WRITE (tekhex),
1063 BFD_JUMP_TABLE_LINK (tekhex),
1064 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1066 NULL,
1068 (PTR) 0