1 /* BFD backend for Extended Tektronix Hex Format objects.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2009 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
25 Tektronix Hex Format handling
29 Tek Hex records can hold symbols and data, but not
30 relocations. Their main application is communication with
31 devices like PROM programmers and ICE equipment.
33 It seems that the sections are described as being really big,
34 the example I have says that the text section is 0..ffffffff.
35 BFD would barf with this, many apps would try to alloc 4GB to
38 Tex Hex may contain many sections, but the data which comes in
39 has no tag saying which section it belongs to, so we create
40 one section for each block of data, called "blknnnn" which we
41 stick all the data into.
43 TekHex may come out of order and there is no header, so an
44 initial scan is required to discover the minimum and maximum
45 addresses used to create the vma and size of the sections we
47 We read in the data into pages of CHUNK_MASK+1 size and read
48 them out from that whenever we need to.
50 Any number of sections may be created for output, we save them
51 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.
67 The data can come out of order, and may be discontigous. This is a
68 serial protocol, so big files are unlikely, so we keep a list of 8k chunks. */
73 #include "libiberty.h"
81 typedef struct tekhex_symbol_struct
84 struct tekhex_symbol_struct *prev;
87 static const char digs[] = "0123456789ABCDEF";
89 static char sum_block[256];
92 #define NIBBLE(x) hex_value(x)
93 #define HEX(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
94 #define ISHEX(x) hex_p(x)
96 (d)[1] = digs[(x) & 0xf]; \
97 (d)[0] = digs[((x)>>4)&0xf];
100 %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
101 %1B3709T_SEGMENT1108FFFFFFFF
102 %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
103 %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
104 %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
105 %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
106 %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
107 %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
108 %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
109 %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
110 %2734D9T_SEGMENT8Bvoid$t15$151035_main10
111 %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
112 %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
116 %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
118 | || +------ 4 char integer 0x8000
119 | |+-------- checksum
120 | +--------- type 6 (data record)
121 +----------- length 3a chars
122 <---------------------- 3a (58 chars) ------------------->
124 %1B3709T_SEGMENT1108FFFFFFFF
125 ^ ^^ ^- 8 character integer 0xffffffff
126 | |+- 1 character integer 0
127 | +-- type 1 symbol (section definition)
128 +------------ 9 char symbol T_SEGMENT
130 %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
131 %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
132 %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
133 %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
134 %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
135 %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
136 %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
137 %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
138 %2734D9T_SEGMENT8Bvoid$t15$151035_main10
139 %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
140 %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
144 sac@thepub$ ./objdump -dx -m m68k f
146 f: file format tekhex
147 -----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
148 architecture: UNKNOWN!, flags 0x00000010:
150 start address 0x00000000
151 SECTION 0 [D00000000] : size 00020000 vma 00000000 align 2**0
153 SECTION 1 [D00008000] : size 00002001 vma 00008000 align 2**0
155 SECTION 2 [T_SEGMENT] : size ffffffff vma 00000000 align 2**0
158 00000000 g T_SEGMENT gcc_compiled$
159 00000000 g T_SEGMENT hello$c
160 00000000 g T_SEGMENT int$t1$r1$$21474
161 00000000 g T_SEGMENT char$t2$r2$0$127
162 00000000 g T_SEGMENT long$int$t3$r1$$
163 00000000 g T_SEGMENT unsigned$int$t4$
164 00000000 g T_SEGMENT long$unsigned$in
165 00000000 g T_SEGMENT short$int$t6$r1$
166 00000000 g T_SEGMENT long$long$int$t7
167 00000000 g T_SEGMENT short$unsigned$i
168 00000000 g T_SEGMENT long$long$unsign
169 00000000 g T_SEGMENT signed$char$t10$
170 00000000 g T_SEGMENT unsigned$char$t1
171 00000000 g T_SEGMENT float$t12$r1$4$0
172 00000000 g T_SEGMENT double$t13$r1$8$
173 00000000 g T_SEGMENT long$double$t14$
174 00000000 g T_SEGMENT void$t15$15
175 00000000 g T_SEGMENT _main
176 00000000 g T_SEGMENT $
177 00000000 g T_SEGMENT $
178 00000000 g T_SEGMENT $
179 00000010 g T_SEGMENT $
180 00000000 g T_SEGMENT main$F1
181 fcffffff g T_SEGMENT i$1
182 00000000 g T_SEGMENT $
183 00000010 g T_SEGMENT $
185 RELOCATION RECORDS FOR [D00000000]: (none)
187 RELOCATION RECORDS FOR [D00008000]: (none)
189 RELOCATION RECORDS FOR [T_SEGMENT]: (none)
191 Disassembly of section D00000000:
193 00008000 ($+)7ff0 linkw fp,#-4
194 00008004 ($+)7ff4 nop
195 00008006 ($+)7ff6 movel #99,d0
196 00008008 ($+)7ff8 cmpl fp@(-4),d0
197 0000800c ($+)7ffc blts 00008014 ($+)8004
198 0000800e ($+)7ffe addql #1,fp@(-4)
199 00008012 ($+)8002 bras 00008006 ($+)7ff6
200 00008014 ($+)8004 unlk fp
201 00008016 ($+)8006 rts
208 static bfd_boolean inited = FALSE;
216 for (i = 0; i < 10; i++)
217 sum_block[i + '0'] = val++;
219 for (i = 'A'; i <= 'Z'; i++)
220 sum_block[i] = val++;
222 sum_block['$'] = val++;
223 sum_block['%'] = val++;
224 sum_block['.'] = val++;
225 sum_block['_'] = val++;
226 for (i = 'a'; i <= 'z'; i++)
227 sum_block[i] = val++;
231 /* The maximum number of bytes on a line is FF. */
232 #define MAXCHUNK 0xff
233 /* The number of bytes we fit onto a line on output. */
236 /* We cannot output our tekhexords as we see them, we have to glue them
237 together, this is done in this structure : */
239 struct tekhex_data_list_struct
244 struct tekhex_data_list_struct *next;
247 typedef struct tekhex_data_list_struct tekhex_data_list_type;
249 #define CHUNK_MASK 0x1fff
253 char chunk_data[CHUNK_MASK + 1];
254 char chunk_init[CHUNK_MASK + 1];
256 struct data_struct *next;
259 typedef struct tekhex_data_struct
261 tekhex_data_list_type *head;
263 struct tekhex_symbol_struct *symbols;
264 struct data_struct *data;
267 #define enda(x) (x->vma + x->size)
270 getvalue (char **srcp, bfd_vma *valuep)
279 len = hex_value (*src++);
286 value = value << 4 | hex_value (*src++);
295 getsym (char *dstp, char **srcp, unsigned int *lenp)
304 len = hex_value (*src++);
307 for (i = 0; i < len; i++)
315 static struct data_struct *
316 find_chunk (bfd *abfd, bfd_vma vma)
318 struct data_struct *d = abfd->tdata.tekhex_data->data;
321 while (d && (d->vma) != vma)
326 /* No chunk for this address, so make one up. */
327 d = bfd_zalloc (abfd, (bfd_size_type) sizeof (struct data_struct));
332 d->next = abfd->tdata.tekhex_data->data;
334 abfd->tdata.tekhex_data->data = d;
340 insert_byte (bfd *abfd, int value, bfd_vma addr)
342 /* Find the chunk that this byte needs and put it in. */
343 struct data_struct *d = find_chunk (abfd, addr);
345 d->chunk_data[addr & CHUNK_MASK] = value;
346 d->chunk_init[addr & CHUNK_MASK] = 1;
349 /* The first pass is to find the names of all the sections, and see
350 how big the data is. */
353 first_phase (bfd *abfd, int type, char *src)
355 asection *section = bfd_abs_section_ptr;
358 char sym[17]; /* A symbol can only be 16chars long. */
363 /* Data record - read it and store it. */
367 if (!getvalue (&src, &addr))
372 insert_byte (abfd, HEX (src), addr);
380 /* Symbol record, read the segment. */
381 if (!getsym (sym, &src, &len))
383 section = bfd_get_section_by_name (abfd, sym);
386 char *n = bfd_alloc (abfd, (bfd_size_type) len + 1);
390 memcpy (n, sym, len + 1);
391 section = bfd_make_section (abfd, n);
399 case '1': /* Section range. */
401 if (!getvalue (&src, §ion->vma))
403 if (!getvalue (&src, &val))
405 section->size = val - section->vma;
406 section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
415 /* Symbols, add to section. */
417 bfd_size_type amt = sizeof (tekhex_symbol_type);
418 tekhex_symbol_type *new_symbol = (tekhex_symbol_type *)
419 bfd_alloc (abfd, amt);
424 new_symbol->symbol.the_bfd = abfd;
427 abfd->flags |= HAS_SYMS;
428 new_symbol->prev = abfd->tdata.tekhex_data->symbols;
429 abfd->tdata.tekhex_data->symbols = new_symbol;
430 if (!getsym (sym, &src, &len))
432 new_symbol->symbol.name = (const char *)
433 bfd_alloc (abfd, (bfd_size_type) len + 1);
434 if (!new_symbol->symbol.name)
436 memcpy ((char *) (new_symbol->symbol.name), sym, len + 1);
437 new_symbol->symbol.section = section;
439 new_symbol->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
441 new_symbol->symbol.flags = BSF_LOCAL;
442 if (!getvalue (&src, &val))
444 new_symbol->symbol.value = val - section->vma;
456 /* Pass over a tekhex, calling one of the above functions on each
460 pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
462 unsigned int chars_on_line;
463 bfd_boolean eof = FALSE;
465 /* To the front of the file. */
466 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
473 /* Find first '%'. */
474 eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
475 while (*src != '%' && !eof)
476 eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
481 /* Fetch the type and the length and the checksum. */
482 if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
487 if (!ISHEX (src[0]) || !ISHEX (src[1]))
490 /* Already read five chars. */
491 chars_on_line = HEX (src) - 5;
493 if (chars_on_line >= MAXCHUNK)
496 if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
499 /* Put a null at the end. */
500 src[chars_on_line] = 0;
502 if (!func (abfd, type, src))
510 tekhex_canonicalize_symtab (bfd *abfd, asymbol **table)
512 tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
513 unsigned int c = bfd_get_symcount (abfd);
518 table[--c] = &(p->symbol);
522 return bfd_get_symcount (abfd);
526 tekhex_get_symtab_upper_bound (bfd *abfd)
528 return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
533 tekhex_mkobject (bfd *abfd)
537 tdata = bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
540 abfd->tdata.tekhex_data = tdata;
543 tdata->symbols = NULL;
548 /* Return TRUE if the file looks like it's in TekHex format. Just look
549 for a percent sign and some hex digits. */
551 static const bfd_target *
552 tekhex_object_p (bfd *abfd)
558 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
559 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
562 if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
565 tekhex_mkobject (abfd);
567 if (!pass_over (abfd, first_phase))
574 move_section_contents (bfd *abfd,
576 const void * locationp,
582 char *location = (char *) locationp;
583 bfd_vma prev_number = 1; /* Nothing can have this as a high bit. */
584 struct data_struct *d = NULL;
586 BFD_ASSERT (offset == 0);
587 for (addr = section->vma; count != 0; count--, addr++)
589 /* Get high bits of address. */
590 bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
591 bfd_vma low_bits = addr & CHUNK_MASK;
593 if (chunk_number != prev_number)
594 /* Different chunk, so move pointer. */
595 d = find_chunk (abfd, chunk_number);
599 if (d->chunk_init[low_bits])
600 *location = d->chunk_data[low_bits];
606 d->chunk_data[low_bits] = *location;
607 d->chunk_init[low_bits] = (*location != 0);
615 tekhex_get_section_contents (bfd *abfd,
621 if (section->flags & (SEC_LOAD | SEC_ALLOC))
623 move_section_contents (abfd, section, locationp, offset, count, TRUE);
631 tekhex_set_arch_mach (bfd *abfd,
632 enum bfd_architecture arch,
633 unsigned long machine)
635 return bfd_default_set_arch_mach (abfd, arch, machine);
638 /* We have to save up all the Tekhexords for a splurge before output. */
641 tekhex_set_section_contents (bfd *abfd,
643 const void * locationp,
645 bfd_size_type bytes_to_do)
647 if (! abfd->output_has_begun)
649 /* The first time around, allocate enough sections to hold all the chunks. */
650 asection *s = abfd->sections;
653 for (s = abfd->sections; s; s = s->next)
655 if (s->flags & SEC_LOAD)
657 for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
658 vma < s->vma + s->size;
660 find_chunk (abfd, vma);
665 if (section->flags & (SEC_LOAD | SEC_ALLOC))
667 move_section_contents (abfd, section, locationp, offset, bytes_to_do,
676 writevalue (char **dst, bfd_vma value)
682 for (len = 8, shift = 28; shift; shift -= 4, len--)
684 if ((value >> shift) & 0xf)
689 *p++ = digs[(value >> shift) & 0xf];
704 writesym (char **dst, const char *sym)
707 int len = (sym ? strlen (sym) : 0);
733 out (bfd *abfd, int type, char *start, char *end)
741 TOHEX (front + 1, end - start + 5);
744 for (s = start; s < end; s++)
745 sum += sum_block[(unsigned char) *s];
747 sum += sum_block[(unsigned char) front[1]]; /* Length. */
748 sum += sum_block[(unsigned char) front[2]];
749 sum += sum_block[(unsigned char) front[3]]; /* Type. */
750 TOHEX (front + 4, sum);
751 if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
754 wrlen = end - start + 1;
755 if (bfd_bwrite (start, wrlen, abfd) != wrlen)
760 tekhex_write_object_contents (bfd *abfd)
765 struct data_struct *d;
769 /* And the raw data. */
770 for (d = abfd->tdata.tekhex_data->data;
779 /* Write it in blocks of 32 bytes. */
780 for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
784 /* Check to see if necessary. */
785 for (low = 0; !need && low < span; low++)
786 if (d->chunk_init[addr + low])
793 writevalue (&dst, addr + d->vma);
794 for (low = 0; low < span; low++)
796 TOHEX (dst, d->chunk_data[addr + low]);
799 out (abfd, '6', buffer, dst);
804 /* Write all the section headers for the sections. */
805 for (s = abfd->sections; s != NULL; s = s->next)
809 writesym (&dst, s->name);
811 writevalue (&dst, s->vma);
812 writevalue (&dst, s->vma + s->size);
813 out (abfd, '3', buffer, dst);
816 /* And the symbols. */
817 if (abfd->outsymbols)
819 for (p = abfd->outsymbols; *p; p++)
821 int section_code = bfd_decode_symclass (*p);
823 if (section_code != '?')
825 /* Do not include debug symbols. */
829 writesym (&dst, sym->section->name);
831 switch (section_code)
857 bfd_set_error (bfd_error_wrong_format);
861 writesym (&dst, sym->name);
862 writevalue (&dst, sym->value + sym->section->vma);
863 out (abfd, '3', buffer, dst);
868 /* And the terminator. */
869 if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
875 tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
876 struct bfd_link_info *info ATTRIBUTE_UNUSED)
882 tekhex_make_empty_symbol (bfd *abfd)
884 bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
885 tekhex_symbol_type *new_symbol = (tekhex_symbol_type *) bfd_zalloc (abfd,
890 new_symbol->symbol.the_bfd = abfd;
891 new_symbol->prev = NULL;
892 return &(new_symbol->symbol);
896 tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
900 bfd_symbol_info (symbol, ret);
904 tekhex_print_symbol (bfd *abfd,
907 bfd_print_symbol_type how)
909 FILE *file = (FILE *) filep;
913 case bfd_print_symbol_name:
914 fprintf (file, "%s", symbol->name);
916 case bfd_print_symbol_more:
919 case bfd_print_symbol_all:
921 const char *section_name = symbol->section->name;
923 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
925 fprintf (file, " %-5s %s",
926 section_name, symbol->name);
931 #define tekhex_close_and_cleanup _bfd_generic_close_and_cleanup
932 #define tekhex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
933 #define tekhex_new_section_hook _bfd_generic_new_section_hook
934 #define tekhex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
935 #define tekhex_bfd_is_local_label_name bfd_generic_is_local_label_name
936 #define tekhex_get_lineno _bfd_nosymbols_get_lineno
937 #define tekhex_find_nearest_line _bfd_nosymbols_find_nearest_line
938 #define tekhex_find_inliner_info _bfd_nosymbols_find_inliner_info
939 #define tekhex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
940 #define tekhex_read_minisymbols _bfd_generic_read_minisymbols
941 #define tekhex_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
942 #define tekhex_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
943 #define tekhex_bfd_relax_section bfd_generic_relax_section
944 #define tekhex_bfd_gc_sections bfd_generic_gc_sections
945 #define tekhex_bfd_merge_sections bfd_generic_merge_sections
946 #define tekhex_bfd_is_group_section bfd_generic_is_group_section
947 #define tekhex_bfd_discard_group bfd_generic_discard_group
948 #define tekhex_section_already_linked _bfd_generic_section_already_linked
949 #define tekhex_bfd_define_common_symbol bfd_generic_define_common_symbol
950 #define tekhex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
951 #define tekhex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
952 #define tekhex_bfd_link_add_symbols _bfd_generic_link_add_symbols
953 #define tekhex_bfd_link_just_syms _bfd_generic_link_just_syms
954 #define tekhex_bfd_final_link _bfd_generic_final_link
955 #define tekhex_bfd_link_split_section _bfd_generic_link_split_section
956 #define tekhex_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
958 const bfd_target tekhex_vec =
960 "tekhex", /* Name. */
961 bfd_target_tekhex_flavour,
962 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
963 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
964 (EXEC_P | /* Object flags. */
965 HAS_SYMS | HAS_LINENO | HAS_DEBUG |
966 HAS_RELOC | HAS_LOCALS | WP_TEXT | D_PAGED),
967 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
968 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
969 0, /* Leading underscore. */
970 ' ', /* AR_pad_char. */
971 16, /* AR_max_namelen. */
972 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
973 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
974 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
975 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
976 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
977 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
981 tekhex_object_p, /* bfd_check_format. */
988 _bfd_generic_mkarchive,
991 { /* bfd_write_contents. */
993 tekhex_write_object_contents,
994 _bfd_write_archive_contents,
998 BFD_JUMP_TABLE_GENERIC (tekhex),
999 BFD_JUMP_TABLE_COPY (_bfd_generic),
1000 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1001 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1002 BFD_JUMP_TABLE_SYMBOLS (tekhex),
1003 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1004 BFD_JUMP_TABLE_WRITE (tekhex),
1005 BFD_JUMP_TABLE_LINK (tekhex),
1006 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),