1 /* BFD backend for Extended Tektronix Hex Format objects.
2 Copyright (C) 1992, 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 Tektronix Hex Format handling
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
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
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.
53 A TekHex record looks like:
55 %<block length><type><checksum><stuff><cr>
60 is the number of bytes in the record not including the % sign.
68 The data can come out of order, and may be discontigous. This is a
69 serial protocol, so big files are unlikely, so we keep a list of 8k chunks
82 typedef struct tekhex_symbol_struct
86 struct tekhex_symbol_struct *prev;
90 static char digs[] = "0123456789ABCDEF";
92 static char sum_block[256];
94 /* Horrible ascii dependent macros for converting between hex and
97 #define CHARS_IN_SET 256
98 static char hex_value[CHARS_IN_SET];
101 #define NIBBLE(x) hex_value[x]
102 #define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
104 (d)[1] = digs[(x) & 0xf]; \
105 (d)[0] = digs[((x)>>4)&0xf];
106 #define ISHEX(x) (hex_value[x] != NOT_HEX)
110 %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
111 %1B3709T_SEGMENT1108FFFFFFFF
112 %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
113 %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
114 %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
115 %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
116 %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
117 %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
118 %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
119 %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
120 %2734D9T_SEGMENT8Bvoid$t15$151035_main10
121 %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
122 %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
126 %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
128 | || +------ 4 char integer 0x8000
129 | |+-------- checksum
130 | +--------- type 6 (data record)
131 +----------- length 3a chars
132 <---------------------- 3a (58 chars) ------------------->
134 %1B3709T_SEGMENT1108FFFFFFFF
135 ^ ^^ ^- 8 character integer 0xffffffff
136 | |+- 1 character integer 0
137 | +-- type 1 symbol (section definition)
138 +------------ 9 char symbol T_SEGMENT
140 %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
141 %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
142 %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
143 %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
144 %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
145 %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
146 %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
147 %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
148 %2734D9T_SEGMENT8Bvoid$t15$151035_main10
149 %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
150 %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
154 sac@thepub$ ./objdump -dx -m m68k f
156 f: file format tekhex
157 -----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
158 architecture: UNKNOWN!, flags 0x00000010:
160 start address 0x00000000
161 SECTION 0 [D00000000] : size 00020000 vma 00000000 align 2**0
163 SECTION 1 [D00008000] : size 00002001 vma 00008000 align 2**0
165 SECTION 2 [T_SEGMENT] : size ffffffff vma 00000000 align 2**0
168 00000000 g T_SEGMENT gcc_compiled$
169 00000000 g T_SEGMENT hello$c
170 00000000 g T_SEGMENT int$t1$r1$$21474
171 00000000 g T_SEGMENT char$t2$r2$0$127
172 00000000 g T_SEGMENT long$int$t3$r1$$
173 00000000 g T_SEGMENT unsigned$int$t4$
174 00000000 g T_SEGMENT long$unsigned$in
175 00000000 g T_SEGMENT short$int$t6$r1$
176 00000000 g T_SEGMENT long$long$int$t7
177 00000000 g T_SEGMENT short$unsigned$i
178 00000000 g T_SEGMENT long$long$unsign
179 00000000 g T_SEGMENT signed$char$t10$
180 00000000 g T_SEGMENT unsigned$char$t1
181 00000000 g T_SEGMENT float$t12$r1$4$0
182 00000000 g T_SEGMENT double$t13$r1$8$
183 00000000 g T_SEGMENT long$double$t14$
184 00000000 g T_SEGMENT void$t15$15
185 00000000 g T_SEGMENT _main
186 00000000 g T_SEGMENT $
187 00000000 g T_SEGMENT $
188 00000000 g T_SEGMENT $
189 00000010 g T_SEGMENT $
190 00000000 g T_SEGMENT main$F1
191 fcffffff g T_SEGMENT i$1
192 00000000 g T_SEGMENT $
193 00000010 g T_SEGMENT $
196 RELOCATION RECORDS FOR [D00000000]: (none)
198 RELOCATION RECORDS FOR [D00008000]: (none)
200 RELOCATION RECORDS FOR [T_SEGMENT]: (none)
202 Disassembly of section D00000000:
204 00008000 ($+)7ff0 linkw fp,#-4
205 00008004 ($+)7ff4 nop
206 00008006 ($+)7ff6 movel #99,d0
207 00008008 ($+)7ff8 cmpl fp@(-4),d0
208 0000800c ($+)7ffc blts 00008014 ($+)8004
209 0000800e ($+)7ffe addql #1,fp@(-4)
210 00008012 ($+)8002 bras 00008006 ($+)7ff6
211 00008014 ($+)8004 unlk fp
212 00008016 ($+)8006 rts
221 static boolean inited = false;
229 for (i = 0; i < CHARS_IN_SET; i++)
231 hex_value[i] = NOT_HEX;
234 for (i = 0; i < 10; i++)
236 hex_value[i + '0'] = i;
239 for (i = 0; i < 6; i++)
241 hex_value[i + 'a'] = i + 10;
242 hex_value[i + 'A'] = i + 10;
245 for (i = 0; i < 10; i++)
247 sum_block[i + '0'] = val++;
249 for (i = 'A'; i <= 'Z'; i++)
251 sum_block[i] = val++;
253 sum_block['$'] = val++;
254 sum_block['%'] = val++;
255 sum_block['.'] = val++;
256 sum_block['_'] = val++;
257 for (i = 'a'; i <= 'z'; i++)
259 sum_block[i] = val++;
264 /* The maximum number of bytes on a line is FF */
265 #define MAXCHUNK 0xff
266 /* The number of bytes we fit onto a line on output */
269 /* We cannot output our tekhexords as we see them, we have to glue them
270 together, this is done in this structure : */
272 struct tekhex_data_list_struct
277 struct tekhex_data_list_struct *next;
280 typedef struct tekhex_data_list_struct tekhex_data_list_type;
282 #define CHUNK_MASK 0x1fff
286 char chunk_data[CHUNK_MASK + 1];
287 char chunk_init[CHUNK_MASK + 1];
289 struct data_struct *next;
292 typedef struct tekhex_data_struct
294 tekhex_data_list_type *head;
296 struct tekhex_symbol_struct *symbols;
297 struct data_struct *data;
300 #define enda(x) (x->vma + x->size)
308 unsigned int len = hex_value[*src++];
314 value = value << 4 | hex_value[*src++];
327 unsigned int len = hex_value[*src++];
331 for (i = 0; i < len; i++)
339 find_chunk (abfd, vma)
343 struct data_struct *d = abfd->tdata.tekhex_data->data;
346 while (d && (d->vma) != vma)
352 char *sname = bfd_alloc (abfd, 12);
355 /* No chunk for this address, so make one up */
356 d = (struct data_struct *)
357 bfd_alloc (abfd, sizeof (struct data_struct));
361 bfd_set_error (bfd_error_no_memory);
365 memset (d->chunk_init, 0, CHUNK_MASK + 1);
366 memset (d->chunk_data, 0, CHUNK_MASK + 1);
367 d->next = abfd->tdata.tekhex_data->data;
369 abfd->tdata.tekhex_data->data = d;
375 insert_byte (abfd, value, addr)
380 /* Find the chunk that this byte needs and put it in */
381 struct data_struct *d = find_chunk (abfd, addr);
383 d->chunk_data[addr & CHUNK_MASK] = value;
384 d->chunk_init[addr & CHUNK_MASK] = 1;
387 /* The first pass is to find the names of all the sections, and see
388 how big the data is */
390 first_phase (abfd, type, src)
395 asection *section = &bfd_abs_section;
397 char sym[17]; /* A symbol can only be 16chars long */
402 /* Data record - read it and store it */
404 bfd_vma addr = getvalue (&src);
408 insert_byte (abfd, HEX (src), addr);
416 /* Symbol record, read the segment */
417 len = getsym (sym, &src);
418 section = bfd_get_section_by_name (abfd, sym);
419 if (section == (asection *) NULL)
421 char *n = bfd_alloc (abfd, len + 1);
425 bfd_set_error (bfd_error_no_memory);
428 memcpy (n, sym, len + 1);
429 section = bfd_make_section (abfd, n);
437 case '1': /* section range */
439 section->vma = getvalue (&src);
440 section->_raw_size = getvalue (&src) - section->vma;
441 section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
450 /* Symbols, add to section */
452 tekhex_symbol_type *new =
453 (tekhex_symbol_type *) bfd_alloc (abfd,
454 sizeof (tekhex_symbol_type));
459 bfd_set_error (bfd_error_no_memory);
462 new->symbol.the_bfd = abfd;
465 abfd->flags |= HAS_SYMS;
466 new->prev = abfd->tdata.tekhex_data->symbols;
467 abfd->tdata.tekhex_data->symbols = new;
468 len = getsym (sym, &src);
469 new->symbol.name = bfd_alloc (abfd, len + 1);
470 if (!new->symbol.name)
472 bfd_set_error (bfd_error_no_memory);
475 memcpy ((char *) (new->symbol.name), sym, len + 1);
476 new->symbol.section = section;
478 new->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
480 new->symbol.flags = BSF_LOCAL;
481 new->symbol.value = getvalue (&src) - section->vma;
488 /* Pass over an tekhex, calling one of the above functions on each
492 pass_over (abfd, func)
496 unsigned int chars_on_line;
499 /* To the front of the file */
500 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
503 char buffer[MAXCHUNK];
509 eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
510 while (*src != '%' && !eof)
512 eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
518 /* Fetch the type and the length and the checksum */
519 bfd_read (src, 1, 5, abfd);
523 if (!ISHEX (src[0]) || !ISHEX (src[1]))
526 chars_on_line = HEX (src) - 5; /* Already read five char */
528 bfd_read (src, 1, chars_on_line, abfd);
529 src[chars_on_line] = 0; /* put a null at the end */
531 func (abfd, type, src);
537 tekhex_get_symtab (abfd, table)
542 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
543 unsigned int c = bfd_get_symcount (abfd);
548 table[--c] = &(p->symbol);
552 return bfd_get_symcount (abfd);
556 tekhex_get_symtab_upper_bound (abfd)
559 return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
564 tekhex_mkobject (abfd)
567 tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
571 bfd_set_error (bfd_error_no_memory);
574 abfd->tdata.tekhex_data = tdata;
576 tdata->head = (tekhex_data_list_type *) NULL;
577 tdata->symbols = (struct tekhex_symbol_struct *) NULL;
578 tdata->data = (struct data_struct *) NULL;
583 Return true if the file looks like it's in TekHex format. Just look
584 for a percent sign and some hex digits */
587 tekhex_object_p (abfd)
595 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
596 bfd_read (b, 1, 4, abfd);
598 if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
599 return (bfd_target *) NULL;
601 tekhex_mkobject (abfd);
603 pass_over (abfd, first_phase);
608 move_section_contents (abfd, section, locationp, offset, count, get)
617 char *location = (char *) locationp;
618 bfd_vma prev_number = 1; /* Nothing can have this as a high bit*/
619 struct data_struct *d = (struct data_struct *) NULL;
621 for (addr = section->vma; count != 0; count--, addr++)
624 bfd_vma chunk_number = addr & ~CHUNK_MASK; /* Get high bits of address */
625 bfd_vma low_bits = addr & CHUNK_MASK;
627 if (chunk_number != prev_number)
629 /* Different chunk, so move pointer */
630 d = find_chunk (abfd, chunk_number);
635 if (d->chunk_init[low_bits])
637 *location = d->chunk_data[low_bits];
646 d->chunk_data[low_bits] = *location;
647 d->chunk_init[low_bits] = (*location != 0);
656 tekhex_get_section_contents (abfd, section, locationp, offset, count)
663 if (section->flags & (SEC_LOAD | SEC_ALLOC))
665 move_section_contents (abfd, section, locationp, offset, count, true);
673 tekhex_set_arch_mach (abfd, arch, machine)
675 enum bfd_architecture arch;
676 unsigned long machine;
678 return bfd_default_set_arch_mach (abfd, arch, machine);
681 /* we have to save up all the Tekhexords for a splurge before output,
685 tekhex_set_section_contents (abfd, section, locationp, offset, bytes_to_do)
690 bfd_size_type bytes_to_do;
693 if (abfd->output_has_begun == false)
695 /* The first time around, allocate enough sections to hold all the chunks */
696 asection *s = abfd->sections;
699 for (s = abfd->sections; s; s = s->next)
701 if (s->flags & SEC_LOAD)
703 for (vma = s->vma & ~CHUNK_MASK;
704 vma < s->vma + s->_raw_size;
706 find_chunk (abfd, vma);
711 if (section->flags & (SEC_LOAD | SEC_ALLOC))
713 move_section_contents (abfd, section, locationp, offset, bytes_to_do, false);
722 writevalue (dst, value)
730 for (len = 8, shift = 28; shift; shift -= 4, len--)
732 if ((value >> shift) & 0xf)
737 *p++ = digs[(value >> shift) & 0xf];
757 int len = (sym ? strlen (sym) : 0);
787 out (abfd, type, start, end)
798 TOHEX (front + 1, end - start + 5);
801 for (s = start; s < end; s++)
803 sum += sum_block[*s];
806 sum += sum_block[front[1]]; /* length */
807 sum += sum_block[front[2]];
808 sum += sum_block[front[3]]; /* type */
809 TOHEX (front + 4, sum);
810 bfd_write (front, 1, 6, abfd);
812 bfd_write (start, 1, end - start + 1, abfd);
817 tekhex_write_object_contents (abfd)
823 tdata_type *tdata = abfd->tdata.tekhex_data;
824 tekhex_data_list_type *list;
826 struct data_struct *d;
830 /* And the raw data */
831 for (d = abfd->tdata.tekhex_data->data;
832 d != (struct data_struct *) NULL;
840 /* Write it in blocks of 32 bytes */
842 for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
846 /* Check to see if necessary */
847 for (low = 0; !need && low < span; low++)
849 if (d->chunk_init[addr + low])
856 writevalue (&dst, addr + d->vma);
857 for (low = 0; low < span; low++)
859 TOHEX (dst, d->chunk_data[addr + low]);
862 out (abfd, '6', buffer, dst);
866 /* write all the section headers for the sections */
867 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
871 writesym (&dst, s->name);
873 writevalue (&dst, s->vma);
874 writevalue (&dst, s->vma + s->_raw_size);
875 out (abfd, '3', buffer, dst);
878 /* And the symbols */
879 for (p = abfd->outsymbols; *p; p++)
881 int section_code = bfd_decode_symclass (*p);
883 if (section_code != '?')
884 { /* do not include debug symbols */
888 writesym (&dst, s->section->name);
890 switch (section_code)
916 bfd_set_error (bfd_error_wrong_format);
920 writesym (&dst, s->name);
921 writevalue (&dst, s->value + s->section->vma);
922 out (abfd, '3', buffer, dst);
926 /* And the terminator */
927 bfd_write ("%7081010\n", 1, 9, abfd);
932 tekhex_sizeof_headers (abfd, exec)
941 tekhex_make_empty_symbol (abfd)
944 tekhex_symbol_type *new =
945 (tekhex_symbol_type *) bfd_zalloc (abfd, sizeof (struct tekhex_symbol_struct));
949 bfd_set_error (bfd_error_no_memory);
952 new->symbol.the_bfd = abfd;
953 new->prev = (struct tekhex_symbol_struct *) NULL;
954 return &(new->symbol);
958 tekhex_get_symbol_info (ignore_abfd, symbol, ret)
963 bfd_symbol_info (symbol, ret);
967 tekhex_print_symbol (ignore_abfd, filep, symbol, how)
971 bfd_print_symbol_type how;
973 FILE *file = (FILE *) filep;
977 case bfd_print_symbol_name:
978 fprintf (file, "%s", symbol->name);
980 case bfd_print_symbol_more:
983 case bfd_print_symbol_all:
985 CONST char *section_name = symbol->section->name;
987 bfd_print_symbol_vandf ((PTR) file, symbol);
989 fprintf (file, " %-5s %s",
997 #define tekhex_new_section_hook (FOO(boolean, (*), (bfd *, asection *)))bfd_true
998 #define tekhex_get_reloc_upper_bound (FOO(long, (*),(bfd*, asection *)))bfd_0l
999 #define tekhex_canonicalize_reloc (FOO(long, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0l
1001 #define tekhex_openr_next_archived_file (FOO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr
1002 #define tekhex_find_nearest_line (FOO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false
1003 #define tekhex_generic_stat_arch_elt (FOO(int, (*), (bfd *,struct stat *))) bfd_0
1005 #define tekhex_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
1006 #define tekhex_core_file_failing_signal (int (*)())bfd_0
1007 #define tekhex_core_file_matches_executable_p (FOO(boolean, (*),(bfd*, bfd*)))bfd_false
1008 #define tekhex_slurp_armap bfd_true
1009 #define tekhex_slurp_extended_name_table bfd_true
1010 #define tekhex_truncate_arname (void (*)())bfd_nullvoidptr
1011 #define tekhex_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
1012 #define tekhex_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
1013 #define tekhex_close_and_cleanup bfd_generic_close_and_cleanup
1014 #define tekhex_bfd_debug_info_start bfd_void
1015 #define tekhex_bfd_debug_info_end bfd_void
1016 #define tekhex_bfd_debug_info_accumulate (FOO(void, (*), (bfd *, asection *))) bfd_void
1017 #define tekhex_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
1018 #define tekhex_bfd_relax_section bfd_generic_relax_section
1019 #define tekhex_bfd_reloc_type_lookup \
1020 ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
1021 #define tekhex_bfd_make_debug_symbol \
1022 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
1023 #define tekhex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1024 #define tekhex_bfd_link_add_symbols _bfd_generic_link_add_symbols
1025 #define tekhex_bfd_final_link _bfd_generic_final_link
1026 #define tekhex_bfd_copy_private_section_data \
1027 ((boolean (*) PARAMS ((bfd *, asection *, bfd *, asection *))) bfd_true)
1028 #define tekhex_bfd_copy_private_bfd_data \
1029 ((boolean (*) PARAMS ((bfd *, bfd *))) bfd_true)
1030 #define tekhex_bfd_is_local_label bfd_generic_is_local_label
1031 #define tekhex_bfd_free_cached_info bfd_true
1033 bfd_target tekhex_vec =
1035 "tekhex", /* name */
1036 bfd_target_tekhex_flavour,
1037 true, /* target byte order */
1038 true, /* target headers byte order */
1039 (EXEC_P | /* object flags */
1040 HAS_SYMS | HAS_LINENO | HAS_DEBUG | HAS_RELOC | HAS_LOCALS |
1042 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1043 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1044 0, /* leading underscore */
1045 ' ', /* ar_pad_char */
1046 16, /* ar_max_namelen */
1047 1, /* minimum alignment */
1048 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1049 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1050 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1051 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1052 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1053 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1057 tekhex_object_p, /* bfd_check_format */
1058 (struct bfd_target * (*)()) bfd_nullvoidptr,
1059 (struct bfd_target * (*)()) bfd_nullvoidptr,
1064 _bfd_generic_mkarchive,
1067 { /* bfd_write_contents */
1069 tekhex_write_object_contents,
1070 _bfd_write_archive_contents,
1073 JUMP_TABLE (tekhex),