1 /* BFD back-end for s-record objects.
2 Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
27 Ordinary S-Records cannot hold anything but addresses and
28 data, so that's all that we implement.
30 The only interesting thing is that S-Records may come out of
31 order and there is no header, so an initial scan is required
32 to discover the minimum and maximum addresses used to create
33 the vma and size of the only section we create. We
34 arbitrarily call this section ".text".
36 When bfd_get_section_contents is called the file is read
37 again, and this time the data is placed into a bfd_alloc'd
40 Any number of sections may be created for output, we save them
41 up and output them when it's time to close the bfd.
43 An s record looks like:
46 S<type><length><address><data><checksum>
51 is the number of bytes following upto the checksum. Note that
52 this is not the number of chars following, since it takes two
53 chars to represent a byte.
57 1) two byte address data record
58 2) three byte address data record
59 3) four byte address data record
60 7) four byte address termination record
61 8) three byte address termination record
62 9) two byte address termination record
65 is the start address of the data following, or in the case of
66 a termination record, the start address of the image
70 is the sum of all the raw byte data in the record, from the length
71 upwards, modulo 256 and subtracted from 255.
75 Symbol S-Record handling
78 Some ICE equipment understands an addition to the standard
79 S-Record format; symbols and their addresses can be sent
82 The format of this is:
84 (<space> <symbol> <address>)*)
87 so a short symbol table could look like:
101 We allow symbols to be anywhere in the data stream - the module names
110 static boolean srec_write_record
PARAMS ((bfd
*, int, bfd_vma
,
111 const unsigned char *,
112 const unsigned char *));
113 static boolean srec_write_header
PARAMS ((bfd
*));
114 static boolean srec_write_symbols
PARAMS ((bfd
*));
116 /* Macros for converting between hex and binary. */
118 static CONST
char digs
[] = "0123456789ABCDEF";
120 /* Table that gets filled in with numbers corresponding to hex chars. */
122 static char hex_value
[256];
125 #define NIBBLE(x) hex_value[(unsigned char)(x)]
126 #define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
127 #define TOHEX(d, x, ch) \
128 d[1] = digs[(x) & 0xf]; \
129 d[0] = digs[((x)>>4)&0xf]; \
131 #define ISHEX(x) (hex_value[(unsigned char)(x)] != NOT_HEX)
133 /* Initialize by filling in the hex conversion array. */
139 static boolean inited
= false;
145 for (i
= 0; i
< sizeof (hex_value
); i
++)
147 hex_value
[i
] = NOT_HEX
;
149 for (i
= 0; i
< 10; i
++)
151 hex_value
[i
+ '0'] = i
;
153 for (i
= 0; i
< 6; i
++)
155 hex_value
[i
+ 'a'] = i
+ 10;
156 hex_value
[i
+ 'A'] = i
+ 10;
162 /* The maximum number of bytes on a line is FF */
163 #define MAXCHUNK 0xff
164 /* The number of bytes we fit onto a line on output */
167 /* We cannot output our srecords as we see them, we have to glue them
168 together, this is done in this structure : */
170 struct srec_data_list_struct
175 struct srec_data_list_struct
*next
;
179 typedef struct srec_data_list_struct srec_data_list_type
;
182 typedef struct srec_data_struct
184 srec_data_list_type
*head
;
185 srec_data_list_type
*tail
;
188 int done_symbol_read
;
198 static boolean srec_write_section
PARAMS ((bfd
*, tdata_type
*,
199 srec_data_list_type
*));
200 static boolean srec_write_terminator
PARAMS ((bfd
*, tdata_type
*));
203 called once per input S-Record, used to work out vma and size of data.
206 static bfd_vma low
, high
;
210 size_symbols (abfd
, buf
, len
, val
)
217 abfd
->tdata
.srec_data
->string_size
+= len
+ 1;
221 fillup_symbols (abfd
, buf
, len
, val
)
227 if (!abfd
->tdata
.srec_data
->done_symbol_read
)
230 if (abfd
->tdata
.srec_data
->symbols
== 0)
232 abfd
->tdata
.srec_data
->symbols
= (asymbol
*) bfd_alloc (abfd
, abfd
->symcount
* sizeof (asymbol
));
233 abfd
->tdata
.srec_data
->strings
= (char *) bfd_alloc (abfd
, abfd
->tdata
.srec_data
->string_size
);
234 if (!abfd
->tdata
.srec_data
->symbols
|| !abfd
->tdata
.srec_data
->strings
)
236 bfd_set_error (bfd_error_no_memory
);
237 abort (); /* FIXME */
239 abfd
->tdata
.srec_data
->symbol_idx
= 0;
240 abfd
->tdata
.srec_data
->string_idx
= 0;
243 p
= abfd
->tdata
.srec_data
->symbols
+ abfd
->tdata
.srec_data
->symbol_idx
++;
245 p
->name
= abfd
->tdata
.srec_data
->strings
+ abfd
->tdata
.srec_data
->string_idx
;
246 memcpy ((char *) (p
->name
), buf
, len
+ 1);
247 abfd
->tdata
.srec_data
->string_idx
+= len
+ 1;
249 p
->flags
= BSF_EXPORT
| BSF_GLOBAL
;
250 p
->section
= bfd_abs_section_ptr
;
256 size_srec (abfd
, section
, address
, raw
, length
)
265 if (address
+ length
> high
)
266 high
= address
+ length
- 1;
271 called once per input S-Record, copies data from input into bfd_alloc'd area
276 fillup (abfd
, section
, address
, raw
, length
)
285 (bfd_byte
*) (section
->used_by_bfd
) + address
- section
->vma
;
286 /* length -1 because we don't read in the checksum */
287 for (i
= 0; i
< length
- 1; i
++)
295 /* Pass over an S-Record file, calling one of the above functions on each
302 return (x
== ' ' || x
== '\t' || x
== '\n' || x
== '\r');
305 skipwhite (src
, abfd
)
310 while (white (*src
) && !eof
)
312 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
321 if (abfd
->tdata
.srec_data
== 0)
323 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
326 bfd_set_error (bfd_error_no_memory
);
329 abfd
->tdata
.srec_data
= tdata
;
339 pass_over (abfd
, func
, symbolfunc
, section
)
342 void (*symbolfunc
) ();
345 unsigned int bytes_on_line
;
348 srec_mkobject (abfd
);
349 /* To the front of the file */
350 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
354 char buffer
[MAXCHUNK
];
359 /* Find first 'S' or $ */
360 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
369 /* Inside a symbol definition - just ignore the module name */
370 while (*src
!= '\n' && !eof
)
372 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
377 /* spaces - maybe just before a symbol */
378 while (*src
!= '\n' && *src
!= '\r' && white (*src
))
380 eof
= skipwhite (src
, abfd
);
385 char symbol
[MAXCHUNK
];
387 /* get the symbol part */
388 while (!eof
&& !white (*src
) && slen
< MAXCHUNK
)
390 symbol
[slen
++] = *src
;
391 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
394 eof
= skipwhite (src
, abfd
);
395 /* skip the $ for the hex value */
398 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
401 /* Scan off the hex number */
402 while (isxdigit (*src
))
407 else if (isupper (*src
))
409 val
+= *src
- 'A' + 10;
413 val
+= *src
- 'a' + 10;
415 eof
= (boolean
) (bfd_read (src
, 1, 1, abfd
) != 1);
417 symbolfunc (abfd
, symbol
, slen
, val
);
424 /* Fetch the type and the length */
425 if (bfd_read (src
, 1, 3, abfd
) != 3)
426 abort (); /* FIXME */
430 if (!ISHEX (src
[0]) || !ISHEX (src
[1]))
433 bytes_on_line
= HEX (src
);
435 if (bytes_on_line
> MAXCHUNK
/ 2)
439 if (bfd_read (src
, 1, bytes_on_line
* 2, abfd
) != bytes_on_line
* 2)
440 abort (); /* FIXME */
446 /* Prologue - ignore */
454 address
= HEX (src
) | (address
<< 8);
458 address
= HEX (src
) | (address
<< 8);
460 address
= HEX (src
) | (address
<< 8);
463 func (abfd
, section
, address
, src
, bytes_on_line
);
471 address
= HEX (src
) | (address
<< 8);
475 address
= HEX (src
) | (address
<< 8);
477 address
= HEX (src
) | (address
<< 8);
480 abfd
->start_address
= address
;
491 static const bfd_target
*
496 /* We create one section called .text for all the contents,
497 and allocate enough room for the entire file. */
499 section
= bfd_make_section (abfd
, ".text");
500 section
->_raw_size
= 0;
501 section
->vma
= 0xffffffff;
504 pass_over (abfd
, size_srec
, size_symbols
, section
);
505 section
->_raw_size
= high
- low
;
507 section
->flags
= SEC_HAS_CONTENTS
| SEC_LOAD
| SEC_ALLOC
;
510 abfd
->flags
|= HAS_SYMS
;
514 static const bfd_target
*
522 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
523 || bfd_read (b
, 1, 4, abfd
) != 4)
526 if (b
[0] != 'S' || !ISHEX (b
[1]) || !ISHEX (b
[2]) || !ISHEX (b
[3]))
527 return (const bfd_target
*) NULL
;
529 /* We create one section called .text for all the contents,
530 and allocate enough room for the entire file. */
532 return object_p (abfd
);
536 static const bfd_target
*
537 symbolsrec_object_p (abfd
)
544 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
545 || bfd_read (b
, 1, 4, abfd
) != 4)
548 if (b
[0] != '$' || b
[1] != '$')
549 return (const bfd_target
*) NULL
;
551 return object_p (abfd
);
556 srec_get_section_contents (abfd
, section
, location
, offset
, count
)
563 if (section
->used_by_bfd
== (PTR
) NULL
)
565 section
->used_by_bfd
= (PTR
) bfd_alloc (abfd
, section
->_raw_size
);
566 if (!section
->used_by_bfd
)
568 bfd_set_error (bfd_error_no_memory
);
572 pass_over (abfd
, fillup
, fillup_symbols
, section
);
574 memcpy ((PTR
) location
,
575 (PTR
) ((char *) (section
->used_by_bfd
) + offset
),
583 srec_set_arch_mach (abfd
, arch
, machine
)
585 enum bfd_architecture arch
;
586 unsigned long machine
;
588 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
592 /* we have to save up all the Srecords for a splurge before output,
596 srec_set_section_contents (abfd
, section
, location
, offset
, bytes_to_do
)
601 bfd_size_type bytes_to_do
;
603 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
604 register srec_data_list_type
*entry
;
606 entry
= ((srec_data_list_type
*)
607 bfd_alloc (abfd
, sizeof (srec_data_list_type
)));
610 bfd_set_error (bfd_error_no_memory
);
614 if ((section
->flags
& SEC_ALLOC
)
615 && (section
->flags
& SEC_LOAD
))
617 unsigned char *data
= (unsigned char *) bfd_alloc (abfd
, bytes_to_do
);
620 bfd_set_error (bfd_error_no_memory
);
623 memcpy ((PTR
) data
, location
, bytes_to_do
);
625 if ((section
->lma
+ offset
+ bytes_to_do
) <= 0xffff)
629 else if ((section
->lma
+ offset
+ bytes_to_do
) <= 0xffffff
640 entry
->where
= section
->lma
+ offset
;
641 entry
->size
= bytes_to_do
;
643 /* Sort the records by address. Optimize for the common case of
644 adding a record to the end of the list. */
645 if (tdata
->tail
!= NULL
646 && entry
->where
>= tdata
->tail
->where
)
648 tdata
->tail
->next
= entry
;
654 register srec_data_list_type
**look
;
656 for (look
= &tdata
->head
;
657 *look
!= NULL
&& (*look
)->where
< entry
->where
;
658 look
= &(*look
)->next
)
662 if (entry
->next
== NULL
)
669 /* Write a record of type, of the supplied number of bytes. The
670 supplied bytes and length don't have a checksum. That's worked out
674 srec_write_record (abfd
, type
, address
, data
, end
)
678 const unsigned char *data
;
679 const unsigned char *end
;
681 char buffer
[MAXCHUNK
];
683 unsigned int check_sum
= 0;
684 CONST
unsigned char *src
= data
;
693 dst
+= 2; /* leave room for dst*/
699 TOHEX (dst
, (address
>> 24), check_sum
);
703 TOHEX (dst
, (address
>> 16), check_sum
);
708 TOHEX (dst
, (address
>> 8), check_sum
);
710 TOHEX (dst
, (address
), check_sum
);
715 for (src
= data
; src
< end
; src
++)
717 TOHEX (dst
, *src
, check_sum
);
721 /* Fill in the length */
722 TOHEX (length
, (dst
- length
) / 2, check_sum
);
724 check_sum
= 255 - check_sum
;
725 TOHEX (dst
, check_sum
, check_sum
);
730 if (bfd_write ((PTR
) buffer
, 1, dst
- buffer
, abfd
) != dst
- buffer
)
738 srec_write_header (abfd
)
741 unsigned char buffer
[MAXCHUNK
];
742 unsigned char *dst
= buffer
;
745 /* I'll put an arbitary 40 char limit on header size */
746 for (i
= 0; i
< 40 && abfd
->filename
[i
]; i
++)
748 *dst
++ = abfd
->filename
[i
];
750 return srec_write_record (abfd
, 0, 0, buffer
, dst
);
754 srec_write_section (abfd
, tdata
, list
)
757 srec_data_list_type
*list
;
759 unsigned int bytes_written
= 0;
760 unsigned char *location
= list
->data
;
762 while (bytes_written
< list
->size
)
766 unsigned int bytes_this_chunk
= list
->size
- bytes_written
;
768 if (bytes_this_chunk
> CHUNK
)
770 bytes_this_chunk
= CHUNK
;
773 address
= list
->where
+ bytes_written
;
775 if (! srec_write_record (abfd
,
779 location
+ bytes_this_chunk
))
782 bytes_written
+= bytes_this_chunk
;
783 location
+= bytes_this_chunk
;
790 srec_write_terminator (abfd
, tdata
)
794 unsigned char buffer
[2];
796 return srec_write_record (abfd
, 10 - tdata
->type
,
797 abfd
->start_address
, buffer
, buffer
);
803 srec_write_symbols (abfd
)
806 char buffer
[MAXCHUNK
];
807 /* Dump out the symbols of a bfd */
809 int count
= bfd_get_symcount (abfd
);
814 asymbol
**table
= bfd_get_outsymbols (abfd
);
815 sprintf (buffer
, "$$ %s\r\n", abfd
->filename
);
817 len
= strlen (buffer
);
818 if (bfd_write (buffer
, len
, 1, abfd
) != len
)
821 for (i
= 0; i
< count
; i
++)
823 asymbol
*s
= table
[i
];
825 int len
= strlen (s
->name
);
827 /* If this symbol has a .[ocs] in it, it's probably a file name
828 and we'll output that as the module name */
830 if (len
> 3 && s
->name
[len
- 2] == '.')
833 sprintf (buffer
, "$$ %s\r\n", s
->name
);
835 if (bfd_write (buffer
, l
, 1, abfd
) != l
)
840 if (s
->flags
& (BSF_GLOBAL
| BSF_LOCAL
)
841 && (s
->flags
& BSF_DEBUGGING
) == 0
843 && s
->name
[0] != 't')
845 /* Just dump out non debug symbols */
851 s
->value
+ s
->section
->output_section
->lma
852 + s
->section
->output_offset
);
854 while (p
[0] == '0' && p
[1] != 0)
856 sprintf (buffer
, " %s $%s\r\n", s
->name
, p
);
858 if (bfd_write (buffer
, l
, 1, abfd
) != l
)
862 sprintf (buffer
, "$$ \r\n");
863 len
= strlen (buffer
);
864 if (bfd_write (buffer
, len
, 1, abfd
) != len
)
872 internal_srec_write_object_contents (abfd
, symbols
)
876 tdata_type
*tdata
= abfd
->tdata
.srec_data
;
877 srec_data_list_type
*list
;
881 if (! srec_write_symbols (abfd
))
885 if (! srec_write_header (abfd
))
888 /* Now wander though all the sections provided and output them */
891 while (list
!= (srec_data_list_type
*) NULL
)
893 if (! srec_write_section (abfd
, tdata
, list
))
897 return srec_write_terminator (abfd
, tdata
);
901 srec_write_object_contents (abfd
)
904 return internal_srec_write_object_contents (abfd
, 0);
908 symbolsrec_write_object_contents (abfd
)
911 return internal_srec_write_object_contents (abfd
, 1);
916 srec_sizeof_headers (abfd
, exec
)
924 srec_make_empty_symbol (abfd
)
927 asymbol
*new = (asymbol
*) bfd_zalloc (abfd
, sizeof (asymbol
));
934 srec_get_symtab_upper_bound (abfd
)
937 /* Read in all the info */
938 if (! srec_get_section_contents (abfd
, abfd
->sections
, 0, 0, 0))
940 return (bfd_get_symcount (abfd
) + 1) * (sizeof (asymbol
*));
944 srec_get_symtab (abfd
, alocation
)
948 int lim
= abfd
->symcount
;
950 for (i
= 0; i
< lim
; i
++)
952 alocation
[i
] = abfd
->tdata
.srec_data
->symbols
+ i
;
960 srec_get_symbol_info (ignore_abfd
, symbol
, ret
)
965 bfd_symbol_info (symbol
, ret
);
970 srec_print_symbol (ignore_abfd
, afile
, symbol
, how
)
974 bfd_print_symbol_type how
;
976 FILE *file
= (FILE *) afile
;
979 case bfd_print_symbol_name
:
980 fprintf (file
, "%s", symbol
->name
);
983 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
984 fprintf (file
, " %-5s %s",
985 symbol
->section
->name
,
991 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup
992 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
993 #define srec_new_section_hook _bfd_generic_new_section_hook
995 #define srec_bfd_is_local_label bfd_generic_is_local_label
996 #define srec_get_lineno _bfd_nosymbols_get_lineno
997 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
998 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1000 #define srec_bfd_get_relocated_section_contents \
1001 bfd_generic_get_relocated_section_contents
1002 #define srec_bfd_relax_section bfd_generic_relax_section
1003 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1004 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
1005 #define srec_bfd_final_link _bfd_generic_final_link
1007 const bfd_target srec_vec
=
1010 bfd_target_srec_flavour
,
1011 true, /* target byte order */
1012 true, /* target headers byte order */
1013 (HAS_RELOC
| EXEC_P
| /* object flags */
1014 HAS_LINENO
| HAS_DEBUG
|
1015 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1016 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
1017 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
1018 0, /* leading underscore */
1019 ' ', /* ar_pad_char */
1020 16, /* ar_max_namelen */
1021 1, /* minimum alignment */
1022 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1023 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1024 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
1025 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1026 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1027 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1031 srec_object_p
, /* bfd_check_format */
1038 _bfd_generic_mkarchive
,
1041 { /* bfd_write_contents */
1043 srec_write_object_contents
,
1044 _bfd_write_archive_contents
,
1048 BFD_JUMP_TABLE_GENERIC (srec
),
1049 BFD_JUMP_TABLE_COPY (_bfd_generic
),
1050 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1051 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
1052 BFD_JUMP_TABLE_SYMBOLS (srec
),
1053 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
1054 BFD_JUMP_TABLE_WRITE (srec
),
1055 BFD_JUMP_TABLE_LINK (srec
),
1056 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
1063 const bfd_target symbolsrec_vec
=
1065 "symbolsrec", /* name */
1066 bfd_target_srec_flavour
,
1067 true, /* target byte order */
1068 true, /* target headers byte order */
1069 (HAS_RELOC
| EXEC_P
| /* object flags */
1070 HAS_LINENO
| HAS_DEBUG
|
1071 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1072 (SEC_CODE
| SEC_DATA
| SEC_ROM
| SEC_HAS_CONTENTS
1073 | SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
1074 0, /* leading underscore */
1075 ' ', /* ar_pad_char */
1076 16, /* ar_max_namelen */
1077 1, /* minimum alignment */
1078 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1079 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1080 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
1081 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1082 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1083 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1087 symbolsrec_object_p
, /* bfd_check_format */
1094 _bfd_generic_mkarchive
,
1097 { /* bfd_write_contents */
1099 symbolsrec_write_object_contents
,
1100 _bfd_write_archive_contents
,
1104 BFD_JUMP_TABLE_GENERIC (srec
),
1105 BFD_JUMP_TABLE_COPY (_bfd_generic
),
1106 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1107 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
1108 BFD_JUMP_TABLE_SYMBOLS (srec
),
1109 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
1110 BFD_JUMP_TABLE_WRITE (srec
),
1111 BFD_JUMP_TABLE_LINK (srec
),
1112 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),